@modular-react/journeys 1.0.1 → 1.0.2

package/dist/runtime-DPPLlqbu.js

@@ -0,0 +1,1564 @@
+import { isDevEnv as e, isExitContract as t } from "@modular-react/core";
+//#region src/semver.ts
+var n = /* @__PURE__ */ function(e) {
+	return e[e.GT = 0] = "GT", e[e.GTE = 1] = "GTE", e[e.LT = 2] = "LT", e[e.LTE = 3] = "LTE", e[e.EQ = 4] = "EQ", e;
+}(n || {}), r = class extends Error {
+	constructor(e) {
+		super(`[@modular-react/journeys] ${e}`), this.name = "SemverParseError";
+	}
+};
+function i(e) {
+	let t = x(S(e.trim()));
+	if (!t) throw new r(`invalid version "${e}"`);
+	return t;
+}
+function a(e) {
+	let t = e.trim();
+	if (t === "" || t === "*" || t === "x" || t === "X") return { sets: [[]] };
+	let n = t.split("||"), r = [];
+	for (let e of n) {
+		let t = d(e);
+		r.push(t);
+	}
+	return { sets: r };
+}
+function o(e, t) {
+	for (let n of t.sets) {
+		let t = !0;
+		for (let r of n) if (!u(e, r)) {
+			t = !1;
+			break;
+		}
+		if (t) return !0;
+	}
+	return !1;
+}
+function s(e, t) {
+	return o(i(e), a(t));
+}
+function c(e, t) {
+	return e[0] === t[0] ? e[1] === t[1] ? e[2] === t[2] ? 0 : e[2] < t[2] ? -1 : 1 : e[1] < t[1] ? -1 : 1 : e[0] < t[0] ? -1 : 1;
+}
+function l(e, t) {
+	return c(i(e), i(t));
+}
+function u(e, t) {
+	let r = c(e, t.v);
+	switch (t.op) {
+		case n.GT: return r > 0;
+		case n.GTE: return r >= 0;
+		case n.LT: return r < 0;
+		case n.LTE: return r <= 0;
+		case n.EQ: return r === 0;
+	}
+}
+function d(e) {
+	let t = [], n = f(e);
+	if (n) return p(n[0], n[1], t), t;
+	let r = e.split(/\s+/).filter((e) => e.length > 0);
+	if (r.length === 0) return t;
+	for (let e of r) m(e, t);
+	return t;
+}
+function f(e) {
+	let t = e.match(/^\s*(\S+)\s+-\s+(\S+)\s*$/);
+	return t ? [t[1], t[2]] : null;
+}
+function p(e, t, i) {
+	let a = v(S(e));
+	if (!a) throw new r(`invalid lower bound in hyphen range "${e}"`);
+	i.push({
+		op: n.GTE,
+		v: y(a, 0)
+	});
+	let o = v(S(t));
+	if (!o || o.major === null) throw new r(`invalid upper bound in hyphen range "${t}"`);
+	o.minor === null ? i.push({
+		op: n.LT,
+		v: [
+			o.major + 1,
+			0,
+			0
+		]
+	}) : o.patch === null ? i.push({
+		op: n.LT,
+		v: [
+			o.major,
+			o.minor + 1,
+			0
+		]
+	}) : i.push({
+		op: n.LTE,
+		v: [
+			o.major,
+			o.minor,
+			o.patch
+		]
+	});
+}
+function m(e, t) {
+	if (!(e === "*" || e === "x" || e === "X")) {
+		if (e.startsWith("^")) {
+			h(e.slice(1), t);
+			return;
+		}
+		if (e.startsWith("~")) {
+			g(e.slice(1), t);
+			return;
+		}
+		if (e.startsWith(">=")) {
+			t.push({
+				op: n.GTE,
+				v: b(e.slice(2), e)
+			});
+			return;
+		}
+		if (e.startsWith("<=")) {
+			t.push({
+				op: n.LTE,
+				v: b(e.slice(2), e)
+			});
+			return;
+		}
+		if (e.startsWith(">")) {
+			t.push({
+				op: n.GT,
+				v: b(e.slice(1), e)
+			});
+			return;
+		}
+		if (e.startsWith("<")) {
+			t.push({
+				op: n.LT,
+				v: b(e.slice(1), e)
+			});
+			return;
+		}
+		if (e.startsWith("=")) {
+			_(e.slice(1), e, t);
+			return;
+		}
+		_(e, e, t);
+	}
+}
+function h(e, t) {
+	let i = v(S(e));
+	if (!i) throw new r(`invalid caret range "^${e}"`);
+	let { major: a, minor: o, patch: s } = i;
+	if (a === null) throw new r(`invalid caret range "^${e}"`);
+	if (a > 0) {
+		t.push({
+			op: n.GTE,
+			v: [
+				a,
+				o ?? 0,
+				s ?? 0
+			]
+		}), t.push({
+			op: n.LT,
+			v: [
+				a + 1,
+				0,
+				0
+			]
+		});
+		return;
+	}
+	if (o === null) {
+		t.push({
+			op: n.GTE,
+			v: [
+				0,
+				0,
+				0
+			]
+		}), t.push({
+			op: n.LT,
+			v: [
+				1,
+				0,
+				0
+			]
+		});
+		return;
+	}
+	if (o > 0) {
+		t.push({
+			op: n.GTE,
+			v: [
+				0,
+				o,
+				s ?? 0
+			]
+		}), t.push({
+			op: n.LT,
+			v: [
+				0,
+				o + 1,
+				0
+			]
+		});
+		return;
+	}
+	if (s === null) {
+		t.push({
+			op: n.GTE,
+			v: [
+				0,
+				0,
+				0
+			]
+		}), t.push({
+			op: n.LT,
+			v: [
+				0,
+				1,
+				0
+			]
+		});
+		return;
+	}
+	t.push({
+		op: n.GTE,
+		v: [
+			0,
+			0,
+			s
+		]
+	}), t.push({
+		op: n.LT,
+		v: [
+			0,
+			0,
+			s + 1
+		]
+	});
+}
+function g(e, t) {
+	let i = v(S(e));
+	if (!i) throw new r(`invalid tilde range "~${e}"`);
+	let { major: a, minor: o, patch: s } = i;
+	if (a === null) throw new r(`invalid tilde range "~${e}"`);
+	if (o === null) {
+		t.push({
+			op: n.GTE,
+			v: [
+				a,
+				0,
+				0
+			]
+		}), t.push({
+			op: n.LT,
+			v: [
+				a + 1,
+				0,
+				0
+			]
+		});
+		return;
+	}
+	t.push({
+		op: n.GTE,
+		v: [
+			a,
+			o,
+			s ?? 0
+		]
+	}), t.push({
+		op: n.LT,
+		v: [
+			a,
+			o + 1,
+			0
+		]
+	});
+}
+function _(e, t, i) {
+	let a = v(S(e));
+	if (!a) throw new r(`invalid version or range "${t}"`);
+	let { major: o, minor: s, patch: c } = a;
+	if (o !== null) {
+		if (s === null) {
+			i.push({
+				op: n.GTE,
+				v: [
+					o,
+					0,
+					0
+				]
+			}), i.push({
+				op: n.LT,
+				v: [
+					o + 1,
+					0,
+					0
+				]
+			});
+			return;
+		}
+		if (c === null) {
+			i.push({
+				op: n.GTE,
+				v: [
+					o,
+					s,
+					0
+				]
+			}), i.push({
+				op: n.LT,
+				v: [
+					o,
+					s + 1,
+					0
+				]
+			});
+			return;
+		}
+		i.push({
+			op: n.EQ,
+			v: [
+				o,
+				s,
+				c
+			]
+		});
+	}
+}
+function v(e) {
+	if (e === "" || e === "*" || e === "x" || e === "X") return {
+		major: null,
+		minor: null,
+		patch: null
+	};
+	let t = e.split(".");
+	if (t.length > 3) return null;
+	let n = [];
+	for (let e of t) {
+		if (e === "" || e === "x" || e === "X" || e === "*") {
+			n.push(null);
+			continue;
+		}
+		if (!/^\d+$/.test(e)) return null;
+		let t = Number(e);
+		if (!Number.isFinite(t)) return null;
+		n.push(t);
+	}
+	for (; n.length < 3;) n.push(null);
+	let r = !1;
+	for (let e of n) if (e === null) r = !0;
+	else if (r) return null;
+	return {
+		major: n[0],
+		minor: n[1],
+		patch: n[2]
+	};
+}
+function y(e, t) {
+	return [
+		e.major ?? t,
+		e.minor ?? t,
+		e.patch ?? t
+	];
+}
+function b(e, t) {
+	let n = x(S(e));
+	if (!n) throw new r(`invalid version in "${t}"`);
+	return n;
+}
+function x(e) {
+	let t = /^(\d+)\.(\d+)\.(\d+)$/.exec(e);
+	if (!t) return null;
+	let n = [
+		Number(t[1]),
+		Number(t[2]),
+		Number(t[3])
+	];
+	return n.every((e) => Number.isFinite(e)) ? n : null;
+}
+function S(e) {
+	if (e.length === 0) return e;
+	let t = e.charCodeAt(0);
+	return t === 118 || t === 86 || t === 61 ? e.slice(1) : e;
+}
+//#endregion
+//#region src/validation.ts
+var C = class extends Error {
+	issues;
+	constructor(e) {
+		super(`[@modular-react/journeys] Invalid journey registration:\n  - ${e.join("\n  - ")}`), this.name = "JourneyValidationError", this.issues = e;
+	}
+}, w = class extends Error {
+	constructor(e, t) {
+		super(`[@modular-react/journeys] ${e}`, t), this.name = "JourneyHydrationError";
+	}
+}, T = class extends Error {
+	journeyId;
+	constructor(e, t) {
+		super(`[@modular-react/journeys] Unknown journey id "${e}". Registered: ${t.join(", ") || "(none)"}`), this.name = "UnknownJourneyError", this.journeyId = e;
+	}
+};
+function E(e, t) {
+	let n = [], s = /* @__PURE__ */ new Map();
+	for (let e of t) s.set(e.id, e);
+	for (let t of O(e)) n.push(t);
+	for (let e of t) e.exitPoints && Object.prototype.hasOwnProperty.call(e.exitPoints, "allowBack") && n.push(`module "${e.id}" declares an exit named "allowBack", which collides with the reserved per-entry transition control key. Rename the exit (e.g. "allowBackExit").`);
+	let c = /* @__PURE__ */ new Set();
+	for (let l of e) {
+		let e = l.definition;
+		c.has(e.id) && n.push(`journey "${e.id}" is registered more than once`), c.add(e.id);
+		let u = e.transitions ?? {};
+		for (let [t, r] of Object.entries(u)) {
+			let i = s.get(t);
+			if (!i) {
+				n.push(`journey "${e.id}" references unknown module id "${t}" in transitions`);
+				continue;
+			}
+			if (!r || typeof r != "object") {
+				n.push(`journey "${e.id}" has malformed transitions for module "${t}" (expected an object)`);
+				continue;
+			}
+			for (let [a, o] of Object.entries(r)) {
+				let r = i.entryPoints?.[a];
+				if (!r) {
+					n.push(`journey "${e.id}" references unknown entry "${t}.${a}"`);
+					continue;
+				}
+				if (!o || typeof o != "object") {
+					n.push(`journey "${e.id}" has malformed transitions for entry "${t}.${a}" (expected an object)`);
+					continue;
+				}
+				let s = o;
+				for (let r of Object.keys(s)) r !== "allowBack" && (!i.exitPoints || !(r in i.exitPoints)) && n.push(`journey "${e.id}" references unknown exit "${t}.${a}.${r}"`);
+				if (s.allowBack === !0) {
+					let i = r.allowBack;
+					i !== "preserve-state" && i !== "rollback" && n.push(`journey "${e.id}" sets allowBack on "${t}.${a}" but the module entry does not declare allowBack`);
+				}
+			}
+		}
+		if (M(e, t, s, n), e.moduleCompat) for (let [t, c] of Object.entries(e.moduleCompat)) {
+			if (typeof c != "string") {
+				n.push(`journey "${e.id}" declares a non-string version range for module "${t}" in moduleCompat`);
+				continue;
+			}
+			let l = c.trim();
+			if (l.length === 0) {
+				n.push(`journey "${e.id}" declares an empty version range for module "${t}" in moduleCompat`);
+				continue;
+			}
+			let u = s.get(t);
+			if (!u) {
+				n.push(`journey "${e.id}" requires module "${t}" (range "${l}") in moduleCompat but it is not registered`);
+				continue;
+			}
+			let d;
+			try {
+				d = a(l);
+			} catch (i) {
+				let a = i instanceof r ? i.message : String(i);
+				n.push(`journey "${e.id}" has an unparseable moduleCompat range for "${t}": ${a}`);
+				continue;
+			}
+			let f;
+			try {
+				f = i(u.version);
+			} catch (i) {
+				let a = i instanceof r ? i.message : String(i);
+				n.push(`module "${t}" declares an unparseable version "${u.version}" (referenced by journey "${e.id}"): ${a}`);
+				continue;
+			}
+			o(f, d) || n.push(`journey "${e.id}" requires module "${t}" "${l}" but registered version is "${u.version}"`);
+		}
+		let d = e.resumes ?? {};
+		for (let [t, r] of Object.entries(d)) {
+			let i = s.get(t);
+			if (!i) {
+				n.push(`journey "${e.id}" references unknown module id "${t}" in resumes`);
+				continue;
+			}
+			if (!r || typeof r != "object") {
+				n.push(`journey "${e.id}" has malformed resumes for module "${t}" (expected an object)`);
+				continue;
+			}
+			for (let [a, o] of Object.entries(r)) {
+				if (!i.entryPoints?.[a]) {
+					n.push(`journey "${e.id}" references unknown entry "${t}.${a}" in resumes`);
+					continue;
+				}
+				if (!o || typeof o != "object") {
+					n.push(`journey "${e.id}" has malformed resumes for entry "${t}.${a}" (expected an object)`);
+					continue;
+				}
+				for (let r of Object.keys(o)) i.exitPoints && Object.prototype.hasOwnProperty.call(i.exitPoints, r) && n.push(`journey "${e.id}" declares resume "${t}.${a}.${r}" but "${r}" is also an exit name on that module — rename one to avoid silent confusion`), typeof o[r] != "function" && n.push(`journey "${e.id}" has non-function resume "${t}.${a}.${r}"`);
+			}
+		}
+	}
+	if (n.length > 0) throw new C(n);
+}
+function D(e) {
+	let t = O(e);
+	if (t.length > 0) throw new C(t);
+}
+function O(e) {
+	let t = /* @__PURE__ */ new Set();
+	for (let n of e) t.add(n.definition.id);
+	let n = /* @__PURE__ */ new Map();
+	for (let r of e) {
+		let e = [], i = r.definition.invokes;
+		if (Array.isArray(i)) for (let n of i) !n || typeof n.id != "string" || t.has(n.id) && e.push(n.id);
+		n.set(r.definition.id, e);
+	}
+	let r = [], i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Set(), s = [], c = [];
+	for (let t of e) {
+		let e = t.definition.id;
+		if (!a.has(e)) for (c.push({
+			id: e,
+			nextIndex: 0
+		}), o.add(e), s.push(e); c.length > 0;) {
+			let e = c[c.length - 1], t = n.get(e.id);
+			if (!t || e.nextIndex >= t.length) {
+				c.pop(), s.pop(), o.delete(e.id), a.add(e.id);
+				continue;
+			}
+			let l = t[e.nextIndex];
+			if (e.nextIndex++, o.has(l)) {
+				let e = s.indexOf(l), t = s.slice(e), n = k(t);
+				if (!i.has(n)) {
+					i.add(n);
+					let e = [...t, l].map(A).join(" → ");
+					r.push(`journey invoke cycle detected: ${e}`);
+				}
+				continue;
+			}
+			a.has(l) || (c.push({
+				id: l,
+				nextIndex: 0
+			}), o.add(l), s.push(l));
+		}
+	}
+	return r;
+}
+function k(e) {
+	let t = 0;
+	for (let n = 1; n < e.length; n++) e[n] < e[t] && (t = n);
+	return e.slice(t).concat(e.slice(0, t)).join("→");
+}
+function A(e) {
+	return `"${e}"`;
+}
+function j(e) {
+	return typeof e == "object" && !!e && !Array.isArray(e);
+}
+function M(e, t, n, r) {
+	let i = e.wildcardTransitions;
+	if (i == null) return;
+	if (!j(i)) {
+		r.push(`journey "${e.id}" has malformed wildcardTransitions (expected an object, got ${P(i)})`);
+		return;
+	}
+	let a = i, o = new Set(Object.keys(e.transitions ?? {})), s = [];
+	for (let e of o) {
+		let t = n.get(e);
+		t && s.push(t);
+	}
+	let c = N(a.byEntryAndExit, `journey "${e.id}" has malformed wildcardTransitions.byEntryAndExit`, r);
+	c && F(e.id, c, t, s, r);
+	let l = N(a.byExit, `journey "${e.id}" has malformed wildcardTransitions.byExit`, r);
+	l && I(e.id, l, c, t, s, r);
+}
+function N(e, t, n) {
+	if (e != null) {
+		if (!j(e)) {
+			n.push(`${t} (expected an object, got ${P(e)})`);
+			return;
+		}
+		return e;
+	}
+}
+function P(e) {
+	return e === null ? "null" : Array.isArray(e) ? "array" : typeof e;
+}
+function F(e, t, n, r, i) {
+	for (let [a, o] of Object.entries(t)) {
+		if (!j(o)) {
+			i.push(`journey "${e}" has malformed wildcardTransitions.byEntryAndExit["${a}"] (expected an object, got ${P(o)})`);
+			continue;
+		}
+		for (let [t, s] of Object.entries(o)) {
+			if (typeof s != "function") {
+				i.push(`journey "${e}" has non-function wildcardTransitions.byEntryAndExit["${a}"]["${t}"]`);
+				continue;
+			}
+			if (n.filter((e) => e.entryPoints?.[a] !== void 0 && e.exitPoints !== void 0 && t in e.exitPoints).length === 0) {
+				i.push(`journey "${e}" declares wildcardTransitions.byEntryAndExit["${a}"]["${t}"] but no registered module pairs that entry with that exit`);
+				continue;
+			}
+			let o = r.filter((e) => e.entryPoints?.[a] !== void 0 && e.exitPoints !== void 0 && t in e.exitPoints);
+			L(i, e, `wildcardTransitions.byEntryAndExit["${a}"]["${t}"]`, t, o);
+		}
+	}
+}
+function I(e, t, n, r, i, a) {
+	for (let [o, s] of Object.entries(t)) {
+		if (typeof s != "function") {
+			a.push(`journey "${e}" has non-function wildcardTransitions.byExit["${o}"]`);
+			continue;
+		}
+		if (r.filter((e) => e.exitPoints !== void 0 && o in e.exitPoints).length === 0) {
+			a.push(`journey "${e}" declares wildcardTransitions.byExit["${o}"] but no registered module emits that exit`);
+			continue;
+		}
+		let t = i.filter((e) => e.exitPoints !== void 0 && o in e.exitPoints);
+		if (L(a, e, `wildcardTransitions.byExit["${o}"]`, o, t), n) {
+			let t = [];
+			for (let [e, r] of Object.entries(n)) j(r) && typeof r[o] == "function" && t.push(e);
+			t.length > 0 && console.warn(`[@modular-react/journeys] journey "${e}" declares both wildcardTransitions.byExit["${o}"] and wildcardTransitions.byEntryAndExit[${t.map(A).join(",")}]["${o}"]; the byExit handler is unreachable from those entries (the more specific one wins).`);
+		}
+	}
+}
+function L(e, n, r, i, a) {
+	let o = null, s = null;
+	for (let e of a) {
+		let n = e.exitPoints?.[i];
+		if (n && t(n)) {
+			o = n, s = e.id;
+			break;
+		}
+	}
+	if (o) for (let c of a) {
+		if (c.id === s) continue;
+		let a = c.exitPoints?.[i];
+		a && t(a) && a !== o && e.push(`journey "${n}" ${r}: module "${c.id}" declares exit "${i}" with a different ExitContract than module "${s}" (contract identity mismatch — share a single defineExitContract value across modules to make the wildcard's output shape uniform)`);
+	}
+}
+function R(e) {
+	let t = [];
+	return (!e.id || typeof e.id != "string") && t.push("journey is missing a string id"), (!e.version || typeof e.version != "string") && t.push(`journey "${e.id ?? "(unknown)"}" is missing a string version`), typeof e.initialState != "function" && t.push(`journey "${e.id}" must declare initialState as a function`), typeof e.start != "function" && t.push(`journey "${e.id}" must declare start as a function`), (!e.transitions || typeof e.transitions != "object") && t.push(`journey "${e.id}" must declare transitions`), t;
+}
+//#endregion
+//#region src/runtime.ts
+var ee = 16, te = 8, z = /* @__PURE__ */ new WeakMap();
+function B(n, r = {}) {
+	let i = r.debug ?? e(), a = r.modules ?? {}, o = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Map();
+	for (let e of n) c.set(e.definition.id, e);
+	let l = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map();
+	function f(e, t) {
+		return `${e}
${t}`;
+	}
+	function p(e) {
+		e.revision += 1, e.cachedSnapshot = null;
+		for (let t of e.listeners) try {
+			t();
+		} catch (e) {
+			i && console.error("[@modular-react/journeys] listener threw", e);
+		}
+	}
+	function m() {
+		return (/* @__PURE__ */ new Date()).toISOString();
+	}
+	function h() {
+		try {
+			let e = globalThis.crypto;
+			if (e?.randomUUID) return `ji_${e.randomUUID()}`;
+		} catch {}
+		let e = Math.random().toString(36).slice(2, 10);
+		return `ji_${Date.now().toString(36)}_${e}`;
+	}
+	function g(e) {
+		return {
+			id: e.definition.id,
+			version: e.definition.version,
+			meta: e.definition.meta
+		};
+	}
+	function _(e) {
+		let t = c.get(e);
+		if (!t) throw new T(e, [...c.keys()]);
+		return t;
+	}
+	function v(e) {
+		return {
+			moduleId: e.module,
+			entry: e.entry,
+			input: e.input
+		};
+	}
+	function y(e) {
+		if (!e) return !1;
+		let t = a[e.moduleId]?.entryPoints?.[e.entry]?.allowBack;
+		return t === "rollback" || t === "preserve-state" ? t : !1;
+	}
+	function b(e, t) {
+		return t ? e.transitions?.[t.moduleId]?.[t.entry]?.allowBack === !0 : !1;
+	}
+	function x(e) {
+		if (typeof e != "object" || !e) return e;
+		let t = Array.isArray(e) ? [...e] : { ...e };
+		try {
+			Object.freeze(t);
+		} catch {}
+		return t;
+	}
+	function S(e, t) {
+		let n = t.options?.maxHistory;
+		if (!(n === void 0 || n <= 0)) {
+			for (; e.history.length > n;) e.history.shift(), e.rollbackSnapshots.shift();
+			e.hasRollbackSnapshot = e.rollbackSnapshots.some((e) => e !== void 0);
+		}
+	}
+	function C(e, t) {
+		let n = A(e);
+		if (e.saveInFlight) {
+			e.pendingSave = n;
+			return;
+		}
+		E(e, t, n);
+	}
+	async function E(e, t, n) {
+		e.saveInFlight = !0;
+		try {
+			if (!e.persistenceKey) return;
+			await t.save(e.persistenceKey, n);
+		} catch (t) {
+			i && console.error(`[@modular-react/journeys] Failed to persist "${e.journeyId}" instance ${e.id}`, t);
+		} finally {
+			if (e.saveInFlight = !1, e.pendingRemove) e.pendingRemove = !1, e.pendingSave = null, e.persistenceKey && k(t, e.persistenceKey);
+			else if (e.pendingSave) {
+				let n = e.pendingSave;
+				e.pendingSave = null, E(e, t, n);
+			}
+		}
+	}
+	function D(e, t) {
+		if (!e.persistenceKey) return;
+		e.pendingSave = null;
+		let n = e.persistenceKey;
+		if (u.delete(f(e.journeyId, n)), e.saveInFlight) {
+			e.pendingRemove = !0;
+			return;
+		}
+		k(t, n);
+	}
+	function O(e, t) {
+		k(e, t);
+	}
+	function k(e, t) {
+		try {
+			let n = e.remove(t);
+			n && typeof n.catch == "function" && n.catch((e) => {
+				i && console.error("[@modular-react/journeys] persistence.remove rejected", e);
+			});
+		} catch (e) {
+			i && console.error("[@modular-react/journeys] persistence.remove threw", e);
+		}
+	}
+	function A(e) {
+		let t;
+		if (e.activeChildId) {
+			let n = l.get(e.activeChildId);
+			if (n) {
+				let r = n.parent;
+				r && r.instanceId === e.id && (t = {
+					childJourneyId: n.journeyId,
+					childInstanceId: n.id,
+					childPersistenceKey: n.persistenceKey,
+					resumeName: r.resumeName
+				});
+			}
+		}
+		let n = e.parent ? {
+			parentInstanceId: e.parent.instanceId,
+			resumeName: e.parent.resumeName
+		} : void 0;
+		return {
+			definitionId: e.journeyId,
+			version: c.get(e.journeyId).definition.version,
+			instanceId: e.id,
+			status: e.status === "loading" ? "active" : e.status,
+			step: e.step,
+			history: [...e.history],
+			rollbackSnapshots: e.hasRollbackSnapshot ? e.rollbackSnapshots.map((e) => e === void 0 ? null : e) : void 0,
+			terminalPayload: e.status === "completed" || e.status === "aborted" ? e.terminalPayload : void 0,
+			state: e.state,
+			startedAt: e.startedAt,
+			updatedAt: e.updatedAt,
+			pendingInvoke: t,
+			parentLink: n,
+			resumeBouncesAtStep: e.resumeBouncesAtStep ?? void 0
+		};
+	}
+	function j(e, t, n, r, a, o) {
+		let s = {
+			journeyId: t.journeyId,
+			instanceId: t.id,
+			from: n,
+			to: r,
+			exit: a,
+			state: t.state,
+			history: [...t.history],
+			kind: o?.kind ?? "step",
+			child: o?.child,
+			outcome: o?.outcome,
+			resume: o?.resume
+		};
+		try {
+			e.definition.onTransition?.(s);
+		} catch (e) {
+			i && console.error("[@modular-react/journeys] onTransition (definition) threw", e);
+		}
+		try {
+			e.options?.onTransition?.(s);
+		} catch (e) {
+			i && console.error("[@modular-react/journeys] onTransition (registration) threw", e);
+		}
+	}
+	function M(e, t, n) {
+		if (t.terminalFired) return;
+		t.terminalFired = !0;
+		let r = {
+			journeyId: t.journeyId,
+			instanceId: t.id,
+			state: t.state,
+			history: t.history
+		};
+		try {
+			e.definition.onComplete?.(r, n);
+		} catch (e) {
+			i && console.error("[@modular-react/journeys] onComplete (definition) threw", e);
+		}
+		try {
+			e.options?.onComplete?.(r, n);
+		} catch (e) {
+			i && console.error("[@modular-react/journeys] onComplete (registration) threw", e);
+		}
+	}
+	function N(e, t, n) {
+		if (t.terminalFired) return;
+		t.terminalFired = !0;
+		let r = {
+			journeyId: t.journeyId,
+			instanceId: t.id,
+			state: t.state,
+			history: t.history
+		};
+		try {
+			e.definition.onAbort?.(r, n);
+		} catch (e) {
+			i && console.error("[@modular-react/journeys] onAbort (definition) threw", e);
+		}
+		try {
+			e.options?.onAbort?.(r, n);
+		} catch (e) {
+			i && console.error("[@modular-react/journeys] onAbort (registration) threw", e);
+		}
+	}
+	function P(e, t, n, r, a = "step") {
+		try {
+			e.options?.onError?.(n, {
+				step: r,
+				phase: a
+			});
+		} catch (e) {
+			i && console.error("[@modular-react/journeys] onError (registration) threw", e);
+		}
+	}
+	function F(e, t, n) {
+		let r = e.definition.resumes;
+		if (!r) return;
+		let i = r[t.moduleId];
+		if (!i) return;
+		let a = i[t.entry];
+		if (a) return a[n];
+	}
+	function I(e) {
+		let t = [], n = e.parent, r = new Set([e.id]);
+		for (; n && !r.has(n.instanceId);) {
+			let e = l.get(n.instanceId);
+			if (!e) break;
+			r.add(e.id), t.unshift(e), n = e.parent;
+		}
+		return t;
+	}
+	function L(e) {
+		let t = e.options?.maxResumeBouncesPerStep;
+		return typeof t == "number" && Number.isFinite(t) && t > 0 ? t : te;
+	}
+	function R(e, t, n) {
+		let r = ee, i = !1, a = (e) => {
+			let t = e?.options?.maxCallStackDepth;
+			typeof t == "number" && Number.isFinite(t) && t > 0 && (r = i ? Math.min(r, t) : t, i = !0);
+		};
+		for (let t of e) a(c.get(t.journeyId));
+		return a(t), a(n), r;
+	}
+	function B(e, t, n, r) {
+		let a = e.step;
+		if (!a) return V(e, t, { abort: {
+			reason: "invoke-without-step",
+			exit: r
+		} }, { kind: "invoke" }), !1;
+		if (!n || typeof n != "object") return V(e, t, { abort: {
+			reason: "invoke-missing-spec",
+			exit: r
+		} }, { kind: "invoke" }), !1;
+		let o = n.handle?.id;
+		if (!o || !c.has(o)) return i && console.error(`[@modular-react/journeys] Invoke from "${e.journeyId}.${a.moduleId}.${a.entry}" references unknown child journey id "${o}".`), P(t, e, /* @__PURE__ */ Error(`Unknown child journey "${o}"`), a, "invoke"), V(e, t, { abort: {
+			reason: "invoke-unknown-journey",
+			journeyId: o,
+			exit: r
+		} }, { kind: "invoke" }), !1;
+		if (typeof n.resume != "string" || n.resume.length === 0) return i && console.error(`[@modular-react/journeys] Invoke from "${e.journeyId}.${a.moduleId}.${a.entry}" is missing a resume name.`), P(t, e, /* @__PURE__ */ Error("Invoke missing resume name"), a, "invoke"), V(e, t, { abort: {
+			reason: "invoke-missing-resume",
+			exit: r
+		} }, { kind: "invoke" }), !1;
+		if (!F(t, a, n.resume)) return i && console.error(`[@modular-react/journeys] Invoke from "${e.journeyId}.${a.moduleId}.${a.entry}" names resume "${n.resume}" but no such handler is declared on def.resumes[${a.moduleId}][${a.entry}].`), P(t, e, /* @__PURE__ */ Error(`Resume "${n.resume}" not declared on ${a.moduleId}.${a.entry}`), a, "invoke"), V(e, t, { abort: {
+			reason: "invoke-unknown-resume",
+			resume: n.resume,
+			exit: r
+		} }, { kind: "invoke" }), !1;
+		let s = c.get(o), u = t.definition.invokes;
+		if (Array.isArray(u)) {
+			let n = !1;
+			for (let e of u) if (e?.id === o) {
+				n = !0;
+				break;
+			}
+			if (!n) return i && console.error(`[@modular-react/journeys] Invoke from "${e.journeyId}.${a.moduleId}.${a.entry}" dispatched handle "${o}" which is not in the parent's declared invokes[]. Add the handle to the parent journey's \`invokes\` array, or remove the declaration to opt out of static checking.`), P(t, e, /* @__PURE__ */ Error(`Child journey "${o}" is not in "${e.journeyId}".invokes[]`), a, "invoke"), V(e, t, { abort: {
+				reason: "invoke-undeclared-child",
+				parentJourneyId: e.journeyId,
+				childJourneyId: o,
+				exit: r
+			} }, { kind: "invoke" }), !1;
+		}
+		let f = I(e);
+		{
+			let n = f.map((e) => e.journeyId).concat(e.journeyId), s = n.indexOf(o);
+			if (s >= 0) {
+				let c = [...n.slice(s), o], l = c.map((e) => `"${e}"`).join(" → ");
+				return i && console.error(`[@modular-react/journeys] Invoke would re-enter journey "${o}" already on the active chain: ${l}. Aborting parent "${e.id}".`), P(t, e, /* @__PURE__ */ Error(`Invoke cycle on chain: ${l}`), a, "invoke"), V(e, t, { abort: {
+					reason: "invoke-cycle",
+					childJourneyId: o,
+					chain: c,
+					exit: r
+				} }, { kind: "invoke" }), !1;
+			}
+		}
+		let m = R(f, t, s), h = f.length + 2;
+		if (h > m) {
+			let n = f.map((e) => e.journeyId).concat(e.journeyId, o), s = n.map((e) => `"${e}"`).join(" → ");
+			return i && console.error(`[@modular-react/journeys] Invoke would exceed maxCallStackDepth (${m}) — chain: ${s}. Aborting parent "${e.id}".`), P(t, e, /* @__PURE__ */ Error(`Invoke would exceed depth cap ${m} on chain ${s}`), a, "invoke"), V(e, t, { abort: {
+				reason: "invoke-stack-overflow",
+				depth: h,
+				cap: m,
+				chain: n,
+				exit: r
+			} }, { kind: "invoke" }), !1;
+		}
+		let g;
+		try {
+			g = $.start(n.handle, n.input);
+		} catch (n) {
+			return i && console.error("[@modular-react/journeys] runtime.start during invoke threw", n), P(t, e, n, a, "invoke"), V(e, t, { abort: {
+				reason: "invoke-start-threw",
+				error: n,
+				exit: r
+			} }, { kind: "invoke" }), !1;
+		}
+		let _ = l.get(g);
+		if (!_) return V(e, t, { abort: {
+			reason: "invoke-start-no-record",
+			exit: r
+		} }, { kind: "invoke" }), !1;
+		if (_.parent && _.parent.instanceId !== e.id) return i && console.error(`[@modular-react/journeys] Invoke target "${_.id}" is already linked to parent "${_.parent.instanceId}". Aborting parent "${e.id}".`), P(t, e, /* @__PURE__ */ Error(`Child instance "${_.id}" is already linked to parent "${_.parent.instanceId}"`), a, "invoke"), V(e, t, { abort: {
+			reason: "invoke-child-already-linked",
+			childInstanceId: _.id,
+			existingParentId: _.parent.instanceId,
+			exit: r
+		} }, { kind: "invoke" }), !1;
+		e.activeChildId = g, _.parent = {
+			instanceId: e.id,
+			resumeName: n.resume
+		}, d.set(g, e.id);
+		let v = s?.options?.persistence;
+		return v && C(_, v), p(_), _;
+	}
+	function V(e, t, n, r) {
+		U(e, t, n, null, r);
+	}
+	function H(e) {
+		if (e.status !== "completed" && e.status !== "aborted") return;
+		let t = e.parent;
+		if (!t) return;
+		let n = t.instanceId, r = l.get(n);
+		if (d.delete(e.id), e.parent = null, p(e), !r || r.activeChildId !== e.id) return;
+		if (r.activeChildId = null, r.status !== "active") {
+			p(r);
+			return;
+		}
+		let a = c.get(r.journeyId), o = r.step;
+		if (!a || !o) {
+			p(r);
+			return;
+		}
+		let s = F(a, o, t.resumeName);
+		if (!s) {
+			i && console.warn(`[@modular-react/journeys] Resume "${t.resumeName}" no longer declared on ${o.moduleId}.${o.entry} — aborting parent ${r.id}.`), P(a, r, /* @__PURE__ */ Error(`Resume "${t.resumeName}" missing`), o, "resume"), U(r, a, { abort: {
+				reason: "resume-missing",
+				resume: t.resumeName,
+				childJourneyId: e.journeyId
+			} }, null);
+			return;
+		}
+		let u = e.status === "completed" ? {
+			status: "completed",
+			payload: e.terminalPayload
+		} : {
+			status: "aborted",
+			reason: e.terminalPayload
+		}, f;
+		try {
+			f = s({
+				state: r.state,
+				input: o.input,
+				outcome: u
+			});
+		} catch (e) {
+			i && console.error("[@modular-react/journeys] resume handler threw", e), P(a, r, e, o, "resume"), U(r, a, { abort: {
+				reason: "resume-threw",
+				resume: t.resumeName,
+				error: e
+			} }, null);
+			return;
+		}
+		if (f && typeof f.then == "function") {
+			i && console.error(`[@modular-react/journeys] Resume handler "${t.resumeName}" on ${o.moduleId}.${o.entry} returned a Promise. Resumes must be synchronous and pure.`), U(r, a, { abort: {
+				reason: "resume-returned-promise",
+				resume: t.resumeName
+			} }, null, {
+				kind: "resume",
+				outcome: u,
+				resume: t.resumeName
+			});
+			return;
+		}
+		U(r, a, f, null, {
+			kind: "resume",
+			outcome: u,
+			resume: t.resumeName
+		});
+	}
+	function U(e, t, n, r, o) {
+		let s = e.step, c = e.state;
+		if ("state" in n && (e.state = n.state), ("next" in n || "complete" in n || "abort" in n) && (e.resumeBouncesAtStep = null), "next" in n) {
+			let l = v(n.next);
+			if (i && Object.keys(a).length > 0) {
+				let e = a[l.moduleId];
+				e ? e.entryPoints?.[l.entry] || console.warn(`[@modular-react/journeys] Transition on "${s?.moduleId}.${s?.entry}" returned next.entry="${l.moduleId}.${l.entry}" which is not a declared entry on that module.`) : console.warn(`[@modular-react/journeys] Transition on "${s?.moduleId}.${s?.entry}" returned next.module="${l.moduleId}" which is not in the runtime's module map — the outlet will render a "no entry" error.`);
+			}
+			s && (e.history.push(s), W(l) === "rollback" ? (e.rollbackSnapshots.push(x(c)), e.hasRollbackSnapshot = !0) : e.rollbackSnapshots.push(void 0)), e.step = l, e.status = "active", e.stepToken += 1, e.updatedAt = m(), e.cachedCallbacks = null, S(e, t), j(t, e, s, l, r, o);
+		} else if ("complete" in n) s && (e.history.push(s), e.rollbackSnapshots.push(void 0)), e.step = null, e.status = "completed", e.terminalPayload = n.complete, e.stepToken += 1, e.updatedAt = m(), e.cachedCallbacks = null, S(e, t), j(t, e, s, null, r, o), M(t, e, n.complete);
+		else if ("abort" in n) s && (e.history.push(s), e.rollbackSnapshots.push(void 0)), e.step = null, e.status = "aborted", e.terminalPayload = n.abort, e.stepToken += 1, e.updatedAt = m(), e.cachedCallbacks = null, S(e, t), j(t, e, s, null, r, o), N(t, e, n.abort);
+		else if ("invoke" in n) {
+			if (o?.kind === "resume") {
+				let n = L(t), r = e.resumeBouncesAtStep, a = r && r.stepToken === e.stepToken ? r.count + 1 : 1;
+				if (a > n) {
+					i && console.error(`[@modular-react/journeys] Resume on "${e.journeyId}.${s?.moduleId}.${s?.entry}" would bounce ${a} times in a row at the same step (cap ${n}). Aborting "${e.id}" to break the loop.`), P(t, e, /* @__PURE__ */ Error(`Resume bounce limit exceeded (${n}) at ${s?.moduleId}.${s?.entry}`), s, "resume"), U(e, t, { abort: {
+						reason: "resume-bounce-limit",
+						cap: n,
+						count: a,
+						resume: o.resume
+					} }, null, {
+						kind: "resume",
+						outcome: o.outcome,
+						resume: o.resume
+					});
+					return;
+				}
+				e.resumeBouncesAtStep = {
+					stepToken: e.stepToken,
+					count: a
+				};
+			}
+			let a = B(e, t, n.invoke, r);
+			if (!a) return;
+			e.updatedAt = m(), j(t, e, s, s, r, {
+				kind: "invoke",
+				child: {
+					instanceId: a.id,
+					journeyId: a.journeyId
+				}
+			});
+		}
+		let l = t.options?.persistence;
+		l && (e.status === "active" ? C(e, l) : D(e, l)), p(e), H(e);
+	}
+	function W(e) {
+		return y(e);
+	}
+	function G(e, n) {
+		let r = `${e.definition.id}${n}`;
+		if (s.has(r)) return;
+		s.add(r);
+		let i = Object.keys(e.definition.transitions ?? {}), o = null;
+		for (let r of i) {
+			let i = a[r];
+			if (!i) continue;
+			let s = i.exitPoints?.[n];
+			if (!(!s || !t(s))) {
+				if (!o) {
+					o = {
+						contract: s,
+						moduleId: r
+					};
+					continue;
+				}
+				if (s !== o.contract) {
+					console.warn(`[@modular-react/journeys] Journey "${e.definition.id}": modules "${o.moduleId}" and "${r}" declare exit "${n}" via different ExitContract instances. Wildcard handlers may receive a non-uniform output shape. This drift was not caught at registration time — re-resolve the registry, or call validateJourneyContracts(...) after registering new modules.`);
+					return;
+				}
+			}
+		}
+	}
+	function ne(e, n, r, s, c) {
+		if (e.status !== "active") {
+			i && console.warn(`[@modular-react/journeys] Exit("${s}") dropped on instance ${e.id} — status=${e.status}. (This is the expected no-op when an exit fires before the initial async load settles; await the load or subscribe for status changes before dispatching.)`);
+			return;
+		}
+		if (e.activeChildId) {
+			i && console.warn(`[@modular-react/journeys] Exit("${s}") dropped on instance ${e.id} — a child journey is in flight (activeChildId=${e.activeChildId}). The parent advances when the child resumes.`);
+			return;
+		}
+		if (e.stepToken !== r) {
+			i && console.warn(`[@modular-react/journeys] Stale exit("${s}") dropped on instance ${e.id}`);
+			return;
+		}
+		let l = e.step;
+		if (!l) return;
+		let u = c, d = a[l.moduleId];
+		!d && i && !o.has(l.moduleId) && (o.add(l.moduleId), console.warn(`[@modular-react/journeys] No descriptor for module "${l.moduleId}" in the runtime's module map. ExitContract payload validation is skipped for any contract-based exit on this step. Pass it via createJourneyRuntime({ modules: ... }) to enable schema validation.`));
+		let f = d?.exitPoints?.[s], p = f !== void 0 && t(f);
+		if (i && p && G(n, s), p && f.schema) {
+			let t = f, r;
+			try {
+				r = t.schema["~standard"].validate(c);
+			} catch (t) {
+				i && console.error(`[@modular-react/journeys] Exit contract schema for "${l.moduleId}.${s}" threw during validation.`, t), P(n, e, t, l), U(e, n, { abort: {
+					reason: "transition-error",
+					exit: s,
+					error: t
+				} }, s);
+				return;
+			}
+			if (r && typeof r.then == "function") {
+				i && console.error(`[@modular-react/journeys] Exit contract schema for "${l.moduleId}.${s}" returned a Promise. Schemas attached to ExitContracts must be synchronous — async refinements run in a loading entry point instead.`), r.catch(() => {}), U(e, n, { abort: {
+					reason: "exit-payload-invalid-async",
+					exit: s
+				} }, s);
+				return;
+			}
+			let a = r;
+			if (a.issues) {
+				i && console.warn(`[@modular-react/journeys] Exit("${s}") on ${l.moduleId} failed contract validation:`, a.issues), U(e, n, { abort: {
+					reason: "exit-payload-invalid",
+					exit: s,
+					issues: a.issues
+				} }, s);
+				return;
+			}
+			u = a.value;
+		}
+		let m = n.definition.transitions?.[l.moduleId]?.[l.entry]?.[s], h = n.definition.wildcardTransitions, g = h?.byEntryAndExit?.[l.entry]?.[s], _ = h?.byExit?.[s], v = typeof m == "function" ? m : typeof g == "function" ? g : typeof _ == "function" ? _ : void 0;
+		if (typeof v != "function") {
+			i && console.warn(`[@modular-react/journeys] No transition for exit("${s}") on ${l.moduleId}.${l.entry} — ignoring.`);
+			return;
+		}
+		let y;
+		try {
+			y = v({
+				state: e.state,
+				input: l.input,
+				output: u
+			});
+		} catch (t) {
+			i && console.error("[@modular-react/journeys] transition handler threw", t), P(n, e, t, l), U(e, n, { abort: {
+				reason: "transition-error",
+				exit: s,
+				error: t
+			} }, s);
+			return;
+		}
+		if (y && typeof y.then == "function") {
+			i && console.error(`[@modular-react/journeys] Transition handler for ${l.moduleId}.${l.entry}."${s}" returned a Promise. Transitions must be synchronous and pure — put async work inside a loading entry point on a module.`), U(e, n, { abort: {
+				reason: "transition-returned-promise",
+				exit: s
+			} }, s);
+			return;
+		}
+		U(e, n, y, s);
+	}
+	function re(e, t, n) {
+		if (e.status !== "active" || e.activeChildId || e.stepToken !== n || e.history.length === 0) return;
+		let r = e.step;
+		if (!r || !b(t.definition, r)) return;
+		let i = e.history.pop(), a = e.rollbackSnapshots.pop();
+		y(r) === "rollback" && a !== void 0 && (e.state = a), e.hasRollbackSnapshot = e.rollbackSnapshots.some((e) => e !== void 0), e.step = i, e.resumeBouncesAtStep = null, e.stepToken += 1, e.updatedAt = m(), e.cachedCallbacks = null, j(t, e, r, i, null);
+		let o = t.options?.persistence;
+		o && C(e, o), p(e);
+	}
+	function ie(e, t) {
+		if (e.cachedCallbacks && e.cachedCallbacks.stepToken === e.stepToken) return e.cachedCallbacks;
+		let n = e.stepToken, r = (r, i) => {
+			ne(e, t, n, r, i);
+		}, i = y(e.step);
+		return i === !1 && e.step && b(t.definition, e.step) && !a[e.step.moduleId] && (i = "preserve-state"), e.cachedCallbacks = {
+			stepToken: n,
+			exit: r,
+			goBack: i !== !1 && b(t.definition, e.step) && e.history.length > 0 ? () => {
+				re(e, t, n);
+			} : void 0
+		}, e.cachedCallbacks;
+	}
+	function ae(e) {
+		if (e.cachedSnapshot && e.cachedSnapshot.revision === e.revision) return e.cachedSnapshot.instance;
+		let t = [...e.history], n = {
+			id: e.id,
+			journeyId: e.journeyId,
+			status: e.status,
+			step: e.step,
+			history: t,
+			state: e.state,
+			terminalPayload: e.status === "completed" || e.status === "aborted" ? e.terminalPayload : void 0,
+			startedAt: e.startedAt,
+			updatedAt: e.updatedAt,
+			activeChildId: e.activeChildId,
+			parent: e.parent ? { ...e.parent } : null,
+			serialize: () => A(e)
+		};
+		return e.cachedSnapshot = {
+			revision: e.revision,
+			instance: n
+		}, n;
+	}
+	function K(e, t, n, r) {
+		let i = m();
+		return {
+			id: t,
+			journeyId: e.definition.id,
+			status: "loading",
+			step: null,
+			history: [],
+			rollbackSnapshots: [],
+			hasRollbackSnapshot: !1,
+			state: r,
+			terminalPayload: void 0,
+			startedAt: i,
+			updatedAt: i,
+			stepToken: 0,
+			persistenceKey: n,
+			terminalFired: !1,
+			retryCount: 0,
+			listeners: /* @__PURE__ */ new Set(),
+			pendingSave: null,
+			saveInFlight: !1,
+			pendingRemove: !1,
+			revision: 0,
+			cachedSnapshot: null,
+			cachedCallbacks: null,
+			parent: null,
+			activeChildId: null,
+			resumeBouncesAtStep: null
+		};
+	}
+	function q(e, t, n) {
+		let r = e.definition, i = n ?? K(e, h(), null, r.initialState(t));
+		n ? (i.state = r.initialState(t), i.history = [], i.rollbackSnapshots = [], i.hasRollbackSnapshot = !1) : l.set(i.id, i);
+		let a = v(r.start(i.state, t));
+		i.step = a, i.status = "active", i.stepToken += 1, i.terminalFired = !1, i.terminalPayload = void 0, i.retryCount = 0, i.updatedAt = m(), i.cachedCallbacks = null, j(e, i, null, a, null);
+		let o = e.options?.persistence;
+		return o && C(i, o), p(i), i.id;
+	}
+	function J(e, t) {
+		let n = t.history.length;
+		if (t.rollbackSnapshots && t.rollbackSnapshots.length !== n) throw new w(`Blob for journey "${e.journeyId}" has rollbackSnapshots.length=${t.rollbackSnapshots.length} but history.length=${n}. Fix the persisted blob (pad rollbackSnapshots with null for non-rollback entries) or provide onHydrate to migrate.`);
+		e.state = t.state, e.step = t.step, e.history = [...t.history], t.rollbackSnapshots ? (e.rollbackSnapshots = t.rollbackSnapshots.map((e) => e === null ? void 0 : e), e.hasRollbackSnapshot = e.rollbackSnapshots.some((e) => e !== void 0)) : (e.rollbackSnapshots = Array.from({ length: n }, () => void 0), e.hasRollbackSnapshot = !1), e.status = t.status, e.terminalPayload = t.terminalPayload, e.startedAt = t.startedAt, e.updatedAt = t.updatedAt, e.stepToken += 1, e.terminalFired = t.status !== "active", e.cachedCallbacks = null, t.parentLink ? e.parent = {
+			instanceId: t.parentLink.parentInstanceId,
+			resumeName: t.parentLink.resumeName
+		} : e.parent = null, t.pendingInvoke ? e.activeChildId = t.pendingInvoke.childInstanceId : e.activeChildId = null, t.resumeBouncesAtStep && Number.isFinite(t.resumeBouncesAtStep.count) ? e.resumeBouncesAtStep = {
+			stepToken: e.stepToken,
+			count: Math.max(0, Math.floor(t.resumeBouncesAtStep.count))
+		} : e.resumeBouncesAtStep = null;
+	}
+	function Y() {
+		d.clear();
+		for (let e of l.values()) {
+			if (!e.parent) continue;
+			let t = l.get(e.parent.instanceId);
+			t && t.activeChildId === e.id && d.set(e.id, t.id);
+		}
+	}
+	function X(e, t) {
+		let n = t.pendingInvoke;
+		if (!n || l.has(n.childInstanceId) || !n.childPersistenceKey) return;
+		let r = c.get(n.childJourneyId);
+		if (!r) return;
+		let a = r.options?.persistence;
+		if (!a) return;
+		let o = f(n.childJourneyId, n.childPersistenceKey);
+		if (u.has(o)) return;
+		let s = Z(r, a, n.childPersistenceKey), d = (t) => {
+			if (!t || t.status !== "active" || l.has(n.childInstanceId) || u.has(o) || e.activeChildId !== n.childInstanceId) return;
+			let a = Q(r, t);
+			if (!a.ok) return;
+			let s = K(r, n.childInstanceId, n.childPersistenceKey, a.blob.state);
+			l.set(n.childInstanceId, s), u.set(o, n.childInstanceId);
+			try {
+				J(s, a.blob);
+			} catch (e) {
+				i && console.error("[@modular-react/journeys] auto-rehydrate child failed", e), l.delete(n.childInstanceId), u.delete(o);
+				return;
+			}
+			X(s, a.blob), Y(), p(s), p(e);
+		};
+		if (s && typeof s.then == "function") {
+			s.then((e) => d(e), (e) => {
+				i && console.error("[@modular-react/journeys] auto-rehydrate child persistence.load rejected", e);
+			});
+			return;
+		}
+		d(s);
+	}
+	function Z(e, t, n) {
+		let r;
+		try {
+			r = t.load(n);
+		} catch (e) {
+			return i && console.error("[@modular-react/journeys] persistence.load threw", e), null;
+		}
+		return r && r.then, r;
+	}
+	function Q(e, t) {
+		let n = t, r = !1;
+		if (e.definition.onHydrate) {
+			r = !0;
+			try {
+				n = e.definition.onHydrate(n);
+			} catch (e) {
+				return i && console.error("[@modular-react/journeys] onHydrate (definition) threw", e), {
+					ok: !1,
+					reason: "on-hydrate-threw",
+					cause: e
+				};
+			}
+		}
+		let a = e.options?.onHydrate;
+		if (a) {
+			r = !0;
+			try {
+				n = a(n);
+			} catch (e) {
+				return i && console.error("[@modular-react/journeys] onHydrate (registration) threw", e), {
+					ok: !1,
+					reason: "on-hydrate-threw",
+					cause: e
+				};
+			}
+		}
+		return r ? {
+			ok: !0,
+			blob: n
+		} : t.version === e.definition.version ? {
+			ok: !0,
+			blob: t
+		} : {
+			ok: !1,
+			reason: "version-mismatch"
+		};
+	}
+	let $ = {
+		start(e, ...t) {
+			let n = t.length > 0 ? t[0] : void 0, r = _(typeof e == "string" ? e : e.id), a = r.options?.persistence;
+			if (a) {
+				let e = a.keyFor({
+					journeyId: r.definition.id,
+					input: n
+				}), t = f(r.definition.id, e), o = u.get(t), s = o ? l.get(o) : null;
+				if (s && (s.status === "active" || s.status === "loading")) return s.id;
+				let c = r.definition, d = Z(r, a, e);
+				if (d && typeof d.then == "function") {
+					let o = h(), s = K(r, o, e, c.initialState(n));
+					return l.set(o, s), u.set(t, o), p(s), d.then((t) => {
+						if (s.status !== "loading") return;
+						if (!t || t.status !== "active") {
+							t && O(a, e), q(r, n, s);
+							return;
+						}
+						let o = Q(r, t);
+						if (!o.ok) {
+							O(a, e), q(r, n, s);
+							return;
+						}
+						try {
+							J(s, o.blob);
+						} catch (t) {
+							i && console.error("[@modular-react/journeys] hydrate after async load failed", t), O(a, e), q(r, n, s);
+							return;
+						}
+						X(s, o.blob), Y(), p(s);
+					}, (e) => {
+						i && console.error("[@modular-react/journeys] persistence.load rejected", e), s.status === "loading" && q(r, n, s);
+					}), o;
+				}
+				let m = d;
+				if (m && m.status === "active") {
+					let o = Q(r, m);
+					if (o.ok) {
+						let s = o.blob.instanceId && !l.has(o.blob.instanceId) ? o.blob.instanceId : h(), d = K(r, s, e, c.initialState(n));
+						l.set(s, d), u.set(t, s);
+						try {
+							J(d, o.blob);
+						} catch (o) {
+							i && console.error("[@modular-react/journeys] hydrate during start failed", o), l.delete(s), u.delete(t), O(a, e);
+							let d = h(), f = K(r, d, e, c.initialState(n));
+							return l.set(d, f), u.set(t, d), q(r, n, f);
+						}
+						return X(d, o.blob), Y(), p(d), s;
+					}
+					O(a, e);
+				} else m && O(a, e);
+				let g = h(), _ = K(r, g, e, c.initialState(n));
+				return l.set(g, _), u.set(t, g), q(r, n, _);
+			}
+			return q(r, n);
+		},
+		hydrate(e, t) {
+			let n = _(e), r = Q(n, t);
+			if (!r.ok) throw r.reason === "on-hydrate-threw" ? new w(`onHydrate threw while migrating blob for "${e}" (blob=${t.version} def=${n.definition.version}).`, { cause: r.cause }) : new w(`Hydrate version mismatch for "${e}": blob=${t.version} def=${n.definition.version}. Provide onHydrate to migrate.`);
+			let i = r.blob.instanceId || h();
+			if (l.has(i)) throw new w(`Cannot hydrate journey "${e}" with instance id "${i}" — an instance with the same id is already in memory. Call forget(id) first if you intend to replace it.`);
+			let a = K(n, i, null, r.blob.state);
+			l.set(i, a);
+			try {
+				J(a, r.blob);
+			} catch (e) {
+				throw l.delete(i), e;
+			}
+			return X(a, r.blob), Y(), p(a), i;
+		},
+		getInstance(e) {
+			let t = l.get(e);
+			return t ? ae(t) : null;
+		},
+		listInstances() {
+			return [...l.keys()];
+		},
+		listDefinitions() {
+			return [...c.values()].map(g);
+		},
+		isRegistered(e) {
+			return c.has(e);
+		},
+		subscribe(e, t) {
+			let n = l.get(e);
+			return n ? (n.listeners.add(t), () => {
+				n.listeners.delete(t);
+			}) : () => {};
+		},
+		end(e, t) {
+			let n = l.get(e);
+			if (!n || n.status === "completed" || n.status === "aborted") return;
+			let r = c.get(n.journeyId);
+			if (!r) return;
+			if (n.activeChildId) {
+				let e = n.activeChildId;
+				n.activeChildId = null;
+				let r = l.get(e);
+				r && r.parent && r.parent.instanceId === n.id && (r.parent = null), d.delete(e), $.end(e, {
+					reason: "parent-ended",
+					parentId: n.id,
+					cause: t
+				});
+			}
+			if (n.status === "loading") {
+				U(n, r, { abort: t ?? "abandoned" }, null);
+				return;
+			}
+			let a = { abort: t ?? "abandoned" }, o = r.options?.onAbandon ?? r.definition.onAbandon;
+			if (o) try {
+				a = o({
+					journeyId: n.journeyId,
+					instanceId: n.id,
+					step: n.step,
+					state: n.state,
+					reason: t ?? "abandoned"
+				});
+			} catch (e) {
+				i && console.error("[@modular-react/journeys] onAbandon threw", e), P(r, n, e, n.step, "abandon"), a = { abort: {
+					reason: t ?? "abandoned",
+					cause: "onAbandon-threw",
+					error: e
+				} };
+			}
+			U(n, r, a, null);
+		},
+		forget(e) {
+			let t = l.get(e);
+			if (t && !(t.status !== "completed" && t.status !== "aborted")) {
+				if (t.persistenceKey && u.delete(f(t.journeyId, t.persistenceKey)), d.delete(e), t.activeChildId) {
+					let e = l.get(t.activeChildId);
+					e && e.parent && e.parent.instanceId === t.id && (e.parent = null, p(e)), d.delete(t.activeChildId), t.activeChildId = null;
+				}
+				t.listeners.clear(), l.delete(e);
+			}
+		},
+		forgetTerminal() {
+			let e = 0;
+			for (let [t, n] of l) if (n.status === "completed" || n.status === "aborted") {
+				if (n.persistenceKey && u.delete(f(n.journeyId, n.persistenceKey)), d.delete(t), n.activeChildId) {
+					let e = l.get(n.activeChildId);
+					e && e.parent && e.parent.instanceId === n.id && (e.parent = null, p(e)), d.delete(n.activeChildId);
+				}
+				n.listeners.clear(), l.delete(t), e += 1;
+			}
+			return e;
+		}
+	};
+	function oe(e, t, n) {
+		let r = l.get(e);
+		if (!r) return;
+		let i = c.get(r.journeyId);
+		i && P(i, r, t, n, "step");
+	}
+	let se = {
+		__bindStepCallbacks: ie,
+		__getRecord: (e) => l.get(e),
+		__getRegistered: (e) => c.get(e),
+		__moduleMap: a,
+		__debug: i,
+		__fireComponentError: oe,
+		__synthesizeCompletion: (e, t) => {
+			let n = l.get(e);
+			if (!n) return;
+			let r = c.get(n.journeyId);
+			r && U(n, r, { complete: t }, null);
+		},
+		__synthesizeAbort: (e, t) => {
+			let n = l.get(e);
+			if (!n) return;
+			let r = c.get(n.journeyId);
+			r && U(n, r, { abort: t }, null);
+		},
+		__consumeRetry: (e, t) => {
+			let n = l.get(e);
+			return !n || n.retryCount >= t ? !1 : (n.retryCount += 1, !0);
+		}
+	};
+	return z.set($, se), $;
+}
+function V(e) {
+	let t = z.get(e);
+	if (!t) throw Error("[@modular-react/journeys] getInternals() called on a runtime that was not produced by createJourneyRuntime().");
+	return t;
+}
+//#endregion
+export { T as a, D as c, s as d, C as i, r as l, V as n, E as o, w as r, R as s, B as t, l as u };
+
+//# sourceMappingURL=runtime-DPPLlqbu.js.map