@raphy-js/raph 1.0.0-dev.18

package/dist/machine.js

@@ -0,0 +1,837 @@
+import { b as B, g as N, h as L, c as J, r as Q, d as W, s as H } from "./core-CyilRD7s.js";
+import { e as rt, a as st, t as nt } from "./core-CyilRD7s.js";
+import { RaphScope as F } from "./debug/runtime/ownership/RaphScope.js";
+class m extends Error {
+}
+function V(o, t) {
+  return B(
+    o,
+    t
+  ), y(t.context, "context"), t.output !== void 0 && y(t.output, "output"), Object.freeze({
+    active: Object.freeze([...t.active]),
+    context: P(t.context),
+    history: Object.freeze(Object.fromEntries(
+      Object.entries(t.history).map(([e, r]) => [e, Object.freeze([...r])])
+    )),
+    modelId: o.id,
+    ...t.output === void 0 ? {} : { output: P(t.output) },
+    revision: t.revision,
+    status: t.status,
+    version: o.version
+  });
+}
+function G(o, t, e) {
+  const r = N(o);
+  try {
+    if (typeof t != "object" || t === null || Array.isArray(t))
+      throw new m("[Raph machine] Persisted snapshot must be an object.");
+    if (t.modelId !== o.id)
+      throw new m(
+        `[Raph machine] Snapshot model "${t.modelId}" is incompatible with "${o.id}".`
+      );
+    if (!Number.isSafeInteger(t.version) || t.version < 1)
+      throw new m("[Raph machine] Persisted version must be a positive integer.");
+    let i = t;
+    for (; i.version < o.version; ) {
+      const s = r.migrations.get(i.version);
+      if (s === void 0)
+        throw new m(
+          `[Raph machine] Missing migration from version ${i.version} for "${o.id}".`
+        );
+      const n = s(i);
+      if (n.version !== i.version + 1 || n.modelId !== o.id)
+        throw new m(
+          `[Raph machine] Migration from version ${i.version} must produce version ${i.version + 1}.`
+        );
+      i = n;
+    }
+    if (i.version !== o.version)
+      throw new m(
+        `[Raph machine] Snapshot version ${i.version} is newer than model version ${o.version}.`
+      );
+    return y(i.context, "context"), i.output !== void 0 && y(i.output, "output"), L(
+      o,
+      i,
+      e
+    );
+  } catch (i) {
+    throw i instanceof m ? i : new m(
+      `[Raph machine] Persisted snapshot is invalid: ${i instanceof Error ? i.message : String(i)}`
+    );
+  }
+}
+function y(o, t, e = /* @__PURE__ */ new Set()) {
+  if (o === null)
+    return;
+  const r = typeof o;
+  if (r === "string" || r === "boolean")
+    return;
+  if (r === "number") {
+    if (!Number.isFinite(o))
+      throw new m(`[Raph machine] ${t} contains a non-finite number.`);
+    return;
+  }
+  if (r !== "object")
+    throw new m(`[Raph machine] ${t} is not JSON-safe.`);
+  const i = o;
+  if (e.has(i))
+    throw new m(`[Raph machine] ${t} contains a cycle.`);
+  if (e.add(i), Array.isArray(o))
+    o.forEach((s, n) => y(s, `${t}[${n}]`, e));
+  else {
+    const s = Object.getPrototypeOf(o);
+    if (s !== Object.prototype && s !== null)
+      throw new m(`[Raph machine] ${t} contains a non-plain object.`);
+    for (const [n, a] of Object.entries(o))
+      y(a, `${t}.${n}`, e);
+  }
+  e.delete(i);
+}
+function P(o) {
+  return JSON.parse(JSON.stringify(o));
+}
+const k = /* @__PURE__ */ new WeakMap(), S = Symbol("RaphMachineActivationCancelled"), A = Object.freeze({ type: "@@init" }), K = Object.freeze({
+  clearTimeout: (o) => clearTimeout(o),
+  now: () => Date.now(),
+  setTimeout: (o, t) => setTimeout(o, t)
+});
+class E {
+  constructor(t, e, r, i) {
+    if (this.id = void 0, this.model = void 0, this.snapshot = void 0, this._owner = void 0, this._runtime = void 0, this._compiled = void 0, this._bindings = void 0, this._clock = void 0, this._input = void 0, this._errorPolicy = void 0, this._releaseSnapshot = O, this._writeSnapshotInBoundary = void 0, this._currentSnapshot = void 0, this._queue = void 0, this._listeners = void 0, this._stateCleanups = void 0, this._invocations = void 0, this._actors = void 0, this._releaseOwnership = O, this._releaseDebug = O, this._restored = !1, this._initialPlan = void 0, this._onError = void 0, this._queueCursor = 0, this._processing = !1, this._started = !1, this._stopped = !1, this._lastIgnoredSnapshot = void 0, this._lastIgnoredResult = void 0, !(t instanceof F))
+      throw new TypeError("[Raph machine] Machine owner must be a Raph Runtime scope or node.");
+    if (t._assertAlive(), this._owner = t, this._runtime = t.runtime, this._compiled = N(
+      e
+    ), this.model = e, this._bindings = r, this._clock = i.clock ?? K, this._input = i.input, this._errorPolicy = i.errorPolicy ?? "throw", this._errorPolicy !== "ignore" && this._errorPolicy !== "stop" && this._errorPolicy !== "throw")
+      throw new TypeError(`[Raph machine] Unknown error policy "${String(this._errorPolicy)}".`);
+    this._onError = i.onError;
+    const s = (k.get(this._runtime) ?? 0) + 1;
+    if (k.set(this._runtime, s), this.id = i.id ?? `${e.id}#${s}`, !this.id.trim())
+      throw new TypeError("[Raph machine] Instance id must not be empty.");
+    if (this._runtime._hasMachineDebug(this.id))
+      throw new Error(`[Raph] Machine diagnostic id "${this.id}" is already registered.`);
+    const n = i.persisted === void 0 ? this._runtime.untracked(() => J(
+      e,
+      this._input,
+      r,
+      this._runtime._traces("machine") ? this._traceHooks() : void 0
+    )) : void 0, a = (n == null ? void 0 : n.snapshot) ?? G(e, i.persisted, this._input);
+    this._initialPlan = n == null ? void 0 : n.plan, this._restored = i.persisted !== void 0;
+    const c = U(this._runtime, t, a);
+    this._releaseSnapshot = c.dispose, this._writeSnapshotInBoundary = c.writeInBoundary, this._currentSnapshot = a, this.snapshot = c.source;
+    try {
+      this._releaseDebug = this._runtime._registerMachineDebug({
+        id: this.id,
+        ownerId: t.id,
+        ...i.parentId === void 0 ? {} : { parentId: i.parentId },
+        snapshot: () => {
+          var _;
+          const h = this._currentSnapshot, u = Object.fromEntries(this._activeClosure(h).flatMap((f) => {
+            const d = this._compiled.states[f].meta;
+            return d === void 0 ? [] : [[this._compiled.states[f].path, d]];
+          }));
+          return Object.freeze({
+            active: h.active,
+            actors: Object.freeze([...((_ = this._actors) == null ? void 0 : _.keys()) ?? []]),
+            contextKeys: Object.freeze(D(h.context) ? Object.keys(h.context) : []),
+            id: this.id,
+            meta: Object.freeze(u),
+            modelId: e.id,
+            ownerId: t.id,
+            ...i.parentId === void 0 ? {} : { parentId: i.parentId },
+            revision: h.revision,
+            status: h.status
+          });
+        }
+      }), this._releaseOwnership = t.own(() => this._dispose(!1));
+    } catch (h) {
+      const u = [h];
+      try {
+        this._releaseDebug();
+      } catch (_) {
+        u.push(_);
+      }
+      try {
+        this._releaseSnapshot();
+      } catch (_) {
+        u.push(_);
+      }
+      throw u.length > 1 ? new AggregateError(u, `[Raph machine] Machine "${this.id}" construction rollback failed.`) : h;
+    }
+  }
+  get started() {
+    return this._started && !this._stopped;
+  }
+  start() {
+    var s, n;
+    if (this._stopped)
+      throw new Error(`[Raph machine] Machine "${this.id}" is stopped.`);
+    if (this._started)
+      return this;
+    this._owner._assertAlive();
+    const t = this._currentSnapshot;
+    if (t.status === "stopped")
+      throw new Error(`[Raph machine] Persisted machine "${this.id}" is stopped.`);
+    if (this._started = !0, this._compiled.flat)
+      return this;
+    const e = this._activeClosure(t).sort((a, c) => this._compiled.states[a].depth - this._compiled.states[c].depth);
+    let r = !1, i;
+    this._processing = !0;
+    try {
+      const a = [];
+      if (!this._restored) {
+        try {
+          this._runOutputs(
+            ((s = this._initialPlan) == null ? void 0 : s.exitOutputs) ?? [],
+            t,
+            this._runtime._currentTraceCauseId()
+          );
+        } catch (c) {
+          a.push(c);
+        }
+        if (this.started)
+          try {
+            this._runOutputs(
+              ((n = this._initialPlan) == null ? void 0 : n.transitionOutputs) ?? [],
+              t,
+              this._runtime._currentTraceCauseId()
+            );
+          } catch (c) {
+            a.push(c);
+          }
+        if (this.started) {
+          const c = e.flatMap((h) => this._compiled.states[h].entry.map((u) => ({ event: A, ref: u })));
+          try {
+            this._runOutputs(c, t, this._runtime._currentTraceCauseId());
+          } catch (h) {
+            a.push(h);
+          }
+        }
+      }
+      if (this.started && t.status === "active")
+        for (const c of e) {
+          if (!this.started)
+            break;
+          try {
+            this._activateState(c, A, t);
+          } catch (h) {
+            a.push(h);
+          }
+        }
+      g(a, `[Raph machine] Machine "${this.id}" start work failed.`);
+    } catch (a) {
+      try {
+        this._handlePostCommitError(a, "start", this._runtime._currentTraceCauseId());
+      } catch (c) {
+        r = !0, i = c;
+      }
+    } finally {
+      this._processing = !1, r ? (this._queue !== void 0 && (this._queue.length = 0), this._queueCursor = 0) : this._drainQueued();
+    }
+    if (r)
+      throw i;
+    return this;
+  }
+  send(t) {
+    return this._enqueue(t);
+  }
+  sendTo(t, e) {
+    var i;
+    const r = (i = this._actors) == null ? void 0 : i.get(t);
+    if (r === void 0)
+      throw new Error(`[Raph machine] Actor "${t}" is not active in "${this.id}".`);
+    return r.send(e);
+  }
+  matches(t) {
+    return this.snapshot.get().active.some((e) => e === t || e.startsWith(`${t}.`));
+  }
+  hasTag(t) {
+    for (const e of this._activeClosure(this.snapshot.get()))
+      if (this._compiled.states[e].tags.includes(t))
+        return !0;
+    return !1;
+  }
+  subscribe(t) {
+    if (typeof t != "function")
+      throw new TypeError("[Raph machine] Subscriber must be a function.");
+    if (this._stopped)
+      return () => {
+      };
+    const e = { listener: t }, r = this._listeners;
+    return this._listeners = r === void 0 ? [e] : [...r, e], () => this._removeListener(e);
+  }
+  persist() {
+    return V(this.model, this.snapshot.get());
+  }
+  stop() {
+    let t;
+    try {
+      this._dispose(!0);
+    } catch (e) {
+      (t ?? (t = [])).push(e);
+    }
+    try {
+      this._releaseOwnership();
+    } catch (e) {
+      (t ?? (t = [])).push(e);
+    }
+    g(t, `[Raph machine] Machine "${this.id}" stop failed.`);
+  }
+  _enqueue(t, e) {
+    if (!this.started)
+      throw new Error(`[Raph machine] Machine "${this.id}" must be started before send().`);
+    if (X(t), this._processing)
+      return (this._queue ?? (this._queue = [])).push({ event: t, ...e === void 0 ? {} : { transitions: e } }), { snapshot: this._currentSnapshot, status: "queued" };
+    this._processing = !0;
+    let r;
+    try {
+      r = this._process(t, e), this._drainQueuedItems();
+    } finally {
+      this._queue !== void 0 && (this._queue.length = 0), this._queueCursor = 0, this._processing = !1;
+    }
+    return r;
+  }
+  _process(t, e) {
+    const r = this._currentSnapshot, i = this._runtime._nextTraceOperation("machine"), s = this._runtime._currentTraceCauseId() ?? i;
+    let n;
+    i !== void 0 && this._trace(t.type, "start", i, s, r);
+    try {
+      const a = e === void 0 ? this._compiled.eventIndexes.get(t.type) : void 0;
+      if (e === void 0 && a === void 0)
+        return i !== void 0 && this._trace(t.type, "ignored", i, s, r), this._ignored(r);
+      const c = i === void 0 ? void 0 : this._traceHooks(i, s), h = this._runtime._hasActiveReactiveContext() ? this._runtime.untracked(() => this._evaluate(r, t, a, e, c)) : this._evaluate(r, t, a, e, c);
+      if (!h.changed)
+        return i !== void 0 && this._trace(t.type, "ignored", i, s, r), this._ignored(r);
+      this._runtime._batchReactive(() => {
+        this._writeSnapshotInBoundary(h.snapshot), this._currentSnapshot = h.snapshot, n = h.snapshot;
+      });
+      let u;
+      try {
+        this._applyPlan(h.plan, h.snapshot, s);
+      } catch (d) {
+        (u ?? (u = [])).push(d);
+      }
+      const _ = this._listeners;
+      if (this.started && _ !== void 0) {
+        const d = this._notifyListeners(_, h.snapshot);
+        d !== void 0 && (u ?? (u = [])).push(...d);
+      }
+      if (this.started && h.snapshot.status === "done")
+        try {
+          this._stopStateResources();
+        } catch (d) {
+          (u ?? (u = [])).push(d);
+        }
+      u !== void 0 && g(u, `[Raph machine] Machine "${this.id}" post-commit work failed.`);
+      const f = this.started ? h.snapshot : this._currentSnapshot;
+      return i !== void 0 && this._trace(t.type, "end", i, s, f), { snapshot: f, status: "transitioned" };
+    } catch (a) {
+      if (n !== void 0)
+        return this._handlePostCommitError(a, t.type, s), { snapshot: this._currentSnapshot, status: "transitioned" };
+      if (this._traceError(t.type, a, i, s), this._onError !== void 0)
+        return this._onError(a), this._ignored(this._currentSnapshot);
+      if (this._errorPolicy === "stop" && this._dispose(!0), this._errorPolicy === "ignore")
+        return this._ignored(this._currentSnapshot);
+      throw a;
+    }
+  }
+  _ignored(t) {
+    return this._lastIgnoredSnapshot !== t && (this._lastIgnoredSnapshot = t, this._lastIgnoredResult = { snapshot: t, status: "ignored" }), this._lastIgnoredResult;
+  }
+  _evaluate(t, e, r, i, s) {
+    return i === void 0 ? Q(
+      this.model,
+      t,
+      e,
+      this._bindings,
+      this._input,
+      s,
+      this._compiled,
+      r
+    ) : W(
+      this.model,
+      t,
+      e,
+      i,
+      this._bindings,
+      this._input,
+      s
+    );
+  }
+  _drainQueued() {
+    if (this._queue === void 0 || this._queue.length === 0 || !this.started) {
+      this._queue !== void 0 && (this._queue.length = 0), this._queueCursor = 0;
+      return;
+    }
+    this._processing = !0;
+    try {
+      this._drainQueuedItems();
+    } finally {
+      this._queue !== void 0 && (this._queue.length = 0), this._queueCursor = 0, this._processing = !1;
+    }
+  }
+  _drainQueuedItems() {
+    const t = this._queue;
+    if (t !== void 0)
+      for (; this._queueCursor < t.length && this.started; ) {
+        const e = t[this._queueCursor++];
+        this._process(e.event, e.transitions);
+      }
+  }
+  _applyPlan(t, e, r) {
+    if (t.exited.length === 0 && t.exitOutputs.length === 0 && t.transitionOutputs.length === 0 && t.transitionOutputRefs === void 0 && t.entryOutputs.length === 0 && t.entered.length === 0)
+      return;
+    const i = [];
+    for (const s of t.exited) {
+      try {
+        this._cleanupState(s);
+      } catch (n) {
+        i.push(n);
+      }
+      if (!this.started)
+        break;
+    }
+    if (this.started && t.exitOutputs.length !== 0)
+      try {
+        this._runOutputs(t.exitOutputs, e, r);
+      } catch (s) {
+        i.push(s);
+      }
+    if (this.started && t.transitionOutputRefs !== void 0)
+      try {
+        this._runOutputRefs(t.transitionOutputRefs, t.event, e, r);
+      } catch (s) {
+        i.push(s);
+      }
+    else if (this.started && t.transitionOutputs.length !== 0)
+      try {
+        this._runOutputs(t.transitionOutputs, e, r);
+      } catch (s) {
+        i.push(s);
+      }
+    if (this.started && t.entryOutputs.length !== 0)
+      try {
+        this._runOutputs(t.entryOutputs, e, r);
+      } catch (s) {
+        i.push(s);
+      }
+    if (this.started)
+      for (const s of t.entered) {
+        if (!this.started)
+          break;
+        try {
+          this._activateState(s, t.event, e);
+        } catch (n) {
+          i.push(n);
+        }
+      }
+    g(i, `[Raph machine] Machine "${this.id}" post-commit work failed.`);
+  }
+  _activateState(t, e, r) {
+    var a, c;
+    if (!this.started || (a = this._stateCleanups) != null && a.has(t))
+      return;
+    const i = this._compiled.states[t];
+    if (i.resources.length === 0 && i.after.size === 0 && i.invokes.length === 0)
+      return;
+    const s = [], n = this._stateCleanups ?? (this._stateCleanups = /* @__PURE__ */ new Map());
+    n.set(t, s);
+    try {
+      for (const h of i.resources) {
+        const u = (c = this._bindings.resources) == null ? void 0 : c[h];
+        if (u === void 0)
+          throw new Error(`[Raph machine] Resource binding "${h}" is not defined.`);
+        const _ = new AbortController();
+        let f;
+        try {
+          const d = this._runtime.untracked(() => u({
+            context: r.context,
+            event: e,
+            input: this._input,
+            owner: this._owner,
+            signal: _.signal,
+            snapshot: r
+          }));
+          typeof d == "function" && (f = d);
+        } catch (d) {
+          throw _.abort(), d;
+        }
+        if (s.push(R(() => {
+          _.abort(), f == null || f();
+        })), !this.started)
+          throw S;
+      }
+      for (const [h, u] of i.after) {
+        const _ = this._resolveDelay(h, r, e);
+        if (!this.started)
+          throw S;
+        const f = this._clock.setTimeout(() => {
+          var d;
+          !this.started || !((d = this._stateCleanups) != null && d.has(t)) || this._enqueue(Object.freeze({ type: `@@after:${i.path}:${h}` }), u);
+        }, _);
+        if (s.push(R(() => this._clock.clearTimeout(f))), !this.started)
+          throw S;
+      }
+      for (const h of i.invokes)
+        if (this._startInvoke(i, h, e, r, s), !this.started)
+          throw S;
+    } catch (h) {
+      n.get(t) === s && n.delete(t), n.size === 0 && this._stateCleanups === n && (this._stateCleanups = void 0);
+      const u = z(s);
+      g(
+        h === S ? u : [h, ...u],
+        `[Raph machine] State "${i.path}" activation failed.`
+      );
+    }
+  }
+  _startInvoke(t, e, r, i, s) {
+    var C, x, T, M, q, I;
+    const n = this._invocations ?? (this._invocations = /* @__PURE__ */ new Map());
+    if (n.has(e.id))
+      throw new Error(`[Raph machine] Invoke id "${e.id}" is already active.`);
+    const a = new AbortController(), c = {}, h = { controller: a, invoke: e, token: c };
+    n.set(e.id, h);
+    const u = () => {
+      var v;
+      a.abort();
+      const l = n.get(e.id);
+      (l == null ? void 0 : l.token) === c && n.delete(e.id), n.size === 0 && this._invocations === n && (this._invocations = void 0);
+      const p = this._actors;
+      p == null || p.delete(e.id), (p == null ? void 0 : p.size) === 0 && this._actors === p && (this._actors = void 0), (v = h.actor) == null || v.stop();
+    };
+    s.push(R(u));
+    const _ = typeof e.input == "function" ? e.input({ context: i.context, event: r, input: this._input }) : e.input;
+    if (!this.started)
+      return;
+    if (e.type === "machine") {
+      const l = typeof e.src == "string" ? (C = this._bindings.actors) == null ? void 0 : C[e.src] : e.src;
+      if (l === void 0)
+        throw new Error(`[Raph machine] Actor source "${String(e.src)}" is not defined.`);
+      const p = new E(
+        this._owner,
+        l,
+        {},
+        {
+          errorPolicy: e.onError.length === 0 ? "throw" : "ignore",
+          id: `${this.id}/${e.id}`,
+          input: _,
+          onError: e.onError.length === 0 ? void 0 : ($) => {
+            var w, b;
+            !this.started || ((b = (w = this._invocations) == null ? void 0 : w.get(e.id)) == null ? void 0 : b.token) !== c || this._enqueue(
+              Object.freeze({ error: $, type: `@@error.actor:${e.id}` }),
+              e.onError
+            );
+          },
+          parentId: this.id
+        }
+      );
+      if (!this.started || ((T = (x = this._invocations) == null ? void 0 : x.get(e.id)) == null ? void 0 : T.token) !== c || a.signal.aborted) {
+        p.stop();
+        return;
+      }
+      h.actor = p, (this._actors ?? (this._actors = /* @__PURE__ */ new Map())).set(e.id, p);
+      const v = p.subscribe(($) => {
+        var w, b;
+        $.status === "done" && ((b = (w = this._invocations) == null ? void 0 : w.get(e.id)) == null ? void 0 : b.token) === c && this._enqueue(
+          Object.freeze({ output: $.output, type: `@@done.actor:${e.id}` }),
+          e.onDone
+        );
+      });
+      if (s.push(R(v)), p.start(), !this.started)
+        return;
+      const j = p.snapshot.peek();
+      j.status === "done" && ((q = (M = this._invocations) == null ? void 0 : M.get(e.id)) == null ? void 0 : q.token) === c && this._enqueue(
+        Object.freeze({ output: j.output, type: `@@done.actor:${e.id}` }),
+        e.onDone
+      );
+      return;
+    }
+    if (typeof e.src != "string")
+      throw new TypeError(`[Raph machine] Task invoke "${e.id}" requires a string source.`);
+    const f = (I = this._bindings.tasks) == null ? void 0 : I[e.src];
+    if (f === void 0)
+      throw new Error(`[Raph machine] Task binding "${e.src}" is not defined.`);
+    let d;
+    try {
+      d = this._runtime.untracked(() => f({
+        context: i.context,
+        event: r,
+        input: this._input,
+        send: (l) => {
+          var v;
+          const p = (v = this._invocations) == null ? void 0 : v.get(e.id);
+          !this.started || (p == null ? void 0 : p.token) !== c || a.signal.aborted || this.send(l);
+        },
+        signal: a.signal
+      }));
+    } catch (l) {
+      this._completeInvoke(e, c, !1, l);
+      return;
+    }
+    this.started && Promise.resolve(d).then(
+      (l) => this._completeInvoke(e, c, !0, l),
+      (l) => this._completeInvoke(e, c, !1, l)
+    );
+  }
+  _completeInvoke(t, e, r, i) {
+    var n;
+    const s = (n = this._invocations) == null ? void 0 : n.get(t.id);
+    !this.started || (s == null ? void 0 : s.token) !== e || s.controller.signal.aborted || this._enqueue(
+      Object.freeze(r ? { data: i, type: `@@done.invoke:${t.id}` } : { error: i, type: `@@error.invoke:${t.id}` }),
+      r ? t.onDone : t.onError
+    );
+  }
+  _resolveDelay(t, e, r) {
+    var a;
+    const i = Number(t), s = Number.isFinite(i) && t.trim() !== "" ? i : (a = this._bindings.delays) == null ? void 0 : a[t];
+    if (s === void 0)
+      throw new Error(`[Raph machine] Delay binding "${t}" is not defined.`);
+    const n = typeof s == "function" ? s({ context: e.context, event: r, input: this._input }) : s;
+    if (!Number.isFinite(n) || n < 0)
+      throw new TypeError(`[Raph machine] Delay "${t}" must resolve to a non-negative finite number.`);
+    return n;
+  }
+  _runOutputs(t, e, r) {
+    if (t.length === 0)
+      return;
+    let i;
+    for (const s of t) {
+      try {
+        const n = this._resolveOutput(s.ref);
+        this._runtime._runWithTraceCause(r, () => this._runtime.untracked(() => n({
+          context: e.context,
+          event: s.event,
+          input: this._input,
+          snapshot: e
+        })));
+      } catch (n) {
+        (i ?? (i = [])).push(n);
+      }
+      if (!this.started)
+        break;
+    }
+    i !== void 0 && g(i, `[Raph machine] Machine "${this.id}" output work failed.`);
+  }
+  _notifyListeners(t, e) {
+    let r;
+    for (let i = 0; i < t.length; i += 1)
+      try {
+        t[i].listener(e);
+      } catch (s) {
+        (r ?? (r = [])).push(s);
+      }
+    return r;
+  }
+  _removeListener(t) {
+    const e = this._listeners;
+    if (e === void 0)
+      return;
+    const r = e.indexOf(t);
+    r !== -1 && (this._listeners = e.length === 1 ? void 0 : [...e.slice(0, r), ...e.slice(r + 1)]);
+  }
+  _runOutputRefs(t, e, r, i) {
+    let s;
+    for (const n of t) {
+      try {
+        const a = this._resolveOutput(n);
+        this._runtime._runWithTraceCause(i, () => this._runtime.untracked(() => a({
+          context: r.context,
+          event: e,
+          input: this._input,
+          snapshot: r
+        })));
+      } catch (a) {
+        (s ?? (s = [])).push(a);
+      }
+      if (!this.started)
+        break;
+    }
+    s !== void 0 && g(s, `[Raph machine] Machine "${this.id}" output work failed.`);
+  }
+  _resolveOutput(t) {
+    var r;
+    if (typeof t == "function")
+      return t;
+    const e = (r = this._bindings.outputs) == null ? void 0 : r[t];
+    if (e === void 0)
+      throw new Error(`[Raph machine] Output binding "${t}" is not defined.`);
+    return e;
+  }
+  _cleanupState(t) {
+    const e = this._stateCleanups, r = e == null ? void 0 : e.get(t);
+    e === void 0 || r === void 0 || (e.delete(t), e.size === 0 && this._stateCleanups === e && (this._stateCleanups = void 0), g(
+      z(r),
+      `[Raph machine] State "${this._compiled.states[t].path}" cleanup failed.`
+    ));
+  }
+  _stopStateResources() {
+    if (this._stateCleanups === void 0)
+      return;
+    const t = [...this._stateCleanups.keys()].sort((r, i) => this._compiled.states[i].depth - this._compiled.states[r].depth), e = [];
+    for (const r of t)
+      try {
+        this._cleanupState(r);
+      } catch (i) {
+        e.push(i);
+      }
+    g(e, `[Raph machine] Machine "${this.id}" final cleanup failed.`);
+  }
+  _dispose(t) {
+    if (this._stopped)
+      return;
+    this._stopped = !0, this._started = !1;
+    let e;
+    try {
+      this._stopStateResources();
+    } catch (r) {
+      (e ?? (e = [])).push(r);
+    }
+    this._queue !== void 0 && (this._queue.length = 0), this._queueCursor = 0, this._listeners = void 0;
+    try {
+      this._releaseDebug();
+    } catch (r) {
+      (e ?? (e = [])).push(r);
+    }
+    if (t && !this._runtime.disposed) {
+      const r = this._currentSnapshot, i = H(this.model, r);
+      try {
+        this._runtime._batchReactive(() => {
+          this._writeSnapshotInBoundary(i), this._currentSnapshot = i;
+        });
+      } catch (s) {
+        (e ?? (e = [])).push(s);
+      }
+    }
+    try {
+      this._releaseSnapshot();
+    } catch (r) {
+      (e ?? (e = [])).push(r);
+    }
+    g(e, `[Raph machine] Machine "${this.id}" stop failed.`);
+  }
+  _activeClosure(t) {
+    const e = /* @__PURE__ */ new Set();
+    for (const r of t.active) {
+      let i = this._compiled.pathToState.get(r);
+      for (; i !== void 0; )
+        e.add(i), i = this._compiled.states[i].parent;
+    }
+    return [...e];
+  }
+  _traceHooks(t, e = this._runtime._currentTraceCauseId() ?? t) {
+    return {
+      guard: (r, i, s) => this._runtime._recordTrace({
+        ...e === void 0 ? {} : { causeId: e },
+        ...s === void 0 ? {} : { context: s },
+        guard: i ? "passed" : "failed",
+        kind: "machine",
+        name: `${this.id}:guard:${r}`,
+        ...t === void 0 ? {} : { operationId: t }
+      }),
+      transition: (r) => this._runtime._recordTrace({
+        ...e === void 0 ? {} : { causeId: e },
+        details: r,
+        kind: "machine",
+        name: `${this.id}:transition`,
+        ...t === void 0 ? {} : { operationId: t }
+      })
+    };
+  }
+  _trace(t, e, r, i, s) {
+    this._runtime._recordTrace({
+      ...i === void 0 ? {} : { causeId: i },
+      context: D(s.context) ? s.context : void 0,
+      details: { active: s.active, revision: s.revision },
+      kind: "machine",
+      name: `${this.id}:${t}`,
+      ...r === void 0 ? {} : { operationId: r },
+      status: e
+    });
+  }
+  _traceError(t, e, r, i) {
+    const s = { message: e instanceof Error ? e.message : String(e) };
+    this._runtime._recordTrace({
+      ...i === void 0 ? {} : { causeId: i },
+      details: s,
+      kind: "machine",
+      name: `${this.id}:${t}`,
+      ...r === void 0 ? {} : { operationId: r },
+      status: "error"
+    }), this._runtime._recordTrace({
+      ...i === void 0 ? {} : { causeId: i },
+      details: s,
+      kind: "error",
+      name: `machine:${this.id}`,
+      ...r === void 0 ? {} : { operationId: r },
+      status: "error"
+    });
+  }
+  _handlePostCommitError(t, e, r) {
+    if (this._traceError(e, t, void 0, r), this._onError !== void 0) {
+      this._onError(t);
+      return;
+    }
+    if (this._errorPolicy === "stop" && this._dispose(!0), this._errorPolicy === "throw")
+      throw t;
+  }
+}
+function tt(o, t, e = {}, r = {}) {
+  return new E(o, t, e, r);
+}
+function U(o, t, e) {
+  const r = o._getWorkGraph(), i = r.createProducer(t), s = o._getReactivity()._ownedSignal(e, r.producerHooks(i));
+  let n = s.source, a = e;
+  const c = Object.freeze({
+    get: () => (o._assertSourceReadable(t), n === void 0 ? a : n.get()),
+    peek: () => (t._assertAlive(), n === void 0 ? a : n.peek())
+  });
+  return r.attachProducer(i, c), {
+    dispose: () => {
+      const h = n;
+      h !== void 0 && (a = h.peek(), n = void 0, s.dispose());
+    },
+    source: c,
+    writeInBoundary: (h) => {
+      t._assertAlive(), n.set(h), a = h;
+    }
+  };
+}
+function z(o) {
+  const t = [];
+  for (let e = o.length - 1; e >= 0; e--)
+    try {
+      o[e]();
+    } catch (r) {
+      t.push(r);
+    }
+  return t;
+}
+function g(o, t) {
+  if ((o == null ? void 0 : o.length) === 1)
+    throw o[0];
+  if (o !== void 0 && o.length > 1)
+    throw new AggregateError(o, t);
+}
+function X(o) {
+  if (typeof o != "object" || o === null || typeof o.type != "string" || !o.type)
+    throw new TypeError("[Raph machine] Event must contain a non-empty string type.");
+}
+function D(o) {
+  return typeof o == "object" && o !== null && !Array.isArray(o);
+}
+function O() {
+}
+function R(o) {
+  let t = !0;
+  return () => {
+    t && (t = !1, o());
+  };
+}
+export {
+  m as MachinePersistenceError,
+  tt as createMachine,
+  rt as defineMachine,
+  st as getInitialSnapshot,
+  V as persistMachineSnapshot,
+  G as restoreMachineSnapshot,
+  nt as transition
+};