@raphy-js/raph 1.0.0-dev.18

package/dist/debug/runtime/RaphRuntime.js

@@ -0,0 +1,979 @@
+var E = Object.defineProperty;
+var T = (p, e, t) => e in p ? E(p, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : p[e] = t;
+var u = (p, e, t) => T(p, typeof e != "symbol" ? e + "" : e, t);
+import { parseDataPath as P } from "../path/data-path.utils.js";
+import { DataPath as x } from "../path/DataPath.js";
+import { RaphMeta as W } from "../path/meta/RaphMeta.js";
+import { RaphKernel as G } from "../path/RaphKernel.js";
+import { configureReactiveObjectPolicy as O, disposeReactiveObjectContext as L } from "../reactivity/reactive-object.js";
+import { RaphDebugController as M, createOwnerSnapshot as b, createOwnerTree as R } from "./diagnostics/RaphDebug.js";
+import { RaphDisposedError as A, RaphCrossRuntimeError as k, RaphActionError as B } from "./errors.js";
+import { parentGraph as F } from "./ownership/parentGraph.js";
+import { RaphNode as g, createProvisionalNode as q } from "./ownership/RaphNode.js";
+import { RaphScope as D } from "./ownership/RaphScope.js";
+import { throwDisposalErrors as y } from "./ownership/throwDisposalErrors.js";
+import { RaphSchedulerType as w } from "./phases/phase.types.js";
+import { RaphFrameLoop as I } from "./phases/RaphFrameLoop.js";
+import { RaphPhasePipeline as H } from "./phases/RaphPhasePipeline.js";
+import { PathHandle as z } from "./reactivity/PathHandle.js";
+import { RaphMetaSource as N } from "./reactivity/RaphMetaSource.js";
+import { RaphWorkGraph as $ } from "./reactivity/RaphWorkGraph.js";
+import { RuntimeReactivity as j } from "./reactivity/RuntimeReactivity.js";
+import { RuntimeWatch as U } from "./reactivity/RuntimeWatch.js";
+const v = class v {
+  constructor(e = {}) {
+    u(this, "mode", "runtime");
+    u(this, "configuration");
+    u(this, "rootScope");
+    u(this, "root");
+    u(this, "frameTick");
+    u(this, "_reactivity");
+    u(this, "_signalLifecycle");
+    u(this, "_workGraph");
+    u(this, "_frameTickWritable");
+    u(this, "_setFrameTick");
+    u(this, "_pathHandles");
+    u(this, "_meta");
+    u(this, "_phases");
+    u(this, "_frameLoop");
+    u(this, "_debug");
+    u(this, "_debugController");
+    u(this, "_parentGraph");
+    u(this, "_owners", /* @__PURE__ */ new Set());
+    u(this, "_batchDepth", 0);
+    u(this, "_mutationDepth", 0);
+    u(this, "_kernelBatchDepth", 0);
+    u(this, "_ownerDisposalDepth", 0);
+    u(this, "_actionDepth", 0);
+    u(this, "_actionCounter", 0);
+    u(this, "_traceCauseStack", []);
+    u(this, "_phaseTraceOperations");
+    u(this, "_executionRequested", !1);
+    u(this, "_disposed", !1);
+    u(this, "_disposedListeners", /* @__PURE__ */ new Set());
+    const t = e.id ?? `runtime-${v._runtimeCounter++}`, r = e.adaptiveDependencyIndex ?? !1, s = e.enforceActions ?? !1, i = e.scheduler ?? w.Sync;
+    if (!K(i))
+      throw new Error(`[Raph] Unsupported scheduler "${String(i)}".`);
+    const o = e.kernel ?? new G({ id: `${t}-kernel` });
+    this.configuration = Object.freeze({
+      adaptiveDependencyIndex: r,
+      ...e.debug === void 0 ? {} : { debug: e.debug },
+      id: t,
+      kernel: o,
+      enforceActions: s,
+      scheduler: i
+    }), this._debugController = new M(e.debug);
+    const c = `[Raph] Runtime "${t}" is disposed.`;
+    this._signalLifecycle = {
+      owner: this,
+      runWrite: (d) => this._runWrite(d),
+      assertDependencyAllowed: (d, l) => {
+        this._assertImplicitDependency(d, l);
+      },
+      ...s ? { assertWriteAllowed: () => this._assertWriteAllowed() } : {},
+      throwDisposed: () => {
+        throw new A(c);
+      },
+      throwCrossRuntime: (d) => this._throwCrossRuntime(d)
+    }, this._reactivity = new j(this._signalLifecycle, { adaptiveDependencyIndex: r }), this._workGraph = new $(this), o._attachRuntime(this), this.rootScope = new D(`${t}:root-scope`, this), this.root = new g(null, { id: `${t}:root` }, this), O(this._reactivity, {
+      owner: this,
+      assertRead: () => {
+        this._assertAlive();
+        const d = this._reactivity.getActiveOwner();
+        d !== void 0 && d !== this && this._throwCrossRuntime(d);
+        const l = this._reactivity.getActiveConsumerOwner();
+        l !== void 0 && this._assertImplicitDependency(this.rootScope, l);
+      },
+      assertWrite: () => this._assertWriteAllowed(),
+      runWrite: (d) => this._runWrite(d),
+      throwForeign: (d) => {
+        throw d instanceof v && this._throwCrossRuntime(d), new k(
+          "[Raph] Reactive object belongs to another reactivity engine."
+        );
+      }
+    });
+    const n = this._workGraph.createProducer(this.rootScope, "frame", {
+      includeRuntime: !1
+    });
+    let a;
+    const h = this._reactivity.signalForOwner(
+      0,
+      this.rootScope,
+      this._workGraph.producerHooks(n),
+      (d) => {
+        a = d;
+      }
+    );
+    this._setFrameTick = (d) => this._runWrite(() => a(d)), this._frameTickWritable = h, this.frameTick = this._workGraph.attachProducer(n, {
+      get: h.get,
+      peek: h.peek
+    });
+  }
+  /** @internal */
+  _getReactivity() {
+    return this._reactivity;
+  }
+  /**
+   * Возвращает внутренний WorkGraph для optional execution layers.
+   *
+   * @internal
+   */
+  _getWorkGraph() {
+    return this._workGraph;
+  }
+  get id() {
+    return this.configuration.id;
+  }
+  get kernel() {
+    return this.configuration.kernel;
+  }
+  get disposed() {
+    return this._disposed;
+  }
+  get graph() {
+    return this._parentGraph ?? (this._parentGraph = F());
+  }
+  get loopEnabled() {
+    var e;
+    return ((e = this._frameLoop) == null ? void 0 : e.running) ?? !1;
+  }
+  get frame() {
+    var e;
+    return ((e = this._phases) == null ? void 0 : e.frame) ?? { now: 0, delta: 0, elapsed: 0, frame: 0 };
+  }
+  get phases() {
+    var e;
+    return ((e = this._phases) == null ? void 0 : e.phases) ?? [];
+  }
+  /** Runtime metadata facade intentionally excludes unphased watch(). */
+  get meta() {
+    if (this._assertAlive(), this._meta !== void 0)
+      return this._meta;
+    const e = new W(this.kernel, {
+      assertReadable: () => this._assertAlive(),
+      assertWritable: () => this._assertWriteAllowed(),
+      runWrite: (t, r) => this._runWrite(t, r)
+    });
+    return this._meta = Object.freeze({
+      delete: e.delete.bind(e),
+      get: e.get.bind(e),
+      has: e.has.bind(e),
+      merge: e.merge.bind(e),
+      set: e.set.bind(e)
+    });
+  }
+  getDerivedSnapshot() {
+    return this.kernel.getDerivedSnapshot();
+  }
+  get debug() {
+    return this._debug ?? (this._debug = Object.freeze({
+      snapshot: () => this._createDebugSnapshot(),
+      getTree: () => this._createDebugTree(),
+      stats: () => this._createDebugStats(),
+      trace: this._debugController.trace,
+      machines: this._debugController.machines
+    }));
+  }
+  signal(e, t = this.rootScope) {
+    this._assertOwnerRuntime(t);
+    const r = this._workGraph.createProducer(t), s = this._reactivity.signalForOwner(
+      e,
+      t,
+      this._workGraph.producerHooks(r)
+    );
+    return this._workGraph.attachProducer(r, s);
+  }
+  /**
+   * Creates a deep reactive Proxy owned by this Runtime root scope.
+   * Property dependencies use the intrusive graph directly and intentionally
+   * do not create per-property WorkGraph producers or phase causes.
+   */
+  reactive(e) {
+    return this._assertAlive(), this._reactivity.reactive(e);
+  }
+  computed(e, t = this.rootScope) {
+    this._assertOwnerRuntime(t);
+    const r = this._workGraph.createProducer(t), s = typeof e == "function" ? e : e.get, i = this._reactivity.computedForOwner(
+      () => this._runTracked(t, s),
+      t,
+      this._workGraph.producerHooks(r)
+    );
+    if (this._workGraph.setProducerActivation(r, () => {
+      i.peek();
+    }), typeof e == "function")
+      return this._workGraph.attachProducer(r, i);
+    const o = this._attachWritableComputed(i, e.set, t);
+    return this._workGraph.attachProducer(r, o);
+  }
+  /** Low-level adapter form. Prefer consumer.effect(). */
+  effect(e, t, r, s = {}) {
+    return this._effectRegistration(e, t, r, s).dispose;
+  }
+  /** @internal */
+  _effectRegistration(e, t, r, s = {}, i = !1) {
+    this._assertOwnerRuntime(e);
+    const o = this._validatePhaseBinding(t, r, s), c = this._execution, n = s.initial ?? "scheduled";
+    let a, h, d = !1;
+    const l = this._reactivity.withEffectBinding(
+      (f) => {
+        const _ = c.bindTask(
+          o,
+          e,
+          r,
+          s.priority ?? 0,
+          f
+        );
+        return i && _.pause(), a = _;
+      },
+      () => this._reactivity.effect(
+        () => this._runTracked(e, () => {
+          const f = r(a.task);
+          return typeof f == "function" ? () => this._runUntracked(f) : f;
+        }),
+        () => {
+          h === void 0 ? d = !0 : h();
+        }
+      )
+    );
+    h = this._own(l, e), d && h(), a.abort = () => h == null ? void 0 : h();
+    try {
+      n === "sync" ? this.flush() : this._requestExecution();
+    } catch (f) {
+      try {
+        h();
+      } catch (_) {
+        throw new AggregateError(
+          [f, _],
+          "[Raph] Phase effect registration and rollback failed."
+        );
+      }
+      throw f;
+    }
+    return {
+      dispose: () => h == null ? void 0 : h(),
+      pause: () => a == null ? void 0 : a.pause(),
+      resume: () => a == null ? void 0 : a.resume()
+    };
+  }
+  /** Low-level adapter form. Prefer consumer.watch(). */
+  watch(e, t, r, s, i = {}) {
+    return this._watchRegistration(e, t, r, s, i).dispose;
+  }
+  /** @internal */
+  _watchRegistration(e, t, r, s, i = {}, o = !1) {
+    this._assertOwnerRuntime(e);
+    const c = this._validatePhaseBinding(r, s, i, !0);
+    this._workGraph.assertSubscriptionAllowed(e, t);
+    let n;
+    const a = new U(
+      (_) => this._runUntracked(_),
+      () => s(n.task)
+    );
+    n = this._execution.bindTask(
+      c,
+      e,
+      s,
+      i.priority ?? 0,
+      a.deliver
+    ), o && n.pause();
+    let h;
+    try {
+      h = this._workGraph.subscribe(
+        t,
+        i.include,
+        n.enqueue
+      );
+    } catch (_) {
+      throw n.dispose(), _;
+    }
+    const d = () => a.stop(() => {
+      const _ = [];
+      try {
+        h();
+      } catch (m) {
+        _.push(m);
+      }
+      try {
+        n.dispose();
+      } catch (m) {
+        _.push(m);
+      }
+      y(_, "[Raph] Phase watch disposal failed.");
+    }), l = this._own(d, e), f = i.initial ?? "scheduled";
+    try {
+      f !== "none" && n.schedule(), f === "sync" && this.flush();
+    } catch (_) {
+      try {
+        l();
+      } catch (m) {
+        throw new AggregateError(
+          [_, m],
+          "[Raph] Phase watch registration and rollback failed."
+        );
+      }
+      throw _;
+    }
+    return {
+      dispose: l,
+      pause: n.pause,
+      resume: n.resume
+    };
+  }
+  aggregate(e, t) {
+    return this._assertOwnerRuntime(e), this._workGraph.createAggregate(e, t);
+  }
+  /** Creates a lazy root-owned metadata event source for phase watches. */
+  metaSource(e, t = {}) {
+    this._assertAlive(), J(e, t);
+    const r = this._workGraph.createProducer(this.rootScope, "path"), s = this._workGraph.producerHooks(r).onDispose, i = N._create(
+      this.rootScope,
+      e,
+      t,
+      () => this.kernel._watchMeta(
+        i.masks,
+        ({ events: o }) => this._workGraph.notifyProducerEvents(r, o, !1),
+        i.options,
+        (o) => {
+          o && this._execution.request();
+        }
+      ),
+      () => s(!1)
+    );
+    i._bindOwner(this.rootScope._adoptResource(() => i._disposeOwned()));
+    try {
+      return this._workGraph.setProducerActivation(r, () => i._activate(), !0), this._workGraph.attachProducer(r, i), i;
+    } catch (o) {
+      try {
+        i.dispose();
+      } catch (c) {
+        throw new AggregateError(
+          [o, c],
+          "[Raph] Meta source activation and rollback failed."
+        );
+      }
+      throw o;
+    }
+  }
+  path(e, t = {}) {
+    this._assertAlive();
+    const r = P(e, t), s = this._pathHandles ?? (this._pathHandles = /* @__PURE__ */ new Map()), i = s.get(r.canonical);
+    if (i !== void 0)
+      return i;
+    const o = this._workGraph.createProducer(this.rootScope, "path"), c = this._workGraph.producerHooks(o), n = new z(
+      this.kernel,
+      r,
+      t,
+      (a) => this._releasePathHandle(a),
+      this._reactivity,
+      () => this._assertAlive(),
+      () => this._assertTrackedRead(),
+      this.configuration.enforceActions ? () => this._assertWriteAllowed() : void 0,
+      (a) => this._runWrite(a),
+      { token: o, onDispose: c.onDispose },
+      ({ events: a }, h) => this._workGraph.notifyProducerEvents(o, a, !0, h)
+    );
+    try {
+      return this._workGraph.setProducerActivation(o, () => n._activate(), !0), this._workGraph.attachProducer(o, n), s.set(r.canonical, n), n;
+    } catch (a) {
+      let h, d = !1;
+      try {
+        n.dispose();
+      } catch (l) {
+        d = !0, h = l;
+      }
+      throw s.size === 0 && this._pathHandles === s && (this._pathHandles = void 0), d ? new AggregateError(
+        [a, h],
+        "[Raph] Path source activation and rollback failed."
+      ) : a;
+    }
+  }
+  get(e, t) {
+    this._assertTrackedRead();
+    const r = e ?? "";
+    return this._reactivity._isTracking() ? this.path(r, t)._getTracked() : this.kernel.get(r, t);
+  }
+  peek(e, t) {
+    return this._assertAlive(), this.kernel.peek(e ?? "", t);
+  }
+  has(e, t) {
+    return this._assertAlive(), this.kernel.has(e, t);
+  }
+  set(e, t, r) {
+    this._assertWriteAllowed(), this._runWrite(() => this.kernel.set(e, t, r));
+  }
+  merge(e, t, r) {
+    this._assertWriteAllowed(), this._runWrite(() => this.kernel.merge(e, t, r));
+  }
+  delete(e, t) {
+    this._assertWriteAllowed(), this._runWrite(() => this.kernel.delete(e, t));
+  }
+  batch(e) {
+    return this._batch(e, !0);
+  }
+  /** Batches an internal reactive-only commit without opening an unused Kernel boundary. @internal */
+  _batchReactive(e) {
+    return this._batch(e, !1);
+  }
+  _batch(e, t) {
+    this._assertAlive(), this._batchDepth++;
+    let r, s, i = !1;
+    try {
+      r = this._reactivity.batch(() => t ? this.kernel.batch(e) : e());
+    } catch (c) {
+      i = !0, s = c;
+    }
+    this._batchDepth--;
+    const o = this._finishExecutionBoundary();
+    if (i)
+      throw o.length !== 0 ? new AggregateError(
+        [s, ...o],
+        "[Raph] Batch and scheduled phase execution failed."
+      ) : s;
+    return y(o, "[Raph] Batch phase execution failed."), r;
+  }
+  action(e, t, r) {
+    const s = typeof e == "function" ? e : t, i = typeof e == "function" ? t instanceof D ? t : this.rootScope : r ?? this.rootScope, o = typeof e == "string" ? e : `action#${++this._actionCounter}`;
+    if (this._assertOwnerRuntime(i), typeof s != "function")
+      throw new TypeError("[Raph] Action operation must be a function.");
+    if (!o.trim())
+      throw new Error("[Raph] Action name must not be empty.");
+    return (...c) => {
+      i._assertAlive();
+      const n = this._debugController.nextOperationId("action"), h = this._traceCauseStack.at(-1) ?? n;
+      this._debugController.record({
+        ...h === void 0 ? {} : { causeId: h },
+        kind: "action",
+        name: o,
+        ...n === void 0 ? {} : { operationId: n },
+        status: "start"
+      }), h !== void 0 && this._traceCauseStack.push(h), this._actionDepth++;
+      try {
+        const d = this.batch(() => this._runUntracked(() => s(...c)));
+        return this._debugController.record({
+          ...h === void 0 ? {} : { causeId: h },
+          kind: "action",
+          name: o,
+          ...n === void 0 ? {} : { operationId: n },
+          status: "end"
+        }), d;
+      } catch (d) {
+        throw this._debugController.record({
+          ...h === void 0 ? {} : { causeId: h },
+          details: { message: C(d) },
+          kind: "action",
+          name: o,
+          ...n === void 0 ? {} : { operationId: n },
+          status: "error"
+        }), this._debugController.record({
+          ...h === void 0 ? {} : { causeId: h },
+          details: { message: C(d) },
+          kind: "error",
+          name: `action:${o}`,
+          ...n === void 0 ? {} : { operationId: n },
+          status: "error"
+        }), d;
+      } finally {
+        this._actionDepth--, h !== void 0 && this._traceCauseStack.pop();
+      }
+    };
+  }
+  untracked(e) {
+    return this._assertAlive(), this._runUntracked(e);
+  }
+  scope(e) {
+    return this._assertAlive(), new D(e, this);
+  }
+  node(e, t) {
+    this._assertAlive();
+    const r = this._runNodeMutation(() => {
+      const s = e.parent ?? this.root, i = q(s, e, this);
+      try {
+        const o = t == null ? void 0 : t(i);
+        return i._assertAlive(), s._assertAlive(), i._setApi(o), i._publishCreation(), i;
+      } catch (o) {
+        try {
+          i.dispose();
+        } catch (c) {
+          throw new AggregateError([o, c], `[Raph] Node "${i.id}" setup and cleanup failed.`);
+        }
+        throw o;
+      }
+    });
+    return r._assertAlive(), r;
+  }
+  getNode(e) {
+    this._assertAlive();
+    const t = [this.root];
+    for (; t.length !== 0; ) {
+      const r = t.pop();
+      if (r.id === e)
+        return r;
+      t.push(...r.children);
+    }
+  }
+  definePhases(e) {
+    this._execution.definePhases(e);
+  }
+  addPhase(e) {
+    this._execution.addPhase(e);
+  }
+  clearPhases() {
+    var e;
+    this._assertAlive(), (e = this._phases) == null || e.clearPhases();
+  }
+  requestExecution() {
+    var e;
+    this._assertAlive(), (e = this._phases) == null || e.request();
+  }
+  flush() {
+    var e;
+    this._assertAlive(), this._executionRequested = !1, (e = this._phases) == null || e.flush();
+  }
+  afterFlush() {
+    var e;
+    return this._assertAlive(), ((e = this._phases) == null ? void 0 : e.afterFlush()) ?? Promise.resolve();
+  }
+  acquireLoop(e) {
+    return this._assertAlive(), this._clock.acquire(e);
+  }
+  startLoop() {
+    this._assertAlive(), this._clock.start();
+  }
+  stopLoop() {
+    var e;
+    (e = this._frameLoop) == null || e.stop();
+  }
+  derive(e) {
+    this._assertAlive();
+    const t = e.compute, r = this.kernel.derive({
+      ...e,
+      compute: (s) => this._runUntracked(() => t(s))
+    });
+    return this._own(() => r.dispose(), this.rootScope), r;
+  }
+  dispose() {
+    var c, n;
+    if (this._disposed)
+      return;
+    this._disposed = !0, this._executionRequested = !1, this._signalLifecycle.owner = void 0;
+    const e = [], t = [...this._owners];
+    try {
+      (c = this._frameLoop) == null || c.dispose();
+    } catch (a) {
+      e.push(a);
+    }
+    this._frameLoop = void 0;
+    try {
+      (n = this._phases) == null || n.dispose();
+    } catch (a) {
+      e.push(a);
+    }
+    this._phases = void 0;
+    try {
+      this.root.dispose();
+    } catch (a) {
+      e.push(a);
+    }
+    for (const a of t.reverse())
+      if (!(a === this.root || a === this.rootScope || a.disposed))
+        try {
+          a.dispose();
+        } catch (h) {
+          e.push(h);
+        }
+    try {
+      this.rootScope.dispose();
+    } catch (a) {
+      e.push(a);
+    }
+    const r = `[Raph] Runtime "${this.id}" is disposed.`, s = () => {
+      throw new A(r);
+    };
+    try {
+      L(this._reactivity, {
+        assertRead: s,
+        assertWrite: s,
+        throwForeign: s
+      });
+    } catch (a) {
+      e.push(a);
+    }
+    this._owners.clear(), this._meta = void 0;
+    const i = this._pathHandles;
+    if (this._pathHandles = void 0, i !== void 0) {
+      for (const a of i.values())
+        try {
+          a.dispose();
+        } catch (h) {
+          e.push(h);
+        }
+      i.clear();
+    }
+    try {
+      this._workGraph.dispose();
+    } catch (a) {
+      e.push(a);
+    }
+    try {
+      this.kernel._detachRuntime(this);
+    } catch (a) {
+      e.push(a);
+    }
+    const o = [...this._disposedListeners];
+    this._disposedListeners.clear();
+    for (const a of o)
+      try {
+        a();
+      } catch (h) {
+        e.push(h);
+      }
+    y(e, `[Raph] Runtime "${this.id}" disposal failed.`);
+  }
+  /** @internal */
+  _onDisposed(e) {
+    return this._disposed ? (e(), () => {
+    }) : (this._disposedListeners.add(e), () => {
+      this._disposedListeners.delete(e);
+    });
+  }
+  /** @internal */
+  _notifyNodeStructure(e, t, r, s) {
+    this._runNodeMutation(() => {
+      this._workGraph.notifyNode(e, "structure", { structure: t, oldAncestors: r, newAncestors: s });
+    });
+  }
+  /** @internal */
+  _notifyNodeTouch(e, t) {
+    this._runNodeMutation(() => this._workGraph.notifyNode(e, "touch", { metadata: t }));
+  }
+  /** @internal */
+  _assertNodeReparentAllowed(e, t) {
+    this._workGraph.assertReparentAllowed(e, t);
+  }
+  /** @internal */
+  _releaseNode(e) {
+    this._workGraph.releaseNode(e);
+  }
+  /** @internal */
+  _runNodeMutation(e) {
+    return this._runWrite(e);
+  }
+  /** @internal */
+  _runPhaseTransition(e) {
+    return this._runWrite(e, !1);
+  }
+  /** @internal */
+  _beginOwnerDisposal() {
+    this._ownerDisposalDepth++;
+  }
+  /** @internal */
+  _endOwnerDisposal() {
+    this._ownerDisposalDepth !== 0 && (this._ownerDisposalDepth--, this._clearTransientCausesIfSettled(), this._disposed || this._requestExecution());
+  }
+  /** @internal */
+  _ownerDisposalActive() {
+    return this._ownerDisposalDepth !== 0;
+  }
+  /** @internal */
+  _registerOwner(e) {
+    this._assertAlive(), this._owners.add(e);
+  }
+  /** @internal */
+  _unregisterOwner(e) {
+    this._owners.delete(e);
+  }
+  /** @internal */
+  _assertOwnerRuntime(e) {
+    if (this._assertAlive(), e.runtime !== this)
+      throw new k("[Raph] Owner belongs to another runtime.");
+    e._assertAlive();
+  }
+  /** @internal */
+  _beginKernelBatch() {
+    this._disposed || this._kernelBatchDepth++;
+  }
+  /** @internal */
+  _endKernelBatch() {
+    this._kernelBatchDepth !== 0 && (this._kernelBatchDepth--, this._clearTransientCausesIfSettled(), this._disposed || this._requestExecution());
+  }
+  /** Регистрирует read-only diagnostics projection optional Machine. @internal */
+  _registerMachineDebug(e) {
+    return this._assertAlive(), this._debugController.registerMachine(e);
+  }
+  /**
+   * Проверяет optional diagnostic identity без создания public facade.
+   *
+   * @internal
+   */
+  _hasMachineDebug(e) {
+    return this._debugController.hasMachine(e);
+  }
+  /**
+   * Проверяет optional trace path без выделения operation ID.
+   *
+   * @internal
+   */
+  _traces(e) {
+    return this._debugController.traces(e);
+  }
+  /** Возвращает наследуемый cause для optional execution layers. @internal */
+  _currentTraceCauseId() {
+    return this._traceCauseStack.at(-1);
+  }
+  /** Выдаёт operation id только на активном trace path. @internal */
+  _nextTraceOperation(e) {
+    return this._debugController.nextOperationId(e);
+  }
+  /**
+   * Проверяет, должен ли untracked work изолировать reactive или Runtime owner context.
+   *
+   * @internal
+   */
+  _hasActiveReactiveContext() {
+    return this._assertAlive(), this._reactivity.hasActiveContext();
+  }
+  /** Записывает optional trace event без machine dependency. @internal */
+  _recordTrace(e) {
+    this._debugController.record(e);
+  }
+  /** Наследует cause через outputs/tasks optional execution layers. @internal */
+  _runWithTraceCause(e, t) {
+    if (e === void 0)
+      return t();
+    this._traceCauseStack.push(e);
+    try {
+      return t();
+    } finally {
+      this._traceCauseStack.pop();
+    }
+  }
+  _validatePhaseBinding(e, t, r, s = !1) {
+    if (typeof t != "function")
+      throw new TypeError("[Raph] Phase callback must be a function.");
+    const i = e.trim();
+    this._execution.requirePhase(i);
+    const o = r.priority ?? 0;
+    if (!Number.isFinite(o))
+      throw new TypeError("[Raph] Effect priority must be finite.");
+    const c = r.initial ?? "scheduled";
+    if (c !== "scheduled" && c !== "sync" && !(s && c === "none"))
+      throw new TypeError(`[Raph] Unsupported effect initial mode "${String(c)}".`);
+    return i;
+  }
+  _createDebugSnapshot() {
+    var r, s, i;
+    const e = ((r = this._frameLoop) == null ? void 0 : r._debugState()) ?? { running: !1, manual: !1, leases: 0 }, t = [...this._owners].filter((o) => o !== this.rootScope && !(o instanceof g)).map(b);
+    return Object.freeze({
+      id: this.id,
+      disposed: this._disposed,
+      pending: !this._disposed && (this._executionRequested || (((s = this._phases) == null ? void 0 : s._debugPending()) ?? !1)),
+      batchDepth: this._batchDepth,
+      kernelBatchDepth: this._kernelBatchDepth,
+      owners: this._owners.size,
+      pathHandles: ((i = this._pathHandles) == null ? void 0 : i.size) ?? 0,
+      rootScope: b(this.rootScope),
+      scopes: Object.freeze(t),
+      root: b(this.root),
+      frameLoop: Object.freeze(e),
+      actionDepth: this._actionDepth,
+      machines: this._debugController.machineCount,
+      traceEvents: this._debugController.traceSize
+    });
+  }
+  _createDebugTree() {
+    const e = this._debugController.machineTreeNodesByOwner(), t = [
+      R(this.rootScope, e),
+      R(this.root, e),
+      ...[...this._owners].filter((r) => r !== this.rootScope && r !== this.root && !(r instanceof g)).map((r) => R(r, e))
+    ];
+    return Object.freeze({
+      children: Object.freeze(t),
+      disposed: this._disposed,
+      id: this.id,
+      kind: "runtime"
+    });
+  }
+  _createDebugStats() {
+    var i, o;
+    let e = 0, t = 0, r = 0, s = 0;
+    for (const c of this._owners)
+      c instanceof g ? e++ : t++, r += c._debugResourceCount(), s += c._debugSourceCount();
+    return Object.freeze({
+      actors: this._debugController.actorCount,
+      machines: this._debugController.machineCount,
+      nodes: e,
+      owners: this._owners.size,
+      pathHandles: ((i = this._pathHandles) == null ? void 0 : i.size) ?? 0,
+      pending: !this._disposed && (this._executionRequested || (((o = this._phases) == null ? void 0 : o._debugPending()) ?? !1)),
+      resources: r,
+      scopes: t,
+      sources: s,
+      traceEvents: this._debugController.traceSize
+    });
+  }
+  _releasePathHandle(e) {
+    const t = this._pathHandles;
+    (t == null ? void 0 : t.get(e.path)) === e && (t.delete(e.path), t.size === 0 && (this._pathHandles = void 0));
+  }
+  get _execution() {
+    return this._assertAlive(), this._phases ?? (this._phases = new H(
+      this.configuration.scheduler,
+      (e) => this._runUntracked(e),
+      (e) => this._workGraph.causeForToken(e),
+      () => {
+        const e = this._mutationDepth !== 0 || this._batchDepth !== 0 || this._kernelBatchDepth !== 0 || this._ownerDisposalDepth !== 0 || this._reactivity._isFlushingEffects();
+        return e && this.configuration.scheduler === w.Sync && (this._executionRequested = !0), e;
+      },
+      (e, t, r) => {
+        var i, o, c;
+        let s;
+        t === "start" ? (s = this._debugController.nextOperationId("phase"), s !== void 0 && (this._phaseTraceOperations ?? (this._phaseTraceOperations = /* @__PURE__ */ new Map())).set(e, s)) : (s = (i = this._phaseTraceOperations) == null ? void 0 : i.get(e), (o = this._phaseTraceOperations) == null || o.delete(e), ((c = this._phaseTraceOperations) == null ? void 0 : c.size) === 0 && (this._phaseTraceOperations = void 0)), this._debugController.record({
+          ...s === void 0 ? {} : { causeId: s },
+          ...r === void 0 ? {} : { details: { message: C(r) } },
+          kind: "phase",
+          name: e,
+          ...s === void 0 ? {} : { operationId: s },
+          status: t
+        });
+      }
+    ));
+  }
+  get _clock() {
+    return this._frameLoop ?? (this._frameLoop = new I(() => this._tickFrameLoop()));
+  }
+  _tickFrameLoop() {
+    this._disposed || this._setFrameTick(this._frameTickWritable.peek() + 1);
+  }
+  _attachWritableComputed(e, t, r) {
+    let s = t;
+    this._own(() => {
+      s = void 0;
+    }, r);
+    const i = e;
+    return i.set = (o) => {
+      r._assertAlive(), this._assertWriteAllowed(), this._runWrite(() => s(o));
+    }, i;
+  }
+  _own(e, t) {
+    try {
+      return t._adoptResource(e);
+    } catch (r) {
+      try {
+        e();
+      } catch (s) {
+        throw new AggregateError([r, s], "[Raph] Resource registration and cleanup failed.");
+      }
+      throw r;
+    }
+  }
+  _runTracked(e, t) {
+    return this._reactivity.runWithOwner(this._signalLifecycle, e, t);
+  }
+  _runUntracked(e) {
+    return this._reactivity.untrackedWithOwner(e);
+  }
+  _runWrite(e, t = !0) {
+    t && this.configuration.scheduler === w.Sync && (this._executionRequested = !0), this._mutationDepth++;
+    let r, s, i = !1;
+    try {
+      r = e();
+    } catch (c) {
+      i = !0, s = c;
+    }
+    this._mutationDepth--;
+    const o = this._finishExecutionBoundary();
+    if (i)
+      throw o.length !== 0 ? new AggregateError(
+        [s, ...o],
+        "[Raph] Mutation and scheduled phase execution failed."
+      ) : s;
+    return y(o, "[Raph] Mutation phase execution failed."), r;
+  }
+  _finishExecutionBoundary() {
+    const e = [];
+    try {
+      this._clearTransientCausesIfSettled();
+    } catch (t) {
+      e.push(t);
+    }
+    try {
+      this._requestExecution();
+    } catch (t) {
+      e.push(t);
+    }
+    return e;
+  }
+  _clearTransientCausesIfSettled() {
+    this._mutationDepth === 0 && this._batchDepth === 0 && this._kernelBatchDepth === 0 && this._ownerDisposalDepth === 0 && !this._reactivity._isFlushingEffects() && this._workGraph.clearTransientCauses();
+  }
+  _requestExecution() {
+    var e;
+    this._disposed || this.configuration.scheduler !== w.Sync || this._mutationDepth !== 0 || this._batchDepth !== 0 || this._kernelBatchDepth !== 0 || this._ownerDisposalDepth !== 0 || this._reactivity._isFlushingEffects() || this._executionRequested && (this._executionRequested = !1, (e = this._phases) == null || e.flush());
+  }
+  _assertTrackedRead() {
+    this._assertAlive();
+    const e = this._reactivity.getActiveOwner();
+    e !== void 0 && e !== this && this._throwCrossRuntime(e);
+    const t = this._reactivity.getActiveConsumerOwner();
+    t !== void 0 && this._assertImplicitDependency(this.rootScope, t);
+  }
+  /**
+   * Проверяет tracked read из optional owned source.
+   *
+   * @internal
+   */
+  _assertSourceReadable(e) {
+    this._assertAlive();
+    const t = this._reactivity.getActiveOwner();
+    t !== void 0 && t !== this && this._throwCrossRuntime(t);
+    const r = this._reactivity.getActiveConsumerOwner();
+    r !== void 0 && this._assertImplicitDependency(e, r), e._assertAlive();
+  }
+  _assertImplicitDependency(e, t) {
+    if (e.runtime !== this || t.runtime !== this)
+      throw new k("[Raph] Implicit dependency crosses runtime boundaries.");
+    if (!(e === this.rootScope || e === t)) {
+      if (e instanceof g && t instanceof g) {
+        for (let r = t.parent; r !== null; r = r.parent)
+          if (r === e)
+            return;
+      }
+      throw new Error(
+        `[Raph] Implicit dependency from "${t.id}" to "${e.id}" is not allowed; use watch().`
+      );
+    }
+  }
+  _assertWriteAllowed() {
+    if (this._assertAlive(), this.configuration.enforceActions && this._batchDepth === 0)
+      throw new B("[Raph] Writes are allowed only inside action() or batch().");
+  }
+  _throwCrossRuntime(e) {
+    throw new k(
+      `[Raph] Runtime "${this.id}" cannot be tracked by runtime "${e.id}".`
+    );
+  }
+  _assertAlive() {
+    if (this._disposed)
+      throw new A(`[Raph] Runtime "${this.id}" is disposed.`);
+  }
+};
+u(v, "_runtimeCounter", 0);
+let S = v;
+function K(p) {
+  return p === w.Sync || p === w.Microtask || p === w.AnimationFrame;
+}
+function J(p, e) {
+  const t = Array.isArray(p) ? p : [p];
+  if (t.length === 0)
+    throw new TypeError("[RaphMeta] watch requires at least one mask.");
+  if (e.namespace !== void 0 && !e.namespace.trim())
+    throw new Error("[RaphMeta] namespace must not be empty.");
+  for (const r of t)
+    x.from(r, e)._asMask();
+}
+function C(p) {
+  return p instanceof Error ? p.message : String(p);
+}
+export {
+  S as RaphRuntime
+};