@mmmnt/cli 0.8.0 → 0.10.0

package/dist/moment.mjs

@@ -55439,6 +55439,9 @@ var PolicyDeclaration = {
   $type: "PolicyDeclaration",
   action: "action",
   chainsTo: "chainsTo",
+  conditionAfter: "conditionAfter",
+  conditionField: "conditionField",
+  conditionValue: "conditionValue",
   gateways: "gateways",
   name: "name",
   trigger: "trigger"
@@ -56130,6 +56133,18 @@ var MomentAstReflection = class extends AbstractAstReflection {
         chainsTo: {
           name: PolicyDeclaration.chainsTo
         },
+        conditionAfter: {
+          name: PolicyDeclaration.conditionAfter,
+          optional: true
+        },
+        conditionField: {
+          name: PolicyDeclaration.conditionField,
+          optional: true
+        },
+        conditionValue: {
+          name: PolicyDeclaration.conditionValue,
+          optional: true
+        },
         gateways: {
           name: PolicyDeclaration.gateways,
           defaultValue: [],
@@ -58059,6 +58074,66 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
               "arguments": []
             }
           },
+          {
+            "$type": "Group",
+            "elements": [
+              {
+                "$type": "Keyword",
+                "value": "when"
+              },
+              {
+                "$type": "Assignment",
+                "feature": "conditionField",
+                "operator": "=",
+                "terminal": {
+                  "$type": "RuleCall",
+                  "rule": {
+                    "$ref": "#/rules@50"
+                  },
+                  "arguments": []
+                }
+              },
+              {
+                "$type": "Keyword",
+                "value": "="
+              },
+              {
+                "$type": "Assignment",
+                "feature": "conditionValue",
+                "operator": "=",
+                "terminal": {
+                  "$type": "RuleCall",
+                  "rule": {
+                    "$ref": "#/rules@10"
+                  },
+                  "arguments": []
+                }
+              }
+            ],
+            "cardinality": "?"
+          },
+          {
+            "$type": "Group",
+            "elements": [
+              {
+                "$type": "Keyword",
+                "value": "after"
+              },
+              {
+                "$type": "Assignment",
+                "feature": "conditionAfter",
+                "operator": "=",
+                "terminal": {
+                  "$type": "RuleCall",
+                  "rule": {
+                    "$ref": "#/rules@56"
+                  },
+                  "arguments": []
+                }
+              }
+            ],
+            "cardinality": "?"
+          },
           {
             "$type": "Keyword",
             "value": "action"
@@ -59218,6 +59293,14 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
           {
             "$type": "Keyword",
             "value": "note"
+          },
+          {
+            "$type": "Keyword",
+            "value": "outcome"
+          },
+          {
+            "$type": "Keyword",
+            "value": "after"
           }
         ]
       },
@@ -59324,6 +59407,10 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
           {
             "$type": "Keyword",
             "value": "terminal"
+          },
+          {
+            "$type": "Keyword",
+            "value": "outcome"
           }
         ]
       },
@@ -59765,6 +59852,14 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
           {
             "$type": "Keyword",
             "value": "note"
+          },
+          {
+            "$type": "Keyword",
+            "value": "outcome"
+          },
+          {
+            "$type": "Keyword",
+            "value": "after"
           }
         ]
       },
@@ -60291,7 +60386,7 @@ var MomentValidator = class {
   // those are alternative branch arms, not continuations.
   // =========================================================================
   checkTerminalIsLast(node, accept) {
-    if (node.modifier?.type !== "terminal")
+    if (!endsFlow(node))
       return;
     const container = node.$container;
     const siblings = "nodes" in container ? container.nodes : [];
@@ -60762,6 +60857,10 @@ var MomentValidator = class {
     return false;
   }
 };
+function endsFlow(node) {
+  const type = node.modifier?.type;
+  return type === "terminal" || type === "outcome";
+}
 
 // ../core/dist/moment-module.js
 var MomentModule = {
@@ -61045,6 +61144,76 @@ function validateMultiEvent(ir, options = {}) {
   ];
 }
 
+// ../core/dist/validation/policy-condition.js
+function placedOrder(flow) {
+  return flow.moments.flatMap((m) => [
+    ...m.contextEntries.map((e) => e.nodeName),
+    ...(m.branches ?? []).flatMap((b) => b.entries.map((e) => e.nodeName))
+  ]);
+}
+function someFlowPlacesBefore(flows, cause, trigger) {
+  let triggerPlaced = false;
+  for (const flow of flows) {
+    const order = placedOrder(flow);
+    const firstCause = order.indexOf(cause);
+    const lastTrigger = order.lastIndexOf(trigger);
+    if (lastTrigger >= 0)
+      triggerPlaced = true;
+    if (firstCause >= 0 && lastTrigger > firstCause)
+      return { reached: true, triggerPlaced };
+  }
+  return { reached: false, triggerPlaced };
+}
+function fieldsByEvent(ir) {
+  const events = /* @__PURE__ */ new Map();
+  for (const ctx of ir.contexts)
+    for (const e of ctx.events) {
+      const fields = events.get(e.name) ?? /* @__PURE__ */ new Set();
+      for (const f of e.fields ?? [])
+        fields.add(f.name);
+      events.set(e.name, fields);
+    }
+  return events;
+}
+function v49(p, events) {
+  const c = p.condition;
+  const fields = events.get(p.trigger);
+  if (c?.field === void 0 || fields === void 0 || fields.has(c.field))
+    return [];
+  return [
+    {
+      ruleId: "V49",
+      message: `Policy '${p.name}' reacts when '${c.field}' of '${p.trigger}' is '${c.equals ?? ""}', but '${p.trigger}' has no field '${c.field}'.`
+    }
+  ];
+}
+function v50v51(p, events, flows) {
+  const after = p.condition?.after;
+  if (after === void 0)
+    return [];
+  if (!events.has(after))
+    return [
+      {
+        ruleId: "V50",
+        message: `Policy '${p.name}' reacts after '${after}', which is no declared event.`
+      }
+    ];
+  const { reached, triggerPlaced } = someFlowPlacesBefore(flows, after, p.trigger);
+  if (!triggerPlaced || reached)
+    return [];
+  return [
+    {
+      ruleId: "V51",
+      severity: "warning",
+      message: `Policy '${p.name}' reacts to '${p.trigger}' after '${after}', but no flow places '${after}' before '${p.trigger}'; the condition is never met.`
+    }
+  ];
+}
+function validatePolicyConditions(ir) {
+  const events = fieldsByEvent(ir);
+  return ir.contexts.flatMap((ctx) => ctx.policies.filter((p) => p.condition !== void 0).flatMap((p) => [...v49(p, events), ...v50v51(p, events, ir.flows ?? [])]));
+}
+
 // ../core/dist/validation/palette-conformance.js
 function namesOf2(ir) {
   const contexts = ir.contexts;
@@ -61298,6 +61467,7 @@ function validatePaletteConformance(ir, options = {}) {
     ...v41v42Placements(ir, commands),
     ...v43(ir),
     ...validateMultiEvent(ir, options),
+    ...validatePolicyConditions(ir),
     ...(ir.externals ?? []).flatMap((e) => gatewayFindings(`external '${e.name}'`, e.gateways ?? [], known))
   ];
 }
@@ -61607,6 +61777,12 @@ function transformPolicy(pol, annotations) {
     trigger: pol.trigger,
     action: pol.action,
     chainsTo: pol.chainsTo,
+    ...pol.conditionField !== void 0 || pol.conditionAfter !== void 0 ? {
+      condition: {
+        ...pol.conditionField !== void 0 ? { field: pol.conditionField, equals: pol.conditionValue } : {},
+        ...pol.conditionAfter !== void 0 ? { after: pol.conditionAfter } : {}
+      }
+    } : {},
     ...gatewaysOf(pol.gateways)
   };
 }
@@ -61778,13 +61954,18 @@ function transformNodeToEntry(node, laneContextMap, nodeKindMap) {
   if (node.cause !== void 0) {
     entry.cause = node.cause;
   }
-  const modifierType = node.modifier?.type;
+  applyModifier(entry, node.modifier?.type);
+  return entry;
+}
+function applyModifier(entry, modifierType) {
   if (modifierType === "optional") {
     entry.optional = true;
   } else if (modifierType === "terminal") {
     entry.terminal = true;
+  } else if (modifierType === "outcome") {
+    entry.terminal = true;
+    entry.exit = "outcome";
   }
-  return entry;
 }
 function extractConnections(flow, laneContextMap) {
   const connections = [];
@@ -64829,6 +65010,7 @@ function multiEventPlacements(steps, commandOf) {
 }
 
 // ../derive/dist/engine/simulation-scenario-generator.js
+var BRANCH_KEY = "$branch";
 function resolveNodeKind(nodeName, contextId, contextMap, declaredKind) {
   const ctx = contextMap.get(contextId);
   if (!ctx)
@@ -64934,14 +65116,16 @@ function resolveScenarioLabel(flow, reachedBranches) {
   if (deviations.length === 0)
     return `Happy Path: ${flow.name}`;
   const bracket = deviations.map((b) => b.condition).join(", ");
-  const hasTerminalArm = deviations.some((b) => b.armHasTerminal);
-  return hasTerminalArm ? `Failure Path: ${flow.name} [${bracket}]` : `Variant: ${flow.name} [${bracket}]`;
+  return endsAtFailureExit(deviations) ? `Failure Path: ${flow.name} [${bracket}]` : `Variant: ${flow.name} [${bracket}]`;
 }
 function resolveScenarioKind(reachedBranches) {
   const deviations = reachedBranches.filter((b) => !b.isFirstArm);
   if (deviations.length === 0)
     return "happy";
-  return deviations.some((b) => b.armHasTerminal) ? "failure" : "variant";
+  return endsAtFailureExit(deviations) ? "failure" : "variant";
+}
+function endsAtFailureExit(deviations) {
+  return deviations.some((b) => b.armHasFailureExit);
 }
 function buildContextMap(ir) {
   return new Map(ir.contexts.map((c) => [c.id, c]));
@@ -65021,6 +65205,10 @@ function selectBranch(moment, branchSelections, state) {
   const branch = (selected ? branches.find((b) => b.condition === selected) : void 0) ?? branches[0];
   return { branch, forced };
 }
+function armEndsAtFailureExit(branch) {
+  const exit = branch.entries.find((e) => e.terminal);
+  return exit !== void 0 && exit.exit !== "outcome";
+}
 function recordBranchPoint(state, moment, branch, branchIdx, forced) {
   state.activations.push({ momentName: moment.name, condition: branch.condition });
   if (!forced && !state.reachedNames.has(moment.name)) {
@@ -65029,7 +65217,7 @@ function recordBranchPoint(state, moment, branch, branchIdx, forced) {
       momentName: moment.name,
       condition: branch.condition,
       isFirstArm: branchIdx === 0,
-      armHasTerminal: branch.entries.some((e) => e.terminal)
+      armHasFailureExit: armEndsAtFailureExit(branch)
     });
   }
 }
@@ -65091,6 +65279,7 @@ function generateEvents(nodes, flow, contextMap, sessionId, correlationId, baseT
   const eventIds = nodes.map((_, i) => `evt-${String(i + 1).padStart(3, "0")}`);
   const placements2 = placementsOf(nodes, contextMap);
   const commandOfEvent = new Map(placements2.flatMap((p) => p.events.map((k) => [k, p.command])));
+  const conditioned = policyConditionedOccurrences(nodes, flow, contextMap);
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
     const recordedBy = commandOfEvent.get(i);
@@ -65100,6 +65289,7 @@ function generateEvents(nodes, flow, contextMap, sessionId, correlationId, baseT
     const eventType = resolveEventType(node, effectiveKind);
     const productSource = resolveProductSource(node, effectiveKind, contextMap);
     const payload = buildPayload(node, effectiveKind, contextMap, flow);
+    applyPolicyConditions(payload, i, node, conditioned, contextMap);
     const whenState = placements2.find((p) => p.command === i)?.whenState;
     if (whenState !== void 0)
       payload.whenState = whenState;
@@ -65117,6 +65307,89 @@ function generateEvents(nodes, flow, contextMap, sessionId, correlationId, baseT
   }
   return events;
 }
+function guardedPolicies(contextMap) {
+  const byTrigger = /* @__PURE__ */ new Map();
+  for (const ctx of contextMap.values())
+    for (const policy of ctx.policies) {
+      if (policy.condition?.field === void 0)
+        continue;
+      byTrigger.set(policy.trigger, [...byTrigger.get(policy.trigger) ?? [], policy]);
+    }
+  return byTrigger;
+}
+function policyConditionedOccurrences(nodes, flow, contextMap) {
+  const guarded = guardedPolicies(contextMap);
+  const named = /* @__PURE__ */ new Map();
+  if (guarded.size === 0)
+    return named;
+  nodes.forEach((node, index) => {
+    for (const conn of flow.connections) {
+      if (!isCausationConnectionFor(conn, node))
+        continue;
+      const triggerName = conn.sourceNodeName ?? conn.eventId.replace(/^evt-/, "");
+      const policies = (guarded.get(triggerName) ?? []).filter((p) => p.chainsTo === node.nodeName);
+      if (policies.length === 0)
+        continue;
+      for (let j = index - 1; j >= 0; j--) {
+        if (nodes[j].nodeName !== triggerName)
+          continue;
+        named.set(j, [...named.get(j) ?? [], ...policies]);
+        break;
+      }
+    }
+  });
+  return named;
+}
+function typedValue(type, value) {
+  if (type === "number" && value.trim() !== "" && !Number.isNaN(Number(value)))
+    return Number(value);
+  if (type === "boolean" && (value === "true" || value === "false"))
+    return value === "true";
+  return value;
+}
+function otherThan(value) {
+  if (typeof value === "number")
+    return value + 1;
+  if (typeof value === "boolean")
+    return !value;
+  return `${String(value)}-other`;
+}
+function guardedField(policy, payload) {
+  const field = policy.condition?.field;
+  return field !== void 0 && field in payload ? field : void 0;
+}
+function declaredValue(evt, policy) {
+  const field = policy.condition?.field ?? "";
+  const type = evt.fields.find((f) => f.name === field)?.type ?? "";
+  return typedValue(type, policy.condition?.equals ?? "");
+}
+function moveOffDeclared(payload, guarded, evt, fixed) {
+  for (const policy of guarded) {
+    const field = guardedField(policy, payload);
+    if (field === void 0 || fixed.has(field))
+      continue;
+    const declared = declaredValue(evt, policy);
+    if (payload[field] === declared)
+      payload[field] = otherThan(declared);
+  }
+}
+function applyPolicyConditions(payload, index, node, conditioned, contextMap) {
+  const ctx = contextMap.get(node.contextId);
+  const evt = ctx ? findEvent(ctx, node.nodeName) : void 0;
+  if (!evt)
+    return;
+  const guarded = [...contextMap.values()].flatMap((c) => c.policies.filter((p) => p.trigger === node.nodeName && p.condition?.field !== void 0));
+  const naming = conditioned.get(index) ?? [];
+  const fixed = /* @__PURE__ */ new Set();
+  for (const policy of guarded.filter((p) => naming.includes(p))) {
+    const field = guardedField(policy, payload);
+    if (field === void 0 || fixed.has(field))
+      continue;
+    payload[field] = declaredValue(evt, policy);
+    fixed.add(field);
+  }
+  moveOffDeclared(payload, guarded, evt, fixed);
+}
 function findCausationEvents(node, allNodes, flow, eventIds, currentIndex, recordedBy) {
   const causation = [];
   for (const conn of flow.connections) {
@@ -65193,11 +65466,16 @@ function buildPayload(node, effectiveKind, contextMap, flow) {
     }
   }
   addContractFields(payload, node, flow);
-  if (node.outcome !== void 0) {
-    payload.outcome = node.outcome;
-  }
+  stampBranch(payload, node);
   return payload;
 }
+function stampBranch(payload, node) {
+  if (node.outcome === void 0)
+    return;
+  payload[BRANCH_KEY] = node.outcome;
+  if (!("outcome" in payload))
+    payload.outcome = node.outcome;
+}
 function addContractFields(payload, node, flow) {
   for (const conn of flow.connections) {
     if (conn.connectionType !== "crosses-to")
@@ -65278,23 +65556,40 @@ function findEventAfter(events, eventType, afterIndex) {
 function deriveNegativeScenarios(ir, flow, options) {
   const contextMap = buildContextMap(ir);
   const opts = resolveOptions(flow, options);
-  const walk = walkPath(flow, opts.branchSelections);
-  const nodes = walk.nodes;
   const scenarios = [];
   const usedIds = /* @__PURE__ */ new Set();
-  for (let i = 0; i < nodes.length; i++) {
-    const node = nodes[i];
-    const kind = resolveNodeKind(node.nodeName, node.contextId, contextMap, node.nodeKind);
-    if (kind !== "command")
-      continue;
-    const preconditions = findPreconditions(node, contextMap);
-    for (const pre of preconditions) {
-      const baseId = `${opts.scenarioId}-neg-${node.nodeName}-${pre.name}`;
-      const scenarioId = usedIds.has(baseId) ? `${baseId}-${i}` : baseId;
-      usedIds.add(scenarioId);
-      usedIds.add(baseId);
-      scenarios.push(buildNegativeScenario(ir, flow, walk, i, pre, contextMap, opts, scenarioId));
+  const covered = /* @__PURE__ */ new Set();
+  const deriveOnPath = (walk, onlyUncovered) => {
+    const nodes = walk.nodes;
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      const kind = resolveNodeKind(node.nodeName, node.contextId, contextMap, node.nodeKind);
+      if (kind !== "command")
+        continue;
+      for (const pre of findPreconditions(node, contextMap)) {
+        const key = [node.nodeName, pre.name, node.cause ?? ""].join("\0");
+        if (onlyUncovered && covered.has(key))
+          continue;
+        covered.add(key);
+        const baseId = `${opts.scenarioId}-neg-${node.nodeName}-${pre.name}`;
+        const scenarioId = usedIds.has(baseId) ? `${baseId}-${i}` : baseId;
+        usedIds.add(scenarioId);
+        usedIds.add(baseId);
+        scenarios.push(buildNegativeScenario(ir, flow, walk, i, pre, contextMap, opts, scenarioId));
+      }
     }
+  };
+  deriveOnPath(walkPath(flow, opts.branchSelections), false);
+  if (options?.branchSelections !== void 0)
+    return scenarios;
+  const seenPaths = /* @__PURE__ */ new Set();
+  for (const selections of enumerateBranchCombinations(flow)) {
+    const walk = walkPath(flow, selections);
+    const pathKey = walk.nodes.map((n) => n.nodeId).join("|");
+    if (seenPaths.has(pathKey))
+      continue;
+    seenPaths.add(pathKey);
+    deriveOnPath(walk, true);
   }
   return scenarios;
 }
@@ -65560,7 +65855,8 @@ function generatePolicyDefinitions(ir) {
         contextId: context.id,
         trigger: policy.trigger,
         ...policy.action ? { actionDescription: policy.action } : {},
-        chainsTo: normalizeChainsTo(policy.chainsTo)
+        chainsTo: normalizeChainsTo(policy.chainsTo),
+        ...policy.condition ? { condition: { ...policy.condition } } : {}
       });
     }
   }
@@ -66253,46 +66549,51 @@ function findProcess(nodeName, ctx) {
   return null;
 }
 function buildConnections(flow) {
-  return flow.connections.map((conn) => {
-    const eventType = conn.eventId.replace(/^evt-/, "");
-    const endpoints = {
-      eventType,
-      sourceNodeName: conn.sourceNodeName,
-      targetNodeName: conn.targetNodeName
-    };
-    if (conn.connectionType === "returns-to") {
-      if (conn.targetMomentId) {
-        return {
-          from: conn.sourceMomentId,
-          to: conn.targetMomentId,
-          style: "return",
-          targetMomentLabel: conn.targetMomentLabel,
-          ...endpoints
-        };
-      }
+  return flow.connections.map((conn) => ({
+    ...buildConnection(conn),
+    // ADR-044: the IR already states which arm declared the connection.
+    ...conn.branchCondition !== void 0 ? { branchCondition: conn.branchCondition } : {}
+  }));
+}
+function buildConnection(conn) {
+  const eventType = conn.eventId.replace(/^evt-/, "");
+  const endpoints = {
+    eventType,
+    sourceNodeName: conn.sourceNodeName,
+    targetNodeName: conn.targetNodeName
+  };
+  if (conn.connectionType === "returns-to") {
+    if (conn.targetMomentId) {
       return {
         from: conn.sourceMomentId,
-        to: conn.targetContextId,
-        label: `unresolved returns-to target: ${conn.targetMomentLabel ?? "(unknown)"}`,
+        to: conn.targetMomentId,
         style: "return",
         targetMomentLabel: conn.targetMomentLabel,
         ...endpoints
       };
     }
-    const isCrossing2 = conn.connectionType === "crosses-to";
     return {
       from: conn.sourceMomentId,
-      // For 'triggers' the core now resolves targetContextId to the context
-      // where the TARGET node is placed (not the source's own lane).
       to: conn.targetContextId,
-      label: isCrossing2 ? eventType : void 0,
-      style: mapConnectionStyle(conn),
-      crossBoundary: isCrossing2 || void 0,
-      relationship: isCrossing2 ? conn.schemaContract.relationshipType : void 0,
-      schemaContract: isCrossing2 ? mapSchemaContract(conn) : void 0,
+      label: `unresolved returns-to target: ${conn.targetMomentLabel ?? "(unknown)"}`,
+      style: "return",
+      targetMomentLabel: conn.targetMomentLabel,
       ...endpoints
     };
-  });
+  }
+  const isCrossing2 = conn.connectionType === "crosses-to";
+  return {
+    from: conn.sourceMomentId,
+    // For 'triggers' the core now resolves targetContextId to the context
+    // where the TARGET node is placed (not the source's own lane).
+    to: conn.targetContextId,
+    label: isCrossing2 ? eventType : void 0,
+    style: mapConnectionStyle(conn),
+    crossBoundary: isCrossing2 || void 0,
+    relationship: isCrossing2 ? conn.schemaContract.relationshipType : void 0,
+    schemaContract: isCrossing2 ? mapSchemaContract(conn) : void 0,
+    ...endpoints
+  };
 }
 function mapConnectionStyle(conn) {
   if (conn.connectionType === "crosses-to")
@@ -66369,7 +66670,7 @@ function buildBranchPredicates(flow) {
       routes[branch.condition] = branch.condition;
     }
     predicates[moment.id] = {
-      field: "outcome",
+      field: BRANCH_KEY,
       defaultRoute: moment.branches[0].condition,
       routes
     };
@@ -66565,12 +66866,16 @@ function renderNoteOnlyMoment(lines, moment, flow) {
   lines.push(...noteComments(moment, flow, "    "));
   lines.push("");
 }
+function armEndsAtOutcome(branchEntries) {
+  return branchEntries.find((e) => e.terminal)?.exit === "outcome";
+}
 function renderTerminalBranchScenario(lines, moment, condition, branchEntries, flow, ctxMap, ir) {
-  const tags = ["@terminal", "@failure-path"];
+  const endsAtOutcome = armEndsAtOutcome(branchEntries);
+  const tags = ["@terminal", endsAtOutcome ? "@alt-path" : "@failure-path"];
   lines.push(`    ${tags.join(" ")}`);
   lines.push(`    Scenario: ${moment.name} [${condition}]`);
   lines.push(...noteComments(moment, flow, "      "));
-  const failedPrecondition = findFailedPrecondition(moment, ctxMap);
+  const failedPrecondition = endsAtOutcome ? void 0 : findFailedPrecondition(moment, ctxMap);
   lines.push(`      Given the ${moment.name.toLowerCase()} is evaluated`);
   if (failedPrecondition) {
     lines.push(`      When ${failedPrecondition.name} is not satisfied`);
@@ -66585,7 +66890,8 @@ function renderTerminalBranchScenario(lines, moment, condition, branchEntries, f
     lines.push(`      Then the flow terminates because ${failedPrecondition.description}`);
   } else {
     const terminalNode = branchEntries.find((e) => e.terminal)?.nodeName;
-    lines.push(`      Then the flow terminates${terminalNode ? ` at ${terminalNode}` : ""}`);
+    const verb = endsAtOutcome ? "ends" : "terminates";
+    lines.push(`      Then the flow ${verb}${terminalNode ? ` at ${terminalNode}` : ""}`);
   }
   const compensation = findCompensationForMoment(moment, ir);
   if (compensation) {
@@ -66714,7 +67020,7 @@ function readOrEmit(entry) {
   return "emits";
 }
 function renderInternalEventStep(lines, entry, evt, ctxName) {
-  const modifier = entry.optional ? " (optional)" : entry.terminal ? " (terminal)" : "";
+  const modifier = entry.optional ? " (optional)" : entry.terminal ? entry.exit === "outcome" ? " (outcome)" : " (terminal)" : "";
   lines.push(`      Then ${ctxName} ${readOrEmit(entry)} ${entry.nodeName}${modifier}`);
   if (evt && evt.fields.length > 0) {
     lines.push(`        carrying ${evt.fields.map((f) => f.name).join(", ")}`);
@@ -67221,8 +67527,10 @@ var SpecificationDocumentGenerator = class {
   }
   renderTerminalBranch(lines, moment, branch, flow, ir) {
     const usedConnections = /* @__PURE__ */ new Set();
-    const terminalNode = branch.entries.find((e) => e.terminal)?.nodeName;
-    lines.push(`  - \u274C **If ${branch.condition}:** flow terminates${terminalNode ? ` at **${terminalNode}**` : ""}`);
+    const exit = branch.entries.find((e) => e.terminal);
+    const terminalNode = exit?.nodeName;
+    const [mark, verb] = exit?.exit === "outcome" ? ["\u2705", "ends"] : ["\u274C", "terminates"];
+    lines.push(`  - ${mark} **If ${branch.condition}:** flow ${verb}${terminalNode ? ` at **${terminalNode}**` : ""}`);
     for (const entry of branch.entries) {
       if (entry.terminal)
         continue;
@@ -67548,8 +67856,11 @@ var SpecificationDocumentGenerator = class {
   }
   renderBranchAltBlock(lines, moment, ctxName, flow, ir) {
     const nonTerminal = moment.branches.filter((b) => !b.entries.some((e) => e.terminal));
-    const terminal = moment.branches.filter((b) => b.entries.some((e) => e.terminal));
-    if (nonTerminal.length === 0 && terminal.length === 0)
+    const ending = moment.branches.filter((b) => b.entries.some((e) => e.terminal));
+    const isOutcome = (b) => b.entries.find((e) => e.terminal)?.exit === "outcome";
+    const terminal = ending.filter((b) => !isOutcome(b));
+    const outcome = ending.filter(isOutcome);
+    if (nonTerminal.length === 0 && ending.length === 0)
       return;
     for (let i = 0; i < nonTerminal.length; i++) {
       const branch = nonTerminal[i];
@@ -67557,11 +67868,16 @@ var SpecificationDocumentGenerator = class {
       lines.push(`  ${keyword} ${branch.condition}`);
       this.renderSequenceEntries(lines, branch.entries, moment, branch.condition, flow, ir);
     }
-    if (terminal.length > 0) {
-      const keyword = nonTerminal.length === 0 ? "alt" : "else";
-      const labels = terminal.map((b) => b.condition).join(" / ");
-      lines.push(`  ${keyword} ${labels}`);
-      lines.push(`  Note over ${ctxName}: Flow terminates`);
+    let opened = nonTerminal.length > 0;
+    for (const [arms, note] of [
+      [terminal, "Flow terminates"],
+      [outcome, "Flow ends at an outcome"]
+    ]) {
+      if (arms.length === 0)
+        continue;
+      lines.push(`  ${opened ? "else" : "alt"} ${arms.map((b) => b.condition).join(" / ")}`);
+      lines.push(`  Note over ${ctxName}: ${note}`);
+      opened = true;
     }
     lines.push("  end");
   }