deepline 0.3.421 → 0.3.423

package/dist/cli/{chunk-AARWVK4C.mjs → chunk-2BQUML3X.mjs}

@@ -31,7 +31,7 @@ import { existsSync, readFileSync } from "fs";
 import { mkdir, readFile, realpath, stat, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import {
-  basename,
+  basename as basename2,
   dirname,
   extname,
   isAbsolute,
@@ -194,17 +194,17 @@ var PLAY_AUTHORING_DEFINE_PLAY_OPTION_FIELDS = [
 ];
 var PLAY_AUTHORING_DOCUMENTATION = {
   fetchBatching: {
-    warning: "A static ctx.fetch key inside a loop is a warning because every iteration must still have distinct method, URL, body, or safe headers. One durable receipt must never stand in for every request.",
-    guidance: "Keep the static fetch label. For a mutating batch, make the body distinct and use a replay-stable external Idempotency-Key such as `${ctx.run.id}:signals:${batchIndex}`."
+    warning: "A static deepline.fetch key inside a loop is a warning because every iteration must still have distinct method, URL, body, or safe headers. One durable receipt must never stand in for every request.",
+    guidance: "Keep the static fetch label. For a mutating batch, make the body distinct and use a replay-stable external Idempotency-Key such as `${deepline.run.id}:signals:${batchIndex}`."
   },
   runId: {
-    semantics: "ctx.run.id is stable while Deepline retries or resumes one durable run. A separately submitted run receives a new id.",
+    semantics: "deepline.run.id is stable while Deepline retries or resumes one durable run. A separately submitted run receives a new id.",
     use: "Use it when deriving an external idempotency key for a sequence of batches."
   },
   staticCallKeys: {
-    constraint: "Durable call keys \u2014 the ctx.fetch key, the ctx.dataset key, the ctx.step id \u2014 must be static string literals. The key names a durable receipt, so check, publish, and replay have to agree on it before the body runs. A key computed at runtime cannot be resolved at check time and is rejected.",
+    constraint: "Durable call keys \u2014 the deepline.fetch key, the deepline.dataset key, the deepline.step id \u2014 must be static string literals. The key names a durable receipt, so check, publish, and replay have to agree on it before the body runs. A key computed at runtime cannot be resolved at check time and is rejected.",
     consequence: "This is an architectural constraint, not a style rule. A play cannot loop over a computed key, so it cannot page a large table with a helper like page(pageNumber). Unrolling one literal key per page is not a design at any real page count.",
-    workaround: "Push the aggregation server-side and call it once: a SQL function, a view, or a provider endpoint that returns the whole result. Keep unrolled literal keys only for a handful of genuinely distinct calls. To fan out over rows, use ctx.dataset with a static key \u2014 the per-row receipt identity comes from the row, not from the key."
+    workaround: "Push the aggregation server-side and call it once: a SQL function, a view, or a provider endpoint that returns the whole result. Keep unrolled literal keys only for a handful of genuinely distinct calls. To fan out over rows, use deepline.dataset with a static key \u2014 the per-row receipt identity comes from the row, not from the key."
   }
 };
 var PLAY_AUTHORING_STATIC_FETCH_KEY_HINT = `${PLAY_AUTHORING_DOCUMENTATION.staticCallKeys.workaround} Do not compute the key.`;
@@ -1890,13 +1890,598 @@ function parsePlaySourceForAnalysis(sourceCode) {
     return TypeScriptParser.parse(sourceCode, {
       ecmaVersion: "latest",
       sourceType: "module",
-      allowHashBang: true
+      allowHashBang: true,
+      // Script plays may end early with a top-level `return`.
+      allowReturnOutsideFunction: true
     });
   } catch {
     return null;
   }
 }
 
+// ../plays/script-entry.ts
+import { basename } from "path";
+var SCRIPT_SDK = "deepline";
+var PLAY_FILE_PATTERN = /\.play\.[cm]?[jt]sx?$/i;
+var DEFINE_CALLEES = /* @__PURE__ */ new Set(["definePlay", "defineWorkflow"]);
+var FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  "FunctionDeclaration",
+  "FunctionExpression",
+  "ArrowFunctionExpression"
+]);
+var MODULE_SCOPE = /* @__PURE__ */ new Set([
+  "ImportDeclaration",
+  "TSTypeAliasDeclaration",
+  "TSInterfaceDeclaration"
+]);
+var DECLARATION_TYPES = /* @__PURE__ */ new Set([
+  "FunctionDeclaration",
+  "TSDeclareFunction",
+  "ClassDeclaration",
+  "TSTypeAliasDeclaration",
+  "TSInterfaceDeclaration",
+  "TSEnumDeclaration"
+]);
+var UNWRAPPED_TYPES = /* @__PURE__ */ new Set([
+  "TSAsExpression",
+  "TSSatisfiesExpression",
+  "TSTypeAssertion",
+  "ParenthesizedExpression",
+  "AwaitExpression"
+]);
+var CONDITIONAL_TYPES = /* @__PURE__ */ new Set([
+  ...FUNCTION_TYPES,
+  "ClassDeclaration",
+  "ClassExpression",
+  "IfStatement",
+  "ConditionalExpression",
+  "LogicalExpression",
+  "SwitchStatement",
+  "ForStatement",
+  "ForInStatement",
+  "ForOfStatement",
+  "WhileStatement",
+  "DoWhileStatement",
+  "CatchClause"
+]);
+var INLINE_PLAY_FILE = ".inline.play.ts";
+var LEADING_IMPORT = /^\s*import\s+(?:[\w$*{}\s,]+?\s+from\s+)?['"][^'"]+['"]\s*;?/;
+function inlinePlaySource(code) {
+  let header = "";
+  let body = code;
+  for (let match = LEADING_IMPORT.exec(body); match; ) {
+    header += match[0];
+    body = body.slice(match[0].length);
+    match = LEADING_IMPORT.exec(body);
+  }
+  const runtimeImport = /\bimport\s+\w+\s*(,\s*\{[^}]*\}\s*)?from\s+['"]deepline['"]/.test(header) ? "" : `import ${SCRIPT_SDK} from '${SCRIPT_SDK}'; `;
+  if (/\bexport\s+default\b/.test(code)) return runtimeImport + code;
+  return `${runtimeImport}${header}export default async function (input: any) {${body}
+}
+`;
+}
+function playNameFromPath(filePath) {
+  return basename(filePath).replace(/^\.+/, "").replace(/(\.play)?\.[cm]?[jt]sx?$/, "");
+}
+function parseScriptPlay(source) {
+  const program = programOf(source);
+  const form = program ? playForm(program) : null;
+  if (!program || !form) return null;
+  const { entry } = form;
+  const header = headerOf(program);
+  const contextName = defaultImportName(header.find(isSdkImport)) ?? SCRIPT_SDK;
+  const parts = scriptPlayParts(program, contextName, entry?.node ?? null);
+  const configExport = configExportOf(program);
+  const headerEnd = header.at(-1)?.end ?? 0;
+  const [entryCall = null] = entry ? entryCallsOf(program, entry) : [];
+  const callStatement = entryCall ? program.body.find(
+    (node) => node.start <= entryCall.start && node.end >= entryCall.end
+  ) : void 0;
+  const excluded = new Set(
+    [
+      entry?.exportStatement,
+      entry?.declaration,
+      callStatement,
+      configExport
+    ].filter(Boolean)
+  );
+  const moduleCode = program.body.slice(header.length).filter(
+    (node) => !excluded.has(node) && !MODULE_SCOPE.has(node.type) && !(node.type === "ExpressionStatement" && scriptCallName(unwrapped(node.expression), contextName) === "config") && // Beside a play function, module code that neither awaits nor uses
+    // the runtime only names values and helpers, as a definePlay file's
+    // module scope does.
+    (!entry || usesRuntime(node, contextName))
+  );
+  const body = entry?.node.body;
+  const code = [
+    ...moduleCode,
+    ...body?.type === "BlockStatement" ? body.body : []
+  ];
+  const [parameter] = entry?.node.params ?? [];
+  return {
+    entry,
+    entryCall,
+    code,
+    contextName,
+    headerEnd,
+    delegate: delegateOf(code, contextName),
+    config: (configExport && configObjectOf(configExport)) ?? parts.config,
+    // The entry's parameter is its input; `(input) => ({ ... })` returns its
+    // expression.
+    inputType: parameterType(parameter) ?? parts.inputType,
+    outputs: body && body.type !== "BlockStatement" ? [body] : parts.outputs
+  };
+}
+function playRuntimeNames(source) {
+  const program = programOf(source);
+  const imported = program ? program.body.filter(isSdkImport).map(defaultImportName) : [];
+  return /* @__PURE__ */ new Set([
+    "ctx",
+    SCRIPT_SDK,
+    ...imported.filter((name) => name !== null)
+  ]);
+}
+function isRuntimeReceiver(name, runtimeNames) {
+  return runtimeNames.has(name) || name.endsWith("Ctx");
+}
+function delegateOf(code, contextName) {
+  const [statement, extra] = code.filter(
+    (node) => !isSignatureStatement(node, contextName) && !isDeclarationOnly(node)
+  );
+  if (extra || statement?.type !== "ReturnStatement") return null;
+  const returned = statement.argument;
+  const call = isAstNode(returned) && returned.type === "AwaitExpression" ? returned.argument : returned;
+  if (!isAstNode(call) || call.type !== "CallExpression") return null;
+  const [runtime] = call.arguments;
+  return isAstNode(call.callee) && call.callee.type === "Identifier" && runtime?.type === "Identifier" && (runtime.name === "ctx" || runtime.name === contextName) ? { handlerName: call.callee.name } : null;
+}
+function isSignatureStatement(node, contextName) {
+  if (node.type === "ExpressionStatement") {
+    return scriptCallName(unwrapped(node.expression), contextName) === "config";
+  }
+  if (node.type !== "VariableDeclaration") return false;
+  const declarations = node.declarations;
+  return declarations.length === 1 && scriptCallName(unwrapped(declarations[0].init), contextName) === "input";
+}
+function isDeclarationOnly(node) {
+  if (DECLARATION_TYPES.has(node.type)) return true;
+  return node.type === "VariableDeclaration" && node.kind === "const" && node.declarations.every(
+    (declarator) => isAstNode(declarator.init) && isLiteralValue(declarator.init)
+  );
+}
+function isLiteralValue(node) {
+  return node.type === "TemplateLiteral" ? node.expressions.length === 0 : node.type === "Literal" && (node.regex !== void 0 || ["string", "number", "bigint"].includes(typeof node.value));
+}
+function unwrapped(node) {
+  let current = isAstNode(node) ? node : null;
+  while (current && UNWRAPPED_TYPES.has(current.type)) {
+    const inner = current.expression ?? current.argument;
+    current = isAstNode(inner) ? inner : null;
+  }
+  return current;
+}
+function parameterType(parameter) {
+  const target = parameter?.type === "AssignmentPattern" ? parameter.left : parameter;
+  const annotation = isAstNode(target) ? target.typeAnnotation : null;
+  return isAstNode(annotation) && isAstNode(annotation.typeAnnotation) ? annotation.typeAnnotation : null;
+}
+function scriptPlayParts(program, contextName, playFunction) {
+  const parts = { config: null, inputType: null, outputs: [] };
+  const visit = (node, insideFunction) => {
+    if (node.type === "ReturnStatement" && !insideFunction && isAstNode(node.argument)) {
+      parts.outputs.push(node.argument);
+    }
+    const call = scriptCallName(node, contextName);
+    const [argument] = Array.isArray(node.arguments) ? node.arguments.filter(isAstNode) : [];
+    if (call === "config" && argument?.type === "ObjectExpression") {
+      parts.config ??= argument;
+    } else if (call === "input") {
+      parts.inputType ??= typeArgument(node);
+    } else if (call === "output" && argument) {
+      parts.outputs.push(argument);
+    }
+    const nested = node === playFunction ? false : insideFunction || FUNCTION_TYPES.has(node.type);
+    childNodes(node).forEach((child) => visit(child, nested));
+  };
+  visit(program, playFunction !== null);
+  return parts;
+}
+function usesRuntime(node, contextName) {
+  if (node.type === "AwaitExpression" || node.type === "Identifier" && node.name === contextName) {
+    return true;
+  }
+  if (FUNCTION_TYPES.has(node.type)) return false;
+  return childNodes(node).some((child) => usesRuntime(child, contextName));
+}
+function scriptCallName(node, contextName) {
+  if (node?.type !== "CallExpression" || !isAstNode(node.callee)) return null;
+  const callee = node.callee;
+  if (callee.type !== "MemberExpression" || callee.computed || !isAstNode(callee.object) || callee.object.type !== "Identifier" || callee.object.name !== contextName || !isAstNode(callee.property)) {
+    return null;
+  }
+  const name = callee.property.name;
+  return name === "config" || name === "input" || name === "output" ? name : null;
+}
+function typeArgument(call) {
+  const instantiation = call.typeArguments ?? call.typeParameters;
+  return isAstNode(instantiation) && Array.isArray(instantiation.params) ? instantiation.params.find(isAstNode) ?? null : null;
+}
+function wrapScriptPlay(source, script, { typed }) {
+  const { entry, entryCall } = script;
+  const unknownType = typed ? ": unknown" : "";
+  const anyType = typed ? ": any" : "";
+  const runtimeImport = defaultImportName(
+    headerOf(programOf(source)).find(isSdkImport)
+  ) ? `import { runScriptPlay as __deeplineRunScriptPlay } from '${SCRIPT_SDK}';` : `import ${SCRIPT_SDK}, { runScriptPlay as __deeplineRunScriptPlay } from '${SCRIPT_SDK}';`;
+  const entryBindings = entry ? ` let __deeplineEntry${anyType}; let __deeplineEntryResult${anyType};` : "";
+  const prefix = `${runtimeImport} export default async function (__deeplineContext${unknownType}, __deeplineInput${anyType}) { return __deeplineRunScriptPlay(__deeplineContext, __deeplineInput, async () => {${entryBindings}`;
+  const edits = [
+    {
+      at: script.headerEnd,
+      text: script.headerEnd === 0 ? `${prefix} ` : ` ${prefix}`
+    }
+  ];
+  const configExport = configExportOf(programOf(source));
+  if (configExport) {
+    const declared = configExport.declaration;
+    edits.push({
+      at: configExport.start,
+      end: declared.start,
+      text: blank(
+        source.slice(configExport.start, declared.start)
+      )
+    });
+  }
+  let entryName = "__deeplineEntry";
+  if (entry) {
+    const statement = entry.exportStatement;
+    const declared = statement.declaration;
+    if (entry.exportedAs === "specifier") {
+      entryName = entry.name;
+      edits.push({
+        at: statement.start,
+        end: statement.end,
+        text: blank(
+          source.slice(statement.start, statement.end)
+        )
+      });
+    } else if (entry.exportedAs === "declaration" && entry.name) {
+      entryName = entry.name;
+      edits.push({
+        at: statement.start,
+        end: declared.start,
+        text: blank(
+          source.slice(statement.start, declared.start)
+        )
+      });
+    } else {
+      edits.push({
+        at: statement.start,
+        end: declared.start,
+        text: "__deeplineEntry = "
+      });
+      if (entry.exportedAs === "declaration") {
+        edits.push({ at: statement.end, text: ";" });
+      }
+    }
+    if (entryCall) {
+      edits.push(
+        { at: entryCall.start, text: "(__deeplineEntryResult = " },
+        { at: entryCall.end, text: ")" }
+      );
+    }
+  }
+  const dispatch = !entry ? "" : entryCall ? " return await __deeplineEntryResult;" : (
+    // A play function that takes no input is called without one.
+    ` return await ${entryName}(${entry.node.params.length ? "__deeplineInput" : ""});`
+  );
+  return edits.sort(
+    (left, right) => right.at - left.at || (right.end ?? right.at) - (left.end ?? left.at)
+  ).reduce(
+    (text, edit) => text.slice(0, edit.at) + edit.text + text.slice(edit.end ?? edit.at),
+    source
+  ) + `
+;${dispatch} }); }
+`;
+}
+function blank(text) {
+  return text.replace(/[^\n]/g, " ");
+}
+function validateScriptPlay(source, script) {
+  const { contextName, entry } = script;
+  const program = programOf(source);
+  const statements = program.body;
+  const defaultExport = statements.find(isDefaultExport);
+  if (defaultExport && !entry) {
+    fail(
+      source,
+      defaultExport,
+      "The default export must be the play function: export default async function (input) { ... return { ... }; }."
+    );
+  }
+  if (entry) {
+    const calls = entryCallsOf(program, entry);
+    if (calls.length > 1) {
+      fail(
+        source,
+        calls[1],
+        `The play function is called ${calls.length} times at the top of the file; the runtime runs it once per run. Call it once, or not at all.`
+      );
+    }
+    const moduleResult = (node, insideFunction) => {
+      const call = scriptCallName(node, contextName);
+      if (!insideFunction && (node.type === "ReturnStatement" || call === "output")) {
+        fail(
+          source,
+          node,
+          "The play function's return is the play's result; this top-level result would compete with it. Return the result from the play function."
+        );
+      }
+      const nested = insideFunction || FUNCTION_TYPES.has(node.type);
+      childNodes(node).forEach((child) => moduleResult(child, nested));
+    };
+    moduleResult(program, false);
+  }
+  const lateImport = statements.slice(headerOf(program).length).find((node) => node.type === "ImportDeclaration");
+  if (lateImport) {
+    fail(
+      source,
+      lateImport,
+      "Move this import above the play code; imports come first in a script play."
+    );
+  }
+  const topLevelConfig = new Set(
+    statements.map(
+      (node) => node.type === "ExpressionStatement" ? node.expression : null
+    ).filter((node) => isAstNode(node))
+  );
+  const configExport = configExportOf(program);
+  if (configExport) {
+    const config = configObjectOf(configExport);
+    if (!config) {
+      fail(
+        source,
+        configExport,
+        "export const config must be one object literal, e.g. export const config = { description: '...' };"
+      );
+    }
+    validateConfigName(source, config);
+  }
+  const configCalls = [];
+  const inputTypes = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    const call = scriptCallName(node, contextName);
+    const args = Array.isArray(node.arguments) ? node.arguments : [];
+    if (call === "config") {
+      configCalls.push(node);
+      if (!topLevelConfig.has(node)) {
+        fail(
+          source,
+          node,
+          `${contextName}.config(...) must be its own top-level statement.`
+        );
+      }
+      if (args.length !== 1 || !isAstNode(args[0]) || args[0].type !== "ObjectExpression") {
+        fail(
+          source,
+          node,
+          `${contextName}.config(...) takes one object literal, e.g. ${contextName}.config({ description: '...' }).`
+        );
+      }
+      validateConfigName(source, args[0]);
+      if (configCalls.length > 1) {
+        fail(source, node, `${contextName}.config(...) may appear only once.`);
+      }
+      if (configExport) {
+        fail(
+          source,
+          node,
+          `The play config is declared twice: export const config (line ${lineOf(source, configExport)}) and ${contextName}.config(...) (line ${lineOf(source, node)}). Keep only export const config.`
+        );
+      }
+    } else if (call === "input") {
+      if (args.length > 0) {
+        fail(
+          source,
+          node,
+          `${contextName}.input() takes no arguments; declare the shape as a type: ${contextName}.input<{ domain: string }>().`
+        );
+      }
+      const type = typeArgument(node);
+      if (type)
+        inputTypes.add(source.slice(type.start, type.end));
+      if (inputTypes.size > 1) {
+        fail(
+          source,
+          node,
+          `${contextName}.input<T>() is called with different types (${[...inputTypes].join(", ")}). Use one input type.`
+        );
+      }
+    }
+    childNodes(node).forEach(visit);
+  };
+  visit(program);
+}
+var SCRIPT_PLAY_MODULE_DECLARATION = `import type { DefinedPlay } from '${SCRIPT_SDK}';
+declare const play: DefinedPlay<Record<string, unknown>, Record<string, unknown>>;
+export default play;
+`;
+function validateConfigName(source, config) {
+  const name = (config.properties ?? []).find(
+    (property) => property.type === "Property" && !property.computed && isAstNode(property.key) && (property.key.name === "name" || property.key.value === "name")
+  );
+  if (name && !(isAstNode(name.value) && name.value.type === "Literal" && typeof name.value.value === "string" && name.value.value.trim())) {
+    fail(source, name, "config name must be a non-empty string literal.");
+  }
+}
+function lineOf(source, node) {
+  return source.slice(0, node.start).split("\n").length;
+}
+function fail(source, node, message) {
+  throw new Error(`line ${lineOf(source, node)}: ${message}`);
+}
+function childNodes(node) {
+  return Object.entries(node).flatMap(
+    ([key, value]) => key === "loc" ? [] : Array.isArray(value) ? value.filter(isAstNode) : isAstNode(value) ? [value] : []
+  );
+}
+var programs = /* @__PURE__ */ new Map();
+var MAX_PROGRAMS = 16;
+function programOf(source) {
+  const program = programs.has(source) ? programs.get(source) : parse(source);
+  programs.delete(source);
+  programs.set(source, program);
+  if (programs.size > MAX_PROGRAMS) {
+    programs.delete(programs.keys().next().value);
+  }
+  return program;
+}
+function headerOf(program) {
+  const statements = program.body;
+  const firstCode = statements.findIndex(
+    (node) => !MODULE_SCOPE.has(node.type)
+  );
+  return firstCode === -1 ? statements : statements.slice(0, firstCode);
+}
+function isSdkImport(node) {
+  return node.type === "ImportDeclaration" && isAstNode(node.source) && node.source.value === SCRIPT_SDK;
+}
+function parse(source) {
+  try {
+    return TypeScriptParser.parse(source, {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      allowHashBang: true,
+      // Script plays may end early with a top-level `return`.
+      allowReturnOutsideFunction: true
+    });
+  } catch (error) {
+    const looksLikeScript = /\bdeepline\s*\./.test(source) && !/\bexport\b|\bdefinePlay\b/.test(source);
+    if (!looksLikeScript) return null;
+    const line = error.loc?.line;
+    throw new Error(
+      `line ${line ?? "?"}: ${error.message.replace(/ \(\d+:\d+\)$/, "")}`
+    );
+  }
+}
+function playForm(program) {
+  if (containsDefinePlayCall(program)) return null;
+  const configExport = configExportOf(program);
+  const exports = program.body.filter(
+    (node) => node !== configExport && /^Export|^TSExportAssignment$/.test(node.type)
+  );
+  if (exports.length === 0) return { entry: null };
+  const [statement] = exports;
+  if (exports.length !== 1 || !isDefaultExport(statement)) return null;
+  const entry = entryOf(program, statement);
+  if (entry && entry.node.params.length > 1) return null;
+  if (!importsRuntime(program) && (!entry || importsRuntimeName(program))) {
+    return null;
+  }
+  return { entry };
+}
+function configExportOf(program) {
+  return program.body.find(
+    (node) => node.type === "ExportNamedDeclaration" && !node.source && isAstNode(node.declaration) && node.declaration.type === "VariableDeclaration" && node.declaration.declarations.some(
+      (declarator) => declarator.id.name === "config"
+    )
+  ) ?? null;
+}
+function configObjectOf(configExport) {
+  const declaration = configExport.declaration;
+  const declarators = declaration.declarations;
+  if (declaration.kind !== "const" || declarators.length !== 1) return null;
+  const init = unwrapped(declarators[0].init);
+  return init?.type === "ObjectExpression" ? init : null;
+}
+function isDefaultExport(node) {
+  if (node.type === "ExportDefaultDeclaration") return true;
+  const specifiers = node.specifiers ?? [];
+  return node.type === "ExportNamedDeclaration" && !node.declaration && !node.source && specifiers.length === 1 && exportedName(specifiers[0]) === "default";
+}
+function exportedName(specifier) {
+  const exported = specifier.exported;
+  return exported?.name ?? exported?.value;
+}
+function entryOf(program, statement) {
+  if (statement.type === "ExportDefaultDeclaration") {
+    const declared = unwrapped(statement.declaration);
+    if (declared && FUNCTION_TYPES.has(declared.type)) {
+      const id = declared.id;
+      return {
+        node: declared,
+        name: declared.type === "FunctionDeclaration" && id ? id.name : null,
+        exportedAs: declared.type === "FunctionDeclaration" ? "declaration" : "expression",
+        exportStatement: statement,
+        declaration: null
+      };
+    }
+    return declared?.type === "Identifier" ? boundEntry(program, statement, declared.name, "binding") : null;
+  }
+  const [specifier] = statement.specifiers;
+  const local = specifier.local;
+  return boundEntry(program, statement, local.name, "specifier");
+}
+function boundEntry(program, exportStatement, name, exportedAs) {
+  for (const node of program.body) {
+    if (node.type === "FunctionDeclaration" && node.id?.name === name) {
+      return { node, name, exportedAs, exportStatement, declaration: node };
+    }
+    if (node.type !== "VariableDeclaration") continue;
+    for (const declarator of node.declarations) {
+      const init = unwrapped(declarator.init);
+      if (declarator.id.name === name && init && FUNCTION_TYPES.has(init.type)) {
+        return {
+          node: init,
+          name,
+          exportedAs,
+          exportStatement,
+          declaration: node
+        };
+      }
+    }
+  }
+  return null;
+}
+function entryCallsOf(program, entry) {
+  if (!entry.name) return [];
+  const calls = [];
+  const visit = (node) => {
+    if (CONDITIONAL_TYPES.has(node.type)) return;
+    if (node.type === "CallExpression" && isAstNode(node.callee) && node.callee.type === "Identifier" && node.callee.name === entry.name) {
+      calls.push(node);
+    }
+    childNodes(node).forEach(visit);
+  };
+  program.body.filter(
+    (node) => node !== entry.declaration && node !== entry.exportStatement
+  ).forEach(visit);
+  return calls;
+}
+function importsRuntime(program) {
+  return program.body.some(
+    (node) => isSdkImport(node) && defaultImportName(node) !== null
+  );
+}
+function importsRuntimeName(program) {
+  return program.body.some(
+    (node) => node.type === "ImportDeclaration" && node.specifiers.some(
+      (specifier) => specifier.local.name === SCRIPT_SDK
+    )
+  );
+}
+function containsDefinePlayCall(node) {
+  if (node.type === "CallExpression" && isAstNode(node.callee)) {
+    const callee = node.callee;
+    const name = callee.type === "Identifier" ? callee.name : callee.type === "MemberExpression" && isAstNode(callee.property) ? callee.property.name : null;
+    if (DEFINE_CALLEES.has(name)) return true;
+  }
+  return childNodes(node).some(containsDefinePlayCall);
+}
+function defaultImportName(importDeclaration) {
+  const specifier = importDeclaration?.specifiers?.find((node) => node.type === "ImportDefaultSpecifier");
+  return specifier && isAstNode(specifier.local) ? specifier.local.name : null;
+}
+
 // ../plays/play-exports.ts
 var PLAY_DEFAULT_EXPORT = "default";
 function getIdentifierName(node) {
@@ -1933,19 +2518,34 @@ function definePlayName(node) {
     astArray(expression.arguments)[0] ?? null
   );
   if (first?.type !== "ObjectExpression") return stringLiteralValue(first);
-  let id = null;
-  for (const property of astArray(first.properties)) {
+  return objectStringProperty(first, "id");
+}
+function objectStringProperty(object, propertyName) {
+  let value = null;
+  for (const property of astArray(object?.properties)) {
     if (property.type !== "Property" || property.computed) continue;
     const key = isAstNode(property.key) ? property.key : null;
     const keyName = getIdentifierName(key) ?? (key?.type === "Literal" && typeof key.value === "string" ? key.value : null);
-    if (keyName !== "id") continue;
-    id = stringLiteralValue(isAstNode(property.value) ? property.value : null);
+    if (keyName !== propertyName) continue;
+    value = stringLiteralValue(
+      isAstNode(property.value) ? property.value : null
+    );
   }
-  return id;
+  return value;
 }
 function listPlayFileExports(sourceCode) {
   const ast = parsePlaySourceForAnalysis(sourceCode);
   if (!ast) return null;
+  const script = parseScriptPlay(sourceCode);
+  if (script) {
+    return [
+      {
+        name: PLAY_DEFAULT_EXPORT,
+        aliases: [],
+        playName: objectStringProperty(script.config, "name")
+      }
+    ];
+  }
   const declarations = /* @__PURE__ */ new Map();
   const namedExports = /* @__PURE__ */ new Map();
   let defaultExpression = null;
@@ -1979,8 +2579,8 @@ function listPlayFileExports(sourceCode) {
     }
     for (const specifier of astArray(statement.specifiers)) {
       const localName = getIdentifierName(specifier.local);
-      const exportedName = getIdentifierName(specifier.exported);
-      if (localName && exportedName) namedExports.set(exportedName, localName);
+      const exportedName2 = getIdentifierName(specifier.exported);
+      if (localName && exportedName2) namedExports.set(exportedName2, localName);
     }
   }
   const defaultLocalName = getIdentifierName(
@@ -2000,13 +2600,13 @@ function listPlayFileExports(sourceCode) {
       )
     });
   }
-  for (const [exportedName, localName] of namedExports) {
-    if (exportedName === PLAY_DEFAULT_EXPORT) continue;
+  for (const [exportedName2, localName] of namedExports) {
+    if (exportedName2 === PLAY_DEFAULT_EXPORT) continue;
     if (aliasedLocals.has(localName)) continue;
     const declaration = declarations.get(localName) ?? null;
     if (!isDefinePlayCall(declaration)) continue;
     exports.push({
-      name: exportedName,
+      name: exportedName2,
       aliases: [],
       playName: definePlayName(declaration)
     });
@@ -2598,14 +3198,14 @@ function playExportSourceRanges(sourceCode) {
     }
   }
   const resolveCall = (expression, seen = /* @__PURE__ */ new Set()) => {
-    const unwrapped = unwrapExportExpression(expression);
-    if (!unwrapped) return null;
-    if (isDefinePlayCall(unwrapped)) return unwrapped;
-    if (unwrapped.type !== "Identifier" || typeof unwrapped.name !== "string" || seen.has(unwrapped.name)) {
+    const unwrapped2 = unwrapExportExpression(expression);
+    if (!unwrapped2) return null;
+    if (isDefinePlayCall(unwrapped2)) return unwrapped2;
+    if (unwrapped2.type !== "Identifier" || typeof unwrapped2.name !== "string" || seen.has(unwrapped2.name)) {
       return null;
     }
-    seen.add(unwrapped.name);
-    return resolveCall(declarations.get(unwrapped.name) ?? null, seen);
+    seen.add(unwrapped2.name);
+    return resolveCall(declarations.get(unwrapped2.name) ?? null, seen);
   };
   const defaultCall = resolveCall(defaultExpression);
   const ranges = [];
@@ -2660,6 +3260,7 @@ function attachBindingsToBlocks(sourceCode, blocks, bindings, errors, rejectedNo
   const exportRanges = playExportSourceRanges(sourceCode);
   for (const binding of bindings) {
     let owners = blocks.filter((block) => block.nodes.has(binding.nodeId));
+    if (owners.length === 0 && binding.sourcePath) continue;
     if (owners.length === 0) {
       errors.push(
         `Docflow annotation "${binding.nodeId}" does not name a graph node.`
@@ -2914,12 +3515,12 @@ function isDocflowStepCallForName(node, stepName) {
   );
 }
 function docflowExpressionWrapsStepBuilder(expression, stepName) {
-  const unwrapped = expression.type === "AwaitExpression" && isAstNode(expression.argument) ? expression.argument : expression;
-  if (isDocflowStepCallForName(unwrapped, stepName)) return false;
-  const pending = [unwrapped];
+  const unwrapped2 = expression.type === "AwaitExpression" && isAstNode(expression.argument) ? expression.argument : expression;
+  if (isDocflowStepCallForName(unwrapped2, stepName)) return false;
+  const pending = [unwrapped2];
   while (pending.length > 0) {
     const node = pending.pop();
-    if (node !== unwrapped && isDocflowStepCallForName(node, stepName)) {
+    if (node !== unwrapped2 && isDocflowStepCallForName(node, stepName)) {
       return true;
     }
     for (const child of Object.values(node)) {
@@ -3240,6 +3841,29 @@ function extractPlaySourceAuthoringEdition(ast, exportName = null) {
   const expression = resolve4(
     local ?? legacyExports.get(requested) ?? (exportName === null ? definitions[0] ?? null : null)
   );
+  const functionTypes = [
+    "FunctionDeclaration",
+    "FunctionExpression",
+    "ArrowFunctionExpression"
+  ];
+  const localName = identifier(local);
+  const defaultIsFunction = !local && !legacyExports.has("default") && definitions.length === 0 || expression !== null && functionTypes.includes(expression.type) || localName !== null && astArray(ast.body).some(
+    (statement) => statement.type === "FunctionDeclaration" && identifier(statement.id) === localName
+  );
+  if (requested === "default" && defaultIsFunction) {
+    const config = exports.has("config") ? declarations.get("config") ?? null : scriptConfigCall(ast);
+    if (config) {
+      const compatibility = property(config, "compatibility");
+      const marker2 = compatibility.kind === "found" ? property(compatibility.value, "authoringContract") : compatibility;
+      if (marker2.kind !== "found") return { marker: marker2, localExport: true };
+      const value2 = resolve4(marker2.value);
+      return {
+        marker: value2?.type === "Literal" ? { kind: "value", value: value2.value } : { kind: "unknown" },
+        localExport: true
+      };
+    }
+    return { marker: { kind: "absent" }, localExport: Boolean(local) };
+  }
   if (!expression || expression.type !== "CallExpression") {
     return {
       marker: {
@@ -3262,6 +3886,17 @@ function extractPlaySourceAuthoringEdition(ast, exportName = null) {
     definition: expression
   };
 }
+function scriptConfigCall(ast) {
+  for (const statement of astArray(ast.body)) {
+    const call = statement.type === "ExpressionStatement" && isAstNode(statement.expression) ? statement.expression : null;
+    const callee = call?.type === "CallExpression" && isAstNode(call.callee) ? call.callee : null;
+    if (callee?.type === "MemberExpression" && !callee.computed && identifier(callee.property) === "config") {
+      const [argument] = astArray(call.arguments);
+      if (argument?.type === "ObjectExpression") return argument;
+    }
+  }
+  return null;
+}
 function resolvePlaySourceAuthoringContractEdition(marker, pinnedEdition) {
   if (marker.kind === "unknown") {
     throw new PlayAuthoringFieldValidationError(
@@ -3298,7 +3933,6 @@ var SOURCE_EXTENSIONS = [
   ".cjs",
   ".json"
 ];
-var PLAY_SOURCE_FILE_PATTERN = /\.play\.(?:[cm]?[jt]sx?)$/i;
 var TEXT_IMPORT_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt"]);
 var EXPLICIT_IMPORT_EXTENSIONS = /* @__PURE__ */ new Set([
   ...SOURCE_EXTENSIONS,
@@ -3331,7 +3965,7 @@ function sourceIdentityPath(filePath, sourceIdentityRoot) {
   const resolvedFilePath = resolve(filePath);
   const logicalPath = relative(identityRoot, resolvedFilePath);
   if (!logicalPath) {
-    return basename(resolvedFilePath);
+    return basename2(resolvedFilePath);
   }
   if (logicalPath === ".." || logicalPath.startsWith(`..${sep}`) || isAbsolute(logicalPath)) {
     return filePath;
@@ -3378,7 +4012,7 @@ function getPackageName(specifier) {
   return specifier.split("/")[0] ?? specifier;
 }
 function isPlaySourceFile(filePath) {
-  return PLAY_SOURCE_FILE_PATTERN.test(filePath);
+  return PLAY_FILE_PATTERN.test(filePath);
 }
 function stripCommentsToSpaces(source) {
   return source.replace(/\/\*[\s\S]*?\*\//g, (match) => match.replace(/[^\n]/g, " ")).replace(
@@ -3452,15 +4086,17 @@ function findSourceImportReferences(sourceCode) {
     (left, right) => left.line === right.line ? left.column - right.column : left.line - right.line
   );
 }
-function extractDefinedPlayName(sourceCode) {
-  return extractDefinedPlayMetadata(sourceCode, null)?.name ?? null;
+function extractDefinedPlayName(sourceCode, filePath) {
+  return extractDefinedPlayMetadata(sourceCode, null, filePath)?.name ?? null;
 }
 function parsePlaySourceAst(sourceCode) {
   try {
     return TypeScriptParser.parse(sourceCode, {
       ecmaVersion: "latest",
       sourceType: "module",
-      allowHashBang: true
+      allowHashBang: true,
+      // Script plays may end early with a top-level `return`.
+      allowReturnOutsideFunction: true
     });
   } catch {
     try {
@@ -3474,7 +4110,9 @@ function parsePlaySourceAst(sourceCode) {
       return Parser2.parse(transformed, {
         ecmaVersion: "latest",
         sourceType: "module",
-        allowHashBang: true
+        allowHashBang: true,
+        // Script plays may end early with a top-level `return`.
+        allowReturnOutsideFunction: true
       });
     } catch {
       return null;
@@ -3581,9 +4219,9 @@ function buildPlayMetadataContext(ast) {
       }
       for (const specifier of astArray(statement.specifiers)) {
         const localName = getIdentifierName3(specifier.local);
-        const exportedName = getIdentifierName3(specifier.exported) ?? (isAstNode(specifier.exported) && specifier.exported.type === "Literal" && typeof specifier.exported.value === "string" ? specifier.exported.value : null);
-        if (localName && exportedName) {
-          namedExports.set(exportedName, localName);
+        const exportedName2 = getIdentifierName3(specifier.exported) ?? (isAstNode(specifier.exported) && specifier.exported.type === "Literal" && typeof specifier.exported.value === "string" ? specifier.exported.value : null);
+        if (localName && exportedName2) {
+          namedExports.set(exportedName2, localName);
         }
       }
     }
@@ -3915,6 +4553,32 @@ function playMetadataFromDefinePlayCall(node, context) {
     toolResponseReceiptRevisionUnknown
   };
 }
+function playMetadataFromScriptConfig(config, context, filePath) {
+  const toolErrorSchemaVersion = toolErrorSchemaVersionFromOptions(
+    config,
+    context
+  );
+  const toolResponseReceiptRevision = toolResponseReceiptRevisionFromOptions(
+    config,
+    context
+  );
+  return {
+    name: stringPropertyFromObjectExpression(config, "name", context) ?? (filePath ? playNameFromPath(filePath) : null),
+    description: stringPropertyFromObjectExpression(
+      config,
+      "description",
+      context
+    ),
+    sandboxRuntimeDeclaration: sandboxRuntimeDeclarationFromOptions(
+      config,
+      context
+    ),
+    toolErrorSchemaVersion: toolErrorSchemaVersion ?? null,
+    toolErrorSchemaVersionUnknown: toolErrorSchemaVersion === null,
+    toolResponseReceiptRevision: toolResponseReceiptRevision ?? null,
+    toolResponseReceiptRevisionUnknown: toolResponseReceiptRevision === null
+  };
+}
 function resolveExportExpression(exportName, context) {
   if (exportName === "default") {
     const commonJsDefault = context.commonJsExports.get("default");
@@ -3945,10 +4609,13 @@ function resolveExportExpression(exportName, context) {
   }
   return null;
 }
-function extractDefinedPlayMetadata(sourceCode, exportName) {
+function extractDefinedPlayMetadata(sourceCode, exportName, filePath) {
   const ast = parsePlaySourceAst(sourceCode);
   if (!ast) return null;
   const context = buildPlayMetadataContext(ast);
+  const script = exportName === null || exportName === "default" ? parseScriptPlay(sourceCode) : null;
+  if (script)
+    return playMetadataFromScriptConfig(script.config, context, filePath);
   const exportedExpression = resolveExportExpression(exportName, context);
   const exportedMetadata = playMetadataFromDefinePlayCall(
     exportedExpression,
@@ -4221,6 +4888,7 @@ function instrumentPlayDocflowRuntimeHits(sourceCode) {
   const targets = [];
   const injectedContextAt = /* @__PURE__ */ new Set();
   const parents = buildDocflowParentIndex(ast);
+  const scriptContext = parseScriptPlay(sourceCode)?.contextName ?? null;
   for (const binding of parsed.bindings) {
     const resolution = resolveDocflowBinding(ast, binding, lineStarts, parents);
     const context = findDocflowContext({
@@ -4230,7 +4898,7 @@ function instrumentPlayDocflowRuntimeHits(sourceCode) {
       bindingLine: binding.line,
       lineStarts,
       parents
-    });
+    }) ?? (scriptContext ? { kind: "named", name: scriptContext } : null);
     if (!context) continue;
     if (context.kind === "unsupported") {
       throw new Error(
@@ -4310,26 +4978,32 @@ function instrumentPlayDocflowRuntimeHits(sourceCode) {
     sourceCode
   );
 }
-function docflowRuntimeInstrumentationPlugin(customerSourceFilePaths) {
-  const customerSourceFiles = new Set(
-    customerSourceFilePaths.filter((path) => extname(path).toLowerCase() !== ".json").map((path) => resolve(path))
+function docflowRuntimeInstrumentationPlugin(analyzedSources, scriptEntry) {
+  const customerSourceFiles = new Map(
+    Object.entries(analyzedSources).filter(([path]) => extname(path).toLowerCase() !== ".json").map(([path, contents]) => [resolve(path), contents])
   );
   return {
     name: "deepline-docflow-runtime-instrumentation",
     setup(buildContext) {
       buildContext.onLoad({ filter: /./ }, (args) => {
-        if (!customerSourceFiles.has(resolve(args.path))) return void 0;
+        if (scriptEntry && resolve(args.path) === resolve(scriptEntry.path)) {
+          return {
+            contents: scriptEntryModule(scriptEntry.source, args.path),
+            loader: sourceLoaderForPath(args.path),
+            resolveDir: dirname(args.path)
+          };
+        }
+        const contents = customerSourceFiles.get(resolve(args.path));
+        if (contents === void 0) return void 0;
         if (isTextImportFile(args.path)) {
           return {
-            contents: readFileSync(args.path, "utf8"),
+            contents,
             loader: "text",
             resolveDir: dirname(args.path)
           };
         }
         return {
-          contents: instrumentPlayDocflowRuntimeHits(
-            readFileSync(args.path, "utf8")
-          ),
+          contents: instrumentPlayDocflowRuntimeHits(contents),
           loader: sourceLoaderForPath(args.path),
           resolveDir: dirname(args.path)
         };
@@ -4337,6 +5011,18 @@ function docflowRuntimeInstrumentationPlugin(customerSourceFilePaths) {
     }
   };
 }
+function scriptEntryModule(source, path) {
+  const instrumented = instrumentPlayDocflowRuntimeHits(source);
+  const script = parseScriptPlay(instrumented);
+  if (!script) {
+    throw new Error(
+      "Docflow instrumentation turned a script play into a non-script."
+    );
+  }
+  return wrapScriptPlay(instrumented, script, {
+    typed: /^tsx?$/.test(sourceLoaderForPath(path))
+  });
+}
 function buildImportedPlayProxyModule(playName) {
   const serializedName = JSON.stringify(playName);
   return `
@@ -4473,6 +5159,8 @@ async function analyzeSourceGraph(entryFile, adapter, exportName) {
   const nodeBuiltins = /* @__PURE__ */ new Set();
   const packages = /* @__PURE__ */ new Map();
   const importedPlayDependencies = /* @__PURE__ */ new Map();
+  const importedPlaySources = /* @__PURE__ */ new Map();
+  let entryScript = null;
   const visited = /* @__PURE__ */ new Set();
   const importViolations = [];
   const visitFile = async (filePath) => {
@@ -4486,6 +5174,13 @@ async function analyzeSourceGraph(entryFile, adapter, exportName) {
       absolutePath,
       "utf-8"
     );
+    if (absolutePath === absoluteEntryFile) {
+      const script = parseScriptPlay(sourceCode2);
+      if (script) {
+        validateScriptPlay(sourceCode2, script);
+        entryScript = sourceCode2;
+      }
+    }
     localFiles.set(absolutePath, sourceCode2);
     if (extname(absolutePath).toLowerCase() === ".json" || isTextImportFile(absolutePath)) {
       return;
@@ -4518,10 +5213,18 @@ async function analyzeSourceGraph(entryFile, adapter, exportName) {
             resolved,
             "utf-8"
           );
-          const importedPlayName = extractDefinedPlayName(importedSource);
+          const importedScript = parseScriptPlay(importedSource);
+          if (importedScript)
+            validateScriptPlay(importedSource, importedScript);
+          if (importedScript)
+            importedPlaySources.set(resolved, SCRIPT_PLAY_MODULE_DECLARATION);
+          const importedPlayName = extractDefinedPlayName(
+            importedSource,
+            resolved
+          );
           if (!importedPlayName) {
             throw new Error(
-              `${absolutePath}:${line}:${column} Imported play file "${specifier}" must export definePlay(...) so it can be runtime-composed.`
+              `${absolutePath}:${line}:${column} Imported play file "${specifier}" is not a play: write it as a script play (import deepline from 'deepline') or default-export a play function, so it can be runtime-composed.`
             );
           }
           importedPlayDependencies.set(resolved, {
@@ -4582,6 +5285,7 @@ async function analyzeSourceGraph(entryFile, adapter, exportName) {
       })).sort((left, right) => left.filePath.localeCompare(right.filePath))
     })
   );
+  const authoredSource = sourceCode;
   const sourceAst = parsePlaySourceAst(sourceCode);
   if (!sourceAst)
     throw new Error(
@@ -4594,7 +5298,11 @@ async function analyzeSourceGraph(entryFile, adapter, exportName) {
   const metadata = (selection.marker.kind === "value" && selection.definition ? playMetadataFromDefinePlayCall(
     selection.definition,
     buildPlayMetadataContext(sourceAst)
-  ) : extractDefinedPlayMetadata(sourceCode, exportName)) ?? (exportName === "default" ? extractDefinedPlayMetadata(sourceCode, null) : null);
+  ) : extractDefinedPlayMetadata(
+    authoredSource,
+    exportName,
+    absoluteEntryFile
+  )) ?? (exportName === "default" ? extractDefinedPlayMetadata(authoredSource, null, absoluteEntryFile) : null);
   const compatibilityDiagnostic = metadata?.toolErrorSchemaVersionUnknown ? "definePlay compatibility.toolErrorSchemaVersion must be the static literal 0 or 1." : metadata?.toolResponseReceiptRevisionUnknown ? "definePlay compatibility.toolResponseReceiptRevision must be a static non-empty string." : null;
   try {
     resolvePlaySourceAuthoringContractEdition(selection.marker);
@@ -4634,7 +5342,9 @@ ${error instanceof Error ? error.message : String(error)}`
     sourceHasLocalPlayExport: selection.localExport,
     importedPlayDependencies: [...importedPlayDependencies.values()].sort(
       (left, right) => left.filePath.localeCompare(right.filePath)
-    )
+    ),
+    importedPlaySources: Object.fromEntries(importedPlaySources),
+    entryScript
   };
 }
 function artifactCachePath(graphHash, artifactKind, adapter) {
@@ -4704,21 +5414,21 @@ function getBundleSizeError(filePath, bundledCode, artifactKind) {
     artifactKind
   );
 }
-async function runEsbuildForCjsNode(entryFile, customerSourceFilePaths, importedPlayDependencies, adapter, exportName, bundleRoot) {
+async function runEsbuildForCjsNode(entryFile, analyzedSources, entryScript, importedPlayDependencies, adapter, exportName, bundleRoot) {
   const sdkAliasPlugin = localSdkAliasPlugin(adapter);
   const playProxyPlugin = importedPlayProxyPlugin(importedPlayDependencies);
-  const docflowPlugin = docflowRuntimeInstrumentationPlugin([
-    entryFile,
-    ...customerSourceFilePaths
-  ]);
-  const namedExportShim = exportName === "default" ? null : `export { ${exportName} as default } from ${JSON.stringify(entryFile)};
-`;
+  const docflowPlugin = docflowRuntimeInstrumentationPlugin(
+    analyzedSources,
+    entryScript === null ? null : { path: entryFile, source: entryScript }
+  );
+  const namedExportShim = exportName !== "default" ? `export { ${exportName} as default } from ${JSON.stringify(entryFile)};
+` : null;
   const result = await build({
     ...namedExportShim ? {
       stdin: {
         contents: namedExportShim,
         resolveDir: dirname(entryFile),
-        sourcefile: `${basename(entryFile)}.${exportName}.entry.ts`,
+        sourcefile: `${basename2(entryFile)}.${exportName}.entry.ts`,
         loader: "ts"
       }
     } : { entryPoints: [entryFile] },
@@ -4790,7 +5500,9 @@ async function bundlePlayFile(filePath, options) {
       `${analysis.graphHash}
 entry-export:${exportName}
 authoring-contract-edition:${edition}${edition >= 10 ? "\nimported-proxy-options:description" : ""}${preservedCompatibility === void 0 ? "\ndataset-row-input:current_run" : `
-preserved-compatibility:${JSON.stringify(preservedCompatibility)}`}`
+preserved-compatibility:${JSON.stringify(preservedCompatibility)}`}` + // A script entry is bundled wrapped; keep its artifacts apart.
+      // definePlay plays keep their existing hash.
+      (analysis.entryScript === null ? "" : "\nentry-form:script-v2")
     );
     const sourceFiles = Object.fromEntries(
       Object.entries(analysis.sourceFiles).map(([sourcePath, sourceCode]) => [
@@ -4823,7 +5535,11 @@ preserved-compatibility:${JSON.stringify(preservedCompatibility)}`}`
           ...analysis.importedPlayDependencies.map(
             (dependency) => dependency.filePath
           )
-        ]
+        ],
+        sourceFiles: {
+          ...analysis.sourceFiles,
+          ...analysis.importedPlaySources
+        }
       }) ?? []
     ];
     if (typecheckErrors.length > 0) {
@@ -4838,7 +5554,10 @@ preserved-compatibility:${JSON.stringify(preservedCompatibility)}`}`
       target,
       adapter
     );
-    const discoveredFiles = await adapter.discoverPackagedLocalFiles(absolutePath);
+    const discoveredFiles = await adapter.discoverPackagedLocalFiles(
+      absolutePath,
+      analysis.sourceFiles
+    );
     if (cachedArtifact) {
       const cachedArtifactSizeError = getBundleSizeError(
         absolutePath,
@@ -4882,7 +5601,8 @@ preserved-compatibility:${JSON.stringify(preservedCompatibility)}`}`
     const bundleRoot = resolve(sourceIdentityRoot ?? adapter.projectRoot);
     const buildOutcome = await runEsbuildForCjsNode(
       absolutePath,
-      analysis.importPolicy.localFiles,
+      analysis.sourceFiles,
+      analysis.entryScript,
       analysis.importedPlayDependencies,
       adapter,
       exportName,
@@ -4900,10 +5620,10 @@ preserved-compatibility:${JSON.stringify(preservedCompatibility)}`}`
       sourceMapText,
       bundleRoot
     );
-    const virtualBaseName = exportName === "default" ? basename(absolutePath).replace(/\.[^.]+$/, "") : `${basename(absolutePath).replace(/\.[^.]+$/, "")}.${exportName}`;
+    const virtualBaseName = exportName === "default" ? basename2(absolutePath).replace(/\.[^.]+$/, "") : `${basename2(absolutePath).replace(/\.[^.]+$/, "")}.${exportName}`;
     const virtualFilename = `/virtual/deepline-plays/${analysis.graphHash}/${virtualBaseName}.${outputExtension}`;
     const executableCode = `${bundledCode}
-//# sourceMappingURL=${basename(virtualFilename)}.map
+//# sourceMappingURL=${basename2(virtualFilename)}.map
 `;
     const bundleSizeError = getBundleSizeError(
       absolutePath,
@@ -5070,7 +5790,7 @@ function resolveEnabledExecutionProfile(override) {
 import { createHash as createHash2 } from "crypto";
 import { readFile as readFile2, stat as stat2 } from "fs/promises";
 import {
-  basename as basename2,
+  basename as basename3,
   dirname as dirname2,
   extname as extname2,
   isAbsolute as isAbsolute2,
@@ -5329,7 +6049,7 @@ async function resolveLocalImport2(fromFile, specifier) {
     `Could not resolve local import "${specifier}" from ${fromFile}`
   );
 }
-async function discoverPackagedLocalFiles(entryFile) {
+async function discoverPackagedLocalFiles(entryFile, analyzedSources = {}) {
   const absoluteEntryFile = resolve2(entryFile);
   const packagingRoot = dirname2(absoluteEntryFile);
   const files = /* @__PURE__ */ new Map();
@@ -5341,18 +6061,19 @@ async function discoverPackagedLocalFiles(entryFile) {
       return;
     }
     visitedFiles.add(absolutePath);
-    const sourceCode = await readFile2(absolutePath, "utf-8");
+    const sourceCode = analyzedSources[absolutePath] ?? await readFile2(absolutePath, "utf-8");
     if (extname2(absolutePath).toLowerCase() === ".json" || isTextImportFile2(absolutePath)) {
       return;
     }
     const scanSource = stripCommentsToSpaces2(sourceCode);
     const constants = collectTopLevelStringConstants(sourceCode);
+    const runtimeNames = playRuntimeNames(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")) {
+      if (!isRuntimeReceiver(target, runtimeNames)) {
         continue;
       }
       const openParen = findCallOpenParen(
@@ -5509,6 +6230,8 @@ async function bundleDeployPlayFile(entryFile, options) {
 export {
   isAstNode,
   parsePlaySourceForAnalysis,
+  INLINE_PLAY_FILE,
+  inlinePlaySource,
   PLAY_DEFAULT_EXPORT,
   listPlayFileExports,
   extractDefinedPlayName,