deepline 0.3.480 → 0.3.481

package/dist/cli/chunk-KQSTV4MW.js

@@ -0,0 +1,789 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// ../plays/script-entry.ts
+var _path = require('path');
+
+// ../plays/ts-ast.ts
+var _acorn = require('acorn');
+var _acorntypescript = require('acorn-typescript');
+var TypeScriptParser = _acorn.Parser.extend(
+  _acorntypescript.tsPlugin.call(void 0, {
+    allowSatisfies: true,
+    jsx: {
+      allowNamespaces: true,
+      allowNamespacedObjects: true
+    }
+  })
+);
+function isAstNode(value) {
+  return value !== null && typeof value === "object" && "type" in value;
+}
+function astArray(value) {
+  return Array.isArray(value) ? value.filter(isAstNode) : [];
+}
+function parsePlaySourceForAnalysis(sourceCode) {
+  try {
+    return TypeScriptParser.parse(sourceCode, {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      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', _ => _.node]), () => ( null)));
+  const configExport = configExportOf(program);
+  const headerEnd = _nullishCoalesce(_optionalChain([header, 'access', _2 => _2.at, 'call', _3 => _3(-1), 'optionalAccess', _4 => _4.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', _5 => _5.exportStatement]),
+      _optionalChain([entry, 'optionalAccess', _6 => _6.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', _7 => _7.node, 'access', _8 => _8.body]);
+  const code = [
+    ...moduleCode,
+    ..._optionalChain([body, 'optionalAccess', _9 => _9.type]) === "BlockStatement" ? body.body : []
+  ];
+  const [parameter] = _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _10 => _10.node, 'access', _11 => _11.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', _12 => _12.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', _13 => _13.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', _14 => _14.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', _15 => _15.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', _16 => _16.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', _17 => _17.loc, 'optionalAccess', _18 => _18.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', _19 => _19.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', _20 => _20.name]), () => ( _optionalChain([exported, 'optionalAccess', _21 => _21.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', _22 => _22.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', _23 => _23.id, 'optionalAccess', _24 => _24.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', _25 => _25.specifiers, 'optionalAccess', _26 => _26.find, 'call', _27 => _27((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) {
+  return isAstNode(node) && node.type === "Identifier" ? typeof node.name === "string" ? node.name : null : null;
+}
+function unwrapStaticExpression(node) {
+  let current = node;
+  while (current && (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression" || current.type === "ParenthesizedExpression")) {
+    current = isAstNode(current.expression) ? current.expression : null;
+  }
+  return current;
+}
+function isDefinePlayCall(node) {
+  const expression = unwrapStaticExpression(node);
+  if (!expression || expression.type !== "CallExpression") return false;
+  const callee = isAstNode(expression.callee) ? expression.callee : null;
+  if (!callee) return false;
+  if (callee.type === "Identifier") {
+    return callee.name === "definePlay" || callee.name === "defineWorkflow";
+  }
+  if (callee.type === "MemberExpression" && !callee.computed && isAstNode(callee.property) && callee.property.type === "Identifier") {
+    return callee.property.name === "definePlay" || callee.property.name === "defineWorkflow";
+  }
+  return false;
+}
+function stringLiteralValue(node) {
+  const expression = unwrapStaticExpression(node);
+  return _optionalChain([expression, 'optionalAccess', _28 => _28.type]) === "Literal" && typeof expression.value === "string" ? expression.value : null;
+}
+function definePlayName(node) {
+  const expression = unwrapStaticExpression(node);
+  if (!expression || expression.type !== "CallExpression") return null;
+  const first = unwrapStaticExpression(
+    _nullishCoalesce(astArray(expression.arguments)[0], () => ( null))
+  );
+  if (_optionalChain([first, 'optionalAccess', _29 => _29.type]) !== "ObjectExpression") return stringLiteralValue(first);
+  return objectStringProperty(first, "id");
+}
+function objectStringProperty(object, propertyName) {
+  let value = null;
+  for (const property of astArray(_optionalChain([object, 'optionalAccess', _30 => _30.properties]))) {
+    if (property.type !== "Property" || property.computed) continue;
+    const key = isAstNode(property.key) ? property.key : null;
+    const keyName = _nullishCoalesce(getIdentifierName(key), () => ( (_optionalChain([key, 'optionalAccess', _31 => _31.type]) === "Literal" && typeof key.value === "string" ? key.value : null)));
+    if (keyName !== propertyName) continue;
+    value = stringLiteralValue(
+      isAstNode(property.value) ? property.value : null
+    );
+  }
+  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;
+  const recordDeclarations = (declaration, exported) => {
+    for (const declarator of astArray(declaration.declarations)) {
+      const name = getIdentifierName(declarator.id);
+      if (!name) continue;
+      declarations.set(
+        name,
+        isAstNode(declarator.init) ? declarator.init : null
+      );
+      if (exported) namedExports.set(name, name);
+    }
+  };
+  for (const statement of astArray(ast.body)) {
+    if (statement.type === "VariableDeclaration") {
+      recordDeclarations(statement, false);
+      continue;
+    }
+    if (statement.type === "ExportDefaultDeclaration") {
+      defaultExpression = isAstNode(statement.declaration) ? statement.declaration : null;
+      continue;
+    }
+    if (statement.type === "TSExportAssignment") {
+      defaultExpression = isAstNode(statement.expression) ? statement.expression : null;
+      continue;
+    }
+    if (statement.type !== "ExportNamedDeclaration") continue;
+    if (isAstNode(statement.declaration) && statement.declaration.type === "VariableDeclaration") {
+      recordDeclarations(statement.declaration, true);
+    }
+    for (const specifier of astArray(statement.specifiers)) {
+      const localName = getIdentifierName(specifier.local);
+      const exportedName2 = getIdentifierName(specifier.exported);
+      if (localName && exportedName2) namedExports.set(exportedName2, localName);
+    }
+  }
+  const defaultLocalName = getIdentifierName(
+    unwrapStaticExpression(defaultExpression)
+  );
+  const defaultIsPlay = defaultLocalName ? isDefinePlayCall(_nullishCoalesce(declarations.get(defaultLocalName), () => ( null))) : isDefinePlayCall(defaultExpression);
+  const exports = [];
+  const aliasedLocals = /* @__PURE__ */ new Set();
+  if (defaultIsPlay) {
+    const aliases = defaultLocalName ? [...namedExports.entries()].filter(([, local]) => local === defaultLocalName).map(([exported]) => exported) : [];
+    if (defaultLocalName) aliasedLocals.add(defaultLocalName);
+    exports.push({
+      name: PLAY_DEFAULT_EXPORT,
+      aliases,
+      playName: definePlayName(
+        defaultLocalName ? _nullishCoalesce(declarations.get(defaultLocalName), () => ( null)) : defaultExpression
+      )
+    });
+  }
+  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: exportedName2,
+      aliases: [],
+      playName: definePlayName(declaration)
+    });
+  }
+  return exports;
+}
+function canonicalPlayExportName(exportName, exports) {
+  const requested = _optionalChain([exportName, 'optionalAccess', _32 => _32.trim, 'call', _33 => _33()]) || PLAY_DEFAULT_EXPORT;
+  for (const entry of exports) {
+    if (entry.name === requested || entry.aliases.includes(requested)) {
+      return entry.name;
+    }
+  }
+  for (const entry of exports) {
+    if (entry.playName === requested) return entry.name;
+  }
+  return null;
+}
+function playExportNamesForMessage(exports) {
+  return exports.flatMap((entry) => [
+    ...entry.playName ? [entry.playName] : [],
+    entry.name,
+    ...entry.aliases
+  ]);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.TypeScriptParser = TypeScriptParser; exports.isAstNode = isAstNode; exports.astArray = astArray; exports.parsePlaySourceForAnalysis = parsePlaySourceForAnalysis; exports.PLAY_FILE_PATTERN = PLAY_FILE_PATTERN; exports.INLINE_PLAY_FILE = INLINE_PLAY_FILE; exports.inlinePlaySource = inlinePlaySource; exports.playNameFromPath = playNameFromPath; exports.parseScriptPlay = parseScriptPlay; exports.playRuntimeNames = playRuntimeNames; exports.isRuntimeReceiver = isRuntimeReceiver; exports.wrapScriptPlay = wrapScriptPlay; exports.validateScriptPlay = validateScriptPlay; exports.SCRIPT_PLAY_MODULE_DECLARATION = SCRIPT_PLAY_MODULE_DECLARATION; exports.PLAY_DEFAULT_EXPORT = PLAY_DEFAULT_EXPORT; exports.isDefinePlayCall = isDefinePlayCall; exports.listPlayFileExports = listPlayFileExports; exports.canonicalPlayExportName = canonicalPlayExportName; exports.playExportNamesForMessage = playExportNamesForMessage;