@mmmnt/cli 0.4.0 → 0.5.0

package/dist/moment.mjs

@@ -35652,6 +35652,173 @@ ${obj.gpgsig ? obj.gpgsig : ""}`;
 import { parseArgs } from "node:util";
 import { resolve as resolve5 } from "node:path";
 
+// ../core/dist/services/schema-validator.js
+var SchemaValidator = class {
+  /**
+   * Validates structural correctness of an IntermediateRepresentation.
+   * Enforces SP-01 through SP-04 (pure IR checks, no I/O).
+   * SP-05 (manifest file references) requires filesystem access —
+   * use `validateManifestFiles()` separately.
+   */
+  validate(ir) {
+    const diagnostics = [];
+    this.checkSP01(ir, diagnostics);
+    this.checkSP02(ir, diagnostics);
+    this.checkSP03(ir, diagnostics);
+    this.checkSP04(ir, diagnostics);
+    return { valid: diagnostics.length === 0, diagnostics };
+  }
+  /**
+   * Validates that all file references in the manifest exist on disk (SP-05).
+   * Requires an injected `fileExists` function for filesystem access.
+   */
+  validateManifestFiles(files, fileExists) {
+    const diagnostics = [];
+    for (const file of files) {
+      if (!fileExists(file.path)) {
+        diagnostics.push({
+          severity: "error",
+          message: `SP-05: File '${file.path}' referenced in manifest does not exist.`,
+          ruleId: "SP-05"
+        });
+      }
+    }
+    return { valid: diagnostics.length === 0, diagnostics };
+  }
+  checkSP01(ir, diagnostics) {
+    const contextIds = new Set(ir.contexts.map((c) => c.id));
+    for (const flow of ir.flows) {
+      for (const conn of flow.connections) {
+        if (conn.connectionType === "crosses-to" && !contextIds.has(conn.targetContextId)) {
+          diagnostics.push({
+            severity: "error",
+            message: `SP-01: Connection '${conn.id}' references unknown context '${conn.targetContextId}'.`,
+            ruleId: "SP-01"
+          });
+        }
+      }
+    }
+  }
+  /**
+   * SP-02: A crossing's event must be declared on the boundary it crosses —
+   * by the source context (the emitter, the convention the shipped examples
+   * follow) or by the target context (consumer-side re-declaration). The
+   * original target-only rule flagged every crossing in the canonical
+   * examples, because events are declared once, in the emitting context.
+   */
+  checkSP02(ir, diagnostics) {
+    const contextEventsMap = /* @__PURE__ */ new Map();
+    for (const ctx of ir.contexts) {
+      const eventIds = new Set(ctx.events.map((e) => e.id));
+      contextEventsMap.set(ctx.id, eventIds);
+    }
+    for (const flow of ir.flows) {
+      for (const conn of flow.connections) {
+        if (conn.connectionType === "crosses-to") {
+          this.checkCrossingEventDeclared(flow, conn, contextEventsMap, diagnostics);
+        }
+      }
+    }
+  }
+  checkCrossingEventDeclared(flow, conn, contextEventsMap, diagnostics) {
+    const targetEvents = contextEventsMap.get(conn.targetContextId);
+    const sourceContextId = this.resolveSourceContextId(flow, conn);
+    const sourceEvents = sourceContextId !== void 0 ? contextEventsMap.get(sourceContextId) : void 0;
+    if (!targetEvents && !sourceEvents)
+      return;
+    if (!targetEvents?.has(conn.eventId) && !sourceEvents?.has(conn.eventId)) {
+      diagnostics.push({
+        severity: "error",
+        message: `SP-02: Connection '${conn.id}' references event '${conn.eventId}' which is declared neither by its source context nor by target context '${conn.targetContextId}'.`,
+        ruleId: "SP-02"
+      });
+    }
+  }
+  /** Context that owns the connection's declaring node, via its moment entry. */
+  resolveSourceContextId(flow, conn) {
+    if (conn.sourceNodeName === void 0)
+      return void 0;
+    const moment = flow.moments.find((m) => m.id === conn.sourceMomentId);
+    if (!moment)
+      return void 0;
+    const entries = [
+      ...moment.contextEntries,
+      ...moment.branches?.flatMap((b) => b.entries) ?? []
+    ];
+    return entries.find((e) => e.nodeName === conn.sourceNodeName)?.contextId;
+  }
+  checkSP03(ir, diagnostics) {
+    for (const flow of ir.flows) {
+      for (const conn of flow.connections) {
+        if (conn.connectionType === "crosses-to") {
+          if (conn.schemaContract.fields.length === 0) {
+            diagnostics.push({
+              severity: "error",
+              message: `SP-03: Crossing connection '${conn.id}' has an empty schema contract.`,
+              ruleId: "SP-03"
+            });
+          }
+        }
+      }
+    }
+  }
+  /**
+   * SP-04: returns-to must land on a prior moment in the same flow.
+   *
+   * Resolution uses the connection's `targetMomentId` (with a
+   * `targetMomentLabel` name-match fallback) — the moment the spec actually
+   * names. The original implementation resolved via `targetContextId`, which
+   * is the SOURCE node's own lane (audit M-P10) and flagged every moment that
+   * merely shared that context — semantically wrong in both directions.
+   */
+  checkSP04(ir, diagnostics) {
+    for (const flow of ir.flows) {
+      const momentIndexMap = /* @__PURE__ */ new Map();
+      flow.moments.forEach((m, index) => {
+        momentIndexMap.set(m.id, index);
+      });
+      for (const conn of flow.connections) {
+        if (conn.connectionType === "returns-to") {
+          this.checkReturnsToIsPrior(flow, conn, momentIndexMap, diagnostics);
+        }
+      }
+    }
+  }
+  checkReturnsToIsPrior(flow, conn, momentIndexMap, diagnostics) {
+    const sourceIndex = momentIndexMap.get(conn.sourceMomentId);
+    if (sourceIndex === void 0) {
+      diagnostics.push({
+        severity: "error",
+        message: `SP-04: Connection '${conn.id}' references unresolvable source moment '${conn.sourceMomentId}'.`,
+        ruleId: "SP-04"
+      });
+      return;
+    }
+    const targetMomentId = conn.targetMomentId ?? this.resolveMomentIdByLabel(flow, conn.targetMomentLabel);
+    const targetIndex = targetMomentId !== void 0 ? momentIndexMap.get(targetMomentId) : void 0;
+    if (targetIndex === void 0) {
+      diagnostics.push({
+        severity: "error",
+        message: `SP-04: Connection '${conn.id}' returns-to target moment '${conn.targetMomentLabel ?? conn.targetMomentId ?? "unknown"}' which cannot be resolved in this flow.`,
+        ruleId: "SP-04"
+      });
+      return;
+    }
+    if (targetIndex >= sourceIndex) {
+      diagnostics.push({
+        severity: "error",
+        message: `SP-04: Connection '${conn.id}' returns-to a moment that is not prior (source moment index ${sourceIndex}, target moment index ${targetIndex}).`,
+        ruleId: "SP-04"
+      });
+    }
+  }
+  resolveMomentIdByLabel(flow, label) {
+    if (label === void 0)
+      return void 0;
+    return flow.moments.find((m) => m.name === label)?.id;
+  }
+};
+
 // ../core/dist/manifest/manifest-reader.js
 var import_yaml = __toESM(require_dist(), 1);
 import { readFileSync as readFileSync2, existsSync } from "node:fs";
@@ -57272,6 +57439,9 @@ var MomentFile = {
   contexts: "contexts",
   flows: "flows"
 };
+function isMomentFile(item) {
+  return reflection2.isInstance(item, MomentFile.$type);
+}
 var Multiplicity = {
   $type: "Multiplicity",
   count: "count",
@@ -57320,9 +57490,10 @@ function isReturnsTo(item) {
 var SagaDeclaration = {
   $type: "SagaDeclaration",
   compensation: "compensation",
+  initialState: "initialState",
   name: "name",
-  states: "states",
   timeout: "timeout",
+  transitions: "transitions",
   trigger: "trigger"
 };
 function isSagaDeclaration(item) {
@@ -57333,6 +57504,11 @@ var SagaTimeout = {
   duration: "duration",
   none: "none"
 };
+var SagaTransition = {
+  $type: "SagaTransition",
+  event: "event",
+  target: "target"
+};
 var TriggeredBy = {
   $type: "TriggeredBy",
   nodeName: "nodeName"
@@ -57774,16 +57950,19 @@ var MomentAstReflection = class extends AbstractAstReflection {
         compensation: {
           name: SagaDeclaration.compensation
         },
+        initialState: {
+          name: SagaDeclaration.initialState
+        },
         name: {
           name: SagaDeclaration.name
         },
-        states: {
-          name: SagaDeclaration.states,
-          defaultValue: []
-        },
         timeout: {
           name: SagaDeclaration.timeout
         },
+        transitions: {
+          name: SagaDeclaration.transitions,
+          defaultValue: []
+        },
         trigger: {
           name: SagaDeclaration.trigger
         }
@@ -57802,6 +57981,18 @@ var MomentAstReflection = class extends AbstractAstReflection {
       },
       superTypes: []
     },
+    SagaTransition: {
+      name: SagaTransition.$type,
+      properties: {
+        event: {
+          name: SagaTransition.event
+        },
+        target: {
+          name: SagaTransition.target
+        }
+      },
+      superTypes: []
+    },
     TriggeredBy: {
       name: TriggeredBy.$type,
       properties: {
@@ -57899,7 +58090,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@19"
+                "$ref": "#/rules@20"
               },
               "arguments": []
             }
@@ -57927,7 +58118,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@41"
+                "$ref": "#/rules@42"
               },
               "arguments": []
             }
@@ -57939,7 +58130,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@37"
+                "$ref": "#/rules@38"
               },
               "arguments": []
             },
@@ -57959,7 +58150,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
                 "terminal": {
                   "$type": "RuleCall",
                   "rule": {
-                    "$ref": "#/rules@41"
+                    "$ref": "#/rules@42"
                   },
                   "arguments": []
                 }
@@ -58023,7 +58214,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
           {
             "$type": "RuleCall",
             "rule": {
-              "$ref": "#/rules@18"
+              "$ref": "#/rules@19"
             },
             "arguments": []
           },
@@ -58057,7 +58248,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -58098,14 +58289,14 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
           {
             "$type": "RuleCall",
             "rule": {
-              "$ref": "#/rules@40"
+              "$ref": "#/rules@41"
             },
             "arguments": []
           },
           {
             "$type": "RuleCall",
             "rule": {
-              "$ref": "#/rules@41"
+              "$ref": "#/rules@42"
             },
             "arguments": []
           }
@@ -58132,7 +58323,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@41"
+                "$ref": "#/rules@42"
               },
               "arguments": []
             }
@@ -58148,7 +58339,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@33"
+                "$ref": "#/rules@34"
               },
               "arguments": []
             }
@@ -58236,7 +58427,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -58309,7 +58500,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -58333,7 +58524,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -58349,7 +58540,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@35"
+                "$ref": "#/rules@36"
               },
               "arguments": []
             }
@@ -58361,7 +58552,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@34"
+                "$ref": "#/rules@35"
               },
               "arguments": []
             },
@@ -58390,7 +58581,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -58406,7 +58597,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@41"
+                "$ref": "#/rules@42"
               },
               "arguments": []
             }
@@ -58434,7 +58625,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -58446,7 +58637,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@33"
+                "$ref": "#/rules@34"
               },
               "arguments": []
             },
@@ -58475,7 +58666,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -58487,7 +58678,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@33"
+                "$ref": "#/rules@34"
               },
               "arguments": []
             },
@@ -58516,7 +58707,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -58528,7 +58719,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@41"
+                "$ref": "#/rules@42"
               },
               "arguments": []
             }
@@ -58544,7 +58735,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -58572,7 +58763,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -58588,7 +58779,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -58604,7 +58795,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -58620,7 +58811,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@41"
+                "$ref": "#/rules@42"
               },
               "arguments": []
             }
@@ -58648,7 +58839,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -58680,7 +58871,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@41"
+                "$ref": "#/rules@42"
               },
               "arguments": []
             }
@@ -58699,7 +58890,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
                 "terminal": {
                   "$type": "RuleCall",
                   "rule": {
-                    "$ref": "#/rules@40"
+                    "$ref": "#/rules@41"
                   },
                   "arguments": []
                 }
@@ -58726,7 +58917,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -58763,7 +58954,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -58779,7 +58970,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -58790,36 +58981,27 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
           },
           {
             "$type": "Assignment",
-            "feature": "states",
-            "operator": "+=",
+            "feature": "initialState",
+            "operator": "=",
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
           },
           {
-            "$type": "Group",
-            "elements": [
-              {
-                "$type": "Keyword",
-                "value": "->"
+            "$type": "Assignment",
+            "feature": "transitions",
+            "operator": "+=",
+            "terminal": {
+              "$type": "RuleCall",
+              "rule": {
+                "$ref": "#/rules@17"
               },
-              {
-                "$type": "Assignment",
-                "feature": "states",
-                "operator": "+=",
-                "terminal": {
-                  "$type": "RuleCall",
-                  "rule": {
-                    "$ref": "#/rules@40"
-                  },
-                  "arguments": []
-                }
-              }
-            ],
+              "arguments": []
+            },
             "cardinality": "*"
           },
           {
@@ -58833,7 +59015,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@41"
+                "$ref": "#/rules@42"
               },
               "arguments": []
             }
@@ -58849,10 +59031,60 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@17"
+                "$ref": "#/rules@18"
+              },
+              "arguments": []
+            }
+          }
+        ]
+      },
+      "entry": false,
+      "fragment": false,
+      "parameters": []
+    },
+    {
+      "$type": "ParserRule",
+      "name": "SagaTransition",
+      "definition": {
+        "$type": "Group",
+        "elements": [
+          {
+            "$type": "Keyword",
+            "value": "->"
+          },
+          {
+            "$type": "Assignment",
+            "feature": "target",
+            "operator": "=",
+            "terminal": {
+              "$type": "RuleCall",
+              "rule": {
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
+          },
+          {
+            "$type": "Group",
+            "elements": [
+              {
+                "$type": "Keyword",
+                "value": "on"
+              },
+              {
+                "$type": "Assignment",
+                "feature": "event",
+                "operator": "=",
+                "terminal": {
+                  "$type": "RuleCall",
+                  "rule": {
+                    "$ref": "#/rules@41"
+                  },
+                  "arguments": []
+                }
+              }
+            ],
+            "cardinality": "?"
           }
         ]
       },
@@ -58873,7 +59105,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -58910,7 +59142,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -58926,7 +59158,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -58942,7 +59174,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@39"
+                "$ref": "#/rules@40"
               },
               "arguments": []
             }
@@ -58958,7 +59190,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@41"
+                "$ref": "#/rules@42"
               },
               "arguments": []
             }
@@ -58986,7 +59218,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@41"
+                "$ref": "#/rules@42"
               },
               "arguments": []
             }
@@ -59005,7 +59237,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
                 "terminal": {
                   "$type": "RuleCall",
                   "rule": {
-                    "$ref": "#/rules@41"
+                    "$ref": "#/rules@42"
                   },
                   "arguments": []
                 }
@@ -59020,7 +59252,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@20"
+                "$ref": "#/rules@21"
               },
               "arguments": []
             },
@@ -59033,7 +59265,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@21"
+                "$ref": "#/rules@22"
               },
               "arguments": []
             },
@@ -59076,7 +59308,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -59088,7 +59320,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@41"
+                "$ref": "#/rules@42"
               },
               "arguments": []
             }
@@ -59100,7 +59332,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@37"
+                "$ref": "#/rules@38"
               },
               "arguments": []
             },
@@ -59129,7 +59361,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@41"
+                "$ref": "#/rules@42"
               },
               "arguments": []
             }
@@ -59154,7 +59386,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
                 "terminal": {
                   "$type": "RuleCall",
                   "rule": {
-                    "$ref": "#/rules@23"
+                    "$ref": "#/rules@24"
                   },
                   "arguments": []
                 }
@@ -59166,7 +59398,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
                 "terminal": {
                   "$type": "RuleCall",
                   "rule": {
-                    "$ref": "#/rules@22"
+                    "$ref": "#/rules@23"
                   },
                   "arguments": []
                 }
@@ -59197,7 +59429,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -59216,7 +59448,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
                 "terminal": {
                   "$type": "RuleCall",
                   "rule": {
-                    "$ref": "#/rules@40"
+                    "$ref": "#/rules@41"
                   },
                   "arguments": []
                 }
@@ -59235,7 +59467,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@23"
+                "$ref": "#/rules@24"
               },
               "arguments": []
             },
@@ -59260,7 +59492,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -59276,7 +59508,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -59288,7 +59520,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@24"
+                "$ref": "#/rules@25"
               },
               "arguments": []
             },
@@ -59301,7 +59533,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@25"
+                "$ref": "#/rules@26"
               },
               "arguments": []
             },
@@ -59314,7 +59546,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@28"
+                "$ref": "#/rules@29"
               },
               "arguments": []
             },
@@ -59327,7 +59559,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@27"
+                "$ref": "#/rules@28"
               },
               "arguments": []
             },
@@ -59363,7 +59595,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
                 "terminal": {
                   "$type": "RuleCall",
                   "rule": {
-                    "$ref": "#/rules@42"
+                    "$ref": "#/rules@43"
                   },
                   "arguments": []
                 }
@@ -59375,7 +59607,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
                 "terminal": {
                   "$type": "RuleCall",
                   "rule": {
-                    "$ref": "#/rules@40"
+                    "$ref": "#/rules@41"
                   },
                   "arguments": []
                 }
@@ -59409,7 +59641,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@26"
+                "$ref": "#/rules@27"
               },
               "arguments": []
             }
@@ -59454,21 +59686,21 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
           {
             "$type": "RuleCall",
             "rule": {
-              "$ref": "#/rules@30"
+              "$ref": "#/rules@31"
             },
             "arguments": []
           },
           {
             "$type": "RuleCall",
             "rule": {
-              "$ref": "#/rules@31"
+              "$ref": "#/rules@32"
             },
             "arguments": []
           },
           {
             "$type": "RuleCall",
             "rule": {
-              "$ref": "#/rules@32"
+              "$ref": "#/rules@33"
             },
             "arguments": []
           }
@@ -59495,7 +59727,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -59511,7 +59743,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@39"
+                "$ref": "#/rules@40"
               },
               "arguments": []
             }
@@ -59527,7 +59759,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@29"
+                "$ref": "#/rules@30"
               },
               "arguments": []
             },
@@ -59552,7 +59784,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -59568,7 +59800,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@35"
+                "$ref": "#/rules@36"
               },
               "arguments": []
             }
@@ -59606,7 +59838,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -59634,7 +59866,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -59662,7 +59894,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@41"
+                "$ref": "#/rules@42"
               },
               "arguments": []
             }
@@ -59686,7 +59918,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@40"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -59702,7 +59934,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@35"
+                "$ref": "#/rules@36"
               },
               "arguments": []
             }
@@ -59714,7 +59946,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@34"
+                "$ref": "#/rules@35"
               },
               "arguments": []
             },
@@ -59747,7 +59979,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@41"
+                "$ref": "#/rules@42"
               },
               "arguments": []
             }
@@ -59763,7 +59995,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@41"
+                "$ref": "#/rules@42"
               },
               "arguments": []
             }
@@ -59791,7 +60023,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@36"
+                "$ref": "#/rules@37"
               },
               "arguments": []
             }
@@ -59850,7 +60082,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
           {
             "$type": "RuleCall",
             "rule": {
-              "$ref": "#/rules@40"
+              "$ref": "#/rules@41"
             },
             "arguments": []
           }
@@ -59877,7 +60109,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@38"
+                "$ref": "#/rules@39"
               },
               "arguments": []
             }
@@ -59959,7 +60191,7 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
           {
             "$type": "RuleCall",
             "rule": {
-              "$ref": "#/rules@40"
+              "$ref": "#/rules@41"
             },
             "arguments": []
           }
@@ -60061,25 +60293,90 @@ var MomentGeneratedModule = {
   parser: {}
 };
 
+// ../core/dist/parser/moment-sequence.js
+function buildMomentSequence(moment) {
+  const positioned = [];
+  moment.nodes.forEach((node, index) => {
+    positioned.push({ item: { kind: "entry", index }, offset: node.$cstNode?.offset });
+  });
+  moment.whenBlocks.forEach((block2, index) => {
+    positioned.push({ item: { kind: "branch", index }, offset: block2.$cstNode?.offset });
+  });
+  const fromCst = positioned.every((p) => p.offset !== void 0);
+  if (!fromCst) {
+    return { sequence: positioned.map((p) => p.item), fromCst: false };
+  }
+  const sequence = positioned.slice().sort((a, b) => a.offset - b.offset).map((p) => p.item);
+  return { sequence, fromCst: true };
+}
+
 // ../core/dist/validation/moment-validator.js
+function unquote(s) {
+  return s.startsWith('"') && s.endsWith('"') ? s.slice(1, -1) : s;
+}
+function buildCrossFileContext(file) {
+  const declaredContextNames = [];
+  const declaredEvents = /* @__PURE__ */ new Map();
+  const declaredBuildingBlocks = /* @__PURE__ */ new Map();
+  const declaredSagas = [];
+  for (const ctx of file.contexts) {
+    const contextName = unquote(ctx.name);
+    declaredContextNames.push(contextName);
+    const events = [];
+    const blocks = [];
+    for (const member of ctx.members) {
+      if (isAggregateDeclaration(member)) {
+        for (const aggMember of member.members) {
+          if (isCommandDeclaration(aggMember)) {
+            blocks.push({ name: aggMember.name, kind: "command" });
+          } else if (isDomainEventDeclaration(aggMember)) {
+            events.push(aggMember.name);
+            blocks.push({ name: aggMember.name, kind: "event" });
+          } else if (isValueObjectDeclaration(aggMember)) {
+            blocks.push({ name: aggMember.name, kind: "value-object" });
+          }
+        }
+      } else if (isPolicyDeclaration(member)) {
+        blocks.push({ name: member.name, kind: "policy" });
+      } else if (isSagaDeclaration(member)) {
+        blocks.push({ name: member.name, kind: "saga" });
+        declaredSagas.push(member.name);
+      }
+    }
+    declaredEvents.set(contextName, events);
+    declaredBuildingBlocks.set(contextName, blocks);
+  }
+  return { declaredContextNames, declaredEvents, declaredBuildingBlocks, declaredSagas };
+}
 function registerMomentValidationChecks(services) {
   const registry = services.validation.ValidationRegistry;
   const validator = services.validation.MomentValidator;
   const checks = {
     MomentDeclaration: validator.checkMoment,
     FieldDeclaration: validator.checkDeprecatedReplacement,
+    InputField: validator.checkDeprecatedReplacement,
     AnnotationDeclaration: validator.checkAnnotationName,
+    ContextDeclaration: validator.checkTrailingAnnotation,
+    AggregateDeclaration: validator.checkTrailingAnnotation,
+    SagaDeclaration: validator.checkSagaTransitionEvents,
     NodePlacement: [
       validator.checkNodePlacement,
       validator.checkOptionalWithCrossing,
       validator.checkTerminalIsLast,
-      validator.checkLaneIdExists
+      validator.checkLaneIdExists,
+      validator.checkTriggerDirection
     ],
     ContextCrossing: [
       validator.checkCrossingEmptyContract,
-      validator.checkCrossingTargetBranchLane
+      validator.checkCrossingTargetBranchLane,
+      validator.checkCrossingCrossFileRules
     ],
-    FlowDeclaration: [validator.checkReturnsToDepth, validator.checkBranchLaneReferenced]
+    FlowDeclaration: [
+      validator.checkReturnsToDepth,
+      validator.checkBranchLaneReferenced,
+      validator.checkV14,
+      validator.checkFlowCrossFileRules
+    ]
   };
   registry.register(checks, validator);
 }
@@ -60095,7 +60392,24 @@ function getFlowFromNode(node) {
 }
 function collectSiblingNames(field) {
   const container = field.$container;
-  return new Set(container.fields.map((f) => f.name));
+  const siblings = container.fields ?? container.inputs;
+  return siblings ? new Set(siblings.map((f) => f.name)) : void 0;
+}
+function laneDeclaresEvent(lane, eventName, ctx) {
+  if (!lane)
+    return false;
+  const events = ctx.declaredEvents.get(unquote(lane.label)) ?? [];
+  return events.includes(eventName);
+}
+function getMomentFileFromNode(node) {
+  let current = node;
+  while (current) {
+    if (isMomentFile(current)) {
+      return current;
+    }
+    current = current.$container;
+  }
+  return void 0;
 }
 function getMomentFromNode(node) {
   let current = node;
@@ -60123,6 +60437,8 @@ var MomentValidator = class {
       return;
     const replacement = field.deprecation.replacement.replace(/^"|"$/g, "");
     const siblings = collectSiblingNames(field);
+    if (siblings === void 0)
+      return;
     if (!siblings.has(replacement)) {
       accept("warning", `V12: Deprecated field '${field.name}' references replacement '${replacement}' which does not exist on this type.`, {
         node: field.deprecation,
@@ -60180,6 +60496,13 @@ var MomentValidator = class {
   }
   // =========================================================================
   // V8: [terminal] must be last node in branch/when block -> error
+  //
+  // M-P13 blind spot: the sibling-array check cannot see `when` blocks that
+  // textually follow a terminal node in the same moment (grammar splits nodes
+  // and whenBlocks into separate arrays). CST offsets recover the textual
+  // order; a main-list terminal followed by a when block gets a warning.
+  // A terminal INSIDE a when block followed by later when blocks is legal —
+  // those are alternative branch arms, not continuations.
   // =========================================================================
   checkTerminalIsLast(node, accept) {
     if (node.modifier?.type !== "terminal")
@@ -60193,6 +60516,17 @@ var MomentValidator = class {
         property: "modifier"
       });
     }
+    if (isMomentDeclaration(container)) {
+      const { sequence, fromCst } = buildMomentSequence(container);
+      if (!fromCst)
+        return;
+      const nodeIndex = container.nodes.indexOf(node);
+      const position = sequence.findIndex((s) => s.kind === "entry" && s.index === nodeIndex);
+      const followedByWhenBlock = position >= 0 && sequence.slice(position + 1).some((s) => s.kind === "branch");
+      if (followedByWhenBlock) {
+        accept("warning", "V8: Terminal node is textually followed by a when block in the same moment; the flow would continue past the terminal.", { node, property: "modifier" });
+      }
+    }
   }
   // =========================================================================
   // V13: Lane ID in node placement not matching any declared lane -> error
@@ -60230,6 +60564,110 @@ var MomentValidator = class {
     }
   }
   // =========================================================================
+  // V19: trailing annotation classifies nothing -> warning (M-P4)
+  // An annotation applies to the NEXT declaration in the member list; when
+  // nothing follows it, it silently classifies nothing.
+  // =========================================================================
+  checkTrailingAnnotation(container, accept) {
+    const members = container.members;
+    for (let i = members.length - 1; i >= 0; i--) {
+      const member = members[i];
+      if (!isAnnotationDeclaration(member))
+        break;
+      accept("warning", `V19: Annotation '@${member.name}' is not followed by a declaration and has no effect.`, { node: member, property: "name" });
+    }
+  }
+  // =========================================================================
+  // V20: declared trigger direction vs flow order -> warning (M-S10)
+  // `N triggers X` declares N as the cause of X, so X must not be placed
+  // before N's moment; `N triggered-by X` declares X as the cause, so X must
+  // not be placed after N's moment. Dangling references (X not placed in the
+  // flow at all) are V1's job and are skipped here.
+  // =========================================================================
+  checkTriggerDirection(node, accept) {
+    const flow = getFlowFromNode(node);
+    const moment = getMomentFromNode(node);
+    if (!flow || !moment)
+      return;
+    const currentIndex = flow.moments.indexOf(moment);
+    if (currentIndex < 0)
+      return;
+    const placementIndex = this.buildPlacementIndex(flow);
+    for (const conn of node.connections) {
+      if (isTriggers(conn)) {
+        this.warnIfPlacedBefore(conn, node, placementIndex, currentIndex, accept);
+      } else if (isTriggeredBy(conn)) {
+        this.warnIfPlacedAfter(conn, node, placementIndex, currentIndex, accept);
+      }
+    }
+  }
+  warnIfPlacedBefore(conn, node, placementIndex, currentIndex, accept) {
+    const targetIndex = placementIndex.get(conn.nodeName);
+    if (targetIndex !== void 0 && targetIndex < currentIndex) {
+      accept("warning", `V20: declared trigger direction contradicts flow order: '${conn.nodeName}' occurs before '${node.nodeName}'.`, { node: conn, property: "nodeName" });
+    }
+  }
+  warnIfPlacedAfter(conn, node, placementIndex, currentIndex, accept) {
+    const sourceIndex = placementIndex.get(conn.nodeName);
+    if (sourceIndex !== void 0 && sourceIndex > currentIndex) {
+      accept("warning", `V20: declared trigger direction contradicts flow order: trigger '${conn.nodeName}' occurs after '${node.nodeName}'.`, { node: conn, property: "nodeName" });
+    }
+  }
+  // =========================================================================
+  // V21: saga transition event unknown -> warning (M-S6)
+  // A `-> Target on Event` mapping whose event is neither declared by any
+  // context in the file nor placed in any flow is probably a typo. Guarded
+  // like the other cross-file checks: only meaningful when the file declares
+  // contexts (sagas always live inside one); an `on` event that only appears
+  // as a flow node placement is accepted, so mixed/flow-heavy specs that
+  // never re-declare events in contexts do not warn.
+  // =========================================================================
+  checkSagaTransitionEvents(saga, accept) {
+    const file = getMomentFileFromNode(saga);
+    if (!file || file.contexts.length === 0)
+      return;
+    const knownEvents = this.collectDeclaredEventNames(file);
+    const placedNodeNames = this.collectPlacedNodeNames(file);
+    for (const transition of saga.transitions) {
+      const event = transition.event;
+      if (event === void 0)
+        continue;
+      if (!knownEvents.has(event) && !placedNodeNames.has(event)) {
+        accept("warning", `V21: Saga transition event '${event}' is not declared by any context in this file and is not placed in any flow \u2014 possible typo.`, { node: transition, property: "event" });
+      }
+    }
+  }
+  /** Event names declared by any aggregate in any context of the file. */
+  collectDeclaredEventNames(file) {
+    const names = /* @__PURE__ */ new Set();
+    for (const ctx of file.contexts) {
+      for (const member of ctx.members) {
+        if (!isAggregateDeclaration(member))
+          continue;
+        for (const aggMember of member.members) {
+          if (isDomainEventDeclaration(aggMember))
+            names.add(aggMember.name);
+        }
+      }
+    }
+    return names;
+  }
+  /** Node names placed anywhere in the file's flows (main lists and when blocks). */
+  collectPlacedNodeNames(file) {
+    const names = /* @__PURE__ */ new Set();
+    for (const flow of file.flows) {
+      for (const moment of flow.moments) {
+        for (const node of moment.nodes)
+          names.add(node.nodeName);
+        for (const wb of moment.whenBlocks) {
+          for (const node of wb.nodes)
+            names.add(node.nodeName);
+        }
+      }
+    }
+    return names;
+  }
+  // =========================================================================
   // V17: returns-to depth capped at 1 -> warning
   // =========================================================================
   checkReturnsToDepth(flow, accept) {
@@ -60260,11 +60698,29 @@ var MomentValidator = class {
     }
   }
   // =========================================================================
+  // Registered cross-file entry points: no-ops unless a CrossFileContext has
+  // been set (single-file mode sets it only when the file declares contexts),
+  // so flow-only specs are never spammed with cross-file diagnostics.
+  // =========================================================================
+  checkFlowCrossFileRules(flow, accept) {
+    if (!this.crossFileContext)
+      return;
+    this.checkSP01(flow, accept, this.crossFileContext);
+  }
+  checkCrossingCrossFileRules(crossing, accept) {
+    if (!this.crossFileContext)
+      return;
+    this.checkSP02(crossing, accept, this.crossFileContext);
+  }
+  // =========================================================================
   // Cross-file validators (SP-01, SP-02, V1, V9, V11, V14)
   // =========================================================================
-  // SP-01: Flow lane references must match declared context names
+  // SP-01: Flow lane references must match declared context names.
+  // Branch-lanes are outcome routes (e.g. "Refusals"), not contexts — skipped.
   checkSP01(flow, accept, ctx) {
     for (const lane of flow.lanes) {
+      if (lane.isBranch)
+        continue;
       if (!ctx.declaredContextNames.includes(lane.label.replace(/^"|"$/g, ""))) {
         accept("error", "SP-01: Lane label does not match any declared context name.", {
           node: lane,
@@ -60273,7 +60729,11 @@ var MomentValidator = class {
       }
     }
   }
-  // SP-02: Crossing event names must be declared events in the target context
+  // SP-02: Crossing event names must be declared events on the boundary —
+  // in the source context (the emitter, the convention every shipped example
+  // follows) or in the target context (a consumer-side re-declaration).
+  // The original target-only rule flagged every crossing in the canonical
+  // examples, because events are declared once, in the emitting context.
   checkSP02(crossing, accept, ctx) {
     const flow = getFlowFromNode(crossing);
     if (!flow)
@@ -60281,23 +60741,27 @@ var MomentValidator = class {
     const targetLane = flow.lanes.find((l) => l.id === crossing.targetLaneId);
     if (!targetLane)
       return;
-    const contextName = targetLane.label.replace(/^"|"$/g, "");
-    const events = ctx.declaredEvents.get(contextName) ?? [];
     const parentNode = crossing.$container;
-    if (!events.includes(parentNode.nodeName)) {
-      accept("error", "SP-02: Crossing event is not declared in the target context.", {
+    const sourceLane = flow.lanes.find((l) => l.id === parentNode.laneId);
+    if (targetLane.isBranch || sourceLane?.isBranch)
+      return;
+    const declaredOnBoundary = [sourceLane, targetLane].some((lane) => laneDeclaresEvent(lane, parentNode.nodeName, ctx));
+    if (!declaredOnBoundary) {
+      accept("error", "SP-02: Crossing event is not declared in the source or target context.", {
         node: crossing,
         property: "targetLaneId"
       });
     }
   }
-  // V1: Node names must resolve to declared building blocks via lane context
+  // V1: Node names must resolve to declared building blocks via lane context.
+  // Branch-lane placements are skipped: those lanes route outcomes and do not
+  // correspond to a declared context.
   checkV1(node, accept, ctx) {
     const flow = getFlowFromNode(node);
     if (!flow)
       return;
     const lane = flow.lanes.find((l) => l.id === node.laneId);
-    if (!lane)
+    if (!lane || lane.isBranch)
       return;
     const contextName = lane.label.replace(/^"|"$/g, "");
     const blocks = ctx.declaredBuildingBlocks.get(contextName) ?? [];
@@ -60335,7 +60799,7 @@ var MomentValidator = class {
     if (!flow)
       return;
     const lane = flow.lanes.find((l) => l.id === node.laneId);
-    if (!lane)
+    if (!lane || lane.isBranch)
       return;
     const contextName = lane.label.replace(/^"|"$/g, "");
     const blocks = ctx.declaredBuildingBlocks.get(contextName) ?? [];
@@ -60355,7 +60819,7 @@ var MomentValidator = class {
     if (!flow)
       return;
     const lane = flow.lanes.find((l) => l.id === node.laneId);
-    if (!lane)
+    if (!lane || lane.isBranch)
       return;
     const contextName = lane.label.replace(/^"|"$/g, "");
     const blocks = ctx.declaredBuildingBlocks.get(contextName) ?? [];
@@ -60443,6 +60907,19 @@ var MomentValidator = class {
     }
     return labels;
   }
+  /** Earliest moment index at which each node name is placed in the flow. */
+  buildPlacementIndex(flow) {
+    const index = /* @__PURE__ */ new Map();
+    flow.moments.forEach((moment, momentIndex) => {
+      const record = (n) => {
+        if (!index.has(n.nodeName))
+          index.set(n.nodeName, momentIndex);
+      };
+      moment.nodes.forEach(record);
+      moment.whenBlocks.forEach((wb) => wb.nodes.forEach(record));
+    });
+    return index;
+  }
   collectPriorNodeNames(flow, currentMoment) {
     const names = /* @__PURE__ */ new Set();
     for (const moment of flow.moments) {
@@ -60544,26 +61021,31 @@ var MomentModule = {
 };
 
 // ../core/dist/parser/ast-to-ir.js
-function unquote(s) {
+function unquote2(s) {
   if (s.startsWith('"') && s.endsWith('"')) {
     return s.slice(1, -1);
   }
   return s;
 }
-function astToIr(file) {
+function astToIr(file, metadata) {
   const contexts = file.contexts.map(transformContext);
-  const flows = file.flows.map(transformFlow);
+  const nodeKindMap = buildNodeKindMap(contexts);
+  const flows = file.flows.map((flow) => transformFlow(flow, nodeKindMap));
   const relationships = file.contexts.flatMap(extractRelationships);
   return {
     contexts,
     flows,
     glossary: [],
     relationships,
-    metadata: { name: "", version: "0.0.0" }
+    metadata: {
+      name: metadata?.name ?? "",
+      version: metadata?.version ?? "0.0.0",
+      ...metadata?.description !== void 0 ? { description: metadata.description } : {}
+    }
   };
 }
 function transformContext(ctx) {
-  const name = unquote(ctx.name);
+  const name = unquote2(ctx.name);
   const aggregates = [];
   const domainServices = [];
   const policies = [];
@@ -60588,18 +61070,18 @@ function transformContext(ctx) {
       allValueObjects.push(...aggDef.valueObjects);
       allInvariants.push(...aggDef.invariants);
     } else if (isDomainServiceDeclaration(member)) {
-      domainServices.push(transformService(member));
+      domainServices.push(transformService(member, annotations));
     } else if (isPolicyDeclaration(member)) {
-      policies.push(transformPolicy(member));
+      policies.push(transformPolicy(member, annotations));
     } else if (isSagaDeclaration(member)) {
-      sagas.push(transformSaga(member));
+      sagas.push(transformSaga(member, annotations));
     }
   }
   return {
     id: `ctx-${name}`,
     name,
     classification: ctx.classification?.value,
-    description: ctx.description ? unquote(ctx.description) : void 0,
+    description: ctx.description ? unquote2(ctx.description) : void 0,
     aggregates,
     domainServices,
     commands: allCommands,
@@ -60614,11 +61096,11 @@ function transformAnnotation(ann) {
   const raw = ann.value;
   return {
     name: ann.name,
-    value: raw.startsWith('"') ? unquote(raw) : raw
+    value: raw.startsWith('"') ? unquote2(raw) : raw
   };
 }
 function transformAggregate(agg, annotations) {
-  const name = unquote(agg.name);
+  const name = unquote2(agg.name);
   const commands = [];
   const events = [];
   const valueObjects = [];
@@ -60638,7 +61120,7 @@ function transformAggregate(agg, annotations) {
     } else if (isValueObjectDeclaration(member)) {
       valueObjects.push(transformValueObject(member, memberAnnotations));
     } else if (isInvariantDeclaration(member)) {
-      invariants.push(transformInvariant(member));
+      invariants.push(transformInvariant(member, memberAnnotations));
     }
   }
   return {
@@ -60665,7 +61147,7 @@ function transformCommand(cmd, annotations) {
 function transformPrecondition(pre) {
   return {
     name: pre.name,
-    description: unquote(pre.description)
+    description: unquote2(pre.description)
   };
 }
 function transformEvent(evt, annotations) {
@@ -60693,62 +61175,104 @@ function transformFieldDeclaration(field) {
   };
   if ("deprecation" in field && field.deprecation) {
     result.deprecated = {
-      reason: unquote(field.deprecation.reason),
-      replacement: unquote(field.deprecation.replacement)
+      reason: unquote2(field.deprecation.reason),
+      replacement: unquote2(field.deprecation.replacement)
     };
   }
   return result;
 }
-function transformInvariant(inv) {
+function transformInvariant(inv, annotations) {
   return {
     id: inv.id,
-    description: unquote(inv.description),
-    scope: inv.scope
+    description: unquote2(inv.description),
+    scope: inv.scope,
+    ...annotations ? { annotations } : {}
   };
 }
-function transformService(svc) {
+function transformService(svc, annotations) {
   return {
     id: `svc-${svc.name}`,
     name: svc.name,
+    ...annotations ? { annotations } : {},
     consumes: svc.consumes,
     produces: svc.produces,
-    description: unquote(svc.description)
+    description: unquote2(svc.description)
   };
 }
-function transformPolicy(pol) {
+function transformPolicy(pol, annotations) {
   const trigger = pol.trigger.eventName ?? "file-watcher";
   return {
     id: `pol-${pol.name}`,
     name: pol.name,
+    ...annotations ? { annotations } : {},
     trigger,
-    action: unquote(pol.action),
+    action: unquote2(pol.action),
     chainsTo: pol.chainsTo ?? void 0
   };
 }
-function transformSaga(saga) {
+function transformSaga(saga, annotations) {
   const timeout = saga.timeout.duration ?? "none";
+  const states = [saga.initialState, ...saga.transitions.map((t) => t.target)];
+  const transitions = saga.transitions.map((t, i) => ({
+    from: states[i],
+    to: t.target,
+    ...t.event !== void 0 ? { onEvent: t.event } : {}
+  }));
   return {
     id: `saga-${saga.name}`,
     name: saga.name,
+    ...annotations ? { annotations } : {},
     trigger: saga.trigger,
-    states: saga.states,
-    compensation: unquote(saga.compensation),
+    states,
+    transitions,
+    compensation: unquote2(saga.compensation),
     timeout
   };
 }
 function buildLaneContextMap(flow) {
   const map2 = /* @__PURE__ */ new Map();
   for (const lane of flow.lanes) {
-    map2.set(lane.id, `ctx-${unquote(lane.label)}`);
+    map2.set(lane.id, `ctx-${unquote2(lane.label)}`);
+  }
+  return map2;
+}
+function buildNodeKindMap(contexts) {
+  const map2 = /* @__PURE__ */ new Map();
+  for (const ctx of contexts) {
+    for (const cmd of ctx.commands)
+      map2.set(cmd.name, "command");
+    for (const evt of ctx.events)
+      map2.set(evt.name, "event");
+    for (const policy of ctx.policies)
+      map2.set(policy.name, "policy");
+    for (const saga of ctx.sagas)
+      map2.set(saga.name, "saga");
+  }
+  return map2;
+}
+function buildNodeLaneMap(flow) {
+  const map2 = /* @__PURE__ */ new Map();
+  const record = (node) => {
+    if (!map2.has(node.nodeName)) {
+      map2.set(node.nodeName, node.laneId);
+    }
+  };
+  for (const moment of flow.moments) {
+    for (const node of moment.nodes)
+      record(node);
+    for (const when of moment.whenBlocks) {
+      for (const node of when.nodes)
+        record(node);
+    }
   }
   return map2;
 }
-function transformFlow(flow) {
-  const name = unquote(flow.name);
+function transformFlow(flow, nodeKindMap) {
+  const name = unquote2(flow.name);
   const laneContextMap = buildLaneContextMap(flow);
   const lanes = flow.lanes.map((lane) => ({
     id: lane.id,
-    label: unquote(lane.label),
+    label: unquote2(lane.label),
     contextId: laneContextMap.get(lane.id) ?? lane.id,
     classification: lane.classification?.value,
     isBranch: lane.isBranch ?? false
@@ -60756,47 +61280,58 @@ function transformFlow(flow) {
   return {
     id: `flow-${name}`,
     name,
-    description: flow.description ? unquote(flow.description) : void 0,
+    description: flow.description ? unquote2(flow.description) : void 0,
     lanes,
-    moments: flow.moments.map((moment, idx) => transformMoment(moment, idx, laneContextMap)),
+    moments: flow.moments.map((moment, idx) => transformMoment(moment, idx, laneContextMap, nodeKindMap)),
     connections: extractConnections(flow, laneContextMap)
   };
 }
-function transformMoment(moment, index, laneContextMap) {
-  const name = unquote(moment.label);
-  const contextEntries = moment.nodes.map((n) => transformNodeToEntry(n, laneContextMap));
-  const branches = moment.whenBlocks.length > 0 ? moment.whenBlocks.map((wb) => transformWhenBlock(wb, laneContextMap)) : void 0;
-  const hasTerminal = contextEntries.some((e) => e.terminal === true);
+function transformMoment(moment, index, laneContextMap, nodeKindMap) {
+  const name = unquote2(moment.label);
+  const contextEntries = moment.nodes.map((n) => transformNodeToEntry(n, laneContextMap, nodeKindMap));
+  const branches = moment.whenBlocks.length > 0 ? moment.whenBlocks.map((wb) => transformWhenBlock(wb, laneContextMap, nodeKindMap)) : void 0;
+  const hasTerminal = contextEntries.some((e) => e.terminal === true) || (branches?.some((b) => b.entries.some((e) => e.terminal === true)) ?? false);
   return {
     id: `moment-${index}-${name.replace(/\s+/g, "-")}`,
     name,
     contextEntries,
     branches,
-    terminal: hasTerminal || void 0
+    terminal: hasTerminal || void 0,
+    isBranch: moment.isBranch || void 0,
+    // Textual order of entries/branches from CST offsets (M-P13); falls back
+    // to entries-then-branches when the AST carries no CST.
+    sequence: buildMomentSequence(moment).sequence
   };
 }
-function transformWhenBlock(when, laneContextMap) {
+function transformWhenBlock(when, laneContextMap, nodeKindMap) {
   return {
     condition: when.condition,
     ...when.lane ? { lane: when.lane } : {},
-    entries: when.nodes.map((n) => transformNodeToEntry(n, laneContextMap))
+    entries: when.nodes.map((n) => transformNodeToEntry(n, laneContextMap, nodeKindMap))
   };
 }
-function transformNodeToEntry(node, laneContextMap) {
+function multiplicityOf(node) {
+  if (!node.multiplicity)
+    return void 0;
+  return node.multiplicity.count ?? node.multiplicity.countVar;
+}
+function transformNodeToEntry(node, laneContextMap, nodeKindMap) {
   const contextId = laneContextMap?.get(node.laneId) ?? node.laneId;
   const entry = {
     contextId,
     nodeName: node.nodeName,
-    nodeKind: "event"
-    // Default — kind resolution requires cross-file context (MMNT-27)
+    // Resolved from same-file context declarations; 'event' when the spec is
+    // flow-only and the kind is genuinely unknown (MMNT-27).
+    nodeKind: nodeKindMap?.get(node.nodeName) ?? "event"
   };
-  if (node.multiplicity) {
-    entry.multiplicity = node.multiplicity.count ?? node.multiplicity.countVar;
+  const multiplicity = multiplicityOf(node);
+  if (multiplicity !== void 0) {
+    entry.multiplicity = multiplicity;
   }
-  if (node.modifier?.type === "optional") {
+  const modifierType = node.modifier?.type;
+  if (modifierType === "optional") {
     entry.optional = true;
-  }
-  if (node.modifier?.type === "terminal") {
+  } else if (modifierType === "terminal") {
     entry.terminal = true;
   }
   return entry;
@@ -60805,10 +61340,21 @@ function extractConnections(flow, laneContextMap) {
   const connections = [];
   let connectionCounter = 0;
   const resolveCtx = (laneId) => laneContextMap?.get(laneId) ?? laneId;
+  const nodeLaneMap = buildNodeLaneMap(flow);
+  const resolveNodeCtx = (nodeName, fallbackLaneId) => {
+    const laneId = nodeLaneMap.get(nodeName) ?? fallbackLaneId;
+    return resolveCtx(laneId);
+  };
+  const momentLabelToId = /* @__PURE__ */ new Map();
+  for (let momentIdx = 0; momentIdx < flow.moments.length; momentIdx++) {
+    const label = unquote2(flow.moments[momentIdx].label);
+    momentLabelToId.set(label, `moment-${momentIdx}-${label.replace(/\s+/g, "-")}`);
+  }
   for (let momentIdx = 0; momentIdx < flow.moments.length; momentIdx++) {
     const moment = flow.moments[momentIdx];
-    const momentId = `moment-${momentIdx}-${unquote(moment.label).replace(/\s+/g, "-")}`;
-    const processNode = (node) => {
+    const momentId = `moment-${momentIdx}-${unquote2(moment.label).replace(/\s+/g, "-")}`;
+    const processNode = (node, branchCondition) => {
+      const branchFields = branchCondition ? { branchCondition } : {};
       if (node.crossing) {
         const contract = transformCrossingToContract(node);
         connections.push({
@@ -60816,8 +61362,10 @@ function extractConnections(flow, laneContextMap) {
           sourceMomentId: momentId,
           targetContextId: resolveCtx(node.crossing.targetLaneId),
           eventId: `evt-${node.nodeName}`,
+          sourceNodeName: node.nodeName,
           connectionType: "crosses-to",
-          schemaContract: contract
+          schemaContract: contract,
+          ...branchFields
         });
       }
       for (const conn of node.connections) {
@@ -60827,24 +61375,34 @@ function extractConnections(flow, laneContextMap) {
             sourceMomentId: momentId,
             targetContextId: resolveCtx(node.laneId),
             eventId: `evt-${conn.nodeName}`,
-            connectionType: "triggered-by"
+            sourceNodeName: conn.nodeName,
+            targetNodeName: node.nodeName,
+            connectionType: "triggered-by",
+            ...branchFields
           });
         } else if (isTriggers(conn)) {
           connections.push({
             id: `conn-${connectionCounter++}`,
             sourceMomentId: momentId,
-            targetContextId: resolveCtx(node.laneId),
+            targetContextId: resolveNodeCtx(conn.nodeName, node.laneId),
             eventId: `evt-${conn.nodeName}`,
-            connectionType: "triggers"
+            sourceNodeName: node.nodeName,
+            targetNodeName: conn.nodeName,
+            connectionType: "triggers",
+            ...branchFields
           });
         } else if (isReturnsTo(conn)) {
+          const targetLabel = unquote2(conn.frameLabel);
           connections.push({
             id: `conn-${connectionCounter++}`,
             sourceMomentId: momentId,
             targetContextId: resolveCtx(node.laneId),
             eventId: `evt-${node.nodeName}`,
+            sourceNodeName: node.nodeName,
             connectionType: "returns-to",
-            targetMomentLabel: unquote(conn.frameLabel)
+            targetMomentLabel: targetLabel,
+            ...momentLabelToId.has(targetLabel) ? { targetMomentId: momentLabelToId.get(targetLabel) } : {},
+            ...branchFields
           });
         }
       }
@@ -60854,7 +61412,7 @@ function extractConnections(flow, laneContextMap) {
     }
     for (const when of moment.whenBlocks) {
       for (const node of when.nodes) {
-        processNode(node);
+        processNode(node, when.condition);
       }
     }
   }
@@ -60879,10 +61437,11 @@ function extractRelationships(ctx) {
     if (isContextRelationshipDeclaration(member)) {
       const rel = member;
       relationships.push({
-        sourceContextId: rel.source,
-        targetContextId: rel.target,
+        // ctx- prefix matches ContextDefinition.id so consumers can join on id.
+        sourceContextId: `ctx-${rel.source}`,
+        targetContextId: `ctx-${rel.target}`,
         relationshipType: rel.type,
-        contract: unquote(rel.contract)
+        contract: unquote2(rel.contract)
       });
     }
   }
@@ -60890,6 +61449,11 @@ function extractRelationships(ctx) {
 }
 
 // ../core/dist/parser/moment-parser.js
+function specNameFromPath(filePath) {
+  const segments = filePath.split(/[/\\]/);
+  const base = segments[segments.length - 1];
+  return base.replace(/\.[^.]+$/, "");
+}
 var MomentParser = class {
   services;
   constructor() {
@@ -60900,7 +61464,20 @@ var MomentParser = class {
   }
   async parseContent(content, filePath) {
     const doc = this.services.shared.workspace.LangiumDocumentFactory.fromString(content, URI2.parse("memory:///parse.moment"));
-    await this.services.shared.workspace.DocumentBuilder.build([doc], { validation: true });
+    const ast = doc.parseResult.value;
+    const validator = this.services.validation.MomentValidator;
+    const declaresContexts = ast.contexts.length > 0;
+    const useCrossFileContext = declaresContexts && ast.flows.length > 0;
+    if (useCrossFileContext) {
+      validator.setCrossFileContext(buildCrossFileContext(ast));
+    }
+    try {
+      await this.services.shared.workspace.DocumentBuilder.build([doc], { validation: true });
+    } finally {
+      if (useCrossFileContext) {
+        validator.clearCrossFileContext();
+      }
+    }
     const file = filePath ?? "parse.moment";
     const diagnostics = [
       // Chevrotain lexer errors carry 1-based line/column when available.
@@ -60938,7 +61515,17 @@ var MomentParser = class {
     if (hasError) {
       return { success: false, diagnostics };
     }
-    const ir = astToIr(doc.parseResult.value);
+    const ir = astToIr(ast, filePath ? { name: specNameFromPath(filePath) } : void 0);
+    if (declaresContexts) {
+      const schemaResult = new SchemaValidator().validate(ir);
+      diagnostics.push(
+        ...schemaResult.diagnostics.map((d) => ({
+          severity: "warning",
+          message: d.message,
+          ruleId: d.ruleId
+        }))
+      );
+    }
     return { success: true, ir, diagnostics };
   }
 };
@@ -63007,18 +63594,48 @@ import { parseArgs as parseArgs2 } from "node:util";
 import { createHash as createHash2 } from "node:crypto";
 function deriveTopology(ir, derivedAt) {
   const ctxMap = new Map(ir.contexts.map((c) => [c.id, c]));
-  const suites = ir.flows.map((flow) => deriveTestSuite(flow, ctxMap));
+  const suites = ir.flows.map((flow, idx) => deriveTestSuite(flow, ctxMap, resolveSharedCaseFlow(ir.flows, ctxMap, idx)));
   const sourceIrHash = computeHash(ir);
   return {
     suites,
     metadata: { sourceIrHash, derivedAt: derivedAt ?? (/* @__PURE__ */ new Date()).toISOString() }
   };
 }
-function deriveTestSuite(flow, ctxMap) {
+function resolveSharedCaseFlow(flows, ctxMap, flowIdx) {
+  const sagas = /* @__PURE__ */ new Set();
+  const policies = /* @__PURE__ */ new Set();
+  const owningFlowIdx = (trigger) => {
+    const idx = flows.findIndex((f) => flowContainsNode(f, trigger));
+    return idx === -1 ? 0 : idx;
+  };
+  for (const [, ctx] of ctxMap) {
+    for (const saga of ctx.sagas) {
+      if (owningFlowIdx(saga.trigger) === flowIdx)
+        sagas.add(saga.id);
+    }
+    for (const pol of ctx.policies) {
+      if (pol.chainsTo && owningFlowIdx(pol.trigger) === flowIdx)
+        policies.add(pol.id);
+    }
+  }
+  return { sagas, policies };
+}
+function flowContainsNode(flow, nodeName) {
+  for (const moment of flow.moments) {
+    if (moment.contextEntries.some((e) => e.nodeName === nodeName))
+      return true;
+    for (const branch of moment.branches ?? []) {
+      if (branch.entries.some((e) => e.nodeName === nodeName))
+        return true;
+    }
+  }
+  return false;
+}
+function deriveTestSuite(flow, ctxMap, sharedCases) {
   const testCases = flow.moments.flatMap((moment) => deriveTestCases(moment, flow));
-  const sagaCases = deriveSagaTestCases(ctxMap);
+  const sagaCases = deriveSagaTestCases(ctxMap, sharedCases.sagas);
   testCases.push(...sagaCases);
-  const policyCases = derivePolicyChainTestCases(ctxMap);
+  const policyCases = derivePolicyChainTestCases(ctxMap, sharedCases.policies);
   testCases.push(...policyCases);
   return {
     flowId: flow.id,
@@ -63027,10 +63644,12 @@ function deriveTestSuite(flow, ctxMap) {
     contextsCovered: collectContextIds(flow)
   };
 }
-function deriveSagaTestCases(ctxMap) {
+function deriveSagaTestCases(ctxMap, assignedSagaIds) {
   const cases = [];
   for (const [, ctx] of ctxMap) {
     for (const saga of ctx.sagas) {
+      if (!assignedSagaIds.has(saga.id))
+        continue;
       cases.push(buildSagaInitCase(ctx, saga));
       cases.push(...buildSagaTransitionCases(ctx, saga));
       cases.push(buildSagaCompensationCase(ctx, saga));
@@ -63041,7 +63660,7 @@ function deriveSagaTestCases(ctxMap) {
 function buildSagaInitCase(ctx, saga) {
   return {
     momentId: `saga-${saga.name}-initiated`,
-    momentName: `Saga: ${saga.name} initiated`,
+    momentName: `saga ${saga.name} starts on ${saga.trigger}`,
     assertions: [{
       crossingId: `saga-init-${saga.name}`,
       sourceContext: ctx.id,
@@ -63057,7 +63676,7 @@ function buildSagaTransitionCases(ctx, saga) {
   for (let i = 0; i < saga.states.length - 1; i++) {
     cases.push({
       momentId: `saga-${saga.name}-${saga.states[i]}-to-${saga.states[i + 1]}`,
-      momentName: `Saga: ${saga.name} ${saga.states[i]} \u2192 ${saga.states[i + 1]}`,
+      momentName: `saga ${saga.name} transitions ${saga.states[i]} \u2192 ${saga.states[i + 1]}`,
       assertions: [{
         crossingId: `saga-transition-${saga.name}-${i}`,
         sourceContext: ctx.id,
@@ -63073,7 +63692,7 @@ function buildSagaTransitionCases(ctx, saga) {
 function buildSagaCompensationCase(ctx, saga) {
   return {
     momentId: `saga-${saga.name}-compensation`,
-    momentName: `Saga: ${saga.name} compensation`,
+    momentName: `saga ${saga.name} compensates via ${saga.compensation} after ${saga.timeout}`,
     assertions: [{
       crossingId: `saga-comp-${saga.name}`,
       sourceContext: ctx.id,
@@ -63084,15 +63703,17 @@ function buildSagaCompensationCase(ctx, saga) {
     setupSteps: [{ contextName: ctx.name, aggregateName: saga.name, precondition: saga.compensation }]
   };
 }
-function derivePolicyChainTestCases(ctxMap) {
+function derivePolicyChainTestCases(ctxMap, assignedPolicyIds) {
   const cases = [];
   for (const [, ctx] of ctxMap) {
     for (const pol of ctx.policies) {
       if (!pol.chainsTo)
         continue;
+      if (!assignedPolicyIds.has(pol.id))
+        continue;
       cases.push({
         momentId: `policy-${pol.name}`,
-        momentName: `Policy: ${pol.name}`,
+        momentName: `policy ${pol.name} chains ${pol.trigger} \u2192 ${pol.chainsTo}`,
         assertions: [{
           crossingId: `policy-chain-${pol.name}`,
           sourceContext: ctx.id,
@@ -63112,20 +63733,21 @@ function derivePolicyChainTestCases(ctxMap) {
 }
 function deriveTestCases(moment, flow) {
   const crossings = flow.connections.filter((c) => c.sourceMomentId === moment.id && c.connectionType === "crosses-to");
-  const assertions = crossings.map((conn) => mapCrossingToAssertion(conn, moment));
-  const baseCase = {
-    momentId: moment.id,
-    momentName: moment.name,
-    assertions,
-    setupSteps: []
-  };
   if (moment.branches && moment.branches.length > 0) {
     return moment.branches.map((branch) => ({
-      ...baseCase,
+      momentId: moment.id,
+      momentName: moment.name,
+      assertions: crossings.filter((c) => c.branchCondition === void 0 || c.branchCondition === branch.condition).map((conn) => mapCrossingToAssertion(conn, moment)),
+      setupSteps: [],
       variant: branch.condition
     }));
   }
-  return [baseCase];
+  return [{
+    momentId: moment.id,
+    momentName: moment.name,
+    assertions: crossings.map((conn) => mapCrossingToAssertion(conn, moment)),
+    setupSteps: []
+  }];
 }
 function mapCrossingToAssertion(conn, moment) {
   const sourceContextId = resolveSourceContextId(conn, moment);
@@ -63177,13 +63799,52 @@ function computeHash(ir) {
   return createHash2("sha256").update(JSON.stringify(ir)).digest("hex");
 }
 
+// ../derive/dist/engine/moment-children.js
+function orderedMomentChildren(moment, fallback) {
+  const entries = moment.contextEntries;
+  const branches = moment.branches ?? [];
+  const seq = moment.sequence;
+  if (seq && isUsableSequence(seq, entries.length, branches.length)) {
+    return seq.map((item) => item.kind === "entry" ? { kind: "entry", entry: entries[item.index], entryIndex: item.index } : { kind: "branch", branch: branches[item.index], branchIndex: item.index });
+  }
+  const entryChildren = entries.map((entry, i) => ({
+    kind: "entry",
+    entry,
+    entryIndex: i
+  }));
+  const branchChildren = branches.map((branch, i) => ({
+    kind: "branch",
+    branch,
+    branchIndex: i
+  }));
+  return fallback === "entries-first" ? [...entryChildren, ...branchChildren] : [...branchChildren, ...entryChildren];
+}
+function isUsableSequence(seq, entryCount, branchCount) {
+  if (seq.length !== entryCount + branchCount)
+    return false;
+  const seenEntries = /* @__PURE__ */ new Set();
+  const seenBranches = /* @__PURE__ */ new Set();
+  for (const item of seq) {
+    if (item.kind === "entry") {
+      if (item.index < 0 || item.index >= entryCount || seenEntries.has(item.index))
+        return false;
+      seenEntries.add(item.index);
+    } else {
+      if (item.index < 0 || item.index >= branchCount || seenBranches.has(item.index))
+        return false;
+      seenBranches.add(item.index);
+    }
+  }
+  return true;
+}
+
 // ../derive/dist/engine/simulation-scenario-generator.js
 function resolveNodeKind(nodeName, contextId, contextMap) {
   const ctx = contextMap.get(contextId);
   if (!ctx)
     return "event";
-  const isCommand2 = findCommand(ctx, nodeName) !== void 0;
-  if (isCommand2)
+  const isCommand = findCommand(ctx, nodeName) !== void 0;
+  if (isCommand)
     return "command";
   const isEvent = findEvent(ctx, nodeName) !== void 0;
   if (isEvent)
@@ -63203,17 +63864,31 @@ function resolveOptions(flow, options) {
 function generateSimulationScenario(ir, flow, options) {
   const opts = resolveOptions(flow, options);
   const contextMap = buildContextMap(ir);
-  const nodes = collectOrderedNodes(flow, opts.branchSelections);
-  const activeBranches = collectActiveBranches(flow, opts.branchSelections);
-  const rawEvents = generateEvents(nodes, flow, contextMap, ir, opts.sessionId, opts.correlationId, opts.baseTime);
+  const walk = walkPath(flow, opts.branchSelections);
+  const nodes = walk.nodes;
+  const seenActivations = /* @__PURE__ */ new Set();
+  const activeBranches = [];
+  for (const a of walk.activations) {
+    const key = `${a.momentName}\0${a.condition}`;
+    if (seenActivations.has(key))
+      continue;
+    seenActivations.add(key);
+    activeBranches.push({
+      momentName: a.momentName,
+      condition: a.condition,
+      routeChosen: a.condition
+    });
+  }
+  const rawEvents = generateEvents(nodes, flow, contextMap, opts.sessionId, opts.correlationId, opts.baseTime);
   const events = injectSagaTransitions(rawEvents, ir, opts.sessionId, opts.correlationId);
   const contextNames = [...new Set(nodes.map((n) => n.contextName))];
-  const label = resolveScenarioLabel(flow, opts.branchSelections);
+  const label = resolveScenarioLabel(flow, walk.reachedBranches);
   return {
     scenarioId: opts.scenarioId,
     flowId: flow.id,
     flowName: flow.name,
     scenarioLabel: label,
+    kind: resolveScenarioKind(walk.reachedBranches),
     description: flow.description ?? `Full lifecycle flow: ${flow.name}`,
     given: `A ${(flow.moments[0]?.name ?? "").toLowerCase()} scenario is initiated`,
     when: buildWhenClause(flow, nodes),
@@ -63228,105 +63903,184 @@ function generateAllScenarios(ir, flow, options) {
   if (combinations.length === 0) {
     return [generateSimulationScenario(ir, flow, options)];
   }
-  return combinations.map((selections, idx) => generateSimulationScenario(ir, flow, {
-    ...options,
-    scenarioId: options?.scenarioId ? `${options.scenarioId}-${idx}` : `scenario-${flow.id}-${idx}`,
-    branchSelections: selections
-  }));
+  const seenPaths = /* @__PURE__ */ new Set();
+  const scenarios = [];
+  for (const selections of combinations) {
+    const pathKey = walkPath(flow, selections).nodes.map((n) => n.nodeId).join("|");
+    if (seenPaths.has(pathKey))
+      continue;
+    seenPaths.add(pathKey);
+    const idx = scenarios.length;
+    scenarios.push(generateSimulationScenario(ir, flow, {
+      ...options,
+      scenarioId: options?.scenarioId ? `${options.scenarioId}-${idx}` : `scenario-${flow.id}-${idx}`,
+      branchSelections: selections
+    }));
+  }
+  return scenarios;
 }
 function enumerateBranchCombinations(flow) {
-  const branchPoints = flow.moments.filter((m) => m.branches && m.branches.length > 0);
-  if (branchPoints.length === 0)
+  const hasBranchPoints = flow.moments.some((m) => m.branches && m.branches.length > 0);
+  if (!hasBranchPoints)
     return [];
-  let combos = [{}];
-  for (const moment of branchPoints) {
-    const nextCombos = [];
-    for (const existing of combos) {
-      for (const branch of moment.branches) {
-        nextCombos.push({ ...existing, [moment.name]: branch.condition });
-      }
+  const results = [];
+  const expand = (selections) => {
+    const walk = walkPath(flow, selections);
+    const next = walk.reachedBranches.find((b) => !(b.momentName in selections));
+    if (!next) {
+      results.push(selections);
+      return;
     }
-    combos = nextCombos;
-  }
-  return combos;
+    const moment = flow.moments.find((m) => m.name === next.momentName);
+    for (const branch of moment?.branches ?? []) {
+      expand({ ...selections, [next.momentName]: branch.condition });
+    }
+  };
+  expand({});
+  return results;
 }
-function resolveScenarioLabel(flow, branchSelections) {
-  const branchMoments = flow.moments.filter((m) => m.branches && m.branches.length > 0);
-  if (branchMoments.length === 0)
-    return `Happy Path: ${flow.name}`;
-  const terminalConditions = collectTerminalConditions(branchMoments, branchSelections);
-  const isAllFirstBranch = checkAllFirstBranch(branchMoments, branchSelections);
-  if (isAllFirstBranch)
+function resolveScenarioLabel(flow, reachedBranches) {
+  const deviations = reachedBranches.filter((b) => !b.isFirstArm);
+  if (deviations.length === 0)
     return `Happy Path: ${flow.name}`;
-  if (terminalConditions.length > 0) {
-    return `Failure Path: ${flow.name} [${terminalConditions.join(", ")}]`;
-  }
-  const selectedConditions = branchMoments.map((m) => branchSelections[m.name]).filter(Boolean);
-  return `Variant: ${flow.name} [${selectedConditions.join(", ")}]`;
-}
-function collectTerminalConditions(branchMoments, branchSelections) {
-  const conditions = [];
-  for (const moment of branchMoments) {
-    const selected = branchSelections[moment.name];
-    if (!selected)
-      continue;
-    const branch = moment.branches.find((b) => b.condition === selected);
-    if (branch && branch.entries.some((e) => e.terminal)) {
-      conditions.push(selected);
-    }
-  }
-  return conditions;
+  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}]`;
 }
-function checkAllFirstBranch(branchMoments, branchSelections) {
-  for (const moment of branchMoments) {
-    const selected = branchSelections[moment.name];
-    const firstCondition = moment.branches[0]?.condition;
-    if (selected && selected !== firstCondition)
-      return false;
-  }
-  return true;
+function resolveScenarioKind(reachedBranches) {
+  const deviations = reachedBranches.filter((b) => !b.isFirstArm);
+  if (deviations.length === 0)
+    return "happy";
+  return deviations.some((b) => b.armHasTerminal) ? "failure" : "variant";
 }
 function buildContextMap(ir) {
   return new Map(ir.contexts.map((c) => [c.id, c]));
 }
-function collectOrderedNodes(flow, branchSelections) {
+function walkPath(flow, branchSelections) {
   const laneIndex = new Map(flow.lanes.map((l) => [l.contextId, l.id]));
-  const nodes = [];
-  for (let i = 0; i < flow.moments.length; i++) {
-    const moment = flow.moments[i];
-    const stopped = collectMomentNodes(nodes, moment, i, branchSelections, laneIndex);
-    if (stopped)
+  const momentIndexById = new Map(flow.moments.map((m, idx2) => [m.id, idx2]));
+  const returnsToCount = flow.connections.filter((c) => c.connectionType === "returns-to").length;
+  const maxMomentVisits = flow.moments.length * (returnsToCount + 2);
+  const state = {
+    nodes: [],
+    reachedBranches: [],
+    activations: [],
+    reachedNames: /* @__PURE__ */ new Set(),
+    forcedFirstArm: /* @__PURE__ */ new Set(),
+    usedReturns: /* @__PURE__ */ new Set()
+  };
+  let idx = 0;
+  let visits = 0;
+  while (idx < flow.moments.length && visits < maxMomentVisits) {
+    visits++;
+    const moment = flow.moments[idx];
+    const step = moment.branches && moment.branches.length > 0 ? walkBranchedMoment(moment, idx, flow, branchSelections, laneIndex, momentIndexById, state) : walkPlainMoment(moment, idx, laneIndex, state);
+    if (step.stop)
       break;
+    idx = step.jumpTo ?? idx + 1;
   }
-  return nodes;
+  return {
+    nodes: state.nodes,
+    reachedBranches: state.reachedBranches,
+    activations: state.activations
+  };
 }
-function collectMomentNodes(nodes, moment, momentIndex, branchSelections, laneIndex) {
-  if (moment.branches && moment.branches.length > 0) {
-    return collectBranchedMomentNodes(nodes, moment, momentIndex, branchSelections, laneIndex);
-  }
-  for (const entry of moment.contextEntries) {
-    nodes.push(entryToNode(entry, moment, momentIndex, laneIndex, "main"));
+function walkPlainMoment(moment, momentIndex, laneIndex, state) {
+  for (const child of orderedMomentChildren(moment, "entries-first")) {
+    if (child.kind !== "entry")
+      continue;
+    pushEntryNodes(state.nodes, child.entry, moment, momentIndex, laneIndex, "main", void 0);
+    if (child.entry.terminal)
+      return { stop: true };
+  }
+  return { stop: false };
+}
+function walkBranchedMoment(moment, momentIndex, flow, branchSelections, laneIndex, momentIndexById, state) {
+  const branches = moment.branches;
+  const { branch, forced } = selectBranch(moment, branchSelections, state);
+  if (!branch)
+    return walkPlainMoment(moment, momentIndex, laneIndex, state);
+  const branchIdx = branches.indexOf(branch);
+  recordBranchPoint(state, moment, branch, branchIdx, forced);
+  let emittedAny = false;
+  let branchEmitted = false;
+  for (const child of orderedMomentChildren(moment, "branches-first")) {
+    if (child.kind === "branch") {
+      if (branchEmitted)
+        continue;
+      branchEmitted = true;
+      const step = emitSelectedArm(moment, momentIndex, flow, branch, branchIdx, laneIndex, momentIndexById, state);
+      if (step)
+        return step;
+      if (branch.entries.length > 0)
+        emittedAny = true;
+    } else {
+      const outcome = emittedAny ? void 0 : branch.condition;
+      pushEntryNodes(state.nodes, child.entry, moment, momentIndex, laneIndex, "main", outcome);
+      emittedAny = true;
+      if (child.entry.terminal)
+        return { stop: true };
+    }
+  }
+  return { stop: false };
+}
+function selectBranch(moment, branchSelections, state) {
+  const branches = moment.branches;
+  const forced = state.forcedFirstArm.has(moment.name);
+  const selected = forced ? branches[0]?.condition : branchSelections[moment.name];
+  const branch = (selected ? branches.find((b) => b.condition === selected) : void 0) ?? branches[0];
+  return { branch, forced };
+}
+function recordBranchPoint(state, moment, branch, branchIdx, forced) {
+  state.activations.push({ momentName: moment.name, condition: branch.condition });
+  if (!forced && !state.reachedNames.has(moment.name)) {
+    state.reachedNames.add(moment.name);
+    state.reachedBranches.push({
+      momentName: moment.name,
+      condition: branch.condition,
+      isFirstArm: branchIdx === 0,
+      armHasTerminal: branch.entries.some((e) => e.terminal)
+    });
   }
-  return false;
 }
-function collectBranchedMomentNodes(nodes, moment, momentIndex, branchSelections, laneIndex) {
-  const selectedCondition = branchSelections[moment.name];
-  const branch = selectedCondition ? moment.branches.find((b) => b.condition === selectedCondition) : moment.branches[0];
-  let hitTerminal = false;
-  if (branch) {
-    const branchIdx = moment.branches.indexOf(branch);
-    for (const entry of branch.entries) {
-      nodes.push(entryToNode(entry, moment, momentIndex, laneIndex, `br${branchIdx}`));
-      if (entry.terminal)
-        hitTerminal = true;
+function emitSelectedArm(moment, momentIndex, flow, branch, branchIdx, laneIndex, momentIndexById, state) {
+  for (const entry of branch.entries) {
+    pushEntryNodes(state.nodes, entry, moment, momentIndex, laneIndex, `br${branchIdx}`, branch.condition);
+    if (entry.terminal)
+      return { stop: true };
+  }
+  const returnsTo = findReturnsToConnection(flow, moment, branch);
+  if (returnsTo?.targetMomentId !== void 0 && !state.usedReturns.has(returnsTo.id)) {
+    const targetIdx = momentIndexById.get(returnsTo.targetMomentId);
+    if (targetIdx !== void 0) {
+      state.usedReturns.add(returnsTo.id);
+      state.forcedFirstArm.add(moment.name);
+      return { stop: false, jumpTo: targetIdx };
     }
   }
-  for (const entry of moment.contextEntries) {
-    nodes.push(entryToNode(entry, moment, momentIndex, laneIndex, "main"));
+  return null;
+}
+function findReturnsToConnection(flow, moment, branch) {
+  return flow.connections.find((c) => c.connectionType === "returns-to" && c.sourceMomentId === moment.id && (c.branchCondition === branch.condition || c.branchCondition === void 0 && branch.entries.some((e) => e.nodeName === c.sourceNodeName)));
+}
+function pushEntryNodes(nodes, entry, moment, momentIndex, laneIndex, scope, outcome) {
+  const count = resolveMultiplicity(entry.multiplicity);
+  for (let k = 0; k < count; k++) {
+    nodes.push(entryToNode(entry, moment, momentIndex, laneIndex, scope, outcome));
+  }
+}
+function resolveMultiplicity(multiplicity) {
+  if (typeof multiplicity === "number" && Number.isFinite(multiplicity) && multiplicity > 1) {
+    return Math.floor(multiplicity);
+  }
+  if (typeof multiplicity === "string" && /^\d+$/.test(multiplicity)) {
+    const n = parseInt(multiplicity, 10);
+    if (n > 1)
+      return n;
   }
-  return hitTerminal;
+  return 1;
 }
-function entryToNode(entry, moment, momentIndex, laneIndex, scope) {
+function entryToNode(entry, moment, momentIndex, laneIndex, scope, outcome) {
   const contextName = entry.contextId.replace(/^ctx-/, "");
   const laneId = laneIndex.get(entry.contextId) ?? entry.contextId;
   return {
@@ -63336,42 +64090,24 @@ function entryToNode(entry, moment, momentIndex, laneIndex, scope) {
     contextName,
     nodeKind: entry.nodeKind,
     momentName: moment.name,
-    momentIndex
+    momentId: moment.id,
+    momentIndex,
+    ...outcome !== void 0 ? { outcome } : {}
   };
 }
-function collectActiveBranches(flow, branchSelections) {
-  const branches = [];
-  for (const moment of flow.moments) {
-    if (moment.branches && moment.branches.length > 0) {
-      const selected = branchSelections[moment.name] ?? moment.branches[0]?.condition;
-      if (selected) {
-        branches.push({
-          momentName: moment.name,
-          condition: selected,
-          routeChosen: selected
-        });
-      }
-    }
-  }
-  return branches;
-}
-function generateEvents(nodes, flow, contextMap, ir, sessionId, correlationId, baseTime) {
+function generateEvents(nodes, flow, contextMap, sessionId, correlationId, baseTime) {
   const events = [];
-  const nodeToEventId = /* @__PURE__ */ new Map();
-  let eventCounter = 0;
+  const eventIds = nodes.map((_, i) => `evt-${String(i + 1).padStart(3, "0")}`);
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
-    eventCounter++;
-    const eventId = `evt-${String(eventCounter).padStart(3, "0")}`;
-    nodeToEventId.set(node.nodeId, eventId);
     const timestamp = new Date(baseTime.getTime() + i * 1e3).toISOString();
-    const causationEventIds = findCausationEvents(node, nodes, flow, nodeToEventId, i);
+    const causationEventIds = findCausationEvents(node, nodes, flow, eventIds, i);
     const effectiveKind = resolveNodeKind(node.nodeName, node.contextId, contextMap);
     const eventType = resolveEventType(node, effectiveKind);
     const productSource = resolveProductSource(node, effectiveKind, contextMap);
-    const payload = buildPayload(node, effectiveKind, contextMap, ir);
+    const payload = buildPayload(node, effectiveKind, contextMap, flow);
     events.push({
-      eventId,
+      eventId: eventIds[i],
       eventType,
       productSource,
       sessionId,
@@ -63384,34 +64120,40 @@ function generateEvents(nodes, flow, contextMap, ir, sessionId, correlationId, b
   }
   return events;
 }
-function findCausationEvents(node, allNodes, flow, nodeToEventId, currentIndex) {
+function findCausationEvents(node, allNodes, flow, eventIds, currentIndex) {
   const causation = [];
   for (const conn of flow.connections) {
-    if (conn.connectionType === "triggered-by") {
-      addTriggeredByCausation(conn, allNodes, nodeToEventId, currentIndex, causation);
-    }
+    if (!isCausationConnectionFor(conn, node))
+      continue;
+    const triggerName = conn.sourceNodeName ?? conn.eventId.replace(/^evt-/, "");
+    const causeId = findLatestPriorEmission(triggerName, allNodes, eventIds, currentIndex);
+    if (causeId !== void 0)
+      causation.push(causeId);
   }
-  if (causation.length === 0 && currentIndex > 0) {
-    const prevNode = allNodes[currentIndex - 1];
-    const prevEvtId = nodeToEventId.get(prevNode.nodeId);
-    if (prevEvtId)
-      causation.push(prevEvtId);
+  const deduped = [...new Set(causation)];
+  if (deduped.length === 0 && currentIndex > 0) {
+    deduped.push(eventIds[currentIndex - 1]);
   }
-  return causation;
+  return deduped;
 }
-function addTriggeredByCausation(conn, allNodes, nodeToEventId, currentIndex, causation) {
-  const triggerNodeName = conn.eventId.replace(/^evt-/, "");
-  const currentNodeInMoment = allNodes.some((n, idx) => idx === currentIndex && n.nodeName === triggerNodeName);
-  if (currentNodeInMoment)
-    return;
+function isCausationConnectionFor(conn, node) {
+  if (conn.connectionType !== "triggered-by")
+    return false;
+  if (conn.targetNodeName !== node.nodeName)
+    return false;
+  if (conn.sourceMomentId !== node.momentId)
+    return false;
+  if (conn.branchCondition !== void 0 && conn.branchCondition !== node.outcome)
+    return false;
+  return true;
+}
+function findLatestPriorEmission(triggerName, allNodes, eventIds, currentIndex) {
   for (let j = currentIndex - 1; j >= 0; j--) {
-    if (allNodes[j].nodeName === triggerNodeName) {
-      const evtId = nodeToEventId.get(allNodes[j].nodeId);
-      if (evtId)
-        causation.push(evtId);
-      break;
+    if (allNodes[j].nodeName === triggerName) {
+      return eventIds[j];
     }
   }
+  return void 0;
 }
 function resolveEventType(node, effectiveKind) {
   if (effectiveKind === "command") {
@@ -63431,99 +64173,112 @@ function resolveProductSource(node, effectiveKind, contextMap) {
   }
   return "moment:simulation";
 }
-function buildPayload(node, effectiveKind, contextMap, ir) {
+function buildPayload(node, effectiveKind, contextMap, flow) {
   const payload = {
     nodeId: node.nodeId
   };
   const ctx = contextMap.get(node.contextId);
-  if (!ctx)
-    return payload;
-  if (effectiveKind === "command") {
-    return buildCommandPayload(payload, ctx, node);
-  }
-  if (effectiveKind === "event") {
-    return buildEventPayload(payload, ctx, node);
-  }
-  return payload;
-}
-function buildCommandPayload(payload, ctx, node) {
-  payload.processName = node.nodeName;
-  const cmd = findCommand(ctx, node.nodeName);
+  const cmd = ctx && effectiveKind === "command" ? findCommand(ctx, node.nodeName) : void 0;
+  const evt = ctx && effectiveKind === "event" ? findEvent(ctx, node.nodeName) : void 0;
   if (cmd) {
+    payload.processName = node.nodeName;
     for (const input of cmd.inputs) {
       payload[input.name] = generatePlaceholder(input.type, input.name);
     }
+  } else if (evt) {
+    for (const field of evt.fields) {
+      payload[field.name] = generatePlaceholder(field.type, field.name);
+    }
+  }
+  addContractFields(payload, node, flow);
+  if (node.outcome !== void 0) {
+    payload.outcome = node.outcome;
   }
   return payload;
 }
-function buildEventPayload(payload, ctx, node) {
-  const evt = findEvent(ctx, node.nodeName);
-  if (evt) {
-    for (const field of evt.fields) {
+function addContractFields(payload, node, flow) {
+  for (const conn of flow.connections) {
+    if (conn.connectionType !== "crosses-to")
+      continue;
+    if (conn.sourceNodeName !== node.nodeName)
+      continue;
+    if (!("schemaContract" in conn))
+      continue;
+    for (const field of conn.schemaContract.fields) {
+      if (field.name in payload)
+        continue;
       payload[field.name] = generatePlaceholder(field.type, field.name);
     }
   }
-  return payload;
 }
 function injectSagaTransitions(events, ir, sessionId, correlationId) {
-  const sagaIndex = buildSagaIndex(ir);
-  if (sagaIndex.size === 0)
+  const sagas = collectSagas(ir);
+  if (sagas.length === 0 || events.length === 0)
     return events;
-  const result = [];
-  const sagaProgress = /* @__PURE__ */ new Map();
-  let eventCounter = events.length;
-  for (const event of events) {
-    result.push(event);
-    const matchingSagas = sagaIndex.get(event.eventType);
-    if (!matchingSagas)
-      continue;
-    for (const saga of matchingSagas) {
-      eventCounter++;
-      const sagaEvent = buildSagaEvent(saga, sagaProgress, event, eventCounter, sessionId, correlationId);
-      if (sagaEvent)
-        result.push(sagaEvent);
+  const sagaEvents = [];
+  const lastPathTime = new Date(events[events.length - 1].timestamp).getTime();
+  for (const saga of sagas) {
+    for (const step of computeSagaProgression(saga, events)) {
+      const eventCounter = events.length + sagaEvents.length + 1;
+      const timestamp = new Date(lastPathTime + (sagaEvents.length + 1) * 1e3).toISOString();
+      sagaEvents.push({
+        eventId: `evt-${String(eventCounter).padStart(3, "0")}`,
+        eventType: `SimSaga.${saga.name}.${step.state}`,
+        productSource: "moment:simulation",
+        sessionId,
+        causationEventIds: [step.cause.eventId],
+        correlationId,
+        timestamp,
+        version: 1,
+        payload: {
+          sagaName: saga.name,
+          state: step.state,
+          triggeredBy: step.cause.eventType
+        }
+      });
     }
   }
-  return result;
+  return [...events, ...sagaEvents];
 }
-function buildSagaIndex(ir) {
-  const index = /* @__PURE__ */ new Map();
-  for (const ctx of ir.contexts) {
-    for (const saga of ctx.sagas) {
-      const existing = index.get(saga.trigger) ?? [];
-      existing.push(saga);
-      index.set(saga.trigger, existing);
-    }
+function collectSagas(ir) {
+  return ir.contexts.flatMap((ctx) => ctx.sagas);
+}
+function computeSagaProgression(saga, events) {
+  if (saga.states.length === 0)
+    return [];
+  const triggerIdx = events.findIndex((e) => e.eventType === saga.trigger);
+  if (triggerIdx === -1)
+    return [];
+  const steps = [{ state: saga.states[0], cause: events[triggerIdx] }];
+  let cursor = triggerIdx;
+  for (const transition of sagaTransitionChain(saga)) {
+    if (!transition.onEvent)
+      break;
+    const fireIdx = findEventAfter(events, transition.onEvent, cursor);
+    if (fireIdx === -1)
+      break;
+    steps.push({ state: transition.to, cause: events[fireIdx] });
+    cursor = fireIdx;
   }
-  return index;
+  return steps;
 }
-function buildSagaEvent(saga, sagaProgress, triggerEvent, eventCounter, sessionId, correlationId) {
-  const currentIdx = sagaProgress.get(saga.name) ?? 0;
-  if (currentIdx >= saga.states.length)
-    return null;
-  const nextState = saga.states[currentIdx];
-  sagaProgress.set(saga.name, currentIdx + 1);
-  return {
-    eventId: `evt-${String(eventCounter).padStart(3, "0")}`,
-    eventType: `SimSaga.${saga.name}.${nextState}`,
-    productSource: "moment:simulation",
-    sessionId,
-    causationEventIds: [triggerEvent.eventId],
-    correlationId,
-    timestamp: triggerEvent.timestamp,
-    version: 1,
-    payload: {
-      sagaName: saga.name,
-      state: nextState,
-      triggeredBy: triggerEvent.eventType
-    }
-  };
+function sagaTransitionChain(saga) {
+  return saga.transitions ?? [];
+}
+function findEventAfter(events, eventType, afterIndex) {
+  for (let i = afterIndex + 1; i < events.length; i++) {
+    if (events[i].eventType === eventType)
+      return i;
+  }
+  return -1;
 }
 function deriveNegativeScenarios(ir, flow, options) {
   const contextMap = buildContextMap(ir);
   const opts = resolveOptions(flow, options);
-  const nodes = collectOrderedNodes(flow, opts.branchSelections);
+  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);
@@ -63531,7 +64286,11 @@ function deriveNegativeScenarios(ir, flow, options) {
       continue;
     const preconditions = findPreconditions(node, contextMap);
     for (const pre of preconditions) {
-      scenarios.push(buildNegativeScenario(ir, flow, nodes, i, pre, contextMap, opts));
+      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));
     }
   }
   return scenarios;
@@ -63543,23 +64302,41 @@ function findPreconditions(node, contextMap) {
   const cmd = findCommand(ctx, node.nodeName);
   return cmd?.preconditions ?? [];
 }
-function buildNegativeScenario(ir, flow, allNodes, failIndex, precondition, contextMap, opts) {
+function buildNegativeScenario(ir, flow, walk, failIndex, precondition, contextMap, opts, scenarioId) {
+  const allNodes = walk.nodes;
   const precedingNodes = allNodes.slice(0, failIndex + 1);
   const failNode = allNodes[failIndex];
-  const events = generateEvents(precedingNodes, flow, contextMap, ir, opts.sessionId, opts.correlationId, opts.baseTime);
+  const reachedMoments = new Set(precedingNodes.map((n) => n.momentName));
+  const seenActivations = /* @__PURE__ */ new Set();
+  const activeBranches = [];
+  for (const a of walk.activations) {
+    if (!reachedMoments.has(a.momentName))
+      continue;
+    const key = `${a.momentName} ${a.condition}`;
+    if (seenActivations.has(key))
+      continue;
+    seenActivations.add(key);
+    activeBranches.push({
+      momentName: a.momentName,
+      condition: a.condition,
+      routeChosen: a.condition
+    });
+  }
+  const events = generateEvents(precedingNodes, flow, contextMap, opts.sessionId, opts.correlationId, opts.baseTime);
   const failureEvent = buildFailureEvent(failNode, precondition, events, opts);
-  const allEvents = [...events, failureEvent];
+  const allEvents = injectSagaTransitions([...events, failureEvent], ir, opts.sessionId, opts.correlationId);
   return {
-    scenarioId: `${opts.scenarioId}-neg-${failNode.nodeName}-${precondition.name}`,
+    scenarioId,
     flowId: flow.id,
     flowName: flow.name,
     scenarioLabel: `Failure: ${precondition.description} not met`,
+    kind: "negative",
     description: `Negative scenario: ${precondition.description} precondition violation at ${failNode.nodeName}`,
     given: `A ${(flow.moments[0]?.name ?? "").toLowerCase()} scenario is initiated`,
     when: `${failNode.nodeName} is invoked without satisfying ${precondition.name}`,
     then: `The command ${failNode.nodeName} is rejected`,
     expectedPath: precedingNodes.map((n) => n.nodeId),
-    activeBranches: [],
+    activeBranches,
     events: allEvents
   };
 }
@@ -63582,6 +64359,111 @@ function buildFailureEvent(failNode, precondition, precedingEvents, opts) {
     }
   };
 }
+function deriveTimeoutScenarios(ir, flow, options) {
+  const opts = resolveOptions(flow, options);
+  const contextMap = buildContextMap(ir);
+  const scenarios = [];
+  for (const saga of collectSagas(ir)) {
+    if (saga.timeout === "none" || saga.timeout === "")
+      continue;
+    if (saga.states.length === 0)
+      continue;
+    const owner = ir.flows.find((f) => flowContainsNodeName(f, saga.trigger)) ?? ir.flows[0];
+    if (!owner || owner.id !== flow.id)
+      continue;
+    const scenario = buildTimeoutScenario(flow, saga, contextMap, opts);
+    if (scenario)
+      scenarios.push(scenario);
+  }
+  return scenarios;
+}
+function flowContainsNodeName(flow, nodeName) {
+  for (const moment of flow.moments) {
+    if (moment.contextEntries.some((e) => e.nodeName === nodeName))
+      return true;
+    for (const branch of moment.branches ?? []) {
+      if (branch.entries.some((e) => e.nodeName === nodeName))
+        return true;
+    }
+  }
+  return false;
+}
+function buildTimeoutScenario(flow, saga, contextMap, opts) {
+  const walk = walkPath(flow, {});
+  const triggerIdx = walk.nodes.findIndex((n) => n.nodeName === saga.trigger);
+  if (triggerIdx === -1)
+    return null;
+  const nodes = truncateAfterTriggerMoment(walk.nodes, triggerIdx);
+  const pathEvents = generateEvents(nodes, flow, contextMap, opts.sessionId, opts.correlationId, opts.baseTime);
+  const events = appendTimeoutMarkers(pathEvents, saga, triggerIdx, opts);
+  const activeBranches = collectTruncatedActiveBranches(walk.activations, nodes);
+  const hasCompensation = saga.compensation !== "none" && saga.compensation !== "";
+  const lastMomentName = nodes[nodes.length - 1]?.momentName ?? flow.name;
+  return {
+    scenarioId: `${opts.scenarioId}-timeout-${saga.name}`,
+    flowId: flow.id,
+    flowName: flow.name,
+    scenarioLabel: `Timeout: ${flow.name} [${saga.name}.${saga.timeout}]`,
+    kind: "timeout",
+    description: `Timeout scenario: saga ${saga.name} timeout ${saga.timeout} elapses after ${saga.trigger}; the domain flow stops at ${lastMomentName}`,
+    given: `A ${(flow.moments[0]?.name ?? "").toLowerCase()} scenario is initiated`,
+    when: `Saga ${saga.name} timeout ${saga.timeout} elapses after ${saga.trigger}`,
+    then: hasCompensation ? `Saga ${saga.name} times out and compensates: ${saga.compensation}` : `Saga ${saga.name} times out`,
+    expectedPath: nodes.map((n) => n.nodeId),
+    activeBranches,
+    events
+  };
+}
+function truncateAfterTriggerMoment(walkNodes, triggerIdx) {
+  let cut = triggerIdx;
+  while (cut + 1 < walkNodes.length && walkNodes[cut + 1].momentId === walkNodes[triggerIdx].momentId) {
+    cut++;
+  }
+  return walkNodes.slice(0, cut + 1);
+}
+function collectTruncatedActiveBranches(activations, nodes) {
+  const includedMoments = new Set(nodes.map((n) => n.momentName));
+  const seenActivations = /* @__PURE__ */ new Set();
+  const activeBranches = [];
+  for (const a of activations) {
+    if (!includedMoments.has(a.momentName))
+      continue;
+    const key = `${a.momentName} ${a.condition}`;
+    if (seenActivations.has(key))
+      continue;
+    seenActivations.add(key);
+    activeBranches.push({ momentName: a.momentName, condition: a.condition, routeChosen: a.condition });
+  }
+  return activeBranches;
+}
+function appendTimeoutMarkers(pathEvents, saga, triggerIdx, opts) {
+  const lastPathTime = pathEvents.length > 0 ? new Date(pathEvents[pathEvents.length - 1].timestamp).getTime() : opts.baseTime.getTime();
+  const markers = [];
+  const push = (eventType, payload, causeEventId) => {
+    const counter = pathEvents.length + markers.length + 1;
+    const marker = {
+      eventId: `evt-${String(counter).padStart(3, "0")}`,
+      eventType,
+      productSource: "moment:simulation",
+      sessionId: opts.sessionId,
+      causationEventIds: causeEventId ? [causeEventId] : [],
+      correlationId: opts.correlationId,
+      timestamp: new Date(lastPathTime + (markers.length + 1) * 1e3).toISOString(),
+      version: 1,
+      payload
+    };
+    markers.push(marker);
+    return marker;
+  };
+  const triggerEvent = pathEvents[triggerIdx];
+  const initialState = saga.states[0];
+  const initial = push(`SimSaga.${saga.name}.${initialState}`, { sagaName: saga.name, state: initialState, triggeredBy: triggerEvent?.eventType ?? saga.trigger }, triggerEvent?.eventId);
+  const timedOut = push(`SimSaga.${saga.name}.TimedOut`, { timeoutName: saga.timeout }, initial.eventId);
+  if (saga.compensation !== "none" && saga.compensation !== "") {
+    push(`SimSaga.${saga.name}.Compensated`, { description: saga.compensation }, timedOut.eventId);
+  }
+  return [...pathEvents, ...markers];
+}
 function findCommand(ctx, name) {
   const topLevel = ctx.commands.find((c) => c.name === name);
   if (topLevel)
@@ -63632,6 +64514,30 @@ function buildThenClause(flow, nodes, contextNames) {
   return `The flow completes at ${lastNode?.momentName ?? "end"} across ${contextNames.join(", ")}`;
 }
 
+// ../derive/dist/engine/policy-definitions-generator.js
+function generatePolicyDefinitions(ir) {
+  const definitions = [];
+  for (const context of ir.contexts) {
+    for (const policy of context.policies) {
+      definitions.push({
+        name: policy.name,
+        contextId: context.id,
+        trigger: policy.trigger,
+        ...policy.action ? { actionDescription: policy.action } : {},
+        chainsTo: normalizeChainsTo(policy.chainsTo)
+      });
+    }
+  }
+  return definitions;
+}
+function normalizeChainsTo(chainsTo) {
+  if (chainsTo === void 0 || chainsTo === null)
+    return [];
+  if (Array.isArray(chainsTo))
+    return chainsTo.filter((c) => typeof c === "string");
+  return [chainsTo];
+}
+
 // ../derive/dist/engine/event-catalog-generator.js
 function generateEventCatalog(ir) {
   const entries = [];
@@ -63643,6 +64549,7 @@ function generateEventCatalog(ir) {
       }
     }
   }
+  addFlowFallbackEntries(ir, entries);
   return {
     events: entries,
     metadata: {
@@ -63651,12 +64558,94 @@ function generateEventCatalog(ir) {
     }
   };
 }
+function allMomentEntries(flow) {
+  const out = [];
+  for (let i = 0; i < flow.moments.length; i++) {
+    const moment = flow.moments[i];
+    for (const entry of entriesInSequenceOrder(moment)) {
+      out.push({ entry, momentName: moment.name, momentIndex: i });
+    }
+  }
+  return out;
+}
+function entriesInSequenceOrder(moment) {
+  const entries = [];
+  for (const child of orderedMomentChildren(moment, "entries-first")) {
+    if (child.kind === "entry") {
+      entries.push(child.entry);
+    } else {
+      entries.push(...child.branch.entries);
+    }
+  }
+  return entries;
+}
+function contextDisplayName(contextId, ir) {
+  const ctx = ir.contexts.find((c) => c.id === contextId);
+  return ctx?.name ?? contextId.replace(/^ctx-/, "");
+}
+function addFlowFallbackEntries(ir, entries) {
+  const known = new Set(entries.map((e) => e.eventName));
+  for (const flow of ir.flows) {
+    for (const { entry, momentName, momentIndex } of allMomentEntries(flow)) {
+      if (known.has(entry.nodeName))
+        continue;
+      known.add(entry.nodeName);
+      entries.push(buildFlowEntry(entry, momentName, momentIndex, ir));
+    }
+  }
+}
+function buildFlowEntry(entry, momentName, momentIndex, ir) {
+  const contractFields = [];
+  const consumers = [];
+  const seenConsumers = /* @__PURE__ */ new Set();
+  let producerCommand = "";
+  for (const flow of ir.flows) {
+    for (const conn of flow.connections) {
+      const connEventName = conn.eventId.replace(/^evt-/, "");
+      if (conn.connectionType === "crosses-to" && connEventName === entry.nodeName) {
+        recordCrossingConsumer(conn, ir, contractFields, consumers, seenConsumers);
+      }
+      if (conn.connectionType === "triggers" && conn.targetNodeName === entry.nodeName && conn.sourceNodeName && producerCommand === "") {
+        producerCommand = conn.sourceNodeName;
+      }
+    }
+  }
+  return {
+    eventName: entry.nodeName,
+    kind: entry.nodeKind,
+    schema: { fields: contractFields },
+    producer: {
+      context: contextDisplayName(entry.contextId, ir),
+      aggregate: "",
+      command: producerCommand
+    },
+    consumers,
+    temporalLocation: { moment: momentName, momentIndex }
+  };
+}
+function recordCrossingConsumer(conn, ir, contractFields, consumers, seenConsumers) {
+  if (contractFields.length === 0) {
+    for (const f of conn.schemaContract.fields) {
+      contractFields.push({ name: f.name, type: f.type, isArray: false });
+    }
+  }
+  const consumerName = contextDisplayName(conn.targetContextId, ir);
+  const key = `${consumerName}|${conn.schemaContract.relationshipType}`;
+  if (!seenConsumers.has(key)) {
+    seenConsumers.add(key);
+    consumers.push({
+      context: consumerName,
+      relationshipType: conn.schemaContract.relationshipType
+    });
+  }
+}
 function buildCatalogEntry(event, aggregate, context, ir) {
   const producer = findProducerCommand(event, aggregate, context);
   const consumers = findConsumers(event, ir);
   const temporalLocation = findTemporalLocation(event, ir);
   return {
     eventName: event.name,
+    kind: "event",
     schema: {
       fields: event.fields.map((f) => ({
         name: f.name,
@@ -63690,13 +64679,14 @@ function findConsumers(event, ir) {
       const targetCtx = ir.contexts.find((c) => c.id === conn.targetContextId);
       if (!targetCtx)
         continue;
-      const key = `${targetCtx.name}|${conn.connectionType}`;
+      const relationshipType = conn.schemaContract.relationshipType;
+      const key = `${targetCtx.name}|${relationshipType}`;
       if (seen.has(key))
         continue;
       seen.add(key);
       consumers.push({
         context: targetCtx.name,
-        relationshipType: conn.connectionType
+        relationshipType
       });
     }
   }
@@ -63706,7 +64696,7 @@ function findTemporalLocation(event, ir) {
   for (const flow of ir.flows) {
     for (let i = 0; i < flow.moments.length; i++) {
       const moment = flow.moments[i];
-      for (const entry of moment.contextEntries) {
+      for (const entry of entriesInSequenceOrder(moment)) {
         if (entry.nodeKind === "event" && entry.nodeName === event.name) {
           return { moment: moment.name, momentIndex: i };
         }
@@ -63730,9 +64720,10 @@ function generateImpactAnalysis(ir) {
   for (const context of ir.contexts) {
     addCommandNodes(context, nodeMap);
     addEventNodes(context, nodeMap);
-    addPolicyNodes(context, nodeMap);
-    addSagaNodes(context, nodeMap);
+    addPolicyNodes(context, nodeMap, ir);
+    addSagaNodes(context, nodeMap, ir);
   }
+  addFlowNodes(ir, nodeMap);
   addCrossingNodes(ir, nodeMap);
   const nodes = Array.from(nodeMap.values()).map((n) => ({
     type: n.type,
@@ -63777,59 +64768,145 @@ function addEventNodes(context, nodeMap) {
     }
   }
 }
-function addPolicyNodes(context, nodeMap) {
+function findDeclaringContextForEvent(eventName, ir) {
+  for (const ctx of ir.contexts) {
+    if (ctx.events.some((e) => e.name === eventName))
+      return ctx;
+    for (const agg of ctx.aggregates) {
+      if (agg.events.some((e) => e.name === eventName))
+        return ctx;
+    }
+  }
+  return void 0;
+}
+function findDeclaringContextForCommand(commandName, ir) {
+  for (const ctx of ir.contexts) {
+    if (ctx.commands.some((c) => c.name === commandName))
+      return ctx;
+    for (const agg of ctx.aggregates) {
+      if (agg.commands.some((c) => c.name === commandName))
+        return ctx;
+    }
+  }
+  return void 0;
+}
+function addPolicyNodes(context, nodeMap, ir) {
   for (const policy of context.policies) {
     const policyNode = getOrCreate(nodeMap, "policy", policy.name, context.name);
     if (policy.trigger) {
-      const evtNode = getOrCreate(nodeMap, "event", policy.trigger, context.name);
-      policyNode.dependsOn.push(nodeKey("event", policy.trigger, context.name));
+      const evtCtxName = (findDeclaringContextForEvent(policy.trigger, ir) ?? context).name;
+      const evtNode = getOrCreate(nodeMap, "event", policy.trigger, evtCtxName);
+      policyNode.dependsOn.push(nodeKey("event", policy.trigger, evtCtxName));
       evtNode.triggers.push(nodeKey("policy", policy.name, context.name));
     }
     if (policy.chainsTo) {
-      const cmdNode = getOrCreate(nodeMap, "command", policy.chainsTo, context.name);
-      policyNode.triggers.push(nodeKey("command", policy.chainsTo, context.name));
+      const cmdCtxName = (findDeclaringContextForCommand(policy.chainsTo, ir) ?? context).name;
+      const cmdNode = getOrCreate(nodeMap, "command", policy.chainsTo, cmdCtxName);
+      policyNode.triggers.push(nodeKey("command", policy.chainsTo, cmdCtxName));
       cmdNode.dependsOn.push(nodeKey("policy", policy.name, context.name));
     }
   }
 }
-function addSagaNodes(context, nodeMap) {
+function addSagaNodes(context, nodeMap, ir) {
   for (const saga of context.sagas) {
     const sagaNode = getOrCreate(nodeMap, "saga", saga.name, context.name);
     if (saga.trigger) {
-      const evtNode = getOrCreate(nodeMap, "event", saga.trigger, context.name);
-      sagaNode.dependsOn.push(nodeKey("event", saga.trigger, context.name));
+      const evtCtxName = (findDeclaringContextForEvent(saga.trigger, ir) ?? context).name;
+      const evtNode = getOrCreate(nodeMap, "event", saga.trigger, evtCtxName);
+      sagaNode.dependsOn.push(nodeKey("event", saga.trigger, evtCtxName));
       evtNode.triggers.push(nodeKey("saga", saga.name, context.name));
     }
   }
 }
+function contextDisplayName2(contextId, ir) {
+  const ctx = ir.contexts.find((c) => c.id === contextId);
+  return ctx?.name ?? contextId.replace(/^ctx-/, "");
+}
+function addFlowNodes(ir, nodeMap) {
+  for (const flow of ir.flows) {
+    addFlowMomentNodes(flow, nodeMap, ir);
+    addFlowTriggerEdges(flow, nodeMap);
+  }
+}
+function addFlowMomentNodes(flow, nodeMap, ir) {
+  for (const moment of flow.moments) {
+    const entries = [
+      ...moment.contextEntries,
+      ...(moment.branches ?? []).flatMap((b) => b.entries)
+    ];
+    for (const entry of entries) {
+      getOrCreate(nodeMap, entry.nodeKind, entry.nodeName, contextDisplayName2(entry.contextId, ir));
+    }
+  }
+}
+function addFlowTriggerEdges(flow, nodeMap) {
+  for (const conn of flow.connections) {
+    if (conn.connectionType !== "triggers" && conn.connectionType !== "triggered-by")
+      continue;
+    if (!conn.sourceNodeName || !conn.targetNodeName)
+      continue;
+    const cause = findNodeByName(nodeMap, conn.sourceNodeName);
+    const effect = findNodeByName(nodeMap, conn.targetNodeName);
+    if (!cause || !effect)
+      continue;
+    const causeKey = nodeKey(cause.type, cause.name, cause.context);
+    const effectKey = nodeKey(effect.type, effect.name, effect.context);
+    if (!cause.triggers.includes(effectKey))
+      cause.triggers.push(effectKey);
+    if (!effect.dependsOn.includes(causeKey))
+      effect.dependsOn.push(causeKey);
+  }
+}
+function findNodeByName(nodeMap, name) {
+  for (const node of nodeMap.values()) {
+    if (node.name === name)
+      return node;
+  }
+  return void 0;
+}
 function addCrossingNodes(ir, nodeMap) {
   for (const flow of ir.flows) {
     for (const conn of flow.connections) {
       if (conn.connectionType !== "crosses-to")
         continue;
-      const sourceCtx = findSourceContextForEvent(conn.eventId, ir);
-      const targetCtx = ir.contexts.find((c) => c.id === conn.targetContextId);
-      if (!sourceCtx || !targetCtx)
-        continue;
-      const eventName = resolveEventName(conn.eventId, ir);
-      if (!eventName)
-        continue;
-      const crossingName = `${eventName}->${targetCtx.name}`;
-      const crossingNode = getOrCreate(nodeMap, "crossing", crossingName, sourceCtx.name);
-      const evtKey = nodeKey("event", eventName, sourceCtx.name);
-      if (!crossingNode.dependsOn.includes(evtKey)) {
-        crossingNode.dependsOn.push(evtKey);
-      }
-      const evtNode = nodeMap.get(evtKey);
-      if (evtNode) {
-        const crossKey = nodeKey("crossing", crossingName, sourceCtx.name);
-        if (!evtNode.triggers.includes(crossKey)) {
-          evtNode.triggers.push(crossKey);
-        }
-      }
+      addCrossingNode(conn, flow, nodeMap, ir);
     }
   }
 }
+function addCrossingNode(conn, flow, nodeMap, ir) {
+  const eventName = resolveEventName(conn.eventId, ir) ?? conn.schemaContract.eventType;
+  if (!eventName)
+    return;
+  const sourceCtx = findSourceContextForEvent(conn.eventId, ir);
+  const sourceCtxName = sourceCtx?.name ?? findProducingEntryContext(eventName, conn.sourceMomentId, flow, ir);
+  if (!sourceCtxName)
+    return;
+  const targetCtxName = contextDisplayName2(conn.targetContextId, ir);
+  const crossingName = `${eventName}->${targetCtxName}`;
+  const crossingNode = getOrCreate(nodeMap, "crossing", crossingName, sourceCtxName);
+  const evtKey = nodeKey("event", eventName, sourceCtxName);
+  if (!crossingNode.dependsOn.includes(evtKey)) {
+    crossingNode.dependsOn.push(evtKey);
+  }
+  const evtNode = nodeMap.get(evtKey);
+  if (evtNode) {
+    const crossKey = nodeKey("crossing", crossingName, sourceCtxName);
+    if (!evtNode.triggers.includes(crossKey)) {
+      evtNode.triggers.push(crossKey);
+    }
+  }
+}
+function findProducingEntryContext(eventName, sourceMomentId, flow, ir) {
+  const moment = flow.moments.find((m) => m.id === sourceMomentId);
+  if (!moment)
+    return void 0;
+  const entries = [
+    ...moment.contextEntries,
+    ...(moment.branches ?? []).flatMap((b) => b.entries)
+  ];
+  const producing = entries.find((e) => e.nodeName === eventName);
+  return producing ? contextDisplayName2(producing.contextId, ir) : void 0;
+}
 function findSourceContextForEvent(eventId, ir) {
   for (const ctx of ir.contexts) {
     if (ctx.events.some((e) => e.id === eventId))
@@ -63873,9 +64950,8 @@ function buildStateMachine(saga, contextName) {
   const initialState = sagaStates.length > 0 ? sagaStates[0] : "";
   const finalState = sagaStates.length > 0 ? sagaStates[sagaStates.length - 1] : "";
   const states = buildStates(sagaStates, initialState, finalState);
-  const transitions = buildTransitions(sagaStates);
+  const transitions = buildTransitions(saga);
   const reachability = computeReachability(states, transitions, initialState);
-  const earlyExitStates = sagaStates.filter((s) => s !== initialState && s !== finalState);
   return {
     sagaName: saga.name,
     context: contextName,
@@ -63885,7 +64961,6 @@ function buildStateMachine(saga, contextName) {
     transitions,
     compensation: saga.compensation,
     timeout: saga.timeout,
-    earlyExitStates,
     reachability
   };
 }
@@ -63896,7 +64971,15 @@ function buildStates(stateNames, initialState, finalState) {
     isFinal: name === finalState
   }));
 }
-function buildTransitions(stateNames) {
+function buildTransitions(saga) {
+  if (saga.transitions) {
+    return saga.transitions.map((t) => ({
+      from: t.from,
+      to: t.to,
+      ...t.onEvent !== void 0 ? { onEvent: t.onEvent } : {}
+    }));
+  }
+  const stateNames = saga.states;
   const transitions = [];
   for (let i = 0; i < stateNames.length - 1; i++) {
     transitions.push({
@@ -63977,15 +65060,14 @@ function buildFrames(flow, ctxMap, laneIndex) {
 }
 function buildFrameNodes(moment, ctxMap, laneIndex) {
   const nodes = [];
-  let branchIdx = 0;
-  for (const entry of moment.contextEntries) {
-    nodes.push(entryToNode2(entry, moment, ctxMap, laneIndex, "main"));
-  }
-  for (const branch of moment.branches ?? []) {
-    for (const entry of branch.entries) {
-      nodes.push(entryToNode2(entry, moment, ctxMap, laneIndex, `br${branchIdx}`));
+  for (const child of orderedMomentChildren(moment, "entries-first")) {
+    if (child.kind === "entry") {
+      nodes.push(entryToNode2(child.entry, moment, ctxMap, laneIndex, "main"));
+    } else {
+      for (const entry of child.branch.entries) {
+        nodes.push(entryToNode2(entry, moment, ctxMap, laneIndex, `br${child.branchIndex}`));
+      }
     }
-    branchIdx++;
   }
   return nodes;
 }
@@ -64031,15 +65113,43 @@ function findAggregate(nodeName, ctx) {
 }
 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 {
+        from: conn.sourceMomentId,
+        to: conn.targetContextId,
+        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 ? conn.eventId.replace(/^evt-/, "") : void 0,
+      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
+      schemaContract: isCrossing2 ? mapSchemaContract(conn) : void 0,
+      ...endpoints
     };
   });
 }
@@ -64069,7 +65179,6 @@ function mapSchemaContract(conn) {
 function buildEventRouting(flow, ctxMap, laneIndex) {
   const routing = {};
   for (const moment of flow.moments) {
-    let branchIdx = 0;
     const addEntry = (entry, scope) => {
       const ctx = ctxMap.get(entry.contextId);
       const kind = resolveNodeKind2(entry, ctx);
@@ -64088,14 +65197,14 @@ function buildEventRouting(flow, ctxMap, laneIndex) {
         routing[key] = existing;
       }
     };
-    for (const entry of moment.contextEntries) {
-      addEntry(entry, "main");
-    }
-    for (const branch of moment.branches ?? []) {
-      for (const entry of branch.entries) {
-        addEntry(entry, `br${branchIdx}`);
+    for (const child of orderedMomentChildren(moment, "entries-first")) {
+      if (child.kind === "entry") {
+        addEntry(child.entry, "main");
+      } else {
+        for (const entry of child.branch.entries) {
+          addEntry(entry, `br${child.branchIndex}`);
+        }
       }
-      branchIdx++;
     }
   }
   const result = {};
@@ -64111,8 +65220,7 @@ function buildBranchPredicates(flow) {
       continue;
     const routes = {};
     for (const branch of moment.branches) {
-      const hasTerminal = branch.entries.some((e) => e.terminal);
-      routes[branch.condition] = hasTerminal ? "terminal" : "happy";
+      routes[branch.condition] = branch.condition;
     }
     predicates[moment.id] = {
       field: "outcome",
@@ -64124,7 +65232,8 @@ function buildBranchPredicates(flow) {
 }
 function buildContextMap2(flow, ctxMap) {
   const contexts = buildBoundedContexts(flow, ctxMap);
-  const relationships = buildContextRelationships(flow);
+  const known = new Set(contexts.map((c) => c.contextId));
+  const relationships = buildContextRelationships(flow).filter((r) => known.has(r.sourceContextId) && known.has(r.targetContextId));
   return { contexts, relationships };
 }
 function buildBoundedContexts(flow, ctxMap) {
@@ -64176,8 +65285,7 @@ function collectContextIds2(flow) {
       ids.add(entry.contextId);
     for (const branch of moment.branches ?? []) {
       for (const entry of branch.entries) {
-        if (!entry.terminal)
-          ids.add(entry.contextId);
+        ids.add(entry.contextId);
       }
     }
   }
@@ -64213,6 +65321,7 @@ function renderFeatureHeader(lines, flow, ir) {
 }
 function renderMomentsByContext(lines, flow, ir, ctxMap) {
   const contextGroups = groupMomentsByContext(flow);
+  const ownedSagaIds = collectOwnedSagaIds(flow, ir);
   for (const [ctxId, moments] of contextGroups) {
     const ctx = ctxMap.get(ctxId);
     const ctxName = ctx?.name ?? ctxId.replace(/^ctx-/, "");
@@ -64230,51 +65339,83 @@ function renderMomentsByContext(lines, flow, ir, ctxMap) {
         renderScenario(lines, moment, moment.contextEntries, flow, ctxMap, ir, void 0, sharedPreconditions);
       }
     }
-    renderSagaScenarios(lines, ctxId, ir);
+    renderSagaScenarios(lines, ctxId, ir, ownedSagaIds);
   }
+  renderOrphanOwnedSagas(lines, ir, contextGroups, ownedSagaIds);
 }
 function renderScenario(lines, moment, entries, flow, ctxMap, ir, variant, sharedPreconditions = /* @__PURE__ */ new Set()) {
   const label = variant ? `${moment.name} [${variant}]` : moment.name;
-  const tags = buildScenarioTags(entries, flow, ctxMap, ir, variant);
+  const tags = buildScenarioTags(entries, moment, void 0, flow, ctxMap, ir);
   if (tags.length > 0)
     lines.push(`    ${tags.join(" ")}`);
   lines.push(`    Scenario: ${label}`);
-  for (const entry of entries) {
-    renderEntrySteps(lines, entry, flow, ctxMap, sharedPreconditions);
+  const steps = [];
+  const usedConnections = /* @__PURE__ */ new Set();
+  for (const entry of orderedMainEntries(moment)) {
+    renderEntrySteps(steps, entry, moment, void 0, flow, ctxMap, sharedPreconditions, usedConnections);
   }
+  promoteLeadingAnd(steps);
+  lines.push(...steps);
   lines.push("");
 }
 function renderBranchScenario(lines, moment, condition, branchEntries, flow, ctxMap, ir, sharedPreconditions = /* @__PURE__ */ new Set()) {
   const isTerminal = branchEntries.some((e) => e.terminal);
   if (isTerminal) {
-    renderTerminalBranchScenario(lines, moment, condition, flow, ctxMap, ir);
+    renderTerminalBranchScenario(lines, moment, condition, branchEntries, flow, ctxMap, ir);
     return;
   }
   const allEntries = [...moment.contextEntries, ...branchEntries];
-  const tags = buildScenarioTags(allEntries, flow, ctxMap, ir, condition);
+  const tags = buildScenarioTags(allEntries, moment, condition, flow, ctxMap, ir);
+  const returnsTo = findReturnsTo(moment, condition, flow);
   if (!tags.includes("@failure-path"))
-    tags.push("@happy-path");
+    tags.push(returnsTo ? "@retry-path" : "@alt-path");
   if (tags.length > 0)
     lines.push(`    ${tags.join(" ")}`);
   lines.push(`    Scenario: ${moment.name} [${condition}]`);
-  for (const entry of allEntries) {
-    renderEntrySteps(lines, entry, flow, ctxMap, sharedPreconditions);
-  }
+  const steps = buildBranchScenarioSteps(moment, condition, branchEntries, flow, ctxMap, sharedPreconditions);
+  if (returnsTo) {
+    const targetLabel = resolveReturnsToLabel(returnsTo, flow);
+    if (targetLabel)
+      steps.push(`      Then the flow returns to "${targetLabel}"`);
+  }
+  promoteLeadingAnd(steps);
+  lines.push(...steps);
   lines.push("");
 }
-function renderTerminalBranchScenario(lines, moment, condition, flow, ctxMap, ir) {
+function buildBranchScenarioSteps(moment, condition, branchEntries, flow, ctxMap, sharedPreconditions) {
+  const steps = [];
+  const usedConnections = /* @__PURE__ */ new Set();
+  for (const child of orderedMomentChildren2(moment)) {
+    if (child.kind === "entry") {
+      renderEntrySteps(steps, child.entry, moment, void 0, flow, ctxMap, sharedPreconditions, usedConnections);
+    } else if (child.branch.condition === condition && child.branch.entries === branchEntries) {
+      for (const entry of child.branch.entries) {
+        renderEntrySteps(steps, entry, moment, condition, flow, ctxMap, sharedPreconditions, usedConnections);
+      }
+    }
+  }
+  return steps;
+}
+function renderTerminalBranchScenario(lines, moment, condition, branchEntries, flow, ctxMap, ir) {
   const tags = ["@terminal", "@failure-path"];
   lines.push(`    ${tags.join(" ")}`);
   lines.push(`    Scenario: ${moment.name} [${condition}]`);
-  const failedPrecondition = findFailedPrecondition(moment, condition, ctxMap);
+  const failedPrecondition = findFailedPrecondition(moment, ctxMap);
+  lines.push(`      Given the ${moment.name.toLowerCase()} is evaluated`);
   if (failedPrecondition) {
-    lines.push(`      Given the ${moment.name.toLowerCase()} is evaluated`);
     lines.push(`      When ${failedPrecondition.name} is not satisfied`);
-    lines.push(`      Then the flow terminates because ${failedPrecondition.description}`);
   } else {
-    lines.push(`      Given the ${moment.name.toLowerCase()} is evaluated`);
     lines.push(`      When the outcome is ${condition}`);
-    lines.push(`      Then the flow terminates`);
+  }
+  const usedConnections = /* @__PURE__ */ new Set();
+  for (const entry of branchEntries) {
+    renderEntrySteps(lines, entry, moment, condition, flow, ctxMap, /* @__PURE__ */ new Set(), usedConnections);
+  }
+  if (failedPrecondition) {
+    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 compensation = findCompensationForMoment(moment, ir);
   if (compensation) {
@@ -64282,10 +65423,10 @@ function renderTerminalBranchScenario(lines, moment, condition, flow, ctxMap, ir
   }
   lines.push("");
 }
-function buildScenarioTags(entries, flow, ctxMap, ir, variant) {
+function buildScenarioTags(entries, moment, branchCondition, flow, ctxMap, ir) {
   const tags = [];
   collectAggregateTags(entries, ctxMap, tags);
-  if (entries.some((e) => findCrossing(e, flow)))
+  if (entries.some((e) => findCrossing(e, moment, branchCondition, flow)))
     tags.push("@crossing");
   collectPolicyTags(entries, ctxMap, tags);
   collectSagaTags(entries, ir, tags);
@@ -64334,16 +65475,16 @@ function collectInvariantTags(entries, ctxMap, tags) {
     }
   }
 }
-function renderEntrySteps(lines, entry, flow, ctxMap, sharedPreconditions = /* @__PURE__ */ new Set()) {
+function renderEntrySteps(lines, entry, moment, branchCondition, flow, ctxMap, sharedPreconditions = /* @__PURE__ */ new Set(), usedConnections = /* @__PURE__ */ new Set()) {
   const ctx = ctxMap.get(entry.contextId);
   const ctxName = entry.contextId.replace(/^ctx-/, "");
-  if (isCommand(entry.nodeName, ctx)) {
-    renderCommandStep(lines, entry, ctx, ctxName, flow, sharedPreconditions);
+  if (entry.nodeKind === "command") {
+    renderCommandStep(lines, entry, ctx, ctxName, moment, flow, sharedPreconditions);
   } else {
-    renderEventStep(lines, entry, ctx, ctxName, flow);
+    renderEventStep(lines, entry, ctx, ctxName, moment, branchCondition, flow, usedConnections);
   }
 }
-function renderCommandStep(lines, entry, ctx, ctxName, flow, sharedPreconditions = /* @__PURE__ */ new Set()) {
+function renderCommandStep(lines, entry, ctx, ctxName, moment, flow, sharedPreconditions = /* @__PURE__ */ new Set()) {
   const cmd = findCommand2(ctx, entry.nodeName);
   if (cmd) {
     for (const pre of cmd.preconditions) {
@@ -64352,7 +65493,7 @@ function renderCommandStep(lines, entry, ctx, ctxName, flow, sharedPreconditions
       }
     }
   }
-  const trigger = findTriggeredBy(entry, flow);
+  const trigger = findTriggeredBy(entry, moment, flow);
   if (trigger) {
     lines.push(`      And ${trigger} has occurred`);
   }
@@ -64380,9 +65521,10 @@ function renderInternalEventStep(lines, entry, evt, ctxName) {
     lines.push(`        carrying ${evt.fields.map((f) => f.name).join(", ")}`);
   }
 }
-function renderEventStep(lines, entry, ctx, ctxName, flow) {
-  const crossing = findCrossing(entry, flow);
+function renderEventStep(lines, entry, ctx, ctxName, moment, branchCondition, flow, usedConnections = /* @__PURE__ */ new Set()) {
+  const crossing = findCrossing(entry, moment, branchCondition, flow, usedConnections);
   if (crossing) {
+    usedConnections.add(crossing.id);
     renderCrossingStep(lines, entry, crossing);
   } else {
     renderInternalEventStep(lines, entry, findEvent2(ctx, entry.nodeName), ctxName);
@@ -64435,15 +65577,51 @@ function renderBackgroundBlock(lines, sharedPreconditions) {
   }
   lines.push("");
 }
-function renderSagaScenarios(lines, ctxId, ir) {
+function collectOwnedSagaIds(flow, ir) {
+  const owned = /* @__PURE__ */ new Set();
+  for (const ctx of ir.contexts) {
+    for (const saga of ctx.sagas) {
+      const owner = ir.flows.find((f) => flowContainsNode2(f, saga.trigger)) ?? ir.flows[0];
+      if (owner && owner.id === flow.id)
+        owned.add(saga.id);
+    }
+  }
+  return owned;
+}
+function flowContainsNode2(flow, nodeName) {
+  for (const moment of flow.moments) {
+    if (momentContainsNode(moment, nodeName))
+      return true;
+  }
+  return false;
+}
+function renderSagaScenarios(lines, ctxId, ir, ownedSagaIds) {
   const ctx = ir.contexts.find((c) => c.id === ctxId);
   if (!ctx)
     return;
   for (const saga of ctx.sagas) {
+    if (!ownedSagaIds.has(saga.id))
+      continue;
     renderSagaTransitionScenario(lines, saga);
     renderSagaCompensationScenario(lines, saga);
   }
 }
+function renderOrphanOwnedSagas(lines, ir, contextGroups, ownedSagaIds) {
+  for (const ctx of ir.contexts) {
+    if (contextGroups.has(ctx.id))
+      continue;
+    const owned = ctx.sagas.filter((s) => ownedSagaIds.has(s.id));
+    if (owned.length === 0)
+      continue;
+    const classification = ctx.classification ? ` [${ctx.classification}]` : "";
+    lines.push(`  Rule: ${ctx.name}${classification}`);
+    lines.push("");
+    for (const saga of owned) {
+      renderSagaTransitionScenario(lines, saga);
+      renderSagaCompensationScenario(lines, saga);
+    }
+  }
+}
 function renderSagaTransitionScenario(lines, saga) {
   lines.push(`    @saga:${saga.name}`);
   lines.push(`    Scenario: ${saga.name} state transitions`);
@@ -64459,17 +65637,14 @@ function renderSagaCompensationScenario(lines, saga) {
   lines.push(`      Then ${saga.compensation} is executed`);
   lines.push("");
 }
-function findFailedPrecondition(moment, _condition, ctxMap) {
-  if (!moment.branches)
-    return void 0;
-  const nonTerminalBranches = moment.branches.filter((b) => !b.entries.some((e) => e.terminal));
-  for (const branch of nonTerminalBranches) {
-    for (const entry of branch.entries) {
-      const ctx = ctxMap.get(entry.contextId);
-      const cmd = findCommand2(ctx, entry.nodeName);
-      if (cmd && cmd.preconditions.length > 0) {
-        return cmd.preconditions[0];
-      }
+function findFailedPrecondition(moment, ctxMap) {
+  for (const entry of moment.contextEntries) {
+    if (entry.nodeKind !== "command")
+      continue;
+    const ctx = ctxMap.get(entry.contextId);
+    const cmd = findCommand2(ctx, entry.nodeName);
+    if (cmd && cmd.preconditions.length > 0) {
+      return cmd.preconditions[0];
     }
   }
   return void 0;
@@ -64489,10 +65664,47 @@ function findCompensationForMoment(moment, ir) {
   }
   return void 0;
 }
-function isCommand(name, ctx) {
-  if (!ctx)
+function orderedMomentChildren2(moment) {
+  const entries = moment.contextEntries;
+  const branches = moment.branches ?? [];
+  const seq = moment.sequence;
+  if (seq && isUsableSequence2(seq, entries.length, branches.length)) {
+    return seq.map((item) => item.kind === "entry" ? { kind: "entry", entry: entries[item.index] } : { kind: "branch", branch: branches[item.index] });
+  }
+  return [
+    ...entries.map((entry) => ({ kind: "entry", entry })),
+    ...branches.map((branch) => ({ kind: "branch", branch }))
+  ];
+}
+function isUsableSequence2(seq, entryCount, branchCount) {
+  if (seq.length !== entryCount + branchCount)
     return false;
-  return ctx.commands.some((c) => c.name === name);
+  const seenEntries = /* @__PURE__ */ new Set();
+  const seenBranches = /* @__PURE__ */ new Set();
+  for (const item of seq) {
+    const max = item.kind === "entry" ? entryCount : branchCount;
+    const seen = item.kind === "entry" ? seenEntries : seenBranches;
+    if (item.index < 0 || item.index >= max || seen.has(item.index))
+      return false;
+    seen.add(item.index);
+  }
+  return true;
+}
+function orderedMainEntries(moment) {
+  const out = [];
+  for (const child of orderedMomentChildren2(moment)) {
+    if (child.kind === "entry")
+      out.push(child.entry);
+  }
+  return out;
+}
+function promoteLeadingAnd(steps) {
+  if (steps.length === 0)
+    return;
+  const first2 = steps[0];
+  if (first2.trimStart().startsWith("And ")) {
+    steps[0] = first2.replace("And ", "Given ");
+  }
 }
 function findCommand2(ctx, name) {
   if (!ctx)
@@ -64532,19 +65744,36 @@ function momentContainsNode(moment, nodeName) {
   }
   return false;
 }
-function findTriggeredBy(entry, flow) {
+function findTriggeredBy(entry, moment, flow) {
   for (const conn of flow.connections) {
     if (conn.connectionType !== "triggered-by")
       continue;
     const triggerEventName = conn.eventId.replace(/^evt-/, "");
-    const moment = flow.moments.find((m) => m.id === conn.sourceMomentId);
-    if (moment && momentContainsNode(moment, entry.nodeName))
-      return triggerEventName;
+    if (conn.targetNodeName) {
+      if (conn.sourceMomentId === moment.id && conn.targetNodeName === entry.nodeName) {
+        return triggerEventName;
+      }
+    } else {
+      const owner = flow.moments.find((m) => m.id === conn.sourceMomentId);
+      if (owner && momentContainsNode(owner, entry.nodeName))
+        return triggerEventName;
+    }
   }
   return void 0;
 }
-function findCrossing(entry, flow) {
-  return flow.connections.find((c) => c.connectionType === "crosses-to" && c.eventId === `evt-${entry.nodeName}`);
+function findCrossing(entry, moment, branchCondition, flow, usedConnections = /* @__PURE__ */ new Set()) {
+  return flow.connections.find((c) => c.connectionType === "crosses-to" && c.sourceMomentId === moment.id && (c.sourceNodeName ? c.sourceNodeName === entry.nodeName : c.eventId === `evt-${entry.nodeName}`) && (c.branchCondition === void 0 || c.branchCondition === branchCondition) && !usedConnections.has(c.id));
+}
+function findReturnsTo(moment, branchCondition, flow) {
+  return flow.connections.find((c) => c.connectionType === "returns-to" && c.sourceMomentId === moment.id && (c.branchCondition === void 0 || c.branchCondition === branchCondition));
+}
+function resolveReturnsToLabel(conn, flow) {
+  if (conn.targetMomentId) {
+    const target = flow.moments.find((m) => m.id === conn.targetMomentId);
+    if (target)
+      return target.name;
+  }
+  return "targetMomentLabel" in conn ? conn.targetMomentLabel : void 0;
 }
 function collectFlowContextIds(flow) {
   const ids = /* @__PURE__ */ new Set();
@@ -64713,8 +65942,9 @@ var SpecificationDocumentGenerator = class {
   }
   renderMomentNarrative(lines, moment, step, flow, ir) {
     this.renderMomentHeader(lines, moment, step, flow, ir);
+    const usedConnections = /* @__PURE__ */ new Set();
     for (const entry of moment.contextEntries) {
-      this.renderEntryNarrative(lines, entry, flow, ir);
+      this.renderEntryNarrative(lines, entry, moment, void 0, flow, ir, "  ", usedConnections);
     }
     this.renderMomentBranches(lines, moment, flow, ir);
     this.renderMomentPoliciesAndRules(lines, moment, ir);
@@ -64738,15 +65968,35 @@ var SpecificationDocumentGenerator = class {
     for (const branch of moment.branches) {
       const isTerminal = branch.entries.some((e) => e.terminal);
       if (isTerminal) {
-        lines.push(`  - \u274C **If ${branch.condition}** \u2192 flow terminates`);
+        this.renderTerminalBranch(lines, moment, branch, flow, ir);
       } else {
-        lines.push(`  - \u2705 **If ${branch.condition}:**`);
-        for (const entry of branch.entries) {
-          this.renderEntryNarrative(lines, entry, flow, ir, "    ");
-        }
+        this.renderNonTerminalBranch(lines, moment, branch, flow, ir);
       }
     }
   }
+  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}**` : ""}`);
+    for (const entry of branch.entries) {
+      if (entry.terminal)
+        continue;
+      this.renderEntryNarrative(lines, entry, moment, branch.condition, flow, ir, "    ", usedConnections);
+    }
+  }
+  renderNonTerminalBranch(lines, moment, branch, flow, ir) {
+    const usedConnections = /* @__PURE__ */ new Set();
+    lines.push(`  - \u2705 **If ${branch.condition}:**`);
+    for (const entry of branch.entries) {
+      this.renderEntryNarrative(lines, entry, moment, branch.condition, flow, ir, "    ", usedConnections);
+    }
+    const returnsTo = this.findReturnsTo(moment, branch.condition, flow);
+    if (returnsTo) {
+      const label = this.resolveReturnsToLabel(returnsTo, flow);
+      if (label)
+        lines.push(`    - \u21A9 *returns to "${label}"*`);
+    }
+  }
   renderMomentPoliciesAndRules(lines, moment, ir) {
     for (const pol of this.findPoliciesTriggeredBy(moment, ir)) {
       lines.push(`  - \u{1F517} *Policy: ${pol.name}* \u2014 ${pol.action}`);
@@ -64755,13 +66005,16 @@ var SpecificationDocumentGenerator = class {
       lines.push(`  - \u{1F4CB} *Rule ${rule.id}:* ${rule.description}`);
     }
   }
-  renderEntryNarrative(lines, entry, flow, ir, indent = "  ") {
+  renderEntryNarrative(lines, entry, moment, branchCondition, flow, ir, indent = "  ", usedConnections = /* @__PURE__ */ new Set()) {
     const ctx = ir.contexts.find((c) => c.id === entry.contextId);
     const ctxName = entry.contextId.replace(/^ctx-/, "");
-    const crossing = this.findCrossing(entry.nodeName, flow);
-    if (this.isCommand(entry.nodeName, ctx)) {
+    if (entry.nodeKind === "command") {
       this.renderCommandNarrative(lines, entry, ctx, ctxName, indent);
-    } else if (crossing) {
+      return;
+    }
+    const crossing = this.findCrossing(entry, moment, branchCondition, flow, usedConnections);
+    if (crossing) {
+      usedConnections.add(crossing.id);
       const target = this.resolveCtxName(crossing.targetContextId, ir);
       lines.push(`${indent}- **${entry.nodeName}** \u2192 crosses to **${target}**`);
     } else {
@@ -64954,7 +66207,7 @@ var SpecificationDocumentGenerator = class {
         if (conn.connectionType !== "crosses-to")
           continue;
         const moment = flow.moments.find((m) => m.id === conn.sourceMomentId);
-        const sourceCtxId = this.resolveSourceContextId(moment);
+        const sourceCtxId = moment ? this.findEntryForConnection(conn, moment)?.contextId : void 0;
         if (!sourceCtxId)
           continue;
         const sourceNode = this.mermaidNodeId(this.resolveCtxName(sourceCtxId, ir));
@@ -65019,7 +66272,7 @@ var SpecificationDocumentGenerator = class {
   }
   renderMomentSequenceMessages(lines, moment, flow, ir) {
     const ctxName = this.resolveMomentCtxName(moment, ir);
-    this.renderSequenceEntries(lines, moment.contextEntries, ctxName, flow, ir);
+    this.renderSequenceEntries(lines, moment.contextEntries, moment, void 0, flow, ir);
     if (moment.branches && moment.branches.length > 0) {
       this.renderBranchAltBlock(lines, moment, ctxName, flow, ir);
     }
@@ -65033,8 +66286,7 @@ var SpecificationDocumentGenerator = class {
       const branch = nonTerminal[i];
       const keyword = i === 0 ? "alt" : "else";
       lines.push(`  ${keyword} ${branch.condition}`);
-      const branchCtx = this.resolveBranchCtx(branch, ctxName, ir);
-      this.renderSequenceEntries(lines, branch.entries, branchCtx, flow, ir);
+      this.renderSequenceEntries(lines, branch.entries, moment, branch.condition, flow, ir);
     }
     if (terminal.length > 0) {
       const keyword = nonTerminal.length === 0 ? "alt" : "else";
@@ -65044,24 +66296,22 @@ var SpecificationDocumentGenerator = class {
     }
     lines.push("  end");
   }
-  resolveBranchCtx(branch, fallback, ir) {
-    const entry = branch.entries.find((e) => !e.terminal);
-    return entry ? this.resolveCtxName(entry.contextId, ir) : fallback;
-  }
-  renderSequenceEntries(lines, entries, ctxName, flow, ir) {
+  renderSequenceEntries(lines, entries, moment, branchCondition, flow, ir) {
+    const usedConnections = /* @__PURE__ */ new Set();
     for (const entry of entries) {
       if (entry.terminal)
         continue;
-      this.renderSingleSequenceEntry(lines, entry, ctxName, flow, ir);
+      this.renderSingleSequenceEntry(lines, entry, moment, branchCondition, flow, ir, usedConnections);
     }
   }
-  renderSingleSequenceEntry(lines, entry, ctxName, flow, ir) {
+  renderSingleSequenceEntry(lines, entry, moment, branchCondition, flow, ir, usedConnections) {
     const entryCtx = this.resolveCtxName(entry.contextId, ir);
-    const crossing = this.findCrossing(entry.nodeName, flow);
+    const crossing = this.findCrossing(entry, moment, branchCondition, flow, usedConnections);
     if (crossing) {
+      usedConnections.add(crossing.id);
       const target = this.resolveCtxName(crossing.targetContextId, ir);
       lines.push(`  ${entryCtx}->>${target}: ${entry.nodeName} (crosses)`);
-    } else if (this.isCommand(entry.nodeName, ir.contexts.find((c) => c.id === entry.contextId))) {
+    } else if (entry.nodeKind === "command") {
       const cmd = this.findCommand(ir.contexts.find((c) => c.id === entry.contextId), entry.nodeName);
       const emits = cmd?.emitsEvent ? ` \u2192 ${cmd.emitsEvent}` : "";
       lines.push(`  ${entryCtx}->>${entryCtx}: ${entry.nodeName}${emits}`);
@@ -65076,12 +66326,6 @@ var SpecificationDocumentGenerator = class {
   mermaidNodeId(name) {
     return name.replace(/[^a-zA-Z0-9]/g, "");
   }
-  resolveSourceContextId(moment) {
-    if (!moment)
-      return void 0;
-    const entry = moment.contextEntries[0] ?? moment.branches?.[0]?.entries?.[0];
-    return entry?.contextId;
-  }
   // ===========================================================================
   // Saga Helpers
   // ===========================================================================
@@ -65137,11 +66381,6 @@ var SpecificationDocumentGenerator = class {
   resolveCtxName(id, ir) {
     return ir.contexts.find((c) => c.id === id)?.name ?? id.replace(/^ctx-/, "");
   }
-  isCommand(name, ctx) {
-    if (!ctx)
-      return false;
-    return ctx.commands.some((c) => c.name === name);
-  }
   findCommand(ctx, name) {
     if (!ctx)
       return void 0;
@@ -65152,17 +66391,49 @@ var SpecificationDocumentGenerator = class {
     }
     return void 0;
   }
-  findCrossing(nodeName, flow) {
-    return flow.connections.find((c) => c.connectionType === "crosses-to" && c.eventId === `evt-${nodeName}`);
+  /**
+   * Finds the crossing declared by this entry in this moment (and branch).
+   * Scoped to (sourceMomentId, node) so an event crossing to several targets
+   * from different moments resolves to the right connection and contract.
+   */
+  findCrossing(entry, moment, branchCondition, flow, usedConnections = /* @__PURE__ */ new Set()) {
+    return flow.connections.find((c) => c.connectionType === "crosses-to" && c.sourceMomentId === moment.id && (c.sourceNodeName ? c.sourceNodeName === entry.nodeName : c.eventId === `evt-${entry.nodeName}`) && (c.branchCondition === void 0 || c.branchCondition === branchCondition) && !usedConnections.has(c.id));
+  }
+  findReturnsTo(moment, branchCondition, flow) {
+    return flow.connections.find((c) => c.connectionType === "returns-to" && c.sourceMomentId === moment.id && (c.branchCondition === void 0 || c.branchCondition === branchCondition));
+  }
+  resolveReturnsToLabel(conn, flow) {
+    if (conn.targetMomentId) {
+      const target = flow.moments.find((m) => m.id === conn.targetMomentId);
+      if (target)
+        return target.name;
+    }
+    return "targetMomentLabel" in conn ? conn.targetMomentLabel : void 0;
   }
   findSourceCtx(conn, moment, ir) {
     if (!moment)
       return "\u2014";
-    const entry = moment.contextEntries[0] ?? moment.branches?.[0]?.entries?.[0];
+    const entry = this.findEntryForConnection(conn, moment);
     return entry ? this.resolveCtxName(entry.contextId, ir) : "\u2014";
   }
+  /**
+   * Resolves the entry that declared a connection, preferring the connection's
+   * own sourceNodeName over positional guessing.
+   */
+  findEntryForConnection(conn, moment) {
+    const allEntries = [
+      ...moment.contextEntries,
+      ...(moment.branches ?? []).flatMap((b) => b.entries)
+    ];
+    if (conn.sourceNodeName) {
+      const declared = allEntries.find((e) => e.nodeName === conn.sourceNodeName);
+      if (declared)
+        return declared;
+    }
+    return allEntries[0];
+  }
   findPoliciesTriggeredBy(moment, ir) {
-    const eventNames = moment.contextEntries.filter((e) => !this.isCommand(e.nodeName, ir.contexts.find((c) => c.id === e.contextId))).map((e) => e.nodeName);
+    const eventNames = moment.contextEntries.filter((e) => e.nodeKind !== "command").map((e) => e.nodeName);
     const policies = [];
     for (const ctx of ir.contexts) {
       for (const pol of ctx.policies) {
@@ -65200,8 +66471,9 @@ function generateAsyncApiSpec(ir) {
   const crossings = collectCrossings(ir);
   const channels = buildChannelYaml(crossings);
   const messages = buildMessageYaml(crossings);
-  const title = escapeYaml(ir.metadata.name || "Untitled");
-  const version = escapeYaml(ir.metadata.version || "1.0.0");
+  const title = escapeYaml(ir.metadata.name || "Moment Specification");
+  const rawVersion = ir.metadata.version;
+  const version = escapeYaml(!rawVersion || rawVersion === "0.0.0" ? "1.0.0" : rawVersion);
   const description = escapeYaml(ir.metadata.description || "");
   const parts = [];
   parts.push(`asyncapi: '3.0.0'`);
@@ -65229,27 +66501,58 @@ function collectCrossings(ir) {
     for (const conn of flow.connections) {
       if (conn.connectionType !== "crosses-to")
         continue;
-      const event = findEventById(conn.eventId, ir);
-      if (!event)
+      const info = crossingFromConnection(conn, flow, ir);
+      if (!info)
         continue;
-      const producerCtx = findProducerContext(conn.eventId, ir);
-      const consumerCtx = ir.contexts.find((c) => c.id === conn.targetContextId);
-      if (!producerCtx || !consumerCtx)
-        continue;
-      const key = `${event.name}|${producerCtx.name}|${consumerCtx.name}`;
+      const key = `${info.eventName}|${info.producerContext}|${info.consumerContext}`;
       if (seen.has(key))
         continue;
       seen.add(key);
-      crossings.push({
-        eventName: event.name,
-        eventFields: event.fields.map((f) => ({ name: f.name, type: f.type, deprecated: f.deprecated ? true : void 0 })),
-        producerContext: producerCtx.name,
-        consumerContext: consumerCtx.name
-      });
+      crossings.push(info);
     }
   }
   return crossings;
 }
+function crossingFromConnection(conn, flow, ir) {
+  const event = findEventById(conn.eventId, ir);
+  const eventName = event?.name ?? conn.schemaContract.eventType;
+  if (!eventName)
+    return void 0;
+  const producerCtx = findProducerContext(conn.eventId, ir);
+  const producerName = producerCtx?.name ?? findProducingEntryContext2(eventName, conn.sourceMomentId, flow, ir);
+  if (!producerName)
+    return void 0;
+  const consumerCtx = ir.contexts.find((c) => c.id === conn.targetContextId);
+  const consumerName = consumerCtx?.name ?? conn.targetContextId.replace(/^ctx-/, "");
+  const { eventFields, requiredFields } = crossingSchema(event, conn);
+  return {
+    eventName,
+    eventFields,
+    requiredFields,
+    producerContext: producerName,
+    consumerContext: consumerName
+  };
+}
+function crossingSchema(event, conn) {
+  const eventFields = event ? event.fields.map((f) => ({ name: f.name, type: f.type, deprecated: f.deprecated ? true : void 0 })) : conn.schemaContract.fields.map((f) => ({ name: f.name, type: f.type, deprecated: void 0 }));
+  const contractRequired = conn.schemaContract.fields.filter((f) => f.required).map((f) => f.name);
+  const requiredFields = contractRequired.length > 0 ? contractRequired : event?.fields.filter((f) => f.required).map((f) => f.name) ?? [];
+  return { eventFields, requiredFields };
+}
+function findProducingEntryContext2(eventName, sourceMomentId, flow, ir) {
+  const moment = flow.moments.find((m) => m.id === sourceMomentId);
+  if (!moment)
+    return void 0;
+  const entries = [
+    ...moment.contextEntries,
+    ...(moment.branches ?? []).flatMap((b) => b.entries)
+  ];
+  const producing = entries.find((e) => e.nodeName === eventName);
+  if (!producing)
+    return void 0;
+  const ctx = ir.contexts.find((c) => c.id === producing.contextId);
+  return ctx?.name ?? producing.contextId.replace(/^ctx-/, "");
+}
 function findEventById(eventId, ir) {
   for (const ctx of ir.contexts) {
     for (const evt of ctx.events) {
@@ -65277,15 +66580,31 @@ function findProducerContext(eventId, ir) {
   return void 0;
 }
 function buildChannelYaml(crossings) {
-  const lines = [];
+  const byEvent = /* @__PURE__ */ new Map();
   for (const crossing of crossings) {
-    const channelName = toKebabCase(crossing.eventName);
+    let group = byEvent.get(crossing.eventName);
+    if (!group) {
+      group = { producers: [], consumers: [] };
+      byEvent.set(crossing.eventName, group);
+    }
+    if (!group.producers.includes(crossing.producerContext)) {
+      group.producers.push(crossing.producerContext);
+    }
+    if (!group.consumers.includes(crossing.consumerContext)) {
+      group.consumers.push(crossing.consumerContext);
+    }
+  }
+  const lines = [];
+  for (const [eventName, group] of byEvent) {
+    const channelName = toKebabCase(eventName);
+    const producers = group.producers.map(escapeYaml).join(", ");
+    const consumers = group.consumers.map(escapeYaml).join(", ");
     lines.push(`  ${channelName}:`);
     lines.push(`    address: '${channelName}'`);
     lines.push(`    messages:`);
-    lines.push(`      ${crossing.eventName}:`);
-    lines.push(`        $ref: '#/components/messages/${crossing.eventName}'`);
-    lines.push(`    description: 'Published by ${escapeYaml(crossing.producerContext)}, consumed by ${escapeYaml(crossing.consumerContext)}'`);
+    lines.push(`      ${eventName}:`);
+    lines.push(`        $ref: '#/components/messages/${eventName}'`);
+    lines.push(`    description: 'Published by ${producers}, consumed by ${consumers}'`);
   }
   return lines.join("\n");
 }
@@ -65308,6 +66627,12 @@ function buildMessageYaml(crossings) {
         lines.push(`            deprecated: true`);
       }
     }
+    if (crossing.requiredFields.length > 0) {
+      lines.push(`        required:`);
+      for (const name of crossing.requiredFields) {
+        lines.push(`          - ${name}`);
+      }
+    }
   }
   return lines.join("\n");
 }
@@ -65399,7 +66724,7 @@ function isStepLine(line) {
 function parseStepLine(line, lineNumber) {
   const keyword = line.split(" ")[0] + " ";
   const name = line.slice(keyword.length);
-  return { keyword, name, line: lineNumber, result: { status: "passed", duration: 0 } };
+  return { keyword, name, line: lineNumber, result: { status: "pending", duration: 0 } };
 }
 function buildScenario(parsed, flow, suite) {
   const status = resolveScenarioStatus(parsed.name, parsed.tags, flow, suite);
@@ -65420,23 +66745,22 @@ function buildScenario(parsed, flow, suite) {
 function resolveScenarioStatus(scenarioName, tags, flow, suite) {
   if (!suite)
     return "skipped";
+  const bracketIdx = scenarioName.indexOf(" [");
+  const momentName = bracketIdx !== -1 ? scenarioName.slice(0, bracketIdx) : scenarioName;
+  const variant = bracketIdx !== -1 ? scenarioName.slice(bracketIdx + 2, scenarioName.length - 1) : void 0;
+  const moment = flow.moments.find((m) => m.name === momentName);
+  if (moment) {
+    const matchingCase = suite.testCases.find((tc) => tc.momentId === moment.id && (variant === void 0 || tc.variant === variant));
+    return matchingCase ? "pending" : "skipped";
+  }
   const isSaga = tags.some((t) => t.name.startsWith("@saga:"));
-  const isCompensation = tags.some((t) => t.name === "@compensation");
   if (isSaga) {
-    const sagaPrefix = isCompensation ? "saga-" : "saga-";
-    const matchingCases = suite.testCases.filter((tc) => tc.momentId.startsWith(sagaPrefix));
+    const matchingCases = suite.testCases.filter((tc) => tc.momentId.startsWith("saga-"));
     if (matchingCases.length === 0)
       return "skipped";
-    return "passed";
+    return "pending";
   }
-  const bracketIdx = scenarioName.indexOf(" [");
-  const momentName = bracketIdx !== -1 ? scenarioName.slice(0, bracketIdx) : scenarioName;
-  const variant = bracketIdx !== -1 ? scenarioName.slice(bracketIdx + 2, scenarioName.length - 1) : void 0;
-  const moment = flow.moments.find((m) => m.name === momentName);
-  if (!moment)
-    return "skipped";
-  const matchingCase = suite.testCases.find((tc) => tc.momentId === moment.id && (variant === void 0 || tc.variant === variant));
-  return matchingCase ? "passed" : "skipped";
+  return "skipped";
 }
 function extractFeatureTags(content) {
   const firstLine = content.split("\n")[0]?.trim() ?? "";
@@ -65748,27 +67072,35 @@ function sanitizeComment(s) {
 function generateSetupComment(step) {
   return `      // Setup: ${sanitizeComment(step.contextName)}.${sanitizeComment(step.aggregateName)} \u2014 ${sanitizeComment(step.precondition)}`;
 }
-function generateAssertionIt(assertion) {
+function assertionTestName(assertion, testCase) {
+  if (assertion.assertionType === "saga" || assertion.assertionType === "policy-chain") {
+    return `should verify ${escapeStringLiteral(testCase.momentName)}`;
+  }
   const eventType = assertion.schemaContract.eventType;
   const source = assertion.sourceContext;
   const target = assertion.targetContext;
+  return `should verify ${escapeStringLiteral(eventType)} crosses from ${escapeStringLiteral(source)} to ${escapeStringLiteral(target)}`;
+}
+function generateAssertionIt(assertion, testCase) {
   const lines = [];
-  lines.push(`    it('should verify ${escapeStringLiteral(eventType)} crosses from ${escapeStringLiteral(source)} to ${escapeStringLiteral(target)}', () => {`);
-  lines.push(`      // Crossing: ${assertion.crossingId}`);
-  lines.push(`      // Assertion type: ${assertion.assertionType}`);
+  lines.push(`    // Crossing: ${assertion.crossingId}`);
+  lines.push(`    // Assertion type: ${assertion.assertionType}`);
   if (assertion.schemaContract.expectedFields.length > 0) {
-    lines.push(`      // Expected fields:`);
+    lines.push(`    // Expected fields:`);
     for (const field of assertion.schemaContract.expectedFields) {
-      lines.push(`      //   ${field.fieldName}: ${field.expectedType} (${field.required ? "required" : "optional"})`);
+      lines.push(`    //   ${field.fieldName}: ${field.expectedType} (${field.required ? "required" : "optional"})`);
     }
   }
-  lines.push(`      // TODO: implement assertion`);
-  lines.push(`    });`);
+  lines.push(`    it.todo('${assertionTestName(assertion, testCase)}');`);
   return lines.join("\n");
 }
+function describeName(testCase) {
+  const base = escapeStringLiteral(testCase.momentName);
+  return testCase.variant ? `${base} [${escapeStringLiteral(testCase.variant)}]` : base;
+}
 function generateTestCase(testCase) {
   const lines = [];
-  lines.push(`  describe('${escapeStringLiteral(testCase.momentName)}', () => {`);
+  lines.push(`  describe('${describeName(testCase)}', () => {`);
   if (testCase.setupSteps.length > 0) {
     lines.push(`    beforeEach(() => {`);
     for (const step of testCase.setupSteps) {
@@ -65778,7 +67110,7 @@ function generateTestCase(testCase) {
     lines.push("");
   }
   for (const assertion of testCase.assertions) {
-    lines.push(generateAssertionIt(assertion));
+    lines.push(generateAssertionIt(assertion, testCase));
     lines.push("");
   }
   if (lines[lines.length - 1] === "") {
@@ -65787,12 +67119,12 @@ function generateTestCase(testCase) {
   lines.push(`  });`);
   return lines.join("\n");
 }
-function hasAnySetupSteps(suite) {
-  return suite.testCases.some((tc) => tc.setupSteps.length > 0);
+function renderableTestCases(suite) {
+  return suite.testCases.filter((tc) => tc.assertions.length > 0);
 }
-function generateFlowSpecFile(suite) {
+function generateFlowSpecFile(suite, testCases) {
   const lines = [];
-  const needsBeforeEach = hasAnySetupSteps(suite);
+  const needsBeforeEach = testCases.some((tc) => tc.setupSteps.length > 0);
   if (needsBeforeEach) {
     lines.push("import { describe, it, beforeEach, expect } from 'vitest';");
   } else {
@@ -65800,9 +67132,9 @@ function generateFlowSpecFile(suite) {
   }
   lines.push("");
   lines.push(`describe('${escapeStringLiteral(suite.flowName)}', () => {`);
-  for (let i = 0; i < suite.testCases.length; i++) {
-    lines.push(generateTestCase(suite.testCases[i]));
-    if (i < suite.testCases.length - 1) {
+  for (let i = 0; i < testCases.length; i++) {
+    lines.push(generateTestCase(testCases[i]));
+    if (i < testCases.length - 1) {
       lines.push("");
     }
   }
@@ -65816,15 +67148,12 @@ function generateAggregateSpecFile(aggregate) {
   lines.push("");
   lines.push(`describe('${escapeStringLiteral(aggregate.name)}', () => {`);
   for (const command2 of aggregate.commands) {
-    lines.push(`  it('should handle ${escapeStringLiteral(command2.name)}', () => {`);
-    lines.push(`    // TODO: implement`);
-    lines.push(`  });`);
+    lines.push(`  it.todo('should handle ${escapeStringLiteral(command2.name)}');`);
     lines.push("");
   }
   for (const invariant of aggregate.invariants) {
-    lines.push(`  it('should enforce invariant: ${escapeStringLiteral(invariant.description)}', () => {`);
-    lines.push(`    // TODO: implement invariant violation test`);
-    lines.push(`  });`);
+    lines.push(`  // TODO: implement invariant violation test`);
+    lines.push(`  it.todo('should enforce invariant: ${escapeStringLiteral(invariant.description)}');`);
     lines.push("");
   }
   if (lines[lines.length - 1] === "") {
@@ -65852,8 +67181,11 @@ var TestScaffoldEmitter = class {
     const files = /* @__PURE__ */ new Map();
     const specFilesWritten = [];
     for (const suite of topology.suites) {
+      const testCases = renderableTestCases(suite);
+      if (testCases.length === 0)
+        continue;
       const fileName = `__tests__/flows/${safePathSegment2(suite.flowName)}.spec.ts`;
-      const content = generateFlowSpecFile(suite);
+      const content = generateFlowSpecFile(suite, testCases);
       files.set(fileName, content);
       specFilesWritten.push(fileName);
     }
@@ -65861,6 +67193,8 @@ var TestScaffoldEmitter = class {
     for (const context of ir.contexts) {
       for (const aggregate of context.aggregates) {
         allAggregates.push(aggregate);
+        if (aggregate.commands.length === 0 && aggregate.invariants.length === 0)
+          continue;
         const contextDir = safePathSegment2(context.name);
         const fileName = `__tests__/${contextDir}/${safePathSegment2(aggregate.name)}.spec.ts`;
         const content = generateAggregateSpecFile(aggregate);
@@ -65877,6 +67211,31 @@ var TestScaffoldEmitter = class {
   }
 };
 
+// src/lib/flags.ts
+function collectUnknownFlags(tokens, knownOptions) {
+  const known = new Set(knownOptions);
+  const unknown = [];
+  for (const token of tokens) {
+    if (token.kind !== "option" || !token.name) continue;
+    if (known.has(token.name)) continue;
+    const raw = token.rawName ?? `--${token.name}`;
+    if (!unknown.includes(raw)) unknown.push(raw);
+  }
+  return unknown;
+}
+function resolveStringFlag(values2, ...names) {
+  for (const name of names) {
+    const value = values2[name];
+    if (typeof value === "string") return value;
+  }
+  return void 0;
+}
+function warnUnknownFlags(tokens, knownOptions, warn = (m) => console.warn(m)) {
+  for (const flag of collectUnknownFlags(tokens, knownOptions)) {
+    warn(`Warning: unrecognized flag ${flag} (ignored)`);
+  }
+}
+
 // src/commands/generate.ts
 var EMPTY2 = [];
 function fail2(message) {
@@ -65891,16 +67250,21 @@ function readFile2(path) {
   }
 }
 async function runGenerate(argv) {
-  const { values: values2, positionals } = parseArgs2({
+  const options = {
+    out: { type: "string", short: "o" },
+    // Alias for --out, symmetric with `moment simulate --out-dir`.
+    "out-dir": { type: "string" }
+  };
+  const { values: values2, positionals, tokens } = parseArgs2({
     args: argv,
-    options: {
-      out: { type: "string", short: "o" }
-    },
+    options,
     allowPositionals: true,
-    strict: false
+    strict: false,
+    tokens: true
   });
+  warnUnknownFlags(tokens, Object.keys(options));
   const filePath = positionals[0];
-  if (!filePath) return fail2("Usage: moment generate <file.moment> [--out <dir>]");
+  if (!filePath) return fail2("Usage: moment generate <file.moment> [--out <dir> | --out-dir <dir>]");
   const resolvedPath = resolve8(filePath);
   if (!existsSync5(resolvedPath)) return fail2(`Error: File not found: ${resolvedPath}`);
   const content = readFile2(resolvedPath);
@@ -65926,10 +67290,7 @@ async function runGenerate(argv) {
   const docs = docGen.generate(ir);
   const tsOutput = tsEmitter.emit(ir, { scope: { level: "system" } });
   const scaffoldOutput = scaffoldEmitter.emit(ir, topology);
-  const outDir = resolveOutputBaseDir(
-    resolvedPath,
-    typeof values2.out === "string" ? values2.out : void 0
-  );
+  const outDir = resolveOutputBaseDir(resolvedPath, resolveStringFlag(values2, "out-dir", "out"));
   const allFiles = /* @__PURE__ */ new Map();
   for (const [path, content2] of tsOutput.files) allFiles.set(path, content2);
   for (const [path, content2] of scaffoldOutput.files) allFiles.set(path, content2);
@@ -69890,13 +71251,14 @@ function writeOutputFiles3(groups, ir, outDir) {
       manifestScenarios.push({
         scenarioId: scenario.scenarioId,
         scenarioLabel: scenario.scenarioLabel,
+        kind: scenario.kind,
         description: scenario.description,
         file: fileName,
         eventCount: scenario.events.length,
         pathLength: scenario.expectedPath.length,
         branchCount: scenario.activeBranches.length,
-        isHappyPath: scenario.scenarioLabel.startsWith("Happy Path:"),
-        isNegative: scenario.scenarioLabel.startsWith("Failure:")
+        isHappyPath: scenario.kind === "happy",
+        isNegative: scenario.kind === "negative"
       });
     }
     manifestFlows.push({
@@ -69926,6 +71288,9 @@ function writeArtifacts(ir, outDir) {
   const sagas = generateSagaStateMachines(ir);
   files.sagaStateMachines = "saga-state-machines.json";
   writeSafe(outDir, files.sagaStateMachines, JSON.stringify(sagas, null, 2) + "\n");
+  const policies = generatePolicyDefinitions(ir);
+  files.policyDefinitions = "policy-definitions.json";
+  writeSafe(outDir, files.policyDefinitions, JSON.stringify(policies, null, 2) + "\n");
   const asyncapi = generateAsyncApiSpec(ir);
   files.asyncApi = "asyncapi.yaml";
   writeSafe(outDir, files.asyncApi, asyncapi);
@@ -69937,7 +71302,13 @@ function kebab3(s) {
 function runOutDirWrite(flows, ir, outDir, includeAll) {
   const groups = flows.map((flow) => ({
     flow,
-    scenarios: includeAll ? [...generateAllScenarios(ir, flow), ...deriveNegativeScenarios(ir, flow)] : [generateSimulationScenario(ir, flow)]
+    scenarios: includeAll ? [
+      ...generateAllScenarios(ir, flow),
+      ...deriveNegativeScenarios(ir, flow),
+      // Saga-timeout scenarios: neither happy nor negative — the manifest
+      // carries kind:'timeout' with both flags false.
+      ...deriveTimeoutScenarios(ir, flow)
+    ] : [generateSimulationScenario(ir, flow)]
   }));
   try {
     return writeOutputFiles3(groups, ir, outDir);
@@ -69947,17 +71318,22 @@ function runOutDirWrite(flows, ir, outDir, includeAll) {
   }
 }
 async function runSimulate(argv) {
-  const { values: values2, positionals } = parseArgs18({
+  const options = {
+    json: { type: "boolean" },
+    flow: { type: "string" },
+    all: { type: "boolean" },
+    "out-dir": { type: "string" },
+    // Alias for --out-dir, symmetric with `moment generate --out`.
+    out: { type: "string" }
+  };
+  const { values: values2, positionals, tokens } = parseArgs18({
     args: argv,
-    options: {
-      json: { type: "boolean" },
-      flow: { type: "string" },
-      all: { type: "boolean" },
-      "out-dir": { type: "string" }
-    },
+    options,
     allowPositionals: true,
-    strict: false
+    strict: false,
+    tokens: true
   });
+  warnUnknownFlags(tokens, Object.keys(options));
   const filePath = positionals[0];
   if (!filePath)
     return fail16(
@@ -69984,13 +71360,14 @@ async function runSimulate(argv) {
   if (targetFlows.length === 0) {
     return fail16(`Flow '${values2.flow}' not found.`);
   }
-  const outDir = values2["out-dir"];
+  const outDir = resolveStringFlag(values2, "out-dir", "out");
   if (outDir) {
     return runOutDirWrite(targetFlows, ir, outDir, values2.all === true);
   }
   const scenarios = values2.all ? targetFlows.flatMap((flow) => [
     ...generateAllScenarios(ir, flow),
-    ...deriveNegativeScenarios(ir, flow)
+    ...deriveNegativeScenarios(ir, flow),
+    ...deriveTimeoutScenarios(ir, flow)
   ]) : targetFlows.map((flow) => generateSimulationScenario(ir, flow));
   return formatScenarios(scenarios, values2.json === true);
 }
@@ -70000,8 +71377,8 @@ function getClientId() {
   if (process.env.MOMENT_GITHUB_CLIENT_ID) {
     return process.env.MOMENT_GITHUB_CLIENT_ID;
   }
-  if ("Ov23li5nhWuDstHvLltG") {
-    return "Ov23li5nhWuDstHvLltG";
+  if ("") {
+    return "";
   }
   throw new Error(
     "GitHub App client ID not configured. Set MOMENT_GITHUB_CLIENT_ID or build with GH_APP_CLIENT_ID."