deepline 0.3.293 → 0.3.295

package/dist/cli/chunk-GONRLVV3.js

@@ -0,0 +1,3440 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await 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; }
+
+var _chunk3KC45UVFjs = require('./chunk-3KC45UVF.js');
+
+
+var _chunkZDO3TO3Mjs = require('./chunk-ZDO3TO3M.js');
+
+
+
+
+
+
+var _chunk6A3TJUWCjs = require('./chunk-6A3TJUWC.js');
+
+
+var _chunk7P5AA3SNjs = require('./chunk-7P5AA3SN.js');
+
+
+var _chunkOG64RBACjs = require('./chunk-OG64RBAC.js');
+
+// src/plays/bundle-play-file.ts
+var _os = require('os');
+var _path = require('path');
+var _url = require('url');
+var _fs = require('fs');
+var _promises = require('fs/promises');
+
+// ../plays/bundling/index.ts
+var _crypto = require('crypto');
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _module = require('module');
+var _acorn = require('acorn');
+
+
+
+var _esbuild = require('esbuild');
+
+// ../plays/contracts.ts
+var PLAY_ARTIFACT_VERSION = _chunkOG64RBACjs.CURRENT_PLAY_ARTIFACT_CONTRACT_VERSION;
+function buildPlayContractCompatibility(input) {
+  return {
+    artifactVersion: PLAY_ARTIFACT_VERSION,
+    runtimeBackend: _nullishCoalesce(_optionalChain([input, 'optionalAccess', _ => _.runtimeBackend]), () => ( null)),
+    toolErrorSchemaVersion: _nullishCoalesce(_optionalChain([input, 'optionalAccess', _2 => _2.toolErrorSchemaVersion]), () => ( _chunk7P5AA3SNjs.TOOL_EXECUTION_ERROR_SCHEMA_VERSION)),
+    authoringContractEdition: _nullishCoalesce(_optionalChain([input, 'optionalAccess', _3 => _3.authoringContractEdition]), () => ( _chunkZDO3TO3Mjs.PLAY_AUTHORING_CONTRACT_EDITION)),
+    toolResponseContract: _nullishCoalesce(_optionalChain([input, 'optionalAccess', _4 => _4.toolResponseContract]), () => ( _chunk6A3TJUWCjs.RAW_V2_TOOL_RESPONSE_CONTRACT)),
+    toolResponseReceiptRevision: _chunk6A3TJUWCjs.normalizeToolResponseReceiptRevision.call(void 0, 
+      _nullishCoalesce(_optionalChain([input, 'optionalAccess', _5 => _5.toolResponseReceiptRevision]), () => ( _chunk6A3TJUWCjs.RAW_V2_TOOL_RESPONSE_RECEIPT_REVISION))
+    )
+  };
+}
+
+// ../plays/ts-ast.ts
+
+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
+    });
+  } catch (e) {
+    return 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', _6 => _6.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', _7 => _7.type]) !== "ObjectExpression") return stringLiteralValue(first);
+  let id = null;
+  for (const property of astArray(first.properties)) {
+    if (property.type !== "Property" || property.computed) continue;
+    const key = isAstNode(property.key) ? property.key : null;
+    const keyName = _nullishCoalesce(getIdentifierName(key), () => ( (_optionalChain([key, 'optionalAccess', _8 => _8.type]) === "Literal" && typeof key.value === "string" ? key.value : null)));
+    if (keyName !== "id") continue;
+    id = stringLiteralValue(isAstNode(property.value) ? property.value : null);
+  }
+  return id;
+}
+function listPlayFileExports(sourceCode) {
+  const ast = parsePlaySourceForAnalysis(sourceCode);
+  if (!ast) return null;
+  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 exportedName = getIdentifierName(specifier.exported);
+      if (localName && exportedName) namedExports.set(exportedName, 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 [exportedName, localName] of namedExports) {
+    if (exportedName === PLAY_DEFAULT_EXPORT) continue;
+    if (aliasedLocals.has(localName)) continue;
+    const declaration = _nullishCoalesce(declarations.get(localName), () => ( null));
+    if (!isDefinePlayCall(declaration)) continue;
+    exports.push({
+      name: exportedName,
+      aliases: [],
+      playName: definePlayName(declaration)
+    });
+  }
+  return exports;
+}
+function canonicalPlayExportName(exportName, exports) {
+  const requested = _optionalChain([exportName, 'optionalAccess', _9 => _9.trim, 'call', _10 => _10()]) || 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
+  ]);
+}
+
+// ../plays/docflow.ts
+var PLAY_DOCFLOW_NODE_KINDS = [
+  "action",
+  "decision",
+  "dataset",
+  "play",
+  "conceptual"
+];
+var PLAY_DOCFLOW_ARMS = [
+  "run",
+  "else"
+];
+var FLOW_START = /^\s*(?:flowchart|graph)\s+(LR|RL|TB|TD|BT)\s*$/i;
+var MERMAID_NODE = /^\s*\/\/\s*@mermaid-node\s+([A-Za-z][\w-]*)(?:\s+(.*))?$/;
+var MERMAID_NODE_HINT = /@mermaid-node/;
+var ATTRIBUTE = /([A-Za-z][\w-]*)\s*:\s*"([^"\n]*)"/y;
+var MERMAID_NODE_ATTRIBUTES = ["label", "type", "in", "out", "arm"];
+var MERMAID_NODE_ID = /^[A-Za-z][\w-]*/;
+var SKETCH_CLASS = /^\s*class\s+([A-Za-z][\w-]*(?:\s*,\s*[A-Za-z][\w-]*)*)\s+sketch\s*;?\s*$/;
+var MERMAID_NODE_SHAPES = [
+  ["[[", "]]"],
+  ["[(", ")]"],
+  ["([", "])"],
+  ["{{", "}}"],
+  ["((", "))"],
+  ["[/", "/]"],
+  ["[\\", "\\]"],
+  ["[/", "\\]"],
+  ["[\\", "/]"],
+  ["[", "]"],
+  ["{", "}"],
+  ["(", ")"],
+  [">", "]"]
+];
+var SUBGRAPH_OPEN = /^\s*subgraph\s+([A-Za-z][\w-]*)\s*(?:\[(.*)\])?\s*$/i;
+var SUBGRAPH_END = /^\s*end\s*$/i;
+var MERMAID_EDGE_CONNECTOR = /^\s*(?:-->|-\.->|==>|---)(?:\|([^|]+)\|)?/;
+var DOCFLOW_PATH = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/;
+var IDENTIFIER = /[A-Za-z_$][\w$]*/g;
+var JS_WORDS = /* @__PURE__ */ new Set([
+  "async",
+  "await",
+  "const",
+  "else",
+  "false",
+  "if",
+  "let",
+  "new",
+  "null",
+  "return",
+  "true",
+  "undefined",
+  "var"
+]);
+function parseAttributes(source, line, errors) {
+  const attributes = {};
+  const validAttributes = MERMAID_NODE_ATTRIBUTES;
+  let cursor = 0;
+  while (cursor < source.length) {
+    cursor += _nullishCoalesce(_optionalChain([/^\s*/, 'access', _11 => _11.exec, 'call', _12 => _12(source.slice(cursor)), 'optionalAccess', _13 => _13[0], 'access', _14 => _14.length]), () => ( 0));
+    if (cursor >= source.length) break;
+    ATTRIBUTE.lastIndex = cursor;
+    const match = ATTRIBUTE.exec(source);
+    if (!match) {
+      const fragment = _nullishCoalesce(source.slice(cursor).split(/\s+/)[0], () => ( source.slice(cursor)));
+      errors.push(
+        `Docflow \`// @mermaid-node\` annotation on line ${line} has malformed attribute ${JSON.stringify(fragment)}. Use key:"value" pairs. Valid attributes: ${validAttributes.map((name2) => `"${name2}"`).join(", ")}.`
+      );
+      return null;
+    }
+    const name = match[1];
+    if (!validAttributes.includes(name)) {
+      errors.push(
+        `Docflow \`// @mermaid-node\` annotation on line ${line} has unknown attribute "${name}". Valid attributes: ${validAttributes.map((option) => `"${option}"`).join(", ")}.`
+      );
+      return null;
+    }
+    if (Object.prototype.hasOwnProperty.call(attributes, name)) {
+      errors.push(
+        `Docflow \`// @mermaid-node\` annotation on line ${line} repeats attribute "${name}". Write each attribute once.`
+      );
+      return null;
+    }
+    attributes[name] = match[2];
+    cursor = ATTRIBUTE.lastIndex;
+  }
+  return attributes;
+}
+function nodeKind(value) {
+  if (!value) return void 0;
+  return PLAY_DOCFLOW_NODE_KINDS.includes(value) ? value : null;
+}
+function nodeArm(value) {
+  if (!value) return void 0;
+  return PLAY_DOCFLOW_ARMS.includes(value) ? value : null;
+}
+var SHAPE_KINDS = {
+  "{": "decision",
+  "[[": "play"
+};
+var MERMAID_LABEL_LOOKS_LIKE_SOURCE = /^(?:\[|\{|\(|>)/;
+function parseMermaidNodeAtStart(source) {
+  const leadingWhitespace = _nullishCoalesce(_optionalChain([/^\s*/, 'access', _15 => _15.exec, 'call', _16 => _16(source), 'optionalAccess', _17 => _17[0], 'access', _18 => _18.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', _19 => _19.exec, 'call', _20 => _20(source.slice(cursor)), 'optionalAccess', _21 => _21[0], 'access', _22 => _22.length]), () => ( 0));
+  const shape = MERMAID_NODE_SHAPES.find(
+    ([open2]) => source.startsWith(open2, cursor)
+  );
+  if (!shape) {
+    return { id, label: id, kind: "action", length: cursor, shaped: false };
+  }
+  const [open, close] = shape;
+  const labelStart = cursor + open.length;
+  const openingQuote = source[labelStart];
+  let labelEnd = -1;
+  if (openingQuote === '"' || openingQuote === "'") {
+    for (let index = labelStart + 1; index < source.length; index += 1) {
+      if (source[index] === "\\") {
+        index += 1;
+        continue;
+      }
+      if (source[index] !== openingQuote) continue;
+      const whitespace = _nullishCoalesce(_optionalChain([/^\s*/, 'access', _23 => _23.exec, 'call', _24 => _24(source.slice(index + 1)), 'optionalAccess', _25 => _25[0], 'access', _26 => _26.length]), () => ( 0));
+      const candidate = index + 1 + whitespace;
+      if (source.startsWith(close, candidate)) {
+        labelEnd = candidate;
+        break;
+      }
+    }
+  } else {
+    labelEnd = source.indexOf(close, labelStart);
+  }
+  if (labelEnd < 0) {
+    return {
+      id,
+      label: id,
+      kind: "action",
+      length: cursor + open.length,
+      shaped: false,
+      unterminated: { open, close }
+    };
+  }
+  const rawLabel = source.slice(labelStart, labelEnd).trim();
+  const label = rawLabel.length >= 2 && (rawLabel.startsWith('"') && rawLabel.endsWith('"') || rawLabel.startsWith("'") && rawLabel.endsWith("'")) ? rawLabel.slice(1, -1) : rawLabel;
+  return {
+    id,
+    label: label || id,
+    kind: _nullishCoalesce(SHAPE_KINDS[open], () => ( "action")),
+    length: labelEnd + close.length,
+    shaped: true
+  };
+}
+function parseShapedMermaidNodes(fragment) {
+  const nodes = [];
+  let cursor = 0;
+  while (cursor < fragment.length) {
+    const identifier = /[A-Za-z][\w-]*/.exec(fragment.slice(cursor));
+    if (!identifier) break;
+    const start = cursor + (_nullishCoalesce(identifier.index, () => ( 0)));
+    const parsed = parseMermaidNodeAtStart(fragment.slice(start));
+    if (_optionalChain([parsed, 'optionalAccess', _27 => _27.shaped]) || _optionalChain([parsed, 'optionalAccess', _28 => _28.unterminated])) nodes.push(parsed);
+    cursor = start + Math.max(_nullishCoalesce(_optionalChain([parsed, 'optionalAccess', _29 => _29.length]), () => ( identifier[0].length)), 1);
+  }
+  return nodes;
+}
+function parseEdgeChain(line) {
+  let remaining = line;
+  const first = parseMermaidNodeAtStart(remaining);
+  if (!first) return null;
+  const nodes = [first];
+  const labels = [];
+  remaining = remaining.slice(first.length);
+  while (remaining.trim()) {
+    const connector = MERMAID_EDGE_CONNECTOR.exec(remaining);
+    if (!connector) return null;
+    remaining = remaining.slice(connector[0].length);
+    const next = parseMermaidNodeAtStart(remaining);
+    if (!next) return null;
+    labels.push(_optionalChain([connector, 'access', _30 => _30[1], 'optionalAccess', _31 => _31.trim, 'call', _32 => _32()]) || void 0);
+    nodes.push(next);
+    remaining = remaining.slice(next.length);
+  }
+  return nodes.length > 1 ? { nodes, labels } : null;
+}
+function parseContractPaths(value, attribute, nodeId, line, errors) {
+  if (value === void 0) return void 0;
+  const paths = value.split(",").map((path) => path.trim()).filter(Boolean);
+  if (paths.some((path) => !DOCFLOW_PATH.test(path))) {
+    errors.push(
+      `Docflow annotation "${nodeId}" on line ${line} has an invalid ${attribute}:"\u2026" contract. Use comma-separated identifiers or property paths only \u2014 e.g. the assigned const name (out:"result"). Prose labels belong in the diagram box, not here.`
+    );
+    return void 0;
+  }
+  return [...new Set(paths)];
+}
+function inferBindingIo(statement) {
+  const returned = /^return\s+(.+?);?\s*$/.exec(statement.trim());
+  if (returned) {
+    const inputs2 = /* @__PURE__ */ new Set();
+    const expression2 = returned[1].replace(/(['"`])(?:\\.|(?!\1).)*\1/g, "");
+    IDENTIFIER.lastIndex = 0;
+    for (const match of expression2.matchAll(IDENTIFIER)) {
+      const identifier = match[0];
+      const index = _nullishCoalesce(match.index, () => ( 0));
+      if (JS_WORDS.has(identifier) || expression2[index - 1] === ".") continue;
+      inputs2.add(identifier);
+    }
+    return {
+      inputs: [...inputs2],
+      ioConfidence: "inferred"
+    };
+  }
+  const assignment = /^(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*([^;]+);?\s*$/.exec(
+    statement.trim()
+  );
+  if (!assignment || assignment[2].includes("await")) {
+    return { ioConfidence: "ambiguous" };
+  }
+  const output = assignment[1];
+  const expression = assignment[2];
+  const inputs = /* @__PURE__ */ new Set();
+  IDENTIFIER.lastIndex = 0;
+  for (const match of expression.matchAll(IDENTIFIER)) {
+    const identifier = match[0];
+    const index = _nullishCoalesce(match.index, () => ( 0));
+    const previous = _nullishCoalesce(expression[index - 1], () => ( ""));
+    const next = _nullishCoalesce(expression[index + identifier.length], () => ( ""));
+    if (JS_WORDS.has(identifier) || identifier === output || previous === "." || next === ":" || /^\s*\(/.test(expression.slice(index + identifier.length))) {
+      continue;
+    }
+    inputs.add(identifier);
+  }
+  return {
+    inputs: [...inputs],
+    outputs: [output],
+    ioConfidence: "inferred"
+  };
+}
+var JSDOC_BLOCK = /\/\*\*([\s\S]*?)\*\//g;
+var BLOCK_EXPORT_HEADER = /^[A-Za-z_$][\w$-]*$/;
+function cleanBlockBody(raw) {
+  return raw.split(/\r?\n/).map((line) => /^\s*\*/.test(line) ? line.replace(/^\s*\* ?/, "") : line).join("\n").trim();
+}
+function splitBlockExportHeader(body) {
+  const newlineIndex = body.indexOf("\n");
+  const firstLine = (newlineIndex < 0 ? body : body.slice(0, newlineIndex)).trim();
+  if (!BLOCK_EXPORT_HEADER.test(firstLine) || /^(?:flowchart|graph)$/i.test(firstLine)) {
+    return { exportName: null, diagram: body };
+  }
+  return {
+    exportName: firstLine,
+    diagram: newlineIndex < 0 ? "" : body.slice(newlineIndex + 1).trim()
+  };
+}
+function blockLabel(block) {
+  return block.authoredExportName ? `@mermaid ${block.authoredExportName}` : "@mermaid";
+}
+function parseDocflowBlockGraph(mermaidSource, errors) {
+  const docLines = mermaidSource.split(/\r?\n/).filter((line) => line.trim() && !line.trim().startsWith("%%"));
+  const direction = _optionalChain([FLOW_START, 'access', _33 => _33.exec, 'call', _34 => _34(_nullishCoalesce(docLines[0], () => ( ""))), 'optionalAccess', _35 => _35[1], 'optionalAccess', _36 => _36.toUpperCase, 'call', _37 => _37()]);
+  if (!direction) {
+    errors.push(
+      "Docflow must start with `flowchart` or `graph` and direction `LR`, `RL`, `TB`, `TD`, or `BT`."
+    );
+    return null;
+  }
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = [];
+  const subgraphs = /* @__PURE__ */ new Map();
+  const ignoredDirectives = [];
+  const sketchIds = /* @__PURE__ */ new Set();
+  const subgraphStack = [];
+  const subgraphIds = /* @__PURE__ */ new Set();
+  for (const line of docLines.slice(1)) {
+    const opened = SUBGRAPH_OPEN.exec(line);
+    if (opened) subgraphIds.add(opened[1]);
+  }
+  const declaredIds = /* @__PURE__ */ new Set();
+  const addNodes = (fragment, line) => {
+    let sawDeclaration = false;
+    for (const node of parseShapedMermaidNodes(fragment)) {
+      const { id, label, kind } = node;
+      if (node.unterminated) {
+        sawDeclaration = true;
+        errors.push(
+          `Docflow node "${id}" opens with \`${node.unterminated.open}\` but never closes with \`${node.unterminated.close}\`: ${line.trim()}`
+        );
+        continue;
+      }
+      sawDeclaration = true;
+      if (subgraphIds.has(id)) {
+        errors.push(
+          `Docflow subgraph "${id}" collides with a node of the same id.`
+        );
+        continue;
+      }
+      if (MERMAID_LABEL_LOOKS_LIKE_SOURCE.test(label)) {
+        errors.push(
+          `Docflow node "${id}" has an unreadable label \`${label}\` \u2014 the shape around it is not one this parser knows, so its own syntax became the label. Supported shapes: ${MERMAID_NODE_SHAPES.map(([open, close]) => `${open}\u2026${close}`).join(", ")}. Line: ${line.trim()}`
+        );
+        continue;
+      }
+      declaredIds.add(id);
+      const existing = nodes.get(id);
+      if (existing && existing.label === existing.id && label !== id) {
+        existing.label = label;
+        existing.kind = kind;
+        for (const subgraph of subgraphs.values()) {
+          const at = subgraph.memberIds.indexOf(id);
+          if (at !== -1) subgraph.memberIds.splice(at, 1);
+        }
+        _optionalChain([subgraphStack, 'access', _38 => _38[subgraphStack.length - 1], 'optionalAccess', _39 => _39.memberIds, 'access', _40 => _40.push, 'call', _41 => _41(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', _42 => _42[subgraphStack.length - 1], 'optionalAccess', _43 => _43.memberIds, 'access', _44 => _44.push, 'call', _45 => _45(id)]);
+      }
+    }
+    return sawDeclaration;
+  };
+  for (const line of docLines.slice(1)) {
+    const opened = SUBGRAPH_OPEN.exec(line);
+    if (opened) {
+      const id = opened[1];
+      const rawLabel = _nullishCoalesce(_optionalChain([opened, 'access', _46 => _46[2], 'optionalAccess', _47 => _47.trim, 'call', _48 => _48()]), () => ( ""));
+      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 = {
+        id,
+        label: label || id,
+        memberIds: [],
+        ...parent ? { parentId: parent.id } : {}
+      };
+      subgraphs.set(id, subgraph);
+      subgraphStack.push(subgraph);
+      continue;
+    }
+    if (SUBGRAPH_END.test(line)) {
+      if (subgraphStack.length === 0) {
+        errors.push(
+          "Docflow has an `end` with no open `subgraph` above it. Every `end` closes exactly one `subgraph`."
+        );
+      }
+      subgraphStack.pop();
+      continue;
+    }
+    let declaredOnThisLine = false;
+    const isDirective = /^\s*(?:direction|classDef|class|style|linkStyle|click)\b/i.test(line);
+    if (isDirective) {
+      const sketch = SKETCH_CLASS.exec(line);
+      if (sketch) {
+        for (const id of sketch[1].split(",")) {
+          const trimmed = id.trim();
+          if (trimmed) sketchIds.add(trimmed);
+        }
+      } else {
+        ignoredDirectives.push(line.trim());
+      }
+    }
+    if (!isDirective) {
+      declaredOnThisLine = addNodes(line, line);
+    }
+    const chain = parseEdgeChain(line);
+    if (!chain) {
+      if (!isDirective && !declaredOnThisLine) {
+        errors.push(
+          `Docflow line is not an edge, a node declaration, or a directive this parser understands: ${line.trim()}`
+        );
+      }
+      continue;
+    }
+    addNodes(line, line);
+    for (const node of chain.nodes) {
+      if (subgraphIds.has(node.id)) continue;
+      const existing = nodes.get(node.id);
+      if (!existing) {
+        nodes.set(node.id, node);
+        _optionalChain([subgraphStack, 'access', _49 => _49[subgraphStack.length - 1], 'optionalAccess', _50 => _50.memberIds, 'access', _51 => _51.push, 'call', _52 => _52(node.id)]);
+      } else if (existing.label === existing.id && node.label !== node.id) {
+        existing.label = node.label;
+        existing.kind = node.kind;
+      }
+    }
+    for (let index = 0; index < chain.nodes.length - 1; index += 1) {
+      edges.push({
+        from: chain.nodes[index].id,
+        to: chain.nodes[index + 1].id,
+        ...chain.labels[index] ? { label: chain.labels[index] } : {}
+      });
+    }
+  }
+  if (subgraphStack.length > 0) {
+    errors.push(
+      `Docflow subgraph${subgraphStack.length === 1 ? "" : "s"} ${subgraphStack.map((subgraph) => `"${subgraph.id}"`).join(
+        ", "
+      )} ${subgraphStack.length === 1 ? "is" : "are"} never closed with \`end\`. Everything below an unclosed subgraph is silently drawn inside it.`
+    );
+  }
+  for (const node of nodes.values()) {
+    if (declaredIds.has(node.id) || subgraphIds.has(node.id)) continue;
+    errors.push(
+      `Docflow node "${node.id}" is referenced by an edge but never declared with a shape and label, so the canvas would show its id. Declare it once, e.g. \`${node.id}["What this step does"]\`.`
+    );
+  }
+  for (const id of sketchIds) {
+    const node = nodes.get(id);
+    if (!node) {
+      errors.push(
+        subgraphs.has(id) ? `Docflow \`class ${id} sketch\` names a subgraph. A subgraph is a region, not a box, and never binds code \u2014 drop it from the class line.` : `Docflow \`class ${id} sketch\` names "${id}", which this diagram does not draw.`
+      );
+      continue;
+    }
+    node.sketch = true;
+  }
+  return { direction, nodes, edges, subgraphs, ignoredDirectives, sketchIds };
+}
+function materializeDocflow(block) {
+  return {
+    direction: block.direction,
+    nodes: [...block.nodes.values()],
+    edges: block.edges,
+    bindings: block.bindings,
+    syntax: block.syntax,
+    mermaidSource: block.mermaidSource,
+    ...block.subgraphs.size ? { subgraphs: [...block.subgraphs.values()] } : {},
+    ...block.ignoredDirectives.length ? { ignoredDirectives: block.ignoredDirectives } : {}
+  };
+}
+function parsePlayDocflowFile(sourceCode, moduleSources) {
+  const errors = [];
+  const rawBlocks = [];
+  JSDOC_BLOCK.lastIndex = 0;
+  for (const match of sourceCode.matchAll(JSDOC_BLOCK)) {
+    const cleanedBody = cleanBlockBody(match[1]);
+    const mermaid = /^@mermaid(?:[ \t]+|\r?\n|$)([\s\S]*)$/.exec(cleanedBody);
+    if (!mermaid) continue;
+    rawBlocks.push({ syntax: "mermaid", body: mermaid[1].trim() });
+  }
+  if (rawBlocks.length === 0) return { blocks: [], bindings: [], errors };
+  const rejectedNodeIds = /* @__PURE__ */ new Set();
+  const annotationSources = [{ sourceCode }];
+  for (const [sourcePath, moduleCode] of _nullishCoalesce(moduleSources, () => ( []))) {
+    if (!MERMAID_NODE_HINT.test(moduleCode)) continue;
+    annotationSources.push({ sourceCode: moduleCode, sourcePath });
+  }
+  const bindings = parseDocflowBindings(
+    annotationSources,
+    errors,
+    rejectedNodeIds
+  );
+  const parsedBlocks = [];
+  for (const raw of rawBlocks) {
+    const { exportName, diagram } = splitBlockExportHeader(raw.body);
+    const graph = parseDocflowBlockGraph(diagram, errors);
+    if (!graph) continue;
+    parsedBlocks.push({
+      ...graph,
+      authoredExportName: exportName,
+      exportName: null,
+      syntax: raw.syntax,
+      mermaidSource: diagram,
+      bindings: []
+    });
+  }
+  resolveBlockExports(sourceCode, parsedBlocks, errors);
+  attachBindingsToBlocks(
+    sourceCode,
+    parsedBlocks,
+    bindings,
+    errors,
+    rejectedNodeIds
+  );
+  return {
+    blocks: parsedBlocks.filter((block) => block.exportName !== null).map((block) => ({
+      exportName: block.exportName,
+      docflow: materializeDocflow(block)
+    })),
+    bindings,
+    errors
+  };
+}
+function resolveBlockExports(sourceCode, blocks, errors) {
+  const fileExports = blocks.some((block) => block.authoredExportName !== null) ? listPlayFileExports(sourceCode) : null;
+  const claimed = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    if (block.authoredExportName === null) {
+      block.exportName = PLAY_DEFAULT_EXPORT;
+    } else if (fileExports === null) {
+      block.exportName = block.authoredExportName;
+    } else {
+      const canonical = canonicalPlayExportName(
+        block.authoredExportName,
+        fileExports
+      );
+      if (!canonical) {
+        const available = playExportNamesForMessage(fileExports);
+        errors.push(
+          `Docflow block \`${blockLabel(block)}\` names an export this file does not define. ` + (available.length ? `Exported plays: ${available.map((name) => `"${name}"`).join(", ")}.` : "This file exports no play.")
+        );
+        continue;
+      }
+      block.exportName = canonical;
+    }
+    const existing = claimed.get(block.exportName);
+    if (existing) {
+      errors.push(
+        `Docflow blocks \`${blockLabel(existing)}\` and \`${blockLabel(block)}\` both describe export "${block.exportName}". One diagram per export.`
+      );
+      block.exportName = null;
+      continue;
+    }
+    claimed.set(block.exportName, block);
+  }
+}
+function unwrapExportExpression(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 playExportSourceRanges(sourceCode) {
+  const ast = parsePlaySourceForAnalysis(sourceCode);
+  const fileExports = listPlayFileExports(sourceCode);
+  if (!ast || !fileExports) return [];
+  const declarations = /* @__PURE__ */ new Map();
+  const namedExports = /* @__PURE__ */ new Map();
+  let defaultExpression = null;
+  for (const statement of astArray(ast.body)) {
+    const recordDeclarations = (declaration, exported) => {
+      for (const declarator of astArray(declaration.declarations)) {
+        const id = isAstNode(declarator.id) ? declarator.id : null;
+        const name = _optionalChain([id, 'optionalAccess', _53 => _53.type]) === "Identifier" && typeof id.name === "string" ? id.name : null;
+        if (!name) continue;
+        declarations.set(
+          name,
+          isAstNode(declarator.init) ? declarator.init : null
+        );
+        if (exported) namedExports.set(name, name);
+      }
+    };
+    if (statement.type === "VariableDeclaration") {
+      recordDeclarations(statement, false);
+    } else if (statement.type === "ExportDefaultDeclaration") {
+      defaultExpression = isAstNode(statement.declaration) ? statement.declaration : null;
+    } else if (statement.type === "TSExportAssignment") {
+      defaultExpression = isAstNode(statement.expression) ? statement.expression : null;
+    } else if (statement.type === "ExportNamedDeclaration") {
+      if (isAstNode(statement.declaration) && statement.declaration.type === "VariableDeclaration") {
+        recordDeclarations(statement.declaration, true);
+      }
+      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', _54 => _54.type]) === "Identifier" && typeof local.name === "string" && _optionalChain([exported, 'optionalAccess', _55 => _55.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)) {
+      return null;
+    }
+    seen.add(unwrapped.name);
+    return resolveCall(_nullishCoalesce(declarations.get(unwrapped.name), () => ( null)), seen);
+  };
+  const defaultCall = resolveCall(defaultExpression);
+  const ranges = [];
+  for (const fileExport of fileExports) {
+    const call = fileExport.name === PLAY_DEFAULT_EXPORT ? defaultCall : resolveCall(
+      _nullishCoalesce(declarations.get(_nullishCoalesce(namedExports.get(fileExport.name), () => ( ""))), () => ( null))
+    );
+    if (call && typeof call.start === "number" && typeof call.end === "number") {
+      ranges.push({
+        exportName: fileExport.name,
+        start: call.start,
+        end: call.end
+      });
+    }
+  }
+  return ranges;
+}
+function projectRecordedArms(block, errors) {
+  const declaredBy = /* @__PURE__ */ new Map();
+  for (const binding of block.bindings) {
+    if (!binding.arm) continue;
+    const incoming = block.edges.filter(
+      (edge2) => edge2.to === binding.nodeId && _optionalChain([block, 'access', _56 => _56.nodes, 'access', _57 => _57.get, 'call', _58 => _58(edge2.from), 'optionalAccess', _59 => _59.kind]) === "decision"
+    );
+    if (incoming.length === 0) {
+      errors.push(
+        `Docflow annotation "${binding.nodeId}" declares arm:"${binding.arm}" but no decision points at it. Put arm:"\u2026" on the node a decision's labelled edge leads to.`
+      );
+      continue;
+    }
+    if (incoming.length > 1) {
+      errors.push(
+        `Docflow annotation "${binding.nodeId}" declares arm:"${binding.arm}" but ${incoming.length} decisions point at it, so the arm names no single edge. Give each decision its own arm node.`
+      );
+      continue;
+    }
+    const edge = incoming[0];
+    const key = `${edge.from}\0${binding.arm}`;
+    const already = declaredBy.get(key);
+    if (already !== void 0) {
+      errors.push(
+        `Decision "${edge.from}" has two arms declaring arm:"${binding.arm}" ("${already}" and "${binding.nodeId}"). A conditional has one run arm and one else arm.`
+      );
+      continue;
+    }
+    declaredBy.set(key, binding.nodeId);
+    edge.arm = binding.arm;
+  }
+}
+function attachBindingsToBlocks(sourceCode, blocks, bindings, errors, rejectedNodeIds) {
+  const lineStarts = sourceLineStartsForDocflow(sourceCode);
+  const exportRanges = playExportSourceRanges(sourceCode);
+  for (const binding of bindings) {
+    let owners = blocks.filter((block) => block.nodes.has(binding.nodeId));
+    if (owners.length === 0) {
+      errors.push(
+        `Docflow annotation "${binding.nodeId}" does not name a graph node.`
+      );
+      continue;
+    }
+    if (owners.length > 1) {
+      const lineStart = lineStarts[binding.line - 1];
+      if (lineStart !== void 0) {
+        const scoped = owners.filter(
+          (owner2) => exportRanges.some(
+            (range) => range.exportName === owner2.exportName && lineStart >= range.start && lineStart < range.end
+          )
+        );
+        if (scoped.length === 1) owners = scoped;
+      }
+    }
+    if (owners.length > 1) {
+      errors.push(
+        `Docflow annotation "${binding.nodeId}" names a node in ${owners.map((owner2) => `\`${blockLabel(owner2)}\``).join(" and ")}, and its enclosing play could not identify one owner. Put the annotation inside the definePlay handler for the export it describes.`
+      );
+      continue;
+    }
+    const owner = owners[0];
+    if (owner.bindings.some((candidate) => candidate.nodeId === binding.nodeId)) {
+      errors.push(
+        `Docflow node "${binding.nodeId}" has more than one code binding.`
+      );
+      continue;
+    }
+    owner.bindings.push(binding);
+  }
+  for (const block of blocks) {
+    for (const binding of block.bindings) {
+      const node = block.nodes.get(binding.nodeId);
+      if (binding.label) node.label = binding.label;
+      if (block.sketchIds.has(binding.nodeId)) {
+        errors.push(
+          `Docflow box "${binding.nodeId}" is declared \`class ${binding.nodeId} sketch\` and also bound by \`// @mermaid-node ${binding.nodeId}\` on line ${binding.line}. It is one or the other: drop it from the class line, or drop the annotation.`
+        );
+        continue;
+      }
+      if (binding.kind) node.kind = binding.kind;
+    }
+    projectRecordedArms(block, errors);
+    const bound = new Set(block.bindings.map((binding) => binding.nodeId));
+    for (const node of block.nodes.values()) {
+      if (node.sketch || node.kind === "conceptual" || bound.has(node.id) || rejectedNodeIds.has(node.id))
+        continue;
+      errors.push(
+        `Docflow box "${node.id}" in \`${blockLabel(block)}\` points at nothing, so the canvas can only draw it and say nothing about it. Either put \`// @mermaid-node ${node.id}\` above the statement it runs, or \u2014 if this play has no such statement, because the work happens in another module or inside a loop \u2014 add it to a \`class ${node.id} sketch\` line in the block to declare it a sketch.`
+      );
+    }
+  }
+}
+function sourceLineStartsForDocflow(sourceCode) {
+  const starts = [0];
+  for (let index = 0; index < sourceCode.length; index += 1) {
+    if (sourceCode[index] === "\n") starts.push(index + 1);
+  }
+  return starts;
+}
+function parseDocflowBindings(sources, errors, rejectedNodeIds) {
+  const bindings = [];
+  for (const source of sources) {
+    bindings.push(
+      ...parseDocflowBindingsInSource(source, errors, rejectedNodeIds)
+    );
+  }
+  return bindings;
+}
+function parseDocflowBindingsInSource(source, errors, rejectedNodeIds) {
+  const { sourceCode, sourcePath } = source;
+  const lines = sourceCode.split(/\r?\n/);
+  const bindings = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    MERMAID_NODE.lastIndex = 0;
+    const mermaidMatch = _nullishCoalesce(MERMAID_NODE.exec(lines[index]), () => ( null));
+    if (!mermaidMatch) continue;
+    const annotatedId = _optionalChain([mermaidMatch, 'access', _60 => _60[1], 'optionalAccess', _61 => _61.trim, 'call', _62 => _62()]);
+    if (annotatedId) rejectedNodeIds.add(annotatedId);
+    const attributes = parseAttributes(
+      _nullishCoalesce(mermaidMatch[2], () => ( "")),
+      index + 1,
+      errors
+    );
+    if (!attributes) continue;
+    const id = _optionalChain([(_nullishCoalesce(annotatedId, () => ( attributes.id))), 'optionalAccess', _63 => _63.trim, 'call', _64 => _64()]);
+    if (!id) {
+      errors.push(`Docflow annotation on line ${index + 1} requires id:"\u2026".`);
+      continue;
+    }
+    rejectedNodeIds.add(id);
+    const kind = nodeKind(attributes.type);
+    if (attributes.type && !kind) {
+      errors.push(
+        `Docflow annotation "${id}" has unsupported type "${attributes.type}". Valid types: ${PLAY_DOCFLOW_NODE_KINDS.map((nodeType) => `"${nodeType}"`).join(", ")}.`
+      );
+      continue;
+    }
+    const arm = nodeArm(attributes.arm);
+    if (attributes.arm && !arm) {
+      errors.push(
+        `Docflow annotation "${id}" has unsupported arm "${attributes.arm}". Valid arms: ${PLAY_DOCFLOW_ARMS.map((token) => `"${token}"`).join(", ")}. The arm names which side of the conditional this node is, not what the edge is labelled.`
+      );
+      continue;
+    }
+    let nextLine = index + 1;
+    while (nextLine < lines.length && (!lines[nextLine].trim() || lines[nextLine].trim().startsWith("//")))
+      nextLine += 1;
+    if (nextLine === lines.length) {
+      errors.push(
+        `Docflow annotation "${id}" must be followed by executable code.`
+      );
+      continue;
+    }
+    const inputs = parseContractPaths(
+      attributes.in,
+      "in",
+      id,
+      index + 1,
+      errors
+    );
+    const outputs = parseContractPaths(
+      attributes.out,
+      "out",
+      id,
+      index + 1,
+      errors
+    );
+    if (attributes.in !== void 0 && !inputs || attributes.out !== void 0 && !outputs) {
+      continue;
+    }
+    const inferred = inputs || outputs ? {
+      ...inputs ? { inputs } : {},
+      ...outputs ? { outputs } : {},
+      ioConfidence: "explicit"
+    } : inferBindingIo(lines[nextLine]);
+    rejectedNodeIds.delete(id);
+    bindings.push({
+      nodeId: id,
+      line: nextLine + 1,
+      ...sourcePath ? { sourcePath } : {},
+      ...attributes.label ? { label: attributes.label } : {},
+      ...kind ? { kind } : {},
+      // Spread, never `arm: arm ?? undefined` — see `PlayDocflowEdge.arm`. An
+      // explicit `undefined` key survives `JSON.stringify` round-trips in some
+      // callers and would reintroduce the hash drift this omission avoids.
+      ...arm ? { arm } : {},
+      ...inferred
+    });
+  }
+  return bindings;
+}
+
+// ../plays/docflow-binding.ts
+function sourceLineStarts(sourceCode) {
+  const starts = [0];
+  for (let index = 0; index < sourceCode.length; index += 1) {
+    if (sourceCode[index] === "\n") starts.push(index + 1);
+  }
+  return starts;
+}
+function astNodeBounds(node) {
+  return typeof node.start === "number" && typeof node.end === "number" ? { start: node.start, end: node.end } : null;
+}
+function findDocflowBoundStatement(ast, line, lineStarts) {
+  const lineStart = lineStarts[line - 1];
+  const lineEnd = _nullishCoalesce(lineStarts[line], () => ( Number.POSITIVE_INFINITY));
+  if (lineStart === void 0) return null;
+  let match = null;
+  const pending = [ast];
+  const statementTypes = /* @__PURE__ */ new Set([
+    "ExpressionStatement",
+    "IfStatement",
+    "ReturnStatement",
+    "ThrowStatement",
+    "VariableDeclaration"
+  ]);
+  while (pending.length > 0) {
+    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', _65 => _65(match), 'optionalAccess', _66 => _66.end]), () => ( 0))) - (_nullishCoalesce(_optionalChain([astNodeBounds, 'call', _67 => _67(match), 'optionalAccess', _68 => _68.start]), () => ( 0)))) {
+        match = node;
+      }
+    }
+    for (const child of Object.values(node)) {
+      if (Array.isArray(child)) pending.push(...child.filter(isAstNode));
+      else if (isAstNode(child)) pending.push(child);
+    }
+  }
+  return match;
+}
+var DOCFLOW_STATEMENT_TYPES = /* @__PURE__ */ new Set([
+  "ExpressionStatement",
+  "IfStatement",
+  "ReturnStatement",
+  "ThrowStatement",
+  "VariableDeclaration"
+]);
+function docflowOutputRoot(binding) {
+  const first = _optionalChain([binding, 'access', _69 => _69.outputs, 'optionalAccess', _70 => _70[0]]);
+  if (!first) return null;
+  const root = first.split(".")[0];
+  if (!root || root === "$output") return null;
+  return root;
+}
+function buildDocflowParentIndex(ast) {
+  const parents = /* @__PURE__ */ new Map();
+  const pending = [ast];
+  while (pending.length > 0) {
+    const node = pending.pop();
+    for (const child of Object.values(node)) {
+      const children = Array.isArray(child) ? child.filter(isAstNode) : isAstNode(child) ? [child] : [];
+      for (const nested of children) {
+        parents.set(nested, node);
+        pending.push(nested);
+      }
+    }
+  }
+  return parents;
+}
+function enclosingDocflowStatement(node, parents) {
+  let current = node;
+  while (current) {
+    if (DOCFLOW_STATEMENT_TYPES.has(current.type)) return current;
+    current = _nullishCoalesce(parents.get(current), () => ( null));
+  }
+  return null;
+}
+function isWithColumnCallForName(node, columnName) {
+  if (node.type !== "CallExpression") return false;
+  const callee = isAstNode(node.callee) ? node.callee : null;
+  if (!callee || callee.type !== "MemberExpression" || callee.computed || !isAstNode(callee.property) || callee.property.type !== "Identifier" || callee.property.name !== "withColumn") {
+    return false;
+  }
+  const firstArg = astArray(node.arguments)[0];
+  return Boolean(
+    firstArg && firstArg.type === "Literal" && typeof firstArg.value === "string" && firstArg.value === columnName
+  );
+}
+function isDocflowStepCallForName(node, stepName) {
+  if (node.type !== "CallExpression") return false;
+  const callee = isAstNode(node.callee) ? node.callee : null;
+  if (!callee || callee.type !== "MemberExpression" || callee.computed || !isAstNode(callee.property) || callee.property.type !== "Identifier" || callee.property.name !== "step") {
+    return false;
+  }
+  const firstArg = astArray(node.arguments)[0];
+  return Boolean(
+    firstArg && firstArg.type === "Literal" && typeof firstArg.value === "string" && firstArg.value === 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];
+  while (pending.length > 0) {
+    const node = pending.pop();
+    if (node !== unwrapped && isDocflowStepCallForName(node, stepName)) {
+      return true;
+    }
+    for (const child of Object.values(node)) {
+      if (Array.isArray(child)) pending.push(...child.filter(isAstNode));
+      else if (isAstNode(child)) pending.push(child);
+    }
+  }
+  return false;
+}
+function getIdentifierName2(node) {
+  return isAstNode(node) && node.type === "Identifier" ? typeof node.name === "string" ? node.name : null : null;
+}
+function enclosingDefinePlayCall(ast, line, lineStarts) {
+  const lineStart = lineStarts[line - 1];
+  const lineEnd = _nullishCoalesce(lineStarts[line], () => ( Number.POSITIVE_INFINITY));
+  if (lineStart === void 0) return null;
+  let match = null;
+  const pending = [ast];
+  while (pending.length > 0) {
+    const node = pending.pop();
+    const bounds = astNodeBounds(node);
+    if (bounds && bounds.start < lineEnd && bounds.end > lineStart && isDefinePlayCall(node)) {
+      const matchBounds = match ? astNodeBounds(match) : null;
+      if (!match || !matchBounds || bounds.end - bounds.start < matchBounds.end - matchBounds.start) {
+        match = node;
+      }
+    }
+    for (const child of Object.values(node)) {
+      if (Array.isArray(child)) pending.push(...child.filter(isAstNode));
+      else if (isAstNode(child)) pending.push(child);
+    }
+  }
+  return match;
+}
+function isVariableDeclarationForName(node, name) {
+  if (node.type !== "VariableDeclaration") return false;
+  return astArray(node.declarations).some(
+    (declarator) => getIdentifierName2(declarator.id) === name
+  );
+}
+function resolveDocflowBindingSymbol(ast, binding, lineStarts, parents) {
+  const root = docflowOutputRoot(binding);
+  if (!root) return { kind: "abstain" };
+  const parentIndex = _nullishCoalesce(parents, () => ( buildDocflowParentIndex(ast)));
+  const scope = _nullishCoalesce(enclosingDefinePlayCall(ast, binding.line, lineStarts), () => ( ast));
+  const inScope = (node) => {
+    if (scope === ast) return true;
+    const bounds = astNodeBounds(node);
+    const scopeBounds = astNodeBounds(scope);
+    return Boolean(
+      bounds && scopeBounds && bounds.start >= scopeBounds.start && bounds.end <= scopeBounds.end
+    );
+  };
+  const matchesColumn = (node) => isWithColumnCallForName(node, root) && inScope(node);
+  const matchesStep = (node) => isDocflowStepCallForName(node, root) && inScope(node);
+  const matchesVariable = (node) => isVariableDeclarationForName(node, root) && inScope(node);
+  const collectStatements = (predicate) => {
+    const statements = /* @__PURE__ */ new Map();
+    const pending = [scope];
+    while (pending.length > 0) {
+      const node = pending.pop();
+      if (predicate(node)) {
+        const statement = enclosingDocflowStatement(node, parentIndex);
+        const kind = matchesColumn(node) ? "declaredColumn" : matchesStep(node) ? "declaredStep" : "variable";
+        if (statement && (!statements.has(statement) || kind === "declaredColumn")) {
+          statements.set(statement, kind);
+        }
+      }
+      for (const child of Object.values(node)) {
+        if (Array.isArray(child)) pending.push(...child.filter(isAstNode));
+        else if (isAstNode(child)) pending.push(child);
+      }
+    }
+    return statements;
+  };
+  let candidates = collectStatements(
+    (node) => matchesColumn(node) || matchesStep(node)
+  );
+  if (candidates.size === 0) candidates = collectStatements(matchesVariable);
+  if (candidates.size === 0) return { kind: "abstain" };
+  const resolved = (statement) => ({
+    kind: "resolved",
+    statement,
+    symbolKind: _nullishCoalesce(candidates.get(statement), () => ( "variable"))
+  });
+  const lineStart = lineStarts[binding.line - 1];
+  const lineEnd = _nullishCoalesce(lineStarts[binding.line], () => ( Number.POSITIVE_INFINITY));
+  if (lineStart !== void 0) {
+    const containing = [...candidates.keys()].filter((statement) => {
+      const bounds = astNodeBounds(statement);
+      return bounds && bounds.start < lineEnd && bounds.end > lineStart;
+    });
+    if (containing.length === 1) return resolved(containing[0]);
+    if (containing.length > 1) {
+      return { kind: "ambiguous", candidates: containing };
+    }
+  }
+  if (candidates.size === 1) {
+    return resolved([...candidates.keys()][0]);
+  }
+  return { kind: "ambiguous", candidates: [...candidates.keys()] };
+}
+function statementLine(statement, lineStarts) {
+  const bounds = statement ? astNodeBounds(statement) : null;
+  if (!bounds) return null;
+  let line = 1;
+  for (let index = 0; index < lineStarts.length; index += 1) {
+    if (lineStarts[index] > bounds.start) break;
+    line = index + 1;
+  }
+  return line;
+}
+function resolveDocflowBinding(ast, binding, lineStarts, parents) {
+  const positional = findDocflowBoundStatement(ast, binding.line, lineStarts);
+  const symbol = resolveDocflowBindingSymbol(ast, binding, lineStarts, parents);
+  const root = docflowOutputRoot(binding);
+  if (symbol.kind === "ambiguous") {
+    return {
+      binding,
+      statement: positional,
+      symbolKind: null,
+      drift: {
+        binding,
+        symbol: _nullishCoalesce(root, () => ( "")),
+        annotatedLine: statementLine(positional, lineStarts),
+        symbolLine: statementLine(_nullishCoalesce(symbol.candidates[0], () => ( null)), lineStarts),
+        ambiguous: true
+      }
+    };
+  }
+  if (symbol.kind === "resolved") {
+    const drift = positional && positional !== symbol.statement ? {
+      binding,
+      symbol: _nullishCoalesce(root, () => ( "")),
+      annotatedLine: statementLine(positional, lineStarts),
+      symbolLine: statementLine(symbol.statement, lineStarts),
+      ambiguous: false
+    } : null;
+    return {
+      binding,
+      statement: symbol.statement,
+      symbolKind: symbol.symbolKind,
+      drift
+    };
+  }
+  return { binding, statement: positional, symbolKind: null, drift: null };
+}
+
+// ../plays/bundling/limits.ts
+var MAX_PLAY_BUNDLE_BYTES = 30 * 1024 * 1024;
+
+// ../plays/bundling/index.ts
+var PLAY_BUNDLE_CACHE_NAMESPACE = "deepline-play-artifacts-docflow-jsdoc";
+var PLAY_ARTIFACT_CACHE_DIR = _path.join.call(void 0, _os.tmpdir.call(void 0, ), PLAY_BUNDLE_CACHE_NAMESPACE);
+var PLAY_PROXY_NAMESPACE = "deepline-play-runtime-ref";
+var SOURCE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".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,
+  ...TEXT_IMPORT_EXTENSIONS
+]);
+var NODE_BUILTIN_SET = new Set(
+  _module.builtinModules.flatMap(
+    (name) => name.startsWith("node:") ? [name, name.slice(5)] : [name, `node:${name}`]
+  )
+);
+var defaultPathRelationshipApi = {
+  relative: _path.relative,
+  isAbsolute: _path.isAbsolute,
+  sep: _path.sep
+};
+function assertValidExportName(exportName) {
+  if (exportName === "default") return;
+  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(exportName)) {
+    throw new Error(
+      `Invalid play export name "${exportName}". Named prebuilt exports must be valid JavaScript identifiers.`
+    );
+  }
+}
+function sha256(value) {
+  return _crypto.createHash.call(void 0, "sha256").update(value).digest("hex");
+}
+function sourceIdentityPath(filePath, sourceIdentityRoot) {
+  if (!sourceIdentityRoot) return filePath;
+  const identityRoot = _path.resolve.call(void 0, sourceIdentityRoot);
+  const resolvedFilePath = _path.resolve.call(void 0, filePath);
+  const logicalPath = _path.relative.call(void 0, identityRoot, resolvedFilePath);
+  if (!logicalPath) {
+    return _path.basename.call(void 0, resolvedFilePath);
+  }
+  if (logicalPath === ".." || logicalPath.startsWith(`..${_path.sep}`) || _path.isAbsolute.call(void 0, logicalPath)) {
+    return filePath;
+  }
+  return logicalPath.split(/[\\/]+/).join("/");
+}
+function formatEsbuildMessage(message) {
+  const location = message.location ? `${message.location.file}:${message.location.line}:${message.location.column}` : null;
+  return location ? `${location} ${message.text}` : message.text;
+}
+function isLocalSpecifier(specifier) {
+  return specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/") || specifier.startsWith("file:");
+}
+async function normalizeLocalPath(filePath) {
+  try {
+    return await _promises.realpath.call(void 0, filePath);
+  } catch (e2) {
+    return _path.resolve.call(void 0, filePath);
+  }
+}
+function createPlayWorkspace(entryFile) {
+  return {
+    entryFile,
+    rootDir: _path.dirname.call(void 0, entryFile)
+  };
+}
+function isPathInsideDirectory(filePath, directory, pathApi = defaultPathRelationshipApi) {
+  const relationship = pathApi.relative(directory, filePath);
+  return relationship === "" || relationship !== ".." && !relationship.startsWith(`..${pathApi.sep}`) && !pathApi.isAbsolute(relationship);
+}
+function assertWithinPlayWorkspace(input) {
+  if (isPathInsideDirectory(input.resolvedPath, input.workspace.rootDir)) {
+    return;
+  }
+  throw new Error(
+    `${input.importer}:${input.line}:${input.column} Local play imports must stay inside the play workspace (${input.workspace.rootDir}). Import "${input.specifier}" resolved to ${input.resolvedPath}, which crosses into app/backend code. Use the public SDK/API surface or move shared helpers into the play workspace.`
+  );
+}
+function getPackageName(specifier) {
+  if (specifier.startsWith("@")) {
+    const [scope, name] = specifier.split("/");
+    return scope && name ? `${scope}/${name}` : specifier;
+  }
+  return _nullishCoalesce(specifier.split("/")[0], () => ( specifier));
+}
+function isPlaySourceFile(filePath) {
+  return PLAY_SOURCE_FILE_PATTERN.test(filePath);
+}
+function stripCommentsToSpaces(source) {
+  return source.replace(/\/\*[\s\S]*?\*\//g, (match) => match.replace(/[^\n]/g, " ")).replace(
+    /(^|[^:])\/\/.*$/gm,
+    (match, prefix) => prefix + " ".repeat(Math.max(0, match.length - prefix.length))
+  );
+}
+function lineAndColumnAt(source, index) {
+  const prefix = source.slice(0, index);
+  const lines = prefix.split("\n");
+  return { line: lines.length, column: lines[lines.length - 1].length + 1 };
+}
+function findSourceImportReferences(sourceCode) {
+  const source = stripCommentsToSpaces(sourceCode);
+  const references = [];
+  const addReference = (specifier, specifierIndex, kind) => {
+    if (!specifier) return;
+    const position = lineAndColumnAt(sourceCode, specifierIndex);
+    references.push({
+      specifier,
+      line: position.line,
+      column: position.column,
+      kind
+    });
+  };
+  const staticImportPattern = /\b(?:import|export)\s+(?!type\b)(?:[\s\S]*?\s+from\s*)?(['"])([^'"\n]+)\1/g;
+  for (const match of source.matchAll(staticImportPattern)) {
+    addReference(
+      match[2],
+      match.index + match[0].lastIndexOf(match[1]),
+      "static"
+    );
+  }
+  const dynamicImportPattern = /\bimport\s*\(\s*(['"])([^'"\n]+)\1/g;
+  for (const match of source.matchAll(dynamicImportPattern)) {
+    addReference(
+      match[2],
+      match.index + match[0].lastIndexOf(match[1]),
+      "dynamic-import"
+    );
+  }
+  const requirePattern = /\brequire\s*\(\s*(['"])([^'"\n]+)\1/g;
+  for (const match of source.matchAll(requirePattern)) {
+    addReference(
+      match[2],
+      match.index + match[0].lastIndexOf(match[1]),
+      "require"
+    );
+  }
+  const literalDynamicImportIndexes = new Set(
+    [...source.matchAll(dynamicImportPattern)].map((match) => match.index)
+  );
+  for (const match of source.matchAll(/\bimport\s*\(/g)) {
+    if (literalDynamicImportIndexes.has(match.index)) continue;
+    const position = lineAndColumnAt(sourceCode, match.index);
+    throw new Error(
+      `:${position.line}:${position.column} Dynamic import() is not allowed in plays. Use static imports instead.`
+    );
+  }
+  const literalRequireIndexes = new Set(
+    [...source.matchAll(requirePattern)].map((match) => match.index)
+  );
+  for (const match of source.matchAll(/\brequire\s*\(/g)) {
+    if (literalRequireIndexes.has(match.index)) continue;
+    const position = lineAndColumnAt(sourceCode, match.index);
+    throw new Error(
+      `:${position.line}:${position.column} Dynamic require() is not allowed in plays. Use static imports or require("literal") only.`
+    );
+  }
+  return references.sort(
+    (left, right) => left.line === right.line ? left.column - right.column : left.line - right.line
+  );
+}
+function extractDefinedPlayName(sourceCode) {
+  return _nullishCoalesce(_optionalChain([extractDefinedPlayMetadata, 'call', _71 => _71(sourceCode, null), 'optionalAccess', _72 => _72.name]), () => ( null));
+}
+function parsePlaySourceAst(sourceCode) {
+  try {
+    return TypeScriptParser.parse(sourceCode, {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      allowHashBang: true
+    });
+  } catch (e3) {
+    try {
+      const transformed = _esbuild.transformSync.call(void 0, sourceCode, {
+        loader: "ts",
+        format: "esm",
+        target: "esnext",
+        legalComments: "none",
+        sourcemap: false
+      }).code;
+      return _acorn.Parser.parse(transformed, {
+        ecmaVersion: "latest",
+        sourceType: "module",
+        allowHashBang: true
+      });
+    } catch (e4) {
+      return null;
+    }
+  }
+}
+function getIdentifierName3(node) {
+  return isAstNode(node) && node.type === "Identifier" ? typeof node.name === "string" ? node.name : null : null;
+}
+function memberExpressionPath(node) {
+  const expression = unwrapStaticExpression2(node);
+  if (!expression) return null;
+  if (expression.type === "Identifier" && typeof expression.name === "string") {
+    return [expression.name];
+  }
+  if (expression.type !== "MemberExpression") return null;
+  const objectPath = memberExpressionPath(
+    isAstNode(expression.object) ? expression.object : null
+  );
+  if (!objectPath) return null;
+  const property = isAstNode(expression.property) ? expression.property : null;
+  if (!property) return null;
+  if (!expression.computed && property.type === "Identifier") {
+    return typeof property.name === "string" ? [...objectPath, property.name] : null;
+  }
+  if (expression.computed && property.type === "Literal") {
+    return typeof property.value === "string" ? [...objectPath, property.value] : null;
+  }
+  return null;
+}
+function commonJsExportName(left) {
+  const path = memberExpressionPath(left);
+  if (!path) return null;
+  if (path.length === 2 && path[0] === "module" && path[1] === "exports") {
+    return "default";
+  }
+  if (path.length === 3 && path[0] === "module" && path[1] === "exports") {
+    return path[2] || null;
+  }
+  if (path.length === 2 && path[0] === "exports") {
+    return path[1] || null;
+  }
+  return null;
+}
+function isDefinePlayCallExpression(node) {
+  if (!node || node.type !== "CallExpression") return false;
+  const callee = isAstNode(node.callee) ? node.callee : null;
+  if (!callee) return false;
+  if (callee.type === "Identifier") {
+    return callee.name === "definePlay" || callee.name === "defineWorkflow";
+  }
+  if (callee.type === "MemberExpression" && isAstNode(callee.property)) {
+    const property = callee.property;
+    return !callee.computed && property.type === "Identifier" && (property.name === "definePlay" || property.name === "defineWorkflow");
+  }
+  return false;
+}
+function canResolveDeclarationInitializer(declarationKind, initializer) {
+  return declarationKind === "const" || isDefinePlayCallExpression(initializer);
+}
+function buildPlayMetadataContext(ast) {
+  const declarations = /* @__PURE__ */ new Map();
+  const namedExports = /* @__PURE__ */ new Map();
+  const commonJsExports = /* @__PURE__ */ new Map();
+  let defaultExport = null;
+  for (const statement of astArray(ast.body)) {
+    if (statement.type === "VariableDeclaration") {
+      for (const declaration of astArray(statement.declarations)) {
+        const name = getIdentifierName3(declaration.id);
+        if (!name) continue;
+        const initializer = isAstNode(declaration.init) ? declaration.init : null;
+        declarations.set(
+          name,
+          canResolveDeclarationInitializer(statement.kind, initializer) ? initializer : null
+        );
+      }
+      continue;
+    }
+    if (statement.type === "ExportDefaultDeclaration") {
+      defaultExport = isAstNode(statement.declaration) ? statement.declaration : null;
+      continue;
+    }
+    if (statement.type === "TSExportAssignment") {
+      defaultExport = isAstNode(statement.expression) ? statement.expression : null;
+      continue;
+    }
+    if (statement.type === "ExportNamedDeclaration") {
+      if (isAstNode(statement.declaration) && statement.declaration.type === "VariableDeclaration") {
+        for (const declaration of astArray(
+          statement.declaration.declarations
+        )) {
+          const name = getIdentifierName3(declaration.id);
+          if (!name) continue;
+          const initializer = isAstNode(declaration.init) ? declaration.init : null;
+          declarations.set(
+            name,
+            canResolveDeclarationInitializer(
+              statement.declaration.kind,
+              initializer
+            ) ? initializer : null
+          );
+          namedExports.set(name, name);
+        }
+      }
+      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);
+        }
+      }
+    }
+    if (statement.type === "ExpressionStatement" && isAstNode(statement.expression) && statement.expression.type === "AssignmentExpression") {
+      const exportName = commonJsExportName(
+        isAstNode(statement.expression.left) ? statement.expression.left : null
+      );
+      if (exportName && isAstNode(statement.expression.right)) {
+        commonJsExports.set(exportName, statement.expression.right);
+      }
+    }
+  }
+  return { declarations, namedExports, commonJsExports, defaultExport };
+}
+function unwrapStaticExpression2(node) {
+  let current = _nullishCoalesce(node, () => ( null));
+  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 staticStringFromExpression(node, context, seen = /* @__PURE__ */ new Set(), trimResult = true) {
+  const expression = unwrapStaticExpression2(node);
+  if (!expression) return null;
+  if (expression.type === "Literal") {
+    const value = expression.value;
+    if (typeof value !== "string" || !value.trim()) return null;
+    return trimResult ? value.trim() : value;
+  }
+  if (expression.type === "TemplateLiteral" && astArray(expression.expressions).length === 0) {
+    const firstQuasi = astArray(expression.quasis)[0];
+    const cooked = firstQuasi && typeof firstQuasi.value === "object" ? firstQuasi.value.cooked : null;
+    if (typeof cooked !== "string" || !cooked.trim()) return null;
+    return trimResult ? cooked.trim() : cooked;
+  }
+  if (expression.type === "BinaryExpression" && expression.operator === "+") {
+    const left = staticStringFromExpression(
+      isAstNode(expression.left) ? expression.left : null,
+      context,
+      new Set(seen),
+      false
+    );
+    const right = staticStringFromExpression(
+      isAstNode(expression.right) ? expression.right : null,
+      context,
+      new Set(seen),
+      false
+    );
+    const value = left !== null && right !== null ? `${left}${right}` : null;
+    if (!_optionalChain([value, 'optionalAccess', _73 => _73.trim, 'call', _74 => _74()])) return null;
+    return trimResult ? value.trim() : value;
+  }
+  const identifier = getIdentifierName3(expression);
+  if (!identifier || seen.has(identifier)) return null;
+  seen.add(identifier);
+  return staticStringFromExpression(
+    context.declarations.get(identifier),
+    context,
+    seen,
+    trimResult
+  );
+}
+function propertyNameFromKey(property) {
+  const key = isAstNode(property.key) ? property.key : null;
+  if (!key) return null;
+  if (property.computed) {
+    return key.type === "Literal" && typeof key.value === "string" ? key.value : null;
+  }
+  if (key.type === "Identifier" && typeof key.name === "string") {
+    return key.name;
+  }
+  if (key.type === "Literal" && typeof key.value === "string") {
+    return key.value;
+  }
+  return null;
+}
+function objectExpressionFromNode(node, context, seen = /* @__PURE__ */ new Set()) {
+  const expression = unwrapStaticExpression2(node);
+  if (!expression) return null;
+  if (expression.type === "ObjectExpression") return expression;
+  const identifier = getIdentifierName3(expression);
+  if (!identifier || seen.has(identifier)) return null;
+  seen.add(identifier);
+  return objectExpressionFromNode(
+    context.declarations.get(identifier),
+    context,
+    seen
+  );
+}
+function resolveStaticProperty(node, propertyName, context, ancestors = /* @__PURE__ */ new Set()) {
+  if (!node) return { kind: "absent" };
+  const object = objectExpressionFromNode(node, context);
+  if (!object) return { kind: "unknown" };
+  if (ancestors.has(object)) return { kind: "unknown" };
+  const nextAncestors = new Set(ancestors).add(object);
+  let resolution = { kind: "absent" };
+  for (const property of astArray(object.properties)) {
+    if (property.type === "SpreadElement") {
+      const spreadResolution = resolveStaticProperty(
+        isAstNode(property.argument) ? property.argument : null,
+        propertyName,
+        context,
+        nextAncestors
+      );
+      if (spreadResolution.kind !== "absent") {
+        resolution = spreadResolution;
+      }
+      continue;
+    }
+    if (property.type !== "Property") continue;
+    const resolvedPropertyName = propertyNameFromKey(property);
+    if (resolvedPropertyName !== propertyName) {
+      if (property.computed && resolvedPropertyName === null) {
+        resolution = { kind: "unknown" };
+      }
+      continue;
+    }
+    const propertyValue = property.shorthand ? property.key : property.value;
+    resolution = isAstNode(propertyValue) ? { kind: "found", value: propertyValue } : { kind: "unknown" };
+  }
+  return resolution;
+}
+function staticPropertyNames(node, context, ancestors = /* @__PURE__ */ new Set()) {
+  if (!node) return /* @__PURE__ */ new Set();
+  const object = objectExpressionFromNode(node, context);
+  if (!object || ancestors.has(object)) return null;
+  const nextAncestors = new Set(ancestors).add(object);
+  const names = /* @__PURE__ */ new Set();
+  for (const property of astArray(object.properties)) {
+    if (property.type === "SpreadElement") {
+      const spreadNames = staticPropertyNames(
+        isAstNode(property.argument) ? property.argument : null,
+        context,
+        nextAncestors
+      );
+      if (!spreadNames) return null;
+      for (const name2 of spreadNames) names.add(name2);
+      continue;
+    }
+    if (property.type !== "Property") return null;
+    const name = propertyNameFromKey(property);
+    if (name === null) return null;
+    names.add(name);
+  }
+  return names;
+}
+function staticNumberFromExpression(node, context, seen = /* @__PURE__ */ new Set()) {
+  const expression = unwrapStaticExpression2(node);
+  if (!expression) return null;
+  if (expression.type === "Literal" && typeof expression.value === "number") {
+    return expression.value;
+  }
+  const identifier = getIdentifierName3(expression);
+  if (!identifier || seen.has(identifier)) return null;
+  seen.add(identifier);
+  return staticNumberFromExpression(
+    context.declarations.get(identifier),
+    context,
+    seen
+  );
+}
+function toolErrorSchemaVersionFromOptions(node, context) {
+  const directCompatibility = resolveStaticProperty(
+    node,
+    "compatibility",
+    context
+  );
+  if (directCompatibility.kind === "unknown") return null;
+  const bindings = resolveStaticProperty(node, "bindings", context);
+  if (bindings.kind === "unknown") return null;
+  const bindingCompatibility = bindings.kind === "found" ? resolveStaticProperty(bindings.value, "compatibility", context) : { kind: "absent" };
+  if (bindingCompatibility.kind === "unknown") return null;
+  const compatibility = directCompatibility.kind === "found" ? directCompatibility : bindingCompatibility;
+  if (compatibility.kind === "absent") return void 0;
+  const schema = resolveStaticProperty(
+    compatibility.value,
+    "toolErrorSchemaVersion",
+    context
+  );
+  if (schema.kind === "absent") return void 0;
+  if (schema.kind !== "found") return null;
+  const schemaVersion = staticNumberFromExpression(schema.value, context);
+  if (schemaVersion === 0 || schemaVersion === 1) return schemaVersion;
+  return null;
+}
+function toolResponseReceiptRevisionFromOptions(node, context) {
+  const directCompatibility = resolveStaticProperty(
+    node,
+    "compatibility",
+    context
+  );
+  if (directCompatibility.kind === "unknown") return null;
+  const bindings = resolveStaticProperty(node, "bindings", context);
+  if (bindings.kind === "unknown") return null;
+  const bindingCompatibility = bindings.kind === "found" ? resolveStaticProperty(bindings.value, "compatibility", context) : { kind: "absent" };
+  if (bindingCompatibility.kind === "unknown") return null;
+  const compatibility = directCompatibility.kind === "found" ? directCompatibility : bindingCompatibility;
+  if (compatibility.kind === "absent") return void 0;
+  const revision = resolveStaticProperty(
+    compatibility.value,
+    "toolResponseReceiptRevision",
+    context
+  );
+  if (revision.kind === "absent") return void 0;
+  if (revision.kind !== "found") return null;
+  return staticStringFromExpression(revision.value, context);
+}
+function sandboxRuntimeDeclarationFromOptions(node, context) {
+  const directRuntime = resolveStaticProperty(node, "runtime", context);
+  const bindings = resolveStaticProperty(node, "bindings", context);
+  const bindingRuntime = bindings.kind === "found" ? resolveStaticProperty(bindings.value, "runtime", context) : { kind: "absent" };
+  const runtime = directRuntime.kind === "found" ? directRuntime : bindingRuntime;
+  if (runtime.kind !== "found") return null;
+  const propertyNames = staticPropertyNames(runtime.value, context);
+  const unsupportedProperties = propertyNames ? [...propertyNames].filter(
+    (propertyName) => propertyName !== "timeout" && propertyName !== "size"
+  ) : [];
+  if (unsupportedProperties.length > 0) {
+    throw new Error(
+      `Unsupported runtime sandbox option${unsupportedProperties.length === 1 ? "" : "s"} "${unsupportedProperties.join('", "')}". Use runtime.size with a Deepline prebuilt sandbox. Supported sizes: "standard".`
+    );
+  }
+  const timeout = resolveStaticProperty(runtime.value, "timeout", context);
+  const size = resolveStaticProperty(runtime.value, "size", context);
+  const declaration = {};
+  if (timeout.kind === "found") {
+    const value = staticStringFromExpression(timeout.value, context);
+    if (value === null) return null;
+    declaration.timeout = value;
+  }
+  if (size.kind === "found") {
+    const value = staticStringFromExpression(size.value, context);
+    if (value === null) return null;
+    declaration.size = value;
+  }
+  return declaration;
+}
+function stringPropertyFromObjectExpression(node, propertyName, context, seenObjects = /* @__PURE__ */ new Set()) {
+  const object = objectExpressionFromNode(node, context);
+  if (!object || seenObjects.has(object)) return null;
+  seenObjects.add(object);
+  let value = null;
+  for (const property of astArray(object.properties)) {
+    if (property.type === "SpreadElement") {
+      const spreadValue = stringPropertyFromObjectExpression(
+        isAstNode(property.argument) ? property.argument : null,
+        propertyName,
+        context,
+        seenObjects
+      );
+      if (spreadValue) value = spreadValue;
+      continue;
+    }
+    if (property.type !== "Property") continue;
+    if (propertyNameFromKey(property) !== propertyName) continue;
+    const propertyValue = property.shorthand ? property.key : property.value;
+    value = staticStringFromExpression(
+      isAstNode(propertyValue) ? propertyValue : null,
+      context
+    );
+  }
+  return value;
+}
+function isDefinePlayCallee(node) {
+  const callee = unwrapStaticExpression2(node);
+  if (!callee) return false;
+  if (callee.type === "Identifier" && (callee.name === "definePlay" || callee.name === "defineWorkflow")) {
+    return true;
+  }
+  if (callee.type === "MemberExpression" && isAstNode(callee.property)) {
+    const property = callee.property;
+    return !callee.computed && property.type === "Identifier" && (property.name === "definePlay" || property.name === "defineWorkflow");
+  }
+  return false;
+}
+function playMetadataFromDefinePlayCall(node, context) {
+  const expression = unwrapStaticExpression2(node);
+  if (!expression || expression.type !== "CallExpression" || !isDefinePlayCallee(isAstNode(expression.callee) ? expression.callee : null)) {
+    return null;
+  }
+  const args = astArray(expression.arguments);
+  const firstArg = _nullishCoalesce(args[0], () => ( null));
+  const isObjectForm = args.length === 1 || objectExpressionFromNode(firstArg, context) !== null;
+  const objectName = stringPropertyFromObjectExpression(
+    firstArg,
+    "id",
+    context
+  );
+  const name = isObjectForm ? objectName : staticStringFromExpression(firstArg, context);
+  let description = _nullishCoalesce(stringPropertyFromObjectExpression(firstArg, "description", context), () => ( null));
+  for (let index = args.length - 1; !description && index >= 2; index -= 1) {
+    description = stringPropertyFromObjectExpression(
+      args[index],
+      "description",
+      context
+    );
+  }
+  const options = isObjectForm ? firstArg : _nullishCoalesce(args[2], () => ( null));
+  const sandboxRuntimeDeclaration = sandboxRuntimeDeclarationFromOptions(
+    options,
+    context
+  );
+  const toolErrorSchemaVersion = toolErrorSchemaVersionFromOptions(
+    options,
+    context
+  );
+  const toolErrorSchemaVersionUnknown = toolErrorSchemaVersion === null;
+  const toolResponseReceiptRevision = toolResponseReceiptRevisionFromOptions(
+    options,
+    context
+  );
+  const toolResponseReceiptRevisionUnknown = toolResponseReceiptRevision === null;
+  if (!name && !description && toolErrorSchemaVersion === void 0 && !toolErrorSchemaVersionUnknown && toolResponseReceiptRevision === void 0 && !toolResponseReceiptRevisionUnknown) {
+    return null;
+  }
+  return {
+    name,
+    description,
+    sandboxRuntimeDeclaration,
+    toolErrorSchemaVersion: _nullishCoalesce(toolErrorSchemaVersion, () => ( null)),
+    toolErrorSchemaVersionUnknown,
+    toolResponseReceiptRevision: _nullishCoalesce(toolResponseReceiptRevision, () => ( null)),
+    toolResponseReceiptRevisionUnknown
+  };
+}
+function resolveExportExpression(exportName, context) {
+  if (exportName === "default") {
+    const commonJsDefault = context.commonJsExports.get("default");
+    if (commonJsDefault) {
+      const commonJsDefaultIdentifier = getIdentifierName3(
+        unwrapStaticExpression2(commonJsDefault)
+      );
+      return commonJsDefaultIdentifier ? _nullishCoalesce(context.declarations.get(commonJsDefaultIdentifier), () => ( commonJsDefault)) : commonJsDefault;
+    }
+    const defaultExpression = unwrapStaticExpression2(context.defaultExport);
+    const defaultIdentifier = getIdentifierName3(defaultExpression);
+    if (!defaultIdentifier) {
+      const defaultExportName = context.namedExports.get("default");
+      return defaultExportName ? _nullishCoalesce(context.declarations.get(defaultExportName), () => ( null)) : defaultExpression;
+    }
+    return defaultIdentifier ? _nullishCoalesce(context.declarations.get(defaultIdentifier), () => ( context.defaultExport)) : context.defaultExport;
+  }
+  if (exportName) {
+    const commonJsExport = context.commonJsExports.get(exportName);
+    if (commonJsExport) {
+      const commonJsExportIdentifier = getIdentifierName3(
+        unwrapStaticExpression2(commonJsExport)
+      );
+      return commonJsExportIdentifier ? _nullishCoalesce(context.declarations.get(commonJsExportIdentifier), () => ( commonJsExport)) : commonJsExport;
+    }
+    const localName = _nullishCoalesce(context.namedExports.get(exportName), () => ( exportName));
+    return _nullishCoalesce(context.declarations.get(localName), () => ( null));
+  }
+  return null;
+}
+function extractDefinedPlayMetadata(sourceCode, exportName) {
+  const ast = parsePlaySourceAst(sourceCode);
+  if (!ast) return null;
+  const context = buildPlayMetadataContext(ast);
+  const exportedExpression = resolveExportExpression(exportName, context);
+  const exportedMetadata = playMetadataFromDefinePlayCall(
+    exportedExpression,
+    context
+  );
+  if (exportedMetadata) return exportedMetadata;
+  if (exportName) return null;
+  if (context.defaultExport) {
+    const directDefaultMetadata = playMetadataFromDefinePlayCall(
+      context.defaultExport,
+      context
+    );
+    if (directDefaultMetadata) return directDefaultMetadata;
+    const defaultIdentifier = getIdentifierName3(context.defaultExport);
+    if (defaultIdentifier) {
+      const defaultMetadata = playMetadataFromDefinePlayCall(
+        context.declarations.get(defaultIdentifier),
+        context
+      );
+      if (defaultMetadata) return defaultMetadata;
+    }
+  }
+  for (const expression of context.declarations.values()) {
+    const metadata = playMetadataFromDefinePlayCall(expression, context);
+    if (metadata) return metadata;
+  }
+  for (const expression of context.commonJsExports.values()) {
+    const metadata = playMetadataFromDefinePlayCall(expression, context);
+    if (metadata) return metadata;
+  }
+  return null;
+}
+function readPackageVersionFromPackageJson(packageJsonPath, packageName) {
+  try {
+    const packageJson = JSON.parse(_fs.readFileSync.call(void 0, packageJsonPath, "utf-8"));
+    if (packageJson.name === packageName && typeof packageJson.version === "string") {
+      return packageJson.version;
+    }
+  } catch (e5) {
+    return null;
+  }
+  return null;
+}
+function findPackageJsonPathFrom(startDir, packageName) {
+  if (!_path.isAbsolute.call(void 0, startDir)) {
+    throw new Error(
+      `Package resolution requires an absolute start directory, got ${startDir}`
+    );
+  }
+  let current = startDir;
+  while (true) {
+    const packageJsonPath = _path.join.call(void 0, 
+      current,
+      "node_modules",
+      packageName,
+      "package.json"
+    );
+    if (_fs.existsSync.call(void 0, packageJsonPath)) {
+      return packageJsonPath;
+    }
+    const parent = _path.dirname.call(void 0, current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function findPackageJsonPath(packageName, fromFile, adapter) {
+  const startDirs = [
+    _path.resolve.call(void 0, _path.dirname.call(void 0, fromFile)),
+    _path.resolve.call(void 0, adapter.projectRoot),
+    _path.resolve.call(void 0, _path.dirname.call(void 0, adapter.sdkPackageJson))
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  for (const startDir of startDirs) {
+    if (seen.has(startDir)) continue;
+    seen.add(startDir);
+    const packageJsonPath = findPackageJsonPathFrom(startDir, packageName);
+    if (packageJsonPath) return packageJsonPath;
+  }
+  const adapterNodeModulesPackageJson = _path.join.call(void 0, 
+    adapter.nodeModulesDir,
+    packageName,
+    "package.json"
+  );
+  return _fs.existsSync.call(void 0, adapterNodeModulesPackageJson) ? adapterNodeModulesPackageJson : null;
+}
+function localSdkAliasPlugin(adapter) {
+  const entryFile = adapter.sdkEntryFile;
+  if (!_fs.existsSync.call(void 0, entryFile)) {
+    return null;
+  }
+  return {
+    name: "deepline-sdk-local-alias",
+    setup(buildContext) {
+      buildContext.onResolve({ filter: /^deepline$/ }, () => ({
+        path: entryFile
+      }));
+      buildContext.onResolve({ filter: /^deepline\/helpers$/ }, () => ({
+        path: _path.join.call(void 0, adapter.sdkSourceRoot, "helpers.ts")
+      }));
+    }
+  };
+}
+function isTextImportFile(path) {
+  return TEXT_IMPORT_EXTENSIONS.has(_path.extname.call(void 0, path));
+}
+function sourceLoaderForPath(path) {
+  const rawExtension = _path.extname.call(void 0, path);
+  if (TEXT_IMPORT_EXTENSIONS.has(rawExtension)) return "text";
+  const extension = rawExtension.toLowerCase();
+  if (extension === ".tsx") return "tsx";
+  if (extension === ".jsx") return "jsx";
+  if (extension === ".js" || extension === ".mjs" || extension === ".cjs") {
+    return "js";
+  }
+  return "ts";
+}
+function isFunctionNode(node) {
+  return !!node && (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression");
+}
+function definePlayRunFunction(call) {
+  if (!isDefinePlayCallExpression(call)) return null;
+  const args = astArray(call.arguments);
+  const positional = args.find((argument) => isFunctionNode(argument));
+  if (positional) return positional;
+  const config = unwrapStaticExpression2(_nullishCoalesce(args[0], () => ( null)));
+  if (!config || config.type !== "ObjectExpression") return null;
+  let run = null;
+  for (const property of astArray(config.properties)) {
+    if (property.type !== "Property") continue;
+    if (propertyNameFromKey(property) !== "run") continue;
+    const value = unwrapStaticExpression2(
+      isAstNode(property.value) ? property.value : null
+    );
+    run = isFunctionNode(value) ? value : null;
+  }
+  return run;
+}
+var DOCFLOW_INJECTED_CONTEXT_NAME = "__deeplineDocflowContext";
+function docflowContextFromCall(call, sourceCode) {
+  if (!isDefinePlayCallExpression(call)) return null;
+  const run = definePlayRunFunction(call);
+  if (!run) {
+    return {
+      kind: "unsupported",
+      reason: "its definePlay call does not declare the run function inline (pass `definePlay(name, async (ctx, input) => \u2026)` or `definePlay({ id, run: async (ctx, input) => \u2026 })`)"
+    };
+  }
+  const params = astArray(run.params);
+  const first = params[0];
+  if (first) {
+    const name = getIdentifierName3(first);
+    return name ? { kind: "named", name } : {
+      kind: "unsupported",
+      reason: `its run function's first parameter is not a plain identifier (found ${first.type}; declare the context as \`ctx\` and destructure inside the body)`
+    };
+  }
+  const runBounds = astNodeBounds(run);
+  const body = isAstNode(run.body) ? astNodeBounds(run.body) : null;
+  if (!runBounds || !body) {
+    return {
+      kind: "unsupported",
+      reason: "its run function has no source span"
+    };
+  }
+  const signature = sourceCode.slice(runBounds.start, body.start);
+  const emptyParams = /\(\s*\)/.exec(signature);
+  if (!emptyParams) {
+    return {
+      kind: "unsupported",
+      reason: "its parameterless run function has no `()` parameter list"
+    };
+  }
+  return {
+    kind: "inject",
+    name: DOCFLOW_INJECTED_CONTEXT_NAME,
+    at: runBounds.start + emptyParams.index + 1
+  };
+}
+function findDocflowContext(input) {
+  let owner = input.statement;
+  while (owner) {
+    const context = docflowContextFromCall(owner, input.sourceCode);
+    if (context) return context;
+    owner = _nullishCoalesce(input.parents.get(owner), () => ( null));
+  }
+  const lineStart = input.lineStarts[input.bindingLine - 1];
+  const lineEnd = _nullishCoalesce(input.lineStarts[input.bindingLine], () => ( Number.POSITIVE_INFINITY));
+  if (lineStart === void 0) return null;
+  let best = null;
+  const pending = [input.ast];
+  while (pending.length > 0) {
+    const value = pending.pop();
+    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', _75 => _75(best), 'optionalAccess', _76 => _76.end]), () => ( 0))) - (_nullishCoalesce(_optionalChain([astNodeBounds, 'call', _77 => _77(best), 'optionalAccess', _78 => _78.start]), () => ( 0))))) {
+        best = value;
+      }
+    }
+    for (const child of Object.values(value)) {
+      if (Array.isArray(child)) pending.push(...child);
+      else if (isAstNode(child)) pending.push(child);
+    }
+  }
+  return best ? docflowContextFromCall(best, input.sourceCode) : null;
+}
+function docflowInputCaptureSource(paths) {
+  return `[${paths.map((path) => {
+    const [root, ...properties] = path.split(".");
+    return `{path:${JSON.stringify(path)},readRoot:()=>${root},properties:${JSON.stringify(properties)}}`;
+  }).join(",")}]`;
+}
+function docflowObservationTarget(statement) {
+  if (!statement) return null;
+  let expression = null;
+  if (statement.type === "VariableDeclaration") {
+    const declarations = astArray(statement.declarations);
+    if (declarations.length === 1 && isAstNode(declarations[0].init)) {
+      expression = declarations[0].init;
+    }
+  } else if (statement.type === "ReturnStatement" && isAstNode(statement.argument)) {
+    expression = statement.argument;
+  } else if (statement.type === "ExpressionStatement" && isAstNode(statement.expression)) {
+    expression = statement.expression;
+  } else if (statement.type === "IfStatement" && isAstNode(statement.test)) {
+    expression = statement.test;
+  } else if (statement.type === "ThrowStatement" && isAstNode(statement.argument)) {
+    expression = statement.argument;
+  }
+  if (!expression) return null;
+  const bounds = astNodeBounds(expression);
+  if (!bounds) return null;
+  return {
+    ...bounds,
+    awaitsResult: expressionContainsTopLevelAwait(expression),
+    expression,
+    throws: statement.type === "ThrowStatement"
+  };
+}
+function docflowObservedExpression(input) {
+  const body = input.throws ? `{throw (${input.expression})}` : `(${input.expression})`;
+  const callback = input.awaitsResult ? `async()=>${body}` : `()=>${body}`;
+  const observation = `((runtimeContext,inputCaptures,execute)=>typeof runtimeContext.__deeplineObserveDocflowNode==="function"?runtimeContext.__deeplineObserveDocflowNode(${JSON.stringify(input.nodeId)},inputCaptures,${JSON.stringify(input.outputs)},execute):execute())(${input.contextName},${docflowInputCaptureSource(input.inputs)},${callback})`;
+  return input.awaitsResult ? `(await ${observation})` : observation;
+}
+function expressionContainsTopLevelAwait(expression) {
+  const pending = [expression];
+  while (pending.length > 0) {
+    const node = pending.pop();
+    if (node.type === "AwaitExpression") return true;
+    if (node !== expression && (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" || node.type === "FunctionDeclaration")) {
+      continue;
+    }
+    for (const child of Object.values(node)) {
+      if (Array.isArray(child)) pending.push(...child.filter(isAstNode));
+      else if (isAstNode(child)) pending.push(child);
+    }
+  }
+  return false;
+}
+function instrumentPlayDocflowRuntimeHits(sourceCode) {
+  const parsed = parsePlayDocflowFile(sourceCode);
+  if (parsed.blocks.length === 0 || parsed.errors.length > 0) return sourceCode;
+  const ast = parsePlaySourceAst(sourceCode);
+  if (!ast) return sourceCode;
+  const lineStarts = sourceLineStarts(sourceCode);
+  const replacements = [];
+  const targets = [];
+  const injectedContextAt = /* @__PURE__ */ new Set();
+  const parents = buildDocflowParentIndex(ast);
+  for (const binding of parsed.bindings) {
+    const resolution = resolveDocflowBinding(ast, binding, lineStarts, parents);
+    const context = findDocflowContext({
+      ast,
+      sourceCode,
+      statement: resolution.statement,
+      bindingLine: binding.line,
+      lineStarts,
+      parents
+    });
+    if (!context) continue;
+    if (context.kind === "unsupported") {
+      throw new Error(
+        `@mermaid-node ${binding.nodeId} (line ${binding.line}) cannot be observed at runtime: ${context.reason}.`
+      );
+    }
+    if (context.kind === "inject") injectedContextAt.add(context.at);
+    const contextName = context.kind === "inject" ? `(${context.name}??{})` : context.name;
+    const target = docflowObservationTarget(resolution.statement);
+    const observedRoot = docflowOutputRoot(binding);
+    if (target && observedRoot && docflowExpressionWrapsStepBuilder(target.expression, observedRoot)) {
+      continue;
+    }
+    if (target) {
+      targets.push({ ...target, contextName, binding });
+      continue;
+    }
+    const lineStart = lineStarts[binding.line - 1];
+    if (lineStart !== void 0) {
+      const indentationLength = _nullishCoalesce(_optionalChain([/^\s*/, 'access', _79 => _79.exec, 'call', _80 => _80(sourceCode.slice(lineStart)), 'optionalAccess', _81 => _81[0], 'access', _82 => _82.length]), () => ( 0));
+      replacements.push({
+        start: lineStart + indentationLength,
+        end: lineStart + indentationLength,
+        value: `await (typeof ${contextName}.__deeplineDocflowHit==="function"?${contextName}.__deeplineDocflowHit(${JSON.stringify(binding.nodeId)}):void 0); `
+      });
+    }
+  }
+  targets.sort(
+    (left, right) => left.start - right.start || right.end - left.end
+  );
+  const groups = [];
+  for (const target of targets) {
+    const open = groups[groups.length - 1];
+    if (open && target.start < open.end) {
+      open.bindings.push(target.binding);
+    } else {
+      groups.push({
+        start: target.start,
+        end: target.end,
+        awaitsResult: target.awaitsResult,
+        throws: target.throws,
+        contextName: target.contextName,
+        bindings: [target.binding]
+      });
+    }
+  }
+  for (const group of groups) {
+    let expression = sourceCode.slice(group.start, group.end);
+    let innermost = true;
+    for (const binding of [...group.bindings].reverse()) {
+      expression = docflowObservedExpression({
+        contextName: group.contextName,
+        nodeId: binding.nodeId,
+        inputs: _nullishCoalesce(binding.inputs, () => ( [])),
+        outputs: _nullishCoalesce(binding.outputs, () => ( [])),
+        expression,
+        awaitsResult: group.awaitsResult,
+        throws: group.throws && innermost
+      });
+      innermost = false;
+    }
+    replacements.push({
+      start: group.start,
+      end: group.end,
+      value: expression
+    });
+  }
+  for (const at of injectedContextAt) {
+    replacements.push({
+      start: at,
+      end: at,
+      value: DOCFLOW_INJECTED_CONTEXT_NAME
+    });
+  }
+  return replacements.sort((left, right) => right.start - left.start).reduce(
+    (source, replacement) => `${source.slice(0, replacement.start)}${replacement.value}${source.slice(replacement.end)}`,
+    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))
+  );
+  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 (isTextImportFile(args.path)) {
+          return {
+            contents: _fs.readFileSync.call(void 0, args.path, "utf8"),
+            loader: "text",
+            resolveDir: _path.dirname.call(void 0, args.path)
+          };
+        }
+        return {
+          contents: instrumentPlayDocflowRuntimeHits(
+            _fs.readFileSync.call(void 0, args.path, "utf8")
+          ),
+          loader: sourceLoaderForPath(args.path),
+          resolveDir: _path.dirname.call(void 0, args.path)
+        };
+      });
+    }
+  };
+}
+function buildImportedPlayProxyModule(playName) {
+  const serializedName = JSON.stringify(playName);
+  return `
+const PLAY_METADATA_SYMBOL = Symbol.for('deepline.play.metadata');
+const importedPlayRef = async function importedPlayRef(ctx, input) {
+  return ctx.runPlay(${JSON.stringify(`imported_${playName.replace(/[^A-Za-z0-9_]+/g, "_")}`)}, importedPlayRef, input, {
+    description: 'Run the imported Deepline play dependency.',
+  });
+};
+Object.defineProperty(importedPlayRef, 'playName', {
+  value: ${serializedName},
+  enumerable: true,
+  configurable: false,
+  writable: false,
+});
+Object.defineProperty(importedPlayRef, PLAY_METADATA_SYMBOL, {
+  value: { name: ${serializedName} },
+  enumerable: false,
+  configurable: false,
+  writable: false,
+});
+export const playName = ${serializedName};
+export const name = ${serializedName};
+export default importedPlayRef;
+`;
+}
+function importedPlayProxyPlugin(importedPlayDependencies) {
+  if (importedPlayDependencies.length === 0) {
+    return null;
+  }
+  const dependenciesByPath = new Map(
+    importedPlayDependencies.map((dependency) => [
+      dependency.filePath,
+      dependency
+    ])
+  );
+  return {
+    name: "deepline-imported-play-proxy",
+    setup(buildContext) {
+      buildContext.onResolve({ filter: /.*/ }, async (args) => {
+        if (!args.importer || !isLocalSpecifier(args.path) || args.importer.split(/[\\/]+/).includes("node_modules")) {
+          return null;
+        }
+        const resolvedPath = await resolveLocalImport(args.importer, args.path);
+        const dependency = dependenciesByPath.get(resolvedPath);
+        if (!dependency) {
+          return null;
+        }
+        return {
+          path: dependency.filePath,
+          namespace: PLAY_PROXY_NAMESPACE,
+          pluginData: dependency
+        };
+      });
+      buildContext.onLoad(
+        { filter: /.*/, namespace: PLAY_PROXY_NAMESPACE },
+        async (args) => {
+          const dependency = _nullishCoalesce(args.pluginData, () => ( dependenciesByPath.get(args.path)));
+          if (!dependency) {
+            return null;
+          }
+          return {
+            contents: buildImportedPlayProxyModule(dependency.playName),
+            loader: "ts",
+            resolveDir: _path.dirname.call(void 0, args.path)
+          };
+        }
+      );
+    }
+  };
+}
+async function fileExists(filePath) {
+  try {
+    await _promises.stat.call(void 0, filePath);
+    return true;
+  } catch (e6) {
+    return false;
+  }
+}
+async function resolveLocalImport(fromFile, specifier) {
+  if (specifier.startsWith("file:")) {
+    return normalizeLocalPath(new URL(specifier).pathname);
+  }
+  const base = _path.isAbsolute.call(void 0, specifier) ? _path.resolve.call(void 0, specifier) : _path.resolve.call(void 0, _path.dirname.call(void 0, fromFile), specifier);
+  const candidates = [base];
+  const explicitExtension = _path.extname.call(void 0, base).toLowerCase();
+  if ([".js", ".jsx", ".mjs", ".cjs"].includes(explicitExtension)) {
+    const stem = base.slice(0, -explicitExtension.length);
+    candidates.push(
+      ...SOURCE_EXTENSIONS.map((extension) => `${stem}${extension}`)
+    );
+  } else if (!EXPLICIT_IMPORT_EXTENSIONS.has(explicitExtension)) {
+    candidates.push(
+      ...SOURCE_EXTENSIONS.map((extension) => `${base}${extension}`)
+    );
+    candidates.push(
+      ...SOURCE_EXTENSIONS.map((extension) => _path.join.call(void 0, base, `index${extension}`))
+    );
+  }
+  for (const candidate of candidates) {
+    if (await fileExists(candidate)) {
+      return normalizeLocalPath(candidate);
+    }
+  }
+  throw new Error(
+    `Could not resolve local import "${specifier}" from ${fromFile}`
+  );
+}
+function resolvePackageImport(specifier, fromFile, adapter) {
+  const packageName = getPackageName(specifier);
+  if (packageName === "deepline" && _fs.existsSync.call(void 0, adapter.sdkPackageJson)) {
+    const packageJson = JSON.parse(
+      _fs.readFileSync.call(void 0, adapter.sdkPackageJson, "utf-8")
+    );
+    return {
+      name: "deepline",
+      version: _nullishCoalesce(packageJson.version, () => ( null))
+    };
+  }
+  const packageJsonPath = findPackageJsonPath(packageName, fromFile, adapter);
+  if (!packageJsonPath) {
+    throw new Error(`Could not resolve "${specifier}" from ${fromFile}`);
+  }
+  return {
+    name: packageName,
+    version: readPackageVersionFromPackageJson(packageJsonPath, packageName)
+  };
+}
+async function analyzeSourceGraph(entryFile, adapter, exportName) {
+  const absoluteEntryFile = await normalizeLocalPath(entryFile);
+  const workspace = createPlayWorkspace(absoluteEntryFile);
+  const sourceIdentityRoot = adapter.sourceIdentityRoot ? await normalizeLocalPath(adapter.sourceIdentityRoot) : void 0;
+  const localFiles = /* @__PURE__ */ new Map();
+  const nodeBuiltins = /* @__PURE__ */ new Set();
+  const packages = /* @__PURE__ */ new Map();
+  const importedPlayDependencies = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const visitFile = async (filePath) => {
+    const absolutePath = await normalizeLocalPath(filePath);
+    if (visited.has(absolutePath)) {
+      return;
+    }
+    visited.add(absolutePath);
+    const sourceCode2 = await _promises.readFile.call(void 0, 
+      /* turbopackIgnore: true */
+      absolutePath,
+      "utf-8"
+    );
+    localFiles.set(absolutePath, sourceCode2);
+    if (_path.extname.call(void 0, absolutePath).toLowerCase() === ".json" || isTextImportFile(absolutePath)) {
+      return;
+    }
+    const handleSpecifier = async (specifier, line, column, kind) => {
+      if (kind === "dynamic-import") {
+        throw new Error(
+          `${absolutePath}:${line}:${column} Dynamic import() is not allowed in plays. Use static imports instead.`
+        );
+      }
+      if (NODE_BUILTIN_SET.has(specifier)) {
+        nodeBuiltins.add(
+          specifier.startsWith("node:") ? specifier : `node:${specifier}`
+        );
+        return;
+      }
+      if (isLocalSpecifier(specifier)) {
+        const resolved = await resolveLocalImport(absolutePath, specifier);
+        assertWithinPlayWorkspace({
+          importer: absolutePath,
+          specifier,
+          resolvedPath: resolved,
+          workspace,
+          line,
+          column
+        });
+        if (resolved !== absoluteEntryFile && isPlaySourceFile(resolved)) {
+          const importedSource = await _promises.readFile.call(void 0, 
+            /* turbopackIgnore: true */
+            resolved,
+            "utf-8"
+          );
+          const importedPlayName = extractDefinedPlayName(importedSource);
+          if (!importedPlayName) {
+            throw new Error(
+              `${absolutePath}:${line}:${column} Imported play file "${specifier}" must export definePlay(...) so it can be runtime-composed.`
+            );
+          }
+          importedPlayDependencies.set(resolved, {
+            filePath: resolved,
+            playName: importedPlayName
+          });
+          return;
+        }
+        await visitFile(resolved);
+        return;
+      }
+      if (specifier.includes(":")) {
+        throw new Error(
+          `${absolutePath}:${line}:${column} Unsupported import specifier "${specifier}". Allowed imports are relative files, Node builtins, and installed packages.`
+        );
+      }
+      const packageImport = resolvePackageImport(
+        specifier,
+        absolutePath,
+        adapter
+      );
+      packages.set(packageImport.name, packageImport.version);
+    };
+    try {
+      for (const reference of findSourceImportReferences(sourceCode2)) {
+        await handleSpecifier(
+          reference.specifier,
+          reference.line,
+          reference.column,
+          reference.kind
+        );
+      }
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith(":")) {
+        throw new Error(`${absolutePath}${error.message}`);
+      }
+      throw error;
+    }
+  };
+  await visitFile(absoluteEntryFile);
+  const sourceCode = _nullishCoalesce(localFiles.get(absoluteEntryFile), () => ( ""));
+  const sourceHash = sha256(sourceCode);
+  const graphHash = sha256(
+    JSON.stringify({
+      entryFile: sourceIdentityPath(absoluteEntryFile, sourceIdentityRoot),
+      localFiles: [...localFiles.entries()].map(([filePath, contents]) => ({
+        filePath: sourceIdentityPath(filePath, sourceIdentityRoot),
+        hash: sha256(contents)
+      })).sort((left, right) => left.filePath.localeCompare(right.filePath)),
+      nodeBuiltins: [...nodeBuiltins].sort(),
+      packages: [...packages.entries()].map(([name, version]) => ({ name, version })).sort((left, right) => left.name.localeCompare(right.name)),
+      importedPlayDependencies: [...importedPlayDependencies.values()].map((dependency) => ({
+        filePath: sourceIdentityPath(dependency.filePath, sourceIdentityRoot),
+        playName: dependency.playName
+      })).sort((left, right) => left.filePath.localeCompare(right.filePath))
+    })
+  );
+  const metadata = _nullishCoalesce(extractDefinedPlayMetadata(sourceCode, exportName), () => ( (exportName === "default" ? extractDefinedPlayMetadata(sourceCode, null) : null)));
+  if (_optionalChain([metadata, 'optionalAccess', _83 => _83.toolErrorSchemaVersionUnknown])) {
+    throw new Error(
+      "definePlay compatibility.toolErrorSchemaVersion must be the static literal 0 or 1."
+    );
+  }
+  if (_optionalChain([metadata, 'optionalAccess', _84 => _84.toolResponseReceiptRevisionUnknown])) {
+    throw new Error(
+      "definePlay compatibility.toolResponseReceiptRevision must be a static non-empty string."
+    );
+  }
+  const playName = _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _85 => _85.name]), () => ( null));
+  const playDescription = _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _86 => _86.description]), () => ( null));
+  const sandboxRuntimeDeclaration = _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _87 => _87.sandboxRuntimeDeclaration]), () => ( null));
+  return {
+    sourceCode,
+    sourceFiles: Object.fromEntries(
+      [...localFiles.entries()].sort(
+        (left, right) => left[0].localeCompare(right[0])
+      )
+    ),
+    sourceHash,
+    graphHash,
+    importPolicy: {
+      localFiles: [...localFiles.keys()].sort(),
+      nodeBuiltins: [...nodeBuiltins].sort(),
+      packages: [...packages.entries()].map(([name, version]) => ({ name, version })).sort((left, right) => left.name.localeCompare(right.name))
+    },
+    playName,
+    playDescription,
+    sandboxRuntimeDeclaration,
+    toolErrorSchemaVersion: _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _88 => _88.toolErrorSchemaVersion]), () => ( null)),
+    toolResponseReceiptRevision: _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _89 => _89.toolResponseReceiptRevision]), () => ( null)),
+    importedPlayDependencies: [...importedPlayDependencies.values()].sort(
+      (left, right) => left.filePath.localeCompare(right.filePath)
+    )
+  };
+}
+function artifactCachePath(graphHash, artifactKind, adapter) {
+  return _path.join.call(void 0, 
+    /* turbopackIgnore: true */
+    _nullishCoalesce(adapter.cacheDir, () => ( PLAY_ARTIFACT_CACHE_DIR)),
+    `${graphHash}.${artifactKind}.json`
+  );
+}
+async function readArtifactCache(graphHash, artifactKind, adapter) {
+  if (adapter.cacheDir === null) return null;
+  try {
+    const serialized = await _promises.readFile.call(void 0, 
+      /* turbopackIgnore: true */
+      artifactCachePath(
+        graphHash,
+        artifactKind,
+        adapter
+      ),
+      "utf-8"
+    );
+    return JSON.parse(serialized);
+  } catch (e7) {
+    return null;
+  }
+}
+async function writeArtifactCache(artifact, adapter) {
+  if (adapter.cacheDir === null) return;
+  const cacheDir = _nullishCoalesce(adapter.cacheDir, () => ( PLAY_ARTIFACT_CACHE_DIR));
+  await _promises.mkdir.call(void 0, 
+    /* turbopackIgnore: true */
+    cacheDir,
+    { recursive: true }
+  );
+  await _promises.writeFile.call(void 0, 
+    /* turbopackIgnore: true */
+    artifactCachePath(
+      artifact.graphHash,
+      _nullishCoalesce(artifact.artifactKind, () => ( _chunk6A3TJUWCjs.PLAY_ARTIFACT_KINDS.cjsNode20)),
+      adapter
+    ),
+    JSON.stringify(artifact),
+    "utf-8"
+  );
+}
+function normalizeSourceMapForRuntime(sourceMapText, projectRoot) {
+  const parsed = JSON.parse(sourceMapText);
+  parsed.sources = (_nullishCoalesce(parsed.sources, () => ( []))).map((sourcePath) => {
+    if (sourcePath.startsWith("data:") || sourcePath.startsWith("node:") || sourcePath.startsWith("/") || /^[a-zA-Z]+:\/\//.test(sourcePath)) {
+      return sourcePath;
+    }
+    return _path.join.call(void 0, projectRoot, sourcePath);
+  });
+  parsed.sourceRoot = void 0;
+  return JSON.stringify(parsed);
+}
+function getBundleSizeErrorForBytes(filePath, bundleBytes, _artifactKind) {
+  if (bundleBytes > MAX_PLAY_BUNDLE_BYTES) {
+    return `${filePath} Play bundle exceeds the 30 MiB limit (${bundleBytes} bytes > ${MAX_PLAY_BUNDLE_BYTES} bytes).`;
+  }
+  return null;
+}
+function getBundleSizeError(filePath, bundledCode, artifactKind) {
+  return getBundleSizeErrorForBytes(
+    filePath,
+    Buffer.byteLength(bundledCode, "utf8"),
+    artifactKind
+  );
+}
+async function runEsbuildForCjsNode(entryFile, customerSourceFilePaths, 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 result = await _esbuild.build.call(void 0, {
+    ...namedExportShim ? {
+      stdin: {
+        contents: namedExportShim,
+        resolveDir: _path.dirname.call(void 0, entryFile),
+        sourcefile: `${_path.basename.call(void 0, entryFile)}.${exportName}.entry.ts`,
+        loader: "ts"
+      }
+    } : { entryPoints: [entryFile] },
+    // esbuild writes `// <path relative to absWorkingDir>` above every module
+    // it inlines, and artifactHash is sha256 of those bytes. Rooting the build
+    // at the identity root keeps the customer's own files repo-relative, so a
+    // deploy worker building the same commit in a fresh temp directory each
+    // time produces the same bytes. Files outside the root (the SDK on the
+    // worker image) come out as a `..`-prefixed path whose shape depends only
+    // on the image's layout, which is fixed, not on the build's name.
+    absWorkingDir: bundleRoot,
+    bundle: true,
+    format: "cjs",
+    nodePaths: [adapter.nodeModulesDir],
+    platform: "node",
+    target: ["node20"],
+    outfile: "play-artifact.cjs",
+    write: false,
+    sourcemap: "external",
+    sourcesContent: false,
+    logLevel: "silent",
+    legalComments: "none",
+    plugins: [docflowPlugin, sdkAliasPlugin, playProxyPlugin].filter(
+      (plugin) => plugin != null
+    )
+  });
+  const codeFile = _optionalChain([result, 'access', _90 => _90.outputFiles, 'optionalAccess', _91 => _91.find, 'call', _92 => _92((f) => f.path.endsWith(".cjs"))]);
+  const mapFile = _optionalChain([result, 'access', _93 => _93.outputFiles, 'optionalAccess', _94 => _94.find, 'call', _95 => _95((f) => f.path.endsWith(".cjs.map"))]);
+  if (!_optionalChain([codeFile, 'optionalAccess', _96 => _96.text]) || !_optionalChain([mapFile, 'optionalAccess', _97 => _97.text])) {
+    return ["Play bundling produced incomplete output."];
+  }
+  return {
+    bundledCode: codeFile.text,
+    sourceMapText: mapFile.text,
+    outputExtension: "cjs"
+  };
+}
+async function bundlePlayFile(filePath, options) {
+  const adapter = options.adapter;
+  const target = _nullishCoalesce(options.target, () => ( _chunk6A3TJUWCjs.PLAY_ARTIFACT_KINDS.cjsNode20));
+  const exportName = _optionalChain([options, 'access', _98 => _98.exportName, 'optionalAccess', _99 => _99.trim, 'call', _100 => _100()]) || "default";
+  assertValidExportName(exportName);
+  const absolutePath = await normalizeLocalPath(filePath);
+  const sourceIdentityRoot = adapter.sourceIdentityRoot;
+  _optionalChain([adapter, 'access', _101 => _101.warnAboutNonDevelopmentBundling, 'optionalCall', _102 => _102(absolutePath)]);
+  try {
+    const analysis = await analyzeSourceGraph(
+      absolutePath,
+      adapter,
+      exportName
+    );
+    analysis.graphHash = sha256(
+      `${analysis.graphHash}
+entry-export:${exportName}
+authoring-contract-edition:${_chunkZDO3TO3Mjs.PLAY_AUTHORING_CONTRACT_EDITION}`
+    );
+    const sourceFiles = Object.fromEntries(
+      Object.entries(analysis.sourceFiles).map(([sourcePath, sourceCode]) => [
+        sourceIdentityPath(sourcePath, sourceIdentityRoot),
+        sourceCode
+      ])
+    );
+    const importPolicy = {
+      ...analysis.importPolicy,
+      localFiles: analysis.importPolicy.localFiles.map(
+        (sourcePath) => sourceIdentityPath(sourcePath, sourceIdentityRoot)
+      )
+    };
+    const entryFile = sourceIdentityPath(absolutePath, sourceIdentityRoot);
+    try {
+      _chunk3KC45UVFjs.validatePlaySourceFilesHaveNoInlineSecrets.call(void 0, analysis.sourceFiles);
+    } catch (error) {
+      return {
+        success: false,
+        filePath: absolutePath,
+        errors: [error instanceof Error ? error.message : String(error)]
+      };
+    }
+    const typecheckErrors = [
+      ...await _asyncNullishCoalesce(await _optionalChain([adapter, 'access', _103 => _103.typecheckPlaySource, 'optionalCall', _104 => _104({
+        sourceCode: analysis.sourceCode,
+        sourcePath: absolutePath,
+        importedFilePaths: [
+          ...analysis.importPolicy.localFiles,
+          ...analysis.importedPlayDependencies.map(
+            (dependency) => dependency.filePath
+          )
+        ]
+      })]), async () => ( []))
+    ];
+    if (typecheckErrors.length > 0) {
+      return {
+        success: false,
+        filePath: absolutePath,
+        errors: typecheckErrors
+      };
+    }
+    const cachedArtifact = await readArtifactCache(
+      analysis.graphHash,
+      target,
+      adapter
+    );
+    const discoveredFiles = await adapter.discoverPackagedLocalFiles(absolutePath);
+    if (cachedArtifact) {
+      const cachedArtifactSizeError = getBundleSizeError(
+        absolutePath,
+        cachedArtifact.bundledCode,
+        target
+      );
+      if (cachedArtifactSizeError) {
+        return {
+          success: false,
+          filePath: absolutePath,
+          errors: [cachedArtifactSizeError]
+        };
+      }
+      return {
+        success: true,
+        artifact: {
+          ...cachedArtifact,
+          entryFile,
+          sourceHash: analysis.sourceHash,
+          importPolicy,
+          compatibility: buildPlayContractCompatibility({
+            toolErrorSchemaVersion: _nullishCoalesce(analysis.toolErrorSchemaVersion, () => ( void 0)),
+            toolResponseReceiptRevision: _nullishCoalesce(analysis.toolResponseReceiptRevision, () => ( void 0))
+          }),
+          cacheHit: true
+        },
+        sourceCode: analysis.sourceCode,
+        sourceFiles,
+        filePath: absolutePath,
+        playName: analysis.playName,
+        playDescription: analysis.playDescription,
+        sandboxRuntimeDeclaration: analysis.sandboxRuntimeDeclaration,
+        packagedFiles: discoveredFiles.files,
+        unresolvedFileReferences: discoveredFiles.unresolved,
+        importedPlayDependencies: analysis.importedPlayDependencies
+      };
+    }
+    const bundleRoot = _path.resolve.call(void 0, _nullishCoalesce(sourceIdentityRoot, () => ( adapter.projectRoot)));
+    const buildOutcome = await runEsbuildForCjsNode(
+      absolutePath,
+      analysis.importPolicy.localFiles,
+      analysis.importedPlayDependencies,
+      adapter,
+      exportName,
+      bundleRoot
+    );
+    if (Array.isArray(buildOutcome)) {
+      return {
+        success: false,
+        filePath: absolutePath,
+        errors: buildOutcome
+      };
+    }
+    const { bundledCode, sourceMapText, outputExtension } = buildOutcome;
+    const normalizedSourceMap = normalizeSourceMapForRuntime(
+      sourceMapText,
+      bundleRoot
+    );
+    const virtualBaseName = exportName === "default" ? _path.basename.call(void 0, absolutePath).replace(/\.[^.]+$/, "") : `${_path.basename.call(void 0, absolutePath).replace(/\.[^.]+$/, "")}.${exportName}`;
+    const virtualFilename = `/virtual/deepline-plays/${analysis.graphHash}/${virtualBaseName}.${outputExtension}`;
+    const executableCode = `${bundledCode}
+//# sourceMappingURL=${_path.basename.call(void 0, virtualFilename)}.map
+`;
+    const bundleSizeError = getBundleSizeError(
+      absolutePath,
+      executableCode,
+      target
+    );
+    if (bundleSizeError) {
+      return {
+        success: false,
+        filePath: absolutePath,
+        errors: [bundleSizeError]
+      };
+    }
+    const artifact = {
+      codeFormat: "cjs_module",
+      artifactKind: target,
+      entryFile,
+      virtualFilename,
+      sourceHash: analysis.sourceHash,
+      graphHash: analysis.graphHash,
+      artifactHash: sha256(executableCode),
+      sourceMapHash: sha256(normalizedSourceMap),
+      bundledCode: executableCode,
+      sourceMap: normalizedSourceMap,
+      importPolicy,
+      compatibility: buildPlayContractCompatibility({
+        toolErrorSchemaVersion: _nullishCoalesce(analysis.toolErrorSchemaVersion, () => ( void 0)),
+        toolResponseReceiptRevision: _nullishCoalesce(analysis.toolResponseReceiptRevision, () => ( void 0))
+      }),
+      generatedAt: Date.now(),
+      cacheHit: false
+    };
+    try {
+      await writeArtifactCache(artifact, adapter);
+    } catch (error) {
+      console.warn(
+        "Play artifact cache write failed; continuing without a disk cache.",
+        error
+      );
+    }
+    return {
+      success: true,
+      artifact,
+      sourceCode: analysis.sourceCode,
+      sourceFiles,
+      filePath: absolutePath,
+      playName: analysis.playName,
+      playDescription: analysis.playDescription,
+      sandboxRuntimeDeclaration: analysis.sandboxRuntimeDeclaration,
+      packagedFiles: discoveredFiles.files,
+      unresolvedFileReferences: discoveredFiles.unresolved,
+      importedPlayDependencies: analysis.importedPlayDependencies
+    };
+  } catch (error) {
+    if (error && typeof error === "object" && "errors" in error) {
+      const errors = Array.isArray(error.errors) ? error.errors.map(formatEsbuildMessage) : ["Play bundling failed."];
+      return {
+        success: false,
+        filePath: absolutePath,
+        errors
+      };
+    }
+    return {
+      success: false,
+      filePath: absolutePath,
+      errors: [error instanceof Error ? error.message : String(error)]
+    };
+  }
+}
+
+// ../play-runtime/scheduler-backend.ts
+var PLAY_SCHEDULER_BACKENDS = {
+  /**
+   * Postgres-native durable-execution scheduler (vendored Absurd engine). Runs
+   * on the battle-tested run-state store without an external workflow engine.
+   * Selected explicitly by the `absurd` profile.
+   */
+  absurd: "absurd",
+  inProcess: "in-process"
+};
+
+// ../play-runtime/providers.ts
+var PLAY_RUNTIME_PROVIDER_IDS = {
+  absurd: "absurd"
+};
+var PLAY_RUNTIME_PROVIDERS = {
+  absurd: {
+    id: PLAY_RUNTIME_PROVIDER_IDS.absurd,
+    scheduler: PLAY_SCHEDULER_BACKENDS.absurd,
+    // Server runs execute on Daytona; the local-dev/test shape swaps the runner
+    // axis to local_process (same as the local profile) via an explicit
+    // runtimeBackend override at submit while tests drive local_process.
+    runner: _chunk6A3TJUWCjs.PLAY_RUNTIME_BACKENDS.daytona,
+    artifactKind: _chunk6A3TJUWCjs.PLAY_ARTIFACT_KINDS.cjsNode20,
+    label: "Absurd (Postgres-native durable) scheduler + one-shot Daytona runner"
+  }
+};
+function defaultPlayRuntimeProvider() {
+  return PLAY_RUNTIME_PROVIDERS.absurd;
+}
+function resolvePlayRuntimeProvider(override) {
+  if (_optionalChain([override, 'optionalAccess', _105 => _105.trim, 'call', _106 => _106()])) {
+    const id = override.trim();
+    if (id in PLAY_RUNTIME_PROVIDERS) {
+      return PLAY_RUNTIME_PROVIDERS[id];
+    }
+    throw new Error(
+      `Unsupported play runtime provider "${id}". Expected one of: ${Object.keys(
+        PLAY_RUNTIME_PROVIDERS
+      ).join(", ")}.`
+    );
+  }
+  return defaultPlayRuntimeProvider();
+}
+function resolveEnabledPlayRuntimeProvider(override) {
+  return resolvePlayRuntimeProvider(override);
+}
+
+// ../play-runtime/profiles.ts
+var PLAY_EXECUTION_PROFILE_IDS = {
+  ...PLAY_RUNTIME_PROVIDER_IDS
+};
+var PLAY_EXECUTION_PROFILES = PLAY_RUNTIME_PROVIDERS;
+function resolveExecutionProfile(override) {
+  try {
+    return resolvePlayRuntimeProvider(override);
+  } catch (error) {
+    if (_optionalChain([override, 'optionalAccess', _107 => _107.trim, 'call', _108 => _108()])) {
+      throw new Error(
+        `Unknown execution profile "${override.trim()}". Expected one of: ${Object.keys(
+          PLAY_EXECUTION_PROFILES
+        ).join(", ")}.`
+      );
+    }
+    throw error;
+  }
+}
+function resolveEnabledExecutionProfile(override) {
+  try {
+    return resolveEnabledPlayRuntimeProvider(override);
+  } catch (error) {
+    if (_optionalChain([override, 'optionalAccess', _109 => _109.trim, 'call', _110 => _110()]) && 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
+        ).join(", ")}.`
+      );
+    }
+    throw error;
+  }
+}
+
+// src/plays/local-file-discovery.ts
+
+
+
+
+
+
+
+
+
+
+
+var SOURCE_EXTENSIONS2 = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".json"
+];
+var TEXT_IMPORT_EXTENSIONS2 = /* @__PURE__ */ new Set([".md", ".txt"]);
+var EXPLICIT_IMPORT_EXTENSIONS2 = /* @__PURE__ */ new Set([
+  ...SOURCE_EXTENSIONS2,
+  ...TEXT_IMPORT_EXTENSIONS2
+]);
+function isTextImportFile2(filePath) {
+  return TEXT_IMPORT_EXTENSIONS2.has(_path.extname.call(void 0, filePath));
+}
+function sha2562(buffer) {
+  return _crypto.createHash.call(void 0, "sha256").update(buffer).digest("hex");
+}
+function contentTypeForFile(filePath) {
+  const extension = _path.extname.call(void 0, filePath).toLowerCase();
+  if (extension === ".csv") return "text/csv";
+  if (extension === ".json") return "application/json";
+  if (extension === ".txt") return "text/plain";
+  return "application/octet-stream";
+}
+function stripCommentsToSpaces2(source) {
+  return source.replace(/\/\*[\s\S]*?\*\//g, (match) => match.replace(/[^\n]/g, " ")).replace(
+    /(^|[^:])\/\/.*$/gm,
+    (match, prefix) => prefix + " ".repeat(Math.max(0, match.length - prefix.length))
+  );
+}
+function unquoteStringLiteral(literal) {
+  const trimmed = literal.trim();
+  const quote = trimmed[0];
+  if (quote !== '"' && quote !== "'" || trimmed[trimmed.length - 1] !== quote) {
+    return null;
+  }
+  try {
+    return JSON.parse(
+      quote === '"' ? trimmed : `"${trimmed.slice(1, -1).replace(/"/g, '\\"')}"`
+    );
+  } catch (e8) {
+    return trimmed.slice(1, -1);
+  }
+}
+function splitTopLevelPlus(expression) {
+  const parts = [];
+  let start = 0;
+  let depth = 0;
+  let quote = null;
+  let escaped = false;
+  for (let index = 0; index < expression.length; index += 1) {
+    const char = expression[index];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "(" || char === "[" || char === "{") depth += 1;
+    if (char === ")" || char === "]" || char === "}") depth -= 1;
+    if (char === "+" && depth === 0) {
+      parts.push(expression.slice(start, index));
+      start = index + 1;
+    }
+  }
+  if (parts.length === 0) return null;
+  parts.push(expression.slice(start));
+  return parts;
+}
+function stripOuterParens(expression) {
+  let value = expression.trim();
+  while (value.startsWith("(") && value.endsWith(")")) {
+    value = value.slice(1, -1).trim();
+  }
+  return value;
+}
+function isRuntimeInputExpression(expression) {
+  return /(^|[^\w$])input([^\w$]|$)/.test(expression);
+}
+function resolveStringExpression(expression, constants) {
+  const value = stripOuterParens(expression);
+  if (/^(['"])(?:\\.|(?!\1)[\s\S])*\1$/.test(value)) {
+    return unquoteStringLiteral(value);
+  }
+  if (/^`(?:\\.|[^`$]|\$(?!\{))*`$/.test(value)) {
+    return value.slice(1, -1);
+  }
+  if (/^[A-Za-z_$][\w$]*$/.test(value)) {
+    return _nullishCoalesce(constants.get(value), () => ( null));
+  }
+  const parts = splitTopLevelPlus(value);
+  if (parts) {
+    const resolved = parts.map(
+      (part) => resolveStringExpression(part, constants)
+    );
+    return resolved.every((part) => part != null) ? resolved.join("") : null;
+  }
+  return null;
+}
+function collectTopLevelStringConstants(sourceCode) {
+  const constants = /* @__PURE__ */ new Map();
+  const source = stripCommentsToSpaces2(sourceCode);
+  for (const match of source.matchAll(
+    /(?:^|\n)\s*const\s+([A-Za-z_$][\w$]*)\s*=\s*([^;\n]+)/g
+  )) {
+    const resolved = resolveStringExpression(match[2], constants);
+    if (resolved != null) {
+      constants.set(match[1], resolved);
+    }
+  }
+  return constants;
+}
+function findMatchingGenericEnd(source, openIndex) {
+  let depth = 0;
+  let quote = null;
+  let escaped = false;
+  for (let index = openIndex; index < source.length; index += 1) {
+    const char = source[index];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "<") depth += 1;
+    if (char === ">") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+function findCallOpenParen(source, afterCsvIndex) {
+  let index = afterCsvIndex;
+  while (/\s/.test(_nullishCoalesce(source[index], () => ( "")))) index += 1;
+  if (source[index] === "<") {
+    const genericEnd = findMatchingGenericEnd(source, index);
+    if (genericEnd < 0) return -1;
+    index = genericEnd + 1;
+    while (/\s/.test(_nullishCoalesce(source[index], () => ( "")))) index += 1;
+  }
+  return source[index] === "(" ? index : -1;
+}
+function firstCallArgument(source, openParen) {
+  let depth = 0;
+  let quote = null;
+  let escaped = false;
+  const start = openParen + 1;
+  for (let index = start; index < source.length; index += 1) {
+    const char = source[index];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "(" || char === "[" || char === "{") depth += 1;
+    if (char === ")" && depth === 0) {
+      const text = source.slice(start, index).trim();
+      return text ? { text, start, end: index } : null;
+    }
+    if (char === "," && depth === 0) {
+      const text = source.slice(start, index).trim();
+      return text ? { text, start, end: index } : null;
+    }
+    if (char === ")" || char === "]" || char === "}") depth -= 1;
+  }
+  return null;
+}
+function localImportSpecifiers(sourceCode) {
+  const source = stripCommentsToSpaces2(sourceCode);
+  const specifiers = [];
+  for (const match of source.matchAll(
+    /\b(?:import|export)\s+(?!type\b)(?:[\s\S]*?\s+from\s*)?['"]([^'"]+)['"]/g
+  )) {
+    if (_optionalChain([match, 'access', _111 => _111[1], 'optionalAccess', _112 => _112.startsWith, 'call', _113 => _113(".")])) specifiers.push(match[1]);
+  }
+  for (const match of source.matchAll(
+    /\brequire\s*\(\s*(['"])(\.[^'"]*)\1\s*\)/g
+  )) {
+    specifiers.push(match[2]);
+  }
+  return specifiers;
+}
+async function fileExists2(filePath) {
+  try {
+    await _promises.stat.call(void 0, filePath);
+    return true;
+  } catch (e9) {
+    return false;
+  }
+}
+function isPathInsideDirectory2(filePath, directory) {
+  const relativePath = _path.relative.call(void 0, directory, filePath);
+  return relativePath === "" || !relativePath.startsWith("..") && !_path.isAbsolute.call(void 0, relativePath);
+}
+async function resolveLocalImport2(fromFile, specifier) {
+  const base = _path.isAbsolute.call(void 0, specifier) ? _path.resolve.call(void 0, specifier) : _path.resolve.call(void 0, _path.dirname.call(void 0, fromFile), specifier);
+  const candidates = [base];
+  const explicitExtension = _path.extname.call(void 0, base).toLowerCase();
+  if ([".js", ".jsx", ".mjs", ".cjs"].includes(explicitExtension)) {
+    const stem = base.slice(0, -explicitExtension.length);
+    candidates.push(
+      ...SOURCE_EXTENSIONS2.map((extension) => `${stem}${extension}`)
+    );
+  } else if (!EXPLICIT_IMPORT_EXTENSIONS2.has(explicitExtension)) {
+    candidates.push(
+      ...SOURCE_EXTENSIONS2.map((extension) => `${base}${extension}`)
+    );
+    candidates.push(
+      ...SOURCE_EXTENSIONS2.map((extension) => _path.join.call(void 0, base, `index${extension}`))
+    );
+  }
+  for (const candidate of candidates) {
+    if (await fileExists2(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    `Could not resolve local import "${specifier}" from ${fromFile}`
+  );
+}
+async function discoverPackagedLocalFiles(entryFile) {
+  const absoluteEntryFile = _path.resolve.call(void 0, entryFile);
+  const packagingRoot = _path.dirname.call(void 0, absoluteEntryFile);
+  const files = /* @__PURE__ */ new Map();
+  const unresolved = [];
+  const visitedFiles = /* @__PURE__ */ new Set();
+  const visitSourceFile = async (filePath) => {
+    const absolutePath = _path.resolve.call(void 0, filePath);
+    if (visitedFiles.has(absolutePath)) {
+      return;
+    }
+    visitedFiles.add(absolutePath);
+    const sourceCode = 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 childVisits = [];
+    for (const match of scanSource.matchAll(
+      /\b([A-Za-z_$][\w$]*)\s*\.\s*csv\b/g
+    )) {
+      const target = match[1];
+      if (target !== "ctx" && !target.endsWith("Ctx")) {
+        continue;
+      }
+      const openParen = findCallOpenParen(
+        scanSource,
+        match.index + match[0].length
+      );
+      if (openParen < 0) {
+        continue;
+      }
+      const argument = firstCallArgument(scanSource, openParen);
+      if (!argument) {
+        unresolved.push({
+          sourceFragment: "ctx.csv()",
+          message: "ctx.csv() requires a file path string or input reference."
+        });
+      } else if (!isRuntimeInputExpression(argument.text)) {
+        const resolvedPath = resolveStringExpression(argument.text, constants);
+        if (resolvedPath == null) {
+          unresolved.push({
+            sourceFragment: sourceCode.slice(argument.start, argument.end).trim(),
+            message: "Could not resolve this ctx.csv(...) path at submit time. Use a string literal, a top-level const string, or pass a runtime input like input.file."
+          });
+        } else {
+          const absoluteCsvPath = _path.resolve.call(void 0, _path.dirname.call(void 0, absolutePath), resolvedPath);
+          if (_path.isAbsolute.call(void 0, resolvedPath) || !isPathInsideDirectory2(absoluteCsvPath, packagingRoot)) {
+            unresolved.push({
+              sourceFragment: sourceCode.slice(argument.start, argument.end).trim(),
+              message: "ctx.csv(...) packaged file paths must be relative paths inside the play directory. Pass external files at runtime with input.file instead."
+            });
+            continue;
+          }
+          const buffer = await _promises.readFile.call(void 0, absoluteCsvPath);
+          const stats = await _promises.stat.call(void 0, absoluteCsvPath);
+          files.set(absoluteCsvPath, {
+            sourceFragment: sourceCode.slice(argument.start, argument.end).trim(),
+            logicalPath: resolvedPath,
+            absolutePath: absoluteCsvPath,
+            bytes: stats.size,
+            contentHash: sha2562(buffer),
+            contentType: contentTypeForFile(absoluteCsvPath)
+          });
+        }
+      }
+    }
+    for (const specifier of localImportSpecifiers(sourceCode)) {
+      childVisits.push(
+        resolveLocalImport2(absolutePath, specifier).then(
+          (resolvedImport) => visitSourceFile(resolvedImport)
+        )
+      );
+    }
+    await Promise.all(childVisits);
+  };
+  await visitSourceFile(absoluteEntryFile);
+  return {
+    files: [...files.values()],
+    unresolved
+  };
+}
+
+// src/plays/bundle-play-file.ts
+var MODULE_DIR = _path.dirname.call(void 0, _url.fileURLToPath.call(void 0, import.meta.url));
+var SDK_PACKAGE_ROOT = _path.resolve.call(void 0, MODULE_DIR, "..", "..");
+var SOURCE_REPO_ROOT = _path.resolve.call(void 0, SDK_PACKAGE_ROOT, "..", "..");
+var HAS_SOURCE_BUNDLING_SOURCES = _fs.existsSync.call(void 0, 
+  _path.resolve.call(void 0, SOURCE_REPO_ROOT, "packages", "plays", "bundling", "index.ts")
+);
+var PACKAGED_BUNDLING_SOURCE_ROOT = _path.resolve.call(void 0, 
+  SDK_PACKAGE_ROOT,
+  "dist",
+  "bundling-sources"
+);
+var HAS_PACKAGED_BUNDLING_SOURCES = _fs.existsSync.call(void 0, 
+  _path.resolve.call(void 0, 
+    PACKAGED_BUNDLING_SOURCE_ROOT,
+    "shared_libs",
+    "plays",
+    "bundling",
+    "index.ts"
+  )
+);
+var PROJECT_ROOT = HAS_SOURCE_BUNDLING_SOURCES ? SOURCE_REPO_ROOT : HAS_PACKAGED_BUNDLING_SOURCES ? PACKAGED_BUNDLING_SOURCE_ROOT : _path.resolve.call(void 0, SDK_PACKAGE_ROOT, "..");
+var SDK_SOURCE_ROOT = HAS_SOURCE_BUNDLING_SOURCES ? _path.resolve.call(void 0, SDK_PACKAGE_ROOT, "src") : HAS_PACKAGED_BUNDLING_SOURCES ? _path.resolve.call(void 0, PACKAGED_BUNDLING_SOURCE_ROOT, "sdk", "src") : _path.resolve.call(void 0, SDK_PACKAGE_ROOT, "src");
+var SDK_PACKAGE_JSON = _path.resolve.call(void 0, SDK_PACKAGE_ROOT, "package.json");
+var SDK_ENTRY_FILE = _path.resolve.call(void 0, SDK_SOURCE_ROOT, "index.ts");
+var SDK_TYPES_ENTRY_FILE = HAS_SOURCE_BUNDLING_SOURCES ? SDK_ENTRY_FILE : _path.resolve.call(void 0, SDK_PACKAGE_ROOT, "dist", "index.d.ts");
+var hasWarnedAboutNonDevelopmentBundling = false;
+function warnAboutNonDevelopmentBundling(filePath) {
+  if (hasWarnedAboutNonDevelopmentBundling) {
+    return;
+  }
+  const nodeEnv = String(_nullishCoalesce(process.env.NODE_ENV, () => ( ""))).trim().toLowerCase();
+  if (!nodeEnv || nodeEnv === "development" || nodeEnv === "test") {
+    return;
+  }
+  hasWarnedAboutNonDevelopmentBundling = true;
+  console.warn(
+    `[deepline] Warning: live play bundling was invoked while NODE_ENV=${nodeEnv} for ${filePath}. This source-first SDK path is intended for local development. For preview/production, run a published or prebuilt play reference instead of bundling source at runtime.`
+  );
+  console.warn(
+    '[deepline] Preferred production call pattern: client.play("person-to-email").run(...) or run a previously registered/published org play.'
+  );
+}
+function defaultPlayBundleTarget() {
+  return resolveExecutionProfile(null).artifactKind;
+}
+function createSdkPlayBundlingAdapter() {
+  return {
+    projectRoot: PROJECT_ROOT,
+    nodeModulesDir: HAS_PACKAGED_BUNDLING_SOURCES ? _path.resolve.call(void 0, SDK_PACKAGE_ROOT, "node_modules") : _path.resolve.call(void 0, PROJECT_ROOT, "node_modules"),
+    cacheDir: _path.join.call(void 0, _os.tmpdir.call(void 0, ), PLAY_BUNDLE_CACHE_NAMESPACE),
+    sdkSourceRoot: SDK_SOURCE_ROOT,
+    sdkPackageJson: SDK_PACKAGE_JSON,
+    sdkEntryFile: SDK_ENTRY_FILE,
+    sdkTypesEntryFile: HAS_SOURCE_BUNDLING_SOURCES || !_fs.existsSync.call(void 0, SDK_TYPES_ENTRY_FILE) ? SDK_ENTRY_FILE : SDK_TYPES_ENTRY_FILE,
+    discoverPackagedLocalFiles,
+    warnAboutNonDevelopmentBundling
+  };
+}
+async function bundlePlayFile2(filePath, options = {}) {
+  const localWorkspaceRoot = _path.dirname.call(void 0, _path.resolve.call(void 0, filePath));
+  const sourceIdentityRoot = await _promises.realpath.call(void 0, localWorkspaceRoot).catch(
+    () => localWorkspaceRoot
+  );
+  const result = await bundlePlayFile(filePath, {
+    target: _nullishCoalesce(options.target, () => ( defaultPlayBundleTarget())),
+    exportName: options.exportName,
+    adapter: {
+      ...createSdkPlayBundlingAdapter(),
+      sourceIdentityRoot
+    }
+  });
+  if (result.success)
+    _chunk3KC45UVFjs.validatePlaySourceFilesHaveNoInlineSecrets.call(void 0, result.sourceFiles);
+  return result;
+}
+async function bundleDeployPlayFile(entryFile, options) {
+  return bundlePlayFile(entryFile, {
+    target: _chunk6A3TJUWCjs.PLAY_ARTIFACT_KINDS.cjsNode20,
+    adapter: {
+      ...createSdkPlayBundlingAdapter(),
+      sourceIdentityRoot: options.sourceIdentityRoot,
+      // CI commonly runs with NODE_ENV=production; a deploy bundles by design.
+      warnAboutNonDevelopmentBundling: void 0
+    }
+  });
+}
+
+
+
+
+
+
+
+
+
+
+
+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;