@raphy-js/raph 1.0.0-dev.2 → 1.0.1-dev.25

package/dist/debug/reactivity/engine.js

@@ -1,26 +1,85 @@
-var C = Object.defineProperty;
-var R = (a, e, t) => e in a ? C(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t;
-var p = (a, e, t) => R(a, typeof e != "symbol" ? e + "" : e, t);
-import { appendScopeChild as m, ScopeNode as _, throwScopeErrors as E, detachScopeChild as A } from "./scope.js";
-import { watchWithReactivity as L } from "./watch.js";
-const d = 1, f = 2, S = 4, h = 8, w = 16, o = 32, v = 64, k = 128, x = 256, g = d | f, I = 16;
-function T(a, e) {
-  const t = a.firstSub;
-  if (t === null)
+import { reactiveObject as O } from "./reactive-object.js";
+import { appendScopeChild as W, ScopeNode as U, throwScopeErrors as V, detachScopeChild as q } from "./scope.js";
+import { watchWithReactivity as z } from "./watch.js";
+const g = 1, f = 2, D = 4, p = 8, _ = 16, d = 32, v = 64, x = 128, k = 256, o = 512, L = 2048, E = 4096, m = 8192, R = L | E, T = 1e4, b = g | f, I = 16, F = 2;
+function A(c) {
+  c.dependencyLookupDebt === void 0 && c.dependencyIndex === void 0 || (c.dependencyIndex = void 0, c.dependencyLookupDebt = void 0, c.dependencyLookupSearches = void 0);
+}
+function H(c, e) {
+  if (e <= I || c.flags & x || c.dependencyIndex !== void 0)
+    return;
+  const t = (c.dependencyLookupSearches ?? 0) + 1, i = (c.dependencyLookupDebt ?? 0) + e;
+  if (c.dependencyLookupSearches = t, c.dependencyLookupDebt = i, t < F || i < c.depCount)
     return;
-  if (t === a.lastSub)
-    return t.sub === e ? t : void 0;
-  const i = a.subSearchCursor ?? t;
-  if (i.sub === e)
-    return a.subSearchCursor = i.nextSub ?? t, i;
-  let s = i.nextSub ?? t;
-  for (; s !== i; ) {
-    if (s.sub === e)
-      return a.subSearchCursor = s.nextSub ?? t, s;
-    s = s.nextSub ?? t;
+  const s = /* @__PURE__ */ new Map();
+  for (let n = c.firstDep; n !== null; n = n.nextDep)
+    s.set(n.dep, n);
+  c.dependencyIndex = s, c.dependencyLookupDebt = void 0, c.dependencyLookupSearches = void 0;
+}
+function Q(c, e, t) {
+  const i = c.firstSub;
+  if (i === null)
+    return;
+  if (i === c.lastSub)
+    return i.sub === e ? i : void 0;
+  const s = c.subSearchCursor ?? i;
+  let n = 1;
+  if (s.sub === e)
+    return c.subSearchCursor = s.nextSub ?? i, s;
+  if (t) {
+    const a = e.dependencyIndex?.get(c);
+    if (a !== void 0)
+      return c.subSearchCursor = a.nextSub ?? i, a;
+    if (e.dependencyIndex !== void 0)
+      return;
   }
+  let r = s.nextSub ?? i;
+  for (; r !== s; ) {
+    if (++n, r.sub === e)
+      return c.subSearchCursor = r.nextSub ?? i, t && H(e, n), r;
+    r = r.nextSub ?? i;
+  }
+  t && H(e, n);
 }
-class y {
+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() выполняется только при создании
@@ -28,41 +87,7 @@ class y {
    * @param options Необязательная внешняя политика эффектов.
    */
   constructor(e = {}) {
-    // Потребитель текущего синхронного чтения; null отключает отслеживание.
-    p(this, "activeSub", null);
-    // Глубина вложенных синхронных границ группировки.
-    p(this, "batchDepth", 0);
-    // Индекс следующего элемента внутренней очереди эффектов.
-    p(this, "effectReadIndex", 0);
-    // Позиция добавления элемента в текущем проходе очереди.
-    p(this, "effectWriteIndex", 0);
-    // Граница активного префикса переиспользуемого стека invalidation.
-    p(this, "invalidationDepth", 0);
-    // Граница активного префикса стека проверки зависимостей.
-    p(this, "dependencyDepth", 0);
-    // Защита внутренней очереди от вложенного повторного прохода.
-    p(this, "flushingEffects", !1);
-    // Переиспользуемый буфер очереди; прочитанная ячейка сразу освобождает ссылку.
-    p(this, "effectQueue", new Array(16).fill(void 0));
-    // Переиспользуемый стек распространения invalidation; исходный способ выделения сохранён.
-    p(this, "invalidationStack", new Array(512).fill(null));
-    // Переиспользуемый стек проверки зависимостей с защитой активного вложенного префикса.
-    p(this, "dependencyStack", []);
-    // Общие адаптеры receiver для handles этого экземпляра.
-    // Создаются один раз, чтобы computed не хранил дополнительную ссылку на движок
-    // и не выделял отдельные get/peek closures на каждый источник.
-    p(this, "handleReaders", this.createHandleReaders());
-    // Выбранная внешняя политика; у синхронного экземпляра отсутствует.
-    p(this, "effectScheduler");
-    // Прямой обработчик очереди, выбранный один раз при создании экземпляра.
-    p(this, "flushEffects");
-    /**
-     * Синхронная регистрация эффекта для Runtime и watch независимо от внешней политики.
-     * Это связанная ссылка на реализацию effect(), а не делегирующая функция.
-     * @internal
-     */
-    p(this, "_effectImmediate");
-    this.effectScheduler = e.effectScheduler, this._effectImmediate = this.effect.bind(this), this.signal = this.signal.bind(this), this.computed = this.computed.bind(this), this.watch = this.watch.bind(this), this.batch = this.batch.bind(this), this.untracked = this.untracked.bind(this), this.scope = this.scope.bind(this), this._signalAccess = this._signalAccess.bind(this), this._computedAccess = this._computedAccess.bind(this), this._ownedSignal = this._ownedSignal.bind(this), this._ownedComputed = this._ownedComputed.bind(this), this._isTracking = this._isTracking.bind(this), this._isFlushingEffects = this._isFlushingEffects.bind(this), this._startBatch = this._startBatch.bind(this), this._endBatch = this._endBatch.bind(this), this.effect = this.effectScheduler === void 0 ? this._effectImmediate : this.createScheduledEffect.bind(this), this.flushEffects = this.effectScheduler === void 0 ? this.flushSyncEffects : this.flushExternalEffects;
+    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
@@ -78,15 +103,15 @@ class y {
       const r = i;
       if (r !== void 0)
         return this.readSignalValue(r);
-      const l = this.activeSub;
-      return l === null || (i = this.materializeSignal(
+      const a = this.activeSub;
+      return a === null || (i = this.materializeSignal(
         t,
-        l
+        a
       )), t;
     }, n = (r) => {
-      const l = i;
-      if (l !== void 0) {
-        this.writeSignalValue(l, r);
+      const a = i;
+      if (a !== void 0) {
+        this.writeSignalValue(a, r);
         return;
       }
       t !== r && (t = r);
@@ -97,6 +122,13 @@ class y {
       set: n
     };
   }
+  /**
+   * Возвращает стабильный глубокий Proxy для plain object или array.
+   * Object context и per-property sources создаются лениво внутри этого engine.
+   */
+  reactive(e) {
+    return O(this, e, () => this.createReactivePropertySourceBridge());
+  }
   computed(e) {
     if (typeof e == "function")
       return this.createComputedHandle(e);
@@ -113,10 +145,10 @@ class y {
    * @param onStop Однократная окончательная очистка, независимая от повторных запусков.
    */
   effect(e, t) {
-    const i = this.allocateGraphRecord(void 0, e, f | d | o);
+    const i = this.allocateGraphRecord(void 0, e, f | g | d);
     t !== void 0 && (i.onStop = t);
     const s = this.activeSub;
-    s !== null && s.flags & o && m(s, i);
+    s !== null && s.flags & d && W(s, i);
     try {
       this.executeEffect(i);
     } catch (n) {
@@ -133,7 +165,7 @@ class y {
    * Наблюдает за источниками; callback и cleanup не создают зависимостей.
    */
   watch(e, t, i) {
-    return L(this.effect, this.untracked, e, t, i);
+    return z(this.effect, this.untracked, e, t, i);
   }
   /**
    * Группирует синхронные записи и обрабатывает эффекты после внешней границы.
@@ -179,7 +211,7 @@ class y {
    * Создаёт владельца ресурсов в текущем графе без Runtime и фаз.
    */
   scope() {
-    return new _(this);
+    return new U(this);
   }
   // ---------------------------------------------
   // PRIVATE
@@ -201,6 +233,26 @@ class y {
       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 в графе при первом отслеживаемом чтении
    * и связывает его с активным потребителем.
@@ -208,24 +260,25 @@ class y {
    * До этого момента signal может хранить значение только в замыкании
    * и вообще не создавать `ReactiveNode`.
    */
-  materializeSignal(e, t) {
-    const i = this.allocateGraphRecord(
+  materializeSignal(e, t, i) {
+    const s = this.allocateGraphRecord(
       e,
       void 0,
       0
     );
-    return t.flags & k ? this.appendInitialDependency(i, t) : this.trackDependency(i, t), i;
+    return i !== void 0 && (s.sourceHooks = i, s.flags |= o), t.flags & x ? this.appendInitialDependency(s, t) : this.trackDependency(s, t), s;
   }
   /**
    * Создаёт минимальный handle computed без преждевременного выделения полей графа.
    * Первый get() материализует запись на этом же объекте и заменяет метод чтения.
    */
-  createComputedHandle(e) {
-    return {
+  createComputedHandle(e, t) {
+    const i = {
       evaluate: e,
       get: this.handleReaders.initializeComputed,
       peek: this.handleReaders.peek
     };
+    return t !== void 0 && (i.sourceHooks = t), i;
   }
   /**
    * Создаёт эффект с одной постоянной задачей внешнего scheduler.
@@ -235,39 +288,43 @@ class y {
    * @param onStop Однократная окончательная очистка.
    */
   createScheduledEffect(e, t) {
-    const i = this.allocateGraphRecord(void 0, e, f | d | o);
+    const i = this.allocateGraphRecord(void 0, e, f | g | d);
+    let s = !1;
     t !== void 0 && (i.onStop = t);
-    const s = this.activeSub;
-    s !== null && s.flags & o && m(s, i);
-    const n = () => {
+    const n = this.activeSub;
+    n !== null && n.flags & d && W(n, i);
+    const r = () => {
       if (!(!(i.flags & v) || i.evaluate === void 0)) {
-        i.flags &= ~v;
+        i.flags &= ~v, s = !0;
         try {
           this.executeEffect(i);
-        } catch (r) {
+        } catch (a) {
           if (!this.batchDepth && this.effectReadIndex !== this.effectWriteIndex)
             try {
               this.flushEffects();
             } catch (l) {
               throw new AggregateError(
-                [r, l],
+                [a, l],
                 "Effect execution and queue processing failed."
               );
             }
-          throw r;
+          throw a;
         }
         !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects();
       }
     };
     try {
-      i.effectTask = this.effectScheduler.bind(n), this.requestEffectTask(i);
-    } catch (r) {
+      const a = this.effectScheduler.bind(r);
+      a.cancelPending = () => i.evaluate === void 0 || !s ? !1 : (this.settleCancelledDependencies(i), i.flags &= ~(v | b | D), !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects(), !0), a.rearmPending = () => {
+        i.evaluate !== void 0 && (i.flags |= f | v, a.schedule());
+      }, i.effectTask = a, this.requestEffectTask(i);
+    } catch (a) {
       try {
         this.disposeEffect(i);
       } catch (l) {
-        throw new AggregateError([r, l], "Effect registration and cleanup failed.");
+        throw new AggregateError([a, l], "Effect registration and cleanup failed.");
       }
-      throw r;
+      throw a;
     }
     return !this.batchDepth && this.effectReadIndex !== this.effectWriteIndex && this.flushEffects(), () => this.disposeEffect(i);
   }
@@ -294,11 +351,11 @@ class y {
         e.flags &= ~f, e.pendingAuthor = void 0;
       else {
         e.flags |= f;
-        const l = this.activeSub !== null && this.activeSub.flags & h ? this.activeSub : null;
-        s ? e.pendingAuthor !== l && (e.pendingAuthor = null) : e.pendingAuthor = l;
+        const a = this.activeSub !== null && this.activeSub.flags & p ? this.activeSub : null;
+        s ? e.pendingAuthor !== a && (e.pendingAuthor = null) : e.pendingAuthor = a;
       }
       const r = e.firstSub;
-      r != null && (!s || this.activeSub !== null && this.activeSub.flags & h) && this.propagateInvalidation(r, !0);
+      r != null && (!s || this.activeSub !== null && this.activeSub.flags & p || e.flags & o) && this.propagateInvalidation(r, !0);
       return;
     }
     if (e.cachedValue === t)
@@ -309,14 +366,21 @@ class y {
   }
   /**
    * Возвращает кеш либо синхронно актуализирует вычисляемое значение.
-   * Неуспешное вычисление не считается значением. Даже ошибочное чтение сохраняет
-   * связь с активным потребителем, чтобы тот мог восстановиться при изменении источника.
+   * Неуспешное вычисление не считается значением. Ошибка getter сохраняет связь
+   * с активным потребителем для восстановления. Повторное чтение во время
+   * первого сбора зависимостей отклоняется до регистрации связи и чтения кеша.
    */
   readComputedValue(e) {
-    const t = e.flags, i = t & (w | g | x), s = i === 0 ? e.cachedValue : i & w ? this.evaluateFirstValue(e) : this.refreshComputedValue(e, t), n = this.activeSub;
+    const t = e.flags;
+    if ((t & (p | x)) === (p | x))
+      throw new Error("Computed value is already being evaluated.");
+    const i = t & (_ | b | k), s = i === 0 ? e.cachedValue : i & _ ? this.evaluateFirstValue(e) : this.refreshComputedValue(e, t);
+    if (e.evaluate === void 0)
+      return s;
+    const n = this.activeSub;
     if (n !== null) {
       const r = n.tailDep;
-      n.flags & k ? (r === null || r.dep !== e) && this.appendInitialDependency(e, n) : this.trackDependency(e, n);
+      n.flags & x ? (r === null || r.dep !== e) && this.appendInitialDependency(e, n) : this.trackDependency(e, n);
     }
     return s;
   }
@@ -326,30 +390,34 @@ class y {
    * Уже прочитанные зависимости сохраняются для последующего уведомления.
    */
   evaluateFirstValue(e) {
-    e.flags = h | k;
-    const t = this.activeSub;
+    const t = e.flags & o, i = e.evaluate;
+    e.flags = t | p | x;
+    const s = this.activeSub;
     this.activeSub = e;
+    let n;
     try {
-      const i = e.evaluate();
-      return e.cachedValue = i, e.flags = e.flags & S ? f : 0, i;
-    } catch (i) {
-      throw e.flags = x, t !== null && this.trackDependency(e, t), i;
+      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 = t;
+      this.activeSub = s;
     }
+    return e.flags & f ? this.refreshComputedValue(e, e.flags) : (e.cachedValue = n, n);
   }
   /**
    * Актуализирует computed: выполняет прямой пересчёт либо проверяет зависимости.
    * После ошибки getter разрешён повторный пересчёт даже без новой записи источника.
    */
-  refreshComputedValue(e, t) {
+  refreshComputedValue(e, t, i = null) {
     try {
-      if (t & (f | S | x))
-        return this.recomputeValue(e) || (e.flags &= ~g), e.cachedValue;
-      const i = e.firstDep;
-      return (i === null || !this.refreshDependencies(e, i) || !this.recomputeValue(e)) && (e.flags &= ~g), e.cachedValue;
-    } catch (i) {
-      throw this.activeSub !== null && this.trackDependency(e, this.activeSub), i;
+      if (t & (f | D | k))
+        return this.recomputeValue(e, i), e.cachedValue;
+      const s = e.firstDep;
+      return s !== null && this.refreshDependencies(e, s) ? this.recomputeValue(e, i) : e.flags &= ~b, e.cachedValue;
+    } catch (s) {
+      throw this.activeSub !== null && this.trackDependency(e, this.activeSub), s;
     }
   }
   /**
@@ -383,32 +451,32 @@ class y {
    */
   reconcileDependency(e, t, i, s) {
     if (t.depCount <= I) {
-      for (let c = s; c !== null; c = c.nextDep)
-        if (c.dep === e)
-          return this.reorderDependency(t, c, i), t.tailDep = c, c;
-      for (let c = i; c !== null; c = c.prevDep)
-        if (c.dep === e)
-          return c;
+      for (let l = s; l !== null; l = l.nextDep)
+        if (l.dep === e)
+          return this.reorderDependency(t, l, i), t.tailDep = l, l;
+      for (let l = i; l !== null; l = l.prevDep)
+        if (l.dep === e)
+          return l;
       return s !== null ? (t.tailDep = this.reuseDepLink(s, e), s) : t.tailDep = this.insertDependency(e, t, i);
     }
     let n = 0, r = s;
     for (; r !== null && n < I; ) {
-      const c = r;
-      if (c.dep === e)
-        return this.reorderDependency(t, c, i), t.tailDep = c, c;
-      r = c.nextDep, ++n;
+      const l = r;
+      if (l.dep === e)
+        return this.reorderDependency(t, l, i), t.tailDep = l, l;
+      r = l.nextDep, ++n;
     }
-    let l = i;
-    for (; l !== null && n < I; ) {
-      const c = l;
-      if (c.dep === e)
-        return c;
-      l = c.prevDep, ++n;
+    let a = i;
+    for (; a !== null && n < I; ) {
+      const l = a;
+      if (l.dep === e)
+        return l;
+      a = l.prevDep, ++n;
     }
-    if (r !== null || l !== null) {
-      const c = T(e, t);
-      if (c !== void 0)
-        return this.reorderDependency(t, c, i), t.tailDep = c, c;
+    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);
   }
@@ -426,7 +494,7 @@ class y {
       prevDep: i,
       nextDep: null
     };
-    return s === null ? e.firstSub = n : s.nextSub = n, e.lastSub = n, i === null ? t.firstDep = n : i.nextDep = n, t.tailDep = n, ++t.depCount, n;
+    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;
   }
   /**
    * Вставляет связь после заданного курсора зависимостей потребителя.
@@ -443,16 +511,17 @@ class y {
     };
     s === null ? e.firstSub = n : s.nextSub = n, e.lastSub = n;
     const r = i === null ? t.firstDep : i.nextDep;
-    return n.nextDep = r, r !== null && (r.prevDep = n), i === null ? t.firstDep = n : i.nextDep = n, ++t.depCount, n;
+    return n.nextDep = r, r !== null && (r.prevDep = n), i === null ? t.firstDep = n : i.nextDep = n, ++t.depCount, t.dependencyIndex?.set(e, n), e.flags & o && this.attachDependencyCleanup(n), n;
   }
   /**
    * Переназначает существующую связь другому производителю.
    * Положение в списке зависимостей потребителя и число его связей сохраняются.
    */
   reuseDepLink(e, t) {
+    const i = e.sub.dependencyIndex;
     this.detachSubLink(e);
-    const i = t.lastSub;
-    return e.dep = t, e.prevSub = i, e.nextSub = null, i === null ? t.firstSub = e : i.nextSub = e, t.lastSub = e, e;
+    const s = t.lastSub;
+    return e.dep = t, e.prevSub = s, e.nextSub = null, s === null ? t.firstSub = e : s.nextSub = e, t.lastSub = e, i?.set(t, e), t.flags & o && this.attachDependencyCleanup(e), e;
   }
   /**
    * Перемещает существующую зависимость после курсора текущего чтения.
@@ -469,24 +538,50 @@ class y {
   /**
    * Удаляет непрочитанный хвост зависимостей завершившегося запуска.
    * 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);
       }
+      i = n;
+    }
+    s !== void 0 && V(s, "Dependency cleanup failed.");
   }
   /**
    * Удаляет связь только из списка потребителей производителя.
    * Список зависимостей потребителя и его счётчик здесь не изменяются.
    * Также исправляет курсор поиска, если он указывал на удаляемую связь.
    */
-  detachSubLink(e) {
-    e.dep.subSearchCursor === e && (e.dep.subSearchCursor = e.nextSub ?? (e.dep.firstSub === e ? void 0 : e.dep.firstSub ?? void 0)), e.prevSub === null ? e.dep.firstSub = e.nextSub : e.prevSub.nextSub = e.nextSub, e.nextSub === null ? e.dep.lastSub = e.prevSub : e.nextSub.prevSub = e.prevSub;
+  detachSubLink(e, t = !1) {
+    e.sub.dependencyIndex?.delete(e.dep);
+    let i;
+    e.dep.flags & o && (i = e.dependencyCleanup, e.dependencyCleanup = void 0, i?.()), this.unlinkSubLink(e, t || i !== void 0);
+  }
+  /** Завершает удаление producer-связи без вызова source cleanup. */
+  unlinkSubLink(e, t) {
+    t && ((e.prevSub === null ? e.dep.firstSub !== e : e.prevSub.nextSub !== e) || (e.nextSub === null ? e.dep.lastSub !== e : e.nextSub.prevSub !== e)) || (e.dep.subSearchCursor === e && (e.dep.subSearchCursor = e.nextSub ?? (e.dep.firstSub === e ? void 0 : e.dep.firstSub ?? void 0)), e.prevSub === null ? e.dep.firstSub = e.nextSub : e.prevSub.nextSub = e.nextSub, e.nextSub === null ? e.dep.lastSub = e.prevSub : e.nextSub.prevSub = e.prevSub);
+  }
+  /** Connects Runtime ownership metadata only for edges whose producer opted in. */
+  attachDependencyCleanup(e) {
+    const i = e.dep.sourceHooks?.onDependency;
+    if (i === void 0)
+      return;
+    const s = e.sub.sourceHooks?.dependencyOwner ?? e.sub.effectTask?.dependencyOwner;
+    s !== void 0 && (e.dependencyCleanup = i(s));
   }
   /**
    * Отсоединяет owned-источник сразу с обеих сторон каждой связи.
@@ -494,14 +589,29 @@ class y {
    * Переводит ожидавших проверку потребителей к повторному вычислению при необходимости.
    */
   releaseSourceSubs(e) {
-    let t = e.firstSub;
+    if (!(e.flags & o)) {
+      let s = e.firstSub;
+      for (; s != null; ) {
+        const n = s.nextSub, r = s.sub;
+        this.detachDependencyLink(s), this.detachSubLink(s);
+        const a = r.flags;
+        (a & (b | p)) === g && (r.flags = a & ~g | f, a & d && this.enqueueEffect(r, e)), s = n;
+      }
+      e.firstSub = e.lastSub = null, e.subSearchCursor = void 0;
+      return;
+    }
+    let t = e.firstSub, i;
     for (; t != null; ) {
-      const i = t.nextSub, s = t.sub;
-      this.detachDependencyLink(t), this.detachSubLink(t);
-      const n = s.flags;
-      (n & (g | h)) === d && (s.flags = n & ~d | f, n & o && this.enqueueEffect(s)), t = i;
+      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.");
   }
   /**
    * Удаляет связь только из списка зависимостей потребителя.
@@ -510,14 +620,15 @@ class y {
    */
   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;
+    (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) {
-    e.flags & v || (e.flags |= v, this.effectQueue[this.effectWriteIndex] = e, ++this.effectWriteIndex);
+  enqueueEffect(e, t) {
+    const i = t !== void 0 && t.flags & o ? t.sourceHooks.token : void 0;
+    i !== void 0 && e.effectTask?.notify?.(i), !(e.flags & v) && (e.flags |= v, this.effectQueue[this.effectWriteIndex] = e, ++this.effectWriteIndex);
   }
   /**
    * Распространяет invalidation от непосредственных к транзитивным потребителям.
@@ -525,31 +636,55 @@ class y {
    * не выполняет. Непосредственное и потенциальное изменения отмечает разными флагами.
    */
   propagateInvalidation(e, t = !1) {
+    this.checkingDepth !== 0 && this.markActiveChecks(e);
     const i = this.invalidationDepth;
     let s = i;
     for (let n = e; n !== null; n = n.nextSub) {
-      const r = n.sub, l = r.flags;
-      let c = 0;
-      l & (g | h) ? l & h && (c = this.invalidateReadDependency(n, r, l)) : (c = l & ~S | (t ? d : f), r.flags = c), c !== 0 && (c & o && !(c & h) ? this.enqueueEffect(r) : r.firstSub !== null && (this.invalidationStack[s++] = r.firstSub));
+      const r = n.sub, a = r.flags;
+      let l = 0;
+      if (a & (b | p) ? a & p ? l = this.invalidateReadDependency(n, r, a) : !t && !(a & f) && (r.flags = a & ~g | f) : (l = a & ~D | (t ? g : f), r.flags = l), l === 0) {
+        if (a & d && a & v) {
+          const u = n.dep.flags & o ? n.dep.sourceHooks.token : void 0;
+          u !== void 0 && r.effectTask?.notify?.(u);
+        } else r.flags & (o | m) && (r.flags & o && r.sourceHooks.onInvalidate?.(r.firstSub !== null), r.flags &= ~m, r.firstSub !== null && (this.invalidationStack[s++] = r.firstSub));
+        continue;
+      }
+      l & d ? (!(l & p) || r.effectTask?.allowScheduleDuringRun === !0) && this.enqueueEffect(r, n.dep) : (!(a & b) && r.flags & o && r.sourceHooks.onInvalidate?.(r.firstSub !== null), r.firstSub !== null && (this.invalidationStack[s++] = r.firstSub));
     }
     for (; s !== i; ) {
       let n = this.invalidationStack[--s];
-      for (; n !== null; ) {
-        const r = n.sub, l = r.flags;
-        let c = 0;
-        if (l & (g | h) ? l & h && (c = this.invalidateReadDependency(n, r, l)) : (c = l & ~S | d, r.flags = c), c !== 0) {
-          if (c & o)
-            this.enqueueEffect(r);
-          else if (r.firstSub !== null) {
+      do {
+        const r = n.sub, a = r.flags;
+        let l = 0;
+        if (a & (b | p) ? a & p && (l = this.invalidateReadDependency(n, r, a)) : (l = a & ~D | g, r.flags = l), l === 0) {
+          if (a & d && a & v) {
+            const u = n.dep.flags & o ? n.dep.sourceHooks.token : void 0;
+            u !== void 0 && r.effectTask?.notify?.(u);
+          } else if (r.flags & (o | m) && (r.flags & o && r.sourceHooks.onInvalidate?.(r.firstSub !== null), r.flags &= ~m, r.firstSub !== null)) {
             n.nextSub !== null && (this.invalidationStack[s++] = n.nextSub), n = r.firstSub;
             continue;
           }
+        } else if (l & d)
+          this.enqueueEffect(r, n.dep);
+        else if (!(a & b) && r.flags & o && r.sourceHooks.onInvalidate?.(r.firstSub !== null), r.firstSub !== null) {
+          n.nextSub !== null && (this.invalidationStack[s++] = n.nextSub), n = r.firstSub;
+          continue;
         }
         n = n.nextSub;
-      }
+      } while (n !== null);
     }
     this.invalidationDepth = i;
   }
+  // Дополнительный обход не вызывает callbacks и проходит уже dirty computed:
+  // флаги обычной invalidation не показывают, какую связь check уже прошёл.
+  markActiveChecks(e) {
+    const t = [e], i = /* @__PURE__ */ new Set();
+    for (; t.length !== 0; )
+      for (let s = t.pop(); s !== null; s = s.nextSub) {
+        const n = s.sub;
+        i.has(n) || (i.add(n), n.flags & L && (n.flags |= E), !(n.flags & d) && n.firstSub !== null && t.push(n.firstSub));
+      }
+  }
   /**
    * Помечает работающего потребителя, только если затронута уже прочитанная связь.
    * Связи за trackedTail принадлежат прошлому запуску и не означают повторную invalidation.
@@ -564,7 +699,7 @@ class y {
         if (r === s)
           return 0;
     }
-    const n = i | S | d;
+    const n = i | D | g;
     return t.flags = n, n;
   }
   /**
@@ -577,7 +712,7 @@ class y {
       if (s === t || s.sub === i)
         continue;
       const n = s.sub, r = n.flags;
-      r & f || (n.flags = r & ~d | f, r & o && this.enqueueEffect(n));
+      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));
     }
   }
   /**
@@ -588,24 +723,52 @@ class y {
    * Неверное значение в кеш не записывается.
    */
   recomputeValue(e, t = null) {
-    const i = e.evaluate;
-    e.tailDep = null;
-    const s = e.flags & ~S | h;
-    e.flags = s;
-    const n = this.activeSub;
-    this.activeSub = e;
-    let r;
+    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 {
-      r = i();
-    } catch (V) {
-      throw this.restoreComputedFailure(e, t), V;
-    } finally {
-      this.activeSub = n;
+      this.restoreComputedFailure(e, t);
+    } catch (s) {
+      throw new AggregateError([i, s], "Computed evaluation and dependency cleanup failed.");
     }
-    const l = e.flags & S, c = s & -268, u = e.tailDep;
-    (u === null ? e.firstDep : u.nextDep) !== null && this.pruneUnreadDependencies(e);
-    const D = e.cachedValue;
-    return e.cachedValue = r, e.flags = l ? f : c, D === r ? !1 : (e.firstSub !== null && this.confirmSubUpdates(e.firstSub, t), !0);
+    throw i;
   }
   /**
    * Восстанавливает связи и состояния после неудачного getter.
@@ -613,7 +776,12 @@ class y {
    * Потребитель исключаемой связи мог уже покинуть активный префикс стека.
    */
   restoreComputedFailure(e, t) {
-    e.flags = e.flags & -144 | x, 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-сигналы перед запуском потребителя.
@@ -626,12 +794,19 @@ class y {
     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;
     }
   }
+  /** Settles every direct dependency so a cancelled external delivery can be re-armed. */
+  settleCancelledDependencies(e) {
+    for (let t = e.firstDep; t !== null; t = t.nextDep) {
+      const i = t.dep, s = i.flags;
+      s & (_ | b | k) && (i.evaluate === void 0 ? s & f && this.commitSignalValue(i, t) : this.refreshComputedValue(i, s, t));
+    }
+  }
   /**
    * Выполняет исходный итеративный обход зависимостей без обработки ошибок внутри цикла.
    * Перед пользовательским вычислением публикует активную высоту стека; оболочка
@@ -639,51 +814,70 @@ class y {
    */
   walkDependencyChain(e, t) {
     const i = this.dependencyDepth;
-    let s = i, n = !1;
-    e: for (; ; ) {
-      if (e.flags & f)
-        n = !0;
-      else {
-        const r = t.dep, l = r.flags;
-        if (l & (f | x))
-          this.dependencyDepth = s, n = r.evaluate === void 0 ? this.commitSignalValue(r, t) : this.recomputeValue(r, t);
-        else if (l & d) {
-          if (r.firstDep !== null) {
-            this.dependencyStack[s++] = t, e = r, t = r.firstDep;
-            continue e;
+    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(r, 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 r = this.dependencyStack[s];
-          if (n = this.recomputeValue(e, r), e = r.sub, !n) {
-            if (r.nextDep !== null) {
-              t = r.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 r = this.dependencyStack[s];
-        if (e.flags &= ~d, e = r.sub, r.nextDep !== null) {
-          t = r.nextDep;
+        if (e.flags & (f | E))
           continue e;
-        }
+        return e.flags &= ~(g | R), this.dependencyDepth = i, !1;
       }
-      return e.flags &= ~d, this.dependencyDepth = i, !1;
+    } finally {
+      e.flags &= ~R;
+      for (let a = i; a < s; a++)
+        this.dependencyStack[a].sub.flags &= ~R;
+      --this.checkingDepth;
     }
   }
   /**
@@ -692,7 +886,11 @@ class y {
    * для следующей invalidation. Вызывается только на ошибочном пути.
    */
   restoreFailedDependency(e) {
-    e.flags &= -16, e.flags & o || (e.flags |= x);
+    if (e.evaluate === void 0) {
+      e.cachedValue = void 0, e.flags = 0;
+      return;
+    }
+    e.flags &= -6160, e.flags & d || (e.flags |= k);
   }
   /**
    * Проверяет необходимость запуска, очищает прошлые ресурсы и выполняет тело эффекта.
@@ -703,22 +901,22 @@ class y {
    */
   executeEffect(e) {
     const t = e.flags;
-    if (!(t & g))
+    if (!(t & b))
       return;
-    if (!(t & (f | S))) {
+    if (!(t & (f | D))) {
       const u = e.firstDep;
       try {
         if (u === null || !this.refreshDependencies(e, u)) {
-          e.flags &= ~g;
+          e.flags &= ~b;
           return;
         }
-      } catch (D) {
-        throw e.flags &= -80, D;
+      } catch (w) {
+        throw e.flags &= -80, w;
       }
     }
     const i = e.evaluate;
     if (i === void 0) {
-      e.flags &= ~g;
+      e.flags &= ~b;
       return;
     }
     let s;
@@ -729,11 +927,11 @@ class y {
         s = [u];
       }
     const n = typeof e.cachedValue == "function" ? e.cachedValue : void 0;
-    if (e.cachedValue = void 0, e.flags &= ~S, n !== void 0)
+    if (e.cachedValue = void 0, e.flags &= ~D, n !== void 0)
       try {
         this.untracked(n);
       } catch (u) {
-        s ?? (s = []), s.push(u);
+        s ??= [], s.push(u);
       }
     if (s !== void 0) {
       try {
@@ -741,32 +939,32 @@ class y {
       } catch (u) {
         s.push(u);
       }
-      E(s, "Effect cleanup failed.");
+      V(s, "Effect cleanup failed.");
     }
     if (e.evaluate === void 0)
       return;
-    e.tailDep = null, e.flags = e.flags & ~S | h;
+    e.tailDep = null, e.flags = e.flags & ~D | p;
     const r = this.activeSub;
     this.activeSub = e;
-    let l;
+    let a;
     try {
-      l = i();
+      a = i();
     } catch (u) {
-      this.activeSub = r, e.flags &= ~h, this.failEffectRun(e, u, s);
+      this.activeSub = r, e.flags &= ~p, this.failEffectRun(e, u, s);
     } finally {
-      this.activeSub = r, e.flags &= ~h;
+      this.activeSub = r, e.flags &= ~p;
     }
-    const c = e.tailDep;
-    if ((c === null ? e.firstDep : c.nextDep) !== null && this.pruneUnreadDependencies(e), typeof l == "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(l);
+          this.untracked(a);
         } catch (u) {
-          s ?? (s = []), s.push(u);
+          s ??= [], s.push(u);
         }
       else
-        e.cachedValue = l;
-    e.flags & v ? e.flags = e.flags & -7 | d : e.flags &= -8;
+        e.cachedValue = a;
+    e.flags & v ? e.flags = e.flags & -7 | g : e.flags &= -8;
   }
   /**
    * Завершает неудачный запуск эффекта, не затрагивая успешный путь исполнения.
@@ -789,7 +987,7 @@ class y {
    * Путь не проверяет наличие внешней задачи у каждого узла.
    */
   flushSyncEffects() {
-    if (!(this.flushingEffects || this.activeSub !== null && (this.activeSub.flags & (o | h)) === (o | h))) {
+    if (!(this.flushingEffects || this.activeSub !== null && (this.activeSub.flags & (d | p)) === (d | p))) {
       this.flushingEffects = !0;
       try {
         for (; this.effectReadIndex !== this.effectWriteIndex; ) {
@@ -809,12 +1007,14 @@ class y {
    * Ошибка одного элемента не оставляет необработанные записи со старым SCHEDULED.
    */
   flushExternalEffects() {
-    if (!(this.flushingEffects || this.activeSub !== null && (this.activeSub.flags & (o | h)) === (o | h))) {
+    if (!(this.flushingEffects || this.activeSub !== null && (this.activeSub.flags & (d | p)) === (d | p))) {
       this.flushingEffects = !0;
       try {
         for (; this.effectReadIndex !== this.effectWriteIndex; ) {
           const e = this.effectReadIndex, t = this.effectQueue[e];
-          this.effectQueue[e] = void 0, ++this.effectReadIndex, t.flags &= ~v, t.effectTask === void 0 ? this.executeEffect(t) : this.requestEffectTask(t);
+          this.effectQueue[e] = void 0, ++this.effectReadIndex;
+          const i = t.effectTask;
+          i === void 0 ? (t.flags &= ~v, this.executeEffect(t)) : t.evaluate !== void 0 ? this.scheduleEffectTask(t, i) : t.flags &= ~v;
         }
       } catch (e) {
         this.drainQueueAfterError(e, !0);
@@ -823,6 +1023,20 @@ class y {
       }
     }
   }
+  // Только ошибочный путь; новые 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));
+        }
+      }
+    }
+  }
   /**
    * Завершает очередь после первой ошибки, собирая последующие причины сбоя.
    * Вызывается только на ошибочном пути; успешный проход не создаёт массив ошибок
@@ -832,9 +1046,10 @@ class y {
     const i = [e];
     for (; this.effectReadIndex !== this.effectWriteIndex; ) {
       const s = this.effectReadIndex++, n = this.effectQueue[s];
-      this.effectQueue[s] = void 0, n.flags &= ~v;
+      this.effectQueue[s] = void 0;
       try {
-        t && n.effectTask !== void 0 ? this.requestEffectTask(n) : this.executeEffect(n);
+        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);
       }
@@ -848,13 +1063,14 @@ class y {
    */
   requestEffectTask(e) {
     const t = e.effectTask;
-    if (!(t === void 0 || e.evaluate === void 0)) {
-      e.flags |= v;
-      try {
-        t.schedule();
-      } catch (i) {
-        throw e.flags &= -72, i;
-      }
+    t === void 0 || e.evaluate === void 0 || (e.flags |= v, this.scheduleEffectTask(e, t));
+  }
+  // Передаёт уже запланированный эффект его постоянной внешней задаче.
+  scheduleEffectTask(e, t) {
+    try {
+      t.schedule();
+    } catch (i) {
+      throw e.flags &= -72, i;
     }
   }
   /**
@@ -866,39 +1082,40 @@ class y {
   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), A(e);
-    let n = e.firstDep;
-    for (; n !== null; ) {
-      const l = n.nextDep;
-      this.detachSubLink(n), n = l;
+    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;
-    let r;
-    if (t !== void 0)
+    if (e.firstDep = e.tailDep = null, e.depCount = 0, A(e), t !== void 0)
       try {
         t.dispose();
-      } catch (l) {
-        r = [l];
+      } catch (r) {
+        n ??= [], n.push(r);
       }
     try {
       this.disposeNestedEffects(e);
-    } catch (l) {
-      r ?? (r = []), r.push(l);
+    } catch (r) {
+      n ??= [], n.push(r);
     }
     if (s !== void 0)
       try {
         this.untracked(s);
-      } catch (l) {
-        r ?? (r = []), r.push(l);
+      } catch (r) {
+        n ??= [], n.push(r);
       }
     if (i !== void 0)
       try {
         this.untracked(i);
-      } catch (l) {
-        r ?? (r = []), r.push(l);
+      } catch (r) {
+        n ??= [], n.push(r);
       }
-    this.invalidationStack.length = this.invalidationDepth, this.dependencyStack.length = this.dependencyDepth, r !== void 0 && E(r, "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.");
   }
   /**
    * Останавливает все вложенные эффекты в обратном порядке регистрации.
@@ -911,16 +1128,16 @@ class y {
       try {
         this.disposeEffect(e.scopeLastChild);
       } catch (i) {
-        t ?? (t = []), t.push(i);
+        t ??= [], t.push(i);
       }
-    t !== void 0 && E(t, "Nested effect disposal failed.");
+    t !== void 0 && V(t, "Nested effect disposal failed.");
   }
   /**
    * Задаёт обязательные поля графа перед первым вычислением.
    * Вызывается только для нематериализованного handle; getter и контекст сохраняются.
    */
   static materializeComputed(e) {
-    e.flags = w, e.firstSub = null, e.lastSub = null, e.firstDep = null, e.tailDep = null, e.depCount = 0, e.cachedValue = void 0;
+    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.
@@ -938,14 +1155,14 @@ class y {
        */
       initializeComputed() {
         const i = this;
-        return y.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;
-        y.materializeComputed(i);
+        N.materializeComputed(i);
         const s = () => e.readComputedValue(i);
         return this.read = s, s();
       },
@@ -989,11 +1206,11 @@ class y {
         u !== void 0 ? t.writeSignalValue(u, r) : i !== r && (i = r);
         return;
       }
-      const l = s;
-      if (l !== void 0)
-        return t.readSignalValue(l);
-      const c = t.activeSub;
-      return c === null || (s = t.materializeSignal(i, c)), i;
+      const a = s;
+      if (a !== void 0)
+        return t.readSignalValue(a);
+      const l = t.activeSub;
+      return l === null || (s = t.materializeSignal(i, l)), i;
     }
     return {
       read: n,
@@ -1019,29 +1236,36 @@ class y {
    *
    * @internal
    */
-  _ownedSignal(e) {
-    const t = this;
-    let i = e, s, n = !1;
-    const r = () => {
-      const u = s;
-      if (u !== void 0)
-        return this.readSignalValue(u);
-      const D = this.activeSub;
-      return D === null || (s = this.materializeSignal(
-        i,
-        D
-      )), i;
-    }, l = (u) => {
-      const D = s;
-      if (D !== void 0) {
-        this.writeSignalValue(D, u);
+  _ownedSignal(e, t) {
+    const i = this;
+    let s = e, n, r = !1;
+    const a = () => {
+      const h = n;
+      if (h !== void 0)
+        return this.readSignalValue(h);
+      const S = this.activeSub;
+      if (S === null)
+        return s;
+      const C = s;
+      return n = this.materializeSignal(
+        C,
+        S,
+        t
+      ), s = void 0, C;
+    }, l = t === void 0 ? (h) => {
+      const S = n;
+      S !== void 0 ? this.writeSignalValue(S, h) : s !== h && (s = h);
+    } : (h) => {
+      const S = n;
+      if (S !== void 0) {
+        const C = S.flags & f ? S.pendingValue : S.cachedValue;
+        C !== h && t.onChange?.(C, h, S.firstSub !== null), this.writeSignalValue(S, h);
         return;
       }
-      i !== u && (i = u);
-    };
-    return {
+      s !== h && (t.onChange?.(s, h, !1), s = h);
+    }, w = {
       source: {
-        get: r,
+        get: a,
         peek: this.handleReaders.peek,
         set: l
       },
@@ -1049,36 +1273,77 @@ class y {
        * Освобождает источник и отсоединяет его от реактивного графа.
        */
       dispose() {
-        return n || (n = !0, i = void 0, s !== void 0 && (t.releaseSourceSubs(s), s.cachedValue = void 0, s.pendingValue = void 0, s.pendingAuthor = void 0, s.flags = 0), s = void 0), !0;
+        if (r)
+          return !0;
+        r = !0, s = void 0;
+        let h;
+        try {
+          t?.onDispose?.(n?.firstSub != null);
+        } catch (S) {
+          (h ??= []).push(S);
+        }
+        if (n !== void 0) {
+          try {
+            i.releaseSourceSubs(n);
+          } catch (S) {
+            (h ??= []).push(S);
+          }
+          n.cachedValue = void 0, n.pendingValue = void 0, n.pendingAuthor = void 0, n.flags = 0;
+        }
+        if (n = void 0, h?.length === 1)
+          throw h[0];
+        if (h !== void 0 && h.length > 1)
+          throw new AggregateError(h, "Owned signal disposal failed.");
+        return !0;
       }
     };
+    return t !== void 0 && (w.hasSubscribers = () => n?.firstSub != null), w;
   }
   /**
    * Создаёт ленивый computed с финализатором исходящих и входящих связей.
    * Финализатор работает и до первого вычисления, не материализуя узел ради очистки.
    * @internal
    */
-  _ownedComputed(e) {
-    const t = this, i = this.createComputedHandle(e);
-    let s = !1;
-    return {
-      source: i,
+  _ownedComputed(e, t) {
+    const i = this, s = this.createComputedHandle(e, t);
+    let n = !1;
+    const r = {
+      source: s,
       /**
        * Отсоединяет принадлежащий источник и освобождает его ссылки.
        * Повторный вызов возвращает true без повторной очистки.
        */
       dispose() {
-        if (s)
+        if (n)
           return !0;
-        s = !0, i.flags !== void 0 && t.releaseSourceSubs(i);
-        let n = i.firstDep;
-        for (; n != null; ) {
-          const r = n.nextDep;
-          t.detachSubLink(n), n = r;
+        n = !0, i.activeSub === s && (i.activeSub = null);
+        const a = [];
+        try {
+          t?.onDispose?.(s.firstSub != null);
+        } catch (u) {
+          a.push(u);
         }
-        return i.firstDep = i.tailDep = null, i.depCount = 0, i.evaluate = void 0, i.cachedValue = void 0, i.flags = 0, !0;
+        if (s.flags !== void 0)
+          try {
+            i.releaseSourceSubs(s);
+          } catch (u) {
+            a.push(u);
+          }
+        const l = s.flags !== void 0;
+        if (s.evaluate = void 0, s.cachedValue = void 0, s.flags = 0, s.tailDep = null, l)
+          try {
+            i.pruneUnreadDependencies(s);
+          } catch (u) {
+            a.push(u);
+          }
+        if (s.firstDep = s.tailDep = null, s.depCount = 0, A(s), a.length === 1)
+          throw a[0];
+        if (a.length > 1)
+          throw new AggregateError(a, "Owned computed disposal failed.");
+        return !0;
       }
     };
+    return t !== void 0 && (r.hasSubscribers = () => s.firstSub != null), r;
   }
   /**
    * Открывает вложенную синхронную границу группировки.
@@ -1110,24 +1375,326 @@ class y {
   _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 N;
-function b() {
-  return N ?? (N = new y());
+let P;
+function y() {
+  return P ??= new N();
 }
-const Q = (a) => b().signal(a);
-function q(a) {
-  return b().computed(a);
+const K = (c) => y().signal(c), Y = (c) => y().reactive(c);
+function X(c) {
+  return y().computed(c);
 }
-const z = (a, e) => b().effect(a, e), H = (a, e, t) => b().watch(a, e, t), B = (a) => b().batch(a), G = (a) => b().untracked(a), P = () => b().scope();
+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 {
-  y as RaphReactivity,
-  _ as ScopeNode,
-  B as batch,
-  q as computed,
-  z as effect,
-  P as scope,
-  Q as signal,
-  G as untracked,
-  H as watch
+  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
 };