@raphy-js/raph 1.0.0-dev.2

package/dist/debug/reactivity/engine.js

@@ -0,0 +1,1133 @@
+var C = Object.defineProperty;
+var R = (a, e, t) => e in a ? C(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t;
+var p = (a, e, t) => R(a, typeof e != "symbol" ? e + "" : e, t);
+import { appendScopeChild as m, ScopeNode as _, throwScopeErrors as E, detachScopeChild as A } from "./scope.js";
+import { watchWithReactivity as L } from "./watch.js";
+const d = 1, f = 2, S = 4, h = 8, w = 16, o = 32, v = 64, k = 128, x = 256, g = d | f, I = 16;
+function T(a, e) {
+  const t = a.firstSub;
+  if (t === null)
+    return;
+  if (t === a.lastSub)
+    return t.sub === e ? t : void 0;
+  const i = a.subSearchCursor ?? t;
+  if (i.sub === e)
+    return a.subSearchCursor = i.nextSub ?? t, i;
+  let s = i.nextSub ?? t;
+  for (; s !== i; ) {
+    if (s.sub === e)
+      return a.subSearchCursor = s.nextSub ?? t, s;
+    s = s.nextSub ?? t;
+  }
+}
+class y {
+  /**
+   * Выбирает политику исполнения и сохраняет совместимость извлечённых методов.
+   * Тела методов находятся на прототипе; bind() выполняется только при создании
+   * экземпляра, чтобы Runtime и глобальный API могли передавать методы как callbacks.
+   * @param options Необязательная внешняя политика эффектов.
+   */
+  constructor(e = {}) {
+    // Потребитель текущего синхронного чтения; null отключает отслеживание.
+    p(this, "activeSub", null);
+    // Глубина вложенных синхронных границ группировки.
+    p(this, "batchDepth", 0);
+    // Индекс следующего элемента внутренней очереди эффектов.
+    p(this, "effectReadIndex", 0);
+    // Позиция добавления элемента в текущем проходе очереди.
+    p(this, "effectWriteIndex", 0);
+    // Граница активного префикса переиспользуемого стека invalidation.
+    p(this, "invalidationDepth", 0);
+    // Граница активного префикса стека проверки зависимостей.
+    p(this, "dependencyDepth", 0);
+    // Защита внутренней очереди от вложенного повторного прохода.
+    p(this, "flushingEffects", !1);
+    // Переиспользуемый буфер очереди; прочитанная ячейка сразу освобождает ссылку.
+    p(this, "effectQueue", new Array(16).fill(void 0));
+    // Переиспользуемый стек распространения invalidation; исходный способ выделения сохранён.
+    p(this, "invalidationStack", new Array(512).fill(null));
+    // Переиспользуемый стек проверки зависимостей с защитой активного вложенного префикса.
+    p(this, "dependencyStack", []);
+    // Общие адаптеры receiver для handles этого экземпляра.
+    // Создаются один раз, чтобы computed не хранил дополнительную ссылку на движок
+    // и не выделял отдельные get/peek closures на каждый источник.
+    p(this, "handleReaders", this.createHandleReaders());
+    // Выбранная внешняя политика; у синхронного экземпляра отсутствует.
+    p(this, "effectScheduler");
+    // Прямой обработчик очереди, выбранный один раз при создании экземпляра.
+    p(this, "flushEffects");
+    /**
+     * Синхронная регистрация эффекта для Runtime и watch независимо от внешней политики.
+     * Это связанная ссылка на реализацию effect(), а не делегирующая функция.
+     * @internal
+     */
+    p(this, "_effectImmediate");
+    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 l = this.activeSub;
+      return l === null || (i = this.materializeSignal(
+        t,
+        l
+      )), t;
+    }, n = (r) => {
+      const l = i;
+      if (l !== void 0) {
+        this.writeSignalValue(l, r);
+        return;
+      }
+      t !== r && (t = r);
+    };
+    return {
+      get: s,
+      peek: this.handleReaders.peek,
+      set: n
+    };
+  }
+  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 | d | o);
+    t !== void 0 && (i.onStop = t);
+    const s = this.activeSub;
+    s !== null && s.flags & o && m(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 L(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 _(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
+    };
+  }
+  /**
+   * Материализует signal в графе при первом отслеживаемом чтении
+   * и связывает его с активным потребителем.
+   *
+   * До этого момента signal может хранить значение только в замыкании
+   * и вообще не создавать `ReactiveNode`.
+   */
+  materializeSignal(e, t) {
+    const i = this.allocateGraphRecord(
+      e,
+      void 0,
+      0
+    );
+    return t.flags & k ? this.appendInitialDependency(i, t) : this.trackDependency(i, t), i;
+  }
+  /**
+   * Создаёт минимальный handle computed без преждевременного выделения полей графа.
+   * Первый get() материализует запись на этом же объекте и заменяет метод чтения.
+   */
+  createComputedHandle(e) {
+    return {
+      evaluate: e,
+      get: this.handleReaders.initializeComputed,
+      peek: this.handleReaders.peek
+    };
+  }
+  /**
+   * Создаёт эффект с одной постоянной задачей внешнего scheduler.
+   * Первый и последующие запуски проходят через задачу; устаревший runner после stop
+   * ничего не выполняет. При синхронной ошибке runner обрабатывает независимую очередь.
+   * @param fn Тело эффекта.
+   * @param onStop Однократная окончательная очистка.
+   */
+  createScheduledEffect(e, t) {
+    const i = this.allocateGraphRecord(void 0, e, f | d | o);
+    t !== void 0 && (i.onStop = t);
+    const s = this.activeSub;
+    s !== null && s.flags & o && m(s, i);
+    const n = () => {
+      if (!(!(i.flags & v) || i.evaluate === void 0)) {
+        i.flags &= ~v;
+        try {
+          this.executeEffect(i);
+        } catch (r) {
+          if (!this.batchDepth && this.effectReadIndex !== this.effectWriteIndex)
+            try {
+              this.flushEffects();
+            } catch (l) {
+              throw new AggregateError(
+                [r, l],
+                "Effect execution and queue processing failed."
+              );
+            }
+          throw r;
+        }
+        !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects();
+      }
+    };
+    try {
+      i.effectTask = this.effectScheduler.bind(n), this.requestEffectTask(i);
+    } catch (r) {
+      try {
+        this.disposeEffect(i);
+      } catch (l) {
+        throw new AggregateError([r, l], "Effect registration and cleanup failed.");
+      }
+      throw r;
+    }
+    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 l = this.activeSub !== null && this.activeSub.flags & h ? this.activeSub : null;
+        s ? e.pendingAuthor !== l && (e.pendingAuthor = null) : e.pendingAuthor = l;
+      }
+      const r = e.firstSub;
+      r != null && (!s || this.activeSub !== null && this.activeSub.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());
+  }
+  /**
+   * Возвращает кеш либо синхронно актуализирует вычисляемое значение.
+   * Неуспешное вычисление не считается значением. Даже ошибочное чтение сохраняет
+   * связь с активным потребителем, чтобы тот мог восстановиться при изменении источника.
+   */
+  readComputedValue(e) {
+    const t = e.flags, i = t & (w | g | x), s = i === 0 ? e.cachedValue : i & w ? this.evaluateFirstValue(e) : this.refreshComputedValue(e, t), n = this.activeSub;
+    if (n !== null) {
+      const r = n.tailDep;
+      n.flags & k ? (r === null || r.dep !== e) && this.appendInitialDependency(e, n) : this.trackDependency(e, n);
+    }
+    return s;
+  }
+  /**
+   * Выполняет первый сбор зависимостей и кеширует только успешный результат.
+   * При исключении оставляет состояние повторяемой ошибки, а не чистый undefined.
+   * Уже прочитанные зависимости сохраняются для последующего уведомления.
+   */
+  evaluateFirstValue(e) {
+    e.flags = h | k;
+    const t = this.activeSub;
+    this.activeSub = e;
+    try {
+      const i = e.evaluate();
+      return e.cachedValue = i, e.flags = e.flags & S ? f : 0, i;
+    } catch (i) {
+      throw e.flags = x, t !== null && this.trackDependency(e, t), i;
+    } finally {
+      this.activeSub = t;
+    }
+  }
+  /**
+   * Актуализирует computed: выполняет прямой пересчёт либо проверяет зависимости.
+   * После ошибки getter разрешён повторный пересчёт даже без новой записи источника.
+   */
+  refreshComputedValue(e, t) {
+    try {
+      if (t & (f | S | x))
+        return this.recomputeValue(e) || (e.flags &= ~g), e.cachedValue;
+      const i = e.firstDep;
+      return (i === null || !this.refreshDependencies(e, i) || !this.recomputeValue(e)) && (e.flags &= ~g), e.cachedValue;
+    } catch (i) {
+      throw this.activeSub !== null && this.trackDependency(e, this.activeSub), i;
+    }
+  }
+  /**
+   * Фиксирует 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 c = s; c !== null; c = c.nextDep)
+        if (c.dep === e)
+          return this.reorderDependency(t, c, i), t.tailDep = c, c;
+      for (let c = i; c !== null; c = c.prevDep)
+        if (c.dep === e)
+          return c;
+      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 c = r;
+      if (c.dep === e)
+        return this.reorderDependency(t, c, i), t.tailDep = c, c;
+      r = c.nextDep, ++n;
+    }
+    let l = i;
+    for (; l !== null && n < I; ) {
+      const c = l;
+      if (c.dep === e)
+        return c;
+      l = c.prevDep, ++n;
+    }
+    if (r !== null || l !== null) {
+      const c = T(e, t);
+      if (c !== void 0)
+        return this.reorderDependency(t, c, i), t.tailDep = c, c;
+    }
+    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, 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, n;
+  }
+  /**
+   * Переназначает существующую связь другому производителю.
+   * Положение в списке зависимостей потребителя и число его связей сохраняются.
+   */
+  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, 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 обозначает границу прочитанного префикса, а не неизменный конец списка.
+   * Удаление из списков производителей не выполняет пользовательские callbacks.
+   */
+  pruneUnreadDependencies(e) {
+    const t = e.tailDep;
+    let i = t === null ? e.firstDep : t.nextDep;
+    if (i !== null)
+      for (t === null ? e.firstDep = null : t.nextDep = null; i !== null; ) {
+        const s = i.nextDep;
+        this.detachSubLink(i), --e.depCount, i = s;
+      }
+  }
+  /**
+   * Удаляет связь только из списка потребителей производителя.
+   * Список зависимостей потребителя и его счётчик здесь не изменяются.
+   * Также исправляет курсор поиска, если он указывал на удаляемую связь.
+   */
+  detachSubLink(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;
+  }
+  /**
+   * Отсоединяет owned-источник сразу с обеих сторон каждой связи.
+   * Вызывается на границе lifetime, а не при обычных чтениях и записях.
+   * Переводит ожидавших проверку потребителей к повторному вычислению при необходимости.
+   */
+  releaseSourceSubs(e) {
+    let t = e.firstSub;
+    for (; t != null; ) {
+      const i = t.nextSub, s = t.sub;
+      this.detachDependencyLink(t), this.detachSubLink(t);
+      const n = s.flags;
+      (n & (g | h)) === d && (s.flags = n & ~d | f, n & o && this.enqueueEffect(s)), t = i;
+    }
+    e.firstSub = e.lastSub = null, e.subSearchCursor = void 0;
+  }
+  /**
+   * Удаляет связь только из списка зависимостей потребителя.
+   * Исправляет курсор прочитанного префикса и dependencyCount; список производителя
+   * должен быть обновлён отдельной операцией.
+   */
+  detachDependencyLink(e) {
+    const t = e.sub, i = e.prevDep, s = e.nextDep;
+    i === null ? t.firstDep = s : i.nextDep = s, s !== null && (s.prevDep = i), t.tailDep === e && (t.tailDep = i), --t.depCount;
+  }
+  /**
+   * Добавляет эффект во внутреннюю очередь один раз до обработки текущей записи.
+   * Флаг SCHEDULED предотвращает повторное добавление без создания task-объекта.
+   */
+  enqueueEffect(e) {
+    e.flags & v || (e.flags |= v, this.effectQueue[this.effectWriteIndex] = e, ++this.effectWriteIndex);
+  }
+  /**
+   * Распространяет invalidation от непосредственных к транзитивным потребителям.
+   * Сохраняет исходный итеративный обход с переиспользуемым стеком; callbacks
+   * не выполняет. Непосредственное и потенциальное изменения отмечает разными флагами.
+   */
+  propagateInvalidation(e, t = !1) {
+    const i = this.invalidationDepth;
+    let s = i;
+    for (let n = e; n !== null; n = n.nextSub) {
+      const r = n.sub, l = r.flags;
+      let c = 0;
+      l & (g | h) ? l & h && (c = this.invalidateReadDependency(n, r, l)) : (c = l & ~S | (t ? d : f), r.flags = c), c !== 0 && (c & o && !(c & h) ? this.enqueueEffect(r) : r.firstSub !== null && (this.invalidationStack[s++] = r.firstSub));
+    }
+    for (; s !== i; ) {
+      let n = this.invalidationStack[--s];
+      for (; n !== null; ) {
+        const r = n.sub, l = r.flags;
+        let c = 0;
+        if (l & (g | h) ? l & h && (c = this.invalidateReadDependency(n, r, l)) : (c = l & ~S | d, r.flags = c), c !== 0) {
+          if (c & o)
+            this.enqueueEffect(r);
+          else if (r.firstSub !== null) {
+            n.nextSub !== null && (this.invalidationStack[s++] = n.nextSub), n = r.firstSub;
+            continue;
+          }
+        }
+        n = n.nextSub;
+      }
+    }
+    this.invalidationDepth = i;
+  }
+  /**
+   * Помечает работающего потребителя, только если затронута уже прочитанная связь.
+   * Связи за 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 | S | d;
+    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 & ~d | f, r & o && this.enqueueEffect(n));
+    }
+  }
+  /**
+   * Повторно вычисляет узел, согласует зависимости и сравнивает результат с кешем.
+   * При ошибке восстанавливает контекст, удаляет непрочитанный хвост и оставляет
+   * повторяемое состояние ошибки. Также восстанавливает непосредственного потребителя
+   * skipSub: при разворачивании стека его связь могла быть уже извлечена из буфера.
+   * Неверное значение в кеш не записывается.
+   */
+  recomputeValue(e, t = null) {
+    const i = e.evaluate;
+    e.tailDep = null;
+    const s = e.flags & ~S | h;
+    e.flags = s;
+    const n = this.activeSub;
+    this.activeSub = e;
+    let r;
+    try {
+      r = i();
+    } catch (V) {
+      throw this.restoreComputedFailure(e, t), V;
+    } finally {
+      this.activeSub = n;
+    }
+    const l = e.flags & S, c = s & -268, u = e.tailDep;
+    (u === null ? e.firstDep : u.nextDep) !== null && this.pruneUnreadDependencies(e);
+    const D = e.cachedValue;
+    return e.cachedValue = r, e.flags = l ? f : c, D === r ? !1 : (e.firstSub !== null && this.confirmSubUpdates(e.firstSub, t), !0);
+  }
+  /**
+   * Восстанавливает связи и состояния после неудачного getter.
+   * Отдельная функция удерживает обработку исключений вне обычной части пересчёта.
+   * Потребитель исключаемой связи мог уже покинуть активный префикс стека.
+   */
+  restoreComputedFailure(e, t) {
+    e.flags = e.flags & -144 | x, this.pruneUnreadDependencies(e), t !== null && this.restoreFailedDependency(t.sub);
+  }
+  /**
+   * Итеративно проверяет зависимые computed и pending-сигналы перед запуском потребителя.
+   * Использует общий стек с сохранением активного префикса вложенного обхода.
+   * При исключении восстанавливает высоту стека и состояния всех незавершённых
+   * узлов текущего прохода; порядок успешного обхода не меняется.
+   */
+  refreshDependencies(e, t) {
+    const i = this.dependencyDepth;
+    try {
+      return this.walkDependencyChain(e, t);
+    } catch (s) {
+      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;
+    }
+  }
+  /**
+   * Выполняет исходный итеративный обход зависимостей без обработки ошибок внутри цикла.
+   * Перед пользовательским вычислением публикует активную высоту стека; оболочка
+   * refreshDependencies() использует этот префикс для восстановления после сбоя.
+   */
+  walkDependencyChain(e, t) {
+    const i = this.dependencyDepth;
+    let s = i, n = !1;
+    e: for (; ; ) {
+      if (e.flags & f)
+        n = !0;
+      else {
+        const r = t.dep, l = r.flags;
+        if (l & (f | x))
+          this.dependencyDepth = s, n = r.evaluate === void 0 ? this.commitSignalValue(r, t) : this.recomputeValue(r, t);
+        else if (l & d) {
+          if (r.firstDep !== null) {
+            this.dependencyStack[s++] = t, e = r, t = r.firstDep;
+            continue e;
+          }
+          this.dependencyDepth = s, n = this.recomputeValue(r, t);
+        } else
+          n = !1;
+      }
+      if (!n && t.nextDep !== null) {
+        t = t.nextDep;
+        continue;
+      }
+      if (n) {
+        for (; s !== i; ) {
+          this.dependencyDepth = --s;
+          const r = this.dependencyStack[s];
+          if (n = this.recomputeValue(e, r), e = r.sub, !n) {
+            if (r.nextDep !== null) {
+              t = r.nextDep;
+              continue e;
+            }
+            break;
+          }
+        }
+        if (n)
+          return this.dependencyDepth = i, !0;
+      }
+      for (; s !== i; ) {
+        this.dependencyDepth = --s;
+        const r = this.dependencyStack[s];
+        if (e.flags &= ~d, e = r.sub, r.nextDep !== null) {
+          t = r.nextDep;
+          continue e;
+        }
+      }
+      return e.flags &= ~d, this.dependencyDepth = i, !1;
+    }
+  }
+  /**
+   * Восстанавливает незавершённую запись после прерванной проверки зависимостей.
+   * Computed получает повторяемое состояние ошибки, effect остаётся доступным
+   * для следующей invalidation. Вызывается только на ошибочном пути.
+   */
+  restoreFailedDependency(e) {
+    e.flags &= -16, e.flags & o || (e.flags |= x);
+  }
+  /**
+   * Проверяет необходимость запуска, очищает прошлые ресурсы и выполняет тело эффекта.
+   * Ошибка cleanup останавливает эффект до создания ресурсов следующего запуска.
+   * При ошибке тела сохраняет фактически прочитанные зависимости, останавливает
+   * созданных детей и разрешает повторный запуск после следующей записи.
+   * Cleanup, возвращённый после собственного stop, освобождается сразу.
+   */
+  executeEffect(e) {
+    const t = e.flags;
+    if (!(t & g))
+      return;
+    if (!(t & (f | S))) {
+      const u = e.firstDep;
+      try {
+        if (u === null || !this.refreshDependencies(e, u)) {
+          e.flags &= ~g;
+          return;
+        }
+      } catch (D) {
+        throw e.flags &= -80, D;
+      }
+    }
+    const i = e.evaluate;
+    if (i === void 0) {
+      e.flags &= ~g;
+      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 &= ~S, n !== void 0)
+      try {
+        this.untracked(n);
+      } catch (u) {
+        s ?? (s = []), s.push(u);
+      }
+    if (s !== void 0) {
+      try {
+        this.disposeEffect(e);
+      } catch (u) {
+        s.push(u);
+      }
+      E(s, "Effect cleanup failed.");
+    }
+    if (e.evaluate === void 0)
+      return;
+    e.tailDep = null, e.flags = e.flags & ~S | h;
+    const r = this.activeSub;
+    this.activeSub = e;
+    let l;
+    try {
+      l = i();
+    } catch (u) {
+      this.activeSub = r, e.flags &= ~h, this.failEffectRun(e, u, s);
+    } finally {
+      this.activeSub = r, e.flags &= ~h;
+    }
+    const c = e.tailDep;
+    if ((c === null ? e.firstDep : c.nextDep) !== null && this.pruneUnreadDependencies(e), typeof l == "function")
+      if (e.evaluate === void 0)
+        try {
+          this.untracked(l);
+        } catch (u) {
+          s ?? (s = []), s.push(u);
+        }
+      else
+        e.cachedValue = l;
+    e.flags & v ? e.flags = e.flags & -7 | d : 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 & (o | h)) === (o | h))) {
+      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 & (o | h)) === (o | h))) {
+      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, t.effectTask === void 0 ? this.executeEffect(t) : this.requestEffectTask(t);
+        }
+      } catch (e) {
+        this.drainQueueAfterError(e, !0);
+      } finally {
+        this.effectReadIndex = 0, this.effectWriteIndex = 0, this.flushingEffects = !1;
+      }
+    }
+  }
+  /**
+   * Завершает очередь после первой ошибки, собирая последующие причины сбоя.
+   * Вызывается только на ошибочном пути; успешный проход не создаёт массив ошибок
+   * и не устанавливает отдельный 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, n.flags &= ~v;
+      try {
+        t && n.effectTask !== void 0 ? this.requestEffectTask(n) : 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;
+    if (!(t === void 0 || e.evaluate === void 0)) {
+      e.flags |= v;
+      try {
+        t.schedule();
+      } catch (i) {
+        throw e.flags &= -72, i;
+      }
+    }
+  }
+  /**
+   * Окончательно останавливает эффект и освобождает все принадлежащие ему ресурсы.
+   * Сначала делает узел неактивным и отсоединяет связи, затем отменяет задачу,
+   * останавливает детей, выполняет cleanup и onStop. Каждая стадия завершается
+   * несмотря на ошибки соседних стадий; повторный или вложенный stop безопасен.
+   */
+  disposeEffect(e) {
+    if (e.evaluate === void 0)
+      return;
+    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), A(e);
+    let n = e.firstDep;
+    for (; n !== null; ) {
+      const l = n.nextDep;
+      this.detachSubLink(n), n = l;
+    }
+    e.firstDep = e.tailDep = null, e.depCount = 0;
+    let r;
+    if (t !== void 0)
+      try {
+        t.dispose();
+      } catch (l) {
+        r = [l];
+      }
+    try {
+      this.disposeNestedEffects(e);
+    } catch (l) {
+      r ?? (r = []), r.push(l);
+    }
+    if (s !== void 0)
+      try {
+        this.untracked(s);
+      } catch (l) {
+        r ?? (r = []), r.push(l);
+      }
+    if (i !== void 0)
+      try {
+        this.untracked(i);
+      } catch (l) {
+        r ?? (r = []), r.push(l);
+      }
+    this.invalidationStack.length = this.invalidationDepth, this.dependencyStack.length = this.dependencyDepth, r !== void 0 && E(r, "Effect disposal failed.");
+  }
+  /**
+   * Останавливает все вложенные эффекты в обратном порядке регистрации.
+   * Всегда берёт актуальный хвост: cleanup может удалить другого ребёнка.
+   * Передаёт собранные ошибки только после освобождения всех детей.
+   */
+  disposeNestedEffects(e) {
+    let t;
+    for (; e.scopeLastChild !== void 0; )
+      try {
+        this.disposeEffect(e.scopeLastChild);
+      } catch (i) {
+        t ?? (t = []), t.push(i);
+      }
+    t !== void 0 && E(t, "Nested effect disposal failed.");
+  }
+  /**
+   * Задаёт обязательные поля графа перед первым вычислением.
+   * Вызывается только для нематериализованного handle; getter и контекст сохраняются.
+   */
+  static materializeComputed(e) {
+    e.flags = w, 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 y.materializeComputed(i), this.get = t, e.readComputedValue(i);
+      },
+      /**
+       * Материализует raw computed, сохраняя извлечение read после первого вызова.
+       */
+      initializeRaw() {
+        const i = this;
+        y.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 l = s;
+      if (l !== void 0)
+        return t.readSignalValue(l);
+      const c = t.activeSub;
+      return c === null || (s = t.materializeSignal(i, c)), 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) {
+    const t = this;
+    let i = e, s, n = !1;
+    const r = () => {
+      const u = s;
+      if (u !== void 0)
+        return this.readSignalValue(u);
+      const D = this.activeSub;
+      return D === null || (s = this.materializeSignal(
+        i,
+        D
+      )), i;
+    }, l = (u) => {
+      const D = s;
+      if (D !== void 0) {
+        this.writeSignalValue(D, u);
+        return;
+      }
+      i !== u && (i = u);
+    };
+    return {
+      source: {
+        get: r,
+        peek: this.handleReaders.peek,
+        set: l
+      },
+      /**
+       * Освобождает источник и отсоединяет его от реактивного графа.
+       */
+      dispose() {
+        return n || (n = !0, i = void 0, s !== void 0 && (t.releaseSourceSubs(s), s.cachedValue = void 0, s.pendingValue = void 0, s.pendingAuthor = void 0, s.flags = 0), s = void 0), !0;
+      }
+    };
+  }
+  /**
+   * Создаёт ленивый computed с финализатором исходящих и входящих связей.
+   * Финализатор работает и до первого вычисления, не материализуя узел ради очистки.
+   * @internal
+   */
+  _ownedComputed(e) {
+    const t = this, i = this.createComputedHandle(e);
+    let s = !1;
+    return {
+      source: i,
+      /**
+       * Отсоединяет принадлежащий источник и освобождает его ссылки.
+       * Повторный вызов возвращает true без повторной очистки.
+       */
+      dispose() {
+        if (s)
+          return !0;
+        s = !0, i.flags !== void 0 && t.releaseSourceSubs(i);
+        let n = i.firstDep;
+        for (; n != null; ) {
+          const r = n.nextDep;
+          t.detachSubLink(n), n = r;
+        }
+        return i.firstDep = i.tailDep = null, i.depCount = 0, i.evaluate = void 0, i.cachedValue = void 0, i.flags = 0, !0;
+      }
+    };
+  }
+  /**
+   * Открывает вложенную синхронную границу группировки.
+   * Внутренний вызывающий код обязан выполнить соответствующий 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;
+  }
+}
+let N;
+function b() {
+  return N ?? (N = new y());
+}
+const Q = (a) => b().signal(a);
+function q(a) {
+  return b().computed(a);
+}
+const z = (a, e) => b().effect(a, e), H = (a, e, t) => b().watch(a, e, t), B = (a) => b().batch(a), G = (a) => b().untracked(a), P = () => b().scope();
+export {
+  y as RaphReactivity,
+  _ as ScopeNode,
+  B as batch,
+  q as computed,
+  z as effect,
+  P as scope,
+  Q as signal,
+  G as untracked,
+  H as watch
+};