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

package/dist/debug/runtime/RaphRuntime.js

@@ -1,700 +1,1332 @@
-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";
-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))
+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 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 = {}) {
+    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 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: s,
+      ...e.debug === void 0 ? {} : { debug: e.debug },
+      id: t,
+      kernel: o,
+      enforceActions: r,
+      scheduler: i
+    }), this._debugController = new M(e.debug);
+    const a = `[Raph] Runtime "${t}" is disposed.`;
     this._signalLifecycle = {
       owner: this,
-      runWrite: (n) => this._runWrite(n),
-      ...s ? { assertWriteAllowed: () => this._assertWriteAllowed() } : {},
+      assertDependencyAllowed: (h, u) => {
+        this._assertImplicitDependency(h, u);
+      },
+      ...r ? { assertWriteAllowed: () => this._assertWriteAllowed() } : {},
       throwDisposed: () => {
-        throw new R(o);
+        throw new A(a);
+      },
+      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 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);
       },
-      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: (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._reactivity.signalForOwner(0, this.rootScope, "frame", !1);
+    this._frameTickSignal = n, this.frameTick = this._workGraph.attachProducer(n, {
+      get: () => n.get(),
+      peek: () => n.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 ??= $();
   }
-  /**
-   * Показывает, удерживается ли автоматический frame-loop.
-   */
   get loopEnabled() {
-    var t;
-    return ((t = this._frameLoop) == null ? void 0 : t.running) ?? !1;
+    return this._frameLoop?.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 };
+    return this._phases?.frame ?? { now: 0, delta: 0, elapsed: 0, frame: 0 };
   }
-  /**
-   * Возвращает текущее определение runtime phases.
-   */
   get phases() {
-    var t;
-    return ((t = this._phases) == null ? void 0 : t.phases) ?? [];
+    return this._phases?.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, s) => this._runWrite(t, s)
+    });
+    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({
+    return 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) {
+    return this._assertOwnerRuntime(t), this._reactivity.signalForOwner(e, t);
   }
   /**
-   * Создаёт 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(e, t = this.rootScope) {
+    this._assertOwnerRuntime(t);
+    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(s)
+    );
+    if (this._workGraph.setProducerActivation(s, () => {
+      i.peek();
+    }), typeof e == "function")
+      return this._workGraph.attachProducer(s, i);
+    const o = this._attachWritableComputed(i, e.set, t);
+    return this._workGraph.attachProducer(s, o);
+  }
+  /** Low-level adapter form. Prefer consumer.effect(). */
+  effect(e, t, s, r = y) {
+    return te(
+      this._effectRegistration(e, t, s, r)
+    );
   }
-  computed(t, e = this.rootScope) {
+  /**
+   * Регистрирует один 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 s = typeof t == "function" ? t : t.get, i = this._reactivity.computedForOwner(
-      () => this._runTracked(s),
-      e
-    );
-    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)))
+    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 this._own(w, o);
     }
-    return this._own(
-      this._reactivity._effectImmediate(() => this._runTracked(r)),
-      o
-    );
+    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 {
+      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;
   }
-  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,
+  /**
+   * Запускает один 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 {
+        this._reactivity._disposeTaskEffect(o);
+      } catch (_) {
+        d = new AggregateError(
+          [c, _],
+          "[Raph] Phase effect registration and rollback failed."
+        );
+      }
+      throw u && r !== void 0 && r(d), d;
+    }
+  }
+  /** Low-level adapter form. Prefer consumer.watch(). */
+  watch(e, t, s, r, i = y) {
+    const o = this._watchRegistration(e, t, s, r, i).watch;
+    return o === void 0 ? re : se(o);
+  }
+  /**
+   * Регистрирует один explicit phase watch. Возвращаемая запись binding является
+   * pausable-регистрацией и одновременно ресурсом владельца этого watch.
+   *
+   * @internal
+   */
+  _watchRegistration(e, t, s, r, i = y, o = !1, a, n) {
+    this._assertOwnerRuntime(e);
+    const h = this._execution, u = this._validatePhaseBinding(h, s, r, i, !0);
+    this._workGraph.assertSubscriptionAllowed(e, t);
+    const c = h.bindTask(u, e, r, i.priority ?? 0), d = V((l) => this._runUntracked(l), c);
+    c.watch = d, o && c.pause();
+    try {
+      if (d.source = this._workGraph.subscribe(
         t,
-        e,
-        s,
-        (r) => this._runTracked(r)
+        i.include,
+        (l, g, w) => d.record?.enqueue(l, g, w)
+      ), n?.())
+        return c.dispose(), c;
+    } catch (l) {
+      throw c.dispose(), l;
+    }
+    try {
+      e._adoptRecord(c);
+    } catch (l) {
+      this._rollbackRegistration(c, l, "[Raph] Resource registration and cleanup failed.");
+    }
+    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(), 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(s, o, !1),
+        i.options,
+        (o) => {
+          o && this._execution.request();
+        }
       ),
-      i
+      () => r(!1)
     );
+    i._bindOwner(this.rootScope._adoptResource(() => i._disposeOwned()));
+    try {
+      return this._workGraph.setProducerActivation(s, () => i._activate(), !0), this._workGraph.attachProducer(s, i), i;
+    } catch (o) {
+      try {
+        i.dispose();
+      } catch (a) {
+        throw new AggregateError(
+          [o, a],
+          "[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 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"), a = this._workGraph.producerHooks(o), n = new X(
       this.kernel,
       s,
-      e,
-      (n) => this._releasePathHandle(n),
+      t,
+      (h) => this._releasePathHandle(h),
       this._reactivity,
       () => this._assertAlive(),
       () => this._assertTrackedRead(),
       this.configuration.enforceActions ? () => this._assertWriteAllowed() : void 0,
-      (n) => this._runWrite(n)
+      (h) => this._runWrite(h),
+      { token: o, onDispose: a.onDispose },
+      ({ events: h }, u) => this._workGraph.notifyProducerEvents(o, h, !0, u)
     );
-    return i.set(s.canonical, o), o;
+    try {
+      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 (d) {
+        c = !0, u = d;
+      }
+      throw r.size === 0 && this._pathHandles === r && (this._pathHandles = void 0), c ? new AggregateError(
+        [h, u],
+        "[Raph] Path source activation and rollback failed."
+      ) : h;
+    }
   }
-  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 s = e ?? "";
+    return this._reactivity._isTracking() ? this.path(s, t)._getTracked() : this.kernel.get(s, 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, s) {
+    this._assertWriteAllowed(), this._runWrite(() => this.kernel.set(e, t, s));
   }
-  /**
-   * Объединяет значение Kernel внутри runtime write policy.
-   */
-  merge(t, e, s) {
-    this._assertWriteAllowed(), this._runWrite(() => this.kernel.merge(t, e, s));
+  merge(e, t, s) {
+    this._assertWriteAllowed(), this._runWrite(() => this.kernel.merge(e, t, s));
   }
-  /**
-   * Удаляет значение 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++;
+  batch(e) {
+    return this._batch(e, !0);
+  }
+  /** Batches an internal reactive-only commit without opening an unused Kernel boundary. @internal */
+  _batchReactive(e) {
+    return this._batch(e, !1);
+  }
+  _batch(e, t) {
+    this._assertAlive(), this._batchDepth++;
+    let s, r, i = !1;
     try {
-      return this._reactivity.batch(() => this.kernel.transaction(t));
-    } finally {
-      this._transactionDepth--, this._requestExecution();
+      s = this._reactivity.batch(() => t ? this.kernel.batch(e) : e());
+    } catch (o) {
+      i = !0, r = o;
     }
+    return this._closeBatch(i, r), s;
   }
   /**
-   * Создаёт именованную action boundary для разрешённых записей.
+   * Закрывает один уровень batch: внешний уровень очищает transient causes и
+   * запускает фазы. Бросает ошибку операции, ошибки закрытия либо все вместе;
+   * после успешной операции и закрытия возвращает управление.
    */
-  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)));
+  _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."
+      ) : t;
+    s !== void 0 && m(s, "[Raph] Batch phase execution failed.");
   }
   /**
-   * Выполняет операцию внутри action boundary.
+   * Исполняет тело action: `batch(() => _runUntracked(() => operation(...args)))`
+   * без closures и без промежуточных вызовов слоёв. Runtime, который один
+   * владеет своим Kernel без derived handles, metadata watchers и adapter,
+   * открывает границы reactive batch, Kernel и path batch явными вызовами и
+   * закрывает их в том же порядке и с теми же ошибками, что вложенные
+   * `batch()` этих слоёв. В любом другом состоянии исполняется сам `batch()`.
    */
-  runInAction(t, e) {
-    this._assertAlive(), this._actionDepth++;
+  _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 {
-      return this.transaction(() => this._runUntracked(e));
-    } finally {
-      this._actionDepth--;
+      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;
   }
-  /**
-   * Выполняет операцию без регистрации реактивных зависимостей.
-   */
-  untracked(t) {
-    return this._assertAlive(), this._reactivity.untrackedWithOwner(t);
+  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 (...a) => {
+      i._assertAlive();
+      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,
+        ...u === void 0 ? {} : { operationId: u },
+        status: "start"
+      }), d !== void 0 && h.push(d), this._actionDepth++;
+      try {
+        const _ = this._applyBatch(r, a);
+        return n.traces("action") && n.record({
+          ...d === void 0 ? {} : { causeId: d },
+          kind: "action",
+          name: o,
+          ...u === void 0 ? {} : { operationId: u },
+          status: "end"
+        }), _;
+      } catch (_) {
+        throw this._debugController.record({
+          ...d === void 0 ? {} : { causeId: d },
+          details: { message: x(_) },
+          kind: "action",
+          name: o,
+          ...u === void 0 ? {} : { operationId: u },
+          status: "error"
+        }), this._debugController.record({
+          ...d === void 0 ? {} : { causeId: d },
+          details: { message: x(_) },
+          kind: "error",
+          name: `action:${o}`,
+          ...u === void 0 ? {} : { operationId: u },
+          status: "error"
+        }), _;
+      } finally {
+        this._actionDepth--, d !== void 0 && h.pop();
+      }
+    };
   }
-  /**
-   * Создаёт дочерний lifecycle scope.
-   */
-  scope(t) {
-    return this._assertAlive(), new S(t, this);
+  untracked(e) {
+    return this._assertAlive(), this._runUntracked(e);
+  }
+  scope(e) {
+    return this._assertAlive(), new O(e, this);
+  }
+  node(e, t) {
+    this._assertAlive(), this._enterWrite();
+    let s;
+    try {
+      s = this._createCommittedNode(e, t);
+    } catch (r) {
+      throw this._failWrite(r);
+    }
+    return this._exitWrite(), s._assertAlive(), s;
   }
   /**
-   * Создаёт дочерний execution node.
+   * Создаёт provisional node, выполняет setup и публикует результат; при ошибке
+   * setup откатывает node до выхода из границы mutation.
    */
-  node(t, e) {
-    this._assertAlive();
-    const s = t.parent ?? this.root, i = new m(s, t, this);
+  _createCommittedNode(e, t) {
+    const s = e.parent ?? this.root, r = H(s, e, this);
     try {
-      return i._setApi(e(i)), i;
-    } catch (r) {
+      const i = t?.(r);
+      return r._assertAlive(), s._assertAlive(), r._setApi(i), r._publishCreation(), r;
+    } catch (i) {
       try {
-        i.dispose();
+        r.dispose();
       } catch (o) {
-        throw new AggregateError(
-          [r, o],
-          `[Raph] Node "${i.id}" setup and cleanup failed.`
-        );
+        throw new AggregateError([i, o], `[Raph] Node "${r.id}" setup and cleanup failed.`);
       }
-      throw r;
+      throw i;
     }
   }
-  /**
-   * Находит принадлежащий runtime node по id для диагностики.
-   */
-  getNode(t) {
-    this._assertAlive();
-    const e = [this.root];
-    for (; e.length !== 0; ) {
-      const s = e.pop();
-      if (s.id === t)
-        return s;
-      e.push(...s.children);
-    }
+  getNode(e) {
+    return this._assertAlive(), this.root._findNode(e);
   }
-  /**
-   * Заменяет полное определение 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();
+    this._assertAlive(), this._phases?.clearPhases();
   }
-  /**
-   * Регистрирует path observer в phase pipeline.
-   */
-  observeData(t, e, s) {
-    return this._assertOwnerRuntime(t), this._own(this._execution.observeData(t, e, s), t);
+  requestExecution() {
+    this._assertAlive(), this._phases?.request();
   }
-  /**
-   * Регистрирует 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);
-  }
-  /**
-   * Синхронно выполняет все готовые очереди pipeline.
-   */
   flush() {
-    var t;
-    this._assertAlive(), this._executionRequested = !1, (t = this._phases) == null || t.flush();
+    this._assertAlive(), this._executionRequested = !1, this._phases?.flush();
   }
-  /**
-   * Получает lease автоматического frame-loop.
-   */
-  acquireLoop(t) {
-    return this._assertAlive(), this._clock.acquire(t);
+  afterFlush() {
+    return this._assertAlive(), this._phases?.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();
+    this._frameLoop?.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, s = this.kernel.derive({
+      ...e,
+      compute: (r) => this._runUntracked(() => t(r))
     });
     return this._own(() => s.dispose(), this.rootScope), s;
   }
-  /**
-   * Освобождает execution graph и отсоединяет runtime от shared Kernel.
-   */
   dispose() {
-    var r, o;
     if (this._disposed)
       return;
     this._disposed = !0, this._executionRequested = !1, this._signalLifecycle.owner = void 0;
-    const t = [], e = [...this._owners];
+    const e = [];
     try {
-      (r = this._frameLoop) == null || r.dispose();
-    } catch (n) {
-      t.push(n);
+      this._frameLoop?.dispose();
+    } catch (a) {
+      e.push(a);
     }
     this._frameLoop = void 0;
     try {
-      (o = this._phases) == null || o.dispose();
-    } catch (n) {
-      t.push(n);
+      this._phases?.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))
+    const t = this._collectOwners().sort(ie);
+    for (const a of t)
+      if (!(a === this.root || a === this.rootScope || a.disposed))
         try {
-          n.dispose();
-        } catch (c) {
-          t.push(c);
+          a.dispose();
+        } catch (n) {
+          e.push(n);
         }
     try {
       this.rootScope.dispose();
-    } catch (n) {
-      t.push(n);
+    } catch (a) {
+      e.push(a);
+    }
+    const s = `[Raph] Runtime "${this.id}" is disposed.`, r = () => {
+      throw new A(s);
+    };
+    try {
+      L(this._reactivity, {
+        assertRead: r,
+        assertWrite: r,
+        throwForeign: r
+      });
+    } 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())
+    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 {
-          n.dispose();
-        } catch (c) {
-          t.push(c);
+          a.dispose();
+        } catch (n) {
+          e.push(n);
         }
-      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 (n) {
+        e.push(n);
       }
-    D(t, `[Raph] Runtime "${this.id}" disposal failed.`);
+    m(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, s, r) {
+    if (!this._workGraph._hasStructuralDemand(e)) {
+      this._touchMutationBoundary();
+      return;
+    }
+    this._runNodeMutation(() => {
+      this._workGraph.notifyNode(e, "structure", { structure: t, oldAncestors: s, newAncestors: r });
+    });
   }
   /**
-   * Регистрирует listener освобождения runtime.
+   * Сообщает, может ли structural publication этой node дойти до подписчика;
+   * `false` позволяет не строить structure cause и списки ancestors.
+   *
    * @internal
    */
-  _onDisposed(t) {
-    return this._disposed ? (t(), () => {
-    }) : (this._disposedListeners.add(t), () => {
-      this._disposedListeners.delete(t);
-    });
+  _hasNodeStructureDemand(e) {
+    return this._workGraph._hasStructuralDemand(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);
+  /**
+   * Сообщает, есть ли у 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 }));
+  }
+  /** @internal */
+  _assertNodeReparentAllowed(e, t) {
+    this._workGraph.assertReparentAllowed(e, t);
+  }
+  /** @internal */
+  _releaseNode(e) {
+    this._workGraph.releaseNode(e);
+  }
+  /** @internal */
+  _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);
+  }
+  /**
+   * Открывает границу освобождения. `node` передаёт только dispose самой node:
+   * Runtime помнит её до парного `_endOwnerDisposal`.
+   *
+   * @internal
+   */
+  _beginOwnerDisposal(e) {
+    this._disposingNodes[this._ownerDisposalDepth++] = e;
+  }
+  /** @internal */
+  _endOwnerDisposal() {
+    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;
+  }
+  /**
+   * Учитывает нового владельца и возвращает его порядковый номер регистрации.
+   * Plain scope сразу входит в набор владельцев вне списков детей; node входит
+   * в него сама через `_addTopOwner`, и только если у неё нет parent.
+   *
+   * @internal
+   */
+  _registerOwner(e) {
+    return this._assertAlive(), e._isNode || this._topOwners.add(e), ++this._ownerRegistrations;
+  }
+  /**
+   * Снимает владельца с учёта. Plain scope выходит и из набора владельцев вне
+   * списков детей; node без parent выходит из него сама через
+   * `_removeTopOwner`, а node с parent в нём не состоит.
+   *
+   * @internal
+   */
+  _unregisterOwner(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 b("[Raph] Owner belongs to another runtime.");
+    e._assertAlive();
+  }
+  /** @internal */
+  _beginKernelBatch() {
+    this._disposed || this._kernelBatchDepth++;
+  }
+  /** @internal */
+  _endKernelBatch() {
+    this._kernelBatchDepth !== 0 && (this._kernelBatchDepth--, this._clearTransientCausesIfSettled(), this._disposed || this._requestExecution());
+  }
+  /** Регистрирует read-only diagnostics projection optional Machine. @internal */
+  _registerMachineDebug(e) {
+    return this._assertAlive(), this._debugController.registerMachine(e);
+  }
+  /**
+   * Проверяет optional diagnostic identity без создания public facade.
+   *
+   * @internal
+   */
+  _hasMachineDebug(e) {
+    return this._debugController.hasMachine(e);
+  }
+  /**
+   * Проверяет optional trace path без выделения operation ID.
+   *
+   * @internal
+   */
+  _traces(e) {
+    return this._debugController.traces(e);
+  }
+  /** Возвращает наследуемый cause для optional execution layers. @internal */
+  _currentTraceCauseId() {
+    return this._traceCauseStack.at(-1);
+  }
+  /** Выдаёт operation id только на активном trace path. @internal */
+  _nextTraceOperation(e) {
+    return this._debugController.nextOperationId(e);
+  }
+  /**
+   * Проверяет, должен ли untracked work изолировать reactive или Runtime owner context.
+   *
+   * @internal
+   */
+  _hasActiveReactiveContext() {
+    return this._assertAlive(), this._reactivity.hasActiveContext();
+  }
+  /** Записывает optional trace event без machine dependency. @internal */
+  _recordTrace(e) {
+    this._debugController.record(e);
+  }
+  /** Наследует cause через outputs/tasks optional execution layers. @internal */
+  _runWithTraceCause(e, t) {
+    if (e === void 0)
+      return t();
+    this._traceCauseStack.push(e);
+    try {
+      return t();
+    } finally {
+      this._traceCauseStack.pop();
+    }
+  }
+  /**
+   * Выполняет единственную проверку binding: pipeline доверяет её результату.
+   */
+  _validatePhaseBinding(e, t, s, r, i = !1) {
+    if (typeof s != "function")
+      throw new TypeError("[Raph] Phase callback must be a function.");
+    const o = e.resolvePhase(t), a = r.priority ?? 0;
+    if (!Number.isFinite(a))
+      throw new TypeError("[Raph] Effect priority must be finite.");
+    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 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);
+    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 || (((i = this._phases) == null ? void 0 : i._debugPending()) ?? !1)),
-      transactionDepth: this._transactionDepth,
-      kernelTransactionDepth: this._kernelTransactionDepth,
-      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)
+      pending: !this._disposed && (this._executionRequested || (this._phases?._debugPending() ?? !1)),
+      batchDepth: this._batchDepth,
+      kernelBatchDepth: this._kernelBatchDepth,
+      owners: this._liveOwnerCount(),
+      pathHandles: this._pathHandles?.size ?? 0,
+      rootScope: D(this.rootScope),
+      scopes: Object.freeze(t),
+      root: D(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);
+  _createDebugTree() {
+    const e = this._debugController.machineTreeNodesByOwner(), t = [
+      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),
+      disposed: this._disposed,
+      id: this.id,
+      kind: "runtime"
+    });
+  }
+  _createDebugStats() {
+    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);
       }
-      u = void 0, p = [], D(_, "[RaphMeta] Phase watch disposal failed.");
-    };
+    }
+    return Object.freeze({
+      actors: this._debugController.actorCount,
+      machines: this._debugController.machineCount,
+      // Каждый учтённый владелец, который не 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,
+      traceEvents: this._debugController.traceSize
+    });
   }
-  _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));
+  /**
+   * Возвращает число владельцев, которых 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?.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 ??= new j(
       this.configuration.scheduler,
-      (t) => this._runUntracked(t),
+      this._reactivity,
+      (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 === f.Sync && (this._executionRequested = !0), e;
+      },
+      (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,
+          ...r === void 0 ? {} : { operationId: r },
+          status: t
+        });
       }
-    ));
+    );
   }
   get _clock() {
-    return this._frameLoop ?? (this._frameLoop = new H(() => this._tickFrameLoop()));
+    return this._frameLoop ??= new z(() => 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._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(t, e, s) {
-    let i = e;
+  _attachWritableComputed(e, t, s) {
+    let r = t;
     this._own(() => {
-      i = void 0;
+      r = void 0;
     }, s);
-    const r = t;
-    return r.set = (o) => {
-      s._assertAlive(), this._assertWriteAllowed(), i(o);
-    }, r;
+    const i = e;
+    return i.set = (o) => {
+      s._assertAlive(), this._assertWriteAllowed(), this._runWrite(() => r(o));
+    }, i;
   }
-  _own(t, e) {
+  _own(e, t) {
     try {
-      return e._adoptResource(t);
+      return t._adoptResource(e);
     } catch (s) {
       try {
-        t();
-      } catch (i) {
-        throw new AggregateError(
-          [s, i],
-          "[Raph] Resource registration and cleanup failed."
-        );
+        e();
+      } catch (r) {
+        throw new AggregateError([s, r], "[Raph] Resource registration and cleanup failed.");
       }
       throw s;
     }
   }
+  _runTracked(e, t) {
+    return this._reactivity.runWithOwner(this._signalLifecycle, e, t);
+  }
+  _runUntracked(e) {
+    return this._reactivity.untrackedWithOwner(e);
+  }
+  _runWrite(e, t = !0) {
+    t && this.configuration.scheduler === f.Sync && (this._executionRequested = !0), this._mutationDepth++;
+    let s, r, i = !1;
+    try {
+      s = e();
+    } catch (a) {
+      i = !0, r = a;
+    }
+    if (this._mutationDepth--, this._executionBoundaryOpen()) {
+      if (i)
+        throw r;
+      return s;
+    }
+    const o = this._finishExecutionBoundary();
+    if (i)
+      throw o !== void 0 ? new AggregateError(
+        [r, ...o],
+        "[Raph] Mutation and scheduled phase execution failed."
+      ) : r;
+    return o !== void 0 && m(o, "[Raph] Mutation phase execution failed."), s;
+  }
   /**
-   * Регистрирует lifecycle owner в runtime registry.
+   * Открывает границу записи без closure; повторяет начало `_runWrite`.
+   *
    * @internal
    */
-  _registerOwner(t) {
-    this._assertAlive(), this._owners.add(t);
+  _enterWrite() {
+    this.configuration.scheduler === f.Sync && (this._executionRequested = !0), this._mutationDepth++;
   }
   /**
-   * Удаляет lifecycle owner из runtime registry.
+   * Закрывает успешную запись, открытую `_enterWrite`; внешняя граница очищает
+   * transient causes и запускает фазы с теми же ошибками, что и `_runWrite`.
+   *
    * @internal
    */
-  _unregisterOwner(t) {
-    this._owners.delete(t);
+  _exitWrite() {
+    if (this._mutationDepth--, this._executionBoundaryOpen())
+      return;
+    const e = this._finishExecutionBoundary();
+    e !== void 0 && m(e, "[Raph] Mutation phase execution failed.");
   }
   /**
-   * Проверяет, что owner принадлежит этому живому runtime.
+   * Закрывает запись после ошибки операции и возвращает ошибку для throw:
+   * исходную либо AggregateError, если упало и закрытие внешней границы.
+   *
    * @internal
    */
-  _assertOwnerRuntime(t) {
-    if (this._assertAlive(), t.runtime !== this)
-      throw new k("[Raph] Owner belongs to another runtime.");
-    t._assertAlive();
-  }
-  _runTracked(t) {
-    return this._reactivity.runWithOwner(this._signalLifecycle, t);
+  _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."
+    );
   }
-  _runUntracked(t) {
-    return this._reactivity.untrackedWithOwner(t);
+  /**
+   * Сообщает, что внешняя write-, batch-, Kernel- или disposal-граница ещё открыта.
+   * В этом состоянии оба шага `_finishExecutionBoundary` заведомо ничего не делают:
+   * transient causes очищаются и фазы запускаются только при нулевых глубинах.
+   */
+  _executionBoundaryOpen() {
+    return this._mutationDepth !== 0 || this._batchDepth !== 0 || this._kernelBatchDepth !== 0 || this._ownerDisposalDepth !== 0;
   }
-  _runWrite(t, e = !0) {
-    e && this.configuration.scheduler === d.Sync && (this._executionRequested = !0), this._mutationDepth++;
+  /** Закрывает внешнюю границу; массив ошибок создаётся только при первой ошибке. */
+  _finishExecutionBoundary() {
+    let e;
     try {
-      return t();
-    } finally {
-      this._mutationDepth--, this._requestExecution();
+      this._clearTransientCausesIfSettled();
+    } catch (t) {
+      e = [t];
     }
+    try {
+      this._requestExecution();
+    } catch (t) {
+      e === void 0 ? e = [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());
+    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());
   }
-  /**
-   * Открывает 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 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 b("[Raph] Implicit dependency crosses runtime boundaries.");
+    if (!(e === this.rootScope || e === t)) {
+      if (e instanceof v && t instanceof v) {
+        for (let s = t.parent; s !== null; s = s.parent)
+          if (s === 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 F("[Raph] Writes are allowed only inside action() or batch().");
   }
-  _throwCrossRuntime(t) {
-    throw new k(
-      `[Raph] Runtime "${this.id}" cannot be tracked by runtime "${t.id}".`
+  _throwCrossRuntime(e) {
+    throw new b(
+      `[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)
-  );
 }
-function E(a) {
-  return typeof a == "object" && a !== null && "segs" in a && a.segs !== void 0 && Array.isArray(a.segs);
+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 s of t)
+    B.from(s, e)._asMask();
 }
-function I(a) {
-  return a === d.Sync || a === d.Microtask || a === d.AnimationFrame;
+function x(p) {
+  return p instanceof Error ? p.message : String(p);
 }
 export {
-  P as RaphRuntime
+  T as RaphRuntime
 };