jssm 5.141.3 → 5.141.5

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.141.3 at 6/2/2026, 9:10:12 AM
+* Generated for version 5.141.5 at 6/4/2026, 3:42:26 PM
 
 -->
-# jssm 5.141.3
+# jssm 5.141.5
 
 [**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,482 tests at 100.0% line coverage
+  library.**  6,484 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,482 tests***, run 57,269 times.
+***6,484 tests***, run 57,271 times.
 
-- 5,969 specs with 100.0% coverage
+- 5,971 specs with 100.0% coverage
 - 513 fuzz tests with 3.4% coverage
-- 5,566 TypeScript lines - 1.2 tests per line, 10.3 generated tests per line
+- 5,581 TypeScript lines - 1.2 tests per line, 10.3 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

@@ -21327,7 +21327,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.141.3";
+const version = "5.141.5";
 
 // whargarbl lots of these return arrays could/should be sets
 const { state_name_chars, state_name_first_chars, action_label_chars } = constants;
@@ -21643,6 +21643,11 @@ 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
+        const seen_edges = new Map();
         // walk the transitions
         transitions.map((tr) => {
             if (tr.from === undefined) {
@@ -21662,11 +21667,20 @@ class Machine {
             if (!(this._states.has(tr.to))) {
                 this._new_state(cursor_to);
             }
-            // guard against existing connections being re-added
-            if (cursor_from.to.includes(tr.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);
                 cursor_from.to.push(tr.to);
                 cursor_to.from.push(tr.from);
             }
@@ -23032,6 +23046,62 @@ class Machine {
         this._event_listener_count++;
         return () => { this._unsubscribe_entry(set, entry); };
     }
+    /**
+     *  Invoke a single event-handler entry, respecting its filter, once-removal
+     *  semantics, and the error re-fire / recursion-guard logic.  Extracted so
+     *  {@link _fire} can share identical behavior between the size-1 fast-path
+     *  and the general snapshotted loop.
+     *
+     *  @param entry  - The subscriber descriptor to invoke.
+     *  @param set    - The live Set that owns `entry`; needed for once-removal.
+     *  @param name   - The event name being dispatched (used in error re-fires).
+     *  @param detail - The event payload forwarded to the handler.
+     *
+     *  @internal
+     */
+    _fire_one(entry, set, name, detail) {
+        // filter check
+        if (entry.filter !== undefined) {
+            for (const k of Object.keys(entry.filter)) {
+                if (entry.filter[k] !== detail[k]) {
+                    return;
+                }
+            }
+        }
+        // once removal happens BEFORE invocation so a throwing handler still
+        // gets removed and so re-entrant `on` calls during the handler see
+        // the post-removal state.
+        if (entry.once) {
+            this._unsubscribe_entry(set, entry);
+        }
+        try {
+            entry.handler(detail);
+        }
+        catch (err) {
+            if (name === 'error' || this._firing_error) {
+                // surface to stderr as a last resort but never recurse;
+                // `console` is in the JS standard library and present in every
+                // supported runtime, so guarding it would just add an untestable
+                // branch.  See #638.
+                // eslint-disable-next-line no-console
+                console.error(err);
+            }
+            else {
+                this._firing_error = true;
+                try {
+                    this._fire('error', {
+                        error: err,
+                        source_event: name,
+                        source_detail: detail,
+                        handler: entry.handler
+                    });
+                }
+                finally {
+                    this._firing_error = false;
+                }
+            }
+        }
+    }
     /**
      *  Dispatch an event to every registered subscriber in registration
      *  order.  Filters are checked first; non-matching handlers are skipped
@@ -23043,6 +23113,11 @@ class Machine {
      *  handler throws, the new exception is swallowed rather than rebroadcast
      *  to avoid an infinite loop.
      *
+     *  When exactly one subscriber is registered the common case avoids the
+     *  `Array.from(set)` snapshot allocation by capturing the lone entry into a
+     *  local first — equivalent to a 1-element snapshot but allocation-free.
+     *  The general path still snapshots for re-entrancy safety.
+     *
      *  @internal
      */
     _fire(name, detail) {
@@ -23050,55 +23125,19 @@ class Machine {
         if (set === undefined || set.size === 0) {
             return;
         }
-        // Snapshot so handlers can `off()` mid-loop without disturbing iteration.
+        // Fast-path: single subscriber — capture entry before invoking so that
+        // even if the handler mutates `set` (via off/once auto-removal) we hold a
+        // stable reference.  Behaviorally identical to a 1-element snapshot.
+        if (set.size === 1) {
+            const only = set.values().next().value;
+            this._fire_one(only, set, name, detail);
+            return;
+        }
+        // General path: snapshot so handlers can `off()` mid-loop without
+        // disturbing iteration.
         const entries = Array.from(set);
         for (const entry of entries) {
-            // filter check
-            if (entry.filter !== undefined) {
-                let matched = true;
-                for (const k of Object.keys(entry.filter)) {
-                    if (entry.filter[k] !== detail[k]) {
-                        matched = false;
-                        break;
-                    }
-                }
-                if (!matched) {
-                    continue;
-                }
-            }
-            // once removal happens BEFORE invocation so a throwing handler still
-            // gets removed and so re-entrant `on` calls during the handler see
-            // the post-removal state.
-            if (entry.once) {
-                this._unsubscribe_entry(set, entry);
-            }
-            try {
-                entry.handler(detail);
-            }
-            catch (err) {
-                if (name === 'error' || this._firing_error) {
-                    // surface to stderr as a last resort but never recurse;
-                    // `console` is in the JS standard library and present in every
-                    // supported runtime, so guarding it would just add an untestable
-                    // branch.  See #638.
-                    // eslint-disable-next-line no-console
-                    console.error(err);
-                }
-                else {
-                    this._firing_error = true;
-                    try {
-                        this._fire('error', {
-                            error: err,
-                            source_event: name,
-                            source_detail: detail,
-                            handler: entry.handler
-                        });
-                    }
-                    finally {
-                        this._firing_error = false;
-                    }
-                }
-            }
+            this._fire_one(entry, set, name, detail);
         }
     }
     /** Low-level hook registration.  Installs a handler described by a

package/dist/cdn/viz.js

@@ -21352,7 +21352,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.141.3";
+const version = "5.141.5";
 
 // whargarbl lots of these return arrays could/should be sets
 const { state_name_chars, state_name_first_chars, action_label_chars } = constants;
@@ -21668,6 +21668,11 @@ 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
+        const seen_edges = new Map();
         // walk the transitions
         transitions.map((tr) => {
             if (tr.from === undefined) {
@@ -21687,11 +21692,20 @@ class Machine {
             if (!(this._states.has(tr.to))) {
                 this._new_state(cursor_to);
             }
-            // guard against existing connections being re-added
-            if (cursor_from.to.includes(tr.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);
                 cursor_from.to.push(tr.to);
                 cursor_to.from.push(tr.from);
             }
@@ -23057,6 +23071,62 @@ class Machine {
         this._event_listener_count++;
         return () => { this._unsubscribe_entry(set, entry); };
     }
+    /**
+     *  Invoke a single event-handler entry, respecting its filter, once-removal
+     *  semantics, and the error re-fire / recursion-guard logic.  Extracted so
+     *  {@link _fire} can share identical behavior between the size-1 fast-path
+     *  and the general snapshotted loop.
+     *
+     *  @param entry  - The subscriber descriptor to invoke.
+     *  @param set    - The live Set that owns `entry`; needed for once-removal.
+     *  @param name   - The event name being dispatched (used in error re-fires).
+     *  @param detail - The event payload forwarded to the handler.
+     *
+     *  @internal
+     */
+    _fire_one(entry, set, name, detail) {
+        // filter check
+        if (entry.filter !== undefined) {
+            for (const k of Object.keys(entry.filter)) {
+                if (entry.filter[k] !== detail[k]) {
+                    return;
+                }
+            }
+        }
+        // once removal happens BEFORE invocation so a throwing handler still
+        // gets removed and so re-entrant `on` calls during the handler see
+        // the post-removal state.
+        if (entry.once) {
+            this._unsubscribe_entry(set, entry);
+        }
+        try {
+            entry.handler(detail);
+        }
+        catch (err) {
+            if (name === 'error' || this._firing_error) {
+                // surface to stderr as a last resort but never recurse;
+                // `console` is in the JS standard library and present in every
+                // supported runtime, so guarding it would just add an untestable
+                // branch.  See #638.
+                // eslint-disable-next-line no-console
+                console.error(err);
+            }
+            else {
+                this._firing_error = true;
+                try {
+                    this._fire('error', {
+                        error: err,
+                        source_event: name,
+                        source_detail: detail,
+                        handler: entry.handler
+                    });
+                }
+                finally {
+                    this._firing_error = false;
+                }
+            }
+        }
+    }
     /**
      *  Dispatch an event to every registered subscriber in registration
      *  order.  Filters are checked first; non-matching handlers are skipped
@@ -23068,6 +23138,11 @@ class Machine {
      *  handler throws, the new exception is swallowed rather than rebroadcast
      *  to avoid an infinite loop.
      *
+     *  When exactly one subscriber is registered the common case avoids the
+     *  `Array.from(set)` snapshot allocation by capturing the lone entry into a
+     *  local first — equivalent to a 1-element snapshot but allocation-free.
+     *  The general path still snapshots for re-entrancy safety.
+     *
      *  @internal
      */
     _fire(name, detail) {
@@ -23075,55 +23150,19 @@ class Machine {
         if (set === undefined || set.size === 0) {
             return;
         }
-        // Snapshot so handlers can `off()` mid-loop without disturbing iteration.
+        // Fast-path: single subscriber — capture entry before invoking so that
+        // even if the handler mutates `set` (via off/once auto-removal) we hold a
+        // stable reference.  Behaviorally identical to a 1-element snapshot.
+        if (set.size === 1) {
+            const only = set.values().next().value;
+            this._fire_one(only, set, name, detail);
+            return;
+        }
+        // General path: snapshot so handlers can `off()` mid-loop without
+        // disturbing iteration.
         const entries = Array.from(set);
         for (const entry of entries) {
-            // filter check
-            if (entry.filter !== undefined) {
-                let matched = true;
-                for (const k of Object.keys(entry.filter)) {
-                    if (entry.filter[k] !== detail[k]) {
-                        matched = false;
-                        break;
-                    }
-                }
-                if (!matched) {
-                    continue;
-                }
-            }
-            // once removal happens BEFORE invocation so a throwing handler still
-            // gets removed and so re-entrant `on` calls during the handler see
-            // the post-removal state.
-            if (entry.once) {
-                this._unsubscribe_entry(set, entry);
-            }
-            try {
-                entry.handler(detail);
-            }
-            catch (err) {
-                if (name === 'error' || this._firing_error) {
-                    // surface to stderr as a last resort but never recurse;
-                    // `console` is in the JS standard library and present in every
-                    // supported runtime, so guarding it would just add an untestable
-                    // branch.  See #638.
-                    // eslint-disable-next-line no-console
-                    console.error(err);
-                }
-                else {
-                    this._firing_error = true;
-                    try {
-                        this._fire('error', {
-                            error: err,
-                            source_event: name,
-                            source_detail: detail,
-                            handler: entry.handler
-                        });
-                    }
-                    finally {
-                        this._firing_error = false;
-                    }
-                }
-            }
+            this._fire_one(entry, set, name, detail);
         }
     }
     /** Low-level hook registration.  Installs a handler described by a