jssm 5.162.6 → 5.162.8

package/jssm_viz.es5.d.cts

@@ -63,7 +63,6 @@ type JssmAllowIslands = true | false | 'with_start';
  *  - `{ height }` — height-only form (`default_size: height 600;`)
  *
  *  This is a *hint*, not a hard constraint.  Renderers may ignore it.
- *
  *  @see Machine.default_size
  */
 type JssmDefaultSize = {
@@ -98,8 +97,7 @@ type FslTheme = typeof FslThemes[number];
  *  and consumed by {@link jssm!deserialize}.  Carries the current state, the
  *  associated machine data, the recent history (subject to the configured
  *  capacity), and metadata to detect version-skew on rehydration.
- *
- *  @typeParam DataType - The type of the user-supplied data payload (`mDT`).
+ *  @template DataType - The type of the user-supplied data payload (`mDT`).
  */
 type JssmSerialization<DataType> = {
     jssm_version: string;
@@ -125,7 +123,6 @@ type JssmSerialization<DataType> = {
  *  // [ { kind: 'group', name: 'inner', mode: 'nest' },
  *  //   { kind: 'state', name: 'x' } ]
  *  ```
- *
  *  @see JssmGroupRef
  *  @see JssmGroupRegistry
  */
@@ -152,7 +149,6 @@ type JssmGroupMemberRef = {
  *  // registry.get('outer') === [ { kind:'group', name:'inner', mode:'nest' },
  *  //                             { kind:'state', name:'c' } ]
  *  ```
- *
  *  @see JssmGroupMemberRef
  */
 type JssmGroupRegistry = Map<string, JssmGroupMemberRef[]>;
@@ -162,7 +158,6 @@ type JssmGroupRegistry = Map<string, JssmGroupMemberRef[]>;
  *  Each is optional so a subject may declare only one direction; the compiler
  *  merges an `enter` and an `exit` declaration for the same subject into one
  *  of these.
- *
  *  @see JssmHookDeclaration
  */
 type JssmBoundaryHooks = {
@@ -173,7 +168,6 @@ type JssmBoundaryHooks = {
  *  Maps each group name that has at least one boundary hook to its merged
  *  {@link JssmBoundaryHooks}.  Carried on {@link JssmGenericConfig} for the
  *  runtime to consume; depth-aware firing is a later task.
- *
  *  @see JssmHookDeclaration
  */
 type JssmGroupHooks = Map<string, JssmBoundaryHooks>;
@@ -181,7 +175,6 @@ type JssmGroupHooks = Map<string, JssmBoundaryHooks>;
  *  Maps each plain state name that has at least one boundary hook to its
  *  merged {@link JssmBoundaryHooks}.  The state-subject analogue of
  *  {@link JssmGroupHooks}.
- *
  *  @see JssmHookDeclaration
  */
 type JssmStateHooks = Map<string, JssmBoundaryHooks>;
@@ -213,9 +206,8 @@ type JssmTransitionPermitterMaybeArray<DataType> = JssmTransitionPermitter<DataT
  *  per-edge `name`, an action label, a guard `check`, a transition
  *  `probability` for stochastic models, and an `after_time` for timed
  *  transitions.
- *
- *  @typeParam StateType - The state-name type (usually `string`).
- *  @typeParam DataType  - The machine's data payload type (`mDT`).
+ *  @template StateType - The state-name type (usually `string`).
+ *  @template DataType  - The machine's data payload type (`mDT`).
  */
 type JssmTransition<StateType, DataType> = {
     from: StateType;
@@ -399,7 +391,6 @@ type JssmGraphDefaultEdgeColor = {
  *  reuses the per-state style items (so `color: red;` works inside a
  *  `transition:` block exactly as inside a `state:` block) plus the
  *  edge-scoped {@link JssmGraphDefaultEdgeColor} default.
- *
  *  @see JssmTransitionConfig
  */
 type JssmTransitionStyleKey = JssmStateStyleKey | JssmGraphDefaultEdgeColor;
@@ -414,7 +405,6 @@ type JssmTransitionStyleKey = JssmStateStyleKey | JssmGraphDefaultEdgeColor;
  *  const cfg = compile(parse('a -> b; transition: { color: red; };'));
  *  // cfg.default_transition_config === [ { key: 'color', value: '#ff0000ff' } ]
  *  ```
- *
  *  @see JssmGraphConfig
  */
 type JssmTransitionConfig = JssmTransitionStyleKey[];
@@ -425,7 +415,7 @@ type JssmTransitionConfig = JssmTransitionStyleKey[];
  *  default) into the consolidated `graph: {}` config.  Each carries the
  *  legacy parse key so downstream consumers can disambiguate.
  */
-type JssmGraphAliasKey = {
+type JssmGraphAliasKey = JssmGraphDefaultEdgeColor | {
     key: 'graph_layout';
     value: JssmLayout;
 } | {
@@ -440,13 +430,12 @@ type JssmGraphAliasKey = {
 } | {
     key: 'flow';
     value: FslDirection;
-} | JssmGraphDefaultEdgeColor;
+};
 /**
  *  A single item inside a `graph: {}` default-config block.  For v1 this
  *  reuses the per-state style items plus the graph-scope alias items
  *  ({@link JssmGraphAliasKey}) folded in from the deprecated top-level
  *  graph keywords.
- *
  *  @see JssmGraphConfig
  */
 type JssmGraphStyleKey = JssmStateStyleKey | JssmGraphAliasKey;
@@ -463,40 +452,9 @@ type JssmGraphStyleKey = JssmStateStyleKey | JssmGraphAliasKey;
  *  // `background-color` item, so:
  *  // cfg.default_graph_config includes { key: 'background-color', value: '#ffffffff' }
  *  ```
- *
  *  @see JssmTransitionConfig
  */
 type JssmGraphConfig = JssmGraphStyleKey[];
-/**
- *  Complete shape of a jssm-viz theme.  A theme provides a style block for
- *  each kind of state (`state`, `hooked`, `start`, `end`, `terminal`) as
- *  well as a matching `active_*` variant used while that state is current.
- *
- *  The `graph`, `legal`, `main`, `forced`, `action`, and `title` slots are
- *  reserved for future use and currently typed as `undefined`.
- *
- *  Most user-defined themes should be typed as {@link JssmTheme} (the
- *  `Partial` of this) so that omitted fields fall back to the base theme.
- */
-type JssmBaseTheme = {
-    name: string;
-    state: JssmStateConfig;
-    hooked: JssmStateConfig;
-    start: JssmStateConfig;
-    end: JssmStateConfig;
-    terminal: JssmStateConfig;
-    active: JssmStateConfig;
-    active_hooked: JssmStateConfig;
-    active_start: JssmStateConfig;
-    active_end: JssmStateConfig;
-    active_terminal: JssmStateConfig;
-    graph: undefined;
-    legal: undefined;
-    main: undefined;
-    forced: undefined;
-    action: undefined;
-    title: undefined;
-};
 /**
  *  Full configuration object accepted by the {@link jssm!Machine} constructor and
  *  by {@link from}.  Carries the transition list and the optional knobs
@@ -506,9 +464,8 @@ type JssmBaseTheme = {
  *
  *  Most users never construct one of these directly — the `sm` tagged
  *  template literal and {@link from} produce one from FSL source.
- *
- *  @typeParam StateType - The state-name type (usually `string`).
- *  @typeParam DataType  - The user-supplied data payload type (`mDT`).
+ *  @template StateType - The state-name type (usually `string`).
+ *  @template DataType  - The user-supplied data payload type (`mDT`).
  */
 /**
  *  Editor/panel defaults an FSL machine declares in an `editor: {}` block
@@ -568,7 +525,6 @@ type JssmGenericConfig<StateType, DataType> = {
      *
      *  Defaults to `100`.  Raise it for legitimate pipelines that genuinely nest
      *  more than 100 transitions via boundary hooks.
-     *
      *  @see Machine._boundary_depth_limit
      *  @see Machine._fire_boundary_actions
      */
@@ -588,7 +544,7 @@ type JssmGenericConfig<StateType, DataType> = {
     failed_outputs?: Array<StateType>;
     initial_state?: StateType;
     start_states_no_enforce?: boolean;
-    state_declaration?: Object[];
+    state_declaration?: object[];
     property_definition?: JssmPropertyDefinition[];
     state_property?: JssmPropertyDefinition[];
     arrange_declaration?: Array<Array<StateType>>;
@@ -652,7 +608,6 @@ type JssmGenericConfig<StateType, DataType> = {
  *  arrow with optional per-direction action labels, probabilities, and
  *  after-times.  The recursive `se` field allows the parser to chain
  *  arrows of the form `A -> B -> C`.  Not intended for end-user code.
- *
  *  @internal
  */
 type JssmCompileSe<StateType, mDT> = {
@@ -961,7 +916,6 @@ type JssmRng = () => number;
  *  All event names that {@link jssm!Machine.on} accepts.  These are observation
  *  events fired by the machine in addition to (not in place of) the hook
  *  system.  Hooks intercept; events observe.
- *
  *  @see Machine.on
  */
 type JssmEventName = 'transition' | 'rejection' | 'action' | 'entry' | 'exit' | 'terminal' | 'complete' | 'error' | 'data-change' | 'override' | 'timeout' | 'hook-registration' | 'hook-removal';
@@ -1055,7 +1009,7 @@ type JssmErrorEventDetail = {
     error: unknown;
     source_event: JssmEventName;
     source_detail: unknown;
-    handler: Function;
+    handler: JssmEventHandler<unknown, JssmEventName>;
 };
 /**
  *  Detail payload fired with a `data-change` event.  Fires whenever the
@@ -1150,15 +1104,15 @@ type JssmEventFilterMap<mDT> = {
 /**
  *  Per-event filter object (as passed to {@link jssm!Machine.on}).  Use
  *  `JssmEventDetailMap<mDT>[Ev]` to find the matching detail type.
- *  @typeParam mDT The type of the machine data member.
- *  @typeParam Ev  The event name.
+ *  @template mDT The type of the machine data member.
+ *  @template Ev  The event name.
  */
 type JssmEventFilter<mDT, Ev extends JssmEventName> = JssmEventFilterMap<mDT>[Ev];
 /**
  *  Per-event handler signature.  Receives a detail object typed by event
  *  name, so `e.action` (etc.) only exist where they're meaningful.
- *  @typeParam mDT The type of the machine data member.
- *  @typeParam Ev  The event name.
+ *  @template mDT The type of the machine data member.
+ *  @template Ev  The event name.
  */
 type JssmEventHandler<mDT, Ev extends JssmEventName> = (detail: JssmEventDetailMap<mDT>[Ev]) => void;
 /**
@@ -1175,7 +1129,6 @@ type JssmUnsubscribe = () => void;
  * (integer hashing) instead of repeated string-keyed lookups.  Internal
  * machinery only — deliberately not re-exported from the `jssm` public
  * surface, so the public API is unchanged.
- *
  * @internal
  */
 /**
@@ -1184,7 +1137,6 @@ type JssmUnsubscribe = () => void;
  * no removal, matching machine semantics (states and actions are fixed
  * after construction; late interning only happens for never-matching
  * lookups such as hook registrations naming unknown states).
- *
  * @example
  *   const i = new Interner();
  *   i.intern('red');     // 0
@@ -1192,7 +1144,6 @@ type JssmUnsubscribe = () => void;
  *   i.intern('red');     // 0  (idempotent)
  *   i.id_of('green');    // 1
  *   i.name_of(0);        // 'red'
- *
  * @see pair_key
  */
 declare class Interner {
@@ -1202,10 +1153,8 @@ declare class Interner {
     /**
      * Return the id for `name`, assigning the next dense id if the name has
      * not been seen before.
-     *
      * @param name - The string to intern.
      * @returns The (possibly newly assigned) integer id.
-     *
      * @example
      *   interner.intern('red');  // 0 on first call, 0 on every later call
      */
@@ -1214,18 +1163,14 @@ declare class Interner {
      * Return the id for `name` without interning, or `undefined` when the
      * name has never been interned.  This is the hot-path probe for
      * user-supplied names.
-     *
      * @param name - The string to look up.
-     *
      * @example
      *   interner.id_of('mauve');  // undefined — never interned
      */
     id_of(name: string): number | undefined;
     /**
      * Return the name for `id`, or `undefined` for an id never assigned.
-     *
      * @param id - The integer id to invert.
-     *
      * @example
      *   interner.name_of(0);  // 'red'
      */
@@ -1254,7 +1199,6 @@ type StateType = string;
  *  Internal record holding a single registered event subscription: the
  *  handler, its optional filter, and a flag for `once` semantics.  Not
  *  exported.
- *
  *  @internal
  */
 type JssmEventEntry<mDT, Ev extends JssmEventName> = {
@@ -1263,15 +1207,8 @@ type JssmEventEntry<mDT, Ev extends JssmEventName> = {
     once: boolean;
 };
 declare class Machine<mDT> {
+    #private;
     _state: StateType;
-    _states: Map<StateType, JssmGenericState>;
-    _edges: Array<JssmTransition<StateType, mDT>>;
-    _edge_map: Map<StateType, Map<StateType, number>>;
-    _outbound_edge_ids: Map<StateType, Array<number>>;
-    _named_transitions: Map<StateType, number>;
-    _actions: Map<StateType, Map<StateType, number>>;
-    _reverse_actions: Map<StateType, Map<StateType, number>>;
-    _reverse_action_targets: Map<StateType, Map<StateType, number>>;
     _state_interner: Interner;
     _action_interner: Interner;
     _state_id: number;
@@ -1292,7 +1229,7 @@ declare class Machine<mDT> {
     _npm_name?: string;
     _default_size?: JssmDefaultSize;
     _fsl_version?: string;
-    _raw_state_declaration?: Array<Object>;
+    _raw_state_declaration?: Array<object>;
     _state_declarations: Map<StateType, JssmStateDeclaration>;
     _data?: mDT;
     _instance_name: string;
@@ -1380,8 +1317,8 @@ declare class Machine<mDT> {
     _create_started: number;
     _created: number;
     _after_mapping: Map<string, [string, number]>;
-    _timeout_source: (Function: any, number: any) => number;
-    _clear_timeout_source: (h: any) => void;
+    _timeout_source: (f: () => void, a: number) => number;
+    _clear_timeout_source: (h: number) => void;
     _timeout_handle: number | undefined;
     _timeout_target: string | undefined;
     _timeout_target_time: number | undefined;
@@ -1534,9 +1471,7 @@ declare class Machine<mDT> {
      *  const m = jssm.from('on <=> off;', { data: { a: { b: 1 } } });
      *  m._data_ref().a.b;   // 1, zero-copy
      *  ```
-     *
      *  @returns The live data value; treat as read-only.
-     *
      *  @see Machine.data
      *  @internal
      */
@@ -1794,18 +1729,21 @@ declare class Machine<mDT> {
      *  current state, data, and timestamp.
      *
      */
-    serialize(comment?: string | undefined): JssmSerialization<mDT>;
-    /** Get the graph layout direction (e.g. `'LR'`, `'TB'`).  Set via the
+    serialize(comment?: string): JssmSerialization<mDT>;
+    /**
+     * Get the graph layout direction (e.g. `'LR'`, `'TB'`).  Set via the
      *  FSL `graph_layout` directive.
      *  @returns The layout string, or the default if not set.
      */
     graph_layout(): string;
-    /** Get the Graphviz DOT preamble string, injected before the graph body
+    /**
+     * Get the Graphviz DOT preamble string, injected before the graph body
      *  during visualization.  Set via the FSL `dot_preamble` directive.
      *  @returns The preamble string.
      */
     dot_preamble(): string;
-    /** Get the consolidated `transition: {}` default-config block: the ordered,
+    /**
+     * Get the consolidated `transition: {}` default-config block: the ordered,
      *  de-duplicated `{ key, value }[]` list of edge-default style items compiled
      *  from a `transition: {}` block (e.g. `transition: { color: blue; }`).  The
      *  viz layer projects this onto a Graphviz `edge [ … ]` default statement so
@@ -1816,13 +1754,13 @@ declare class Machine<mDT> {
      *  sm`a -> b; transition: { color: blue; };`.default_transition_config();
      *  // [ { key: 'color', value: '#0000ffff' } ]
      *  ```
-     *
      *  @returns The transition-config item list, or `undefined` if the machine
      *  declared no `transition: {}` block.
      *  @see default_graph_config
      */
     default_transition_config(): JssmTransitionConfig | undefined;
-    /** Get the consolidated `graph: {}` default-config block: the ordered,
+    /**
+     * Get the consolidated `graph: {}` default-config block: the ordered,
      *  de-duplicated `{ key, value }[]` list of graph-scope style items.  The
      *  compiler folds the deprecated top-level graph keywords
      *  (`graph_bg_color` → `background-color`, plus `graph_layout`, `theme`,
@@ -1836,29 +1774,33 @@ declare class Machine<mDT> {
      *  sm`a -> b; graph: { background-color: #ffffff; };`.default_graph_config();
      *  // [ { key: 'background-color', value: '#ffffffff' } ]
      *  ```
-     *
      *  @returns The graph-config item list, or `undefined` if the machine has no
      *  graph config (no `graph: {}` block and no deprecated graph keyword).
      *  @see default_transition_config
      */
     default_graph_config(): JssmGraphConfig | undefined;
-    /** Get the machine's author list.  Set via the FSL `machine_author` directive.
+    /**
+     * Get the machine's author list.  Set via the FSL `machine_author` directive.
      *  @returns An array of author name strings.
      */
     machine_author(): Array<string>;
-    /** Get the machine's comment string.  Set via the FSL `machine_comment` directive.
+    /**
+     * Get the machine's comment string.  Set via the FSL `machine_comment` directive.
      *  @returns The comment string.
      */
     machine_comment(): string;
-    /** Get the machine's contributor list.  Set via the FSL `machine_contributor` directive.
+    /**
+     * Get the machine's contributor list.  Set via the FSL `machine_contributor` directive.
      *  @returns An array of contributor name strings.
      */
     machine_contributor(): Array<string>;
-    /** Get the machine's definition string.  Set via the FSL `machine_definition` directive.
+    /**
+     * Get the machine's definition string.  Set via the FSL `machine_definition` directive.
      *  @returns The definition string.
      */
     machine_definition(): string;
-    /** Get the machine's natural language as an ISO 639-1 code.  Set via the FSL
+    /**
+     * Get the machine's natural language as an ISO 639-1 code.  Set via the FSL
      *  `machine_language` directive, which accepts a language name or code, or a
      *  BCP-47 tag whose region subtag is dropped (`en-us` -> `en`).  Unrecognized
      *  values resolve to `undefined`.
@@ -1866,32 +1808,35 @@ declare class Machine<mDT> {
      *           supplied value did not resolve to a known language.
      */
     machine_language(): string;
-    /** Get the machine's license string.  Set via the FSL `machine_license` directive.
+    /**
+     * Get the machine's license string.  Set via the FSL `machine_license` directive.
      *  @returns The license string.
      */
     machine_license(): string;
-    /** Get the machine's name.  Set via the FSL `machine_name` directive.
+    /**
+     * Get the machine's name.  Set via the FSL `machine_name` directive.
      *  @returns The machine name string.
      */
     machine_name(): string;
-    /** The editor/panel defaults declared in the FSL `editor: {}` block, or
+    /**
+     * The editor/panel defaults declared in the FSL `editor: {}` block, or
      *  `undefined` when none was given.  Read by the all-widgets web control
      *  (fsl#1334) — `panels` drives `request` panel mode.
-     *
      *  @returns `{ stochastic_run_count?, panels? }`, or `undefined`.
-     *
      *  @example
      *    const m = sm`editor: { panels: [history]; }; a -> b;`;
      *    m.editor_config();  // => { panels: ['history'] }
      */
     editor_config(): JssmEditorConfig | undefined;
-    /** Get the npm package name associated with the machine.  Set via the FSL `npm_name` directive.
+    /**
+     * Get the npm package name associated with the machine.  Set via the FSL `npm_name` directive.
      *  Returns `undefined` when not present.
      *  @returns The npm package name string, or `undefined`.
      *  @see machine_name
      */
     npm_name(): string;
-    /** Get the render-size hint for the machine's visualization.  Set via the
+    /**
+     * Get the render-size hint for the machine's visualization.  Set via the
      *  FSL `default_size` directive.  Returns `undefined` when not present.
      *
      *  The three FSL forms each produce a different subset of fields:
@@ -1901,33 +1846,38 @@ declare class Machine<mDT> {
      *  - `default_size: height 600;` → `{ height: 600 }`
      *
      *  This is a hint, not a hard constraint.  Renderers may ignore it.
-     *
      *  @returns The size-hint object, or `undefined` if not set.
      *  @see npm_name
      */
     default_size(): JssmDefaultSize | undefined;
-    /** Get the machine's version string.  Set via the FSL `machine_version` directive.
+    /**
+     * Get the machine's version string.  Set via the FSL `machine_version` directive.
      *  @returns The version string.
      */
     machine_version(): string;
-    /** Get the raw state declaration objects as parsed from the FSL source.
+    /**
+     * Get the raw state declaration objects as parsed from the FSL source.
      *  @returns An array of raw state declaration objects.
      */
-    raw_state_declarations(): Array<Object>;
-    /** Get the processed state declaration for a specific state.
+    raw_state_declarations(): Array<object>;
+    /**
+     * Get the processed state declaration for a specific state.
      *  @param which - The state to look up.
      *  @returns The {@link JssmStateDeclaration} for the given state.
      */
     state_declaration(which: StateType): JssmStateDeclaration;
-    /** Get all processed state declarations as a Map.
+    /**
+     * Get all processed state declarations as a Map.
      *  @returns A `Map` from state name to {@link JssmStateDeclaration}.
      */
     state_declarations(): Map<StateType, JssmStateDeclaration>;
-    /** Get the FSL language version this machine was compiled under.
+    /**
+     * Get the FSL language version this machine was compiled under.
      *  @returns The FSL version string.
      */
     fsl_version(): string;
-    /** Get the complete internal state of the machine as a serializable
+    /**
+     * Get the complete internal state of the machine as a serializable
      *  structure.  Includes actions, edges, edge map, named transitions,
      *  reverse actions, current state, and states map.
      *  @returns A {@link JssmMachineInternalState} snapshot.
@@ -1951,7 +1901,8 @@ declare class Machine<mDT> {
      *
      */
     states(): Array<StateType>;
-    /** Get the internal state descriptor for a given state name.
+    /**
+     * Get the internal state descriptor for a given state name.
      *  @param whichState - The state to look up.
      *  @returns The {@link JssmGenericState} descriptor.
      *  @throws {JssmError} If the state does not exist.
@@ -2014,19 +1965,23 @@ declare class Machine<mDT> {
      *
      */
     list_edges(): Array<JssmTransition<StateType, mDT>>;
-    /** Get the map of named transitions (transitions with explicit names).
+    /**
+     * Get the map of named transitions (transitions with explicit names).
      *  @returns A `Map` from transition name to edge index.
      */
     list_named_transitions(): Map<StateType, number>;
-    /** List all distinct action names defined anywhere in the machine.
+    /**
+     * List all distinct action names defined anywhere in the machine.
      *  @returns An array of action name strings.
      */
     list_actions(): Array<StateType>;
-    /** Whether any actions are defined on this machine.
+    /**
+     * Whether any actions are defined on this machine.
      *  @returns `true` if the machine has at least one action.
      */
     get uses_actions(): boolean;
-    /** Whether any forced (`~>`) transitions exist in this machine.
+    /**
+     * Whether any forced (`~>`) transitions exist in this machine.
      *  @returns `true` if at least one forced transition is defined.
      */
     get uses_forced_transitions(): boolean;
@@ -2067,16 +2022,16 @@ declare class Machine<mDT> {
      *
      */
     get allow_islands(): JssmAllowIslands;
-    /** List all available theme names.
+    /**
+     * List all available theme names.
      *  @returns An array of theme name strings.
      */
     all_themes(): FslTheme[];
-    /** List the character ranges accepted by the FSL grammar in any but the
+    /**
+     * List the character ranges accepted by the FSL grammar in any but the
      *  first position of a state name (atom).  Each entry is an inclusive
      *  `{from, to}` range of single Unicode characters.
-     *
      *  @returns An array of `{from, to}` inclusive character ranges.
-     *
      *  @example
      *  import { sm } from 'jssm';
      *  const m = sm`a -> b;`;
@@ -2086,12 +2041,11 @@ declare class Machine<mDT> {
         from: string;
         to: string;
     }>;
-    /** List the character ranges accepted by the FSL grammar in the first
+    /**
+     * List the character ranges accepted by the FSL grammar in the first
      *  position of a state name (atom).  Narrower than
      *  {@link all_state_name_chars}: notably omits `+`, `(`, `)`, `&`, `#`, `@`.
-     *
      *  @returns An array of `{from, to}` inclusive character ranges.
-     *
      *  @example
      *  import { sm } from 'jssm';
      *  const m = sm`a -> b;`;
@@ -2101,12 +2055,11 @@ declare class Machine<mDT> {
         from: string;
         to: string;
     }>;
-    /** List the character ranges accepted inside a single-quoted FSL action
+    /**
+     * List the character ranges accepted inside a single-quoted FSL action
      *  label without escaping.  Space is allowed; the apostrophe `'` is
      *  explicitly excluded since it terminates the label.
-     *
      *  @returns An array of `{from, to}` inclusive character ranges.
-     *
      *  @example
      *  import { sm } from 'jssm';
      *  const m = sm`a -> b;`;
@@ -2117,28 +2070,33 @@ declare class Machine<mDT> {
         from: string;
         to: string;
     }>;
-    /** Get the active theme(s) for this machine.  Always stored as an array
+    /**
+     * Get the active theme(s) for this machine.  Always stored as an array
      *  internally; the union return type exists for setter compatibility.
      *  @returns The current theme or array of themes.
      */
     get themes(): FslTheme | FslTheme[];
-    /** Set the active theme(s).  Accepts a single theme name or an array.
+    /**
+     * Set the active theme(s).  Accepts a single theme name or an array.
      *  @param to - A theme name or array of theme names to apply.
      */
     set themes(to: FslTheme | FslTheme[]);
-    /** Get the flow direction for graph layout (e.g. `'right'`, `'down'`).
+    /**
+     * Get the flow direction for graph layout (e.g. `'right'`, `'down'`).
      *  Set via the FSL `flow` directive.
      *  @returns The current flow direction.
      */
     flow(): FslDirection;
-    /** Look up a transition's edge index by source and target state names.
+    /**
+     * Look up a transition's edge index by source and target state names.
      *  @param from - Source state name.
      *  @param to   - Target state name.
      *  @returns The edge index in the edges array, or `undefined` if no
      *  such transition exists.
      */
     get_transition_by_state_names(from: StateType, to: StateType): number;
-    /** Look up the full transition object for a given source→target pair.
+    /**
+     * Look up the full transition object for a given source→target pair.
      *  @param from - Source state name.
      *  @param to   - Target state name.
      *  @returns The {@link JssmTransition} object, or `undefined` if none exists.
@@ -2210,7 +2168,8 @@ declare class Machine<mDT> {
      *
      */
     list_exits(whichState?: StateType): Array<StateType>;
-    /** Get the transitions available from a state for use by the probabilistic
+    /**
+     * Get the transitions available from a state for use by the probabilistic
      *  walk system.
      *
      *  If any exit declares a `probability`, only those probability-bearing
@@ -2223,37 +2182,39 @@ declare class Machine<mDT> {
      *  Fixes StoneCypher/fsl#1325, in which the function previously returned
      *  every exit unconditionally — including forced-only exits and exits
      *  with no `probability`, which distorted the weighted distribution.
-     *
      *  @param whichState - The state to inspect.
      *  @returns An array of {@link JssmTransition} edges exiting the state,
      *  filtered as described above.  May be empty.
      *  @throws {JssmError} If the state does not exist.
      */
     probable_exits_for(whichState: StateType): Array<JssmTransition<StateType, mDT>>;
-    /** Take a single random transition from the current state, weighted by
+    /**
+     * Take a single random transition from the current state, weighted by
      *  edge probabilities.
      *  @returns `true` if a transition was taken, `false` otherwise.
      */
     probabilistic_transition(): boolean;
-    /** Take `n` consecutive probabilistic transitions and return the sequence
+    /**
+     * Take `n` consecutive probabilistic transitions and return the sequence
      *  of states visited (before each transition).
      *  @param n - Number of steps to walk.
      *  @returns An array of state names visited during the walk.
      */
     probabilistic_walk(n: number): Array<StateType>;
-    /** Take `n` probabilistic steps and return a histograph of how many times
+    /**
+     * Take `n` probabilistic steps and return a histograph of how many times
      *  each state was visited.
      *  @param n - Number of steps to walk.
      *  @returns A `Map` from state name to visit count.
      */
     probabilistic_histo_walk(n: number): Map<StateType, number>;
-    /** One non-destructive weighted-random walk over the graph from `start`.
+    /**
+     * One non-destructive weighted-random walk over the graph from `start`.
      *
      *  Reads the graph and advances the PRNG only — it never calls
      *  {@link Machine.transition}, so it fires no hooks, mutates no machine
      *  state, and touches no `data`.  A state with no probabilistic exits
      *  (a terminal, or a forced-only `~>` state) ends the walk.
-     *
      *  @param start - State to begin the walk from.
      *  @param max_steps - Maximum transitions before the walk is step-capped.
      *  @param exit_memo - Per-run-set cache of {@link Machine.probable_exits_for}
@@ -2266,7 +2227,8 @@ declare class Machine<mDT> {
      *  @returns The {@link JssmStochasticRun} for this walk.
      */
     private _stochastic_one_walk;
-    /** Lazily yield one {@link JssmStochasticRun} at a time.
+    /**
+     * Lazily yield one {@link JssmStochasticRun} at a time.
      *
      *  In `montecarlo` mode (default) yields `runs` independent walks from the
      *  current state, each ending at a terminal or after `max_steps`.  In
@@ -2277,16 +2239,16 @@ declare class Machine<mDT> {
      *  Passing `seed` reseeds the machine for reproducible runs.  Unlike
      *  {@link Machine.stochastic_summary}, the generator does NOT restore the
      *  prior seed afterward — a direct caller's machine is left reseeded.
-     *
      *  @param opts - {@link JssmStochasticOptions}.
+     *  @yields One {@link JssmStochasticRun} per completed walk.
      *  @returns A generator of per-run results.
-     *
      *  @example
      *  const m = sm`a 'go' -> b 'go' -> c;`;
      *  [...m.stochastic_runs({ runs: 2, seed: 1 })].length;  // => 2
      */
     stochastic_runs(opts?: JssmStochasticOptions): Generator<JssmStochasticRun>;
-    /** Run many weighted-random walks and return aggregate statistics.
+    /**
+     * Run many weighted-random walks and return aggregate statistics.
      *
      *  Honors `%` transition probabilities (via the existing probabilistic
      *  machinery).  Non-destructive: the machine's current state and
@@ -2297,16 +2259,13 @@ declare class Machine<mDT> {
      *
      *  Timing (`after`) decorations and data-guard conditions are not modeled
      *  by this sampler; it walks the probabilistic graph topology.
-     *
      *  @param opts - {@link JssmStochasticOptions}.  `runs` defaults to the
      *  machine's declared `editor: { stochastic_run_count }` (fsl#1334) when
      *  present, otherwise {@link STOCHASTIC_DEFAULT_RUNS}.
      *  @returns A {@link JssmStochasticSummary}.
-     *
      *  @see Machine.stochastic_runs
      *  @see Machine.probabilistic_walk
      *  @see Machine.editor_config
-     *
      *  @example
      *  const m = sm`a 'go' -> b 'go' -> c;`;
      *  const s = m.stochastic_summary({ runs: 100, seed: 1 });
@@ -2374,17 +2333,16 @@ declare class Machine<mDT> {
      *
      */
     list_states_having_action(whichState: StateType): Array<StateType>;
-    /** List all action names available as exits from a given state.
+    /**
+     * List all action names available as exits from a given state.
      *
      *  Returns the empty array (does not throw) when `whichState` exists but has
      *  no action-named exits — including terminal states, states whose only
      *  exits are plain `->` transitions, and states in machines that use no
      *  actions at all.  Only nonexistent states cause a throw.
-     *
      *  @param whichState - The state to inspect.  Defaults to the current state.
      *  @returns An array of action name strings, possibly empty.
      *  @throws {JssmError} If the state does not exist.
-     *
      *  @example
      *    const m = sm`a 'go' -> b; b -> c;`;
      *    m.list_exit_actions('a');  // => ['go']
@@ -2393,33 +2351,39 @@ declare class Machine<mDT> {
      *    expect(() => m.list_exit_actions('z')).toThrow();
      */
     list_exit_actions(whichState?: StateType): Array<StateType>;
-    /** List all action exits from a state with their probabilities.
+    /**
+     * List all action exits from a state with their probabilities.
      *  @param whichState - The state to inspect.  Defaults to the current state.
      *  @returns An array of `{ action, probability }` objects.
      *  @throws {JssmError} If the state does not exist.
      */
     probable_action_exits(whichState?: StateType): Array<any>;
-    /** Check whether a state has no incoming transitions (unreachable after start).
+    /**
+     * Check whether a state has no incoming transitions (unreachable after start).
      *  @param whichState - The state to check.
      *  @returns `true` if the state has zero entrances.
      *  @throws {JssmError} If the state does not exist.
      */
     is_unenterable(whichState: StateType): boolean;
-    /** Check whether any state in the machine is unenterable.
+    /**
+     * Check whether any state in the machine is unenterable.
      *  @returns `true` if at least one state has no incoming transitions.
      */
     has_unenterables(): boolean;
-    /** Check whether the current state is terminal (has no exits).
+    /**
+     * Check whether the current state is terminal (has no exits).
      *  @returns `true` if the current state has zero exits.
      */
     is_terminal(): boolean;
-    /** Check whether a specific state is terminal (has no exits).
+    /**
+     * Check whether a specific state is terminal (has no exits).
      *  @param whichState - The state to check.
      *  @returns `true` if the state has zero exits.
      *  @throws {JssmError} If the state does not exist.
      */
     state_is_terminal(whichState: StateType): boolean;
-    /** Check whether any state in the machine is terminal.
+    /**
+     * Check whether any state in the machine is terminal.
      *  @returns `true` if at least one state has no exits.
      */
     has_terminals(): boolean;
@@ -2531,17 +2495,20 @@ declare class Machine<mDT> {
      *
      */
     statesIn(groupName: string): Array<StateType>;
-    /** Check whether the current state is complete (every exit has an action).
+    /**
+     * Check whether the current state is complete (every exit has an action).
      *  @returns `true` if the current state is complete.
      */
     is_complete(): boolean;
-    /** Check whether a specific state is complete (every exit has an action).
+    /**
+     * Check whether a specific state is complete (every exit has an action).
      *  @param whichState - The state to check.
      *  @returns `true` if the state is complete.
      *  @throws {JssmError} If the state does not exist.
      */
     state_is_complete(whichState: StateType): boolean;
-    /** Check whether any state in the machine is complete.
+    /**
+     * Check whether any state in the machine is complete.
      *  @returns `true` if at least one state is complete.
      */
     has_completes(): boolean;
@@ -2565,14 +2532,12 @@ declare class Machine<mDT> {
      *  const off = m.on('transition', () => {});
      *  off();  // unsubscribe
      *  ```
-     *
-     *  @typeParam Ev      The event name (drives the detail type).
+     *  @template Ev      The event name (drives the detail type).
      *  @param name        The event name to subscribe to.
      *  @param handler     The handler invoked on each matching delivery.  The
      *                     three-argument `(name, filter, handler)` form inserts a
      *                     filter object before the handler (see the example above).
      *  @returns A function that unsubscribes when called.
-     *
      *  @see Machine.off
      *  @see Machine.once
      */
@@ -2586,15 +2551,13 @@ declare class Machine<mDT> {
      *  ```typescript
      *  m.once('terminal', e => console.log(`done at ${e.state}`));
      *  ```
-     *
-     *  @typeParam Ev      The event name.
+     *  @template Ev      The event name.
      *  @param name        The event name.
      *  @param handler     The handler invoked on the first matching delivery.  The
      *                     three-argument `(name, filter, handler)` form inserts a
      *                     filter object before the handler (same shapes as `on`).
      *  @returns A function that unsubscribes early if called before the
      *           handler has fired.
-     *
      *  @see Machine.on
      *  @see Machine.off
      */
@@ -2612,112 +2575,11 @@ declare class Machine<mDT> {
      *  m.off('transition', fn);  // true
      *  m.off('transition', fn);  // false
      *  ```
-     *
      *  @param name    The event name.
      *  @param handler The handler reference to remove.
      *  @returns `true` if removed, `false` if no match was registered.
      */
     off<Ev extends JssmEventName>(name: Ev, handler: JssmEventHandler<mDT, Ev>): boolean;
-    /**
-     *  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: Set<JssmEventEntry<any, any>>, entry: JssmEventEntry<any, any>): void;
-    /**
-     *  Shared registration core used by {@link Machine.on} and
-     *  {@link Machine.once}.  Normalizes the optional filter argument and
-     *  installs the entry into the per-event subscription set.
-     *
-     *  @internal
-     */
-    _subscribe<Ev extends JssmEventName>(name: Ev, filterOrFn: JssmEventFilter<mDT, Ev> | JssmEventHandler<mDT, Ev>, maybeFn: JssmEventHandler<mDT, Ev> | undefined, once: boolean): JssmUnsubscribe;
-    /**
-     *  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<Ev extends JssmEventName>(entry: JssmEventEntry<mDT, Ev>, set: Set<JssmEventEntry<any, any>>, name: Ev, detail: JssmEventDetailMap<mDT>[Ev]): void;
-    /**
-     *  Dispatch an event to every registered subscriber in registration
-     *  order.  Filters are checked first; non-matching handlers are skipped
-     *  without invoking the handler.  Exceptions thrown by a handler are
-     *  caught and re-emitted as an `error` event so subsequent handlers
-     *  still run.
-     *
-     *  Re-entry into the `error` event itself is guarded — if an `error`
-     *  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
-     */
-    /**
-     *  Whether at least one live subscriber is registered for `name`.  Used by
-     *  the transition-commit observation block to skip building a detail
-     *  literal that {@link Machine._fire} would immediately discard — a panel
-     *  listening only to `'transition'` (fsl-bind, fsl-viz, fsl-info-panel)
-     *  previously paid for the exit/entry/data-change detail allocations on
-     *  every transition.  Read at fire time, so a listener installed by a
-     *  pre-hook is still seen (#671).
-     *
-     *  @param name The event name to probe.
-     *  @returns `true` when a subsequent `_fire(name, ...)` would reach at
-     *  least one handler.
-     *
-     *  ```typescript
-     *  machine.on('transition', () => {});
-     *  machine._has_subscribers('transition');  // true
-     *  machine._has_subscribers('exit');        // false
-     *  ```
-     *
-     *  @see Machine._fire
-     *  @internal
-     */
-    _has_subscribers(name: JssmEventName): boolean;
-    _fire<Ev extends JssmEventName>(name: Ev, detail: JssmEventDetailMap<mDT>[Ev]): void;
-    /** Low-level hook registration.  Installs a handler described by a
-     *  {@link HookDescription} into the appropriate internal map.  Prefer the
-     *  convenience wrappers ({@link hook}, {@link hook_entry}, etc.) over
-     *  calling this directly.
-     *  @param HookDesc - A hook descriptor specifying kind, states, and handler.
-     */
-    /**
-     *  Validate a {@link HookDescription} before registration.  Every hook needs
-     *  a `handler` function, and each kind's identifying spatial fields
-     *  (`from`/`to`/`action`) must be exactly those `set_hook` reads for that
-     *  kind — present when required, absent otherwise.  This turns a mis-shaped
-     *  descriptor into a thrown error instead of a silently dead hook keyed on
-     *  `undefined` (e.g. an `exit` hook handed `to` instead of `from`, #734).
-     *
-     *  @param HookDesc - The descriptor about to be registered.
-     *  @throws JssmError if the kind is unknown, the handler is not a function, a
-     *          required field is missing, or an inapplicable field is present.
-     *
-     *  @example
-     *    const m = sm`a -> b;`;
-     *    // an exit hook is keyed by `from`, so supplying `to` is rejected:
-     *    expect(() => m.set_hook({ kind: 'exit', to: 'a', handler: () => true })).toThrow();
-     */
-    _validate_hook_description(HookDesc: HookDescription<mDT>): void;
     set_hook(HookDesc: HookDescription<mDT>): void;
     /**
      *  Remove a previously-registered hook described by a
@@ -2736,12 +2598,12 @@ declare class Machine<mDT> {
      *  m.set_hook({ kind: 'hook', from: 'a', to: 'b', handler: fn });
      *  m.remove_hook({ kind: 'hook', from: 'a', to: 'b', handler: fn });
      *  ```
-     *
      *  @param HookDesc - A hook descriptor identifying the hook to remove.
      *  @returns `true` if a hook was removed, `false` otherwise.
      */
     remove_hook(HookDesc: HookDescription<mDT>): boolean;
-    /** Register a pre-transition hook on a specific edge.  Fires before
+    /**
+     * Register a pre-transition hook on a specific edge.  Fires before
      *  transitioning from `from` to `to`.  If the handler returns `false`, the
      *  transition is blocked.
      *
@@ -2749,14 +2611,14 @@ declare class Machine<mDT> {
      *  const m = sm`a -> b -> c;`;
      *  m.hook('a', 'b', () => console.log('a->b'));
      *  ```
-     *
      *  @param from    - Source state name.
      *  @param to      - Target state name.
      *  @param handler - Callback invoked before the transition.
      *  @returns `this` for chaining.
      */
     hook(from: string, to: string, handler: HookHandler<mDT>): Machine<mDT>;
-    /** Register a pre-transition hook on a specific action-labeled edge.
+    /**
+     * Register a pre-transition hook on a specific action-labeled edge.
      *  @param from    - Source state name.
      *  @param to      - Target state name.
      *  @param action  - The action label that triggers this hook.
@@ -2764,50 +2626,59 @@ declare class Machine<mDT> {
      *  @returns `this` for chaining.
      */
     hook_action(from: string, to: string, action: string, handler: HookHandler<mDT>): Machine<mDT>;
-    /** Register a pre-transition hook on any edge triggered by a specific action.
+    /**
+     * Register a pre-transition hook on any edge triggered by a specific action.
      *  @param action  - The action name to hook.
      *  @param handler - Callback invoked before any transition with this action.
      *  @returns `this` for chaining.
      */
     hook_global_action(action: string, handler: HookHandler<mDT>): Machine<mDT>;
-    /** Register a pre-transition hook on any action-driven transition.
+    /**
+     * Register a pre-transition hook on any action-driven transition.
      *  @param handler - Callback invoked before any action transition.
      *  @returns `this` for chaining.
      */
     hook_any_action(handler: HookHandler<mDT>): Machine<mDT>;
-    /** Register a pre-transition hook on any standard (`->`) transition.
+    /**
+     * Register a pre-transition hook on any standard (`->`) transition.
      *  @param handler - Callback invoked before any legal transition.
      *  @returns `this` for chaining.
      */
     hook_standard_transition(handler: HookHandler<mDT>): Machine<mDT>;
-    /** Register a pre-transition hook on any main-path (`=>`) transition.
+    /**
+     * Register a pre-transition hook on any main-path (`=>`) transition.
      *  @param handler - Callback invoked before any main transition.
      *  @returns `this` for chaining.
      */
     hook_main_transition(handler: HookHandler<mDT>): Machine<mDT>;
-    /** Register a pre-transition hook on any forced (`~>`) transition.
+    /**
+     * Register a pre-transition hook on any forced (`~>`) transition.
      *  @param handler - Callback invoked before any forced transition.
      *  @returns `this` for chaining.
      */
     hook_forced_transition(handler: HookHandler<mDT>): Machine<mDT>;
-    /** Register a pre-transition hook on any transition regardless of kind.
+    /**
+     * Register a pre-transition hook on any transition regardless of kind.
      *  @param handler - Callback invoked before every transition.
      *  @returns `this` for chaining.
      */
     hook_any_transition(handler: HookHandler<mDT>): Machine<mDT>;
-    /** Register a hook that fires when entering a specific state.
+    /**
+     * Register a hook that fires when entering a specific state.
      *  @param to      - The state being entered.
      *  @param handler - Callback invoked on entry.
      *  @returns `this` for chaining.
      */
     hook_entry(to: string, handler: HookHandler<mDT>): Machine<mDT>;
-    /** Register a hook that fires when leaving a specific state.
+    /**
+     * Register a hook that fires when leaving a specific state.
      *  @param from    - The state being exited.
      *  @param handler - Callback invoked on exit.
      *  @returns `this` for chaining.
      */
     hook_exit(from: string, handler: HookHandler<mDT>): Machine<mDT>;
-    /** Register a hook that fires when a state's `after` timer elapses — the
+    /**
+     * Register a hook that fires when a state's `after` timer elapses — the
      *  delay-over companion to `a after 5s -> b;` style time transitions.  It
      *  does NOT fire when the state is entered or left by ordinary dispatch;
      *  use {@link hook_entry} / {@link hook_exit} for those.  (Versions through
@@ -2818,7 +2689,6 @@ declare class Machine<mDT> {
      *                   timed transition is taken; informational — its outcome
      *                   cannot reject the transition.
      *  @returns `this` for chaining.
-     *
      *  @example
      *    const m = sm`a after 1000 -> b; a -> c; c -> a;`;
      *    let calls = 0;
@@ -2828,13 +2698,13 @@ declare class Machine<mDT> {
      *    // ordinary dispatch never fires it; only the timer elapsing does:
      *    calls;  // => 0
      *    m.clear_state_timeout();
-     *
      *  @see hook_entry
      *  @see hook_exit
      *  @see set_state_timeout
      */
     hook_after(from: string, handler: HookHandler<mDT>): Machine<mDT>;
-    /** Register a hook that fires when ANY state's `after` timer elapses — the
+    /**
+     * Register a hook that fires when ANY state's `after` timer elapses — the
      *  whole-machine companion to {@link hook_after}, mirroring how
      *  {@link hook_any_transition} companions {@link hook}.  When the elapsing
      *  state also has a specific {@link hook_after}, the specific hook fires
@@ -2845,7 +2715,6 @@ declare class Machine<mDT> {
      *  @param handler - Callback invoked whenever any `after` timer fires, just
      *                   before the timed transition is taken.
      *  @returns `this` for chaining.
-     *
      *  @example
      *    const m = sm`a after 1000 -> b; a -> c; c -> a;`;
      *    let calls = 0;
@@ -2855,13 +2724,13 @@ declare class Machine<mDT> {
      *    // ordinary dispatch never fires it; only a timer elapsing does:
      *    calls;  // => 0
      *    m.clear_state_timeout();
-     *
      *  @see hook_after
      *  @see hook_any_transition
      *  @see set_state_timeout
      */
     hook_after_any(handler: HookHandler<mDT>): Machine<mDT>;
-    /** Post-transition hook on a specific edge.  Fires after the transition
+    /**
+     * Post-transition hook on a specific edge.  Fires after the transition
      *  from `from` to `to` has completed.  Cannot block the transition.
      *  @param from    - Source state name.
      *  @param to      - Target state name.
@@ -2869,7 +2738,8 @@ declare class Machine<mDT> {
      *  @returns `this` for chaining.
      */
     post_hook(from: string, to: string, handler: HookHandler<mDT>): Machine<mDT>;
-    /** Post-transition hook on a specific action-labeled edge.
+    /**
+     * Post-transition hook on a specific action-labeled edge.
      *  @param from    - Source state name.
      *  @param to      - Target state name.
      *  @param action  - The action label.
@@ -2877,50 +2747,59 @@ declare class Machine<mDT> {
      *  @returns `this` for chaining.
      */
     post_hook_action(from: string, to: string, action: string, handler: HookHandler<mDT>): Machine<mDT>;
-    /** Post-transition hook on any edge triggered by a specific action.
+    /**
+     * Post-transition hook on any edge triggered by a specific action.
      *  @param action  - The action name.
      *  @param handler - Callback invoked after any transition with this action.
      *  @returns `this` for chaining.
      */
     post_hook_global_action(action: string, handler: HookHandler<mDT>): Machine<mDT>;
-    /** Post-transition hook on any action-driven transition.
+    /**
+     * Post-transition hook on any action-driven transition.
      *  @param handler - Callback invoked after any action transition.
      *  @returns `this` for chaining.
      */
     post_hook_any_action(handler: HookHandler<mDT>): Machine<mDT>;
-    /** Post-transition hook on any standard (`->`) transition.
+    /**
+     * Post-transition hook on any standard (`->`) transition.
      *  @param handler - Callback invoked after any legal transition.
      *  @returns `this` for chaining.
      */
     post_hook_standard_transition(handler: HookHandler<mDT>): Machine<mDT>;
-    /** Post-transition hook on any main-path (`=>`) transition.
+    /**
+     * Post-transition hook on any main-path (`=>`) transition.
      *  @param handler - Callback invoked after any main transition.
      *  @returns `this` for chaining.
      */
     post_hook_main_transition(handler: HookHandler<mDT>): Machine<mDT>;
-    /** Post-transition hook on any forced (`~>`) transition.
+    /**
+     * Post-transition hook on any forced (`~>`) transition.
      *  @param handler - Callback invoked after any forced transition.
      *  @returns `this` for chaining.
      */
     post_hook_forced_transition(handler: HookHandler<mDT>): Machine<mDT>;
-    /** Post-transition hook on any transition regardless of kind.
+    /**
+     * Post-transition hook on any transition regardless of kind.
      *  @param handler - Callback invoked after every transition.
      *  @returns `this` for chaining.
      */
     post_hook_any_transition(handler: HookHandler<mDT>): Machine<mDT>;
-    /** Post-transition hook that fires after entering a specific state.
+    /**
+     * Post-transition hook that fires after entering a specific state.
      *  @param to      - The state that was entered.
      *  @param handler - Callback invoked after entry.
      *  @returns `this` for chaining.
      */
     post_hook_entry(to: string, handler: HookHandler<mDT>): Machine<mDT>;
-    /** Post-transition hook that fires after leaving a specific state.
+    /**
+     * Post-transition hook that fires after leaving a specific state.
      *  @param from    - The state that was exited.
      *  @param handler - Callback invoked after exit.
      *  @returns `this` for chaining.
      */
     post_hook_exit(from: string, handler: HookHandler<mDT>): Machine<mDT>;
-    /** Register a pre-transition hook that fires **before** all other pre-hooks
+    /**
+     * Register a pre-transition hook that fires **before** all other pre-hooks
      *  on every transition.  If the handler returns `false`, the transition is
      *  blocked.  The handler receives an {@link EverythingHookContext} whose
      *  `hook_name` is `'pre everything'`.
@@ -2932,12 +2811,12 @@ declare class Machine<mDT> {
      *    return true;
      *  });
      *  ```
-     *
      *  @param handler - Callback invoked before all other pre-hooks.
      *  @returns `this` for chaining.
      */
     hook_pre_everything(handler: EverythingHookHandler<mDT>): Machine<mDT>;
-    /** Register a pre-transition hook that fires **after** all other pre-hooks
+    /**
+     * Register a pre-transition hook that fires **after** all other pre-hooks
      *  on every transition.  If the handler returns `false`, the transition is
      *  blocked.  The handler receives an {@link EverythingHookContext} whose
      *  `hook_name` is `'everything'`.
@@ -2949,12 +2828,12 @@ declare class Machine<mDT> {
      *    return true;
      *  });
      *  ```
-     *
      *  @param handler - Callback invoked after all other pre-hooks.
      *  @returns `this` for chaining.
      */
     hook_everything(handler: EverythingHookHandler<mDT>): Machine<mDT>;
-    /** Register a post-transition hook that fires **after** all other
+    /**
+     * Register a post-transition hook that fires **after** all other
      *  post-hooks on every transition.  Cannot block the transition.  The
      *  handler receives an {@link EverythingHookContext} whose `hook_name` is
      *  `'post everything'`.
@@ -2965,12 +2844,12 @@ declare class Machine<mDT> {
      *    console.log(`${hook_name} fired`);
      *  });
      *  ```
-     *
      *  @param handler - Callback invoked after all other post-hooks.
      *  @returns `this` for chaining.
      */
     hook_post_everything(handler: PostEverythingHookHandler<mDT>): Machine<mDT>;
-    /** Register a post-transition hook that fires **before** all other
+    /**
+     * Register a post-transition hook that fires **before** all other
      *  post-hooks on every transition.  Cannot block the transition.  The
      *  handler receives an {@link EverythingHookContext} whose `hook_name` is
      *  `'pre post everything'`.
@@ -2981,22 +2860,24 @@ declare class Machine<mDT> {
      *    console.log(`${hook_name} fired`);
      *  });
      *  ```
-     *
      *  @param handler - Callback invoked before all other post-hooks.
      *  @returns `this` for chaining.
      */
     hook_pre_post_everything(handler: PostEverythingHookHandler<mDT>): Machine<mDT>;
-    /** Get the current RNG seed used for probabilistic transitions.
+    /**
+     * Get the current RNG seed used for probabilistic transitions.
      *  @returns The numeric seed value.
      */
     get rng_seed(): number;
-    /** Set the RNG seed.  Pass `undefined` to reseed from the current time.
+    /**
+     * Set the RNG seed.  Pass `undefined` to reseed from the current time.
      *  Resets the internal PRNG so subsequent probabilistic operations use the
      *  new seed.
      *  @param to - The seed value, or `undefined` for time-based seeding.
      */
     set rng_seed(to: number | undefined);
-    /** Get all edges between two states (there can be multiple with
+    /**
+     * Get all edges between two states (there can be multiple with
      *  different actions).
      *  @param from - Source state name.
      *  @param to   - Target state name.
@@ -3038,82 +2919,7 @@ declare class Machine<mDT> {
      *  @see set_data
      *
      */
-    override(newState: StateType, newData?: mDT | undefined): void;
-    /*********
-     *
-     *  Fire a `'rejection'` event caused by a hook vetoing a pending transition.
-     *  Extracted from the per-call closures inside {@link transition_impl} so
-     *  that it is allocated once at class-definition time rather than on every
-     *  hooked transition.
-     *
-     *  @param hook_name  Name of the hook that rejected (e.g. `'exit'`).
-     *  @param fromState  State the machine was in when the transition was
-     *    attempted; used as the `from` field of the rejection event.
-     *  @param newState   State that would have been entered had the hook
-     *    passed; used as the `to` field of the rejection event.
-     *  @param fromAction Action name when the transition was initiated by an
-     *    action call; `undefined` for plain state transitions.
-     *  @param oldData    Machine data at the moment the transition was
-     *    attempted, before any hook mutations.
-     *  @param newData    The `next_data` value passed to the transition call.
-     *  @param wasForced  Whether the transition was attempted via
-     *    `force_transition`.
-     *
-     *  @see transition_impl
-     *  @see _fire
-     *
-     *  @internal
-     *
-     */
-    _fire_hook_rejection(hook_name: string, fromState: StateType, newState: StateType, fromAction: StateType | undefined, oldData: mDT, newData: mDT | undefined, wasForced: boolean): void;
-    /*********
-     *
-     *  Fire the FSL boundary-hook actions for a single, already-committed state
-     *  change.  In FSL, `do` is a synonym for `action`, so `on enter &g do 'X';`
-     *  means "when the machine crosses INTO group `g`, dispatch machine action
-     *  `X`" — and likewise `on exit` / plain-state subjects.  This is the runtime
-     *  that fires those parked hooks.
-     *
-     *  Crossing semantics (statechart convention — exits before enters):
-     *
-     *  1. `prev_groups` / `next_groups` are the deep (transitive) group sets of
-     *     the old and new states, from `_state_to_groups`.
-     *  2. **Exits** fire first: every group in `prev_groups \ next_groups` with an
-     *     `onExit`, plus the plain `prev_state`'s `onExit` (when the state name
-     *     actually changed).
-     *  3. **Enters** fire next: every group in `next_groups \ prev_groups` with an
-     *     `onEnter`, plus the plain `next_state`'s `onEnter` (when the state name
-     *     changed).
-     *  4. A group present in BOTH sets is a transition *within* that group and
-     *     fires neither of its boundary hooks.  `prev_state === next_state` fires
-     *     nothing at all.
-     *  5. "Fire its action" is `this.action(label)`.  If that action is not valid
-     *     from the current state, `action` is a safe no-op (returns `false`) — an
-     *     inapplicable boundary action never throws.
-     *  6. Multi-membership and nesting both fan out naturally: a state in groups
-     *     A and B fires both; crossing an inner and an outer boundary fires both
-     *     levels.
-     *
-     *  Because firing an action can drive a further transition (which crosses
-     *  more boundaries, which fires more actions), this is a bounded
-     *  run-to-completion: `_boundary_depth` tracks the live cascade depth and a
-     *  cascade deeper than `_boundary_depth_limit` throws a {@link JssmError}
-     *  rather than overflowing the stack or hanging.  The limit defaults to 100
-     *  and is configurable via the `boundary_depth_limit` constructor option.
-     *
-     *  @param prev_state The state the machine was in before this commit.
-     *  @param next_state The state the machine is in now (already committed).
-     *
-     *  @throws {JssmError} If cascaded boundary firing exceeds `_boundary_depth_limit`
-     *    (a probable infinite loop).
-     *
-     *  @see action
-     *  @see transition_impl
-     *
-     *  @internal
-     *
-     */
-    _fire_boundary_actions(prev_state: StateType, next_state: StateType): void;
+    override(newState: StateType, newData?: mDT): void;
     /*********
      *
      *  Shared transition core used by {@link transition}, {@link force_transition},
@@ -3165,7 +2971,8 @@ declare class Machine<mDT> {
      *
      */
     transition_impl(newStateOrAction: StateType, newData: mDT | undefined, wasForced: boolean, wasAction: boolean, dataProvided?: boolean): boolean;
-    /** If the current state has an `after` timeout configured, schedule it.
+    /**
+     * If the current state has an `after` timeout configured, schedule it.
      *  Called internally after each transition.
      */
     auto_set_state_timeout(): void;
@@ -3576,94 +3383,6 @@ declare class Machine<mDT> {
      *
      */
     state_has_hooks(state: StateType): boolean;
-    /********
-     *
-     *  Returns the list of resolved theme implementations for this machine, in
-     *  the order they should layer (outer/base-most first).  Each declared theme
-     *  name is mapped through {@link theme_mapping}; unknown names are skipped.
-     *
-     *  The list is reversed relative to declaration order to match the historical
-     *  layering of {@link style_for}: a later-declared theme layers under an
-     *  earlier-declared one.
-     *
-     *  @returns The resolved {@link JssmBaseTheme} stack, base-most first.
-     *
-     *  @internal
-     *
-     */
-    _resolved_themes(): JssmBaseTheme[];
-    /********
-     *
-     *  Reads the condensed per-state style fields (`color`, `shape`, …) out of a
-     *  state's declaration into a fresh {@link JssmStateConfig} — the tier-5
-     *  "`state foo : { … }`" contribution of the config cascade.  A state with no
-     *  declaration yields an all-`undefined` config (which contributes nothing
-     *  once folded with `merge_state_config`).
-     *
-     *  @param state The state whose per-state declared style is wanted.
-     *
-     *  @returns The per-state style config (fields may be `undefined`).
-     *
-     *  @internal
-     *
-     */
-    _individual_state_config(state: StateType): JssmStateConfig;
-    /********
-     *
-     *  Orders the groups a state belongs to by nesting depth for the config
-     *  cascade — outermost first, innermost last — so that, folded in order,
-     *  the innermost (nearest / smallest {@link membership_distance}) group's
-     *  metadata wins.  Equal-distance groups are ordered by group declaration
-     *  order, so a later-declared group of the same depth wins the tie.
-     *
-     *  Concretely: groups are sorted by descending membership distance (largest
-     *  distance applied first / wins least), and for equal distances by
-     *  ascending declaration index (later index applied last / wins most).
-     *
-     *  @param state The state whose containing groups are being ordered.
-     *
-     *  @returns The containing group names, ordered for outer→inner folding
-     *  (the last entry wins).
-     *
-     *  @internal
-     *
-     */
-    _groups_by_depth(state: StateType): string[];
-    /********
-     *
-     *  Folds the static tiers 1–5 of the unified config cascade for a state, plus
-     *  — when `active` is set — the active-state THEME layers, which historically
-     *  sit just below the per-state config so that a `state foo : { … }` block
-     *  still overrides a theme's `active` styling.  The user `active_state : { … }`
-     *  overlay (tier 6) is NOT applied here; it is layered on top by
-     *  {@link resolve_state_config} so it wins over per-state config.
-     *
-     *  Tiers, folded least-specific → most-specific with `merge_state_config`
-     *  (later wins, never throwing on a cross-tier key collision):
-     *
-     *    1. theme defaults — `base_theme.state`, then each selected theme's
-     *       `.state` block.
-     *    2. `default_state_config` (the implicit `state : { … }` root over every
-     *       state).
-     *    3. static per-kind defaults selected by structural kind — terminal,
-     *       then start, then end — each contributing its `base_theme.<kind>`,
-     *       selected themes' `.<kind>`, and the machine's `default_<kind>_state_config`.
-     *       When `active`, the active-state theme layers (`base_theme.active` and
-     *       each selected theme's `.active`) are folded here too.
-     *    4. group metadata, depth-ordered outer→inner (see {@link _groups_by_depth}),
-     *       each group's RAW `{ declarations }` already condensed at construction.
-     *    5. the per-state `state foo : { … }` config.
-     *
-     *  @param state  The state to resolve config for.
-     *  @param active Whether to include the active-state theme layers (true only
-     *                for the machine's currently-occupied state).
-     *
-     *  @returns The composited tiers-1–5 {@link JssmStateConfig} for the state.
-     *
-     *  @internal
-     *
-     */
-    _compose_state_config(state: StateType, active: boolean): JssmStateConfig;
     /********
      *
      *  Resolves the full unified style/config cascade for a state — the runtime
@@ -3838,76 +3557,90 @@ declare class Machine<mDT> {
      *
      */
     force_transition(newState: StateType, newData?: mDT): boolean;
-    /** Get the edge index for an action from the current state.
+    /**
+     * Get the edge index for an action from the current state.
      *  Interned dispatch: resolves via the numeric (action, from) index —
      *  unknown action names miss without throwing.
      *  @param action - The action name.
      *  @returns The edge index, or `undefined` if the action is not available.
      */
     current_action_for(action: StateType): number;
-    /** Get the full transition object for an action from the current state.
+    /**
+     * Get the full transition object for an action from the current state.
      *  @param action - The action name.
      *  @returns The {@link JssmTransition} object.
      *  @throws {JssmError} If the action is not available from the current state.
      */
     current_action_edge_for(action: StateType): JssmTransition<StateType, mDT>;
-    /** Check whether an action is available from the current state.
+    /**
+     * Check whether an action is available from the current state.
      *  @param action   - The action name to check.
      *  @param _newData - Reserved for future data validation.
      *  @returns `true` if the action can be taken.
      */
     valid_action(action: StateType, _newData?: mDT): boolean;
-    /** Check whether a transition to a given state is legal (non-forced) from
+    /**
+     * Check whether a transition to a given state is legal (non-forced) from
      *  the current state.
      *  @param newState - The target state.
      *  @param _newData - Reserved for future data validation.
      *  @returns `true` if the transition is legal.
      */
     valid_transition(newState: StateType, _newData?: mDT): boolean;
-    /** Check whether a forced transition to a given state exists from the
+    /**
+     * Check whether a forced transition to a given state exists from the
      *  current state.
      *  @param newState - The target state.
      *  @param _newData - Reserved for future data validation.
      *  @returns `true` if a forced (or any) transition exists.
      */
     valid_force_transition(newState: StateType, _newData?: mDT): boolean;
-    /** Get the instance name of this machine, if one was assigned at creation.
+    /**
+     * Get the instance name of this machine, if one was assigned at creation.
      *  @returns The instance name string, or `undefined`.
      */
     instance_name(): string | undefined;
-    /** Get the creation date of this machine as a `Date` object.
+    /**
+     * Get the creation date of this machine as a `Date` object.
      *  @returns A `Date` representing when the machine was created.
      */
     get creation_date(): Date;
-    /** Get the creation timestamp (milliseconds since epoch).
+    /**
+     * Get the creation timestamp (milliseconds since epoch).
      *  @returns The timestamp as a number.
      */
     get creation_timestamp(): number;
-    /** Get the timestamp when construction began (before parsing).
+    /**
+     * Get the timestamp when construction began (before parsing).
      *  @returns The start-of-construction timestamp as a number.
      */
     get create_start_time(): number;
-    /** Schedule an automatic transition to `next_state` after `after_time`
+    /**
+     * Schedule an automatic transition to `next_state` after `after_time`
      *  milliseconds.  Only one timeout may be active at a time.
      *  @param next_state - The state to transition to when the timer fires.
      *  @param after_time - Delay in milliseconds.
      *  @throws {JssmError} If a timeout is already pending.
      */
     set_state_timeout(next_state: StateType, after_time: number): void;
-    /** Cancel any pending state timeout.  Safe to call when no timeout is active.
+    /**
+      Cancel any pending state timeout.  Safe to call when no timeout is active.
      */
     clear_state_timeout(): void;
-    /** Get the configured `after` timeout for a given state, if any.
+    /**
+     * Get the configured `after` timeout for a given state, if any.
      *  @param which_state - The state to look up.
      *  @returns A `[targetState, delayMs]` tuple, or `undefined` if no timeout
      *  is configured for that state.
      */
     state_timeout_for(which_state: StateType): [StateType, number] | undefined;
-    /** Get the configured `after` timeout for the current state, if any.
+    /**
+     * Get the configured `after` timeout for the current state, if any.
      *  @returns A `[targetState, delayMs]` tuple, or `undefined`.
      */
     current_state_timeout(): [StateType, number] | undefined;
-    /** Convenience method to create a new machine from a tagged template literal.
+    /**
+     * Convenience method to create a new machine from a tagged template literal.
      *  Equivalent to calling the top-level `sm` function.
      *  @param template_strings - The template string array.
      *  @param remainder        - Interpolated values.
@@ -3946,11 +3679,9 @@ type RenderGroups = 'cluster' | 'chips' | 'off';
  *  configure({ DOMParser: new JSDOM().window.DOMParser });
  *  const el = await fsl_to_svg_element('a -> b;');
  *  ```
- *
  *  @param opts Configuration overrides.
  *  @param opts.DOMParser Constructor compatible with the WHATWG `DOMParser`
  *  interface.  Used as a fallback when `globalThis.DOMParser` is undefined.
- *
  *  @throws {JssmError} if `DOMParser` is provided and is not a constructor.
  */
 declare function configure(opts: {
@@ -3959,7 +3690,6 @@ declare function configure(opts: {
 /**
  *  Look up a color from the default viz palette by key, returning empty
  *  string if the key is unknown (so it disappears in feature concatenation).
- *
  *  @internal
  */
 declare function vc(col: string): string;
@@ -3973,10 +3703,8 @@ declare function vc(col: string): string;
  *  doublequote('a"b');  // 'a\\"b'
  *  doublequote('safe'); // 'safe'
  *  ```
- *
  *  @param txt Any string that will be placed inside `"…"` in a DOT attribute.
  *  @returns The string with every `"` replaced by `\"`.
- *
  *  @internal
  */
 declare function doublequote(txt: string): string;
@@ -3991,10 +3719,8 @@ declare function doublequote(txt: string): string;
  *  undoublequote('a\\"b');  // 'a"b'
  *  undoublequote('safe');   // 'safe'
  *  ```
- *
  *  @param txt A DOT-escaped attribute string (as produced by `doublequote`).
  *  @returns The string with every `\"` collapsed back to `"`.
- *
  *  @internal
  */
 declare function undoublequote(txt: string): string;
@@ -4017,11 +3743,9 @@ declare function undoublequote(txt: string): string;
  *  slug_for('!!!');          // ''
  *  slug_for('  Foo  Bar  '); // 'foo-bar'
  *  ```
- *
  *  @param state The state name to slugify.
  *  @returns The lowercase hyphen-separated slug, or empty string if none of
  *  the characters were retainable.
- *
  *  @internal
  */
 declare function slug_for(state: string): string;
@@ -4050,10 +3774,8 @@ declare function slug_for(state: string): string;
  *  slug_states(['!!!', '???']);
  *  // Map { '!!!' => 'node-1', '???' => 'node-2' }
  *  ```
- *
  *  @param states States in declaration order.
  *  @returns A `Map` from each state name to its unique slug.
- *
  *  @internal
  */
 declare function slug_states(states: string[]): Map<string, string>;
@@ -4074,7 +3796,6 @@ declare function slug_states(states: string[]): Map<string, string>;
  *  node_of('Red Light', new Map([['Red Light', 'red-light']]));
  *  // '"red-light"'
  *  ```
- *
  *  @internal
  */
 declare function node_of(state: string, state_index: string[] | Map<string, number> | Map<string, string>): string;
@@ -4084,13 +3805,11 @@ declare function node_of(state: string, state_index: string[] | Map<string, numb
  *  a 9-character `#`-prefixed string.
  *
  *  Graphviz dot does not support alpha; this is a lossy projection.
- *
  *  @internal
  */
 declare function color8to6(color8: string): string;
 /**
  *  Variant of {@link color8to6} that passes `undefined` through.
- *
  *  @internal
  */
 declare function u_color8to6(color8?: string): string | undefined;
@@ -4099,7 +3818,6 @@ declare function u_color8to6(color8?: string): string | undefined;
  *  so theme-supplied shapes are honoured along with per-state declarations.
  *  Returns `undefined` if neither a theme nor a state declaration supplies a
  *  shape.
- *
  *  @internal
  */
 declare function shape_for_state<T>(u_jssm: Machine<T>, state: string): string | undefined;
@@ -4108,7 +3826,6 @@ declare function shape_for_state<T>(u_jssm: Machine<T>, state: string): string |
  *  so theme-supplied images are honoured along with per-state declarations.
  *  Returns `undefined` if neither a theme nor a state declaration supplies an
  *  image.
- *
  *  @internal
  */
 declare function image_for_state<T>(u_jssm: Machine<T>, state: string): string | undefined;
@@ -4117,13 +3834,12 @@ declare function image_for_state<T>(u_jssm: Machine<T>, state: string): string |
  *  style via {@link jssm.Machine.style_for}, then delegating to
  *  {@link compose_style_string}.  Theme-supplied `corners` and `lineStyle`
  *  are honoured along with per-state declarations.
- *
  *  @internal
  */
 declare function style_for_state<T>(u_jssm: Machine<T>, state: string): string;
 /**
  *  Map a single `transition: {}` config item (`{ key, value }`) to a Graphviz
- *  *edge*-scope attribute `name="value"` pair, or `undefined` when the key has
+ *  edge*-scope attribute `name="value"` pair, or `undefined` when the key has
  *  no edge-meaningful projection.  Mirrors the per-node mapping in
  *  {@link state_node_line}, but targets the attribute names Graphviz uses on
  *  edges:
@@ -4136,7 +3852,6 @@ declare function style_for_state<T>(u_jssm: Machine<T>, state: string): string;
  *  Node-only keys (`background-color`, `shape`, `corners`, `image`, `url`,
  *  `state-label`, `border-color`) have no edge meaning and yield `undefined`,
  *  so they are dropped from the `edge [ … ]` default statement.
- *
  *  @internal
  */
 declare function edge_attr_for(key: string, value: string): string | undefined;
@@ -4153,13 +3868,12 @@ declare function edge_attr_for(key: string, value: string): string | undefined;
  *  edge_defaults_body([{ key: 'color', value: '#0000ffff' }]);
  *  // 'color="#0000ffff"'
  *  ```
- *
  *  @internal
  */
 declare function edge_defaults_body(config: JssmTransitionConfig | undefined): string;
 /**
  *  Map a single `graph: {}` config item (`{ key, value }`) to a Graphviz
- *  *graph*-scope attribute `name="value"` pair, or `undefined` when the key is
+ *  graph*-scope attribute `name="value"` pair, or `undefined` when the key is
  *  either not graph-meaningful or already handled by another machine path
  *  (`graph_layout` → SVG engine, `flow` → `rankdir`, `theme` → style cascade,
  *  `dot_preamble` → preamble).  `background-color` is handled separately — it
@@ -4168,7 +3882,6 @@ declare function edge_defaults_body(config: JssmTransitionConfig | undefined): s
  *
  *  - `color`      → graph `color` (cluster/graph border).
  *  - `text-color` → graph `fontcolor`.
- *
  *  @internal
  */
 declare function graph_attr_for(key: string, value: string): string | undefined;
@@ -4183,7 +3896,6 @@ declare function graph_attr_for(key: string, value: string): string | undefined;
  *  This is the single reconciliation point for the graph background: the value
  *  it returns flows into {@link dot_template}'s one `bgcolor="…"` slot, so the
  *  `graph: {}` value wins over the legacy alias and is never emitted twice.
- *
  *  @internal
  */
 declare function graph_bg_color_from_config(config: JssmGraphConfig | undefined, fallback: string): string;
@@ -4193,7 +3905,6 @@ declare function graph_bg_color_from_config(config: JssmGraphConfig | undefined,
  *  one Graphviz graph attribute statement per key (e.g. `color="…";`).  Returns
  *  the empty string when nothing applies, so machines without graph-scope color
  *  attributes are byte-identical to before.
- *
  *  @internal
  */
 declare function graph_attrs_body(config: JssmGraphConfig | undefined): string;
@@ -4216,7 +3927,6 @@ declare function graph_attrs_body(config: JssmGraphConfig | undefined): string;
  *  or only terminal — a long-standing bug.  The fix is to check the two
  *  underlying predicates directly so the three named buckets reflect
  *  three meaningfully distinct conditions.
- *
  *  @internal
  */
 type StateKind = 'final' | 'complete' | 'terminal' | 'base';
@@ -4235,12 +3945,10 @@ type StateKind = 'final' | 'complete' | 'terminal' | 'base';
  *  cluster_id_for('Active Players', 0);  // 'cluster_active_players_0'
  *  cluster_id_for('!!!', 3);             // 'cluster_g3'
  *  ```
- *
  *  @param group The FSL group name.
  *  @param index The group's stable declaration-order index (0-based); included
  *  in the emitted id to prevent slug collisions.
  *  @returns A valid Graphviz subgraph identifier starting with `cluster_`.
- *
  *  @internal
  */
 declare function cluster_id_for(group: string, index: number): string;
@@ -4255,7 +3963,6 @@ declare function cluster_id_for(group: string, index: number): string;
  *  label_with_chips('Foo', []);              // 'Foo'
  *  label_with_chips('Foo', ['a', 'b']);      // 'Foo [a] [b]'
  *  ```
- *
  *  @internal
  */
 declare function label_with_chips(label: string, chips: string[]): string;
@@ -4272,7 +3979,6 @@ declare function label_with_chips(label: string, chips: string[]): string;
  *  // for `&inner:[a]; &outer:[&inner b];`
  *  // group_parent_map(reg, ['inner','outer']) === Map { 'inner' => 'outer' }
  *  ```
- *
  *  @internal
  */
 declare function group_parent_map(registry: Map<string, JssmGroupMemberRef[]>, order: string[]): Map<string, string>;
@@ -4281,7 +3987,6 @@ declare function group_parent_map(registry: Map<string, JssmGroupMemberRef[]>, o
  *  ancestor set *including the group itself*.  Used both to nest clusters and
  *  to decide which of a state's memberships its primary cluster already
  *  represents (so the rest become chips).
- *
  *  @internal
  */
 declare function group_ancestry(group: string, parents: Map<string, string>): Set<string>;
@@ -4291,7 +3996,6 @@ declare function group_ancestry(group: string, parents: Map<string, string>): Se
  *  declaration order — the same precedence the config cascade uses, so a
  *  state's cluster placement agrees with the group whose style won.  Returns
  *  `undefined` for a state in no group.
- *
  *  @internal
  */
 declare function primary_group_for<T>(u_jssm: Machine<T>, state: string, order: string[]): string | undefined;
@@ -4301,11 +4005,9 @@ declare function primary_group_for<T>(u_jssm: Machine<T>, state: string, order:
  *  ungrouped state) plus the *chip* groups — memberships the primary cluster's
  *  ancestry does not already represent, i.e. genuine overlap that nesting
  *  cannot show.
- *
  *  @returns `{ placement, chips }` where `placement` maps state → primary
  *  group, and `chips` maps state → the overflow group names (declaration
  *  order).
- *
  *  @internal
  */
 declare function plan_cluster_groups<T>(u_jssm: Machine<T>, l_states: string[], order: string[], parents: Map<string, string>): {
@@ -4328,10 +4030,8 @@ declare function plan_cluster_groups<T>(u_jssm: Machine<T>, l_states: string[],
  *  // for `&inner:[a]; &outer:[&inner b]; a -> b;` the result contains
  *  //   subgraph cluster_outer { label="outer"; … subgraph cluster_inner { … } }
  *  ```
- *
  *  @returns `{ clusters, ungrouped_nodes }` — the cluster DOT block and the
  *  node statements for states in no group.
- *
  *  @internal
  */
 declare function groups_to_subgraph_string<T>(u_jssm: Machine<T>, l_states: string[], state_index: Map<string, string>, state_kinds: Map<string, StateKind>, hide_state_labels: boolean): {
@@ -4348,7 +4048,6 @@ declare function groups_to_subgraph_string<T>(u_jssm: Machine<T>, l_states: stri
  *  // for `&inner:[a]; &outer:[&inner b]; a -> b;`
  *  // chips_for_all_groups(m, ['a','b']) === Map { 'a' => ['inner','outer'], 'b' => ['outer'] }
  *  ```
- *
  *  @internal
  */
 declare function chips_for_all_groups<T>(u_jssm: Machine<T>, l_states: string[]): Map<string, string[]>;
@@ -4388,7 +4087,6 @@ type VizRenderOpts = {
  *
  *  A machine that declares no groups produces the same flat node list in every
  *  mode, so `'cluster'`/`'chips'` are no-ops there.
- *
  *  @internal
  */
 declare function node_block_for<T>(u_jssm: Machine<T>, l_states: string[], state_index: Map<string, string>, state_kinds: Map<string, StateKind>, hide_labels: boolean, mode: RenderGroups): string;
@@ -4399,7 +4097,6 @@ declare function node_block_for<T>(u_jssm: Machine<T>, l_states: string[], state
  *  {@link plan_cluster_groups} (with identical inputs) for `'cluster'` — so a
  *  reconstructed label can never disagree with the one graphviz was handed.
  *  `'off'`, and any machine that declares no groups, yields an empty map.
- *
  *  @internal
  */
 declare function chips_for_render_mode<T>(u_jssm: Machine<T>, l_states: string[], mode: RenderGroups): Map<string, string[]>;
@@ -4418,7 +4115,6 @@ declare function chips_for_render_mode<T>(u_jssm: Machine<T>, l_states: string[]
  *  alike.  It is built by running the node builder's own
  *  `label_with_chips(doublequote(display_text), chips)` and inverting the one
  *  escaping step, so it follows any change to the label format for free.
- *
  *  @param u_jssm The machine being rendered.
  *  @param opts Render flags; only `render_groups` affects the label text
  *  (default `'cluster'`, matching `fsl_to_svg_string`).
@@ -4432,7 +4128,6 @@ declare function chips_for_render_mode<T>(u_jssm: Machine<T>, l_states: string[]
  *  state_svg_label_texts(sm`&g1 : [a b]; &g2 : [a]; a -> b;`).get('a');  // 'a [g1]'
  *  state_svg_label_texts(sm`a -> b;`).get('a');                          // 'a'
  *  ```
- *
  *  @see extract_state_fills
  */
 declare function state_svg_label_texts<T>(u_jssm: Machine<T>, opts?: VizRenderOpts): Map<string, string>;
@@ -4464,7 +4159,6 @@ declare function state_svg_label_texts<T>(u_jssm: Machine<T>, opts?: VizRenderOp
  *  // or as label chips, with no cluster boxes
  *  const chipped = machine_to_dot(sm`&g : [a b]; a -> b;`, { render_groups: 'chips' });
  *  ```
- *
  *  @param u_jssm The machine to render.
  *  @param opts Optional render flags.  See {@link VizRenderOpts}.
  *  @returns A complete graphviz dot source string.
@@ -4483,7 +4177,6 @@ declare function machine_to_dot<T>(u_jssm: Machine<T>, opts?: VizRenderOpts): st
  *  const dot_with_footer = fsl_to_dot('a -> b;', { footer: 'label="caption";' });
  *  // 'digraph G { ... label="caption"; }'
  *  ```
- *
  *  @param fsl The FSL source.
  *  @param opts Optional render flags.  See {@link VizRenderOpts}.
  *  @returns A complete graphviz dot source string.
@@ -4498,7 +4191,6 @@ declare function fsl_to_dot(fsl: string, opts?: VizRenderOpts): string;
  *  const svg = await dot_to_svg('digraph G { a -> b }');
  *  const svg_neato = await dot_to_svg('digraph G { a -> b }', { engine: 'neato' });
  *  ```
- *
  *  @param dot Graphviz dot source.
  *  @param options Optional renderer overrides.
  *  @param options.engine Graphviz layout engine to use (e.g. `'dot'`,
@@ -4516,7 +4208,6 @@ declare function dot_to_svg(dot: string, options?: {
  *  const svg = await fsl_to_svg_string('a -> b;');
  *  const svg_neato = await fsl_to_svg_string('a -> b;', { engine: 'neato' });
  *  ```
- *
  *  @param fsl The FSL source.
  *  @param opts Optional render flags.  See {@link VizRenderOpts}.
  *  @returns A promise resolving to an SVG XML string.
@@ -4524,7 +4215,6 @@ declare function dot_to_svg(dot: string, options?: {
 declare function fsl_to_svg_string(fsl: string, opts?: VizRenderOpts): Promise<string>;
 /**
  *  Render a {@link jssm.Machine} to SVG.
- *
  *  @param u_jssm The machine to render.
  *  @param opts Optional render flags.  See {@link VizRenderOpts}.
  *  @returns A promise resolving to an SVG XML string.
@@ -4532,7 +4222,6 @@ declare function fsl_to_svg_string(fsl: string, opts?: VizRenderOpts): Promise<s
 declare function machine_to_svg_string<T>(u_jssm: Machine<T>, opts?: VizRenderOpts): Promise<string>;
 /**
  *  Render an FSL string directly to a parsed `SVGSVGElement`.
- *
  *  @param fsl The FSL source.
  *  @param opts Optional render flags.  See {@link VizRenderOpts}.
  *  @returns A promise resolving to a parsed `SVGSVGElement`.
@@ -4541,7 +4230,6 @@ declare function machine_to_svg_string<T>(u_jssm: Machine<T>, opts?: VizRenderOp
 declare function fsl_to_svg_element(fsl: string, opts?: VizRenderOpts): Promise<SVGSVGElement>;
 /**
  *  Render a {@link jssm.Machine} to a parsed `SVGSVGElement`.
- *
  *  @param u_jssm The machine to render.
  *  @param opts Optional render flags.  See {@link VizRenderOpts}.
  *  @returns A promise resolving to a parsed `SVGSVGElement`.
@@ -4551,12 +4239,11 @@ declare function machine_to_svg_element<T>(u_jssm: Machine<T>, opts?: VizRenderO
 /**
  *  Compatibility wrapper for {@link machine_to_dot}, retained from
  *  jssm-viz.  Will be removed in the next major.
- *
  *  @deprecated Use {@link machine_to_dot} instead.
  */
 declare function dot<T>(machine: Machine<T>): string;
 
-/** @internal — test-only access to private helpers. */
+/** @internal */
 declare const _test: {
     doublequote: typeof doublequote;
     color8to6: typeof color8to6;