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

package/dist/machine.js

@@ -0,0 +1,822 @@
+import { b as I, g as M, h as j, c as P, r as k, d as A, s as z } from "./core-CClhT8WR.js";
+import { e as K, a as U, t as X } from "./core-CClhT8WR.js";
+import { RaphScope as D } from "./debug/runtime/ownership/RaphScope.js";
+class _ extends Error {
+}
+function N(o, t) {
+  return I(
+    o,
+    t
+  ), v(t.context, "context"), t.output !== void 0 && v(t.output, "output"), Object.freeze({
+    active: Object.freeze([...t.active]),
+    context: O(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: O(t.output) },
+    revision: t.revision,
+    status: t.status,
+    version: o.version
+  });
+}
+function B(o, t, e) {
+  const r = M(o);
+  try {
+    if (typeof t != "object" || t === null || Array.isArray(t))
+      throw new _("[Raph machine] Persisted snapshot must be an object.");
+    if (t.modelId !== o.id)
+      throw new _(
+        `[Raph machine] Snapshot model "${t.modelId}" is incompatible with "${o.id}".`
+      );
+    if (!Number.isSafeInteger(t.version) || t.version < 1)
+      throw new _("[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 _(
+          `[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 _(
+          `[Raph machine] Migration from version ${i.version} must produce version ${i.version + 1}.`
+        );
+      i = n;
+    }
+    if (i.version !== o.version)
+      throw new _(
+        `[Raph machine] Snapshot version ${i.version} is newer than model version ${o.version}.`
+      );
+    return v(i.context, "context"), i.output !== void 0 && v(i.output, "output"), j(
+      o,
+      i,
+      e
+    );
+  } catch (i) {
+    throw i instanceof _ ? i : new _(
+      `[Raph machine] Persisted snapshot is invalid: ${i instanceof Error ? i.message : String(i)}`
+    );
+  }
+}
+function v(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 _(`[Raph machine] ${t} contains a non-finite number.`);
+    return;
+  }
+  if (r !== "object")
+    throw new _(`[Raph machine] ${t} is not JSON-safe.`);
+  const i = o;
+  if (e.has(i))
+    throw new _(`[Raph machine] ${t} contains a cycle.`);
+  if (e.add(i), Array.isArray(o))
+    o.forEach((s, n) => v(s, `${t}[${n}]`, e));
+  else {
+    const s = Object.getPrototypeOf(o);
+    if (s !== Object.prototype && s !== null)
+      throw new _(`[Raph machine] ${t} contains a non-plain object.`);
+    for (const [n, h] of Object.entries(o))
+      v(h, `${t}.${n}`, e);
+  }
+  e.delete(i);
+}
+function O(o) {
+  return JSON.parse(JSON.stringify(o));
+}
+const E = /* @__PURE__ */ new WeakMap(), y = Symbol("RaphMachineActivationCancelled"), C = Object.freeze({ type: "@@init" }), L = Object.freeze({
+  clearTimeout: (o) => clearTimeout(o),
+  now: () => Date.now(),
+  setTimeout: (o, t) => setTimeout(o, t)
+});
+class S {
+  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 = R, 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 = R, this._releaseDebug = R, 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 D))
+      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 = M(
+      e
+    ), this.model = e, this._bindings = r, this._clock = i.clock ?? L, 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 = (E.get(this._runtime) ?? 0) + 1;
+    if (E.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(() => P(
+      e,
+      this._input,
+      r,
+      this._runtime._traces("machine") ? this._traceHooks() : void 0
+    )) : void 0, h = n?.snapshot ?? B(e, i.persisted, this._input);
+    this._initialPlan = n?.plan, this._restored = i.persisted !== void 0;
+    const c = J(this._runtime, t, h);
+    this._releaseSnapshot = c.dispose, this._writeSnapshotInBoundary = c.writeInBoundary, this._currentSnapshot = h, this.snapshot = c.source;
+    try {
+      this._releaseDebug = this._runtime._registerMachineDebug({
+        id: this.id,
+        ownerId: t.id,
+        ...i.parentId === void 0 ? {} : { parentId: i.parentId },
+        snapshot: () => {
+          const a = this._currentSnapshot, u = Object.fromEntries(this._activeClosure(a).flatMap((d) => {
+            const g = this._compiled.states[d].meta;
+            return g === void 0 ? [] : [[this._compiled.states[d].path, g]];
+          }));
+          return Object.freeze({
+            active: a.active,
+            actors: Object.freeze([...this._actors?.keys() ?? []]),
+            contextKeys: Object.freeze(T(a.context) ? Object.keys(a.context) : []),
+            id: this.id,
+            meta: Object.freeze(u),
+            modelId: e.id,
+            ownerId: t.id,
+            ...i.parentId === void 0 ? {} : { parentId: i.parentId },
+            revision: a.revision,
+            status: a.status
+          });
+        }
+      }), this._releaseOwnership = t.own(() => this._dispose(!1));
+    } catch (a) {
+      const u = [a];
+      try {
+        this._releaseDebug();
+      } catch (d) {
+        u.push(d);
+      }
+      try {
+        this._releaseSnapshot();
+      } catch (d) {
+        u.push(d);
+      }
+      throw u.length > 1 ? new AggregateError(u, `[Raph machine] Machine "${this.id}" construction rollback failed.`) : a;
+    }
+  }
+  get started() {
+    return this._started && !this._stopped;
+  }
+  start() {
+    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((s, n) => this._compiled.states[s].depth - this._compiled.states[n].depth);
+    let r = !1, i;
+    this._processing = !0;
+    try {
+      const s = [];
+      if (!this._restored) {
+        try {
+          this._runOutputs(
+            this._initialPlan?.exitOutputs ?? [],
+            t,
+            this._runtime._currentTraceCauseId()
+          );
+        } catch (n) {
+          s.push(n);
+        }
+        if (this.started)
+          try {
+            this._runOutputs(
+              this._initialPlan?.transitionOutputs ?? [],
+              t,
+              this._runtime._currentTraceCauseId()
+            );
+          } catch (n) {
+            s.push(n);
+          }
+        if (this.started) {
+          const n = e.flatMap((h) => this._compiled.states[h].entry.map((c) => ({ event: C, ref: c })));
+          try {
+            this._runOutputs(n, t, this._runtime._currentTraceCauseId());
+          } catch (h) {
+            s.push(h);
+          }
+        }
+      }
+      if (this.started && t.status === "active")
+        for (const n of e) {
+          if (!this.started)
+            break;
+          try {
+            this._activateState(n, C, t);
+          } catch (h) {
+            s.push(h);
+          }
+        }
+      l(s, `[Raph machine] Machine "${this.id}" start work failed.`);
+    } catch (s) {
+      try {
+        this._handlePostCommitError(s, "start", this._runtime._currentTraceCauseId());
+      } catch (n) {
+        r = !0, i = n;
+      }
+    } 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) {
+    const r = this._actors?.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 N(this.model, this.snapshot.get());
+  }
+  stop() {
+    let t;
+    try {
+      this._dispose(!0);
+    } catch (e) {
+      (t ??= []).push(e);
+    }
+    try {
+      this._releaseOwnership();
+    } catch (e) {
+      (t ??= []).push(e);
+    }
+    l(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 (Q(t), this._processing)
+      return (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 h = e === void 0 ? this._compiled.eventIndexes.get(t.type) : void 0;
+      if (e === void 0 && h === 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), a = this._runtime._hasActiveReactiveContext() ? this._runtime.untracked(() => this._evaluate(r, t, h, e, c)) : this._evaluate(r, t, h, e, c);
+      if (!a.changed)
+        return i !== void 0 && this._trace(t.type, "ignored", i, s, r), this._ignored(r);
+      this._runtime._batchReactive(() => {
+        this._writeSnapshotInBoundary(a.snapshot), this._currentSnapshot = a.snapshot, n = a.snapshot;
+      });
+      let u;
+      try {
+        this._applyPlan(a.plan, a.snapshot, s);
+      } catch (m) {
+        (u ??= []).push(m);
+      }
+      const d = this._listeners;
+      if (this.started && d !== void 0) {
+        const m = this._notifyListeners(d, a.snapshot);
+        m !== void 0 && (u ??= []).push(...m);
+      }
+      if (this.started && a.snapshot.status === "done")
+        try {
+          this._stopStateResources();
+        } catch (m) {
+          (u ??= []).push(m);
+        }
+      u !== void 0 && l(u, `[Raph machine] Machine "${this.id}" post-commit work failed.`);
+      const g = this.started ? a.snapshot : this._currentSnapshot;
+      return i !== void 0 && this._trace(t.type, "end", i, s, g), { snapshot: g, status: "transitioned" };
+    } catch (h) {
+      if (n !== void 0)
+        return this._handlePostCommitError(h, t.type, s), { snapshot: this._currentSnapshot, status: "transitioned" };
+      if (this._traceError(t.type, h, i, s), this._onError !== void 0)
+        return this._onError(h), this._ignored(this._currentSnapshot);
+      if (this._errorPolicy === "stop" && this._dispose(!0), this._errorPolicy === "ignore")
+        return this._ignored(this._currentSnapshot);
+      throw h;
+    }
+  }
+  _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 ? k(
+      this.model,
+      t,
+      e,
+      this._bindings,
+      this._input,
+      s,
+      this._compiled,
+      r
+    ) : A(
+      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);
+        }
+      }
+    l(i, `[Raph machine] Machine "${this.id}" post-commit work failed.`);
+  }
+  _activateState(t, e, r) {
+    if (!this.started || this._stateCleanups?.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 ??= /* @__PURE__ */ new Map();
+    n.set(t, s);
+    try {
+      for (const h of i.resources) {
+        const c = this._bindings.resources?.[h];
+        if (c === void 0)
+          throw new Error(`[Raph machine] Resource binding "${h}" is not defined.`);
+        const a = new AbortController();
+        let u;
+        try {
+          const d = this._runtime.untracked(() => c({
+            context: r.context,
+            event: e,
+            input: this._input,
+            owner: this._owner,
+            signal: a.signal,
+            snapshot: r
+          }));
+          typeof d == "function" && (u = d);
+        } catch (d) {
+          throw a.abort(), d;
+        }
+        if (s.push(b(() => {
+          a.abort(), u?.();
+        })), !this.started)
+          throw y;
+      }
+      for (const [h, c] of i.after) {
+        const a = this._resolveDelay(h, r, e);
+        if (!this.started)
+          throw y;
+        const u = this._clock.setTimeout(() => {
+          !this.started || !this._stateCleanups?.has(t) || this._enqueue(Object.freeze({ type: `@@after:${i.path}:${h}` }), c);
+        }, a);
+        if (s.push(b(() => this._clock.clearTimeout(u))), !this.started)
+          throw y;
+      }
+      for (const h of i.invokes)
+        if (this._startInvoke(i, h, e, r, s), !this.started)
+          throw y;
+    } catch (h) {
+      n.get(t) === s && n.delete(t), n.size === 0 && this._stateCleanups === n && (this._stateCleanups = void 0);
+      const c = x(s);
+      l(
+        h === y ? c : [h, ...c],
+        `[Raph machine] State "${i.path}" activation failed.`
+      );
+    }
+  }
+  _startInvoke(t, e, r, i, s) {
+    const n = this._invocations ??= /* @__PURE__ */ new Map();
+    if (n.has(e.id))
+      throw new Error(`[Raph machine] Invoke id "${e.id}" is already active.`);
+    const h = new AbortController(), c = {}, a = { controller: h, invoke: e, token: c };
+    n.set(e.id, a);
+    const u = () => {
+      h.abort(), n.get(e.id)?.token === c && n.delete(e.id), n.size === 0 && this._invocations === n && (this._invocations = void 0);
+      const p = this._actors;
+      p?.delete(e.id), p?.size === 0 && this._actors === p && (this._actors = void 0), a.actor?.stop();
+    };
+    s.push(b(u));
+    const d = 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 f = typeof e.src == "string" ? this._bindings.actors?.[e.src] : e.src;
+      if (f === void 0)
+        throw new Error(`[Raph machine] Actor source "${String(e.src)}" is not defined.`);
+      const p = new S(
+        this._owner,
+        f,
+        {},
+        {
+          errorPolicy: e.onError.length === 0 ? "throw" : "ignore",
+          id: `${this.id}/${e.id}`,
+          input: d,
+          onError: e.onError.length === 0 ? void 0 : (w) => {
+            !this.started || this._invocations?.get(e.id)?.token !== c || this._enqueue(
+              Object.freeze({ error: w, type: `@@error.actor:${e.id}` }),
+              e.onError
+            );
+          },
+          parentId: this.id
+        }
+      );
+      if (!this.started || this._invocations?.get(e.id)?.token !== c || h.signal.aborted) {
+        p.stop();
+        return;
+      }
+      a.actor = p, (this._actors ??= /* @__PURE__ */ new Map()).set(e.id, p);
+      const q = p.subscribe((w) => {
+        w.status === "done" && this._invocations?.get(e.id)?.token === c && this._enqueue(
+          Object.freeze({ output: w.output, type: `@@done.actor:${e.id}` }),
+          e.onDone
+        );
+      });
+      if (s.push(b(q)), p.start(), !this.started)
+        return;
+      const $ = p.snapshot.peek();
+      $.status === "done" && this._invocations?.get(e.id)?.token === c && this._enqueue(
+        Object.freeze({ output: $.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 g = this._bindings.tasks?.[e.src];
+    if (g === void 0)
+      throw new Error(`[Raph machine] Task binding "${e.src}" is not defined.`);
+    let m;
+    try {
+      m = this._runtime.untracked(() => g({
+        context: i.context,
+        event: r,
+        input: this._input,
+        send: (f) => {
+          const p = this._invocations?.get(e.id);
+          !this.started || p?.token !== c || h.signal.aborted || this.send(f);
+        },
+        signal: h.signal
+      }));
+    } catch (f) {
+      this._completeInvoke(e, c, !1, f);
+      return;
+    }
+    this.started && Promise.resolve(m).then(
+      (f) => this._completeInvoke(e, c, !0, f),
+      (f) => this._completeInvoke(e, c, !1, f)
+    );
+  }
+  _completeInvoke(t, e, r, i) {
+    const s = this._invocations?.get(t.id);
+    !this.started || 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) {
+    const i = Number(t), s = Number.isFinite(i) && t.trim() !== "" ? i : this._bindings.delays?.[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 ??= []).push(n);
+      }
+      if (!this.started)
+        break;
+    }
+    i !== void 0 && l(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 ??= []).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 h = this._resolveOutput(n);
+        this._runtime._runWithTraceCause(i, () => this._runtime.untracked(() => h({
+          context: r.context,
+          event: e,
+          input: this._input,
+          snapshot: r
+        })));
+      } catch (h) {
+        (s ??= []).push(h);
+      }
+      if (!this.started)
+        break;
+    }
+    s !== void 0 && l(s, `[Raph machine] Machine "${this.id}" output work failed.`);
+  }
+  _resolveOutput(t) {
+    if (typeof t == "function")
+      return t;
+    const e = this._bindings.outputs?.[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?.get(t);
+    e === void 0 || r === void 0 || (e.delete(t), e.size === 0 && this._stateCleanups === e && (this._stateCleanups = void 0), l(
+      x(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);
+      }
+    l(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 ??= []).push(r);
+    }
+    this._queue !== void 0 && (this._queue.length = 0), this._queueCursor = 0, this._listeners = void 0;
+    try {
+      this._releaseDebug();
+    } catch (r) {
+      (e ??= []).push(r);
+    }
+    if (t && !this._runtime.disposed) {
+      const r = this._currentSnapshot, i = z(this.model, r);
+      try {
+        this._runtime._batchReactive(() => {
+          this._writeSnapshotInBoundary(i), this._currentSnapshot = i;
+        });
+      } catch (s) {
+        (e ??= []).push(s);
+      }
+    }
+    try {
+      this._releaseSnapshot();
+    } catch (r) {
+      (e ??= []).push(r);
+    }
+    l(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: T(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 F(o, t, e = {}, r = {}) {
+  return new S(o, t, e, r);
+}
+function J(o, t, e) {
+  const r = o._getWorkGraph(), i = r.createProducer(t), s = o._getReactivity()._ownedSignal(e, r.producerHooks(i));
+  let n = s.source, h = e;
+  const c = Object.freeze({
+    get: () => (o._assertSourceReadable(t), n === void 0 ? h : n.get()),
+    peek: () => (t._assertAlive(), n === void 0 ? h : n.peek())
+  });
+  return r.attachProducer(i, c), {
+    dispose: () => {
+      const a = n;
+      a !== void 0 && (h = a.peek(), n = void 0, s.dispose());
+    },
+    source: c,
+    writeInBoundary: (a) => {
+      t._assertAlive(), n.set(a), h = a;
+    }
+  };
+}
+function x(o) {
+  const t = [];
+  for (let e = o.length - 1; e >= 0; e--)
+    try {
+      o[e]();
+    } catch (r) {
+      t.push(r);
+    }
+  return t;
+}
+function l(o, t) {
+  if (o?.length === 1)
+    throw o[0];
+  if (o !== void 0 && o.length > 1)
+    throw new AggregateError(o, t);
+}
+function Q(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 T(o) {
+  return typeof o == "object" && o !== null && !Array.isArray(o);
+}
+function R() {
+}
+function b(o) {
+  let t = !0;
+  return () => {
+    t && (t = !1, o());
+  };
+}
+export {
+  _ as MachinePersistenceError,
+  F as createMachine,
+  K as defineMachine,
+  U as getInitialSnapshot,
+  N as persistMachineSnapshot,
+  B as restoreMachineSnapshot,
+  X as transition
+};