jssm 5.143.16 → 5.143.21

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.16 at 6/12/2026, 10:06:43 AM
+* Generated for version 5.143.21 at 6/12/2026, 1:26:44 PM
 
 -->
-# jssm 5.143.16
+# jssm 5.143.21
 
 [**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.**  6,987 tests at 100.0% line coverage
+  library.**  7,009 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/>
 
-***6,987 tests***, run 81,831 times.
+***7,009 tests***, run 81,853 times.
 
-- 6,231 specs with 100.0% coverage
+- 6,253 specs with 100.0% coverage
 - 756 fuzz tests with 83.6% coverage
-- 5,865 TypeScript lines - 1.2 tests per line, 14.0 generated tests per line
+- 5,870 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

@@ -20751,9 +20751,9 @@ function seq(n) {
     if (n < 0) {
         throw new TypeError('seq/1 takes a non-negative integer n as an argument');
     }
-    return (new Array(n))
-        .fill(true)
-        .map((_, i) => i);
+    // single-allocation form; the old new Array(n).fill().map() chain built
+    // three arrays per call, and seq runs per probabilistic walk / sample
+    return Array.from({ length: n }, (_, i) => i);
 }
 /*******
  *
@@ -20836,7 +20836,22 @@ function gen_splitmix32(a) {
  *  ```
  *
  */
-const unique = (arr) => arr.filter((v, i, a) => a.indexOf(v) === i);
+const unique = (arr) => {
+    // Set membership makes this O(n); the old indexOf-per-element filter was
+    // O(n^2).  NaN is dropped *explicitly* here because Sets self-match NaN
+    // (SameValueZero) where the documented indexOf behavior (===) never did.
+    const seen = new Set();
+    return arr.filter((v) => {
+        if (v !== v) {
+            return false;
+        } // NaN: preserve documented dropping
+        if (seen.has(v)) {
+            return false;
+        }
+        seen.add(v);
+        return true;
+    });
+};
 /*******
  *
  *  Lists all repeated items in an array along with their counts.  Subject to
@@ -22788,7 +22803,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.16";
+const version = "5.143.21";
 
 // whargarbl lots of these return arrays could/should be sets
 const { state_name_chars, state_name_first_chars, action_label_chars } = constants;
@@ -24064,7 +24079,8 @@ class Machine {
      *  @returns `true` if the machine has at least one action.
      */
     get uses_actions() {
-        return Array.from(this._actions.keys()).length > 0;
+        // Map.size answers emptiness without materializing the key list
+        return this._actions.size > 0;
     }
     /** Whether any forced (`~>`) transitions exist in this machine.
      *  @returns `true` if at least one forced transition is defined.
@@ -24341,17 +24357,31 @@ class Machine {
         if (!(wstate)) {
             throw new JssmError(this, `No such state ${JSON.stringify(whichState)} in probable_exits_for`);
         }
-        const wstate_to = wstate.to, 
-        // every transition that exits whichState
-        all_exits = wstate_to
-            .map((ws) => this.lookup_transition_for(whichState, ws))
-            .filter(Boolean), 
-        // forced-only exits cannot be reached by transition(), so they are
-        // never legal probabilistic outcomes
-        legal_exits = all_exits.filter((e) => !e.forced_only), 
-        // if any legal exit declares a probability, filter to those only so
-        // that probability-bearing edges are not diluted by their peers
-        probability_bearing = legal_exits.filter((e) => e.probability !== undefined);
+        // single pass over the state's exits, replacing the old map -> filter ->
+        // filter -> filter chain and its three intermediate arrays; selection and
+        // ordering semantics are unchanged
+        const legal_exits = [], probability_bearing = [];
+        for (const ws of wstate.to) {
+            // wstate.to is built from the same edge set lookup_transition_for
+            // resolves against, so the lookup cannot miss; the guard mirrors the
+            // old defensive .filter(Boolean) and is equally unreachable.
+            const edge = this.lookup_transition_for(whichState, ws);
+            /* v8 ignore next */
+            if (!edge) {
+                continue;
+            }
+            // forced-only exits cannot be reached by transition(), so they are
+            // never legal probabilistic outcomes
+            if (edge.forced_only) {
+                continue;
+            }
+            legal_exits.push(edge);
+            // if any legal exit declares a probability, only those are returned, so
+            // that probability-bearing edges are not diluted by their peers
+            if (edge.probability !== undefined) {
+                probability_bearing.push(edge);
+            }
+        }
         return (probability_bearing.length > 0) ? probability_bearing : legal_exits;
     }
     /** Take a single random transition from the current state, weighted by

package/dist/cdn/viz.js

@@ -20776,9 +20776,9 @@ function seq(n) {
     if (n < 0) {
         throw new TypeError('seq/1 takes a non-negative integer n as an argument');
     }
-    return (new Array(n))
-        .fill(true)
-        .map((_, i) => i);
+    // single-allocation form; the old new Array(n).fill().map() chain built
+    // three arrays per call, and seq runs per probabilistic walk / sample
+    return Array.from({ length: n }, (_, i) => i);
 }
 /*******
  *
@@ -20861,7 +20861,22 @@ function gen_splitmix32(a) {
  *  ```
  *
  */
-const unique = (arr) => arr.filter((v, i, a) => a.indexOf(v) === i);
+const unique = (arr) => {
+    // Set membership makes this O(n); the old indexOf-per-element filter was
+    // O(n^2).  NaN is dropped *explicitly* here because Sets self-match NaN
+    // (SameValueZero) where the documented indexOf behavior (===) never did.
+    const seen = new Set();
+    return arr.filter((v) => {
+        if (v !== v) {
+            return false;
+        } // NaN: preserve documented dropping
+        if (seen.has(v)) {
+            return false;
+        }
+        seen.add(v);
+        return true;
+    });
+};
 /*******
  *
  *  Lists all repeated items in an array along with their counts.  Subject to
@@ -22813,7 +22828,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.16";
+const version = "5.143.21";
 
 // whargarbl lots of these return arrays could/should be sets
 const { state_name_chars, state_name_first_chars, action_label_chars } = constants;
@@ -24089,7 +24104,8 @@ class Machine {
      *  @returns `true` if the machine has at least one action.
      */
     get uses_actions() {
-        return Array.from(this._actions.keys()).length > 0;
+        // Map.size answers emptiness without materializing the key list
+        return this._actions.size > 0;
     }
     /** Whether any forced (`~>`) transitions exist in this machine.
      *  @returns `true` if at least one forced transition is defined.
@@ -24366,17 +24382,31 @@ class Machine {
         if (!(wstate)) {
             throw new JssmError(this, `No such state ${JSON.stringify(whichState)} in probable_exits_for`);
         }
-        const wstate_to = wstate.to, 
-        // every transition that exits whichState
-        all_exits = wstate_to
-            .map((ws) => this.lookup_transition_for(whichState, ws))
-            .filter(Boolean), 
-        // forced-only exits cannot be reached by transition(), so they are
-        // never legal probabilistic outcomes
-        legal_exits = all_exits.filter((e) => !e.forced_only), 
-        // if any legal exit declares a probability, filter to those only so
-        // that probability-bearing edges are not diluted by their peers
-        probability_bearing = legal_exits.filter((e) => e.probability !== undefined);
+        // single pass over the state's exits, replacing the old map -> filter ->
+        // filter -> filter chain and its three intermediate arrays; selection and
+        // ordering semantics are unchanged
+        const legal_exits = [], probability_bearing = [];
+        for (const ws of wstate.to) {
+            // wstate.to is built from the same edge set lookup_transition_for
+            // resolves against, so the lookup cannot miss; the guard mirrors the
+            // old defensive .filter(Boolean) and is equally unreachable.
+            const edge = this.lookup_transition_for(whichState, ws);
+            /* v8 ignore next */
+            if (!edge) {
+                continue;
+            }
+            // forced-only exits cannot be reached by transition(), so they are
+            // never legal probabilistic outcomes
+            if (edge.forced_only) {
+                continue;
+            }
+            legal_exits.push(edge);
+            // if any legal exit declares a probability, only those are returned, so
+            // that probability-bearing edges are not diluted by their peers
+            if (edge.probability !== undefined) {
+                probability_bearing.push(edge);
+            }
+        }
         return (probability_bearing.length > 0) ? probability_bearing : legal_exits;
     }
     /** Take a single random transition from the current state, weighted by