@meistrari/tela-cli 1.4.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) {
@@ -369187,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) {
@@ -369200,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;
@@ -369270,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",
@@ -369283,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) {
@@ -369292,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());
@@ -369301,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) {
@@ -369367,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 };
@@ -369380,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,
@@ -369393,6 +369681,656 @@ var require_extract3 = __commonJS({
       });
       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)
@@ -369524,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);
@@ -369533,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;
@@ -369588,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;
@@ -370114,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();
@@ -370402,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();
     }
@@ -370534,155 +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;
-    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 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) {
@@ -370692,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();
@@ -370769,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]));
@@ -370945,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,
@@ -370973,6 +372023,8 @@ 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,
@@ -371497,9 +372549,7 @@ var require_modules = __commonJS({
     }
     function resolveVisibleNodeOutput(targetKey, context) {
       const identity2 = (0, refs_1.resolveVisibleNodeIdentity)(targetKey, {
-        inputIdsByKey: context.inputIdsByKey,
         nodeIdentitiesByKey: context.nodeIdentitiesByKey,
-        nodesByPath: context.nodesByPath,
         currentNode: context.currentNode
       });
       if (!identity2)
@@ -371730,6 +372780,8 @@ 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],
@@ -371747,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 [];
@@ -371787,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(() => ({
@@ -371794,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) {
@@ -371875,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;
@@ -371923,6 +373084,10 @@ 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")
@@ -371952,6 +373117,47 @@ var require_transpile = __commonJS({
         }
       };
     }
+    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);
@@ -372103,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,
@@ -372116,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({
@@ -372140,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();
@@ -372160,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();
@@ -372167,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);
@@ -372207,9 +373461,10 @@ 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);
@@ -372217,7 +373472,7 @@ var require_transpile = __commonJS({
       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 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];
@@ -372229,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;
@@ -372246,11 +373504,13 @@ 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,
@@ -372880,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))) {
@@ -372930,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;
@@ -372987,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 }
@@ -373071,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: {
@@ -373084,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());
@@ -373110,6 +374377,7 @@ var require_evaluate_source = __commonJS({
               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)) {
@@ -373118,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);
               }
@@ -373132,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)]);
@@ -373146,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);
           };
@@ -373246,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([
@@ -373278,7 +374557,7 @@ var require_evaluate_source = __commonJS({
       return Boolean(namespaceMemberBindings.get(root)?.has(members.join(".")));
     }
     function isPromptNodeMemberName(name) {
-      return name === "agent" || name === "docTemplate" || 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);
@@ -373798,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) {
@@ -373884,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}`);
         }
@@ -373915,6 +375194,7 @@ var require_evaluate_source = __commonJS({
         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;
@@ -374086,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)
@@ -374102,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)
@@ -374110,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)
@@ -374120,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'
@@ -374139,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)
@@ -374281,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.')
@@ -374297,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 })
@@ -374304,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
@@ -374316,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)
@@ -374373,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)
@@ -374447,11 +375793,13 @@ const __workflowCodeApi = (() => {
         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',
@@ -374477,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()
@@ -374606,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) => {