@meistrari/tela-cli 1.3.0 → 1.5.0

package/dist/index.js

@@ -146996,7 +146996,7 @@ var require_contracts = __commonJS({
   "../../packages/workflow-code/dist/contracts.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.BUILD_BINDING = exports2.CODE_BINDING = exports2.CODE_DIAGNOSTICS = exports2.REMOTE_REF_BINDING = void 0;
+    exports2.CONDITION_BINDING = exports2.BUILD_BINDING = exports2.CODE_BINDING = exports2.CODE_DIAGNOSTICS = exports2.REMOTE_REF_BINDING = void 0;
     exports2.REMOTE_REF_BINDING = /* @__PURE__ */ Symbol.for("@meistrari/workflow-code/remote-ref-binding");
     exports2.CODE_DIAGNOSTICS = Object.freeze({
       missingHandlerBinding: "code.source.missing_handler_binding",
@@ -147019,6 +147019,7 @@ var require_contracts = __commonJS({
     });
     exports2.CODE_BINDING = /* @__PURE__ */ Symbol.for("@meistrari/workflow-code/code-binding");
     exports2.BUILD_BINDING = /* @__PURE__ */ Symbol.for("@meistrari/workflow-code/build-binding");
+    exports2.CONDITION_BINDING = /* @__PURE__ */ Symbol.for("@meistrari/workflow-code/condition-binding");
   }
 });
 
@@ -154670,6 +154671,7 @@ var require_ids = __commonJS({
     exports2.defaultInputPortId = defaultInputPortId;
     exports2.defaultOutputPortId = defaultOutputPortId;
     exports2.subgraphOutputPortId = subgraphOutputPortId;
+    exports2.branchOutputPortId = branchOutputPortId;
     exports2.defaultEdgeId = defaultEdgeId;
     exports2.slugId = slugId;
     function stableInputId(workflowKey, input, index) {
@@ -154687,6 +154689,9 @@ var require_ids = __commonJS({
     function subgraphOutputPortId(nodeId) {
       return `${nodeId}:out:subgraph`;
     }
+    function branchOutputPortId(nodeId, branchIndex) {
+      return `${nodeId}:out:branch:${branchIndex}`;
+    }
     function defaultEdgeId(sourcePortId, targetPortId) {
       return `from_${sourcePortId}_to_${targetPortId}`.replace(/[^\w:-]+/g, "_");
     }
@@ -154769,6 +154774,23 @@ var require_remote = __commonJS({
   }
 });
 
+// ../../packages/workflow-code/dist/authoring/condition-provenance.js
+var require_condition_provenance = __commonJS({
+  "../../packages/workflow-code/dist/authoring/condition-provenance.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.trustConditionBinding = trustConditionBinding;
+    exports2.isTrustedConditionBinding = isTrustedConditionBinding;
+    var trustedConditionBindings = /* @__PURE__ */ new WeakMap();
+    function trustConditionBinding(declaration, binding) {
+      trustedConditionBindings.set(binding, declaration);
+    }
+    function isTrustedConditionBinding(declaration, binding) {
+      return trustedConditionBindings.get(binding) === declaration;
+    }
+  }
+});
+
 // ../../packages/workflow-code/dist/vault/reference.js
 var require_reference = __commonJS({
   "../../packages/workflow-code/dist/vault/reference.js"(exports2) {
@@ -368614,6 +368636,7 @@ var require_imports = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.collectPreservedImports = collectPreservedImports;
     exports2.collectMissingPackageImportDiagnostics = collectMissingPackageImportDiagnostics;
+    exports2.collectUnsupportedConditionImportDiagnostics = collectUnsupportedConditionImportDiagnostics;
     exports2.mergeLibraries = mergeLibraries;
     exports2.packageNameFromSpecifier = packageNameFromSpecifier;
     var node_module_1 = require("node:module");
@@ -368660,6 +368683,20 @@ var require_imports = __commonJS({
       }
       return [...diagnosticsByBuiltin.values(), ...diagnosticsByPackage.values()];
     }
+    function collectUnsupportedConditionImportDiagnostics(closureNodes, resolutionContext) {
+      const referenced = collectReferencedIdentifiersFromNodes(closureNodes);
+      const sourceFiles = new Set(closureNodes.map(sourceFileForNode).filter((sourceFile) => Boolean(sourceFile)));
+      const diagnosticsBySpecifier = /* @__PURE__ */ new Map();
+      for (const { specifier } of collectReferencedExternalImports(sourceFiles, referenced, resolutionContext)) {
+        diagnosticsBySpecifier.set(specifier, {
+          code: "condition.source.unsupported_package_import",
+          severity: "error",
+          message: `Condition predicate imports package "${specifier}", but condition expressions cannot load runtime packages.`,
+          hint: "Move the package-dependent logic into a prior code() node and reference its output from the condition predicate."
+        });
+      }
+      return [...diagnosticsBySpecifier.values()];
+    }
     function collectReferencedExternalImports(sourceFiles, referenced, resolutionContext) {
       const imports = [];
       for (const sourceFile of sourceFiles) {
@@ -368782,7 +368819,7 @@ var require_output_schema = __commonJS({
   "../../packages/workflow-code/dist/compiler/output-schema.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.CROP_OUTPUT_JSON_SCHEMA = exports2.SPLITTER_OUTPUT_JSON_SCHEMA = exports2.FILE_INPUT_JSON_SCHEMA = exports2.FILE_OUTPUT_JSON_SCHEMA = void 0;
+    exports2.DOC_TEMPLATE_OUTPUT_JSON_SCHEMA = exports2.CROP_OUTPUT_JSON_SCHEMA = exports2.SPLITTER_OUTPUT_JSON_SCHEMA = exports2.FILE_INPUT_JSON_SCHEMA = exports2.FILE_OUTPUT_JSON_SCHEMA = void 0;
     exports2.createPromptOutputJsonSchema = createPromptOutputJsonSchema;
     exports2.selectOutputJsonSchema = selectOutputJsonSchema;
     exports2.isFileCompatibleOutputJsonSchema = isFileCompatibleOutputJsonSchema;
@@ -368834,6 +368871,17 @@ var require_output_schema = __commonJS({
         required: Object.freeze(["indexes", "originalFile", "file"])
       })
     });
+    exports2.DOC_TEMPLATE_OUTPUT_JSON_SCHEMA = Object.freeze({
+      type: "object",
+      properties: Object.freeze({
+        generatedDocument: exports2.FILE_OUTPUT_JSON_SCHEMA,
+        generatedAt: Object.freeze({ type: "string" }),
+        permalinkUrl: Object.freeze({ type: "string" }),
+        permalinkId: Object.freeze({ type: "string" }),
+        permalinkExpiresAt: Object.freeze({ anyOf: Object.freeze([{ type: "string" }, { type: "null" }]) })
+      }),
+      required: Object.freeze(["generatedDocument", "generatedAt"])
+    });
     function createPromptOutputJsonSchema(schema) {
       return schema === void 0 || schema === null ? void 0 : { type: "object", properties: schema };
     }
@@ -369176,7 +369224,7 @@ var require_rewrite_refs = __commonJS({
       const targetInfo = targetResolution.target;
       const targetKey = targetInfo?.effectiveKey ?? target.text;
       if (!targetInfo) {
-        diagnostics.push(targetResolution.unsupportedDynamicBuildArray ? unsupportedDynamicBuildArray(targetKey, context.nodeName) : unknownTarget(targetKey, context.nodeName));
+        diagnostics.push(unresolvedTargetDiagnostic(targetResolution, targetKey, context.nodeName));
         return void 0;
       }
       if (targetInfo.nodeIndex !== void 0 && targetInfo.nodeIndex >= context.currentNodeIndex) {
@@ -369189,6 +369237,15 @@ var require_rewrite_refs = __commonJS({
         expression = safeAccess(expression, segment);
       return expression;
     }
+    function unresolvedTargetDiagnostic(targetResolution, targetKey, nodeName) {
+      if (targetResolution.unsupportedDynamicBuildArray)
+        return unsupportedDynamicBuildArray(targetKey, nodeName);
+      if (targetResolution.refFailure === "forward")
+        return forwardReference(targetKey, nodeName);
+      if (targetResolution.refFailure === "scope")
+        return scopeReference(targetKey, nodeName);
+      return unknownTarget(targetKey, nodeName);
+    }
     function extractPath(node, expectedTarget, context, diagnostics) {
       const segments = [];
       let current = node;
@@ -369259,6 +369316,13 @@ var require_rewrite_refs = __commonJS({
         hint: `Move "${targetKey}" before "${nodeName}" or remove the reference.`
       };
     }
+    function scopeReference(targetKey, nodeName) {
+      return {
+        code: "code.ref.scope_reference",
+        severity: "error",
+        message: `Code node "${nodeName}" references "${targetKey}", but that node is outside the visible scope.`
+      };
+    }
     function unsupportedStandalonePaths(nodeName) {
       return {
         code: "code.ref.unsupported_paths",
@@ -369272,6 +369336,149 @@ var require_rewrite_refs = __commonJS({
   }
 });
 
+// ../../packages/workflow-code/dist/compiler/refs.js
+var require_refs = __commonJS({
+  "../../packages/workflow-code/dist/compiler/refs.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.resolvePromptRefs = resolvePromptRefs;
+    exports2.resolveReferenceRecordRefs = resolveReferenceRecordRefs;
+    exports2.resolveWorkflowRef = resolveWorkflowRef;
+    exports2.resolveExclusiveRef = resolveExclusiveRef;
+    exports2.resolveVisibleNodeIdentity = resolveVisibleNodeIdentity;
+    var workflow_shared_1 = require_cjs2();
+    function resolvePromptRefs(context) {
+      const diagnostics = [];
+      let prompt = context.prompt;
+      for (const ref of context.refs) {
+        const resolved = resolveWorkflowRef(ref, context);
+        diagnostics.push(...resolved.diagnostics);
+        if (!resolved.reference)
+          continue;
+        prompt = prompt.split(ref.token).join(resolved.reference);
+      }
+      return { prompt, diagnostics };
+    }
+    function resolveReferenceRecordRefs(context) {
+      const diagnostics = [];
+      const values = { ...context.values };
+      for (const ref of context.refs) {
+        const resolved = resolveWorkflowRef(ref, context);
+        if (resolved.reference) {
+          values[ref.key] = resolved.reference;
+          continue;
+        }
+        diagnostics.push(...resolved.diagnostics.map((diagnostic) => ({
+          ...diagnostic,
+          message: diagnostic.message.replace("Prompt reference", `Reference record ${ref.key} reference`)
+        })));
+      }
+      return { values: Object.freeze(values), diagnostics };
+    }
+    function resolveWorkflowRef(ref, context) {
+      const resolved = ref.targetKind === "input" ? resolveInputRef(ref, context) : resolveNodeRef(ref, context);
+      if (!resolved) {
+        return {
+          diagnostics: [{
+            code: "compiler.ref.dangling",
+            severity: "error",
+            message: `Prompt reference ${ref.targetKey} does not match a workflow input or previous node`
+          }]
+        };
+      }
+      if (resolved === "forward") {
+        return {
+          diagnostics: [{
+            code: "compiler.ref.forward",
+            severity: "error",
+            message: `Prompt reference ${ref.targetKey} points to a future workflow node`
+          }]
+        };
+      }
+      if (resolved === "scope") {
+        return {
+          diagnostics: [{
+            code: "compiler.ref.scope",
+            severity: "error",
+            message: `Prompt reference ${ref.targetKey} points to a workflow node outside the visible scope`
+          }]
+        };
+      }
+      return {
+        reference: resolved.reference,
+        inputType: "inputType" in resolved ? resolved.inputType : void 0,
+        nodeId: "nodeId" in resolved ? resolved.nodeId : void 0,
+        diagnostics: []
+      };
+    }
+    function resolveExclusiveRef(ref, context) {
+      const resolved = resolveWorkflowRef(ref, context);
+      if (resolved.reference)
+        return resolved;
+      return {
+        diagnostics: resolved.diagnostics.map((diagnostic) => ({
+          ...diagnostic,
+          message: diagnostic.message.replace("Prompt reference", "Exclusive reference")
+        }))
+      };
+    }
+    function resolveInputRef(ref, context) {
+      const id = context.inputIdsByKey.get(ref.targetKey);
+      if (!id)
+        return void 0;
+      const reference = workflow_shared_1.InputReferenceURI.fromVariable({ name: id });
+      return {
+        reference: formatPromptReference(reference, ref),
+        inputType: context.inputTypesByKey?.get(ref.targetKey)
+      };
+    }
+    function resolveNodeRef(ref, context) {
+      const candidates = context.nodeIdentitiesByKey.get(ref.targetKey) ?? [];
+      if (candidates.length === 0)
+        return void 0;
+      const visible = resolveVisibleNodeIdentity(ref.targetKey, context);
+      if (visible) {
+        const reference = workflow_shared_1.ActionOutputReferenceURI.fromStepId(visible.id);
+        return { reference: formatPromptReference(reference, ref), nodeId: visible.id };
+      }
+      if (candidates.some((candidate) => samePath(candidate.scopePath, context.currentNode.scopePath) && candidate.sequenceIndex >= context.currentNode.sequenceIndex)) {
+        return "forward";
+      }
+      return "scope";
+    }
+    function resolveVisibleNodeIdentity(key, context) {
+      const currentScopeCandidate = resolvePriorCandidateInScope(key, context.currentNode.scopePath, context.currentNode.sequenceIndex, context);
+      if (currentScopeCandidate)
+        return currentScopeCandidate;
+      for (const boundary of [...context.currentNode.ancestorScopes].reverse()) {
+        const candidate = resolvePriorCandidateInScope(key, boundary.scopePath, boundary.sequenceIndex, context);
+        if (candidate)
+          return candidate;
+      }
+      return void 0;
+    }
+    function resolvePriorCandidateInScope(key, scopePath, beforeSequenceIndex, context) {
+      const candidates = (context.nodeIdentitiesByKey.get(key) ?? []).filter((candidate) => samePath(candidate.scopePath, scopePath) && candidate.sequenceIndex < beforeSequenceIndex).sort((left, right) => right.sequenceIndex - left.sequenceIndex);
+      const nearest = candidates[0];
+      if (!nearest)
+        return void 0;
+      if (candidates.filter((candidate) => candidate.sequenceIndex === nearest.sequenceIndex).length > 1)
+        return void 0;
+      return nearest;
+    }
+    function samePath(left, right) {
+      return left.length === right.length && left.every((segment, index) => segment === right[index]);
+    }
+    function formatPromptReference(reference, ref) {
+      if (ref.path && ref.path.length > 0)
+        reference.appendPath([...ref.path]);
+      if ("format" in ref && ref.format)
+        reference.setFormat(ref.format);
+      return reference.toReference();
+    }
+  }
+});
+
 // ../../packages/workflow-code/dist/compiler/code-extraction/extract.js
 var require_extract3 = __commonJS({
   "../../packages/workflow-code/dist/compiler/code-extraction/extract.js"(exports2) {
@@ -369281,6 +369488,7 @@ var require_extract3 = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.extractInlineCode = extractInlineCode;
+    exports2.extractConditionExpression = extractConditionExpression;
     exports2.resolveBuiltRefTargetResult = resolveBuiltRefTargetResult;
     exports2.resolveIdentifierDeclarationWithChecker = resolveIdentifierDeclarationWithChecker;
     var typescript_1 = __importDefault(require_typescript3());
@@ -369290,7 +369498,10 @@ var require_extract3 = __commonJS({
     var program_1 = require_program();
     var rewrite_refs_1 = require_rewrite_refs();
     var output_schema_2 = require_output_schema();
+    var refs_1 = require_refs();
+    var condition_provenance_1 = require_condition_provenance();
     var RESERVED_RUNTIME_DECLARATION_NAMES = /* @__PURE__ */ new Set(["execute", "TelaInput"]);
+    var READ_ONLY_OBJECT_INSPECTION_METHODS = /* @__PURE__ */ new Set(["keys", "hasOwn", "isFrozen", "isSealed", "isExtensible"]);
     function extractInlineCode(input) {
       const binding = input.node[contracts_1.CODE_BINDING];
       if (!binding) {
@@ -369356,7 +369567,9 @@ var require_extract3 = __commonJS({
         nodeName: input.node.name,
         inputNamesByKey: input.inputNamesByKey,
         nodeNamesByKey: input.nodeNamesByKey,
-        nodeIndexesByKey: input.nodeIndexesByKey
+        nodeIndexesByKey: input.nodeIndexesByKey,
+        nodeIdentitiesByKey: input.nodeIdentitiesByKey,
+        currentNode: input.currentNode
       });
       if (rewritten.diagnostics.length > 0)
         return { code: "", diagnostics: rewritten.diagnostics, preservedImports };
@@ -369369,6 +369582,92 @@ var require_extract3 = __commonJS({
         preservedImports
       };
     }
+    function extractConditionExpression(input) {
+      const binding = input.node[contracts_1.CONDITION_BINDING];
+      if (!isConditionBindingObject(binding))
+        return { diagnostics: [diagnostic("condition.source.missing_handler_binding", "Condition node is missing predicate binding")] };
+      if (!(0, condition_provenance_1.isTrustedConditionBinding)(input.node, binding))
+        return { diagnostics: [diagnostic("condition.source.untrusted_binding", "Condition node predicate binding was not produced by Workflow Code authoring evaluation")] };
+      if (!hasOwnFunctionProperty(binding.handlers, input.caseName))
+        return { diagnostics: [diagnostic("condition.source.missing_handler_binding", `Condition case "${input.caseName}" is missing predicate handler binding`)] };
+      if (!binding.source)
+        return { diagnostics: [diagnostic("condition.source.missing_handler", "Condition node is missing source marker")] };
+      const file2 = input.source.files.find((snapshot) => snapshot.path === binding.source?.file);
+      if (!file2)
+        return { diagnostics: [diagnostic("condition.source.missing_handler", "Condition predicate source file was not included in source bundle")] };
+      const sourceProgram = (0, program_1.createSourceProgram)(input.source);
+      const sourceFile = sourceProgram.sourceFilesByPath.get(file2.path) ?? typescript_1.default.createSourceFile(file2.path, file2.content, typescript_1.default.ScriptTarget.ES2022, true, typescript_1.default.ScriptKind.TS);
+      const call = findCodeCall(sourceFile, binding.source.pos, binding.source.end);
+      const predicate = call ? getConditionPredicateExpression(call, input.caseName, sourceProgram.checker, collectStaticDependencySourceFiles(sourceFile, call, input.source.entrypoint, sourceProgram.checker, sourceProgram.sourceFilesByPath)) : void 0;
+      if (!predicate)
+        return { diagnostics: [diagnostic("condition.source.missing_handler", `Condition predicate for case "${input.caseName}" could not be located`)] };
+      if (!isConditionFunction(predicate))
+        return { diagnostics: [diagnostic("condition.source.unsupported_predicate", "Condition predicates must be inline function expressions")] };
+      if (predicate.modifiers?.some((modifier) => modifier.kind === typescript_1.default.SyntaxKind.AsyncKeyword) || "asteriskToken" in predicate && predicate.asteriskToken)
+        return { diagnostics: [diagnostic("condition.source.unsupported_predicate", "Condition predicates must be synchronous non-generator functions")] };
+      if (containsAwait(predicate.body))
+        return { diagnostics: [diagnostic("condition.source.unsupported_predicate", "Condition predicates cannot use await")] };
+      if (!hasPredicateReturn(predicate))
+        return { diagnostics: [diagnostic("condition.source.unsupported_predicate", "Condition predicates must return a boolean")] };
+      const signature = sourceProgram.checker.getSignatureFromDeclaration(predicate);
+      const returnType = signature ? sourceProgram.checker.getReturnTypeOfSignature(signature) : void 0;
+      if (!returnType || isAnyOrUnknown(returnType) || !isBooleanLike(returnType, sourceProgram.checker) || isPromiseLike(returnType, sourceProgram.checker))
+        return { diagnostics: [diagnostic("condition.source.unsupported_predicate", "Condition predicates must return boolean")] };
+      const generatedHandlerName = createGeneratedConditionHandlerName(sourceFile);
+      const helperBindings = collectCodeContextHelperBindings(predicate, generatedHandlerName, sourceProgram.checker);
+      const closure = collectHelperClosure(predicate, generatedHandlerName, "Condition", sourceProgram.checker, helperBindings);
+      const closureNodes = [...closure.declarations, predicate];
+      const closureDiagnostics = [
+        ...closure.diagnostics,
+        ...detectUnsupportedPatterns(closureNodes),
+        ...detectUnsupportedContextHelperPropagation(closureNodes, sourceProgram.checker, helperBindings),
+        ...(0, imports_1.collectUnsupportedConditionImportDiagnostics)(closureNodes, {
+          program: sourceProgram.program,
+          sourceFilePaths: new Set(sourceProgram.sourceFilesByPath.keys())
+        })
+      ];
+      if (closureDiagnostics.length > 0)
+        return { diagnostics: closureDiagnostics };
+      const runtimeSource = createRuntimeSourceFile(sourceFile, [...closure.declarations, createInlineHandlerStatement(generatedHandlerName, predicate)], void 0);
+      const buildSourceFile = input.buildSource ? sourceProgram.sourceFilesByPath.get(input.buildSource.file) : void 0;
+      const rewritten = (0, rewrite_refs_1.rewriteCodeRefs)(runtimeSource, {
+        checker: sourceProgram.checker,
+        helperBindings,
+        builtInputs: input.builtInputs,
+        builtNodes: input.builtNodes,
+        buildSource: input.buildSource,
+        buildSourceFile,
+        currentNodeIndex: input.currentNodeIndex,
+        nodeName: "Condition",
+        inputNamesByKey: input.inputNamesByKey,
+        nodeNamesByKey: input.nodeNamesByKey,
+        nodeIndexesByKey: input.nodeIndexesByKey,
+        nodeIdentitiesByKey: input.nodeIdentitiesByKey,
+        currentNode: input.currentNode
+      });
+      if (rewritten.diagnostics.length > 0)
+        return { diagnostics: rewritten.diagnostics };
+      const rewrittenPredicate = getVariableFunction(rewritten.sourceFile, generatedHandlerName);
+      if (!rewrittenPredicate)
+        return { diagnostics: [diagnostic("condition.source.missing_handler", `Condition predicate for case "${input.caseName}" could not be printed`)] };
+      return {
+        expression: printConditionExpressionWithClosure(rewrittenPredicate, rewritten.sourceFile, generatedHandlerName),
+        diagnostics: []
+      };
+    }
+    function isConditionBindingObject(value) {
+      if (!value || typeof value !== "object")
+        return false;
+      const handlers = value.handlers;
+      const source = value.source;
+      return Boolean(handlers) && typeof handlers === "object" && !Array.isArray(handlers) && (source === void 0 || isWorkflowCodeSourceMarker(source));
+    }
+    function isWorkflowCodeSourceMarker(value) {
+      return Boolean(value) && typeof value === "object" && typeof value.file === "string" && typeof value.pos === "number" && Number.isInteger(value.pos) && value.pos >= 0 && typeof value.end === "number" && Number.isInteger(value.end) && value.end >= value.pos;
+    }
+    function hasOwnFunctionProperty(value, property) {
+      return Object.prototype.hasOwnProperty.call(value, property) && typeof value[property] === "function";
+    }
     function createCodeInputSchemaBindings(input) {
       const inputBindings = input.builtInputs.map((declaration) => ({
         name: declaration.name,
@@ -369376,11 +369675,662 @@ var require_extract3 = __commonJS({
         required: declaration.required
       }));
       const nodeBindings = input.builtNodes.slice(0, input.currentNodeIndex).flatMap((node) => {
-        const schema = input.nodeOutputSchemasById.get(input.nodeIdsByKey.get(node.key ?? node.name) ?? "");
+        const nodeId = input.nodeIdsByKey.get(node.key ?? node.name);
+        const schema = nodeId === void 0 ? void 0 : input.nodeOutputSchemasById.get(nodeId);
         return schema ? [{ name: node.name, schema, required: true }] : [];
       });
       return [...inputBindings, ...nodeBindings];
     }
+    function getConditionPredicateExpression(call, caseName, checker, sourceFiles) {
+      const firstArg = call.arguments[0];
+      if (!firstArg || !typescript_1.default.isObjectLiteralExpression(firstArg))
+        return void 0;
+      const casesExpression = getStaticObjectPropertyValue(firstArg, "cases", checker, /* @__PURE__ */ new Set(), call, sourceFiles);
+      const casesObject = casesExpression ? resolveStaticObjectLiteral(casesExpression, checker, /* @__PURE__ */ new Set(), call, sourceFiles) : void 0;
+      if (!casesObject)
+        return void 0;
+      const caseExpression = getStaticObjectPropertyValue(casesObject, caseName, checker, /* @__PURE__ */ new Set(), call, sourceFiles);
+      const caseObject = caseExpression ? resolveStaticObjectLiteral(caseExpression, checker, /* @__PURE__ */ new Set(), call, sourceFiles) : void 0;
+      if (!caseObject)
+        return void 0;
+      return getStaticObjectPropertyValue(caseObject, "when", checker, /* @__PURE__ */ new Set(), call, sourceFiles);
+    }
+    function getStaticObjectPropertyValue(objectLiteral, propertyName, checker, seen = /* @__PURE__ */ new Set(), sourceNode, sourceFiles = []) {
+      let value;
+      for (const property of objectLiteral.properties) {
+        if (typescript_1.default.isSpreadAssignment(property)) {
+          const spreadSeen = new Set(seen);
+          const spreadObject = resolveStaticObjectLiteral(property.expression, checker, spreadSeen, sourceNode, sourceFiles);
+          if (!spreadObject)
+            return void 0;
+          const spreadValue = getStaticObjectPropertyValue(spreadObject, propertyName, checker, spreadSeen, sourceNode, sourceFiles);
+          if (spreadValue)
+            value = spreadValue;
+          continue;
+        }
+        if (getStaticPropertyNameText(property.name, checker) !== propertyName)
+          continue;
+        if (typescript_1.default.isPropertyAssignment(property))
+          value = property.initializer;
+        else if (typescript_1.default.isShorthandPropertyAssignment(property))
+          value = property.name;
+        else
+          return void 0;
+      }
+      return value;
+    }
+    function resolveStaticObjectLiteral(expression, checker, seen = /* @__PURE__ */ new Set(), sourceNode, sourceFiles = []) {
+      const unwrapped = unwrapStaticExpression(expression);
+      if (typescript_1.default.isObjectLiteralExpression(unwrapped))
+        return unwrapped;
+      if (!typescript_1.default.isIdentifier(unwrapped))
+        return void 0;
+      const declaration = resolveIdentifierDeclarationWithChecker(unwrapped, checker);
+      const initializer3 = declaration && typescript_1.default.isVariableDeclaration(declaration) && declaration.initializer ? unwrapStaticExpression(declaration.initializer) : void 0;
+      if (!declaration || seen.has(declaration) || !typescript_1.default.isVariableDeclaration(declaration) || !isConstVariableDeclaration(declaration) || !initializer3 || !typescript_1.default.isObjectLiteralExpression(initializer3) && !typescript_1.default.isIdentifier(initializer3) || sourceNode !== void 0 && hasPotentialObjectMutationBefore(declaration, checker, sourceNode, sourceFiles)) {
+        return void 0;
+      }
+      seen.add(declaration);
+      return resolveStaticObjectLiteral(initializer3, checker, seen, sourceNode, sourceFiles);
+    }
+    function collectStaticDependencySourceFiles(sourceFile, sourceNode, entrypoint, checker, sourceFilesByPath) {
+      const dependencies = /* @__PURE__ */ new Map();
+      const entrypointSourceFile = sourceFilesByPath.get(entrypoint);
+      const visited = /* @__PURE__ */ new Set();
+      const addDependency = (dependency, end) => {
+        const existing = dependencies.get(dependency.fileName);
+        if (!existing || existing.end < end)
+          dependencies.set(dependency.fileName, { sourceFile: dependency, end });
+      };
+      const collectBeforeSourceNode = (current) => {
+        if (visited.has(current.fileName))
+          return false;
+        visited.add(current.fileName);
+        for (const statement of current.statements) {
+          if (current === sourceFile && statementContainsNode(statement, sourceNode)) {
+            addDependency(current, sourceNode.getStart(current));
+            return true;
+          }
+          const dependency = localModuleSourceFile(statement, checker, sourceFilesByPath);
+          if (!dependency)
+            continue;
+          if (collectBeforeSourceNode(dependency)) {
+            addDependency(current, statement.getFullStart());
+            return true;
+          }
+        }
+        addDependency(current, Number.POSITIVE_INFINITY);
+        return false;
+      };
+      if (entrypointSourceFile)
+        collectBeforeSourceNode(entrypointSourceFile);
+      return [...dependencies.values()];
+    }
+    function statementContainsNode(statement, node) {
+      return statement.getFullStart() <= node.pos && node.end <= statement.end;
+    }
+    function localModuleSourceFile(statement, checker, sourceFilesByPath) {
+      if (!typescript_1.default.isImportDeclaration(statement) && !typescript_1.default.isExportDeclaration(statement) || !isRuntimeModuleReference(statement) || !statement.moduleSpecifier || !typescript_1.default.isStringLiteral(statement.moduleSpecifier)) {
+        return void 0;
+      }
+      return (checker.getSymbolAtLocation(statement.moduleSpecifier)?.declarations ?? []).map((declaration) => sourceFilesByPath.get(declaration.getSourceFile().fileName)).find((sourceFile) => Boolean(sourceFile));
+    }
+    function isRuntimeModuleReference(statement) {
+      if (typescript_1.default.isImportDeclaration(statement)) {
+        const importClause = statement.importClause;
+        if (!importClause)
+          return true;
+        if (importClause.isTypeOnly)
+          return false;
+        if (importClause.name || !importClause.namedBindings || typescript_1.default.isNamespaceImport(importClause.namedBindings))
+          return true;
+        return importClause.namedBindings.elements.length === 0 || importClause.namedBindings.elements.some((element) => !element.isTypeOnly);
+      }
+      if (statement.isTypeOnly || !statement.exportClause || typescript_1.default.isNamespaceExport(statement.exportClause))
+        return !statement.isTypeOnly;
+      return statement.exportClause.elements.length === 0 || statement.exportClause.elements.some((element) => !element.isTypeOnly);
+    }
+    function hasPotentialObjectMutationBefore(declaration, checker, sourceNode, sourceFiles = []) {
+      if (!typescript_1.default.isIdentifier(declaration.name))
+        return true;
+      const declarationSourceFile = declaration.getSourceFile();
+      const candidateSourceFiles = /* @__PURE__ */ new Map();
+      const addCandidate = (candidate) => {
+        const existing = candidateSourceFiles.get(candidate.sourceFile.fileName);
+        if (!existing || existing.end < candidate.end)
+          candidateSourceFiles.set(candidate.sourceFile.fileName, candidate);
+      };
+      addCandidate({
+        sourceFile: declarationSourceFile,
+        end: sourceNode?.getSourceFile() === declarationSourceFile && !isNestedInDeferredFunction(sourceNode) ? sourceNode.getStart(declarationSourceFile) : Number.POSITIVE_INFINITY
+      });
+      for (const sourceFile of sourceFiles)
+        addCandidate(sourceFile);
+      const ignoredCall = sourceNode && typescript_1.default.isCallExpression(sourceNode) ? sourceNode : void 0;
+      return [...candidateSourceFiles.values()].some(({ sourceFile, end }) => {
+        let foundMutation = false;
+        const visit = (node, inDeferredFunction = false, inSourceCall = false) => {
+          const isDeferredFunction = inDeferredFunction || typescript_1.default.isFunctionLike(node);
+          const isSourceCall = inSourceCall || node === sourceNode;
+          if (foundMutation || !isSourceCall && !isDeferredFunction && node.getStart(sourceFile) >= end)
+            return;
+          if (typescript_1.default.isIdentifier(node) && node !== declaration.name && isStaticObjectAliasReference(node, declaration, checker) && isPotentialObjectMutationReference(node, checker, ignoredCall)) {
+            foundMutation = true;
+            return;
+          }
+          typescript_1.default.forEachChild(node, (child) => visit(child, isDeferredFunction, isSourceCall));
+        };
+        visit(sourceFile);
+        return foundMutation;
+      });
+    }
+    function isNestedInDeferredFunction(node) {
+      for (let current = node.parent; current && !typescript_1.default.isSourceFile(current); current = current.parent) {
+        if (typescript_1.default.isFunctionLike(current))
+          return true;
+      }
+      return false;
+    }
+    function isStaticObjectAliasReference(identifier, declaration, checker, seen = /* @__PURE__ */ new Set()) {
+      const resolved = resolveStaticObjectAliasDeclaration(identifier, checker);
+      if (resolved === declaration)
+        return true;
+      if (!resolved || seen.has(resolved)) {
+        return false;
+      }
+      seen.add(resolved);
+      if (typescript_1.default.isBindingElement(resolved)) {
+        return isStaticObjectBindingAliasReference(resolved, declaration, checker, seen);
+      }
+      if (!typescript_1.default.isVariableDeclaration(resolved) || !resolved.initializer) {
+        return false;
+      }
+      const initializer3 = unwrapStaticExpression(resolved.initializer);
+      if (typescript_1.default.isObjectLiteralExpression(initializer3)) {
+        return initializer3.properties.some((property) => {
+          if (typescript_1.default.isPropertyAssignment(property))
+            return isStaticObjectAliasExpression(property.initializer, declaration, checker, seen);
+          if (typescript_1.default.isShorthandPropertyAssignment(property) && typescript_1.default.isIdentifier(property.name))
+            return isStaticObjectAliasExpression(property.name, declaration, checker, seen);
+          return typescript_1.default.isSpreadAssignment(property) && isStaticObjectAliasExpression(property.expression, declaration, checker, seen);
+        });
+      }
+      return isStaticObjectAliasExpression(initializer3, declaration, checker, seen);
+    }
+    function resolveStaticObjectAliasDeclaration(identifier, checker) {
+      return resolvedIdentifierDeclarations(identifier, checker).find((declaration) => typescript_1.default.isVariableDeclaration(declaration) || typescript_1.default.isBindingElement(declaration));
+    }
+    function variableDeclarationForBindingElement(bindingElement) {
+      let bindingPattern = bindingElement.parent;
+      if (!typescript_1.default.isObjectBindingPattern(bindingPattern))
+        return void 0;
+      while (typescript_1.default.isBindingElement(bindingPattern.parent)) {
+        const parentBindingPattern = bindingPattern.parent.parent;
+        if (!typescript_1.default.isObjectBindingPattern(parentBindingPattern))
+          return void 0;
+        bindingPattern = parentBindingPattern;
+      }
+      return typescript_1.default.isVariableDeclaration(bindingPattern.parent) ? bindingPattern.parent : void 0;
+    }
+    function bindingElementPropertyPath(bindingElement, checker) {
+      const propertyNames = [];
+      let includesRest = false;
+      for (let current = bindingElement; current; ) {
+        if (current.dotDotDotToken) {
+          includesRest = true;
+        } else {
+          const propertyName = current.propertyName ? getStaticPropertyNameText(current.propertyName, checker) : typescript_1.default.isIdentifier(current.name) ? current.name.text : void 0;
+          if (propertyName === void 0)
+            return void 0;
+          propertyNames.unshift(propertyName);
+        }
+        const bindingPattern = current.parent;
+        if (!typescript_1.default.isObjectBindingPattern(bindingPattern) || !typescript_1.default.isBindingElement(bindingPattern.parent))
+          break;
+        current = bindingPattern.parent;
+      }
+      return { propertyNames, includesRest };
+    }
+    function hasPotentialObjectBindingDefaultAlias(bindingElement, declaration, checker, seen) {
+      for (let current = bindingElement; current; ) {
+        if (current.initializer && isStaticObjectAliasExpression(current.initializer, declaration, checker, new Set(seen)))
+          return true;
+        const bindingPattern = current.parent;
+        if (!typescript_1.default.isObjectBindingPattern(bindingPattern) || !typescript_1.default.isBindingElement(bindingPattern.parent))
+          return false;
+        current = bindingPattern.parent;
+      }
+      return false;
+    }
+    function isStaticObjectBindingAliasReference(bindingElement, declaration, checker, seen) {
+      if (typescript_1.default.isArrayBindingPattern(bindingElement.parent) || hasEnclosingArrayBindingPattern(bindingElement)) {
+        return isStaticCollectionBindingAliasReference(bindingElement, declaration, checker, seen);
+      }
+      const variableDeclaration = variableDeclarationForBindingElement(bindingElement);
+      const propertyPath = bindingElementPropertyPath(bindingElement, checker);
+      if (!variableDeclaration?.initializer || !propertyPath)
+        return false;
+      if (hasPotentialObjectBindingDefaultAlias(bindingElement, declaration, checker, seen))
+        return true;
+      let expression = variableDeclaration.initializer;
+      for (const propertyName of propertyPath.propertyNames) {
+        if (isDirectStaticObjectAliasExpression(expression, declaration, checker, new Set(seen)))
+          return true;
+        const objectLiteral = resolveStaticObjectLiteralAlias(expression, checker, new Set(seen));
+        if (!objectLiteral)
+          return false;
+        const propertyValue = getStaticObjectPropertyValue(objectLiteral, propertyName, checker, /* @__PURE__ */ new Set());
+        if (propertyValue === void 0)
+          return false;
+        expression = propertyValue;
+      }
+      return propertyPath.includesRest ? isStaticObjectAliasExpression(expression, declaration, checker, new Set(seen)) : isDirectStaticObjectAliasExpression(expression, declaration, checker, new Set(seen));
+    }
+    function hasEnclosingArrayBindingPattern(bindingElement) {
+      for (let current = bindingElement; current; ) {
+        const pattern = current.parent;
+        if (typescript_1.default.isArrayBindingPattern(pattern))
+          return true;
+        if (!typescript_1.default.isObjectBindingPattern(pattern) || !typescript_1.default.isBindingElement(pattern.parent))
+          return false;
+        current = pattern.parent;
+      }
+      return false;
+    }
+    function isStaticCollectionBindingAliasReference(bindingElement, declaration, checker, seen) {
+      if (hasPotentialCollectionBindingDefaultAlias(bindingElement, declaration, checker, seen))
+        return true;
+      const values = getStaticCollectionBindingValues(bindingElement, checker);
+      if (!values)
+        return true;
+      return values.some((value) => isStaticObjectAliasExpression(value, declaration, checker, new Set(seen)));
+    }
+    function hasPotentialCollectionBindingDefaultAlias(bindingElement, declaration, checker, seen) {
+      for (let current = bindingElement; current; ) {
+        if (current.initializer && isStaticObjectAliasExpression(current.initializer, declaration, checker, new Set(seen))) {
+          return true;
+        }
+        const pattern = current.parent;
+        if (!typescript_1.default.isObjectBindingPattern(pattern) && !typescript_1.default.isArrayBindingPattern(pattern))
+          return true;
+        if (!typescript_1.default.isBindingElement(pattern.parent))
+          return false;
+        current = pattern.parent;
+      }
+      return true;
+    }
+    function getStaticCollectionBindingValues(bindingElement, checker) {
+      const pattern = bindingElement.parent;
+      const source = getStaticBindingPatternSource(pattern, checker);
+      if (!source)
+        return void 0;
+      if (typescript_1.default.isArrayBindingPattern(pattern)) {
+        const arrayLiteral = resolveStaticArrayLiteralAlias(source, checker, /* @__PURE__ */ new Set(), bindingElement);
+        const elements = arrayLiteral && expandStaticArrayElements(arrayLiteral, checker, bindingElement);
+        if (!elements)
+          return void 0;
+        const elementIndex = pattern.elements.indexOf(bindingElement);
+        if (elementIndex === -1)
+          return void 0;
+        if (bindingElement.dotDotDotToken)
+          return elements.slice(elementIndex).filter((element) => Boolean(element));
+        const value2 = elements[elementIndex];
+        if (!value2 || isStaticUndefinedExpression(value2))
+          return bindingElement.initializer ? [bindingElement.initializer] : [];
+        return [value2];
+      }
+      if (!typescript_1.default.isObjectBindingPattern(pattern))
+        return void 0;
+      const objectLiteral = resolveStaticObjectLiteralAlias(source, checker, /* @__PURE__ */ new Set());
+      if (!objectLiteral || bindingElement.dotDotDotToken)
+        return void 0;
+      const propertyName = bindingElement.propertyName ? getStaticPropertyNameText(bindingElement.propertyName, checker) : typescript_1.default.isIdentifier(bindingElement.name) ? bindingElement.name.text : void 0;
+      if (propertyName === void 0)
+        return void 0;
+      const value = getStaticObjectPropertyValue(objectLiteral, propertyName, checker, /* @__PURE__ */ new Set());
+      if (value === void 0 && hasUnresolvedStaticObjectSpread(objectLiteral, checker))
+        return void 0;
+      return value === void 0 ? [] : [value];
+    }
+    function hasUnresolvedStaticObjectSpread(objectLiteral, checker, seen = /* @__PURE__ */ new Set()) {
+      return objectLiteral.properties.some((property) => {
+        if (!typescript_1.default.isSpreadAssignment(property))
+          return false;
+        const spreadSeen = new Set(seen);
+        const spreadObject = resolveStaticObjectLiteralAlias(property.expression, checker, spreadSeen);
+        return !spreadObject || hasUnresolvedStaticObjectSpread(spreadObject, checker, spreadSeen);
+      });
+    }
+    function getStaticBindingPatternSource(pattern, checker) {
+      if (typescript_1.default.isVariableDeclaration(pattern.parent))
+        return pattern.parent.initializer;
+      if (!typescript_1.default.isBindingElement(pattern.parent))
+        return void 0;
+      const values = getStaticCollectionBindingValues(pattern.parent, checker);
+      return values?.length === 1 ? values[0] : void 0;
+    }
+    function expandStaticArrayElements(arrayLiteral, checker, sourceNode) {
+      const elements = [];
+      for (const element of arrayLiteral.elements) {
+        if (typescript_1.default.isOmittedExpression(element)) {
+          elements.push(void 0);
+          continue;
+        }
+        if (!typescript_1.default.isSpreadElement(element)) {
+          elements.push(element);
+          continue;
+        }
+        const nestedArray = resolveStaticArrayLiteralAlias(element.expression, checker, /* @__PURE__ */ new Set(), sourceNode);
+        const nestedElements = nestedArray && expandStaticArrayElements(nestedArray, checker, sourceNode);
+        if (!nestedElements)
+          return void 0;
+        elements.push(...nestedElements);
+      }
+      return elements;
+    }
+    function resolveStaticArrayLiteralAlias(expression, checker, seen, sourceNode) {
+      const unwrapped = unwrapStaticExpression(expression);
+      if (typescript_1.default.isArrayLiteralExpression(unwrapped))
+        return unwrapped;
+      if (!typescript_1.default.isIdentifier(unwrapped))
+        return void 0;
+      const declaration = resolvedIdentifierDeclarations(unwrapped, checker).find(typescript_1.default.isVariableDeclaration);
+      if (!declaration?.initializer || !isConstVariableDeclaration(declaration) || seen.has(declaration)) {
+        return void 0;
+      }
+      seen.add(declaration);
+      return resolveStaticArrayLiteralAlias(declaration.initializer, checker, seen, sourceNode);
+    }
+    function isStaticUndefinedExpression(expression) {
+      const unwrapped = unwrapStaticExpression(expression);
+      return typescript_1.default.isIdentifier(unwrapped) && unwrapped.text === "undefined" || typescript_1.default.isVoidExpression(unwrapped);
+    }
+    function isDirectStaticObjectAliasExpression(expression, declaration, checker, seen) {
+      const unwrapped = unwrapStaticExpression(expression);
+      if (typescript_1.default.isPropertyAccessExpression(unwrapped) || typescript_1.default.isElementAccessExpression(unwrapped)) {
+        if (isDirectStaticObjectAliasExpression(unwrapped.expression, declaration, checker, new Set(seen)))
+          return true;
+        const objectLiteral = resolveStaticObjectLiteralAlias(unwrapped.expression, checker, new Set(seen));
+        const propertyName = typescript_1.default.isPropertyAccessExpression(unwrapped) ? unwrapped.name.text : unwrapped.argumentExpression && resolveStaticStringExpression(unwrapped.argumentExpression, checker);
+        if (!objectLiteral || propertyName === void 0)
+          return false;
+        const propertyValue = getStaticObjectPropertyValue(objectLiteral, propertyName, checker, /* @__PURE__ */ new Set());
+        return propertyValue === void 0 ? false : isDirectStaticObjectAliasExpression(propertyValue, declaration, checker, seen);
+      }
+      if (!typescript_1.default.isIdentifier(unwrapped))
+        return false;
+      const resolved = resolveStaticObjectAliasDeclaration(unwrapped, checker);
+      if (resolved === declaration)
+        return true;
+      if (!resolved || seen.has(resolved))
+        return false;
+      seen.add(resolved);
+      if (typescript_1.default.isBindingElement(resolved))
+        return isStaticObjectBindingAliasReference(resolved, declaration, checker, seen);
+      if (!typescript_1.default.isVariableDeclaration(resolved) || !resolved.initializer)
+        return false;
+      return isDirectStaticObjectAliasExpression(resolved.initializer, declaration, checker, seen);
+    }
+    function isStaticObjectAliasExpression(expression, declaration, checker, seen) {
+      const unwrapped = unwrapStaticExpression(expression);
+      if (typescript_1.default.isConditionalExpression(unwrapped)) {
+        return isStaticObjectAliasExpression(unwrapped.whenTrue, declaration, checker, new Set(seen)) || isStaticObjectAliasExpression(unwrapped.whenFalse, declaration, checker, new Set(seen));
+      }
+      if (typescript_1.default.isBinaryExpression(unwrapped) && (unwrapped.operatorToken.kind === typescript_1.default.SyntaxKind.AmpersandAmpersandToken || unwrapped.operatorToken.kind === typescript_1.default.SyntaxKind.BarBarToken || unwrapped.operatorToken.kind === typescript_1.default.SyntaxKind.QuestionQuestionToken)) {
+        return isStaticObjectAliasExpression(unwrapped.left, declaration, checker, new Set(seen)) || isStaticObjectAliasExpression(unwrapped.right, declaration, checker, new Set(seen));
+      }
+      if (typescript_1.default.isObjectLiteralExpression(unwrapped)) {
+        return unwrapped.properties.some((property) => {
+          if (typescript_1.default.isPropertyAssignment(property))
+            return isStaticObjectAliasExpression(property.initializer, declaration, checker, seen);
+          if (typescript_1.default.isShorthandPropertyAssignment(property) && typescript_1.default.isIdentifier(property.name))
+            return isStaticObjectAliasExpression(property.name, declaration, checker, seen);
+          if (!typescript_1.default.isSpreadAssignment(property))
+            return true;
+          const spreadObject = resolveStaticObjectLiteralAlias(property.expression, checker, new Set(seen));
+          return !spreadObject || isStaticObjectAliasExpression(property.expression, declaration, checker, seen);
+        });
+      }
+      if (typescript_1.default.isArrayLiteralExpression(unwrapped)) {
+        return unwrapped.elements.some((element) => {
+          if (typescript_1.default.isOmittedExpression(element))
+            return false;
+          if (!typescript_1.default.isSpreadElement(element))
+            return isStaticObjectAliasExpression(element, declaration, checker, seen);
+          const spreadArray = resolveStaticArrayLiteralAlias(element.expression, checker, /* @__PURE__ */ new Set());
+          return !spreadArray || isStaticObjectAliasExpression(element.expression, declaration, checker, seen);
+        });
+      }
+      if (typescript_1.default.isIdentifier(unwrapped))
+        return isStaticObjectAliasReference(unwrapped, declaration, checker, seen);
+      if (typescript_1.default.isPropertyAccessExpression(unwrapped) || typescript_1.default.isElementAccessExpression(unwrapped)) {
+        const directBase = unwrapStaticExpression(unwrapped.expression);
+        if (typescript_1.default.isIdentifier(directBase) && resolveStaticObjectAliasDeclaration(directBase, checker) === declaration) {
+          return true;
+        }
+        const objectLiteral = resolveStaticObjectLiteralAlias(unwrapped.expression, checker, new Set(seen));
+        const propertyName = typescript_1.default.isPropertyAccessExpression(unwrapped) ? unwrapped.name.text : unwrapped.argumentExpression && resolveStaticStringExpression(unwrapped.argumentExpression, checker);
+        if (objectLiteral && propertyName) {
+          const propertyValue = getStaticObjectPropertyValue(objectLiteral, propertyName, checker, /* @__PURE__ */ new Set());
+          if (propertyValue !== void 0)
+            return isStaticObjectAliasExpression(propertyValue, declaration, checker, seen);
+          return hasUnresolvedStaticObjectSpread(objectLiteral, checker);
+        }
+        if (isStaticObjectAliasExpression(unwrapped.expression, declaration, checker, new Set(seen)))
+          return true;
+      }
+      const accessBase = getPotentialObjectAliasAccessBase(unwrapped);
+      return accessBase ? isStaticObjectAliasExpression(accessBase, declaration, checker, seen) : false;
+    }
+    function resolveStaticObjectLiteralAlias(expression, checker, seen) {
+      const unwrapped = unwrapStaticExpression(expression);
+      if (typescript_1.default.isObjectLiteralExpression(unwrapped))
+        return unwrapped;
+      if (!typescript_1.default.isIdentifier(unwrapped))
+        return void 0;
+      const resolved = resolveStaticObjectAliasDeclaration(unwrapped, checker);
+      if (!resolved || seen.has(resolved) || !typescript_1.default.isVariableDeclaration(resolved) || !resolved.initializer)
+        return void 0;
+      seen.add(resolved);
+      return resolveStaticObjectLiteralAlias(resolved.initializer, checker, seen);
+    }
+    function getPotentialObjectAliasAccessBase(expression) {
+      if (typescript_1.default.isPropertyAccessExpression(expression))
+        return expression.expression;
+      if (typescript_1.default.isElementAccessExpression(expression))
+        return expression.expression;
+      return void 0;
+    }
+    function isPotentialObjectMutationReference(identifier, checker, ignoredCall) {
+      for (let current = identifier; current.parent; current = current.parent) {
+        const parent = current.parent;
+        if (parent === ignoredCall)
+          return false;
+        if (typescript_1.default.isCallExpression(parent) && isReadOnlyObjectInspection(parent, identifier, checker))
+          return false;
+        if (typescript_1.default.isBinaryExpression(parent) && isAssignmentOperator(parent.operatorToken.kind) && (isDescendantOf(identifier, parent.left) || isDescendantOf(identifier, parent.right))) {
+          return true;
+        }
+        if ((typescript_1.default.isPrefixUnaryExpression(parent) || typescript_1.default.isPostfixUnaryExpression(parent)) && isDescendantOf(identifier, parent.operand)) {
+          return true;
+        }
+        if (typescript_1.default.isDeleteExpression(parent) && isDescendantOf(identifier, parent.expression))
+          return true;
+        if (typescript_1.default.isReturnStatement(parent) || typescript_1.default.isYieldExpression(parent))
+          return true;
+        if ((typescript_1.default.isCallExpression(parent) || typescript_1.default.isNewExpression(parent)) && parent !== ignoredCall && (parent.arguments?.some((argument) => isDescendantOf(identifier, argument)) || isDescendantOf(identifier, parent.expression))) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function isReadOnlyObjectInspection(call, identifier, checker) {
+      if (!typescript_1.default.isPropertyAccessExpression(call.expression) || !typescript_1.default.isIdentifier(call.expression.expression) || call.expression.expression.text !== "Object" || !isGlobalObjectIdentifier(call.expression.expression, checker) || !READ_ONLY_OBJECT_INSPECTION_METHODS.has(call.expression.name.text)) {
+        return false;
+      }
+      return call.arguments[0] === identifier;
+    }
+    function isGlobalObjectIdentifier(identifier, checker) {
+      const declarations = checker.getSymbolAtLocation(identifier)?.declarations;
+      return Boolean(declarations?.length && declarations.every((declaration) => declaration.getSourceFile().isDeclarationFile));
+    }
+    function isDescendantOf(node, ancestor) {
+      for (let current = node; current; current = current.parent) {
+        if (current === ancestor)
+          return true;
+      }
+      return false;
+    }
+    function getStaticPropertyNameText(name, checker) {
+      if (typescript_1.default.isIdentifier(name) || typescript_1.default.isStringLiteral(name) || typescript_1.default.isNumericLiteral(name))
+        return name.text;
+      if (typescript_1.default.isComputedPropertyName(name))
+        return resolveStaticStringExpression(name.expression, checker);
+      return void 0;
+    }
+    function isConditionFunction(node) {
+      return typescript_1.default.isArrowFunction(node) || typescript_1.default.isFunctionExpression(node);
+    }
+    function containsAwait(node) {
+      let found = false;
+      const visit = (current) => {
+        if (found)
+          return;
+        if (typescript_1.default.isAwaitExpression(current)) {
+          found = true;
+          return;
+        }
+        typescript_1.default.forEachChild(current, visit);
+      };
+      visit(node);
+      return found;
+    }
+    function hasPredicateReturn(predicate) {
+      if (!typescript_1.default.isBlock(predicate.body))
+        return true;
+      let found = false;
+      const visit = (node) => {
+        if (found)
+          return;
+        if (node !== predicate.body && isNestedFunctionLike(node))
+          return;
+        if (typescript_1.default.isReturnStatement(node) && node.expression)
+          found = true;
+        typescript_1.default.forEachChild(node, visit);
+      };
+      visit(predicate.body);
+      return found;
+    }
+    function isAnyOrUnknown(type2) {
+      return Boolean(type2.flags & (typescript_1.default.TypeFlags.Any | typescript_1.default.TypeFlags.Unknown));
+    }
+    function isBooleanLike(type2, checker) {
+      const booleanType2 = checker.getBooleanType();
+      if (checker.isTypeAssignableTo(type2, booleanType2))
+        return true;
+      if (type2.isUnion())
+        return type2.types.every((item) => checker.isTypeAssignableTo(item, booleanType2));
+      return false;
+    }
+    function isPromiseLike(type2, checker) {
+      void checker;
+      return type2.getProperty("then") !== void 0;
+    }
+    function isNestedFunctionLike(node) {
+      return typescript_1.default.isFunctionDeclaration(node) || typescript_1.default.isFunctionExpression(node) || typescript_1.default.isArrowFunction(node) || typescript_1.default.isMethodDeclaration(node) || typescript_1.default.isGetAccessorDeclaration(node) || typescript_1.default.isSetAccessorDeclaration(node) || typescript_1.default.isConstructorDeclaration(node);
+    }
+    function getVariableFunction(sourceFile, name) {
+      for (const statement of sourceFile.statements) {
+        if (!typescript_1.default.isVariableStatement(statement))
+          continue;
+        for (const declaration of statement.declarationList.declarations) {
+          if (!typescript_1.default.isIdentifier(declaration.name) || declaration.name.text !== name)
+            continue;
+          const initializer3 = declaration.initializer;
+          if (initializer3 && (typescript_1.default.isArrowFunction(initializer3) || typescript_1.default.isFunctionExpression(initializer3)))
+            return initializer3;
+        }
+      }
+      return void 0;
+    }
+    function createGeneratedConditionHandlerName(sourceFile) {
+      const names = /* @__PURE__ */ new Set();
+      const visit = (node) => {
+        if (typescript_1.default.isIdentifier(node))
+          names.add(node.text);
+        typescript_1.default.forEachChild(node, visit);
+      };
+      visit(sourceFile);
+      let index = 0;
+      while (names.has(`__workflowCondition${index === 0 ? "" : index}`))
+        index++;
+      return `__workflowCondition${index === 0 ? "" : index}`;
+    }
+    function printConditionExpressionWithClosure(predicate, sourceFile, generatedHandlerName) {
+      const body = printConditionBody(predicate, sourceFile);
+      const closure = printConditionClosure(sourceFile, generatedHandlerName);
+      if (closure.length === 0)
+        return body;
+      return `(() => {
+${closure}
+return (${body})
+})()`;
+    }
+    function printConditionClosure(sourceFile, generatedHandlerName) {
+      const statements2 = sourceFile.statements.filter((statement) => !isNamedVariableStatement(statement, generatedHandlerName));
+      if (statements2.length === 0)
+        return "";
+      const printed = printFile(createRuntimeSourceFile(sourceFile, statements2, void 0));
+      return transpileTypeScriptToJavaScript(printed);
+    }
+    function isNamedVariableStatement(statement, name) {
+      return typescript_1.default.isVariableStatement(statement) && statement.declarationList.declarations.some((declaration) => typescript_1.default.isIdentifier(declaration.name) && declaration.name.text === name);
+    }
+    function printConditionBody(predicate, sourceFile) {
+      if (!typescript_1.default.isBlock(predicate.body))
+        return printConditionJavaScriptExpression(predicate.body, sourceFile);
+      return `(() => {${printConditionJavaScriptBlockStatements(predicate.body.statements, sourceFile)}})()`;
+    }
+    function printConditionJavaScriptExpression(expression, sourceFile) {
+      const expressionText = printExpression(expression, sourceFile);
+      const javascript = transpileTypeScriptToJavaScript(`const __workflowConditionExpression = (${expressionText});`);
+      const javascriptSourceFile = typescript_1.default.createSourceFile("workflow-condition-expression.js", javascript, typescript_1.default.ScriptTarget.ES2022, true, typescript_1.default.ScriptKind.JS);
+      const initializer3 = findVariableInitializer(javascriptSourceFile, "__workflowConditionExpression");
+      return initializer3 ? printExpression(unwrapParenthesizedExpression(initializer3), javascriptSourceFile) : expressionText;
+    }
+    function unwrapParenthesizedExpression(expression) {
+      return typescript_1.default.isParenthesizedExpression(expression) ? unwrapParenthesizedExpression(expression.expression) : expression;
+    }
+    function printConditionJavaScriptBlockStatements(statements2, sourceFile) {
+      const statementText = statements2.map((statement) => printStatement(statement, sourceFile)).join("\n");
+      const javascript = transpileTypeScriptToJavaScript(`const __workflowConditionBlock = () => {
+${statementText}
+};`);
+      const javascriptSourceFile = typescript_1.default.createSourceFile("workflow-condition-block.js", javascript, typescript_1.default.ScriptTarget.ES2022, true, typescript_1.default.ScriptKind.JS);
+      const initializer3 = findVariableInitializer(javascriptSourceFile, "__workflowConditionBlock");
+      const body = initializer3 && typescript_1.default.isArrowFunction(initializer3) && typescript_1.default.isBlock(initializer3.body) ? initializer3.body : void 0;
+      return body ? body.statements.map((statement) => printStatement(statement, javascriptSourceFile)).join("") : statementText;
+    }
+    function findVariableInitializer(sourceFile, name) {
+      for (const statement of sourceFile.statements) {
+        if (!typescript_1.default.isVariableStatement(statement))
+          continue;
+        for (const declaration of statement.declarationList.declarations) {
+          if (typescript_1.default.isIdentifier(declaration.name) && declaration.name.text === name)
+            return declaration.initializer;
+        }
+      }
+      return void 0;
+    }
+    function transpileTypeScriptToJavaScript(source) {
+      return typescript_1.default.transpileModule(source, {
+        compilerOptions: {
+          target: typescript_1.default.ScriptTarget.ES2022,
+          module: typescript_1.default.ModuleKind.ESNext,
+          removeComments: false
+        }
+      }).outputText.replace(/^"use strict";\r?\n?/u, "").trim();
+    }
     function resolveHandler(call, sourceFile, checker) {
       const handler = getHandlerExpression(call);
       if (!handler)
@@ -369512,7 +370462,7 @@ var require_extract3 = __commonJS({
       if (effectiveKey) {
         const staticTarget = resolveBuiltRefTargetByEffectiveKey(effectiveKey, context);
         if (staticTarget)
-          return { target: staticTarget };
+          return staticTarget;
       }
       if (declaration)
         return resolveBuiltRefTargetFromBuildArrays(identifier, declaration, checker, context);
@@ -369521,12 +370471,40 @@ var require_extract3 = __commonJS({
     function resolveBuiltRefTargetByEffectiveKey(effectiveKey, context) {
       const inputName = context.inputNamesByKey.get(effectiveKey);
       if (inputName)
-        return { kind: "input", effectiveKey, runtimeName: inputName };
+        return { target: { kind: "input", effectiveKey, runtimeName: inputName } };
+      const scopedTarget = resolveScopedBuiltRefTarget(effectiveKey, context);
+      if (scopedTarget)
+        return scopedTarget;
       const nodeName = context.nodeNamesByKey.get(effectiveKey);
       if (nodeName)
-        return { kind: "node", effectiveKey, runtimeName: nodeName, nodeIndex: context.nodeIndexesByKey.get(effectiveKey) };
+        return { target: { kind: "node", effectiveKey, runtimeName: nodeName, nodeIndex: context.nodeIndexesByKey.get(effectiveKey) } };
       return void 0;
     }
+    function resolveScopedBuiltRefTarget(effectiveKey, context) {
+      const { currentNode, nodeIdentitiesByKey } = context;
+      if (!nodeIdentitiesByKey || !currentNode)
+        return void 0;
+      const candidates = nodeIdentitiesByKey.get(effectiveKey) ?? [];
+      if (candidates.length === 0)
+        return void 0;
+      const visible = (0, refs_1.resolveVisibleNodeIdentity)(effectiveKey, { nodeIdentitiesByKey, currentNode });
+      if (visible) {
+        return {
+          target: {
+            kind: "node",
+            effectiveKey,
+            runtimeName: visible.runtimeName
+          }
+        };
+      }
+      if (candidates.some((candidate) => samePath(candidate.scopePath, currentNode.scopePath) && candidate.sequenceIndex >= currentNode.sequenceIndex)) {
+        return { refFailure: "forward" };
+      }
+      return { refFailure: "scope" };
+    }
+    function samePath(left, right) {
+      return left.length === right.length && left.every((segment, index) => segment === right[index]);
+    }
     function resolveBuiltRefTargetFromBuildArrays(identifier, declaration, checker, context) {
       const candidates = [];
       let unsupportedDynamicBuildArray = false;
@@ -369576,10 +370554,13 @@ var require_extract3 = __commonJS({
         return false;
       }
       const builtNode = context.builtNodes[match];
-      if (builtNode)
+      if (builtNode && isOutputProducingNode(builtNode))
         candidates.push({ kind: "node", effectiveKey: builtNode.key ?? builtNode.name, runtimeName: builtNode.name, nodeIndex: match });
       return false;
     }
+    function isOutputProducingNode(node) {
+      return node.nodeKind !== "condition" && node.nodeKind !== "stop";
+    }
     function uniqueBuiltRefTarget(candidates) {
       if (candidates.length === 0)
         return void 0;
@@ -370102,7 +371083,27 @@ var require_extract3 = __commonJS({
     }
     function isDeclaredInsideRoot(identifier, root, checker) {
       const symbol3 = checker.getSymbolAtLocation(identifier);
-      return Boolean(symbol3?.declarations?.some((declaration) => nodeContains(root, declaration)));
+      return Boolean(symbol3?.declarations?.some((declaration) => nodeContains(root, declaration))) || isLexicallyDeclaredInsideRoot(identifier, root);
+    }
+    function isLexicallyDeclaredInsideRoot(identifier, root) {
+      let current = identifier.parent;
+      while (current && current !== root) {
+        const currentParameters = functionLikeParameters(current);
+        if (currentParameters && currentParameters.some((parameter) => bindingNames(parameter.name).includes(identifier.text)))
+          return true;
+        if ((typescript_1.default.isBlock(current) || typescript_1.default.isModuleBlock(current) || typescript_1.default.isCaseClause(current) || typescript_1.default.isDefaultClause(current)) && blockBindingNames(current).has(identifier.text)) {
+          return true;
+        }
+        current = current.parent;
+      }
+      const rootParameters = functionLikeParameters(root);
+      return Boolean(rootParameters?.some((parameter) => bindingNames(parameter.name).includes(identifier.text)));
+    }
+    function functionLikeParameters(node) {
+      if (typescript_1.default.isFunctionDeclaration(node) || typescript_1.default.isFunctionExpression(node) || typescript_1.default.isArrowFunction(node) || typescript_1.default.isMethodDeclaration(node) || typescript_1.default.isGetAccessorDeclaration(node) || typescript_1.default.isSetAccessorDeclaration(node) || typescript_1.default.isConstructorDeclaration(node)) {
+        return [...node.parameters];
+      }
+      return void 0;
     }
     function nodeContains(root, node) {
       const sourceFile = root.getSourceFile();
@@ -370390,6 +371391,14 @@ var require_extract3 = __commonJS({
       const printer = typescript_1.default.createPrinter({ removeComments: false });
       return sourceFile.statements.map((statement) => printer.printNode(typescript_1.default.EmitHint.Unspecified, statement, sourceFileForNode(statement) ?? sourceFile)).join("\n\n");
     }
+    function printExpression(expression, sourceFile) {
+      const printer = typescript_1.default.createPrinter({ removeComments: false });
+      return printer.printNode(typescript_1.default.EmitHint.Expression, expression, sourceFileForNode(expression) ?? sourceFile);
+    }
+    function printStatement(statement, sourceFile) {
+      const printer = typescript_1.default.createPrinter({ removeComments: false });
+      return printer.printNode(typescript_1.default.EmitHint.Unspecified, statement, sourceFileForNode(statement) ?? sourceFile);
+    }
     function sourceFileForNode(node) {
       return node.getSourceFile() ?? typescript_1.default.getOriginalNode(node)?.getSourceFile();
     }
@@ -370522,154 +371531,6 @@ ${code}`;
   }
 });
 
-// ../../packages/workflow-code/dist/compiler/refs.js
-var require_refs = __commonJS({
-  "../../packages/workflow-code/dist/compiler/refs.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.resolvePromptRefs = resolvePromptRefs;
-    exports2.resolveReferenceRecordRefs = resolveReferenceRecordRefs;
-    exports2.resolveWorkflowRef = resolveWorkflowRef;
-    exports2.resolveExclusiveRef = resolveExclusiveRef;
-    var workflow_shared_1 = require_cjs2();
-    function resolvePromptRefs(context) {
-      const diagnostics = [];
-      let prompt = context.prompt;
-      for (const ref of context.refs) {
-        const resolved = resolveWorkflowRef(ref, context);
-        diagnostics.push(...resolved.diagnostics);
-        if (!resolved.reference)
-          continue;
-        prompt = prompt.split(ref.token).join(resolved.reference);
-      }
-      return { prompt, diagnostics };
-    }
-    function resolveReferenceRecordRefs(context) {
-      const diagnostics = [];
-      const values = { ...context.values };
-      for (const ref of context.refs) {
-        const resolved = resolveWorkflowRef(ref, context);
-        if (resolved.reference) {
-          values[ref.key] = resolved.reference;
-          continue;
-        }
-        diagnostics.push(...resolved.diagnostics.map((diagnostic) => ({
-          ...diagnostic,
-          message: diagnostic.message.replace("Prompt reference", `Reference record ${ref.key} reference`)
-        })));
-      }
-      return { values: Object.freeze(values), diagnostics };
-    }
-    function resolveWorkflowRef(ref, context) {
-      const resolved = ref.targetKind === "input" ? resolveInputRef(ref, context) : resolveNodeRef(ref, context);
-      if (!resolved) {
-        return {
-          diagnostics: [{
-            code: "compiler.ref.dangling",
-            severity: "error",
-            message: `Prompt reference ${ref.targetKey} does not match a workflow input or previous node`
-          }]
-        };
-      }
-      if (resolved === "forward") {
-        return {
-          diagnostics: [{
-            code: "compiler.ref.forward",
-            severity: "error",
-            message: `Prompt reference ${ref.targetKey} points to a future workflow node`
-          }]
-        };
-      }
-      if (resolved === "scope") {
-        return {
-          diagnostics: [{
-            code: "compiler.ref.scope",
-            severity: "error",
-            message: `Prompt reference ${ref.targetKey} points to a workflow node outside the visible scope`
-          }]
-        };
-      }
-      return {
-        reference: resolved.reference,
-        inputType: "inputType" in resolved ? resolved.inputType : void 0,
-        nodeId: "nodeId" in resolved ? resolved.nodeId : void 0,
-        diagnostics: []
-      };
-    }
-    function resolveExclusiveRef(ref, context) {
-      const resolved = resolveWorkflowRef(ref, context);
-      if (resolved.reference)
-        return resolved;
-      return {
-        diagnostics: resolved.diagnostics.map((diagnostic) => ({
-          ...diagnostic,
-          message: diagnostic.message.replace("Prompt reference", "Exclusive reference")
-        }))
-      };
-    }
-    function resolveInputRef(ref, context) {
-      const id = context.inputIdsByKey.get(ref.targetKey);
-      if (!id)
-        return void 0;
-      const reference = workflow_shared_1.InputReferenceURI.fromVariable({ name: id });
-      return {
-        reference: formatPromptReference(reference, ref),
-        inputType: context.inputTypesByKey?.get(ref.targetKey)
-      };
-    }
-    function resolveNodeRef(ref, context) {
-      const candidates = context.nodeIdentitiesByKey.get(ref.targetKey) ?? [];
-      if (candidates.length === 0)
-        return void 0;
-      const visible = findVisibleCandidate(ref.targetKey, context);
-      if (visible) {
-        const reference = workflow_shared_1.ActionOutputReferenceURI.fromStepId(visible.id);
-        return { reference: formatPromptReference(reference, ref), nodeId: visible.id };
-      }
-      if (candidates.some((candidate) => samePath(candidate.scopePath, context.currentNode.scopePath) && candidate.sequenceIndex >= context.currentNode.sequenceIndex)) {
-        return "forward";
-      }
-      return "scope";
-    }
-    function findVisibleCandidate(key, context) {
-      const currentScopeCandidate = resolvePriorCandidateInScope(key, context.currentNode.scopePath, context.currentNode.sequenceIndex, context);
-      if (currentScopeCandidate)
-        return currentScopeCandidate;
-      for (const ancestorMapPath of [...context.currentNode.ancestorMapPaths].reverse()) {
-        const ancestorMap = context.nodesByPath.get(pathKey(ancestorMapPath));
-        if (!ancestorMap)
-          continue;
-        const candidate = resolvePriorCandidateInScope(key, ancestorMap.scopePath, ancestorMap.sequenceIndex, context);
-        if (candidate)
-          return candidate;
-      }
-      return void 0;
-    }
-    function resolvePriorCandidateInScope(key, scopePath, beforeSequenceIndex, context) {
-      const candidates = (context.nodeIdentitiesByKey.get(key) ?? []).filter((candidate) => samePath(candidate.scopePath, scopePath) && candidate.sequenceIndex < beforeSequenceIndex).sort((left, right) => right.sequenceIndex - left.sequenceIndex);
-      const nearest = candidates[0];
-      if (!nearest)
-        return void 0;
-      if (candidates.filter((candidate) => candidate.sequenceIndex === nearest.sequenceIndex).length > 1)
-        return void 0;
-      return nearest;
-    }
-    function samePath(left, right) {
-      return left.length === right.length && left.every((segment, index) => segment === right[index]);
-    }
-    function pathKey(path3) {
-      return path3.join(".");
-    }
-    function formatPromptReference(reference, ref) {
-      if (ref.path && ref.path.length > 0)
-        reference.appendPath([...ref.path]);
-      if ("format" in ref && ref.format)
-        reference.setFormat(ref.format);
-      return reference.toReference();
-    }
-  }
-});
-
 // ../../packages/workflow-code/dist/compiler/modules.js
 var require_modules = __commonJS({
   "../../packages/workflow-code/dist/compiler/modules.js"(exports2) {
@@ -370679,6 +371540,7 @@ var require_modules = __commonJS({
     var contracts_1 = require_contracts();
     var workflow_shared_1 = require_cjs2();
     var remote_1 = require_remote();
+    var condition_provenance_1 = require_condition_provenance();
     var reference_1 = require_reference();
     var asset_1 = require_asset();
     var extract_1 = require_extract3();
@@ -370756,6 +371618,42 @@ var require_modules = __commonJS({
         output: (0, ids_1.defaultOutputPortId)(nodeId)
       };
     }
+    var stopModule = {
+      kind: "stop",
+      actionId: workflow_shared_1.WORKFLOW_ACTION_IDS.stop,
+      createFailedInput() {
+        return null;
+      },
+      validate(node) {
+        return hasValidStopDeclaration(node) ? [] : [invalidStopInputDiagnostic(node)];
+      },
+      lower(node, context) {
+        if (!hasValidStopDeclaration(node))
+          return void 0;
+        const input = (0, ids_1.defaultInputPortId)(context.nodeId);
+        return {
+          node: {
+            id: context.nodeId,
+            name: node.name,
+            actionId: workflow_shared_1.WORKFLOW_ACTION_IDS.stop,
+            ports: [{ id: input, dir: "in", type: "default" }],
+            input: null
+          },
+          linearPorts: { input },
+          terminal: true
+        };
+      }
+    };
+    function hasValidStopDeclaration(node) {
+      return Boolean(node) && typeof node === "object" && node.kind === "node" && node.nodeKind === "stop" && node.name === "Stop" && node.key === void 0 && node.input === null;
+    }
+    function invalidStopInputDiagnostic(node) {
+      return {
+        code: "compiler.module.invalid_input",
+        severity: "error",
+        message: `Node ${node.name || "<unnamed>"} has invalid stop declaration`
+      };
+    }
     function collectRemoteInputFacts(values, refs, context) {
       const refsByInputName = new Map((refs ?? []).map((ref) => [ref.key, ref]));
       const inputsByKey = new Map(context.builtInputs.map((input) => [input.key ?? input.name, input]));
@@ -370932,6 +371830,171 @@ var require_modules = __commonJS({
         message: `Map node ${nodeName || "<unnamed>"}: ${message}`
       };
     }
+    function hasValidConditionInput(node) {
+      if (!node || node.nodeKind !== "condition")
+        return false;
+      if (node.kind !== "node" || node.name !== "Condition" || "key" in node)
+        return false;
+      const input = node.input;
+      if (!input || typeof input !== "object")
+        return false;
+      const cases = input.cases;
+      const defaultBranch = input.default;
+      return Array.isArray(cases) && cases.every((branch) => branch && typeof branch === "object" && typeof branch.name === "string" && branch.name.trim().length > 0 && Array.isArray(branch.nodes)) && (defaultBranch === void 0 || Boolean(defaultBranch && typeof defaultBranch === "object" && Array.isArray(defaultBranch.nodes)));
+    }
+    function validateConditionBinding(node) {
+      const binding = node[contracts_1.CONDITION_BINDING];
+      if (!isConditionBindingObject(binding)) {
+        return [{
+          code: "condition.source.missing_handler_binding",
+          severity: "error",
+          message: "Condition node is missing predicate binding"
+        }];
+      }
+      const diagnostics = [];
+      if (!(0, condition_provenance_1.isTrustedConditionBinding)(node, binding)) {
+        diagnostics.push({
+          code: "condition.source.untrusted_binding",
+          severity: "error",
+          message: "Condition node predicate binding was not produced by Workflow Code authoring evaluation"
+        });
+      }
+      const caseNames = new Set(node.input.cases.map((branch) => branch.name));
+      const handlerNames = Object.keys(binding.handlers);
+      for (const branch of node.input.cases) {
+        if (!hasOwnFunctionProperty(binding.handlers, branch.name)) {
+          diagnostics.push({
+            code: "condition.source.missing_handler_binding",
+            severity: "error",
+            message: `Condition case "${branch.name}" is missing predicate handler binding`
+          });
+        }
+      }
+      for (const handlerName of handlerNames) {
+        if (!caseNames.has(handlerName)) {
+          diagnostics.push({
+            code: "condition.source.missing_handler_binding",
+            severity: "error",
+            message: `Condition predicate handler binding "${handlerName}" does not match a declared case`
+          });
+        }
+      }
+      if (binding.source !== void 0 && !isWorkflowCodeSourceMarker(binding.source)) {
+        diagnostics.push({
+          code: "condition.source.missing_handler",
+          severity: "error",
+          message: "Condition node has invalid source marker metadata"
+        });
+      }
+      return diagnostics;
+    }
+    function isConditionBindingObject(value) {
+      if (!value || typeof value !== "object")
+        return false;
+      const handlers = value.handlers;
+      const source = value.source;
+      return Boolean(handlers) && typeof handlers === "object" && !Array.isArray(handlers) && (source === void 0 || isWorkflowCodeSourceMarker(source));
+    }
+    function isWorkflowCodeSourceMarker(value) {
+      return Boolean(value) && typeof value === "object" && typeof value.file === "string" && typeof value.pos === "number" && Number.isInteger(value.pos) && value.pos >= 0 && typeof value.end === "number" && Number.isInteger(value.end) && value.end >= value.pos;
+    }
+    function hasOwnFunctionProperty(value, property) {
+      return Object.prototype.hasOwnProperty.call(value, property) && typeof value[property] === "function";
+    }
+    function invalidConditionInputDiagnostic(node) {
+      return {
+        code: "compiler.module.invalid_input",
+        severity: "error",
+        message: `Node ${node.name || "<unnamed>"} has invalid condition input`
+      };
+    }
+    function guardConditionExpression(expression) {
+      return `(() => {
+        const value = (${expression})
+        if (value !== null
+            && (typeof value === 'object' || typeof value === 'function')
+            && typeof value.then === 'function')
+            throw new TypeError('Workflow Code condition predicate returned a thenable')
+        if (typeof value !== 'boolean')
+            throw new TypeError('Workflow Code condition predicate must return a boolean')
+        return value
+    })()`;
+    }
+    var conditionModule = {
+      kind: "condition",
+      actionId: workflow_shared_1.WORKFLOW_ACTION_IDS.condition,
+      createFailedInput() {
+        return { cases: [] };
+      },
+      validate(node) {
+        const diagnostics = hasValidConditionInput(node) ? [] : [invalidConditionInputDiagnostic(node)];
+        if (hasValidConditionInput(node)) {
+          diagnostics.push(...validateConditionBinding(node));
+          const branchCount = node.input.cases.length + (node.input.default ? 1 : 0);
+          if (branchCount < 2 || node.input.cases.length === 1 && !node.input.default)
+            diagnostics.push({ code: "compiler.condition.invalid_cardinality", severity: "error", message: "Condition requires at least two branches; one named case requires default" });
+        }
+        return diagnostics;
+      },
+      lower(node, context) {
+        if (!hasValidConditionInput(node))
+          return void 0;
+        const extractedCases = node.input.cases.map((branch) => ({
+          branch,
+          extracted: (0, extract_1.extractConditionExpression)({
+            node,
+            caseName: branch.name,
+            source: context.source,
+            buildSource: context.buildSource,
+            builtInputs: context.builtInputs,
+            builtNodes: context.builtNodes,
+            currentNodeIndex: context.nodeIndex,
+            nodeIdentitiesByKey: context.nodeIdentitiesByKey,
+            currentNode: context.currentNode,
+            inputNamesByKey: context.inputNamesByKey,
+            nodeNamesByKey: context.nodeNamesByKey,
+            nodeIndexesByKey: context.nodeIndexesByKey
+          })
+        }));
+        context.diagnostics.push(...extractedCases.flatMap((item) => item.extracted.diagnostics));
+        if (extractedCases.some((item) => item.extracted.expression === void 0 || item.extracted.diagnostics.some((diagnostic) => diagnostic.severity === "error"))) {
+          return void 0;
+        }
+        const cases = extractedCases.map(({ branch, extracted }) => ({
+          branch,
+          expression: guardConditionExpression(extracted.expression ?? "")
+        }));
+        const inputPort = (0, ids_1.defaultInputPortId)(context.nodeId);
+        const branchPorts = node.input.cases.map((_2, index) => (0, ids_1.branchOutputPortId)(context.nodeId, index));
+        const defaultPort = node.input.default ? (0, ids_1.branchOutputPortId)(context.nodeId, node.input.cases.length) : void 0;
+        return {
+          node: {
+            id: context.nodeId,
+            name: node.name,
+            actionId: workflow_shared_1.WORKFLOW_ACTION_IDS.condition,
+            ports: [
+              { id: inputPort, dir: "in", type: "default" },
+              ...branchPorts.map((id) => ({ id, dir: "out", type: "branch" })),
+              ...defaultPort ? [{ id: defaultPort, dir: "out", type: "branch" }] : []
+            ],
+            input: {
+              cases: cases.map(({ branch, expression }, index) => ({
+                name: branch.name,
+                condition: expression,
+                steps: [],
+                type: "code",
+                portId: branchPorts[index]
+              })),
+              ...node.input.default && defaultPort ? {
+                default: { name: "Default", condition: null, steps: [], type: "code", portId: defaultPort }
+              } : {}
+            }
+          },
+          linearPorts: { input: inputPort, output: "" },
+          branchOutputPorts: Object.freeze([...branchPorts, ...defaultPort ? [defaultPort] : []])
+        };
+      }
+    };
     var codeModule = {
       kind: "code",
       actionId: workflow_shared_1.WORKFLOW_ACTION_IDS.codeExecution,
@@ -370960,11 +372023,13 @@ var require_modules = __commonJS({
           builtInputs: context.builtInputs,
           builtNodes: context.builtNodes,
           currentNodeIndex: context.nodeIndex,
+          nodeIdentitiesByKey: context.nodeIdentitiesByKey,
+          currentNode: context.currentNode,
           inputNamesByKey: context.inputNamesByKey,
           nodeNamesByKey: context.nodeNamesByKey,
+          nodeIdsByKey: context.nodeIdsByKey,
           nodeIndexesByKey: context.nodeIndexesByKey,
-          nodeOutputSchemasById: context.nodeOutputSchemasById,
-          nodeIdsByKey: context.nodeIdsByKey
+          nodeOutputSchemasById: context.nodeOutputSchemasById
         });
         context.diagnostics.push(...extracted.diagnostics);
         if (extracted.diagnostics.some((item) => item.severity === "error"))
@@ -371106,6 +372171,255 @@ var require_modules = __commonJS({
         diagnostics.push(invalidDocumentInputDiagnostic(node, "crop", "type must be pdf"));
       return diagnostics;
     }
+    var DOCX_MIME_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+    var docTemplateModule = {
+      kind: "doc-template",
+      actionId: workflow_shared_1.WORKFLOW_ACTION_IDS.documentTemplater,
+      createFailedInput() {
+        return {
+          vaultUrl: "vault://00000000-0000-4000-8000-000000000000",
+          placeholders: [],
+          outputFilename: "compilation-failed.docx",
+          mustache: false,
+          createPermalink: false
+        };
+      },
+      validate(node) {
+        return validateDocTemplateInput(node);
+      },
+      lower(node, context) {
+        if (validateDocTemplateInput(node).length > 0)
+          return void 0;
+        const template = lowerDocTemplateSource(node.input.template, context);
+        const placeholders = lowerDocTemplatePlaceholders(node, context);
+        context.diagnostics.push(...template.diagnostics, ...placeholders.diagnostics);
+        if (!template.reference)
+          return void 0;
+        const templateFilename = node.input.templateFilename ?? template.lock?.name;
+        const templateFileSize = node.input.templateFileSize ?? template.lock?.size;
+        context.diagnostics.push(...validateKnownTemplateMetadata(node, template.lock));
+        const linearPorts = defaultLinearPorts(context.nodeId);
+        return {
+          node: {
+            id: context.nodeId,
+            name: node.name,
+            actionId: workflow_shared_1.WORKFLOW_ACTION_IDS.documentTemplater,
+            ports: [
+              { id: linearPorts.input, dir: "in", type: "default" },
+              { id: linearPorts.output, dir: "out", type: "default" }
+            ],
+            input: {
+              vaultUrl: template.reference,
+              placeholders: Object.entries(placeholders.values).map(([key, reference]) => ({ key, reference })),
+              outputFilename: node.input.outputFilename,
+              mustache: node.input.mustache ?? false,
+              createPermalink: node.input.createPermalink ?? false,
+              ...templateFilename === void 0 ? {} : { templateFilename },
+              ...templateFileSize === void 0 ? {} : { templateFileSize }
+            }
+          },
+          linearPorts,
+          outputSchema: output_schema_1.DOC_TEMPLATE_OUTPUT_JSON_SCHEMA,
+          vaultRefs: [...template.vaultRefs, ...placeholders.vaultRefs],
+          ...(0, reference_1.isWorkflowCodeVaultReference)(template.reference) ? { vaultRequirements: [{
+            reference: template.reference,
+            ...templateFilename === void 0 ? {} : { expectedName: templateFilename },
+            ...templateFileSize === void 0 ? {} : { expectedSize: templateFileSize },
+            requiredExtension: ".docx",
+            requiredMimeType: DOCX_MIME_TYPE
+          }] } : {}
+        };
+      }
+    };
+    function validateDocTemplateInput(node) {
+      if (!node.input || typeof node.input !== "object")
+        return [invalidDocTemplateInputDiagnostic(node, "input must be an object")];
+      const diagnostics = [];
+      if (!isVaultSource(node.input.template) && !isExclusiveWorkflowRef(node.input.template))
+        diagnostics.push(invalidDocTemplateInputDiagnostic(node, "template must be vault.ref(), vault.asset(), or a workflow reference callback"));
+      if (typeof node.input.outputFilename !== "string" || node.input.outputFilename.trim().length === 0)
+        diagnostics.push(invalidDocTemplateInputDiagnostic(node, "outputFilename must be a non-empty string"));
+      if (!isRecord3(node.input.placeholders))
+        diagnostics.push(invalidDocTemplateInputDiagnostic(node, "placeholders must be an object"));
+      else if (Object.entries(node.input.placeholders).some(([key, value]) => key.trim().length === 0 || !isReferencePlaceholder(value) && !isVaultSource(value)))
+        diagnostics.push(invalidDocTemplateInputDiagnostic(node, "placeholder keys must be non-empty and values must be string literals or compatible refs"));
+      if (node.input.mustache !== void 0 && typeof node.input.mustache !== "boolean")
+        diagnostics.push(invalidDocTemplateInputDiagnostic(node, "mustache must be a boolean"));
+      if (node.input.createPermalink !== void 0 && typeof node.input.createPermalink !== "boolean")
+        diagnostics.push(invalidDocTemplateInputDiagnostic(node, "createPermalink must be a boolean"));
+      if (node.input.templateFilename !== void 0 && (typeof node.input.templateFilename !== "string" || !hasDocxExtension(node.input.templateFilename)))
+        diagnostics.push(invalidDocTemplateInputDiagnostic(node, "templateFilename must name a .docx file"));
+      if (node.input.templateFileSize !== void 0 && (typeof node.input.templateFileSize !== "number" || !Number.isFinite(node.input.templateFileSize) || node.input.templateFileSize < 0))
+        diagnostics.push(invalidDocTemplateInputDiagnostic(node, "templateFileSize must be a non-negative finite number"));
+      if (isVaultAsset(node.input.template)) {
+        const assetName = node.input.template.name ?? node.input.template.path;
+        if (!hasDocxExtension(assetName))
+          diagnostics.push(invalidDocTemplateInputDiagnostic(node, "vault.asset() template must name a .docx file"));
+        if (node.input.template.mimeType !== void 0 && node.input.template.mimeType !== DOCX_MIME_TYPE)
+          diagnostics.push(invalidDocTemplateInputDiagnostic(node, `vault.asset() template MIME type must be ${DOCX_MIME_TYPE}`));
+      }
+      return diagnostics;
+    }
+    function invalidDocTemplateInputDiagnostic(node, detail) {
+      return {
+        code: "compiler.module.invalid_input",
+        severity: "error",
+        message: `Node ${node.name || "<unnamed>"} has invalid docTemplate input: ${detail}`
+      };
+    }
+    function lowerDocTemplateSource(source, context) {
+      if (isExclusiveWorkflowRef(source)) {
+        const compatibility = validateDocTemplateSourceTarget(source, context);
+        if (compatibility.length > 0)
+          return { vaultRefs: [], diagnostics: compatibility };
+        const resolved = (0, refs_1.resolveExclusiveRef)(source, {
+          inputIdsByKey: context.inputIdsByKey,
+          nodeIdentitiesByKey: context.nodeIdentitiesByKey,
+          nodesByPath: context.nodesByPath,
+          currentNode: context.currentNode
+        });
+        return { reference: resolved.reference, vaultRefs: [], diagnostics: resolved.diagnostics };
+      }
+      if (isVaultRef(source)) {
+        if (!(0, reference_1.isWorkflowCodeVaultReference)(source.reference))
+          return { vaultRefs: [], diagnostics: [invalidVaultRefDiagnostic(source.reference)] };
+        return { reference: source.reference, vaultRefs: [source.reference], diagnostics: [] };
+      }
+      if (!isVaultAsset(source))
+        return { vaultRefs: [], diagnostics: [] };
+      const lock = context.vaultAssetsByKey.get((0, asset_1.workflowCodeVaultAssetKey)(context.workflowKey, source));
+      if (!lock || !(0, reference_1.isWorkflowCodeVaultReference)(lock.ref)) {
+        return {
+          vaultRefs: [],
+          diagnostics: [{
+            code: "vault.asset.missing_lock",
+            severity: "error",
+            message: `Vault asset ${source.path} has no uploaded lock for this workflow`,
+            hint: "Run tela workflow sync so the CLI can upload and lock the local asset before compilation."
+          }]
+        };
+      }
+      return {
+        reference: lock.ref,
+        lock,
+        vaultRefs: [lock.ref],
+        diagnostics: []
+      };
+    }
+    function validateDocTemplateSourceTarget(source, context) {
+      if (source.targetKind === "input") {
+        const target2 = context.builtInputs.find((input) => (input.key ?? input.name) === source.targetKey);
+        if (!target2 || target2.inputType === "text")
+          return [];
+        return [incompatibleDocTemplateSourceDiagnostic(source.targetKey)];
+      }
+      const target = resolveVisibleNodeOutput(source.targetKey, context);
+      if (!target)
+        return [];
+      const directStringLlm = target.declaration?.nodeKind === "llm" && target.declaration.schema == null && (source.path?.length ?? 0) === 0;
+      const selectedSchema = (0, output_schema_1.selectOutputJsonSchema)(target.schema, source.path ?? []);
+      return directStringLlm || (0, output_schema_1.isStringCompatibleOutputJsonSchema)(selectedSchema) ? [] : [incompatibleDocTemplateSourceDiagnostic(source.targetKey)];
+    }
+    function incompatibleDocTemplateSourceDiagnostic(targetKey) {
+      return {
+        code: "compiler.ref.incompatible",
+        severity: "error",
+        message: `Template reference ${targetKey} does not select a string-compatible value for docTemplate.input.template`
+      };
+    }
+    function lowerDocTemplatePlaceholders(node, context) {
+      const diagnostics = validateDocTemplatePlaceholderCompatibility(node, context);
+      const resolved = (0, refs_1.resolveReferenceRecordRefs)({
+        values: node.input.placeholders,
+        refs: node.placeholderRefs ?? [],
+        inputIdsByKey: context.inputIdsByKey,
+        inputTypesByKey: context.inputTypesByKey,
+        nodeIdentitiesByKey: context.nodeIdentitiesByKey,
+        nodesByPath: context.nodesByPath,
+        currentNode: context.currentNode
+      });
+      diagnostics.push(...resolved.diagnostics);
+      const values = {};
+      const vaultRefs = [];
+      for (const [key, value] of Object.entries(resolved.values)) {
+        if (typeof value === "string") {
+          values[key] = value;
+          continue;
+        }
+        if (isVaultRef(value)) {
+          if ((0, reference_1.isWorkflowCodeVaultReference)(value.reference)) {
+            values[key] = value.reference;
+            vaultRefs.push(value.reference);
+          } else {
+            diagnostics.push(invalidVaultRefDiagnostic(value.reference));
+          }
+          continue;
+        }
+        if (isVaultAsset(value)) {
+          const lock = context.vaultAssetsByKey.get((0, asset_1.workflowCodeVaultAssetKey)(context.workflowKey, value));
+          if (!lock || !(0, reference_1.isWorkflowCodeVaultReference)(lock.ref)) {
+            diagnostics.push({
+              code: "vault.asset.missing_lock",
+              severity: "error",
+              message: `Vault asset ${value.path} has no uploaded lock for this workflow`,
+              hint: "Run tela workflow sync so the CLI can upload and lock the local asset before compilation."
+            });
+          } else {
+            values[key] = lock.ref;
+            vaultRefs.push(lock.ref);
+          }
+        }
+      }
+      return { values: Object.freeze(values), vaultRefs, diagnostics };
+    }
+    function validateDocTemplatePlaceholderCompatibility(node, context) {
+      const diagnostics = [];
+      for (const ref of node.placeholderRefs ?? []) {
+        if (ref.targetKind === "input") {
+          if (context.inputTypesByKey.get(ref.targetKey) === "file")
+            diagnostics.push(incompatibleDocTemplatePlaceholderDiagnostic(ref.key, ref.targetKey));
+          continue;
+        }
+        const target = resolveVisibleNodeOutput(ref.targetKey, context);
+        if (!target)
+          continue;
+        const directStringLlm = target.declaration?.nodeKind === "llm" && target.declaration.schema == null && (ref.path?.length ?? 0) === 0;
+        const selected = (0, output_schema_1.selectOutputJsonSchema)(target.schema, ref.path ?? []);
+        if (!directStringLlm && !(0, output_schema_1.isStringCompatibleOutputJsonSchema)(selected))
+          diagnostics.push(incompatibleDocTemplatePlaceholderDiagnostic(ref.key, ref.targetKey));
+      }
+      return diagnostics;
+    }
+    function incompatibleDocTemplatePlaceholderDiagnostic(key, targetKey) {
+      return {
+        code: "compiler.ref.incompatible",
+        severity: "error",
+        message: `Placeholder ${key} reference ${targetKey} does not select a string-compatible value`
+      };
+    }
+    function validateKnownTemplateMetadata(node, lock) {
+      if (!lock)
+        return [];
+      const diagnostics = [];
+      if (node.input.templateFilename !== void 0 && lock.name !== void 0 && node.input.templateFilename !== lock.name)
+        diagnostics.push(invalidDocTemplateInputDiagnostic(node, `templateFilename ${node.input.templateFilename} does not match locked asset name ${lock.name}`));
+      if (node.input.templateFileSize !== void 0 && lock.size !== void 0 && node.input.templateFileSize !== lock.size)
+        diagnostics.push(invalidDocTemplateInputDiagnostic(node, `templateFileSize ${node.input.templateFileSize} does not match locked asset size ${lock.size}`));
+      if (lock.name !== void 0 && !hasDocxExtension(lock.name))
+        diagnostics.push(invalidDocTemplateInputDiagnostic(node, `locked asset name ${lock.name} is not a .docx file`));
+      if (lock.mimeType !== void 0 && lock.mimeType !== DOCX_MIME_TYPE)
+        diagnostics.push(invalidDocTemplateInputDiagnostic(node, `locked asset MIME type ${lock.mimeType} is not ${DOCX_MIME_TYPE}`));
+      return diagnostics;
+    }
+    function hasDocxExtension(value) {
+      return value.toLowerCase().endsWith(".docx");
+    }
+    function isReferencePlaceholder(value) {
+      return typeof value === "string";
+    }
+    function isVaultSource(value) {
+      return isVaultRef(value) || isVaultAsset(value);
+    }
     function validateSplitterInput(node) {
       if (!node.input || typeof node.input !== "object")
         return [invalidSplitterInputDiagnostic(node, "input must be an object")];
@@ -371220,19 +372534,32 @@ var require_modules = __commonJS({
     }
     function validateExclusiveFileTarget(file2, context, targetField) {
       if (file2.targetKind === "input") {
-        const target = context.builtInputs.find((input) => (input.key ?? input.name) === file2.targetKey);
-        if (!target || target.inputType === "file")
+        const target2 = context.builtInputs.find((input) => (input.key ?? input.name) === file2.targetKey);
+        if (!target2 || target2.inputType === "file")
           return [];
         return [incompatibleDocumentRefDiagnostic(file2.targetKey, targetField)];
       }
-      const resolved = (0, refs_1.resolveWorkflowRef)(file2, context);
-      if (resolved.nodeId === void 0)
+      const target = resolveVisibleNodeOutput(file2.targetKey, context);
+      if (!target)
         return [];
-      const selectedSchema = (0, output_schema_1.selectOutputJsonSchema)(context.nodeOutputSchemasById.get(resolved.nodeId), file2.path ?? []);
-      if (selectedSchema === void 0 && context.remoteMode.kind === "symbolic" && context.remoteTemplateNodeIds.has(resolved.nodeId))
+      const selectedSchema = (0, output_schema_1.selectOutputJsonSchema)(target.schema, file2.path ?? []);
+      if (selectedSchema === void 0 && context.remoteMode.kind === "symbolic" && context.remoteTemplateNodeIds.has(target.id))
         return [];
       return (0, output_schema_1.isFileCompatibleOutputJsonSchema)(selectedSchema) ? [] : [incompatibleDocumentRefDiagnostic(file2.targetKey, targetField)];
     }
+    function resolveVisibleNodeOutput(targetKey, context) {
+      const identity2 = (0, refs_1.resolveVisibleNodeIdentity)(targetKey, {
+        nodeIdentitiesByKey: context.nodeIdentitiesByKey,
+        currentNode: context.currentNode
+      });
+      if (!identity2)
+        return void 0;
+      return {
+        id: identity2.id,
+        declaration: context.nodeDeclarationsById.get(identity2.id),
+        schema: context.nodeOutputSchemasById.get(identity2.id)
+      };
+    }
     function incompatibleDocumentRefDiagnostic(targetKey, targetField) {
       return {
         code: "compiler.ref.incompatible",
@@ -371453,9 +372780,12 @@ var require_modules = __commonJS({
       [remoteAgentModule.kind, remoteAgentModule],
       [remoteTemplateModule.kind, remoteTemplateModule],
       [codeModule.kind, codeModule],
+      [conditionModule.kind, conditionModule],
+      [stopModule.kind, stopModule],
       [mapModule.kind, mapModule],
       [splitterModule.kind, splitterModule],
-      [cropModule.kind, cropModule]
+      [cropModule.kind, cropModule],
+      [docTemplateModule.kind, docTemplateModule]
     ]);
   }
 });
@@ -371469,20 +372799,64 @@ var require_validation = __commonJS({
     var modules_1 = require_modules();
     function validateDeclaration(declaration) {
       const nodes = flattenValidationNodes(declaration.nodes);
+      const stopPlacementDiagnostics = [];
+      validateStopPlacement(declaration.nodes, { directConditionBranch: false, insideMapBody: false }, stopPlacementDiagnostics);
       return [
         ...validateWorkflowIdentity(declaration),
         ...validateInputIdentities(declaration.inputs),
         ...validateNodeIdentities(declaration.nodes),
-        ...validateModuleInputs(nodes)
+        ...validateModuleInputs(nodes),
+        ...stopPlacementDiagnostics
       ];
     }
     function flattenValidationNodes(nodes) {
       return nodes.flatMap((node) => {
-        if (!isNodeLike(node) || node.nodeKind !== "map" || !Array.isArray(node.nodes))
+        if (!isNodeLike(node))
+          return [node];
+        if (node.nodeKind === "condition") {
+          const input = node.input;
+          const cases = Array.isArray(input?.cases) ? input.cases : [];
+          const defaultBranch = input?.default && typeof input.default === "object" && Array.isArray(input.default.nodes) ? input.default : void 0;
+          return [node, ...cases.flatMap((branch) => {
+            if (!branch || typeof branch !== "object" || !Array.isArray(branch.nodes))
+              return [];
+            return flattenValidationNodes(branch.nodes);
+          }), ...defaultBranch ? flattenValidationNodes(defaultBranch.nodes) : []];
+        }
+        if (node.nodeKind !== "map" || !Array.isArray(node.nodes))
           return [node];
         return [node, ...flattenValidationNodes(node.nodes)];
       });
     }
+    function validateStopPlacement(nodes, context, diagnostics) {
+      nodes.forEach((node, index) => {
+        if (!isNodeLike(node))
+          return;
+        const nodeContext = {
+          ...context,
+          isFinalDirectNode: index === nodes.length - 1
+        };
+        if (node.nodeKind === "stop" && (!nodeContext.directConditionBranch || !nodeContext.isFinalDirectNode || nodeContext.insideMapBody)) {
+          diagnostics.push({
+            code: "compiler.stop.invalid_placement",
+            severity: "error",
+            message: "stop() is allowed only as the final direct node of a condition branch"
+          });
+        }
+        if (node.nodeKind === "map" && Array.isArray(node.nodes))
+          validateStopPlacement(node.nodes, { directConditionBranch: false, insideMapBody: true }, diagnostics);
+        if (node.nodeKind === "condition") {
+          const input = node.input;
+          const cases = Array.isArray(input?.cases) ? input.cases : [];
+          for (const branch of cases) {
+            if (branch && typeof branch === "object" && Array.isArray(branch.nodes))
+              validateStopPlacement(branch.nodes, { directConditionBranch: true, insideMapBody: context.insideMapBody }, diagnostics);
+          }
+          if (input?.default && typeof input.default === "object" && Array.isArray(input.default.nodes))
+            validateStopPlacement(input.default.nodes, { directConditionBranch: true, insideMapBody: context.insideMapBody }, diagnostics);
+        }
+      });
+    }
     function validateWorkflowIdentity(declaration) {
       if (typeof declaration.workflow.workflowKey === "string" && declaration.workflow.workflowKey.trim().length > 0)
         return [];
@@ -371509,6 +372883,7 @@ var require_validation = __commonJS({
     }
     function validateNodeIdentities(nodes, scopePath = []) {
       const validNodes = nodes.filter(isNodeLike);
+      const authoredIdentityNodes = validNodes.filter((node) => !isCompilerOwnedTopologyNode(node));
       const scopeLabel = scopePath.length > 0 ? `workflow node at ${scopePath.join(".")}` : "workflow node";
       return [
         ...nodes.filter((node) => !isNodeLike(node)).map(() => ({
@@ -371516,14 +372891,33 @@ var require_validation = __commonJS({
           severity: "error",
           message: `${scopeLabel} must be an object declaration`
         })),
-        ...findEmpty(validNodes.map((node) => node.name), "compiler.node.invalid_name", `${scopeLabel} name`),
-        ...findEmpty(validNodes.flatMap((node) => node.key !== void 0 ? [node.key] : []), "compiler.node.invalid_name", `${scopeLabel} key`),
-        ...findDuplicates(validNodes.map((node) => node.name), "compiler.node.duplicate_name", `${scopeLabel} name`),
-        ...findDuplicates(validNodes.flatMap((node) => node.key !== void 0 ? [node.key] : []), "compiler.node.duplicate_name", `${scopeLabel} key`),
-        ...findDuplicates(validNodes.map((node) => node.key ?? node.name), "compiler.node.duplicate_name", `${scopeLabel} effective identity`),
-        ...validNodes.flatMap((node, index) => node.nodeKind === "map" && Array.isArray(node.nodes) ? validateNodeIdentities(node.nodes, [...scopePath, index]) : [])
+        ...findEmpty(authoredIdentityNodes.map((node) => node.name), "compiler.node.invalid_name", `${scopeLabel} name`),
+        ...findEmpty(authoredIdentityNodes.flatMap((node) => node.key !== void 0 ? [node.key] : []), "compiler.node.invalid_name", `${scopeLabel} key`),
+        ...findDuplicates(authoredIdentityNodes.map((node) => node.name), "compiler.node.duplicate_name", `${scopeLabel} name`),
+        ...findDuplicates(authoredIdentityNodes.flatMap((node) => node.key !== void 0 ? [node.key] : []), "compiler.node.duplicate_name", `${scopeLabel} key`),
+        ...findDuplicates(authoredIdentityNodes.map((node) => node.key ?? node.name), "compiler.node.duplicate_name", `${scopeLabel} effective identity`),
+        ...validNodes.flatMap((node, index) => nestedIdentityScopes(node, [...scopePath, index]))
       ];
     }
+    function isCompilerOwnedTopologyNode(node) {
+      return node.nodeKind === "condition" || node.nodeKind === "stop";
+    }
+    function nestedIdentityScopes(node, path3) {
+      if (node.nodeKind === "map" && Array.isArray(node.nodes))
+        return validateNodeIdentities(node.nodes, path3);
+      if (node.nodeKind !== "condition")
+        return [];
+      const input = node.input;
+      const cases = Array.isArray(input?.cases) ? input.cases : [];
+      const branchDiagnostics = cases.flatMap((branch, branchIndex) => {
+        if (!branch || typeof branch !== "object" || !Array.isArray(branch.nodes))
+          return [];
+        return validateNodeIdentities(branch.nodes, [...path3, branchIndex]);
+      });
+      const defaultIndex = cases.length;
+      const defaultDiagnostics = input?.default && typeof input.default === "object" && Array.isArray(input.default.nodes) ? validateNodeIdentities(input.default.nodes, [...path3, defaultIndex]) : [];
+      return [...branchDiagnostics, ...defaultDiagnostics];
+    }
     function validateModuleInputs(nodes) {
       const diagnostics = [];
       for (const node of nodes) {
@@ -371597,24 +372991,69 @@ var require_transpile = __commonJS({
     }
     function createTopologyEdges(records, loweredByPath) {
       const edges = [];
-      function lowerSequence(sequence) {
-        for (let index = 1; index < sequence.length; index++) {
-          const source = loweredByPath.get(pathKey(sequence[index - 1]?.path ?? []));
-          const target = loweredByPath.get(pathKey(sequence[index]?.path ?? []));
-          if (!source?.linearPorts || !target?.linearPorts)
+      function lowerSequence(sequence, continuation) {
+        let pendingTails = [];
+        for (let index = 0; index < sequence.length; index++) {
+          const record2 = sequence[index];
+          if (!record2)
             continue;
-          edges.push(createEdge(source.node.id, source.linearPorts.output, target.node.id, target.linearPorts.input));
-        }
-        for (const record2 of sequence) {
           const lowered = loweredByPath.get(pathKey(record2.path));
+          if (!lowered) {
+            pendingTails = [];
+            continue;
+          }
+          if (lowered.linearPorts)
+            connectTails(pendingTails, lowered.node.id, lowered.linearPorts.input);
+          if (lowered.branchOutputPorts)
+            pendingTails = lowerConditionBranches(record2, lowered);
+          else if (lowered.terminal)
+            pendingTails = [];
+          else if (lowered.linearPorts?.output)
+            pendingTails = [{ nodeId: lowered.node.id, outputPortId: lowered.linearPorts.output }];
+          else
+            pendingTails = [];
+          const next = sequence[index + 1] ?? continuation;
+          const loweredNext = next ? loweredByPath.get(pathKey(next.path)) : void 0;
+          if (loweredNext?.linearPorts) {
+            connectTails(pendingTails, loweredNext.node.id, loweredNext.linearPorts.input);
+            pendingTails = [];
+          } else if (next) {
+            pendingTails = [];
+          }
           const root = record2.children[0];
           const loweredRoot = root ? loweredByPath.get(pathKey(root.path)) : void 0;
-          if (lowered?.subgraphOutputPort && loweredRoot?.linearPorts) {
+          if (lowered.subgraphOutputPort && loweredRoot?.linearPorts) {
             edges.push(createEdge(lowered.node.id, lowered.subgraphOutputPort, loweredRoot.node.id, loweredRoot.linearPorts.input));
           }
           if (record2.children.length > 0)
             lowerSequence(record2.children);
         }
+        const loweredContinuation = continuation ? loweredByPath.get(pathKey(continuation.path)) : void 0;
+        if (loweredContinuation?.linearPorts)
+          connectTails(pendingTails, loweredContinuation.node.id, loweredContinuation.linearPorts.input);
+        return pendingTails;
+      }
+      function lowerConditionBranches(record2, lowered) {
+        const tails = [];
+        for (const branch of record2.branches) {
+          const port = lowered.branchOutputPorts?.[branch.portIndex];
+          if (!port)
+            continue;
+          const branchRoot = branch.records[0];
+          const loweredBranchRoot = branchRoot ? loweredByPath.get(pathKey(branchRoot.path)) : void 0;
+          if (branchRoot && loweredBranchRoot?.linearPorts) {
+            edges.push(createEdge(lowered.node.id, port, loweredBranchRoot.node.id, loweredBranchRoot.linearPorts.input));
+            tails.push(...lowerSequence(branch.records));
+            continue;
+          }
+          if (!branchRoot)
+            tails.push({ nodeId: lowered.node.id, outputPortId: port });
+        }
+        return tails;
+      }
+      function connectTails(tails, targetId, targetPortId) {
+        for (const tail of tails)
+          edges.push(createEdge(tail.nodeId, tail.outputPortId, targetId, targetPortId));
       }
       lowerSequence(records);
       return edges;
@@ -371645,14 +373084,80 @@ var require_transpile = __commonJS({
         return createFailedCodeNode(workflowKey, declaration);
       if (declaration.node.nodeKind === "map")
         return createFailedMapNode(workflowKey, declaration);
+      if (declaration.node.nodeKind === "condition")
+        return createFailedConditionNode(workflowKey, declaration);
+      if (declaration.node.nodeKind === "stop")
+        return createFailedStopNode(workflowKey, declaration);
       if (declaration.node.nodeKind === "splitter")
         return createFailedSplitterNode(workflowKey, declaration);
       if (declaration.node.nodeKind === "crop")
         return createFailedCropNode(workflowKey, declaration);
+      if (declaration.node.nodeKind === "doc-template")
+        return createFailedDocTemplateNode(workflowKey, declaration);
       if (declaration.node.nodeKind === "remote-executable" || declaration.node.nodeKind === "remote-agent" || declaration.node.nodeKind === "remote-template")
         return createFailedRemoteNode(workflowKey, declaration);
       return createFailedPromptNode(workflowKey, declaration);
     }
+    function createFailedDocTemplateNode(workflowKey, declaration) {
+      const nodeId = (0, ids_1.stableNodeId)(workflowKey, declaration.node, declaration.path);
+      const linearPorts = failedNodePorts(nodeId);
+      const module3 = modules_1.nodeModuleRegistry.get(declaration.node.nodeKind);
+      return {
+        declarationIndex: declaration.ordinal,
+        path: declaration.path,
+        scopePath: declaration.scopePath,
+        sequenceIndex: declaration.sequenceIndex,
+        linearPorts,
+        node: {
+          id: nodeId,
+          name: declaration.node.name,
+          actionId: module3?.actionId ?? workflow_shared_1.WORKFLOW_ACTION_IDS.documentTemplater,
+          ports: workflowNodePorts(linearPorts),
+          input: module3?.createFailedInput(declaration.node) ?? {}
+        }
+      };
+    }
+    function createFailedStopNode(workflowKey, declaration) {
+      const nodeId = (0, ids_1.stableNodeId)(workflowKey, declaration.node, declaration.path);
+      const linearPorts = failedNodePorts(nodeId);
+      return {
+        declarationIndex: declaration.ordinal,
+        path: declaration.path,
+        scopePath: declaration.scopePath,
+        sequenceIndex: declaration.sequenceIndex,
+        linearPorts,
+        node: {
+          id: nodeId,
+          name: declaration.node.name,
+          actionId: workflow_shared_1.WORKFLOW_ACTION_IDS.codeExecution,
+          ports: workflowNodePorts(linearPorts),
+          input: {
+            code: "export async function execute(): Promise<never> {\n    throw new Error('Workflow Code compilation failed for this stop node. Check compiler diagnostics before syncing this workflow.')\n}\n",
+            language: "typescript",
+            libraries: []
+          }
+        }
+      };
+    }
+    function createFailedConditionNode(workflowKey, declaration) {
+      const nodeId = (0, ids_1.stableNodeId)(workflowKey, declaration.node, declaration.path);
+      const inputPort = (0, ids_1.defaultInputPortId)(nodeId);
+      return {
+        declarationIndex: declaration.ordinal,
+        path: declaration.path,
+        scopePath: declaration.scopePath,
+        sequenceIndex: declaration.sequenceIndex,
+        linearPorts: { input: inputPort, output: "" },
+        branchOutputPorts: Object.freeze([]),
+        node: {
+          id: nodeId,
+          name: declaration.node.name,
+          actionId: workflow_shared_1.WORKFLOW_ACTION_IDS.condition,
+          ports: [{ id: inputPort, dir: "in", type: "default" }],
+          input: { cases: [] }
+        }
+      };
+    }
     function createFailedRemoteNode(workflowKey, declaration) {
       const nodeId = (0, ids_1.stableNodeId)(workflowKey, declaration.node, declaration.path);
       const linearPorts = failedNodePorts(nodeId);
@@ -371804,12 +373309,14 @@ var require_transpile = __commonJS({
         { id: linearPorts.output, dir: "out", type: "default" }
       ];
     }
-    function createNodeRecords(nodes, scopePath = [], ancestorMapPaths = [], ordinalOffset = { value: 0 }) {
+    function createNodeRecords(nodes, scopePath = [], ancestorMapPaths = [], ancestorScopes = [], ordinalOffset = { value: 0 }) {
       const records = [];
       nodes.forEach((node, sequenceIndex) => {
         const path3 = [...scopePath, sequenceIndex];
         const ordinal = ordinalOffset.value++;
-        const children = node.nodeKind === "map" && Array.isArray(node.nodes) ? createNodeRecords(node.nodes.filter(isNodeLike), path3, [...ancestorMapPaths, path3], ordinalOffset) : [];
+        const boundary = { scopePath, sequenceIndex };
+        const children = node.nodeKind === "map" && Array.isArray(node.nodes) ? createNodeRecords(node.nodes.filter(isNodeLike), path3, [...ancestorMapPaths, path3], [...ancestorScopes, boundary], ordinalOffset) : [];
+        const branches = isValidConditionBranchContainer(node) ? createConditionBranchRecords(node, path3, ancestorMapPaths, [...ancestorScopes, boundary], ordinalOffset) : [];
         records.push({
           node,
           path: path3,
@@ -371817,18 +373324,43 @@ var require_transpile = __commonJS({
           sequenceIndex,
           ordinal,
           ancestorMapPaths,
-          children
+          ancestorScopes,
+          children,
+          branches
         });
       });
       return records;
     }
+    function isValidConditionBranchContainer(node) {
+      return node.nodeKind === "condition" && Boolean(node.input) && typeof node.input === "object" && Array.isArray(node.input.cases) && node.input.cases.every(isConditionBranchShape) && (node.input.default === void 0 || isConditionDefaultShape(node.input.default));
+    }
+    function isConditionBranchShape(branch) {
+      return Boolean(branch) && typeof branch === "object" && typeof branch.name === "string" && Array.isArray(branch.nodes);
+    }
+    function isConditionDefaultShape(branch) {
+      return Boolean(branch) && typeof branch === "object" && Array.isArray(branch.nodes);
+    }
+    function createConditionBranchRecords(node, conditionPath, ancestorMapPaths, ancestorScopes, ordinalOffset) {
+      const records = node.input.cases.map((branch, branchIndex) => ({
+        name: branch.name,
+        portIndex: branchIndex,
+        records: createNodeRecords(branch.nodes.filter(isNodeLike), [...conditionPath, branchIndex], ancestorMapPaths, ancestorScopes, ordinalOffset)
+      }));
+      if (!node.input.default)
+        return records;
+      return [...records, {
+        name: "Default",
+        portIndex: node.input.cases.length,
+        records: createNodeRecords(node.input.default.nodes.filter(isNodeLike), [...conditionPath, node.input.cases.length], ancestorMapPaths, ancestorScopes, ordinalOffset)
+      }];
+    }
     function flattenRecords(records) {
-      return records.flatMap((record2) => [record2, ...flattenRecords(record2.children)]);
+      return records.flatMap((record2) => [record2, ...flattenRecords(record2.children), ...record2.branches.flatMap((branch) => flattenRecords(branch.records))]);
     }
     function validateMapTopology(nodes) {
       const diagnostics = [];
       for (const item of nodes) {
-        if (item.scopePath.length === 0)
+        if (item.ancestorMapPaths.length === 0)
           continue;
         if (item.node.nodeKind === "code") {
           diagnostics.push({
@@ -371841,7 +373373,7 @@ var require_transpile = __commonJS({
       return diagnostics;
     }
     function isUnsupportedMapBodyNode(item) {
-      return item.scopePath.length > 0 && item.node.nodeKind === "code";
+      return item.ancestorMapPaths.length > 0 && item.node.nodeKind === "code";
     }
     function createChildNodeIdsByParentId(workflowKey, nodes) {
       const ids = /* @__PURE__ */ new Map();
@@ -371861,6 +373393,23 @@ var require_transpile = __commonJS({
     function createLoweredByPath(nodes) {
       return new Map(nodes.map((node) => [pathKey(node.path), node]));
     }
+    function collectInvalidStopPlacementPathKeys(records) {
+      const invalid = /* @__PURE__ */ new Set();
+      function visit(sequence, context) {
+        sequence.forEach((record2, index) => {
+          const isFinalDirectNode = index === sequence.length - 1;
+          if (record2.node.nodeKind === "stop" && (!context.directConditionBranch || !isFinalDirectNode || context.insideMapBody)) {
+            invalid.add(pathKey(record2.path));
+          }
+          if (record2.children.length > 0)
+            visit(record2.children, { directConditionBranch: false, insideMapBody: true });
+          for (const branch of record2.branches)
+            visit(branch.records, { directConditionBranch: true, insideMapBody: context.insideMapBody });
+        });
+      }
+      visit(records, { directConditionBranch: false, insideMapBody: false });
+      return invalid;
+    }
     function createScopedIdentities(workflowKey, records) {
       const nodesByPath = /* @__PURE__ */ new Map();
       const identitiesByKey = /* @__PURE__ */ new Map();
@@ -371868,13 +373417,17 @@ var require_transpile = __commonJS({
         const key = record2.node.key ?? record2.node.name;
         const identity2 = {
           key,
+          runtimeName: record2.node.name,
           id: (0, ids_1.stableNodeId)(workflowKey, record2.node, record2.path),
           path: record2.path,
           scopePath: record2.scopePath,
           sequenceIndex: record2.sequenceIndex,
-          ancestorMapPaths: record2.ancestorMapPaths
+          ancestorMapPaths: record2.ancestorMapPaths,
+          ancestorScopes: record2.ancestorScopes
         };
         nodesByPath.set(pathKey(record2.path), identity2);
+        if (record2.node.nodeKind === "condition" || record2.node.nodeKind === "stop")
+          continue;
         const identities = identitiesByKey.get(key) ?? [];
         identities.push(identity2);
         identitiesByKey.set(key, identities);
@@ -371908,17 +373461,18 @@ var require_transpile = __commonJS({
       });
       const inputTypesByKey = new Map(declarationInputs.map((declaration) => [declaration.key ?? declaration.name, declaration.inputType]));
       const topLevelNodes = flattenedNodes.filter((node) => node.scopePath.length === 0);
+      const outputProducingTopLevelNodes = topLevelNodes.filter(({ node }) => node.nodeKind !== "condition" && node.nodeKind !== "stop");
       const nodeIdsByKey = /* @__PURE__ */ new Map();
       const nodeIndexesByKey = /* @__PURE__ */ new Map();
-      topLevelNodes.forEach(({ node, path: path3, ordinal }) => {
+      outputProducingTopLevelNodes.forEach(({ node, path: path3, ordinal }) => {
         const key = node.key ?? node.name;
         nodeIdsByKey.set(key, (0, ids_1.stableNodeId)(workflowKey, node, path3));
         nodeIndexesByKey.set(key, ordinal);
       });
       const { nodesByPath, nodeIdentitiesByKey } = createScopedIdentities(workflowKey, flattenedNodes);
+      const nodeDeclarationsById = new Map(flattenedNodes.map(({ node, path: path3 }) => [(0, ids_1.stableNodeId)(workflowKey, node, path3), node]));
       const inputNamesByKey = new Map(declarationInputs.map((declaration) => [declaration.key ?? declaration.name, declaration.name]));
-      const nodeNamesByKey = new Map(topLevelNodes.map(({ node }) => [node.key ?? node.name, node.name]));
-      const nodeOutputSchemasByKey = /* @__PURE__ */ new Map();
+      const nodeNamesByKey = new Map(outputProducingTopLevelNodes.map(({ node }) => [node.key ?? node.name, node.name]));
       const nodeOutputSchemasById = /* @__PURE__ */ new Map();
       const remoteTemplateNodeIds = new Set(flattenedNodes.filter(({ node }) => node.nodeKind === "remote-template").map(({ node, path: path3 }) => (0, ids_1.stableNodeId)(workflowKey, node, path3)));
       const buildBinding = input.declaration[contracts_1.BUILD_BINDING];
@@ -371930,10 +373484,13 @@ var require_transpile = __commonJS({
         ...declaration.description !== void 0 ? { description: declaration.description } : {}
       }));
       const childNodeIdsByParentId = createChildNodeIdsByParentId(workflowKey, flattenedNodes);
+      const invalidStopPlacementPathKeys = collectInvalidStopPlacementPathKeys(rootRecords);
       const loweredModuleNodesByDeclaration = flattenedNodes.map((flattened, index) => {
         const { node } = flattened;
         if (isUnsupportedMapBodyNode(flattened))
           return void 0;
+        if (node.nodeKind === "stop" && invalidStopPlacementPathKeys.has(pathKey(flattened.path)))
+          return void 0;
         const module3 = modules_1.nodeModuleRegistry.get(node.nodeKind);
         if (!module3)
           return void 0;
@@ -371947,17 +373504,19 @@ var require_transpile = __commonJS({
           nodesByPath,
           currentNode: nodesByPath.get(pathKey(flattened.path)) ?? {
             key: node.key ?? node.name,
+            runtimeName: node.name,
             id: (0, ids_1.stableNodeId)(workflowKey, node, flattened.path),
             path: flattened.path,
             scopePath: flattened.scopePath,
             sequenceIndex: flattened.sequenceIndex,
-            ancestorMapPaths: flattened.ancestorMapPaths
+            ancestorMapPaths: flattened.ancestorMapPaths,
+            ancestorScopes: flattened.ancestorScopes
           },
           nodeIdsByKey,
           nodeIndexesByKey,
+          nodeDeclarationsById,
           inputNamesByKey,
           nodeNamesByKey,
-          nodeOutputSchemasByKey,
           nodeOutputSchemasById,
           remoteTemplateNodeIds,
           builtInputs: declarationInputs,
@@ -371970,10 +373529,8 @@ var require_transpile = __commonJS({
           remoteRefs,
           diagnostics
         });
-        if (lowered?.outputSchema !== void 0) {
-          nodeOutputSchemasByKey.set(node.key ?? node.name, lowered.outputSchema);
+        if (lowered?.outputSchema !== void 0)
           nodeOutputSchemasById.set((0, ids_1.stableNodeId)(workflowKey, node, flattened.path), lowered.outputSchema);
-        }
         return lowered ? {
           ...lowered,
           declarationIndex: index,
@@ -371985,6 +373542,7 @@ var require_transpile = __commonJS({
       const loweredModuleNodes = loweredModuleNodesByDeclaration.filter(isLoweredModuleNodeWithIndex);
       const vaultRefs = [...new Set(loweredModuleNodes.flatMap((item) => item.vaultRefs ?? []))].sort((left, right) => left.localeCompare(right));
       const vaultAssets = collectVaultAssetUses(flattenedNodes, workflowKey);
+      const vaultRequirements = [...new Map(loweredModuleNodes.flatMap((item) => item.vaultRequirements ?? []).map((item) => [JSON.stringify(item), item])).values()].sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
       const loweredByPath = createLoweredByPath(loweredModuleNodes);
       const nodes = loweredModuleNodes.map((item) => item.node);
       const edges = createTopologyEdges(rootRecords, loweredByPath);
@@ -372027,7 +373585,8 @@ var require_transpile = __commonJS({
         },
         resources: Object.freeze({
           vaultRefs: Object.freeze(vaultRefs),
-          ...vaultAssets.length === 0 ? {} : { vaultAssets: Object.freeze(vaultAssets) }
+          ...vaultAssets.length === 0 ? {} : { vaultAssets: Object.freeze(vaultAssets) },
+          ...vaultRequirements.length === 0 ? {} : { vaultRequirements: Object.freeze(vaultRequirements) }
         }),
         diagnostics
       });
@@ -372035,9 +373594,7 @@ var require_transpile = __commonJS({
     function collectVaultAssetUses(records, workflowKey) {
       const byKey = /* @__PURE__ */ new Map();
       for (const { node } of records) {
-        if (node.nodeKind !== "splitter" && node.nodeKind !== "crop")
-          continue;
-        const values = Array.isArray(node.input.file) ? node.input.file : [node.input.file];
+        const values = node.nodeKind === "doc-template" ? [node.input.template, ...Object.values(node.input.placeholders)] : node.nodeKind === "splitter" || node.nodeKind === "crop" ? Array.isArray(node.input.file) ? node.input.file : [node.input.file] : [];
         for (const value of values) {
           if (!isVaultAsset(value))
             continue;
@@ -372583,6 +374140,7 @@ var require_evaluate_source = __commonJS({
     var node_path_1 = require("node:path");
     var node_vm_1 = require("node:vm");
     var typescript_1 = __importDefault(require_typescript3());
+    var condition_provenance_1 = require_condition_provenance();
     var hash_1 = require_hash();
     var diagnostics_1 = require_diagnostics();
     function evaluateWorkflowSource(entrypoint, compilerOptions = {}, sourceRoot = (0, node_path_1.dirname)((0, node_path_1.resolve)(entrypoint))) {
@@ -372633,10 +374191,12 @@ var require_evaluate_source = __commonJS({
       includeSourceOnlyLocalModules(resolvedPath, content, files, compilerOptions, sourceRoot, /* @__PURE__ */ new Set([resolvedPath]));
       let outputText;
       let sourceMap;
+      let trustedConditionSourceToken;
       try {
         const transpiled = transpileWorkflowSource(content, resolvedPath, compilerOptions, sourceRoot);
         outputText = transpiled.outputText;
         sourceMap = transpiled.sourceMap;
+        trustedConditionSourceToken = transpiled.trustedConditionSourceToken;
       } catch (error48) {
         if (error48 instanceof SourceEvaluationError)
           throw error48;
@@ -372690,7 +374250,9 @@ var require_evaluate_source = __commonJS({
           exports: exports3,
           module: module3,
           process: createWorkflowProcessFacade(),
-          __workflowCodeRandomUUID: node_crypto_1.randomUUID
+          __workflowCodeRandomUUID: node_crypto_1.randomUUID,
+          __workflowCodeTrustConditionBinding: condition_provenance_1.trustConditionBinding,
+          __workflowCodeTrustedConditionSourceToken: trustedConditionSourceToken
         });
         new node_vm_1.Script(`${prelude}${outputText}`, { filename: resolvedPath }).runInNewContext(sandbox, {
           contextCodeGeneration: { strings: false, wasm: false }
@@ -372774,6 +374336,7 @@ var require_evaluate_source = __commonJS({
       return exportClause.elements.some((element) => element.isTypeOnly);
     }
     function transpileWorkflowSource(content, fileName, compilerOptions, sourceRoot) {
+      const trustedConditionSourceToken = (0, node_crypto_1.randomUUID)();
       const result = typescript_1.default.transpileModule(content, {
         fileName,
         compilerOptions: {
@@ -372787,15 +374350,16 @@ var require_evaluate_source = __commonJS({
           target: typescript_1.default.ScriptTarget.ES2022
         },
         transformers: {
-          before: [createWorkflowCodeSourceMarkerTransformer(fileName, compilerOptions, sourceRoot)]
+          before: [createWorkflowCodeSourceMarkerTransformer(fileName, compilerOptions, sourceRoot, trustedConditionSourceToken)]
         }
       });
       return {
         outputText: result.outputText,
-        sourceMap: parseWorkflowSourceMap(result.sourceMapText)
+        sourceMap: parseWorkflowSourceMap(result.sourceMapText),
+        trustedConditionSourceToken
       };
     }
-    function createWorkflowCodeSourceMarkerTransformer(fileName, compilerOptions, sourceRoot) {
+    function createWorkflowCodeSourceMarkerTransformer(fileName, compilerOptions, sourceRoot, trustedConditionSourceToken) {
       return (context) => (root) => {
         const sourceFile = root;
         const baseBindings = collectWorkflowCodeImportBindings(root, fileName, compilerOptions, sourceRoot, createWorkflowCodeImportBindingContext());
@@ -372812,6 +374376,8 @@ var require_evaluate_source = __commonJS({
               collectWorkflowCodeAliasBindings(node, node.statements, "agent", scopedBindings.promptNodeBindings, scopedBindings.promptNodeNamespaceBindings, scopedBindings.promptNodeNamespaceMemberBindings);
               collectWorkflowCodeAliasBindings(node, node.statements, "llm", scopedBindings.promptNodeBindings, scopedBindings.promptNodeNamespaceBindings, scopedBindings.promptNodeNamespaceMemberBindings);
               collectWorkflowCodeAliasBindings(node, node.statements, "map", scopedBindings.promptNodeBindings, scopedBindings.promptNodeNamespaceBindings, scopedBindings.promptNodeNamespaceMemberBindings);
+              collectWorkflowCodeAliasBindings(node, node.statements, "docTemplate", scopedBindings.promptNodeBindings, scopedBindings.promptNodeNamespaceBindings, scopedBindings.promptNodeNamespaceMemberBindings);
+              collectWorkflowCodeAliasBindings(node, node.statements, "condition", scopedBindings.promptNodeBindings, scopedBindings.promptNodeNamespaceBindings, scopedBindings.promptNodeNamespaceMemberBindings);
               return typescript_1.default.visitEachChild(node, createVisit(scopedBindings), context);
             }
             if (isForLikeStatement(node)) {
@@ -372820,9 +374386,8 @@ var require_evaluate_source = __commonJS({
             }
             if (typescript_1.default.isCallExpression(node) && isWorkflowBuildCallExpression(node.expression, bindings.buildBindings, bindings.buildNamespaceBindings, bindings.buildNamespaceMemberBindings)) {
               const [workflowArg, optionsArg, ...rest] = node.arguments;
-              if (workflowArg && optionsArg && typescript_1.default.isObjectLiteralExpression(optionsArg) && !hasWorkflowCodeSourceMarker(optionsArg)) {
-                const marker = typescript_1.default.factory.createPropertyAssignment("__workflowCodeSource", createWorkflowCodeSourceMarker(fileName, node, root));
-                const updatedOptions = typescript_1.default.factory.updateObjectLiteralExpression(optionsArg, [...optionsArg.properties, marker]);
+              if (workflowArg && optionsArg && typescript_1.default.isObjectLiteralExpression(optionsArg)) {
+                const updatedOptions = withTrustedWorkflowCodeSourceMarker(optionsArg, createWorkflowCodeSourceMarker(fileName, node, root));
                 const updatedNode = typescript_1.default.factory.updateCallExpression(node, node.expression, node.typeArguments, [workflowArg, updatedOptions, ...rest]);
                 return typescript_1.default.visitEachChild(updatedNode, visit, context);
               }
@@ -372834,12 +374399,8 @@ var require_evaluate_source = __commonJS({
             if (typescript_1.default.isCallExpression(node) && isWorkflowCodeCallExpression(node.expression, bindings.codeBindings, bindings.codeNamespaceBindings, bindings.codeNamespaceMemberBindings)) {
               const [firstArg, ...rest] = node.arguments;
               if (firstArg && typescript_1.default.isObjectLiteralExpression(firstArg)) {
-                if (!hasWorkflowCodeSourceMarker(firstArg)) {
-                  const marker = typescript_1.default.factory.createPropertyAssignment("__workflowCodeSource", createWorkflowCodeSourceMarker(fileName, node, root));
-                  const updatedArg = typescript_1.default.factory.updateObjectLiteralExpression(firstArg, [...firstArg.properties, marker]);
-                  return typescript_1.default.factory.updateCallExpression(node, node.expression, node.typeArguments, [updatedArg, ...rest]);
-                }
-                return node;
+                const updatedArg = withTrustedWorkflowCodeSourceMarker(firstArg, createWorkflowCodeSourceMarker(fileName, node, root));
+                return typescript_1.default.factory.updateCallExpression(node, node.expression, node.typeArguments, [updatedArg, ...rest]);
               }
               if (firstArg) {
                 const rejectedArg = typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier("__workflowCodeRejectNonInlineCodeOptions"), void 0, [firstArg, createWorkflowCodeSourceMarker(fileName, node, root)]);
@@ -372848,11 +374409,17 @@ var require_evaluate_source = __commonJS({
             }
             if (typescript_1.default.isCallExpression(node) && isWorkflowPromptNodeCallExpression(node.expression, bindings.promptNodeBindings, bindings.promptNodeNamespaceBindings, bindings.promptNodeNamespaceMemberBindings)) {
               const [firstArg, ...rest] = node.arguments;
-              if (firstArg && typescript_1.default.isObjectLiteralExpression(firstArg) && !hasWorkflowCodeSourceMarker(firstArg)) {
-                const marker = typescript_1.default.factory.createPropertyAssignment("__workflowCodeSource", createWorkflowCodeSourceMarker(fileName, node, sourceFile));
-                const updatedArg = typescript_1.default.factory.updateObjectLiteralExpression(firstArg, [...firstArg.properties, marker]);
+              if (firstArg && typescript_1.default.isObjectLiteralExpression(firstArg)) {
+                const updatedArg = withTrustedWorkflowCodeSourceMarker(firstArg, createWorkflowCodeSourceMarker(fileName, node, sourceFile), trustedConditionSourceToken);
                 return typescript_1.default.factory.updateCallExpression(node, node.expression, node.typeArguments, [updatedArg, ...rest]);
               }
+              if (firstArg) {
+                return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier("__workflowCodeCallPromptNodeWithTrustedSource"), void 0, [
+                  node.expression,
+                  typescript_1.default.factory.createArrayLiteralExpression(node.arguments),
+                  createWorkflowCodeSourceMarker(fileName, node, root)
+                ]);
+              }
             }
             return typescript_1.default.visitEachChild(node, visit, context);
           };
@@ -372948,8 +374515,18 @@ var require_evaluate_source = __commonJS({
       bindings.promptNodeNamespaceBindings.delete(name);
       bindings.promptNodeNamespaceMemberBindings.delete(name);
     }
-    function hasWorkflowCodeSourceMarker(objectLiteral) {
-      return objectLiteral.properties.some((property) => typescript_1.default.isPropertyAssignment(property) && typescript_1.default.isIdentifier(property.name) && property.name.text === "__workflowCodeSource");
+    function withTrustedWorkflowCodeSourceMarker(objectLiteral, markerValue, trustedConditionSourceToken) {
+      const marker = typescript_1.default.factory.createPropertyAssignment("__workflowCodeSource", markerValue);
+      return typescript_1.default.factory.updateObjectLiteralExpression(objectLiteral, [
+        ...objectLiteral.properties.filter((property) => !(typescript_1.default.isPropertyAssignment(property) && (getWorkflowCodePropertyName(property.name) === "__workflowCodeSource" || getWorkflowCodePropertyName(property.name) === "__workflowCodeTrustedConditionSourceToken"))),
+        marker,
+        ...trustedConditionSourceToken === void 0 ? [] : [typescript_1.default.factory.createPropertyAssignment("__workflowCodeTrustedConditionSourceToken", typescript_1.default.factory.createStringLiteral(trustedConditionSourceToken))]
+      ]);
+    }
+    function getWorkflowCodePropertyName(name) {
+      if (typescript_1.default.isIdentifier(name) || typescript_1.default.isStringLiteral(name) || typescript_1.default.isNumericLiteral(name))
+        return name.text;
+      return void 0;
     }
     function createWorkflowCodeSourceMarker(fileName, node, sourceFile) {
       return typescript_1.default.factory.createObjectLiteralExpression([
@@ -372980,7 +374557,7 @@ var require_evaluate_source = __commonJS({
       return Boolean(namespaceMemberBindings.get(root)?.has(members.join(".")));
     }
     function isPromptNodeMemberName(name) {
-      return name === "agent" || name === "llm" || name === "map";
+      return name === "agent" || name === "condition" || name === "docTemplate" || name === "llm" || name === "map";
     }
     function isWorkflowCodeMemberExpression(expression, memberName, memberBindings, namespaceBindings, namespaceMemberBindings) {
       const unwrapped = unwrapExpression(expression);
@@ -373500,7 +375077,7 @@ var require_evaluate_source = __commonJS({
       }
     }
     function addWorkflowCodePromptNodeMembersToExport(prefix, exportedNamespaces) {
-      for (const memberName of ["agent", "llm", "map"])
+      for (const memberName of ["agent", "condition", "llm", "map"])
         exportedNamespaces.add(`${prefix}.${memberName}`);
     }
     function addWorkflowCodeNamespaceMembersToExport(members, prefix, exportedNamespaces) {
@@ -373586,7 +375163,7 @@ var require_evaluate_source = __commonJS({
           exportedNames.codeNamespaces.add(statement.exportClause.name.text);
         for (const exportedName of targetExports.codeNamespaces)
           exportedNames.codeNamespaces.add(`${statement.exportClause.name.text}.${exportedName}`);
-        for (const memberName of ["agent", "llm", "map"]) {
+        for (const memberName of ["agent", "condition", "llm", "map"]) {
           if (targetExports.promptNodes.has(memberName))
             exportedNames.promptNodeNamespaces.add(`${statement.exportClause.name.text}.${memberName}`);
         }
@@ -373616,6 +375193,8 @@ var require_evaluate_source = __commonJS({
         exportedNames.build.add("build");
         exportedNames.code.add("code");
         exportedNames.promptNodes.add("agent");
+        exportedNames.promptNodes.add("docTemplate");
+        exportedNames.promptNodes.add("condition");
         exportedNames.promptNodes.add("llm");
         exportedNames.promptNodes.add("map");
         return;
@@ -373787,12 +375366,17 @@ const __workflowCodeApi = (() => {
         toString: () => registerRefUse(use, refs),
         [Symbol.toPrimitive]: () => registerRefUse(use, refs),
     })
+    const assertOutputRefTarget = (target, source) => {
+        if (target && target.kind === 'node' && (target.nodeKind === 'condition' || target.nodeKind === 'stop'))
+            throwAuthoringDiagnostic(target.nodeKind + '() does not produce a workflow output reference', source)
+    }
     const renderPrompt = (input, source) => {
         if (typeof input === 'string')
             return freeze({ prompt: input, refs: freeze([]) })
         const refs = []
         const prompt = input(freeze({
             ref(target, path) {
+                assertOutputRefTarget(target, source)
                 const targetKey = target.key ?? target.name
                 if (path && (path.__workflowCodePathTargetKind !== target.kind || path.__workflowCodePathTargetKey !== targetKey))
                     throwAuthoringDiagnostic('ref path source must match ref target', source)
@@ -373803,7 +375387,7 @@ const __workflowCodeApi = (() => {
                 }
                 return createRefValue(use, refs)
             },
-            paths(target) { return createPathProxy([], target.kind, target.key ?? target.name) },
+            paths(target) { assertOutputRefTarget(target, source); return createPathProxy([], target.kind, target.key ?? target.name) },
         }))
         if (typeof prompt !== 'string')
             throwAuthoringDiagnostic('prompt callback must return a string', source)
@@ -373811,6 +375395,7 @@ const __workflowCodeApi = (() => {
     }
     const exclusiveRefContext = (source) => freeze({
         ref(target, path) {
+            assertOutputRefTarget(target, source)
             const targetKey = target.key ?? target.name
             if (path && (path.__workflowCodePathTargetKind !== target.kind || path.__workflowCodePathTargetKey !== targetKey))
                 throwAuthoringDiagnostic('ref path source must match ref target', source)
@@ -373821,7 +375406,7 @@ const __workflowCodeApi = (() => {
                 ...(path ? { path: freeze([...path[pathKey]]) } : {}),
             })
         },
-        paths(target) { return createPathProxy([], target.kind, target.key ?? target.name) },
+        paths(target) { assertOutputRefTarget(target, source); return createPathProxy([], target.kind, target.key ?? target.name) },
     })
     const isVaultRef = (value) => value && typeof value === 'object' && !Array.isArray(value) && value.kind === 'vault-ref'
     const isVaultAsset = (value) => value && typeof value === 'object' && !Array.isArray(value) && value.kind === 'vault-asset'
@@ -373840,12 +375425,13 @@ const __workflowCodeApi = (() => {
         const refs = []
         const record = input(freeze({
             ref(target, path) {
+                assertOutputRefTarget(target, source)
                 const targetKey = target.key ?? target.name
                 if (path && (path.__workflowCodePathTargetKind !== target.kind || path.__workflowCodePathTargetKey !== targetKey))
                     throwAuthoringDiagnostic('ref path source must match ref target', source)
                 return createRefValue({ targetKind: target.kind, targetKey, ...(path ? { path: path[pathKey] } : {}) }, refs)
             },
-            paths(target) { return createPathProxy([], target.kind, target.key ?? target.name) },
+            paths(target) { assertOutputRefTarget(target, source); return createPathProxy([], target.kind, target.key ?? target.name) },
         }))
         if (!record || typeof record !== 'object' || Array.isArray(record))
             throwAuthoringDiagnostic('reference record callback must return an object', source)
@@ -373982,6 +375568,11 @@ const __workflowCodeApi = (() => {
     }
     const buildBindingKey = Symbol.for('@meistrari/workflow-code/build-binding')
     const codeBindingKey = Symbol.for('@meistrari/workflow-code/code-binding')
+    const conditionBindingKey = Symbol.for('@meistrari/workflow-code/condition-binding')
+    const trustConditionBinding = globalThis.__workflowCodeTrustConditionBinding
+    delete globalThis.__workflowCodeTrustConditionBinding
+    const trustedConditionSourceToken = globalThis.__workflowCodeTrustedConditionSourceToken
+    delete globalThis.__workflowCodeTrustedConditionSourceToken
     const buildWorkflow = (workflow, options) => {
         if (options.input !== undefined && options.inputs !== undefined)
             throwAuthoringDiagnostic('Use either input or inputs, not both.')
@@ -373998,6 +375589,7 @@ const __workflowCodeApi = (() => {
         if (typeof input !== 'function') {
             if (!input || typeof input !== 'object' || (input.kind !== 'input' && input.kind !== 'node'))
                 throwAuthoringDiagnostic(label + ' must return exactly one workflow reference', source)
+            assertOutputRefTarget(input, source)
             if (input.kind === 'input' && input.inputType !== 'file')
                 throwAuthoringDiagnostic(label + ' must reference a file input or node output', source)
             return freeze({ token: '__workflow_code_ref_0__', targetKind: input.kind, targetKey: input.key ?? input.name })
@@ -374005,6 +375597,7 @@ const __workflowCodeApi = (() => {
         const refs = []
         const rendered = String(input(freeze({
             ref(target, path) {
+                assertOutputRefTarget(target, source)
                 if (target.kind === 'input' && target.inputType !== 'file')
                     throwAuthoringDiagnostic(label + ' must reference a file input or node output', source)
                 const targetKey = target.key ?? target.name
@@ -374017,7 +375610,7 @@ const __workflowCodeApi = (() => {
                 }
                 return createRefValue(use, refs)
             },
-            paths(target) { return createPathProxy([], target.kind, target.key ?? target.name) },
+            paths(target) { assertOutputRefTarget(target, source); return createPathProxy([], target.kind, target.key ?? target.name) },
         })))
         const registered = refs[0]
         if (refs.length !== 1 || !registered || rendered !== registered.token)
@@ -374074,6 +375667,58 @@ const __workflowCodeApi = (() => {
         })
         return freeze(declaration)
     }
+    const conditionNode = (options) => {
+        if (!options || typeof options !== 'object')
+            throwAuthoringDiagnostic('condition.options must be an object')
+        if (!options.cases || typeof options.cases !== 'object' || Array.isArray(options.cases))
+            throwAuthoringDiagnostic('condition.cases must be an object', options.__workflowCodeSource)
+        const freezeNodes = (nodes, label) => {
+            if (!Array.isArray(nodes))
+                throwAuthoringDiagnostic(label + ' must be an array', options.__workflowCodeSource)
+            return freeze([...nodes])
+        }
+        const cases = Object.entries(options.cases).map(([name, branch]) => {
+            if (name.trim().length === 0)
+                throwAuthoringDiagnostic('condition.case name must be non-empty', options.__workflowCodeSource)
+            if (/^(?:0|[1-9]d*)$/u.test(name) && Number(name) < 2 ** 32 - 1)
+                throwAuthoringDiagnostic('condition.case name must not be an array-index string', options.__workflowCodeSource)
+            if (!branch || typeof branch !== 'object' || typeof branch.when !== 'function')
+                throwAuthoringDiagnostic('condition.cases.' + name + '.when must be a function', options.__workflowCodeSource)
+            return freeze({ name, nodes: freezeNodes(branch.nodes, 'condition.cases.' + name + '.nodes') })
+        })
+        const defaultBranch = options.default === undefined ? undefined : freeze({ nodes: freezeNodes(options.default.nodes, 'condition.default.nodes') })
+        const branchCount = cases.length + (defaultBranch ? 1 : 0)
+        if (branchCount < 2 || (cases.length === 1 && !defaultBranch))
+            throwAuthoringDiagnostic('condition requires at least two branches; one named case requires default', options.__workflowCodeSource)
+        const declaration = {
+            kind: 'node',
+            nodeKind: 'condition',
+            name: 'Condition',
+            input: freeze({
+                cases: freeze(cases),
+                ...(defaultBranch ? { default: defaultBranch } : {}),
+            }),
+        }
+        const binding = freeze({
+            handlers: freeze(Object.fromEntries(Object.entries(options.cases).map(([name, branch]) => [name, branch.when]))),
+            source: options.__workflowCodeSource,
+        })
+        Object.defineProperty(declaration, conditionBindingKey, {
+            enumerable: false,
+            configurable: false,
+            writable: false,
+            value: binding,
+        })
+        if (typeof trustConditionBinding === 'function' && options.__workflowCodeTrustedConditionSourceToken === trustedConditionSourceToken)
+            trustConditionBinding(declaration, binding)
+        return freeze(declaration)
+    }
+    const stopNode = () => freeze({
+        kind: 'node',
+        nodeKind: 'stop',
+        name: 'Stop',
+        input: null,
+    })
     const splitterNode = (options) => {
         if (!options || typeof options !== 'object' || !options.input || typeof options.input !== 'object')
             throwAuthoringDiagnostic('splitter.input must be an object', options && typeof options === 'object' ? options.__workflowCodeSource : undefined)
@@ -374113,17 +375758,48 @@ const __workflowCodeApi = (() => {
             }),
         })
     }
+    const docTemplateNode = (options) => {
+        if (!options || typeof options !== 'object' || !options.input || typeof options.input !== 'object')
+            throwAuthoringDiagnostic('docTemplate.input must be an object', options && typeof options === 'object' ? options.__workflowCodeSource : undefined)
+        assertNonEmptyString(options.name, 'docTemplate.name', options.__workflowCodeSource)
+        assertNonEmptyString(options.input.outputFilename, 'docTemplate.input.outputFilename', options.__workflowCodeSource)
+        const template = typeof options.input.template === 'function'
+            ? options.input.template(exclusiveRefContext(options.__workflowCodeSource))
+            : options.input.template
+        if (!isVaultRef(template) && !isVaultAsset(template) && !isWorkflowRef(template))
+            throwAuthoringDiagnostic('docTemplate.input.template must be vault.ref(), vault.asset(), or a workflow reference callback', options.__workflowCodeSource)
+        const placeholders = renderReferenceRecord(options.input.placeholders ?? {}, options.__workflowCodeSource)
+        return freeze({
+            kind: 'node',
+            nodeKind: 'doc-template',
+            name: options.name,
+            ...(options.key !== undefined ? { key: options.key } : {}),
+            input: freeze({
+                template,
+                placeholders: placeholders.values,
+                outputFilename: options.input.outputFilename,
+                ...(options.input.mustache === undefined ? {} : { mustache: options.input.mustache }),
+                ...(options.input.createPermalink === undefined ? {} : { createPermalink: options.input.createPermalink }),
+                ...(options.input.templateFilename === undefined ? {} : { templateFilename: options.input.templateFilename }),
+                ...(options.input.templateFileSize === undefined ? {} : { templateFileSize: options.input.templateFileSize }),
+            }),
+            ...(placeholders.refs.length === 0 ? {} : { placeholderRefs: placeholders.refs }),
+        })
+    }
     return freeze({
         agent: (ref, options) => publishedAgent(ref, options),
         build: buildWorkflow,
         canvas: canvasNode,
         code: codeNode,
         crop: cropNode,
+        docTemplate: docTemplateNode,
+        condition: conditionNode,
         input: freeze({ text: (options) => baseInput('text', options), file: (options) => baseInput('file', options) }),
         llm: (options) => promptNode('llm', options, llmInput),
         map: mapNode,
         splitter: splitterNode,
         template: templateNode,
+        stop: stopNode,
         vault: freeze({
             asset: (path, options = {}) => freeze({
                 kind: 'vault-asset',
@@ -374149,6 +375825,7 @@ const __workflowCodePackageFacade = (() => {
     const workflowCodeBindingKeys = new Set([
         Symbol.for('@meistrari/workflow-code/code-binding'),
         Symbol.for('@meistrari/workflow-code/build-binding'),
+        Symbol.for('@meistrari/workflow-code/condition-binding'),
         Symbol.for('@meistrari/workflow-code/remote-ref-binding'),
     ])
     const cache = new WeakMap()
@@ -374278,6 +375955,33 @@ const __workflowCodeRejectNonInlineBuildOptions = (_options, source) => {
         stack: new Error('Workflow Code build() calls must use an inline object literal options argument.').stack,
     }))
 }
+const __workflowCodeRejectNonInlineConditionOptions = (_options, source) => {
+    throw Object.freeze(Object.assign(Object.create(null), {
+        __workflowCodeSourceDiagnostic: true,
+        code: 'condition.source.non_inline_options',
+        message: 'Workflow Code condition() calls must use an inline object literal options argument.',
+        hint: 'Use condition({ ... }) or wf.condition({ ... }) directly so Workflow Code can attach trusted predicate source at ' + source.file,
+        stack: new Error('Workflow Code condition() calls must use an inline object literal options argument.').stack,
+    }))
+}
+const __workflowCodeWithoutUserSourceMarker = (value) => {
+    if (value === null || typeof value !== 'object' || !Object.prototype.hasOwnProperty.call(value, '__workflowCodeSource'))
+        return value
+    if (Array.isArray(value))
+        return value.map(__workflowCodeWithoutUserSourceMarker)
+    const clone = {}
+    for (const key of Object.keys(value)) {
+        if (key !== '__workflowCodeSource')
+            clone[key] = value[key]
+    }
+    return clone
+}
+const __workflowCodeCallPromptNodeWithTrustedSource = (callee, args, source) => {
+    const sanitizedArgs = Array.isArray(args) ? args.map(__workflowCodeWithoutUserSourceMarker) : []
+    if (callee === __workflowCodeApi.condition)
+        return __workflowCodeRejectNonInlineConditionOptions(sanitizedArgs[0], source)
+    return callee(...sanitizedArgs)
+}
 const require = ((hostRequire) => {
     delete globalThis.__workflowCodeRequire
     return (specifier) => {
@@ -376253,8 +377957,8 @@ var require_vault_preflight = __commonJS({
       }
       const results = await Promise.all(references.map(async (reference) => {
         try {
-          await input.vaultApi?.validateVaultRef({ reference });
-          return [];
+          const metadata = await input.vaultApi?.validateVaultRef({ reference });
+          return validateRequirements(reference, metadata, input.compiled);
         } catch (error48) {
           if (hasDiagnostics(error48))
             return error48.diagnostics;
@@ -376264,6 +377968,27 @@ var require_vault_preflight = __commonJS({
       const diagnostics = results.flat();
       return diagnostics.length > 0 ? { ok: false, diagnostics } : { ok: true, value: createValidation(references) };
     }
+    function validateRequirements(reference, metadata, compiled) {
+      if (!metadata)
+        return [];
+      const requirements = compiled.flatMap((item) => item.resources.vaultRequirements ?? []).filter((requirement) => requirement.reference === reference);
+      const diagnostics = [];
+      for (const requirement of requirements) {
+        if (requirement.expectedName !== void 0 && metadata.name !== void 0 && requirement.expectedName !== metadata.name) {
+          diagnostics.push((0, diagnostics_1.diagnostic)("vault.template.metadata_mismatch", "error", `Vault template ${reference} is named ${metadata.name}, not the declared ${requirement.expectedName}.`, "Update templateFilename or select the matching Vault file before syncing."));
+        }
+        if (requirement.expectedSize !== void 0 && metadata.size !== void 0 && requirement.expectedSize !== metadata.size) {
+          diagnostics.push((0, diagnostics_1.diagnostic)("vault.template.metadata_mismatch", "error", `Vault template ${reference} has size ${metadata.size}, not the declared ${requirement.expectedSize}.`, "Update templateFileSize or select the matching Vault file before syncing."));
+        }
+        if (requirement.requiredExtension !== void 0 && metadata.name !== void 0 && !metadata.name.toLowerCase().endsWith(requirement.requiredExtension)) {
+          diagnostics.push((0, diagnostics_1.diagnostic)("vault.template.invalid_file", "error", `Vault template ${reference} is named ${metadata.name}; docTemplate() requires a ${requirement.requiredExtension} file.`, "Upload a .docx template or correct the Vault reference before syncing."));
+        }
+        if (requirement.requiredMimeType !== void 0 && metadata.mimeType !== void 0 && metadata.mimeType !== requirement.requiredMimeType) {
+          diagnostics.push((0, diagnostics_1.diagnostic)("vault.template.invalid_file", "error", `Vault template ${reference} has MIME type ${metadata.mimeType}; docTemplate() requires ${requirement.requiredMimeType}.`, "Upload a .docx template or correct the Vault reference before syncing."));
+        }
+      }
+      return diagnostics;
+    }
     function collectVaultRefs(compiled) {
       return [...new Set(compiled.flatMap((item) => item.resources?.vaultRefs ?? []))].sort((left, right) => left.localeCompare(right));
     }
@@ -376574,12 +378299,21 @@ var require_remote_api2 = __commonJS({
             throw workflowApiError("vault.ref.inaccessible", "The active Tela environment does not configure a Vault service URL.", "Add services.vault to the active Tela environment and retry.");
           }
           try {
-            await vaultRequest(`/files/${encodeURIComponent((0, reference_1.vaultReferenceId)(input.reference))}`, {
+            const result = await vaultRequest(`/files/${encodeURIComponent((0, reference_1.vaultReferenceId)(input.reference))}`, {
               failureCode: "vault.ref.inaccessible",
               invalidResponseCode: "vault.ref.inaccessible",
               failureMessage: (status2) => `Vault reference ${input.reference} is not accessible in the active Tela context (HTTP ${status2}).`,
               failureHint: "Check the selected workspace, context credentials, and file permissions."
             });
+            const metadata = isRecord3(result.metadata) ? result.metadata : {};
+            const name = typeof metadata.originalFileName === "string" ? metadata.originalFileName : typeof metadata.name === "string" ? metadata.name : void 0;
+            const size = typeof metadata.size === "number" ? metadata.size : typeof result.size === "number" ? result.size : void 0;
+            const mimeType = typeof metadata.mimeType === "string" ? metadata.mimeType : void 0;
+            return {
+              ...name === void 0 ? {} : { name },
+              ...size === void 0 ? {} : { size },
+              ...mimeType === void 0 ? {} : { mimeType }
+            };
           } catch (error48) {
             if (hasDiagnostics(error48))
               throw error48;
@@ -376947,18 +378681,30 @@ var require_vault_assets = __commonJS({
   "../../packages/workflow-code/dist/cli/sync/vault-assets.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.snapshotPreparedWorkflowVaultAssets = snapshotPreparedWorkflowVaultAssets;
+    exports2.prepareWorkflowVaultAssetUploads = prepareWorkflowVaultAssetUploads;
+    exports2.uploadPreparedWorkflowVaultAssets = uploadPreparedWorkflowVaultAssets;
     exports2.prepareWorkflowVaultAssets = prepareWorkflowVaultAssets;
     var node_crypto_1 = require("node:crypto");
     var node_fs_1 = require("node:fs");
     var promises_1 = require("node:fs/promises");
     var node_path_1 = require("node:path");
     var diagnostics_1 = require_diagnostics();
-    async function prepareWorkflowVaultAssets(input) {
+    function snapshotPreparedWorkflowVaultAssets(assets) {
+      return assets.map((asset) => asset.previous ?? Object.freeze({
+        ...asset.asset,
+        name: asset.name,
+        resolvedPath: asset.resolvedPath,
+        contentHash: asset.contentHash,
+        size: asset.content.byteLength,
+        // The compiler only needs lock-derived local metadata at this stage.
+        ref: `vault://${asset.contentHash}`,
+        uploadedAt: ""
+      }));
+    }
+    async function prepareWorkflowVaultAssetUploads(input) {
       if (input.assets.length === 0)
         return { ok: true, value: [] };
-      if (!input.vaultApi) {
-        return { ok: false, diagnostics: [(0, diagnostics_1.diagnostic)("vault.asset.upload_failed", "error", "Vault assets cannot be uploaded because the active remote client has no Vault service.", "Configure services.vault for the active Tela environment and retry before syncing.")] };
-      }
       const existingByKey = new Map((input.existing ?? []).map((asset) => [asset.key, asset]));
       const prepared = [];
       let projectRoot;
@@ -376998,33 +378744,70 @@ var require_vault_assets = __commonJS({
         }
         const contentHash = (0, node_crypto_1.createHash)("sha256").update(content).digest("hex");
         const previous = existingByKey.get(asset.key);
-        if (previous?.contentHash === contentHash) {
-          prepared.push(previous);
+        const name = asset.name ?? (0, node_path_1.basename)(resolvedPath);
+        prepared.push(Object.freeze({
+          asset,
+          name,
+          resolvedPath,
+          content,
+          contentHash,
+          ...previous?.contentHash === contentHash ? { previous } : {}
+        }));
+      }
+      return { ok: true, value: prepared };
+    }
+    async function uploadPreparedWorkflowVaultAssets(input) {
+      if (input.assets.length === 0)
+        return { ok: true, value: [] };
+      if (!input.vaultApi) {
+        return { ok: false, diagnostics: [(0, diagnostics_1.diagnostic)("vault.asset.upload_failed", "error", "Vault assets cannot be uploaded because the active remote client has no Vault service.", "Configure services.vault for the active Tela environment and retry before syncing.")] };
+      }
+      const uploaded = [];
+      for (const asset of input.assets) {
+        if (asset.previous) {
+          uploaded.push(asset.previous);
           continue;
         }
-        const name = asset.name ?? (0, node_path_1.basename)(resolvedPath);
         try {
           const ref = await input.vaultApi.uploadVaultAsset({
-            name,
-            ...asset.mimeType === void 0 ? {} : { mimeType: asset.mimeType },
-            content
+            name: asset.name,
+            ...asset.asset.mimeType === void 0 ? {} : { mimeType: asset.asset.mimeType },
+            content: asset.content
           });
-          prepared.push(Object.freeze({
-            ...asset,
-            name,
-            resolvedPath,
-            contentHash,
-            size: content.byteLength,
+          uploaded.push(Object.freeze({
+            ...asset.asset,
+            name: asset.name,
+            resolvedPath: asset.resolvedPath,
+            contentHash: asset.contentHash,
+            size: asset.content.byteLength,
             ref,
             uploadedAt: input.now?.() ?? (/* @__PURE__ */ new Date()).toISOString()
           }));
+          const persisted = await input.onUploaded?.(snapshotKnownWorkflowVaultAssets(input.assets, uploaded));
+          if (persisted !== void 0 && !persisted.ok)
+            return persisted;
         } catch (error48) {
           if (hasDiagnostics(error48))
             return { ok: false, diagnostics: error48.diagnostics };
-          return { ok: false, diagnostics: [(0, diagnostics_1.diagnostic)("vault.asset.upload_failed", "error", `Vault asset ${asset.path} could not be uploaded.`, "Check the active Vault service and retry sync.")] };
+          return { ok: false, diagnostics: [(0, diagnostics_1.diagnostic)("vault.asset.upload_failed", "error", `Vault asset ${asset.asset.path} could not be uploaded.`, "Check the active Vault service and retry sync.")] };
         }
       }
-      return { ok: true, value: prepared };
+      return { ok: true, value: uploaded };
+    }
+    function snapshotKnownWorkflowVaultAssets(plans, uploaded) {
+      return plans.flatMap((plan, index) => {
+        const snapshot = uploaded[index] ?? plan.previous;
+        return snapshot === void 0 ? [] : [snapshot];
+      });
+    }
+    async function prepareWorkflowVaultAssets(input) {
+      if (input.assets.length > 0 && !input.vaultApi) {
+        return { ok: false, diagnostics: [(0, diagnostics_1.diagnostic)("vault.asset.upload_failed", "error", "Vault assets cannot be uploaded because the active remote client has no Vault service.", "Configure services.vault for the active Tela environment and retry before syncing.")] };
+      }
+      const prepared = await prepareWorkflowVaultAssetUploads(input);
+      if (!prepared.ok)
+        return prepared;
+      return await uploadPreparedWorkflowVaultAssets({ assets: prepared.value, vaultApi: input.vaultApi, now: input.now });
     }
     function isWithinRoot(path3, rootDir) {
       const relativePath = (0, node_path_1.relative)((0, node_path_1.resolve)(rootDir), path3);
@@ -377036,6 +378819,79 @@ var require_vault_assets = __commonJS({
   }
 });
 
+// ../../packages/workflow-code/dist/cli/sync/vault-locks.js
+var require_vault_locks = __commonJS({
+  "../../packages/workflow-code/dist/cli/sync/vault-locks.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createWorkflowVaultAssetLockPersister = createWorkflowVaultAssetLockPersister;
+    var diagnostics_1 = require_diagnostics();
+    var state_1 = require_state2();
+    async function createWorkflowVaultAssetLockPersister(input) {
+      const lockfilePath = (0, state_1.deriveLockfilePath)(input.cwd, input.facts);
+      if (!lockfilePath.ok)
+        return { ok: false, diagnostics: lockfilePath.diagnostics };
+      const remote = await fetchPromptSnapshot(input.remoteApi, input.facts);
+      if (!remote.ok)
+        return { ok: false, diagnostics: remote.diagnostics };
+      let current = input.existing;
+      return {
+        ok: true,
+        value: {
+          persist: async (vaultAssets) => {
+            const plan = (0, state_1.planRemoteSnapshotWrite)(lockfilePath.value, input.facts, remote.value, current, void 0, vaultAssets);
+            if (!plan.ok)
+              return { ok: false, diagnostics: plan.diagnostics };
+            const written = await (0, state_1.writePlannedLockfile)(plan.value);
+            if (!written.ok)
+              return { ok: false, diagnostics: written.diagnostics };
+            current = {
+              path: lockfilePath.value,
+              hash: written.value.hash,
+              content: plan.value.content,
+              lockfile: plan.value.lockfile
+            };
+            return { ok: true, value: current };
+          }
+        }
+      };
+    }
+    async function fetchPromptSnapshot(remoteApi, facts) {
+      const promptId = facts.context.promptId;
+      if (promptId === void 0) {
+        return {
+          ok: false,
+          diagnostics: [(0, diagnostics_1.diagnostic)("state.prompt_id.missing", "error", `Workflow target ${facts.targetName} has no prompt id for context ${facts.context.key}`, "Add promptId to the active workflow context binding before retrying the upload.")]
+        };
+      }
+      try {
+        const snapshot = await remoteApi.fetchPromptSnapshot({
+          promptId,
+          projectId: facts.context.projectId
+        });
+        if (snapshot.prompt.id !== promptId) {
+          return {
+            ok: false,
+            diagnostics: [(0, diagnostics_1.diagnostic)("sync.remote.prompt_mismatch", "error", `Remote prompt ${snapshot.prompt.id} does not match configured prompt ${promptId}`, "Check the workflow target promptId binding.")]
+          };
+        }
+        return { ok: true, value: snapshot };
+      } catch (error48) {
+        return {
+          ok: false,
+          diagnostics: diagnosticsFromError(error48)
+        };
+      }
+    }
+    function diagnosticsFromError(error48) {
+      if (error48 && typeof error48 === "object" && "diagnostics" in error48 && Array.isArray(error48.diagnostics))
+        return error48.diagnostics;
+      const detail = error48 instanceof Error ? ` ${error48.message}` : "";
+      return [(0, diagnostics_1.diagnostic)("sync.remote.request_failed", "error", `Unable to fetch the workflow state before persisting uploaded Vault assets.${detail}`, "Check the active Tela context and retry sync.")];
+    }
+  }
+});
+
 // ../../packages/workflow-code/dist/cli/sync/index.js
 var require_sync2 = __commonJS({
   "../../packages/workflow-code/dist/cli/sync/index.js"(exports2) {
@@ -377062,6 +378918,7 @@ var require_sync2 = __commonJS({
     __exportStar(require_remote_api2(), exports2);
     __exportStar(require_types5(), exports2);
     __exportStar(require_vault_assets(), exports2);
+    __exportStar(require_vault_locks(), exports2);
     __exportStar(require_vault_preflight(), exports2);
   }
 });
@@ -377503,7 +379360,7 @@ var require_publish2 = __commonJS({
         tsconfig: configResult.value.config.tsconfig,
         targets: resolved.targets,
         rootDir: context.cwd,
-        vaultApi: remoteApi
+        remoteApi
       });
       if (!prepared.ok)
         return { exitCode: 1, diagnostics: [...environmentCreationDiagnostics, ...prepared.diagnostics], compiled: prepared.compiled };
@@ -377596,7 +379453,7 @@ var require_publish2 = __commonJS({
       return { ok: true, targets: Object.entries(workflows).map(([name, target]) => ({ name, target })) };
     }
     async function preparePublishTargets(options2) {
-      const prepared = [];
+      const staged = [];
       for (const selected of options2.targets) {
         const source = await (0, load_source_1.loadWorkflowSource)((0, node_path_1.dirname)(options2.configPath), selected.target, options2.configEnv, options2.tsconfig);
         if (!source.ok)
@@ -377640,26 +379497,75 @@ var require_publish2 = __commonJS({
           if (!lockfileIdentity.ok)
             return { ok: false, diagnostics: lockfileIdentity.diagnostics, compiled: initial };
         }
-        const vaultAssets = await (0, sync_1.prepareWorkflowVaultAssets)({
+        const vaultPlans = await (0, sync_1.prepareWorkflowVaultAssetUploads)({
           rootDir: (0, node_path_1.dirname)(options2.configPath),
           assets: initial.resources.vaultAssets ?? [],
-          existing: existing.ok ? existing.value.lockfile.vaultAssets : void 0,
-          vaultApi: options2.vaultApi
+          existing: existing.ok ? existing.value.lockfile.vaultAssets : void 0
         });
-        if (!vaultAssets.ok)
-          return { ok: false, diagnostics: vaultAssets.diagnostics, compiled: initial };
-        const compiled = (0, compiler_1.transpileWorkflow)({
+        if (!vaultPlans.ok)
+          return { ok: false, diagnostics: vaultPlans.diagnostics, compiled: initial };
+        const preflight = (0, compiler_1.transpileWorkflow)({
           targetName: selected.name,
           workflowKey: selected.target.workflowKey,
           title: selected.target.title,
           declaration: source.value.declaration,
           source: source.value.source,
+          vaultAssets: (0, sync_1.snapshotPreparedWorkflowVaultAssets)(vaultPlans.value)
+        });
+        if (preflight.diagnostics.some((item) => item.severity === "error"))
+          return { ok: false, diagnostics: [...preflight.diagnostics], compiled: preflight };
+        staged.push({
+          ...selected,
+          source: source.value,
+          preflight,
+          vaultPlans: vaultPlans.value,
+          ...existing.ok ? { lockfileState: existing.value } : {}
+        });
+      }
+      const prepared = [];
+      for (const stagedTarget of staged) {
+        let onUploaded;
+        if (stagedTarget.vaultPlans.some((asset) => asset.previous === void 0)) {
+          const persister = await (0, sync_1.createWorkflowVaultAssetLockPersister)({
+            cwd: options2.rootDir,
+            facts: {
+              targetName: stagedTarget.name,
+              workflowKey: stagedTarget.preflight.workflowKey,
+              context: {
+                key: stagedTarget.identity.contextKey ?? "default",
+                ...stagedTarget.identity.contextId === void 0 ? {} : { id: stagedTarget.identity.contextId },
+                projectId: stagedTarget.identity.projectId,
+                promptId: stagedTarget.identity.promptId
+              }
+            },
+            existing: stagedTarget.lockfileState,
+            remoteApi: options2.remoteApi
+          });
+          if (!persister.ok)
+            return { ok: false, diagnostics: persister.diagnostics, compiled: stagedTarget.preflight };
+          onUploaded = persister.value.persist;
+        }
+        const vaultAssets = await (0, sync_1.uploadPreparedWorkflowVaultAssets)({
+          assets: stagedTarget.vaultPlans,
+          vaultApi: options2.remoteApi,
+          ...onUploaded === void 0 ? {} : { onUploaded }
+        });
+        if (!vaultAssets.ok)
+          return { ok: false, diagnostics: vaultAssets.diagnostics, compiled: stagedTarget.preflight };
+        const compiled = (0, compiler_1.transpileWorkflow)({
+          targetName: stagedTarget.name,
+          workflowKey: stagedTarget.target.workflowKey,
+          title: stagedTarget.target.title,
+          declaration: stagedTarget.source.declaration,
+          source: stagedTarget.source.source,
           vaultAssets: vaultAssets.value
         });
         if (compiled.diagnostics.some((item) => item.severity === "error"))
           return { ok: false, diagnostics: [...compiled.diagnostics], compiled };
         prepared.push({
-          ...selected,
+          name: stagedTarget.name,
+          target: stagedTarget.target,
+          identity: stagedTarget.identity,
           compiled,
           vaultAssets: vaultAssets.value
         });
@@ -377871,30 +379777,14 @@ var require_sync3 = __commonJS({
         const existing = await (0, state_1.readLockfile)(lockPath.value);
         if (!existing.ok && existing.diagnostics[0]?.code !== "state.lockfile.missing")
           return { ok: false, diagnostics: existing.diagnostics, compiled: initialSymbolic };
-        const vaultAssets = await (0, sync_1.prepareWorkflowVaultAssets)({
-          rootDir: options2.projectDir,
-          assets: initialSymbolic.resources.vaultAssets ?? [],
-          existing: existing.ok ? existing.value.lockfile.vaultAssets : void 0,
-          vaultApi: options2.vaultApi
-        });
-        if (!vaultAssets.ok)
-          return { ok: false, diagnostics: vaultAssets.diagnostics, compiled: initialSymbolic };
-        const symbolic = (0, compiler_1.transpileWorkflow)({
-          targetName: selected.name,
-          workflowKey: selected.target.workflowKey,
-          title: selected.target.title,
-          declaration: sourceResult.value.declaration,
-          source: sourceResult.value.source,
-          vaultAssets: vaultAssets.value
-        });
-        if (symbolic.diagnostics.some((item) => item.severity === "error"))
-          return { ok: false, diagnostics: [...symbolic.diagnostics], compiled: symbolic };
         symbolicPrepared.push({
           ...selected,
           source: sourceResult.value,
-          symbolic,
-          compiled: symbolic,
-          vaultAssets: vaultAssets.value,
+          symbolic: initialSymbolic,
+          compiled: initialSymbolic,
+          vaultAssets: [],
+          ...existing.ok ? { lockfile: existing.value.lockfile } : {},
+          ...existing.ok ? { lockfileState: existing.value } : {},
           identity: {
             contextKey: identity2.value.contextKey,
             contextId: identity2.value.contextId,
@@ -377905,7 +379795,7 @@ var require_sync3 = __commonJS({
       }
       const needsCatalog = options2.catalogApi !== void 0 || symbolicPrepared.some((item) => item.symbolic.remoteRefs.length > 0);
       if (!needsCatalog)
-        return { ok: true, targets: symbolicPrepared };
+        return await prepareVaultAssetsForTargets({ ...options2, remoteApi: options2.vaultApi }, symbolicPrepared);
       let api;
       try {
         api = options2.catalogApi ?? await (0, catalog_1.createWorkflowCatalogApi)();
@@ -377928,19 +379818,12 @@ var require_sync3 = __commonJS({
       }
       const prepared = [];
       for (const item of symbolicPrepared) {
-        const facts = factsForPrepared(item);
-        const lockPath = (0, state_1.deriveLockfilePath)(options2.rootDir, facts);
-        if (!lockPath.ok)
-          return { ok: false, diagnostics: lockPath.diagnostics, compiled: item.symbolic };
-        const existing = await (0, state_1.readLockfile)(lockPath.value);
-        if (!existing.ok && existing.diagnostics[0]?.code !== "state.lockfile.missing")
-          return { ok: false, diagnostics: existing.diagnostics, compiled: item.symbolic };
         const initialGenerated = (0, catalog_1.validateAndLockRemoteRefs)({
           contextId: snapshot.context.id,
           workspaceId: snapshot.context.workspaceId,
           snapshot,
           refs: item.symbolic.remoteRefs,
-          existing: existing.ok ? existing.value.lockfile.generatedMetadata : void 0
+          existing: item.lockfile?.generatedMetadata
         });
         if (initialGenerated.diagnostics.some((diagnostic) => diagnostic.severity === "error"))
           return { ok: false, diagnostics: [...initialGenerated.diagnostics], compiled: item.symbolic };
@@ -377958,26 +379841,87 @@ var require_sync3 = __commonJS({
           workspaceId: snapshot.context.workspaceId,
           snapshot,
           refs: compiled.remoteRefs,
-          existing: existing.ok ? existing.value.lockfile.generatedMetadata : void 0
+          existing: item.lockfile?.generatedMetadata
         });
         const diagnostics = [...generated.diagnostics, ...compiled.diagnostics];
-        if (diagnostics.some((diagnostic) => diagnostic.severity === "error"))
+        if (diagnostics.some((diagnostic) => diagnostic.severity === "error" && diagnostic.code !== "vault.asset.missing_lock"))
           return { ok: false, diagnostics, compiled };
-        prepared.push({ ...item, generatedMetadata: generated.locks, compiled });
+        prepared.push({
+          ...item,
+          generatedMetadata: generated.locks,
+          remote: { kind: "resolved", snapshot, locks: generated.locks.refs },
+          compiled
+        });
       }
-      return { ok: true, targets: prepared };
+      return await prepareVaultAssetsForTargets({ ...options2, remoteApi: options2.vaultApi }, prepared);
     }
-    function factsForPrepared(prepared) {
-      return {
-        targetName: prepared.name,
-        workflowKey: prepared.symbolic.workflowKey,
-        context: {
-          key: prepared.identity.contextKey ?? "default",
-          ...prepared.identity.contextId === void 0 ? {} : { id: prepared.identity.contextId },
-          projectId: prepared.identity.projectId,
-          promptId: prepared.identity.promptId
+    async function prepareVaultAssetsForTargets(options2, targets) {
+      const staged = [];
+      for (const target of targets) {
+        const vaultAssets = await (0, sync_1.prepareWorkflowVaultAssetUploads)({
+          rootDir: options2.projectDir,
+          assets: target.symbolic.resources.vaultAssets ?? [],
+          existing: target.lockfile?.vaultAssets
+        });
+        if (!vaultAssets.ok)
+          return { ok: false, diagnostics: vaultAssets.diagnostics, compiled: target.compiled };
+        const preflight = (0, compiler_1.transpileWorkflow)({
+          targetName: target.name,
+          workflowKey: target.target.workflowKey,
+          title: target.target.title,
+          declaration: target.source.declaration,
+          source: target.source.source,
+          ...target.remote === void 0 ? {} : { remote: target.remote },
+          vaultAssets: (0, sync_1.snapshotPreparedWorkflowVaultAssets)(vaultAssets.value)
+        });
+        if (preflight.diagnostics.some((item) => item.severity === "error"))
+          return { ok: false, diagnostics: [...preflight.diagnostics], compiled: preflight };
+        staged.push({ target, vaultAssets: vaultAssets.value });
+      }
+      const prepared = [];
+      for (const item of staged) {
+        let onUploaded;
+        if (item.vaultAssets.some((asset) => asset.previous === void 0)) {
+          const persister = await (0, sync_1.createWorkflowVaultAssetLockPersister)({
+            cwd: options2.rootDir,
+            facts: {
+              targetName: item.target.name,
+              workflowKey: item.target.symbolic.workflowKey,
+              context: {
+                key: item.target.identity.contextKey ?? "default",
+                ...item.target.identity.contextId === void 0 ? {} : { id: item.target.identity.contextId },
+                projectId: item.target.identity.projectId,
+                promptId: item.target.identity.promptId
+              }
+            },
+            existing: item.target.lockfileState,
+            remoteApi: options2.remoteApi
+          });
+          if (!persister.ok)
+            return { ok: false, diagnostics: persister.diagnostics, compiled: item.target.compiled };
+          onUploaded = persister.value.persist;
         }
-      };
+        const vaultAssets = await (0, sync_1.uploadPreparedWorkflowVaultAssets)({
+          assets: item.vaultAssets,
+          vaultApi: options2.vaultApi,
+          ...onUploaded === void 0 ? {} : { onUploaded }
+        });
+        if (!vaultAssets.ok)
+          return { ok: false, diagnostics: vaultAssets.diagnostics, compiled: item.target.compiled };
+        const compiled = (0, compiler_1.transpileWorkflow)({
+          targetName: item.target.name,
+          workflowKey: item.target.target.workflowKey,
+          title: item.target.target.title,
+          declaration: item.target.source.declaration,
+          source: item.target.source.source,
+          ...item.target.remote === void 0 ? {} : { remote: item.target.remote },
+          vaultAssets: vaultAssets.value
+        });
+        if (compiled.diagnostics.some((item2) => item2.severity === "error"))
+          return { ok: false, diagnostics: [...compiled.diagnostics], compiled };
+        prepared.push({ ...item.target, compiled, vaultAssets: vaultAssets.value });
+      }
+      return { ok: true, targets: prepared };
     }
     function renderSingleSyncResult(item) {
       return {