machina 6.2.0 → 7.0.0

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/emitter.ts","../src/types.ts","../src/fsm.ts","../src/behavioral-fsm.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/emitter.ts","../src/behavioral-fsm.ts","../src/types.ts","../src/fsm.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -49,6 +49,121 @@ var Emitter = class {
 	}
 };
 
+//#endregion
+//#region src/json-safe.ts
+/**
+* Thrown internally when the walk hits a value that can't survive a
+* serialization boundary. Callers catch this to attach FSM/input context
+* before re-throwing a fully descriptive error — see `path`/`label` below.
+*/
+var NonSerializableValueError = class extends Error {
+	constructor(path, label) {
+		super(`non-serializable value at ${path} (${label})`);
+		this.path = path;
+		this.label = label;
+	}
+};
+/**
+* Deep-clones `value`, throwing `NonSerializableValueError` the moment it
+* finds anything that isn't `null`, a boolean, a finite number, a string, a
+* plain array, or a plain object. `rootPath` seeds the path used in error
+* messages — e.g. `"args"` so a nested failure reads as `args[1].onComplete`.
+*
+* Cloning (rather than just validating) is what keeps a returned snapshot
+* from aliasing live FSM state: mutating the snapshot afterward — or the
+* original value passed into a deferred `handle()` call — can't reach back
+* into the FSM's internal deferred queue.
+*/
+const cloneJsonSafe = (value, rootPath) => {
+	return cloneNode(value, rootPath, /* @__PURE__ */ new Set());
+};
+const cloneNode = (value, path, ancestors) => {
+	if (value === null) return null;
+	switch (typeof value) {
+		case "string":
+		case "boolean": return value;
+		case "number":
+			if (!Number.isFinite(value)) throw new NonSerializableValueError(path, describeNonFiniteNumber(value));
+			return value;
+		case "object": return cloneObject(value, path, ancestors);
+		default: throw new NonSerializableValueError(path, typeof value);
+	}
+};
+const cloneObject = (obj, path, ancestors) => {
+	if (ancestors.has(obj)) throw new NonSerializableValueError(path, "circular reference");
+	if (Array.isArray(obj)) {
+		if (obj.length !== Object.keys(obj).length) throw new NonSerializableValueError(path, "sparse array or array with non-index properties");
+		ancestors.add(obj);
+		const cloned = obj.map((item, i) => cloneNode(item, `${path}[${i}]`, ancestors));
+		ancestors.delete(obj);
+		return cloned;
+	}
+	const proto = Object.getPrototypeOf(obj);
+	if (proto !== Object.prototype && proto !== null) throw new NonSerializableValueError(path, obj.constructor?.name ?? "object");
+	ancestors.add(obj);
+	const cloned = {};
+	for (const key of Object.keys(obj)) {
+		const value = cloneNode(obj[key], `${path}.${key}`, ancestors);
+		Object.defineProperty(cloned, key, {
+			value,
+			enumerable: true,
+			writable: true,
+			configurable: true
+		});
+	}
+	ancestors.delete(obj);
+	return cloned;
+};
+const describeNonFiniteNumber = (n) => {
+	if (Number.isNaN(n)) return "NaN";
+	return n > 0 ? "Infinity" : "-Infinity";
+};
+/**
+* Deep-clones `value` WITHOUT validating it — unlike `cloneJsonSafe`, this
+* never throws. Plain objects/arrays are cloned recursively (so a caller
+* can't alias state back into whatever holds the result); anything else
+* (functions, `Date`/`Map`/class instances, symbols, non-finite numbers,
+* etc.) is passed through by reference as-is.
+*
+* This is `rehydrate()`'s side of the aliasing guarantee: `dehydrate()`
+* validates-and-clones on the way OUT (via `cloneJsonSafe`), but `rehydrate()`
+* trusts the snapshot it's given is already valid data — re-validating on
+* the way IN would be a redundant, unwanted asymmetry (see the build plan's
+* disclosed known gaps). We still need the clone so mutating the caller's
+* snapshot object after `rehydrate()` returns can't reach into the live
+* FSM's internal deferred queue.
+*
+* Cycle-safe: a value that contains itself is returned as-is (by reference)
+* rather than cloned infinitely — there's no validation step here to make
+* that throw, so silently keeping the shared reference is the only option
+* that doesn't hang.
+*/
+const cloneDeep = (value, ancestors = /* @__PURE__ */ new Set()) => {
+	if (value === null || typeof value !== "object") return value;
+	if (ancestors.has(value)) return value;
+	if (Array.isArray(value)) {
+		ancestors.add(value);
+		const cloned = value.map((item) => cloneDeep(item, ancestors));
+		ancestors.delete(value);
+		return cloned;
+	}
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null) return value;
+	ancestors.add(value);
+	const cloned = {};
+	for (const key of Object.keys(value)) {
+		const clonedValue = cloneDeep(value[key], ancestors);
+		Object.defineProperty(cloned, key, {
+			value: clonedValue,
+			enumerable: true,
+			writable: true,
+			configurable: true
+		});
+	}
+	ancestors.delete(value);
+	return cloned;
+};
+
 //#endregion
 //#region src/types.ts
 /**
@@ -76,6 +191,9 @@ const MAX_TRANSITION_DEPTH = 20;
 *   so it can serve as a WeakMap key.
 * @typeParam TStateNames - String literal union of valid state names.
 * @typeParam TInputNames - String literal union of valid input names.
+* @typeParam TBubbles - String literal union of inputs this FSM declares via
+*   `bubbles`. Type-only — carried so `BubblesOfInstance` can extract it from
+*   a constructed instance; nothing at runtime reads this generic.
 */
 var BehavioralFsm = class {
 	id;
@@ -124,15 +242,20 @@ var BehavioralFsm = class {
 	}
 	/**
 	* Returns true if the client's current state has a handler for `inputName`
-	* (or a catch-all `"*"` handler). Does NOT initialize the client — no
-	* `_onEnter`, no events, no side effects. Unseen clients are treated as
-	* if they were already in `initialState`. Returns false when disposed.
+	* (or a catch-all `"*"` handler), or if the current state's `_child` chain
+	* can handle it — the check recurses to the same depth `handle()`'s
+	* delegation can actually reach, so a grandchild-only input answers true
+	* from the root. Does NOT initialize the client — no `_onEnter`, no
+	* events, no side effects. Unseen clients are treated as if they were
+	* already in `initialState`. Returns false when disposed.
 	*/
 	canHandle(client, inputName) {
 		if (this.disposed) return false;
 		const state = this.clients.get(client)?.state ?? this.initialState;
 		const stateObj = this.states[state];
-		return !!(stateObj?.[inputName] ?? stateObj?.["*"]);
+		if (stateObj?.[inputName] ?? stateObj?.["*"]) return true;
+		const childLink = stateObj?._child;
+		return childLink ? childLink.canHandle(client, inputName) : false;
 	}
 	/**
 	* Transition the client back to `initialState`, firing `_onEnter` and
@@ -167,7 +290,7 @@ var BehavioralFsm = class {
 		const meta = this.getOrCreateClientMeta(client);
 		const fromState = meta.state;
 		if (toState === fromState) return;
-		if (!(toState in this.states)) {
+		if (!Object.hasOwn(this.states, toState)) {
 			this.emitter.emit("invalidstate", {
 				stateName: toState,
 				client
@@ -223,6 +346,182 @@ var BehavioralFsm = class {
 		}
 		return meta.state;
 	}
+	rehydrate(client, input) {
+		if (this.disposed) return;
+		if (typeof input === "string") {
+			this.rehydrateCompositePath(client, input);
+			return;
+		}
+		const writes = this.planSnapshotWrites(client, input);
+		for (const write of writes) write();
+	}
+	/**
+	* Snapshot everything machina tracks for `client`: current state, pending
+	* deferred inputs, and — recursively — the same for every `_child` that has
+	* ever seen this client, active or not. Feed the result to the object form
+	* of `rehydrate()` to restore it later, deferrals included.
+	*
+	* Returns `undefined` for a client this FSM has never seen (mirrors
+	* `currentState()`) — the call does NOT trigger initialization.
+	*
+	* Throws if any deferred input's args contain a non-serializable value
+	* (function, undefined, symbol, bigint, non-finite number, Date/Map/class
+	* instance, or a circular reference) — naming the input, its `until` target
+	* if any, the FSM id, and the exact value path. Throws for an Fsm child
+	* that's on `client`'s active path *relative to the true root* (consistent
+	* with `rehydrate()`'s conditional throw) — an Fsm owns its own context, so
+	* there's nothing per-client to snapshot. An Fsm child declared at a state
+	* `client` never visited, OR nested under a `BehavioralFsm` child that is
+	* itself off-path from the root, is skipped rather than throwing — neither
+	* has any per-client state to lose, so one Fsm child anywhere in the
+	* hierarchy doesn't disable `dehydrate()` for clients that never reach that
+	* branch, no matter how deeply nested the Fsm child is.
+	*
+	* Meant for clients at rest between `handle()` calls — `currentActionArgs`
+	* (the in-flight args mid-handler) has no meaning here and is excluded.
+	*
+	* @param isOnActivePath - @internal Whether this FSM itself is currently
+	* reachable from the true root's active path. Defaults to `true` for the
+	* public entry point (this FSM IS the root from its own perspective); the
+	* `ChildLink` adapter passes `false` down when recursing into a nested
+	* `BehavioralFsm` child that is itself off-path, so that child's own
+	* Fsm-child checks don't recompute reachability from its dormant local
+	* state alone.
+	*/
+	dehydrate(client, isOnActivePath = true) {
+		const meta = this.clients.get(client);
+		if (!meta) return;
+		const snapshot = {
+			state: meta.state,
+			deferred: meta.deferredQueue.map((item) => this.snapshotDeferredInput(item))
+		};
+		const children = this.collectChildSnapshots(client, meta.state, isOnActivePath);
+		if (children) snapshot.children = children;
+		return snapshot;
+	}
+	/**
+	* @internal
+	* Validates `snapshot` against this level's state graph and recurses into
+	* every declared child, returning write thunks to run only once the WHOLE
+	* tree — every level — validates successfully. Nothing is written here.
+	* Called by the object-form of `rehydrate()` and, recursively, by ChildLink
+	* so a nested BehavioralFsm participates in the same validate-then-write
+	* pass. Not part of the public persistence API — call `rehydrate()` instead.
+	*/
+	planSnapshotWrites(client, snapshot) {
+		if (this.disposed) return [];
+		const { state, deferred, children } = snapshot;
+		if (!Object.hasOwn(this.states, state)) throw new Error(`rehydrate: unknown state "${state}" in FSM "${this.id}". Valid states: ${Object.keys(this.states).join(", ")}`);
+		const writes = [];
+		if (children) for (const stateName of Object.keys(children)) {
+			if (!Object.hasOwn(this.states, stateName)) throw new Error(`rehydrate: unknown state "${stateName}" in FSM "${this.id}" referenced by snapshot.children.`);
+			const childLink = this.states[stateName]?._child;
+			if (!childLink) throw new Error(`rehydrate: state "${stateName}" in FSM "${this.id}" has no _child, but the snapshot has a children["${stateName}"] entry.`);
+			writes.push(...childLink.planRehydrate(client, children[stateName]));
+		}
+		const deferredQueue = deferred.map((item) => ({
+			inputName: item.inputName,
+			args: cloneDeep(item.args),
+			...item.untilState !== void 0 ? { untilState: item.untilState } : {}
+		}));
+		writes.push(() => {
+			if (!this.clients.has(client)) this.knownClients.add(new WeakRef(client));
+			this.clients.set(client, {
+				state,
+				deferredQueue
+			});
+		});
+		return writes;
+	}
+	rehydrateCompositePath(client, compositeState) {
+		const [state, ...rest] = compositeState.split(".");
+		if (!Object.hasOwn(this.states, state)) throw new Error(`rehydrate: unknown state "${state}" in FSM "${this.id}". Valid states: ${Object.keys(this.states).join(", ")}`);
+		if (rest.length > 0) {
+			const childPath = rest.join(".");
+			const childLink = this.states[state]?._child;
+			if (!childLink) throw new Error(`rehydrate: state "${state}" in FSM "${this.id}" has no _child, but composite path "${compositeState}" requires one.`);
+			childLink.rehydrate(client, childPath);
+		}
+		if (!this.clients.has(client)) this.knownClients.add(new WeakRef(client));
+		this.clients.set(client, {
+			state,
+			deferredQueue: []
+		});
+	}
+	/**
+	* Walks every declared state's `_child`, dehydrating each one that has ever
+	* seen `client`. The same child instance can be declared under multiple
+	* state names (shared child) — it's dehydrated once and the result is
+	* reused under every declaring state name, matching how the engine already
+	* treats shared children elsewhere (dispose, event subscriptions).
+	*
+	* Declaring names are grouped by `childLink.instance` (the actual FSM
+	* instance, not the `ChildLink` wrapper — `wrapChildLinks()` mints a fresh
+	* wrapper per declaring state, so grouping by wrapper would never hit for a
+	* shared child) BEFORE any `onPath` is computed or any child is dehydrated.
+	* A shared child's `onPath` is the OR of `stateName === activeState` across
+	* every declaring name in its group: at most one declaring name can ever
+	* equal `activeState`, so this combined flag is correct and, critically,
+	* independent of `Object.keys(this.states)` iteration order — computing
+	* `onPath` per-declaring-name and caching whichever one happened to run
+	* first would silently launder an on-path client's Fsm-child throw through
+	* an unrelated off-path declaring name.
+	*
+	* An off-path Fsm child (declared only at states other than `activeState`,
+	* OR nested anywhere under a `BehavioralFsm` child that is itself off-path
+	* relative to the true root) is skipped entirely rather than dehydrated:
+	* Fsm state isn't tracked per-client to begin with, so an off-path Fsm
+	* child has nothing to lose by being skipped — unlike a BehavioralFsm
+	* child's off-path meta, which is real per-client data. `isOnActivePath`
+	* is the inherited "am I even reachable from the root" flag; combining it
+	* with the group's `stateNames.includes(activeState)` check (rather than
+	* using that check alone) is what keeps a nested Fsm grandchild from
+	* throwing when its immediate BehavioralFsm parent is itself off-path —
+	* the parent's own dormant `activeState` is irrelevant once the parent
+	* isn't reachable. This keeps one Fsm child anywhere in the hierarchy from
+	* disabling `dehydrate()` for every client, only for clients actually on
+	* that branch.
+	*/
+	collectChildSnapshots(client, activeState, isOnActivePath) {
+		const declaringNamesByInstance = /* @__PURE__ */ new Map();
+		for (const stateName of Object.keys(this.states)) {
+			const childLink = this.states[stateName]?._child;
+			if (!childLink) continue;
+			const entry = declaringNamesByInstance.get(childLink.instance);
+			if (entry) entry.stateNames.push(stateName);
+			else declaringNamesByInstance.set(childLink.instance, {
+				childLink,
+				stateNames: [stateName]
+			});
+		}
+		let children;
+		for (const { childLink, stateNames } of declaringNamesByInstance.values()) {
+			const onPath = isOnActivePath && stateNames.includes(activeState);
+			if (childLink.instance[MACHINA_TYPE] === "Fsm" && !onPath) continue;
+			const childSnapshot = childLink.dehydrate(client, onPath);
+			if (childSnapshot) {
+				children ??= {};
+				for (const stateName of stateNames) children[stateName] = childSnapshot;
+			}
+		}
+		return children;
+	}
+	snapshotDeferredInput(item) {
+		let clonedArgs;
+		try {
+			clonedArgs = cloneJsonSafe(item.args, "args");
+		} catch (err) {
+			if (!(err instanceof NonSerializableValueError)) throw err;
+			const untilPart = item.untilState ? ` (until "${item.untilState}")` : "";
+			throw new Error(`dehydrate: deferred input "${item.inputName}"${untilPart} in FSM "${this.id}" has a non-serializable value at ${err.path} (${err.label})`);
+		}
+		const snapshot = {
+			inputName: item.inputName,
+			args: clonedArgs
+		};
+		if (item.untilState !== void 0) snapshot.untilState = item.untilState;
+		return snapshot;
+	}
 	on(eventName, callback) {
 		if (this.disposed) return { off() {} };
 		return this.emitter.on(eventName, callback);
@@ -249,8 +548,8 @@ var BehavioralFsm = class {
 			const seen = /* @__PURE__ */ new Set();
 			for (const stateName of Object.keys(this.states)) {
 				const childLink = this.states[stateName]?._child;
-				if (childLink && !seen.has(childLink)) {
-					seen.add(childLink);
+				if (childLink && !seen.has(childLink.instance)) {
+					seen.add(childLink.instance);
 					childLink.dispose();
 				}
 			}
@@ -276,15 +575,23 @@ var BehavioralFsm = class {
 	/**
 	* Walks all states at construction time, finds states with _child, and
 	* subscribes once to each unique child's wildcard events. Subscriptions are
-	* stored for cleanup in dispose(). We deduplicate by child reference to
-	* avoid double-subscribing when the same child appears in multiple states.
+	* stored for cleanup in dispose(). We deduplicate by `childLink.instance`
+	* (the underlying Fsm/BehavioralFsm instance), not the `ChildLink` wrapper —
+	* `wrapChildLinks()` mints a fresh wrapper per declaring state, so a child
+	* shared across states would otherwise get one subscription PER declaring
+	* state, each independently walking known clients and relaying events. That
+	* silently double-fires client-less relays (Fsm-child events, or a
+	* BehavioralFsm child's custom `emit()` with no `client` in the payload)
+	* whenever two different clients are active on two different declaring
+	* names at once — the same wrapper-vs-instance identity bug
+	* `collectChildSnapshots()` had before its #184 fix.
 	*/
 	setupChildSubscriptions() {
-		const seenChildren = /* @__PURE__ */ new Set();
+		const seenInstances = /* @__PURE__ */ new Set();
 		for (const stateName of Object.keys(this.states)) {
 			const childLink = this.states[stateName]?._child;
-			if (!childLink || seenChildren.has(childLink)) continue;
-			seenChildren.add(childLink);
+			if (!childLink || seenInstances.has(childLink.instance)) continue;
+			seenInstances.add(childLink.instance);
 			const sub = childLink.onAny((eventName, data) => {
 				if (eventName === "nohandler") {
 					const payload = data;
@@ -330,13 +637,22 @@ var BehavioralFsm = class {
 	}
 	/**
 	* Returns true if the given client is currently in a parent state whose
-	* _child is the specified childLink. Returns false if the client has no
-	* meta (never initialized) or is in a state with a different (or no) child.
+	* _child resolves to the same underlying instance as childLink. Returns
+	* false if the client has no meta (never initialized) or is in a state
+	* with a different (or no) child.
+	*
+	* Compares `.instance`, not the `ChildLink` wrapper itself — setupChildSubscriptions()
+	* dedupes subscriptions by instance and keeps only ONE representative wrapper
+	* per shared child, so the client's actual active declaring state may hold a
+	* DIFFERENT wrapper for that same instance (wrapChildLinks() mints one per
+	* declaring state). Comparing wrappers directly would only ever match the one
+	* declaring state whose wrapper happened to be kept for the subscription,
+	* silently breaking relay for every other declaring name of a shared child.
 	*/
 	isChildActiveForClient(client, childLink) {
 		const meta = this.clients.get(client);
 		if (!meta) return false;
-		return this.states[meta.state]?._child === childLink;
+		return (this.states[meta.state]?._child)?.instance === childLink.instance;
 	}
 	/**
 	* The inner handler dispatch — no delegation, no initialization side effects
@@ -444,6 +760,15 @@ function createChildLink(child) {
 		compositeState(client) {
 			return child.compositeState(client);
 		},
+		rehydrate(client, compositeState) {
+			child.rehydrate(client, compositeState);
+		},
+		dehydrate(client, isOnActivePath) {
+			return child.dehydrate(client, isOnActivePath);
+		},
+		planRehydrate(client, snapshot) {
+			return child.planSnapshotWrites(client, snapshot);
+		},
 		dispose() {
 			child.dispose();
 		}
@@ -465,43 +790,23 @@ function createChildLink(child) {
 		compositeState(_client) {
 			return child.compositeState();
 		},
+		rehydrate(_client, _compositeState) {
+			throw new Error("rehydrate: cannot rehydrate an Fsm child. Fsm owns its own context; rehydrate is only valid for BehavioralFsm hierarchies.");
+		},
+		dehydrate(_client, _isOnActivePath) {
+			throw new Error("dehydrate: cannot dehydrate an Fsm child. Fsm owns its own context; dehydrate is only valid for BehavioralFsm hierarchies.");
+		},
+		planRehydrate(_client, _snapshot) {
+			throw new Error("rehydrate: cannot rehydrate an Fsm child. Fsm owns its own context; rehydrate is only valid for BehavioralFsm hierarchies.");
+		},
 		dispose() {
 			child.dispose();
 		}
 	};
 	throw new Error(`createChildLink: expected an Fsm or BehavioralFsm instance, got [MACHINA_TYPE] = ${String(childType ?? "undefined")}`);
 }
-/**
-* Create a behavioral FSM (one definition, many clients) from a config object.
-*
-* Generic parameters are inferred automatically:
-* - `TClient` must be provided explicitly as a type parameter (it can't be
-*   inferred from the config since no `context` property exists at the FSM level).
-* - `TStates` is captured with `const` inference to preserve string literal
-*   types, enabling compile-time validation of transition targets and `handle()`
-*   input names.
-*
-* State names, input names, and all handler signatures derive from `TStates`.
-*
-* @example
-* ```ts
-* interface Connection { url: string; retries: number; }
-*
-* const connFsm = createBehavioralFsm<Connection>({
-*   id: "connectivity",
-*   initialState: "disconnected",
-*   states: {
-*     disconnected: { connect: "connecting" },
-*     connecting:   { connected: "online", failed: "disconnected" },
-*     online:       { disconnect: "disconnected" },
-*   },
-* });
-*
-* const conn = { url: "wss://example.com", retries: 0 };
-* connFsm.handle(conn, "connect");
-* ```
-*/
 function createBehavioralFsm(config) {
+	if (config === void 0) return (curriedConfig) => new BehavioralFsm(curriedConfig);
 	return new BehavioralFsm(config);
 }
 
@@ -519,6 +824,9 @@ function createBehavioralFsm(config) {
 * @typeParam TCtx - The context type, inferred from `config.context`.
 * @typeParam TStateNames - String literal union of valid state names.
 * @typeParam TInputNames - String literal union of valid input names.
+* @typeParam TBubbles - String literal union of inputs this FSM declares via
+*   `bubbles`. Type-only — carried so `BubblesOfInstance` can extract it from
+*   a constructed instance; nothing at runtime reads this generic.
 */
 var Fsm = class {
 	id;
@@ -555,8 +863,10 @@ var Fsm = class {
 	}
 	/**
 	* Returns true if the current state has a handler for `inputName`
-	* (or a catch-all `"*"` handler). Does not trigger initialization
-	* or any side effects. Returns false when disposed.
+	* (or a catch-all `"*"` handler), or if the current state's `_child`
+	* chain can handle it (checked recursively, matching `handle()`'s
+	* delegation reach). Does not trigger initialization or any side
+	* effects. Returns false when disposed.
 	*/
 	canHandle(inputName) {
 		if (this.disposed) return false;