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

package/dist/debug/reactivity/engine.js

@@ -1,1700 +1,36 @@
-import { reactiveObject as O } from "./reactive-object.js";
-import { appendScopeChild as W, ScopeNode as U, throwScopeErrors as V, detachScopeChild as q } from "./scope.js";
-import { watchWithReactivity as z } from "./watch.js";
-const g = 1, f = 2, D = 4, p = 8, _ = 16, d = 32, v = 64, x = 128, k = 256, o = 512, L = 2048, E = 4096, m = 8192, R = L | E, T = 1e4, b = g | f, I = 16, F = 2;
-function A(c) {
-  c.dependencyLookupDebt === void 0 && c.dependencyIndex === void 0 || (c.dependencyIndex = void 0, c.dependencyLookupDebt = void 0, c.dependencyLookupSearches = void 0);
-}
-function H(c, e) {
-  if (e <= I || c.flags & x || c.dependencyIndex !== void 0)
-    return;
-  const t = (c.dependencyLookupSearches ?? 0) + 1, i = (c.dependencyLookupDebt ?? 0) + e;
-  if (c.dependencyLookupSearches = t, c.dependencyLookupDebt = i, t < F || i < c.depCount)
-    return;
-  const s = /* @__PURE__ */ new Map();
-  for (let n = c.firstDep; n !== null; n = n.nextDep)
-    s.set(n.dep, n);
-  c.dependencyIndex = s, c.dependencyLookupDebt = void 0, c.dependencyLookupSearches = void 0;
-}
-function Q(c, e, t) {
-  const i = c.firstSub;
-  if (i === null)
-    return;
-  if (i === c.lastSub)
-    return i.sub === e ? i : void 0;
-  const s = c.subSearchCursor ?? i;
-  let n = 1;
-  if (s.sub === e)
-    return c.subSearchCursor = s.nextSub ?? i, s;
-  if (t) {
-    const a = e.dependencyIndex?.get(c);
-    if (a !== void 0)
-      return c.subSearchCursor = a.nextSub ?? i, a;
-    if (e.dependencyIndex !== void 0)
-      return;
-  }
-  let r = s.nextSub ?? i;
-  for (; r !== s; ) {
-    if (++n, r.sub === e)
-      return c.subSearchCursor = r.nextSub ?? i, t && H(e, n), r;
-    r = r.nextSub ?? i;
-  }
-  t && H(e, n);
-}
-class N {
-  // Opt-in стратегия длинного slow path; не добавляет policy field каждой ноде.
-  adaptiveDependencyIndex;
-  // Потребитель текущего синхронного чтения; null отключает отслеживание.
-  activeSub = null;
-  // Глубина вложенных синхронных границ группировки.
-  batchDepth = 0;
-  // Индекс следующего элемента внутренней очереди эффектов.
-  effectReadIndex = 0;
-  // Позиция добавления элемента в текущем проходе очереди.
-  effectWriteIndex = 0;
-  // Граница активного префикса переиспользуемого стека invalidation.
-  invalidationDepth = 0;
-  // Граница активного префикса стека проверки зависимостей.
-  dependencyDepth = 0;
-  // Только активная проверка зависимостей требует дополнительной отметки записей.
-  checkingDepth = 0;
-  // Защита внутренней очереди от вложенного повторного прохода.
-  flushingEffects = !1;
-  // Переиспользуемый буфер очереди; прочитанная ячейка сразу освобождает ссылку.
-  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.adaptiveDependencyIndex = e.adaptiveDependencyIndex ?? !1, this.effectScheduler = e.effectScheduler, this._effectImmediate = this.effect.bind(this), this.signal = this.signal.bind(this), this.computed = this.computed.bind(this), this.reactive = this.reactive.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 a = this.activeSub;
-      return a === null || (i = this.materializeSignal(
-        t,
-        a
-      )), t;
-    }, n = (r) => {
-      const a = i;
-      if (a !== void 0) {
-        this.writeSignalValue(a, r);
-        return;
-      }
-      t !== r && (t = r);
-    };
-    return {
-      get: s,
-      peek: this.handleReaders.peek,
-      set: n
-    };
+import { ReactivityEngine as r } from "./engine-core.js";
+import { reactiveObject as i } from "./reactive-object.js";
+import { ScopeNode as b } from "./scope.js";
+class a extends r {
+  constructor(c = {}) {
+    super(c), this.reactive = this.reactive.bind(this);
   }
   /**
    * Возвращает стабильный глубокий Proxy для plain object или array.
    * Object context и per-property sources создаются лениво внутри этого engine.
    */
-  reactive(e) {
-    return O(this, e, () => this.createReactivePropertySourceBridge());
-  }
-  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 | g | d);
-    t !== void 0 && (i.onStop = t);
-    const s = this.activeSub;
-    s !== null && s.flags & d && W(s, i);
-    try {
-      this.executeEffect(i);
-    } catch (n) {
-      try {
-        this.disposeEffect(i);
-      } catch (r) {
-        throw new AggregateError([n, r], "Effect registration and cleanup failed.");
-      }
-      throw n;
-    }
-    return this.effectReadIndex !== this.effectWriteIndex && this.flushEffects(), () => this.disposeEffect(i);
-  }
-  /**
-   * Наблюдает за источниками; callback и cleanup не создают зависимостей.
-   */
-  watch(e, t, i) {
-    return z(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 U(this);
-  }
-  // ---------------------------------------------
-  // PRIVATE
-  // ---------------------------------------------
-  /**
-   * Создаёт запись графа с одинаковым порядком основных полей.
-   * Значение служит кешем signal/computed либо хранит cleanup эффекта.
-   * Поля внешней задачи и окончательной очистки добавляются только при необходимости.
-   */
-  allocateGraphRecord(e, t, i) {
-    return {
-      flags: i,
-      firstSub: null,
-      lastSub: null,
-      firstDep: null,
-      tailDep: null,
-      depCount: 0,
-      evaluate: t,
-      cachedValue: e
-    };
-  }
-  /** Creates a narrow Proxy adapter over the existing intrusive graph. */
-  createReactivePropertySourceBridge() {
-    return {
-      batch: this.batch,
-      create: () => {
-        if (this.activeSub === null)
-          throw new Error("[Raph] Reactive property source requires a tracked read.");
-        return { firstSub: null, lastSub: null };
-      },
-      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());
-      }
-    };
-  }
-  /**
-   * Материализует signal в графе при первом отслеживаемом чтении
-   * и связывает его с активным потребителем.
-   *
-   * До этого момента signal может хранить значение только в замыкании
-   * и вообще не создавать `ReactiveNode`.
-   */
-  materializeSignal(e, t, i) {
-    const s = this.allocateGraphRecord(
-      e,
-      void 0,
-      0
-    );
-    return i !== void 0 && (s.sourceHooks = i, s.flags |= o), t.flags & x ? this.appendInitialDependency(s, t) : this.trackDependency(s, t), s;
-  }
-  /**
-   * Создаёт минимальный handle computed без преждевременного выделения полей графа.
-   * Первый get() материализует запись на этом же объекте и заменяет метод чтения.
-   */
-  createComputedHandle(e, t) {
-    const i = {
-      evaluate: e,
-      get: this.handleReaders.initializeComputed,
-      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 | g | d);
-    let s = !1;
-    t !== void 0 && (i.onStop = t);
-    const n = this.activeSub;
-    n !== null && n.flags & d && W(n, i);
-    const r = () => {
-      if (!(!(i.flags & v) || i.evaluate === void 0)) {
-        i.flags &= ~v, s = !0;
-        try {
-          this.executeEffect(i);
-        } catch (a) {
-          if (!this.batchDepth && this.effectReadIndex !== this.effectWriteIndex)
-            try {
-              this.flushEffects();
-            } catch (l) {
-              throw new AggregateError(
-                [a, l],
-                "Effect execution and queue processing failed."
-              );
-            }
-          throw a;
-        }
-        !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects();
-      }
-    };
-    try {
-      const a = this.effectScheduler.bind(r);
-      a.cancelPending = () => i.evaluate === void 0 || !s ? !1 : (this.settleCancelledDependencies(i), i.flags &= ~(v | b | D), !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects(), !0), a.rearmPending = () => {
-        i.evaluate !== void 0 && (i.flags |= f | v, a.schedule());
-      }, i.effectTask = a, this.requestEffectTask(i);
-    } catch (a) {
-      try {
-        this.disposeEffect(i);
-      } catch (l) {
-        throw new AggregateError([a, l], "Effect registration and cleanup failed.");
-      }
-      throw a;
-    }
-    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), 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 a = this.activeSub !== null && this.activeSub.flags & p ? this.activeSub : null;
-        s ? e.pendingAuthor !== a && (e.pendingAuthor = null) : e.pendingAuthor = a;
-      }
-      const r = e.firstSub;
-      r != null && (!s || this.activeSub !== null && this.activeSub.flags & p || e.flags & o) && 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 | x)) === (p | x))
-      throw new Error("Computed value is already being evaluated.");
-    const i = t & (_ | b | k), s = i === 0 ? e.cachedValue : i & _ ? this.evaluateFirstValue(e) : this.refreshComputedValue(e, t);
-    if (e.evaluate === void 0)
-      return s;
-    const n = this.activeSub;
-    if (n !== null) {
-      const r = n.tailDep;
-      n.flags & x ? (r === null || r.dep !== e) && this.appendInitialDependency(e, n) : this.trackDependency(e, n);
-    }
-    return s;
-  }
-  /**
-   * Выполняет первый сбор зависимостей и кеширует только успешный результат.
-   * При исключении оставляет состояние повторяемой ошибки, а не чистый undefined.
-   * Уже прочитанные зависимости сохраняются для последующего уведомления.
-   */
-  evaluateFirstValue(e) {
-    const t = e.flags & o, i = e.evaluate;
-    e.flags = t | p | x;
-    const s = this.activeSub;
-    this.activeSub = e;
-    let n;
-    try {
-      if (n = i(), e.evaluate !== i)
-        return e.cachedValue = void 0, e.flags = 0, n;
-      e.flags = t | (e.flags & D ? f : 0);
-    } catch (r) {
-      throw e.evaluate !== i ? (e.cachedValue = void 0, e.flags = 0, r) : (e.flags = t | k, s !== null && this.trackDependency(e, s), r);
-    } finally {
-      this.activeSub = s;
-    }
-    return e.flags & f ? this.refreshComputedValue(e, e.flags) : (e.cachedValue = n, n);
-  }
-  /**
-   * Актуализирует computed: выполняет прямой пересчёт либо проверяет зависимости.
-   * После ошибки getter разрешён повторный пересчёт даже без новой записи источника.
-   */
-  refreshComputedValue(e, t, i = null) {
-    try {
-      if (t & (f | D | k))
-        return this.recomputeValue(e, i), e.cachedValue;
-      const s = e.firstDep;
-      return s !== null && this.refreshDependencies(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 n = i.nextDep;
-      return n !== null && n.dep === e ? (t.tailDep = n, n) : i.dep === e ? i : this.reconcileDependency(e, t, i, n);
-    }
-    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.depCount <= I) {
-      for (let l = s; l !== null; l = l.nextDep)
-        if (l.dep === e)
-          return this.reorderDependency(t, l, i), t.tailDep = l, l;
-      for (let l = i; l !== null; l = l.prevDep)
-        if (l.dep === e)
-          return l;
-      return s !== null ? (t.tailDep = this.reuseDepLink(s, e), s) : t.tailDep = this.insertDependency(e, t, i);
-    }
-    let n = 0, r = s;
-    for (; r !== null && n < I; ) {
-      const l = r;
-      if (l.dep === e)
-        return this.reorderDependency(t, l, i), t.tailDep = l, l;
-      r = l.nextDep, ++n;
-    }
-    let a = i;
-    for (; a !== null && n < I; ) {
-      const l = a;
-      if (l.dep === e)
-        return l;
-      a = l.prevDep, ++n;
-    }
-    if (r !== null || a !== null) {
-      const l = Q(e, t, this.adaptiveDependencyIndex);
-      if (l !== void 0)
-        return this.reorderDependency(t, l, i), t.tailDep = l, l;
-    }
-    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, n = {
-      dep: e,
-      sub: t,
-      prevSub: s,
-      nextSub: null,
-      prevDep: i,
-      nextDep: null
-    };
-    return s === null ? e.firstSub = n : s.nextSub = n, e.lastSub = n, i === null ? t.firstDep = n : i.nextDep = n, t.tailDep = n, ++t.depCount, t.dependencyIndex?.set(e, n), e.flags & o && this.attachDependencyCleanup(n), n;
-  }
-  /**
-   * Вставляет связь после заданного курсора зависимостей потребителя.
-   * Сохраняет ещё не прочитанный хвост списка и увеличивает dependencyCount.
-   */
-  insertDependency(e, t, i) {
-    const s = e.lastSub, n = {
-      dep: e,
-      sub: t,
-      prevSub: s,
-      nextSub: null,
-      prevDep: i,
-      nextDep: null
-    };
-    s === null ? e.firstSub = n : s.nextSub = n, e.lastSub = n;
-    const r = i === null ? t.firstDep : i.nextDep;
-    return n.nextDep = r, r !== null && (r.prevDep = n), i === null ? t.firstDep = n : i.nextDep = n, ++t.depCount, t.dependencyIndex?.set(e, n), e.flags & o && this.attachDependencyCleanup(n), n;
-  }
-  /**
-   * Переназначает существующую связь другому производителю.
-   * Положение в списке зависимостей потребителя и число его связей сохраняются.
-   */
-  reuseDepLink(e, t) {
-    const i = e.sub.dependencyIndex;
-    this.detachSubLink(e);
-    const s = t.lastSub;
-    return e.dep = t, e.prevSub = s, e.nextSub = null, s === null ? t.firstSub = e : s.nextSub = e, t.lastSub = e, i?.set(t, e), t.flags & o && this.attachDependencyCleanup(e), e;
-  }
-  /**
-   * Перемещает существующую зависимость после курсора текущего чтения.
-   * Список потребителей производителя и количество зависимостей не изменяет.
-   */
-  reorderDependency(e, t, i) {
-    if (t.prevDep === i)
-      return;
-    const s = t.prevDep, n = t.nextDep;
-    s === null ? e.firstDep = n : s.nextDep = n, n !== null && (n.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 n = i; n !== null; n = n.nextDep)
-      n.prevDep = null, --e.depCount;
-    e.depCount <= I && A(e);
-    let s;
-    for (; i !== null; ) {
-      const n = i.nextDep;
-      try {
-        this.detachSubLink(i, !0);
-      } catch (r) {
-        this.unlinkSubLink(i, !0), s ??= [], s.push(r);
-      }
-      i = n;
-    }
-    s !== void 0 && V(s, "Dependency cleanup failed.");
-  }
-  /**
-   * Удаляет связь только из списка потребителей производителя.
-   * Список зависимостей потребителя и его счётчик здесь не изменяются.
-   * Также исправляет курсор поиска, если он указывал на удаляемую связь.
-   */
-  detachSubLink(e, t = !1) {
-    e.sub.dependencyIndex?.delete(e.dep);
-    let i;
-    e.dep.flags & o && (i = e.dependencyCleanup, e.dependencyCleanup = void 0, i?.()), this.unlinkSubLink(e, t || i !== void 0);
-  }
-  /** Завершает удаление 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 & o)) {
-      let s = e.firstSub;
-      for (; s != null; ) {
-        const n = s.nextSub, r = s.sub;
-        this.detachDependencyLink(s), this.detachSubLink(s);
-        const a = r.flags;
-        (a & (b | p)) === g && (r.flags = a & ~g | f, a & d && this.enqueueEffect(r, e)), s = n;
-      }
-      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 (n) {
-        this.unlinkSubLink(t, !0), i ??= [], i.push(n);
-      }
-      t = s;
-    }
-    e.firstSub = e.lastSub = null, e.subSearchCursor = void 0, i !== void 0 && V(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), --t.depCount, t.depCount <= I && A(t));
-  }
-  /**
-   * Добавляет эффект во внутреннюю очередь один раз до обработки текущей записи.
-   * Флаг SCHEDULED предотвращает повторное добавление без создания task-объекта.
-   */
-  enqueueEffect(e, t) {
-    const i = t !== void 0 && t.flags & o ? t.sourceHooks.token : void 0;
-    i !== void 0 && e.effectTask?.notify?.(i), !(e.flags & v) && (e.flags |= v, 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 n = e; n !== null; n = n.nextSub) {
-      const r = n.sub, a = r.flags;
-      let l = 0;
-      if (a & (b | p) ? a & p ? l = this.invalidateReadDependency(n, r, a) : !t && !(a & f) && (r.flags = a & ~g | f) : (l = a & ~D | (t ? g : f), r.flags = l), l === 0) {
-        if (a & d && a & v) {
-          const u = n.dep.flags & o ? n.dep.sourceHooks.token : void 0;
-          u !== void 0 && r.effectTask?.notify?.(u);
-        } else r.flags & (o | m) && (r.flags & o && r.sourceHooks.onInvalidate?.(r.firstSub !== null), r.flags &= ~m, r.firstSub !== null && (this.invalidationStack[s++] = r.firstSub));
-        continue;
-      }
-      l & d ? (!(l & p) || r.effectTask?.allowScheduleDuringRun === !0) && this.enqueueEffect(r, n.dep) : (!(a & b) && r.flags & o && r.sourceHooks.onInvalidate?.(r.firstSub !== null), r.firstSub !== null && (this.invalidationStack[s++] = r.firstSub));
-    }
-    for (; s !== i; ) {
-      let n = this.invalidationStack[--s];
-      do {
-        const r = n.sub, a = r.flags;
-        let l = 0;
-        if (a & (b | p) ? a & p && (l = this.invalidateReadDependency(n, r, a)) : (l = a & ~D | g, r.flags = l), l === 0) {
-          if (a & d && a & v) {
-            const u = n.dep.flags & o ? n.dep.sourceHooks.token : void 0;
-            u !== void 0 && r.effectTask?.notify?.(u);
-          } else if (r.flags & (o | m) && (r.flags & o && r.sourceHooks.onInvalidate?.(r.firstSub !== null), r.flags &= ~m, r.firstSub !== null)) {
-            n.nextSub !== null && (this.invalidationStack[s++] = n.nextSub), n = r.firstSub;
-            continue;
-          }
-        } else if (l & d)
-          this.enqueueEffect(r, n.dep);
-        else if (!(a & b) && r.flags & o && r.sourceHooks.onInvalidate?.(r.firstSub !== null), r.firstSub !== null) {
-          n.nextSub !== null && (this.invalidationStack[s++] = n.nextSub), n = r.firstSub;
-          continue;
-        }
-        n = n.nextSub;
-      } while (n !== null);
-    }
-    this.invalidationDepth = i;
-  }
-  // Дополнительный обход не вызывает callbacks и проходит уже dirty computed:
-  // флаги обычной invalidation не показывают, какую связь check уже прошёл.
-  markActiveChecks(e) {
-    const t = [e], i = /* @__PURE__ */ new Set();
-    for (; t.length !== 0; )
-      for (let s = t.pop(); s !== null; s = s.nextSub) {
-        const n = s.sub;
-        i.has(n) || (i.add(n), n.flags & L && (n.flags |= E), !(n.flags & d) && n.firstSub !== null && t.push(n.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;
-    }
-    const n = i | D | g;
-    return t.flags = n, n;
-  }
-  /**
-   * Подтверждает необходимость пересчёта непосредственных потребителей.
-   * Применяется после фиксации реально изменившегося значения; позволяет исключить
-   * текущую связь и автора записи.
-   */
-  confirmSubUpdates(e, t, i = null) {
-    for (let s = e; s !== null; s = s.nextSub) {
-      if (s === t || s.sub === i)
-        continue;
-      const n = s.sub, r = n.flags;
-      r & f || (n.flags = r & ~g | f, r & d ? this.enqueueEffect(n, s.dep) : r & b || n.flags & o && n.sourceHooks.onInvalidate?.(n.firstSub !== null));
-    }
-  }
-  /**
-   * Повторно вычисляет узел, согласует зависимости и сравнивает результат с кешем.
-   * При ошибке восстанавливает контекст, удаляет непрочитанный хвост и оставляет
-   * повторяемое состояние ошибки. Также восстанавливает непосредственного потребителя
-   * skipSub: при разворачивании стека его связь могла быть уже извлечена из буфера.
-   * Неверное значение в кеш не записывается.
-   */
-  recomputeValue(e, t = null) {
-    const i = e.cachedValue;
-    for (let s = 0; s < T; s++) {
-      const n = e.evaluate;
-      e.tailDep = null;
-      const r = e.flags & -6149 | p;
-      e.flags = r;
-      const a = this.activeSub;
-      this.activeSub = e;
-      let l;
-      try {
-        l = n();
-      } catch (h) {
-        if (e.evaluate !== n)
-          throw e.cachedValue = void 0, e.flags = 0, h;
-        this.failComputedValue(e, t, h);
-      } finally {
-        this.activeSub = a;
-      }
-      if (e.evaluate !== n)
-        return e.cachedValue = void 0, e.flags = 0, !1;
-      const u = e.tailDep;
-      if ((u === null ? e.firstDep : u.nextDep) !== null)
-        try {
-          this.pruneUnreadDependencies(e);
-        } catch (h) {
-          this.failComputedValue(e, t, h);
-        }
-      if (e.evaluate !== n)
-        return e.cachedValue = void 0, e.flags = 0, !1;
-      const w = e.flags & D;
-      if (e.flags = r & -8460, w) {
-        e.flags |= f;
-        continue;
-      }
-      return e.cachedValue = l, i === l ? !1 : (e.firstSub !== null && this.confirmSubUpdates(e.firstSub, t), !0);
-    }
-    return this.failComputedValue(e, t, new Error(`Computed settlement exceeded ${T} attempts.`));
-  }
-  /** Сохраняет первичную ошибку и отдельные ошибки 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 & -6288 | k);
-    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);
-    }
-  }
-  /**
-   * Итеративно проверяет зависимые computed и pending-сигналы перед запуском потребителя.
-   * Использует общий стек с сохранением активного префикса вложенного обхода.
-   * При исключении восстанавливает высоту стека и состояния всех незавершённых
-   * узлов текущего прохода; порядок успешного обхода не меняется.
-   */
-  refreshDependencies(e, t) {
-    const i = this.dependencyDepth;
-    try {
-      return this.walkDependencyChain(e, t);
-    } catch (s) {
-      this.markRecoveryDependencies(e), this.restoreFailedDependency(e);
-      for (let n = i; n < this.dependencyDepth; n++)
-        this.restoreFailedDependency(this.dependencyStack[n].sub);
-      throw this.dependencyDepth = i, this.dependencyStack.length = i, s;
-    }
-  }
-  /** 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 & (_ | b | k) && (i.evaluate === void 0 ? s & f && this.commitSignalValue(i, t) : this.refreshComputedValue(i, s, t));
-    }
-  }
-  /**
-   * Выполняет исходный итеративный обход зависимостей без обработки ошибок внутри цикла.
-   * Перед пользовательским вычислением публикует активную высоту стека; оболочка
-   * refreshDependencies() использует этот префикс для восстановления после сбоя.
-   */
-  walkDependencyChain(e, t) {
-    const i = this.dependencyDepth;
-    let s = i, n = !1, r;
-    e.flags = e.flags & ~E | L, ++this.checkingDepth;
-    try {
-      e: for (; ; ) {
-        if (e.flags & E) {
-          r ??= /* @__PURE__ */ new Map();
-          const a = (r.get(e) ?? 0) + 1;
-          if (r.set(e, a), a > T)
-            throw new Error(`Dependency check exceeded ${T} restarts.`);
-          e.flags &= ~E, e.firstDep !== null && (t = e.firstDep);
-        }
-        if (e.flags & f)
-          n = !0;
-        else {
-          const a = t.dep, l = a.flags;
-          if (l & (f | k))
-            this.dependencyDepth = s, n = a.evaluate === void 0 ? this.commitSignalValue(a, t) : this.recomputeValue(a, t);
-          else if (l & g) {
-            if (a.firstDep !== null) {
-              this.dependencyStack[s++] = t, e = a, e.flags = e.flags & ~E | L, t = a.firstDep;
-              continue e;
-            }
-            this.dependencyDepth = s, n = this.recomputeValue(a, t);
-          } else
-            n = !1;
-        }
-        if (!n && t.nextDep !== null) {
-          t = t.nextDep;
-          continue;
-        }
-        if (n) {
-          for (; s !== i; ) {
-            this.dependencyDepth = --s;
-            const a = this.dependencyStack[s];
-            if (e.flags &= ~R, n = this.recomputeValue(e, a), e = a.sub, !n) {
-              if (a.nextDep !== null) {
-                t = a.nextDep;
-                continue e;
-              }
-              break;
-            }
-          }
-          if (n)
-            return this.dependencyDepth = i, !0;
-        }
-        for (; s !== i; ) {
-          if (e.flags & (f | E))
-            continue e;
-          this.dependencyDepth = --s;
-          const a = this.dependencyStack[s];
-          if (e.flags &= ~(g | R), e = a.sub, a.nextDep !== null) {
-            t = a.nextDep;
-            continue e;
-          }
-        }
-        if (e.flags & (f | E))
-          continue e;
-        return e.flags &= ~(g | R), this.dependencyDepth = i, !1;
-      }
-    } finally {
-      e.flags &= ~R;
-      for (let a = i; a < s; a++)
-        this.dependencyStack[a].sub.flags &= ~R;
-      --this.checkingDepth;
-    }
-  }
-  /**
-   * Восстанавливает незавершённую запись после прерванной проверки зависимостей.
-   * Computed получает повторяемое состояние ошибки, effect остаётся доступным
-   * для следующей invalidation. Вызывается только на ошибочном пути.
-   */
-  restoreFailedDependency(e) {
-    if (e.evaluate === void 0) {
-      e.cachedValue = void 0, e.flags = 0;
-      return;
-    }
-    e.flags &= -6160, e.flags & d || (e.flags |= k);
-  }
-  /**
-   * Проверяет необходимость запуска, очищает прошлые ресурсы и выполняет тело эффекта.
-   * Ошибка cleanup останавливает эффект до создания ресурсов следующего запуска.
-   * При ошибке тела сохраняет фактически прочитанные зависимости, останавливает
-   * созданных детей и разрешает повторный запуск после следующей записи.
-   * Cleanup, возвращённый после собственного stop, освобождается сразу.
-   */
-  executeEffect(e) {
-    const t = e.flags;
-    if (!(t & b))
-      return;
-    if (!(t & (f | D))) {
-      const u = e.firstDep;
-      try {
-        if (u === null || !this.refreshDependencies(e, u)) {
-          e.flags &= ~b;
-          return;
-        }
-      } catch (w) {
-        throw e.flags &= -80, w;
-      }
-    }
-    const i = e.evaluate;
-    if (i === void 0) {
-      e.flags &= ~b;
-      return;
-    }
-    let s;
-    if (e.scopeLastChild !== void 0)
-      try {
-        this.disposeNestedEffects(e);
-      } catch (u) {
-        s = [u];
-      }
-    const n = typeof e.cachedValue == "function" ? e.cachedValue : void 0;
-    if (e.cachedValue = void 0, e.flags &= ~D, n !== void 0)
-      try {
-        this.untracked(n);
-      } catch (u) {
-        s ??= [], s.push(u);
-      }
-    if (s !== void 0) {
-      try {
-        this.disposeEffect(e);
-      } catch (u) {
-        s.push(u);
-      }
-      V(s, "Effect cleanup failed.");
-    }
-    if (e.evaluate === void 0)
-      return;
-    e.tailDep = null, e.flags = e.flags & ~D | p;
-    const r = this.activeSub;
-    this.activeSub = e;
-    let a;
-    try {
-      a = i();
-    } catch (u) {
-      this.activeSub = r, e.flags &= ~p, this.failEffectRun(e, u, s);
-    } finally {
-      this.activeSub = r, e.flags &= ~p;
-    }
-    const l = e.tailDep;
-    if ((l === null ? e.firstDep : l.nextDep) !== null && this.pruneUnreadDependencies(e), typeof a == "function")
-      if (e.evaluate === void 0)
-        try {
-          this.untracked(a);
-        } catch (u) {
-          s ??= [], s.push(u);
-        }
-      else
-        e.cachedValue = a;
-    e.flags & v ? e.flags = e.flags & -7 | g : e.flags &= -8;
-  }
-  /**
-   * Завершает неудачный запуск эффекта, не затрагивая успешный путь исполнения.
-   * Сохраняет прочитанные зависимости для следующей invalidation, освобождает
-   * детей неудачного запуска и объединяет ошибки с предыдущими ошибками cleanup.
-   */
-  failEffectRun(e, t, i) {
-    const s = i ?? [];
-    s.push(t), this.pruneUnreadDependencies(e);
-    try {
-      this.disposeNestedEffects(e);
-    } catch (n) {
-      s.push(n);
-    }
-    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 & (d | p)) === (d | p))) {
-      this.flushingEffects = !0;
-      try {
-        for (; this.effectReadIndex !== this.effectWriteIndex; ) {
-          const e = this.effectReadIndex, t = this.effectQueue[e];
-          this.effectQueue[e] = void 0, ++this.effectReadIndex, t.flags &= ~v, 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 & (d | p)) === (d | p))) {
-      this.flushingEffects = !0;
-      try {
-        for (; this.effectReadIndex !== this.effectWriteIndex; ) {
-          const e = this.effectReadIndex, t = this.effectQueue[e];
-          this.effectQueue[e] = void 0, ++this.effectReadIndex;
-          const i = t.effectTask;
-          i === void 0 ? (t.flags &= ~v, this.executeEffect(t)) : t.evaluate !== void 0 ? this.scheduleEffectTask(t, i) : t.flags &= ~v;
-        }
-      } 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 n = s.firstDep; n !== null; n = n.nextDep) {
-          const r = n.dep;
-          r.evaluate !== void 0 && !(r.flags & d) && (r.flags |= m, t.push(r));
-        }
-      }
-    }
-  }
-  /**
-   * Завершает очередь после первой ошибки, собирая последующие причины сбоя.
-   * Вызывается только на ошибочном пути; успешный проход не создаёт массив ошибок
-   * и не устанавливает отдельный catch для каждого элемента.
-   */
-  drainQueueAfterError(e, t) {
-    const i = [e];
-    for (; this.effectReadIndex !== this.effectWriteIndex; ) {
-      const s = this.effectReadIndex++, n = this.effectQueue[s];
-      this.effectQueue[s] = void 0;
-      try {
-        const r = t ? n.effectTask : void 0;
-        r !== void 0 && n.evaluate !== void 0 ? this.scheduleEffectTask(n, r) : (n.flags &= ~v, this.executeEffect(n));
-      } 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 |= v, this.scheduleEffectTask(e, t));
-  }
-  // Передаёт уже запланированный эффект его постоянной внешней задаче.
-  scheduleEffectTask(e, t) {
-    try {
-      t.schedule();
-    } catch (i) {
-      throw e.flags &= -72, i;
-    }
-  }
-  /**
-   * Окончательно останавливает эффект и освобождает все принадлежащие ему ресурсы.
-   * Сначала делает узел неактивным и отсоединяет связи, затем отменяет задачу,
-   * останавливает детей, выполняет 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), q(e);
-    let n;
-    e.tailDep = null;
-    try {
-      this.pruneUnreadDependencies(e);
-    } catch (r) {
-      n = [r];
-    }
-    if (e.firstDep = e.tailDep = null, e.depCount = 0, A(e), t !== void 0)
-      try {
-        t.dispose();
-      } catch (r) {
-        n ??= [], n.push(r);
-      }
-    try {
-      this.disposeNestedEffects(e);
-    } catch (r) {
-      n ??= [], n.push(r);
-    }
-    if (s !== void 0)
-      try {
-        this.untracked(s);
-      } catch (r) {
-        n ??= [], n.push(r);
-      }
-    if (i !== void 0)
-      try {
-        this.untracked(i);
-      } catch (r) {
-        n ??= [], n.push(r);
-      }
-    this.invalidationStack.length !== this.invalidationDepth && (this.invalidationStack.length = this.invalidationDepth), this.dependencyStack.length !== this.dependencyDepth && (this.dependencyStack.length = this.dependencyDepth), n !== void 0 && V(n, "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 && V(t, "Nested effect disposal failed.");
-  }
-  /**
-   * Задаёт обязательные поля графа перед первым вычислением.
-   * Вызывается только для нематериализованного handle; getter и контекст сохраняются.
-   */
-  static materializeComputed(e) {
-    e.flags = _ | (e.sourceHooks === void 0 ? 0 : o), e.firstSub = null, e.lastSub = null, e.firstDep = null, e.tailDep = null, e.depCount = 0, e.cachedValue = void 0;
-  }
-  /**
-   * Связывает два разных receiver: движок-владелец и читаемый handle.
-   * Эти четыре общие функции адаптируют this; алгоритмы чтения остаются методами
-   * RaphReactivity. Адаптеры создаются один раз на граф, а не на каждое вычисление.
-   */
-  createHandleReaders() {
-    const e = this;
-    function t() {
-      return e.readComputedValue(this);
-    }
-    return {
-      /**
-       * Материализует computed на месте и заменяет первоначальный get общим reader.
-       */
-      initializeComputed() {
-        const i = this;
-        return N.materializeComputed(i), this.get = t, e.readComputedValue(i);
-      },
-      /**
-       * Материализует raw computed, сохраняя извлечение read после первого вызова.
-       */
-      initializeRaw() {
-        const i = this;
-        N.materializeComputed(i);
-        const s = () => e.readComputedValue(i);
-        return this.read = s, s();
-      },
-      /**
-       * Передаёт 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 n(r) {
-      if (arguments.length !== 0) {
-        const u = s;
-        u !== void 0 ? t.writeSignalValue(u, r) : i !== r && (i = r);
-        return;
-      }
-      const a = s;
-      if (a !== void 0)
-        return t.readSignalValue(a);
-      const l = t.activeSub;
-      return l === null || (s = t.materializeSignal(i, l)), i;
-    }
-    return {
-      read: n,
-      write: n
-    };
-  }
-  /**
-   * Создаёт нематериализованный computed для низкоуровневого read API.
-   * Графовые поля появляются при первом чтении; тип описывает обе стадии.
-   * @internal
-   */
-  _computedAccess(e) {
-    return {
-      evaluate: e,
-      read: this.handleReaders.initializeRaw
-    };
-  }
-  /**
-   * Создаёт signal, жизненным циклом которого управляет `ScopeNode`.
-   *
-   * Реактивная логика совпадает с обычным `signal()`, но disposer
-   * дополнительно отсоединяет материализованный источник от графа.
-   *
-   * @internal
-   */
-  _ownedSignal(e, t) {
-    const i = this;
-    let s = e, n, r = !1;
-    const a = () => {
-      const h = n;
-      if (h !== void 0)
-        return this.readSignalValue(h);
-      const S = this.activeSub;
-      if (S === null)
-        return s;
-      const C = s;
-      return n = this.materializeSignal(
-        C,
-        S,
-        t
-      ), s = void 0, C;
-    }, l = t === void 0 ? (h) => {
-      const S = n;
-      S !== void 0 ? this.writeSignalValue(S, h) : s !== h && (s = h);
-    } : (h) => {
-      const S = n;
-      if (S !== void 0) {
-        const C = S.flags & f ? S.pendingValue : S.cachedValue;
-        C !== h && t.onChange?.(C, h, S.firstSub !== null), this.writeSignalValue(S, h);
-        return;
-      }
-      s !== h && (t.onChange?.(s, h, !1), s = h);
-    }, w = {
-      source: {
-        get: a,
-        peek: this.handleReaders.peek,
-        set: l
-      },
-      /**
-       * Освобождает источник и отсоединяет его от реактивного графа.
-       */
-      dispose() {
-        if (r)
-          return !0;
-        r = !0, s = void 0;
-        let h;
-        try {
-          t?.onDispose?.(n?.firstSub != null);
-        } catch (S) {
-          (h ??= []).push(S);
-        }
-        if (n !== void 0) {
-          try {
-            i.releaseSourceSubs(n);
-          } catch (S) {
-            (h ??= []).push(S);
-          }
-          n.cachedValue = void 0, n.pendingValue = void 0, n.pendingAuthor = void 0, n.flags = 0;
-        }
-        if (n = void 0, h?.length === 1)
-          throw h[0];
-        if (h !== void 0 && h.length > 1)
-          throw new AggregateError(h, "Owned signal disposal failed.");
-        return !0;
-      }
-    };
-    return t !== void 0 && (w.hasSubscribers = () => n?.firstSub != null), w;
-  }
-  /**
-   * Создаёт ленивый computed с финализатором исходящих и входящих связей.
-   * Финализатор работает и до первого вычисления, не материализуя узел ради очистки.
-   * @internal
-   */
-  _ownedComputed(e, t) {
-    const i = this, s = this.createComputedHandle(e, t);
-    let n = !1;
-    const r = {
-      source: s,
-      /**
-       * Отсоединяет принадлежащий источник и освобождает его ссылки.
-       * Повторный вызов возвращает true без повторной очистки.
-       */
-      dispose() {
-        if (n)
-          return !0;
-        n = !0, i.activeSub === s && (i.activeSub = null);
-        const a = [];
-        try {
-          t?.onDispose?.(s.firstSub != null);
-        } catch (u) {
-          a.push(u);
-        }
-        if (s.flags !== void 0)
-          try {
-            i.releaseSourceSubs(s);
-          } catch (u) {
-            a.push(u);
-          }
-        const l = s.flags !== void 0;
-        if (s.evaluate = void 0, s.cachedValue = void 0, s.flags = 0, s.tailDep = null, l)
-          try {
-            i.pruneUnreadDependencies(s);
-          } catch (u) {
-            a.push(u);
-          }
-        if (s.firstDep = s.tailDep = null, s.depCount = 0, A(s), a.length === 1)
-          throw a[0];
-        if (a.length > 1)
-          throw new AggregateError(a, "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;
-  }
-  /**
-   * Показывает, обрабатывает ли экземпляр внутреннюю очередь эффектов.
-   * @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 | g | d), s = this.activeSub;
-    return s !== null && s.flags & d && W(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 |= v), !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects();
-  }
-  /**
-   * Открывает одну доставку эффекта с задачей. Возвращает false для устаревшей
-   * доставки: запись остановлена или запуск больше не запланирован.
-   * @internal
-   */
-  _beginTaskEffectRun(e) {
-    return !(e.flags & v) || e.evaluate === void 0 ? !1 : (e.flags &= ~v, !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 | v, 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 n = s.sub, r = n.sourceHooks?.dependencyOwner ?? n.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: o,
-      firstSub: null,
-      lastSub: null,
-      evaluate: void 0,
-      cachedValue: 0,
-      sourceHooks: e
-    };
-    return t.flags & x ? 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;
+  reactive(c) {
+    return i(this, c, () => this._createReactivePropertySourceBridge());
   }
 }
-let P;
-function y() {
-  return P ??= new N();
+let n;
+function e() {
+  return n ??= new a();
 }
-const K = (c) => y().signal(c), Y = (c) => y().reactive(c);
-function X(c) {
-  return y().computed(c);
+const f = (t) => e().signal(t), p = (t) => e().reactive(t);
+function v(t) {
+  return e().computed(t);
 }
-const $ = (c, e) => y().effect(c, e), j = (c, e, t) => y().watch(c, e, t), Z = (c) => y().batch(c), J = (c) => y().untracked(c), ee = () => y().scope();
+const d = (t, c) => e().effect(t, c), h = (t, c, o) => e().watch(t, c, o), m = (t) => e().batch(t), l = (t) => e().untracked(t), y = () => e().scope();
 export {
-  N as RaphReactivity,
-  U as ScopeNode,
-  Z as batch,
-  X as computed,
-  $ as effect,
-  Y as reactive,
-  ee as scope,
-  K as signal,
-  J as untracked,
-  j as watch
+  a as RaphReactivity,
+  b as ScopeNode,
+  m as batch,
+  v as computed,
+  d as effect,
+  p as reactive,
+  y as scope,
+  f as signal,
+  l as untracked,
+  h as watch
 };