@raphy-js/raph 1.0.0-dev.18

package/dist/debug/reactivity/engine.js

@@ -0,0 +1,1305 @@
+var P = Object.defineProperty;
+var B = (c, e, t) => e in c ? P(c, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : c[e] = t;
+var D = (c, e, t) => B(c, typeof e != "symbol" ? e + "" : e, t);
+import { reactiveObject as G } from "./reactive-object.js";
+import { appendScopeChild as z, ScopeNode as M, throwScopeErrors as F, detachScopeChild as K } from "./scope.js";
+import { watchWithReactivity as Y } from "./watch.js";
+const w = 1, d = 2, C = 4, S = 8, T = 16, y = 32, x = 64, W = 128, m = 256, v = 512, E = w | d, R = 16, X = 2;
+function N(c) {
+  c.dependencyLookupDebt === void 0 && c.dependencyIndex === void 0 || (c.dependencyIndex = void 0, c.dependencyLookupDebt = void 0, c.dependencyLookupSearches = void 0);
+}
+function q(c, e) {
+  if (e <= R || c.flags & W || c.dependencyIndex !== void 0)
+    return;
+  const t = (c.dependencyLookupSearches ?? 0) + 1, i = (c.dependencyLookupDebt ?? 0) + e;
+  if (c.dependencyLookupSearches = t, c.dependencyLookupDebt = i, t < X || 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 j(c, e, t) {
+  var l;
+  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 r = (l = e.dependencyIndex) == null ? void 0 : l.get(c);
+    if (r !== void 0)
+      return c.subSearchCursor = r.nextSub ?? i, r;
+    if (e.dependencyIndex !== void 0)
+      return;
+  }
+  let a = s.nextSub ?? i;
+  for (; a !== s; ) {
+    if (++n, a.sub === e)
+      return c.subSearchCursor = a.nextSub ?? i, t && q(e, n), a;
+    a = a.nextSub ?? i;
+  }
+  t && q(e, n);
+}
+class U {
+  /**
+   * Выбирает политику исполнения и сохраняет совместимость извлечённых методов.
+   * Тела методов находятся на прототипе; bind() выполняется только при создании
+   * экземпляра, чтобы Runtime и глобальный API могли передавать методы как callbacks.
+   * @param options Необязательная внешняя политика эффектов.
+   */
+  constructor(e = {}) {
+    // Opt-in стратегия длинного slow path; не добавляет policy field каждой ноде.
+    D(this, "adaptiveDependencyIndex");
+    // Потребитель текущего синхронного чтения; null отключает отслеживание.
+    D(this, "activeSub", null);
+    // Глубина вложенных синхронных границ группировки.
+    D(this, "batchDepth", 0);
+    // Индекс следующего элемента внутренней очереди эффектов.
+    D(this, "effectReadIndex", 0);
+    // Позиция добавления элемента в текущем проходе очереди.
+    D(this, "effectWriteIndex", 0);
+    // Граница активного префикса переиспользуемого стека invalidation.
+    D(this, "invalidationDepth", 0);
+    // Граница активного префикса стека проверки зависимостей.
+    D(this, "dependencyDepth", 0);
+    // Защита внутренней очереди от вложенного повторного прохода.
+    D(this, "flushingEffects", !1);
+    // Переиспользуемый буфер очереди; прочитанная ячейка сразу освобождает ссылку.
+    D(this, "effectQueue", new Array(16).fill(void 0));
+    // Переиспользуемый стек распространения invalidation; исходный способ выделения сохранён.
+    D(this, "invalidationStack", new Array(512).fill(null));
+    // Переиспользуемый стек проверки зависимостей с защитой активного вложенного префикса.
+    D(this, "dependencyStack", []);
+    // Общие адаптеры receiver для handles этого экземпляра.
+    // Создаются один раз, чтобы computed не хранил дополнительную ссылку на движок
+    // и не выделял отдельные get/peek closures на каждый источник.
+    D(this, "handleReaders", this.createHandleReaders());
+    // Выбранная внешняя политика; у синхронного экземпляра отсутствует.
+    D(this, "effectScheduler");
+    // Прямой обработчик очереди, выбранный один раз при создании экземпляра.
+    D(this, "flushEffects");
+    /**
+     * Синхронная регистрация эффекта для Runtime и watch независимо от внешней политики.
+     * Это связанная ссылка на реализацию effect(), а не делегирующая функция.
+     * @internal
+     */
+    D(this, "_effectImmediate");
+    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 a = i;
+      if (a !== void 0)
+        return this.readSignalValue(a);
+      const l = this.activeSub;
+      return l === null || (i = this.materializeSignal(
+        t,
+        l
+      )), t;
+    }, n = (a) => {
+      const l = i;
+      if (l !== void 0) {
+        this.writeSignalValue(l, a);
+        return;
+      }
+      t !== a && (t = a);
+    };
+    return {
+      get: s,
+      peek: this.handleReaders.peek,
+      set: n
+    };
+  }
+  /**
+   * Возвращает стабильный глубокий Proxy для plain object или array.
+   * Object context и per-property sources создаются лениво внутри этого engine.
+   */
+  reactive(e) {
+    return G(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, d | w | y);
+    t !== void 0 && (i.onStop = t);
+    const s = this.activeSub;
+    s !== null && s.flags & y && z(s, i);
+    try {
+      this.executeEffect(i);
+    } catch (n) {
+      try {
+        this.disposeEffect(i);
+      } catch (a) {
+        throw new AggregateError([n, a], "Effect registration and cleanup failed.");
+      }
+      throw n;
+    }
+    return this.effectReadIndex !== this.effectWriteIndex && this.flushEffects(), () => this.disposeEffect(i);
+  }
+  /**
+   * Наблюдает за источниками; callback и cleanup не создают зависимостей.
+   */
+  watch(e, t, i) {
+    return Y(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 M(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 |= v), t.flags & W ? 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, d | w | y);
+    let s = !1;
+    t !== void 0 && (i.onStop = t);
+    const n = this.activeSub;
+    n !== null && n.flags & y && z(n, i);
+    const a = () => {
+      if (!(!(i.flags & x) || i.evaluate === void 0)) {
+        i.flags &= ~x, s = !0;
+        try {
+          this.executeEffect(i);
+        } catch (l) {
+          if (!this.batchDepth && this.effectReadIndex !== this.effectWriteIndex)
+            try {
+              this.flushEffects();
+            } catch (r) {
+              throw new AggregateError(
+                [l, r],
+                "Effect execution and queue processing failed."
+              );
+            }
+          throw l;
+        }
+        !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects();
+      }
+    };
+    try {
+      const l = this.effectScheduler.bind(a);
+      l.cancelPending = () => i.evaluate === void 0 || !s ? !1 : (this.settleCancelledDependencies(i), i.flags &= ~(x | E | C), !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects(), !0), l.rearmPending = () => {
+        i.evaluate !== void 0 && (i.flags |= d | x, l.schedule());
+      }, i.effectTask = l, this.requestEffectTask(i);
+    } catch (l) {
+      try {
+        this.disposeEffect(i);
+      } catch (r) {
+        throw new AggregateError([l, r], "Effect registration and cleanup failed.");
+      }
+      throw l;
+    }
+    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 & d && this.commitSignalValue(e, i), e.cachedValue;
+  }
+  /**
+   * Записывает новое значение или откладывает его фиксацию до чтения в batch.
+   * Сохраняет исходное сравнение через === и учёт автора pending-записи.
+   * Без batch и внешней политики очередь эффектов завершается до возврата из set().
+   */
+  writeSignalValue(e, t) {
+    if (e.flags & d || this.batchDepth) {
+      const s = !!(e.flags & d);
+      if ((e.flags & d ? e.pendingValue : e.cachedValue) === t)
+        return;
+      if (e.pendingValue = t, e.cachedValue === t)
+        e.flags &= ~d, e.pendingAuthor = void 0;
+      else {
+        e.flags |= d;
+        const l = this.activeSub !== null && this.activeSub.flags & S ? this.activeSub : null;
+        s ? e.pendingAuthor !== l && (e.pendingAuthor = null) : e.pendingAuthor = l;
+      }
+      const a = e.firstSub;
+      a != null && (!s || this.activeSub !== null && this.activeSub.flags & S || e.flags & v) && this.propagateInvalidation(a, !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 & (T | E | m), s = i === 0 ? e.cachedValue : i & T ? this.evaluateFirstValue(e) : this.refreshComputedValue(e, t);
+    if (e.evaluate === void 0)
+      return s;
+    const n = this.activeSub;
+    if (n !== null) {
+      const a = n.tailDep;
+      n.flags & W ? (a === null || a.dep !== e) && this.appendInitialDependency(e, n) : this.trackDependency(e, n);
+    }
+    return s;
+  }
+  /**
+   * Выполняет первый сбор зависимостей и кеширует только успешный результат.
+   * При исключении оставляет состояние повторяемой ошибки, а не чистый undefined.
+   * Уже прочитанные зависимости сохраняются для последующего уведомления.
+   */
+  evaluateFirstValue(e) {
+    const t = e.flags & v, i = e.evaluate;
+    e.flags = t | S | W;
+    const s = this.activeSub;
+    this.activeSub = e;
+    try {
+      const n = i();
+      return e.evaluate !== i ? (e.cachedValue = void 0, e.flags = 0, n) : (e.cachedValue = n, e.flags = t | (e.flags & C ? d : 0), n);
+    } catch (n) {
+      throw e.evaluate !== i ? (e.cachedValue = void 0, e.flags = 0, n) : (e.flags = t | m, s !== null && this.trackDependency(e, s), n);
+    } finally {
+      this.activeSub = s;
+    }
+  }
+  /**
+   * Актуализирует computed: выполняет прямой пересчёт либо проверяет зависимости.
+   * После ошибки getter разрешён повторный пересчёт даже без новой записи источника.
+   */
+  refreshComputedValue(e, t, i = null) {
+    try {
+      if (t & (d | C | m))
+        return this.recomputeValue(e, i) || (e.flags &= ~E), e.cachedValue;
+      const s = e.firstDep;
+      return (s === null || !this.refreshDependencies(e, s) || !this.recomputeValue(e, i)) && (e.flags &= ~E), 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 &= ~d;
+    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 <= R) {
+      for (let r = s; r !== null; r = r.nextDep)
+        if (r.dep === e)
+          return this.reorderDependency(t, r, i), t.tailDep = r, r;
+      for (let r = i; r !== null; r = r.prevDep)
+        if (r.dep === e)
+          return r;
+      return s !== null ? (t.tailDep = this.reuseDepLink(s, e), s) : t.tailDep = this.insertDependency(e, t, i);
+    }
+    let n = 0, a = s;
+    for (; a !== null && n < R; ) {
+      const r = a;
+      if (r.dep === e)
+        return this.reorderDependency(t, r, i), t.tailDep = r, r;
+      a = r.nextDep, ++n;
+    }
+    let l = i;
+    for (; l !== null && n < R; ) {
+      const r = l;
+      if (r.dep === e)
+        return r;
+      l = r.prevDep, ++n;
+    }
+    if (a !== null || l !== null) {
+      const r = j(e, t, this.adaptiveDependencyIndex);
+      if (r !== void 0)
+        return this.reorderDependency(t, r, i), t.tailDep = r, r;
+    }
+    return s !== null ? (t.tailDep = this.reuseDepLink(s, e), s) : t.tailDep = this.insertDependency(e, t, i);
+  }
+  /**
+   * Добавляет связь при первоначальном сборе зависимостей.
+   * Предусловие: after является хвостом собранного префикса нового списка.
+   * Связь одновременно включается в список потребителей производителя.
+   */
+  appendInitialDependency(e, t) {
+    var a;
+    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, (a = t.dependencyIndex) == null || a.set(e, n), e.flags & v && this.attachDependencyCleanup(n), n;
+  }
+  /**
+   * Вставляет связь после заданного курсора зависимостей потребителя.
+   * Сохраняет ещё не прочитанный хвост списка и увеличивает dependencyCount.
+   */
+  insertDependency(e, t, i) {
+    var l;
+    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 a = i === null ? t.firstDep : i.nextDep;
+    return n.nextDep = a, a !== null && (a.prevDep = n), i === null ? t.firstDep = n : i.nextDep = n, ++t.depCount, (l = t.dependencyIndex) == null || l.set(e, n), e.flags & v && 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 == null || i.set(t, e), t.flags & v && 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 a = i === null ? e.firstDep : i.nextDep;
+    t.prevDep = i, t.nextDep = a, a !== null && (a.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;
+      }
+      e.depCount <= R && N(e);
+    }
+  }
+  /**
+   * Удаляет связь только из списка потребителей производителя.
+   * Список зависимостей потребителя и его счётчик здесь не изменяются.
+   * Также исправляет курсор поиска, если он указывал на удаляемую связь.
+   */
+  detachSubLink(e) {
+    var t;
+    if ((t = e.sub.dependencyIndex) == null || t.delete(e.dep), e.dep.flags & v) {
+      const i = e.dependencyCleanup;
+      e.dependencyCleanup = void 0, i == null || i();
+    }
+    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) {
+    var n, a;
+    const t = e.dep.sourceHooks, i = t == null ? void 0 : t.onDependency;
+    if (i === void 0)
+      return;
+    const s = ((n = e.sub.sourceHooks) == null ? void 0 : n.dependencyOwner) ?? ((a = e.sub.effectTask) == null ? void 0 : a.dependencyOwner);
+    s !== void 0 && (e.dependencyCleanup = i(s));
+  }
+  /**
+   * Отсоединяет owned-источник сразу с обеих сторон каждой связи.
+   * Вызывается на границе lifetime, а не при обычных чтениях и записях.
+   * Переводит ожидавших проверку потребителей к повторному вычислению при необходимости.
+   */
+  releaseSourceSubs(e) {
+    if (!(e.flags & v)) {
+      let i = e.firstSub;
+      for (; i != null; ) {
+        const s = i.nextSub, n = i.sub;
+        this.detachDependencyLink(i), this.detachSubLink(i);
+        const a = n.flags;
+        (a & (E | S)) === w && (n.flags = a & ~w | d, a & y && this.enqueueEffect(n, e)), i = s;
+      }
+      e.firstSub = e.lastSub = null, e.subSearchCursor = void 0;
+      return;
+    }
+    let t = e.firstSub;
+    for (; t != null; ) {
+      const i = t.nextSub;
+      this.detachDependencyLink(t), this.detachSubLink(t), 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, t.depCount <= R && N(t);
+  }
+  /**
+   * Добавляет эффект во внутреннюю очередь один раз до обработки текущей записи.
+   * Флаг SCHEDULED предотвращает повторное добавление без создания task-объекта.
+   */
+  enqueueEffect(e, t) {
+    var s, n;
+    const i = t !== void 0 && t.flags & v ? t.sourceHooks.token : void 0;
+    i !== void 0 && ((n = (s = e.effectTask) == null ? void 0 : s.notify) == null || n.call(s, i)), !(e.flags & x) && (e.flags |= x, this.effectQueue[this.effectWriteIndex] = e, ++this.effectWriteIndex);
+  }
+  /**
+   * Распространяет invalidation от непосредственных к транзитивным потребителям.
+   * Сохраняет исходный итеративный обход с переиспользуемым стеком; callbacks
+   * не выполняет. Непосредственное и потенциальное изменения отмечает разными флагами.
+   */
+  propagateInvalidation(e, t = !1) {
+    var n, a, l, r, h, b, u, o, I, _, A, O, Q;
+    const i = this.invalidationDepth;
+    let s = i;
+    for (let p = e; p !== null; p = p.nextSub) {
+      const f = p.sub, g = f.flags;
+      let k = 0;
+      if (g & (E | S) ? g & S && (k = this.invalidateReadDependency(p, f, g)) : (k = g & ~C | (t ? w : d), f.flags = k), k === 0) {
+        if (g & y && g & x) {
+          const L = p.dep.flags & v ? p.dep.sourceHooks.token : void 0;
+          L !== void 0 && ((a = (n = f.effectTask) == null ? void 0 : n.notify) == null || a.call(n, L));
+        } else f.flags & v && ((r = (l = f.sourceHooks).onInvalidate) == null || r.call(l, f.firstSub !== null), f.firstSub !== null && (this.invalidationStack[s++] = f.firstSub));
+        continue;
+      }
+      k & y ? (!(k & S) || ((h = f.effectTask) == null ? void 0 : h.allowScheduleDuringRun) === !0) && this.enqueueEffect(f, p.dep) : (!(g & E) && f.flags & v && ((u = (b = f.sourceHooks).onInvalidate) == null || u.call(b, f.firstSub !== null)), f.firstSub !== null && (this.invalidationStack[s++] = f.firstSub));
+    }
+    for (; s !== i; ) {
+      let p = this.invalidationStack[--s];
+      do {
+        const f = p.sub, g = f.flags;
+        let k = 0;
+        if (g & (E | S) ? g & S && (k = this.invalidateReadDependency(p, f, g)) : (k = g & ~C | w, f.flags = k), k === 0) {
+          if (g & y && g & x) {
+            const L = p.dep.flags & v ? p.dep.sourceHooks.token : void 0;
+            L !== void 0 && ((I = (o = f.effectTask) == null ? void 0 : o.notify) == null || I.call(o, L));
+          } else if (f.flags & v && ((A = (_ = f.sourceHooks).onInvalidate) == null || A.call(_, f.firstSub !== null), f.firstSub !== null)) {
+            p.nextSub !== null && (this.invalidationStack[s++] = p.nextSub), p = f.firstSub;
+            continue;
+          }
+        } else if (k & y)
+          this.enqueueEffect(f, p.dep);
+        else if (!(g & E) && f.flags & v && ((Q = (O = f.sourceHooks).onInvalidate) == null || Q.call(O, f.firstSub !== null)), f.firstSub !== null) {
+          p.nextSub !== null && (this.invalidationStack[s++] = p.nextSub), p = f.firstSub;
+          continue;
+        }
+        p = p.nextSub;
+      } while (p !== null);
+    }
+    this.invalidationDepth = i;
+  }
+  /**
+   * Помечает работающего потребителя, только если затронута уже прочитанная связь.
+   * Связи за trackedTail принадлежат прошлому запуску и не означают повторную invalidation.
+   * @returns Новое состояние либо ноль, если уведомление не требуется.
+   */
+  invalidateReadDependency(e, t, i) {
+    const s = t.tailDep;
+    if (s === null)
+      return 0;
+    if (e !== s) {
+      for (let a = e.prevDep; a !== null; a = a.prevDep)
+        if (a === s)
+          return 0;
+    }
+    const n = i | C | w;
+    return t.flags = n, n;
+  }
+  /**
+   * Подтверждает необходимость пересчёта непосредственных потребителей.
+   * Применяется после фиксации реально изменившегося значения; позволяет исключить
+   * текущую связь и автора записи.
+   */
+  confirmSubUpdates(e, t, i = null) {
+    var s, n;
+    for (let a = e; a !== null; a = a.nextSub) {
+      if (a === t || a.sub === i)
+        continue;
+      const l = a.sub, r = l.flags;
+      r & d || (l.flags = r & ~w | d, r & y ? this.enqueueEffect(l, a.dep) : r & E || l.flags & v && ((n = (s = l.sourceHooks).onInvalidate) == null || n.call(s, l.firstSub !== null)));
+    }
+  }
+  /**
+   * Повторно вычисляет узел, согласует зависимости и сравнивает результат с кешем.
+   * При ошибке восстанавливает контекст, удаляет непрочитанный хвост и оставляет
+   * повторяемое состояние ошибки. Также восстанавливает непосредственного потребителя
+   * skipSub: при разворачивании стека его связь могла быть уже извлечена из буфера.
+   * Неверное значение в кеш не записывается.
+   */
+  recomputeValue(e, t = null) {
+    const i = e.evaluate;
+    e.tailDep = null;
+    const s = e.flags & ~C | S;
+    e.flags = s;
+    const n = this.activeSub;
+    this.activeSub = e;
+    let a;
+    try {
+      a = i();
+    } catch (u) {
+      throw e.evaluate !== i ? (e.cachedValue = void 0, e.flags = 0, u) : (this.restoreComputedFailure(e, t), u);
+    } finally {
+      this.activeSub = n;
+    }
+    if (e.evaluate !== i)
+      return e.cachedValue = void 0, e.flags = 0, !1;
+    const l = e.flags & C, r = s & -268, h = e.tailDep;
+    (h === null ? e.firstDep : h.nextDep) !== null && this.pruneUnreadDependencies(e);
+    const b = e.cachedValue;
+    return e.cachedValue = a, e.flags = s & v | (l ? d : r), b === a ? !1 : (e.firstSub !== null && this.confirmSubUpdates(e.firstSub, t), !0);
+  }
+  /**
+   * Восстанавливает связи и состояния после неудачного getter.
+   * Отдельная функция удерживает обработку исключений вне обычной части пересчёта.
+   * Потребитель исключаемой связи мог уже покинуть активный префикс стека.
+   */
+  restoreComputedFailure(e, t) {
+    e.flags = e.flags & -144 | m, 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;
+    }
+  }
+  /** 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 & (T | E | m) && (i.evaluate === void 0 ? s & d && this.commitSignalValue(i, t) : this.refreshComputedValue(i, s, t));
+    }
+  }
+  /**
+   * Выполняет исходный итеративный обход зависимостей без обработки ошибок внутри цикла.
+   * Перед пользовательским вычислением публикует активную высоту стека; оболочка
+   * refreshDependencies() использует этот префикс для восстановления после сбоя.
+   */
+  walkDependencyChain(e, t) {
+    const i = this.dependencyDepth;
+    let s = i, n = !1;
+    e: for (; ; ) {
+      if (e.flags & d)
+        n = !0;
+      else {
+        const a = t.dep, l = a.flags;
+        if (l & (d | m))
+          this.dependencyDepth = s, n = a.evaluate === void 0 ? this.commitSignalValue(a, t) : this.recomputeValue(a, t);
+        else if (l & w) {
+          if (a.firstDep !== null) {
+            this.dependencyStack[s++] = t, e = a, 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 (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; ) {
+        this.dependencyDepth = --s;
+        const a = this.dependencyStack[s];
+        if (e.flags &= ~w, e = a.sub, a.nextDep !== null) {
+          t = a.nextDep;
+          continue e;
+        }
+      }
+      return e.flags &= ~w, this.dependencyDepth = i, !1;
+    }
+  }
+  /**
+   * Восстанавливает незавершённую запись после прерванной проверки зависимостей.
+   * Computed получает повторяемое состояние ошибки, effect остаётся доступным
+   * для следующей invalidation. Вызывается только на ошибочном пути.
+   */
+  restoreFailedDependency(e) {
+    e.flags &= -16, e.flags & y || (e.flags |= m);
+  }
+  /**
+   * Проверяет необходимость запуска, очищает прошлые ресурсы и выполняет тело эффекта.
+   * Ошибка cleanup останавливает эффект до создания ресурсов следующего запуска.
+   * При ошибке тела сохраняет фактически прочитанные зависимости, останавливает
+   * созданных детей и разрешает повторный запуск после следующей записи.
+   * Cleanup, возвращённый после собственного stop, освобождается сразу.
+   */
+  executeEffect(e) {
+    const t = e.flags;
+    if (!(t & E))
+      return;
+    if (!(t & (d | C))) {
+      const h = e.firstDep;
+      try {
+        if (h === null || !this.refreshDependencies(e, h)) {
+          e.flags &= ~E;
+          return;
+        }
+      } catch (b) {
+        throw e.flags &= -80, b;
+      }
+    }
+    const i = e.evaluate;
+    if (i === void 0) {
+      e.flags &= ~E;
+      return;
+    }
+    let s;
+    if (e.scopeLastChild !== void 0)
+      try {
+        this.disposeNestedEffects(e);
+      } catch (h) {
+        s = [h];
+      }
+    const n = typeof e.cachedValue == "function" ? e.cachedValue : void 0;
+    if (e.cachedValue = void 0, e.flags &= ~C, n !== void 0)
+      try {
+        this.untracked(n);
+      } catch (h) {
+        s ?? (s = []), s.push(h);
+      }
+    if (s !== void 0) {
+      try {
+        this.disposeEffect(e);
+      } catch (h) {
+        s.push(h);
+      }
+      F(s, "Effect cleanup failed.");
+    }
+    if (e.evaluate === void 0)
+      return;
+    e.tailDep = null, e.flags = e.flags & ~C | S;
+    const a = this.activeSub;
+    this.activeSub = e;
+    let l;
+    try {
+      l = i();
+    } catch (h) {
+      this.activeSub = a, e.flags &= ~S, this.failEffectRun(e, h, s);
+    } finally {
+      this.activeSub = a, e.flags &= ~S;
+    }
+    const r = e.tailDep;
+    if ((r === null ? e.firstDep : r.nextDep) !== null && this.pruneUnreadDependencies(e), typeof l == "function")
+      if (e.evaluate === void 0)
+        try {
+          this.untracked(l);
+        } catch (h) {
+          s ?? (s = []), s.push(h);
+        }
+      else
+        e.cachedValue = l;
+    e.flags & x ? e.flags = e.flags & -7 | w : 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 & (y | S)) === (y | S))) {
+      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 &= ~x, 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 & (y | S)) === (y | S))) {
+      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 &= ~x, this.executeEffect(t)) : t.evaluate !== void 0 ? this.scheduleEffectTask(t, i) : t.flags &= ~x;
+        }
+      } 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;
+      try {
+        const a = t ? n.effectTask : void 0;
+        a !== void 0 && n.evaluate !== void 0 ? this.scheduleEffectTask(n, a) : (n.flags &= ~x, this.executeEffect(n));
+      } catch (a) {
+        i.push(a);
+      }
+    }
+    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 |= x, 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), K(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, N(e);
+    let a;
+    if (t !== void 0)
+      try {
+        t.dispose();
+      } catch (l) {
+        a = [l];
+      }
+    try {
+      this.disposeNestedEffects(e);
+    } catch (l) {
+      a ?? (a = []), a.push(l);
+    }
+    if (s !== void 0)
+      try {
+        this.untracked(s);
+      } catch (l) {
+        a ?? (a = []), a.push(l);
+      }
+    if (i !== void 0)
+      try {
+        this.untracked(i);
+      } catch (l) {
+        a ?? (a = []), a.push(l);
+      }
+    this.invalidationStack.length = this.invalidationDepth, this.dependencyStack.length = this.dependencyDepth, a !== void 0 && F(a, "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 && F(t, "Nested effect disposal failed.");
+  }
+  /**
+   * Задаёт обязательные поля графа перед первым вычислением.
+   * Вызывается только для нематериализованного handle; getter и контекст сохраняются.
+   */
+  static materializeComputed(e) {
+    e.flags = T | (e.sourceHooks === void 0 ? 0 : v), 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 U.materializeComputed(i), this.get = t, e.readComputedValue(i);
+      },
+      /**
+       * Материализует raw computed, сохраняя извлечение read после первого вызова.
+       */
+      initializeRaw() {
+        const i = this;
+        U.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(a) {
+      if (arguments.length !== 0) {
+        const h = s;
+        h !== void 0 ? t.writeSignalValue(h, a) : i !== a && (i = a);
+        return;
+      }
+      const l = s;
+      if (l !== void 0)
+        return t.readSignalValue(l);
+      const r = t.activeSub;
+      return r === null || (s = t.materializeSignal(i, r)), 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, a = !1;
+    const l = () => {
+      const u = n;
+      if (u !== void 0)
+        return this.readSignalValue(u);
+      const o = this.activeSub;
+      if (o === null)
+        return s;
+      const I = s;
+      return n = this.materializeSignal(
+        I,
+        o,
+        t
+      ), s = void 0, I;
+    }, r = t === void 0 ? (u) => {
+      const o = n;
+      o !== void 0 ? this.writeSignalValue(o, u) : s !== u && (s = u);
+    } : (u) => {
+      var I, _;
+      const o = n;
+      if (o !== void 0) {
+        const A = o.flags & d ? o.pendingValue : o.cachedValue;
+        A !== u && ((I = t.onChange) == null || I.call(t, A, u, o.firstSub !== null)), this.writeSignalValue(o, u);
+        return;
+      }
+      s !== u && ((_ = t.onChange) == null || _.call(t, s, u, !1), s = u);
+    }, b = {
+      source: {
+        get: l,
+        peek: this.handleReaders.peek,
+        set: r
+      },
+      /**
+       * Освобождает источник и отсоединяет его от реактивного графа.
+       */
+      dispose() {
+        var o;
+        if (a)
+          return !0;
+        a = !0, s = void 0;
+        let u;
+        try {
+          (o = t == null ? void 0 : t.onDispose) == null || o.call(t, (n == null ? void 0 : n.firstSub) != null);
+        } catch (I) {
+          (u ?? (u = [])).push(I);
+        }
+        if (n !== void 0) {
+          try {
+            i.releaseSourceSubs(n);
+          } catch (I) {
+            (u ?? (u = [])).push(I);
+          }
+          n.cachedValue = void 0, n.pendingValue = void 0, n.pendingAuthor = void 0, n.flags = 0;
+        }
+        if (n = void 0, (u == null ? void 0 : u.length) === 1)
+          throw u[0];
+        if (u !== void 0 && u.length > 1)
+          throw new AggregateError(u, "Owned signal disposal failed.");
+        return !0;
+      }
+    };
+    return t !== void 0 && (b.hasSubscribers = () => (n == null ? void 0 : n.firstSub) != null), b;
+  }
+  /**
+   * Создаёт ленивый computed с финализатором исходящих и входящих связей.
+   * Финализатор работает и до первого вычисления, не материализуя узел ради очистки.
+   * @internal
+   */
+  _ownedComputed(e, t) {
+    const i = this, s = this.createComputedHandle(e, t);
+    let n = !1;
+    const a = {
+      source: s,
+      /**
+       * Отсоединяет принадлежащий источник и освобождает его ссылки.
+       * Повторный вызов возвращает true без повторной очистки.
+       */
+      dispose() {
+        var h;
+        if (n)
+          return !0;
+        n = !0, i.activeSub === s && (i.activeSub = null);
+        const l = [];
+        try {
+          (h = t == null ? void 0 : t.onDispose) == null || h.call(t, s.firstSub != null);
+        } catch (b) {
+          l.push(b);
+        }
+        if (s.flags !== void 0)
+          try {
+            i.releaseSourceSubs(s);
+          } catch (b) {
+            l.push(b);
+          }
+        let r = s.firstDep;
+        for (; r != null; ) {
+          const b = r.nextDep;
+          i.detachSubLink(r), r = b;
+        }
+        if (s.firstDep = s.tailDep = null, s.depCount = 0, N(s), s.evaluate = void 0, s.cachedValue = void 0, s.flags = 0, l.length === 1)
+          throw l[0];
+        if (l.length > 1)
+          throw new AggregateError(l, "Owned computed disposal failed.");
+        return !0;
+      }
+    };
+    return t !== void 0 && (a.hasSubscribers = () => s.firstSub != null), a;
+  }
+  /**
+   * Открывает вложенную синхронную границу группировки.
+   * Внутренний вызывающий код обязан выполнить соответствующий 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 Z;
+function V() {
+  return Z ?? (Z = new U());
+}
+const te = (c) => V().signal(c), ie = (c) => V().reactive(c);
+function se(c) {
+  return V().computed(c);
+}
+const ne = (c, e) => V().effect(c, e), ae = (c, e, t) => V().watch(c, e, t), le = (c) => V().batch(c), re = (c) => V().untracked(c), ce = () => V().scope();
+export {
+  U as RaphReactivity,
+  M as ScopeNode,
+  le as batch,
+  se as computed,
+  ne as effect,
+  ie as reactive,
+  ce as scope,
+  te as signal,
+  re as untracked,
+  ae as watch
+};