jssm 5.162.21 → 5.162.23

package/dist/fence/fence.js

@@ -24226,7 +24226,7 @@ function fslSemanticSpans(text) {
  *  Useful for runtime diagnostics and for embedding in serialized machine
  *  snapshots so that deserializers can detect version-skew.
  */
-const version = "5.162.21";
+const version = "5.162.23";
 
 /**
  *  The FSL Markdown fence convention parser — pure, host-agnostic logic that
@@ -28146,13 +28146,27 @@ class Machine {
                     }
                 }
                 // all hooks passed!  let's now establish the result
+                // a hook may have redirected the destination via a complex result's
+                // `state` (carried on hook_args.to).  Apply it now, validating it names
+                // a real state.  Pre-transition hooks (including entry/exit) fired for
+                // the original edge; the committed state and the post-hooks, observation
+                // events, and after-timer all reflect the override.  Last writer wins.
+                // StoneCypher/fsl#1947
+                if (hook_args.to !== newState) {
+                    const override_id = this._state_interner.id_of(hook_args.to);
+                    if (override_id === undefined) {
+                        throw new JssmError(this, `A hook overrode the transition destination to '${hook_args.to}', which is not a state in this machine`);
+                    }
+                    newState = hook_args.to;
+                    newStateId = override_id;
+                }
                 if (this._history_length) {
                     this._history.shove([this._state, this._data]);
                 }
                 this._state = newState;
                 this._state_id = newStateId;
                 if (data_changed) {
-                    this._data = hook_args.data;
+                    this._data = hook_args.next_data;
                 }
                 else if (dataProvided) {
                     this._data = newData;
@@ -29732,18 +29746,36 @@ 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
+    // ~10 steps per hooked transition.  It can never carry `data`/`state` (frozen,
+    // built without them), so one pointer compare replaces the hasOwnProperty
     // reflection call for the common case.
     if (res === HOOK_PASSED) {
         return false;
     }
+    // a complex result's `state` redirects the transition's destination; carry it
+    // on hook_args.to (the destination field), which transition_impl applies at
+    // commit (last writer wins).  An explicit `state: undefined` is not a
+    // redirect.  StoneCypher/fsl#1947
+    if (Object.prototype.hasOwnProperty.call(res, 'state') && res.state !== undefined) {
+        hook_args.to = res.state;
+    }
+    // Two channels (StoneCypher/fsl#1948): `data` overrides the value observed by
+    // later hooks in this chain AND is the default committed value; `next_data`
+    // overrides only the committed value.  So `data` sets both, then an explicit
+    // `next_data` overrides the commit channel.  transition_impl commits
+    // hook_args.next_data.  hasOwnProperty (not truthiness) so a falsy override
+    // (false/null/0/''/undefined) still commits (fsl#1264/#935).
+    let changed = false;
     if (Object.prototype.hasOwnProperty.call(res, 'data')) {
         hook_args.data = res.data;
+        hook_args.next_data = res.data;
+        changed = true;
+    }
+    if (Object.prototype.hasOwnProperty.call(res, 'next_data')) {
         hook_args.next_data = res.next_data;
-        return true;
+        changed = true;
     }
-    return false;
+    return changed;
 }
 /**
  *