@raphy-js/raph 1.0.0-dev.2 → 1.0.1-dev.25

package/dist/core-CClhT8WR.js

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