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

package/dist/debug/reactivity/engine-core.js

@@ -0,0 +1,1760 @@
+import { appendScopeChild as A, ScopeNode as O, throwScopeErrors as m, detachScopeChild as H } from "./scope.js";
+import { watchWithReactivity as F } from "./watch.js";
+const S = 1, f = 2, D = 4, p = 8, E = 16, o = 32, d = 64, R = 128, y = 256, h = 512, N = 1 << 17, L = 1024, g = 4096, C = 8192, k = 16384, x = 32768, _ = 65536, W = g, T = 1e4, b = S | f, U = 16;
+function q(w, e) {
+  const t = w.firstSub;
+  if (t === null)
+    return;
+  if (t === w.lastSub)
+    return t.sub === e ? t : void 0;
+  const i = w.subSearchCursor ?? t;
+  if (i.sub === e)
+    return w.subSearchCursor = i.nextSub ?? t, i;
+  let s = i.nextSub ?? t;
+  for (; s !== i; ) {
+    if (s.sub === e)
+      return w.subSearchCursor = s.nextSub ?? t, s;
+    s = s.nextSub ?? t;
+  }
+}
+class G {
+  // Opt-in стратегия длинного slow path; не добавляет policy field каждой ноде.
+  // Потребитель текущего синхронного чтения; null отключает отслеживание.
+  activeSub = null;
+  /** Потребитель-проба `_probeReads`; создаётся при первом вызове. */
+  probeNode = null;
+  probeDepth = 0;
+  // Глубина вложенных синхронных границ группировки.
+  batchDepth = 0;
+  // Индекс следующего элемента внутренней очереди эффектов.
+  effectReadIndex = 0;
+  // Позиция добавления элемента в текущем проходе очереди.
+  effectWriteIndex = 0;
+  // Граница активного префикса переиспользуемого стека invalidation.
+  invalidationDepth = 0;
+  // Граница активного префикса стека проверки зависимостей.
+  dependencyDepth = 0;
+  // Число активных проверок зависимостей; только при нём запись ищет их узлы.
+  checkingDepth = 0;
+  // Корни активных проверок по глубине вложенности. Остальные проверяемые узлы
+  // восстанавливаются из опубликованного префикса dependencyStack: отдельная
+  // пометка каждого узла на обычном пути не нужна (серия Raph Top-1, 2026-10-20).
+  checkRoots = [];
+  // Защита внутренней очереди от вложенного повторного прохода.
+  flushingEffects = !1;
+  // Переиспользуемый буфер очереди; прочитанная ячейка сразу освобождает ссылку.
+  // Первый элемент очереди хранится без обращения к массиву.
+  firstEffect;
+  effectQueue = new Array(16).fill(void 0);
+  // Переиспользуемый стек распространения invalidation; исходный способ выделения сохранён.
+  invalidationStack = new Array(512).fill(null);
+  // Переиспользуемый стек проверки зависимостей с защитой активного вложенного префикса.
+  dependencyStack = [];
+  // Общие адаптеры receiver для handles этого экземпляра.
+  // Создаются один раз, чтобы computed не хранил дополнительную ссылку на движок
+  // и не выделял отдельные get/peek closures на каждый источник.
+  handleReaders = this.createHandleReaders();
+  // Выбранная внешняя политика; у синхронного экземпляра отсутствует.
+  effectScheduler;
+  // Прямой обработчик очереди, выбранный один раз при создании экземпляра.
+  flushEffects;
+  /**
+   * Синхронная регистрация эффекта для Runtime и watch независимо от внешней политики.
+   * Это связанная ссылка на реализацию effect(), а не делегирующая функция.
+   * @internal
+   */
+  _effectImmediate;
+  /**
+   * Выбирает политику исполнения и сохраняет совместимость извлечённых методов.
+   * Тела методов находятся на прототипе; bind() выполняется только при создании
+   * экземпляра, чтобы Runtime и глобальный API могли передавать методы как callbacks.
+   * @param options Необязательная внешняя политика эффектов.
+   */
+  constructor(e = {}) {
+    this.effectScheduler = e.effectScheduler, this._effectImmediate = this.effect.bind(this), this.signal = this.signal.bind(this), this.computed = this.computed.bind(this), this.watch = this.watch.bind(this), this.batch = this.batch.bind(this), this.untracked = this.untracked.bind(this), this.scope = this.scope.bind(this), this._signalAccess = this._signalAccess.bind(this), this._computedAccess = this._computedAccess.bind(this), this._ownedSignal = this._ownedSignal.bind(this), this._ownedComputed = this._ownedComputed.bind(this), this._isTracking = this._isTracking.bind(this), this._isFlushingEffects = this._isFlushingEffects.bind(this), this._startBatch = this._startBatch.bind(this), this._endBatch = this._endBatch.bind(this), this.effect = this.effectScheduler === void 0 ? this._effectImmediate : this.createScheduledEffect.bind(this), this.flushEffects = this.effectScheduler === void 0 ? this.flushSyncEffects : this.flushExternalEffects;
+  }
+  // ---------------------------------------------
+  // PUBLIC API
+  // ---------------------------------------------
+  /**
+   * Создаёт объектный signal с get/peek/set.
+   * get() регистрирует зависимость только при активном потребителе,
+   * а peek() выполняет чтение с временно отключённым отслеживанием.
+   */
+  signal(e) {
+    let t = e, i;
+    const s = () => {
+      const r = i;
+      if (r !== void 0)
+        return this.readSignalValue(r);
+      const n = this.activeSub;
+      return n === null || (i = this.materializeSignal(
+        t,
+        n
+      )), t;
+    }, l = (r) => {
+      const n = i;
+      if (n !== void 0) {
+        this.writeSignalValue(n, r);
+        return;
+      }
+      t !== r && (t = r);
+    };
+    return {
+      get: s,
+      peek: this.handleReaders.peek,
+      set: l
+    };
+  }
+  computed(e) {
+    if (typeof e == "function")
+      return this.createComputedHandle(e);
+    const t = this.createComputedHandle(e.get);
+    return t.set = e.set, t;
+  }
+  /**
+   * Создаёт эффект согласно политике экземпляра и возвращает disposer.
+   * Прототип содержит синхронную реализацию; при наличии scheduler конструктор
+   * подставляет createScheduledEffect, сохраняя этот путь как _effectImmediate.
+   * Вложенный эффект включается в список ресурсов активного эффекта.
+   * При ошибке регистрации удаляет созданные ресурсы, сохраняя обе причины сбоя.
+   * @param fn Синхронное тело с необязательным cleanup очередного запуска.
+   * @param onStop Однократная окончательная очистка, независимая от повторных запусков.
+   */
+  effect(e, t) {
+    const i = this.allocateGraphRecord(void 0, e, f | S | o, void 0);
+    t !== void 0 && (i.onStop = t);
+    const s = this.activeSub;
+    s !== null && s.flags & o && A(s, i);
+    try {
+      this.executeEffect(i);
+    } catch (l) {
+      try {
+        this.disposeEffect(i);
+      } catch (r) {
+        throw new AggregateError([l, r], "Effect registration and cleanup failed.");
+      }
+      throw l;
+    }
+    return this.effectReadIndex !== this.effectWriteIndex && this.flushEffects(), () => this.disposeEffect(i);
+  }
+  /**
+   * Наблюдает за источниками; callback и cleanup не создают зависимостей.
+   */
+  watch(e, t, i) {
+    return F(this.effect, this.untracked, e, t, i);
+  }
+  /**
+   * Группирует синхронные записи и обрабатывает эффекты после внешней границы.
+   * Возвращает результат операции. Если тело и очередь завершаются с ошибками,
+   * передаёт обе ошибки в AggregateError вместо потери первой. Не является откатом данных.
+   */
+  batch(e) {
+    ++this.batchDepth;
+    let t;
+    try {
+      t = e();
+    } catch (i) {
+      if (!--this.batchDepth && this.effectReadIndex !== this.effectWriteIndex)
+        try {
+          this.flushEffects();
+        } catch (s) {
+          throw new AggregateError(
+            [i, s],
+            "Batch operation and effect queue processing failed."
+          );
+        }
+      throw i;
+    }
+    return !--this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects(), t;
+  }
+  /**
+   * Выполняет синхронную операцию без добавления зависимостей текущему потребителю.
+   * Восстанавливает прежний контекст и при исключении. Асинхронное продолжение
+   * операции этим контекстом не охватывается.
+   */
+  untracked(e) {
+    if (this.activeSub === null)
+      return e();
+    const t = this.activeSub;
+    this.activeSub = null;
+    try {
+      return e();
+    } finally {
+      this.activeSub = t;
+    }
+  }
+  /**
+   * Создаёт владельца ресурсов в текущем графе без Runtime и фаз.
+   */
+  scope() {
+    return new O(this);
+  }
+  // ---------------------------------------------
+  // PRIVATE
+  // ---------------------------------------------
+  /**
+   * Создаёт запись графа единой формы для standalone signal, raw computed и effect.
+   * Все горячие поля, включая pending-запись signal, курсор поиска потребителя и
+   * общий raw reader, объявлены в одном литерале: запись целиком лежит внутри
+   * объекта, а signal, computed и effect разделяют один hidden class
+   * (серия Raph Top-1, 2026-10-20). Поля внешней задачи, окончательной очистки,
+   * владельца и адаптивного индекса добавляются только при необходимости.
+   */
+  allocateGraphRecord(e, t, i, s) {
+    return {
+      flags: i,
+      firstSub: null,
+      lastSub: null,
+      firstDep: null,
+      tailDep: null,
+      evaluate: t,
+      cachedValue: e,
+      pendingValue: void 0,
+      pendingAuthor: void 0,
+      subSearchCursor: void 0,
+      read: s
+    };
+  }
+  /** Creates a narrow Proxy adapter over the existing intrusive graph. */
+  /** Узкий adapter SDK; записи графа остаются инкапсулированы. @internal */
+  _createReactivePropertySourceBridge() {
+    return {
+      batch: this.batch,
+      startBatch: this._startBatch,
+      endBatch: this._endBatch,
+      create: (e) => {
+        if (this.activeSub === null)
+          throw new Error("[Raph] Reactive property source requires a tracked read.");
+        return e === void 0 ? { firstSub: null, lastSub: null } : { firstSub: null, lastSub: null, flags: h, sourceHooks: e };
+      },
+      createTransient: (e) => {
+        if (this.activeSub === null)
+          throw new Error("[Raph] Reactive property source requires a tracked read.");
+        return { firstSub: null, lastSub: null, flags: N, onUnobserved: e };
+      },
+      isTracking: this._isTracking,
+      track: (e) => {
+        const t = this.activeSub;
+        t !== null && this.trackDependency(e, t);
+      },
+      trigger: (e) => {
+        const t = e.firstSub;
+        t !== null && (this.propagateInvalidation(t), !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects());
+      },
+      hasMultipleSubscribers: (e) => {
+        const t = e;
+        return t.firstSub !== null && t.firstSub !== t.lastSub;
+      },
+      release: (e) => this.releaseSourceSubs(e)
+    };
+  }
+  /**
+   * Материализует signal в графе при первом отслеживаемом чтении
+   * и связывает его с активным потребителем.
+   *
+   * До этого момента signal может хранить значение только в замыкании
+   * и вообще не создавать `ReactiveNode`.
+   */
+  materializeSignal(e, t, i) {
+    const s = i === void 0 ? this.allocateGraphRecord(e, void 0, 0, void 0) : {
+      flags: h,
+      firstSub: null,
+      lastSub: null,
+      firstDep: null,
+      tailDep: null,
+      evaluate: void 0,
+      cachedValue: e,
+      sourceHooks: i
+    };
+    return t.flags & R ? this.appendInitialDependency(s, t) : this.trackDependency(s, t), s;
+  }
+  /**
+   * Создаёт объектный computed сразу полной записью графа.
+   * Поля графа идут в том же порядке, что и в allocateGraphRecord(), и лежат
+   * внутри объекта; первое вычисление выполняет общий get() по флагу UNINITIALIZED.
+   * get и peek — общие функции графа с receiver (серия Raph Top-1, 2026-10-20).
+   */
+  createComputedHandle(e, t) {
+    const i = {
+      flags: t === void 0 ? E : E | h,
+      firstSub: null,
+      lastSub: null,
+      firstDep: null,
+      tailDep: null,
+      evaluate: e,
+      cachedValue: void 0,
+      pendingValue: void 0,
+      pendingAuthor: void 0,
+      subSearchCursor: void 0,
+      get: this.handleReaders.read,
+      peek: this.handleReaders.peek
+    };
+    return t !== void 0 && (i.sourceHooks = t), i;
+  }
+  /**
+   * Создаёт эффект с одной постоянной задачей внешнего scheduler.
+   * Первый и последующие запуски проходят через задачу; устаревший runner после stop
+   * ничего не выполняет. При синхронной ошибке runner обрабатывает независимую очередь.
+   * @param fn Тело эффекта.
+   * @param onStop Однократная окончательная очистка.
+   */
+  createScheduledEffect(e, t) {
+    const i = this.allocateGraphRecord(void 0, e, f | S | o, void 0);
+    let s = !1;
+    t !== void 0 && (i.onStop = t);
+    const l = this.activeSub;
+    l !== null && l.flags & o && A(l, i);
+    const r = () => {
+      if (!(!(i.flags & d) || i.evaluate === void 0)) {
+        i.flags &= ~d, s = !0;
+        try {
+          this.executeEffect(i);
+        } catch (n) {
+          if (!this.batchDepth && this.effectReadIndex !== this.effectWriteIndex)
+            try {
+              this.flushEffects();
+            } catch (a) {
+              throw new AggregateError(
+                [n, a],
+                "Effect execution and queue processing failed."
+              );
+            }
+          throw n;
+        }
+        !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects();
+      }
+    };
+    try {
+      const n = this.effectScheduler.bind(r);
+      n.cancelPending = () => i.evaluate === void 0 || !s ? !1 : (this.settleCancelledDependencies(i), i.flags &= ~(d | b | D), !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects(), !0), n.rearmPending = () => {
+        i.evaluate !== void 0 && (i.flags |= f | d, n.schedule());
+      }, i.effectTask = n, this.requestEffectTask(i);
+    } catch (n) {
+      try {
+        this.disposeEffect(i);
+      } catch (a) {
+        throw new AggregateError([n, a], "Effect registration and cleanup failed.");
+      }
+      throw n;
+    }
+    return !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects(), () => this.disposeEffect(i);
+  }
+  /**
+   * Регистрирует чтение signal и при необходимости фиксирует pending-значение.
+   * Текущая связь передаётся фиксации, чтобы не уведомлять читающего потребителя повторно.
+   */
+  readSignalValue(e) {
+    const t = this.activeSub;
+    let i = null;
+    return t !== null && (i = this.trackDependency(e, t)), e.flags & f && this.commitSignalValue(e, i), t !== null && t.flags & k && t.firstDep === i && (t.flags |= x), e.cachedValue;
+  }
+  /**
+   * Записывает новое значение или откладывает его фиксацию до чтения в batch.
+   * Сохраняет исходное сравнение через === и учёт автора pending-записи.
+   * Без batch и внешней политики очередь эффектов завершается до возврата из set().
+   */
+  writeSignalValue(e, t) {
+    if (e.flags & f || this.batchDepth) {
+      const s = !!(e.flags & f);
+      if ((e.flags & f ? e.pendingValue : e.cachedValue) === t)
+        return;
+      if (e.pendingValue = t, e.cachedValue === t)
+        e.flags &= ~f, e.pendingAuthor = void 0;
+      else {
+        e.flags |= f;
+        const n = this.activeSub !== null && this.activeSub.flags & p ? this.activeSub : null;
+        s ? e.pendingAuthor !== n && (e.pendingAuthor = null) : e.pendingAuthor = n;
+      }
+      const r = e.firstSub;
+      r != null && (!s || this.activeSub !== null && this.activeSub.flags & p || e.flags & h) && this.propagateInvalidation(r, !0);
+      return;
+    }
+    if (e.cachedValue === t)
+      return;
+    e.cachedValue = t;
+    const i = e.firstSub;
+    i != null && (this.propagateInvalidation(i), !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects());
+  }
+  /**
+   * Возвращает кеш либо синхронно актуализирует вычисляемое значение.
+   * Неуспешное вычисление не считается значением. Ошибка getter сохраняет связь
+   * с активным потребителем для восстановления. Повторное чтение во время
+   * первого сбора зависимостей отклоняется до регистрации связи и чтения кеша.
+   */
+  readComputedValue(e) {
+    const t = e.flags;
+    if ((t & (p | R)) === (p | R))
+      throw new Error("Computed value is already being evaluated.");
+    const i = t & (E | b | y | _), s = i === 0 ? e.cachedValue : i & E ? this.evaluateFirstValue(e) : this.refreshComputedValue(e, t);
+    if (e.evaluate === void 0)
+      return s;
+    const l = this.activeSub;
+    if (l !== null) {
+      const r = l.tailDep;
+      l.flags & R ? (r === null || r.dep !== e) && this.appendInitialDependency(e, l) : this.trackDependency(e, l);
+    }
+    return s;
+  }
+  /**
+   * Выполняет первый сбор зависимостей и кеширует только успешный результат.
+   * При исключении оставляет состояние повторяемой ошибки, а не чистый undefined.
+   * Уже прочитанные зависимости сохраняются для последующего уведомления.
+   */
+  evaluateFirstValue(e) {
+    const t = e.flags & h, i = e.evaluate;
+    e.flags = t | p | R;
+    const s = this.activeSub;
+    this.activeSub = e;
+    let l;
+    try {
+      if (l = i(), e.evaluate !== i)
+        return e.cachedValue = void 0, e.flags = 0, l;
+      const r = e.firstDep !== null && e.firstDep.nextDep === null && (e.flags & (k | x)) === (k | x);
+      if (e.flags = t | (r ? _ : e.flags & D ? f : 0), r)
+        return e.cachedValue = l, l;
+    } catch (r) {
+      throw e.evaluate !== i ? (e.cachedValue = void 0, e.flags = 0, r) : (e.flags = t | y, s !== null && this.trackDependency(e, s), r);
+    } finally {
+      this.activeSub = s;
+    }
+    return e.flags & f ? this.refreshComputedValue(e, e.flags) : (e.cachedValue = l, l);
+  }
+  /**
+   * Актуализирует computed: выполняет прямой пересчёт либо проверяет зависимости.
+   * После ошибки getter разрешён повторный пересчёт даже без новой записи источника.
+   */
+  refreshComputedValue(e, t, i = null) {
+    try {
+      if (t & (f | D | y | _))
+        return this.recomputeValue(e, i), e.cachedValue;
+      const s = e.firstDep;
+      return s !== null && this.walkDependencyChain(e, s) ? this.recomputeValue(e, i) : e.flags &= ~b, e.cachedValue;
+    } catch (s) {
+      throw this.activeSub !== null && this.trackDependency(e, this.activeSub), s;
+    }
+  }
+  /**
+   * Фиксирует pending-значение и уведомляет непосредственных потребителей.
+   * Пропускает указанную связь и автора записи, чтобы не дублировать текущую работу.
+   * @returns Изменилось ли зафиксированное значение.
+   */
+  commitSignalValue(e, t) {
+    const i = e.cachedValue;
+    e.cachedValue = e.pendingValue, e.flags &= ~f;
+    const s = e.pendingAuthor;
+    return e.pendingAuthor = void 0, i === e.cachedValue ? !1 : (e.firstSub !== null && this.confirmSubUpdates(e.firstSub, t, s ?? null), !0);
+  }
+  /**
+   * Обрабатывает чтение производителя активным потребителем.
+   * Сначала проверяет текущую и следующую связи; более дорогой поиск вынесен отдельно.
+   */
+  trackDependency(e, t) {
+    const i = t.tailDep;
+    if (i !== null) {
+      const l = i.nextDep;
+      return l !== null && l.dep === e ? (t.tailDep = l, l) : i.dep === e ? i : this.reconcileDependency(e, t, i, l);
+    }
+    const s = t.firstDep;
+    return s === null ? t.tailDep = this.insertDependency(e, t, null) : s.dep === e ? (t.tailDep = s, s) : this.reconcileDependency(e, t, null, s);
+  }
+  /**
+   * Согласует чтение с существующим списком зависимостей при несовпадении порядка.
+   * Использует ограниченный линейный поиск, затем поиск среди потребителей производителя.
+   * Существующую связь перемещает или переиспользует; новую создаёт только при необходимости.
+   */
+  reconcileDependency(e, t, i, s) {
+    if (t.flags & L) {
+      const a = e.subSearchCursor;
+      if (a !== void 0 && a.sub === t && a.dep === e)
+        return this.reorderDependency(t, a, i), t.tailDep = a, a;
+    }
+    let l = 0, r = s;
+    for (; r !== null && l < U; ) {
+      const a = r;
+      if (a.dep === e)
+        return this.reorderDependency(t, a, i), t.tailDep = a, a;
+      r = a.nextDep, ++l;
+    }
+    let n = i;
+    for (; n !== null && l < U; ) {
+      const a = n;
+      if (a.dep === e)
+        return a;
+      n = a.prevDep, ++l;
+    }
+    if (r !== null && !(t.flags & L)) {
+      t.flags |= L;
+      for (let c = s; c !== null; c = c.nextDep)
+        c.dep.subSearchCursor = c;
+      const a = e.subSearchCursor;
+      if (a !== void 0 && a.sub === t && a.dep === e)
+        return this.reorderDependency(t, a, i), t.tailDep = a, a;
+    }
+    if (r !== null || n !== null) {
+      const a = q(e, t);
+      if (a !== void 0)
+        return this.reorderDependency(t, a, i), t.tailDep = a, a;
+    }
+    return s !== null ? (t.tailDep = this.reuseDepLink(s, e), s) : t.tailDep = this.insertDependency(e, t, i);
+  }
+  /**
+   * Добавляет связь при первоначальном сборе зависимостей.
+   * Предусловие: after является хвостом собранного префикса нового списка.
+   * Связь одновременно включается в список потребителей производителя.
+   */
+  appendInitialDependency(e, t) {
+    const i = t.tailDep, s = e.lastSub, l = {
+      dep: e,
+      sub: t,
+      prevSub: s,
+      nextSub: null,
+      prevDep: i,
+      nextDep: null
+    };
+    return s === null ? e.firstSub = l : s.nextSub = l, e.lastSub = l, i === null ? t.firstDep = l : i.nextDep = l, t.tailDep = l, e.flags & h && this.attachDependencyCleanup(l), l;
+  }
+  /**
+   * Вставляет связь после заданного курсора зависимостей потребителя.
+   * Сохраняет ещё не прочитанный хвост списка и увеличивает dependencyCount.
+   */
+  insertDependency(e, t, i) {
+    const s = e.lastSub, l = {
+      dep: e,
+      sub: t,
+      prevSub: s,
+      nextSub: null,
+      prevDep: i,
+      nextDep: null
+    };
+    s === null ? e.firstSub = l : s.nextSub = l, e.lastSub = l;
+    const r = i === null ? t.firstDep : i.nextDep;
+    return l.nextDep = r, r !== null && (r.prevDep = l), i === null ? t.firstDep = l : i.nextDep = l, e.flags & h && this.attachDependencyCleanup(l), l;
+  }
+  /**
+   * Переназначает существующую связь другому производителю.
+   * Положение в списке зависимостей потребителя и число его связей сохраняются.
+   */
+  reuseDepLink(e, t) {
+    this.detachSubLink(e);
+    const i = t.lastSub;
+    return e.dep = t, e.prevSub = i, e.nextSub = null, i === null ? t.firstSub = e : i.nextSub = e, t.lastSub = e, t.flags & h && this.attachDependencyCleanup(e), e;
+  }
+  /**
+   * Перемещает существующую зависимость после курсора текущего чтения.
+   * Список потребителей производителя и количество зависимостей не изменяет.
+   */
+  reorderDependency(e, t, i) {
+    if (t.prevDep === i)
+      return;
+    const s = t.prevDep, l = t.nextDep;
+    s === null ? e.firstDep = l : s.nextDep = l, l !== null && (l.prevDep = s);
+    const r = i === null ? e.firstDep : i.nextDep;
+    t.prevDep = i, t.nextDep = r, r !== null && (r.prevDep = t), i === null ? e.firstDep = t : i.nextDep = t;
+  }
+  /**
+   * Удаляет непрочитанный хвост зависимостей завершившегося запуска.
+   * trackedTail обозначает границу прочитанного префикса, а не неизменный конец списка.
+   * Ошибка cleanup не прерывает освобождение оставшегося хвоста зависимостей.
+   */
+  pruneUnreadDependencies(e) {
+    const t = e.tailDep;
+    let i = t === null ? e.firstDep : t.nextDep;
+    if (i === null)
+      return;
+    t === null ? e.firstDep = null : t.nextDep = null;
+    for (let l = i; l !== null; l = l.nextDep)
+      l.prevDep = null;
+    let s;
+    for (; i !== null; ) {
+      const l = i.nextDep;
+      try {
+        this.detachSubLink(i, !0);
+      } catch (r) {
+        this.unlinkSubLink(i, !0), s ??= [], s.push(r);
+      }
+      i = l;
+    }
+    s !== void 0 && m(s, "Dependency cleanup failed.");
+  }
+  /**
+   * Удаляет связь только из списка потребителей производителя.
+   * Список зависимостей потребителя и его счётчик здесь не изменяются.
+   * Также исправляет курсор поиска, если он указывал на удаляемую связь.
+   */
+  detachSubLink(e, t = !1) {
+    let i;
+    e.dep.flags & (h | N) && (i = this.cleanupSourceDependency(e)), this.unlinkSubLink(e, t || i !== void 0);
+  }
+  /** Optional source cleanup stays outside the ordinary signal detach path. */
+  cleanupSourceDependency(e) {
+    const t = e.dep;
+    if (t.flags & h) {
+      const i = e.dependencyCleanup;
+      return e.dependencyCleanup = void 0, i?.(), i;
+    }
+    t.firstSub === e && t.lastSub === e && t.onUnobserved();
+  }
+  /** Завершает удаление producer-связи без вызова source cleanup. */
+  unlinkSubLink(e, t) {
+    t && ((e.prevSub === null ? e.dep.firstSub !== e : e.prevSub.nextSub !== e) || (e.nextSub === null ? e.dep.lastSub !== e : e.nextSub.prevSub !== e)) || (e.dep.subSearchCursor === e && (e.dep.subSearchCursor = e.nextSub ?? (e.dep.firstSub === e ? void 0 : e.dep.firstSub ?? void 0)), e.prevSub === null ? e.dep.firstSub = e.nextSub : e.prevSub.nextSub = e.nextSub, e.nextSub === null ? e.dep.lastSub = e.prevSub : e.nextSub.prevSub = e.prevSub);
+  }
+  /** Connects Runtime ownership metadata only for edges whose producer opted in. */
+  attachDependencyCleanup(e) {
+    const i = e.dep.sourceHooks?.onDependency;
+    if (i === void 0)
+      return;
+    const s = e.sub.sourceHooks?.dependencyOwner ?? e.sub.effectTask?.dependencyOwner;
+    s !== void 0 && (e.dependencyCleanup = i(s));
+  }
+  /**
+   * Отсоединяет owned-источник сразу с обеих сторон каждой связи.
+   * Вызывается на границе lifetime, а не при обычных чтениях и записях.
+   * Переводит ожидавших проверку потребителей к повторному вычислению при необходимости.
+   */
+  releaseSourceSubs(e) {
+    if (!(e.flags & (h | N))) {
+      let s = e.firstSub;
+      for (; s != null; ) {
+        const l = s.nextSub, r = s.sub;
+        this.detachDependencyLink(s), this.detachSubLink(s);
+        const n = r.flags;
+        (n & (b | p)) === S && (r.flags = n & ~S | f, n & o && this.enqueueEffect(r, e)), s = l;
+      }
+      e.firstSub = e.lastSub = null, e.subSearchCursor = void 0;
+      return;
+    }
+    let t = e.firstSub, i;
+    for (; t != null; ) {
+      const s = t.nextSub;
+      this.detachDependencyLink(t);
+      try {
+        this.detachSubLink(t, !0);
+      } catch (l) {
+        this.unlinkSubLink(t, !0), i ??= [], i.push(l);
+      }
+      t = s;
+    }
+    e.firstSub = e.lastSub = null, e.subSearchCursor = void 0, i !== void 0 && m(i, "Source dependency cleanup failed.");
+  }
+  /**
+   * Удаляет связь только из списка зависимостей потребителя.
+   * Исправляет курсор прочитанного префикса и dependencyCount; список производителя
+   * должен быть обновлён отдельной операцией.
+   */
+  detachDependencyLink(e) {
+    const t = e.sub, i = e.prevDep, s = e.nextDep;
+    (i === null ? t.firstDep !== e : i.nextDep !== e) || (i === null ? t.firstDep = s : i.nextDep = s, s !== null && (s.prevDep = i), t.tailDep === e && (t.tailDep = i));
+  }
+  /**
+   * Добавляет эффект во внутреннюю очередь один раз до обработки текущей записи.
+   * Флаг SCHEDULED предотвращает повторное добавление без создания task-объекта.
+   */
+  enqueueEffect(e, t) {
+    const i = t !== void 0 && t.flags & h ? t.sourceHooks.token : void 0;
+    i !== void 0 && e.effectTask?.notify?.(i), !(e.flags & d) && (e.flags |= d, this.effectWriteIndex === 0 ? this.firstEffect = e : this.effectQueue[this.effectWriteIndex] = e, ++this.effectWriteIndex);
+  }
+  /**
+   * Распространяет invalidation от непосредственных к транзитивным потребителям.
+   * Сохраняет исходный итеративный обход с переиспользуемым стеком; callbacks
+   * не выполняет. Непосредственное и потенциальное изменения отмечает разными флагами.
+   */
+  propagateInvalidation(e, t = !1) {
+    this.checkingDepth !== 0 && this.markActiveChecks(e);
+    const i = this.invalidationDepth;
+    let s = i;
+    for (let l = e; l !== null; l = l.nextSub) {
+      const r = l.sub, n = r.flags;
+      let a = 0;
+      if (n & (b | p) ? n & p ? a = this.invalidateReadDependency(l, r, n) : !t && !(n & f) && (r.flags = n & ~S | f) : (a = n & ~D | (t ? S : f), r.flags = a), a === 0) {
+        if (n & o && n & d) {
+          const c = l.dep.flags & h ? l.dep.sourceHooks.token : void 0;
+          c !== void 0 && r.effectTask?.notify?.(c);
+        } else r.flags & (h | C) && (r.flags & h && r.sourceHooks.onInvalidate?.(r.firstSub !== null), r.flags &= ~C, r.firstSub !== null && (this.invalidationStack[s++] = r.firstSub));
+        continue;
+      }
+      a & o ? (!(a & p) || r.effectTask?.allowScheduleDuringRun === !0) && this.enqueueEffect(r, l.dep) : (!(n & b) && r.flags & h && r.sourceHooks.onInvalidate?.(r.firstSub !== null), r.firstSub !== null && (this.invalidationStack[s++] = r.firstSub));
+    }
+    for (; s !== i; ) {
+      let l = this.invalidationStack[--s];
+      do {
+        const r = l.sub, n = r.flags;
+        let a = 0;
+        if (n & (b | p) ? n & p && (a = this.invalidateReadDependency(l, r, n)) : (a = n & ~D | S, r.flags = a), a === 0) {
+          if (n & o && n & d) {
+            const c = l.dep.flags & h ? l.dep.sourceHooks.token : void 0;
+            c !== void 0 && r.effectTask?.notify?.(c);
+          } else if (r.flags & (h | C) && (r.flags & h && r.sourceHooks.onInvalidate?.(r.firstSub !== null), r.flags &= ~C, r.firstSub !== null)) {
+            l.nextSub !== null && (this.invalidationStack[s++] = l.nextSub), l = r.firstSub;
+            continue;
+          }
+        } else if (a & o)
+          this.enqueueEffect(r, l.dep);
+        else if (!(n & b) && r.flags & h && r.sourceHooks.onInvalidate?.(r.firstSub !== null), r.firstSub !== null) {
+          l.nextSub !== null && (this.invalidationStack[s++] = l.nextSub), l = r.firstSub;
+          continue;
+        }
+        l = l.nextSub;
+      } while (l !== null);
+    }
+    this.invalidationDepth = i;
+  }
+  // Дополнительный обход не вызывает callbacks и проходит уже dirty computed:
+  // флаги обычной invalidation не показывают, какую связь check уже прошёл.
+  // Запись во время проверки редка, поэтому множество проверяемых узлов строится
+  // только здесь: корни проверок и обе стороны каждой связи опубликованного
+  // префикса dependencyStack. Пользовательский код выполняется внутри проверки
+  // только после публикации dependencyDepth, поэтому префикс актуален.
+  markActiveChecks(e) {
+    const t = /* @__PURE__ */ new Set();
+    for (let l = 0; l < this.checkingDepth; l++)
+      t.add(this.checkRoots[l]);
+    for (let l = 0; l < this.dependencyDepth; l++) {
+      const r = this.dependencyStack[l];
+      t.add(r.sub), t.add(r.dep);
+    }
+    const i = [e], s = /* @__PURE__ */ new Set();
+    for (; i.length !== 0; )
+      for (let l = i.pop(); l !== null; l = l.nextSub) {
+        const r = l.sub;
+        s.has(r) || (s.add(r), t.has(r) && (r.flags |= g), !(r.flags & o) && r.firstSub !== null && i.push(r.firstSub));
+      }
+  }
+  /**
+   * Помечает работающего потребителя, только если затронута уже прочитанная связь.
+   * Связи за trackedTail принадлежат прошлому запуску и не означают повторную invalidation.
+   * @returns Новое состояние либо ноль, если уведомление не требуется.
+   */
+  invalidateReadDependency(e, t, i) {
+    const s = t.tailDep;
+    if (s === null)
+      return 0;
+    if (e !== s) {
+      for (let r = e.prevDep; r !== null; r = r.prevDep)
+        if (r === s)
+          return 0;
+    }
+    let l = i | D | S;
+    return t === this.activeSub && !(i & o) && t.firstDep === e && e.nextDep === null ? l = (l | k) & ~x : l &= -49153, t.flags = l, l;
+  }
+  /**
+   * Подтверждает необходимость пересчёта непосредственных потребителей.
+   * Применяется после фиксации реально изменившегося значения; позволяет исключить
+   * текущую связь и автора записи.
+   */
+  confirmSubUpdates(e, t, i = null) {
+    for (let s = e; s !== null; s = s.nextSub) {
+      if (s === t || s.sub === i)
+        continue;
+      const l = s.sub, r = l.flags;
+      r & f || (l.flags = r & ~S | f, r & o ? this.enqueueEffect(l, s.dep) : r & b || l.flags & h && l.sourceHooks.onInvalidate?.(l.firstSub !== null));
+    }
+  }
+  /**
+   * Повторно вычисляет узел, согласует зависимости и сравнивает результат с кешем.
+   * При ошибке восстанавливает контекст, удаляет непрочитанный хвост и оставляет
+   * повторяемое состояние ошибки. Также восстанавливает непосредственного потребителя
+   * skipSub: при разворачивании стека его связь могла быть уже извлечена из буфера.
+   * Неверное значение в кеш не записывается.
+   */
+  recomputeValue(e, t = null) {
+    const i = e.cachedValue, s = e.evaluate;
+    e.tailDep = null;
+    const l = e.flags & -119813 | p;
+    e.flags = l;
+    const r = this.activeSub;
+    this.activeSub = e;
+    let n;
+    try {
+      n = s();
+    } catch (c) {
+      this.failComputedRun(e, s, t, c, r);
+    }
+    this.activeSub = r;
+    const a = e.tailDep;
+    return e.evaluate !== s || (a === null ? e.firstDep : a.nextDep) !== null || e.flags & (D | k | x) ? this.settleComputedValue(e, t, i, s, l, n) : (e.flags = l & -8460, e.cachedValue = n, i === n ? !1 : (e.firstSub !== null && this.confirmSubUpdates(e.firstSub, t), !0));
+  }
+  /**
+   * Медленный путь пересчёта: удаление непрочитанного хвоста, освобождение owner
+   * во время getter или cleanup, повторная invalidation и самозапись единственной
+   * зависимости. Первое вычисление уже выполнено recomputeValue(); повторные
+   * выполняются здесь до предела MAX_NODE_REPEATS вычислений.
+   */
+  settleComputedValue(e, t, i, s, l, r) {
+    for (let n = 1; ; n++) {
+      if (e.evaluate !== s)
+        return e.cachedValue = void 0, e.flags = 0, !1;
+      const a = e.tailDep;
+      if ((a === null ? e.firstDep : a.nextDep) !== null)
+        try {
+          this.pruneUnreadDependencies(e);
+        } catch (u) {
+          this.failComputedValue(e, t, u);
+        }
+      if (e.evaluate !== s)
+        return e.cachedValue = void 0, e.flags = 0, !1;
+      const c = e.flags & D, I = e.firstDep !== null && e.firstDep.nextDep === null && (e.flags & (k | x)) === (k | x);
+      if (e.flags = l & -8460, c && !I) {
+        if (e.flags |= f, n === T)
+          return this.failComputedValue(e, t, new Error(`Computed settlement exceeded ${T} attempts.`));
+        s = e.evaluate, e.tailDep = null, l = e.flags & -119813 | p, e.flags = l;
+        const u = this.activeSub;
+        this.activeSub = e;
+        try {
+          r = s();
+        } catch (v) {
+          this.failComputedRun(e, s, t, v, u);
+        }
+        this.activeSub = u;
+        continue;
+      }
+      return I && (e.flags |= _), e.cachedValue = r, i === r ? !1 : (e.firstSub !== null && this.confirmSubUpdates(e.firstSub, t), !0);
+    }
+  }
+  /**
+   * Обрабатывает исключение getter до восстановления активного потребителя,
+   * как прежний catch внутри try/finally, и всегда восстанавливает контекст.
+   */
+  failComputedRun(e, t, i, s, l) {
+    try {
+      if (e.evaluate !== t)
+        throw e.cachedValue = void 0, e.flags = 0, s;
+      this.failComputedValue(e, i, s);
+    } finally {
+      this.activeSub = l;
+    }
+  }
+  /** Сохраняет первичную ошибку и отдельные ошибки cleanup при восстановлении. */
+  failComputedValue(e, t, i) {
+    try {
+      this.restoreComputedFailure(e, t);
+    } catch (s) {
+      throw new AggregateError([i, s], "Computed evaluation and dependency cleanup failed.");
+    }
+    throw i;
+  }
+  /**
+   * Восстанавливает связи и состояния после неудачного getter.
+   * Отдельная функция удерживает обработку исключений вне обычной части пересчёта.
+   * Потребитель исключаемой связи мог уже покинуть активный префикс стека.
+   */
+  restoreComputedFailure(e, t) {
+    e.evaluate !== void 0 && (e.flags = e.flags & -118928 | y);
+    try {
+      e.evaluate !== void 0 && this.pruneUnreadDependencies(e);
+    } finally {
+      e.evaluate === void 0 && (e.cachedValue = void 0, e.flags = 0), t !== null && this.restoreFailedDependency(t.sub);
+    }
+  }
+  /** Settles every direct dependency so a cancelled external delivery can be re-armed. */
+  settleCancelledDependencies(e) {
+    for (let t = e.firstDep; t !== null; t = t.nextDep) {
+      const i = t.dep, s = i.flags;
+      s & (E | b | y) && (i.evaluate === void 0 ? s & f && this.commitSignalValue(i, t) : this.refreshComputedValue(i, s, t));
+    }
+  }
+  /**
+   * Итеративно проверяет зависимые computed и pending-сигналы перед запуском потребителя.
+   * Использует общий стек с сохранением активного префикса вложенного обхода и
+   * перед пользовательским вычислением публикует его высоту. Единственный
+   * обработчик ошибок проверки находится здесь: при исключении он восстанавливает
+   * высоту стека, состояния всех незавершённых узлов прохода и корень проверки,
+   * включая снятие SCHEDULED у эффекта. Порядок успешного обхода не меняется
+   * (серия Raph Top-1, 2026-10-20: прежние три вложенных обработчика объединены).
+   */
+  walkDependencyChain(e, t) {
+    const i = e, s = this.dependencyDepth;
+    let l = s, r = !1, n;
+    e.flags & g && (e.flags &= ~g), this.checkRoots[this.checkingDepth++] = e;
+    try {
+      e: for (; ; ) {
+        if (e.flags & g) {
+          n ??= /* @__PURE__ */ new Map();
+          const a = (n.get(e) ?? 0) + 1;
+          if (n.set(e, a), a > T)
+            throw new Error(`Dependency check exceeded ${T} restarts.`);
+          e.flags &= ~g, e.firstDep !== null && (t = e.firstDep);
+        }
+        if (e.flags & f)
+          r = !0;
+        else {
+          const a = t.dep, c = a.flags;
+          if (c & (f | y))
+            this.dependencyDepth = l, r = a.evaluate === void 0 ? this.commitSignalValue(a, t) : this.recomputeValue(a, t);
+          else if (c & S) {
+            if (a.firstDep !== null) {
+              this.dependencyStack[l++] = t, e = a, t = a.firstDep;
+              continue e;
+            }
+            this.dependencyDepth = l, r = this.recomputeValue(a, t);
+          } else
+            r = !1;
+        }
+        if (!r && t.nextDep !== null) {
+          t = t.nextDep;
+          continue;
+        }
+        if (r) {
+          for (; l !== s; ) {
+            this.dependencyDepth = --l;
+            const a = this.dependencyStack[l];
+            if (r = this.recomputeValue(e, a), e = a.sub, !r) {
+              if (a.nextDep !== null) {
+                t = a.nextDep;
+                continue e;
+              }
+              break;
+            }
+          }
+          if (r)
+            return this.dependencyDepth = s, e.flags & g && (e.flags &= ~g), this.checkRoots[--this.checkingDepth] = null, !0;
+        }
+        for (; l !== s; ) {
+          if (e.flags & (f | g))
+            continue e;
+          this.dependencyDepth = --l;
+          const a = this.dependencyStack[l];
+          if (e.flags &= ~(S | W), e = a.sub, a.nextDep !== null) {
+            t = a.nextDep;
+            continue e;
+          }
+        }
+        if (e.flags & (f | g))
+          continue e;
+        return e.flags &= ~(S | W), this.dependencyDepth = s, this.checkRoots[--this.checkingDepth] = null, !1;
+      }
+    } catch (a) {
+      e.flags & g && (e.flags &= ~g);
+      for (let c = s; c < l; c++)
+        this.dependencyStack[c].sub.flags &= ~W;
+      this.checkRoots[--this.checkingDepth] = null, this.markRecoveryDependencies(i), this.restoreFailedDependency(i);
+      for (let c = s; c < this.dependencyDepth; c++)
+        this.restoreFailedDependency(this.dependencyStack[c].sub);
+      throw this.dependencyDepth = s, this.dependencyStack.length = s, i.flags & o && (i.flags &= ~d), a;
+    }
+  }
+  /**
+   * Восстанавливает незавершённую запись после прерванной проверки зависимостей.
+   * Computed получает повторяемое состояние ошибки, effect остаётся доступным
+   * для следующей invalidation. Вызывается только на ошибочном пути.
+   */
+  restoreFailedDependency(e) {
+    if (e.evaluate === void 0) {
+      e.cachedValue = void 0, e.flags = 0;
+      return;
+    }
+    e.flags &= -118800, e.flags & o || (e.flags |= y);
+  }
+  /**
+   * Проверяет необходимость запуска, очищает прошлые ресурсы и выполняет тело эффекта.
+   * Ошибка cleanup останавливает эффект до создания ресурсов следующего запуска.
+   * При ошибке тела сохраняет фактически прочитанные зависимости, останавливает
+   * созданных детей и разрешает повторный запуск после следующей записи.
+   * Cleanup, возвращённый после собственного stop, освобождается сразу.
+   */
+  executeEffect(e) {
+    const t = e.flags;
+    if (!(t & b) || !(t & (f | D)) && !this.refreshEffectBeforeRun(e))
+      return;
+    const i = e.evaluate;
+    if (i === void 0) {
+      e.flags &= ~b;
+      return;
+    }
+    if ((e.scopeLastChild !== void 0 || typeof e.cachedValue == "function") && this.cleanupEffectBeforeRun(e), e.evaluate === void 0)
+      return;
+    e.tailDep = null, e.flags = e.flags & -1029 | p;
+    const s = this.activeSub;
+    this.activeSub = e;
+    let l;
+    try {
+      l = i();
+    } catch (n) {
+      this.activeSub = s, e.flags &= ~p, this.failEffectRun(e, n, void 0);
+    } finally {
+      this.activeSub = s, e.flags &= ~p;
+    }
+    const r = e.tailDep;
+    (r === null ? e.firstDep : r.nextDep) !== null && this.pruneUnreadDependencies(e), typeof l == "function" && (e.evaluate === void 0 ? this.untracked(l) : e.cachedValue = l), e.flags & d ? e.flags = e.flags & -1031 | S : e.flags &= -1032;
+  }
+  /**
+   * Проверяет pending computed только при отсутствии прямой invalidation.
+   * Восстановление эффекта после ошибки проверки выполняет walkDependencyChain().
+   */
+  refreshEffectBeforeRun(e) {
+    const t = e.firstDep;
+    return t === null || !this.walkDependencyChain(e, t) ? (e.flags &= ~b, !1) : !0;
+  }
+  /** Освобождает ресурсы предыдущего запуска; обычный effect без cleanup сюда не входит. */
+  cleanupEffectBeforeRun(e) {
+    let t;
+    if (e.scopeLastChild !== void 0)
+      try {
+        this.disposeNestedEffects(e);
+      } catch (s) {
+        t = [s];
+      }
+    const i = typeof e.cachedValue == "function" ? e.cachedValue : void 0;
+    if (e.cachedValue = void 0, e.flags &= ~D, i !== void 0)
+      try {
+        this.untracked(i);
+      } catch (s) {
+        t ??= [], t.push(s);
+      }
+    if (t !== void 0) {
+      try {
+        this.disposeEffect(e);
+      } catch (s) {
+        t.push(s);
+      }
+      m(t, "Effect cleanup failed.");
+    }
+  }
+  /**
+   * Завершает неудачный запуск эффекта, не затрагивая успешный путь исполнения.
+   * Сохраняет прочитанные зависимости для следующей invalidation, освобождает
+   * детей неудачного запуска и объединяет ошибки с предыдущими ошибками cleanup.
+   */
+  failEffectRun(e, t, i) {
+    const s = i ?? [];
+    s.push(t), this.pruneUnreadDependencies(e);
+    try {
+      this.disposeNestedEffects(e);
+    } catch (l) {
+      s.push(l);
+    }
+    throw e.flags &= -72, s.length === 1 ? s[0] : new AggregateError(s, "Effect execution failed.");
+  }
+  /**
+   * Обрабатывает синхронную очередь до исчерпания, включая добавленную во время прохода работу.
+   * Ошибки отдельных эффектов не блокируют соседей и передаются после обработки.
+   * Путь не проверяет наличие внешней задачи у каждого узла.
+   */
+  flushSyncEffects() {
+    if (!(this.flushingEffects || this.activeSub !== null && (this.activeSub.flags & (o | p)) === (o | p))) {
+      this.flushingEffects = !0;
+      try {
+        for (; this.effectReadIndex !== this.effectWriteIndex; ) {
+          const e = this.effectReadIndex, t = e === 0 ? this.firstEffect : this.effectQueue[e];
+          e === 0 ? this.firstEffect = void 0 : this.effectQueue[e] = void 0, ++this.effectReadIndex, t.flags &= ~d, this.executeEffect(t);
+        }
+      } catch (e) {
+        this.drainQueueAfterError(e, !1);
+      } finally {
+        this.effectReadIndex = 0, this.effectWriteIndex = 0, this.flushingEffects = !1;
+      }
+    }
+  }
+  /**
+   * Обрабатывает очередь экземпляра с внешней политикой выполнения.
+   * Обычные внутренние эффекты выполняет сразу, остальные передаёт постоянной задаче.
+   * Ошибка одного элемента не оставляет необработанные записи со старым SCHEDULED.
+   */
+  flushExternalEffects() {
+    if (!(this.flushingEffects || this.activeSub !== null && (this.activeSub.flags & (o | p)) === (o | p))) {
+      this.flushingEffects = !0;
+      try {
+        for (; this.effectReadIndex !== this.effectWriteIndex; ) {
+          const e = this.effectReadIndex, t = e === 0 ? this.firstEffect : this.effectQueue[e];
+          e === 0 ? this.firstEffect = void 0 : this.effectQueue[e] = void 0, ++this.effectReadIndex;
+          const i = t.effectTask;
+          i === void 0 ? (t.flags &= ~d, this.executeEffect(t)) : t.evaluate !== void 0 ? this.scheduleEffectTask(t, i) : t.flags &= ~d;
+        }
+      } catch (e) {
+        this.drainQueueAfterError(e, !0);
+      } finally {
+        this.effectReadIndex = 0, this.effectWriteIndex = 0, this.flushingEffects = !1;
+      }
+    }
+  }
+  // Только ошибочный путь; новые fields/ссылки в graph records не добавляются.
+  markRecoveryDependencies(e) {
+    const t = [e], i = /* @__PURE__ */ new Set();
+    for (; t.length !== 0; ) {
+      const s = t.pop();
+      if (!i.has(s)) {
+        i.add(s);
+        for (let l = s.firstDep; l !== null; l = l.nextDep) {
+          const r = l.dep;
+          r.evaluate !== void 0 && !(r.flags & o) && (r.flags |= C, t.push(r));
+        }
+      }
+    }
+  }
+  /**
+   * Завершает очередь после первой ошибки, собирая последующие причины сбоя.
+   * Вызывается только на ошибочном пути; успешный проход не создаёт массив ошибок
+   * и не устанавливает отдельный catch для каждого элемента.
+   */
+  drainQueueAfterError(e, t) {
+    const i = [e];
+    for (; this.effectReadIndex !== this.effectWriteIndex; ) {
+      const s = this.effectReadIndex++, l = s === 0 ? this.firstEffect : this.effectQueue[s];
+      s === 0 ? this.firstEffect = void 0 : this.effectQueue[s] = void 0;
+      try {
+        const r = t ? l.effectTask : void 0;
+        r !== void 0 && l.evaluate !== void 0 ? this.scheduleEffectTask(l, r) : (l.flags &= ~d, this.executeEffect(l));
+      } catch (r) {
+        i.push(r);
+      }
+    }
+    throw i.length === 1 ? e : new AggregateError(i, "Effect queue processing failed.");
+  }
+  /**
+   * Передаёт эффект его постоянной внешней задаче.
+   * Если schedule() бросает исключение, снимает незавершённую invalidation,
+   * чтобы последующая запись могла снова запросить выполнение.
+   */
+  requestEffectTask(e) {
+    const t = e.effectTask;
+    t === void 0 || e.evaluate === void 0 || (e.flags |= d, this.scheduleEffectTask(e, t));
+  }
+  // Передаёт уже запланированный эффект его постоянной внешней задаче.
+  scheduleEffectTask(e, t) {
+    try {
+      t.schedule();
+    } catch (i) {
+      this.failEffectSchedule(e, i);
+    }
+  }
+  /** Восстанавливает источники после сбоя scheduler, сохраняя исходную ошибку. */
+  failEffectSchedule(e, t) {
+    try {
+      e.flags & d && this.settleCancelledDependencies(e);
+    } catch (i) {
+      throw new AggregateError([t, i], "Effect scheduling and dependency settlement failed.");
+    } finally {
+      e.flags &= -72;
+    }
+    throw t;
+  }
+  /**
+   * Окончательно останавливает эффект и освобождает все принадлежащие ему ресурсы.
+   * Сначала делает узел неактивным и отсоединяет связи, затем отменяет задачу,
+   * останавливает детей, выполняет cleanup и onStop. Каждая стадия завершается
+   * несмотря на ошибки соседних стадий; повторный или вложенный stop безопасен.
+   */
+  disposeEffect(e) {
+    if (e.evaluate === void 0)
+      return;
+    this.activeSub === e && (this.activeSub = null);
+    const t = e.effectTask, i = e.onStop, s = typeof e.cachedValue == "function" ? e.cachedValue : void 0;
+    e.evaluate = void 0, e.flags = 0, e.cachedValue = void 0, e.effectTask = void 0, i !== void 0 && (e.onStop = void 0), H(e);
+    let l;
+    e.tailDep = null;
+    try {
+      this.pruneUnreadDependencies(e);
+    } catch (r) {
+      l = [r];
+    }
+    if (e.firstDep = e.tailDep = null, t !== void 0)
+      try {
+        t.dispose();
+      } catch (r) {
+        l ??= [], l.push(r);
+      }
+    try {
+      this.disposeNestedEffects(e);
+    } catch (r) {
+      l ??= [], l.push(r);
+    }
+    if (s !== void 0)
+      try {
+        this.untracked(s);
+      } catch (r) {
+        l ??= [], l.push(r);
+      }
+    if (i !== void 0)
+      try {
+        this.untracked(i);
+      } catch (r) {
+        l ??= [], l.push(r);
+      }
+    this.invalidationStack.length !== this.invalidationDepth && (this.invalidationStack.length = this.invalidationDepth), this.dependencyStack.length !== this.dependencyDepth && (this.dependencyStack.length = this.dependencyDepth), l !== void 0 && m(l, "Effect disposal failed.");
+  }
+  /**
+   * Останавливает все вложенные эффекты в обратном порядке регистрации.
+   * Всегда берёт актуальный хвост: cleanup может удалить другого ребёнка.
+   * Передаёт собранные ошибки только после освобождения всех детей.
+   */
+  disposeNestedEffects(e) {
+    let t;
+    for (; e.scopeLastChild !== void 0; )
+      try {
+        this.disposeEffect(e.scopeLastChild);
+      } catch (i) {
+        t ??= [], t.push(i);
+      }
+    t !== void 0 && m(t, "Nested effect disposal failed.");
+  }
+  /**
+   * Связывает два разных receiver: движок-владелец и читаемый handle.
+   * Общие функции адаптируют this; алгоритмы чтения остаются методами
+   * ReactivityEngine. Адаптеры создаются один раз на граф, а не на каждое вычисление.
+   */
+  createHandleReaders() {
+    const e = this;
+    return {
+      /**
+       * Общий reader computed: get() объектного и read() raw handle.
+       * Handle сам является записью графа, поэтому reader требует receiver;
+       * извлечённый без receiver метод не поддерживается (серия Raph Top-1, 2026-10-20).
+       */
+      read() {
+        return e.readComputedValue(this);
+      },
+      /**
+       * Передаёт handle как аргумент; this самого движка берётся из замыкания.
+       */
+      peek() {
+        return e.peekHandle(this);
+      }
+    };
+  }
+  /**
+   * Читает handle без подписки текущего потребителя, сохраняя receiver get().
+   * Прежний контекст восстанавливается и после исключения getter.
+   */
+  peekHandle(e) {
+    const t = this.activeSub;
+    if (t === null)
+      return e.get();
+    this.activeSub = null;
+    try {
+      return e.get();
+    } finally {
+      this.activeSub = t;
+    }
+  }
+  // ---------------------------------------------
+  // INTERNAL
+  // ---------------------------------------------
+  /**
+   * Создаёт единый низкоуровневый read/write accessor для core-дорожки Bench Lab.
+   * Публичный объектный API остаётся отдельным и измеряется в API-tax.
+   * @internal
+   */
+  _signalAccess(e) {
+    const t = this;
+    let i = e, s;
+    function l(r) {
+      if (arguments.length !== 0) {
+        const c = s;
+        c !== void 0 ? t.writeSignalValue(c, r) : i !== r && (i = r);
+        return;
+      }
+      const n = s;
+      if (n !== void 0)
+        return t.readSignalValue(n);
+      const a = t.activeSub;
+      return a === null || (s = t.materializeSignal(i, a)), i;
+    }
+    return {
+      read: l,
+      write: l
+    };
+  }
+  /**
+   * Создаёт computed для низкоуровневого read API сразу записью графа единой формы.
+   * read — общий reader графа с receiver; первое чтение вычисляет значение по
+   * флагу UNINITIALIZED (серия Raph Top-1, 2026-10-20).
+   * @internal
+   */
+  _computedAccess(e) {
+    return this.allocateGraphRecord(
+      void 0,
+      e,
+      E,
+      this.handleReaders.read
+    );
+  }
+  /**
+   * Создаёт signal, жизненным циклом которого управляет `ScopeNode`.
+   *
+   * Реактивная логика совпадает с обычным `signal()`, но disposer
+   * дополнительно отсоединяет материализованный источник от графа.
+   *
+   * @internal
+   */
+  _ownedSignal(e, t) {
+    const i = this;
+    let s = e, l, r = !1;
+    const n = () => {
+      const u = l;
+      if (u !== void 0)
+        return this.readSignalValue(u);
+      const v = this.activeSub;
+      if (v === null)
+        return s;
+      const V = s;
+      return l = this.materializeSignal(
+        V,
+        v,
+        t
+      ), s = void 0, V;
+    }, a = t === void 0 ? (u) => {
+      const v = l;
+      v !== void 0 ? this.writeSignalValue(v, u) : s !== u && (s = u);
+    } : (u) => {
+      const v = l;
+      if (v !== void 0) {
+        const V = v.flags & f ? v.pendingValue : v.cachedValue;
+        V !== u && t.onChange?.(V, u, v.firstSub !== null), this.writeSignalValue(v, u);
+        return;
+      }
+      s !== u && (t.onChange?.(s, u, !1), s = u);
+    }, I = {
+      source: {
+        get: n,
+        peek: this.handleReaders.peek,
+        set: a
+      },
+      /**
+       * Освобождает источник и отсоединяет его от реактивного графа.
+       */
+      dispose() {
+        if (r)
+          return !0;
+        r = !0, s = void 0;
+        let u;
+        try {
+          t?.onDispose?.(l?.firstSub != null);
+        } catch (v) {
+          (u ??= []).push(v);
+        }
+        if (l !== void 0) {
+          try {
+            i.releaseSourceSubs(l);
+          } catch (v) {
+            (u ??= []).push(v);
+          }
+          l.cachedValue = void 0, l.pendingValue = void 0, l.pendingAuthor = void 0, l.flags = 0;
+        }
+        if (l = void 0, u?.length === 1)
+          throw u[0];
+        if (u !== void 0 && u.length > 1)
+          throw new AggregateError(u, "Owned signal disposal failed.");
+        return !0;
+      }
+    };
+    return t !== void 0 && (I.hasSubscribers = () => l?.firstSub != null), I;
+  }
+  /**
+   * Создаёт ленивый computed с финализатором исходящих и входящих связей.
+   * Финализатор работает и до первого вычисления, не материализуя узел ради очистки.
+   * @internal
+   */
+  _ownedComputed(e, t) {
+    const i = this, s = this.createComputedHandle(e, t);
+    let l = !1;
+    const r = {
+      source: s,
+      /**
+       * Отсоединяет принадлежащий источник и освобождает его ссылки.
+       * Повторный вызов возвращает true без повторной очистки.
+       */
+      dispose() {
+        if (l)
+          return !0;
+        l = !0, i.activeSub === s && (i.activeSub = null);
+        const n = [];
+        try {
+          t?.onDispose?.(s.firstSub != null);
+        } catch (c) {
+          n.push(c);
+        }
+        const a = !(s.flags & E);
+        if (a)
+          try {
+            i.releaseSourceSubs(s);
+          } catch (c) {
+            n.push(c);
+          }
+        if (s.evaluate = void 0, s.cachedValue = void 0, s.flags = 0, s.tailDep = null, a)
+          try {
+            i.pruneUnreadDependencies(s);
+          } catch (c) {
+            n.push(c);
+          }
+        if (s.firstDep = s.tailDep = null, n.length === 1)
+          throw n[0];
+        if (n.length > 1)
+          throw new AggregateError(n, "Owned computed disposal failed.");
+        return !0;
+      }
+    };
+    return t !== void 0 && (r.hasSubscribers = () => s.firstSub != null), r;
+  }
+  /**
+   * Открывает вложенную синхронную границу группировки.
+   * Внутренний вызывающий код обязан выполнить соответствующий endBatch().
+   * @internal
+   */
+  _startBatch() {
+    ++this.batchDepth;
+  }
+  /**
+   * Закрывает ранее открытую границу и обрабатывает очередь на внешнем уровне.
+   * Предусловие: число закрытий не должно превышать число открытий.
+   * @internal
+   */
+  _endBatch() {
+    !--this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects();
+  }
+  /**
+   * Проверяет наличие активного потребителя в текущем синхронном стеке чтения.
+   * @internal
+   */
+  _isTracking() {
+    return this.activeSub !== null;
+  }
+  /**
+   * Выполняет операцию с потребителем-пробой вместо текущего и сообщает, было ли
+   * в ней хотя бы одно отслеживаемое чтение. Связи пробы снимаются сразу, и
+   * проба не остаётся потребителем ни одного источника: renderer узнаёт, нужен
+   * ли вычислению эффект, не создавая его. Операция без отслеживаемых чтений
+   * стоит пробе нескольких присваиваний. Вложенный вызов получает собственную
+   * пробу. Прежний потребитель восстанавливается и при исключении.
+   * @internal
+   */
+  _probeReads(e) {
+    const t = this.probeDepth === 0 ? this.probeNode ??= this.allocateGraphRecord(void 0, B, 0, void 0) : this.allocateGraphRecord(void 0, B, 0, void 0), i = this.activeSub;
+    this.activeSub = t, this.probeDepth++;
+    let s = !1;
+    try {
+      e();
+    } finally {
+      this.probeDepth--, this.activeSub = i, t.firstDep !== null && (s = !0, t.tailDep = null, this.pruneUnreadDependencies(t));
+    }
+    return s;
+  }
+  /**
+   * Состояние уже открытой границы, без нового batch/queue.
+   * @internal
+   */
+  _isBatching() {
+    return this.batchDepth !== 0;
+  }
+  /**
+   * Показывает, обрабатывает ли экземпляр внутреннюю очередь эффектов.
+   * @internal
+   */
+  _isFlushingEffects() {
+    return this.flushingEffects;
+  }
+  // ---------------------------------------------
+  // TASK EFFECT GLUE
+  // ---------------------------------------------
+  //
+  // Аналог createScheduledEffect() без closures для вызывающего слоя, который
+  // владеет одним постоянным объектом задачи на эффект. Вызывающий слой хранит
+  // состояние запусков и управляет записью графа через методы ниже; engine не
+  // создаёт closures runner, cancel и re-arm. Такие эффекты требуют экземпляр
+  // с внешним effect scheduler, как и эффекты, связанные через scheduler.
+  /**
+   * Создаёт запись графа для эффекта с внешним планированием и подключает его
+   * постоянную задачу. Запуск ещё не запрошен: вызывающий слой сохраняет запись
+   * и затем вызывает _requestTaskEffect(). Запись, созданная во время работы
+   * другого эффекта, становится его вложенным ресурсом.
+   * @internal
+   */
+  _allocateTaskEffect(e, t) {
+    const i = this.allocateGraphRecord(void 0, e, f | S | o, void 0), s = this.activeSub;
+    return s !== null && s.flags & o && A(s, i), i.effectTask = t, i;
+  }
+  /**
+   * Запрашивает первый запуск эффекта с задачей. При `schedule` задача получает
+   * schedule(), как на пути scheduler bind; без него вызывающий слой уже сам
+   * поставил задачу в очередь, и запись только помечается запланированной.
+   * Если метод бросает исключение, запись освобождает вызывающий слой.
+   * @internal
+   */
+  _requestTaskEffect(e, t) {
+    t ? this.requestEffectTask(e) : e.effectTask !== void 0 && e.evaluate !== void 0 && (e.flags |= d), !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects();
+  }
+  /**
+   * Открывает одну доставку эффекта с задачей. Возвращает false для устаревшей
+   * доставки: запись остановлена или запуск больше не запланирован.
+   * @internal
+   */
+  /**
+   * Сбой первой доставки, выполненной вызывающим слоем без task.schedule():
+   * та же обработка, что у сбоя scheduler.
+   * @internal
+   */
+  _failTaskEffectSchedule(e, t) {
+    return this.failEffectSchedule(e, t);
+  }
+  _beginTaskEffectRun(e) {
+    return !(e.flags & d) || e.evaluate === void 0 ? !1 : (e.flags &= ~d, !0);
+  }
+  /**
+   * Выполняет доставку, открытую через _beginTaskEffectRun(), вне активного
+   * потребителя и затем обрабатывает очередь эффектов, в том числе после
+   * неудачного запуска; при двух сбоях передаёт обе причины.
+   * @internal
+   */
+  _finishTaskEffectRun(e) {
+    const t = this.activeSub;
+    this.activeSub = null;
+    try {
+      try {
+        this.executeEffect(e);
+      } catch (i) {
+        if (!this.batchDepth && this.effectReadIndex !== this.effectWriteIndex)
+          try {
+            this.flushEffects();
+          } catch (s) {
+            throw new AggregateError(
+              [i, s],
+              "Effect execution and queue processing failed."
+            );
+          }
+        throw i;
+      }
+      !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects();
+    } finally {
+      this.activeSub = t;
+    }
+  }
+  /**
+   * Гасит ожидающую доставку, от которой отказывается задача. Вызывающий слой
+   * не должен отменять доставку до первого запуска: зависимости до него ещё не
+   * собраны. Возвращает false, если запись уже остановлена.
+   * @internal
+   */
+  _cancelTaskEffect(e) {
+    return e.evaluate === void 0 ? !1 : (this.settleCancelledDependencies(e), e.flags &= -72, !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects(), !0);
+  }
+  /**
+   * Делает следующую доставку исполняемой и снова планирует задачу. Нужен,
+   * когда invalidation пришла после снимка текущей доставки: её запуск
+   * расходует предыдущее dirty-состояние.
+   * @internal
+   */
+  _rearmTaskEffect(e) {
+    const t = e.effectTask;
+    t === void 0 || e.evaluate === void 0 || (e.flags |= f | d, t.schedule());
+  }
+  /**
+   * Окончательно останавливает эффект с задачей. Engine один раз вызывает
+   * task.dispose() изнутри, поэтому задача может направлять собственное
+   * освобождение через этот метод.
+   * @internal
+   */
+  _disposeTaskEffect(e) {
+    this.disposeEffect(e);
+  }
+  // ---------------------------------------------
+  // SIGNAL NODE GLUE
+  // ---------------------------------------------
+  //
+  // Аналог _ownedSignal() без closures для вызывающего слоя, который хранит
+  // значение, запись графа и source hooks одного signal в одном постоянном
+  // объекте. Вызывающий слой сам держит значение до материализации и ссылку на
+  // запись после неё; engine не создаёт handle, closures чтения и записи и
+  // объект финализатора. Методы повторяют шаги _ownedSignal() по одному.
+  /**
+   * Материализует signal для активного потребителя и связывает их. Без
+   * потребителя возвращает undefined: signal остаётся значением у вызывающего
+   * слоя. После материализации значением владеет запись.
+   * @internal
+   */
+  _trackSignalNode(e, t) {
+    const i = this.activeSub;
+    if (i !== null)
+      return this.materializeSignal(e, i, t);
+  }
+  /**
+   * Читает материализованный signal и регистрирует зависимость активного
+   * потребителя.
+   * @internal
+   */
+  _readSignalNode(e) {
+    return this.readSignalValue(e);
+  }
+  /**
+   * Читает материализованный signal без подписки текущего потребителя;
+   * pending-значение фиксируется так же, как при обычном чтении.
+   * @internal
+   */
+  _peekSignalNode(e) {
+    const t = this.activeSub;
+    if (t === null)
+      return this.readSignalValue(e);
+    this.activeSub = null;
+    try {
+      return this.readSignalValue(e);
+    } finally {
+      this.activeSub = t;
+    }
+  }
+  /**
+   * Возвращает значение, которое увидит следующее чтение: pending-значение
+   * незавершённой группировки либо зафиксированное. Ничего не фиксирует.
+   * @internal
+   */
+  _visibleSignalValue(e) {
+    return e.flags & f ? e.pendingValue : e.cachedValue;
+  }
+  /**
+   * Записывает значение материализованного signal с обычной семантикой batch.
+   * @internal
+   */
+  _writeSignalNode(e, t) {
+    this.writeSignalValue(e, t);
+  }
+  /**
+   * Сообщает, есть ли у материализованного signal потребители в графе.
+   * @internal
+   */
+  _signalNodeHasSubscribers(e) {
+    return e.firstSub !== null;
+  }
+  /**
+   * Отсоединяет материализованный signal от потребителей и освобождает его
+   * значения. Значения освобождаются и при сбое отсоединения. Поля pending
+   * сбрасываются, только если запись их получала: запись без группировок не
+   * меняет набор своих полей при освобождении.
+   * @internal
+   */
+  _releaseSignalNode(e) {
+    try {
+      this.releaseSourceSubs(e);
+    } finally {
+      e.cachedValue = void 0, e.pendingValue !== void 0 && (e.pendingValue = void 0), e.pendingAuthor != null && (e.pendingAuthor = void 0), e.flags = 0;
+    }
+  }
+  // ---------------------------------------------
+  // SUBSCRIBER OWNER GLUE
+  // ---------------------------------------------
+  //
+  // Чтение живых связей производителя для вызывающего слоя, которому нужен
+  // ответ о владельцах потребителей только по запросу. Слой не ведёт своего
+  // учёта рёбер: связь, снятая графом, перестаёт быть видимой сразу, без
+  // отдельного cleanup на ребро.
+  /**
+   * Ищет среди текущих потребителей записи первого, чьего владельца принимает
+   * accept, и возвращает этого владельца. Владелец потребителя определяется
+   * так же, как при привязке ребра через onDependency: у computed это
+   * dependencyOwner его source hooks, у эффекта — dependencyOwner его задачи.
+   * Потребители без владельца пропускаются. Обход идёт в порядке списка
+   * потребителей, ничего не выделяет и не меняет граф; accept не должен менять
+   * связи этой записи.
+   * @param node Материализованная запись производителя.
+   * @param accept Проверка владельца потребителя; context передаётся ей без closure.
+   * @param context Произвольное значение вызывающего слоя для accept.
+   * @internal
+   */
+  _findSubscriberOwner(e, t, i) {
+    for (let s = e.firstSub; s !== null; s = s.nextSub) {
+      const l = s.sub, r = l.sourceHooks?.dependencyOwner ?? l.effectTask?.dependencyOwner;
+      if (r !== void 0 && t(r, i))
+        return r;
+    }
+  }
+  /**
+   * Возвращает владельца активного потребителя: того, кому engine привязал бы
+   * ребро следующего отслеживаемого чтения. Владелец определяется так же, как
+   * в _findSubscriberOwner(). Без активного потребителя и у потребителя без
+   * владельца результат undefined. Метод ничего не выделяет и не меняет граф.
+   *
+   * Вызывающий слой проверяет по этому владельцу допустимость чтения, когда
+   * его собственный контекст снят, а потребитель engine остался активным.
+   * @internal
+   */
+  _activeSubscriberOwner() {
+    const e = this.activeSub;
+    if (e !== null)
+      return e.sourceHooks?.dependencyOwner ?? e.effectTask?.dependencyOwner;
+  }
+  // ---------------------------------------------
+  // COUNTER NODE GLUE
+  // ---------------------------------------------
+  //
+  // Запись графа со счётчиком вместо значения: вызывающий слой будит через неё
+  // потребителей, которым важен сам факт изменения. Значение счётчика только
+  // растёт, поэтому одну запись нельзя отменить следующей.
+  /**
+   * Увеличивает счётчик материализованного signal и уведомляет его
+   * потребителей. Без потребителей ничего не пишет и возвращает false.
+   *
+   * Сдвиг — обычная запись signal. Вне группировки она прямая: счётчик
+   * фиксируется сразу, а потребитель становится обязательным к пересчёту, в
+   * том числе тот, кто ждал только проверки зависимостей или стоит на стеке
+   * идущей проверки. Внутри группировки и у записи с ещё не прочитанным
+   * отложенным сдвигом запись откладывается до первого чтения, как любая запись
+   * внутри batch().
+   *
+   * Потребитель, который выполняется в момент прямого сдвига, получает его по
+   * общему правилу записи во время запуска: у записи не остаётся отложенного
+   * сдвига, который позже подтвердил бы ему изменение.
+   *
+   * Очередь эффектов обрабатывается на выходе, если группировки нет: отложенная
+   * запись сама её не обрабатывает, а потребитель, которого она поставила в
+   * очередь, не должен ждать следующей записи.
+   * @internal
+   */
+  _bumpSignalNode(e) {
+    return e.firstSub === null ? !1 : (this.writeSignalValue(
+      e,
+      (e.flags & f ? e.pendingValue : e.cachedValue) + 1
+    ), !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects(), !0);
+  }
+  /**
+   * Создаёт запись-счётчик для активного потребителя и связывает их; без
+   * потребителя возвращает undefined. Счётчик начинается с нуля и сдвигается
+   * через _bumpSignalNode().
+   *
+   * Счётчик — производитель без собственных зависимостей. Граф читает у него
+   * то же, что у записи signal в роли производителя: признаки, список
+   * потребителей, отсутствие getter, значение и source hooks. Полей списка
+   * зависимостей у записи нет, а hooks лежат в ней самой: счётчик стоит одной
+   * аллокации из шести полей, а запись signal с hooks — двух. Поля отложенной
+   * записи появляются у счётчика с первым сдвигом.
+   * @internal
+   */
+  _trackCounterNode(e) {
+    const t = this.activeSub;
+    if (t === null)
+      return;
+    const i = {
+      flags: h,
+      firstSub: null,
+      lastSub: null,
+      evaluate: void 0,
+      cachedValue: 0,
+      sourceHooks: e
+    };
+    return t.flags & R ? this.appendInitialDependency(i, t) : this.trackDependency(i, t), i;
+  }
+  // ---------------------------------------------
+  // ACTIVE TASK GLUE
+  // ---------------------------------------------
+  //
+  // Тело эффекта с задачей engine вызывает без аргументов и без receiver.
+  // Вызывающий слой, который даёт всем своим эффектам одно общее тело, находит
+  // через метод ниже эффект, ради которого тело вызвано: записи графа не нужна
+  // собственная closure тела.
+  /**
+   * Возвращает постоянную задачу активного потребителя. Engine делает запись
+   * эффекта активным потребителем непосредственно перед вызовом её тела,
+   * поэтому первое обращение из тела возвращает задачу именно этого эффекта,
+   * какие бы доставки ни выполнил cleanup его прошлого запуска.
+   *
+   * Без активного потребителя и у потребителя без задачи — computed либо
+   * эффекта, созданного без внешнего планирования, — результат undefined.
+   * Метод ничего не выделяет и не меняет граф.
+   * @internal
+   */
+  _activeEffectTask() {
+    const e = this.activeSub;
+    return e === null ? void 0 : e.effectTask;
+  }
+}
+function B() {
+}
+export {
+  G as ReactivityEngine,
+  O as ScopeNode
+};