@raphy-js/raph 1.0.1-dev.20 → 1.0.1-dev.26

package/dist/debug/runtime/RaphRuntime.js

@@ -1,112 +1,120 @@
-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 { parseDataPath as N } from "../path/data-path.utils.js";
+import { DataPath as B } 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 {
+import { configureReactiveObjectPolicy as q, disposeReactiveObjectContext as L } from "../reactivity/reactive-object.js";
+import { RaphDebugController as M, createOwnerSnapshot as D, createOwnerTree as S } from "./diagnostics/RaphDebug.js";
+import { RaphDisposedError as A, RaphCrossRuntimeError as b, RaphActionError as F } from "./errors.js";
+import { parentGraph as $ } from "./ownership/parentGraph.js";
+import { RaphNode as v, createProvisionalNode as H } from "./ownership/RaphNode.js";
+import { RaphScope as O } from "./ownership/RaphScope.js";
+import { throwDisposalErrors as m } from "./ownership/throwDisposalErrors.js";
+import { RaphSchedulerType as f } from "./phases/phase.types.js";
+import { RaphFrameLoop as z } from "./phases/RaphFrameLoop.js";
+import { RaphPhasePipeline as j } from "./phases/RaphPhasePipeline.js";
+import { TASK_ACTIVE as E, TASK_TASKLESS as U, GROUP_NODES as k, TASK_PENDING as C, TASK_REQUESTED as K } from "./phases/RaphPhaseTaskRecord.js";
+import { createPhaseWatch as V } from "./phases/RaphPhaseWatch.js";
+import { enqueueSweeper as Y, dequeueSweeper as P, postponeFirstSweeper as Q } from "./reactivity/disposal-sweep.utils.js";
+import { PathHandle as X } from "./reactivity/PathHandle.js";
+import { RaphMetaSource as J } from "./reactivity/RaphMetaSource.js";
+import { RaphWorkGraph as Z } from "./reactivity/RaphWorkGraph.js";
+import { RuntimeReactivity as ee } from "./reactivity/RuntimeReactivity.js";
+const y = Object.freeze({}), I = 2 ** 32 - 1 - k;
+class T {
+  static _runtimeCounter = 0;
+  mode = "runtime";
+  configuration;
+  rootScope;
+  root;
+  frameTick;
+  _reactivity;
+  _signalLifecycle;
+  _workGraph;
+  // Записываемый frame signal; наружу выдаётся только его read-only wrapper.
+  _frameTickSignal;
+  _pathHandles;
+  _meta;
+  _phases;
+  _frameLoop;
+  _debug;
+  _debugController;
+  _parentGraph;
+  // Владельцы вне списков детей в порядке регистрации: plain scopes и nodes
+  // без parent. Node с parent сюда не входит: её достигает обход детей, поэтому
+  // её создание и освобождение не стоят операции с Set.
+  _topOwners = /* @__PURE__ */ new Set();
+  // Число владельцев, зарегистрированных за всё время жизни Runtime; оно же —
+  // порядковый номер последнего из них.
+  _ownerRegistrations = 0;
+  // Runtime освободил владельцев и живых больше не числит.
+  _ownersReleased = !1;
+  _batchDepth = 0;
+  _mutationDepth = 0;
+  _kernelBatchDepth = 0;
+  _ownerDisposalDepth = 0;
+  // Node, чей dispose открыл границу освобождения, на месте глубины этой
+  // границы; у границы, открытой не node, место пусто. Node, вышедшая из списка
+  // parent до конца своего dispose, остаётся перечислимой только отсюда.
+  _disposingNodes = [];
+  // Число владельцев, освобождённых за всё время жизни Runtime.
+  _ownerDisposals = 0;
+  // Очередь участников уборки после освобождения владельцев, ближайший срок в
+  // начале, и число освобождений, при котором этот срок наступает; без
+  // участников поле пусто и срок не наступает.
+  _disposalSweepers;
+  _nextDisposalSweep = Number.POSITIVE_INFINITY;
+  _actionDepth = 0;
+  _actionCounter = 0;
+  _traceCauseStack = [];
+  _phaseTraceOperations;
+  _executionRequested = !1;
+  _disposed = !1;
+  _disposedListeners = /* @__PURE__ */ new Set();
   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))
+    const t = e.id ?? `runtime-${T._runtimeCounter++}`, s = e.adaptiveDependencyIndex ?? !1, r = e.enforceActions ?? !1, i = e.scheduler ?? f.Sync;
+    if (!oe(i))
       throw new Error(`[Raph] Unsupported scheduler "${String(i)}".`);
     const o = e.kernel ?? new G({ id: `${t}-kernel` });
     this.configuration = Object.freeze({
-      adaptiveDependencyIndex: r,
+      adaptiveDependencyIndex: s,
       ...e.debug === void 0 ? {} : { debug: e.debug },
       id: t,
       kernel: o,
-      enforceActions: s,
+      enforceActions: r,
       scheduler: i
     }), this._debugController = new M(e.debug);
-    const c = `[Raph] Runtime "${t}" is disposed.`;
+    const a = `[Raph] Runtime "${t}" is disposed.`;
     this._signalLifecycle = {
       owner: this,
-      runWrite: (d) => this._runWrite(d),
-      assertDependencyAllowed: (d, l) => {
-        this._assertImplicitDependency(d, l);
+      assertDependencyAllowed: (h, u) => {
+        this._assertImplicitDependency(h, u);
       },
-      ...s ? { assertWriteAllowed: () => this._assertWriteAllowed() } : {},
+      ...r ? { assertWriteAllowed: () => this._assertWriteAllowed() } : {},
       throwDisposed: () => {
-        throw new A(c);
+        throw new A(a);
       },
-      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, {
+      throwCrossRuntime: (h) => this._throwCrossRuntime(h)
+    }, this._reactivity = new ee(this._signalLifecycle, { adaptiveDependencyIndex: s }), this._workGraph = new Z(this), o._attachRuntime(this), this.rootScope = new O(`${t}:root-scope`, this), this.root = new v(null, { id: `${t}:root` }, this), q(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);
+        const h = this._reactivity.getActiveOwner();
+        h !== void 0 && h !== this && this._throwCrossRuntime(h);
+        const u = this._reactivity.getActiveConsumerOwner();
+        u !== void 0 && this._assertImplicitDependency(this.rootScope, u);
       },
       assertWrite: () => this._assertWriteAllowed(),
-      runWrite: (d) => this._runWrite(d),
-      throwForeign: (d) => {
-        throw d instanceof v && this._throwCrossRuntime(d), new k(
+      runWrite: (h) => this._runWrite(h),
+      throwForeign: (h) => {
+        throw h instanceof T && this._throwCrossRuntime(h), new b(
           "[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
+    const n = this._reactivity.signalForOwner(0, this.rootScope, "frame", !1);
+    this._frameTickSignal = n, this.frameTick = this._workGraph.attachProducer(n, {
+      get: () => n.get(),
+      peek: () => n.peek()
     });
   }
   /** @internal */
@@ -131,19 +139,16 @@ const v = class v {
     return this._disposed;
   }
   get graph() {
-    return this._parentGraph ?? (this._parentGraph = F());
+    return this._parentGraph ??= $();
   }
   get loopEnabled() {
-    var e;
-    return ((e = this._frameLoop) == null ? void 0 : e.running) ?? !1;
+    return this._frameLoop?.running ?? !1;
   }
   get frame() {
-    var e;
-    return ((e = this._phases) == null ? void 0 : e.frame) ?? { now: 0, delta: 0, elapsed: 0, frame: 0 };
+    return this._phases?.frame ?? { now: 0, delta: 0, elapsed: 0, frame: 0 };
   }
   get phases() {
-    var e;
-    return ((e = this._phases) == null ? void 0 : e.phases) ?? [];
+    return this._phases?.phases ?? [];
   }
   /** Runtime metadata facade intentionally excludes unphased watch(). */
   get meta() {
@@ -152,7 +157,7 @@ const v = class v {
     const e = new W(this.kernel, {
       assertReadable: () => this._assertAlive(),
       assertWritable: () => this._assertWriteAllowed(),
-      runWrite: (t, r) => this._runWrite(t, r)
+      runWrite: (t, s) => this._runWrite(t, s)
     });
     return this._meta = Object.freeze({
       delete: e.delete.bind(e),
@@ -166,22 +171,16 @@ const v = class v {
     return this.kernel.getDerivedSnapshot();
   }
   get debug() {
-    return this._debug ?? (this._debug = Object.freeze({
+    return 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);
+    return this._assertOwnerRuntime(t), this._reactivity.signalForOwner(e, t);
   }
   /**
    * Creates a deep reactive Proxy owned by this Runtime root scope.
@@ -193,161 +192,214 @@ const v = class v {
   }
   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),
+    const s = this._workGraph.createProducer(t), r = typeof e == "function" ? e : e.get, i = this._reactivity.computedForOwner(
+      () => this._runTracked(t, r),
       t,
-      this._workGraph.producerHooks(r)
+      this._workGraph.producerHooks(s)
     );
-    if (this._workGraph.setProducerActivation(r, () => {
+    if (this._workGraph.setProducerActivation(s, () => {
       i.peek();
     }), typeof e == "function")
-      return this._workGraph.attachProducer(r, i);
+      return this._workGraph.attachProducer(s, i);
     const o = this._attachWritableComputed(i, e.set, t);
-    return this._workGraph.attachProducer(r, o);
+    return this._workGraph.attachProducer(s, o);
   }
   /** Low-level adapter form. Prefer consumer.effect(). */
-  effect(e, t, r, s = {}) {
-    return this._effectRegistration(e, t, r, s).dispose;
+  effect(e, t, s, r = y) {
+    return te(
+      this._effectRegistration(e, t, s, r)
+    );
   }
-  /** @internal */
-  _effectRegistration(e, t, r, s = {}, i = !1) {
+  /**
+   * Регистрирует один implicit phase effect. Возвращаемая регистрация является
+   * записью binding: она одновременно ресурс владельца, задача engine и элемент
+   * очереди pipeline, поэтому на effect больше ничего не выделяется. Тело
+   * записи engine у всех bindings графа одно — `RuntimeReactivity._phaseBody`:
+   * свой binding оно находит через engine, а не через собственную closure.
+   *
+   * При `taskless` тело вызывается без task: запись получает `TASK_TASKLESS`,
+   * общее тело не читает `record.task`, и frozen facade этого binding не
+   * создаётся, пока его не запросит `process` своей phase. Режим — бит поля
+   * `state`: запись от него не растёт.
+   *
+   * @internal
+   */
+  _effectRegistration(e, t, s, r = y, i = !1, o = !1, a, n) {
     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();
+    const h = this._execution, u = this._validatePhaseBinding(h, t, s, r), c = h.bindTask(u, e, s, r.priority ?? 0);
+    o && (c.state = E | U);
+    const d = this._reactivity, _ = r.initial === "sync", l = _ && this.configuration.scheduler !== f.Sync;
+    let g = "Effect registration and cleanup failed.", w = !1;
+    try {
+      i && c.pause();
+      const R = d._allocateTaskEffect(d._phaseBody, c);
+      if (c.node = R, l && h._queue(c, !1), w = !0, d._requestTaskEffect(R, !l), n?.())
+        return c.dispose(), c;
+      w = !1, g = "[Raph] Resource registration and cleanup failed.", (c.state & E) !== 0 && c.node !== void 0 ? e._adoptRecord(c) : (e._assertAlive(), c.dispose()), g = "[Raph] Phase effect registration and rollback failed.", w = !0, _ ? this.flush() : this._requestExecution(), n?.() && c.dispose();
+    } catch (R) {
+      this._rollbackRegistration(
+        c,
+        R,
+        g,
+        w ? a : void 0
+      );
+    }
+    return c;
+  }
+  /**
+   * Регистрирует группу из `count` implicit phase effects на одной записи
+   * binding. Каждый slot получает собственную запись графа engine, то есть
+   * собственный набор зависимостей и собственный признак invalidation, а
+   * запись binding и её место в очереди phase и в списке ресурсов владельца у
+   * группы одни. Тело записи engine у slots то же, что у всех bindings графа.
+   * Возвращаемая регистрация — эта запись; она же handle группы.
+   *
+   * Регистрация ничего не исполняет: каждый slot запускает `_startGroupSlot`.
+   * Запись входит в список владельца сразу, поэтому владелец освобождает
+   * группу после ресурсов, которые зарегистрируют тела её slots.
+   *
+   * @internal
+   */
+  _effectGroupRegistration(e, t, s, r, i, o = y, a = !1) {
+    this._assertOwnerRuntime(e);
+    const n = this._execution, h = r, u = this._validatePhaseBinding(n, t, h, o);
+    if (!Number.isInteger(s) || s < 1)
+      throw new RangeError("[Raph] Effect group slot count must be a positive integer.");
+    if (s > I)
+      throw new RangeError(`[Raph] Effect group slot count must not exceed ${I}.`);
+    const c = n.bindGroup(u, e, h, i, s, o.priority ?? 0);
     try {
-      n === "sync" ? this.flush() : this._requestExecution();
-    } catch (f) {
+      a && c.pause();
+      const d = c.group, _ = this._reactivity, l = _._phaseBody, g = k + s;
+      for (let w = k; w < g; w++)
+        d[w] = _._allocateTaskEffect(l, c);
+      e._adoptRecord(c);
+    } catch (d) {
+      this._rollbackRegistration(c, d, "[Raph] Resource registration and cleanup failed.");
+    }
+    return c;
+  }
+  /**
+   * Запускает один slot группы: планирует его запись графа, ставит запись
+   * группы в очередь и, при `initial: 'sync'`, выполняет flush. Шаги те же, что
+   * у регистрации одиночного implicit effect после создания его записи.
+   *
+   * Сбой внутри вызова останавливает только этот slot и бросается вызывающему,
+   * как сбой первой доставки откатывает регистрацию одиночного binding; группа
+   * и остальные её slots остаются. Группа, у которой остановлен последний slot,
+   * освобождается.
+   *
+   * Запуск на освобождённом владельце бросает `RaphDisposedError`, как
+   * `bindEffect()`: и когда владелец освобождён до вызова, и когда его
+   * освободила первая доставка внутри вызова, при любом scheduler. Молчит
+   * только запуск slot группы, освобождённой при живом владельце.
+   *
+   * @internal
+   */
+  _startGroupSlot(e, t, s, r) {
+    const i = e.group;
+    if (i === void 0) {
+      e.consumerOwner._assertAlive();
+      return;
+    }
+    const o = t >= 0 ? i[k + t] : void 0;
+    if (o === void 0)
+      throw new RangeError(`[Raph] Effect group has no slot ${String(t)}.`);
+    if (s !== "scheduled" && s !== "sync")
+      throw new TypeError(`[Raph] Unsupported effect initial mode "${String(s)}".`);
+    if (o === null || o.firstDep !== null)
+      return;
+    const a = e.phaseState.pipeline, n = s === "sync", h = n && this.configuration.scheduler !== f.Sync;
+    let u = !1;
+    try {
+      u = !0, this._reactivity._requestTaskEffect(o, !1), h ? e.state & C || a._queue(e, !1) : e.schedule(), u = !1, e.state & (C | K) || e.consumerOwner._assertAlive(), n ? a._running ? this._executionRequested = !1 : (u = !0, this.flush(), u = !1, e.state & E || e.consumerOwner._assertAlive()) : (u = !0, this._requestExecution());
+    } catch (c) {
+      let d = c;
       try {
-        h();
+        this._reactivity._disposeTaskEffect(o);
       } catch (_) {
-        throw new AggregateError(
-          [f, _],
+        d = new AggregateError(
+          [c, _],
           "[Raph] Phase effect registration and rollback failed."
         );
       }
-      throw f;
+      throw u && r !== void 0 && r(d), d;
     }
-    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;
+  watch(e, t, s, r, i = y) {
+    const o = this._watchRegistration(e, t, s, r, i).watch;
+    return o === void 0 ? re : se(o);
   }
-  /** @internal */
-  _watchRegistration(e, t, r, s, i = {}, o = !1) {
+  /**
+   * Регистрирует один explicit phase watch. Возвращаемая запись binding является
+   * pausable-регистрацией и одновременно ресурсом владельца этого watch.
+   *
+   * @internal
+   */
+  _watchRegistration(e, t, s, r, i = y, o = !1, a, n) {
     this._assertOwnerRuntime(e);
-    const c = this._validatePhaseBinding(r, s, i, !0);
+    const h = this._execution, u = this._validatePhaseBinding(h, s, r, 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;
+    const c = h.bindTask(u, e, r, i.priority ?? 0), d = V((l) => this._runUntracked(l), c);
+    c.watch = d, o && c.pause();
     try {
-      h = this._workGraph.subscribe(
+      if (d.source = this._workGraph.subscribe(
         t,
         i.include,
-        n.enqueue
-      );
-    } catch (_) {
-      throw n.dispose(), _;
+        (l, g, w) => d.record?.enqueue(l, g, w)
+      ), n?.())
+        return c.dispose(), c;
+    } catch (l) {
+      throw c.dispose(), l;
     }
-    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 _;
+      e._adoptRecord(c);
+    } catch (l) {
+      this._rollbackRegistration(c, l, "[Raph] Resource registration and cleanup failed.");
     }
-    return {
-      dispose: l,
-      pause: n.pause,
-      resume: n.resume
-    };
+    const _ = i.initial ?? "scheduled";
+    try {
+      _ !== "none" && c.schedule(), _ === "sync" && this.flush(), n?.() && c.dispose();
+    } catch (l) {
+      this._rollbackRegistration(
+        c,
+        l,
+        "[Raph] Phase watch registration and rollback failed.",
+        a
+      );
+    }
+    return c;
   }
   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._assertAlive(), ae(e, t);
+    const s = this._workGraph.createProducer(this.rootScope, "path"), r = this._workGraph.producerHooks(s).onDispose, i = J._create(
       this.rootScope,
       e,
       t,
       () => this.kernel._watchMeta(
         i.masks,
-        ({ events: o }) => this._workGraph.notifyProducerEvents(r, o, !1),
+        ({ events: o }) => this._workGraph.notifyProducerEvents(s, o, !1),
         i.options,
         (o) => {
           o && this._execution.request();
         }
       ),
-      () => s(!1)
+      () => r(!1)
     );
     i._bindOwner(this.rootScope._adoptResource(() => i._disposeOwned()));
     try {
-      return this._workGraph.setProducerActivation(r, () => i._activate(), !0), this._workGraph.attachProducer(r, i), i;
+      return this._workGraph.setProducerActivation(s, () => i._activate(), !0), this._workGraph.attachProducer(s, i), i;
     } catch (o) {
       try {
         i.dispose();
-      } catch (c) {
+      } catch (a) {
         throw new AggregateError(
-          [o, c],
+          [o, a],
           "[Raph] Meta source activation and rollback failed."
         );
       }
@@ -356,41 +408,41 @@ const v = class v {
   }
   path(e, t = {}) {
     this._assertAlive();
-    const r = P(e, t), s = this._pathHandles ?? (this._pathHandles = /* @__PURE__ */ new Map()), i = s.get(r.canonical);
+    const s = N(e, t), r = this._pathHandles ??= /* @__PURE__ */ new Map(), i = r.get(s.canonical);
     if (i !== void 0)
       return i;
-    const o = this._workGraph.createProducer(this.rootScope, "path"), c = this._workGraph.producerHooks(o), n = new z(
+    const o = this._workGraph.createProducer(this.rootScope, "path"), a = this._workGraph.producerHooks(o), n = new X(
       this.kernel,
-      r,
+      s,
       t,
-      (a) => this._releasePathHandle(a),
+      (h) => this._releasePathHandle(h),
       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)
+      (h) => this._runWrite(h),
+      { token: o, onDispose: a.onDispose },
+      ({ events: h }, u) => this._workGraph.notifyProducerEvents(o, h, !0, u)
     );
     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;
+      return this._workGraph.setProducerActivation(o, () => n._activate(), !0), this._workGraph.attachProducer(o, n), r.set(s.canonical, n), n;
+    } catch (h) {
+      let u, c = !1;
       try {
         n.dispose();
-      } catch (l) {
-        d = !0, h = l;
+      } catch (d) {
+        c = !0, u = d;
       }
-      throw s.size === 0 && this._pathHandles === s && (this._pathHandles = void 0), d ? new AggregateError(
-        [a, h],
+      throw r.size === 0 && this._pathHandles === r && (this._pathHandles = void 0), c ? new AggregateError(
+        [h, u],
         "[Raph] Path source activation and rollback failed."
-      ) : a;
+      ) : h;
     }
   }
   get(e, t) {
     this._assertTrackedRead();
-    const r = e ?? "";
-    return this._reactivity._isTracking() ? this.path(r, t)._getTracked() : this.kernel.get(r, t);
+    const s = e ?? "";
+    return this._reactivity._isTracking() ? this.path(s, t)._getTracked() : this.kernel.get(s, t);
   }
   peek(e, t) {
     return this._assertAlive(), this.kernel.peek(e ?? "", t);
@@ -398,11 +450,11 @@ const v = class v {
   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));
+  set(e, t, s) {
+    this._assertWriteAllowed(), this._runWrite(() => this.kernel.set(e, t, s));
   }
-  merge(e, t, r) {
-    this._assertWriteAllowed(), this._runWrite(() => this.kernel.merge(e, t, r));
+  merge(e, t, s) {
+    this._assertWriteAllowed(), this._runWrite(() => this.kernel.merge(e, t, s));
   }
   delete(e, t) {
     this._assertWriteAllowed(), this._runWrite(() => this.kernel.delete(e, t));
@@ -416,64 +468,109 @@ const v = class v {
   }
   _batch(e, t) {
     this._assertAlive(), this._batchDepth++;
-    let r, s, i = !1;
+    let s, r, i = !1;
     try {
-      r = this._reactivity.batch(() => t ? this.kernel.batch(e) : e());
-    } catch (c) {
-      i = !0, s = c;
+      s = this._reactivity.batch(() => t ? this.kernel.batch(e) : e());
+    } catch (o) {
+      i = !0, r = o;
     }
-    this._batchDepth--;
-    const o = this._finishExecutionBoundary();
-    if (i)
-      throw o.length !== 0 ? new AggregateError(
-        [s, ...o],
+    return this._closeBatch(i, r), s;
+  }
+  /**
+   * Закрывает один уровень batch: внешний уровень очищает transient causes и
+   * запускает фазы. Бросает ошибку операции, ошибки закрытия либо все вместе;
+   * после успешной операции и закрытия возвращает управление.
+   */
+  _closeBatch(e, t) {
+    if (this._batchDepth--, this._executionBoundaryOpen()) {
+      if (e)
+        throw t;
+      return;
+    }
+    const s = this._finishExecutionBoundary();
+    if (e)
+      throw s !== void 0 ? new AggregateError(
+        [t, ...s],
         "[Raph] Batch and scheduled phase execution failed."
-      ) : s;
-    return y(o, "[Raph] Batch phase execution failed."), r;
+      ) : t;
+    s !== void 0 && m(s, "[Raph] Batch phase execution failed.");
+  }
+  /**
+   * Исполняет тело action: `batch(() => _runUntracked(() => operation(...args)))`
+   * без closures и без промежуточных вызовов слоёв. Runtime, который один
+   * владеет своим Kernel без derived handles, metadata watchers и adapter,
+   * открывает границы reactive batch, Kernel и path batch явными вызовами и
+   * закрывает их в том же порядке и с теми же ошибками, что вложенные
+   * `batch()` этих слоёв. В любом другом состоянии исполняется сам `batch()`.
+   */
+  _applyBatch(e, t) {
+    this._assertAlive();
+    const s = this.kernel, r = s._openSoleRuntimeBatch(this);
+    if (r === void 0)
+      return this._batch(() => this._runUntracked(() => e(...t)), !0);
+    const i = this._reactivity;
+    this._batchDepth++, i._startBatch();
+    let o, a, n = !1;
+    try {
+      o = i._applyUntrackedWithOwner(e, t);
+    } catch (h) {
+      n = !0, a = h;
+    }
+    try {
+      s._closeSoleRuntimeBatch(this, r, n, a);
+    } catch (h) {
+      n = !0, a = h;
+    }
+    try {
+      i._endBatch();
+    } catch (h) {
+      a = n ? new AggregateError([a, h], "Batch operation and effect queue processing failed.") : h, n = !0;
+    }
+    return this._closeBatch(n, a), o;
   }
-  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")
+  action(e, t, s) {
+    const r = typeof e == "function" ? e : t, i = typeof e == "function" ? t instanceof O ? t : this.rootScope : s ?? this.rootScope, o = typeof e == "string" ? e : `action#${++this._actionCounter}`;
+    if (this._assertOwnerRuntime(i), typeof r != "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) => {
+    return (...a) => {
       i._assertAlive();
-      const n = this._debugController.nextOperationId("action"), h = this._traceCauseStack.at(-1) ?? n;
-      this._debugController.record({
-        ...h === void 0 ? {} : { causeId: h },
+      const n = this._debugController, h = this._traceCauseStack, u = n.nextOperationId("action"), d = (h.length === 0 ? void 0 : h[h.length - 1]) ?? u;
+      n.traces("action") && n.record({
+        ...d === void 0 ? {} : { causeId: d },
         kind: "action",
         name: o,
-        ...n === void 0 ? {} : { operationId: n },
+        ...u === void 0 ? {} : { operationId: u },
         status: "start"
-      }), h !== void 0 && this._traceCauseStack.push(h), this._actionDepth++;
+      }), d !== void 0 && h.push(d), this._actionDepth++;
       try {
-        const d = this.batch(() => this._runUntracked(() => s(...c)));
-        return this._debugController.record({
-          ...h === void 0 ? {} : { causeId: h },
+        const _ = this._applyBatch(r, a);
+        return n.traces("action") && n.record({
+          ...d === void 0 ? {} : { causeId: d },
           kind: "action",
           name: o,
-          ...n === void 0 ? {} : { operationId: n },
+          ...u === void 0 ? {} : { operationId: u },
           status: "end"
-        }), d;
-      } catch (d) {
+        }), _;
+      } catch (_) {
         throw this._debugController.record({
-          ...h === void 0 ? {} : { causeId: h },
-          details: { message: C(d) },
+          ...d === void 0 ? {} : { causeId: d },
+          details: { message: x(_) },
           kind: "action",
           name: o,
-          ...n === void 0 ? {} : { operationId: n },
+          ...u === void 0 ? {} : { operationId: u },
           status: "error"
         }), this._debugController.record({
-          ...h === void 0 ? {} : { causeId: h },
-          details: { message: C(d) },
+          ...d === void 0 ? {} : { causeId: d },
+          details: { message: x(_) },
           kind: "error",
           name: `action:${o}`,
-          ...n === void 0 ? {} : { operationId: n },
+          ...u === void 0 ? {} : { operationId: u },
           status: "error"
-        }), d;
+        }), _;
       } finally {
-        this._actionDepth--, h !== void 0 && this._traceCauseStack.pop();
+        this._actionDepth--, d !== void 0 && h.pop();
       }
     };
   }
@@ -481,35 +578,38 @@ const v = class v {
     return this._assertAlive(), this._runUntracked(e);
   }
   scope(e) {
-    return this._assertAlive(), new D(e, this);
+    return this._assertAlive(), new O(e, this);
   }
   node(e, t) {
-    this._assertAlive();
-    const r = this._runNodeMutation(() => {
-      const s = e.parent ?? this.root, i = q(s, e, this);
+    this._assertAlive(), this._enterWrite();
+    let s;
+    try {
+      s = this._createCommittedNode(e, t);
+    } catch (r) {
+      throw this._failWrite(r);
+    }
+    return this._exitWrite(), s._assertAlive(), s;
+  }
+  /**
+   * Создаёт provisional node, выполняет setup и публикует результат; при ошибке
+   * setup откатывает node до выхода из границы mutation.
+   */
+  _createCommittedNode(e, t) {
+    const s = e.parent ?? this.root, r = H(s, e, this);
+    try {
+      const i = t?.(r);
+      return r._assertAlive(), s._assertAlive(), r._setApi(i), r._publishCreation(), r;
+    } catch (i) {
       try {
-        const o = t == null ? void 0 : t(i);
-        return i._assertAlive(), s._assertAlive(), i._setApi(o), i._publishCreation(), i;
+        r.dispose();
       } catch (o) {
-        try {
-          i.dispose();
-        } catch (c) {
-          throw new AggregateError([o, c], `[Raph] Node "${i.id}" setup and cleanup failed.`);
-        }
-        throw o;
+        throw new AggregateError([i, o], `[Raph] Node "${r.id}" setup and cleanup failed.`);
       }
-    });
-    return r._assertAlive(), r;
+      throw i;
+    }
   }
   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);
-    }
+    return this._assertAlive(), this.root._findNode(e);
   }
   definePhases(e) {
     this._execution.definePhases(e);
@@ -518,20 +618,16 @@ const v = class v {
     this._execution.addPhase(e);
   }
   clearPhases() {
-    var e;
-    this._assertAlive(), (e = this._phases) == null || e.clearPhases();
+    this._assertAlive(), this._phases?.clearPhases();
   }
   requestExecution() {
-    var e;
-    this._assertAlive(), (e = this._phases) == null || e.request();
+    this._assertAlive(), this._phases?.request();
   }
   flush() {
-    var e;
-    this._assertAlive(), this._executionRequested = !1, (e = this._phases) == null || e.flush();
+    this._assertAlive(), this._executionRequested = !1, this._phases?.flush();
   }
   afterFlush() {
-    var e;
-    return this._assertAlive(), ((e = this._phases) == null ? void 0 : e.afterFlush()) ?? Promise.resolve();
+    return this._assertAlive(), this._phases?.afterFlush() ?? Promise.resolve();
   }
   acquireLoop(e) {
     return this._assertAlive(), this._clock.acquire(e);
@@ -540,31 +636,29 @@ const v = class v {
     this._assertAlive(), this._clock.start();
   }
   stopLoop() {
-    var e;
-    (e = this._frameLoop) == null || e.stop();
+    this._frameLoop?.stop();
   }
   derive(e) {
     this._assertAlive();
-    const t = e.compute, r = this.kernel.derive({
+    const t = e.compute, s = this.kernel.derive({
       ...e,
-      compute: (s) => this._runUntracked(() => t(s))
+      compute: (r) => this._runUntracked(() => t(r))
     });
-    return this._own(() => r.dispose(), this.rootScope), r;
+    return this._own(() => s.dispose(), this.rootScope), s;
   }
   dispose() {
-    var c, n;
     if (this._disposed)
       return;
     this._disposed = !0, this._executionRequested = !1, this._signalLifecycle.owner = void 0;
-    const e = [], t = [...this._owners];
+    const e = [];
     try {
-      (c = this._frameLoop) == null || c.dispose();
+      this._frameLoop?.dispose();
     } catch (a) {
       e.push(a);
     }
     this._frameLoop = void 0;
     try {
-      (n = this._phases) == null || n.dispose();
+      this._phases?.dispose();
     } catch (a) {
       e.push(a);
     }
@@ -574,38 +668,39 @@ const v = class v {
     } catch (a) {
       e.push(a);
     }
-    for (const a of t.reverse())
+    const t = this._collectOwners().sort(ie);
+    for (const a of t)
       if (!(a === this.root || a === this.rootScope || a.disposed))
         try {
           a.dispose();
-        } catch (h) {
-          e.push(h);
+        } catch (n) {
+          e.push(n);
         }
     try {
       this.rootScope.dispose();
     } catch (a) {
       e.push(a);
     }
-    const r = `[Raph] Runtime "${this.id}" is disposed.`, s = () => {
-      throw new A(r);
+    const s = `[Raph] Runtime "${this.id}" is disposed.`, r = () => {
+      throw new A(s);
     };
     try {
       L(this._reactivity, {
-        assertRead: s,
-        assertWrite: s,
-        throwForeign: s
+        assertRead: r,
+        assertWrite: r,
+        throwForeign: r
       });
     } catch (a) {
       e.push(a);
     }
-    this._owners.clear(), this._meta = void 0;
+    this._topOwners.clear(), this._ownersReleased = !0, 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);
+        } catch (n) {
+          e.push(n);
         }
       i.clear();
     }
@@ -624,10 +719,10 @@ const v = class v {
     for (const a of o)
       try {
         a();
-      } catch (h) {
-        e.push(h);
+      } catch (n) {
+        e.push(n);
       }
-    y(e, `[Raph] Runtime "${this.id}" disposal failed.`);
+    m(e, `[Raph] Runtime "${this.id}" disposal failed.`);
   }
   /** @internal */
   _onDisposed(e) {
@@ -637,11 +732,34 @@ const v = class v {
     });
   }
   /** @internal */
-  _notifyNodeStructure(e, t, r, s) {
+  _notifyNodeStructure(e, t, s, r) {
+    if (!this._workGraph._hasStructuralDemand(e)) {
+      this._touchMutationBoundary();
+      return;
+    }
     this._runNodeMutation(() => {
-      this._workGraph.notifyNode(e, "structure", { structure: t, oldAncestors: r, newAncestors: s });
+      this._workGraph.notifyNode(e, "structure", { structure: t, oldAncestors: s, newAncestors: r });
     });
   }
+  /**
+   * Сообщает, может ли structural publication этой node дойти до подписчика;
+   * `false` позволяет не строить structure cause и списки ancestors.
+   *
+   * @internal
+   */
+  _hasNodeStructureDemand(e) {
+    return this._workGraph._hasStructuralDemand(e);
+  }
+  /**
+   * Сообщает, есть ли у Runtime хотя бы один подписчик на node: runtime-,
+   * subtree- или self-watcher. Пока он есть, node поддерживает выданный массив
+   * детей на месте, потому что structure cause берёт из него индексы.
+   *
+   * @internal
+   */
+  _hasNodeSubscribers() {
+    return this._workGraph._hasNodeSubscribers();
+  }
   /** @internal */
   _notifyNodeTouch(e, t) {
     this._runNodeMutation(() => this._workGraph.notifyNode(e, "touch", { metadata: t }));
@@ -658,34 +776,142 @@ const v = class v {
   _runNodeMutation(e) {
     return this._runWrite(e);
   }
+  /**
+   * Выполняет границу пустой node mutation без аллокаций: эквивалент
+   * `_runWrite(noop)` с тем же запросом исполнения и flush на внешней границе.
+   *
+   * @internal
+   */
+  _touchMutationBoundary() {
+    if (this.configuration.scheduler === f.Sync && (this._executionRequested = !0), this._executionBoundaryOpen())
+      return;
+    const e = this._finishExecutionBoundary();
+    e !== void 0 && m(e, "[Raph] Mutation phase execution failed.");
+  }
   /** @internal */
   _runPhaseTransition(e) {
     return this._runWrite(e, !1);
   }
-  /** @internal */
-  _beginOwnerDisposal() {
-    this._ownerDisposalDepth++;
+  /**
+   * Открывает границу освобождения. `node` передаёт только dispose самой node:
+   * Runtime помнит её до парного `_endOwnerDisposal`.
+   *
+   * @internal
+   */
+  _beginOwnerDisposal(e) {
+    this._disposingNodes[this._ownerDisposalDepth++] = e;
   }
   /** @internal */
   _endOwnerDisposal() {
-    this._ownerDisposalDepth !== 0 && (this._ownerDisposalDepth--, this._clearTransientCausesIfSettled(), this._disposed || this._requestExecution());
+    const e = this._ownerDisposalDepth;
+    e !== 0 && (this._ownerDisposalDepth = e - 1, this._disposingNodes[e - 1] = void 0, this._ownerDisposals >= this._nextDisposalSweep && e === 1 && this._sweepAfterDisposals(), this._clearTransientCausesIfSettled(), this._disposed || this._requestExecution());
+  }
+  /**
+   * Возвращает число владельцев, освобождённых этим Runtime за всё время.
+   *
+   * @internal
+   */
+  _ownerDisposalCount() {
+    return this._ownerDisposals;
+  }
+  /**
+   * Подключает участника уборки: Runtime вызовет его на первой внешней границе
+   * освобождения, к которой число освобождённых владельцев достигнет `due`.
+   * Подключённый участник остаётся в очереди, пока сам не откажется от
+   * следующего срока либо не будет отключён.
+   *
+   * @internal
+   */
+  _addDisposalSweeper(e, t) {
+    const s = this._disposalSweepers;
+    if (s === void 0) {
+      e._sweepSlot = 0, e._sweepDue = t, this._disposalSweepers = [e], this._nextDisposalSweep = t;
+      return;
+    }
+    Y(s, e, t), this._nextDisposalSweep = s[0]._sweepDue;
+  }
+  /**
+   * Отключает участника уборки; отключение неизвестного участника безопасно.
+   *
+   * @internal
+   */
+  _removeDisposalSweeper(e) {
+    const t = this._disposalSweepers;
+    t === void 0 || !P(t, e) || (t.length === 0 ? (this._disposalSweepers = void 0, this._nextDisposalSweep = Number.POSITIVE_INFINITY) : this._nextDisposalSweep = t[0]._sweepDue);
+  }
+  /**
+   * Вызывает участников уборки, чей срок подошёл, и назначает ближайший
+   * следующий срок. Участник, чей срок не подошёл, вызова не получает:
+   * освобождение владельца стоит участникам работы, только когда подходит их
+   * собственный срок.
+   */
+  _sweepAfterDisposals() {
+    const e = this._disposalSweepers;
+    if (e === void 0)
+      return;
+    const t = this._ownerDisposals;
+    if (e.length === 1) {
+      const s = e[0], r = s._afterOwnerDisposals(t);
+      r > t ? (s._sweepDue = r, this._nextDisposalSweep = r) : (s._sweepSlot = -1, this._disposalSweepers = void 0, this._nextDisposalSweep = Number.POSITIVE_INFINITY);
+      return;
+    }
+    for (let s = e[0]; s._sweepDue <= t; s = e[0]) {
+      const r = s._afterOwnerDisposals(t);
+      if (r > t)
+        Q(e, r);
+      else if (P(e, s), e.length === 0) {
+        this._disposalSweepers = void 0, this._nextDisposalSweep = Number.POSITIVE_INFINITY;
+        return;
+      }
+    }
+    this._nextDisposalSweep = e[0]._sweepDue;
   }
   /** @internal */
   _ownerDisposalActive() {
     return this._ownerDisposalDepth !== 0;
   }
-  /** @internal */
+  /**
+   * Учитывает нового владельца и возвращает его порядковый номер регистрации.
+   * Plain scope сразу входит в набор владельцев вне списков детей; node входит
+   * в него сама через `_addTopOwner`, и только если у неё нет parent.
+   *
+   * @internal
+   */
   _registerOwner(e) {
-    this._assertAlive(), this._owners.add(e);
+    return this._assertAlive(), e._isNode || this._topOwners.add(e), ++this._ownerRegistrations;
   }
-  /** @internal */
+  /**
+   * Снимает владельца с учёта. Plain scope выходит и из набора владельцев вне
+   * списков детей; node без parent выходит из него сама через
+   * `_removeTopOwner`, а node с parent в нём не состоит.
+   *
+   * @internal
+   */
   _unregisterOwner(e) {
-    this._owners.delete(e);
+    e._isNode || this._topOwners.delete(e), this._ownerDisposals++;
+  }
+  /**
+   * Вносит node без parent в набор владельцев вне списков детей.
+   *
+   * @internal
+   */
+  _addTopOwner(e) {
+    this._topOwners.add(e);
+  }
+  /**
+   * Убирает node из набора владельцев вне списков детей: она освобождена либо
+   * получила parent. Повторный вызов и вызов после освобождения Runtime
+   * безопасны.
+   *
+   * @internal
+   */
+  _removeTopOwner(e) {
+    this._topOwners.delete(e);
   }
   /** @internal */
   _assertOwnerRuntime(e) {
     if (this._assertAlive(), e.runtime !== this)
-      throw new k("[Raph] Owner belongs to another runtime.");
+      throw new b("[Raph] Owner belongs to another runtime.");
     e._assertAlive();
   }
   /** @internal */
@@ -747,33 +973,46 @@ const v = class v {
       this._traceCauseStack.pop();
     }
   }
-  _validatePhaseBinding(e, t, r, s = !1) {
-    if (typeof t != "function")
+  /**
+   * Выполняет единственную проверку binding: pipeline доверяет её результату.
+   */
+  _validatePhaseBinding(e, t, s, r, i = !1) {
+    if (typeof s != "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))
+    const o = e.resolvePhase(t), a = r.priority ?? 0;
+    if (!Number.isFinite(a))
       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;
+    const n = r.initial ?? "scheduled";
+    if (n !== "scheduled" && n !== "sync" && !(i && n === "none"))
+      throw new TypeError(`[Raph] Unsupported effect initial mode "${String(n)}".`);
+    return o;
+  }
+  /**
+   * Освобождает binding, регистрация которого не удалась, и повторно бросает
+   * причину сбоя; ошибка самого освобождения присоединяется к ней.
+   */
+  _rollbackRegistration(e, t, s, r) {
+    let i = t;
+    try {
+      e.dispose();
+    } catch (o) {
+      i = new AggregateError([t, o], s);
+    }
+    throw r !== void 0 && r(i), 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);
+    const e = this._frameLoop?._debugState() ?? { running: !1, manual: !1, leases: 0 }, t = [...this._topOwners].filter((s) => s !== this.rootScope && !(s instanceof v)).map(D);
     return Object.freeze({
       id: this.id,
       disposed: this._disposed,
-      pending: !this._disposed && (this._executionRequested || (((s = this._phases) == null ? void 0 : s._debugPending()) ?? !1)),
+      pending: !this._disposed && (this._executionRequested || (this._phases?._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),
+      owners: this._liveOwnerCount(),
+      pathHandles: this._pathHandles?.size ?? 0,
+      rootScope: D(this.rootScope),
       scopes: Object.freeze(t),
-      root: b(this.root),
+      root: D(this.root),
       frameLoop: Object.freeze(e),
       actionDepth: this._actionDepth,
       machines: this._debugController.machineCount,
@@ -782,9 +1021,9 @@ const v = class v {
   }
   _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))
+      S(this.rootScope, e),
+      S(this.root, e),
+      ...[...this._topOwners].filter((s) => s !== this.rootScope && s !== this.root && !(s instanceof v)).map((s) => S(s, e))
     ];
     return Object.freeze({
       children: Object.freeze(t),
@@ -794,76 +1033,128 @@ const v = class v {
     });
   }
   _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();
+    const e = this._liveOwnerCount();
+    let t = 0;
+    const s = { resources: 0, sources: 0 };
+    if (!this._ownersReleased) {
+      const r = this._topOwners;
+      for (const a of r)
+        a._isNode ? a._countSubtree(s) : (t++, s.resources += a._debugResourceCount(), s.sources += a._debugSourceCount());
+      const i = this._disposingNodes, o = this._ownerDisposalDepth;
+      for (let a = 0; a < o; a++) {
+        const n = i[a];
+        n === void 0 || n._isLinked() || r.has(n) || n._countSubtree(s);
+      }
+    }
     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,
+      // Каждый учтённый владелец, который не plain scope, — node.
+      nodes: e - t,
+      owners: e,
+      pathHandles: this._pathHandles?.size ?? 0,
+      pending: !this._disposed && (this._executionRequested || (this._phases?._debugPending() ?? !1)),
+      resources: s.resources,
       scopes: t,
-      sources: s,
+      sources: s.sources,
       traceEvents: this._debugController.traceSize
     });
   }
+  /**
+   * Возвращает число владельцев, которых Runtime числит живыми: зарегистрированных
+   * и ещё не снятых с учёта. После освобождения Runtime их нет.
+   */
+  _liveOwnerCount() {
+    return this._ownersReleased ? 0 : this._ownerRegistrations - this._ownerDisposals;
+  }
+  /**
+   * Собирает всех владельцев, которых Runtime числит живыми. Владельцы вне
+   * списков детей идут в порядке регистрации, каждый — вместе с потомками по
+   * спискам детей. Node, чей dispose ещё исполняется, из списка parent уже
+   * вышла либо потеряла parent, который сбросил свой список: её и оставшихся
+   * у неё детей добавляют места границ освобождения.
+   */
+  _collectOwners() {
+    const e = [];
+    if (this._ownersReleased)
+      return e;
+    const t = this._topOwners;
+    for (const i of t)
+      e.push(i), i._isNode && i._collectDescendants(e);
+    const s = this._disposingNodes, r = this._ownerDisposalDepth;
+    for (let i = 0; i < r; i++) {
+      const o = s[i];
+      o === void 0 || o._isLinked() || t.has(o) || (e.push(o), o._collectDescendants(e));
+    }
+    return e;
+  }
   _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));
+    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(
+    return this._assertAlive(), this._phases ??= new j(
       this.configuration.scheduler,
-      (e) => this._runUntracked(e),
+      this._reactivity,
       (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;
+        return e && this.configuration.scheduler === f.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) } },
+      (e, t, s) => {
+        if (this._phaseTraceOperations === void 0 && !this._debugController.traces("phase"))
+          return;
+        let r;
+        t === "start" ? (r = this._debugController.nextOperationId("phase"), r !== void 0 && (this._phaseTraceOperations ??= /* @__PURE__ */ new Map()).set(e, r)) : (r = this._phaseTraceOperations?.get(e), this._phaseTraceOperations?.delete(e), this._phaseTraceOperations?.size === 0 && (this._phaseTraceOperations = void 0)), this._debugController.record({
+          ...r === void 0 ? {} : { causeId: r },
+          ...s === void 0 ? {} : { details: { message: x(s) } },
           kind: "phase",
           name: e,
-          ...s === void 0 ? {} : { operationId: s },
+          ...r === void 0 ? {} : { operationId: r },
           status: t
         });
       }
-    ));
+    );
   }
   get _clock() {
-    return this._frameLoop ?? (this._frameLoop = new I(() => this._tickFrameLoop()));
+    return this._frameLoop ??= new z(() => this._tickFrameLoop());
   }
   _tickFrameLoop() {
-    this._disposed || this._setFrameTick(this._frameTickWritable.peek() + 1);
+    this._disposed || this._setFrameTick(this._frameTickSignal.peek() + 1);
+  }
+  /**
+   * Записывает frame signal в собственной границе записи, минуя политику
+   * actions: кадр продвигает сам Runtime.
+   */
+  _setFrameTick(e) {
+    this._enterWrite();
+    try {
+      this._frameTickSignal._writeInBoundary(e);
+    } catch (t) {
+      throw this._failWrite(t);
+    }
+    this._exitWrite();
   }
-  _attachWritableComputed(e, t, r) {
-    let s = t;
+  _attachWritableComputed(e, t, s) {
+    let r = t;
     this._own(() => {
-      s = void 0;
-    }, r);
+      r = void 0;
+    }, s);
     const i = e;
     return i.set = (o) => {
-      r._assertAlive(), this._assertWriteAllowed(), this._runWrite(() => s(o));
+      s._assertAlive(), this._assertWriteAllowed(), this._runWrite(() => r(o));
     }, i;
   }
   _own(e, t) {
     try {
       return t._adoptResource(e);
-    } catch (r) {
+    } catch (s) {
       try {
         e();
-      } catch (s) {
-        throw new AggregateError([r, s], "[Raph] Resource registration and cleanup failed.");
+      } catch (r) {
+        throw new AggregateError([s, r], "[Raph] Resource registration and cleanup failed.");
       }
-      throw r;
+      throw s;
     }
   }
   _runTracked(e, t) {
@@ -873,33 +1164,81 @@ const v = class v {
     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;
+    t && this.configuration.scheduler === f.Sync && (this._executionRequested = !0), this._mutationDepth++;
+    let s, r, i = !1;
     try {
-      r = e();
-    } catch (c) {
-      i = !0, s = c;
+      s = e();
+    } catch (a) {
+      i = !0, r = a;
+    }
+    if (this._mutationDepth--, this._executionBoundaryOpen()) {
+      if (i)
+        throw r;
+      return s;
     }
-    this._mutationDepth--;
     const o = this._finishExecutionBoundary();
     if (i)
-      throw o.length !== 0 ? new AggregateError(
-        [s, ...o],
+      throw o !== void 0 ? new AggregateError(
+        [r, ...o],
         "[Raph] Mutation and scheduled phase execution failed."
-      ) : s;
-    return y(o, "[Raph] Mutation phase execution failed."), r;
+      ) : r;
+    return o !== void 0 && m(o, "[Raph] Mutation phase execution failed."), s;
+  }
+  /**
+   * Открывает границу записи без closure; повторяет начало `_runWrite`.
+   *
+   * @internal
+   */
+  _enterWrite() {
+    this.configuration.scheduler === f.Sync && (this._executionRequested = !0), this._mutationDepth++;
   }
+  /**
+   * Закрывает успешную запись, открытую `_enterWrite`; внешняя граница очищает
+   * transient causes и запускает фазы с теми же ошибками, что и `_runWrite`.
+   *
+   * @internal
+   */
+  _exitWrite() {
+    if (this._mutationDepth--, this._executionBoundaryOpen())
+      return;
+    const e = this._finishExecutionBoundary();
+    e !== void 0 && m(e, "[Raph] Mutation phase execution failed.");
+  }
+  /**
+   * Закрывает запись после ошибки операции и возвращает ошибку для throw:
+   * исходную либо AggregateError, если упало и закрытие внешней границы.
+   *
+   * @internal
+   */
+  _failWrite(e) {
+    if (this._mutationDepth--, this._executionBoundaryOpen())
+      return e;
+    const t = this._finishExecutionBoundary();
+    return t === void 0 ? e : new AggregateError(
+      [e, ...t],
+      "[Raph] Mutation and scheduled phase execution failed."
+    );
+  }
+  /**
+   * Сообщает, что внешняя write-, batch-, Kernel- или disposal-граница ещё открыта.
+   * В этом состоянии оба шага `_finishExecutionBoundary` заведомо ничего не делают:
+   * transient causes очищаются и фазы запускаются только при нулевых глубинах.
+   */
+  _executionBoundaryOpen() {
+    return this._mutationDepth !== 0 || this._batchDepth !== 0 || this._kernelBatchDepth !== 0 || this._ownerDisposalDepth !== 0;
+  }
+  /** Закрывает внешнюю границу; массив ошибок создаётся только при первой ошибке. */
   _finishExecutionBoundary() {
-    const e = [];
+    let e;
     try {
       this._clearTransientCausesIfSettled();
     } catch (t) {
-      e.push(t);
+      e = [t];
     }
     try {
       this._requestExecution();
     } catch (t) {
-      e.push(t);
+      e === void 0 ? e = [t] : e.push(t);
     }
     return e;
   }
@@ -907,8 +1246,7 @@ const v = class v {
     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());
+    this._disposed || this.configuration.scheduler !== f.Sync || this._mutationDepth !== 0 || this._batchDepth !== 0 || this._kernelBatchDepth !== 0 || this._ownerDisposalDepth !== 0 || this._reactivity._isFlushingEffects() || this._executionRequested && (this._executionRequested = !1, this._phases?.flush());
   }
   _assertTrackedRead() {
     this._assertAlive();
@@ -926,16 +1264,16 @@ const v = class v {
     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();
+    const s = this._reactivity.getActiveConsumerOwner();
+    s !== void 0 && this._assertImplicitDependency(e, s), e._assertAlive();
   }
   _assertImplicitDependency(e, t) {
     if (e.runtime !== this || t.runtime !== this)
-      throw new k("[Raph] Implicit dependency crosses runtime boundaries.");
+      throw new b("[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)
+      if (e instanceof v && t instanceof v) {
+        for (let s = t.parent; s !== null; s = s.parent)
+          if (s === e)
             return;
       }
       throw new Error(
@@ -945,10 +1283,10 @@ const v = class v {
   }
   _assertWriteAllowed() {
     if (this._assertAlive(), this.configuration.enforceActions && this._batchDepth === 0)
-      throw new B("[Raph] Writes are allowed only inside action() or batch().");
+      throw new F("[Raph] Writes are allowed only inside action() or batch().");
   }
   _throwCrossRuntime(e) {
-    throw new k(
+    throw new b(
       `[Raph] Runtime "${this.id}" cannot be tracked by runtime "${e.id}".`
     );
   }
@@ -956,24 +1294,39 @@ const v = class v {
     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) {
+function te(p) {
+  let e = p;
+  return () => {
+    const t = e;
+    t !== void 0 && (e = void 0, t.dispose());
+  };
+}
+function se(p) {
+  return () => {
+    p.record?.dispose();
+  };
+}
+function re() {
+}
+function ie(p, e) {
+  return e._order - p._order;
+}
+function oe(p) {
+  return p === f.Sync || p === f.Microtask || p === f.AnimationFrame;
+}
+function ae(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();
+  for (const s of t)
+    B.from(s, e)._asMask();
 }
-function C(p) {
+function x(p) {
   return p instanceof Error ? p.message : String(p);
 }
 export {
-  S as RaphRuntime
+  T as RaphRuntime
 };