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

package/dist/debug/runtime/RaphRuntime.js

@@ -1,700 +1,979 @@
-var W = Object.defineProperty;
-var b = (a, t, e) => t in a ? W(a, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : a[t] = e;
-var h = (a, t, e) => b(a, typeof t != "symbol" ? t + "" : t, e);
-import { RaphDisposedError as R, RaphCrossRuntimeError as k, RaphActionError as T } from "./errors.js";
-import { parentGraph as x } from "./parent-graph.js";
-import { PathHandle as L } from "./PathHandle.js";
-import { RaphSchedulerType as d } from "./phase.types.js";
-import { RaphNode as m } from "./RaphNode.js";
-import { parseDataPath as q, DataPath as A } from "../path/data-path.js";
-import { RaphKernel as O } from "../path/RaphKernel.js";
-import { RaphMeta as M } from "../path/RaphMeta.js";
-import { watchWithReactivity as $ } from "../reactivity/watch.js";
-import { throwDisposalErrors as D } from "./disposal.js";
-import { createOwnerSnapshot as y } from "./RaphDebug.js";
-import { RaphFrameLoop as H } from "./RaphFrameLoop.js";
-import { RaphPhasePipeline as F } from "./RaphPhasePipeline.js";
-import { RaphScope as S } from "./RaphScope.js";
-import { RuntimeReactivity as U } from "./RuntimeReactivity.js";
-import { RuntimeWatch as g } from "./RuntimeWatch.js";
+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 {
-  /**
-   * Создаёт изолированный execution graph поверх собственного или shared Kernel.
-   */
-  constructor(t = {}) {
-    // Публикуют immutable configuration и корневых lifecycle owners.
-    h(this, "configuration");
-    h(this, "rootScope");
-    h(this, "root");
-    // Владеют изолированным reactive graph и его runtime policy.
-    h(this, "_reactivity");
-    h(this, "_signalLifecycle");
-    // Лениво создают adapters и diagnostics только по запросу consumer.
-    h(this, "_pathHandles");
-    h(this, "_meta");
-    h(this, "_phases");
-    h(this, "_frameLoop");
-    h(this, "_frameRevision");
-    h(this, "_frameRevisionValue", !1);
-    h(this, "_debug");
-    h(this, "_parentGraph");
-    // Регистрируют всех lifecycle owners runtime.
-    h(this, "_owners", /* @__PURE__ */ new Set());
-    // Координируют вложенные write boundaries и execution requests.
-    h(this, "_transactionDepth", 0);
-    h(this, "_mutationDepth", 0);
-    h(this, "_kernelTransactionDepth", 0);
-    h(this, "_actionDepth", 0);
-    h(this, "_executionRequested", !1);
-    // Хранят окончательное состояние runtime и dispose listeners.
-    h(this, "_disposed", !1);
-    h(this, "_disposedListeners", /* @__PURE__ */ new Set());
-    const e = t.id ?? `runtime-${v._runtimeCounter++}`, s = t.enforceActions ?? !1, i = t.scheduler ?? d.Sync;
-    if (!I(i))
+  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 r = t.kernel ?? new O({ id: `${e}-kernel` });
-    this.configuration = Object.freeze({ id: e, kernel: r, enforceActions: s, scheduler: i });
-    const o = `[Raph] Runtime "${e}" is disposed.`;
+    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: (n) => this._runWrite(n),
+      runWrite: (d) => this._runWrite(d),
+      assertDependencyAllowed: (d, l) => {
+        this._assertImplicitDependency(d, l);
+      },
       ...s ? { assertWriteAllowed: () => this._assertWriteAllowed() } : {},
       throwDisposed: () => {
-        throw new R(o);
+        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);
       },
-      throwCrossRuntime: (n) => this._throwCrossRuntime(n)
-    }, this._reactivity = new U(this._signalLifecycle), r._attachRuntime(this), this.rootScope = new S(`${e}:root-scope`, this), this.root = new m(null, { id: `${e}:root` }, this);
+      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
+    });
   }
-  /**
-   * Возвращает внутренний runtime reactivity adapter.
-   * @internal
-   */
+  /** @internal */
   _getReactivity() {
     return this._reactivity;
   }
   /**
-   * Возвращает стабильный идентификатор runtime.
+   * Возвращает внутренний WorkGraph для optional execution layers.
+   *
+   * @internal
    */
+  _getWorkGraph() {
+    return this._workGraph;
+  }
   get id() {
     return this.configuration.id;
   }
-  /**
-   * Возвращает data/meta Kernel этого runtime.
-   */
   get kernel() {
     return this.configuration.kernel;
   }
-  /**
-   * Возвращает лениво созданный runtime-owned metadata facade.
-   */
-  get meta() {
-    return this._assertAlive(), this._meta ?? (this._meta = new M(this.kernel, {
-      assertReadable: () => this._assertAlive(),
-      assertWritable: () => this._assertWriteAllowed(),
-      runWrite: (t, e) => this._runWrite(t, e),
-      watch: (t, e, s) => this._own(
-        this._watchMeta(t, e, s),
-        this.rootScope
-      )
-    }));
-  }
-  /**
-   * Показывает, освобождён ли runtime.
-   */
   get disposed() {
     return this._disposed;
   }
-  /**
-   * Возвращает лениво созданное read-only представление ownership graph.
-   */
   get graph() {
-    return this._parentGraph ?? (this._parentGraph = x());
+    return this._parentGraph ?? (this._parentGraph = F());
   }
-  /**
-   * Показывает, удерживается ли автоматический frame-loop.
-   */
   get loopEnabled() {
-    var t;
-    return ((t = this._frameLoop) == null ? void 0 : t.running) ?? !1;
+    var e;
+    return ((e = this._frameLoop) == null ? void 0 : e.running) ?? !1;
   }
-  /**
-   * Возвращает последний frame context runtime pipeline.
-   */
   get frame() {
-    var t;
-    return ((t = this._phases) == null ? void 0 : t.frame) ?? { now: 0, delta: 0, elapsed: 0, frame: 0 };
+    var e;
+    return ((e = this._phases) == null ? void 0 : e.frame) ?? { now: 0, delta: 0, elapsed: 0, frame: 0 };
   }
-  /**
-   * Возвращает текущее определение runtime phases.
-   */
   get phases() {
-    var t;
-    return ((t = this._phases) == null ? void 0 : t.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)
+    });
   }
-  /**
-   * Формирует диагностический снимок materialized derived registry.
-   */
   getDerivedSnapshot() {
     return this.kernel.getDerivedSnapshot();
   }
-  /**
-   * Возвращает лениво созданную read-only диагностику runtime и ownership tree.
-   */
   get debug() {
     return this._debug ?? (this._debug = Object.freeze({
       snapshot: () => this._createDebugSnapshot(),
-      getTree: () => y(this.root)
+      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);
+  }
   /**
-   * Создаёт writable signal, принадлежащий указанному owner.
+   * 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.
    */
-  signal(t, e = this.rootScope) {
-    return this._assertOwnerRuntime(e), this._reactivity.signalForOwner(t, e);
+  reactive(e) {
+    return this._assertAlive(), this._reactivity.reactive(e);
   }
-  computed(t, e = this.rootScope) {
+  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 s = typeof t == "function" ? t : t.get, i = this._reactivity.computedForOwner(
-      () => this._runTracked(s),
-      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();
+        }
+      )
     );
-    return typeof t == "function" ? i : this._attachWritableComputed(i, t.set, e);
-  }
-  effect(t, e, s = {}, i = this.rootScope) {
-    const r = typeof t == "string" ? e : t, o = typeof t == "string" ? i : e ?? this.rootScope;
-    if (this._assertOwnerRuntime(o), typeof t == "string") {
-      const n = t.trim(), c = this._execution;
-      c.requirePhase(n);
-      const p = s.priority ?? 0, u = s.initial ?? "scheduled";
-      if (!Number.isFinite(p))
-        throw new TypeError("[Raph] Effect priority must be finite.");
-      if (u !== "scheduled" && u !== "sync")
-        throw new TypeError(`[Raph] Unsupported effect initial mode "${String(u)}".`);
-      u === "sync" && c.lockConfiguration();
-      const l = c.phaseMode(n) === "always" ? this._frameRevision ?? (this._frameRevision = this._reactivity.signal(!1)) : void 0, w = this._reactivity.withEffectBinding(
-        (_) => c.bindEffect(
-          n,
-          p,
-          _,
-          o instanceof m ? o : void 0
-        ),
-        u,
-        () => this._reactivity.effect(() => (l == null || l.get(), this._runTracked(r)))
-      );
-      return this._own(w, o);
+    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 this._own(
-      this._reactivity._effectImmediate(() => this._runTracked(r)),
-      o
-    );
+    return {
+      dispose: () => h == null ? void 0 : h(),
+      pause: () => a == null ? void 0 : a.pause(),
+      resume: () => a == null ? void 0 : a.resume()
+    };
   }
-  watch(t, e, s = {}, i = this.rootScope) {
-    return this._assertOwnerRuntime(i), z(t) ? this._own(this._watchPath(t, e), i) : this._own(
-      $(
-        this._reactivity._effectImmediate,
-        this._reactivity.untracked,
+  /** 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,
-        e,
-        s,
-        (r) => this._runTracked(r)
+        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();
+        }
       ),
-      i
+      () => 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;
+    }
   }
-  /**
-   * Возвращает кешируемый runtime-owned handle canonical path.
-   */
-  path(t, e = {}) {
+  path(e, t = {}) {
     this._assertAlive();
-    const s = q(t, e), i = this._pathHandles ?? (this._pathHandles = /* @__PURE__ */ new Map()), r = i.get(s.canonical);
-    if (r !== void 0)
-      return r;
-    const o = new L(
+    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,
-      s,
-      e,
-      (n) => this._releasePathHandle(n),
+      r,
+      t,
+      (a) => this._releasePathHandle(a),
       this._reactivity,
       () => this._assertAlive(),
       () => this._assertTrackedRead(),
       this.configuration.enforceActions ? () => this._assertWriteAllowed() : void 0,
-      (n) => this._runWrite(n)
+      (a) => this._runWrite(a),
+      { token: o, onDispose: c.onDispose },
+      ({ events: a }, h) => this._workGraph.notifyProducerEvents(o, a, !0, h)
     );
-    return i.set(s.canonical, o), o;
+    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(t, e) {
+  get(e, t) {
     this._assertTrackedRead();
-    const s = t ?? "";
-    return this._reactivity._isTracking() ? this.path(s, e)._getTracked() : this.kernel.get(s, e);
+    const r = e ?? "";
+    return this._reactivity._isTracking() ? this.path(r, t)._getTracked() : this.kernel.get(r, t);
   }
-  peek(t, e) {
-    return this._assertAlive(), this.kernel.peek(t ?? "", e);
+  peek(e, t) {
+    return this._assertAlive(), this.kernel.peek(e ?? "", t);
   }
-  /**
-   * Проверяет наличие значения Kernel по пути.
-   */
-  has(t, e) {
-    return this._assertAlive(), this.kernel.has(t, e);
+  has(e, t) {
+    return this._assertAlive(), this.kernel.has(e, t);
   }
-  /**
-   * Записывает значение Kernel внутри runtime write policy.
-   */
-  set(t, e, s) {
-    this._assertWriteAllowed(), this._runWrite(() => this.kernel.set(t, e, s));
+  set(e, t, r) {
+    this._assertWriteAllowed(), this._runWrite(() => this.kernel.set(e, t, r));
   }
-  /**
-   * Объединяет значение Kernel внутри runtime write policy.
-   */
-  merge(t, e, s) {
-    this._assertWriteAllowed(), this._runWrite(() => this.kernel.merge(t, e, s));
+  merge(e, t, r) {
+    this._assertWriteAllowed(), this._runWrite(() => this.kernel.merge(e, t, r));
   }
-  /**
-   * Удаляет значение Kernel внутри runtime write policy.
-   */
-  delete(t, e) {
-    this._assertWriteAllowed(), this._runWrite(() => this.kernel.delete(t, e));
+  delete(e, t) {
+    this._assertWriteAllowed(), this._runWrite(() => this.kernel.delete(e, t));
   }
-  /**
-   * Выполняет операцию в общей синхронной transaction boundary.
-   */
-  transaction(t) {
-    this._assertAlive(), this._transactionDepth++;
-    try {
-      return this._reactivity.batch(() => this.kernel.transaction(t));
-    } finally {
-      this._transactionDepth--, this._requestExecution();
-    }
+  batch(e) {
+    return this._batch(e, !0);
   }
-  /**
-   * Создаёт именованную action boundary для разрешённых записей.
-   */
-  action(t, e, s = this.rootScope) {
-    if (this._assertOwnerRuntime(s), !t.trim())
-      throw new Error("[Raph] Action name must not be empty.");
-    return (...i) => (s._assertAlive(), this.runInAction(t, () => e(...i)));
+  /** Batches an internal reactive-only commit without opening an unused Kernel boundary. @internal */
+  _batchReactive(e) {
+    return this._batch(e, !1);
   }
-  /**
-   * Выполняет операцию внутри action boundary.
-   */
-  runInAction(t, e) {
-    this._assertAlive(), this._actionDepth++;
+  _batch(e, t) {
+    this._assertAlive(), this._batchDepth++;
+    let r, s, i = !1;
     try {
-      return this.transaction(() => this._runUntracked(e));
-    } finally {
-      this._actionDepth--;
+      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(t) {
-    return this._assertAlive(), this._reactivity.untrackedWithOwner(t);
+  untracked(e) {
+    return this._assertAlive(), this._runUntracked(e);
   }
-  /**
-   * Создаёт дочерний lifecycle scope.
-   */
-  scope(t) {
-    return this._assertAlive(), new S(t, this);
+  scope(e) {
+    return this._assertAlive(), new D(e, this);
   }
-  /**
-   * Создаёт дочерний execution node.
-   */
-  node(t, e) {
+  node(e, t) {
     this._assertAlive();
-    const s = t.parent ?? this.root, i = new m(s, t, this);
-    try {
-      return i._setApi(e(i)), i;
-    } catch (r) {
+    const r = this._runNodeMutation(() => {
+      const s = e.parent ?? this.root, i = q(s, e, this);
       try {
-        i.dispose();
+        const o = t == null ? void 0 : t(i);
+        return i._assertAlive(), s._assertAlive(), i._setApi(o), i._publishCreation(), i;
       } catch (o) {
-        throw new AggregateError(
-          [r, o],
-          `[Raph] Node "${i.id}" setup and cleanup failed.`
-        );
+        try {
+          i.dispose();
+        } catch (c) {
+          throw new AggregateError([o, c], `[Raph] Node "${i.id}" setup and cleanup failed.`);
+        }
+        throw o;
       }
-      throw r;
-    }
+    });
+    return r._assertAlive(), r;
   }
-  /**
-   * Находит принадлежащий runtime node по id для диагностики.
-   */
-  getNode(t) {
+  getNode(e) {
     this._assertAlive();
-    const e = [this.root];
-    for (; e.length !== 0; ) {
-      const s = e.pop();
-      if (s.id === t)
-        return s;
-      e.push(...s.children);
+    const t = [this.root];
+    for (; t.length !== 0; ) {
+      const r = t.pop();
+      if (r.id === e)
+        return r;
+      t.push(...r.children);
     }
   }
-  /**
-   * Заменяет полное определение phase pipeline до его первого выполнения.
-   */
-  definePhases(t) {
-    this._execution.definePhases(t);
+  definePhases(e) {
+    this._execution.definePhases(e);
   }
-  /**
-   * Добавляет phase до первого выполнения pipeline.
-   */
-  addPhase(t) {
-    this._execution.addPhase(t);
+  addPhase(e) {
+    this._execution.addPhase(e);
   }
-  /**
-   * Удаляет пользовательские phases до первого выполнения pipeline.
-   */
   clearPhases() {
-    var t;
-    this._assertAlive(), (t = this._phases) == null || t.clearPhases();
-  }
-  /**
-   * Регистрирует path observer в phase pipeline.
-   */
-  observeData(t, e, s) {
-    return this._assertOwnerRuntime(t), this._own(this._execution.observeData(t, e, s), t);
+    var e;
+    this._assertAlive(), (e = this._phases) == null || e.clearPhases();
   }
-  /**
-   * Регистрирует tracked executor указанной phase.
-   */
-  track(t, e, s = {}) {
-    return this._assertOwnerRuntime(t), this._own(this._execution.track(t, e, s), t);
-  }
-  /**
-   * Помечает node для выполнения в pipeline.
-   */
-  invalidateNode(t, e) {
-    this._assertOwnerRuntime(t), this._execution.invalidate(t, e);
+  requestExecution() {
+    var e;
+    this._assertAlive(), (e = this._phases) == null || e.request();
   }
-  /**
-   * Синхронно выполняет все готовые очереди pipeline.
-   */
   flush() {
-    var t;
-    this._assertAlive(), this._executionRequested = !1, (t = this._phases) == null || t.flush();
+    var e;
+    this._assertAlive(), this._executionRequested = !1, (e = this._phases) == null || e.flush();
   }
-  /**
-   * Получает lease автоматического frame-loop.
-   */
-  acquireLoop(t) {
-    return this._assertAlive(), this._clock.acquire(t);
+  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);
   }
-  /**
-   * Запускает manual lease автоматического frame-loop.
-   */
   startLoop() {
     this._assertAlive(), this._clock.start();
   }
-  /**
-   * Останавливает manual lease автоматического frame-loop.
-   */
   stopLoop() {
-    var t;
-    (t = this._frameLoop) == null || t.stop();
+    var e;
+    (e = this._frameLoop) == null || e.stop();
   }
-  /**
-   * Создаёт управляемое derived-представление source path в target path.
-   */
-  derive(t) {
+  derive(e) {
     this._assertAlive();
-    const e = t.compute, s = this.kernel.derive({
-      ...t,
-      compute: (i) => this._runUntracked(() => e(i))
+    const t = e.compute, r = this.kernel.derive({
+      ...e,
+      compute: (s) => this._runUntracked(() => t(s))
     });
-    return this._own(() => s.dispose(), this.rootScope), s;
+    return this._own(() => r.dispose(), this.rootScope), r;
   }
-  /**
-   * Освобождает execution graph и отсоединяет runtime от shared Kernel.
-   */
   dispose() {
-    var r, o;
+    var c, n;
     if (this._disposed)
       return;
     this._disposed = !0, this._executionRequested = !1, this._signalLifecycle.owner = void 0;
-    const t = [], e = [...this._owners];
+    const e = [], t = [...this._owners];
     try {
-      (r = this._frameLoop) == null || r.dispose();
-    } catch (n) {
-      t.push(n);
+      (c = this._frameLoop) == null || c.dispose();
+    } catch (a) {
+      e.push(a);
     }
     this._frameLoop = void 0;
     try {
-      (o = this._phases) == null || o.dispose();
-    } catch (n) {
-      t.push(n);
+      (n = this._phases) == null || n.dispose();
+    } catch (a) {
+      e.push(a);
     }
     this._phases = void 0;
     try {
       this.root.dispose();
-    } catch (n) {
-      t.push(n);
+    } catch (a) {
+      e.push(a);
     }
-    for (const n of e.reverse())
-      if (!(n === this.root || n === this.rootScope || n.disposed))
+    for (const a of t.reverse())
+      if (!(a === this.root || a === this.rootScope || a.disposed))
         try {
-          n.dispose();
-        } catch (c) {
-          t.push(c);
+          a.dispose();
+        } catch (h) {
+          e.push(h);
         }
     try {
       this.rootScope.dispose();
-    } catch (n) {
-      t.push(n);
+    } catch (a) {
+      e.push(a);
     }
-    this._owners.clear(), this._meta = void 0, this._frameRevision = void 0;
-    const s = this._pathHandles;
-    if (this._pathHandles = void 0, s !== void 0) {
-      for (const n of s.values())
+    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 {
-          n.dispose();
-        } catch (c) {
-          t.push(c);
+          a.dispose();
+        } catch (h) {
+          e.push(h);
         }
-      s.clear();
+      i.clear();
+    }
+    try {
+      this._workGraph.dispose();
+    } catch (a) {
+      e.push(a);
     }
     try {
       this.kernel._detachRuntime(this);
-    } catch (n) {
-      t.push(n);
+    } catch (a) {
+      e.push(a);
     }
-    const i = [...this._disposedListeners];
+    const o = [...this._disposedListeners];
     this._disposedListeners.clear();
-    for (const n of i)
+    for (const a of o)
       try {
-        n();
-      } catch (c) {
-        t.push(c);
+        a();
+      } catch (h) {
+        e.push(h);
       }
-    D(t, `[Raph] Runtime "${this.id}" disposal failed.`);
+    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);
   }
   /**
-   * Регистрирует listener освобождения runtime.
+   * Проверяет optional diagnostic identity без создания public facade.
+   *
    * @internal
    */
-  _onDisposed(t) {
-    return this._disposed ? (t(), () => {
-    }) : (this._disposedListeners.add(t), () => {
-      this._disposedListeners.delete(t);
-    });
+  _hasMachineDebug(e) {
+    return this._debugController.hasMachine(e);
   }
-  _watchPath(t, e) {
-    const s = new g((r) => this._runUntracked(r)), i = this.kernel.watch(t, (r) => {
-      s.deliver(() => e(r));
-    });
-    return () => s.stop(i);
+  /**
+   * Проверяет 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 s, i, r;
-    const t = ((s = this._frameLoop) == null ? void 0 : s._debugState()) ?? { running: !1, manual: !1, leases: 0 }, e = [...this._owners].filter((o) => o !== this.rootScope && !(o instanceof m)).map(y);
+    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 || (((i = this._phases) == null ? void 0 : i._debugPending()) ?? !1)),
-      transactionDepth: this._transactionDepth,
-      kernelTransactionDepth: this._kernelTransactionDepth,
+      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: ((r = this._pathHandles) == null ? void 0 : r.size) ?? 0,
-      rootScope: y(this.rootScope),
-      scopes: Object.freeze(e),
-      root: y(this.root),
-      frameLoop: Object.freeze(t)
+      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
     });
   }
-  _watchMeta(t, e, s) {
-    if (s.phase !== void 0)
-      return this._watchMetaInPhase(t, e, s);
-    if (s.priority !== void 0)
-      throw new TypeError("[RaphMeta] watch priority requires a phase.");
-    const i = new g((o) => this._runUntracked(o)), r = this.kernel._watchMeta(t, (o) => {
-      i.deliver(() => e(o));
-    }, s);
-    return () => i.stop(r);
-  }
-  _watchMetaInPhase(t, e, s) {
-    const i = s.phase.trim(), r = this._execution;
-    r.requirePhase(i);
-    const o = s.priority ?? 0;
-    if (!Number.isFinite(o))
-      throw new TypeError("[RaphMeta] watch priority must be finite.");
-    const n = r.retainPhase(i), c = new g((_) => this._runUntracked(_));
-    let p = [], u;
-    const l = () => {
-      u = void 0;
-      const _ = p;
-      p = [], c.deliver(() => e({ events: _ }));
-    };
-    let w;
-    try {
-      w = this.kernel._watchMeta(t, ({ events: _ }) => {
-        c.stopped || (p.push(..._), u === void 0 && (u = r.queueEffect(i, o, l, !1)));
-      }, s, (_) => {
-        !c.stopped && _ && u !== void 0 && r.request();
-      });
-    } catch (_) {
-      throw n(), _;
-    }
-    return () => {
-      if (c.stopped)
-        return;
-      const _ = [];
-      try {
-        c.stop(w);
-      } catch (f) {
-        _.push(f);
-      }
-      try {
-        u == null || u();
-      } catch (f) {
-        _.push(f);
-      }
-      try {
-        n();
-      } catch (f) {
-        _.push(f);
-      }
-      u = void 0, p = [], D(_, "[RaphMeta] Phase watch disposal failed.");
-    };
+  _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"
+    });
   }
-  _releasePathHandle(t) {
-    const e = this._pathHandles;
-    (e == null ? void 0 : e.get(t.path)) === t && (e.delete(t.path), e.size === 0 && (this._pathHandles = void 0));
+  _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 F(
-      this.kernel,
-      this.root,
+    return this._assertAlive(), this._phases ?? (this._phases = new H(
       this.configuration.scheduler,
-      (t) => this._runUntracked(t),
+      (e) => this._runUntracked(e),
+      (e) => this._workGraph.causeForToken(e),
       () => {
-        const t = this._mutationDepth !== 0 || this._transactionDepth !== 0 || this._kernelTransactionDepth !== 0 || this._reactivity._isFlushingEffects();
-        return t && this.configuration.scheduler === d.Sync && (this._executionRequested = !0), t;
+        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 H(() => this._tickFrameLoop()));
+    return this._frameLoop ?? (this._frameLoop = new I(() => this._tickFrameLoop()));
   }
   _tickFrameLoop() {
-    var t;
-    this._disposed || (this._frameRevision !== void 0 && (this._frameRevisionValue = !this._frameRevisionValue, this._frameRevision.set(this._frameRevisionValue)), (t = this._phases) == null || t.requestAlwaysPhases(), this._requestExecution());
+    this._disposed || this._setFrameTick(this._frameTickWritable.peek() + 1);
   }
-  _attachWritableComputed(t, e, s) {
-    let i = e;
+  _attachWritableComputed(e, t, r) {
+    let s = t;
     this._own(() => {
-      i = void 0;
-    }, s);
-    const r = t;
-    return r.set = (o) => {
-      s._assertAlive(), this._assertWriteAllowed(), i(o);
-    }, r;
-  }
-  _own(t, e) {
+      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 e._adoptResource(t);
-    } catch (s) {
+      return t._adoptResource(e);
+    } catch (r) {
       try {
-        t();
-      } catch (i) {
-        throw new AggregateError(
-          [s, i],
-          "[Raph] Resource registration and cleanup failed."
-        );
+        e();
+      } catch (s) {
+        throw new AggregateError([r, s], "[Raph] Resource registration and cleanup failed.");
       }
-      throw s;
+      throw r;
     }
   }
-  /**
-   * Регистрирует lifecycle owner в runtime registry.
-   * @internal
-   */
-  _registerOwner(t) {
-    this._assertAlive(), this._owners.add(t);
-  }
-  /**
-   * Удаляет lifecycle owner из runtime registry.
-   * @internal
-   */
-  _unregisterOwner(t) {
-    this._owners.delete(t);
-  }
-  /**
-   * Проверяет, что owner принадлежит этому живому runtime.
-   * @internal
-   */
-  _assertOwnerRuntime(t) {
-    if (this._assertAlive(), t.runtime !== this)
-      throw new k("[Raph] Owner belongs to another runtime.");
-    t._assertAlive();
+  _runTracked(e, t) {
+    return this._reactivity.runWithOwner(this._signalLifecycle, e, t);
   }
-  _runTracked(t) {
-    return this._reactivity.runWithOwner(this._signalLifecycle, t);
+  _runUntracked(e) {
+    return this._reactivity.untrackedWithOwner(e);
   }
-  _runUntracked(t) {
-    return this._reactivity.untrackedWithOwner(t);
-  }
-  _runWrite(t, e = !0) {
-    e && this.configuration.scheduler === d.Sync && (this._executionRequested = !0), this._mutationDepth++;
+  _runWrite(e, t = !0) {
+    t && this.configuration.scheduler === w.Sync && (this._executionRequested = !0), this._mutationDepth++;
+    let r, s, i = !1;
     try {
-      return t();
-    } finally {
-      this._mutationDepth--, this._requestExecution();
+      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 t;
-    this.configuration.scheduler !== d.Sync || this._mutationDepth !== 0 || this._transactionDepth !== 0 || this._kernelTransactionDepth !== 0 || this._reactivity._isFlushingEffects() || this._executionRequested && (this._executionRequested = !1, (t = this._phases) == null || t.flush());
+    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());
   }
-  /**
-   * Открывает shared Kernel transaction для runtime.
-   * @internal
-   */
-  _beginKernelTransaction() {
-    this._disposed || this._kernelTransactionDepth++;
+  _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);
   }
   /**
-   * Закрывает shared Kernel transaction и запускает отложенное выполнение.
+   * Проверяет tracked read из optional owned source.
+   *
    * @internal
    */
-  _endKernelTransaction() {
-    this._kernelTransactionDepth !== 0 && (this._kernelTransactionDepth--, this._disposed || this._requestExecution());
-  }
-  _assertTrackedRead() {
+  _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._actionDepth === 0 && this._transactionDepth === 0)
-      throw new T(
-        "[Raph] Writes are allowed only inside action() or transaction()."
-      );
+    if (this._assertAlive(), this.configuration.enforceActions && this._batchDepth === 0)
+      throw new B("[Raph] Writes are allowed only inside action() or batch().");
   }
-  _throwCrossRuntime(t) {
+  _throwCrossRuntime(e) {
     throw new k(
-      `[Raph] Runtime "${this.id}" cannot be tracked by runtime "${t.id}".`
+      `[Raph] Runtime "${this.id}" cannot be tracked by runtime "${e.id}".`
     );
   }
-  _throwDisposed() {
-    throw new R(`[Raph] Runtime "${this.id}" is disposed.`);
-  }
   _assertAlive() {
-    this._disposed && this._throwDisposed();
+    if (this._disposed)
+      throw new A(`[Raph] Runtime "${this.id}" is disposed.`);
   }
 };
-// Формирует локальный id для runtime без явно заданного имени.
-h(v, "_runtimeCounter", 0);
-let P = v;
-function z(a) {
-  return typeof a == "string" || a instanceof A || E(a) ? !0 : Array.isArray(a) && a.every(
-    (t) => typeof t == "string" || t instanceof A || E(t)
-  );
+u(v, "_runtimeCounter", 0);
+let S = v;
+function K(p) {
+  return p === w.Sync || p === w.Microtask || p === w.AnimationFrame;
 }
-function E(a) {
-  return typeof a == "object" && a !== null && "segs" in a && a.segs !== void 0 && Array.isArray(a.segs);
+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 I(a) {
-  return a === d.Sync || a === d.Microtask || a === d.AnimationFrame;
+function C(p) {
+  return p instanceof Error ? p.message : String(p);
 }
 export {
-  P as RaphRuntime
+  S as RaphRuntime
 };