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

package/dist/debug/runtime/reactivity/RuntimeReactivity.js

@@ -1,156 +1,550 @@
-var f = Object.defineProperty;
-var p = (s, i, e) => i in s ? f(s, i, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[i] = e;
-var l = (s, i, e) => p(s, typeof i != "symbol" ? i + "" : i, e);
-import { RaphReactivity as A } from "../../reactivity/engine.js";
-let n;
-class g {
-  constructor() {
-    // Хранит binding только на время синхронной регистрации effect.
-    l(this, "_active");
+import { RaphReactivity as y } from "../../reactivity/engine.js";
+import { RaphCrossRuntimeError as k } from "../errors.js";
+import { TASK_TASKLESS as O } from "../phases/RaphPhaseTaskRecord.js";
+import { RuntimeSelector as m } from "./RaphSelector.js";
+import { RaphProducer as T } from "./RaphWorkGraph.js";
+let a, d;
+function A(n) {
+  return { schedule: n, dispose: w };
+}
+let p = 0;
+function R(n) {
+  n.firstSub !== null && ++p;
+}
+function E(n, e, t) {
+  n.firstSub === null && t.delete(e);
+}
+const f = Object.freeze({}), S = Object.freeze({ schedule: w, dispose: w }), N = 64;
+class C {
+  constructor(e) {
+    this.items = [e], this.shared = !1;
+  }
+  /**
+   * Заменяет список его копией, которую ещё не обходит ни одна запись, и
+   * возвращает её. Места наблюдателей в копии те же.
+   */
+  detach() {
+    const e = this.items.slice();
+    return this.items = e, this.shared = !1, e;
   }
+}
+class _ extends T {
   /**
-   * Связывает effect с owner и phase только на время регистрации.
+   * Создаёт signal своим собственным handle. Регистрацию у владельца
+   * выполняет вызывающий код.
    */
-  bind(i) {
-    const e = this._active;
-    return e === void 0 ? { schedule: i, dispose: m } : e.binding(i);
+  constructor(e, t, r, s) {
+    super(e, t, r), this._value = s, this._node = void 0, this._previousSource = void 0, this._writeTaps = void 0, this.source = this;
   }
   /**
-   * Выполняет операцию с текущим effect binding.
+   * Identity producer для задач implicit effects: сам signal.
+   * @internal
    */
-  runWith(i, e) {
-    const t = this._active;
-    this._active = i === void 0 ? void 0 : { binding: i };
+  get token() {
+    return this;
+  }
+  /**
+   * Владелец signal. Engine читает это поле только у потребителей, а signal
+   * потребителем не бывает; getter сохраняет полный контракт source hooks.
+   * @internal
+   */
+  get dependencyOwner() {
+    return this.owner;
+  }
+  /**
+   * Возвращает компактное описание signal для JSON.stringify, логов и diff
+   * неуспешной проверки. К описанию producer добавлен номер signal среди
+   * источников его владельца в порядке регистрации: один и тот же signal
+   * описывается одинаково, сколько бы раз и через какую копию его ни
+   * печатали, а разные живые signals одного владельца различаются номером,
+   * пока он меньше SIGNAL_INDEX_LIMIT. Номер считается проходом по списку
+   * источников только при сериализации и не дальше этой границы: у каждого
+   * источника, зарегистрированного после первых SIGNAL_INDEX_LIMIT, он равен
+   * границе. У освобождённого signal номер равен нулю. Значение в описание не
+   * входит: оно может быть сколь угодно большим и само содержать циклы.
+   */
+  toJSON() {
+    let e = 0;
+    for (let t = this._previousSource; t !== void 0 && e < N; t = t._previousSource)
+      ++e;
+    return {
+      kind: this.kind,
+      owner: this.owner.id,
+      index: e,
+      revision: this.revision,
+      disposed: this.disposed
+    };
+  }
+  /**
+   * Читает значение и регистрирует зависимость активного потребителя.
+   */
+  get() {
+    const e = this.owner, t = e.runtime._getReactivity();
+    v(t, e), e._assertAlive();
+    const r = this._node;
+    if (r !== void 0)
+      return t._readSignalNode(r);
+    const s = this._value, i = t._trackSignalNode(s, this);
+    return i !== void 0 && (this._node = i, this._value = void 0), s;
+  }
+  /**
+   * Читает значение без подписки текущего потребителя.
+   */
+  peek() {
+    const e = this.owner, t = e.runtime._getReactivity();
+    h(t._lifecycle), e._assertAlive();
+    const r = this._node;
+    return r === void 0 ? this._value : t._peekSignalNode(r);
+  }
+  /**
+   * Записывает значение в собственной границе записи Runtime. Граница
+   * открывается и закрывается явными вызовами, без closure.
+   */
+  set(e) {
+    const t = this.owner, r = t.runtime, s = r._getReactivity()._lifecycle, i = s.assertWriteAllowed;
+    i === void 0 ? (h(s), t._assertAlive()) : (t._assertAlive(), i()), r._enterWrite();
     try {
-      return e();
-    } finally {
-      this._active = t;
+      this._write(e);
+    } catch (o) {
+      throw r._failWrite(o);
     }
+    r._exitWrite();
+  }
+  /**
+   * Записывает значение внутри уже открытой границы записи, минуя политику
+   * actions: так Runtime продвигает собственный frame signal.
+   * @internal
+   */
+  _writeInBoundary(e) {
+    const t = this.owner;
+    h(t.runtime._getReactivity()._lifecycle), t._assertAlive(), this._write(e);
+  }
+  /**
+   * Подключает наблюдателя фактических записей этого signal. Наблюдатель
+   * вызывается синхронно внутри границы записи, после того как новое значение
+   * стало видимым для чтения, и до выхода из записи. Запись, которая уже идёт,
+   * нового наблюдателя не вызывает. Цена подключения не зависит от числа
+   * наблюдателей.
+   * @internal
+   */
+  _addWriteTap(e) {
+    const t = this._writeTaps;
+    if (t === void 0) {
+      e._tapSlot = 0, this._writeTaps = new C(e);
+      return;
+    }
+    const r = t.shared ? t.detach() : t.items;
+    e._tapSlot = r.length, r.push(e);
+  }
+  /**
+   * Отключает наблюдателя записей: его место занимает последний наблюдатель
+   * списка. Запись, которая уже идёт, ещё вызовет отключённого наблюдателя.
+   * Отключение неизвестного наблюдателя и отключение у освобождённого signal
+   * безопасны. Цена отключения не зависит от числа наблюдателей.
+   * @internal
+   */
+  _removeWriteTap(e) {
+    const t = this._writeTaps;
+    if (t === void 0)
+      return;
+    const r = e._tapSlot;
+    if (r < 0 || t.items[r] !== e)
+      return;
+    if (e._tapSlot = -1, t.items.length === 1) {
+      this._writeTaps = void 0;
+      return;
+    }
+    const s = t.shared ? t.detach() : t.items, i = s.pop();
+    i !== e && (s[r] = i, i._tapSlot = r);
+  }
+  /**
+   * Сообщает WorkGraph о фактической записи до распространения по графу.
+   * @internal
+   */
+  onChange(e, t, r) {
+    this.owner.runtime._getWorkGraph()._notifyValueWrite(
+      this,
+      e,
+      t,
+      r
+    );
+  }
+  /**
+   * Освобождает producer-сторону signal в WorkGraph.
+   * @internal
+   */
+  onDispose(e) {
+    this.owner.runtime._getWorkGraph()._disposeProducer(this, e);
+  }
+  /**
+   * Ищет среди текущих потребителей signal в графе первого, чьего владельца
+   * принимает accept, и возвращает этого владельца. Signal не ведёт учёта
+   * своих implicit-рёбер и не имеет hook onDependency: рёбра читаются из
+   * записи графа только по запросу. У signal без записи графа потребителей
+   * нет: его ещё не читал ни один потребитель либо он уже освобождён.
+   * Владельцы наблюдателей записи считаются потребителями наравне с ними.
+   * @internal
+   */
+  _findConsumerOwner(e, t) {
+    const r = this._writeTaps;
+    if (r !== void 0) {
+      const i = r.items;
+      for (let o = 0; o < i.length; o++) {
+        const c = i[o]._tapOwner;
+        if (e(c, t))
+          return c;
+      }
+    }
+    const s = this._node;
+    return s === void 0 ? void 0 : this.owner.runtime._getReactivity()._findSubscriberOwner(s, e, t);
+  }
+  /**
+   * Освобождает signal как источник владельца: публикует финальную причину,
+   * отсоединяет запись графа и отпускает значение. Сбой одного шага не
+   * отменяет остальные. Повторный вызов безопасен.
+   * @internal
+   */
+  _finalizeSource() {
+    if (this.disposed)
+      return !0;
+    this._value = void 0, this._writeTaps = void 0;
+    const e = this._node, t = this.owner.runtime._getReactivity();
+    let r;
+    try {
+      this.onDispose(e !== void 0 && t._signalNodeHasSubscribers(e));
+    } catch (s) {
+      (r ??= []).push(s);
+    }
+    if (e !== void 0) {
+      this._node = void 0;
+      try {
+        t._releaseSignalNode(e);
+      } catch (s) {
+        (r ??= []).push(s);
+      }
+    }
+    if (r !== void 0)
+      throw r.length === 1 ? r[0] : new AggregateError(r, "Owned signal disposal failed.");
+    return !0;
+  }
+  /**
+   * Записывает значение без проверок lifetime и без границы записи.
+   * Критерий изменения — ===, как у записи графа.
+   */
+  _write(e) {
+    const t = this._writeTaps;
+    if (t !== void 0) {
+      this._writeTapped(e, t);
+      return;
+    }
+    const r = this._node;
+    if (r !== void 0) {
+      const i = this.owner.runtime, o = i._getReactivity(), c = o._visibleSignalValue(r);
+      c !== e && i._getWorkGraph()._notifyValueWrite(this, c, e, r.firstSub !== null), o._writeSignalNode(r, e);
+      return;
+    }
+    const s = this._value;
+    s !== e && (this.owner.runtime._getWorkGraph()._notifyValueWrite(this, s, e, !1), this._value = e);
+  }
+  /**
+   * Запись signal с наблюдателями. Отличается от `_write()` двумя вещами.
+   * Причина записи публикуется и тогда, когда потребители есть только у
+   * наблюдателя: их будит эта же запись. После того как новое значение стало
+   * видимым, каждый наблюдатель получает прежнее и новое значение. Сбой
+   * распространения по графу или одного наблюдателя не отменяет остальных.
+   *
+   * Запись обходит тот список наблюдателей, который застала: подключение и
+   * отключение во время обхода меняют его копию.
+   */
+  _writeTapped(e, t) {
+    const r = this._node, s = this.owner.runtime._getReactivity(), i = r === void 0 ? this._value : s._visibleSignalValue(r);
+    if (i === e)
+      return;
+    const o = t.items;
+    t.shared = !0;
+    let c = r !== void 0 && s._signalNodeHasSubscribers(r);
+    for (let u = 0; !c && u < o.length; u++)
+      c = o[u]._observesWrites();
+    this.onChange(i, e, c);
+    let l;
+    if (r === void 0)
+      this._value = e;
+    else
+      try {
+        s._writeSignalNode(r, e);
+      } catch (u) {
+        l = [u];
+      }
+    for (let u = 0; u < o.length; u++)
+      try {
+        o[u]._afterSourceWrite(i, e);
+      } catch (b) {
+        (l ??= []).push(b);
+      }
+    if (l !== void 0)
+      throw l.length === 1 ? l[0] : new AggregateError(l, "[Raph] Signal write and its observers failed.");
   }
 }
-class O extends A {
+class g extends y {
   /**
    * Создаёт policy adapter реактивного графа для одного runtime.
+   * @param _lifecycle Политика lifetime и записи Runtime; её читают handles
+   * этого графа, поэтому поле доступно внутри пакета.
    */
   constructor(e, t = {}) {
-    const o = new g();
     super({
       ...t.adaptiveDependencyIndex === void 0 ? {} : { adaptiveDependencyIndex: t.adaptiveDependencyIndex },
-      effectScheduler: {
-        bind: o.bind.bind(o)
+      effectScheduler: { bind: A }
+    }), this._lifecycle = e, this._phaseBody = () => {
+      const r = this._activeEffectTask(), s = r.consumerOwner, i = a, o = d;
+      a = e, d = s;
+      let c;
+      try {
+        const l = r.effect;
+        c = l(r.state & O ? r.group : r.task);
+      } finally {
+        a = i, d = o;
       }
-    });
-    // Изолирует registration binding от алгоритмов базового reactive graph.
-    l(this, "_bindings");
-    this._lifecycle = e, this._bindings = o;
-  }
-  /**
-   * Создаёт временную registration boundary для runtime effect.
-   */
-  withEffectBinding(e, t) {
-    return this._bindings.runWith(e, t);
+      return typeof c == "function" ? D(this, c) : c;
+    }, g._releasedShapeAnchor ??= W(this);
   }
   /**
    * Выполняет untracked-операцию, сохраняя runtime owner context.
    */
   untrackedWithOwner(e) {
-    const t = n;
-    n = void 0;
+    const t = a, r = d;
+    a = void 0, d = void 0;
     try {
       return this.untracked(e);
     } finally {
-      n = t;
+      a = t, d = r;
+    }
+  }
+  /**
+   * Вызывает операцию с её аргументами вне Runtime owner context и вне graph
+   * consumer: форма `untrackedWithOwner(() => operation(...args))` без closure.
+   * Closure создаётся, только когда вызов пришёл изнутри отслеживаемого
+   * вычисления и graph consumer нужно снять.
+   *
+   * @internal
+   */
+  _applyUntrackedWithOwner(e, t) {
+    const r = a, s = d;
+    a = void 0, d = void 0;
+    try {
+      return this._isTracking() ? this.untracked(() => e(...t)) : e(...t);
+    } finally {
+      a = r, d = s;
+    }
+  }
+  /**
+   * Выполняет одну открытую доставку phase effect вне Runtime owner context и
+   * вне graph consumer: форма untrackedWithOwner() без closure для записи,
+   * подготовленной через _beginTaskEffectRun().
+   *
+   * @internal
+   */
+  _runTaskEffectUntracked(e) {
+    const t = a, r = d;
+    a = void 0, d = void 0;
+    try {
+      this._finishTaskEffectRun(e);
+    } finally {
+      a = t, d = r;
     }
   }
   /**
    * Возвращает owner текущего синхронного реактивного контекста.
    */
   getActiveOwner() {
-    return n == null ? void 0 : n.lifecycle.owner;
+    return a === void 0 ? void 0 : a.owner;
   }
   /** Returns the Runtime resource owner whose implicit dependencies are being collected. */
   getActiveConsumerOwner() {
-    return n == null ? void 0 : n.consumerOwner;
+    return d;
   }
   /**
    * Сообщает, должен ли untracked work очищать graph consumer или Runtime owner context.
    */
   hasActiveContext() {
-    return n !== void 0 || this._isTracking();
+    return a !== void 0 || this._isTracking();
   }
   /**
    * Выполняет операцию с указанным active owner.
    */
-  runWithOwner(e, t, o) {
-    const d = n;
-    n = e === void 0 ? void 0 : { consumerOwner: t, lifecycle: e };
+  runWithOwner(e, t, r) {
+    const s = a, i = d;
+    a = e, d = e === void 0 ? void 0 : t;
     try {
-      return o();
+      return r();
     } finally {
-      n = d;
+      a = s, d = i;
     }
   }
   /**
-   * Создаёт owned signal с runtime lifecycle policy.
+   * Ищет среди текущих потребителей Runtime signals владельца `sourceOwner`
+   * первого, чьего владельца принимает accept, и возвращает этого владельца.
+   * Signals обходятся от нового к старому по списку источников владельца;
+   * остальные источники списка пропускаются: их рёбра учитывает сам WorkGraph.
+   * Обход ничего не выделяет. Его цена — длина списка источников владельца
+   * плюс потребители каждого его signal с записью графа до первого принятого.
+   *
+   * @internal
    */
-  signalForOwner(e, t, o, d) {
-    const r = this._lifecycle, c = t._adoptSource(this._ownedSignal(e, o)), _ = r.assertWriteAllowed, h = r.runWrite ?? k;
-    return d == null || d((v) => {
-      u(r), t._assertAlive(), c.set(v);
-    }), _ !== void 0 ? {
-      get() {
-        return a(r, t), t._assertAlive(), c.get();
-      },
-      peek() {
-        return u(r), t._assertAlive(), c.peek();
-      },
-      set(v) {
-        t._assertAlive(), _(), h(() => c.set(v));
-      }
-    } : {
-      get() {
-        return a(r, t), t._assertAlive(), c.get();
-      },
-      peek() {
-        return u(r), t._assertAlive(), c.peek();
-      },
-      set(v) {
-        u(r), t._assertAlive(), h(() => c.set(v));
-      }
-    };
+  _findSignalConsumerOwner(e, t, r) {
+    for (let s = e._lastOwnedSource(); s !== void 0; s = s._previousSource) {
+      if (!(s instanceof _) && !(s instanceof m))
+        continue;
+      const i = s._findConsumerOwner(t, r);
+      if (i !== void 0)
+        return i;
+    }
+  }
+  /**
+   * Проверяет отслеживаемое чтение источника владельца `sourceOwner` теми же
+   * правилами, что и чтение его Runtime signal: Runtime жив, активный
+   * потребитель принадлежит этому Runtime и вправе неявно зависеть от
+   * владельца. Lifetime самого владельца проверяет вызывающий код.
+   *
+   * @internal
+   */
+  _assertTrackedRead(e) {
+    v(this, e);
+  }
+  /**
+   * Сообщает, что у записи ровно один потребитель. Внутри cleanup связи,
+   * который engine вызывает до снятия этой связи со списка, ответ `true`
+   * означает, что снимается последняя связь записи.
+   *
+   * @internal
+   */
+  _hasSingleSubscriber(e) {
+    const t = e.firstSub;
+    return t !== null && t === e.lastSub;
+  }
+  /**
+   * Считает записи, у которых есть потребители, в двух частях одного индекса:
+   * в ряду, где пустое место хранит undefined, и в индексе по ключам, если он
+   * есть. Ряд обходится циклом без вызовов. Обход ничего не выделяет и не
+   * меняет граф.
+   *
+   * @internal
+   */
+  _countObserved(e, t) {
+    let r = 0;
+    for (let s = 0; s < e.length; s++) {
+      const i = e[s];
+      i !== void 0 && i.firstSub !== null && ++r;
+    }
+    return t !== void 0 && t.size !== 0 && (p = 0, t.forEach(R), r += p), r;
+  }
+  /**
+   * Убирает записи без потребителей из обеих частей индекса: место ряда
+   * становится пустым, запись индекса по ключам удаляется. Возвращает число
+   * мест ряда, оставшихся занятыми. Сами записи не освобождаются: без
+   * потребителей и без ссылки из индекса они недостижимы.
+   *
+   * @internal
+   */
+  _dropUnobserved(e, t) {
+    let r = 0;
+    for (let s = 0; s < e.length; s++) {
+      const i = e[s];
+      i !== void 0 && (i.firstSub === null ? e[s] = void 0 : ++r);
+    }
+    return t !== void 0 && t.size !== 0 && t.forEach(E), r;
+  }
+  /**
+   * Создаёт selector над записываемым Runtime signal и ставит его в список
+   * источников владельца. Source должен быть доступен владельцу для implicit
+   * чтения: принадлежать ему самому, его предку или root scope. Тогда source
+   * переживает selector, а потребители selector могли бы читать source сами.
+   */
+  selectorForOwner(e, t, r) {
+    if (!(e instanceof _))
+      throw new TypeError("[Raph] selector() source must be a writable Runtime signal.");
+    const s = r?.equals;
+    if (s !== void 0 && typeof s != "function")
+      throw new TypeError("[Raph] selector() equals must be a function.");
+    const i = e.owner;
+    if (i.runtime !== t.runtime)
+      throw new k("[Raph] selector() source belongs to another runtime.");
+    i._assertAlive(), this._lifecycle.assertDependencyAllowed(i, t);
+    const o = new m(t, this, e, s);
+    try {
+      t._adoptSourceEntry(o);
+    } catch (c) {
+      throw o._finalizeSource(), c;
+    }
+    return o;
+  }
+  /**
+   * Создаёт Runtime signal и ставит его в список источников владельца. Signal
+   * одним объектом является handle, producer WorkGraph и записью источника.
+   */
+  signalForOwner(e, t, r = "producer", s = !0) {
+    const i = new _(t, r, s, e);
+    return t._adoptSourceEntry(i), i;
   }
   /**
    * Создаёт owned computed с runtime lifecycle policy.
    */
-  computedForOwner(e, t, o) {
-    const d = this._lifecycle, r = t._adoptSource(this._ownedComputed(e, o));
+  computedForOwner(e, t, r) {
+    const s = this._lifecycle, i = t._adoptSource(this._ownedComputed(e, r));
     return {
-      get() {
-        a(d, t), t._assertAlive();
-        const c = r.get();
-        return t._assertAlive(), c;
+      get: () => {
+        v(this, t), t._assertAlive();
+        const o = i.get();
+        return t._assertAlive(), o;
       },
       peek() {
-        u(d), t._assertAlive();
-        const c = r.peek();
-        return t._assertAlive(), c;
+        h(s), t._assertAlive();
+        const o = i.peek();
+        return t._assertAlive(), o;
       }
     };
   }
 }
-function u(s) {
-  s.owner === void 0 && s.throwDisposed();
+g._releasedShapeAnchor = void 0;
+function W(n) {
+  let e, t;
+  const r = n._allocateTaskEffect(() => {
+    e = n._trackSignalNode(void 0, f), t = n._trackSignalNode(void 0, f);
+  }, S);
+  n._requestTaskEffect(r, !1), n._beginTaskEffectRun(r), n._finishTaskEffectRun(r);
+  const s = e.firstSub;
+  n._disposeTaskEffect(r), n.batch(() => n._writeSignalNode(t, 0)), n._releaseSignalNode(e), n._releaseSignalNode(t);
+  let i, o;
+  const c = n._allocateTaskEffect(() => {
+    i = n._trackCounterNode(f), o = n._trackCounterNode(f);
+  }, S);
+  return n._requestTaskEffect(c, !1), n._beginTaskEffectRun(c), n._finishTaskEffectRun(c), n.batch(() => {
+    n._bumpSignalNode(o);
+  }), n._disposeTaskEffect(c), n._releaseSignalNode(i), n._releaseSignalNode(o), { source: e, written: t, edge: s, consumer: r, counter: i, bumped: o };
+}
+function D(n, e) {
+  return () => n.untrackedWithOwner(e);
 }
-function a(s, i) {
-  u(s);
-  const e = n;
-  e !== void 0 && e.lifecycle !== s && s.throwCrossRuntime(e.lifecycle.owner), (e == null ? void 0 : e.consumerOwner) !== void 0 && s.assertDependencyAllowed(i, e.consumerOwner);
+function h(n) {
+  n.owner === void 0 && n.throwDisposed();
 }
-function k(s) {
-  return s();
+function v(n, e) {
+  const t = n._lifecycle;
+  h(t);
+  const r = a;
+  if (r !== void 0) {
+    r !== t && t.throwCrossRuntime(r.owner);
+    const i = d;
+    i !== void 0 && i !== e && t.assertDependencyAllowed(e, i);
+    return;
+  }
+  const s = n._activeSubscriberOwner();
+  s !== void 0 && t.assertDependencyAllowed(e, s);
 }
-function m() {
+function w() {
 }
 export {
-  O as RuntimeReactivity
+  g as RuntimeReactivity,
+  _ as RuntimeSignal,
+  N as SIGNAL_INDEX_LIMIT
 };

package/dist/debug/runtime/reactivity/RuntimeWatch.cjs

@@ -1 +1 @@
-"use strict";var p=Object.defineProperty;var c=(i,e,t)=>e in i?p(i,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):i[e]=t;var r=(i,e,t)=>c(i,typeof e!="symbol"?e+"":e,t);Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class h{constructor(e,t){r(this,"_cleanup");r(this,"_stopped",!1);r(this,"deliver",()=>{if(this._stopped)return;const e=this._cleanup;if(e===void 0){const t=this._callback();if(typeof t!="function")return;this._stopped?this._runUntracked(t):this._cleanup=t;return}this._deliverWithCleanup(e)});this._runUntracked=e,this._callback=t}get stopped(){return this._stopped}_deliverWithCleanup(e){const t=[];if(this._cleanup=void 0,this._attempt(e,t),!this._stopped){let n=null;try{const s=this._runUntracked(this._callback);typeof s=="function"&&(n=s)}catch(s){t.push(s)}n!==null&&(this._stopped?this._attempt(n,t):this._cleanup=n)}a(t)}stop(e){if(this._stopped)return;this._stopped=!0;const t=[];if(e!==void 0)try{e()}catch(s){t.push(s)}const n=this._cleanup;this._cleanup=void 0,n!==void 0&&this._attempt(n,t),a(t)}_attempt(e,t){try{this._runUntracked(e)}catch(n){t.push(n)}}}function a(i){if(i.length===1)throw i[0];if(i.length>1)throw new AggregateError(i,"[Raph] Runtime watch delivery failed.")}exports.RuntimeWatch=h;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class h{constructor(s,t){this._cleanup=void 0,this._stopped=!1,this._runUntracked=s,this._callback=t,this.deliver=()=>{if(this._stopped)return;const e=this._cleanup;if(e===void 0){const i=this._callback();if(typeof i!="function")return;this._stopped?this._runUntracked(i):this._cleanup=i;return}this._deliverWithCleanup(e)}}get stopped(){return this._stopped}_deliverWithCleanup(s){const t=[];if(this._cleanup=void 0,this._attempt(s,t),!this._stopped){let e=null;try{const i=this._runUntracked(this._callback);typeof i=="function"&&(e=i)}catch(i){t.push(i)}e!==null&&(this._stopped?this._attempt(e,t):this._cleanup=e)}r(t)}stop(s){if(this._stopped)return;this._stopped=!0;const t=[];if(s!==void 0)try{s()}catch(i){t.push(i)}const e=this._cleanup;this._cleanup=void 0,e!==void 0&&this._attempt(e,t),r(t)}_attempt(s,t){try{this._runUntracked(s)}catch(e){t.push(e)}}}function r(n){if(n.length===1)throw n[0];if(n.length>1)throw new AggregateError(n,"[Raph] Runtime watch delivery failed.")}exports.RuntimeWatch=h;