react-agentic 0.0.1

package/dist/index.js

@@ -0,0 +1,2800 @@
+import {
+  RuntimeMarkdownEmitter,
+  TranspileError,
+  buildRuntimeFile,
+  bundleCodeSplit,
+  bundleSingleEntryRuntime,
+  createProject,
+  createRuntimeContext,
+  detectRuntime,
+  emit,
+  emitAgent,
+  emitDocument,
+  emitRuntime,
+  emitSettings,
+  emitSkill,
+  emitSkillFile,
+  extractExportedFunctionNames,
+  extractExternalComponentDeclarations,
+  extractFunctions,
+  extractInlineText,
+  extractInputObjectLiteral,
+  extractInterfaceProperties,
+  extractLocalComponentDeclarations,
+  extractPromptPlaceholders,
+  extractRuntimeFnDeclarations,
+  extractRuntimeVarDeclarations,
+  extractText,
+  extractTypeArguments,
+  extractVariableDeclarations,
+  findRootJsxElement,
+  generateRuntime,
+  getArrayAttributeValue,
+  getAttributeValue,
+  getElementName,
+  getJsxChildren,
+  getNodeLocation,
+  getRuntimeFunctionNames,
+  getRuntimeImportPaths,
+  getSourceCode,
+  hasRuntimeImports,
+  init_parser,
+  init_project,
+  isRuntimeFile,
+  isWhitespaceOnlyText,
+  mergeSettings,
+  normalizeWhitespace,
+  parseFile,
+  parseSource,
+  resolveComponentImport,
+  resolveSpreadAttribute,
+  resolveTypeImport,
+  transformAgent,
+  transformMCPConfig,
+  transformRuntimeBlockChildren,
+  transformRuntimeCommand,
+  transformSkill,
+  transformState,
+  transformToRuntimeBlock
+} from "./chunk-263OAOFB.js";
+import "./chunk-OO3V32L6.js";
+
+// src/components/markdown.ts
+function Markdown(_props) {
+  return null;
+}
+function XmlBlock(_props) {
+  return null;
+}
+function Indent(_props) {
+  return null;
+}
+
+// src/components/structured.ts
+function Table(_props) {
+  return null;
+}
+function List(_props) {
+  return null;
+}
+
+// src/components/Command.ts
+function Command(_props) {
+  return null;
+}
+
+// src/components/Agent.ts
+function defineAgent(config) {
+  return {
+    name: config.name,
+    path: config.path,
+    __isAgentRef: true
+  };
+}
+function isAgentRef(value) {
+  if (!value || typeof value !== "object") return false;
+  return value.__isAgentRef === true;
+}
+function getAgentName(agent) {
+  return isAgentRef(agent) ? agent.name : agent;
+}
+function getAgentPath(agent) {
+  return isAgentRef(agent) ? agent.path : void 0;
+}
+function useOutput(agent) {
+  return {
+    agent,
+    field: (name) => `{${agent}.${String(name)}}`
+  };
+}
+function Agent(_props) {
+  return null;
+}
+function SpawnAgent(_props) {
+  return null;
+}
+function OnStatus(_props) {
+  return null;
+}
+
+// src/components/runtime-var.ts
+var RUNTIME_VAR_MARKER = /* @__PURE__ */ Symbol.for("react-agentic:runtime-var");
+function createRuntimeVarProxy(varName, path) {
+  const target = {
+    __varName: varName,
+    __path: path,
+    [RUNTIME_VAR_MARKER]: true
+  };
+  return new Proxy(target, {
+    get(_target, prop) {
+      if (prop === "__varName") return varName;
+      if (prop === "__path") return path;
+      if (prop === RUNTIME_VAR_MARKER) return true;
+      if (typeof prop === "symbol") return void 0;
+      return createRuntimeVarProxy(varName, [...path, prop]);
+    }
+  });
+}
+function useRuntimeVar(name) {
+  return createRuntimeVarProxy(name, []);
+}
+function isRuntimeVar(value) {
+  if (!value || typeof value !== "object") return false;
+  return value[RUNTIME_VAR_MARKER] === true;
+}
+function getRuntimeVarInfo(runtimeVar) {
+  return {
+    varName: runtimeVar.__varName,
+    path: runtimeVar.__path
+  };
+}
+function toJqExpression(runtimeVar) {
+  const { varName, path } = getRuntimeVarInfo(runtimeVar);
+  const jqPath = path.length === 0 ? "." : "." + path.join(".");
+  return `$(echo "$${varName}" | jq -r '${jqPath}')`;
+}
+function toJqPath(runtimeVar) {
+  const { path } = getRuntimeVarInfo(runtimeVar);
+  return path.length === 0 ? "." : "." + path.join(".");
+}
+
+// src/components/runtime-fn.ts
+var RUNTIME_FN_MARKER = /* @__PURE__ */ Symbol.for("react-agentic:runtime-fn");
+var runtimeFnRegistry = /* @__PURE__ */ new Map();
+function runtimeFn(fn) {
+  const fnName = fn.name;
+  if (!fnName) {
+    throw new Error(
+      "runtimeFn requires a named function. Anonymous functions cannot be extracted to runtime.js."
+    );
+  }
+  runtimeFnRegistry.set(fnName, fn);
+  const Call = (_props) => {
+    return null;
+  };
+  const wrapper = {
+    Call,
+    fnName,
+    fn,
+    __isRuntimeFn: true,
+    [RUNTIME_FN_MARKER]: true
+  };
+  return wrapper;
+}
+function isRuntimeFn(value) {
+  if (!value || typeof value !== "object") return false;
+  return value.__isRuntimeFn === true;
+}
+function getRuntimeFnRegistry() {
+  return new Map(runtimeFnRegistry);
+}
+function clearRuntimeFnRegistry() {
+  runtimeFnRegistry.clear();
+}
+function getRuntimeFn(name) {
+  return runtimeFnRegistry.get(name);
+}
+
+// src/components/control.ts
+function If(_props) {
+  return null;
+}
+function Else(_props) {
+  return null;
+}
+function Loop(_props) {
+  return null;
+}
+function Break(_props) {
+  return null;
+}
+function Return(_props) {
+  return null;
+}
+var IF_MARKER = /* @__PURE__ */ Symbol.for("react-agentic:if");
+var ELSE_MARKER = /* @__PURE__ */ Symbol.for("react-agentic:else");
+var LOOP_MARKER = /* @__PURE__ */ Symbol.for("react-agentic:loop");
+var BREAK_MARKER = /* @__PURE__ */ Symbol.for("react-agentic:break");
+var RETURN_MARKER = /* @__PURE__ */ Symbol.for("react-agentic:return");
+Object.defineProperty(If, IF_MARKER, { value: true });
+Object.defineProperty(Else, ELSE_MARKER, { value: true });
+Object.defineProperty(Loop, LOOP_MARKER, { value: true });
+Object.defineProperty(Break, BREAK_MARKER, { value: true });
+Object.defineProperty(Return, RETURN_MARKER, { value: true });
+
+// src/components/ask-user.ts
+function AskUser(_props) {
+  return null;
+}
+var ASK_USER_MARKER = /* @__PURE__ */ Symbol.for("react-agentic:ask-user");
+Object.defineProperty(AskUser, ASK_USER_MARKER, { value: true });
+
+// src/ir/nodes.ts
+function assertNever(x) {
+  throw new Error(`Unexpected node: ${JSON.stringify(x)}`);
+}
+
+// src/ir/runtime-nodes.ts
+function isRuntimeNode(node) {
+  if (!node || typeof node !== "object") return false;
+  const kind = node.kind;
+  return [
+    "runtimeVarDecl",
+    "runtimeCall",
+    "if",
+    "else",
+    "loop",
+    "break",
+    "return",
+    "askUser",
+    "spawnAgent"
+  ].includes(kind ?? "");
+}
+function isDocument(node) {
+  if (!node || typeof node !== "object") return false;
+  return node.kind === "document";
+}
+
+// src/index.ts
+init_project();
+
+// src/parser/index.ts
+init_parser();
+
+// src/parser/transformer.ts
+import {
+  Node
+} from "ts-morph";
+init_parser();
+function toSnakeCase(name) {
+  return name.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+var HTML_ELEMENTS = /* @__PURE__ */ new Set([
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "p",
+  "div",
+  "span",
+  "ul",
+  "ol",
+  "li",
+  "a",
+  "b",
+  "i",
+  "strong",
+  "em",
+  "code",
+  "pre",
+  "blockquote",
+  "br",
+  "hr"
+]);
+var INLINE_ELEMENTS = /* @__PURE__ */ new Set([
+  "a",
+  "b",
+  "i",
+  "strong",
+  "em",
+  "code",
+  "span",
+  "br"
+]);
+function isInlineElement(tagName) {
+  return INLINE_ELEMENTS.has(tagName);
+}
+var SPECIAL_COMPONENTS = /* @__PURE__ */ new Set([
+  "Command",
+  "Markdown",
+  "XmlBlock",
+  "Agent",
+  "SpawnAgent",
+  "Assign",
+  "AssignGroup",
+  "If",
+  "Else",
+  "Loop",
+  "OnStatus",
+  "Skill",
+  "SkillFile",
+  "SkillStatic",
+  "ReadState",
+  "WriteState",
+  "MCPServer",
+  "MCPStdioServer",
+  "MCPHTTPServer",
+  "MCPConfig",
+  "State",
+  "Operation",
+  "Table",
+  "List",
+  // Semantic workflow components
+  "ExecutionContext",
+  "SuccessCriteria",
+  "OfferNext",
+  "XmlSection",
+  "DeviationRules",
+  "CommitRules",
+  "WaveExecution",
+  "CheckpointHandling",
+  // Step workflow primitive
+  "Step",
+  // Code block primitives
+  "Bash",
+  // File reading
+  "ReadFiles",
+  // Template primitives
+  "PromptTemplate"
+]);
+function isCustomComponent(tagName) {
+  if (HTML_ELEMENTS.has(tagName)) return false;
+  if (SPECIAL_COMPONENTS.has(tagName)) return false;
+  return /^[A-Z]/.test(tagName);
+}
+var XML_NAME_REGEX = /^[a-zA-Z_][a-zA-Z0-9_.\-]*$/;
+function isValidXmlName(name) {
+  if (!name) return false;
+  if (!XML_NAME_REGEX.test(name)) return false;
+  if (name.toLowerCase().startsWith("xml")) return false;
+  return true;
+}
+var Transformer = class {
+  /** Source file for component resolution (optional - only needed for composition) */
+  sourceFile;
+  /** Visited paths for circular import detection */
+  visitedPaths = /* @__PURE__ */ new Set();
+  /** Extracted useVariable declarations from source file */
+  variables = /* @__PURE__ */ new Map();
+  /** Extracted useOutput declarations: identifier name -> agent name */
+  outputs = /* @__PURE__ */ new Map();
+  /** Extracted useStateRef declarations: identifier name -> state key */
+  stateRefs = /* @__PURE__ */ new Map();
+  /** Current render props context for interpolation (set during Command/Agent transformation) */
+  renderPropsContext;
+  /**
+   * Create a TranspileError with source location context from a node
+   */
+  createError(message, node) {
+    const location = getNodeLocation(node);
+    const sourceCode = getSourceCode(node.getSourceFile());
+    return new TranspileError(message, location, sourceCode);
+  }
+  /**
+   * Build a TransformContext from instance state for delegation to document transformers
+   */
+  buildContext() {
+    return {
+      sourceFile: this.sourceFile,
+      visitedPaths: this.visitedPaths,
+      variables: this.variables,
+      outputs: this.outputs,
+      stateRefs: this.stateRefs,
+      renderPropsContext: this.renderPropsContext,
+      createError: this.createError.bind(this),
+      // Provide V1 transformBlockChildren - ignores ctx since we use instance state
+      transformBlockChildren: (children, _ctx) => this.transformBlockChildren(children)
+    };
+  }
+  /**
+   * Transform a root JSX element/fragment into AgentDocumentNode, SkillDocumentNode, MCPConfigDocumentNode, or StateDocumentNode
+   *
+   * Note: Command documents use the runtime transformer (transformRuntimeCommand) for runtime feature support.
+   *
+   * @param node - The root JSX element/fragment to transform
+   * @param sourceFile - Optional source file for component composition resolution
+   */
+  transform(node, sourceFile) {
+    this.sourceFile = sourceFile;
+    this.visitedPaths = /* @__PURE__ */ new Set();
+    this.variables = /* @__PURE__ */ new Map();
+    this.outputs = /* @__PURE__ */ new Map();
+    this.stateRefs = /* @__PURE__ */ new Map();
+    if (sourceFile) {
+      this.visitedPaths.add(sourceFile.getFilePath());
+      this.variables = extractVariableDeclarations(sourceFile);
+      this.outputs = this.extractOutputDeclarations(sourceFile);
+      this.stateRefs = this.extractStateRefDeclarations(sourceFile);
+    }
+    if (Node.isJsxElement(node) || Node.isJsxSelfClosingElement(node)) {
+      const name = getElementName(node);
+      if (name === "Command") {
+        return this.transformCommand(node);
+      }
+      if (name === "Agent") {
+        return this.transformAgent(node);
+      }
+      if (name === "Skill") {
+        return this.transformSkill(node);
+      }
+      if (name === "MCPConfig") {
+        return this.transformMCPConfig(node);
+      }
+      if (name === "State") {
+        return this.transformState(node);
+      }
+    }
+    if (Node.isJsxFragment(node)) {
+      throw new Error(
+        "JSX Fragment not supported. Use a document wrapper: <Agent>, <Skill>, <MCPConfig>, <State>, or use runtime transformer for <Command>."
+      );
+    }
+    throw new Error(
+      `Unknown root element. Use a document wrapper: <Agent>, <Skill>, <MCPConfig>, <State>, or use runtime transformer for <Command>.`
+    );
+  }
+  /**
+   * Merge Command props from spread attributes and explicit attributes
+   *
+   * Processes attributes in order - later props override earlier ones.
+   * Supports spread attributes: {...baseProps}
+   * Supports explicit attributes: name="value" or name={"value"} or name={["a", "b"]}
+   */
+  mergeCommandProps(opening) {
+    const merged = {};
+    for (const attr of opening.getAttributes()) {
+      if (Node.isJsxSpreadAttribute(attr)) {
+        const spreadProps = resolveSpreadAttribute(attr);
+        Object.assign(merged, spreadProps);
+      } else if (Node.isJsxAttribute(attr)) {
+        const attrName = attr.getNameNode().getText();
+        const stringValue = getAttributeValue(opening, attrName);
+        if (stringValue !== void 0) {
+          merged[attrName] = stringValue;
+          continue;
+        }
+        const arrayValue = getArrayAttributeValue(opening, attrName);
+        if (arrayValue !== void 0) {
+          merged[attrName] = arrayValue;
+        }
+      }
+    }
+    return merged;
+  }
+  /**
+   * Transform a Command element
+   *
+   * NOTE: This transformer is deprecated for Commands. Commands should use the runtime transformer
+   * which supports runtime features (useRuntimeVar, If/Else/Loop, etc.).
+   */
+  transformCommand(node) {
+    throw this.createError(
+      "This transformer is deprecated for Commands. Use the runtime transformer (transformRuntimeCommand) instead. Commands should import from react-agentic and use runtime features (useRuntimeVar, If, Else, Loop).",
+      node
+    );
+  }
+  /**
+   * Transform an Agent element to AgentDocumentNode with frontmatter
+   * Delegates to document.ts transformAgent()
+   */
+  transformAgent(node) {
+    return transformAgent(node, this.buildContext());
+  }
+  /**
+   * Transform a Skill element to SkillDocumentNode with frontmatter, body, files, and statics
+   * Delegates to document.ts transformSkill()
+   */
+  transformSkill(node) {
+    return transformSkill(node, this.buildContext());
+  }
+  transformFragmentChildren(node) {
+    return this.transformBlockChildren(node.getJsxChildren());
+  }
+  /**
+   * Transform arrow function body to IR blocks
+   * Handles both block body { return ... } and expression body
+   */
+  transformArrowFunctionBody(arrowFn) {
+    const body = arrowFn.getBody();
+    if (Node.isBlock(body)) {
+      const returnStmt = body.getStatements().find((stmt) => Node.isReturnStatement(stmt));
+      if (returnStmt && Node.isReturnStatement(returnStmt)) {
+        const returnExpr = returnStmt.getExpression();
+        if (returnExpr) {
+          if (Node.isJsxElement(returnExpr) || Node.isJsxSelfClosingElement(returnExpr)) {
+            const block = this.transformToBlock(returnExpr);
+            return block ? [block] : [];
+          }
+          if (Node.isJsxFragment(returnExpr)) {
+            return this.transformFragmentChildren(returnExpr);
+          }
+          if (Node.isParenthesizedExpression(returnExpr)) {
+            const inner = returnExpr.getExpression();
+            if (Node.isJsxElement(inner) || Node.isJsxSelfClosingElement(inner)) {
+              const block = this.transformToBlock(inner);
+              return block ? [block] : [];
+            }
+            if (Node.isJsxFragment(inner)) {
+              return this.transformFragmentChildren(inner);
+            }
+          }
+        }
+      }
+      return [];
+    }
+    if (Node.isJsxElement(body) || Node.isJsxSelfClosingElement(body)) {
+      const block = this.transformToBlock(body);
+      return block ? [block] : [];
+    }
+    if (Node.isJsxFragment(body)) {
+      return this.transformFragmentChildren(body);
+    }
+    if (Node.isParenthesizedExpression(body)) {
+      const inner = body.getExpression();
+      if (Node.isJsxElement(inner) || Node.isJsxSelfClosingElement(inner)) {
+        const block = this.transformToBlock(inner);
+        return block ? [block] : [];
+      }
+      if (Node.isJsxFragment(inner)) {
+        return this.transformFragmentChildren(inner);
+      }
+    }
+    return [];
+  }
+  transformToBlock(node) {
+    if (Node.isJsxText(node)) {
+      const text = extractText(node);
+      if (!text) return null;
+      return { kind: "paragraph", children: [{ kind: "text", value: text }] };
+    }
+    if (Node.isJsxElement(node) || Node.isJsxSelfClosingElement(node)) {
+      const name = getElementName(node);
+      return this.transformElement(name, node);
+    }
+    return null;
+  }
+  transformElement(name, node) {
+    const headingMatch = name.match(/^h([1-6])$/);
+    if (headingMatch) {
+      const level = parseInt(headingMatch[1], 10);
+      const children = Node.isJsxElement(node) ? this.transformInlineChildren(node) : [];
+      return { kind: "heading", level, children };
+    }
+    if (name === "p") {
+      const children = Node.isJsxElement(node) ? this.transformInlineChildren(node) : [];
+      return { kind: "paragraph", children };
+    }
+    if (name === "hr") {
+      return { kind: "thematicBreak" };
+    }
+    if (name === "ul") {
+      return this.transformList(node, false);
+    }
+    if (name === "ol") {
+      return this.transformList(node, true);
+    }
+    if (name === "blockquote") {
+      return this.transformBlockquote(node);
+    }
+    if (name === "pre") {
+      return this.transformCodeBlock(node);
+    }
+    if (name === "div") {
+      return this.transformDiv(node);
+    }
+    if (name === "XmlBlock") {
+      return this.transformXmlBlock(node);
+    }
+    if (name === "SpawnAgent") {
+      return this.transformSpawnAgent(node);
+    }
+    if (name === "Assign") {
+      return this.transformAssign(node);
+    }
+    if (name === "AssignGroup") {
+      return this.transformAssignGroup(node);
+    }
+    if (name === "If") {
+      return this.transformIf(node);
+    }
+    if (name === "Else") {
+      throw this.createError("<Else> must follow <If> as sibling", node);
+    }
+    if (name === "Loop") {
+      return this.transformLoop(node);
+    }
+    if (name === "OnStatus") {
+      return this.transformOnStatus(node);
+    }
+    if (name === "ReadState") {
+      return this.transformReadState(node);
+    }
+    if (name === "WriteState") {
+      return this.transformWriteState(node);
+    }
+    if (name === "Table") {
+      return this.transformTable(node);
+    }
+    if (name === "List") {
+      return this.transformPropList(node);
+    }
+    if (name === "ExecutionContext") {
+      return this.transformExecutionContext(node);
+    }
+    if (name === "SuccessCriteria") {
+      return this.transformSuccessCriteria(node);
+    }
+    if (name === "OfferNext") {
+      return this.transformOfferNext(node);
+    }
+    if (name === "XmlSection") {
+      return this.transformXmlSection(node);
+    }
+    if (name === "DeviationRules" || name === "CommitRules" || name === "WaveExecution" || name === "CheckpointHandling") {
+      return this.transformXmlWrapper(name, node);
+    }
+    if (name === "Step") {
+      return this.transformStep(node);
+    }
+    if (name === "Bash") {
+      return this.transformBash(node);
+    }
+    if (name === "ReadFiles") {
+      return this.transformReadFiles(node);
+    }
+    if (name === "PromptTemplate") {
+      return this.transformPromptTemplate(node);
+    }
+    if (name === "Markdown") {
+      return this.transformMarkdown(node);
+    }
+    if (isCustomComponent(name)) {
+      return this.transformCustomComponent(name, node);
+    }
+    throw this.createError(`Unsupported block element: <${name}>`, node);
+  }
+  transformList(node, ordered) {
+    if (Node.isJsxSelfClosingElement(node)) {
+      return { kind: "list", ordered, items: [] };
+    }
+    const items = [];
+    for (const child of node.getJsxChildren()) {
+      if (Node.isJsxElement(child)) {
+        const childName = getElementName(child);
+        if (childName === "li") {
+          items.push(this.transformListItem(child));
+        } else {
+          throw this.createError(`Expected <li> inside list, got <${childName}>`, child);
+        }
+      } else if (Node.isJsxText(child) && !child.containsOnlyTriviaWhiteSpaces()) {
+        throw this.createError("Lists can only contain <li> elements", child);
+      }
+    }
+    return { kind: "list", ordered, items };
+  }
+  transformListItem(node) {
+    const children = [];
+    const jsxChildren = node.getJsxChildren();
+    const isBlockContent = (child) => {
+      if (Node.isJsxElement(child) || Node.isJsxSelfClosingElement(child)) {
+        const name = getElementName(child);
+        return name === "ul" || name === "ol" || name === "p";
+      }
+      return false;
+    };
+    let inlineSequence = [];
+    const flushInlineSequence = () => {
+      if (inlineSequence.length === 0) return;
+      const inlines = [];
+      for (const child of inlineSequence) {
+        const inline = this.transformToInline(child);
+        if (inline) inlines.push(inline);
+      }
+      this.trimBoundaryTextNodes(inlines);
+      if (inlines.length > 0) {
+        const lastChild = children[children.length - 1];
+        if (lastChild?.kind === "paragraph") {
+          lastChild.children.push(...inlines);
+        } else {
+          children.push({ kind: "paragraph", children: inlines });
+        }
+      }
+      inlineSequence = [];
+    };
+    for (const child of jsxChildren) {
+      if (isBlockContent(child)) {
+        flushInlineSequence();
+        const childName = getElementName(child);
+        if (childName === "ul" || childName === "ol") {
+          const nestedList = this.transformElement(childName, child);
+          if (nestedList) children.push(nestedList);
+        } else if (childName === "p") {
+          const para = this.transformElement(childName, child);
+          if (para) children.push(para);
+        }
+      } else {
+        inlineSequence.push(child);
+      }
+    }
+    flushInlineSequence();
+    return { kind: "listItem", children };
+  }
+  transformBlockquote(node) {
+    if (Node.isJsxSelfClosingElement(node)) {
+      return { kind: "blockquote", children: [] };
+    }
+    const children = this.transformBlockChildren(node.getJsxChildren());
+    return { kind: "blockquote", children };
+  }
+  transformCodeBlock(node) {
+    if (Node.isJsxSelfClosingElement(node)) {
+      return { kind: "codeBlock", content: "" };
+    }
+    const children = node.getJsxChildren();
+    for (const child of children) {
+      if (Node.isJsxElement(child) && getElementName(child) === "code") {
+        const language = getAttributeValue(
+          child.getOpeningElement(),
+          "className"
+        )?.replace(/^language-/, "");
+        const content2 = this.extractCodeContent(child);
+        return { kind: "codeBlock", language, content: content2 };
+      }
+    }
+    const content = this.extractCodeContent(node);
+    return { kind: "codeBlock", content };
+  }
+  extractCodeContent(node) {
+    const parts = [];
+    for (const child of node.getJsxChildren()) {
+      if (Node.isJsxText(child)) {
+        parts.push(child.getText());
+      } else if (Node.isJsxExpression(child)) {
+        const expr = child.getExpression();
+        if (expr) {
+          if (Node.isStringLiteral(expr)) {
+            parts.push(expr.getLiteralValue());
+          } else if (Node.isNoSubstitutionTemplateLiteral(expr)) {
+            parts.push(expr.getLiteralValue());
+          } else if (Node.isTemplateExpression(expr)) {
+            parts.push(this.extractTemplateText(expr));
+          }
+        }
+      }
+    }
+    return parts.join("").trim();
+  }
+  transformInlineChildren(node) {
+    const children = node.getJsxChildren();
+    const inlines = [];
+    for (const child of children) {
+      const inline = this.transformToInline(child);
+      if (inline) inlines.push(inline);
+    }
+    this.trimBoundaryTextNodes(inlines);
+    return inlines;
+  }
+  trimBoundaryTextNodes(inlines) {
+    if (inlines.length === 0) return;
+    const first = inlines[0];
+    if (first.kind === "text") {
+      first.value = first.value.trimStart();
+      if (!first.value) {
+        inlines.shift();
+      }
+    }
+    if (inlines.length === 0) return;
+    const last = inlines[inlines.length - 1];
+    if (last.kind === "text") {
+      last.value = last.value.trimEnd();
+      if (!last.value) {
+        inlines.pop();
+      }
+    }
+  }
+  transformToInline(node) {
+    if (Node.isJsxText(node)) {
+      const text = extractInlineText(node);
+      if (!text) return null;
+      return { kind: "text", value: text };
+    }
+    if (Node.isJsxSelfClosingElement(node)) {
+      const name = getElementName(node);
+      if (name === "br") {
+        return { kind: "lineBreak" };
+      }
+      throw this.createError(`Unsupported inline self-closing element: <${name}>`, node);
+    }
+    if (Node.isJsxElement(node)) {
+      const name = getElementName(node);
+      return this.transformInlineElement(name, node);
+    }
+    if (Node.isJsxExpression(node)) {
+      const expr = node.getExpression();
+      if (!expr) return null;
+      if (Node.isStringLiteral(expr)) {
+        const value = expr.getLiteralValue();
+        if (value) {
+          return { kind: "text", value };
+        }
+        return null;
+      }
+      if (Node.isCallExpression(expr)) {
+        const propAccess = expr.getExpression();
+        if (Node.isPropertyAccessExpression(propAccess)) {
+          const methodName = propAccess.getName();
+          const objExpr = propAccess.getExpression();
+          if (methodName === "field" && Node.isIdentifier(objExpr)) {
+            const outputName = objExpr.getText();
+            if (this.outputs.has(outputName)) {
+              const args = expr.getArguments();
+              if (args.length >= 1) {
+                const keyArg = args[0];
+                if (Node.isStringLiteral(keyArg)) {
+                  const fieldKey = keyArg.getLiteralValue();
+                  return { kind: "text", value: `{output.${fieldKey}}` };
+                }
+              }
+            }
+          }
+        }
+      }
+      if (Node.isPropertyAccessExpression(expr)) {
+        const objExpr = expr.getExpression();
+        const propName = expr.getName();
+        if (Node.isIdentifier(objExpr) && this.renderPropsContext) {
+          const objName = objExpr.getText();
+          if (objName === this.renderPropsContext.paramName) {
+            const value = this.renderPropsContext.values[propName];
+            if (value !== void 0) {
+              return { kind: "text", value };
+            }
+          }
+        }
+      }
+      return null;
+    }
+    return null;
+  }
+  transformInlineElement(name, node) {
+    if (name === "b" || name === "strong") {
+      return { kind: "bold", children: this.transformInlineChildren(node) };
+    }
+    if (name === "i" || name === "em") {
+      return { kind: "italic", children: this.transformInlineChildren(node) };
+    }
+    if (name === "code") {
+      const text = this.extractAllText(node);
+      return { kind: "inlineCode", value: text };
+    }
+    if (name === "a") {
+      return this.transformLink(node);
+    }
+    throw this.createError(`Unsupported inline element: <${name}>`, node);
+  }
+  extractAllText(node) {
+    const parts = [];
+    for (const child of node.getJsxChildren()) {
+      if (Node.isJsxText(child)) {
+        const text = extractText(child);
+        if (text) parts.push(text);
+      } else if (Node.isJsxExpression(child)) {
+        const expr = child.getExpression();
+        if (expr) {
+          if (Node.isStringLiteral(expr)) {
+            parts.push(expr.getLiteralValue());
+          } else if (Node.isNoSubstitutionTemplateLiteral(expr)) {
+            parts.push(expr.getLiteralValue());
+          } else if (Node.isTemplateExpression(expr)) {
+            parts.push(this.extractTemplateText(expr));
+          }
+        }
+      }
+    }
+    return parts.join("");
+  }
+  transformLink(node) {
+    const href = getAttributeValue(node.getOpeningElement(), "href");
+    if (!href) {
+      throw this.createError("<a> element requires href attribute", node);
+    }
+    const children = this.transformInlineChildren(node);
+    return { kind: "link", url: href, children };
+  }
+  transformDiv(node) {
+    const openingElement = Node.isJsxElement(node) ? node.getOpeningElement() : node;
+    const nameAttr = getAttributeValue(openingElement, "name");
+    const children = Node.isJsxElement(node) ? this.transformMixedChildren(node.getJsxChildren()) : [];
+    if (!nameAttr) {
+      return {
+        kind: "group",
+        children
+      };
+    }
+    if (!isValidXmlName(nameAttr)) {
+      throw this.createError(
+        `Invalid XML tag name '${nameAttr}' - must start with letter/underscore, contain only letters, digits, underscores, hyphens, or periods, and not start with 'xml'`,
+        node
+      );
+    }
+    const attributes = {};
+    for (const attr of openingElement.getAttributes()) {
+      if (Node.isJsxAttribute(attr)) {
+        const attrName = attr.getNameNode().getText();
+        if (attrName !== "name") {
+          const value = getAttributeValue(openingElement, attrName);
+          if (value !== void 0) {
+            attributes[attrName] = value;
+          }
+        }
+      }
+    }
+    return {
+      kind: "xmlBlock",
+      name: nameAttr,
+      attributes: Object.keys(attributes).length > 0 ? attributes : void 0,
+      children
+    };
+  }
+  /**
+   * Transform mixed children (inline + block elements)
+   * Consecutive inline elements and text are wrapped in a single paragraph
+   * Block elements are transformed normally
+   */
+  transformMixedChildren(jsxChildren) {
+    const blocks = [];
+    let inlineAccumulator = [];
+    const flushInline = () => {
+      if (inlineAccumulator.length > 0) {
+        const inlineNodes = this.transformInlineNodes(inlineAccumulator);
+        if (inlineNodes.length > 0) {
+          blocks.push({ kind: "paragraph", children: inlineNodes });
+        }
+        inlineAccumulator = [];
+      }
+    };
+    for (const child of jsxChildren) {
+      if (Node.isJsxText(child)) {
+        const text = extractText(child);
+        if (text) {
+          inlineAccumulator.push(child);
+        }
+        continue;
+      }
+      if (Node.isJsxElement(child) || Node.isJsxSelfClosingElement(child)) {
+        const name = getElementName(child);
+        if (isInlineElement(name)) {
+          inlineAccumulator.push(child);
+        } else {
+          flushInline();
+          const block = this.transformToBlock(child);
+          if (block) blocks.push(block);
+        }
+      } else if (Node.isJsxExpression(child)) {
+        inlineAccumulator.push(child);
+      }
+    }
+    flushInline();
+    return blocks;
+  }
+  /**
+   * Transform a list of nodes to inline nodes
+   * Used by transformMixedChildren for inline accumulation
+   */
+  transformInlineNodes(nodes) {
+    const result = [];
+    for (const node of nodes) {
+      if (Node.isJsxText(node)) {
+        const text = extractText(node);
+        if (text) {
+          result.push({ kind: "text", value: text });
+        }
+      } else if (Node.isJsxElement(node)) {
+        const name = getElementName(node);
+        const inlineNode = this.transformInlineElement(name, node);
+        if (inlineNode) result.push(inlineNode);
+      } else if (Node.isJsxSelfClosingElement(node)) {
+        const name = getElementName(node);
+        if (name === "br") {
+          result.push({ kind: "lineBreak" });
+        }
+      } else if (Node.isJsxExpression(node)) {
+        const expr = node.getExpression();
+        if (expr) {
+          const text = expr.getText();
+          const cleaned = text.replace(/^['"`]|['"`]$/g, "");
+          if (cleaned) {
+            result.push({ kind: "text", value: cleaned });
+          }
+        }
+      }
+    }
+    return result;
+  }
+  transformXmlBlock(node) {
+    const openingElement = Node.isJsxElement(node) ? node.getOpeningElement() : node;
+    const nameAttr = getAttributeValue(openingElement, "name");
+    if (!nameAttr) {
+      throw this.createError("XmlBlock requires name prop", node);
+    }
+    if (!isValidXmlName(nameAttr)) {
+      throw this.createError(
+        `Invalid XML tag name '${nameAttr}' - must start with letter/underscore, contain only letters, digits, underscores, hyphens, or periods, and not start with 'xml'`,
+        node
+      );
+    }
+    const children = Node.isJsxElement(node) ? this.transformBlockChildren(node.getJsxChildren()) : [];
+    return {
+      kind: "xmlBlock",
+      name: nameAttr,
+      children
+    };
+  }
+  /**
+   * Transform Table component to TableNode IR
+   */
+  transformTable(node) {
+    const opening = Node.isJsxElement(node) ? node.getOpeningElement() : node;
+    const headers = getArrayAttributeValue(opening, "headers");
+    const rows = this.parseRowsAttribute(opening);
+    const alignRaw = getArrayAttributeValue(opening, "align");
+    const emptyCell = getAttributeValue(opening, "emptyCell");
+    const align = alignRaw?.map((a) => {
+      if (a === "left" || a === "center" || a === "right") return a;
+      return "left";
+    });
+    return {
+      kind: "table",
+      headers: headers?.length ? headers : void 0,
+      rows,
+      align,
+      emptyCell: emptyCell || void 0
+    };
+  }
+  /**
+   * Parse rows attribute (array of arrays)
+   */
+  parseRowsAttribute(opening) {
+    const attr = opening.getAttribute("rows");
+    if (!attr || !Node.isJsxAttribute(attr)) return [];
+    const init = attr.getInitializer();
+    if (!init || !Node.isJsxExpression(init)) return [];
+    const expr = init.getExpression();
+    if (!expr || !Node.isArrayLiteralExpression(expr)) return [];
+    const rows = [];
+    for (const element of expr.getElements()) {
+      if (Node.isArrayLiteralExpression(element)) {
+        const row = [];
+        for (const cell of element.getElements()) {
+          if (Node.isStringLiteral(cell)) {
+            row.push(cell.getLiteralValue());
+          } else if (Node.isNumericLiteral(cell)) {
+            row.push(cell.getLiteralValue().toString());
+          } else if (Node.isPropertyAccessExpression(cell)) {
+            const interpolated = this.interpolatePropertyAccess(cell);
+            row.push(interpolated ?? cell.getText());
+          } else {
+            row.push(cell.getText());
+          }
+        }
+        rows.push(row);
+      }
+    }
+    return rows;
+  }
+  /**
+   * Interpolate a PropertyAccessExpression if it references render props context
+   * Returns the interpolated value or null if not a context access
+   */
+  interpolatePropertyAccess(expr) {
+    const objExpr = expr.getExpression();
+    const propName = expr.getName();
+    if (Node.isIdentifier(objExpr) && this.renderPropsContext) {
+      const objName = objExpr.getText();
+      if (objName === this.renderPropsContext.paramName) {
+        const value = this.renderPropsContext.values[propName];
+        if (value !== void 0) {
+          return value;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Transform List component (prop-based) to ListNode IR
+   * This is separate from HTML <ul>/<ol> transformation
+   */
+  transformPropList(node) {
+    const opening = Node.isJsxElement(node) ? node.getOpeningElement() : node;
+    const items = getArrayAttributeValue(opening, "items") ?? [];
+    const ordered = getAttributeValue(opening, "ordered") === "true" || opening.getAttribute("ordered") !== void 0;
+    let start = void 0;
+    const startAttr = opening.getAttribute("start");
+    if (startAttr && Node.isJsxAttribute(startAttr)) {
+      const init = startAttr.getInitializer();
+      if (init && Node.isJsxExpression(init)) {
+        const expr = init.getExpression();
+        if (expr && Node.isNumericLiteral(expr)) {
+          start = expr.getLiteralValue();
+        }
+      }
+    }
+    const listItems = items.map((item) => ({
+      kind: "listItem",
+      children: [{
+        kind: "paragraph",
+        children: [{ kind: "text", value: String(item) }]
+      }]
+    }));
+    return {
+      kind: "list",
+      ordered,
+      items: listItems,
+      start
+    };
+  }
+  // ============================================================================
+  // Semantic Workflow Components
+  // ============================================================================
+  transformExecutionContext(node) {
+    const opening = Node.isJsxElement(node) ? node.getOpeningElement() : node;
+    const paths = getArrayAttributeValue(opening, "paths") ?? [];
+    const prefix = getAttributeValue(opening, "prefix") ?? "@";
+    const children = [];
+    if (Node.isJsxElement(node)) {
+      for (const child of node.getJsxChildren()) {
+        const block = this.transformToBlock(child);
+        if (block) children.push(block);
+      }
+    }
+    return {
+      kind: "executionContext",
+      paths,
+      prefix,
+      children
+    };
+  }
+  transformSuccessCriteria(node) {
+    const opening = Node.isJsxElement(node) ? node.getOpeningElement() : node;
+    const items = this.parseSuccessCriteriaItems(opening);
+    return {
+      kind: "successCriteria",
+      items
+    };
+  }
+  /**
+   * Parse items attribute for SuccessCriteria
+   * Handles both string shorthand and {text, checked} objects
+   */
+  parseSuccessCriteriaItems(opening) {
+    const attr = opening.getAttribute("items");
+    if (!attr || !Node.isJsxAttribute(attr)) return [];
+    const init = attr.getInitializer();
+    if (!init || !Node.isJsxExpression(init)) return [];
+    const expr = init.getExpression();
+    if (!expr || !Node.isArrayLiteralExpression(expr)) return [];
+    const items = [];
+    for (const element of expr.getElements()) {
+      if (Node.isStringLiteral(element)) {
+        items.push({ text: element.getLiteralValue(), checked: false });
+      } else if (Node.isObjectLiteralExpression(element)) {
+        let text = "";
+        let checked = false;
+        for (const prop of element.getProperties()) {
+          if (Node.isPropertyAssignment(prop)) {
+            const propName = prop.getName();
+            const propInit = prop.getInitializer();
+            if (propName === "text" && propInit && Node.isStringLiteral(propInit)) {
+              text = propInit.getLiteralValue();
+            } else if (propName === "checked" && propInit) {
+              if (propInit.getKind() === 112) {
+                checked = true;
+              } else if (propInit.getKind() === 97) {
+                checked = false;
+              }
+            }
+          }
+        }
+        items.push({ text, checked });
+      }
+    }
+    return items;
+  }
+  transformOfferNext(node) {
+    const opening = Node.isJsxElement(node) ? node.getOpeningElement() : node;
+    const routes = this.parseOfferNextRoutes(opening);
+    return {
+      kind: "offerNext",
+      routes
+    };
+  }
+  /**
+   * Parse routes attribute for OfferNext
+   * Each route is an object with name, path, and optional description
+   */
+  parseOfferNextRoutes(opening) {
+    const attr = opening.getAttribute("routes");
+    if (!attr || !Node.isJsxAttribute(attr)) return [];
+    const init = attr.getInitializer();
+    if (!init || !Node.isJsxExpression(init)) return [];
+    const expr = init.getExpression();
+    if (!expr || !Node.isArrayLiteralExpression(expr)) return [];
+    const routes = [];
+    for (const element of expr.getElements()) {
+      if (Node.isObjectLiteralExpression(element)) {
+        let name = "";
+        let path = "";
+        let description = void 0;
+        for (const prop of element.getProperties()) {
+          if (Node.isPropertyAssignment(prop)) {
+            const propName = prop.getName();
+            const propInit = prop.getInitializer();
+            if (propInit && Node.isStringLiteral(propInit)) {
+              const value = propInit.getLiteralValue();
+              if (propName === "name") {
+                name = value;
+              } else if (propName === "path") {
+                path = value;
+              } else if (propName === "description") {
+                description = value;
+              }
+            }
+          }
+        }
+        if (name && path) {
+          routes.push({ name, path, description });
+        }
+      }
+    }
+    return routes;
+  }
+  /**
+   * Transform Step component to StepNode IR
+   */
+  transformStep(node) {
+    const openingElement = Node.isJsxElement(node) ? node.getOpeningElement() : node;
+    let stepNumber = void 0;
+    const numberAttr = openingElement.getAttribute("number");
+    if (numberAttr && Node.isJsxAttribute(numberAttr)) {
+      const init = numberAttr.getInitializer();
+      if (init) {
+        if (Node.isStringLiteral(init)) {
+          stepNumber = init.getLiteralValue();
+        } else if (Node.isJsxExpression(init)) {
+          const expr = init.getExpression();
+          if (expr) {
+            if (Node.isNumericLiteral(expr)) {
+              stepNumber = String(expr.getLiteralValue());
+            } else if (Node.isStringLiteral(expr)) {
+              stepNumber = expr.getLiteralValue();
+            }
+          }
+        }
+      }
+    }
+    const name = getAttributeValue(openingElement, "name");
+    if (!stepNumber) {
+      throw this.createError("Step requires number prop", openingElement);
+    }
+    if (!name) {
+      throw this.createError("Step requires name prop", openingElement);
+    }
+    const variantAttr = getAttributeValue(openingElement, "variant");
+    let variant = "heading";
+    if (variantAttr === "heading" || variantAttr === "bold" || variantAttr === "xml") {
+      variant = variantAttr;
+    }
+    const children = Node.isJsxElement(node) ? this.transformBlockChildren(node.getJsxChildren()) : [];
+    return {
+      kind: "step",
+      number: stepNumber,
+      name,
+      variant,
+      children
+    };
+  }
+  /**
+   * Transform <Bash> to CodeBlockNode with language 'bash'
+   *
+   * <Bash>ls -la</Bash>
+   * becomes:
+   * ```bash
+   * ls -la
+   * ```
+   */
+  transformBash(node) {
+    if (Node.isJsxSelfClosingElement(node)) {
+      return { kind: "codeBlock", language: "bash", content: "" };
+    }
+    const content = this.extractCodeContent(node);
+    return {
+      kind: "codeBlock",
+      language: "bash",
+      content
+    };
+  }
+  /**
+   * Transform <ReadFiles> to ReadFilesNode
+   *
+   * Extracts the files prop (which should be a defineFiles() result)
+   * and creates a ReadFilesNode with file entries.
+   */
+  transformReadFiles(node) {
+    const opening = Node.isJsxElement(node) ? node.getOpeningElement() : node;
+    const filesAttr = opening.getAttribute("files");
+    if (!filesAttr || !Node.isJsxAttribute(filesAttr)) {
+      throw this.createError("ReadFiles requires files prop", node);
+    }
+    const init = filesAttr.getInitializer();
+    if (!init || !Node.isJsxExpression(init)) {
+      throw this.createError("ReadFiles files prop must be a JSX expression", node);
+    }
+    const expr = init.getExpression();
+    if (!expr) {
+      throw this.createError("ReadFiles files prop expression is empty", node);
+    }
+    const files = [];
+    if (Node.isIdentifier(expr)) {
+      const varName = expr.getText();
+      const sourceFile = this.sourceFile;
+      if (sourceFile) {
+        const statements = sourceFile.getStatements();
+        for (const stmt of statements) {
+          if (Node.isVariableStatement(stmt)) {
+            for (const decl of stmt.getDeclarationList().getDeclarations()) {
+              if (decl.getName() === varName) {
+                const initializer = decl.getInitializer();
+                if (initializer && Node.isCallExpression(initializer)) {
+                  const callee = initializer.getExpression();
+                  if (Node.isIdentifier(callee) && callee.getText() === "defineFiles") {
+                    const args = initializer.getArguments();
+                    if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
+                      this.extractFilesFromSchema(args[0], files);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    } else if (Node.isCallExpression(expr)) {
+      const callee = expr.getExpression();
+      if (Node.isIdentifier(callee) && callee.getText() === "defineFiles") {
+        const args = expr.getArguments();
+        if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
+          this.extractFilesFromSchema(args[0], files);
+        }
+      }
+    }
+    if (files.length === 0) {
+      throw this.createError("ReadFiles: could not extract files from defineFiles schema", node);
+    }
+    return {
+      kind: "readFiles",
+      files
+    };
+  }
+  /**
+   * Extract file entries from defineFiles schema object literal
+   */
+  extractFilesFromSchema(obj, files) {
+    for (const prop of obj.getProperties()) {
+      if (Node.isPropertyAssignment(prop)) {
+        const key = prop.getName();
+        const value = prop.getInitializer();
+        if (value && Node.isObjectLiteralExpression(value)) {
+          let path;
+          let required = true;
+          for (const fileProp of value.getProperties()) {
+            if (Node.isPropertyAssignment(fileProp)) {
+              const propName = fileProp.getName();
+              const propValue = fileProp.getInitializer();
+              if (propName === "path" && propValue) {
+                if (Node.isStringLiteral(propValue)) {
+                  path = propValue.getLiteralValue();
+                } else if (Node.isNoSubstitutionTemplateLiteral(propValue)) {
+                  path = propValue.getLiteralValue();
+                } else if (Node.isTemplateExpression(propValue)) {
+                  path = this.extractTemplatePath(propValue);
+                }
+              } else if (propName === "required" && propValue) {
+                if (propValue.getText() === "false") {
+                  required = false;
+                }
+              }
+            }
+          }
+          if (path) {
+            const varName = key.replace(/([a-z])([A-Z])/g, "$1_$2").toUpperCase() + "_CONTENT";
+            files.push({ varName, path, required });
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Extract path from template expression, preserving ${} for shell
+   */
+  extractTemplatePath(tmpl) {
+    let result = tmpl.getHead().getLiteralText();
+    for (const span of tmpl.getTemplateSpans()) {
+      const spanExpr = span.getExpression();
+      result += "${" + spanExpr.getText() + "}";
+      result += span.getLiteral().getLiteralText();
+    }
+    return result;
+  }
+  /**
+   * Transform <PromptTemplate> to PromptTemplateNode
+   *
+   * <PromptTemplate>
+   *   <XmlBlock name="objective">...</XmlBlock>
+   * </PromptTemplate>
+   *
+   * Becomes:
+   * ```markdown
+   * <objective>
+   * ...
+   * </objective>
+   * ```
+   */
+  transformPromptTemplate(node) {
+    if (Node.isJsxSelfClosingElement(node)) {
+      return { kind: "promptTemplate", children: [] };
+    }
+    const children = this.transformBlockChildren(node.getJsxChildren());
+    return {
+      kind: "promptTemplate",
+      children
+    };
+  }
+  transformXmlSection(node) {
+    const opening = Node.isJsxElement(node) ? node.getOpeningElement() : node;
+    const name = getAttributeValue(opening, "name") ?? "section";
+    const children = [];
+    if (Node.isJsxElement(node)) {
+      for (const child of node.getJsxChildren()) {
+        const block = this.transformToBlock(child);
+        if (block) children.push(block);
+      }
+    }
+    return {
+      kind: "xmlBlock",
+      name,
+      children
+    };
+  }
+  transformXmlWrapper(componentName, node) {
+    const tagName = toSnakeCase(componentName);
+    const children = [];
+    if (Node.isJsxElement(node)) {
+      for (const child of node.getJsxChildren()) {
+        const block = this.transformToBlock(child);
+        if (block) children.push(block);
+      }
+    }
+    return {
+      kind: "xmlBlock",
+      name: tagName,
+      children
+    };
+  }
+  transformMarkdown(node) {
+    if (Node.isJsxSelfClosingElement(node)) {
+      return { kind: "raw", content: "" };
+    }
+    const parts = [];
+    const jsxChildren = node.getJsxChildren();
+    for (let i = 0; i < jsxChildren.length; i++) {
+      const child = jsxChildren[i];
+      const prev = parts[parts.length - 1];
+      if (Node.isJsxText(child)) {
+        let text = child.getText();
+        if (text === "" && i > 0 && i < jsxChildren.length - 1) {
+          const prevChild = jsxChildren[i - 1];
+          const nextChild = jsxChildren[i + 1];
+          if (Node.isJsxExpression(prevChild) && Node.isJsxExpression(nextChild)) {
+            parts.push("\n");
+            continue;
+          }
+        }
+        if (prev && !/\s$/.test(prev) && !/^\s/.test(text) && text !== "") {
+          if (/^#{1,6}\s/.test(text) || /^```/.test(text)) {
+            parts.push("\n\n");
+          } else if (/^\*\*/.test(text)) {
+            parts.push("\n");
+          } else if (/^[-*]\s/.test(text) || /^\d+\.\s/.test(text)) {
+            parts.push("\n");
+          } else if (/^[|]/.test(text)) {
+            if (/[|]\s*$/.test(prev)) {
+              parts.push("\n");
+            } else {
+              parts.push(" ");
+            }
+          } else if (!/^[.,;:!?)}\]>`"'/]/.test(text)) {
+            parts.push(" ");
+          }
+        }
+        parts.push(text);
+      } else if (Node.isJsxExpression(child)) {
+        const expr = child.getExpression();
+        if (expr) {
+          if (Node.isStringLiteral(expr)) {
+            parts.push(expr.getLiteralValue());
+          } else if (Node.isNoSubstitutionTemplateLiteral(expr)) {
+            parts.push(expr.getLiteralValue());
+          } else if (Node.isTemplateExpression(expr)) {
+            let result = expr.getHead().getLiteralText();
+            for (const span of expr.getTemplateSpans()) {
+              const spanExpr = span.getExpression();
+              if (Node.isIdentifier(spanExpr)) {
+                result += `\${${spanExpr.getText()}}`;
+              } else if (Node.isStringLiteral(spanExpr)) {
+                result += spanExpr.getLiteralValue();
+              } else {
+                result += `\${${spanExpr.getText()}}`;
+              }
+              const literal = span.getLiteral();
+              if (Node.isTemplateMiddle(literal)) {
+                result += literal.getLiteralText();
+              } else if (Node.isTemplateTail(literal)) {
+                result += literal.getLiteralText();
+              }
+            }
+            parts.push(result);
+          } else if (Node.isIdentifier(expr)) {
+            parts.push(`{${expr.getText()}}`);
+          } else if (Node.isBinaryExpression(expr)) {
+            const concat = this.evaluateStringConcatenation(expr);
+            if (concat !== null) {
+              parts.push(concat);
+            }
+          } else if (Node.isPropertyAccessExpression(expr)) {
+            const value = this.resolvePropertyAccess(expr);
+            if (value !== null) {
+              parts.push(value);
+            }
+          }
+        }
+      }
+    }
+    const content = parts.join("").trim();
+    return { kind: "raw", content };
+  }
+  /**
+   * Transform a custom component by resolving its import and inlining its JSX
+   *
+   * Custom components are user-defined TSX fragments that get inlined at
+   * transpile time. Component props are NOT supported in v1 - only parameterless
+   * composition.
+   */
+  transformCustomComponent(name, node) {
+    const openingElement = Node.isJsxElement(node) ? node.getOpeningElement() : node;
+    const attributes = openingElement.getAttributes();
+    if (attributes.length > 0) {
+      throw this.createError(`Component props not supported: <${name}> has ${attributes.length} prop(s)`, node);
+    }
+    if (!this.sourceFile) {
+      throw this.createError(
+        `Cannot resolve component '${name}': no source file context. Pass sourceFile to transformer.transform() for component composition.`,
+        node
+      );
+    }
+    const resolved = resolveComponentImport(name, this.sourceFile, this.visitedPaths);
+    this.visitedPaths = resolved.visitedPaths;
+    const previousSourceFile = this.sourceFile;
+    this.sourceFile = resolved.sourceFile;
+    let result = null;
+    if (Node.isJsxFragment(resolved.jsx)) {
+      const blocks = this.transformFragmentChildren(resolved.jsx);
+      result = blocks[0] ?? null;
+    } else {
+      result = this.transformToBlock(resolved.jsx);
+    }
+    this.sourceFile = previousSourceFile;
+    return result;
+  }
+  /**
+   * Transform a SpawnAgent element to SpawnAgentNode
+   * SpawnAgent is a block-level element that emits Task() syntax
+   *
+   * Supports two modes:
+   * 1. prompt prop (deprecated): Manual prompt string
+   * 2. input prop (preferred): Typed input - VariableRef or object literal
+   *
+   * Also supports:
+   * - agent={AgentRef} for type-safe agent references
+   * - loadFromFile prop for "load from file" pattern
+   */
+  transformSpawnAgent(node) {
+    const openingElement = Node.isJsxElement(node) ? node.getOpeningElement() : node;
+    const { agentName, agentPath } = this.extractAgentProp(openingElement);
+    const model = getAttributeValue(openingElement, "model");
+    const description = getAttributeValue(openingElement, "description");
+    const loadFromFile = this.extractLoadFromFileProp(openingElement, agentPath);
+    const prompt = this.extractPromptProp(openingElement);
+    const promptVariable = getAttributeValue(openingElement, "promptVariable");
+    const input = this.extractInputProp(openingElement);
+    const extraInstructions = Node.isJsxElement(node) ? this.extractExtraInstructions(node) : void 0;
+    if (!agentName) {
+      throw this.createError("SpawnAgent requires agent prop", openingElement);
+    }
+    if (!model) {
+      throw this.createError("SpawnAgent requires model prop", openingElement);
+    }
+    if (!description) {
+      throw this.createError("SpawnAgent requires description prop", openingElement);
+    }
+    const promptProps = [prompt, promptVariable, input].filter(Boolean).length;
+    if (promptProps > 1) {
+      throw this.createError(
+        "Cannot use multiple prompt props on SpawnAgent. Use one of: prompt, promptVariable, or input.",
+        openingElement
+      );
+    }
+    if (promptProps === 0) {
+      throw this.createError(
+        "SpawnAgent requires either prompt, promptVariable, or input prop",
+        openingElement
+      );
+    }
+    const typeArgs = extractTypeArguments(node);
+    let inputType;
+    const typeParam = typeArgs && typeArgs.length > 0 ? typeArgs[0] : void 0;
+    if (typeParam) {
+      inputType = {
+        kind: "typeReference",
+        name: typeParam,
+        resolved: false
+        // Will be resolved in validation phase
+      };
+    }
+    if (input) {
+      this.validateInputAgainstInterface(input, typeParam, openingElement);
+    }
+    return {
+      kind: "spawnAgent",
+      agent: agentName,
+      model,
+      description,
+      ...prompt && { prompt },
+      ...promptVariable && { promptVariable },
+      ...input && { input },
+      ...extraInstructions && { extraInstructions },
+      ...inputType && { inputType },
+      ...loadFromFile && { loadFromFile }
+    };
+  }
+  /**
+   * Extract agent prop - handles string OR AgentRef identifier
+   *
+   * Returns:
+   * - agentName: The agent name string (required)
+   * - agentPath: The agent's file path (if AgentRef with path)
+   */
+  extractAgentProp(element) {
+    const attr = element.getAttribute("agent");
+    if (!attr || !Node.isJsxAttribute(attr)) {
+      return { agentName: void 0, agentPath: void 0 };
+    }
+    const init = attr.getInitializer();
+    if (init && Node.isStringLiteral(init)) {
+      return { agentName: init.getLiteralValue(), agentPath: void 0 };
+    }
+    if (init && Node.isJsxExpression(init)) {
+      const expr = init.getExpression();
+      if (expr && Node.isIdentifier(expr)) {
+        const identName = expr.getText();
+        const agentRef = this.resolveAgentRef(identName);
+        if (agentRef) {
+          return { agentName: agentRef.name, agentPath: agentRef.path };
+        }
+        return { agentName: identName, agentPath: void 0 };
+      }
+      if (expr && Node.isStringLiteral(expr)) {
+        return { agentName: expr.getLiteralValue(), agentPath: void 0 };
+      }
+    }
+    return { agentName: void 0, agentPath: void 0 };
+  }
+  /**
+   * Try to resolve an identifier to an AgentRef definition
+   *
+   * Looks for:
+   * 1. Imported AgentRef (from defineAgent call in source file)
+   * 2. Local AgentRef constant
+   */
+  resolveAgentRef(identName) {
+    if (!this.sourceFile) return void 0;
+    const symbol = this.sourceFile.getLocal(identName);
+    if (!symbol) return void 0;
+    const declarations = symbol.getDeclarations();
+    if (!declarations || declarations.length === 0) return void 0;
+    for (const decl of declarations) {
+      if (Node.isImportSpecifier(decl)) {
+        const resolved = this.resolveImportedAgentRef(decl, identName);
+        if (resolved) return resolved;
+        continue;
+      }
+      if (Node.isVariableDeclaration(decl)) {
+        const init = decl.getInitializer();
+        if (init && Node.isCallExpression(init)) {
+          const callExpr = init.getExpression();
+          if (callExpr && callExpr.getText() === "defineAgent") {
+            const args = init.getArguments();
+            if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
+              return this.extractAgentRefFromObject(args[0]);
+            }
+          }
+        }
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Resolve an imported AgentRef by tracing to its source file
+   */
+  resolveImportedAgentRef(importSpec, identName) {
+    let current = importSpec;
+    while (current && !Node.isImportDeclaration(current)) {
+      current = current.getParent();
+    }
+    if (!current || !Node.isImportDeclaration(current)) {
+      return void 0;
+    }
+    const importDecl = current;
+    const resolvedSourceFile = importDecl.getModuleSpecifierSourceFile();
+    if (!resolvedSourceFile) {
+      return void 0;
+    }
+    const exportedVar = resolvedSourceFile.getVariableDeclaration(identName);
+    if (!exportedVar) {
+      return void 0;
+    }
+    const init = exportedVar.getInitializer();
+    if (init && Node.isCallExpression(init)) {
+      const callExpr = init.getExpression();
+      if (callExpr && callExpr.getText() === "defineAgent") {
+        const args = init.getArguments();
+        if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
+          return this.extractAgentRefFromObject(args[0]);
+        }
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Extract AgentRef properties from defineAgent config object
+   */
+  extractAgentRefFromObject(obj) {
+    let name;
+    let path;
+    for (const prop of obj.getProperties()) {
+      if (Node.isPropertyAssignment(prop)) {
+        const propName = prop.getName();
+        const init = prop.getInitializer();
+        if (propName === "name" && init && Node.isStringLiteral(init)) {
+          name = init.getLiteralValue();
+        }
+        if (propName === "path" && init && Node.isStringLiteral(init)) {
+          path = init.getLiteralValue();
+        }
+      }
+    }
+    if (name) {
+      return { name, path };
+    }
+    return void 0;
+  }
+  /**
+   * Extract loadFromFile prop
+   *
+   * Supports:
+   * - loadFromFile (boolean true shorthand)
+   * - loadFromFile={true}
+   * - loadFromFile="explicit/path.md"
+   *
+   * When true, uses agentPath from AgentRef.
+   * Returns resolved path string or undefined.
+   */
+  extractLoadFromFileProp(element, agentPath) {
+    const attr = element.getAttribute("loadFromFile");
+    if (!attr || !Node.isJsxAttribute(attr)) {
+      return void 0;
+    }
+    const init = attr.getInitializer();
+    if (!init) {
+      if (!agentPath) {
+        throw this.createError(
+          'loadFromFile={true} requires an AgentRef with a path property. Either use agent={AgentRef} where AgentRef has a path, or provide an explicit path: loadFromFile="path/to/agent.md"',
+          element
+        );
+      }
+      return agentPath;
+    }
+    if (Node.isStringLiteral(init)) {
+      return init.getLiteralValue();
+    }
+    if (Node.isJsxExpression(init)) {
+      const expr = init.getExpression();
+      if (expr && expr.getText() === "true") {
+        if (!agentPath) {
+          throw this.createError(
+            'loadFromFile={true} requires an AgentRef with a path property. Either use agent={AgentRef} where AgentRef has a path, or provide an explicit path: loadFromFile="path/to/agent.md"',
+            element
+          );
+        }
+        return agentPath;
+      }
+      if (expr && expr.getText() === "false") {
+        return void 0;
+      }
+      if (expr && Node.isStringLiteral(expr)) {
+        return expr.getLiteralValue();
+      }
+      if (expr && Node.isPropertyAccessExpression(expr)) {
+        const resolvedPath = this.resolvePropertyAccess(expr);
+        if (resolvedPath) {
+          return resolvedPath;
+        }
+        throw this.createError(
+          `Cannot resolve property access ${expr.getText()} for loadFromFile. Make sure the object is a const with string literal values.`,
+          element
+        );
+      }
+    }
+    throw this.createError(
+      "loadFromFile must be a boolean or string path",
+      element
+    );
+  }
+  /**
+   * Extract input prop - handles VariableRef identifier or object literal
+   *
+   * Supports:
+   * - input={varRef} - Reference to useVariable result
+   * - input={{ key: "value" }} - Object literal with properties
+   */
+  extractInputProp(element) {
+    const attr = element.getAttribute("input");
+    if (!attr || !Node.isJsxAttribute(attr)) return void 0;
+    const init = attr.getInitializer();
+    if (!init || !Node.isJsxExpression(init)) return void 0;
+    const expr = init.getExpression();
+    if (!expr) return void 0;
+    if (Node.isIdentifier(expr)) {
+      const variable = this.variables.get(expr.getText());
+      if (variable) {
+        return { type: "variable", varName: variable.envName };
+      }
+      throw this.createError(
+        `Input '${expr.getText()}' not found. Use useVariable() or object literal.`,
+        element
+      );
+    }
+    if (Node.isObjectLiteralExpression(expr)) {
+      const properties = extractInputObjectLiteral(expr, this.variables);
+      return { type: "object", properties };
+    }
+    throw this.createError("Input must be a VariableRef or object literal", element);
+  }
+  /**
+   * Extract extra instructions from SpawnAgent children
+   *
+   * Treats children as raw text content (like Markdown component).
+   * Returns undefined if no children or only whitespace.
+   */
+  extractExtraInstructions(node) {
+    const parts = [];
+    for (const child of node.getJsxChildren()) {
+      if (Node.isJsxText(child)) {
+        const text = child.getText();
+        if (text.trim()) {
+          parts.push(text);
+        }
+      } else if (Node.isJsxExpression(child)) {
+        const expr = child.getExpression();
+        if (expr) {
+          if (Node.isStringLiteral(expr)) {
+            parts.push(expr.getLiteralValue());
+          } else if (Node.isNoSubstitutionTemplateLiteral(expr)) {
+            parts.push(expr.getLiteralValue());
+          } else if (Node.isTemplateExpression(expr)) {
+            parts.push(this.extractTemplateText(expr));
+          }
+        }
+      }
+    }
+    const content = parts.join("").trim();
+    return content || void 0;
+  }
+  /**
+   * Extract type argument from SpawnAgent<T> syntax
+   *
+   * Returns the type name string (e.g., "ResearcherInput") or undefined
+   * if no type argument is present.
+   */
+  extractSpawnAgentTypeParam(element) {
+    const parent = element.getParent();
+    if (!parent) return void 0;
+    if (Node.isJsxElement(parent)) {
+      const typeArgs = extractTypeArguments(parent);
+      return typeArgs && typeArgs.length > 0 ? typeArgs[0] : void 0;
+    }
+    if (Node.isJsxSelfClosingElement(element)) {
+      const typeArgs = extractTypeArguments(element);
+      return typeArgs && typeArgs.length > 0 ? typeArgs[0] : void 0;
+    }
+    return void 0;
+  }
+  /**
+   * Validate input object properties against SpawnAgent<T> type parameter.
+   *
+   * Throws compile error if required interface properties are missing.
+   * Only validates object literal inputs (VariableRef is runtime-checked).
+   *
+   * @param input - The parsed SpawnAgentInput (may be variable or object)
+   * @param typeParam - The type parameter name (e.g., "ResearcherInput")
+   * @param element - The JSX element for error reporting
+   */
+  validateInputAgainstInterface(input, typeParam, element) {
+    if (input.type !== "object") return;
+    if (!typeParam) return;
+    if (!this.sourceFile) {
+      return;
+    }
+    const resolved = resolveTypeImport(typeParam, this.sourceFile);
+    if (!resolved?.interface) {
+      return;
+    }
+    const interfaceProps = extractInterfaceProperties(resolved.interface);
+    const requiredProps = interfaceProps.filter((p) => p.required);
+    const inputPropNames = input.properties.map((p) => p.name);
+    const missing = requiredProps.filter((p) => !inputPropNames.includes(p.name));
+    if (missing.length > 0) {
+      const missingNames = missing.map((p) => p.name).join(", ");
+      const requiredNames = requiredProps.map((p) => p.name).join(", ");
+      throw this.createError(
+        `SpawnAgent input missing required properties: ${missingNames}. Interface '${typeParam}' requires: ${requiredNames}`,
+        element
+      );
+    }
+  }
+  /**
+   * Transform an If element to IfNode
+   *
+   * NOTE: V1 control flow is deprecated. Use V3 transformer with useRuntimeVar and condition-based If.
+   */
+  transformIf(node) {
+    throw this.createError(
+      "V1 If control flow is deprecated. Use V3 transformer with useRuntimeVar and condition-based If.",
+      node
+    );
+  }
+  /**
+   * Transform an Else element to ElseNode
+   *
+   * NOTE: V1 control flow is deprecated. Use V3 transformer with useRuntimeVar and condition-based If/Else.
+   */
+  transformElse(node) {
+    throw this.createError(
+      "V1 Else control flow is deprecated. Use V3 transformer with useRuntimeVar and condition-based Else.",
+      node
+    );
+  }
+  /**
+   * Transform Loop component to LoopNode IR
+   *
+   * NOTE: V1 control flow is deprecated. Use V3 transformer with useRuntimeVar and max-based Loop.
+   */
+  transformLoop(node) {
+    throw this.createError(
+      "V1 Loop control flow is deprecated. Use V3 transformer with useRuntimeVar and max-based Loop.",
+      node
+    );
+  }
+  /**
+   * Extract useOutput declarations from source file
+   * Returns map of identifier name -> agent name
+   *
+   * Uses forEachDescendant to find declarations inside function bodies,
+   * following the same pattern as extractVariableDeclarations in parser.ts
+   */
+  extractOutputDeclarations(sourceFile) {
+    const outputs = /* @__PURE__ */ new Map();
+    sourceFile.forEachDescendant((node) => {
+      if (!Node.isVariableDeclaration(node)) return;
+      const init = node.getInitializer();
+      if (!init || !Node.isCallExpression(init)) return;
+      const expr = init.getExpression();
+      if (!Node.isIdentifier(expr) || expr.getText() !== "useOutput") return;
+      const args = init.getArguments();
+      if (args.length < 1) return;
+      const agentArg = args[0];
+      if (Node.isStringLiteral(agentArg)) {
+        const agentName = agentArg.getLiteralValue();
+        const identName = node.getName();
+        outputs.set(identName, agentName);
+      }
+    });
+    return outputs;
+  }
+  /**
+   * Extract useStateRef declarations from source file
+   * Returns map of identifier name -> state key
+   *
+   * Uses forEachDescendant to find declarations inside function bodies,
+   * following the same pattern as extractOutputDeclarations
+   */
+  extractStateRefDeclarations(sourceFile) {
+    const stateRefs = /* @__PURE__ */ new Map();
+    sourceFile.forEachDescendant((node) => {
+      if (!Node.isVariableDeclaration(node)) return;
+      const init = node.getInitializer();
+      if (!init || !Node.isCallExpression(init)) return;
+      const expr = init.getExpression();
+      if (!Node.isIdentifier(expr) || expr.getText() !== "useStateRef") return;
+      const args = init.getArguments();
+      if (args.length < 1) return;
+      const keyArg = args[0];
+      if (Node.isStringLiteral(keyArg)) {
+        const stateKey = keyArg.getLiteralValue();
+        const identName = node.getName();
+        stateRefs.set(identName, stateKey);
+      }
+    });
+    return stateRefs;
+  }
+  /**
+   * Transform ReadState JSX element into IR node
+   *
+   * Extracts:
+   * - state: StateRef with key property
+   * - into: VariableRef with name property
+   * - field: optional nested path string
+   */
+  transformReadState(node) {
+    const openingElement = Node.isJsxElement(node) ? node.getOpeningElement() : node;
+    const stateAttr = openingElement.getAttribute("state");
+    if (!stateAttr || !Node.isJsxAttribute(stateAttr)) {
+      throw this.createError("ReadState requires state prop", openingElement);
+    }
+    const stateInit = stateAttr.getInitializer();
+    if (!stateInit || !Node.isJsxExpression(stateInit)) {
+      throw this.createError("ReadState state prop must be JSX expression", openingElement);
+    }
+    const stateExpr = stateInit.getExpression();
+    if (!stateExpr) {
+      throw this.createError("ReadState state prop expression is empty", openingElement);
+    }
+    const stateKey = this.extractStateKey(stateExpr, openingElement);
+    const intoAttr = openingElement.getAttribute("into");
+    if (!intoAttr || !Node.isJsxAttribute(intoAttr)) {
+      throw this.createError("ReadState requires into prop", openingElement);
+    }
+    const intoInit = intoAttr.getInitializer();
+    if (!intoInit || !Node.isJsxExpression(intoInit)) {
+      throw this.createError("ReadState into prop must be JSX expression", openingElement);
+    }
+    const intoExpr = intoInit.getExpression();
+    if (!intoExpr) {
+      throw this.createError("ReadState into prop expression is empty", openingElement);
+    }
+    const variableName = this.extractVariableName(intoExpr, openingElement);
+    const fieldAttr = openingElement.getAttribute("field");
+    let field;
+    if (fieldAttr && Node.isJsxAttribute(fieldAttr)) {
+      const fieldInit = fieldAttr.getInitializer();
+      if (fieldInit && Node.isStringLiteral(fieldInit)) {
+        field = fieldInit.getLiteralText();
+      }
+    }
+    return {
+      kind: "readState",
+      stateKey,
+      variableName,
+      field
+    };
+  }
+  /**
+   * Extract state key from StateRef expression
+   * Handles: identifier pointing to useStateRef result
+   */
+  extractStateKey(expr, element) {
+    if (Node.isIdentifier(expr)) {
+      const name = expr.getText();
+      const tracked = this.stateRefs.get(name);
+      if (tracked) return tracked;
+      throw this.createError(
+        `State reference '${name}' not found. Did you declare it with useStateRef()?`,
+        element
+      );
+    }
+    throw this.createError(`Cannot extract state key from: ${expr.getText()}`, element);
+  }
+  /**
+   * Extract variable name from VariableRef expression
+   * Handles: identifier pointing to useVariable result
+   */
+  extractVariableName(expr, element) {
+    if (Node.isIdentifier(expr)) {
+      const name = expr.getText();
+      const tracked = this.variables.get(name);
+      if (tracked) return tracked.envName;
+      throw this.createError(
+        `Variable '${name}' not found. Did you declare it with useVariable()?`,
+        element
+      );
+    }
+    throw this.createError(`Cannot extract variable name from: ${expr.getText()}`, element);
+  }
+  /**
+   * Transform WriteState JSX element into IR node
+   *
+   * Two modes:
+   * 1. Field mode: field="path" value={val}
+   * 2. Merge mode: merge={partial}
+   */
+  transformWriteState(node) {
+    const openingElement = Node.isJsxElement(node) ? node.getOpeningElement() : node;
+    const stateAttr = openingElement.getAttribute("state");
+    if (!stateAttr || !Node.isJsxAttribute(stateAttr)) {
+      throw this.createError("WriteState requires state prop", openingElement);
+    }
+    const stateInit = stateAttr.getInitializer();
+    if (!stateInit || !Node.isJsxExpression(stateInit)) {
+      throw this.createError("WriteState state prop must be JSX expression", openingElement);
+    }
+    const stateExpr = stateInit.getExpression();
+    if (!stateExpr) {
+      throw this.createError("WriteState state prop expression is empty", openingElement);
+    }
+    const stateKey = this.extractStateKey(stateExpr, openingElement);
+    const fieldAttr = openingElement.getAttribute("field");
+    const mergeAttr = openingElement.getAttribute("merge");
+    if (fieldAttr && Node.isJsxAttribute(fieldAttr)) {
+      const fieldInit = fieldAttr.getInitializer();
+      if (!fieldInit || !Node.isStringLiteral(fieldInit)) {
+        throw this.createError("WriteState field prop must be string literal", openingElement);
+      }
+      const field = fieldInit.getLiteralText();
+      const valueAttr = openingElement.getAttribute("value");
+      if (!valueAttr || !Node.isJsxAttribute(valueAttr)) {
+        throw this.createError("WriteState with field requires value prop", openingElement);
+      }
+      const valueInit = valueAttr.getInitializer();
+      if (!valueInit) {
+        throw this.createError("WriteState value prop is empty", openingElement);
+      }
+      let value;
+      if (Node.isStringLiteral(valueInit)) {
+        value = { type: "literal", content: valueInit.getLiteralText() };
+      } else if (Node.isJsxExpression(valueInit)) {
+        const valueExpr = valueInit.getExpression();
+        if (!valueExpr) {
+          throw this.createError("WriteState value expression is empty", openingElement);
+        }
+        if (Node.isIdentifier(valueExpr)) {
+          const varName = valueExpr.getText();
+          const tracked = this.variables.get(varName);
+          if (tracked) {
+            value = { type: "variable", content: tracked.envName };
+          } else {
+            value = { type: "literal", content: valueExpr.getText() };
+          }
+        } else {
+          value = { type: "literal", content: valueExpr.getText() };
+        }
+      } else {
+        throw this.createError("WriteState value must be string or expression", openingElement);
+      }
+      return {
+        kind: "writeState",
+        stateKey,
+        mode: "field",
+        field,
+        value
+      };
+    } else if (mergeAttr && Node.isJsxAttribute(mergeAttr)) {
+      const mergeInit = mergeAttr.getInitializer();
+      if (!mergeInit || !Node.isJsxExpression(mergeInit)) {
+        throw this.createError("WriteState merge prop must be JSX expression", openingElement);
+      }
+      const mergeExpr = mergeInit.getExpression();
+      if (!mergeExpr) {
+        throw this.createError("WriteState merge expression is empty", openingElement);
+      }
+      const content = mergeExpr.getText();
+      return {
+        kind: "writeState",
+        stateKey,
+        mode: "merge",
+        value: { type: "literal", content }
+      };
+    } else {
+      throw this.createError("WriteState requires either field+value or merge prop", openingElement);
+    }
+  }
+  /**
+   * Transform an OnStatus element to OnStatusNode
+   * OnStatus is a block-level element that emits status-based conditionals
+   */
+  transformOnStatus(node) {
+    const openingElement = Node.isJsxElement(node) ? node.getOpeningElement() : node;
+    const outputAttr = openingElement.getAttribute("output");
+    if (!outputAttr || !Node.isJsxAttribute(outputAttr)) {
+      throw this.createError("OnStatus requires output prop", openingElement);
+    }
+    const outputInit = outputAttr.getInitializer();
+    if (!outputInit || !Node.isJsxExpression(outputInit)) {
+      throw this.createError("OnStatus output must be a JSX expression: output={outputRef}", openingElement);
+    }
+    const outputExpr = outputInit.getExpression();
+    if (!outputExpr || !Node.isIdentifier(outputExpr)) {
+      throw this.createError("OnStatus output must reference a useOutput result", openingElement);
+    }
+    const outputIdentifier = outputExpr.getText();
+    const agentName = this.outputs.get(outputIdentifier);
+    if (!agentName) {
+      throw this.createError(
+        `Output '${outputIdentifier}' not found. Did you declare it with useOutput()?`,
+        openingElement
+      );
+    }
+    const status = getAttributeValue(openingElement, "status");
+    if (!status) {
+      throw this.createError("OnStatus requires status prop", openingElement);
+    }
+    const validStatuses = ["SUCCESS", "BLOCKED", "NOT_FOUND", "ERROR", "CHECKPOINT"];
+    if (!validStatuses.includes(status)) {
+      throw this.createError(
+        `OnStatus status must be one of: ${validStatuses.join(", ")}. Got: ${status}`,
+        openingElement
+      );
+    }
+    const children = Node.isJsxElement(node) ? this.transformBlockChildren(node.getJsxChildren()) : [];
+    return {
+      kind: "onStatus",
+      outputRef: {
+        kind: "outputReference",
+        agent: agentName
+      },
+      status,
+      children
+    };
+  }
+  // ============================================================================
+  // MCP Configuration Transformation
+  // ============================================================================
+  /**
+   * Transform an MCPConfig element to MCPConfigDocumentNode
+   * MCPConfig wraps multiple MCPServer elements into a single document
+   * Delegates to document.ts transformMCPConfig()
+   */
+  transformMCPConfig(node) {
+    return transformMCPConfig(node, this.buildContext());
+  }
+  /**
+   * Transform JSX children to BlockNodes, handling If/Else sibling pairs
+   */
+  transformBlockChildren(jsxChildren) {
+    const blocks = [];
+    let i = 0;
+    while (i < jsxChildren.length) {
+      const child = jsxChildren[i];
+      if (Node.isJsxText(child)) {
+        const text = extractText(child);
+        if (!text) {
+          i++;
+          continue;
+        }
+      }
+      if (Node.isJsxElement(child) || Node.isJsxSelfClosingElement(child)) {
+        const childName = getElementName(child);
+        if (childName === "If") {
+          const ifNode = this.transformIf(child);
+          blocks.push(ifNode);
+          let nextIndex = i + 1;
+          while (nextIndex < jsxChildren.length) {
+            const sibling = jsxChildren[nextIndex];
+            if (Node.isJsxText(sibling)) {
+              const text = extractText(sibling);
+              if (!text) {
+                nextIndex++;
+                continue;
+              }
+            }
+            if ((Node.isJsxElement(sibling) || Node.isJsxSelfClosingElement(sibling)) && getElementName(sibling) === "Else") {
+              const elseNode = this.transformElse(sibling);
+              blocks.push(elseNode);
+              i = nextIndex;
+            }
+            break;
+          }
+        } else {
+          const block = this.transformToBlock(child);
+          if (block) blocks.push(block);
+        }
+      } else {
+        const block = this.transformToBlock(child);
+        if (block) blocks.push(block);
+      }
+      i++;
+    }
+    return blocks;
+  }
+  /**
+   * Transform an Assign element to AssignNode
+   * Assign emits a bash code block with variable assignment
+   *
+   * Supports three assignment types (exactly one required):
+   * - bash: VAR=$(command)
+   * - value: VAR=value (quoted if spaces)
+   * - env: VAR=$ENV_VAR
+   */
+  transformAssign(node) {
+    const openingElement = Node.isJsxElement(node) ? node.getOpeningElement() : node;
+    const varAttr = openingElement.getAttribute("var");
+    if (!varAttr || !Node.isJsxAttribute(varAttr)) {
+      throw this.createError("Assign requires var prop", openingElement);
+    }
+    const init = varAttr.getInitializer();
+    if (!init || !Node.isJsxExpression(init)) {
+      throw this.createError("Assign var must be a JSX expression: var={variableName}", openingElement);
+    }
+    const expr = init.getExpression();
+    if (!expr) {
+      throw this.createError("Assign var must reference a useVariable or defineVars result", openingElement);
+    }
+    let localName;
+    if (Node.isIdentifier(expr)) {
+      localName = expr.getText();
+    } else if (Node.isPropertyAccessExpression(expr)) {
+      localName = expr.getText();
+    } else {
+      throw this.createError("Assign var must reference a useVariable or defineVars result", openingElement);
+    }
+    const variable = this.variables.get(localName);
+    if (!variable) {
+      throw this.createError(
+        `Variable '${localName}' not found. Did you declare it with useVariable() or defineVars()?`,
+        openingElement
+      );
+    }
+    const bashProp = this.extractAssignPropValue(openingElement, "bash");
+    const valueProp = this.extractAssignPropValue(openingElement, "value");
+    const envProp = this.extractAssignPropValue(openingElement, "env");
+    const propCount = [bashProp, valueProp, envProp].filter((p) => p !== void 0).length;
+    if (propCount === 0) {
+      throw this.createError(
+        "Assign requires one of: bash, value, or env prop",
+        openingElement
+      );
+    }
+    if (propCount > 1) {
+      throw this.createError(
+        "Assign accepts only one of: bash, value, or env prop",
+        openingElement
+      );
+    }
+    let assignment;
+    if (bashProp !== void 0) {
+      assignment = { type: "bash", content: bashProp };
+    } else if (valueProp !== void 0) {
+      assignment = { type: "value", content: valueProp };
+    } else {
+      assignment = { type: "env", content: envProp };
+    }
+    const commentProp = this.extractAssignPropValue(openingElement, "comment");
+    return {
+      kind: "assign",
+      variableName: variable.envName,
+      assignment,
+      ...commentProp && { comment: commentProp }
+    };
+  }
+  /**
+   * Transform an AssignGroup element to AssignGroupNode
+   * AssignGroup collects Assign children into a single bash code block
+   */
+  transformAssignGroup(node) {
+    if (Node.isJsxSelfClosingElement(node)) {
+      throw this.createError("AssignGroup must have Assign children", node);
+    }
+    const children = node.getJsxChildren();
+    const assignments = [];
+    let pendingBlankBefore = false;
+    for (const child of children) {
+      if (Node.isJsxText(child)) {
+        const text = child.getText().trim();
+        if (text === "") continue;
+        throw this.createError("AssignGroup can only contain Assign or br elements, not text", child);
+      }
+      if (!Node.isJsxElement(child) && !Node.isJsxSelfClosingElement(child)) {
+        throw this.createError("AssignGroup can only contain Assign or br elements", child);
+      }
+      const opening = Node.isJsxElement(child) ? child.getOpeningElement() : child;
+      const tagNameNode = opening.getTagNameNode();
+      const name = tagNameNode.getText();
+      if (name === "br") {
+        pendingBlankBefore = true;
+        continue;
+      }
+      if (name !== "Assign") {
+        throw this.createError(`AssignGroup can only contain Assign or br elements, found: ${name}`, child);
+      }
+      const assignNode = this.transformAssign(child);
+      if (pendingBlankBefore) {
+        assignNode.blankBefore = true;
+        pendingBlankBefore = false;
+      }
+      assignments.push(assignNode);
+    }
+    if (assignments.length === 0) {
+      throw this.createError("AssignGroup must contain at least one Assign element", node);
+    }
+    return {
+      kind: "assignGroup",
+      assignments
+    };
+  }
+  /**
+   * Extract assignment prop value from Assign element
+   * Handles string literals, JSX expressions with strings, and template literals
+   */
+  extractAssignPropValue(element, propName) {
+    const attr = element.getAttribute(propName);
+    if (!attr || !Node.isJsxAttribute(attr)) return void 0;
+    const init = attr.getInitializer();
+    if (!init) return void 0;
+    if (Node.isStringLiteral(init)) {
+      return init.getLiteralValue();
+    }
+    if (Node.isJsxExpression(init)) {
+      const expr = init.getExpression();
+      if (!expr) return void 0;
+      if (Node.isStringLiteral(expr)) {
+        return expr.getLiteralValue();
+      }
+      if (Node.isNoSubstitutionTemplateLiteral(expr)) {
+        return expr.getLiteralValue();
+      }
+      if (Node.isTemplateExpression(expr)) {
+        return this.extractBashTemplate(expr);
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Extract template literal content preserving ${VAR} syntax for bash
+   */
+  extractBashTemplate(expr) {
+    const parts = [];
+    parts.push(expr.getHead().getLiteralText());
+    for (const span of expr.getTemplateSpans()) {
+      const spanExpr = span.getExpression();
+      parts.push(`\${${spanExpr.getText()}}`);
+      parts.push(span.getLiteral().getLiteralText());
+    }
+    return parts.join("");
+  }
+  /**
+   * Extract prompt prop value, preserving multi-line content and {variable} placeholders
+   * Supports: prompt="string", prompt={"string"}, prompt={`template`}
+   */
+  extractPromptProp(element) {
+    const attr = element.getAttribute("prompt");
+    if (!attr || !Node.isJsxAttribute(attr)) {
+      return void 0;
+    }
+    const init = attr.getInitializer();
+    if (!init) {
+      return void 0;
+    }
+    if (Node.isStringLiteral(init)) {
+      return init.getLiteralValue();
+    }
+    if (Node.isJsxExpression(init)) {
+      const expr = init.getExpression();
+      if (!expr) {
+        return void 0;
+      }
+      if (Node.isStringLiteral(expr)) {
+        return expr.getLiteralValue();
+      }
+      if (Node.isNoSubstitutionTemplateLiteral(expr)) {
+        return expr.getLiteralValue();
+      }
+      if (Node.isTemplateExpression(expr)) {
+        return this.extractTemplateText(expr);
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Extract text from a template expression, converting ${var} to {var}
+   * This preserves GSD's {variable} placeholder syntax
+   */
+  extractTemplateText(expr) {
+    const parts = [];
+    parts.push(expr.getHead().getLiteralText());
+    for (const span of expr.getTemplateSpans()) {
+      const spanExpr = span.getExpression();
+      parts.push(`{${spanExpr.getText()}}`);
+      parts.push(span.getLiteral().getLiteralText());
+    }
+    return parts.join("");
+  }
+  // ============================================================================
+  // State Document Transformation
+  // ============================================================================
+  /**
+   * Transform a State component into StateDocumentNode
+   * Delegates to document.ts transformState()
+   */
+  transformState(node) {
+    return transformState(node, this.buildContext());
+  }
+  /**
+   * Evaluate a binary expression that represents string concatenation.
+   * Handles chains like: `text ` + AGENT_PATHS.researcher + ` more`
+   * Returns the concatenated string or null if not evaluable.
+   */
+  evaluateStringConcatenation(expr) {
+    const operator = expr.getOperatorToken().getText();
+    if (operator !== "+") {
+      return null;
+    }
+    const left = expr.getLeft();
+    const right = expr.getRight();
+    const leftValue = this.evaluateStringExpression(left);
+    const rightValue = this.evaluateStringExpression(right);
+    if (leftValue === null || rightValue === null) {
+      return null;
+    }
+    return leftValue + rightValue;
+  }
+  /**
+   * Evaluate an expression that should resolve to a string value.
+   * Handles: string literals, template literals, property access, binary expressions.
+   */
+  evaluateStringExpression(expr) {
+    if (Node.isStringLiteral(expr)) {
+      return expr.getLiteralValue();
+    }
+    if (Node.isNoSubstitutionTemplateLiteral(expr)) {
+      return expr.getLiteralValue();
+    }
+    if (Node.isTemplateExpression(expr)) {
+      let result = expr.getHead().getLiteralText();
+      for (const span of expr.getTemplateSpans()) {
+        const spanExpr = span.getExpression();
+        const spanValue = this.evaluateStringExpression(spanExpr);
+        if (spanValue !== null) {
+          result += spanValue;
+        } else if (Node.isIdentifier(spanExpr)) {
+          result += `\${${spanExpr.getText()}}`;
+        } else {
+          result += `\${${spanExpr.getText()}}`;
+        }
+        const literal = span.getLiteral();
+        if (Node.isTemplateMiddle(literal)) {
+          result += literal.getLiteralText();
+        } else if (Node.isTemplateTail(literal)) {
+          result += literal.getLiteralText();
+        }
+      }
+      return result;
+    }
+    if (Node.isPropertyAccessExpression(expr)) {
+      return this.resolvePropertyAccess(expr);
+    }
+    if (Node.isBinaryExpression(expr)) {
+      return this.evaluateStringConcatenation(expr);
+    }
+    if (Node.isParenthesizedExpression(expr)) {
+      return this.evaluateStringExpression(expr.getExpression());
+    }
+    return null;
+  }
+  /**
+   * Resolve a property access expression (e.g., AGENT_PATHS.researcher) to its value.
+   * Only works for const declarations with object literals.
+   */
+  resolvePropertyAccess(expr) {
+    const objectExpr = expr.getExpression();
+    const propertyName = expr.getName();
+    if (!Node.isIdentifier(objectExpr)) {
+      return null;
+    }
+    const objectName = objectExpr.getText();
+    const sourceFile = expr.getSourceFile();
+    const varDecls = sourceFile.getVariableDeclarations();
+    for (const varDecl of varDecls) {
+      if (varDecl.getName() === objectName) {
+        let initializer = varDecl.getInitializer();
+        if (initializer && Node.isAsExpression(initializer)) {
+          initializer = initializer.getExpression();
+        }
+        if (initializer && Node.isObjectLiteralExpression(initializer)) {
+          for (const prop of initializer.getProperties()) {
+            if (Node.isPropertyAssignment(prop) && prop.getName() === propertyName) {
+              const propInit = prop.getInitializer();
+              if (propInit && Node.isStringLiteral(propInit)) {
+                return propInit.getLiteralValue();
+              }
+              if (propInit && Node.isNoSubstitutionTemplateLiteral(propInit)) {
+                return propInit.getLiteralValue();
+              }
+            }
+          }
+        }
+        break;
+      }
+    }
+    return null;
+  }
+};
+function transform(node, sourceFile) {
+  const transformer = new Transformer();
+  return transformer.transform(node, sourceFile);
+}
+
+// src/primitives/schema.ts
+function defineVars(schema) {
+  const result = {};
+  for (const key of Object.keys(schema)) {
+    result[key] = { name: key, ref: key };
+  }
+  return result;
+}
+function defineFiles(schema) {
+  const result = {};
+  const refs = [];
+  for (const key of Object.keys(schema)) {
+    const def = schema[key];
+    const varName = key.replace(/([a-z])([A-Z])/g, "$1_$2").toUpperCase() + "_CONTENT";
+    const pathValue = typeof def.path === "function" ? def.path({}) : def.path;
+    const fileRef = {
+      varName,
+      key,
+      path: pathValue,
+      required: def.required !== false
+      // Default true
+    };
+    result[key] = fileRef;
+    refs.push(fileRef);
+  }
+  return {
+    ...result,
+    _refs: refs
+  };
+}
+function defineContext(def) {
+  const agents = {};
+  if (def.agents) {
+    for (const [key, value] of Object.entries(def.agents)) {
+      if (typeof value === "string") {
+        agents[key] = { path: value };
+      } else {
+        agents[key] = value;
+      }
+    }
+  }
+  return {
+    agents,
+    vars: def.vars || {},
+    files: def.files || { _refs: [] }
+  };
+}
+
+// src/workflow/sections/semantic.ts
+function ExecutionContext(_props) {
+  return null;
+}
+export {
+  ASK_USER_MARKER,
+  Agent,
+  AskUser,
+  BREAK_MARKER,
+  Break,
+  Command,
+  ELSE_MARKER,
+  Else,
+  ExecutionContext,
+  IF_MARKER,
+  If,
+  Indent,
+  LOOP_MARKER,
+  List,
+  Loop,
+  Markdown,
+  OnStatus,
+  RETURN_MARKER,
+  Return,
+  RuntimeMarkdownEmitter,
+  SpawnAgent,
+  Table,
+  Transformer,
+  XmlBlock,
+  assertNever,
+  buildRuntimeFile,
+  bundleCodeSplit,
+  bundleSingleEntryRuntime,
+  clearRuntimeFnRegistry,
+  createProject,
+  createRuntimeContext,
+  defineAgent,
+  defineContext,
+  defineFiles,
+  defineVars,
+  detectRuntime,
+  emit,
+  emitAgent,
+  emitDocument,
+  emitRuntime,
+  emitSettings,
+  emitSkill,
+  emitSkillFile,
+  extractExportedFunctionNames,
+  extractExternalComponentDeclarations,
+  extractFunctions,
+  extractInputObjectLiteral,
+  extractInterfaceProperties,
+  extractLocalComponentDeclarations,
+  extractPromptPlaceholders,
+  extractRuntimeFnDeclarations,
+  extractRuntimeVarDeclarations,
+  extractText,
+  extractTypeArguments,
+  extractVariableDeclarations,
+  findRootJsxElement,
+  generateRuntime,
+  getAgentName,
+  getAgentPath,
+  getArrayAttributeValue,
+  getAttributeValue,
+  getElementName,
+  getJsxChildren,
+  getRuntimeFn,
+  getRuntimeFnRegistry,
+  getRuntimeFunctionNames,
+  getRuntimeImportPaths,
+  getRuntimeVarInfo,
+  hasRuntimeImports,
+  isAgentRef,
+  isDocument,
+  isRuntimeFile,
+  isRuntimeFn,
+  isRuntimeNode,
+  isRuntimeVar,
+  isWhitespaceOnlyText,
+  mergeSettings,
+  normalizeWhitespace,
+  parseFile,
+  parseSource,
+  resolveTypeImport,
+  runtimeFn,
+  toJqExpression,
+  toJqPath,
+  transform,
+  transformRuntimeBlockChildren,
+  transformRuntimeCommand,
+  transformToRuntimeBlock,
+  useOutput,
+  useRuntimeVar
+};
+//# sourceMappingURL=index.js.map