jssm 5.157.0 → 5.157.1

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.157.0 at 7/2/2026, 1:06:52 AM
+* Generated for version 5.157.1 at 7/2/2026, 1:36:48 AM
 
 -->
-# jssm 5.157.0
+# jssm 5.157.1
 
 [**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,862 tests at 100.0% line coverage
+  library.**  7,866 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,862 tests***, run 82,904 times.
+***7,866 tests***, run 82,908 times.
 
-- 7,104 specs with 100.0% coverage
-- 758 fuzz tests with 53.4% coverage
-- 9,871 TypeScript lines - 0.8 tests per line, 8.4 generated tests per line
+- 7,108 specs with 100.0% coverage
+- 758 fuzz tests with 53.5% coverage
+- 9,879 TypeScript lines - 0.8 tests per line, 8.4 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

@@ -20769,11 +20769,26 @@ const weighted_rand_select = (options, probability_property = 'probability', rng
     if (!(typeof options[0] === 'object')) {
         throw new TypeError('options must be a non-empty array of objects');
     }
-    const frand = rng
-        ? (cap) => rng() * cap
-        : (cap) => Math.random() * cap, or_one = (item) => item === undefined ? 1 : item, prob_sum = options.reduce((acc, val) => acc + or_one(val[probability_property]), 0), rnd = frand(prob_sum);
+    // called once per probabilistic walk step: plain loops, no per-call closure
+    // allocations (previously frand, or_one, and a reduce callback each call).
+    // undefined weights count as 1, as before.
+    let prob_sum = 0;
+    for (const opt of options) { // eslint-disable-line fp/no-loops
+        const p = opt[probability_property];
+        prob_sum += (p === undefined) ? 1 : p;
+    }
+    const rnd = (rng ? rng() : Math.random()) * prob_sum;
     let cursor = 0, cursor_sum = 0;
-    while (cursor < options.length && (cursor_sum += or_one(options[cursor++][probability_property])) <= rnd) { } // eslint-disable-line no-empty,fp/no-loops
+    // advance past each element whose running sum is <= rnd; the element that
+    // pushes the sum over rnd is the selection
+    while (cursor < options.length) { // eslint-disable-line fp/no-loops
+        const p = options[cursor][probability_property];
+        cursor_sum += (p === undefined) ? 1 : p;
+        ++cursor;
+        if (cursor_sum > rnd) {
+            break;
+        }
+    }
     return options[cursor - 1];
 };
 /* eslint-enable flowtype/no-weak-types */
@@ -23563,7 +23578,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.157.0";
+const version = "5.157.1";
 
 // whargarbl lots of these return arrays could/should be sets
 const { state_name_chars, state_name_first_chars, action_label_chars } = constants;
@@ -23864,8 +23879,11 @@ function find_connected_components(states, edges) {
         const component = [];
         const queue = [start];
         visited.add(start);
-        while (queue.length > 0) {
-            const node = queue.shift();
+        // index-pointer pop: Array.shift is O(n) per pop, making the BFS O(V²)
+        // worst case; reading by cursor keeps it O(V + E)
+        let head = 0;
+        while (head < queue.length) {
+            const node = queue[head++];
             component.push(node);
             for (const neighbor of adj.get(node)) {
                 if (!visited.has(neighbor)) {
@@ -24080,6 +24098,9 @@ class Machine {
         // 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();
+        // complete.includes was an O(|complete|) array scan per newly-created
+        // state — O(V·C) overall; one Set turns it into O(V)
+        const complete_set = new Set(complete);
         // walk the transitions.  single-lookup cursor fetches: each endpoint was
         // previously a get followed by a has on the same key (four hashes per
         // edge); the undefined check on the get's result carries the same
@@ -24094,12 +24115,12 @@ class Machine {
             // get the cursors.  what a mess
             let cursor_from = this._states.get(tr.from);
             if (cursor_from === undefined) {
-                cursor_from = { name: tr.from, from: [], to: [], complete: complete.includes(tr.from) };
+                cursor_from = { name: tr.from, from: [], to: [], complete: complete_set.has(tr.from) };
                 this._new_state(cursor_from);
             }
             let cursor_to = this._states.get(tr.to);
             if (cursor_to === undefined) {
-                cursor_to = { name: tr.to, from: [], to: [], complete: complete.includes(tr.to) };
+                cursor_to = { name: tr.to, from: [], to: [], complete: complete_set.has(tr.to) };
                 this._new_state(cursor_to);
             }
             // record (from -> to) adjacency once per distinct target, even when
@@ -25345,11 +25366,17 @@ class Machine {
         // filter -> filter chain and its three intermediate arrays; selection and
         // ordering semantics are unchanged
         const legal_exits = [], probability_bearing = [];
+        // hoisted: every exit shares whichState, so probe _edge_map for the
+        // from-side once instead of re-hashing the same key per exit inside
+        // lookup_transition_for.  wstate.to is non-empty only when at least one
+        // outbound edge exists, and every outbound edge creates the from-side
+        // mapping at construction — so emg is defined whenever the loop runs.
+        const emg = this._edge_map.get(whichState);
         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);
+            // wstate.to is built from the same edge set _edge_map indexes, so the
+            // per-target get cannot miss; the guard mirrors the old defensive
+            // .filter(Boolean) and is equally unreachable.
+            const edge = this._edges[emg.get(ws)];
             /* v8 ignore next */
             if (!edge) {
                 continue;
@@ -26750,12 +26777,23 @@ class Machine {
         // instead of O(E) — a large win on dense graphs where d << E.  The `?? []`
         // covers from-states that have no outgoing edges (terminal states) and
         // states that don't exist at all, both of which return [] without iterating.
+        //
+        // The match itself compares interned numeric state ids against the packed
+        // _edge_to_ids array rather than dereferencing each edge object for a
+        // string compare: non-matching edges never touch an edge object, which is
+        // most of the cost on dense shapes (heavier edge objects degrade a deref
+        // loop — the 5.142/5.143 regression mechanism).  Every state named by any
+        // edge is interned at construction, so an unknown `to` provably has no
+        // edges and returns [] immediately.
+        const to_id = this._state_interner.id_of(to);
+        if (to_id === undefined) {
+            return [];
+        }
         const outbound = (_a = this._outbound_edge_ids.get(from)) !== null && _a !== void 0 ? _a : [];
         const result = [];
         for (const edgeId of outbound) {
-            const edge = this._edges[edgeId];
-            if (edge.to === to) {
-                result.push(edge);
+            if (this._edge_to_ids[edgeId] === to_id) {
+                result.push(this._edges[edgeId]);
             }
         }
         return result;
@@ -27045,19 +27083,15 @@ 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) {
-                    // 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;
-                        }
-                    }
+                    // kind of the dispatched edge.  _edge_id_by_pair and _edge_map are
+                    // both first-declared-wins for parallel (from, to) pairs (see the
+                    // constructor around _edge_map / _edge_id_by_pair), and
+                    // _outbound_edge_ids fills in declaration order — so the old
+                    // first-match outbound scan always resolved to this same edgeId.
+                    // Direct read replaces the O(out-degree) object-deref scan; the
+                    // first-declared-kind semantics are pinned by the parallel-edge
+                    // transition-kind hook spec.  #735
+                    trans_type = this._edges[edgeId].kind;
                 }
                 valid = true;
                 newState = newStateOrAction;
@@ -27457,6 +27491,13 @@ class Machine {
      *  Called internally after each transition.
      */
     auto_set_state_timeout() {
+        // called on every successful transition-commit.  Machines with no `after`
+        // clauses at all (the overwhelmingly common case) previously still paid a
+        // string hash + map probe here per transition; one integer size read
+        // short-circuits that.
+        if (this._after_mapping.size === 0) {
+            return;
+        }
         const after_res = this._after_mapping.get(this._state);
         if (after_res !== undefined) {
             const [next_state, after_time] = after_res;
@@ -28742,6 +28783,14 @@ function is_hook_complex_result(hr) {
  *
  */
 function _update_hook_fields(hook_args, res) {
+    // HOOK_PASSED is the shared frozen outcome for "no hook installed" and for
+    // hooks returning true/undefined — the overwhelming majority of the up-to-
+    // ~10 steps per hooked transition.  It can never carry `data` (frozen, built
+    // without one), so one pointer compare replaces the hasOwnProperty
+    // reflection call for the common case.
+    if (res === HOOK_PASSED) {
+        return false;
+    }
     if (Object.prototype.hasOwnProperty.call(res, 'data')) {
         hook_args.data = res.data;
         hook_args.next_data = res.next_data;
@@ -28760,6 +28809,8 @@ function _update_hook_fields(hook_args, res) {
  *  so a shared instance is observationally identical; freezing turns that
  *  read-only contract from incidental into enforced.  Complex results (hooks
  *  returning `{ pass, data, ... }`) still pass through untouched.  #705
+ *  _update_hook_fields additionally identity-checks HOOK_PASSED to skip its
+ *  own-property probe on the common no-op outcome.
  *
  *  @see abstract_hook_step
  *  @see abstract_everything_hook_step

package/dist/cdn/viz.js

@@ -20794,11 +20794,26 @@ const weighted_rand_select = (options, probability_property = 'probability', rng
     if (!(typeof options[0] === 'object')) {
         throw new TypeError('options must be a non-empty array of objects');
     }
-    const frand = rng
-        ? (cap) => rng() * cap
-        : (cap) => Math.random() * cap, or_one = (item) => item === undefined ? 1 : item, prob_sum = options.reduce((acc, val) => acc + or_one(val[probability_property]), 0), rnd = frand(prob_sum);
+    // called once per probabilistic walk step: plain loops, no per-call closure
+    // allocations (previously frand, or_one, and a reduce callback each call).
+    // undefined weights count as 1, as before.
+    let prob_sum = 0;
+    for (const opt of options) { // eslint-disable-line fp/no-loops
+        const p = opt[probability_property];
+        prob_sum += (p === undefined) ? 1 : p;
+    }
+    const rnd = (rng ? rng() : Math.random()) * prob_sum;
     let cursor = 0, cursor_sum = 0;
-    while (cursor < options.length && (cursor_sum += or_one(options[cursor++][probability_property])) <= rnd) { } // eslint-disable-line no-empty,fp/no-loops
+    // advance past each element whose running sum is <= rnd; the element that
+    // pushes the sum over rnd is the selection
+    while (cursor < options.length) { // eslint-disable-line fp/no-loops
+        const p = options[cursor][probability_property];
+        cursor_sum += (p === undefined) ? 1 : p;
+        ++cursor;
+        if (cursor_sum > rnd) {
+            break;
+        }
+    }
     return options[cursor - 1];
 };
 /* eslint-enable flowtype/no-weak-types */
@@ -23588,7 +23603,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.157.0";
+const version = "5.157.1";
 
 // whargarbl lots of these return arrays could/should be sets
 const { state_name_chars, state_name_first_chars, action_label_chars } = constants;
@@ -23889,8 +23904,11 @@ function find_connected_components(states, edges) {
         const component = [];
         const queue = [start];
         visited.add(start);
-        while (queue.length > 0) {
-            const node = queue.shift();
+        // index-pointer pop: Array.shift is O(n) per pop, making the BFS O(V²)
+        // worst case; reading by cursor keeps it O(V + E)
+        let head = 0;
+        while (head < queue.length) {
+            const node = queue[head++];
             component.push(node);
             for (const neighbor of adj.get(node)) {
                 if (!visited.has(neighbor)) {
@@ -24105,6 +24123,9 @@ class Machine {
         // 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();
+        // complete.includes was an O(|complete|) array scan per newly-created
+        // state — O(V·C) overall; one Set turns it into O(V)
+        const complete_set = new Set(complete);
         // walk the transitions.  single-lookup cursor fetches: each endpoint was
         // previously a get followed by a has on the same key (four hashes per
         // edge); the undefined check on the get's result carries the same
@@ -24119,12 +24140,12 @@ class Machine {
             // get the cursors.  what a mess
             let cursor_from = this._states.get(tr.from);
             if (cursor_from === undefined) {
-                cursor_from = { name: tr.from, from: [], to: [], complete: complete.includes(tr.from) };
+                cursor_from = { name: tr.from, from: [], to: [], complete: complete_set.has(tr.from) };
                 this._new_state(cursor_from);
             }
             let cursor_to = this._states.get(tr.to);
             if (cursor_to === undefined) {
-                cursor_to = { name: tr.to, from: [], to: [], complete: complete.includes(tr.to) };
+                cursor_to = { name: tr.to, from: [], to: [], complete: complete_set.has(tr.to) };
                 this._new_state(cursor_to);
             }
             // record (from -> to) adjacency once per distinct target, even when
@@ -25370,11 +25391,17 @@ class Machine {
         // filter -> filter chain and its three intermediate arrays; selection and
         // ordering semantics are unchanged
         const legal_exits = [], probability_bearing = [];
+        // hoisted: every exit shares whichState, so probe _edge_map for the
+        // from-side once instead of re-hashing the same key per exit inside
+        // lookup_transition_for.  wstate.to is non-empty only when at least one
+        // outbound edge exists, and every outbound edge creates the from-side
+        // mapping at construction — so emg is defined whenever the loop runs.
+        const emg = this._edge_map.get(whichState);
         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);
+            // wstate.to is built from the same edge set _edge_map indexes, so the
+            // per-target get cannot miss; the guard mirrors the old defensive
+            // .filter(Boolean) and is equally unreachable.
+            const edge = this._edges[emg.get(ws)];
             /* v8 ignore next */
             if (!edge) {
                 continue;
@@ -26775,12 +26802,23 @@ class Machine {
         // instead of O(E) — a large win on dense graphs where d << E.  The `?? []`
         // covers from-states that have no outgoing edges (terminal states) and
         // states that don't exist at all, both of which return [] without iterating.
+        //
+        // The match itself compares interned numeric state ids against the packed
+        // _edge_to_ids array rather than dereferencing each edge object for a
+        // string compare: non-matching edges never touch an edge object, which is
+        // most of the cost on dense shapes (heavier edge objects degrade a deref
+        // loop — the 5.142/5.143 regression mechanism).  Every state named by any
+        // edge is interned at construction, so an unknown `to` provably has no
+        // edges and returns [] immediately.
+        const to_id = this._state_interner.id_of(to);
+        if (to_id === undefined) {
+            return [];
+        }
         const outbound = (_a = this._outbound_edge_ids.get(from)) !== null && _a !== void 0 ? _a : [];
         const result = [];
         for (const edgeId of outbound) {
-            const edge = this._edges[edgeId];
-            if (edge.to === to) {
-                result.push(edge);
+            if (this._edge_to_ids[edgeId] === to_id) {
+                result.push(this._edges[edgeId]);
             }
         }
         return result;
@@ -27070,19 +27108,15 @@ 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) {
-                    // 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;
-                        }
-                    }
+                    // kind of the dispatched edge.  _edge_id_by_pair and _edge_map are
+                    // both first-declared-wins for parallel (from, to) pairs (see the
+                    // constructor around _edge_map / _edge_id_by_pair), and
+                    // _outbound_edge_ids fills in declaration order — so the old
+                    // first-match outbound scan always resolved to this same edgeId.
+                    // Direct read replaces the O(out-degree) object-deref scan; the
+                    // first-declared-kind semantics are pinned by the parallel-edge
+                    // transition-kind hook spec.  #735
+                    trans_type = this._edges[edgeId].kind;
                 }
                 valid = true;
                 newState = newStateOrAction;
@@ -27482,6 +27516,13 @@ class Machine {
      *  Called internally after each transition.
      */
     auto_set_state_timeout() {
+        // called on every successful transition-commit.  Machines with no `after`
+        // clauses at all (the overwhelmingly common case) previously still paid a
+        // string hash + map probe here per transition; one integer size read
+        // short-circuits that.
+        if (this._after_mapping.size === 0) {
+            return;
+        }
         const after_res = this._after_mapping.get(this._state);
         if (after_res !== undefined) {
             const [next_state, after_time] = after_res;
@@ -28731,6 +28772,14 @@ function is_hook_complex_result(hr) {
  *
  */
 function _update_hook_fields(hook_args, res) {
+    // HOOK_PASSED is the shared frozen outcome for "no hook installed" and for
+    // hooks returning true/undefined — the overwhelming majority of the up-to-
+    // ~10 steps per hooked transition.  It can never carry `data` (frozen, built
+    // without one), so one pointer compare replaces the hasOwnProperty
+    // reflection call for the common case.
+    if (res === HOOK_PASSED) {
+        return false;
+    }
     if (Object.prototype.hasOwnProperty.call(res, 'data')) {
         hook_args.data = res.data;
         hook_args.next_data = res.next_data;
@@ -28749,6 +28798,8 @@ function _update_hook_fields(hook_args, res) {
  *  so a shared instance is observationally identical; freezing turns that
  *  read-only contract from incidental into enforced.  Complex results (hooks
  *  returning `{ pass, data, ... }`) still pass through untouched.  #705
+ *  _update_hook_fields additionally identity-checks HOOK_PASSED to skip its
+ *  own-property probe on the common no-op outcome.
  *
  *  @see abstract_hook_step
  *  @see abstract_everything_hook_step

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

@@ -108,7 +108,7 @@ function parseFslArgs(argv, spec) {
   return { positional, flags, helpText };
 }
 
-const getVersion = () => "5.157.0";
+const getVersion = () => "5.157.1";
 const SPEC = {
   flags: {
     help: { short: "h", boolean: true },