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

package/dist/debug/runtime/RaphRuntime.js

@@ -1,163 +1,36 @@
-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();
+import { parseDataPath as g } from "../path/data-path.utils.js";
+import { DataPath as m } from "../path/DataPath.js";
+import { RaphMeta as b } from "../path/meta/RaphMeta.js";
+import { RaphKernel as k } from "../path/RaphKernel.js";
+import { RaphDebugController as w, createOwnerSnapshot as l, createOwnerTree as u } from "./diagnostics/RaphDebug.js";
+import { RaphNode as _ } from "./ownership/RaphNode.js";
+import { RaphRuntimeBase as v, resolveRuntimeConfiguration as R } from "./RaphRuntimeBase.js";
+import { PathHandle as S } from "./reactivity/PathHandle.js";
+import { RaphMetaSource as D } from "./reactivity/RaphMetaSource.js";
+import { RUNTIME_OBJECT_SUPPORT as y } from "./reactivity/RuntimeObjectSupport.js";
+import { RUNTIME_SELECTOR_SUPPORT as O } from "./reactivity/RuntimeSelectorSupport.js";
+class x extends v {
   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 o = e.kernel ?? new G({ id: `${t}-kernel` });
-    this.configuration = Object.freeze({
-      adaptiveDependencyIndex: s,
+    const t = R(e), r = e.kernel ?? new k({ id: `${t.id}-kernel` }), s = Object.freeze({
+      ...t,
       ...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,
-      assertDependencyAllowed: (h, u) => {
-        this._assertImplicitDependency(h, u);
-      },
-      ...r ? { assertWriteAllowed: () => this._assertWriteAllowed() } : {},
-      throwDisposed: () => {
-        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);
-      },
-      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()
+      kernel: r
     });
+    super(s, void 0, y, O), this._debugController = new w(e.debug, this, this._syncPhaseTrace), r._attachRuntime(this);
   }
-  /** @internal */
-  _getReactivity() {
-    return this._reactivity;
-  }
-  /**
-   * Возвращает внутренний WorkGraph для optional execution layers.
-   *
-   * @internal
-   */
-  _getWorkGraph() {
-    return this._workGraph;
-  }
-  get id() {
-    return this.configuration.id;
-  }
+  _pathHandles;
+  _meta;
+  _debug;
   get kernel() {
     return this.configuration.kernel;
   }
-  get disposed() {
-    return this._disposed;
-  }
-  get graph() {
-    return this._parentGraph ??= $();
-  }
-  get loopEnabled() {
-    return this._frameLoop?.running ?? !1;
-  }
-  get frame() {
-    return this._phases?.frame ?? { now: 0, delta: 0, elapsed: 0, frame: 0 };
-  }
-  get 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, {
+    const e = new b(this.kernel, {
       assertReadable: () => this._assertAlive(),
       assertWritable: () => this._assertWriteAllowed(),
-      runWrite: (t, s) => this._runWrite(t, s)
+      runWrite: (t, r) => this._runWrite(t, r)
     });
     return this._meta = Object.freeze({
       delete: e.delete.bind(e),
@@ -179,241 +52,45 @@ class T {
       machines: this._debugController.machines
     });
   }
-  signal(e, t = this.rootScope) {
-    return this._assertOwnerRuntime(t), this._reactivity.signalForOwner(e, t);
-  }
-  /**
-   * Creates a deep reactive Proxy owned by this Runtime root scope.
-   * Property dependencies use the intrusive graph directly and intentionally
-   * do not create per-property WorkGraph producers or phase causes.
-   */
-  reactive(e) {
-    return this._assertAlive(), this._reactivity.reactive(e);
-  }
-  computed(e, t = this.rootScope) {
-    this._assertOwnerRuntime(t);
-    const 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)
-    );
-  }
-  /**
-   * Регистрирует один 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 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 {
-      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 {
-        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,
-        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._assertAlive(), P(e, t);
+    const r = this._workGraph.createProducer(this.rootScope, "path"), s = this._workGraph.producerHooks(r).onDispose, a = D._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();
+        a.masks,
+        ({ events: i }) => this._workGraph.notifyProducerEvents(r, i, !1),
+        a.options,
+        (i) => {
+          i && this._execution.request();
         }
       ),
-      () => r(!1)
+      () => s(!1)
     );
-    i._bindOwner(this.rootScope._adoptResource(() => i._disposeOwned()));
+    a._bindOwner(this.rootScope._adoptResource(() => a._disposeOwned()));
     try {
-      return this._workGraph.setProducerActivation(s, () => i._activate(), !0), this._workGraph.attachProducer(s, i), i;
-    } catch (o) {
+      return this._workGraph.setProducerActivation(r, () => a._activate(), !0), this._workGraph.attachProducer(r, a), a;
+    } catch (i) {
       try {
-        i.dispose();
-      } catch (a) {
+        a.dispose();
+      } catch (n) {
         throw new AggregateError(
-          [o, a],
+          [i, n],
           "[Raph] Meta source activation and rollback failed."
         );
       }
-      throw o;
+      throw i;
     }
   }
   path(e, t = {}) {
     this._assertAlive();
-    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(
+    const r = g(e, t), s = this._pathHandles ??= /* @__PURE__ */ new Map(), a = s.get(r.canonical);
+    if (a !== void 0)
+      return a;
+    const i = this._workGraph.createProducer(this.rootScope, "path"), n = this._workGraph.producerHooks(i), o = new S(
       this.kernel,
-      s,
+      r,
       t,
       (h) => this._releasePathHandle(h),
       this._reactivity,
@@ -421,28 +98,28 @@ class T {
       () => this._assertTrackedRead(),
       this.configuration.enforceActions ? () => this._assertWriteAllowed() : void 0,
       (h) => this._runWrite(h),
-      { token: o, onDispose: a.onDispose },
-      ({ events: h }, u) => this._workGraph.notifyProducerEvents(o, h, !0, u)
+      { token: i, onDispose: n.onDispose },
+      ({ events: h }, c) => this._workGraph.notifyProducerEvents(i, h, !0, c)
     );
     try {
-      return this._workGraph.setProducerActivation(o, () => n._activate(), !0), this._workGraph.attachProducer(o, n), r.set(s.canonical, n), n;
+      return this._workGraph.setProducerActivation(i, () => o._activate(), !0), this._workGraph.attachProducer(i, o), s.set(r.canonical, o), o;
     } catch (h) {
-      let u, c = !1;
+      let c, p = !1;
       try {
-        n.dispose();
-      } catch (d) {
-        c = !0, u = d;
+        o.dispose();
+      } catch (f) {
+        p = !0, c = f;
       }
-      throw r.size === 0 && this._pathHandles === r && (this._pathHandles = void 0), c ? new AggregateError(
-        [h, u],
+      throw s.size === 0 && this._pathHandles === s && (this._pathHandles = void 0), p ? new AggregateError(
+        [h, c],
         "[Raph] Path source activation and rollback failed."
       ) : h;
     }
   }
   get(e, t) {
     this._assertTrackedRead();
-    const s = e ?? "";
-    return this._reactivity._isTracking() ? this.path(s, t)._getTracked() : this.kernel.get(s, t);
+    const r = e ?? "";
+    return this._reactivity._isTracking() ? this.path(r, t)._getTracked() : this.kernel.get(r, t);
   }
   peek(e, t) {
     return this._assertAlive(), this.kernel.peek(e ?? "", t);
@@ -450,558 +127,25 @@ class T {
   has(e, t) {
     return this._assertAlive(), this.kernel.has(e, t);
   }
-  set(e, t, s) {
-    this._assertWriteAllowed(), this._runWrite(() => this.kernel.set(e, t, s));
+  set(e, t, r) {
+    this._assertWriteAllowed(), this._runWrite(() => this.kernel.set(e, t, r));
   }
-  merge(e, t, s) {
-    this._assertWriteAllowed(), this._runWrite(() => this.kernel.merge(e, t, s));
+  merge(e, t, r) {
+    this._assertWriteAllowed(), this._runWrite(() => this.kernel.merge(e, t, r));
   }
   delete(e, t) {
     this._assertWriteAllowed(), this._runWrite(() => this.kernel.delete(e, t));
   }
-  batch(e) {
-    return this._batch(e, !0);
-  }
-  /** Batches an internal reactive-only commit without opening an unused Kernel boundary. @internal */
-  _batchReactive(e) {
-    return this._batch(e, !1);
-  }
-  _batch(e, t) {
-    this._assertAlive(), this._batchDepth++;
-    let s, r, i = !1;
-    try {
-      s = this._reactivity.batch(() => t ? this.kernel.batch(e) : e());
-    } catch (o) {
-      i = !0, r = 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."
-      ) : 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, 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();
-      }
-    };
-  }
-  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;
-  }
-  /**
-   * Создаёт 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 {
-        r.dispose();
-      } catch (o) {
-        throw new AggregateError([i, o], `[Raph] Node "${r.id}" setup and cleanup failed.`);
-      }
-      throw i;
-    }
-  }
-  getNode(e) {
-    return this._assertAlive(), this.root._findNode(e);
-  }
-  definePhases(e) {
-    this._execution.definePhases(e);
-  }
-  addPhase(e) {
-    this._execution.addPhase(e);
-  }
-  clearPhases() {
-    this._assertAlive(), this._phases?.clearPhases();
-  }
-  requestExecution() {
-    this._assertAlive(), this._phases?.request();
-  }
-  flush() {
-    this._assertAlive(), this._executionRequested = !1, this._phases?.flush();
-  }
-  afterFlush() {
-    return this._assertAlive(), this._phases?.afterFlush() ?? Promise.resolve();
-  }
-  acquireLoop(e) {
-    return this._assertAlive(), this._clock.acquire(e);
-  }
-  startLoop() {
-    this._assertAlive(), this._clock.start();
-  }
-  stopLoop() {
-    this._frameLoop?.stop();
-  }
   derive(e) {
     this._assertAlive();
-    const t = e.compute, s = this.kernel.derive({
+    const t = e.compute, r = this.kernel.derive({
       ...e,
-      compute: (r) => this._runUntracked(() => t(r))
-    });
-    return this._own(() => s.dispose(), this.rootScope), s;
-  }
-  dispose() {
-    if (this._disposed)
-      return;
-    this._disposed = !0, this._executionRequested = !1, this._signalLifecycle.owner = void 0;
-    const e = [];
-    try {
-      this._frameLoop?.dispose();
-    } catch (a) {
-      e.push(a);
-    }
-    this._frameLoop = void 0;
-    try {
-      this._phases?.dispose();
-    } catch (a) {
-      e.push(a);
-    }
-    this._phases = void 0;
-    try {
-      this.root.dispose();
-    } catch (a) {
-      e.push(a);
-    }
-    const t = this._collectOwners().sort(ie);
-    for (const a of t)
-      if (!(a === this.root || a === this.rootScope || a.disposed))
-        try {
-          a.dispose();
-        } catch (n) {
-          e.push(n);
-        }
-    try {
-      this.rootScope.dispose();
-    } 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._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 (n) {
-          e.push(n);
-        }
-      i.clear();
-    }
-    try {
-      this._workGraph.dispose();
-    } catch (a) {
-      e.push(a);
-    }
-    try {
-      this.kernel._detachRuntime(this);
-    } catch (a) {
-      e.push(a);
-    }
-    const o = [...this._disposedListeners];
-    this._disposedListeners.clear();
-    for (const a of o)
-      try {
-        a();
-      } catch (n) {
-        e.push(n);
-      }
-    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 });
+      compute: (s) => this._runUntracked(() => t(s))
     });
-  }
-  /**
-   * Сообщает, может ли 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 }));
-  }
-  /** @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;
+    return this._own(() => r.dispose(), this.rootScope), r;
   }
   _createDebugSnapshot() {
-    const e = this._frameLoop?._debugState() ?? { running: !1, manual: !1, leases: 0 }, t = [...this._topOwners].filter((s) => s !== this.rootScope && !(s instanceof v)).map(D);
+    const e = this._frameLoop?._debugState() ?? { running: !1, manual: !1, leases: 0 }, t = [...this._topOwners].filter((r) => r !== this.rootScope && !(r instanceof _)).map(l);
     return Object.freeze({
       id: this.id,
       disposed: this._disposed,
@@ -1010,9 +154,9 @@ class T {
       kernelBatchDepth: this._kernelBatchDepth,
       owners: this._liveOwnerCount(),
       pathHandles: this._pathHandles?.size ?? 0,
-      rootScope: D(this.rootScope),
+      rootScope: l(this.rootScope),
       scopes: Object.freeze(t),
-      root: D(this.root),
+      root: l(this.root),
       frameLoop: Object.freeze(e),
       actionDepth: this._actionDepth,
       machines: this._debugController.machineCount,
@@ -1021,9 +165,9 @@ class T {
   }
   _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))
+      u(this.rootScope, e),
+      u(this.root, e),
+      ...[...this._topOwners].filter((r) => r !== this.rootScope && r !== this.root && !(r instanceof _)).map((r) => u(r, e))
     ];
     return Object.freeze({
       children: Object.freeze(t),
@@ -1035,15 +179,15 @@ class T {
   _createDebugStats() {
     const e = this._liveOwnerCount();
     let t = 0;
-    const s = { resources: 0, sources: 0 };
+    const r = { 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);
+      const s = this._topOwners;
+      for (const n of s)
+        n._isNode ? n._countSubtree(r) : (t++, r.resources += n._debugResourceCount(), r.sources += n._debugSourceCount());
+      const a = this._disposingNodes, i = this._ownerDisposalDepth;
+      for (let n = 0; n < i; n++) {
+        const o = a[n];
+        o === void 0 || o._isLinked() || s.has(o) || o._countSubtree(r);
       }
     }
     return Object.freeze({
@@ -1054,279 +198,74 @@ class T {
       owners: e,
       pathHandles: this._pathHandles?.size ?? 0,
       pending: !this._disposed && (this._executionRequested || (this._phases?._debugPending() ?? !1)),
-      resources: s.resources,
+      resources: r.resources,
       scopes: t,
-      sources: s.sources,
+      sources: r.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?.get(e.path) === e && (t.delete(e.path), t.size === 0 && (this._pathHandles = void 0));
   }
-  get _execution() {
-    return this._assertAlive(), this._phases ??= new j(
-      this.configuration.scheduler,
-      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 === 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 ??= new z(() => this._tickFrameLoop());
-  }
-  _tickFrameLoop() {
-    this._disposed || this._setFrameTick(this._frameTickSignal.peek() + 1);
-  }
-  /**
-   * Записывает frame signal в собственной границе записи, минуя политику
-   * actions: кадр продвигает сам Runtime.
-   */
-  _setFrameTick(e) {
-    this._enterWrite();
+  _applyBatch(e, t, r) {
+    this._assertAlive();
+    const s = this.kernel, a = s._openSoleRuntimeBatch(this);
+    if (a === void 0)
+      return this._batch(() => this._runUntracked(() => Reflect.apply(e, r, t)), !0);
+    const i = this._reactivity;
+    this._batchDepth++, i._startBatch();
+    let n, o, h = !1;
     try {
-      this._frameTickSignal._writeInBoundary(e);
-    } catch (t) {
-      throw this._failWrite(t);
+      n = i._applyUntrackedWithOwner(e, t, r);
+    } catch (c) {
+      h = !0, o = c;
     }
-    this._exitWrite();
-  }
-  _attachWritableComputed(e, t, s) {
-    let r = t;
-    this._own(() => {
-      r = void 0;
-    }, s);
-    const i = e;
-    return i.set = (o) => {
-      s._assertAlive(), this._assertWriteAllowed(), this._runWrite(() => r(o));
-    }, i;
-  }
-  _own(e, t) {
     try {
-      return t._adoptResource(e);
-    } catch (s) {
-      try {
-        e();
-      } catch (r) {
-        throw new AggregateError([s, r], "[Raph] Resource registration and cleanup failed.");
-      }
-      throw s;
+      s._closeSoleRuntimeBatch(this, a, h, o);
+    } catch (c) {
+      h = !0, o = c;
     }
-  }
-  _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;
+      i._endBatch();
+    } catch (c) {
+      o = h ? new AggregateError([o, c], "Batch operation and effect queue processing failed.") : c, h = !0;
     }
-    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;
+    return this._closeBatch(h, o), n;
   }
-  /**
-   * Открывает границу записи без 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."
-    );
+  _runDataBatch(e) {
+    return this.kernel.batch(e);
   }
-  /**
-   * Сообщает, что внешняя write-, batch-, Kernel- или disposal-граница ещё открыта.
-   * В этом состоянии оба шага `_finishExecutionBoundary` заведомо ничего не делают:
-   * transient causes очищаются и фазы запускаются только при нулевых глубинах.
-   */
-  _executionBoundaryOpen() {
-    return this._mutationDepth !== 0 || this._batchDepth !== 0 || this._kernelBatchDepth !== 0 || this._ownerDisposalDepth !== 0;
-  }
-  /** Закрывает внешнюю границу; массив ошибок создаётся только при первой ошибке. */
-  _finishExecutionBoundary() {
-    let e;
-    try {
-      this._clearTransientCausesIfSettled();
-    } catch (t) {
-      e = [t];
+  _disposeDataSources(e) {
+    this._meta = void 0;
+    const t = this._pathHandles;
+    if (this._pathHandles = void 0, t !== void 0) {
+      for (const r of t.values())
+        try {
+          r.dispose();
+        } catch (s) {
+          e.push(s);
+        }
+      t.clear();
     }
+  }
+  _detachDataPlane(e) {
     try {
-      this._requestExecution();
+      this.kernel._detachRuntime(this);
     } catch (t) {
-      e === void 0 ? e = [t] : e.push(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() {
-    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();
-    const e = this._reactivity.getActiveOwner();
-    e !== void 0 && e !== this && this._throwCrossRuntime(e);
-    const t = this._reactivity.getActiveConsumerOwner();
-    t !== void 0 && this._assertImplicitDependency(this.rootScope, t);
-  }
-  /**
-   * Проверяет tracked read из optional owned source.
-   *
-   * @internal
-   */
-  _assertSourceReadable(e) {
-    this._assertAlive();
-    const t = this._reactivity.getActiveOwner();
-    t !== void 0 && t !== this && this._throwCrossRuntime(t);
-    const 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._batchDepth === 0)
-      throw new F("[Raph] Writes are allowed only inside action() or batch().");
-  }
-  _throwCrossRuntime(e) {
-    throw new b(
-      `[Raph] Runtime "${this.id}" cannot be tracked by runtime "${e.id}".`
-    );
-  }
-  _assertAlive() {
-    if (this._disposed)
-      throw new A(`[Raph] Runtime "${this.id}" is disposed.`);
   }
 }
-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];
+function P(d, e) {
+  const t = Array.isArray(d) ? d : [d];
   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 x(p) {
-  return p instanceof Error ? p.message : String(p);
+  for (const r of t)
+    m.from(r, e)._asMask();
 }
 export {
-  T as RaphRuntime
+  x as RaphRuntime
 };