jssm 5.143.24 → 5.143.26

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.143.24 at 6/12/2026, 2:12:45 PM
+* Generated for version 5.143.26 at 6/12/2026, 2:39:54 PM
 
 -->
-# jssm 5.143.24
+# jssm 5.143.26
 
 [**Try the live editor**](https://stonecypher.github.io/jssm-viz-demo/graph_explorer.html) ·
 [Documentation](https://stonecypher.github.io/jssm/docs/) ·
@@ -281,7 +281,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,012 tests at 100.0% line coverage
+  library.**  7,013 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.
@@ -414,11 +414,11 @@ If your contribution is missing here, please open an issue.
 
 <br/>
 
-***7,012 tests***, run 81,856 times.
+***7,013 tests***, run 81,857 times.
 
-- 6,256 specs with 100.0% coverage
+- 6,257 specs with 100.0% coverage
 - 756 fuzz tests with 83.5% coverage
-- 5,876 TypeScript lines - 1.2 tests per line, 13.9 generated tests per line
+- 5,880 TypeScript lines - 1.2 tests per line, 13.9 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

@@ -3355,49 +3355,35 @@ function peg$parse(input, options) {
         return s0;
     }
     function peg$parseIntegerLiteral() {
-        var s0, s1, s2, s3, s4;
-        s0 = peg$currPos;
-        if (input.charCodeAt(peg$currPos) === 48) {
-            s1 = peg$c312;
+        var c, start;
+        c = input.charCodeAt(peg$currPos);
+        if (c === 48) { // '0' alternative
             peg$currPos++;
+            return '0';
         }
-        else {
-            s1 = peg$FAILED;
-            if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
-                peg$fail(peg$c313);
-            }
+        // the generated code records the "0" alternative's expectation whenever
+        // input doesn't start with 0 — including on the successful 1-9 path
+        if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
+            peg$fail(peg$c313);
         }
-        if (s1 === peg$FAILED) {
-            s1 = peg$currPos;
-            s2 = peg$parseNonZeroDigit();
-            if (s2 !== peg$FAILED) {
-                s3 = [];
-                s4 = peg$parseDecimalDigit();
-                while (s4 !== peg$FAILED) {
-                    s3.push(s4);
-                    s4 = peg$parseDecimalDigit();
-                }
-                if (s3 !== peg$FAILED) {
-                    s2 = [s2, s3];
-                    s1 = s2;
-                }
-                else {
-                    peg$currPos = s1;
-                    s1 = peg$FAILED;
-                }
+        if (c >= 49 && c <= 57) { // 1-9
+            start = peg$currPos;
+            peg$currPos++;
+            c = input.charCodeAt(peg$currPos);
+            while (c >= 48 && c <= 57) { // 0-9 run
+                peg$currPos++;
+                c = input.charCodeAt(peg$currPos);
             }
-            else {
-                peg$currPos = s1;
-                s1 = peg$FAILED;
+            // run-terminating DecimalDigit failure, recorded at the stop position
+            if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
+                peg$fail(peg$c315);
             }
+            return input.substring(start, peg$currPos);
         }
-        if (s1 !== peg$FAILED) {
-            s0 = input.substring(s0, peg$currPos);
-        }
-        else {
-            s0 = s1;
+        if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
+            peg$fail(peg$c317);
         }
-        return s0;
+        return peg$FAILED;
     }
     function peg$parseDecimalDigit() {
         var s0;
@@ -22402,7 +22388,7 @@ 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.143.24";
+const version = "5.143.26";
 
 // whargarbl lots of these return arrays could/should be sets
 const { state_name_chars, state_name_first_chars, action_label_chars } = constants;
@@ -25221,7 +25207,19 @@ class Machine {
             const edgeId = (to_id === undefined) ? undefined : this._edge_id_by_pair.get(pair_key(this._state_id, to_id));
             if ((edgeId !== undefined) && (!(this._edges[edgeId].forced_only))) {
                 if (this._has_transition_hooks || this._has_post_transition_hooks) {
-                    trans_type = this.edges_between(this._state, newStateOrAction)[0].kind; // TODO this won't do the right thing if various edges have different types
+                    // first matching outbound edge's kind, without building the result
+                    // array edges_between allocated here on every hooked transition.
+                    // First-match semantics are kept deliberately: _edge_map is
+                    // last-wins for multi-edge (from, to) pairs, so lookup_transition_for
+                    // could disagree with the old edges_between(...)[0].  #735
+                    // TODO this won't do the right thing if various edges have different types
+                    for (const ob_eid of this._outbound_edge_ids.get(this._state)) {
+                        const ob_edge = this._edges[ob_eid];
+                        if (ob_edge.to === newStateOrAction) {
+                            trans_type = ob_edge.kind;
+                            break;
+                        }
+                    }
                 }
                 valid = true;
                 newState = newStateOrAction;
@@ -25235,6 +25233,11 @@ class Machine {
         // unchanged for all downstream uses without introducing an impossible
         // (uncoverable) branch; the value is only dereferenced under the guards
         // that imply it was built.  #670
+        // NOTE (#735): the { ...hook_args, hook_name } spreads at the four
+        // everything-hook sites are contractual, not waste — handlers may capture
+        // their context, and each captured context must durably carry its own
+        // hook_name (pinned by the simultaneous-everything-hook specs).  A shared
+        // mutated object cannot satisfy that; do not "optimize" the spreads away.
         const hook_args_obj = (this._has_hooks || this._has_post_hooks)
             ? {
                 data: this._data,
@@ -25594,10 +25597,15 @@ class Machine {
                     cause: 'transition'
                 });
             }
-            if (this.state_is_terminal(newState)) {
+            // one state-record fetch answers both checks; newState is known-valid
+            // here, and the public state_is_terminal / state_is_complete pair would
+            // each redo has_state plus its own map walk.  Same predicates:
+            // terminal = no exits, complete = the constructor-set flag.  #735
+            const new_state_rec = this._states.get(newState);
+            if (new_state_rec.to.length === 0) {
                 this._fire('terminal', { state: newState, data: newData_after });
             }
-            if (this.state_is_complete(newState)) {
+            if (new_state_rec.complete) {
                 this._fire('complete', { state: newState, data: newData_after });
             }
         }

package/dist/cdn/viz.js

@@ -3380,49 +3380,35 @@ function peg$parse(input, options) {
         return s0;
     }
     function peg$parseIntegerLiteral() {
-        var s0, s1, s2, s3, s4;
-        s0 = peg$currPos;
-        if (input.charCodeAt(peg$currPos) === 48) {
-            s1 = peg$c312;
+        var c, start;
+        c = input.charCodeAt(peg$currPos);
+        if (c === 48) { // '0' alternative
             peg$currPos++;
+            return '0';
         }
-        else {
-            s1 = peg$FAILED;
-            if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
-                peg$fail(peg$c313);
-            }
+        // the generated code records the "0" alternative's expectation whenever
+        // input doesn't start with 0 — including on the successful 1-9 path
+        if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
+            peg$fail(peg$c313);
         }
-        if (s1 === peg$FAILED) {
-            s1 = peg$currPos;
-            s2 = peg$parseNonZeroDigit();
-            if (s2 !== peg$FAILED) {
-                s3 = [];
-                s4 = peg$parseDecimalDigit();
-                while (s4 !== peg$FAILED) {
-                    s3.push(s4);
-                    s4 = peg$parseDecimalDigit();
-                }
-                if (s3 !== peg$FAILED) {
-                    s2 = [s2, s3];
-                    s1 = s2;
-                }
-                else {
-                    peg$currPos = s1;
-                    s1 = peg$FAILED;
-                }
+        if (c >= 49 && c <= 57) { // 1-9
+            start = peg$currPos;
+            peg$currPos++;
+            c = input.charCodeAt(peg$currPos);
+            while (c >= 48 && c <= 57) { // 0-9 run
+                peg$currPos++;
+                c = input.charCodeAt(peg$currPos);
             }
-            else {
-                peg$currPos = s1;
-                s1 = peg$FAILED;
+            // run-terminating DecimalDigit failure, recorded at the stop position
+            if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
+                peg$fail(peg$c315);
             }
+            return input.substring(start, peg$currPos);
         }
-        if (s1 !== peg$FAILED) {
-            s0 = input.substring(s0, peg$currPos);
-        }
-        else {
-            s0 = s1;
+        if (peg$silentFails === 0 && peg$currPos >= peg$maxFailPos) {
+            peg$fail(peg$c317);
         }
-        return s0;
+        return peg$FAILED;
     }
     function peg$parseDecimalDigit() {
         var s0;
@@ -22427,7 +22413,7 @@ 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.143.24";
+const version = "5.143.26";
 
 // whargarbl lots of these return arrays could/should be sets
 const { state_name_chars, state_name_first_chars, action_label_chars } = constants;
@@ -25246,7 +25232,19 @@ class Machine {
             const edgeId = (to_id === undefined) ? undefined : this._edge_id_by_pair.get(pair_key(this._state_id, to_id));
             if ((edgeId !== undefined) && (!(this._edges[edgeId].forced_only))) {
                 if (this._has_transition_hooks || this._has_post_transition_hooks) {
-                    trans_type = this.edges_between(this._state, newStateOrAction)[0].kind; // TODO this won't do the right thing if various edges have different types
+                    // first matching outbound edge's kind, without building the result
+                    // array edges_between allocated here on every hooked transition.
+                    // First-match semantics are kept deliberately: _edge_map is
+                    // last-wins for multi-edge (from, to) pairs, so lookup_transition_for
+                    // could disagree with the old edges_between(...)[0].  #735
+                    // TODO this won't do the right thing if various edges have different types
+                    for (const ob_eid of this._outbound_edge_ids.get(this._state)) {
+                        const ob_edge = this._edges[ob_eid];
+                        if (ob_edge.to === newStateOrAction) {
+                            trans_type = ob_edge.kind;
+                            break;
+                        }
+                    }
                 }
                 valid = true;
                 newState = newStateOrAction;
@@ -25260,6 +25258,11 @@ class Machine {
         // unchanged for all downstream uses without introducing an impossible
         // (uncoverable) branch; the value is only dereferenced under the guards
         // that imply it was built.  #670
+        // NOTE (#735): the { ...hook_args, hook_name } spreads at the four
+        // everything-hook sites are contractual, not waste — handlers may capture
+        // their context, and each captured context must durably carry its own
+        // hook_name (pinned by the simultaneous-everything-hook specs).  A shared
+        // mutated object cannot satisfy that; do not "optimize" the spreads away.
         const hook_args_obj = (this._has_hooks || this._has_post_hooks)
             ? {
                 data: this._data,
@@ -25619,10 +25622,15 @@ class Machine {
                     cause: 'transition'
                 });
             }
-            if (this.state_is_terminal(newState)) {
+            // one state-record fetch answers both checks; newState is known-valid
+            // here, and the public state_is_terminal / state_is_complete pair would
+            // each redo has_state plus its own map walk.  Same predicates:
+            // terminal = no exits, complete = the constructor-set flag.  #735
+            const new_state_rec = this._states.get(newState);
+            if (new_state_rec.to.length === 0) {
                 this._fire('terminal', { state: newState, data: newData_after });
             }
-            if (this.state_is_complete(newState)) {
+            if (new_state_rec.complete) {
                 this._fire('complete', { state: newState, data: newData_after });
             }
         }