Mechanically identical to abstract_hook_step, but typed for the everything-hook family (pre_everything_hook and everything_hook), whose context object carries an extra hook_name field identifying which bracket of the pipeline is firing. Separated from abstract_hook_step so TypeScript can enforce that the hook handler and the context object agree on shape.

The valid return shapes and their meanings are the same as for abstract_hook_step:

• undefined or true → { pass: true }
• false or null → { pass: false }
• a complex result → returned as-is

This is the central adapter the transition pipeline uses to run every non-"everything" hook kind (basic, named, entry, exit, after, action, etc). It accepts undefined for the hook slot because most hooks are not set on most machines; when no hook is installed the step is a no-op pass.

The valid return shapes from a hook and their normalized meanings are:

• undefined → { pass: true }
• true → { pass: true }
• false → { pass: false }
• null → { pass: false }
• a complex result object → returned as-is

Anything else is a programmer error and throws.

import { parse, compile, Machine } from 'jssm';

const intermediate = parse('a -> b;');
// [ {key:'transition', from:'a', se:{kind:'->',to:'b'}} ]

const cfg = compile(intermediate);
// { start_states:['a'], transitions: [{ from:'a', to:'b', kind:'legal', forced_only:false, main_path:false }] }

const machine = new Machine(cfg);
// Machine { _instance_name: undefined, _state: 'a', ...

This method is mostly for plugin and intermediate tool authors, or people who need to work with the machine's intermediate representation.

Most people looking at this want either the sm operator or method from, which perform all the steps in the chain. The library's author mostly uses operator sm, and mostly falls back to .from when needing to parse strings dynamically instead of from template literals.

Operator sm:

import { sm } from 'jssm';

const lswitch = sm`on <=> off;`;

Method from:

import * as jssm from 'jssm';

const toggle = jssm.from('up <=> down;');

This function recreates a machine from a serialization object, restoring its state, data, and history. For security and compatibility reasons, it will refuse to deserialize data from future versions of the library.

Use this method when you want to conveniently pull a state machine from a string dynamically. Use operator sm when you just want to work with a template expression.

import * as jssm from 'jssm';

const lswitch = jssm.from('on <=> off;');

A hook complex result is an object with at minimum a boolean pass field, and may optionally also carry replacement data / next_data fields that the machine should adopt if the hook passes. This helper is used by the hook-dispatch machinery to tell "hook returned a complex object" from "hook returned a bare boolean / null / undefined".

is_hook_complex_result({ pass: true });                 // true
is_hook_complex_result({ pass: false, data: { x: 1 }}); // true
is_hook_complex_result(true);                           // false
is_hook_complex_result(null);                           // false
is_hook_complex_result({ other: 'thing' });             // false

Hooks in jssm may return any of the following to indicate success: true, undefined, or a complex result whose pass field is true. They may return any of the following to indicate rejection: false, or a complex result whose pass field is false. This helper collapses all of those shapes into one boolean so callers don't have to re-implement the matrix.

is_hook_rejection(true);            // false (pass)
is_hook_rejection(undefined);       // false (pass)
is_hook_rejection(false);           // true  (reject)
is_hook_rejection({ pass: true });  // false (pass)
is_hook_rejection({ pass: false }); // true  (reject)

Use this method when you want to work directly and conveniently with a constant template expression. Use .from when you want to pull from dynamic strings.

import * as jssm from 'jssm';

const lswitch = jssm.from('on <=> off;');