@raphy-js/raph 1.0.0-dev.18

package/dist/core-CyilRD7s.js

@@ -0,0 +1,1055 @@
+const Z = /* @__PURE__ */ new WeakMap(), mt = 16384;
+function Jt(t) {
+  var j;
+  if ($t(t.id, t.version), typeof t.states != "object" || t.states === null || Array.isArray(t.states))
+    throw new TypeError("[Raph machine] states must be an object.");
+  const e = t, n = [], r = /* @__PURE__ */ new Map(), i = [];
+  for (const [h, b] of Object.entries(e.states))
+    i.push(ct(h, b, void 0, 0, n, r));
+  const o = r.get(t.initial);
+  if (o === void 0 || ((j = n[o]) == null ? void 0 : j.parent) !== void 0)
+    throw new Error(`[Raph machine] Initial state "${t.initial}" must be a root state key.`);
+  const s = /* @__PURE__ */ new Set(), a = n.map((h) => {
+    const b = h.initialKey === void 0 ? void 0 : h.children.find((z) => {
+      var l;
+      return ((l = n[z]) == null ? void 0 : l.key) === h.initialKey;
+    });
+    if (h.kind === "compound" && b === void 0)
+      throw new Error(`[Raph machine] Compound state "${h.path}" requires a valid direct initial child.`);
+    if (b !== void 0 && n[b].kind === "history")
+      throw new Error(`[Raph machine] Compound state "${h.path}" cannot use history as its initial child.`);
+    const E = h.historyFallbackPath === void 0 ? void 0 : r.get(h.historyFallbackPath);
+    if (h.historyFallbackPath !== void 0 && E === void 0)
+      throw new Error(
+        `[Raph machine] History state "${h.path}" has unknown fallback "${h.historyFallbackPath}".`
+      );
+    for (const z of h.on.keys())
+      s.add(z);
+    return {
+      after: h.after,
+      always: h.always,
+      children: Object.freeze([...h.children]),
+      depth: h.depth,
+      entry: h.entry,
+      exit: h.exit,
+      history: h.history,
+      ...E === void 0 ? {} : { historyFallback: E },
+      id: h.id,
+      ...b === void 0 ? {} : { initial: b },
+      invokes: h.invokes,
+      key: h.key,
+      kind: h.kind,
+      ...h.meta === void 0 ? {} : { meta: h.meta },
+      on: h.on,
+      onDone: h.onDone,
+      ...h.output === void 0 ? {} : { output: h.output },
+      ...h.parent === void 0 ? {} : { parent: h.parent },
+      path: h.path,
+      resources: h.resources,
+      tags: h.tags
+    };
+  });
+  for (const h of a)
+    zt(h, r, a);
+  const c = t.version ?? 1;
+  kt(a);
+  const u = Object.freeze([...s]), f = new Map(u.map((h, b) => [h, b])), d = Object.freeze(a.map((h) => Object.freeze(Et(a, h.id)))), p = xt(a), v = p && u.length <= Math.floor(
+    mt / a.length
+  ) ? jt(a, f, u.length) : void 0, w = Object.freeze({
+    ancestry: d,
+    context: It(e.context),
+    eventIndexes: f,
+    eventTypes: u,
+    flat: p,
+    ...v === void 0 ? {} : { flatDispatch: v },
+    id: t.id,
+    initial: o,
+    migrations: At(t.migrations, c),
+    ...e.output === void 0 ? {} : { output: e.output },
+    pathToState: r,
+    rootChildren: Object.freeze(i),
+    states: Object.freeze(a),
+    version: c
+  }), m = Object.freeze({ id: t.id, version: c });
+  return Z.set(m, w), m;
+}
+function jt(t, e, n) {
+  const r = Array.from({ length: t.length * n }).fill(void 0);
+  for (const i of t) {
+    const o = i.id * n;
+    for (const [s, a] of i.on)
+      r[o + e.get(s)] = a;
+  }
+  return Object.freeze(r);
+}
+function Et(t, e) {
+  const n = [];
+  for (let r = e; r !== void 0; r = t[r].parent)
+    n.push(r);
+  return n;
+}
+function xt(t) {
+  return t.every((e) => {
+    if (e.parent !== void 0 || e.kind !== "atomic" && e.kind !== "final" || e.always.length !== 0 || e.onDone.length !== 0 || e.after.size !== 0 || e.entry.length !== 0 || e.exit.length !== 0 || e.resources.length !== 0 || e.invokes.length !== 0)
+      return !1;
+    for (const n of e.on.values())
+      if (n.some((r) => r.raise !== void 0))
+        return !1;
+    return !0;
+  });
+}
+function F(t) {
+  const e = Z.get(t);
+  if (e === void 0)
+    throw new TypeError("[Raph machine] Model was not created by defineMachine().");
+  return e;
+}
+function ct(t, e, n, r, i, o) {
+  if (typeof e != "object" || e === null || Array.isArray(e))
+    throw new TypeError(`[Raph machine] State "${t}" must be an object.`);
+  Tt(e, t), Mt(t);
+  const s = n === void 0 ? "" : i[n].path, a = s ? `${s}.${t}` : t, c = i.length;
+  if (o.has(a))
+    throw new Error(`[Raph machine] Duplicate state path "${a}".`);
+  const u = gt(e), f = {
+    after: /* @__PURE__ */ new Map(),
+    always: Object.freeze([]),
+    children: [],
+    depth: r,
+    entry: P(e.entry),
+    exit: P(e.exit),
+    history: e.history ?? "shallow",
+    ...e.target === void 0 ? {} : { historyFallbackPath: e.target },
+    id: c,
+    ...e.initial === void 0 ? {} : { initialKey: e.initial },
+    invokes: Object.freeze([]),
+    key: t,
+    kind: u,
+    ...e.meta === void 0 ? {} : { meta: Object.freeze({ ...e.meta }) },
+    on: /* @__PURE__ */ new Map(),
+    onDone: Object.freeze([]),
+    ...e.output === void 0 ? {} : { output: e.output },
+    ...n === void 0 ? {} : { parent: n },
+    path: a,
+    resources: ot(e.resources),
+    tags: ot(e.tags)
+  };
+  i.push(f), o.set(a, c);
+  for (const [v, w] of Object.entries(e.states ?? {}))
+    f.children.push(ct(v, w, c, r + 1, i, o));
+  let d = 0;
+  for (const [v, w] of Object.entries(e.on ?? {})) {
+    if (!v.trim())
+      throw new Error(`[Raph machine] State "${a}" has an empty event type.`);
+    f.on.set(v, M(w, c, () => d++));
+  }
+  f.always = M(e.always, c, () => d++), f.onDone = M(e.onDone, c, () => d++);
+  for (const [v, w] of Object.entries(e.after ?? {})) {
+    if (!v.trim())
+      throw new Error(`[Raph machine] State "${a}" has an empty delay key.`);
+    f.after.set(v, M(w, c, () => d++));
+  }
+  const p = Pt(e.invoke);
+  return f.invokes = Object.freeze(p.map((v, w) => St(
+    v,
+    f,
+    w,
+    () => d++
+  ))), Rt(f, i), c;
+}
+function St(t, e, n, r) {
+  if (typeof t != "object" || t === null || Array.isArray(t))
+    throw new TypeError(`[Raph machine] Invoke in "${e.path}" must be an object.`);
+  const i = typeof t.src == "string" ? "task" : "machine", o = t.type ?? i, s = t.id ?? `${e.path}:invoke#${n + 1}`;
+  if (!s.trim())
+    throw new Error(`[Raph machine] Invoke id in "${e.path}" must not be empty.`);
+  if (o !== "machine" && o !== "task")
+    throw new Error(`[Raph machine] Invoke "${s}" has unsupported type "${String(o)}".`);
+  if (typeof t.src == "string") {
+    if (!t.src.trim())
+      throw new Error(`[Raph machine] Invoke "${s}" source must not be empty.`);
+  } else if (!Z.has(t.src))
+    throw new TypeError(`[Raph machine] Invoke "${s}" actor source must come from defineMachine().`);
+  if (o === "task" && typeof t.src != "string")
+    throw new TypeError(`[Raph machine] Task invoke "${s}" requires a string source.`);
+  return Object.freeze({
+    id: s,
+    ...t.input === void 0 ? {} : { input: t.input },
+    onDone: M(t.onDone, e.id, r),
+    onError: M(t.onError, e.id, r),
+    src: t.src,
+    type: o
+  });
+}
+function M(t, e, n) {
+  if (t === void 0)
+    return Object.freeze([]);
+  const r = Array.isArray(t) ? t : [t];
+  return Object.freeze(r.map((i) => {
+    const o = typeof i == "string" ? { target: i } : i;
+    if (o === null || typeof o != "object")
+      throw new TypeError("[Raph machine] Transition must be a target string or object.");
+    if (o.reenter === !0 && o.target === void 0)
+      throw new Error("[Raph machine] A targetless transition cannot declare reenter: true.");
+    if (o.reason !== void 0 && (typeof o.reason != "string" || !o.reason.trim()))
+      throw new Error("[Raph machine] Transition reason must be a non-empty string.");
+    return W(o.guard === void 0 ? [] : [o.guard], "guard"), W(P(o.reduce), "reducer"), W(P(o.emit), "output"), {
+      emit: P(o.emit),
+      ...o.guard === void 0 ? {} : { guard: o.guard },
+      index: n(),
+      ...o.raise === void 0 ? {} : { raise: o.raise },
+      ...o.reason === void 0 ? {} : { reason: o.reason },
+      reduce: P(o.reduce),
+      reenter: o.reenter === !0,
+      source: e,
+      ...o.target === void 0 ? {} : { target: o.target }
+    };
+  }));
+}
+function zt(t, e, n) {
+  var i;
+  const r = [t.always, t.onDone, ...t.on.values(), ...t.after.values()];
+  for (const o of t.invokes)
+    r.push(o.onDone, o.onError);
+  for (const o of r)
+    for (const s of o) {
+      if (s.target !== void 0) {
+        const a = s.target, c = e.get(a);
+        if (c === void 0)
+          throw new Error(
+            `[Raph machine] Transition from "${t.path}" targets unknown state "${a}".`
+          );
+        s.target = c;
+      }
+      Object.freeze(s);
+    }
+  if (t.kind === "history" && t.historyFallback !== void 0) {
+    const o = (i = [...e].find(([, a]) => a === t.historyFallback)) == null ? void 0 : i[0], s = t.path.slice(0, t.path.lastIndexOf("."));
+    if (o === void 0 || o === t.path || t.historyFallback === void 0 || !o.startsWith(`${s}.`))
+      throw new Error(
+        `[Raph machine] History fallback for "${t.path}" must stay inside its parent state.`
+      );
+    if (n[t.historyFallback].kind === "history")
+      throw new Error(`[Raph machine] History fallback for "${t.path}" cannot target another history state.`);
+  }
+}
+function gt(t) {
+  if (t.type !== void 0) {
+    if (t.type !== "atomic" && t.type !== "compound" && t.type !== "final" && t.type !== "history" && t.type !== "parallel")
+      throw new TypeError(`[Raph machine] Unsupported state type "${String(t.type)}".`);
+    return t.type;
+  }
+  return t.states === void 0 ? "atomic" : "compound";
+}
+function Rt(t, e) {
+  if ((t.kind === "atomic" || t.kind === "final" || t.kind === "history") && t.children.length !== 0)
+    throw new Error(`[Raph machine] ${t.kind} state "${t.path}" cannot have children.`);
+  if (t.kind === "parallel" && t.initialKey !== void 0)
+    throw new Error(`[Raph machine] Parallel state "${t.path}" cannot declare initial.`);
+  if (t.kind === "parallel" && !t.children.some((n) => e[n].kind !== "history"))
+    throw new Error(`[Raph machine] Parallel state "${t.path}" requires at least one region.`);
+  if (t.kind === "history" && t.parent === void 0)
+    throw new Error(`[Raph machine] History state "${t.path}" must have a parent.`);
+  if (t.kind !== "history" && t.historyFallbackPath !== void 0)
+    throw new Error("[Raph machine] Only a history state may declare target as fallback.");
+  if ((t.kind === "atomic" || t.kind === "final" || t.kind === "history") && t.initialKey !== void 0)
+    throw new Error(`[Raph machine] ${t.kind} state "${t.path}" cannot declare initial.`);
+  if ((t.kind === "final" || t.kind === "history") && (t.on.size !== 0 || t.always.length !== 0 || t.after.size !== 0 || t.onDone.length !== 0 || t.invokes.length !== 0))
+    throw new Error(`[Raph machine] ${t.kind} state "${t.path}" cannot declare transitions or invokes.`);
+}
+function Tt(t, e) {
+  if (V(t.states, `State "${e}" states`), V(t.on, `State "${e}" on`), V(t.after, `State "${e}" after`), t.history !== void 0 && t.history !== "deep" && t.history !== "shallow")
+    throw new TypeError(`[Raph machine] State "${e}" has unsupported history mode.`);
+}
+function V(t, e) {
+  if (t !== void 0 && (typeof t != "object" || t === null || Array.isArray(t)))
+    throw new TypeError(`[Raph machine] ${e} must be an object.`);
+}
+function $t(t, e) {
+  if (typeof t != "string" || !t.trim())
+    throw new TypeError("[Raph machine] Model id must be a non-empty string.");
+  const n = e ?? 1;
+  if (!Number.isSafeInteger(n) || n < 1)
+    throw new TypeError("[Raph machine] Model version must be a positive safe integer.");
+}
+function kt(t) {
+  const e = /* @__PURE__ */ new Set();
+  for (const n of t)
+    for (const r of n.invokes) {
+      if (e.has(r.id))
+        throw new Error(`[Raph machine] Invoke id "${r.id}" is duplicated.`);
+      e.add(r.id);
+    }
+}
+function At(t, e) {
+  const n = /* @__PURE__ */ new Map();
+  for (const [r, i] of Object.entries(t ?? {})) {
+    const o = Number(r);
+    if (!Number.isSafeInteger(o) || o < 1 || o >= e)
+      throw new Error(`[Raph machine] Migration version "${r}" must be a positive integer below ${e}.`);
+    if (typeof i != "function")
+      throw new TypeError(`[Raph machine] Migration from version ${o} must be a function.`);
+    n.set(o, i);
+  }
+  return n;
+}
+function W(t, e) {
+  for (const n of t)
+    if (typeof n != "function" && (typeof n != "string" || !n.trim()))
+      throw new TypeError(`[Raph machine] ${e} reference must be a function or non-empty string.`);
+}
+function Mt(t) {
+  if (!t || t.includes("."))
+    throw new Error("[Raph machine] State keys must be non-empty and cannot contain dots.");
+}
+function P(t) {
+  return Object.freeze(t === void 0 ? [] : Array.isArray(t) ? [...t] : [t]);
+}
+function ot(t) {
+  if (t === void 0)
+    return Object.freeze([]);
+  const e = typeof t == "string" ? [t] : [...t];
+  for (const n of e)
+    if (typeof n != "string" || !n.trim())
+      throw new TypeError("[Raph machine] Tags and resource names must be non-empty strings.");
+  return Object.freeze(e);
+}
+function Pt(t) {
+  return t === void 0 ? [] : Array.isArray(t) ? t : [t];
+}
+function It(t) {
+  return Array.isArray(t) ? Object.freeze([...t]) : typeof t == "object" && t !== null && Object.getPrototypeOf(t) === Object.prototype ? Object.freeze({ ...t }) : t;
+}
+const T = Symbol("RaphMachineSnapshot"), it = /* @__PURE__ */ new WeakMap();
+function ft(t) {
+  const e = Object.getPrototypeOf(t);
+  return e !== null && Object.hasOwn(e, T) ? e : void 0;
+}
+function ut(t) {
+  return t[T];
+}
+function L(t, e, n) {
+  const r = n ?? Object.freeze({ [T]: e }), i = Object.create(r);
+  return i.active = t.active, i.context = t.context, i.history = t.history, t.output !== void 0 && (i.output = t.output), i.revision = t.revision, i.status = t.status, Object.freeze(i);
+}
+function J(t, e, n, r, i) {
+  let o = t == null ? void 0 : t.flatPrototypes;
+  o === void 0 && (n === void 0 ? (o = it.get(r), o === void 0 && (o = [], it.set(r, o))) : o = []);
+  const s = o[e];
+  if (s !== void 0)
+    return s;
+  const a = Object.freeze({
+    [T]: Object.freeze({
+      active: Object.freeze([e]),
+      flatPrototypes: o,
+      input: n,
+      model: r,
+      publicActive: Object.freeze([i])
+    })
+  });
+  return o[e] = a, a;
+}
+const Dt = 100, G = Object.freeze({ type: "@@init" }), ht = Object.freeze([]), q = Object.freeze({}), K = Object.freeze([]), D = Object.freeze([]), Ft = Object.freeze([]), Q = Object.freeze({
+  entered: K,
+  entryOutputs: D,
+  event: G,
+  exited: K,
+  exitOutputs: D,
+  transitionOutputs: D
+});
+function Qt(t, e) {
+  return _t(t, e, void 0).snapshot;
+}
+function te(t, e, n, r, i) {
+  const o = ut(e);
+  if (o !== void 0 && o.model !== t)
+    throw new TypeError("[Raph machine] Snapshot belongs to another model.");
+  const s = F(t);
+  return tt(
+    t,
+    e,
+    n,
+    r,
+    o == null ? void 0 : o.input,
+    i,
+    s
+  ).snapshot;
+}
+function Ct(t, e) {
+  var n;
+  if (((n = ft(e)) == null ? void 0 : n[T].model) !== t)
+    throw new TypeError("[Raph machine] Snapshot belongs to another model or was not created by Raph.");
+}
+function ee(t, e) {
+  if (Ct(
+    t,
+    e
+  ), e.status === "stopped")
+    return e;
+  const n = ft(e);
+  return L({
+    active: e.active,
+    context: e.context,
+    history: e.history,
+    ...e.output === void 0 ? {} : { output: e.output },
+    revision: e.revision + 1,
+    status: "stopped"
+  }, n[T], n);
+}
+function _t(t, e, n, r) {
+  const i = F(t), o = i.context, s = typeof o == "function" ? o(e) : o;
+  if (i.flat) {
+    const u = i.states[i.initial], f = u.kind === "final" ? "done" : "active", d = f === "done" ? u.output ?? i.output : void 0, p = typeof d == "function" ? d({ context: s, event: G, input: e }) : d, v = J(
+      void 0,
+      i.initial,
+      e,
+      t,
+      u.path
+    ), w = v[T], m = L({
+      active: w.publicActive,
+      context: rt(s),
+      history: q,
+      ...p === void 0 ? {} : { output: p },
+      revision: 0,
+      status: f
+    }, w, v);
+    return { changed: !1, plan: Q, snapshot: m };
+  }
+  const a = $(i, i.initial, q), c = C(t, e, {
+    active: a,
+    context: s,
+    history: q
+  }, 0, "active", void 0, i);
+  return tt(t, c, G, n, e, r, i, !0);
+}
+function tt(t, e, n, r, i, o, s, a = !1, c = ht) {
+  return Ot(n), Nt(
+    t,
+    e,
+    n,
+    r,
+    i,
+    o,
+    s,
+    void 0,
+    a,
+    c
+  );
+}
+function Nt(t, e, n, r, i, o, s, a, c = !1, u = ht) {
+  const f = s ?? F(t);
+  if (e.status !== "active")
+    return I(e);
+  if (!c && f.flat) {
+    const y = a ?? f.eventIndexes.get(n.type);
+    return y === void 0 ? I(e) : Ht(t, f, e, n, y, r, i, o);
+  }
+  if (!c && !Gt(f, e.active, n.type))
+    return I(e);
+  const d = {
+    active: e.active.map((y) => N(f, y)),
+    context: e.context,
+    history: { ...e.history }
+  }, p = r, v = /* @__PURE__ */ new Set(), w = /* @__PURE__ */ new Set(), m = [], j = [], h = [], b = [...u];
+  let E = !1;
+  if (!c) {
+    const y = st(f, d, n, p, i, o);
+    at(y, v, w, m, j, h), E = y.changed, b.push(...y.raised);
+  }
+  const z = /* @__PURE__ */ new Set();
+  let l = 0;
+  for (; ; ) {
+    const y = b.shift();
+    let x;
+    if (y !== void 0 ? x = st(f, d, y, p, i, o) : (x = Kt(f, d, n, p, i, o), x.changed || (x = Lt(
+      f,
+      d,
+      n,
+      p,
+      i,
+      z,
+      o
+    ))), !x.changed) {
+      if (b.length !== 0)
+        continue;
+      break;
+    }
+    if (++l > Dt)
+      throw new Error("[Raph machine] Macrostep exceeded 100 stabilization microsteps.");
+    for (const U of x.exited)
+      z.delete(U);
+    for (const U of x.entered)
+      z.delete(U);
+    E = !0, at(x, v, w, m, j, h), b.push(...x.raised);
+  }
+  const O = nt(f, d.active) ? "done" : "active";
+  if (!E && O === e.status)
+    return I(e);
+  const k = O === "done" ? yt(f, d, n, i) : void 0, g = C(
+    t,
+    i,
+    d,
+    e.revision + 1,
+    O,
+    k,
+    f
+  ), R = new Set(_(f, d.active));
+  return Object.freeze({
+    changed: !0,
+    plan: Object.freeze({
+      entered: Object.freeze([...w].filter((y) => R.has(y)).sort((y, x) => f.states[y].depth - f.states[x].depth)),
+      entryOutputs: Object.freeze(h),
+      event: n,
+      exited: Object.freeze([...v].sort((y, x) => f.states[x].depth - f.states[y].depth)),
+      exitOutputs: Object.freeze(m),
+      transitionOutputs: Object.freeze(j)
+    }),
+    snapshot: g
+  });
+}
+function Ht(t, e, n, r, i, o, s, a) {
+  const c = ut(n), u = (c == null ? void 0 : c.active[0]) ?? N(e, n.active[0]), f = e.flatDispatch === void 0 ? e.states[u].on.get(r.type) : e.flatDispatch[u * e.eventTypes.length + i], d = H(
+    f ?? Ft,
+    n.context,
+    r,
+    o,
+    s,
+    a
+  );
+  if (d === void 0)
+    return I(n);
+  dt(e, d, a);
+  let p = n.context;
+  for (const z of d.reduce)
+    p = vt(
+      z,
+      o
+    )({ context: p, event: r, input: s });
+  const v = d.target ?? u, w = e.states[v], m = w.kind === "final" ? "done" : "active", j = m === "done" ? w.output ?? e.output : void 0, h = typeof j == "function" ? j({ context: p, event: r, input: s }) : j, b = J(c, v, s, t, w.path), E = L({
+    active: v === u ? n.active : b[T].publicActive,
+    context: p === n.context ? n.context : rt(p),
+    history: n.history,
+    ...h === void 0 ? {} : { output: h },
+    revision: n.revision + 1,
+    status: m
+  }, b[T], b);
+  return {
+    changed: !0,
+    plan: d.emit.length === 0 ? Q : {
+      entered: K,
+      entryOutputs: D,
+      event: r,
+      exited: K,
+      exitOutputs: D,
+      transitionOutputRefs: d.emit,
+      transitionOutputs: D
+    },
+    snapshot: E
+  };
+}
+function ne(t, e, n, r, i, o, s) {
+  const a = F(t), c = H(
+    r,
+    e.context,
+    n,
+    i,
+    o,
+    s
+  );
+  if (c === void 0)
+    return I(e);
+  const u = {
+    active: e.active.map((b) => N(a, b)),
+    context: e.context,
+    history: { ...e.history }
+  }, f = Y(
+    a,
+    u,
+    [c],
+    n,
+    i,
+    o,
+    s
+  ), d = C(
+    t,
+    o,
+    u,
+    e.revision,
+    "active",
+    void 0,
+    a
+  ), p = tt(
+    t,
+    d,
+    n,
+    i,
+    o,
+    s,
+    a,
+    !0,
+    f.raised
+  ), v = p.changed ? {
+    active: p.snapshot.active.map((b) => N(a, b)),
+    context: p.snapshot.context,
+    history: { ...p.snapshot.history }
+  } : u, w = p.changed ? p.snapshot.status : nt(a, v.active) ? "done" : "active", m = w === "done" ? p.snapshot.output ?? yt(a, v, n, o) : void 0, j = C(
+    t,
+    o,
+    v,
+    e.revision + 1,
+    w,
+    m,
+    a
+  ), h = new Set(_(a, v.active));
+  return Object.freeze({
+    changed: !0,
+    plan: Object.freeze({
+      entered: Object.freeze(A([...f.entered, ...p.plan.entered]).filter((b) => h.has(b)).sort((b, E) => a.states[b].depth - a.states[E].depth)),
+      entryOutputs: Object.freeze([...f.entryOutputs, ...p.plan.entryOutputs]),
+      event: n,
+      exited: Object.freeze(A([...f.exited, ...p.plan.exited]).sort((b, E) => a.states[E].depth - a.states[b].depth)),
+      exitOutputs: Object.freeze([...f.exitOutputs, ...p.plan.exitOutputs]),
+      transitionOutputs: Object.freeze([
+        ...f.transitionOutputs,
+        ...p.plan.transitionOutputs
+      ])
+    }),
+    snapshot: j
+  });
+}
+function re(t, e, n) {
+  const r = F(t);
+  if (e.status !== "active" && e.status !== "done" && e.status !== "stopped")
+    throw new Error(`[Raph machine] Unknown persisted status "${String(e.status)}".`);
+  if (!Number.isSafeInteger(e.revision) || e.revision < 0)
+    throw new Error("[Raph machine] Persisted revision must be a non-negative safe integer.");
+  const i = e.active.map((o) => N(r, o));
+  return qt(r, i, e.history, e.status), C(
+    t,
+    n,
+    {
+      active: A(i),
+      context: e.context,
+      history: { ...e.history }
+    },
+    e.revision,
+    e.status,
+    e.output,
+    r
+  );
+}
+function qt(t, e, n, r) {
+  if (e.length === 0 || new Set(e).size !== e.length)
+    throw new Error("[Raph machine] Persisted active configuration must contain unique leaf states.");
+  for (const s of e) {
+    const a = t.states[s].kind;
+    if (a !== "atomic" && a !== "final")
+      throw new Error(`[Raph machine] Persisted active state "${t.states[s].path}" is not a leaf.`);
+  }
+  if (new Set(e.map((s) => B(t, s))).size !== 1)
+    throw new Error("[Raph machine] Persisted configuration spans multiple root states.");
+  for (const s of t.states) {
+    if (s.kind !== "compound" && s.kind !== "parallel")
+      continue;
+    const a = s.children.filter((u) => t.states[u].kind !== "history" && e.some((f) => f === u || S(t, u, f)));
+    if (e.some((u) => S(t, s.id, u))) {
+      if (s.kind === "compound" && a.length !== 1)
+        throw new Error(`[Raph machine] Compound state "${s.path}" requires one active child.`);
+      if (s.kind === "parallel" && a.length !== s.children.filter((u) => t.states[u].kind !== "history").length)
+        throw new Error(`[Raph machine] Parallel state "${s.path}" requires every region.`);
+    }
+  }
+  const o = nt(t, e);
+  if (r === "done" && !o)
+    throw new Error("[Raph machine] Done persisted snapshot is not in a final configuration.");
+  if (r === "active" && o)
+    throw new Error("[Raph machine] Active persisted snapshot is already final.");
+  for (const [s, a] of Object.entries(n)) {
+    const c = t.pathToState.get(s);
+    if (c === void 0)
+      throw new Error(`[Raph machine] Persisted history has unknown owner "${s}".`);
+    const u = t.states[c];
+    if (u.kind !== "compound" && u.kind !== "parallel")
+      throw new Error(`[Raph machine] Persisted history owner "${s}" cannot own history.`);
+    if (!Array.isArray(a))
+      throw new TypeError(`[Raph machine] Persisted history for "${s}" must be an array.`);
+    for (const f of a) {
+      const d = t.pathToState.get(f);
+      if (d === void 0 || !S(t, c, d))
+        throw new Error(`[Raph machine] Persisted history path "${f}" is invalid for "${s}".`);
+    }
+  }
+}
+function st(t, e, n, r, i, o) {
+  const s = [], a = /* @__PURE__ */ new Set(), c = [...e.active].sort((u, f) => t.states[f].depth - t.states[u].depth || u - f);
+  for (const u of c)
+    for (let f = u; f !== void 0 && !a.has(f); f = t.states[f].parent) {
+      const d = t.states[f].on.get(n.type);
+      if (d === void 0)
+        continue;
+      const p = H(d, e.context, n, r, i, o);
+      if (p !== void 0) {
+        a.add(f), s.push(p);
+        break;
+      }
+    }
+  return Y(
+    t,
+    e,
+    pt(t, s),
+    n,
+    r,
+    i,
+    o
+  );
+}
+function Kt(t, e, n, r, i, o) {
+  const s = [], a = /* @__PURE__ */ new Set();
+  for (const c of e.active)
+    for (let u = c; u !== void 0; u = t.states[u].parent) {
+      if (a.has(u))
+        continue;
+      a.add(u);
+      const f = H(
+        t.states[u].always,
+        e.context,
+        n,
+        r,
+        i,
+        o
+      );
+      f !== void 0 && s.push(f);
+    }
+  return Y(
+    t,
+    e,
+    pt(t, s),
+    n,
+    r,
+    i,
+    o
+  );
+}
+function Lt(t, e, n, r, i, o, s) {
+  const a = _(t, e.active).filter((c) => !o.has(c) && et(t, c, e.active)).sort((c, u) => t.states[u].depth - t.states[c].depth);
+  for (const c of a) {
+    o.add(c);
+    const u = H(
+      t.states[c].onDone,
+      e.context,
+      n,
+      r,
+      i,
+      s
+    );
+    if (u !== void 0)
+      return Y(t, e, [u], n, r, i, s);
+  }
+  return wt();
+}
+function Y(t, e, n, r, i, o, s) {
+  var z;
+  if (n.length === 0)
+    return wt();
+  const a = [...e.active], c = new Set(_(t, a)), u = /* @__PURE__ */ new Set(), f = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Set(), p = [], v = [];
+  let w = !1;
+  for (const l of n) {
+    dt(t, l, s);
+    for (const y of l.reduce)
+      e.context = vt(y, i)({
+        context: e.context,
+        event: r,
+        input: o
+      }), w = !0;
+    for (const y of l.emit)
+      p.push({ event: r, ref: y });
+    if (l.emit.length !== 0 && (w = !0), l.raise !== void 0) {
+      const y = typeof l.raise == "function" ? l.raise({ context: e.context, event: r, input: o }) : l.raise;
+      Ot(y), v.push(y), w = !0;
+    }
+    if (l.target === void 0) {
+      w = !0;
+      continue;
+    }
+    const O = l.source, k = l.target;
+    if (O === k && !l.reenter) {
+      w = !0;
+      continue;
+    }
+    const g = X(t, O, k);
+    if (l.reenter) {
+      d.add(g);
+      for (const y of c)
+        (y === g || S(t, g, y)) && u.add(y);
+    }
+    e.active = e.active.filter((y) => y !== g && !S(t, g, y));
+    const R = lt(t, k, e.history);
+    e.active.push(...R), w = !0;
+  }
+  e.active = Bt(
+    t,
+    A(e.active),
+    e.history
+  );
+  const m = new Set(_(t, e.active));
+  for (const l of d)
+    for (const O of m)
+      (O === l || S(t, l, O)) && f.add(O);
+  const j = [...c].filter((l) => !m.has(l) || u.has(l)).sort((l, O) => t.states[O].depth - t.states[l].depth), h = [...m].filter((l) => !c.has(l) || f.has(l)).sort((l, O) => t.states[l].depth - t.states[O].depth);
+  for (const l of j) {
+    const O = t.states[l];
+    if (O.kind === "compound" || O.kind === "parallel") {
+      const k = a.filter((g) => S(t, l, g));
+      if (k.length !== 0) {
+        const g = ((z = O.children.map((R) => t.states[R]).find((R) => R.kind === "history")) == null ? void 0 : z.history) ?? O.history;
+        e.history[O.path] = Object.freeze(k.map((R) => {
+          if (g === "deep")
+            return t.states[R].path;
+          const y = bt(t, l, R);
+          return t.states[y].path;
+        }));
+      }
+    }
+  }
+  const b = j.flatMap((l) => t.states[l].exit.map((O) => ({ event: r, ref: O }))), E = h.flatMap((l) => t.states[l].entry.map((O) => ({ event: r, ref: O })));
+  return Object.freeze({
+    changed: w || j.length !== 0 || h.length !== 0,
+    entered: Object.freeze(h),
+    entryOutputs: Object.freeze(E),
+    exited: Object.freeze(j),
+    exitOutputs: Object.freeze(b),
+    raised: Object.freeze(v),
+    transitionOutputs: Object.freeze(p)
+  });
+}
+function dt(t, e, n) {
+  (n == null ? void 0 : n.transition) !== void 0 && n.transition({
+    ...e.reason === void 0 ? {} : { reason: e.reason },
+    source: t.states[e.source].path,
+    ...e.target === void 0 ? {} : { target: t.states[e.target].path }
+  });
+}
+function H(t, e, n, r, i, o) {
+  var s;
+  for (const a of t) {
+    if (a.guard === void 0)
+      return a;
+    const c = Ut(a.guard, r), u = c({ context: e, event: n, input: i });
+    if ((s = o == null ? void 0 : o.guard) == null || s.call(
+      o,
+      typeof a.guard == "string" ? a.guard : c.name || "inline",
+      u,
+      Zt(e) ? e : void 0
+    ), u)
+      return a;
+  }
+}
+function pt(t, e) {
+  const n = [...e].sort((i, o) => t.states[o.source].depth - t.states[i.source].depth || i.source - o.source || i.index - o.index), r = [];
+  for (const i of n)
+    r.some((s) => Yt(t, i, s)) || r.push(i);
+  return r;
+}
+function Yt(t, e, n) {
+  const r = X(t, e.source, e.target ?? e.source), i = X(t, n.source, n.target ?? n.source);
+  return e.source === n.source || S(t, e.source, n.source) || S(t, n.source, e.source) || r === i || S(t, r, i) || S(t, i, r);
+}
+function X(t, e, n) {
+  if (e === n || S(t, e, n))
+    return e;
+  const r = Vt(t, e, n);
+  return r !== void 0 && t.states[r].kind === "parallel" ? r : r === void 0 ? B(t, e) : bt(t, r, e);
+}
+function lt(t, e, n) {
+  const r = t.states[e];
+  if (r.kind !== "history")
+    return $(t, e, n);
+  const i = r.parent, o = n[t.states[i].path];
+  if (o !== void 0 && o.length !== 0) {
+    const s = [];
+    for (const a of o) {
+      const c = t.pathToState.get(a);
+      c !== void 0 && s.push(...r.history === "deep" ? $(t, c, n) : $(t, c, {}));
+    }
+    if (s.length !== 0)
+      return A(s);
+  }
+  return r.historyFallback !== void 0 ? $(t, r.historyFallback, n) : $(t, i, {});
+}
+function Bt(t, e, n) {
+  const r = [...e];
+  for (let i = 0; i < r.length; i++)
+    for (const o of t.ancestry[r[i]].slice(1)) {
+      const s = t.states[o];
+      if (s.kind === "parallel")
+        for (const a of s.children)
+          t.states[a].kind !== "history" && (r.some((c) => c === a || S(t, a, c)) || r.push(...$(t, a, n)));
+    }
+  return A(r);
+}
+function $(t, e, n) {
+  const r = t.states[e];
+  if (r.kind === "history")
+    return lt(t, e, n);
+  if (r.kind === "atomic" || r.kind === "final")
+    return [e];
+  if (r.kind === "compound")
+    return $(t, r.initial, n);
+  const i = [];
+  for (const o of r.children)
+    t.states[o].kind !== "history" && i.push(...$(t, o, n));
+  return A(i);
+}
+function et(t, e, n) {
+  const r = t.states[e];
+  return r.kind === "final" ? n.includes(e) : r.kind === "compound" ? r.children.some((i) => t.states[i].kind === "final" && n.includes(i)) : r.kind === "parallel" ? r.children.filter((i) => t.states[i].kind !== "history").every((i) => et(t, i, n)) : !1;
+}
+function nt(t, e) {
+  const n = Wt(t, e[0]);
+  return n === void 0 ? !1 : et(t, n, e);
+}
+function yt(t, e, n, r) {
+  const i = B(t, e.active[0]), o = t.states[i], s = o.kind === "compound" ? e.active.find((c) => t.states[c].parent === i && t.states[c].kind === "final") : o.kind === "final" ? i : void 0, a = s === void 0 ? t.output : t.states[s].output ?? t.output;
+  return typeof a == "function" ? a({ context: e.context, event: n, input: r }) : a;
+}
+function Ut(t, e) {
+  var r;
+  if (typeof t == "function")
+    return t;
+  const n = (r = e == null ? void 0 : e.guards) == null ? void 0 : r[t];
+  if (n === void 0)
+    throw new Error(`[Raph machine] Guard binding "${t}" is not defined.`);
+  return n;
+}
+function vt(t, e) {
+  var r;
+  if (typeof t == "function")
+    return t;
+  const n = (r = e == null ? void 0 : e.reducers) == null ? void 0 : r[t];
+  if (n === void 0)
+    throw new Error(`[Raph machine] Reducer binding "${t}" is not defined.`);
+  return n;
+}
+function C(t, e, n, r, i, o, s) {
+  const a = s ?? F(t), c = a.flat && n.active.length === 1 ? n.active[0] : void 0, u = c === void 0 ? void 0 : J(void 0, c, e, t, a.states[c].path), f = u === void 0 ? Object.freeze([...n.active]) : void 0, d = (u == null ? void 0 : u[T]) ?? Object.freeze({
+    active: f,
+    input: e,
+    model: t
+  });
+  return L({
+    active: d.publicActive ?? Object.freeze(f.map((p) => a.states[p].path)),
+    context: rt(n.context),
+    history: a.flat ? q : Xt(n.history),
+    ...o === void 0 ? {} : { output: o },
+    revision: r,
+    status: i
+  }, d, u);
+}
+function I(t, e) {
+  return {
+    changed: !1,
+    plan: Q,
+    snapshot: t
+  };
+}
+function wt() {
+  return Object.freeze({
+    changed: !1,
+    entered: Object.freeze([]),
+    entryOutputs: Object.freeze([]),
+    exited: Object.freeze([]),
+    exitOutputs: Object.freeze([]),
+    raised: Object.freeze([]),
+    transitionOutputs: Object.freeze([])
+  });
+}
+function at(t, e, n, r, i, o) {
+  for (const s of t.exited)
+    e.add(s);
+  for (const s of t.entered)
+    n.add(s);
+  r.push(...t.exitOutputs), i.push(...t.transitionOutputs), o.push(...t.entryOutputs);
+}
+function _(t, e) {
+  const n = /* @__PURE__ */ new Set();
+  for (const r of e)
+    for (const i of t.ancestry[r])
+      n.add(i);
+  return [...n];
+}
+function Vt(t, e, n) {
+  const r = new Set(t.ancestry[e]);
+  for (const i of t.ancestry[n])
+    if (r.has(i))
+      return i;
+}
+function S(t, e, n) {
+  const r = t.ancestry[n];
+  return r.length > 1 && r.includes(e, 1);
+}
+function bt(t, e, n) {
+  let r = n;
+  for (; t.states[r].parent !== e; ) {
+    const i = t.states[r].parent;
+    if (i === void 0)
+      return r;
+    r = i;
+  }
+  return r;
+}
+function B(t, e) {
+  return t.ancestry[e].at(-1);
+}
+function Wt(t, e) {
+  return e === void 0 ? void 0 : B(t, e);
+}
+function N(t, e) {
+  const n = t.pathToState.get(e);
+  if (n === void 0)
+    throw new Error(`[Raph machine] Snapshot contains unknown state "${e}".`);
+  return n;
+}
+function Gt(t, e, n) {
+  if (!t.eventIndexes.has(n))
+    return !1;
+  for (const r of e) {
+    const i = t.pathToState.get(r);
+    if (i !== void 0) {
+      for (const o of t.ancestry[i])
+        if (t.states[o].on.has(n))
+          return !0;
+    }
+  }
+  return !1;
+}
+function A(t) {
+  return [...new Set(t)].sort((e, n) => e - n);
+}
+function rt(t) {
+  return typeof t == "object" && t !== null ? Object.freeze(t) : t;
+}
+function Xt(t) {
+  const e = {};
+  for (const [n, r] of Object.entries(t))
+    e[n] = Object.freeze([...r]);
+  return Object.freeze(e);
+}
+function Ot(t) {
+  if (typeof t != "object" || t === null || typeof t.type != "string" || !t.type)
+    throw new TypeError("[Raph machine] Event must contain a non-empty string type.");
+}
+function Zt(t) {
+  return typeof t == "object" && t !== null && !Array.isArray(t);
+}
+export {
+  Qt as a,
+  Ct as b,
+  _t as c,
+  ne as d,
+  Jt as e,
+  F as g,
+  re as h,
+  Nt as r,
+  ee as s,
+  te as t
+};