deepline 0.3.422 → 0.3.424

package/dist/cli/{chunk-OQQOXSYA.js → chunk-YHRS6XTB.js}

@@ -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 (e) {
     return null;
   }
 }
 
+// ../plays/script-entry.ts
+
+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 _path.basename.call(void 0, 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 = _nullishCoalesce(defaultImportName(header.find(isSdkImport)), () => ( SCRIPT_SDK));
+  const parts = scriptPlayParts(program, contextName, _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _7 => _7.node]), () => ( null)));
+  const configExport = configExportOf(program);
+  const headerEnd = _nullishCoalesce(_optionalChain([header, 'access', _8 => _8.at, 'call', _9 => _9(-1), 'optionalAccess', _10 => _10.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(
+    [
+      _optionalChain([entry, 'optionalAccess', _11 => _11.exportStatement]),
+      _optionalChain([entry, 'optionalAccess', _12 => _12.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 = _optionalChain([entry, 'optionalAccess', _13 => _13.node, 'access', _14 => _14.body]);
+  const code = [
+    ...moduleCode,
+    ..._optionalChain([body, 'optionalAccess', _15 => _15.type]) === "BlockStatement" ? body.body : []
+  ];
+  const [parameter] = _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _16 => _16.node, 'access', _17 => _17.params]), () => ( []));
+  return {
+    entry,
+    entryCall,
+    code,
+    contextName,
+    headerEnd,
+    delegate: delegateOf(code, contextName),
+    config: _nullishCoalesce((configExport && configObjectOf(configExport)), () => ( parts.config)),
+    // The entry's parameter is its input; `(input) => ({ ... })` returns its
+    // expression.
+    inputType: _nullishCoalesce(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 || _optionalChain([statement, 'optionalAccess', _18 => _18.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" && _optionalChain([runtime, 'optionalAccess', _19 => _19.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 = _nullishCoalesce(current.expression, () => ( current.argument));
+    current = isAstNode(inner) ? inner : null;
+  }
+  return current;
+}
+function parameterType(parameter) {
+  const target = _optionalChain([parameter, 'optionalAccess', _20 => _20.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" && _optionalChain([argument, 'optionalAccess', _21 => _21.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 (_optionalChain([node, 'optionalAccess', _22 => _22.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 = _nullishCoalesce(call.typeArguments, () => ( call.typeParameters));
+  return isAstNode(instantiation) && Array.isArray(instantiation.params) ? _nullishCoalesce(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 || (_nullishCoalesce(right.end, () => ( right.at))) - (_nullishCoalesce(left.end, () => ( left.at)))
+  ).reduce(
+    (text, edit) => text.slice(0, edit.at) + edit.text + text.slice(_nullishCoalesce(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 = (_nullishCoalesce(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 = _optionalChain([error, 'access', _23 => _23.loc, 'optionalAccess', _24 => _24.line]);
+    throw new Error(
+      `line ${_nullishCoalesce(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 _nullishCoalesce(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 _optionalChain([init, 'optionalAccess', _25 => _25.type]) === "ObjectExpression" ? init : null;
+}
+function isDefaultExport(node) {
+  if (node.type === "ExportDefaultDeclaration") return true;
+  const specifiers = _nullishCoalesce(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 _nullishCoalesce(_optionalChain([exported, 'optionalAccess', _26 => _26.name]), () => ( _optionalChain([exported, 'optionalAccess', _27 => _27.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 _optionalChain([declared, 'optionalAccess', _28 => _28.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" && _optionalChain([node, 'access', _29 => _29.id, 'optionalAccess', _30 => _30.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 = _optionalChain([importDeclaration, 'optionalAccess', _31 => _31.specifiers, 'optionalAccess', _32 => _32.find, 'call', _33 => _33((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) {
@@ -1924,7 +2509,7 @@ function isDefinePlayCall(node) {
 }
 function stringLiteralValue(node) {
   const expression = unwrapStaticExpression(node);
-  return _optionalChain([expression, 'optionalAccess', _7 => _7.type]) === "Literal" && typeof expression.value === "string" ? expression.value : null;
+  return _optionalChain([expression, 'optionalAccess', _34 => _34.type]) === "Literal" && typeof expression.value === "string" ? expression.value : null;
 }
 function definePlayName(node) {
   const expression = unwrapStaticExpression(node);
@@ -1932,20 +2517,35 @@ function definePlayName(node) {
   const first = unwrapStaticExpression(
     _nullishCoalesce(astArray(expression.arguments)[0], () => ( null))
   );
-  if (_optionalChain([first, 'optionalAccess', _8 => _8.type]) !== "ObjectExpression") return stringLiteralValue(first);
-  let id = null;
-  for (const property of astArray(first.properties)) {
+  if (_optionalChain([first, 'optionalAccess', _35 => _35.type]) !== "ObjectExpression") return stringLiteralValue(first);
+  return objectStringProperty(first, "id");
+}
+function objectStringProperty(object, propertyName) {
+  let value = null;
+  for (const property of astArray(_optionalChain([object, 'optionalAccess', _36 => _36.properties]))) {
     if (property.type !== "Property" || property.computed) continue;
     const key = isAstNode(property.key) ? property.key : null;
-    const keyName = _nullishCoalesce(getIdentifierName(key), () => ( (_optionalChain([key, 'optionalAccess', _9 => _9.type]) === "Literal" && typeof key.value === "string" ? key.value : null)));
-    if (keyName !== "id") continue;
-    id = stringLiteralValue(isAstNode(property.value) ? property.value : null);
+    const keyName = _nullishCoalesce(getIdentifierName(key), () => ( (_optionalChain([key, 'optionalAccess', _37 => _37.type]) === "Literal" && typeof key.value === "string" ? key.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 = _nullishCoalesce(declarations.get(localName), () => ( null));
     if (!isDefinePlayCall(declaration)) continue;
     exports.push({
-      name: exportedName,
+      name: exportedName2,
       aliases: [],
       playName: definePlayName(declaration)
     });
@@ -2014,7 +2614,7 @@ function listPlayFileExports(sourceCode) {
   return exports;
 }
 function canonicalPlayExportName(exportName, exports) {
-  const requested = _optionalChain([exportName, 'optionalAccess', _10 => _10.trim, 'call', _11 => _11()]) || PLAY_DEFAULT_EXPORT;
+  const requested = _optionalChain([exportName, 'optionalAccess', _38 => _38.trim, 'call', _39 => _39()]) || PLAY_DEFAULT_EXPORT;
   for (const entry of exports) {
     if (entry.name === requested || entry.aliases.includes(requested)) {
       return entry.name;
@@ -2092,7 +2692,7 @@ function parseAttributes(source, line, errors) {
   const validAttributes = MERMAID_NODE_ATTRIBUTES;
   let cursor = 0;
   while (cursor < source.length) {
-    cursor += _nullishCoalesce(_optionalChain([/^\s*/, 'access', _12 => _12.exec, 'call', _13 => _13(source.slice(cursor)), 'optionalAccess', _14 => _14[0], 'access', _15 => _15.length]), () => ( 0));
+    cursor += _nullishCoalesce(_optionalChain([/^\s*/, 'access', _40 => _40.exec, 'call', _41 => _41(source.slice(cursor)), 'optionalAccess', _42 => _42[0], 'access', _43 => _43.length]), () => ( 0));
     if (cursor >= source.length) break;
     ATTRIBUTE.lastIndex = cursor;
     const match = ATTRIBUTE.exec(source);
@@ -2135,12 +2735,12 @@ var SHAPE_KINDS = {
 };
 var MERMAID_LABEL_LOOKS_LIKE_SOURCE = /^(?:\[|\{|\(|>)/;
 function parseMermaidNodeAtStart(source) {
-  const leadingWhitespace = _nullishCoalesce(_optionalChain([/^\s*/, 'access', _16 => _16.exec, 'call', _17 => _17(source), 'optionalAccess', _18 => _18[0], 'access', _19 => _19.length]), () => ( 0));
+  const leadingWhitespace = _nullishCoalesce(_optionalChain([/^\s*/, 'access', _44 => _44.exec, 'call', _45 => _45(source), 'optionalAccess', _46 => _46[0], 'access', _47 => _47.length]), () => ( 0));
   const idMatch = MERMAID_NODE_ID.exec(source.slice(leadingWhitespace));
   if (!idMatch) return null;
   const id = idMatch[0];
   let cursor = leadingWhitespace + id.length;
-  cursor += _nullishCoalesce(_optionalChain([/^\s*/, 'access', _20 => _20.exec, 'call', _21 => _21(source.slice(cursor)), 'optionalAccess', _22 => _22[0], 'access', _23 => _23.length]), () => ( 0));
+  cursor += _nullishCoalesce(_optionalChain([/^\s*/, 'access', _48 => _48.exec, 'call', _49 => _49(source.slice(cursor)), 'optionalAccess', _50 => _50[0], 'access', _51 => _51.length]), () => ( 0));
   const shape = MERMAID_NODE_SHAPES.find(
     ([open2]) => source.startsWith(open2, cursor)
   );
@@ -2158,7 +2758,7 @@ function parseMermaidNodeAtStart(source) {
         continue;
       }
       if (source[index] !== openingQuote) continue;
-      const whitespace = _nullishCoalesce(_optionalChain([/^\s*/, 'access', _24 => _24.exec, 'call', _25 => _25(source.slice(index + 1)), 'optionalAccess', _26 => _26[0], 'access', _27 => _27.length]), () => ( 0));
+      const whitespace = _nullishCoalesce(_optionalChain([/^\s*/, 'access', _52 => _52.exec, 'call', _53 => _53(source.slice(index + 1)), 'optionalAccess', _54 => _54[0], 'access', _55 => _55.length]), () => ( 0));
       const candidate = index + 1 + whitespace;
       if (source.startsWith(close, candidate)) {
         labelEnd = candidate;
@@ -2196,8 +2796,8 @@ function parseShapedMermaidNodes(fragment) {
     if (!identifier2) break;
     const start = cursor + (_nullishCoalesce(identifier2.index, () => ( 0)));
     const parsed = parseMermaidNodeAtStart(fragment.slice(start));
-    if (_optionalChain([parsed, 'optionalAccess', _28 => _28.shaped]) || _optionalChain([parsed, 'optionalAccess', _29 => _29.unterminated])) nodes.push(parsed);
-    cursor = start + Math.max(_nullishCoalesce(_optionalChain([parsed, 'optionalAccess', _30 => _30.length]), () => ( identifier2[0].length)), 1);
+    if (_optionalChain([parsed, 'optionalAccess', _56 => _56.shaped]) || _optionalChain([parsed, 'optionalAccess', _57 => _57.unterminated])) nodes.push(parsed);
+    cursor = start + Math.max(_nullishCoalesce(_optionalChain([parsed, 'optionalAccess', _58 => _58.length]), () => ( identifier2[0].length)), 1);
   }
   return nodes;
 }
@@ -2214,7 +2814,7 @@ function parseEdgeChain(line) {
     remaining = remaining.slice(connector[0].length);
     const next = parseMermaidNodeAtStart(remaining);
     if (!next) return null;
-    labels.push(_optionalChain([connector, 'access', _31 => _31[1], 'optionalAccess', _32 => _32.trim, 'call', _33 => _33()]) || void 0);
+    labels.push(_optionalChain([connector, 'access', _59 => _59[1], 'optionalAccess', _60 => _60.trim, 'call', _61 => _61()]) || void 0);
     nodes.push(next);
     remaining = remaining.slice(next.length);
   }
@@ -2295,7 +2895,7 @@ function blockLabel(block) {
 }
 function parseDocflowBlockGraph(mermaidSource, errors) {
   const docLines = mermaidSource.split(/\r?\n/).filter((line) => line.trim() && !line.trim().startsWith("%%"));
-  const direction = _optionalChain([FLOW_START, 'access', _34 => _34.exec, 'call', _35 => _35(_nullishCoalesce(docLines[0], () => ( ""))), 'optionalAccess', _36 => _36[1], 'optionalAccess', _37 => _37.toUpperCase, 'call', _38 => _38()]);
+  const direction = _optionalChain([FLOW_START, 'access', _62 => _62.exec, 'call', _63 => _63(_nullishCoalesce(docLines[0], () => ( ""))), 'optionalAccess', _64 => _64[1], 'optionalAccess', _65 => _65.toUpperCase, 'call', _66 => _66()]);
   if (!direction) {
     errors.push(
       "Docflow must start with `flowchart` or `graph` and direction `LR`, `RL`, `TB`, `TD`, or `BT`."
@@ -2347,12 +2947,12 @@ function parseDocflowBlockGraph(mermaidSource, errors) {
           const at = subgraph.memberIds.indexOf(id);
           if (at !== -1) subgraph.memberIds.splice(at, 1);
         }
-        _optionalChain([subgraphStack, 'access', _39 => _39[subgraphStack.length - 1], 'optionalAccess', _40 => _40.memberIds, 'access', _41 => _41.push, 'call', _42 => _42(id)]);
+        _optionalChain([subgraphStack, 'access', _67 => _67[subgraphStack.length - 1], 'optionalAccess', _68 => _68.memberIds, 'access', _69 => _69.push, 'call', _70 => _70(id)]);
       } else if (existing && existing.label !== label) {
         errors.push(`Docflow node "${id}" has conflicting labels.`);
       } else if (!existing) {
         nodes.set(id, { id, label, kind });
-        _optionalChain([subgraphStack, 'access', _43 => _43[subgraphStack.length - 1], 'optionalAccess', _44 => _44.memberIds, 'access', _45 => _45.push, 'call', _46 => _46(id)]);
+        _optionalChain([subgraphStack, 'access', _71 => _71[subgraphStack.length - 1], 'optionalAccess', _72 => _72.memberIds, 'access', _73 => _73.push, 'call', _74 => _74(id)]);
       }
     }
     return sawDeclaration;
@@ -2361,7 +2961,7 @@ function parseDocflowBlockGraph(mermaidSource, errors) {
     const opened = SUBGRAPH_OPEN.exec(line);
     if (opened) {
       const id = opened[1];
-      const rawLabel = _nullishCoalesce(_optionalChain([opened, 'access', _47 => _47[2], 'optionalAccess', _48 => _48.trim, 'call', _49 => _49()]), () => ( ""));
+      const rawLabel = _nullishCoalesce(_optionalChain([opened, 'access', _75 => _75[2], 'optionalAccess', _76 => _76.trim, 'call', _77 => _77()]), () => ( ""));
       const label = rawLabel.length >= 2 && (rawLabel.startsWith('"') && rawLabel.endsWith('"') || rawLabel.startsWith("'") && rawLabel.endsWith("'")) ? rawLabel.slice(1, -1) : rawLabel;
       const parent = subgraphStack[subgraphStack.length - 1];
       const subgraph = {
@@ -2414,7 +3014,7 @@ function parseDocflowBlockGraph(mermaidSource, errors) {
       const existing = nodes.get(node.id);
       if (!existing) {
         nodes.set(node.id, node);
-        _optionalChain([subgraphStack, 'access', _50 => _50[subgraphStack.length - 1], 'optionalAccess', _51 => _51.memberIds, 'access', _52 => _52.push, 'call', _53 => _53(node.id)]);
+        _optionalChain([subgraphStack, 'access', _78 => _78[subgraphStack.length - 1], 'optionalAccess', _79 => _79.memberIds, 'access', _80 => _80.push, 'call', _81 => _81(node.id)]);
       } else if (existing.label === existing.id && node.label !== node.id) {
         existing.label = node.label;
         existing.kind = node.kind;
@@ -2569,7 +3169,7 @@ function playExportSourceRanges(sourceCode) {
     const recordDeclarations = (declaration, exported) => {
       for (const declarator of astArray(declaration.declarations)) {
         const id = isAstNode(declarator.id) ? declarator.id : null;
-        const name = _optionalChain([id, 'optionalAccess', _54 => _54.type]) === "Identifier" && typeof id.name === "string" ? id.name : null;
+        const name = _optionalChain([id, 'optionalAccess', _82 => _82.type]) === "Identifier" && typeof id.name === "string" ? id.name : null;
         if (!name) continue;
         declarations.set(
           name,
@@ -2591,21 +3191,21 @@ function playExportSourceRanges(sourceCode) {
       for (const specifier of astArray(statement.specifiers)) {
         const local = isAstNode(specifier.local) ? specifier.local : null;
         const exported = isAstNode(specifier.exported) ? specifier.exported : null;
-        if (_optionalChain([local, 'optionalAccess', _55 => _55.type]) === "Identifier" && typeof local.name === "string" && _optionalChain([exported, 'optionalAccess', _56 => _56.type]) === "Identifier" && typeof exported.name === "string") {
+        if (_optionalChain([local, 'optionalAccess', _83 => _83.type]) === "Identifier" && typeof local.name === "string" && _optionalChain([exported, 'optionalAccess', _84 => _84.type]) === "Identifier" && typeof exported.name === "string") {
           namedExports.set(exported.name, local.name);
         }
       }
     }
   }
   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(_nullishCoalesce(declarations.get(unwrapped.name), () => ( null)), seen);
+    seen.add(unwrapped2.name);
+    return resolveCall(_nullishCoalesce(declarations.get(unwrapped2.name), () => ( null)), seen);
   };
   const defaultCall = resolveCall(defaultExpression);
   const ranges = [];
@@ -2628,7 +3228,7 @@ function projectRecordedArms(block, errors) {
   for (const binding of block.bindings) {
     if (!binding.arm) continue;
     const incoming = block.edges.filter(
-      (edge2) => edge2.to === binding.nodeId && _optionalChain([block, 'access', _57 => _57.nodes, 'access', _58 => _58.get, 'call', _59 => _59(edge2.from), 'optionalAccess', _60 => _60.kind]) === "decision"
+      (edge2) => edge2.to === binding.nodeId && _optionalChain([block, 'access', _85 => _85.nodes, 'access', _86 => _86.get, 'call', _87 => _87(edge2.from), 'optionalAccess', _88 => _88.kind]) === "decision"
     );
     if (incoming.length === 0) {
       errors.push(
@@ -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.`
@@ -2739,7 +3340,7 @@ function parseDocflowBindingsInSource(source, errors, rejectedNodeIds) {
     MERMAID_NODE.lastIndex = 0;
     const mermaidMatch = _nullishCoalesce(MERMAID_NODE.exec(lines[index]), () => ( null));
     if (!mermaidMatch) continue;
-    const annotatedId = _optionalChain([mermaidMatch, 'access', _61 => _61[1], 'optionalAccess', _62 => _62.trim, 'call', _63 => _63()]);
+    const annotatedId = _optionalChain([mermaidMatch, 'access', _89 => _89[1], 'optionalAccess', _90 => _90.trim, 'call', _91 => _91()]);
     if (annotatedId) rejectedNodeIds.add(annotatedId);
     const attributes = parseAttributes(
       _nullishCoalesce(mermaidMatch[2], () => ( "")),
@@ -2747,7 +3348,7 @@ function parseDocflowBindingsInSource(source, errors, rejectedNodeIds) {
       errors
     );
     if (!attributes) continue;
-    const id = _optionalChain([(_nullishCoalesce(annotatedId, () => ( attributes.id))), 'optionalAccess', _64 => _64.trim, 'call', _65 => _65()]);
+    const id = _optionalChain([(_nullishCoalesce(annotatedId, () => ( attributes.id))), 'optionalAccess', _92 => _92.trim, 'call', _93 => _93()]);
     if (!id) {
       errors.push(`Docflow annotation on line ${index + 1} requires id:"\u2026".`);
       continue;
@@ -2843,7 +3444,7 @@ function findDocflowBoundStatement(ast, line, lineStarts) {
     const node = pending.pop();
     const bounds = astNodeBounds(node);
     if (bounds && bounds.start < lineEnd && bounds.end > lineStart && statementTypes.has(node.type)) {
-      if (!match || bounds.end - bounds.start < (_nullishCoalesce(_optionalChain([astNodeBounds, 'call', _66 => _66(match), 'optionalAccess', _67 => _67.end]), () => ( 0))) - (_nullishCoalesce(_optionalChain([astNodeBounds, 'call', _68 => _68(match), 'optionalAccess', _69 => _69.start]), () => ( 0)))) {
+      if (!match || bounds.end - bounds.start < (_nullishCoalesce(_optionalChain([astNodeBounds, 'call', _94 => _94(match), 'optionalAccess', _95 => _95.end]), () => ( 0))) - (_nullishCoalesce(_optionalChain([astNodeBounds, 'call', _96 => _96(match), 'optionalAccess', _97 => _97.start]), () => ( 0)))) {
         match = node;
       }
     }
@@ -2862,7 +3463,7 @@ var DOCFLOW_STATEMENT_TYPES = /* @__PURE__ */ new Set([
   "VariableDeclaration"
 ]);
 function docflowOutputRoot(binding) {
-  const first = _optionalChain([binding, 'access', _70 => _70.outputs, 'optionalAccess', _71 => _71[0]]);
+  const first = _optionalChain([binding, 'access', _98 => _98.outputs, 'optionalAccess', _99 => _99[0]]);
   if (!first) return null;
   const root = first.split(".")[0];
   if (!root || root === "$output") return null;
@@ -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)) {
@@ -3143,7 +3744,7 @@ function extractPlaySourceAuthoringEdition(ast, exportName = null) {
     if (statement.type === "ExpressionStatement" && isAstNode(statement.expression) && statement.expression.type === "AssignmentExpression") {
       const left = isAstNode(statement.expression.left) ? statement.expression.left : null;
       const right = isAstNode(statement.expression.right) ? statement.expression.right : null;
-      if (_optionalChain([left, 'optionalAccess', _72 => _72.type]) === "MemberExpression" && !left.computed && right) {
+      if (_optionalChain([left, 'optionalAccess', _100 => _100.type]) === "MemberExpression" && !left.computed && right) {
         const object = isAstNode(left.object) ? left.object : null;
         if (identifier(object) === "module" && identifier(left.property) === "exports") {
           legacyExports.set("default", right);
@@ -3155,9 +3756,9 @@ function extractPlaySourceAuthoringEdition(ast, exportName = null) {
   }
   const resolve4 = (node, seen = /* @__PURE__ */ new Set()) => {
     const value2 = unwrap(node);
-    if (_optionalChain([value2, 'optionalAccess', _73 => _73.type]) === "UnaryExpression" && value2.operator === "void") {
+    if (_optionalChain([value2, 'optionalAccess', _101 => _101.type]) === "UnaryExpression" && value2.operator === "void") {
       const operand = unwrap(isAstNode(value2.argument) ? value2.argument : null);
-      if (_optionalChain([operand, 'optionalAccess', _74 => _74.type]) === "Literal")
+      if (_optionalChain([operand, 'optionalAccess', _102 => _102.type]) === "Literal")
         return { type: "Literal", value: void 0 };
     }
     const name = identifier(value2);
@@ -3169,12 +3770,12 @@ function extractPlaySourceAuthoringEdition(ast, exportName = null) {
   };
   const staticKey = (node) => {
     const value2 = resolve4(node);
-    if (_optionalChain([value2, 'optionalAccess', _75 => _75.type]) === "Literal" && (typeof value2.value === "string" || typeof value2.value === "number")) {
+    if (_optionalChain([value2, 'optionalAccess', _103 => _103.type]) === "Literal" && (typeof value2.value === "string" || typeof value2.value === "number")) {
       return String(value2.value);
     }
-    if (_optionalChain([value2, 'optionalAccess', _76 => _76.type]) === "TemplateLiteral" && astArray(value2.expressions).length === 0) {
+    if (_optionalChain([value2, 'optionalAccess', _104 => _104.type]) === "TemplateLiteral" && astArray(value2.expressions).length === 0) {
       const quasi = astArray(value2.quasis)[0];
-      const cooked = _optionalChain([quasi, 'optionalAccess', _77 => _77.value]) && typeof quasi.value === "object" ? quasi.value.cooked : null;
+      const cooked = _optionalChain([quasi, 'optionalAccess', _105 => _105.value]) && typeof quasi.value === "object" ? quasi.value.cooked : null;
       return typeof cooked === "string" ? cooked : null;
     }
     return null;
@@ -3182,9 +3783,9 @@ function extractPlaySourceAuthoringEdition(ast, exportName = null) {
   const property = (node, key, ancestors = /* @__PURE__ */ new Set()) => {
     if (!node) return { kind: "absent" };
     const object = resolve4(node);
-    if (_optionalChain([object, 'optionalAccess', _78 => _78.type]) === "Literal" && object.value == null)
+    if (_optionalChain([object, 'optionalAccess', _106 => _106.type]) === "Literal" && object.value == null)
       return { kind: "absent" };
-    if (_optionalChain([object, 'optionalAccess', _79 => _79.type]) !== "ObjectExpression" || ancestors.has(object))
+    if (_optionalChain([object, 'optionalAccess', _107 => _107.type]) !== "ObjectExpression" || ancestors.has(object))
       return { kind: "unknown" };
     const next = new Set(ancestors).add(object);
     for (const entry of astArray(object.properties).reverse()) {
@@ -3209,11 +3810,11 @@ function extractPlaySourceAuthoringEdition(ast, exportName = null) {
   const callMarker = (call) => {
     const args = astArray(call.arguments);
     const first = resolve4(_nullishCoalesce(args[0], () => ( null)));
-    const objectForm = _optionalChain([first, 'optionalAccess', _80 => _80.type]) === "ObjectExpression" || args.length === 1;
+    const objectForm = _optionalChain([first, 'optionalAccess', _108 => _108.type]) === "ObjectExpression" || args.length === 1;
     const options = objectForm ? _nullishCoalesce(args[0], () => ( null)) : _nullishCoalesce(args[2], () => ( null));
     const direct = property(options, "compatibility");
     let compatibility = direct;
-    if (direct.kind === "absent" || direct.kind === "found" && _optionalChain([resolve4, 'call', _81 => _81(direct.value), 'optionalAccess', _82 => _82.type]) === "Literal" && _optionalChain([resolve4, 'call', _83 => _83(direct.value), 'optionalAccess', _84 => _84.value]) == null) {
+    if (direct.kind === "absent" || direct.kind === "found" && _optionalChain([resolve4, 'call', _109 => _109(direct.value), 'optionalAccess', _110 => _110.type]) === "Literal" && _optionalChain([resolve4, 'call', _111 => _111(direct.value), 'optionalAccess', _112 => _112.value]) == null) {
       const bindings = objectForm ? property(options, "bindings") : { kind: "absent" };
       compatibility = bindings.kind === "found" ? property(bindings.value, "compatibility") : bindings;
     }
@@ -3240,6 +3841,29 @@ function extractPlaySourceAuthoringEdition(ast, exportName = null) {
   const expression = resolve4(
     _nullishCoalesce(_nullishCoalesce(local, () => ( legacyExports.get(requested))), () => ( (exportName === null ? _nullishCoalesce(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") ? _nullishCoalesce(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: _optionalChain([value2, 'optionalAccess', _113 => _113.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: {
@@ -3257,11 +3881,22 @@ function extractPlaySourceAuthoringEdition(ast, exportName = null) {
   if (!recognized) return { marker: { kind: "unknown" }, localExport: false };
   const value = resolve4(marker.value);
   return {
-    marker: _optionalChain([value, 'optionalAccess', _85 => _85.type]) === "Literal" ? { kind: "value", value: value.value } : { kind: "unknown" },
+    marker: _optionalChain([value, 'optionalAccess', _114 => _114.type]) === "Literal" ? { kind: "value", value: value.value } : { kind: "unknown" },
     localExport: Boolean(local),
     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 = _optionalChain([call, 'optionalAccess', _115 => _115.type]) === "CallExpression" && isAstNode(call.callee) ? call.callee : null;
+    if (_optionalChain([callee, 'optionalAccess', _116 => _116.type]) === "MemberExpression" && !callee.computed && identifier(callee.property) === "config") {
+      const [argument] = astArray(call.arguments);
+      if (_optionalChain([argument, 'optionalAccess', _117 => _117.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,
@@ -3378,7 +4012,7 @@ function getPackageName(specifier) {
   return _nullishCoalesce(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 _nullishCoalesce(_optionalChain([extractDefinedPlayMetadata, 'call', _86 => _86(sourceCode, null), 'optionalAccess', _87 => _87.name]), () => ( null));
+function extractDefinedPlayName(sourceCode, filePath) {
+  return _nullishCoalesce(_optionalChain([extractDefinedPlayMetadata, 'call', _118 => _118(sourceCode, null, filePath), 'optionalAccess', _119 => _119.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 (e3) {
     try {
@@ -3474,7 +4110,9 @@ function parsePlaySourceAst(sourceCode) {
       return _acorn.Parser.parse(transformed, {
         ecmaVersion: "latest",
         sourceType: "module",
-        allowHashBang: true
+        allowHashBang: true,
+        // Script plays may end early with a top-level `return`.
+        allowReturnOutsideFunction: true
       });
     } catch (e4) {
       return null;
@@ -3581,9 +4219,9 @@ function buildPlayMetadataContext(ast) {
       }
       for (const specifier of astArray(statement.specifiers)) {
         const localName = getIdentifierName3(specifier.local);
-        const exportedName = _nullishCoalesce(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 = _nullishCoalesce(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);
         }
       }
     }
@@ -3633,7 +4271,7 @@ function staticStringFromExpression(node, context, seen = /* @__PURE__ */ new Se
       false
     );
     const value = left !== null && right !== null ? `${left}${right}` : null;
-    if (!_optionalChain([value, 'optionalAccess', _88 => _88.trim, 'call', _89 => _89()])) return null;
+    if (!_optionalChain([value, 'optionalAccess', _120 => _120.trim, 'call', _121 => _121()])) return null;
     return trimResult ? value.trim() : value;
   }
   const identifier2 = getIdentifierName3(expression);
@@ -3752,7 +4390,7 @@ function compatibilityFromOptions(node, context) {
   } else {
     let value = unwrapStaticExpression2(direct.value);
     const seen = /* @__PURE__ */ new Set();
-    while (_optionalChain([value, 'optionalAccess', _90 => _90.type]) === "Identifier") {
+    while (_optionalChain([value, 'optionalAccess', _122 => _122.type]) === "Identifier") {
       const name = getIdentifierName3(value);
       if (name === "undefined" && !context.declarations.has(name)) {
         value = { type: "Literal", value: void 0 };
@@ -3762,8 +4400,8 @@ function compatibilityFromOptions(node, context) {
       seen.add(name);
       value = unwrapStaticExpression2(context.declarations.get(name));
     }
-    const nullish = _optionalChain([value, 'optionalAccess', _91 => _91.type]) === "Literal" && value.value == null;
-    const voidLiteral = _optionalChain([value, 'optionalAccess', _92 => _92.type]) === "UnaryExpression" && value.operator === "void" && isAstNode(value.argument) && value.argument.type === "Literal";
+    const nullish = _optionalChain([value, 'optionalAccess', _123 => _123.type]) === "Literal" && value.value == null;
+    const voidLiteral = _optionalChain([value, 'optionalAccess', _124 => _124.type]) === "UnaryExpression" && value.operator === "void" && isAstNode(value.argument) && value.argument.type === "Literal";
     if (!nullish && !voidLiteral) return direct;
   }
   const bindings = resolveStaticProperty(node, "bindings", context);
@@ -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: _nullishCoalesce(stringPropertyFromObjectExpression(config, "name", context), () => ( (filePath ? playNameFromPath(filePath) : null))),
+    description: stringPropertyFromObjectExpression(
+      config,
+      "description",
+      context
+    ),
+    sandboxRuntimeDeclaration: sandboxRuntimeDeclarationFromOptions(
+      config,
+      context
+    ),
+    toolErrorSchemaVersion: _nullishCoalesce(toolErrorSchemaVersion, () => ( null)),
+    toolErrorSchemaVersionUnknown: toolErrorSchemaVersion === null,
+    toolResponseReceiptRevision: _nullishCoalesce(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,
@@ -4146,7 +4813,7 @@ function findDocflowContext(input) {
     if (!isAstNode(value)) continue;
     if (isDefinePlayCallExpression(value)) {
       const bounds = astNodeBounds(value);
-      if (bounds && bounds.start < lineEnd && bounds.end > lineStart && (!best || bounds.end - bounds.start < (_nullishCoalesce(_optionalChain([astNodeBounds, 'call', _93 => _93(best), 'optionalAccess', _94 => _94.end]), () => ( 0))) - (_nullishCoalesce(_optionalChain([astNodeBounds, 'call', _95 => _95(best), 'optionalAccess', _96 => _96.start]), () => ( 0))))) {
+      if (bounds && bounds.start < lineEnd && bounds.end > lineStart && (!best || bounds.end - bounds.start < (_nullishCoalesce(_optionalChain([astNodeBounds, 'call', _125 => _125(best), 'optionalAccess', _126 => _126.end]), () => ( 0))) - (_nullishCoalesce(_optionalChain([astNodeBounds, 'call', _127 => _127(best), 'optionalAccess', _128 => _128.start]), () => ( 0))))) {
         best = value;
       }
     }
@@ -4221,16 +4888,17 @@ function instrumentPlayDocflowRuntimeHits(sourceCode) {
   const targets = [];
   const injectedContextAt = /* @__PURE__ */ new Set();
   const parents = buildDocflowParentIndex(ast);
+  const scriptContext = _nullishCoalesce(_optionalChain([parseScriptPlay, 'call', _129 => _129(sourceCode), 'optionalAccess', _130 => _130.contextName]), () => ( null));
   for (const binding of parsed.bindings) {
     const resolution = resolveDocflowBinding(ast, binding, lineStarts, parents);
-    const context = findDocflowContext({
+    const context = _nullishCoalesce(findDocflowContext({
       ast,
       sourceCode,
       statement: resolution.statement,
       bindingLine: binding.line,
       lineStarts,
       parents
-    });
+    }), () => ( (scriptContext ? { kind: "named", name: scriptContext } : null)));
     if (!context) continue;
     if (context.kind === "unsupported") {
       throw new Error(
@@ -4250,7 +4918,7 @@ function instrumentPlayDocflowRuntimeHits(sourceCode) {
     }
     const lineStart = lineStarts[binding.line - 1];
     if (lineStart !== void 0) {
-      const indentationLength = _nullishCoalesce(_optionalChain([/^\s*/, 'access', _97 => _97.exec, 'call', _98 => _98(sourceCode.slice(lineStart)), 'optionalAccess', _99 => _99[0], 'access', _100 => _100.length]), () => ( 0));
+      const indentationLength = _nullishCoalesce(_optionalChain([/^\s*/, 'access', _131 => _131.exec, 'call', _132 => _132(sourceCode.slice(lineStart)), 'optionalAccess', _133 => _133[0], 'access', _134 => _134.length]), () => ( 0));
       replacements.push({
         start: lineStart + indentationLength,
         end: lineStart + indentationLength,
@@ -4310,26 +4978,32 @@ function instrumentPlayDocflowRuntimeHits(sourceCode) {
     sourceCode
   );
 }
-function docflowRuntimeInstrumentationPlugin(customerSourceFilePaths) {
-  const customerSourceFiles = new Set(
-    customerSourceFilePaths.filter((path) => _path.extname.call(void 0, path).toLowerCase() !== ".json").map((path) => _path.resolve.call(void 0, path))
+function docflowRuntimeInstrumentationPlugin(analyzedSources, scriptEntry) {
+  const customerSourceFiles = new Map(
+    Object.entries(analyzedSources).filter(([path]) => _path.extname.call(void 0, path).toLowerCase() !== ".json").map(([path, contents]) => [_path.resolve.call(void 0, path), contents])
   );
   return {
     name: "deepline-docflow-runtime-instrumentation",
     setup(buildContext) {
       buildContext.onLoad({ filter: /./ }, (args) => {
-        if (!customerSourceFiles.has(_path.resolve.call(void 0, args.path))) return void 0;
+        if (scriptEntry && _path.resolve.call(void 0, args.path) === _path.resolve.call(void 0, scriptEntry.path)) {
+          return {
+            contents: scriptEntryModule(scriptEntry.source, args.path),
+            loader: sourceLoaderForPath(args.path),
+            resolveDir: _path.dirname.call(void 0, args.path)
+          };
+        }
+        const contents = customerSourceFiles.get(_path.resolve.call(void 0, args.path));
+        if (contents === void 0) return void 0;
         if (isTextImportFile(args.path)) {
           return {
-            contents: _fs.readFileSync.call(void 0, args.path, "utf8"),
+            contents,
             loader: "text",
             resolveDir: _path.dirname.call(void 0, args.path)
           };
         }
         return {
-          contents: instrumentPlayDocflowRuntimeHits(
-            _fs.readFileSync.call(void 0, args.path, "utf8")
-          ),
+          contents: instrumentPlayDocflowRuntimeHits(contents),
           loader: sourceLoaderForPath(args.path),
           resolveDir: _path.dirname.call(void 0, 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 (_path.extname.call(void 0, 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,8 +5298,12 @@ async function analyzeSourceGraph(entryFile, adapter, exportName) {
   const metadata = _nullishCoalesce((selection.marker.kind === "value" && selection.definition ? playMetadataFromDefinePlayCall(
     selection.definition,
     buildPlayMetadataContext(sourceAst)
-  ) : extractDefinedPlayMetadata(sourceCode, exportName)), () => ( (exportName === "default" ? extractDefinedPlayMetadata(sourceCode, null) : null)));
-  const compatibilityDiagnostic = _optionalChain([metadata, 'optionalAccess', _101 => _101.toolErrorSchemaVersionUnknown]) ? "definePlay compatibility.toolErrorSchemaVersion must be the static literal 0 or 1." : _optionalChain([metadata, 'optionalAccess', _102 => _102.toolResponseReceiptRevisionUnknown]) ? "definePlay compatibility.toolResponseReceiptRevision must be a static non-empty string." : null;
+  ) : extractDefinedPlayMetadata(
+    authoredSource,
+    exportName,
+    absoluteEntryFile
+  )), () => ( (exportName === "default" ? extractDefinedPlayMetadata(authoredSource, null, absoluteEntryFile) : null)));
+  const compatibilityDiagnostic = _optionalChain([metadata, 'optionalAccess', _135 => _135.toolErrorSchemaVersionUnknown]) ? "definePlay compatibility.toolErrorSchemaVersion must be the static literal 0 or 1." : _optionalChain([metadata, 'optionalAccess', _136 => _136.toolResponseReceiptRevisionUnknown]) ? "definePlay compatibility.toolResponseReceiptRevision must be a static non-empty string." : null;
   try {
     resolvePlaySourceAuthoringContractEdition(selection.marker);
   } catch (error) {
@@ -4608,9 +5316,9 @@ ${error instanceof Error ? error.message : String(error)}`
     throw error;
   }
   if (compatibilityDiagnostic) throw new Error(compatibilityDiagnostic);
-  const playName = _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _103 => _103.name]), () => ( null));
-  const playDescription = _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _104 => _104.description]), () => ( null));
-  const sandboxRuntimeDeclaration = _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _105 => _105.sandboxRuntimeDeclaration]), () => ( null));
+  const playName = _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _137 => _137.name]), () => ( null));
+  const playDescription = _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _138 => _138.description]), () => ( null));
+  const sandboxRuntimeDeclaration = _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _139 => _139.sandboxRuntimeDeclaration]), () => ( null));
   return {
     sourceCode,
     sourceFiles: Object.fromEntries(
@@ -4628,13 +5336,15 @@ ${error instanceof Error ? error.message : String(error)}`
     playName,
     playDescription,
     sandboxRuntimeDeclaration,
-    toolErrorSchemaVersion: _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _106 => _106.toolErrorSchemaVersion]), () => ( null)),
-    toolResponseReceiptRevision: _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _107 => _107.toolResponseReceiptRevision]), () => ( null)),
+    toolErrorSchemaVersion: _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _140 => _140.toolErrorSchemaVersion]), () => ( null)),
+    toolResponseReceiptRevision: _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _141 => _141.toolResponseReceiptRevision]), () => ( null)),
     sourceAuthoringEdition: selection.marker,
     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,15 +5414,15 @@ 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 _esbuild.build.call(void 0, {
     ...namedExportShim ? {
       stdin: {
@@ -4745,9 +5455,9 @@ async function runEsbuildForCjsNode(entryFile, customerSourceFilePaths, imported
       (plugin) => plugin != null
     )
   });
-  const codeFile = _optionalChain([result, 'access', _108 => _108.outputFiles, 'optionalAccess', _109 => _109.find, 'call', _110 => _110((f) => f.path.endsWith(".cjs"))]);
-  const mapFile = _optionalChain([result, 'access', _111 => _111.outputFiles, 'optionalAccess', _112 => _112.find, 'call', _113 => _113((f) => f.path.endsWith(".cjs.map"))]);
-  if (!_optionalChain([codeFile, 'optionalAccess', _114 => _114.text]) || !_optionalChain([mapFile, 'optionalAccess', _115 => _115.text])) {
+  const codeFile = _optionalChain([result, 'access', _142 => _142.outputFiles, 'optionalAccess', _143 => _143.find, 'call', _144 => _144((f) => f.path.endsWith(".cjs"))]);
+  const mapFile = _optionalChain([result, 'access', _145 => _145.outputFiles, 'optionalAccess', _146 => _146.find, 'call', _147 => _147((f) => f.path.endsWith(".cjs.map"))]);
+  if (!_optionalChain([codeFile, 'optionalAccess', _148 => _148.text]) || !_optionalChain([mapFile, 'optionalAccess', _149 => _149.text])) {
     return ["Play bundling produced incomplete output."];
   }
   return {
@@ -4759,11 +5469,11 @@ async function runEsbuildForCjsNode(entryFile, customerSourceFilePaths, imported
 async function bundlePlayFile(filePath, options) {
   const adapter = options.adapter;
   const target = _nullishCoalesce(options.target, () => ( _chunkE4CABWXLjs.PLAY_ARTIFACT_KINDS.cjsNode20));
-  const exportName = _optionalChain([options, 'access', _116 => _116.exportName, 'optionalAccess', _117 => _117.trim, 'call', _118 => _118()]) || "default";
+  const exportName = _optionalChain([options, 'access', _150 => _150.exportName, 'optionalAccess', _151 => _151.trim, 'call', _152 => _152()]) || "default";
   assertValidExportName(exportName);
   const absolutePath = await normalizeLocalPath(filePath);
   const sourceIdentityRoot = adapter.sourceIdentityRoot;
-  _optionalChain([adapter, 'access', _119 => _119.warnAboutNonDevelopmentBundling, 'optionalCall', _120 => _120(absolutePath)]);
+  _optionalChain([adapter, 'access', _153 => _153.warnAboutNonDevelopmentBundling, 'optionalCall', _154 => _154(absolutePath)]);
   try {
     const preservedCompatibility = options.compatibility === void 0 ? void 0 : {
       ...options.compatibility,
@@ -4778,7 +5488,7 @@ async function bundlePlayFile(filePath, options) {
     );
     const edition = resolvePlaySourceAuthoringContractEdition(
       analysis.sourceAuthoringEdition,
-      _optionalChain([preservedCompatibility, 'optionalAccess', _121 => _121.authoringContractEdition])
+      _optionalChain([preservedCompatibility, 'optionalAccess', _155 => _155.authoringContractEdition])
     );
     const markedSource = analysis.sourceAuthoringEdition.kind === "value";
     if (markedSource && !analysis.sourceHasLocalPlayExport) {
@@ -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]) => [
@@ -4815,7 +5527,7 @@ preserved-compatibility:${JSON.stringify(preservedCompatibility)}`}`
       };
     }
     const typecheckErrors = [
-      ...await _asyncNullishCoalesce(await _optionalChain([adapter, 'access', _122 => _122.typecheckPlaySource, 'optionalCall', _123 => _123({
+      ...await _asyncNullishCoalesce(await _optionalChain([adapter, 'access', _156 => _156.typecheckPlaySource, 'optionalCall', _157 => _157({
         sourceCode: analysis.sourceCode,
         sourcePath: absolutePath,
         importedFilePaths: [
@@ -4823,7 +5535,11 @@ preserved-compatibility:${JSON.stringify(preservedCompatibility)}`}`
           ...analysis.importedPlayDependencies.map(
             (dependency) => dependency.filePath
           )
-        ]
+        ],
+        sourceFiles: {
+          ...analysis.sourceFiles,
+          ...analysis.importedPlaySources
+        }
       })]), async () => ( []))
     ];
     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 = _path.resolve.call(void 0, _nullishCoalesce(sourceIdentityRoot, () => ( adapter.projectRoot)));
     const buildOutcome = await runEsbuildForCjsNode(
       absolutePath,
-      analysis.importPolicy.localFiles,
+      analysis.sourceFiles,
+      analysis.entryScript,
       analysis.importedPlayDependencies,
       adapter,
       exportName,
@@ -5015,7 +5735,7 @@ function defaultPlayRuntimeProvider() {
   return PLAY_RUNTIME_PROVIDERS.absurd;
 }
 function resolvePlayRuntimeProvider(override) {
-  if (_optionalChain([override, 'optionalAccess', _124 => _124.trim, 'call', _125 => _125()])) {
+  if (_optionalChain([override, 'optionalAccess', _158 => _158.trim, 'call', _159 => _159()])) {
     const id = override.trim();
     if (id in PLAY_RUNTIME_PROVIDERS) {
       return PLAY_RUNTIME_PROVIDERS[id];
@@ -5041,7 +5761,7 @@ function resolveExecutionProfile(override) {
   try {
     return resolvePlayRuntimeProvider(override);
   } catch (error) {
-    if (_optionalChain([override, 'optionalAccess', _126 => _126.trim, 'call', _127 => _127()])) {
+    if (_optionalChain([override, 'optionalAccess', _160 => _160.trim, 'call', _161 => _161()])) {
       throw new Error(
         `Unknown execution profile "${override.trim()}". Expected one of: ${Object.keys(
           PLAY_EXECUTION_PROFILES
@@ -5055,7 +5775,7 @@ function resolveEnabledExecutionProfile(override) {
   try {
     return resolveEnabledPlayRuntimeProvider(override);
   } catch (error) {
-    if (_optionalChain([override, 'optionalAccess', _128 => _128.trim, 'call', _129 => _129()]) && error instanceof Error && /Unsupported play runtime provider/.test(error.message)) {
+    if (_optionalChain([override, 'optionalAccess', _162 => _162.trim, 'call', _163 => _163()]) && error instanceof Error && /Unsupported play runtime provider/.test(error.message)) {
       throw new Error(
         `Unknown execution profile "${override.trim()}". Expected one of: ${Object.keys(
           PLAY_EXECUTION_PROFILES
@@ -5282,7 +6002,7 @@ function localImportSpecifiers(sourceCode) {
   for (const match of source.matchAll(
     /\b(?:import|export)\s+(?!type\b)(?:[\s\S]*?\s+from\s*)?['"]([^'"]+)['"]/g
   )) {
-    if (_optionalChain([match, 'access', _130 => _130[1], 'optionalAccess', _131 => _131.startsWith, 'call', _132 => _132(".")])) specifiers.push(match[1]);
+    if (_optionalChain([match, 'access', _164 => _164[1], 'optionalAccess', _165 => _165.startsWith, 'call', _166 => _166(".")])) specifiers.push(match[1]);
   }
   for (const match of source.matchAll(
     /\brequire\s*\(\s*(['"])(\.[^'"]*)\1\s*\)/g
@@ -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 = _path.resolve.call(void 0, entryFile);
   const packagingRoot = _path.dirname.call(void 0, absoluteEntryFile);
   const files = /* @__PURE__ */ new Map();
@@ -5341,18 +6061,19 @@ async function discoverPackagedLocalFiles(entryFile) {
       return;
     }
     visitedFiles.add(absolutePath);
-    const sourceCode = await _promises.readFile.call(void 0, absolutePath, "utf-8");
+    const sourceCode = await _asyncNullishCoalesce(analyzedSources[absolutePath], async () => ( await _promises.readFile.call(void 0, absolutePath, "utf-8")));
     if (_path.extname.call(void 0, 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(
@@ -5516,4 +6237,6 @@ async function bundleDeployPlayFile(entryFile, options) {
 
 
 
-exports.isAstNode = isAstNode; exports.parsePlaySourceForAnalysis = parsePlaySourceForAnalysis; exports.PLAY_DEFAULT_EXPORT = PLAY_DEFAULT_EXPORT; exports.listPlayFileExports = listPlayFileExports; exports.extractDefinedPlayName = extractDefinedPlayName; exports.resolveEnabledExecutionProfile = resolveEnabledExecutionProfile; exports.createSdkPlayBundlingAdapter = createSdkPlayBundlingAdapter; exports.bundlePlayFile = bundlePlayFile2; exports.bundleDeployPlayFile = bundleDeployPlayFile;
+
+
+exports.isAstNode = isAstNode; exports.parsePlaySourceForAnalysis = parsePlaySourceForAnalysis; exports.INLINE_PLAY_FILE = INLINE_PLAY_FILE; exports.inlinePlaySource = inlinePlaySource; exports.PLAY_DEFAULT_EXPORT = PLAY_DEFAULT_EXPORT; exports.listPlayFileExports = listPlayFileExports; exports.extractDefinedPlayName = extractDefinedPlayName; exports.resolveEnabledExecutionProfile = resolveEnabledExecutionProfile; exports.createSdkPlayBundlingAdapter = createSdkPlayBundlingAdapter; exports.bundlePlayFile = bundlePlayFile2; exports.bundleDeployPlayFile = bundleDeployPlayFile;