@modular-react/journeys 0.1.0 → 1.0.1

package/dist/runtime-BUVl0_Ad.js

@@ -0,0 +1,1422 @@
+import { isDevEnv as e } from "@modular-react/core";
+//#region src/semver.ts
+var t = /* @__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;
+}(t || {}), n = class extends Error {
+	constructor(e) {
+		super(`[@modular-react/journeys] ${e}`), this.name = "SemverParseError";
+	}
+};
+function r(e) {
+	let t = b(x(e.trim()));
+	if (!t) throw new n(`invalid version "${e}"`);
+	return t;
+}
+function i(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 = u(e);
+		r.push(t);
+	}
+	return { sets: r };
+}
+function a(e, t) {
+	for (let n of t.sets) {
+		let t = !0;
+		for (let r of n) if (!l(e, r)) {
+			t = !1;
+			break;
+		}
+		if (t) return !0;
+	}
+	return !1;
+}
+function o(e, t) {
+	return a(r(e), i(t));
+}
+function s(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 c(e, t) {
+	return s(r(e), r(t));
+}
+function l(e, n) {
+	let r = s(e, n.v);
+	switch (n.op) {
+		case t.GT: return r > 0;
+		case t.GTE: return r >= 0;
+		case t.LT: return r < 0;
+		case t.LTE: return r <= 0;
+		case t.EQ: return r === 0;
+	}
+}
+function u(e) {
+	let t = [], n = d(e);
+	if (n) return f(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) p(e, t);
+	return t;
+}
+function d(e) {
+	let t = e.match(/^\s*(\S+)\s+-\s+(\S+)\s*$/);
+	return t ? [t[1], t[2]] : null;
+}
+function f(e, r, i) {
+	let a = _(x(e));
+	if (!a) throw new n(`invalid lower bound in hyphen range "${e}"`);
+	i.push({
+		op: t.GTE,
+		v: v(a, 0)
+	});
+	let o = _(x(r));
+	if (!o || o.major === null) throw new n(`invalid upper bound in hyphen range "${r}"`);
+	o.minor === null ? i.push({
+		op: t.LT,
+		v: [
+			o.major + 1,
+			0,
+			0
+		]
+	}) : o.patch === null ? i.push({
+		op: t.LT,
+		v: [
+			o.major,
+			o.minor + 1,
+			0
+		]
+	}) : i.push({
+		op: t.LTE,
+		v: [
+			o.major,
+			o.minor,
+			o.patch
+		]
+	});
+}
+function p(e, n) {
+	if (!(e === "*" || e === "x" || e === "X")) {
+		if (e.startsWith("^")) {
+			m(e.slice(1), n);
+			return;
+		}
+		if (e.startsWith("~")) {
+			h(e.slice(1), n);
+			return;
+		}
+		if (e.startsWith(">=")) {
+			n.push({
+				op: t.GTE,
+				v: y(e.slice(2), e)
+			});
+			return;
+		}
+		if (e.startsWith("<=")) {
+			n.push({
+				op: t.LTE,
+				v: y(e.slice(2), e)
+			});
+			return;
+		}
+		if (e.startsWith(">")) {
+			n.push({
+				op: t.GT,
+				v: y(e.slice(1), e)
+			});
+			return;
+		}
+		if (e.startsWith("<")) {
+			n.push({
+				op: t.LT,
+				v: y(e.slice(1), e)
+			});
+			return;
+		}
+		if (e.startsWith("=")) {
+			g(e.slice(1), e, n);
+			return;
+		}
+		g(e, e, n);
+	}
+}
+function m(e, r) {
+	let i = _(x(e));
+	if (!i) throw new n(`invalid caret range "^${e}"`);
+	let { major: a, minor: o, patch: s } = i;
+	if (a === null) throw new n(`invalid caret range "^${e}"`);
+	if (a > 0) {
+		r.push({
+			op: t.GTE,
+			v: [
+				a,
+				o ?? 0,
+				s ?? 0
+			]
+		}), r.push({
+			op: t.LT,
+			v: [
+				a + 1,
+				0,
+				0
+			]
+		});
+		return;
+	}
+	if (o === null) {
+		r.push({
+			op: t.GTE,
+			v: [
+				0,
+				0,
+				0
+			]
+		}), r.push({
+			op: t.LT,
+			v: [
+				1,
+				0,
+				0
+			]
+		});
+		return;
+	}
+	if (o > 0) {
+		r.push({
+			op: t.GTE,
+			v: [
+				0,
+				o,
+				s ?? 0
+			]
+		}), r.push({
+			op: t.LT,
+			v: [
+				0,
+				o + 1,
+				0
+			]
+		});
+		return;
+	}
+	if (s === null) {
+		r.push({
+			op: t.GTE,
+			v: [
+				0,
+				0,
+				0
+			]
+		}), r.push({
+			op: t.LT,
+			v: [
+				0,
+				1,
+				0
+			]
+		});
+		return;
+	}
+	r.push({
+		op: t.GTE,
+		v: [
+			0,
+			0,
+			s
+		]
+	}), r.push({
+		op: t.LT,
+		v: [
+			0,
+			0,
+			s + 1
+		]
+	});
+}
+function h(e, r) {
+	let i = _(x(e));
+	if (!i) throw new n(`invalid tilde range "~${e}"`);
+	let { major: a, minor: o, patch: s } = i;
+	if (a === null) throw new n(`invalid tilde range "~${e}"`);
+	if (o === null) {
+		r.push({
+			op: t.GTE,
+			v: [
+				a,
+				0,
+				0
+			]
+		}), r.push({
+			op: t.LT,
+			v: [
+				a + 1,
+				0,
+				0
+			]
+		});
+		return;
+	}
+	r.push({
+		op: t.GTE,
+		v: [
+			a,
+			o,
+			s ?? 0
+		]
+	}), r.push({
+		op: t.LT,
+		v: [
+			a,
+			o + 1,
+			0
+		]
+	});
+}
+function g(e, r, i) {
+	let a = _(x(e));
+	if (!a) throw new n(`invalid version or range "${r}"`);
+	let { major: o, minor: s, patch: c } = a;
+	if (o !== null) {
+		if (s === null) {
+			i.push({
+				op: t.GTE,
+				v: [
+					o,
+					0,
+					0
+				]
+			}), i.push({
+				op: t.LT,
+				v: [
+					o + 1,
+					0,
+					0
+				]
+			});
+			return;
+		}
+		if (c === null) {
+			i.push({
+				op: t.GTE,
+				v: [
+					o,
+					s,
+					0
+				]
+			}), i.push({
+				op: t.LT,
+				v: [
+					o,
+					s + 1,
+					0
+				]
+			});
+			return;
+		}
+		i.push({
+			op: t.EQ,
+			v: [
+				o,
+				s,
+				c
+			]
+		});
+	}
+}
+function _(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 v(e, t) {
+	return [
+		e.major ?? t,
+		e.minor ?? t,
+		e.patch ?? t
+	];
+}
+function y(e, t) {
+	let r = b(x(e));
+	if (!r) throw new n(`invalid version in "${t}"`);
+	return r;
+}
+function b(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 x(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 S = class extends Error {
+	issues;
+	constructor(e) {
+		super(`[@modular-react/journeys] Invalid journey registration:\n  - ${e.join("\n  - ")}`), this.name = "JourneyValidationError", this.issues = e;
+	}
+}, C = class extends Error {
+	constructor(e, t) {
+		super(`[@modular-react/journeys] ${e}`, t), this.name = "JourneyHydrationError";
+	}
+}, w = 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 T(e, t) {
+	let o = [], s = /* @__PURE__ */ new Map();
+	for (let e of t) s.set(e.id, e);
+	for (let t of D(e)) o.push(t);
+	for (let e of t) e.exitPoints && Object.prototype.hasOwnProperty.call(e.exitPoints, "allowBack") && o.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 t of e) {
+		let e = t.definition;
+		c.has(e.id) && o.push(`journey "${e.id}" is registered more than once`), c.add(e.id);
+		let l = e.transitions ?? {};
+		for (let [t, n] of Object.entries(l)) {
+			let r = s.get(t);
+			if (!r) {
+				o.push(`journey "${e.id}" references unknown module id "${t}" in transitions`);
+				continue;
+			}
+			if (!n || typeof n != "object") {
+				o.push(`journey "${e.id}" has malformed transitions for module "${t}" (expected an object)`);
+				continue;
+			}
+			for (let [i, a] of Object.entries(n)) {
+				let n = r.entryPoints?.[i];
+				if (!n) {
+					o.push(`journey "${e.id}" references unknown entry "${t}.${i}"`);
+					continue;
+				}
+				if (!a || typeof a != "object") {
+					o.push(`journey "${e.id}" has malformed transitions for entry "${t}.${i}" (expected an object)`);
+					continue;
+				}
+				let s = a;
+				for (let n of Object.keys(s)) n !== "allowBack" && (!r.exitPoints || !(n in r.exitPoints)) && o.push(`journey "${e.id}" references unknown exit "${t}.${i}.${n}"`);
+				if (s.allowBack === !0) {
+					let r = n.allowBack;
+					r !== "preserve-state" && r !== "rollback" && o.push(`journey "${e.id}" sets allowBack on "${t}.${i}" but the module entry does not declare allowBack`);
+				}
+			}
+		}
+		if (e.moduleCompat) for (let [t, c] of Object.entries(e.moduleCompat)) {
+			if (typeof c != "string") {
+				o.push(`journey "${e.id}" declares a non-string version range for module "${t}" in moduleCompat`);
+				continue;
+			}
+			let l = c.trim();
+			if (l.length === 0) {
+				o.push(`journey "${e.id}" declares an empty version range for module "${t}" in moduleCompat`);
+				continue;
+			}
+			let u = s.get(t);
+			if (!u) {
+				o.push(`journey "${e.id}" requires module "${t}" (range "${l}") in moduleCompat but it is not registered`);
+				continue;
+			}
+			let d;
+			try {
+				d = i(l);
+			} catch (r) {
+				let i = r instanceof n ? r.message : String(r);
+				o.push(`journey "${e.id}" has an unparseable moduleCompat range for "${t}": ${i}`);
+				continue;
+			}
+			let f;
+			try {
+				f = r(u.version);
+			} catch (r) {
+				let i = r instanceof n ? r.message : String(r);
+				o.push(`module "${t}" declares an unparseable version "${u.version}" (referenced by journey "${e.id}"): ${i}`);
+				continue;
+			}
+			a(f, d) || o.push(`journey "${e.id}" requires module "${t}" "${l}" but registered version is "${u.version}"`);
+		}
+		let u = e.resumes ?? {};
+		for (let [t, n] of Object.entries(u)) {
+			let r = s.get(t);
+			if (!r) {
+				o.push(`journey "${e.id}" references unknown module id "${t}" in resumes`);
+				continue;
+			}
+			if (!n || typeof n != "object") {
+				o.push(`journey "${e.id}" has malformed resumes for module "${t}" (expected an object)`);
+				continue;
+			}
+			for (let [i, a] of Object.entries(n)) {
+				if (!r.entryPoints?.[i]) {
+					o.push(`journey "${e.id}" references unknown entry "${t}.${i}" in resumes`);
+					continue;
+				}
+				if (!a || typeof a != "object") {
+					o.push(`journey "${e.id}" has malformed resumes for entry "${t}.${i}" (expected an object)`);
+					continue;
+				}
+				for (let n of Object.keys(a)) r.exitPoints && Object.prototype.hasOwnProperty.call(r.exitPoints, n) && o.push(`journey "${e.id}" declares resume "${t}.${i}.${n}" but "${n}" is also an exit name on that module — rename one to avoid silent confusion`), typeof a[n] != "function" && o.push(`journey "${e.id}" has non-function resume "${t}.${i}.${n}"`);
+			}
+		}
+	}
+	if (o.length > 0) throw new S(o);
+}
+function E(e) {
+	let t = D(e);
+	if (t.length > 0) throw new S(t);
+}
+function D(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 = O(t);
+				if (!i.has(n)) {
+					i.add(n);
+					let e = [...t, l].map(k).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 O(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 k(e) {
+	return `"${e}"`;
+}
+function A(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 j = 16, M = 8, N = /* @__PURE__ */ new WeakMap();
+function P(t, n = {}) {
+	let r = n.debug ?? e(), i = n.modules ?? {}, a = /* @__PURE__ */ new Map();
+	for (let e of t) a.set(e.definition.id, e);
+	let o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map();
+	function l(e, t) {
+		return `${e}
${t}`;
+	}
+	function u(e) {
+		e.revision += 1, e.cachedSnapshot = null;
+		for (let t of e.listeners) try {
+			t();
+		} catch (e) {
+			r && console.error("[@modular-react/journeys] listener threw", e);
+		}
+	}
+	function d() {
+		return (/* @__PURE__ */ new Date()).toISOString();
+	}
+	function f() {
+		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 p(e) {
+		return {
+			id: e.definition.id,
+			version: e.definition.version,
+			meta: e.definition.meta
+		};
+	}
+	function m(e) {
+		let t = a.get(e);
+		if (!t) throw new w(e, [...a.keys()]);
+		return t;
+	}
+	function h(e) {
+		return {
+			moduleId: e.module,
+			entry: e.entry,
+			input: e.input
+		};
+	}
+	function g(e) {
+		if (!e) return !1;
+		let t = i[e.moduleId]?.entryPoints?.[e.entry]?.allowBack;
+		return t === "rollback" || t === "preserve-state" ? t : !1;
+	}
+	function _(e, t) {
+		return t ? e.transitions?.[t.moduleId]?.[t.entry]?.allowBack === !0 : !1;
+	}
+	function v(e) {
+		if (typeof e != "object" || !e) return e;
+		let t = Array.isArray(e) ? [...e] : { ...e };
+		try {
+			Object.freeze(t);
+		} catch {}
+		return t;
+	}
+	function y(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 b(e, t) {
+		let n = D(e);
+		if (e.saveInFlight) {
+			e.pendingSave = n;
+			return;
+		}
+		x(e, t, n);
+	}
+	async function x(e, t, n) {
+		e.saveInFlight = !0;
+		try {
+			if (!e.persistenceKey) return;
+			await t.save(e.persistenceKey, n);
+		} catch (t) {
+			r && 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 && E(t, e.persistenceKey);
+			else if (e.pendingSave) {
+				let n = e.pendingSave;
+				e.pendingSave = null, x(e, t, n);
+			}
+		}
+	}
+	function S(e, t) {
+		if (!e.persistenceKey) return;
+		e.pendingSave = null;
+		let n = e.persistenceKey;
+		if (s.delete(l(e.journeyId, n)), e.saveInFlight) {
+			e.pendingRemove = !0;
+			return;
+		}
+		E(t, n);
+	}
+	function T(e, t) {
+		E(e, t);
+	}
+	function E(e, t) {
+		try {
+			let n = e.remove(t);
+			n && typeof n.catch == "function" && n.catch((e) => {
+				r && console.error("[@modular-react/journeys] persistence.remove rejected", e);
+			});
+		} catch (e) {
+			r && console.error("[@modular-react/journeys] persistence.remove threw", e);
+		}
+	}
+	function D(e) {
+		let t;
+		if (e.activeChildId) {
+			let n = o.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: a.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 O(e, t, n, i, a, o) {
+		let s = {
+			journeyId: t.journeyId,
+			instanceId: t.id,
+			from: n,
+			to: i,
+			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) {
+			r && console.error("[@modular-react/journeys] onTransition (definition) threw", e);
+		}
+		try {
+			e.options?.onTransition?.(s);
+		} catch (e) {
+			r && console.error("[@modular-react/journeys] onTransition (registration) threw", e);
+		}
+	}
+	function k(e, t, n) {
+		if (t.terminalFired) return;
+		t.terminalFired = !0;
+		let i = {
+			journeyId: t.journeyId,
+			instanceId: t.id,
+			state: t.state,
+			history: t.history
+		};
+		try {
+			e.definition.onComplete?.(i, n);
+		} catch (e) {
+			r && console.error("[@modular-react/journeys] onComplete (definition) threw", e);
+		}
+		try {
+			e.options?.onComplete?.(i, n);
+		} catch (e) {
+			r && console.error("[@modular-react/journeys] onComplete (registration) threw", e);
+		}
+	}
+	function A(e, t, n) {
+		if (t.terminalFired) return;
+		t.terminalFired = !0;
+		let i = {
+			journeyId: t.journeyId,
+			instanceId: t.id,
+			state: t.state,
+			history: t.history
+		};
+		try {
+			e.definition.onAbort?.(i, n);
+		} catch (e) {
+			r && console.error("[@modular-react/journeys] onAbort (definition) threw", e);
+		}
+		try {
+			e.options?.onAbort?.(i, n);
+		} catch (e) {
+			r && console.error("[@modular-react/journeys] onAbort (registration) threw", e);
+		}
+	}
+	function P(e, t, n, i, a = "step") {
+		try {
+			e.options?.onError?.(n, {
+				step: i,
+				phase: a
+			});
+		} catch (e) {
+			r && 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 = o.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 : M;
+	}
+	function R(e, t, n) {
+		let r = j, i = !1, o = (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) o(a.get(t.journeyId));
+		return o(t), o(n), r;
+	}
+	function z(e, t, n, i) {
+		let s = e.step;
+		if (!s) return B(e, t, { abort: {
+			reason: "invoke-without-step",
+			exit: i
+		} }, { kind: "invoke" }), !1;
+		if (!n || typeof n != "object") return B(e, t, { abort: {
+			reason: "invoke-missing-spec",
+			exit: i
+		} }, { kind: "invoke" }), !1;
+		let l = n.handle?.id;
+		if (!l || !a.has(l)) return r && console.error(`[@modular-react/journeys] Invoke from "${e.journeyId}.${s.moduleId}.${s.entry}" references unknown child journey id "${l}".`), P(t, e, /* @__PURE__ */ Error(`Unknown child journey "${l}"`), s, "invoke"), B(e, t, { abort: {
+			reason: "invoke-unknown-journey",
+			journeyId: l,
+			exit: i
+		} }, { kind: "invoke" }), !1;
+		if (typeof n.resume != "string" || n.resume.length === 0) return r && console.error(`[@modular-react/journeys] Invoke from "${e.journeyId}.${s.moduleId}.${s.entry}" is missing a resume name.`), P(t, e, /* @__PURE__ */ Error("Invoke missing resume name"), s, "invoke"), B(e, t, { abort: {
+			reason: "invoke-missing-resume",
+			exit: i
+		} }, { kind: "invoke" }), !1;
+		if (!F(t, s, n.resume)) return r && console.error(`[@modular-react/journeys] Invoke from "${e.journeyId}.${s.moduleId}.${s.entry}" names resume "${n.resume}" but no such handler is declared on def.resumes[${s.moduleId}][${s.entry}].`), P(t, e, /* @__PURE__ */ Error(`Resume "${n.resume}" not declared on ${s.moduleId}.${s.entry}`), s, "invoke"), B(e, t, { abort: {
+			reason: "invoke-unknown-resume",
+			resume: n.resume,
+			exit: i
+		} }, { kind: "invoke" }), !1;
+		let d = a.get(l), f = t.definition.invokes;
+		if (Array.isArray(f)) {
+			let n = !1;
+			for (let e of f) if (e?.id === l) {
+				n = !0;
+				break;
+			}
+			if (!n) return r && console.error(`[@modular-react/journeys] Invoke from "${e.journeyId}.${s.moduleId}.${s.entry}" dispatched handle "${l}" 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 "${l}" is not in "${e.journeyId}".invokes[]`), s, "invoke"), B(e, t, { abort: {
+				reason: "invoke-undeclared-child",
+				parentJourneyId: e.journeyId,
+				childJourneyId: l,
+				exit: i
+			} }, { kind: "invoke" }), !1;
+		}
+		let p = I(e);
+		{
+			let n = p.map((e) => e.journeyId).concat(e.journeyId), a = n.indexOf(l);
+			if (a >= 0) {
+				let o = [...n.slice(a), l], c = o.map((e) => `"${e}"`).join(" → ");
+				return r && console.error(`[@modular-react/journeys] Invoke would re-enter journey "${l}" already on the active chain: ${c}. Aborting parent "${e.id}".`), P(t, e, /* @__PURE__ */ Error(`Invoke cycle on chain: ${c}`), s, "invoke"), B(e, t, { abort: {
+					reason: "invoke-cycle",
+					childJourneyId: l,
+					chain: o,
+					exit: i
+				} }, { kind: "invoke" }), !1;
+			}
+		}
+		let m = R(p, t, d), h = p.length + 2;
+		if (h > m) {
+			let n = p.map((e) => e.journeyId).concat(e.journeyId, l), a = n.map((e) => `"${e}"`).join(" → ");
+			return r && console.error(`[@modular-react/journeys] Invoke would exceed maxCallStackDepth (${m}) — chain: ${a}. Aborting parent "${e.id}".`), P(t, e, /* @__PURE__ */ Error(`Invoke would exceed depth cap ${m} on chain ${a}`), s, "invoke"), B(e, t, { abort: {
+				reason: "invoke-stack-overflow",
+				depth: h,
+				cap: m,
+				chain: n,
+				exit: i
+			} }, { kind: "invoke" }), !1;
+		}
+		let g;
+		try {
+			g = $.start(n.handle, n.input);
+		} catch (n) {
+			return r && console.error("[@modular-react/journeys] runtime.start during invoke threw", n), P(t, e, n, s, "invoke"), B(e, t, { abort: {
+				reason: "invoke-start-threw",
+				error: n,
+				exit: i
+			} }, { kind: "invoke" }), !1;
+		}
+		let _ = o.get(g);
+		if (!_) return B(e, t, { abort: {
+			reason: "invoke-start-no-record",
+			exit: i
+		} }, { kind: "invoke" }), !1;
+		if (_.parent && _.parent.instanceId !== e.id) return r && 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}"`), s, "invoke"), B(e, t, { abort: {
+			reason: "invoke-child-already-linked",
+			childInstanceId: _.id,
+			existingParentId: _.parent.instanceId,
+			exit: i
+		} }, { kind: "invoke" }), !1;
+		e.activeChildId = g, _.parent = {
+			instanceId: e.id,
+			resumeName: n.resume
+		}, c.set(g, e.id);
+		let v = d?.options?.persistence;
+		return v && b(_, v), u(_), _;
+	}
+	function B(e, t, n, r) {
+		H(e, t, n, null, r);
+	}
+	function V(e) {
+		if (e.status !== "completed" && e.status !== "aborted") return;
+		let t = e.parent;
+		if (!t) return;
+		let n = t.instanceId, i = o.get(n);
+		if (c.delete(e.id), e.parent = null, u(e), !i || i.activeChildId !== e.id) return;
+		if (i.activeChildId = null, i.status !== "active") {
+			u(i);
+			return;
+		}
+		let s = a.get(i.journeyId), l = i.step;
+		if (!s || !l) {
+			u(i);
+			return;
+		}
+		let d = F(s, l, t.resumeName);
+		if (!d) {
+			r && console.warn(`[@modular-react/journeys] Resume "${t.resumeName}" no longer declared on ${l.moduleId}.${l.entry} — aborting parent ${i.id}.`), P(s, i, /* @__PURE__ */ Error(`Resume "${t.resumeName}" missing`), l, "resume"), H(i, s, { abort: {
+				reason: "resume-missing",
+				resume: t.resumeName,
+				childJourneyId: e.journeyId
+			} }, null);
+			return;
+		}
+		let f = e.status === "completed" ? {
+			status: "completed",
+			payload: e.terminalPayload
+		} : {
+			status: "aborted",
+			reason: e.terminalPayload
+		}, p;
+		try {
+			p = d({
+				state: i.state,
+				input: l.input,
+				outcome: f
+			});
+		} catch (e) {
+			r && console.error("[@modular-react/journeys] resume handler threw", e), P(s, i, e, l, "resume"), H(i, s, { abort: {
+				reason: "resume-threw",
+				resume: t.resumeName,
+				error: e
+			} }, null);
+			return;
+		}
+		if (p && typeof p.then == "function") {
+			r && console.error(`[@modular-react/journeys] Resume handler "${t.resumeName}" on ${l.moduleId}.${l.entry} returned a Promise. Resumes must be synchronous and pure.`), H(i, s, { abort: {
+				reason: "resume-returned-promise",
+				resume: t.resumeName
+			} }, null, {
+				kind: "resume",
+				outcome: f,
+				resume: t.resumeName
+			});
+			return;
+		}
+		H(i, s, p, null, {
+			kind: "resume",
+			outcome: f,
+			resume: t.resumeName
+		});
+	}
+	function H(e, t, n, a, 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 = h(n.next);
+			if (r && Object.keys(i).length > 0) {
+				let e = i[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), U(l) === "rollback" ? (e.rollbackSnapshots.push(v(c)), e.hasRollbackSnapshot = !0) : e.rollbackSnapshots.push(void 0)), e.step = l, e.status = "active", e.stepToken += 1, e.updatedAt = d(), e.cachedCallbacks = null, y(e, t), O(t, e, s, l, a, 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 = d(), e.cachedCallbacks = null, y(e, t), O(t, e, s, null, a, o), k(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 = d(), e.cachedCallbacks = null, y(e, t), O(t, e, s, null, a, o), A(t, e, n.abort);
+		else if ("invoke" in n) {
+			if (o?.kind === "resume") {
+				let n = L(t), i = e.resumeBouncesAtStep, a = i && i.stepToken === e.stepToken ? i.count + 1 : 1;
+				if (a > n) {
+					r && 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"), H(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 i = z(e, t, n.invoke, a);
+			if (!i) return;
+			e.updatedAt = d(), O(t, e, s, s, a, {
+				kind: "invoke",
+				child: {
+					instanceId: i.id,
+					journeyId: i.journeyId
+				}
+			});
+		}
+		let l = t.options?.persistence;
+		l && (e.status === "active" ? b(e, l) : S(e, l)), u(e), V(e);
+	}
+	function U(e) {
+		return g(e);
+	}
+	function W(e, t, n, i, a) {
+		if (e.status !== "active") {
+			r && console.warn(`[@modular-react/journeys] Exit("${i}") 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) {
+			r && console.warn(`[@modular-react/journeys] Exit("${i}") 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 !== n) {
+			r && console.warn(`[@modular-react/journeys] Stale exit("${i}") dropped on instance ${e.id}`);
+			return;
+		}
+		let o = e.step;
+		if (!o) return;
+		let s = t.definition.transitions?.[o.moduleId]?.[o.entry]?.[i];
+		if (typeof s != "function") {
+			r && console.warn(`[@modular-react/journeys] No transition for exit("${i}") on ${o.moduleId}.${o.entry} — ignoring.`);
+			return;
+		}
+		let c;
+		try {
+			c = s({
+				state: e.state,
+				input: o.input,
+				output: a
+			});
+		} catch (n) {
+			r && console.error("[@modular-react/journeys] transition handler threw", n), P(t, e, n, o), H(e, t, { abort: {
+				reason: "transition-error",
+				exit: i,
+				error: n
+			} }, i);
+			return;
+		}
+		if (c && typeof c.then == "function") {
+			r && console.error(`[@modular-react/journeys] Transition handler for ${o.moduleId}.${o.entry}."${i}" returned a Promise. Transitions must be synchronous and pure — put async work inside a loading entry point on a module.`), H(e, t, { abort: {
+				reason: "transition-returned-promise",
+				exit: i
+			} }, i);
+			return;
+		}
+		H(e, t, c, i);
+	}
+	function G(e, t, n) {
+		if (e.status !== "active" || e.activeChildId || e.stepToken !== n || e.history.length === 0) return;
+		let r = e.step;
+		if (!r || !_(t.definition, r)) return;
+		let i = e.history.pop(), a = e.rollbackSnapshots.pop();
+		g(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 = d(), e.cachedCallbacks = null, O(t, e, r, i, null);
+		let o = t.options?.persistence;
+		o && b(e, o), u(e);
+	}
+	function ee(e, t) {
+		if (e.cachedCallbacks && e.cachedCallbacks.stepToken === e.stepToken) return e.cachedCallbacks;
+		let n = e.stepToken, r = (r, i) => {
+			W(e, t, n, r, i);
+		}, a = g(e.step);
+		return a === !1 && e.step && _(t.definition, e.step) && !i[e.step.moduleId] && (a = "preserve-state"), e.cachedCallbacks = {
+			stepToken: n,
+			exit: r,
+			goBack: a !== !1 && _(t.definition, e.step) && e.history.length > 0 ? () => {
+				G(e, t, n);
+			} : void 0
+		}, e.cachedCallbacks;
+	}
+	function te(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: () => D(e)
+		};
+		return e.cachedSnapshot = {
+			revision: e.revision,
+			instance: n
+		}, n;
+	}
+	function K(e, t, n, r) {
+		let i = d();
+		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, f(), null, r.initialState(t));
+		n ? (i.state = r.initialState(t), i.history = [], i.rollbackSnapshots = [], i.hasRollbackSnapshot = !1) : o.set(i.id, i);
+		let a = h(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 = d(), i.cachedCallbacks = null, O(e, i, null, a, null);
+		let s = e.options?.persistence;
+		return s && b(i, s), u(i), i.id;
+	}
+	function J(e, t) {
+		let n = t.history.length;
+		if (t.rollbackSnapshots && t.rollbackSnapshots.length !== n) throw new C(`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() {
+		c.clear();
+		for (let e of o.values()) {
+			if (!e.parent) continue;
+			let t = o.get(e.parent.instanceId);
+			t && t.activeChildId === e.id && c.set(e.id, t.id);
+		}
+	}
+	function X(e, t) {
+		let n = t.pendingInvoke;
+		if (!n || o.has(n.childInstanceId) || !n.childPersistenceKey) return;
+		let i = a.get(n.childJourneyId);
+		if (!i) return;
+		let c = i.options?.persistence;
+		if (!c) return;
+		let d = l(n.childJourneyId, n.childPersistenceKey);
+		if (s.has(d)) return;
+		let f = Z(i, c, n.childPersistenceKey), p = (t) => {
+			if (!t || t.status !== "active" || o.has(n.childInstanceId) || s.has(d) || e.activeChildId !== n.childInstanceId) return;
+			let a = Q(i, t);
+			if (!a.ok) return;
+			let c = K(i, n.childInstanceId, n.childPersistenceKey, a.blob.state);
+			o.set(n.childInstanceId, c), s.set(d, n.childInstanceId);
+			try {
+				J(c, a.blob);
+			} catch (e) {
+				r && console.error("[@modular-react/journeys] auto-rehydrate child failed", e), o.delete(n.childInstanceId), s.delete(d);
+				return;
+			}
+			X(c, a.blob), Y(), u(c), u(e);
+		};
+		if (f && typeof f.then == "function") {
+			f.then((e) => p(e), (e) => {
+				r && console.error("[@modular-react/journeys] auto-rehydrate child persistence.load rejected", e);
+			});
+			return;
+		}
+		p(f);
+	}
+	function Z(e, t, n) {
+		let i;
+		try {
+			i = t.load(n);
+		} catch (e) {
+			return r && console.error("[@modular-react/journeys] persistence.load threw", e), null;
+		}
+		return i && i.then, i;
+	}
+	function Q(e, t) {
+		let n = t, i = !1;
+		if (e.definition.onHydrate) {
+			i = !0;
+			try {
+				n = e.definition.onHydrate(n);
+			} catch (e) {
+				return r && console.error("[@modular-react/journeys] onHydrate (definition) threw", e), {
+					ok: !1,
+					reason: "on-hydrate-threw",
+					cause: e
+				};
+			}
+		}
+		let a = e.options?.onHydrate;
+		if (a) {
+			i = !0;
+			try {
+				n = a(n);
+			} catch (e) {
+				return r && console.error("[@modular-react/journeys] onHydrate (registration) threw", e), {
+					ok: !1,
+					reason: "on-hydrate-threw",
+					cause: e
+				};
+			}
+		}
+		return i ? {
+			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, i = m(typeof e == "string" ? e : e.id), a = i.options?.persistence;
+			if (a) {
+				let e = a.keyFor({
+					journeyId: i.definition.id,
+					input: n
+				}), t = l(i.definition.id, e), c = s.get(t), d = c ? o.get(c) : null;
+				if (d && (d.status === "active" || d.status === "loading")) return d.id;
+				let p = i.definition, m = Z(i, a, e);
+				if (m && typeof m.then == "function") {
+					let c = f(), l = K(i, c, e, p.initialState(n));
+					return o.set(c, l), s.set(t, c), u(l), m.then((t) => {
+						if (l.status !== "loading") return;
+						if (!t || t.status !== "active") {
+							t && T(a, e), q(i, n, l);
+							return;
+						}
+						let o = Q(i, t);
+						if (!o.ok) {
+							T(a, e), q(i, n, l);
+							return;
+						}
+						try {
+							J(l, o.blob);
+						} catch (t) {
+							r && console.error("[@modular-react/journeys] hydrate after async load failed", t), T(a, e), q(i, n, l);
+							return;
+						}
+						X(l, o.blob), Y(), u(l);
+					}, (e) => {
+						r && console.error("[@modular-react/journeys] persistence.load rejected", e), l.status === "loading" && q(i, n, l);
+					}), c;
+				}
+				let h = m;
+				if (h && h.status === "active") {
+					let c = Q(i, h);
+					if (c.ok) {
+						let l = c.blob.instanceId && !o.has(c.blob.instanceId) ? c.blob.instanceId : f(), d = K(i, l, e, p.initialState(n));
+						o.set(l, d), s.set(t, l);
+						try {
+							J(d, c.blob);
+						} catch (c) {
+							r && console.error("[@modular-react/journeys] hydrate during start failed", c), o.delete(l), s.delete(t), T(a, e);
+							let u = f(), d = K(i, u, e, p.initialState(n));
+							return o.set(u, d), s.set(t, u), q(i, n, d);
+						}
+						return X(d, c.blob), Y(), u(d), l;
+					}
+					T(a, e);
+				} else h && T(a, e);
+				let g = f(), _ = K(i, g, e, p.initialState(n));
+				return o.set(g, _), s.set(t, g), q(i, n, _);
+			}
+			return q(i, n);
+		},
+		hydrate(e, t) {
+			let n = m(e), r = Q(n, t);
+			if (!r.ok) throw r.reason === "on-hydrate-threw" ? new C(`onHydrate threw while migrating blob for "${e}" (blob=${t.version} def=${n.definition.version}).`, { cause: r.cause }) : new C(`Hydrate version mismatch for "${e}": blob=${t.version} def=${n.definition.version}. Provide onHydrate to migrate.`);
+			let i = r.blob.instanceId || f();
+			if (o.has(i)) throw new C(`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);
+			o.set(i, a);
+			try {
+				J(a, r.blob);
+			} catch (e) {
+				throw o.delete(i), e;
+			}
+			return X(a, r.blob), Y(), u(a), i;
+		},
+		getInstance(e) {
+			let t = o.get(e);
+			return t ? te(t) : null;
+		},
+		listInstances() {
+			return [...o.keys()];
+		},
+		listDefinitions() {
+			return [...a.values()].map(p);
+		},
+		isRegistered(e) {
+			return a.has(e);
+		},
+		subscribe(e, t) {
+			let n = o.get(e);
+			return n ? (n.listeners.add(t), () => {
+				n.listeners.delete(t);
+			}) : () => {};
+		},
+		end(e, t) {
+			let n = o.get(e);
+			if (!n || n.status === "completed" || n.status === "aborted") return;
+			let i = a.get(n.journeyId);
+			if (!i) return;
+			if (n.activeChildId) {
+				let e = n.activeChildId;
+				n.activeChildId = null;
+				let r = o.get(e);
+				r && r.parent && r.parent.instanceId === n.id && (r.parent = null), c.delete(e), $.end(e, {
+					reason: "parent-ended",
+					parentId: n.id,
+					cause: t
+				});
+			}
+			if (n.status === "loading") {
+				H(n, i, { abort: t ?? "abandoned" }, null);
+				return;
+			}
+			let s = { abort: t ?? "abandoned" }, l = i.options?.onAbandon ?? i.definition.onAbandon;
+			if (l) try {
+				s = l({
+					journeyId: n.journeyId,
+					instanceId: n.id,
+					step: n.step,
+					state: n.state,
+					reason: t ?? "abandoned"
+				});
+			} catch (e) {
+				r && console.error("[@modular-react/journeys] onAbandon threw", e), P(i, n, e, n.step, "abandon"), s = { abort: {
+					reason: t ?? "abandoned",
+					cause: "onAbandon-threw",
+					error: e
+				} };
+			}
+			H(n, i, s, null);
+		},
+		forget(e) {
+			let t = o.get(e);
+			if (t && !(t.status !== "completed" && t.status !== "aborted")) {
+				if (t.persistenceKey && s.delete(l(t.journeyId, t.persistenceKey)), c.delete(e), t.activeChildId) {
+					let e = o.get(t.activeChildId);
+					e && e.parent && e.parent.instanceId === t.id && (e.parent = null, u(e)), c.delete(t.activeChildId), t.activeChildId = null;
+				}
+				t.listeners.clear(), o.delete(e);
+			}
+		},
+		forgetTerminal() {
+			let e = 0;
+			for (let [t, n] of o) if (n.status === "completed" || n.status === "aborted") {
+				if (n.persistenceKey && s.delete(l(n.journeyId, n.persistenceKey)), c.delete(t), n.activeChildId) {
+					let e = o.get(n.activeChildId);
+					e && e.parent && e.parent.instanceId === n.id && (e.parent = null, u(e)), c.delete(n.activeChildId);
+				}
+				n.listeners.clear(), o.delete(t), e += 1;
+			}
+			return e;
+		}
+	};
+	function ne(e, t, n) {
+		let r = o.get(e);
+		if (!r) return;
+		let i = a.get(r.journeyId);
+		i && P(i, r, t, n, "step");
+	}
+	let re = {
+		__bindStepCallbacks: ee,
+		__getRecord: (e) => o.get(e),
+		__getRegistered: (e) => a.get(e),
+		__moduleMap: i,
+		__debug: r,
+		__fireComponentError: ne,
+		__synthesizeCompletion: (e, t) => {
+			let n = o.get(e);
+			if (!n) return;
+			let r = a.get(n.journeyId);
+			r && H(n, r, { complete: t }, null);
+		},
+		__synthesizeAbort: (e, t) => {
+			let n = o.get(e);
+			if (!n) return;
+			let r = a.get(n.journeyId);
+			r && H(n, r, { abort: t }, null);
+		},
+		__consumeRetry: (e, t) => {
+			let n = o.get(e);
+			return !n || n.retryCount >= t ? !1 : (n.retryCount += 1, !0);
+		}
+	};
+	return N.set($, re), $;
+}
+function F(e) {
+	let t = N.get(e);
+	if (!t) throw Error("[@modular-react/journeys] getInternals() called on a runtime that was not produced by createJourneyRuntime().");
+	return t;
+}
+//#endregion
+export { w as a, E as c, o as d, S as i, n as l, F as n, T as o, C as r, A as s, P as t, c as u };
+
+//# sourceMappingURL=runtime-BUVl0_Ad.js.map