jssm 5.162.6 → 5.162.8

package/jssm.es6.d.ts

@@ -68,7 +68,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 = {
@@ -103,8 +102,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;
@@ -130,7 +128,6 @@ type JssmSerialization<DataType> = {
  *  // [ { kind: 'group', name: 'inner', mode: 'nest' },
  *  //   { kind: 'state', name: 'x' } ]
  *  ```
- *
  *  @see JssmGroupRef
  *  @see JssmGroupRegistry
  */
@@ -157,7 +154,6 @@ type JssmGroupMemberRef = {
  *  // registry.get('outer') === [ { kind:'group', name:'inner', mode:'nest' },
  *  //                             { kind:'state', name:'c' } ]
  *  ```
- *
  *  @see JssmGroupMemberRef
  */
 type JssmGroupRegistry = Map<string, JssmGroupMemberRef[]>;
@@ -167,7 +163,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 = {
@@ -178,7 +173,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>;
@@ -186,7 +180,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>;
@@ -218,9 +211,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;
@@ -404,7 +396,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;
@@ -419,7 +410,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[];
@@ -430,7 +420,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;
 } | {
@@ -445,13 +435,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;
@@ -468,40 +457,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
@@ -511,9 +469,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
@@ -573,7 +530,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
      */
@@ -593,7 +549,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>>;
@@ -657,7 +613,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> = {
@@ -681,7 +636,6 @@ type JssmCompileSe<StateType, mDT> = {
  *  for non-transition rules (state declarations, property definitions,
  *  machine metadata) via its `key`/`value`/`name`/`state` fields.  Not
  *  intended for end-user code.
- *
  *  @internal
  */
 type JssmCompileSeStart<StateType, DataType> = {
@@ -702,7 +656,6 @@ type JssmCompileSeStart<StateType, DataType> = {
  *  The output shape of the FSL parser: a flat array of
  *  {@link JssmCompileSeStart} entries, one per top-level rule in the
  *  source.  Consumed by the compiler to build a machine configuration.
- *
  *  @internal
  */
 type JssmParseTree<StateType, mDT> = Array<JssmCompileSeStart<StateType, mDT>>;
@@ -997,7 +950,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';
@@ -1091,7 +1043,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
@@ -1186,15 +1138,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;
 /**
@@ -1203,6 +1155,221 @@ type JssmEventHandler<mDT, Ev extends JssmEventName> = (detail: JssmEventDetailM
  */
 type JssmUnsubscribe = () => void;
 
+/**
+ * String interning support for the jssm machine internals.
+ *
+ * State and action names are interned to dense integer ids at machine
+ * construction so that per-transition dispatch can use numeric map keys
+ * (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
+ */
+/**
+ * A string↔integer bimap.  Assigns dense ids (0, 1, 2, …) in first-seen
+ * order; lookups are O(1) both directions.  Grows monotonically — there is
+ * 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
+ *   i.intern('green');   // 1
+ *   i.intern('red');     // 0  (idempotent)
+ *   i.id_of('green');    // 1
+ *   i.name_of(0);        // 'red'
+ * @see pair_key
+ */
+declare class Interner {
+    private readonly ids;
+    private readonly names;
+    constructor();
+    /**
+     * 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
+     */
+    intern(name: string): number;
+    /**
+     * 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'
+     */
+    name_of(id: number): string | undefined;
+    /** The count of distinct interned names. */
+    get size(): number;
+}
+
+/**
+ * Editor-agnostic data types for the FSL language service.
+ *
+ * These are the neutral contract every editor adapter (CodeMirror, VS Code, a
+ * future LSP server) converts to/from. Shapes are kept aligned with LSP types so
+ * an LSP wrapper is a near-mechanical mapping.
+ */
+/** A character-offset range in the FSL source. */
+interface Range {
+    from: number;
+    to: number;
+}
+/** Diagnostic severity, aligned with LSP severities. */
+type DiagnosticSeverity = 'error' | 'warning' | 'info' | 'hint';
+/** An editor-agnostic diagnostic (one parse/compile problem). */
+interface Diagnostic {
+    range: Range;
+    severity: DiagnosticSeverity;
+    message: string;
+}
+/** What a completion item suggests, so adapters can pick an icon. */
+type CompletionKind = 'key' | 'value-color' | 'value-shape' | 'value-enum';
+/** An editor-agnostic completion suggestion. */
+interface CompletionItem {
+    label: string;
+    kind: CompletionKind;
+    detail?: string;
+}
+/** Parser-derived semantic role of a source span. */
+type SemanticSpanKind = 'color' | 'state' | 'enum';
+/** An editor-agnostic semantic span (for decorations / semantic tokens). */
+interface SemanticSpan extends Range {
+    kind: SemanticSpanKind;
+    value?: string;
+}
+
+/**
+ * Editor-agnostic FSL diagnostics: parse then compile, reporting problems as
+ * neutral {@link Diagnostic}s. Adapters map these to CodeMirror lint diagnostics,
+ * VS Code markers, or LSP `Diagnostic`s.
+ *
+ * Parse errors (peg.js) carry `.location`; compile errors carry
+ * `.source_location` *when they reference a parsed node* — but machine-level
+ * compile errors (e.g. an empty machine, an unknown machine rule) have none, so
+ * the location is treated as optional and falls back to the whole document.
+ *
+ * Some validity checks (e.g. a `required` property that no state defines) live
+ * in the {@link Machine} constructor, a stage past `compile`. We therefore also
+ * construct the machine so the editor surfaces those construction-time errors
+ * instead of calling such a machine valid. The `Machine` import closes a cycle
+ * (`jssm` re-exports this module), but it is only referenced at call time inside
+ * {@link fslDiagnostics}, never during module initialization, so the cycle is
+ * benign.
+ */
+
+/**
+ * Parse then compile `text`, returning a list of diagnostics — empty when the
+ * machine parses and compiles cleanly.
+ * @example
+ *   fslDiagnostics('a -> b;');            // => []
+ *   fslDiagnostics('a -> ;')[0].severity; // => 'error'
+ *   // a `required` property no state defines is a construction-time error:
+ *   fslDiagnostics('property p required; a -> b;')[0].severity; // => 'error'
+ */
+declare function fslDiagnostics(text: string): Diagnostic[];
+
+/**
+ * Context-aware, editor-agnostic FSL completions. Value suggestions after a
+ * `key:`, key suggestions at a statement start (top-level vs inside a `{ }`
+ * block, by brace depth). Adapters convert {@link CompletionItem}s to their own
+ * completion type. Value vocab is jssm's own (`gviz_shapes`, `named_colors`,
+ * `FslDirections`), so it cannot drift from the renderer.
+ */
+
+/**
+ * Completions for the caret at `offset` in `text`.
+ * @example
+ *   fslCompletions('state x : { color: ', 19)[0].kind;  // => 'value-color'
+ */
+declare function fslCompletions(text: string, offset: number): CompletionItem[];
+
+/**
+ * Parser-derived semantic spans for FSL: color values (with resolved hex),
+ * state names, and shape-enum values. Returns `[]` if the document does not
+ * parse. Editor-agnostic — adapters map spans to decorations or semantic
+ * tokens. Logic is a verified port of the sketch's `semantic_overlay.mjs`.
+ */
+
+/**
+ * Collect color / state / shape-enum semantic spans from `text`. State spans
+ * cover transition endpoints, state-declaration subjects, group-list members
+ * (`&G : [a b c];` — but not the group's own name, nor `&`/`...&` nested
+ * group references), and plain-label hook subjects (`on enter x do 'act';` —
+ * but not `&group` subjects). Every state span's `value` is the parser's
+ * resolved name (unquoted, unescaped), while `from`/`to` cover the source
+ * spelling including any quotes.
+ * @example
+ *   fslSemanticSpans('state s : { color: crimson; };')
+ *     .find(s => s.kind === 'color')?.value;   // => '#dc143cff'
+ * @example
+ *   fslSemanticSpans('&G : [a b];\na -> b;')
+ *     .filter(s => s.kind === 'state').length;   // => 4 (two members + two endpoints)
+ */
+declare function fslSemanticSpans(text: string): SemanticSpan[];
+
+/**
+ *  The FSL Markdown fence convention parser — pure, host-agnostic logic that
+ *  turns a fenced-code-block info string into a {@link FenceDescriptor}.  Hosts
+ *  (a VS Code preview plugin, a static-site generator, …) each interpret the
+ *  descriptor according to their capabilities.
+ *  @see notes/superpowers/specs/2026-06-23-fsl-markdown-fence-convention-design.md
+ */
+/** A single renderable part of a fence block (stacks in listed order, first on top). */
+type FencePart = 'image' | 'code' | 'dot' | 'editor' | 'actions' | 'info-panel' | 'toolbar' | 'title' | 'footer';
+/** An image output format for the `image` part. */
+type FenceImageFormat = 'svg' | 'png' | 'jpeg' | 'gif';
+/** The unit of a {@link FenceDimension} (`%` is represented as `'percent'`). */
+type FenceDimensionUnit = 'px' | 'percent';
+/** A parsed `width=`/`height=` value with its unit. */
+interface FenceDimension {
+    value: number;
+    unit: FenceDimensionUnit;
+}
+/** The fully-parsed, validated description of one FSL Markdown fence block. */
+interface FenceDescriptor {
+    parts: FencePart[];
+    ide: boolean;
+    format: FenceImageFormat;
+    width: FenceDimension | null;
+    height: FenceDimension | null;
+    interactive: boolean;
+    notes: string[];
+}
+/**
+ *  Canonical fence language for an info string, or `null` if the block is not
+ *  an FSL fence.  Reads only the first whitespace-delimited token,
+ *  case-insensitively.
+ *  @param info The full fence info string (everything after the opening fence).
+ *  @returns `'fsl'` or `'jssm'` for our fences; `null` otherwise.
+ *  @example fsl_fence_lang('fsl image code') // => 'fsl'
+ *  @example fsl_fence_lang('JSSM')           // => 'jssm'
+ *  @example fsl_fence_lang('mermaid')        // => null
+ */
+declare function fsl_fence_lang(info: string): 'fsl' | 'jssm' | null;
+/**
+ *  Parse a fence info string into a {@link FenceDescriptor}.  The first token is
+ *  the (already-validated) language and is ignored; remaining tokens are
+ *  classified as parts, image formats, the `ide` macro, or `width`/`height`
+ *  options.  Unrecognized or conflicting tokens are dropped and recorded in
+ *  `notes` rather than throwing, so a host can render forward-compatibly.
+ *  @param info The full fence info string, e.g. `'fsl image code width=300'`.
+ *  @returns The validated descriptor; `notes` lists anything ignored or overridden.
+ *  @example parse_fence_info('fsl').parts // => ['image', 'code']
+ *  @example parse_fence_info('fsl code image').parts // => ['code', 'image']
+ */
+declare function parse_fence_info(info: string): FenceDescriptor;
+
 /*********
  *
  *  Return the direction of an arrow - `right`, `left`, or `both`.
@@ -1342,7 +1509,7 @@ declare function arrow_right_kind(arrow: JssmArrow): JssmArrowKind;
  *                 tracking on every AST node.
  *
  */
-declare function wrap_parse(input: string, options?: Object): any;
+declare function wrap_parse(input: string, options?: object): any;
 /*********
  *
  *  Compile a machine's JSON intermediate representation to a config object.  If
@@ -1469,7 +1636,7 @@ declare function make<StateType, mDT>(plan: string): JssmGenericConfig<StateType
  *  @throws {TypeError} If `options` is not a non-empty array of objects.
  *
  */
-declare const weighted_rand_select: Function;
+declare const weighted_rand_select: (options: Array<any>, probability_property: string, rng: JssmRng) => any;
 /*******
  *
  *  Returns, for a non-negative integer argument `n`, the series `[0 .. n]`.
@@ -1495,7 +1662,7 @@ declare function seq(n: number): number[];
  *  ```
  *
  */
-declare const histograph: Function;
+declare const histograph: (ar: any[]) => Map<any, number>;
 /*******
  *
  *  Draws `n` weighted random samples from an array of objects.  Each draw is
@@ -1519,7 +1686,7 @@ declare const histograph: Function;
  *  @returns An array of `n` independently selected items.
  *
  */
-declare const weighted_sample_select: Function;
+declare const weighted_sample_select: (n: number, options: Array<any>, probability_property: string, rng?: JssmRng) => Array<any>;
 /*******
  *
  *  Draws `n` weighted random samples, extracts a named key from each, and
@@ -1547,7 +1714,7 @@ declare const weighted_sample_select: Function;
  *  @returns A `Map` from extracted key values to their occurrence counts.
  *
  */
-declare const weighted_histo_key: Function;
+declare const weighted_histo_key: (n: number, opts: Array<any>, prob_prop: string, extract: string, rng?: JssmRng) => Map<any, number>;
 /*******
  *
  *  Creates a SplitMix32 random generator.  Used by the randomness test suite.
@@ -1557,7 +1724,7 @@ declare const weighted_histo_key: Function;
  *  Replaces the Mulberry generator, which was found to have problems
  *
  */
-declare function gen_splitmix32(a?: number | undefined): () => number;
+declare function gen_splitmix32(a?: number): () => number;
 /*******
  *
  *  Reduces an array to its unique contents.  Compares with `===` and makes no
@@ -1611,71 +1778,18 @@ declare function find_repeated<T>(arr: T[]): [T, number][];
 declare function sleep(ms: number): Promise<unknown>;
 
 /**
- * String interning support for the jssm machine internals.
- *
- * State and action names are interned to dense integer ids at machine
- * construction so that per-transition dispatch can use numeric map keys
- * (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
+ *  The published semantic version of the jssm package this build was cut from.
+ *  Mirrored from `package.json` by `src/buildjs/makever.cjs` at build time.
+ *  Useful for runtime diagnostics and for embedding in serialized machine
+ *  snapshots so that deserializers can detect version-skew.
  */
+declare const version: string;
 /**
- * A string↔integer bimap.  Assigns dense ids (0, 1, 2, …) in first-seen
- * order; lookups are O(1) both directions.  Grows monotonically — there is
- * 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
- *   i.intern('green');   // 1
- *   i.intern('red');     // 0  (idempotent)
- *   i.id_of('green');    // 1
- *   i.name_of(0);        // 'red'
- *
- * @see pair_key
+ *  The Unix epoch timestamp (in milliseconds) at which this build was produced,
+ *  written by `src/buildjs/makever.cjs`.  Useful for distinguishing builds
+ *  with the same `version` string during development, and for diagnostic logs.
  */
-declare class Interner {
-    private readonly ids;
-    private readonly names;
-    constructor();
-    /**
-     * 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
-     */
-    intern(name: string): number;
-    /**
-     * 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'
-     */
-    name_of(id: number): string | undefined;
-    /** The count of distinct interned names. */
-    get size(): number;
-}
+declare const build_time: number;
 
 /*******
  *
@@ -1747,7 +1861,6 @@ declare const named_colors$1: string[];
  *  Includes ASCII digits/letters and the symbols
  *  `.`, `+`, `_`, `^`, `(`, `)`, `*`, `&`, `$`, `#`, `@`, `!`, `?`, `,`,
  *  plus the high-Unicode range `U+0080`–`U+FFFF`.
- *
  *  @example
  *  import { state_name_chars } from 'jssm';
  *  state_name_chars.some(r => 'A' >= r.from && 'A' <= r.to);  // => true
@@ -1763,7 +1876,6 @@ declare const state_name_chars$1: ReadonlyArray<{
  *  Notably narrower than {@link state_name_chars}: omits `+`, `(`, `)`, `&`,
  *  `#`, `@`.  Includes ASCII digits/letters, `.`, `_`, `!`, `$`, `^`, `*`,
  *  `?`, `,`, and the high-Unicode range `U+0080`–`U+FFFF`.
- *
  *  @example
  *  import { state_name_first_chars } from 'jssm';
  *  state_name_first_chars.some(r => '+' >= r.from && '+' <= r.to);  // => false
@@ -1779,7 +1891,6 @@ declare const state_name_first_chars$1: ReadonlyArray<{
  *  excluded since it terminates the label.
  *
  *  Three ranges: `U+0020`–`U+0026`, `U+0028`–`U+005B`, `U+005D`–`U+FFFF`.
- *
  *  @example
  *  import { action_label_chars } from 'jssm';
  *  action_label_chars.some(r => ' ' >= r.from && ' ' <= r.to);   // => true
@@ -1835,186 +1946,6 @@ declare namespace jssm_constants_d {
   };
 }
 
-/**
- * Editor-agnostic data types for the FSL language service.
- *
- * These are the neutral contract every editor adapter (CodeMirror, VS Code, a
- * future LSP server) converts to/from. Shapes are kept aligned with LSP types so
- * an LSP wrapper is a near-mechanical mapping.
- */
-/** A character-offset range in the FSL source. */
-interface Range {
-    from: number;
-    to: number;
-}
-/** Diagnostic severity, aligned with LSP severities. */
-type DiagnosticSeverity = 'error' | 'warning' | 'info' | 'hint';
-/** An editor-agnostic diagnostic (one parse/compile problem). */
-interface Diagnostic {
-    range: Range;
-    severity: DiagnosticSeverity;
-    message: string;
-}
-/** What a completion item suggests, so adapters can pick an icon. */
-type CompletionKind = 'key' | 'value-color' | 'value-shape' | 'value-enum';
-/** An editor-agnostic completion suggestion. */
-interface CompletionItem {
-    label: string;
-    kind: CompletionKind;
-    detail?: string;
-}
-/** Parser-derived semantic role of a source span. */
-type SemanticSpanKind = 'color' | 'state' | 'enum';
-/** An editor-agnostic semantic span (for decorations / semantic tokens). */
-interface SemanticSpan extends Range {
-    kind: SemanticSpanKind;
-    value?: string;
-}
-
-/**
- * Editor-agnostic FSL diagnostics: parse then compile, reporting problems as
- * neutral {@link Diagnostic}s. Adapters map these to CodeMirror lint diagnostics,
- * VS Code markers, or LSP `Diagnostic`s.
- *
- * Parse errors (peg.js) carry `.location`; compile errors carry
- * `.source_location` *when they reference a parsed node* — but machine-level
- * compile errors (e.g. an empty machine, an unknown machine rule) have none, so
- * the location is treated as optional and falls back to the whole document.
- *
- * Some validity checks (e.g. a `required` property that no state defines) live
- * in the {@link Machine} constructor, a stage past `compile`. We therefore also
- * construct the machine so the editor surfaces those construction-time errors
- * instead of calling such a machine valid. The `Machine` import closes a cycle
- * (`jssm` re-exports this module), but it is only referenced at call time inside
- * {@link fslDiagnostics}, never during module initialization, so the cycle is
- * benign.
- */
-
-/**
- * Parse then compile `text`, returning a list of diagnostics — empty when the
- * machine parses and compiles cleanly.
- *
- * @example
- *   fslDiagnostics('a -> b;');            // => []
- *   fslDiagnostics('a -> ;')[0].severity; // => 'error'
- *   // a `required` property no state defines is a construction-time error:
- *   fslDiagnostics('property p required; a -> b;')[0].severity; // => 'error'
- */
-declare function fslDiagnostics(text: string): Diagnostic[];
-
-/**
- * Context-aware, editor-agnostic FSL completions. Value suggestions after a
- * `key:`, key suggestions at a statement start (top-level vs inside a `{ }`
- * block, by brace depth). Adapters convert {@link CompletionItem}s to their own
- * completion type. Value vocab is jssm's own (`gviz_shapes`, `named_colors`,
- * `FslDirections`), so it cannot drift from the renderer.
- */
-
-/**
- * Completions for the caret at `offset` in `text`.
- *
- * @example
- *   fslCompletions('state x : { color: ', 19)[0].kind;  // => 'value-color'
- */
-declare function fslCompletions(text: string, offset: number): CompletionItem[];
-
-/**
- * Parser-derived semantic spans for FSL: color values (with resolved hex),
- * state names, and shape-enum values. Returns `[]` if the document does not
- * parse. Editor-agnostic — adapters map spans to decorations or semantic
- * tokens. Logic is a verified port of the sketch's `semantic_overlay.mjs`.
- */
-
-/**
- * Collect color / state / shape-enum semantic spans from `text`. State spans
- * cover transition endpoints, state-declaration subjects, group-list members
- * (`&G : [a b c];` — but not the group's own name, nor `&`/`...&` nested
- * group references), and plain-label hook subjects (`on enter x do 'act';` —
- * but not `&group` subjects). Every state span's `value` is the parser's
- * resolved name (unquoted, unescaped), while `from`/`to` cover the source
- * spelling including any quotes.
- *
- * @example
- *   fslSemanticSpans('state s : { color: crimson; };')
- *     .find(s => s.kind === 'color')?.value;   // => '#dc143cff'
- *
- * @example
- *   fslSemanticSpans('&G : [a b];\na -> b;')
- *     .filter(s => s.kind === 'state').length;   // => 4 (two members + two endpoints)
- */
-declare function fslSemanticSpans(text: string): SemanticSpan[];
-
-/**
- *  The published semantic version of the jssm package this build was cut from.
- *  Mirrored from `package.json` by `src/buildjs/makever.cjs` at build time.
- *  Useful for runtime diagnostics and for embedding in serialized machine
- *  snapshots so that deserializers can detect version-skew.
- */
-declare const version: string;
-/**
- *  The Unix epoch timestamp (in milliseconds) at which this build was produced,
- *  written by `src/buildjs/makever.cjs`.  Useful for distinguishing builds
- *  with the same `version` string during development, and for diagnostic logs.
- */
-declare const build_time: number;
-
-/**
- *  The FSL Markdown fence convention parser — pure, host-agnostic logic that
- *  turns a fenced-code-block info string into a {@link FenceDescriptor}.  Hosts
- *  (a VS Code preview plugin, a static-site generator, …) each interpret the
- *  descriptor according to their capabilities.
- *
- *  @see notes/superpowers/specs/2026-06-23-fsl-markdown-fence-convention-design.md
- */
-/** A single renderable part of a fence block (stacks in listed order, first on top). */
-type FencePart = 'image' | 'code' | 'dot' | 'editor' | 'actions' | 'info-panel' | 'toolbar' | 'title' | 'footer';
-/** An image output format for the `image` part. */
-type FenceImageFormat = 'svg' | 'png' | 'jpeg' | 'gif';
-/** The unit of a {@link FenceDimension} (`%` is represented as `'percent'`). */
-type FenceDimensionUnit = 'px' | 'percent';
-/** A parsed `width=`/`height=` value with its unit. */
-interface FenceDimension {
-    value: number;
-    unit: FenceDimensionUnit;
-}
-/** The fully-parsed, validated description of one FSL Markdown fence block. */
-interface FenceDescriptor {
-    parts: FencePart[];
-    ide: boolean;
-    format: FenceImageFormat;
-    width: FenceDimension | null;
-    height: FenceDimension | null;
-    interactive: boolean;
-    notes: string[];
-}
-/**
- *  Canonical fence language for an info string, or `null` if the block is not
- *  an FSL fence.  Reads only the first whitespace-delimited token,
- *  case-insensitively.
- *
- *  @param info The full fence info string (everything after the opening fence).
- *  @returns `'fsl'` or `'jssm'` for our fences; `null` otherwise.
- *
- *  @example fsl_fence_lang('fsl image code') // => 'fsl'
- *  @example fsl_fence_lang('JSSM')           // => 'jssm'
- *  @example fsl_fence_lang('mermaid')        // => null
- */
-declare function fsl_fence_lang(info: string): 'fsl' | 'jssm' | null;
-/**
- *  Parse a fence info string into a {@link FenceDescriptor}.  The first token is
- *  the (already-validated) language and is ignored; remaining tokens are
- *  classified as parts, image formats, the `ide` macro, or `width`/`height`
- *  options.  Unrecognized or conflicting tokens are dropped and recorded in
- *  `notes` rather than throwing, so a host can render forward-compatibly.
- *
- *  @param info The full fence info string, e.g. `'fsl image code width=300'`.
- *  @returns The validated descriptor; `notes` lists anything ignored or overridden.
- *
- *  @example parse_fence_info('fsl').parts // => ['image', 'code']
- *  @example parse_fence_info('fsl code image').parts // => ['code', 'image']
- */
-declare function parse_fence_info(info: string): FenceDescriptor;
-
 type StateType = string;
 
 declare const shapes: string[];
@@ -2037,7 +1968,6 @@ declare const action_label_chars: readonly {
  *  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> = {
@@ -2055,63 +1985,14 @@ type JssmEventEntry<mDT, Ev extends JssmEventName> = {
  *
  */
 declare function transfer_state_properties(state_decl: JssmStateDeclaration): JssmStateDeclaration;
-/**
- *
- *  Collapse a list of individual state-style key/value pairs into a single
- *  {@link JssmStateConfig} object, remapping FSL-style kebab-case keys to the
- *  camelCase field names the runtime uses.
- *
- *  The parser emits state styling as a flat array like
- *  `[{ key: 'color', value: 'red' }, { key: 'line-style', value: 'dashed' }]`
- *  because that is the most natural shape for the grammar to produce.  This
- *  helper runs once per style bucket during `Machine` construction to turn
- *  those arrays into the compact `{ color, lineStyle, ... }` objects the
- *  graph-rendering code expects.
- *
- *  ```typescript
- *  state_style_condense([
- *    { key: 'color',      value: 'red' },
- *    { key: 'shape',      value: 'oval' },
- *    { key: 'line-style', value: 'dashed' }
- *  ]);
- *  // => { color: 'red', shape: 'oval', lineStyle: 'dashed' }
- *
- *  state_style_condense(undefined);
- *  // => {}
- *  ```
- *
- *  @param jssk The list of style keys to condense.  `undefined` is accepted
- *  and yields an empty config.
- *
- *  @param machine Optional `Machine` reference, used only so that any
- *  {@link JssmError} thrown can point at the offending machine in its
- *  diagnostic message.
- *
- *  @returns A `JssmStateConfig` object containing every key from `jssk`
- *  remapped into its camelCase field.
- *
- *  @throws {JssmError} If `jssk` is neither an array nor `undefined`, if any
- *  element is not an object, if the same key appears more than once, or if a
- *  key is not one of the recognized style names.
- *
- *  @internal
- *
- */
 declare function state_style_condense(jssk: JssmStateStyleKeyList, machine?: any): JssmStateConfig;
 /** Default number of independent Monte-Carlo runs when none is declared. */
 declare const STOCHASTIC_DEFAULT_RUNS = 1000;
 /** Default per-run step cap (montecarlo) / walk length (steady_state). */
 declare const STOCHASTIC_DEFAULT_MAX_STEPS = 1000;
 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;
@@ -2132,7 +2013,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;
@@ -2220,8 +2101,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;
@@ -2374,9 +2255,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
      */
@@ -2634,18 +2513,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
@@ -2656,13 +2538,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`,
@@ -2676,29 +2558,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`.
@@ -2706,32 +2592,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:
@@ -2741,33 +2630,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.
@@ -2791,7 +2685,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.
@@ -2854,19 +2749,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;
@@ -2907,16 +2806,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;`;
@@ -2926,12 +2825,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;`;
@@ -2941,12 +2839,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;`;
@@ -2957,28 +2854,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.
@@ -3050,7 +2952,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
@@ -3063,37 +2966,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}
@@ -3106,7 +3011,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
@@ -3117,16 +3023,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
@@ -3137,16 +3043,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 });
@@ -3214,17 +3117,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']
@@ -3233,33 +3135,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;
@@ -3371,17 +3279,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;
@@ -3405,14 +3316,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
      */
@@ -3426,15 +3335,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
      */
@@ -3452,112 +3359,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
@@ -3576,12 +3382,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.
      *
@@ -3589,14 +3395,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.
@@ -3604,50 +3410,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
@@ -3658,7 +3473,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;
@@ -3668,13 +3482,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
@@ -3685,7 +3499,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;
@@ -3695,13 +3508,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.
@@ -3709,7 +3522,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.
@@ -3717,50 +3531,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'`.
@@ -3772,12 +3595,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'`.
@@ -3789,12 +3612,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'`.
@@ -3805,12 +3628,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'`.
@@ -3821,22 +3644,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.
@@ -3878,82 +3703,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},
@@ -4005,7 +3755,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;
@@ -4416,94 +4167,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
@@ -4678,76 +4341,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.
@@ -4801,7 +4478,7 @@ declare function sm<mDT>(template_strings: TemplateStringsArray, ...remainder: a
  *  @param ExtraConstructorFields Extra non-code configuration to pass at creation time
  *
  */
-declare function from<mDT>(MachineAsString: string, ExtraConstructorFields?: Partial<JssmGenericConfig<StateType, mDT>> | undefined): Machine<mDT>;
+declare function from<mDT>(MachineAsString: string, ExtraConstructorFields?: Partial<JssmGenericConfig<StateType, mDT>>): Machine<mDT>;
 /**
  *
  *  Type guard that narrows an unknown value to a {@link HookComplexResult}.
@@ -4819,15 +4496,11 @@ declare function from<mDT>(MachineAsString: string, ExtraConstructorFields?: Par
  *  is_hook_complex_result(null);                           // false
  *  is_hook_complex_result({ other: 'thing' });             // false
  *  ```
- *
- *  @typeParam mDT The type of the machine data member; usually omitted.
- *
+ *  @template mDT The type of the machine data member; usually omitted.
  *  @param hr The value to test.
- *
  *  @returns `true` if `hr` is a non-null object with a boolean `pass` field;
  *  `false` otherwise.  When `true`, TypeScript narrows `hr` to
  *  `HookComplexResult<mDT>`.
- *
  */
 declare function is_hook_complex_result<mDT>(hr: unknown): hr is HookComplexResult<mDT>;
 /**
@@ -4848,16 +4521,11 @@ declare function is_hook_complex_result<mDT>(hr: unknown): hr is HookComplexResu
  *  is_hook_rejection({ pass: true });  // false (pass)
  *  is_hook_rejection({ pass: false }); // true  (reject)
  *  ```
- *
- *  @typeParam mDT The type of the machine data member; usually omitted.
- *
+ *  @template mDT The type of the machine data member; usually omitted.
  *  @param hr A hook result of any legal shape.
- *
  *  @returns `true` if the hook rejected the transition; `false` if it passed.
- *
  *  @throws {TypeError} If `hr` is not a recognized hook result shape (for
  *  example, a number or a plain object without a `pass` field).
- *
  */
 declare function is_hook_rejection<mDT>(hr: HookResult<mDT>): boolean;
 /**
@@ -4878,24 +4546,17 @@ declare function is_hook_rejection<mDT>(hr: HookResult<mDT>): boolean;
  *  - a complex result object → returned as-is
  *
  *  Anything else is a programmer error and throws.
- *
- *  @typeParam mDT The type of the machine data member; usually omitted.
- *
+ *  @template mDT The type of the machine data member; usually omitted.
  *  @param maybe_hook The hook handler to call, or `undefined` for the
  *  "no hook installed" case.
- *
  *  @param hook_args The context object passed to the hook.  Includes the
  *  current and proposed state, current and proposed data, action name, and
  *  transition kind.
- *
  *  @returns A {@link HookComplexResult} describing whether the hook passed
  *  and, optionally, any data replacements it requested.
- *
  *  @throws {TypeError} If the hook returns a value that is not one of the
  *  legal shapes listed above.
- *
  *  @internal
- *
  */
 declare function abstract_hook_step<mDT>(maybe_hook: HookHandler<mDT> | undefined, hook_args: HookContext<mDT>): HookComplexResult<mDT>;
 /**
@@ -4915,22 +4576,15 @@ declare function abstract_hook_step<mDT>(maybe_hook: HookHandler<mDT> | undefine
  *  - `undefined` or `true` → `{ pass: true }`
  *  - `false` or `null`     → `{ pass: false }`
  *  - a complex result      → returned as-is
- *
- *  @typeParam mDT The type of the machine data member; usually omitted.
- *
+ *  @template mDT The type of the machine data member; usually omitted.
  *  @param maybe_hook The everything-hook handler, or `undefined` when none
  *  is installed.
- *
  *  @param hook_args The everything-hook context object.  Differs from a
  *  normal hook context in that it also includes `hook_name`.
- *
  *  @returns A {@link HookComplexResult} describing whether the hook passed
  *  and any data replacements it requested.
- *
  *  @throws {TypeError} If the hook returns a value outside the legal shapes.
- *
  *  @internal
- *
  */
 declare function abstract_everything_hook_step<mDT>(maybe_hook: EverythingHookHandler<mDT> | undefined, hook_args: EverythingHookContext<mDT>): HookComplexResult<mDT>;
 /**
@@ -4943,32 +4597,24 @@ declare function abstract_everything_hook_step<mDT>(maybe_hook: EverythingHookHa
  * numeric identifiers numerically and below alphanumeric ones, alphanumeric
  * identifiers in ASCII order, and a shorter identifier set precedes a longer
  * one that it prefixes.
- *
  * @param {string} v1 - First version string (e.g., "5.104.2" or "6.0.0-alpha.1")
  * @param {string} v2 - Second version string (e.g., "5.103.1")
- *
  * @returns {number} - Negative if v1 < v2, 0 if equal, positive if v1 > v2
- *
  * @example
  * import { compareVersions } from 'jssm';
  * compareVersions("5.104.2", "5.103.1");  // => 1
- *
  * @example
  * import { compareVersions } from 'jssm';
  * compareVersions("5.104.2", "6.0.0");  // => -1
- *
  * @example
  * import { compareVersions } from 'jssm';
  * compareVersions("5.104.2", "5.104.2");  // => 0
- *
  * @example
  * import { compareVersions } from 'jssm';
  * compareVersions("6.0.0-alpha.1", "6.0.0");  // => -1
- *
  * @example
  * import { compareVersions } from 'jssm';
  * compareVersions("6.0.0-alpha.1", "6.0.0-alpha.2");  // => -1
- *
  * @example
  * import { compareVersions } from 'jssm';
  * compareVersions("6.0.0-beta.1", "6.0.0-alpha.1");  // => 1
@@ -4980,16 +4626,11 @@ declare function compareVersions(v1: string, v2: string): number;
  * 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.
- *
- * @typeParam mDT - The type of the machine data member
- *
+ * @template mDT - The type of the machine data member
  * @param {string} machine_string - The FSL string defining the machine structure
  * @param {JssmSerialization<mDT>} ser - The serialization object to restore from
- *
  * @returns {Machine<mDT>} - The restored machine instance
- *
  * @throws {Error} If the serialization is from a future version
- *
  * @example
  * import { from, deserialize } from 'jssm';
  * const machine    = from("a -> b;");