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

package/dist/debug/reactivity/engine.js

@@ -1,26 +1,22 @@
-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 b = (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, p = 2, C = 4, D = 8, T = 16, y = 32, x = 64, W = 128, m = 256, v = 512, E = w | p, R = 16, X = 2;
-function N(c) {
+import { reactiveObject as O } from "./reactive-object.js";
+import { appendScopeChild as W, ScopeNode as U, throwScopeErrors as V, detachScopeChild as q } from "./scope.js";
+import { watchWithReactivity as z } from "./watch.js";
+const g = 1, f = 2, D = 4, p = 8, _ = 16, d = 32, v = 64, x = 128, k = 256, o = 512, L = 2048, E = 4096, m = 8192, R = L | E, T = 1e4, b = g | f, I = 16, F = 2;
+function A(c) {
   c.dependencyLookupDebt === void 0 && c.dependencyIndex === void 0 || (c.dependencyIndex = void 0, c.dependencyLookupDebt = void 0, c.dependencyLookupSearches = void 0);
 }
-function q(c, e) {
-  if (e <= R || c.flags & W || c.dependencyIndex !== void 0)
+function H(c, e) {
+  if (e <= I || c.flags & x || c.dependencyIndex !== void 0)
     return;
   const t = (c.dependencyLookupSearches ?? 0) + 1, i = (c.dependencyLookupDebt ?? 0) + e;
-  if (c.dependencyLookupSearches = t, c.dependencyLookupDebt = i, t < X || i < c.depCount)
+  if (c.dependencyLookupSearches = t, c.dependencyLookupDebt = i, t < F || i < c.depCount)
     return;
   const s = /* @__PURE__ */ new Map();
   for (let n = c.firstDep; n !== null; n = n.nextDep)
     s.set(n.dep, n);
   c.dependencyIndex = s, c.dependencyLookupDebt = void 0, c.dependencyLookupSearches = void 0;
 }
-function j(c, e, t) {
-  var a;
+function Q(c, e, t) {
   const i = c.firstSub;
   if (i === null)
     return;
@@ -31,21 +27,59 @@ function j(c, e, t) {
   if (s.sub === e)
     return c.subSearchCursor = s.nextSub ?? i, s;
   if (t) {
-    const r = (a = e.dependencyIndex) == null ? void 0 : a.get(c);
-    if (r !== void 0)
-      return c.subSearchCursor = r.nextSub ?? i, r;
+    const a = e.dependencyIndex?.get(c);
+    if (a !== void 0)
+      return c.subSearchCursor = a.nextSub ?? i, a;
     if (e.dependencyIndex !== void 0)
       return;
   }
-  let l = s.nextSub ?? i;
-  for (; l !== s; ) {
-    if (++n, l.sub === e)
-      return c.subSearchCursor = l.nextSub ?? i, t && q(e, n), l;
-    l = l.nextSub ?? i;
+  let r = s.nextSub ?? i;
+  for (; r !== s; ) {
+    if (++n, r.sub === e)
+      return c.subSearchCursor = r.nextSub ?? i, t && H(e, n), r;
+    r = r.nextSub ?? i;
   }
-  t && q(e, n);
+  t && H(e, n);
 }
-class U {
+class N {
+  // Opt-in стратегия длинного slow path; не добавляет policy field каждой ноде.
+  adaptiveDependencyIndex;
+  // Потребитель текущего синхронного чтения; null отключает отслеживание.
+  activeSub = null;
+  // Глубина вложенных синхронных границ группировки.
+  batchDepth = 0;
+  // Индекс следующего элемента внутренней очереди эффектов.
+  effectReadIndex = 0;
+  // Позиция добавления элемента в текущем проходе очереди.
+  effectWriteIndex = 0;
+  // Граница активного префикса переиспользуемого стека invalidation.
+  invalidationDepth = 0;
+  // Граница активного префикса стека проверки зависимостей.
+  dependencyDepth = 0;
+  // Только активная проверка зависимостей требует дополнительной отметки записей.
+  checkingDepth = 0;
+  // Защита внутренней очереди от вложенного повторного прохода.
+  flushingEffects = !1;
+  // Переиспользуемый буфер очереди; прочитанная ячейка сразу освобождает ссылку.
+  effectQueue = new Array(16).fill(void 0);
+  // Переиспользуемый стек распространения invalidation; исходный способ выделения сохранён.
+  invalidationStack = new Array(512).fill(null);
+  // Переиспользуемый стек проверки зависимостей с защитой активного вложенного префикса.
+  dependencyStack = [];
+  // Общие адаптеры receiver для handles этого экземпляра.
+  // Создаются один раз, чтобы computed не хранил дополнительную ссылку на движок
+  // и не выделял отдельные get/peek closures на каждый источник.
+  handleReaders = this.createHandleReaders();
+  // Выбранная внешняя политика; у синхронного экземпляра отсутствует.
+  effectScheduler;
+  // Прямой обработчик очереди, выбранный один раз при создании экземпляра.
+  flushEffects;
+  /**
+   * Синхронная регистрация эффекта для Runtime и watch независимо от внешней политики.
+   * Это связанная ссылка на реализацию effect(), а не делегирующая функция.
+   * @internal
+   */
+  _effectImmediate;
   /**
    * Выбирает политику исполнения и сохраняет совместимость извлечённых методов.
    * Тела методов находятся на прототипе; bind() выполняется только при создании
@@ -53,42 +87,6 @@ class U {
    * @param options Необязательная внешняя политика эффектов.
    */
   constructor(e = {}) {
-    // Opt-in стратегия длинного slow path; не добавляет policy field каждой ноде.
-    b(this, "adaptiveDependencyIndex");
-    // Потребитель текущего синхронного чтения; null отключает отслеживание.
-    b(this, "activeSub", null);
-    // Глубина вложенных синхронных границ группировки.
-    b(this, "batchDepth", 0);
-    // Индекс следующего элемента внутренней очереди эффектов.
-    b(this, "effectReadIndex", 0);
-    // Позиция добавления элемента в текущем проходе очереди.
-    b(this, "effectWriteIndex", 0);
-    // Граница активного префикса переиспользуемого стека invalidation.
-    b(this, "invalidationDepth", 0);
-    // Граница активного префикса стека проверки зависимостей.
-    b(this, "dependencyDepth", 0);
-    // Защита внутренней очереди от вложенного повторного прохода.
-    b(this, "flushingEffects", !1);
-    // Переиспользуемый буфер очереди; прочитанная ячейка сразу освобождает ссылку.
-    b(this, "effectQueue", new Array(16).fill(void 0));
-    // Переиспользуемый стек распространения invalidation; исходный способ выделения сохранён.
-    b(this, "invalidationStack", new Array(512).fill(null));
-    // Переиспользуемый стек проверки зависимостей с защитой активного вложенного префикса.
-    b(this, "dependencyStack", []);
-    // Общие адаптеры receiver для handles этого экземпляра.
-    // Создаются один раз, чтобы computed не хранил дополнительную ссылку на движок
-    // и не выделял отдельные get/peek closures на каждый источник.
-    b(this, "handleReaders", this.createHandleReaders());
-    // Выбранная внешняя политика; у синхронного экземпляра отсутствует.
-    b(this, "effectScheduler");
-    // Прямой обработчик очереди, выбранный один раз при создании экземпляра.
-    b(this, "flushEffects");
-    /**
-     * Синхронная регистрация эффекта для Runtime и watch независимо от внешней политики.
-     * Это связанная ссылка на реализацию effect(), а не делегирующая функция.
-     * @internal
-     */
-    b(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;
   }
   // ---------------------------------------------
@@ -102,21 +100,21 @@ class U {
   signal(e) {
     let t = e, i;
     const s = () => {
-      const l = i;
-      if (l !== void 0)
-        return this.readSignalValue(l);
+      const r = i;
+      if (r !== void 0)
+        return this.readSignalValue(r);
       const a = this.activeSub;
       return a === null || (i = this.materializeSignal(
         t,
         a
       )), t;
-    }, n = (l) => {
+    }, n = (r) => {
       const a = i;
       if (a !== void 0) {
-        this.writeSignalValue(a, l);
+        this.writeSignalValue(a, r);
         return;
       }
-      t !== l && (t = l);
+      t !== r && (t = r);
     };
     return {
       get: s,
@@ -129,7 +127,7 @@ class U {
    * Object context и per-property sources создаются лениво внутри этого engine.
    */
   reactive(e) {
-    return G(this, e, () => this.createReactivePropertySourceBridge());
+    return O(this, e, () => this.createReactivePropertySourceBridge());
   }
   computed(e) {
     if (typeof e == "function")
@@ -147,17 +145,17 @@ class U {
    * @param onStop Однократная окончательная очистка, независимая от повторных запусков.
    */
   effect(e, t) {
-    const i = this.allocateGraphRecord(void 0, e, p | w | y);
+    const i = this.allocateGraphRecord(void 0, e, f | g | d);
     t !== void 0 && (i.onStop = t);
     const s = this.activeSub;
-    s !== null && s.flags & y && z(s, i);
+    s !== null && s.flags & d && W(s, i);
     try {
       this.executeEffect(i);
     } catch (n) {
       try {
         this.disposeEffect(i);
-      } catch (l) {
-        throw new AggregateError([n, l], "Effect registration and cleanup failed.");
+      } catch (r) {
+        throw new AggregateError([n, r], "Effect registration and cleanup failed.");
       }
       throw n;
     }
@@ -167,7 +165,7 @@ class U {
    * Наблюдает за источниками; callback и cleanup не создают зависимостей.
    */
   watch(e, t, i) {
-    return Y(this.effect, this.untracked, e, t, i);
+    return z(this.effect, this.untracked, e, t, i);
   }
   /**
    * Группирует синхронные записи и обрабатывает эффекты после внешней границы.
@@ -213,7 +211,7 @@ class U {
    * Создаёт владельца ресурсов в текущем графе без Runtime и фаз.
    */
   scope() {
-    return new M(this);
+    return new U(this);
   }
   // ---------------------------------------------
   // PRIVATE
@@ -268,7 +266,7 @@ class U {
       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;
+    return i !== void 0 && (s.sourceHooks = i, s.flags |= o), t.flags & x ? this.appendInitialDependency(s, t) : this.trackDependency(s, t), s;
   }
   /**
    * Создаёт минимальный handle computed без преждевременного выделения полей графа.
@@ -290,23 +288,23 @@ class U {
    * @param onStop Однократная окончательная очистка.
    */
   createScheduledEffect(e, t) {
-    const i = this.allocateGraphRecord(void 0, e, p | w | y);
+    const i = this.allocateGraphRecord(void 0, e, f | g | d);
     let s = !1;
     t !== void 0 && (i.onStop = t);
     const n = this.activeSub;
-    n !== null && n.flags & y && z(n, i);
-    const l = () => {
-      if (!(!(i.flags & x) || i.evaluate === void 0)) {
-        i.flags &= ~x, s = !0;
+    n !== null && n.flags & d && W(n, i);
+    const r = () => {
+      if (!(!(i.flags & v) || i.evaluate === void 0)) {
+        i.flags &= ~v, s = !0;
         try {
           this.executeEffect(i);
         } catch (a) {
           if (!this.batchDepth && this.effectReadIndex !== this.effectWriteIndex)
             try {
               this.flushEffects();
-            } catch (r) {
+            } catch (l) {
               throw new AggregateError(
-                [a, r],
+                [a, l],
                 "Effect execution and queue processing failed."
               );
             }
@@ -316,15 +314,15 @@ class U {
       }
     };
     try {
-      const a = this.effectScheduler.bind(l);
-      a.cancelPending = () => i.evaluate === void 0 || !s ? !1 : (this.settleCancelledDependencies(i), i.flags &= ~(x | E | C), !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects(), !0), a.rearmPending = () => {
-        i.evaluate !== void 0 && (i.flags |= p | x, a.schedule());
+      const a = this.effectScheduler.bind(r);
+      a.cancelPending = () => i.evaluate === void 0 || !s ? !1 : (this.settleCancelledDependencies(i), i.flags &= ~(v | b | D), !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects(), !0), a.rearmPending = () => {
+        i.evaluate !== void 0 && (i.flags |= f | v, a.schedule());
       }, i.effectTask = a, this.requestEffectTask(i);
     } catch (a) {
       try {
         this.disposeEffect(i);
-      } catch (r) {
-        throw new AggregateError([a, r], "Effect registration and cleanup failed.");
+      } catch (l) {
+        throw new AggregateError([a, l], "Effect registration and cleanup failed.");
       }
       throw a;
     }
@@ -337,7 +335,7 @@ class U {
   readSignalValue(e) {
     const t = this.activeSub;
     let i = null;
-    return t !== null && (i = this.trackDependency(e, t)), e.flags & p && this.commitSignalValue(e, i), e.cachedValue;
+    return t !== null && (i = this.trackDependency(e, t)), e.flags & f && this.commitSignalValue(e, i), e.cachedValue;
   }
   /**
    * Записывает новое значение или откладывает его фиксацию до чтения в batch.
@@ -345,19 +343,19 @@ class U {
    * Без batch и внешней политики очередь эффектов завершается до возврата из set().
    */
   writeSignalValue(e, t) {
-    if (e.flags & p || this.batchDepth) {
-      const s = !!(e.flags & p);
-      if ((e.flags & p ? e.pendingValue : e.cachedValue) === 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 &= ~p, e.pendingAuthor = void 0;
+        e.flags &= ~f, e.pendingAuthor = void 0;
       else {
-        e.flags |= p;
-        const a = this.activeSub !== null && this.activeSub.flags & D ? this.activeSub : null;
+        e.flags |= f;
+        const a = this.activeSub !== null && this.activeSub.flags & p ? this.activeSub : null;
         s ? e.pendingAuthor !== a && (e.pendingAuthor = null) : e.pendingAuthor = a;
       }
-      const l = e.firstSub;
-      l != null && (!s || this.activeSub !== null && this.activeSub.flags & D || e.flags & v) && this.propagateInvalidation(l, !0);
+      const r = e.firstSub;
+      r != null && (!s || this.activeSub !== null && this.activeSub.flags & p || e.flags & o) && this.propagateInvalidation(r, !0);
       return;
     }
     if (e.cachedValue === t)
@@ -368,17 +366,21 @@ class U {
   }
   /**
    * Возвращает кеш либо синхронно актуализирует вычисляемое значение.
-   * Неуспешное вычисление не считается значением. Даже ошибочное чтение сохраняет
-   * связь с активным потребителем, чтобы тот мог восстановиться при изменении источника.
+   * Неуспешное вычисление не считается значением. Ошибка getter сохраняет связь
+   * с активным потребителем для восстановления. Повторное чтение во время
+   * первого сбора зависимостей отклоняется до регистрации связи и чтения кеша.
    */
   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);
+    const t = e.flags;
+    if ((t & (p | x)) === (p | x))
+      throw new Error("Computed value is already being evaluated.");
+    const i = t & (_ | b | k), s = i === 0 ? e.cachedValue : i & _ ? this.evaluateFirstValue(e) : this.refreshComputedValue(e, t);
     if (e.evaluate === void 0)
       return s;
     const n = this.activeSub;
     if (n !== null) {
-      const l = n.tailDep;
-      n.flags & W ? (l === null || l.dep !== e) && this.appendInitialDependency(e, n) : this.trackDependency(e, n);
+      const r = n.tailDep;
+      n.flags & x ? (r === null || r.dep !== e) && this.appendInitialDependency(e, n) : this.trackDependency(e, n);
     }
     return s;
   }
@@ -388,18 +390,21 @@ class U {
    * Уже прочитанные зависимости сохраняются для последующего уведомления.
    */
   evaluateFirstValue(e) {
-    const t = e.flags & v, i = e.evaluate;
-    e.flags = t | D | W;
+    const t = e.flags & o, i = e.evaluate;
+    e.flags = t | p | x;
     const s = this.activeSub;
     this.activeSub = e;
+    let n;
     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 ? p : 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);
+      if (n = i(), e.evaluate !== i)
+        return e.cachedValue = void 0, e.flags = 0, n;
+      e.flags = t | (e.flags & D ? f : 0);
+    } catch (r) {
+      throw e.evaluate !== i ? (e.cachedValue = void 0, e.flags = 0, r) : (e.flags = t | k, s !== null && this.trackDependency(e, s), r);
     } finally {
       this.activeSub = s;
     }
+    return e.flags & f ? this.refreshComputedValue(e, e.flags) : (e.cachedValue = n, n);
   }
   /**
    * Актуализирует computed: выполняет прямой пересчёт либо проверяет зависимости.
@@ -407,10 +412,10 @@ class U {
    */
   refreshComputedValue(e, t, i = null) {
     try {
-      if (t & (p | C | m))
-        return this.recomputeValue(e, i) || (e.flags &= ~E), e.cachedValue;
+      if (t & (f | D | k))
+        return this.recomputeValue(e, i), e.cachedValue;
       const s = e.firstDep;
-      return (s === null || !this.refreshDependencies(e, s) || !this.recomputeValue(e, i)) && (e.flags &= ~E), e.cachedValue;
+      return s !== null && this.refreshDependencies(e, s) ? this.recomputeValue(e, i) : e.flags &= ~b, e.cachedValue;
     } catch (s) {
       throw this.activeSub !== null && this.trackDependency(e, this.activeSub), s;
     }
@@ -422,7 +427,7 @@ class U {
    */
   commitSignalValue(e, t) {
     const i = e.cachedValue;
-    e.cachedValue = e.pendingValue, e.flags &= ~p;
+    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);
   }
@@ -445,33 +450,33 @@ class U {
    * Существующую связь перемещает или переиспользует; новую создаёт только при необходимости.
    */
   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;
+    if (t.depCount <= I) {
+      for (let l = s; l !== null; l = l.nextDep)
+        if (l.dep === e)
+          return this.reorderDependency(t, l, i), t.tailDep = l, l;
+      for (let l = i; l !== null; l = l.prevDep)
+        if (l.dep === e)
+          return l;
       return s !== null ? (t.tailDep = this.reuseDepLink(s, e), s) : t.tailDep = this.insertDependency(e, t, i);
     }
-    let n = 0, l = s;
-    for (; l !== null && n < R; ) {
-      const r = l;
-      if (r.dep === e)
-        return this.reorderDependency(t, r, i), t.tailDep = r, r;
-      l = r.nextDep, ++n;
+    let n = 0, r = s;
+    for (; r !== null && n < I; ) {
+      const l = r;
+      if (l.dep === e)
+        return this.reorderDependency(t, l, i), t.tailDep = l, l;
+      r = l.nextDep, ++n;
     }
     let a = i;
-    for (; a !== null && n < R; ) {
-      const r = a;
-      if (r.dep === e)
-        return r;
-      a = r.prevDep, ++n;
+    for (; a !== null && n < I; ) {
+      const l = a;
+      if (l.dep === e)
+        return l;
+      a = l.prevDep, ++n;
     }
-    if (l !== null || a !== null) {
-      const r = j(e, t, this.adaptiveDependencyIndex);
-      if (r !== void 0)
-        return this.reorderDependency(t, r, i), t.tailDep = r, r;
+    if (r !== null || a !== null) {
+      const l = Q(e, t, this.adaptiveDependencyIndex);
+      if (l !== void 0)
+        return this.reorderDependency(t, l, i), t.tailDep = l, l;
     }
     return s !== null ? (t.tailDep = this.reuseDepLink(s, e), s) : t.tailDep = this.insertDependency(e, t, i);
   }
@@ -481,7 +486,6 @@ class U {
    * Связь одновременно включается в список потребителей производителя.
    */
   appendInitialDependency(e, t) {
-    var l;
     const i = t.tailDep, s = e.lastSub, n = {
       dep: e,
       sub: t,
@@ -490,14 +494,13 @@ class U {
       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, (l = t.dependencyIndex) == null || l.set(e, n), e.flags & v && this.attachDependencyCleanup(n), n;
+    return s === null ? e.firstSub = n : s.nextSub = n, e.lastSub = n, i === null ? t.firstDep = n : i.nextDep = n, t.tailDep = n, ++t.depCount, t.dependencyIndex?.set(e, n), e.flags & o && this.attachDependencyCleanup(n), n;
   }
   /**
    * Вставляет связь после заданного курсора зависимостей потребителя.
    * Сохраняет ещё не прочитанный хвост списка и увеличивает dependencyCount.
    */
   insertDependency(e, t, i) {
-    var a;
     const s = e.lastSub, n = {
       dep: e,
       sub: t,
@@ -507,8 +510,8 @@ class U {
       nextDep: null
     };
     s === null ? e.firstSub = n : s.nextSub = n, e.lastSub = n;
-    const l = i === null ? t.firstDep : i.nextDep;
-    return n.nextDep = l, l !== null && (l.prevDep = n), i === null ? t.firstDep = n : i.nextDep = n, ++t.depCount, (a = t.dependencyIndex) == null || a.set(e, n), e.flags & v && this.attachDependencyCleanup(n), n;
+    const r = i === null ? t.firstDep : i.nextDep;
+    return n.nextDep = r, r !== null && (r.prevDep = n), i === null ? t.firstDep = n : i.nextDep = n, ++t.depCount, t.dependencyIndex?.set(e, n), e.flags & o && this.attachDependencyCleanup(n), n;
   }
   /**
    * Переназначает существующую связь другому производителю.
@@ -518,7 +521,7 @@ class U {
     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;
+    return e.dep = t, e.prevSub = s, e.nextSub = null, s === null ? t.firstSub = e : s.nextSub = e, t.lastSub = e, i?.set(t, e), t.flags & o && this.attachDependencyCleanup(e), e;
   }
   /**
    * Перемещает существующую зависимость после курсора текущего чтения.
@@ -529,45 +532,55 @@ class U {
       return;
     const s = t.prevDep, n = t.nextDep;
     s === null ? e.firstDep = n : s.nextDep = n, n !== null && (n.prevDep = s);
-    const l = i === null ? e.firstDep : i.nextDep;
-    t.prevDep = i, t.nextDep = l, l !== null && (l.prevDep = t), i === null ? e.firstDep = t : i.nextDep = t;
+    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.
+   * Ошибка cleanup не прерывает освобождение оставшегося хвоста зависимостей.
    */
   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;
+    if (i === null)
+      return;
+    t === null ? e.firstDep = null : t.nextDep = null;
+    for (let n = i; n !== null; n = n.nextDep)
+      n.prevDep = null, --e.depCount;
+    e.depCount <= I && A(e);
+    let s;
+    for (; i !== null; ) {
+      const n = i.nextDep;
+      try {
+        this.detachSubLink(i, !0);
+      } catch (r) {
+        this.unlinkSubLink(i, !0), s ??= [], s.push(r);
       }
-      e.depCount <= R && N(e);
+      i = n;
     }
+    s !== void 0 && V(s, "Dependency cleanup failed.");
   }
   /**
    * Удаляет связь только из списка потребителей производителя.
    * Список зависимостей потребителя и его счётчик здесь не изменяются.
    * Также исправляет курсор поиска, если он указывал на удаляемую связь.
    */
-  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;
+  detachSubLink(e, t = !1) {
+    e.sub.dependencyIndex?.delete(e.dep);
+    let i;
+    e.dep.flags & o && (i = e.dependencyCleanup, e.dependencyCleanup = void 0, i?.()), this.unlinkSubLink(e, t || i !== void 0);
+  }
+  /** Завершает удаление producer-связи без вызова source cleanup. */
+  unlinkSubLink(e, t) {
+    t && ((e.prevSub === null ? e.dep.firstSub !== e : e.prevSub.nextSub !== e) || (e.nextSub === null ? e.dep.lastSub !== e : e.nextSub.prevSub !== e)) || (e.dep.subSearchCursor === e && (e.dep.subSearchCursor = e.nextSub ?? (e.dep.firstSub === e ? void 0 : e.dep.firstSub ?? void 0)), e.prevSub === null ? e.dep.firstSub = e.nextSub : e.prevSub.nextSub = e.nextSub, e.nextSub === null ? e.dep.lastSub = e.prevSub : e.nextSub.prevSub = e.prevSub);
   }
   /** Connects Runtime ownership metadata only for edges whose producer opted in. */
   attachDependencyCleanup(e) {
-    var n, l;
-    const t = e.dep.sourceHooks, i = t == null ? void 0 : t.onDependency;
+    const i = e.dep.sourceHooks?.onDependency;
     if (i === void 0)
       return;
-    const s = ((n = e.sub.sourceHooks) == null ? void 0 : n.dependencyOwner) ?? ((l = e.sub.effectTask) == null ? void 0 : l.dependencyOwner);
+    const s = e.sub.sourceHooks?.dependencyOwner ?? e.sub.effectTask?.dependencyOwner;
     s !== void 0 && (e.dependencyCleanup = i(s));
   }
   /**
@@ -576,23 +589,29 @@ class U {
    * Переводит ожидавших проверку потребителей к повторному вычислению при необходимости.
    */
   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 l = n.flags;
-        (l & (E | D)) === w && (n.flags = l & ~w | p, l & y && this.enqueueEffect(n, e)), i = s;
+    if (!(e.flags & o)) {
+      let s = e.firstSub;
+      for (; s != null; ) {
+        const n = s.nextSub, r = s.sub;
+        this.detachDependencyLink(s), this.detachSubLink(s);
+        const a = r.flags;
+        (a & (b | p)) === g && (r.flags = a & ~g | f, a & d && this.enqueueEffect(r, e)), s = n;
       }
       e.firstSub = e.lastSub = null, e.subSearchCursor = void 0;
       return;
     }
-    let t = e.firstSub;
+    let t = e.firstSub, i;
     for (; t != null; ) {
-      const i = t.nextSub;
-      this.detachDependencyLink(t), this.detachSubLink(t), t = i;
+      const s = t.nextSub;
+      this.detachDependencyLink(t);
+      try {
+        this.detachSubLink(t, !0);
+      } catch (n) {
+        this.unlinkSubLink(t, !0), i ??= [], i.push(n);
+      }
+      t = s;
     }
-    e.firstSub = e.lastSub = null, e.subSearchCursor = void 0;
+    e.firstSub = e.lastSub = null, e.subSearchCursor = void 0, i !== void 0 && V(i, "Source dependency cleanup failed.");
   }
   /**
    * Удаляет связь только из списка зависимостей потребителя.
@@ -601,16 +620,15 @@ class U {
    */
   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);
+    (i === null ? t.firstDep !== e : i.nextDep !== e) || (i === null ? t.firstDep = s : i.nextDep = s, s !== null && (s.prevDep = i), t.tailDep === e && (t.tailDep = i), --t.depCount, t.depCount <= I && A(t));
   }
   /**
    * Добавляет эффект во внутреннюю очередь один раз до обработки текущей записи.
    * Флаг SCHEDULED предотвращает повторное добавление без создания task-объекта.
    */
   enqueueEffect(e, t) {
-    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);
+    const i = t !== void 0 && t.flags & o ? t.sourceHooks.token : void 0;
+    i !== void 0 && e.effectTask?.notify?.(i), !(e.flags & v) && (e.flags |= v, this.effectQueue[this.effectWriteIndex] = e, ++this.effectWriteIndex);
   }
   /**
    * Распространяет invalidation от непосредственных к транзитивным потребителям.
@@ -618,45 +636,55 @@ class U {
    * не выполняет. Непосредственное и потенциальное изменения отмечает разными флагами.
    */
   propagateInvalidation(e, t = !1) {
-    var n, l, a, r, h, g, u, o, I, _, A, O, Q;
+    this.checkingDepth !== 0 && this.markActiveChecks(e);
     const i = this.invalidationDepth;
     let s = i;
-    for (let d = e; d !== null; d = d.nextSub) {
-      const f = d.sub, S = f.flags;
-      let k = 0;
-      if (S & (E | D) ? S & D ? k = this.invalidateReadDependency(d, f, S) : !t && !(S & p) && (f.flags = S & ~w | p) : (k = S & ~C | (t ? w : p), f.flags = k), k === 0) {
-        if (S & y && S & x) {
-          const L = d.dep.flags & v ? d.dep.sourceHooks.token : void 0;
-          L !== void 0 && ((l = (n = f.effectTask) == null ? void 0 : n.notify) == null || l.call(n, L));
-        } else f.flags & v && ((r = (a = f.sourceHooks).onInvalidate) == null || r.call(a, f.firstSub !== null), f.firstSub !== null && (this.invalidationStack[s++] = f.firstSub));
+    for (let n = e; n !== null; n = n.nextSub) {
+      const r = n.sub, a = r.flags;
+      let l = 0;
+      if (a & (b | p) ? a & p ? l = this.invalidateReadDependency(n, r, a) : !t && !(a & f) && (r.flags = a & ~g | f) : (l = a & ~D | (t ? g : f), r.flags = l), l === 0) {
+        if (a & d && a & v) {
+          const u = n.dep.flags & o ? n.dep.sourceHooks.token : void 0;
+          u !== void 0 && r.effectTask?.notify?.(u);
+        } else r.flags & (o | m) && (r.flags & o && r.sourceHooks.onInvalidate?.(r.firstSub !== null), r.flags &= ~m, r.firstSub !== null && (this.invalidationStack[s++] = r.firstSub));
         continue;
       }
-      k & y ? (!(k & D) || ((h = f.effectTask) == null ? void 0 : h.allowScheduleDuringRun) === !0) && this.enqueueEffect(f, d.dep) : (!(S & E) && f.flags & v && ((u = (g = f.sourceHooks).onInvalidate) == null || u.call(g, f.firstSub !== null)), f.firstSub !== null && (this.invalidationStack[s++] = f.firstSub));
+      l & d ? (!(l & p) || r.effectTask?.allowScheduleDuringRun === !0) && this.enqueueEffect(r, n.dep) : (!(a & b) && r.flags & o && r.sourceHooks.onInvalidate?.(r.firstSub !== null), r.firstSub !== null && (this.invalidationStack[s++] = r.firstSub));
     }
     for (; s !== i; ) {
-      let d = this.invalidationStack[--s];
+      let n = this.invalidationStack[--s];
       do {
-        const f = d.sub, S = f.flags;
-        let k = 0;
-        if (S & (E | D) ? S & D && (k = this.invalidateReadDependency(d, f, S)) : (k = S & ~C | w, f.flags = k), k === 0) {
-          if (S & y && S & x) {
-            const L = d.dep.flags & v ? d.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)) {
-            d.nextSub !== null && (this.invalidationStack[s++] = d.nextSub), d = f.firstSub;
+        const r = n.sub, a = r.flags;
+        let l = 0;
+        if (a & (b | p) ? a & p && (l = this.invalidateReadDependency(n, r, a)) : (l = a & ~D | g, r.flags = l), l === 0) {
+          if (a & d && a & v) {
+            const u = n.dep.flags & o ? n.dep.sourceHooks.token : void 0;
+            u !== void 0 && r.effectTask?.notify?.(u);
+          } else if (r.flags & (o | m) && (r.flags & o && r.sourceHooks.onInvalidate?.(r.firstSub !== null), r.flags &= ~m, r.firstSub !== null)) {
+            n.nextSub !== null && (this.invalidationStack[s++] = n.nextSub), n = r.firstSub;
             continue;
           }
-        } else if (k & y)
-          this.enqueueEffect(f, d.dep);
-        else if (!(S & E) && f.flags & v && ((Q = (O = f.sourceHooks).onInvalidate) == null || Q.call(O, f.firstSub !== null)), f.firstSub !== null) {
-          d.nextSub !== null && (this.invalidationStack[s++] = d.nextSub), d = f.firstSub;
+        } else if (l & d)
+          this.enqueueEffect(r, n.dep);
+        else if (!(a & b) && r.flags & o && r.sourceHooks.onInvalidate?.(r.firstSub !== null), r.firstSub !== null) {
+          n.nextSub !== null && (this.invalidationStack[s++] = n.nextSub), n = r.firstSub;
           continue;
         }
-        d = d.nextSub;
-      } while (d !== null);
+        n = n.nextSub;
+      } while (n !== null);
     }
     this.invalidationDepth = i;
   }
+  // Дополнительный обход не вызывает callbacks и проходит уже dirty computed:
+  // флаги обычной invalidation не показывают, какую связь check уже прошёл.
+  markActiveChecks(e) {
+    const t = [e], i = /* @__PURE__ */ new Set();
+    for (; t.length !== 0; )
+      for (let s = t.pop(); s !== null; s = s.nextSub) {
+        const n = s.sub;
+        i.has(n) || (i.add(n), n.flags & L && (n.flags |= E), !(n.flags & d) && n.firstSub !== null && t.push(n.firstSub));
+      }
+  }
   /**
    * Помечает работающего потребителя, только если затронута уже прочитанная связь.
    * Связи за trackedTail принадлежат прошлому запуску и не означают повторную invalidation.
@@ -667,11 +695,11 @@ class U {
     if (s === null)
       return 0;
     if (e !== s) {
-      for (let l = e.prevDep; l !== null; l = l.prevDep)
-        if (l === s)
+      for (let r = e.prevDep; r !== null; r = r.prevDep)
+        if (r === s)
           return 0;
     }
-    const n = i | C | w;
+    const n = i | D | g;
     return t.flags = n, n;
   }
   /**
@@ -680,12 +708,11 @@ class U {
    * текущую связь и автора записи.
    */
   confirmSubUpdates(e, t, i = null) {
-    var s, n;
-    for (let l = e; l !== null; l = l.nextSub) {
-      if (l === t || l.sub === i)
+    for (let s = e; s !== null; s = s.nextSub) {
+      if (s === t || s.sub === i)
         continue;
-      const a = l.sub, r = a.flags;
-      r & p || (a.flags = r & ~w | p, r & y ? this.enqueueEffect(a, l.dep) : r & E || a.flags & v && ((n = (s = a.sourceHooks).onInvalidate) == null || n.call(s, a.firstSub !== null)));
+      const n = s.sub, r = n.flags;
+      r & f || (n.flags = r & ~g | f, r & d ? this.enqueueEffect(n, s.dep) : r & b || n.flags & o && n.sourceHooks.onInvalidate?.(n.firstSub !== null));
     }
   }
   /**
@@ -696,26 +723,52 @@ class U {
    * Неверное значение в кеш не записывается.
    */
   recomputeValue(e, t = null) {
-    const i = e.evaluate;
-    e.tailDep = null;
-    const s = e.flags & ~C | D;
-    e.flags = s;
-    const n = this.activeSub;
-    this.activeSub = e;
-    let l;
+    const i = e.cachedValue;
+    for (let s = 0; s < T; s++) {
+      const n = e.evaluate;
+      e.tailDep = null;
+      const r = e.flags & -6149 | p;
+      e.flags = r;
+      const a = this.activeSub;
+      this.activeSub = e;
+      let l;
+      try {
+        l = n();
+      } catch (h) {
+        if (e.evaluate !== n)
+          throw e.cachedValue = void 0, e.flags = 0, h;
+        this.failComputedValue(e, t, h);
+      } finally {
+        this.activeSub = a;
+      }
+      if (e.evaluate !== n)
+        return e.cachedValue = void 0, e.flags = 0, !1;
+      const u = e.tailDep;
+      if ((u === null ? e.firstDep : u.nextDep) !== null)
+        try {
+          this.pruneUnreadDependencies(e);
+        } catch (h) {
+          this.failComputedValue(e, t, h);
+        }
+      if (e.evaluate !== n)
+        return e.cachedValue = void 0, e.flags = 0, !1;
+      const w = e.flags & D;
+      if (e.flags = r & -8460, w) {
+        e.flags |= f;
+        continue;
+      }
+      return e.cachedValue = l, i === l ? !1 : (e.firstSub !== null && this.confirmSubUpdates(e.firstSub, t), !0);
+    }
+    return this.failComputedValue(e, t, new Error(`Computed settlement exceeded ${T} attempts.`));
+  }
+  /** Сохраняет первичную ошибку и отдельные ошибки cleanup при восстановлении. */
+  failComputedValue(e, t, i) {
     try {
-      l = i();
-    } catch (u) {
-      throw e.evaluate !== i ? (e.cachedValue = void 0, e.flags = 0, u) : (this.restoreComputedFailure(e, t), u);
-    } finally {
-      this.activeSub = n;
+      this.restoreComputedFailure(e, t);
+    } catch (s) {
+      throw new AggregateError([i, s], "Computed evaluation and dependency cleanup failed.");
     }
-    if (e.evaluate !== i)
-      return e.cachedValue = void 0, e.flags = 0, !1;
-    const a = e.flags & C, r = s & -268, h = e.tailDep;
-    (h === null ? e.firstDep : h.nextDep) !== null && this.pruneUnreadDependencies(e);
-    const g = e.cachedValue;
-    return e.cachedValue = l, e.flags = s & v | (a ? p : r), g === l ? !1 : (e.firstSub !== null && this.confirmSubUpdates(e.firstSub, t), !0);
+    throw i;
   }
   /**
    * Восстанавливает связи и состояния после неудачного getter.
@@ -723,7 +776,12 @@ class U {
    * Потребитель исключаемой связи мог уже покинуть активный префикс стека.
    */
   restoreComputedFailure(e, t) {
-    e.flags = e.flags & -144 | m, this.pruneUnreadDependencies(e), t !== null && this.restoreFailedDependency(t.sub);
+    e.evaluate !== void 0 && (e.flags = e.flags & -6288 | k);
+    try {
+      e.evaluate !== void 0 && this.pruneUnreadDependencies(e);
+    } finally {
+      e.evaluate === void 0 && (e.cachedValue = void 0, e.flags = 0), t !== null && this.restoreFailedDependency(t.sub);
+    }
   }
   /**
    * Итеративно проверяет зависимые computed и pending-сигналы перед запуском потребителя.
@@ -736,7 +794,7 @@ class U {
     try {
       return this.walkDependencyChain(e, t);
     } catch (s) {
-      this.restoreFailedDependency(e);
+      this.markRecoveryDependencies(e), this.restoreFailedDependency(e);
       for (let n = i; n < this.dependencyDepth; n++)
         this.restoreFailedDependency(this.dependencyStack[n].sub);
       throw this.dependencyDepth = i, this.dependencyStack.length = i, s;
@@ -746,7 +804,7 @@ class U {
   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 & p && this.commitSignalValue(i, t) : this.refreshComputedValue(i, s, t));
+      s & (_ | b | k) && (i.evaluate === void 0 ? s & f && this.commitSignalValue(i, t) : this.refreshComputedValue(i, s, t));
     }
   }
   /**
@@ -756,51 +814,70 @@ class U {
    */
   walkDependencyChain(e, t) {
     const i = this.dependencyDepth;
-    let s = i, n = !1;
-    e: for (; ; ) {
-      if (e.flags & p)
-        n = !0;
-      else {
-        const l = t.dep, a = l.flags;
-        if (a & (p | m))
-          this.dependencyDepth = s, n = l.evaluate === void 0 ? this.commitSignalValue(l, t) : this.recomputeValue(l, t);
-        else if (a & w) {
-          if (l.firstDep !== null) {
-            this.dependencyStack[s++] = t, e = l, t = l.firstDep;
-            continue e;
+    let s = i, n = !1, r;
+    e.flags = e.flags & ~E | L, ++this.checkingDepth;
+    try {
+      e: for (; ; ) {
+        if (e.flags & E) {
+          r ??= /* @__PURE__ */ new Map();
+          const a = (r.get(e) ?? 0) + 1;
+          if (r.set(e, a), a > T)
+            throw new Error(`Dependency check exceeded ${T} restarts.`);
+          e.flags &= ~E, e.firstDep !== null && (t = e.firstDep);
+        }
+        if (e.flags & f)
+          n = !0;
+        else {
+          const a = t.dep, l = a.flags;
+          if (l & (f | k))
+            this.dependencyDepth = s, n = a.evaluate === void 0 ? this.commitSignalValue(a, t) : this.recomputeValue(a, t);
+          else if (l & g) {
+            if (a.firstDep !== null) {
+              this.dependencyStack[s++] = t, e = a, e.flags = e.flags & ~E | L, t = a.firstDep;
+              continue e;
+            }
+            this.dependencyDepth = s, n = this.recomputeValue(a, t);
+          } else
+            n = !1;
+        }
+        if (!n && t.nextDep !== null) {
+          t = t.nextDep;
+          continue;
+        }
+        if (n) {
+          for (; s !== i; ) {
+            this.dependencyDepth = --s;
+            const a = this.dependencyStack[s];
+            if (e.flags &= ~R, n = this.recomputeValue(e, a), e = a.sub, !n) {
+              if (a.nextDep !== null) {
+                t = a.nextDep;
+                continue e;
+              }
+              break;
+            }
           }
-          this.dependencyDepth = s, n = this.recomputeValue(l, t);
-        } else
-          n = !1;
-      }
-      if (!n && t.nextDep !== null) {
-        t = t.nextDep;
-        continue;
-      }
-      if (n) {
+          if (n)
+            return this.dependencyDepth = i, !0;
+        }
         for (; s !== i; ) {
+          if (e.flags & (f | E))
+            continue e;
           this.dependencyDepth = --s;
-          const l = this.dependencyStack[s];
-          if (n = this.recomputeValue(e, l), e = l.sub, !n) {
-            if (l.nextDep !== null) {
-              t = l.nextDep;
-              continue e;
-            }
-            break;
+          const a = this.dependencyStack[s];
+          if (e.flags &= ~(g | R), e = a.sub, a.nextDep !== null) {
+            t = a.nextDep;
+            continue e;
           }
         }
-        if (n)
-          return this.dependencyDepth = i, !0;
-      }
-      for (; s !== i; ) {
-        this.dependencyDepth = --s;
-        const l = this.dependencyStack[s];
-        if (e.flags &= ~w, e = l.sub, l.nextDep !== null) {
-          t = l.nextDep;
+        if (e.flags & (f | E))
           continue e;
-        }
+        return e.flags &= ~(g | R), this.dependencyDepth = i, !1;
       }
-      return e.flags &= ~w, this.dependencyDepth = i, !1;
+    } finally {
+      e.flags &= ~R;
+      for (let a = i; a < s; a++)
+        this.dependencyStack[a].sub.flags &= ~R;
+      --this.checkingDepth;
     }
   }
   /**
@@ -809,7 +886,11 @@ class U {
    * для следующей invalidation. Вызывается только на ошибочном пути.
    */
   restoreFailedDependency(e) {
-    e.flags &= -16, e.flags & y || (e.flags |= m);
+    if (e.evaluate === void 0) {
+      e.cachedValue = void 0, e.flags = 0;
+      return;
+    }
+    e.flags &= -6160, e.flags & d || (e.flags |= k);
   }
   /**
    * Проверяет необходимость запуска, очищает прошлые ресурсы и выполняет тело эффекта.
@@ -820,70 +901,70 @@ class U {
    */
   executeEffect(e) {
     const t = e.flags;
-    if (!(t & E))
+    if (!(t & b))
       return;
-    if (!(t & (p | C))) {
-      const h = e.firstDep;
+    if (!(t & (f | D))) {
+      const u = e.firstDep;
       try {
-        if (h === null || !this.refreshDependencies(e, h)) {
-          e.flags &= ~E;
+        if (u === null || !this.refreshDependencies(e, u)) {
+          e.flags &= ~b;
           return;
         }
-      } catch (g) {
-        throw e.flags &= -80, g;
+      } catch (w) {
+        throw e.flags &= -80, w;
       }
     }
     const i = e.evaluate;
     if (i === void 0) {
-      e.flags &= ~E;
+      e.flags &= ~b;
       return;
     }
     let s;
     if (e.scopeLastChild !== void 0)
       try {
         this.disposeNestedEffects(e);
-      } catch (h) {
-        s = [h];
+      } catch (u) {
+        s = [u];
       }
     const n = typeof e.cachedValue == "function" ? e.cachedValue : void 0;
-    if (e.cachedValue = void 0, e.flags &= ~C, n !== void 0)
+    if (e.cachedValue = void 0, e.flags &= ~D, n !== void 0)
       try {
         this.untracked(n);
-      } catch (h) {
-        s ?? (s = []), s.push(h);
+      } catch (u) {
+        s ??= [], s.push(u);
       }
     if (s !== void 0) {
       try {
         this.disposeEffect(e);
-      } catch (h) {
-        s.push(h);
+      } catch (u) {
+        s.push(u);
       }
-      F(s, "Effect cleanup failed.");
+      V(s, "Effect cleanup failed.");
     }
     if (e.evaluate === void 0)
       return;
-    e.tailDep = null, e.flags = e.flags & ~C | D;
-    const l = this.activeSub;
+    e.tailDep = null, e.flags = e.flags & ~D | p;
+    const r = this.activeSub;
     this.activeSub = e;
     let a;
     try {
       a = i();
-    } catch (h) {
-      this.activeSub = l, e.flags &= ~D, this.failEffectRun(e, h, s);
+    } catch (u) {
+      this.activeSub = r, e.flags &= ~p, this.failEffectRun(e, u, s);
     } finally {
-      this.activeSub = l, e.flags &= ~D;
+      this.activeSub = r, e.flags &= ~p;
     }
-    const r = e.tailDep;
-    if ((r === null ? e.firstDep : r.nextDep) !== null && this.pruneUnreadDependencies(e), typeof a == "function")
+    const l = e.tailDep;
+    if ((l === null ? e.firstDep : l.nextDep) !== null && this.pruneUnreadDependencies(e), typeof a == "function")
       if (e.evaluate === void 0)
         try {
           this.untracked(a);
-        } catch (h) {
-          s ?? (s = []), s.push(h);
+        } catch (u) {
+          s ??= [], s.push(u);
         }
       else
         e.cachedValue = a;
-    e.flags & x ? e.flags = e.flags & -7 | w : e.flags &= -8;
+    e.flags & v ? e.flags = e.flags & -7 | g : e.flags &= -8;
   }
   /**
    * Завершает неудачный запуск эффекта, не затрагивая успешный путь исполнения.
@@ -906,12 +987,12 @@ class U {
    * Путь не проверяет наличие внешней задачи у каждого узла.
    */
   flushSyncEffects() {
-    if (!(this.flushingEffects || this.activeSub !== null && (this.activeSub.flags & (y | D)) === (y | D))) {
+    if (!(this.flushingEffects || this.activeSub !== null && (this.activeSub.flags & (d | p)) === (d | p))) {
       this.flushingEffects = !0;
       try {
         for (; this.effectReadIndex !== this.effectWriteIndex; ) {
           const e = this.effectReadIndex, t = this.effectQueue[e];
-          this.effectQueue[e] = void 0, ++this.effectReadIndex, t.flags &= ~x, this.executeEffect(t);
+          this.effectQueue[e] = void 0, ++this.effectReadIndex, t.flags &= ~v, this.executeEffect(t);
         }
       } catch (e) {
         this.drainQueueAfterError(e, !1);
@@ -926,14 +1007,14 @@ class U {
    * Ошибка одного элемента не оставляет необработанные записи со старым SCHEDULED.
    */
   flushExternalEffects() {
-    if (!(this.flushingEffects || this.activeSub !== null && (this.activeSub.flags & (y | D)) === (y | D))) {
+    if (!(this.flushingEffects || this.activeSub !== null && (this.activeSub.flags & (d | p)) === (d | p))) {
       this.flushingEffects = !0;
       try {
         for (; this.effectReadIndex !== this.effectWriteIndex; ) {
           const e = this.effectReadIndex, t = this.effectQueue[e];
           this.effectQueue[e] = void 0, ++this.effectReadIndex;
           const i = t.effectTask;
-          i === void 0 ? (t.flags &= ~x, this.executeEffect(t)) : t.evaluate !== void 0 ? this.scheduleEffectTask(t, i) : t.flags &= ~x;
+          i === void 0 ? (t.flags &= ~v, this.executeEffect(t)) : t.evaluate !== void 0 ? this.scheduleEffectTask(t, i) : t.flags &= ~v;
         }
       } catch (e) {
         this.drainQueueAfterError(e, !0);
@@ -942,6 +1023,20 @@ class U {
       }
     }
   }
+  // Только ошибочный путь; новые fields/ссылки в graph records не добавляются.
+  markRecoveryDependencies(e) {
+    const t = [e], i = /* @__PURE__ */ new Set();
+    for (; t.length !== 0; ) {
+      const s = t.pop();
+      if (!i.has(s)) {
+        i.add(s);
+        for (let n = s.firstDep; n !== null; n = n.nextDep) {
+          const r = n.dep;
+          r.evaluate !== void 0 && !(r.flags & d) && (r.flags |= m, t.push(r));
+        }
+      }
+    }
+  }
   /**
    * Завершает очередь после первой ошибки, собирая последующие причины сбоя.
    * Вызывается только на ошибочном пути; успешный проход не создаёт массив ошибок
@@ -953,10 +1048,10 @@ class U {
       const s = this.effectReadIndex++, n = this.effectQueue[s];
       this.effectQueue[s] = void 0;
       try {
-        const l = t ? n.effectTask : void 0;
-        l !== void 0 && n.evaluate !== void 0 ? this.scheduleEffectTask(n, l) : (n.flags &= ~x, this.executeEffect(n));
-      } catch (l) {
-        i.push(l);
+        const r = t ? n.effectTask : void 0;
+        r !== void 0 && n.evaluate !== void 0 ? this.scheduleEffectTask(n, r) : (n.flags &= ~v, this.executeEffect(n));
+      } catch (r) {
+        i.push(r);
       }
     }
     throw i.length === 1 ? e : new AggregateError(i, "Effect queue processing failed.");
@@ -968,7 +1063,7 @@ class U {
    */
   requestEffectTask(e) {
     const t = e.effectTask;
-    t === void 0 || e.evaluate === void 0 || (e.flags |= x, this.scheduleEffectTask(e, t));
+    t === void 0 || e.evaluate === void 0 || (e.flags |= v, this.scheduleEffectTask(e, t));
   }
   // Передаёт уже запланированный эффект его постоянной внешней задаче.
   scheduleEffectTask(e, t) {
@@ -989,38 +1084,38 @@ class U {
       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 a = n.nextDep;
-      this.detachSubLink(n), n = a;
+    e.evaluate = void 0, e.flags = 0, e.cachedValue = void 0, e.effectTask = void 0, i !== void 0 && (e.onStop = void 0), q(e);
+    let n;
+    e.tailDep = null;
+    try {
+      this.pruneUnreadDependencies(e);
+    } catch (r) {
+      n = [r];
     }
-    e.firstDep = e.tailDep = null, e.depCount = 0, N(e);
-    let l;
-    if (t !== void 0)
+    if (e.firstDep = e.tailDep = null, e.depCount = 0, A(e), t !== void 0)
       try {
         t.dispose();
-      } catch (a) {
-        l = [a];
+      } catch (r) {
+        n ??= [], n.push(r);
       }
     try {
       this.disposeNestedEffects(e);
-    } catch (a) {
-      l ?? (l = []), l.push(a);
+    } catch (r) {
+      n ??= [], n.push(r);
     }
     if (s !== void 0)
       try {
         this.untracked(s);
-      } catch (a) {
-        l ?? (l = []), l.push(a);
+      } catch (r) {
+        n ??= [], n.push(r);
       }
     if (i !== void 0)
       try {
         this.untracked(i);
-      } catch (a) {
-        l ?? (l = []), l.push(a);
+      } catch (r) {
+        n ??= [], n.push(r);
       }
-    this.invalidationStack.length = this.invalidationDepth, this.dependencyStack.length = this.dependencyDepth, l !== void 0 && F(l, "Effect disposal failed.");
+    this.invalidationStack.length !== this.invalidationDepth && (this.invalidationStack.length = this.invalidationDepth), this.dependencyStack.length !== this.dependencyDepth && (this.dependencyStack.length = this.dependencyDepth), n !== void 0 && V(n, "Effect disposal failed.");
   }
   /**
    * Останавливает все вложенные эффекты в обратном порядке регистрации.
@@ -1033,16 +1128,16 @@ class U {
       try {
         this.disposeEffect(e.scopeLastChild);
       } catch (i) {
-        t ?? (t = []), t.push(i);
+        t ??= [], t.push(i);
       }
-    t !== void 0 && F(t, "Nested effect disposal failed.");
+    t !== void 0 && V(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;
+    e.flags = _ | (e.sourceHooks === void 0 ? 0 : o), e.firstSub = null, e.lastSub = null, e.firstDep = null, e.tailDep = null, e.depCount = 0, e.cachedValue = void 0;
   }
   /**
    * Связывает два разных receiver: движок-владелец и читаемый handle.
@@ -1060,14 +1155,14 @@ class U {
        */
       initializeComputed() {
         const i = this;
-        return U.materializeComputed(i), this.get = t, e.readComputedValue(i);
+        return N.materializeComputed(i), this.get = t, e.readComputedValue(i);
       },
       /**
        * Материализует raw computed, сохраняя извлечение read после первого вызова.
        */
       initializeRaw() {
         const i = this;
-        U.materializeComputed(i);
+        N.materializeComputed(i);
         const s = () => e.readComputedValue(i);
         return this.read = s, s();
       },
@@ -1105,17 +1200,17 @@ class U {
   _signalAccess(e) {
     const t = this;
     let i = e, s;
-    function n(l) {
+    function n(r) {
       if (arguments.length !== 0) {
-        const h = s;
-        h !== void 0 ? t.writeSignalValue(h, l) : i !== l && (i = l);
+        const u = s;
+        u !== void 0 ? t.writeSignalValue(u, r) : i !== r && (i = r);
         return;
       }
       const a = s;
       if (a !== void 0)
         return t.readSignalValue(a);
-      const r = t.activeSub;
-      return r === null || (s = t.materializeSignal(i, r)), i;
+      const l = t.activeSub;
+      return l === null || (s = t.materializeSignal(i, l)), i;
     }
     return {
       read: n,
@@ -1143,68 +1238,66 @@ class U {
    */
   _ownedSignal(e, t) {
     const i = this;
-    let s = e, n, l = !1;
+    let s = e, n, r = !1;
     const a = () => {
-      const u = n;
-      if (u !== void 0)
-        return this.readSignalValue(u);
-      const o = this.activeSub;
-      if (o === null)
+      const h = n;
+      if (h !== void 0)
+        return this.readSignalValue(h);
+      const S = this.activeSub;
+      if (S === null)
         return s;
-      const I = s;
+      const C = s;
       return n = this.materializeSignal(
-        I,
-        o,
+        C,
+        S,
         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 & p ? o.pendingValue : o.cachedValue;
-        A !== u && ((I = t.onChange) == null || I.call(t, A, u, o.firstSub !== null)), this.writeSignalValue(o, u);
+      ), s = void 0, C;
+    }, l = t === void 0 ? (h) => {
+      const S = n;
+      S !== void 0 ? this.writeSignalValue(S, h) : s !== h && (s = h);
+    } : (h) => {
+      const S = n;
+      if (S !== void 0) {
+        const C = S.flags & f ? S.pendingValue : S.cachedValue;
+        C !== h && t.onChange?.(C, h, S.firstSub !== null), this.writeSignalValue(S, h);
         return;
       }
-      s !== u && ((_ = t.onChange) == null || _.call(t, s, u, !1), s = u);
-    }, g = {
+      s !== h && (t.onChange?.(s, h, !1), s = h);
+    }, w = {
       source: {
         get: a,
         peek: this.handleReaders.peek,
-        set: r
+        set: l
       },
       /**
        * Освобождает источник и отсоединяет его от реактивного графа.
        */
       dispose() {
-        var o;
-        if (l)
+        if (r)
           return !0;
-        l = !0, s = void 0;
-        let u;
+        r = !0, s = void 0;
+        let h;
         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);
+          t?.onDispose?.(n?.firstSub != null);
+        } catch (S) {
+          (h ??= []).push(S);
         }
         if (n !== void 0) {
           try {
             i.releaseSourceSubs(n);
-          } catch (I) {
-            (u ?? (u = [])).push(I);
+          } catch (S) {
+            (h ??= []).push(S);
           }
           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.");
+        if (n = void 0, h?.length === 1)
+          throw h[0];
+        if (h !== void 0 && h.length > 1)
+          throw new AggregateError(h, "Owned signal disposal failed.");
         return !0;
       }
     };
-    return t !== void 0 && (g.hasSubscribers = () => (n == null ? void 0 : n.firstSub) != null), g;
+    return t !== void 0 && (w.hasSubscribers = () => n?.firstSub != null), w;
   }
   /**
    * Создаёт ленивый computed с финализатором исходящих и входящих связей.
@@ -1214,42 +1307,43 @@ class U {
   _ownedComputed(e, t) {
     const i = this, s = this.createComputedHandle(e, t);
     let n = !1;
-    const l = {
+    const r = {
       source: s,
       /**
        * Отсоединяет принадлежащий источник и освобождает его ссылки.
        * Повторный вызов возвращает true без повторной очистки.
        */
       dispose() {
-        var h;
         if (n)
           return !0;
         n = !0, i.activeSub === s && (i.activeSub = null);
         const a = [];
         try {
-          (h = t == null ? void 0 : t.onDispose) == null || h.call(t, s.firstSub != null);
-        } catch (g) {
-          a.push(g);
+          t?.onDispose?.(s.firstSub != null);
+        } catch (u) {
+          a.push(u);
         }
         if (s.flags !== void 0)
           try {
             i.releaseSourceSubs(s);
-          } catch (g) {
-            a.push(g);
+          } catch (u) {
+            a.push(u);
           }
-        let r = s.firstDep;
-        for (; r != null; ) {
-          const g = r.nextDep;
-          i.detachSubLink(r), r = g;
-        }
-        if (s.firstDep = s.tailDep = null, s.depCount = 0, N(s), s.evaluate = void 0, s.cachedValue = void 0, s.flags = 0, a.length === 1)
+        const l = s.flags !== void 0;
+        if (s.evaluate = void 0, s.cachedValue = void 0, s.flags = 0, s.tailDep = null, l)
+          try {
+            i.pruneUnreadDependencies(s);
+          } catch (u) {
+            a.push(u);
+          }
+        if (s.firstDep = s.tailDep = null, s.depCount = 0, A(s), a.length === 1)
           throw a[0];
         if (a.length > 1)
           throw new AggregateError(a, "Owned computed disposal failed.");
         return !0;
       }
     };
-    return t !== void 0 && (l.hasSubscribers = () => s.firstSub != null), l;
+    return t !== void 0 && (r.hasSubscribers = () => s.firstSub != null), r;
   }
   /**
    * Открывает вложенную синхронную границу группировки.
@@ -1281,25 +1375,326 @@ class U {
   _isFlushingEffects() {
     return this.flushingEffects;
   }
+  // ---------------------------------------------
+  // TASK EFFECT GLUE
+  // ---------------------------------------------
+  //
+  // Аналог createScheduledEffect() без closures для вызывающего слоя, который
+  // владеет одним постоянным объектом задачи на эффект. Вызывающий слой хранит
+  // состояние запусков и управляет записью графа через методы ниже; engine не
+  // создаёт closures runner, cancel и re-arm. Такие эффекты требуют экземпляр
+  // с внешним effect scheduler, как и эффекты, связанные через scheduler.
+  /**
+   * Создаёт запись графа для эффекта с внешним планированием и подключает его
+   * постоянную задачу. Запуск ещё не запрошен: вызывающий слой сохраняет запись
+   * и затем вызывает _requestTaskEffect(). Запись, созданная во время работы
+   * другого эффекта, становится его вложенным ресурсом.
+   * @internal
+   */
+  _allocateTaskEffect(e, t) {
+    const i = this.allocateGraphRecord(void 0, e, f | g | d), s = this.activeSub;
+    return s !== null && s.flags & d && W(s, i), i.effectTask = t, i;
+  }
+  /**
+   * Запрашивает первый запуск эффекта с задачей. При `schedule` задача получает
+   * schedule(), как на пути scheduler bind; без него вызывающий слой уже сам
+   * поставил задачу в очередь, и запись только помечается запланированной.
+   * Если метод бросает исключение, запись освобождает вызывающий слой.
+   * @internal
+   */
+  _requestTaskEffect(e, t) {
+    t ? this.requestEffectTask(e) : e.effectTask !== void 0 && e.evaluate !== void 0 && (e.flags |= v), !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects();
+  }
+  /**
+   * Открывает одну доставку эффекта с задачей. Возвращает false для устаревшей
+   * доставки: запись остановлена или запуск больше не запланирован.
+   * @internal
+   */
+  _beginTaskEffectRun(e) {
+    return !(e.flags & v) || e.evaluate === void 0 ? !1 : (e.flags &= ~v, !0);
+  }
+  /**
+   * Выполняет доставку, открытую через _beginTaskEffectRun(), вне активного
+   * потребителя и затем обрабатывает очередь эффектов, в том числе после
+   * неудачного запуска; при двух сбоях передаёт обе причины.
+   * @internal
+   */
+  _finishTaskEffectRun(e) {
+    const t = this.activeSub;
+    this.activeSub = null;
+    try {
+      try {
+        this.executeEffect(e);
+      } catch (i) {
+        if (!this.batchDepth && this.effectReadIndex !== this.effectWriteIndex)
+          try {
+            this.flushEffects();
+          } catch (s) {
+            throw new AggregateError(
+              [i, s],
+              "Effect execution and queue processing failed."
+            );
+          }
+        throw i;
+      }
+      !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects();
+    } finally {
+      this.activeSub = t;
+    }
+  }
+  /**
+   * Гасит ожидающую доставку, от которой отказывается задача. Вызывающий слой
+   * не должен отменять доставку до первого запуска: зависимости до него ещё не
+   * собраны. Возвращает false, если запись уже остановлена.
+   * @internal
+   */
+  _cancelTaskEffect(e) {
+    return e.evaluate === void 0 ? !1 : (this.settleCancelledDependencies(e), e.flags &= -72, !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects(), !0);
+  }
+  /**
+   * Делает следующую доставку исполняемой и снова планирует задачу. Нужен,
+   * когда invalidation пришла после снимка текущей доставки: её запуск
+   * расходует предыдущее dirty-состояние.
+   * @internal
+   */
+  _rearmTaskEffect(e) {
+    const t = e.effectTask;
+    t === void 0 || e.evaluate === void 0 || (e.flags |= f | v, t.schedule());
+  }
+  /**
+   * Окончательно останавливает эффект с задачей. Engine один раз вызывает
+   * task.dispose() изнутри, поэтому задача может направлять собственное
+   * освобождение через этот метод.
+   * @internal
+   */
+  _disposeTaskEffect(e) {
+    this.disposeEffect(e);
+  }
+  // ---------------------------------------------
+  // SIGNAL NODE GLUE
+  // ---------------------------------------------
+  //
+  // Аналог _ownedSignal() без closures для вызывающего слоя, который хранит
+  // значение, запись графа и source hooks одного signal в одном постоянном
+  // объекте. Вызывающий слой сам держит значение до материализации и ссылку на
+  // запись после неё; engine не создаёт handle, closures чтения и записи и
+  // объект финализатора. Методы повторяют шаги _ownedSignal() по одному.
+  /**
+   * Материализует signal для активного потребителя и связывает их. Без
+   * потребителя возвращает undefined: signal остаётся значением у вызывающего
+   * слоя. После материализации значением владеет запись.
+   * @internal
+   */
+  _trackSignalNode(e, t) {
+    const i = this.activeSub;
+    if (i !== null)
+      return this.materializeSignal(e, i, t);
+  }
+  /**
+   * Читает материализованный signal и регистрирует зависимость активного
+   * потребителя.
+   * @internal
+   */
+  _readSignalNode(e) {
+    return this.readSignalValue(e);
+  }
+  /**
+   * Читает материализованный signal без подписки текущего потребителя;
+   * pending-значение фиксируется так же, как при обычном чтении.
+   * @internal
+   */
+  _peekSignalNode(e) {
+    const t = this.activeSub;
+    if (t === null)
+      return this.readSignalValue(e);
+    this.activeSub = null;
+    try {
+      return this.readSignalValue(e);
+    } finally {
+      this.activeSub = t;
+    }
+  }
+  /**
+   * Возвращает значение, которое увидит следующее чтение: pending-значение
+   * незавершённой группировки либо зафиксированное. Ничего не фиксирует.
+   * @internal
+   */
+  _visibleSignalValue(e) {
+    return e.flags & f ? e.pendingValue : e.cachedValue;
+  }
+  /**
+   * Записывает значение материализованного signal с обычной семантикой batch.
+   * @internal
+   */
+  _writeSignalNode(e, t) {
+    this.writeSignalValue(e, t);
+  }
+  /**
+   * Сообщает, есть ли у материализованного signal потребители в графе.
+   * @internal
+   */
+  _signalNodeHasSubscribers(e) {
+    return e.firstSub !== null;
+  }
+  /**
+   * Отсоединяет материализованный signal от потребителей и освобождает его
+   * значения. Значения освобождаются и при сбое отсоединения. Поля pending
+   * сбрасываются, только если запись их получала: запись без группировок не
+   * меняет набор своих полей при освобождении.
+   * @internal
+   */
+  _releaseSignalNode(e) {
+    try {
+      this.releaseSourceSubs(e);
+    } finally {
+      e.cachedValue = void 0, e.pendingValue !== void 0 && (e.pendingValue = void 0), e.pendingAuthor != null && (e.pendingAuthor = void 0), e.flags = 0;
+    }
+  }
+  // ---------------------------------------------
+  // SUBSCRIBER OWNER GLUE
+  // ---------------------------------------------
+  //
+  // Чтение живых связей производителя для вызывающего слоя, которому нужен
+  // ответ о владельцах потребителей только по запросу. Слой не ведёт своего
+  // учёта рёбер: связь, снятая графом, перестаёт быть видимой сразу, без
+  // отдельного cleanup на ребро.
+  /**
+   * Ищет среди текущих потребителей записи первого, чьего владельца принимает
+   * accept, и возвращает этого владельца. Владелец потребителя определяется
+   * так же, как при привязке ребра через onDependency: у computed это
+   * dependencyOwner его source hooks, у эффекта — dependencyOwner его задачи.
+   * Потребители без владельца пропускаются. Обход идёт в порядке списка
+   * потребителей, ничего не выделяет и не меняет граф; accept не должен менять
+   * связи этой записи.
+   * @param node Материализованная запись производителя.
+   * @param accept Проверка владельца потребителя; context передаётся ей без closure.
+   * @param context Произвольное значение вызывающего слоя для accept.
+   * @internal
+   */
+  _findSubscriberOwner(e, t, i) {
+    for (let s = e.firstSub; s !== null; s = s.nextSub) {
+      const n = s.sub, r = n.sourceHooks?.dependencyOwner ?? n.effectTask?.dependencyOwner;
+      if (r !== void 0 && t(r, i))
+        return r;
+    }
+  }
+  /**
+   * Возвращает владельца активного потребителя: того, кому engine привязал бы
+   * ребро следующего отслеживаемого чтения. Владелец определяется так же, как
+   * в _findSubscriberOwner(). Без активного потребителя и у потребителя без
+   * владельца результат undefined. Метод ничего не выделяет и не меняет граф.
+   *
+   * Вызывающий слой проверяет по этому владельцу допустимость чтения, когда
+   * его собственный контекст снят, а потребитель engine остался активным.
+   * @internal
+   */
+  _activeSubscriberOwner() {
+    const e = this.activeSub;
+    if (e !== null)
+      return e.sourceHooks?.dependencyOwner ?? e.effectTask?.dependencyOwner;
+  }
+  // ---------------------------------------------
+  // COUNTER NODE GLUE
+  // ---------------------------------------------
+  //
+  // Запись графа со счётчиком вместо значения: вызывающий слой будит через неё
+  // потребителей, которым важен сам факт изменения. Значение счётчика только
+  // растёт, поэтому одну запись нельзя отменить следующей.
+  /**
+   * Увеличивает счётчик материализованного signal и уведомляет его
+   * потребителей. Без потребителей ничего не пишет и возвращает false.
+   *
+   * Сдвиг — обычная запись signal. Вне группировки она прямая: счётчик
+   * фиксируется сразу, а потребитель становится обязательным к пересчёту, в
+   * том числе тот, кто ждал только проверки зависимостей или стоит на стеке
+   * идущей проверки. Внутри группировки и у записи с ещё не прочитанным
+   * отложенным сдвигом запись откладывается до первого чтения, как любая запись
+   * внутри batch().
+   *
+   * Потребитель, который выполняется в момент прямого сдвига, получает его по
+   * общему правилу записи во время запуска: у записи не остаётся отложенного
+   * сдвига, который позже подтвердил бы ему изменение.
+   *
+   * Очередь эффектов обрабатывается на выходе, если группировки нет: отложенная
+   * запись сама её не обрабатывает, а потребитель, которого она поставила в
+   * очередь, не должен ждать следующей записи.
+   * @internal
+   */
+  _bumpSignalNode(e) {
+    return e.firstSub === null ? !1 : (this.writeSignalValue(
+      e,
+      (e.flags & f ? e.pendingValue : e.cachedValue) + 1
+    ), !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects(), !0);
+  }
+  /**
+   * Создаёт запись-счётчик для активного потребителя и связывает их; без
+   * потребителя возвращает undefined. Счётчик начинается с нуля и сдвигается
+   * через _bumpSignalNode().
+   *
+   * Счётчик — производитель без собственных зависимостей. Граф читает у него
+   * то же, что у записи signal в роли производителя: признаки, список
+   * потребителей, отсутствие getter, значение и source hooks. Полей списка
+   * зависимостей у записи нет, а hooks лежат в ней самой: счётчик стоит одной
+   * аллокации из шести полей, а запись signal с hooks — двух. Поля отложенной
+   * записи появляются у счётчика с первым сдвигом.
+   * @internal
+   */
+  _trackCounterNode(e) {
+    const t = this.activeSub;
+    if (t === null)
+      return;
+    const i = {
+      flags: o,
+      firstSub: null,
+      lastSub: null,
+      evaluate: void 0,
+      cachedValue: 0,
+      sourceHooks: e
+    };
+    return t.flags & x ? this.appendInitialDependency(i, t) : this.trackDependency(i, t), i;
+  }
+  // ---------------------------------------------
+  // ACTIVE TASK GLUE
+  // ---------------------------------------------
+  //
+  // Тело эффекта с задачей engine вызывает без аргументов и без receiver.
+  // Вызывающий слой, который даёт всем своим эффектам одно общее тело, находит
+  // через метод ниже эффект, ради которого тело вызвано: записи графа не нужна
+  // собственная closure тела.
+  /**
+   * Возвращает постоянную задачу активного потребителя. Engine делает запись
+   * эффекта активным потребителем непосредственно перед вызовом её тела,
+   * поэтому первое обращение из тела возвращает задачу именно этого эффекта,
+   * какие бы доставки ни выполнил cleanup его прошлого запуска.
+   *
+   * Без активного потребителя и у потребителя без задачи — computed либо
+   * эффекта, созданного без внешнего планирования, — результат undefined.
+   * Метод ничего не выделяет и не меняет граф.
+   * @internal
+   */
+  _activeEffectTask() {
+    const e = this.activeSub;
+    return e === null ? void 0 : e.effectTask;
+  }
 }
-let Z;
-function V() {
-  return Z ?? (Z = new U());
+let P;
+function y() {
+  return P ??= new N();
 }
-const te = (c) => V().signal(c), ie = (c) => V().reactive(c);
-function se(c) {
-  return V().computed(c);
+const K = (c) => y().signal(c), Y = (c) => y().reactive(c);
+function X(c) {
+  return y().computed(c);
 }
-const ne = (c, e) => V().effect(c, e), le = (c, e, t) => V().watch(c, e, t), ae = (c) => V().batch(c), re = (c) => V().untracked(c), ce = () => V().scope();
+const $ = (c, e) => y().effect(c, e), j = (c, e, t) => y().watch(c, e, t), Z = (c) => y().batch(c), J = (c) => y().untracked(c), ee = () => y().scope();
 export {
-  U as RaphReactivity,
-  M as ScopeNode,
-  ae as batch,
-  se as computed,
-  ne as effect,
-  ie as reactive,
-  ce as scope,
-  te as signal,
-  re as untracked,
-  le as watch
+  N as RaphReactivity,
+  U as ScopeNode,
+  Z as batch,
+  X as computed,
+  $ as effect,
+  Y as reactive,
+  ee as scope,
+  K as signal,
+  J as untracked,
+  j as watch
 };