sysml-diagram 0.25.0 → 0.27.0

package/out/main.js

@@ -162649,7 +162649,12 @@ function keywordFor(node) {
     JoinNode: "join",
     TerminateNode: "terminate",
     PerformStmt: "perform action",
-    EventDecl: "event occurrence"
+    EventDecl: "event occurrence",
+    // REQ-198, issue #113: a state sub-action drawn as a state-transition
+    // node keeps the keyword that says WHEN it runs (OMG 8.2.2.18.1).
+    EntryAction: "entry action",
+    DoAction: "do action",
+    ExitAction: "exit action"
   };
   if (t === "ActionDecl" && n2.inlineBody?.$type === "AcceptNode") {
     return "accept action";
@@ -162698,6 +162703,11 @@ var ACTION_FLOW_STEP_TYPES = /* @__PURE__ */ new Set([
   "ForLoopNode"
 ]);
 var isActionFlowStep = (node) => !!node && ACTION_FLOW_STEP_TYPES.has(node.$type);
+var NESTED_ACTION_LIMIT = 8;
+var withoutCompartments = (compartments, ...titles) => {
+  const kept = (compartments ?? []).filter((compartment) => !titles.includes(compartment.title));
+  return kept.length ? kept : void 0;
+};
 var modifiersOf = (node) => {
   const mods = node.modifiers;
   return Array.isArray(mods) ? mods : [];
@@ -163818,6 +163828,37 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   /** REQ-196 — is this `perform` a SWIMLANE claim (OMG p.90): a part claiming an
    *  action that another action owns? Such a claim is drawn inside that action,
    *  so it is never content of the part that wrote it. */
+  /** issue #114 — the path a referencing `perform`/`exhibit` names, as written
+   *  (`Mission::prepare`, `flow1.step`). A referencing claim has no local name,
+   *  so the written path is the only thing that identifies it in a text row. */
+  behaviorReferenceText(stmt) {
+    return this.behaviorReferenceSegments(stmt).map((segment, at) => at === 0 ? segment.text : `${segment.separator ?? "::"}${segment.text}`).join("");
+  }
+  /** issue #114 — the `perform` claims of the document, grouped by the action
+   *  each one names, so an action can list the parts that perform it
+   *  (`performed by`, OMG SysML v2 §8.4.13.11 `Parts::Part::performedActions`).
+   *  One walk per parse: the reverse listing is otherwise quadratic in the
+   *  number of drawn nodes. */
+  performClaimsByTarget(root4, index2) {
+    const cache = this.perParse(root4);
+    if (cache.performClaims)
+      return cache.performClaims;
+    const claims = /* @__PURE__ */ new Map();
+    for (const node of this.rootContents(root4)) {
+      if (node.$type !== "PerformStmt")
+        continue;
+      const target = this.performTargetOf(node, index2);
+      if (!target || target === node)
+        continue;
+      const existing = claims.get(target);
+      if (existing)
+        existing.push(node);
+      else
+        claims.set(target, [node]);
+    }
+    cache.performClaims = claims;
+    return claims;
+  }
   isSwimlaneClaim(member, index2) {
     if (member.$type !== "PerformStmt")
       return false;
@@ -165326,7 +165367,10 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           isDef: part.isDef === true,
           type: typeText(part),
           multiplicity: multText(part),
-          compartments: this.compartmentsFor(part, uri, index2),
+          // issue #114 — this frame already DRAWS the actions the part
+          // performs, so their textual `perform actions` rows would be a
+          // second depiction of the same members (REQ-181/185).
+          compartments: withoutCompartments(this.compartmentsFor(part, uri, index2), "perform actions"),
           ports: ports.length ? ports : void 0,
           source: sourceOf2(part, uri),
           meta: editMeta
@@ -166688,7 +166732,8 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       else
         emitFlowNode(child, ownerFrameId, holder, occurrence, laneParts);
     };
-    const actionFeatureCompartments = (action) => (this.compartmentsFor(action, uri, index2) ?? []).filter((compartment) => compartment.title !== "parameters" && compartment.title !== "actions");
+    const graphicalAfvTitles = ["perform actions", "performed by"];
+    const actionFeatureCompartments = (action) => withoutCompartments(this.compartmentsFor(action, uri, index2), "parameters", "actions", ...graphicalAfvTitles) ?? [];
     const renderContainer = (holder, frameId, parentFrame, depth, seen, isAnchor, inheritedExecutionContext, holderOccurrence = frameId) => {
       if (!occurrenceEdits.has(holderOccurrence)) {
         occurrenceEdits.set(holderOccurrence, {
@@ -166713,7 +166758,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       frameOfNode.set(holder, frameId);
       const framePorts = isPartDecl(holder) ? [...framePins, ...this.portsOf(holder, index2, uri, frameId).ports.filter((port) => !framePins.some((pin) => pin.name === port.name)).map((port) => ({ ...port, meta: { ...port.meta, afvPartPort: true } }))] : framePins;
       registerPins(holder, frameId, framePins, isAnchor);
-      const frameCompartments = isActionDecl(holder) ? actionFeatureCompartments(holder) : this.compartmentsFor(holder, uri, index2);
+      const frameCompartments = isActionDecl(holder) ? actionFeatureCompartments(holder) : withoutCompartments(this.compartmentsFor(holder, uri, index2), ...graphicalAfvTitles);
       frames.push({
         id: frameId,
         label: nameOf2(holder) ?? lastSeg(frameId),
@@ -166795,6 +166840,10 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       return id2;
     };
     const emitLoopFrame = (loop, parentFrameId, executionContext, occurrence, laneParts, wrapper) => {
+      if (nestingExhausted()) {
+        emitFlowNode(wrapper ?? loop, parentFrameId, executionContext, occurrence, laneParts);
+        return;
+      }
       const banner = loopBanner(loop);
       const wrapperName = wrapper ? nameOf2(wrapper) : void 0;
       const loopId = occurrence;
@@ -166847,9 +166896,11 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         const parentEdit = occurrenceEdits.get(occurrence);
         if (parentEdit)
           occurrenceEdits.set(bodyOccurrence, parentEdit);
+        openFrames.add(loop);
         for (const bm of flowMembersOf(body)) {
           emitChild(bm, loopId, executionContext, bodyOccurrence);
         }
+        openFrames.delete(loop);
       }
       idByNode.set(loop, loopId);
       registerStep(occurrence, loopId, [nameOf2(loop)]);
@@ -166876,10 +166927,11 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       return target && isActionDecl(target) && ownsFlow(target) ? target : void 0;
     };
     const isCompositeAction = (node) => contentSourceOf(node) !== void 0;
-    const openActionFrames = /* @__PURE__ */ new Set();
+    const openFrames = /* @__PURE__ */ new Set();
+    const nestingExhausted = () => openFrames.size >= NESTED_ACTION_LIMIT;
     const emitCompositeActionFrame = (action, parentFrameId, executionContext, occurrence, laneParts) => {
       const content = contentSourceOf(action) ?? action;
-      if (openActionFrames.has(content)) {
+      if (openFrames.has(content) || nestingExhausted()) {
         emitFlowNode(action, parentFrameId, executionContext, occurrence, laneParts);
         return;
       }
@@ -166925,12 +166977,16 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       });
       recordLaneCandidate(id2, true, parentFrameId, laneParts, occurrence);
       actionRecords.push({ m: action, id: id2, performer: executionContext });
-      openActionFrames.add(content);
+      openFrames.add(content);
       for (const child of flowMembersOf(content))
         emitChild(child, id2, executionContext, occurrence);
-      openActionFrames.delete(content);
+      openFrames.delete(content);
     };
     const emitIfFrame = (node, parentFrameId, executionContext, occurrence, laneParts, wrapper) => {
+      if (nestingExhausted()) {
+        emitFlowNode(wrapper ?? node, parentFrameId, executionContext, occurrence, laneParts);
+        return;
+      }
       const inf = node;
       const declaredNode = wrapper ?? (nameOf2(node) ? node : void 0);
       const wrapperName = declaredNode ? nameOf2(declaredNode) : void 0;
@@ -166983,6 +167039,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         idByNode.set(wrapper, frameId);
         registerStep(occurrence, frameId, [wrapperName]);
       }
+      openFrames.add(node);
       for (const [branch, block2] of [
         ["then", inf.thenBody],
         ["else", inf.elseIf ?? inf.elseBody]
@@ -167014,6 +167071,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           [branch === "then" ? "structuredThenMemberIds" : "structuredElseMemberIds"]: memberIds
         };
       }
+      openFrames.delete(node);
     };
     const anchorId = qnameOf(anchor) || nameOf2(anchor) || "__anchor__";
     renderContainer(anchor, anchorId, void 0, 0, /* @__PURE__ */ new Set(), true, void 0);
@@ -167142,6 +167200,15 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         branchInsertable: true
       } : void 0;
     };
+    const drawnRowKeys = /* @__PURE__ */ new Set();
+    const rowKey = (source) => source ? `${source.uri} ${source.range.start.line} ${source.range.start.character}` : void 0;
+    const registerDrawn = (member) => {
+      if (!member)
+        return;
+      const key = rowKey(sourceOf2(member, uri));
+      if (key)
+        drawnRowKeys.add(key);
+    };
     const linkedSuccessions = /* @__PURE__ */ new Set();
     const linkIds = (from, to, label, src, meta) => {
       if (!from || !to)
@@ -167167,6 +167234,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         source: src ? sourceOf2(src, uri) : void 0,
         meta
       });
+      registerDrawn(src);
       return true;
     };
     const linkInlineTerminate = (action, actionId) => {
@@ -167295,6 +167363,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
               label: this.flowPayloadText(fm) ?? typeText(m) ?? transferredFeature ?? nameOf2(m),
               source: sourceOf2(m, uri)
             });
+            registerDrawn(m);
           }
         } else if (m.$type === "BindStmt" || m.$type === "BindingConnectorStmt" || m.$type === "BindingDecl") {
           const binding = m;
@@ -167304,6 +167373,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           const to = resolvePin(right, occurrenceContext);
           if (from && to) {
             edges.push({ id: `e${e++}`, from, to, kind: "binding", label: "=", source: sourceOf2(m, uri) });
+            registerDrawn(m);
           }
         } else {
           const memberName = localFlowName(m);
@@ -167593,6 +167663,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       const toId = match ? nodeIdOf(match.m) : void 0;
       if (fromId && toId) {
         edges.push({ id: `e${e++}`, from: fromId, to: toId, kind: "message", label: payload, source: sourceOf2(s.m, uri) });
+        registerDrawn(s.m);
       }
     }
     this.emitBehaviorDefinitions([
@@ -167607,6 +167678,23 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       bare.notes = ["No actions found to flow."];
       return bare;
     }
+    if (drawnRowKeys.size) {
+      for (const element of [...frames, ...nodes]) {
+        const full = element.compartments;
+        if (!full?.length)
+          continue;
+        const kept = full.map((compartment) => ({
+          title: compartment.title,
+          items: compartment.items.filter((row) => {
+            const key = rowKey(row.source);
+            return !key || !drawnRowKeys.has(key);
+          })
+        })).filter((compartment) => compartment.items.length > 0);
+        if (kept.length === full.length && kept.every((c, at) => c.items.length === full[at].items.length))
+          continue;
+        element.compartments = kept.length ? kept : void 0;
+      }
+    }
     const model = this.model("afv", anchor, nodes, edges);
     model.frames = frames;
     model.meta = { ...model.meta, unified: true, groupMode: "nested" };
@@ -167625,7 +167713,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       const def = this.resolveType(holder, index2);
       return def && def !== holder && def.isDef === true ? def : void 0;
     };
-    const ownStates = (holder) => membersOf(holder).filter((member) => isStateDecl(member) && nameOf2(member) !== void 0);
+    const ownStates = (holder) => membersOf(holder).map((member) => this.thenActionMemberNode(member) ?? member).filter((member) => isStateDecl(member) && nameOf2(member) !== void 0);
     const nestedStates = (holder) => {
       const out = ownStates(holder);
       const def = definitionOf(holder);
@@ -167664,9 +167752,28 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       drawnStates.push({ node: anchor, id: anchorFrameId });
       idByState.set(anchor, anchorFrameId);
     }
+    const drawnRowKeys = /* @__PURE__ */ new Set();
+    const rowKey = (source) => source ? `${source.uri} ${source.range.start.line} ${source.range.start.character}` : void 0;
+    const registerDrawn = (member) => {
+      const key = rowKey(sourceOf2(member, uri));
+      if (key)
+        drawnRowKeys.add(key);
+    };
+    const namesByFrame = /* @__PURE__ */ new Map();
+    const namesIn = (frameId) => {
+      const key = frameId ?? "";
+      const existing = namesByFrame.get(key);
+      if (existing)
+        return existing;
+      const created = /* @__PURE__ */ new Map();
+      namesByFrame.set(key, created);
+      return created;
+    };
     const renderState = (s, parentFrame, depth, seen) => {
       const id2 = qnameOf(s) || nameOf2(s);
       byName.set(nameOf2(s), id2);
+      namesIn(parentFrame).set(nameOf2(s), id2);
+      registerDrawn(s);
       drawnStates.push({ node: s, id: id2 });
       idByState.set(s, id2);
       const def = s.isDef === true ? void 0 : this.resolveType(s, index2);
@@ -167704,6 +167811,75 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     };
     for (const s of topStates)
       renderState(s, anchorFrameId, 0, /* @__PURE__ */ new Set());
+    const endpointName = (path10) => typeof path10 === "string" ? path10.split(/::|\./).pop() || void 0 : void 0;
+    const controlNodeInfo = (m) => {
+      switch (m.$type) {
+        case "ActionDecl":
+          return m.isDef === true || !nameOf2(m) ? void 0 : { shape: "action", label: nameOf2(m) };
+        // A `perform` names the action it performs, which for a feature
+        // chain (`perform machine.selfTest;`) is the LAST segment.
+        case "PerformStmt": {
+          const segments = [nameOf2(m), ...m.chainSegs ?? []].filter((segment) => !!segment);
+          return { shape: "action", label: segments.at(-1) ?? typeText(m) ?? "perform" };
+        }
+        // User direction 2026-08-30: fork and join only. They express
+        // concurrency, which a transition cannot say: nothing about a
+        // guard or a trigger splits control into parallel regions or
+        // gathers it again. `decide` and `merge` are dropped because a
+        // branch between states IS a guarded transition, which this
+        // view already draws and labels, so a diamond would say the
+        // same thing a second time in the action-flow idiom.
+        // `terminate` is dropped with them: the node carries no name,
+        // so no succession can reach it and it could only ever stand
+        // alone. All three remain in the OMG 8.2.3.18 node set.
+        case "JoinNode":
+          return { shape: "join", label: nameOf2(m) ?? "" };
+        case "ForkNode":
+          return { shape: "fork", label: nameOf2(m) ?? "" };
+        default:
+          return void 0;
+      }
+    };
+    const isInitialMarker = (member) => {
+      const entry = member;
+      return !!entry && entry.$type === "EntryAction" && !entry.name && !entry.actionKw && !entry.send && !entry.accept && !entry.assign;
+    };
+    const machineNodeIds = /* @__PURE__ */ new Map();
+    const machineNodeMembers = [];
+    let anonymousNodes = 0;
+    const emitMachineNodes = (holder, frameId) => {
+      const members = membersOf(holder);
+      const drawnHere = namesIn(frameId);
+      for (const raw of members) {
+        const member = this.thenActionMemberNode(raw) ?? raw;
+        const info = controlNodeInfo(member);
+        if (!info)
+          continue;
+        const name = nameOf2(member);
+        if (name && drawnHere.has(name))
+          continue;
+        const id2 = name ? qnameOf(member) || `${frameId}::${name}` : `${frameId}::__stv_${member.$type}_${anonymousNodes++}__`;
+        if (nodes.some((n2) => n2.id === id2) || frames.some((f) => f.id === id2))
+          continue;
+        if (name) {
+          drawnHere.set(name, id2);
+          if (!byName.has(name))
+            byName.set(name, id2);
+        }
+        machineNodeIds.set(member, id2);
+        machineNodeMembers.push({ member, id: id2 });
+        nodes.push({
+          id: id2,
+          name: info.label,
+          keyword: keywordFor(member),
+          isDef: false,
+          shape: info.shape,
+          compartments: this.compartmentsFor(member, uri, index2),
+          frame: frameId,
+          source: sourceOf2(member, uri)
+        });
+      }
+    };
     const edges = [];
     let e = 0;
     const resolveState = (nm) => {
@@ -167719,53 +167895,201 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       }
       return void 0;
     };
-    const transitionScope = [anchor, ...definitionOf(anchor) ? [definitionOf(anchor)] : []];
-    for (const t of transitionScope.flatMap((holder) => [...ast_utils_exports.streamAllContents(holder)])) {
-      if (t.$type !== "TransitionDecl")
-        continue;
-      const tn = t;
-      const from = resolveState(tn.from);
-      const to = resolveState(tn.to);
+    const drawnEdges = /* @__PURE__ */ new Set();
+    const stateLike = /* @__PURE__ */ new Set(["state", "initial", "final"]);
+    const isStateEndpoint = (id2) => {
+      const node = nodes.find((n2) => n2.id === id2);
+      return node ? stateLike.has(node.shape) : frames.some((f) => f.id === id2);
+    };
+    const link = (from, to, label, src) => {
       if (!from || !to)
-        continue;
+        return;
+      const kind = isStateEndpoint(from) && isStateEndpoint(to) ? "transition" : "succession";
+      const key = `${from}\0${to}\0${label ?? ""}`;
+      if (drawnEdges.has(key))
+        return;
+      drawnEdges.add(key);
+      if (src)
+        registerDrawn(src);
       edges.push({
         id: `e${e++}`,
         from,
         to,
-        kind: "transition",
-        label: this.transitionLabel(t),
-        source: sourceOf2(t, uri)
+        kind,
+        label,
+        source: src ? sourceOf2(src, uri) : void 0
       });
+    };
+    const guardText = (guard) => {
+      const text = guard?.$cstNode?.text?.replace(/\s+/g, " ").trim();
+      return text ? `[${text}]` : void 0;
+    };
+    const resolveEndpoint = (path10, initialId, frameId) => {
+      if (typeof path10 !== "string")
+        return void 0;
+      const short = endpointName(path10);
+      const local = namesByFrame.get(frameId ?? "");
+      return (short ? local?.get(short) : void 0) ?? resolveState(path10) ?? resolveState(short) ?? (short === "start" ? initialId : void 0);
+    };
+    const transitionScope = [anchor, ...definitionOf(anchor) ? [definitionOf(anchor)] : []];
+    for (const t of transitionScope.flatMap((holder) => [...ast_utils_exports.streamAllContents(holder)])) {
+      if (t.$type !== "TransitionDecl")
+        continue;
+      const tn = t;
+      link(resolveState(tn.from), resolveState(tn.to), this.transitionLabel(t), t);
     }
-    const designatedInitial = (owner) => {
+    const designatedInitial = (owner, frameId) => {
       const members = owner.members;
       if (!Array.isArray(members))
         return void 0;
-      for (let i = 0; i < members.length - 1; i++) {
-        const entry = members[i];
-        if (entry.$type !== "EntryAction" || entry.name || entry.actionKw || entry.send || entry.accept || entry.assign)
+      for (let i = 0; i < members.length; i++) {
+        const member = members[i];
+        if (member.$type === "FirstThenChain") {
+          const chain = member;
+          if (endpointName(chain.head) !== "start")
+            continue;
+          const target2 = resolveEndpoint((chain.steps ?? [])[0], void 0, frameId);
+          if (target2) {
+            registerDrawn(member);
+            return target2;
+          }
+          continue;
+        }
+        if (!isInitialMarker(member))
           continue;
         const then = members[i + 1];
         if (then?.$type !== "ThenActionMember" || typeof then.target !== "string")
           continue;
         const target = resolveState(lastSeg(then.target));
-        if (target)
+        if (target) {
+          registerDrawn(then);
           return target;
+        }
       }
       return void 0;
     };
-    const anchorDefinition = definitionOf(anchor);
-    const firstStateId = designatedInitial(anchor) ?? (anchorDefinition ? designatedInitial(anchorDefinition) : void 0) ?? (topStates.length ? byName.get(nameOf2(topStates[0])) : void 0);
-    if (firstStateId) {
-      edges.push({ id: `e${e++}`, from: "__initial__", to: firstStateId, kind: "transition" });
+    const machineScope = (holder) => {
+      const def = definitionOf(holder);
+      return def ? [holder, def] : [holder];
+    };
+    if (anchorFrameId) {
+      for (const holder of machineScope(anchor))
+        emitMachineNodes(holder, anchorFrameId);
+    }
+    for (const { state, frameId } of compositeFrames) {
+      for (const holder of machineScope(state))
+        emitMachineNodes(holder, frameId);
     }
+    const anchorDefinition = definitionOf(anchor);
+    const firstStateId = designatedInitial(anchor, anchorFrameId) ?? (anchorDefinition ? designatedInitial(anchorDefinition, anchorFrameId) : void 0) ?? (topStates.length ? byName.get(nameOf2(topStates[0])) : void 0);
+    if (firstStateId)
+      link("__initial__", firstStateId, void 0, void 0);
+    const compositeInitial = /* @__PURE__ */ new Map();
     for (const { state, frameId } of compositeFrames) {
-      const target = designatedInitial(state);
+      const target = designatedInitial(state, frameId);
       if (!target)
         continue;
       const id2 = `__initial__${frameId}`;
       nodes.push({ id: id2, name: "", keyword: "initial", isDef: false, shape: "initial", frame: frameId });
-      edges.push({ id: `e${e++}`, from: id2, to: target, kind: "transition" });
+      compositeInitial.set(state, id2);
+      link(id2, target, void 0, void 0);
+    }
+    const sequentialTransitions = (holder, initialId, frameId) => {
+      let cursor;
+      const idOf = (member) => machineNodeIds.get(member) ?? idByState.get(member) ?? (nameOf2(member) ? resolveEndpoint(nameOf2(member), void 0, frameId) : void 0);
+      const endpoint = (path10) => resolveEndpoint(path10, initialId, frameId);
+      for (const member of membersOf(holder)) {
+        switch (member.$type) {
+          case "StateDecl": {
+            cursor = idOf(member) ?? cursor;
+            break;
+          }
+          // `entry;` IS the start pseudostate, so the succession written
+          // after it leaves that pseudostate rather than the last state.
+          case "EntryAction": {
+            if (isInitialMarker(member)) {
+              cursor = initialId;
+              break;
+            }
+            cursor = machineNodeIds.get(member) ?? cursor;
+            break;
+          }
+          // OMG 8.2.3.18 names this edge `st-succession`, so the
+          // keyworded form is a first-class state-transition edge,
+          // not action-language sugar the state view may skip.
+          // Its ends are ConnectorEnds, not bare paths.
+          case "SuccessionStmt": {
+            const succession = member;
+            let previous = endpoint(this.connectorEndPath(succession.first));
+            let firstHop = true;
+            for (const step of succession.steps ?? []) {
+              const to = endpoint(this.connectorEndPath(step));
+              link(previous, to, firstHop ? guardText(succession.guard) : void 0, member);
+              previous = to;
+              firstHop = false;
+            }
+            if (previous)
+              cursor = previous;
+            break;
+          }
+          case "FirstThenChain": {
+            const chain = member;
+            let previous = endpoint(chain.head);
+            let firstHop = true;
+            for (const step of chain.steps ?? []) {
+              const to = endpoint(step);
+              link(previous, to, firstHop ? guardText(chain.guard) : void 0, member);
+              previous = to;
+              firstHop = false;
+            }
+            if (previous)
+              cursor = previous;
+            break;
+          }
+          case "AcceptNode": {
+            const accept = member;
+            if (typeof accept.thenTarget !== "string")
+              break;
+            link(cursor, endpoint(accept.thenTarget), this.acceptShorthandLabel(member), member);
+            break;
+          }
+          case "ThenActionMember": {
+            const then = member;
+            const declared = this.thenActionMemberNode(member);
+            const to = (declared ? idOf(declared) : void 0) ?? endpoint(then.target);
+            link(cursor, to, void 0, member);
+            if (to)
+              cursor = to;
+            break;
+          }
+          // issue #113: a guarded or default target succession fans out
+          // of the SAME source (a decision node, normally), so neither
+          // branch may advance the cursor past its siblings.
+          case "IfActionNode": {
+            const branch = member;
+            if (typeof branch.thenTarget !== "string")
+              break;
+            link(cursor, endpoint(branch.thenTarget), guardText(branch.cond), member);
+            break;
+          }
+          case "ElseSuccessionMember": {
+            link(cursor, endpoint(member.target), "else", member);
+            break;
+          }
+          default: {
+            cursor = machineNodeIds.get(member) ?? cursor;
+            break;
+          }
+        }
+      }
+    };
+    for (const holder of machineScope(anchor)) {
+      sequentialTransitions(holder, hostsStateMachine ? "__initial__" : void 0, anchorFrameId);
+    }
+    for (const { state, frameId } of compositeFrames) {
+      for (const holder of machineScope(state)) {
+        sequentialTransitions(holder, compositeInitial.get(state), frameId);
+      }
     }
     const exhibitorsByState = /* @__PURE__ */ new Map();
     const exhibitScope = this.packageScopeOf(anchor);
@@ -167847,6 +168171,37 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         edges.push({ id: `e${e++}`, from, to, kind: "causation", label: "\xABcausation\xBB", source: sourceOf2(c, uri) });
       }
     }
+    const wired = /* @__PURE__ */ new Set();
+    for (const edge of edges) {
+      wired.add(edge.from);
+      wired.add(edge.to);
+    }
+    const stranded = new Set(machineNodeMembers.filter(({ id: id2 }) => !wired.has(id2)).map(({ id: id2 }) => id2));
+    if (stranded.size) {
+      for (let at = nodes.length - 1; at >= 0; at--) {
+        if (stranded.has(nodes[at].id))
+          nodes.splice(at, 1);
+      }
+    }
+    for (const { member, id: id2 } of machineNodeMembers) {
+      if (!stranded.has(id2))
+        registerDrawn(member);
+    }
+    for (const frame2 of frames) {
+      const full = frame2.compartments;
+      if (!full?.length)
+        continue;
+      const kept = full.map((compartment) => ({
+        title: compartment.title,
+        items: compartment.items.filter((row) => {
+          const key = rowKey(row.source);
+          return !key || !drawnRowKeys.has(key);
+        })
+      })).filter((compartment) => compartment.items.length > 0);
+      if (kept.length === full.length && kept.every((c, at) => c.items.length === full[at].items.length))
+        continue;
+      frame2.compartments = kept.length ? kept : void 0;
+    }
     const model = this.model("stv", anchor, nodes, edges);
     if (frames.length) {
       model.frames = frames;
@@ -170032,9 +170387,25 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       return item(m, val ? `= ${val}` : "(value)");
     }));
     add("states", usages(isStateDecl).map((m) => item(m)));
-    const stateActions = members.map((m) => ({ m, kind: { EntryAction: "entry", DoAction: "do", ExitAction: "exit" }[m.$type] })).filter((x) => !!x.kind);
-    add("state actions", stateActions.map(({ m, kind }) => item(m, `${kind} ${nameOf2(m) ?? ""}`.trim())));
+    const isInitialStateMarker = (m, at) => {
+      const entry = m;
+      if (m.$type !== "EntryAction" || entry.name || entry.actionKw || entry.send || entry.accept || entry.assign)
+        return false;
+      const next = members[at + 1];
+      return next?.$type === "ThenActionMember" || next?.$type === "FirstThenChain";
+    };
+    const stateActionTitle = {
+      EntryAction: "entry",
+      DoAction: "during",
+      ExitAction: "exit"
+    };
+    const stateActionText = (m) => nameOf2(m) ?? (m.$cstNode?.text ?? "").replace(/\s+/g, " ").replace(/;$/, "").replace(/^(entry|do|exit)\s+(action\s+)?/, "").trim();
+    for (const title of ["entry", "during", "exit"]) {
+      add(title, members.filter((m, at) => stateActionTitle[m.$type] === title && !isInitialStateMarker(m, at)).map((m) => item(m, stateActionText(m))).filter((row) => !!row.text));
+    }
     add("state transition", members.filter((m) => m.$type === "TransitionDecl").map((m) => item(m, `${m.from ?? ""} \u2192 ${m.to ?? ""}`)));
+    const successionText = (m) => (m.$cstNode?.text ?? "").replace(/\s+/g, " ").replace(/;$/, "").trim();
+    add("successions", members.filter((m) => m.$type === "FirstThenChain" || m.$type === "SuccessionStmt" || m.$type === "ThenActionMember" && typeof m.target === "string" || m.$type === "ElseSuccessionMember" || (m.$type === "AcceptNode" || m.$type === "IfActionNode") && typeof m.thenTarget === "string").map((m) => item(m, successionText(m))).filter((row) => !!row.text));
     add("assert constraints", members.filter((m) => m.$type === "AssertConstraintStmt").map((m) => item(m, exprText3(m) || nameOf2(m) || "assert constraint")));
     add("invariants", members.filter((m) => m.$type === "InvShorthand").map((m) => {
       const inv = m;
@@ -170043,6 +170414,31 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       return item(m, `${head2} { ${expr} }`.replace(/\s+/g, " ").trim());
     }));
     add("actions", usages(isActionDecl).map((m) => item(m)));
+    const performRowText = (m) => {
+      const referenced = this.behaviorReferenceText(m);
+      if (this.isAnonymousBehaviorReference(m))
+        return referenced || this.featureText(m);
+      const declared = this.featureText(m);
+      return referenced && referenced !== nameOf2(m) ? `${declared} references ${referenced}` : declared;
+    };
+    add("perform actions", members.filter((m) => m.$type === "PerformStmt").filter(isNonVariantMember).map((m) => item(m, performRowText(m))));
+    if (isActionFlowStep(node)) {
+      const scope = qnameOf(this.packageScopeOf(node));
+      const performerName = (part) => {
+        const qualified = qnameOf(part);
+        if (!qualified)
+          return nameOf2(part) ?? "?";
+        return scope && qualified.startsWith(`${scope}::`) ? qualified.slice(scope.length + 2) : qualified;
+      };
+      const claims = this.performClaimsByTarget(this.documentRootOf(node), index2).get(node) ?? [];
+      const seenPerformers = /* @__PURE__ */ new Set();
+      add("performed by", claims.map((claim) => ({ claim, part: this.declaringOwnerOf(claim) })).filter((entry) => !!entry.part && isPartDecl(entry.part)).map(({ claim, part }) => ({ text: performerName(part), source: sourceOf2(claim, uri) })).filter((row) => {
+        if (seenPerformers.has(row.text))
+          return false;
+        seenPerformers.add(row.text);
+        return true;
+      }));
+    }
     add("concerns", usages(isConcernDecl).map((m) => item(m)));
     add("viewpoints", usages(isViewpointDecl).map((m) => item(m)));
     add("exposes", members.filter((m) => m.$type === "ExposeMember").flatMap((m) => (m.paths ?? []).map((path10) => item(path10, this.featurePath(path10) ?? (path10.$cstNode?.text ?? "").replace(/\s+/g, " ").trim()))));
@@ -170125,9 +170521,19 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   // REQ-186/REQ-198 — transition label: `trigger [guard] / effect`.
   transitionLabel(t) {
     const tn = t;
-    const trigger = this.acceptTriggerLabel(tn.accept);
-    const guard = tn.guard?.$cstNode?.text?.replace(/\s+/g, " ").trim();
-    const effect = this.effectLabel(tn.effect);
+    return this.transitionLabelOf(tn.accept, tn.guard, tn.effect);
+  }
+  // REQ-198: the label of a source-less transition shorthand (`accept Sig if g
+  // do effect then t;`, OMG SysML 8.2.2.18.3). The accept node itself carries
+  // the trigger, so it reads exactly like an explicit `transition`.
+  acceptShorthandLabel(accept) {
+    const node = accept;
+    return this.transitionLabelOf(accept, node.guard, node.effect);
+  }
+  transitionLabelOf(accept, guardExpr, effectClause) {
+    const trigger = this.acceptTriggerLabel(accept);
+    const guard = guardExpr?.$cstNode?.text?.replace(/\s+/g, " ").trim();
+    const effect = this.effectLabel(effectClause);
     const parts = [];
     if (trigger)
       parts.push(String(trigger));
@@ -196775,7 +197181,7 @@ var AFV_LAYOUT_EDGE_KINDS = /* @__PURE__ */ new Set([
   "succession",
   "successionFlow"
 ]);
-var STV_LAYOUT_EDGE_KINDS = /* @__PURE__ */ new Set(["transition"]);
+var STV_LAYOUT_EDGE_KINDS = /* @__PURE__ */ new Set(["transition", "succession"]);
 function behaviorLayoutEdgeKinds(kind) {
   return kind === "afv" ? AFV_LAYOUT_EDGE_KINDS : kind === "stv" ? STV_LAYOUT_EDGE_KINDS : void 0;
 }
@@ -201984,6 +202390,10 @@ var TOOLBOX = {
     ],
     relations: [
       rel("transition", "transition", "\u2192", "click the source state, then the target state"),
+      // issue #113 - a machine's action and control nodes are sequenced by
+      // a succession, not by a transition: `transition` needs a state at
+      // both ends (OMG SysML 8.2.2.18.3), while `first a then b` does not.
+      rel("succession", "succession", "\u21E2", "click the source node, then the target node"),
       // issue #115 — nothing could mark the initial state, so a state
       // machine could not be STARTED from a blank canvas. The gesture runs
       // from the always-drawn initial pseudostate to the first state.
@@ -202142,7 +202552,11 @@ function normalizedElementKeyword(keyword) {
     "loop action",
     "for-loop action",
     "perform action",
-    "assign"
+    "assign",
+    // issue #113 — a state sub-action drawn as a node is an action node.
+    "entry action",
+    "do action",
+    "exit action"
   ].includes(base)) {
     base = "action";
   } else if (["fork", "join", "merge", "decide", "decision"].includes(base)) {
@@ -202244,7 +202658,12 @@ function relationToolsForNode(keyword, viewKind, shape) {
       if (base === "port") return false;
       return base === "pin" && (tool.kind === "flow" || tool.kind === "successionFlow" || tool.kind === "bind");
     }
-    if (viewKind === "stv") return base === "state" && tool.kind !== "initial";
+    if (viewKind === "stv") {
+      if (base === "action" || base === "control") {
+        return tool.kind === "succession" || tool.kind === TERMINAL_RELATION;
+      }
+      return base === "state" && tool.kind !== "initial";
+    }
     if (viewKind === "sv") return shape === "lifeline" && (base === "part" || base === "lifeline");
     if (viewKind === "cv") {
       if (base === "actor") return tool.kind === "actor";
@@ -204707,7 +205126,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.25.0" : "dev";
+var VERSION2 = true ? "0.27.0" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;