jssm 5.141.1 → 5.141.2

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.1 at 6/1/2026, 7:35:45 PM
+* Generated for version 5.141.2 at 6/2/2026, 7:18:20 AM
 
 -->
-# jssm 5.141.1
+# jssm 5.141.2
 
 [**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,458 tests at 100.0% line coverage
+  library.**  6,473 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,458 tests***, run 57,245 times.
+***6,473 tests***, run 57,260 times.
 
-- 5,945 specs with 100.0% coverage
+- 5,960 specs with 100.0% coverage
 - 513 fuzz tests with 3.4% coverage
-- 5,555 TypeScript lines - 1.2 tests per line, 10.3 generated tests per line
+- 5,566 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.1";
+const version = "5.141.2";
 
 // whargarbl lots of these return arrays could/should be sets
 const { state_name_chars, state_name_first_chars, action_label_chars } = constants;
@@ -21622,6 +21622,7 @@ class Machine {
         this._timeout_target_time = undefined;
         this._after_mapping = new Map();
         this._event_handlers = new Map();
+        this._event_listener_count = 0;
         this._firing_error = false;
         // consolidate the state declarations
         if (state_declaration) {
@@ -22978,12 +22979,28 @@ class Machine {
         }
         for (const entry of set) {
             if (entry.handler === handler) {
-                set.delete(entry);
+                this._unsubscribe_entry(set, entry);
                 return true;
             }
         }
         return false;
     }
+    /**
+     *  Remove one event-subscription entry from its set and keep
+     *  {@link Machine._event_listener_count} in sync.  The count is decremented
+     *  only when the entry was actually present, so calling a stale unsubscribe
+     *  closure (or removing an already-fired `once` entry) is idempotent and
+     *  cannot drive the count negative.
+     *
+     *  @param set   The per-event-name subscription set.
+     *  @param entry The entry to remove.
+     *  @internal
+     */
+    _unsubscribe_entry(set, entry) {
+        if (set.delete(entry)) {
+            this._event_listener_count--;
+        }
+    }
     /**
      *  Shared registration core used by {@link Machine.on} and
      *  {@link Machine.once}.  Normalizes the optional filter argument and
@@ -23012,7 +23029,8 @@ class Machine {
         }
         const entry = { handler, filter, once };
         set.add(entry);
-        return () => { set.delete(entry); };
+        this._event_listener_count++;
+        return () => { this._unsubscribe_entry(set, entry); };
     }
     /**
      *  Dispatch an event to every registered subscriber in registration
@@ -23052,7 +23070,7 @@ class Machine {
             // gets removed and so re-entrant `on` calls during the handler see
             // the post-removal state.
             if (entry.once) {
-                set.delete(entry);
+                this._unsubscribe_entry(set, entry);
             }
             try {
                 entry.handler(detail);
@@ -23861,15 +23879,25 @@ class Machine {
                 newState = newStateOrAction;
             }
         }
-        const hook_args = {
-            data: this._data,
-            action: fromAction,
-            from: this._state,
-            to: newState,
-            next_data: newData,
-            forced: wasForced,
-            trans_type
-        };
+        // hook_args is read only inside the `_has_hooks` / `_has_post_hooks`
+        // blocks below.  Skip building it for hook-free machines (every
+        // chain/dense/hub/messy benchmark shape) so the hot path stops allocating
+        // a 7-field object it never reads.  The NonNullable cast keeps the type
+        // 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
+        const hook_args_obj = (this._has_hooks || this._has_post_hooks)
+            ? {
+                data: this._data,
+                action: fromAction,
+                from: this._state,
+                to: newState,
+                next_data: newData,
+                forced: wasForced,
+                trans_type
+            }
+            : undefined;
+        const hook_args = hook_args_obj;
         // 'action' event fires when an action is attempted, regardless of whether
         // it ultimately succeeds — matches the issue spec for observation events.
         if (wasAction) {
@@ -24155,46 +24183,53 @@ class Machine {
                 this._post_everything_hook(Object.assign(Object.assign({}, hook_args), { hook_name: 'post everything' }));
             }
         }
-        // observation events: fire after the state has been committed and all
-        // hooks (pre and post) have completed, matching the semantics that
-        // events observe rather than intercept (#638).
-        const newData_after = this._data;
-        this._fire('exit', {
-            state: fromState,
-            to: newState,
-            action: fromAction,
-            data: newData_after
-        });
-        this._fire('transition', {
-            from: fromState,
-            to: newState,
-            action: fromAction,
-            data: newData_after,
-            next_data: newData,
-            trans_type,
-            forced: wasForced
-        });
-        this._fire('entry', {
-            state: newState,
-            from: fromState,
-            action: fromAction,
-            data: newData_after
-        });
-        if (oldData !== newData_after) {
-            this._fire('data-change', {
+        // Observation events (#638) fire after the state is committed.  Each call
+        // builds a detail literal at the call site, so guard the whole block on a
+        // live subscription count: with zero listeners (the common hot-path case,
+        // and every benchmark shape) we skip all of these allocations entirely.
+        // Read after pre-hooks, so a listener a pre-hook installed is still seen.
+        // ('action' above and 'rejection' on the invalid path are intentionally
+        // NOT under this gate — they fire regardless, and `_fire` itself no-ops
+        // cheaply when that specific event has no subscribers.)  #670
+        if (this._event_listener_count !== 0) {
+            const newData_after = this._data;
+            this._fire('exit', {
+                state: fromState,
+                to: newState,
+                action: fromAction,
+                data: newData_after
+            });
+            this._fire('transition', {
                 from: fromState,
                 to: newState,
                 action: fromAction,
-                old_data: oldData,
-                new_data: newData_after,
-                cause: 'transition'
+                data: newData_after,
+                next_data: newData,
+                trans_type,
+                forced: wasForced
             });
-        }
-        if (this.state_is_terminal(newState)) {
-            this._fire('terminal', { state: newState, data: newData_after });
-        }
-        if (this.state_is_complete(newState)) {
-            this._fire('complete', { state: newState, data: newData_after });
+            this._fire('entry', {
+                state: newState,
+                from: fromState,
+                action: fromAction,
+                data: newData_after
+            });
+            if (oldData !== newData_after) {
+                this._fire('data-change', {
+                    from: fromState,
+                    to: newState,
+                    action: fromAction,
+                    old_data: oldData,
+                    new_data: newData_after,
+                    cause: 'transition'
+                });
+            }
+            if (this.state_is_terminal(newState)) {
+                this._fire('terminal', { state: newState, data: newData_after });
+            }
+            if (this.state_is_complete(newState)) {
+                this._fire('complete', { state: newState, data: newData_after });
+            }
         }
         // possibly re-establish new 'after' clause
         this.auto_set_state_timeout();

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.1";
+const version = "5.141.2";
 
 // whargarbl lots of these return arrays could/should be sets
 const { state_name_chars, state_name_first_chars, action_label_chars } = constants;
@@ -21647,6 +21647,7 @@ class Machine {
         this._timeout_target_time = undefined;
         this._after_mapping = new Map();
         this._event_handlers = new Map();
+        this._event_listener_count = 0;
         this._firing_error = false;
         // consolidate the state declarations
         if (state_declaration) {
@@ -23003,12 +23004,28 @@ class Machine {
         }
         for (const entry of set) {
             if (entry.handler === handler) {
-                set.delete(entry);
+                this._unsubscribe_entry(set, entry);
                 return true;
             }
         }
         return false;
     }
+    /**
+     *  Remove one event-subscription entry from its set and keep
+     *  {@link Machine._event_listener_count} in sync.  The count is decremented
+     *  only when the entry was actually present, so calling a stale unsubscribe
+     *  closure (or removing an already-fired `once` entry) is idempotent and
+     *  cannot drive the count negative.
+     *
+     *  @param set   The per-event-name subscription set.
+     *  @param entry The entry to remove.
+     *  @internal
+     */
+    _unsubscribe_entry(set, entry) {
+        if (set.delete(entry)) {
+            this._event_listener_count--;
+        }
+    }
     /**
      *  Shared registration core used by {@link Machine.on} and
      *  {@link Machine.once}.  Normalizes the optional filter argument and
@@ -23037,7 +23054,8 @@ class Machine {
         }
         const entry = { handler, filter, once };
         set.add(entry);
-        return () => { set.delete(entry); };
+        this._event_listener_count++;
+        return () => { this._unsubscribe_entry(set, entry); };
     }
     /**
      *  Dispatch an event to every registered subscriber in registration
@@ -23077,7 +23095,7 @@ class Machine {
             // gets removed and so re-entrant `on` calls during the handler see
             // the post-removal state.
             if (entry.once) {
-                set.delete(entry);
+                this._unsubscribe_entry(set, entry);
             }
             try {
                 entry.handler(detail);
@@ -23886,15 +23904,25 @@ class Machine {
                 newState = newStateOrAction;
             }
         }
-        const hook_args = {
-            data: this._data,
-            action: fromAction,
-            from: this._state,
-            to: newState,
-            next_data: newData,
-            forced: wasForced,
-            trans_type
-        };
+        // hook_args is read only inside the `_has_hooks` / `_has_post_hooks`
+        // blocks below.  Skip building it for hook-free machines (every
+        // chain/dense/hub/messy benchmark shape) so the hot path stops allocating
+        // a 7-field object it never reads.  The NonNullable cast keeps the type
+        // 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
+        const hook_args_obj = (this._has_hooks || this._has_post_hooks)
+            ? {
+                data: this._data,
+                action: fromAction,
+                from: this._state,
+                to: newState,
+                next_data: newData,
+                forced: wasForced,
+                trans_type
+            }
+            : undefined;
+        const hook_args = hook_args_obj;
         // 'action' event fires when an action is attempted, regardless of whether
         // it ultimately succeeds — matches the issue spec for observation events.
         if (wasAction) {
@@ -24180,46 +24208,53 @@ class Machine {
                 this._post_everything_hook(Object.assign(Object.assign({}, hook_args), { hook_name: 'post everything' }));
             }
         }
-        // observation events: fire after the state has been committed and all
-        // hooks (pre and post) have completed, matching the semantics that
-        // events observe rather than intercept (#638).
-        const newData_after = this._data;
-        this._fire('exit', {
-            state: fromState,
-            to: newState,
-            action: fromAction,
-            data: newData_after
-        });
-        this._fire('transition', {
-            from: fromState,
-            to: newState,
-            action: fromAction,
-            data: newData_after,
-            next_data: newData,
-            trans_type,
-            forced: wasForced
-        });
-        this._fire('entry', {
-            state: newState,
-            from: fromState,
-            action: fromAction,
-            data: newData_after
-        });
-        if (oldData !== newData_after) {
-            this._fire('data-change', {
+        // Observation events (#638) fire after the state is committed.  Each call
+        // builds a detail literal at the call site, so guard the whole block on a
+        // live subscription count: with zero listeners (the common hot-path case,
+        // and every benchmark shape) we skip all of these allocations entirely.
+        // Read after pre-hooks, so a listener a pre-hook installed is still seen.
+        // ('action' above and 'rejection' on the invalid path are intentionally
+        // NOT under this gate — they fire regardless, and `_fire` itself no-ops
+        // cheaply when that specific event has no subscribers.)  #670
+        if (this._event_listener_count !== 0) {
+            const newData_after = this._data;
+            this._fire('exit', {
+                state: fromState,
+                to: newState,
+                action: fromAction,
+                data: newData_after
+            });
+            this._fire('transition', {
                 from: fromState,
                 to: newState,
                 action: fromAction,
-                old_data: oldData,
-                new_data: newData_after,
-                cause: 'transition'
+                data: newData_after,
+                next_data: newData,
+                trans_type,
+                forced: wasForced
             });
-        }
-        if (this.state_is_terminal(newState)) {
-            this._fire('terminal', { state: newState, data: newData_after });
-        }
-        if (this.state_is_complete(newState)) {
-            this._fire('complete', { state: newState, data: newData_after });
+            this._fire('entry', {
+                state: newState,
+                from: fromState,
+                action: fromAction,
+                data: newData_after
+            });
+            if (oldData !== newData_after) {
+                this._fire('data-change', {
+                    from: fromState,
+                    to: newState,
+                    action: fromAction,
+                    old_data: oldData,
+                    new_data: newData_after,
+                    cause: 'transition'
+                });
+            }
+            if (this.state_is_terminal(newState)) {
+                this._fire('terminal', { state: newState, data: newData_after });
+            }
+            if (this.state_is_complete(newState)) {
+                this._fire('complete', { state: newState, data: newData_after });
+            }
         }
         // possibly re-establish new 'after' clause
         this.auto_set_state_timeout();