jssm 5.144.7 → 5.145.0

package/README.md

@@ -18,10 +18,10 @@ Please edit the file it's derived from, instead: `./src/md/readme_base.md`
 
 
 
-* Generated for version 5.144.7 at 6/22/2026, 1:32:53 PM
+* Generated for version 5.145.0 at 6/22/2026, 4:40:44 PM
 
 -->
-# jssm 5.144.7
+# jssm 5.145.0
 
 [**Try the live editor**](https://stonecypher.github.io/jssm-viz-demo/graph_explorer.html) ·
 [Documentation](https://stonecypher.github.io/jssm/docs/) ·
@@ -312,7 +312,7 @@ That decision shows up everywhere downstream:
   or run `npm run benny` against your own machine.
 
 - **More thoroughly tested than any other JavaScript state-machine
-  library.**  7,317 tests at 100.0% line coverage
+  library.**  7,345 tests at 100.0% line coverage
   ([report](https://coveralls.io/github/StoneCypher/jssm)), plus
   fuzz testing via `fast-check`, with parser test data across ten natural
   languages and Emoji.
@@ -445,11 +445,11 @@ If your contribution is missing here, please open an issue.
 
 <br/>
 
-***7,317 tests***, run 82,359 times.
+***7,345 tests***, run 82,387 times.
 
-- 6,559 specs with 100.0% coverage
-- 758 fuzz tests with 73.7% coverage
-- 6,889 TypeScript lines - 1.1 tests per line, 12.0 generated tests per line
+- 6,587 specs with 100.0% coverage
+- 758 fuzz tests with 73.6% coverage
+- 6,962 TypeScript lines - 1.1 tests per line, 11.8 generated tests per line
 
 [![Actions Status](https://github.com/StoneCypher/jssm/workflows/Node%20CI/badge.svg)](https://github.com/StoneCypher/jssm/actions)
 [![NPM version](https://img.shields.io/npm/v/jssm.svg)](https://www.npmjs.com/package/jssm)

package/dist/cdn/instance.js

@@ -23512,11 +23512,48 @@ var constants = /*#__PURE__*/Object.freeze({
  *  Useful for runtime diagnostics and for embedding in serialized machine
  *  snapshots so that deserializers can detect version-skew.
  */
-const version = "5.144.7";
+const version = "5.145.0";
 
 // whargarbl lots of these return arrays could/should be sets
 const { state_name_chars, state_name_first_chars, action_label_chars } = constants;
 const empty_string_set = new Set();
+// The spatial fields (besides `handler`, which every hook needs) that each
+// hook kind requires, mirroring exactly what `set_hook` reads per case.  Used
+// to validate a HookDescription so a mis-shaped one is rejected rather than
+// silently registering a dead hook — e.g. an `exit` hook given `to` instead of
+// `from` would otherwise intern `undefined` and never fire (#734).  Typed as a
+// `Record` over the kind union so the table is exhaustive at compile time:
+// adding a hook kind without listing its fields is a build error.
+const hook_required_fields = {
+    'hook': ['from', 'to'],
+    'named': ['from', 'to', 'action'],
+    'global action': ['action'],
+    'any action': [],
+    'standard transition': [],
+    'main transition': [],
+    'forced transition': [],
+    'any transition': [],
+    'entry': ['to'],
+    'exit': ['from'],
+    'after': ['from'],
+    'post hook': ['from', 'to'],
+    'post named': ['from', 'to', 'action'],
+    'post global action': ['action'],
+    'post any action': [],
+    'post standard transition': [],
+    'post main transition': [],
+    'post forced transition': [],
+    'post any transition': [],
+    'post entry': ['to'],
+    'post exit': ['from'],
+    'pre everything': [],
+    'everything': [],
+    'pre post everything': [],
+    'post everything': [],
+};
+// The spatial fields a hook descriptor can carry, checked against the per-kind
+// requirements above.
+const hook_spatial_fields = ['from', 'to', 'action'];
 /*********
  *
  *  An internal method meant to take a series of declarations and fold them into
@@ -23974,10 +24011,16 @@ class Machine {
                 this._state_labels.set(key, labelled[0].value);
             }
         });
-        // O(1) duplicate-edge guard for the construction loop below: from -> Set<to>.
-        // Keyed by source state; mirrors each state's `to` array with constant-time
-        // membership so the dedup check is O(1) per edge rather than an O(out-degree)
-        // array scan (which made construction O(V*E) on dense graphs).  #673
+        // Duplicate-edge guard for the construction loop below, keyed
+        // from -> (to -> Set<slot>).  A "slot" distinguishes edges that share a
+        // (from, to) pair: an action's name for an actioned edge, or '' for the one
+        // permitted plain action-less edge.  Multiple edges between the same pair
+        // are allowed when they carry distinct actions (#325; the self-loop case is
+        // #531), since they dispatch unambiguously through `action(name)`.  A
+        // probability-bearing action-less edge is exempt from the guard entirely,
+        // so a weighted fan-out may name the same target more than once.  The
+        // nested Map+Set keeps the check O(1) per edge rather than an O(out-degree)
+        // scan (which made construction O(V*E) on dense graphs).  #673
         const seen_edges = new Map();
         // walk the transitions.  single-lookup cursor fetches: each endpoint was
         // previously a get followed by a has on the same key (four hashes per
@@ -24001,23 +24044,35 @@ class Machine {
                 cursor_to = { name: tr.to, from: [], to: [], complete: complete.includes(tr.to) };
                 this._new_state(cursor_to);
             }
-            // guard against existing connections being re-added — O(1) via the
-            // from -> Set<to> index instead of an O(out-degree) `cursor_from.to`
-            // array scan.  Behaviour is identical: the same duplicate (from, to)
-            // pair throws the same JssmError.  #673
-            let seen_to = seen_edges.get(tr.from);
-            if (seen_to === undefined) {
-                seen_to = new Set();
-                seen_edges.set(tr.from, seen_to);
-            }
-            if (seen_to.has(tr.to)) {
-                throw new JssmError(this, `already has ${JSON.stringify(tr.from)} to ${JSON.stringify(tr.to)}`);
-            }
-            else {
-                seen_to.add(tr.to);
+            // record (from -> to) adjacency once per distinct target, even when
+            // several edges connect the pair, so the `to`/`from` arrays stay sets of
+            // state names.  #673
+            let to_slots = seen_edges.get(tr.from);
+            if (to_slots === undefined) {
+                to_slots = new Map();
+                seen_edges.set(tr.from, to_slots);
+            }
+            let slots = to_slots.get(tr.to);
+            if (slots === undefined) {
+                slots = new Set();
+                to_slots.set(tr.to, slots);
                 cursor_from.to.push(tr.to);
                 cursor_to.from.push(tr.from);
             }
+            // duplicate-edge guard.  A probability-bearing action-less edge is exempt
+            // (a weighted fan-out may repeat a target); every other edge claims a slot
+            // — its action name, or '' for the one plain action-less edge — and a
+            // repeated slot throws.  Distinct actions between the same pair coexist
+            // (#325/#531).
+            const edge_exempt = (!tr.action) && (tr.probability !== undefined);
+            if (!edge_exempt) {
+                const slot = tr.action ? tr.action : '';
+                if (slots.has(slot)) {
+                    throw new JssmError(this, `already has ${JSON.stringify(tr.from)} to ${JSON.stringify(tr.to)}`
+                        + (tr.action ? ` on action ${JSON.stringify(tr.action)}` : ''));
+                }
+                slots.add(slot);
+            }
             // add the edge; note its id
             this._edges.push(tr);
             const thisEdgeId = this._edges.length - 1;
@@ -24043,14 +24098,23 @@ class Machine {
                 from_mapping = new Map();
                 this._edge_map.set(tr.from, from_mapping);
             }
-            //    const to_mapping = from_mapping.get(tr.to);
-            from_mapping.set(tr.to, thisEdgeId); // already checked that this mapping doesn't exist, above
+            // first-declared wins: when several edges share a (from, to) pair (parallel
+            // action edges, #325), lookup_transition_for resolves to the first one
+            // declared, so it agrees with edges_between(...)[0].
+            if (!from_mapping.has(tr.to)) {
+                from_mapping.set(tr.to, thisEdgeId);
+            }
             // numeric mirror of the (from, to) endpoint mapping.  intern() rather
             // than id_of(): idempotent, and returns number (not number|undefined)
             // since both endpoints were just created above if missing.
             const from_id = this._state_interner.intern(tr.from);
             const to_id = this._state_interner.intern(tr.to);
-            this._edge_id_by_pair.set(pair_key(from_id, to_id), thisEdgeId);
+            // first-declared wins (see _edge_map above): the transition fast-path that
+            // reads this index resolves parallel (from, to) pairs to the first edge.
+            const pair = pair_key(from_id, to_id);
+            if (!this._edge_id_by_pair.has(pair)) {
+                this._edge_id_by_pair.set(pair, thisEdgeId);
+            }
             this._edge_to_ids[thisEdgeId] = to_id;
             // outbound adjacency: every edge originating at tr.from, regardless of action/target.
             // _edge_map above keys a single edge per (from, to) and overwrites on collision, which
@@ -25774,7 +25838,44 @@ class Machine {
      *  calling this directly.
      *  @param HookDesc - A hook descriptor specifying kind, states, and handler.
      */
+    /**
+     *  Validate a {@link HookDescription} before registration.  Every hook needs
+     *  a `handler` function, and each kind's identifying spatial fields
+     *  (`from`/`to`/`action`) must be exactly those `set_hook` reads for that
+     *  kind — present when required, absent otherwise.  This turns a mis-shaped
+     *  descriptor into a thrown error instead of a silently dead hook keyed on
+     *  `undefined` (e.g. an `exit` hook handed `to` instead of `from`, #734).
+     *
+     *  @param HookDesc - The descriptor about to be registered.
+     *  @throws JssmError if the kind is unknown, the handler is not a function, a
+     *          required field is missing, or an inapplicable field is present.
+     *
+     *  @example
+     *    const m = sm`a -> b;`;
+     *    // an exit hook is keyed by `from`, so supplying `to` is rejected:
+     *    expect(() => m.set_hook({ kind: 'exit', to: 'a', handler: () => true })).toThrow();
+     */
+    _validate_hook_description(HookDesc) {
+        const required = hook_required_fields[HookDesc.kind];
+        if (required === undefined) {
+            throw new JssmError(this, `unknown hook kind ${JSON.stringify(HookDesc.kind)}`);
+        }
+        if (typeof HookDesc.handler !== 'function') {
+            throw new JssmError(this, `${HookDesc.kind} hook requires a handler function`);
+        }
+        for (const field of hook_spatial_fields) {
+            const needed = required.includes(field);
+            const present = HookDesc[field] !== undefined;
+            if (needed && !present) {
+                throw new JssmError(this, `${HookDesc.kind} hook requires '${field}'`);
+            }
+            if (!needed && present) {
+                throw new JssmError(this, `${HookDesc.kind} hook does not take '${field}'`);
+            }
+        }
+    }
     set_hook(HookDesc) {
+        this._validate_hook_description(HookDesc);
         switch (HookDesc.kind) {
             case 'hook': {
                 // Numeric pair key (#729).  intern() rather than id_of(): a hook may
@@ -25916,8 +26017,8 @@ class Machine {
                 this._post_everything_hook = HookDesc.handler;
                 this._has_post_hooks = true;
                 break;
-            default:
-                throw new JssmError(this, `Unknown hook type ${HookDesc.kind}, should be impossible`);
+            // No default: `_validate_hook_description` above rejects any unknown kind
+            // before we reach here, so the switch is exhaustive over the known kinds.
         }
         // The hooked-state styling layer (tier 2.5 of resolve_state_config) depends
         // on which states carry hooks, so registering a hook can change the composed

package/dist/cdn/viz.js

@@ -23537,11 +23537,48 @@ var constants = /*#__PURE__*/Object.freeze({
  *  Useful for runtime diagnostics and for embedding in serialized machine
  *  snapshots so that deserializers can detect version-skew.
  */
-const version = "5.144.7";
+const version = "5.145.0";
 
 // whargarbl lots of these return arrays could/should be sets
 const { state_name_chars, state_name_first_chars, action_label_chars } = constants;
 const empty_string_set = new Set();
+// The spatial fields (besides `handler`, which every hook needs) that each
+// hook kind requires, mirroring exactly what `set_hook` reads per case.  Used
+// to validate a HookDescription so a mis-shaped one is rejected rather than
+// silently registering a dead hook — e.g. an `exit` hook given `to` instead of
+// `from` would otherwise intern `undefined` and never fire (#734).  Typed as a
+// `Record` over the kind union so the table is exhaustive at compile time:
+// adding a hook kind without listing its fields is a build error.
+const hook_required_fields = {
+    'hook': ['from', 'to'],
+    'named': ['from', 'to', 'action'],
+    'global action': ['action'],
+    'any action': [],
+    'standard transition': [],
+    'main transition': [],
+    'forced transition': [],
+    'any transition': [],
+    'entry': ['to'],
+    'exit': ['from'],
+    'after': ['from'],
+    'post hook': ['from', 'to'],
+    'post named': ['from', 'to', 'action'],
+    'post global action': ['action'],
+    'post any action': [],
+    'post standard transition': [],
+    'post main transition': [],
+    'post forced transition': [],
+    'post any transition': [],
+    'post entry': ['to'],
+    'post exit': ['from'],
+    'pre everything': [],
+    'everything': [],
+    'pre post everything': [],
+    'post everything': [],
+};
+// The spatial fields a hook descriptor can carry, checked against the per-kind
+// requirements above.
+const hook_spatial_fields = ['from', 'to', 'action'];
 /*********
  *
  *  An internal method meant to take a series of declarations and fold them into
@@ -23999,10 +24036,16 @@ class Machine {
                 this._state_labels.set(key, labelled[0].value);
             }
         });
-        // O(1) duplicate-edge guard for the construction loop below: from -> Set<to>.
-        // Keyed by source state; mirrors each state's `to` array with constant-time
-        // membership so the dedup check is O(1) per edge rather than an O(out-degree)
-        // array scan (which made construction O(V*E) on dense graphs).  #673
+        // Duplicate-edge guard for the construction loop below, keyed
+        // from -> (to -> Set<slot>).  A "slot" distinguishes edges that share a
+        // (from, to) pair: an action's name for an actioned edge, or '' for the one
+        // permitted plain action-less edge.  Multiple edges between the same pair
+        // are allowed when they carry distinct actions (#325; the self-loop case is
+        // #531), since they dispatch unambiguously through `action(name)`.  A
+        // probability-bearing action-less edge is exempt from the guard entirely,
+        // so a weighted fan-out may name the same target more than once.  The
+        // nested Map+Set keeps the check O(1) per edge rather than an O(out-degree)
+        // scan (which made construction O(V*E) on dense graphs).  #673
         const seen_edges = new Map();
         // walk the transitions.  single-lookup cursor fetches: each endpoint was
         // previously a get followed by a has on the same key (four hashes per
@@ -24026,23 +24069,35 @@ class Machine {
                 cursor_to = { name: tr.to, from: [], to: [], complete: complete.includes(tr.to) };
                 this._new_state(cursor_to);
             }
-            // guard against existing connections being re-added — O(1) via the
-            // from -> Set<to> index instead of an O(out-degree) `cursor_from.to`
-            // array scan.  Behaviour is identical: the same duplicate (from, to)
-            // pair throws the same JssmError.  #673
-            let seen_to = seen_edges.get(tr.from);
-            if (seen_to === undefined) {
-                seen_to = new Set();
-                seen_edges.set(tr.from, seen_to);
-            }
-            if (seen_to.has(tr.to)) {
-                throw new JssmError(this, `already has ${JSON.stringify(tr.from)} to ${JSON.stringify(tr.to)}`);
-            }
-            else {
-                seen_to.add(tr.to);
+            // record (from -> to) adjacency once per distinct target, even when
+            // several edges connect the pair, so the `to`/`from` arrays stay sets of
+            // state names.  #673
+            let to_slots = seen_edges.get(tr.from);
+            if (to_slots === undefined) {
+                to_slots = new Map();
+                seen_edges.set(tr.from, to_slots);
+            }
+            let slots = to_slots.get(tr.to);
+            if (slots === undefined) {
+                slots = new Set();
+                to_slots.set(tr.to, slots);
                 cursor_from.to.push(tr.to);
                 cursor_to.from.push(tr.from);
             }
+            // duplicate-edge guard.  A probability-bearing action-less edge is exempt
+            // (a weighted fan-out may repeat a target); every other edge claims a slot
+            // — its action name, or '' for the one plain action-less edge — and a
+            // repeated slot throws.  Distinct actions between the same pair coexist
+            // (#325/#531).
+            const edge_exempt = (!tr.action) && (tr.probability !== undefined);
+            if (!edge_exempt) {
+                const slot = tr.action ? tr.action : '';
+                if (slots.has(slot)) {
+                    throw new JssmError(this, `already has ${JSON.stringify(tr.from)} to ${JSON.stringify(tr.to)}`
+                        + (tr.action ? ` on action ${JSON.stringify(tr.action)}` : ''));
+                }
+                slots.add(slot);
+            }
             // add the edge; note its id
             this._edges.push(tr);
             const thisEdgeId = this._edges.length - 1;
@@ -24068,14 +24123,23 @@ class Machine {
                 from_mapping = new Map();
                 this._edge_map.set(tr.from, from_mapping);
             }
-            //    const to_mapping = from_mapping.get(tr.to);
-            from_mapping.set(tr.to, thisEdgeId); // already checked that this mapping doesn't exist, above
+            // first-declared wins: when several edges share a (from, to) pair (parallel
+            // action edges, #325), lookup_transition_for resolves to the first one
+            // declared, so it agrees with edges_between(...)[0].
+            if (!from_mapping.has(tr.to)) {
+                from_mapping.set(tr.to, thisEdgeId);
+            }
             // numeric mirror of the (from, to) endpoint mapping.  intern() rather
             // than id_of(): idempotent, and returns number (not number|undefined)
             // since both endpoints were just created above if missing.
             const from_id = this._state_interner.intern(tr.from);
             const to_id = this._state_interner.intern(tr.to);
-            this._edge_id_by_pair.set(pair_key(from_id, to_id), thisEdgeId);
+            // first-declared wins (see _edge_map above): the transition fast-path that
+            // reads this index resolves parallel (from, to) pairs to the first edge.
+            const pair = pair_key(from_id, to_id);
+            if (!this._edge_id_by_pair.has(pair)) {
+                this._edge_id_by_pair.set(pair, thisEdgeId);
+            }
             this._edge_to_ids[thisEdgeId] = to_id;
             // outbound adjacency: every edge originating at tr.from, regardless of action/target.
             // _edge_map above keys a single edge per (from, to) and overwrites on collision, which
@@ -25799,7 +25863,44 @@ class Machine {
      *  calling this directly.
      *  @param HookDesc - A hook descriptor specifying kind, states, and handler.
      */
+    /**
+     *  Validate a {@link HookDescription} before registration.  Every hook needs
+     *  a `handler` function, and each kind's identifying spatial fields
+     *  (`from`/`to`/`action`) must be exactly those `set_hook` reads for that
+     *  kind — present when required, absent otherwise.  This turns a mis-shaped
+     *  descriptor into a thrown error instead of a silently dead hook keyed on
+     *  `undefined` (e.g. an `exit` hook handed `to` instead of `from`, #734).
+     *
+     *  @param HookDesc - The descriptor about to be registered.
+     *  @throws JssmError if the kind is unknown, the handler is not a function, a
+     *          required field is missing, or an inapplicable field is present.
+     *
+     *  @example
+     *    const m = sm`a -> b;`;
+     *    // an exit hook is keyed by `from`, so supplying `to` is rejected:
+     *    expect(() => m.set_hook({ kind: 'exit', to: 'a', handler: () => true })).toThrow();
+     */
+    _validate_hook_description(HookDesc) {
+        const required = hook_required_fields[HookDesc.kind];
+        if (required === undefined) {
+            throw new JssmError(this, `unknown hook kind ${JSON.stringify(HookDesc.kind)}`);
+        }
+        if (typeof HookDesc.handler !== 'function') {
+            throw new JssmError(this, `${HookDesc.kind} hook requires a handler function`);
+        }
+        for (const field of hook_spatial_fields) {
+            const needed = required.includes(field);
+            const present = HookDesc[field] !== undefined;
+            if (needed && !present) {
+                throw new JssmError(this, `${HookDesc.kind} hook requires '${field}'`);
+            }
+            if (!needed && present) {
+                throw new JssmError(this, `${HookDesc.kind} hook does not take '${field}'`);
+            }
+        }
+    }
     set_hook(HookDesc) {
+        this._validate_hook_description(HookDesc);
         switch (HookDesc.kind) {
             case 'hook': {
                 // Numeric pair key (#729).  intern() rather than id_of(): a hook may
@@ -25941,8 +26042,8 @@ class Machine {
                 this._post_everything_hook = HookDesc.handler;
                 this._has_post_hooks = true;
                 break;
-            default:
-                throw new JssmError(this, `Unknown hook type ${HookDesc.kind}, should be impossible`);
+            // No default: `_validate_hook_description` above rejects any unknown kind
+            // before we reach here, so the switch is exhaustive over the known kinds.
         }
         // The hooked-state styling layer (tier 2.5 of resolve_state_config) depends
         // on which states carry hooks, so registering a hook can change the composed
@@ -29182,37 +29283,55 @@ function colored_label(tr, which, color) {
 function states_to_edges_string(u_jssm, l_states, state_index, state_kinds) {
     const strike = new Set();
     const kind_of = (s) => { var _a; return (_a = state_kinds.get(s)) !== null && _a !== void 0 ? _a : 'base'; };
+    // Render one solo directed edge `s -> ex` for transition `tr`.
+    const solo_edge = (s, ex, tr) => {
+        const ex_kind = kind_of(ex);
+        const tailColor = text_color(ex_kind, '_solo');
+        const labelInline = colored_label(tr, 'taillabel', tailColor);
+        const label = transition_label(tr);
+        const maybeLabel = label ? `taillabel="${doublequote(label)}";` : '';
+        const arrowHead = arrow_for(tr);
+        const edgeInline = `${maybeLabel}arrowhead=${arrowHead};color="${line_color(ex_kind, tr.kind, '_solo')}"`;
+        return `${node_of(s, state_index)}->${node_of(ex, state_index)} [${labelInline}${edgeInline}];`;
+    };
     return l_states.map((s) => u_jssm.list_exits(s).map((ex) => {
         if (strike.has(`${s}|${ex}`)) {
             return '';
         }
-        const edge_tr = u_jssm.lookup_transition_for(s, ex);
-        if (!edge_tr) {
+        const forward = u_jssm.edges_between(s, ex);
+        if (forward.length === 0) {
             return '';
         } // belt-and-suspenders; list_exits should always have a corresponding transition
-        const pair_tr = u_jssm.lookup_transition_for(ex, s);
-        const double = (pair_tr !== undefined) && (s !== ex);
-        const s_kind = kind_of(s);
-        const ex_kind = kind_of(ex);
-        // colored-HTML labels (per-direction, with text colors)
-        const headColor = text_color(s_kind, double ? '_1' : '_solo');
-        const tailColor = text_color(ex_kind, double ? '_2' : '_solo');
-        const labelInline = colored_label(double ? pair_tr : undefined, 'headlabel', headColor) +
-            colored_label(edge_tr, 'taillabel', tailColor);
-        // plain `headlabel="..."` / `taillabel="..."` fallback
-        const label = transition_label(edge_tr);
-        const rlabel = transition_label(pair_tr);
-        const maybeLabel = label ? `taillabel="${doublequote(label)}";` : '';
-        const maybeRLabel = rlabel ? `headlabel="${doublequote(rlabel)}";` : '';
-        const arrowHead = arrow_for(edge_tr);
-        const arrowTail = arrow_for(pair_tr);
-        const edgeInline = double
-            ? `${maybeLabel}${maybeRLabel}arrowhead=${arrowHead};arrowtail=${arrowTail};dir=both;color="${line_color(ex_kind, edge_tr.kind, '_1')}:${line_color(s_kind, (pair_tr !== null && pair_tr !== void 0 ? pair_tr : { kind: 'legal' }).kind, '_2')}"`
-            : `${maybeLabel}arrowhead=${arrowHead};color="${line_color(ex_kind, edge_tr.kind, '_solo')}"`;
-        if (pair_tr) {
+        const reverse = (s !== ex) ? u_jssm.edges_between(ex, s) : [];
+        // Bidirectional merge stays the default for the common case: exactly one
+        // edge each way between two distinct states draws as a single `dir=both`
+        // edge with head/tail labels.  Parallel edges (#325) or self-loops fall
+        // through to one directed line per edge.
+        if (forward.length === 1 && reverse.length === 1) {
+            const edge_tr = forward[0];
+            const pair_tr = reverse[0];
+            const s_kind = kind_of(s);
+            const ex_kind = kind_of(ex);
+            // colored-HTML labels (per-direction, with text colors)
+            const headColor = text_color(s_kind, '_1');
+            const tailColor = text_color(ex_kind, '_2');
+            const labelInline = colored_label(pair_tr, 'headlabel', headColor) +
+                colored_label(edge_tr, 'taillabel', tailColor);
+            // plain `headlabel="..."` / `taillabel="..."` fallback
+            const label = transition_label(edge_tr);
+            const rlabel = transition_label(pair_tr);
+            const maybeLabel = label ? `taillabel="${doublequote(label)}";` : '';
+            const maybeRLabel = rlabel ? `headlabel="${doublequote(rlabel)}";` : '';
+            const arrowHead = arrow_for(edge_tr);
+            const arrowTail = arrow_for(pair_tr);
+            const edgeInline = `${maybeLabel}${maybeRLabel}arrowhead=${arrowHead};arrowtail=${arrowTail};dir=both;color="${line_color(ex_kind, edge_tr.kind, '_1')}:${line_color(s_kind, pair_tr.kind, '_2')}"`;
             strike.add(`${ex}|${s}`);
+            return `${node_of(s, state_index)}->${node_of(ex, state_index)} [${labelInline}${edgeInline}];`;
         }
-        return `${node_of(s, state_index)}->${node_of(ex, state_index)} [${labelInline}${edgeInline}];`;
+        // one directed line per forward edge — parallel action edges (#325) and
+        // self-loops (#531) draw each transition separately.  The reverse edges,
+        // if any, render when the loop reaches the (ex, s) pair (not struck here).
+        return forward.map((tr) => solo_edge(s, ex, tr)).join(' ');
     }).join(' ')).join(' ');
 }
 /**

package/dist/cli/fsl-export-system-prompt.cjs

@@ -108,7 +108,7 @@ function parseFslArgs(argv, spec) {
   return { positional, flags, helpText };
 }
 
-const getVersion = () => "5.144.7";
+const getVersion = () => "5.145.0";
 const SPEC = {
   flags: {
     help: { short: "h", boolean: true },
@@ -214,6 +214,6 @@ async function cli(argv) {
 async function main() {
   const argv = process.argv.slice(2);
   const code = await cli(argv);
-  process.exit(code);
+  process.exitCode = code;
 }
 void main();