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

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

@@ -0,0 +1,1157 @@
+import { RaphDisposedError as w, RaphCrossRuntimeError as j } from "../errors.js";
+import { throwDisposalErrors as _ } from "../ownership/throwDisposalErrors.js";
+class v {
+  constructor(e, t, s) {
+    this.owner = e, this.kind = t, this.includeRuntime = s, this.subscribers = void 0, this.memberships = void 0, this.implicitConsumers = void 0, this.source = void 0, this.activate = void 0, this.runtimeActivation = void 0, this.lastCause = void 0, this.transientNext = void 0, this.revision = 0, this.disposed = !1;
+  }
+  get runtime() {
+    return this.owner.runtime;
+  }
+  /**
+   * Тег Object.prototype.toString: `[object RaphProducer]`. По нему инструменты,
+   * которые копируют и обходят только plain objects, принимают producer за
+   * неделимое значение: тестовый runner не клонирует его вместе со всем графом
+   * Runtime перед печатью diff. Accessor лежит на prototype.
+   */
+  get [Symbol.toStringTag]() {
+    return "RaphProducer";
+  }
+  /**
+   * Возвращает компактное описание вместо собственных полей. Поля producer
+   * ведут к владельцу, Runtime и графу зависимостей: без этого метода
+   * JSON.stringify упирался бы в циклы, а печать значения в логах и в diff
+   * неуспешной проверки тестового runner-а обходила бы весь граф Runtime.
+   * Метод лежит на prototype и не добавляет producer ни поля, ни closure.
+   */
+  toJSON() {
+    return {
+      kind: this.kind,
+      owner: this.owner.id,
+      revision: this.revision,
+      disposed: this.disposed
+    };
+  }
+}
+v.prototype._isProducer = !0;
+const R = /* @__PURE__ */ new WeakMap(), k = Object.freeze([]), A = Object.freeze([]);
+class p {
+  /** @internal */
+  constructor(e, t) {
+    this.owner = e, this._sources = H(t);
+  }
+  _sources;
+  _disposed = !1;
+  _releaseOwner;
+  _memberReleases;
+  _firstSubscription;
+  _lastSubscription;
+  _firstDependent;
+  _lastDependent;
+  _revision = 0;
+  _finalCause;
+  /** @internal */
+  static _create(e, t) {
+    return new p(e, t);
+  }
+  get runtime() {
+    return this.owner.runtime;
+  }
+  get disposed() {
+    return this._disposed;
+  }
+  get sources() {
+    return this._sources;
+  }
+  dispose() {
+    if (this._disposed)
+      return;
+    const e = this.runtime, t = !e._ownerDisposalActive();
+    t && e._beginOwnerDisposal();
+    const s = [];
+    try {
+      const i = this._releaseOwner;
+      i !== void 0 ? (this._releaseOwner = void 0, i()) : this._disposeOwned();
+    } catch (i) {
+      s.push(i);
+    } finally {
+      if (t)
+        try {
+          e._endOwnerDisposal();
+        } catch (i) {
+          s.push(i);
+        }
+    }
+    _(s, "[Raph] Aggregate disposal failed.");
+  }
+  /** @internal */
+  _assertAlive() {
+    if (this._disposed || this.owner.disposed)
+      throw new w("[Raph] Aggregate is disposed.");
+  }
+  /** @internal */
+  _bindOwner(e) {
+    this._releaseOwner = e;
+  }
+  /** @internal */
+  _bindMembers(e) {
+    this._memberReleases = e.length === 0 ? void 0 : e;
+  }
+  /** @internal */
+  _removeMember(e) {
+    if (this._disposed)
+      return;
+    const t = this._sources.filter((s) => W(s) !== e);
+    t.length !== this._sources.length && (this._sources = t.length === 0 ? k : Object.freeze(t));
+  }
+  /** @internal */
+  _disposeOwned() {
+    if (this._disposed)
+      return;
+    this._disposed = !0, this._releaseOwner = void 0;
+    const e = d(this.owner) && !this.owner._isPublished() ? void 0 : this._disposalCause(), t = [];
+    let s = this._firstSubscription;
+    for (this._firstSubscription = this._lastSubscription = void 0; s !== void 0; ) {
+      const o = s.next, u = s.dispose;
+      s.aggregate = void 0, s.dispose = void 0, s.previous = s.next = void 0;
+      try {
+        u?.(e);
+      } catch (c) {
+        t.push(c);
+      }
+      s = o;
+    }
+    const i = this._memberReleases;
+    if (this._memberReleases = void 0, i !== void 0)
+      for (let o = i.length - 1; o >= 0; o--)
+        try {
+          i[o]();
+        } catch (u) {
+          t.push(u);
+        }
+    this._sources = k;
+    let r = this._firstDependent;
+    for (this._firstDependent = this._lastDependent = void 0; r !== void 0; ) {
+      const o = r.next, u = r.cleanup;
+      r.source = void 0, r.cleanup = void 0, r.previous = r.next = void 0;
+      try {
+        u?.();
+      } catch (c) {
+        t.push(c);
+      }
+      r = o;
+    }
+    _(t, "[Raph] Aggregate owned cleanup failed.");
+  }
+  /** @internal */
+  _linkSubscription(e) {
+    this._assertAlive();
+    const t = {
+      aggregate: this,
+      dispose: e,
+      previous: this._lastSubscription
+    };
+    return this._lastSubscription === void 0 ? this._firstSubscription = t : this._lastSubscription.next = t, this._lastSubscription = t, () => K(t);
+  }
+  /** @internal */
+  _linkDependent(e) {
+    e.previous = this._lastDependent, this._lastDependent === void 0 ? this._firstDependent = e : this._lastDependent.next = e, this._lastDependent = e;
+  }
+  /** @internal */
+  _detachDependent(e) {
+    e.previous === void 0 ? this._firstDependent = e.next : e.previous.next = e.next, e.next === void 0 ? this._lastDependent = e.previous : e.next.previous = e.previous, e.previous = e.next = void 0;
+  }
+  /** @internal */
+  _disposalCause() {
+    return this._finalCause ??= Object.freeze({
+      kind: "structure",
+      source: this,
+      sourceOwner: this.owner,
+      revision: ++this._revision,
+      metadata: Object.freeze({ disposed: !0 })
+    });
+  }
+  /** @internal */
+  _detachSubscription(e) {
+    if (e.aggregate === void 0)
+      return;
+    const t = e.dispose;
+    e.aggregate = void 0, e.dispose = void 0, e.previous === void 0 ? this._firstSubscription = e.next : e.previous.next = e.next, e.next === void 0 ? this._lastSubscription = e.previous : e.next.previous = e.previous, e.previous = e.next = void 0, t?.();
+  }
+}
+class G {
+  constructor(e) {
+    this._runtime = e;
+  }
+  _selfSubscribers;
+  _subtreeSubscribers;
+  _runtimeSubscribers;
+  _runtimeSubscriberCount = 0;
+  _runtimeActivationProducers;
+  _nodeMemberships;
+  _nodeRevisions;
+  _nodeTouchKeys;
+  _implicitProducers;
+  _transientProducers;
+  _dispatchDepth = 0;
+  _detachedEdges;
+  _disposed = !1;
+  createProducer(e, t = "producer", s = {}) {
+    return this._assertAlive(), new v(e, t, s.includeRuntime ?? !0);
+  }
+  attachProducer(e, t) {
+    const s = e.source;
+    return s !== void 0 && s !== e && R.delete(s), e.source = t, R.set(t, e), t;
+  }
+  setProducerActivation(e, t, s = !1) {
+    if (e.disposed)
+      throw new w("[Raph] Producer is disposed.");
+    if (e.activate = t, !s)
+      return;
+    const i = this._runtimeActivationProducers ??= /* @__PURE__ */ new Set();
+    if (i.add(e), this._runtimeSubscriberCount !== 0)
+      try {
+        e.runtimeActivation = x(t());
+      } catch (r) {
+        throw i.delete(e), i.size === 0 && (this._runtimeActivationProducers = void 0), r;
+      }
+  }
+  producerHooks(e) {
+    return {
+      token: e,
+      dependencyOwner: e.owner,
+      onDependency: (t) => this._linkImplicitDependency(e, t),
+      onChange: (t, s, i) => {
+        this.notifyProducer(e, t, s, void 0, !0, i, !0);
+      },
+      onInvalidate: (t) => this.notifyProducer(
+        e,
+        void 0,
+        void 0,
+        void 0,
+        !0,
+        t,
+        !1
+      ),
+      onDispose: (t) => this._disposeProducer(e, t)
+    };
+  }
+  /**
+   * Возвращает последнюю причину producer, который engine назвал своим token.
+   * Token чужого Runtime и значение, не являющееся producer, причины не имеют.
+   *
+   * Метод вызывается на каждое уведомление implicit consumer, поэтому producer
+   * распознаётся prototype-брендом, а Runtime читается у владельца напрямую:
+   * без `instanceof` и без accessor.
+   */
+  causeForToken(e) {
+    if (typeof e != "object" || e === null)
+      return;
+    const t = e;
+    if (!(t._isProducer !== !0 || t.owner.runtime !== this._runtime))
+      return t.lastCause;
+  }
+  /** Clears mutation-local payloads after engine propagation consumed them. */
+  clearTransientCauses() {
+    let e = this._transientProducers;
+    for (this._transientProducers = void 0; e !== void 0; ) {
+      const t = e.transientNext;
+      e.transientNext = void 0, e.lastCause = void 0, e = t;
+    }
+  }
+  notifyProducer(e, t, s, i, r = !0, o = !1, u = !1) {
+    if (this._disposed || e.disposed || e.source === void 0 || d(e.owner) && !e.owner._isPublished() || !u && i === void 0 && e.lastCause !== void 0)
+      return;
+    if (!o && e.subscribers?.first === void 0 && (!e.includeRuntime || this._runtimeSubscribers?.first === void 0)) {
+      this._dispatchProducerLazily(e, t, s, i, r, u);
+      return;
+    }
+    const c = u && i === void 0 ? y(
+      e.kind,
+      e.source,
+      e.owner,
+      ++e.revision,
+      t,
+      s
+    ) : {
+      kind: e.kind,
+      source: e.source,
+      sourceOwner: e.owner,
+      revision: ++e.revision,
+      ...u ? { previous: t, value: s } : {},
+      ...i === void 0 ? {} : { events: Object.freeze([...i]) }
+    };
+    this._setTransientCause(e, c), this._dispatchProducer(e, c, r);
+  }
+  /**
+   * Публикует запись значения producer: форма `notifyProducer()` для причины с
+   * `previous` и `value`, без events и с планированием. Так свою запись
+   * публикует Runtime signal.
+   *
+   * Причина создаётся при тех же условиях и с теми же полями. Отличие в цене:
+   * у producer с implicit consumers, на который не подписан ни один watch, ни
+   * его node, ни поддерево, ни Runtime, причину получают только consumers через
+   * `causeForToken()`. Тогда обход подписчиков не начинается: запись не строит
+   * массив предков и не выполняет ни одного вызова на каждого из них.
+   *
+   * @internal
+   */
+  _notifyValueWrite(e, t, s, i) {
+    const r = e.source;
+    if (this._disposed || e.disposed || r === void 0)
+      return;
+    const o = e.owner;
+    if (o._isNode && !o._isPublished())
+      return;
+    const u = e.subscribers;
+    if (!i && u?.first === void 0 && (!e.includeRuntime || this._runtimeSubscribers?.first === void 0)) {
+      this._dispatchProducerLazily(e, t, s, void 0, !0, !0);
+      return;
+    }
+    const c = y(e.kind, r, o, ++e.revision, t, s);
+    e.lastCause === void 0 && (e.transientNext = this._transientProducers, this._transientProducers = e), e.lastCause = c, !(u === void 0 && this._selfSubscribers === void 0 && this._subtreeSubscribers === void 0 && this._runtimeSubscribers === void 0) && this._dispatchProducer(e, c, !0);
+  }
+  notifyProducerEvents(e, t, s = !0, i = !1) {
+    if (this._disposed || e.disposed || e.source === void 0 || d(e.owner) && !e.owner._isPublished())
+      return;
+    if (!i && e.subscribers?.first === void 0 && (!e.includeRuntime || this._runtimeSubscribers?.first === void 0)) {
+      this._dispatchProducerLazily(e, void 0, void 0, t, s, !1);
+      return;
+    }
+    const r = {
+      kind: e.kind,
+      source: e.source,
+      sourceOwner: e.owner,
+      revision: ++e.revision,
+      events: Object.freeze([...t])
+    };
+    this._setTransientCause(e, r), this._dispatchProducer(e, r, s);
+  }
+  /**
+   * Дешёвая предварительная проверка structural publication: `false` означает,
+   * что `notifyNode` для этой node вернётся до создания cause и без побочных
+   * эффектов. `true` консервативен и ведёт на полный путь.
+   *
+   * @internal
+   */
+  _hasStructuralDemand(e) {
+    if (this._runtimeSubscribers !== void 0 || this._subtreeSubscribers !== void 0)
+      return !0;
+    const t = this._selfSubscribers;
+    return t !== void 0 && t.has(e);
+  }
+  /**
+   * Сообщает, есть ли хотя бы один runtime-, subtree- или self-подписчик.
+   * `true` означает, что `_hasStructuralDemand` может вернуть `true` для
+   * какой-то node этого Runtime.
+   *
+   * @internal
+   */
+  _hasNodeSubscribers() {
+    return this._runtimeSubscribers !== void 0 || this._subtreeSubscribers !== void 0 || this._selfSubscribers !== void 0;
+  }
+  notifyNode(e, t, s = {}) {
+    if (this._disposed || !e._isPublished() || this._runtimeSubscribers?.first === void 0 && this._selfSubscribers?.get(e)?.first === void 0 && this._subtreeSubscribers === void 0)
+      return;
+    const i = s.oldAncestors === void 0 && s.newAncestors === void 0 ? this._subtreeSubscribers === void 0 ? A : P(e) : void 0, r = s.oldAncestors ?? i ?? A, o = s.newAncestors ?? i ?? A;
+    if (!this._nodeHasDemand(e, r, o))
+      return;
+    const u = this._nodeRevisions ??= /* @__PURE__ */ new WeakMap(), c = (u.get(e) ?? 0) + 1;
+    u.set(e, c);
+    const a = {
+      kind: t,
+      source: e,
+      sourceOwner: e,
+      revision: c,
+      ...s.metadata === void 0 ? {} : { metadata: s.metadata },
+      ...s.structure === void 0 ? {} : { structure: Object.freeze({ ...s.structure }) }
+    }, h = t === "structure" ? e : this._nodeTouchKey(e);
+    if (this._dispatch(this._selfSubscribers?.get(e), a, h), i !== void 0)
+      for (const f of i)
+        this._dispatch(this._subtreeSubscribers?.get(f), a, h);
+    else {
+      const f = /* @__PURE__ */ new Set();
+      for (const l of r)
+        f.add(l);
+      for (const l of o)
+        f.add(l);
+      for (const l of f)
+        this._dispatch(this._subtreeSubscribers?.get(l), a, h);
+    }
+    this._dispatch(this._runtimeSubscribers, a, h);
+  }
+  createAggregate(e, t) {
+    if (this._assertOwner(e), t.length === 0)
+      throw new TypeError("[Raph] Aggregate requires at least one source.");
+    this._validateAggregateSources(t, /* @__PURE__ */ new Set());
+    for (const o of t)
+      this._assertSourceVisibleTo(e, o, /* @__PURE__ */ new Set());
+    const s = p._create(e, t), i = [], r = /* @__PURE__ */ new Set();
+    try {
+      for (const o of s.sources) {
+        const u = W(o);
+        if (u === void 0 || r.has(u))
+          continue;
+        r.add(u);
+        const c = this._linkSourceCleanup(o, () => s._removeMember(u));
+        c !== void 0 && i.push(c);
+      }
+      return s._bindMembers(i), s._bindOwner(e._adoptResource(() => s._disposeOwned())), s;
+    } catch (o) {
+      const u = [];
+      for (let c = i.length - 1; c >= 0; c--)
+        try {
+          i[c]();
+        } catch (a) {
+          u.push(a);
+        }
+      throw u.length !== 0 ? new AggregateError(
+        [o, ...u],
+        "[Raph] Aggregate registration and rollback failed."
+      ) : o;
+    }
+  }
+  subscribe(e, t, s) {
+    this._assertAlive();
+    const i = [], r = /* @__PURE__ */ new WeakMap();
+    try {
+      this._subscribeOne(e, t, s, i, r, /* @__PURE__ */ new Set());
+    } catch (u) {
+      const c = [];
+      for (let a = i.length - 1; a >= 0; a--)
+        try {
+          i[a]();
+        } catch (h) {
+          c.push(h);
+        }
+      throw c.length !== 0 ? new AggregateError(
+        [u, ...c],
+        "[Raph] Granular subscription registration and rollback failed."
+      ) : u;
+    }
+    let o = !0;
+    return () => {
+      if (!o)
+        return;
+      o = !1;
+      const u = [];
+      for (let c = i.length - 1; c >= 0; c--)
+        try {
+          i[c]();
+        } catch (a) {
+          u.push(a);
+        }
+      _(u, "[Raph] Granular subscription disposal failed.");
+    };
+  }
+  assertSubscriptionAllowed(e, t) {
+    this._assertOwner(e), this._assertSourceVisibleTo(e, t, /* @__PURE__ */ new Set());
+  }
+  /**
+   * Rejects a move that would make an existing implicit reactive edge illegal.
+   *
+   * Рёбра от producers с отдельной записью (computed, machine) берутся из
+   * учёта `implicitConsumers`. Рёбра от Runtime signals нигде не учитываются:
+   * они читаются из графа в момент проверки.
+   */
+  assertReparentAllowed(e, t) {
+    const s = this._implicitProducers;
+    if (s !== void 0)
+      for (const i of s) {
+        const r = i.owner;
+        if (!d(r))
+          continue;
+        const o = i.implicitConsumers;
+        if (o !== void 0)
+          for (const u of o.keys())
+            E(u, e) && (E(r, e) || L(r, t) || T(e, u, r));
+      }
+    this._assertSignalEdgesAllowReparent(e, t);
+  }
+  /**
+   * Проверяет живые implicit-рёбра от Runtime signals. Implicit-чтение
+   * разрешено только у собственного владельца, его предков и root scope,
+   * поэтому внешний для переносимого поддерева источник всегда принадлежит
+   * прежнему предку `node`. Предок, который остаётся предком нового parent,
+   * сохраняет все свои рёбра законными. Остаются предки от прежнего parent до
+   * ближайшего общего с новым parent, не включая его: перенос запрещён, если
+   * signal такого предка читает потребитель из переносимого поддерева.
+   *
+   * Посылка о прежнем предке держится на проверке самого чтения: Runtime
+   * signal отклоняет implicit-чтение чужого владельца и тогда, когда общий
+   * контекст владельца снят untracked-работой другого Runtime, а потребитель
+   * этого Runtime остался активным (assertReadable в RuntimeReactivity).
+   *
+   * Цена переноса. Перенос под прежнего parent и перенос корня дерева
+   * проверки не требуют. Иначе для каждого покидаемого предка обходится весь
+   * список его источников (не-signals пропускаются за один шаг), а у каждого
+   * signal с записью графа — список его потребителей до первого потребителя
+   * из переносимого поддерева. Итого O(покидаемые предки × их источники +
+   * потребители их signals), без аллокаций. Цена не зависит от того, сколько
+   * рёбер между nodes есть в остальном Runtime, но растёт с числом источников
+   * и потребителей у покидаемых предков, даже когда их signals читает только
+   * сам владелец: перенос из-под parent с тысячей signals обходит всю тысячу.
+   * Прежний учёт рёбер стоил наоборот: ничего для таких signals и обход всех
+   * producers Runtime с рёбрами между nodes вместе с их потребителями, где бы
+   * в дереве они ни находились.
+   */
+  _assertSignalEdgesAllowReparent(e, t) {
+    const s = e.parent;
+    if (s === null)
+      return;
+    const i = $(s, t);
+    if (i === s)
+      return;
+    const r = this._runtime._getReactivity();
+    for (let o = s; o !== null && o !== i; o = o.parent) {
+      const u = r._findSignalConsumerOwner(o, I, e);
+      u !== void 0 && T(e, u, o);
+    }
+  }
+  releaseNode(e) {
+    this._releaseGranule(this._selfSubscribers, e), this._releaseGranule(this._subtreeSubscribers, e);
+    const t = this._nodeMemberships?.get(e);
+    if (t !== void 0) {
+      this._nodeMemberships.delete(e);
+      try {
+        this._releaseCleanupList(t);
+      } finally {
+        this._nodeMemberships?.size === 0 && (this._nodeMemberships = void 0);
+      }
+    }
+  }
+  dispose() {
+    if (this._disposed)
+      return;
+    this._disposed = !0;
+    const e = [];
+    if (this.clearTransientCauses(), this._implicitProducers !== void 0) {
+      for (const t of this._implicitProducers)
+        t.implicitConsumers = void 0;
+      this._implicitProducers.clear(), this._implicitProducers = void 0;
+    }
+    try {
+      this._releaseRuntimeActivations();
+    } catch (t) {
+      e.push(t);
+    }
+    if (this._runtimeActivationProducers?.clear(), this._runtimeActivationProducers = void 0, this._runtimeSubscriberCount = 0, this._selfSubscribers !== void 0)
+      for (const t of [...this._selfSubscribers.keys()])
+        this._releaseGranule(this._selfSubscribers, t);
+    if (this._subtreeSubscribers !== void 0)
+      for (const t of [...this._subtreeSubscribers.keys()])
+        this._releaseGranule(this._subtreeSubscribers, t);
+    if (this._nodeMemberships !== void 0) {
+      for (const t of this._nodeMemberships.values())
+        this._releaseCleanupList(t, !1);
+      this._nodeMemberships.clear(), this._nodeMemberships = void 0;
+    }
+    if (this._runtimeSubscribers !== void 0) {
+      try {
+        this._releaseWorkList(this._runtimeSubscribers);
+      } catch (t) {
+        e.push(t);
+      }
+      this._runtimeSubscribers = void 0;
+    }
+    _(e, "[Raph] Work graph disposal failed.");
+  }
+  /**
+   * Освобождает producer: публикует финальную structural cause при спросе и
+   * снимает его подписчиков, memberships и регистрацию. Вызывается hook-ом
+   * onDispose owned-источника и самим Runtime signal.
+   *
+   * @internal
+   */
+  _disposeProducer(e, t = !1) {
+    if (e.disposed)
+      return;
+    const s = e.source, i = !d(e.owner) || e.owner._isPublished();
+    let r;
+    if (s !== void 0 && i && (t || this._producerHasDemand(e))) {
+      const c = {
+        kind: "structure",
+        source: s,
+        sourceOwner: e.owner,
+        revision: ++e.revision,
+        metadata: Object.freeze({ disposed: !0 })
+      };
+      this._setTransientCause(e, c);
+      const a = s === e ? c : s;
+      try {
+        this._dispatchProducer(e, c, !0, a);
+      } catch (h) {
+        (r ??= []).push(h);
+      }
+    }
+    e.disposed = !0;
+    const o = e.runtimeActivation;
+    e.runtimeActivation = void 0, this._runtimeActivationProducers?.delete(e), this._runtimeActivationProducers?.size === 0 && (this._runtimeActivationProducers = void 0);
+    try {
+      o?.();
+    } catch (c) {
+      (r ??= []).push(c);
+    }
+    if (e.memberships !== void 0) {
+      try {
+        this._releaseCleanupList(e.memberships);
+      } catch (c) {
+        (r ??= []).push(c);
+      }
+      e.memberships = void 0;
+    }
+    const u = e.source;
+    if (u !== void 0 && u !== e && R.delete(u), e.subscribers !== void 0)
+      try {
+        this._releaseWorkList(e.subscribers);
+      } catch (c) {
+        (r ??= []).push(c);
+      } finally {
+        e.subscribers = void 0;
+      }
+    e.activate = void 0, e.source = void 0, r !== void 0 && _(r, "[Raph] Runtime producer disposal failed.");
+  }
+  _dispatchProducer(e, t, s = !0, i = e) {
+    this._dispatch(e.subscribers, t, i, s);
+    const r = e.owner;
+    if (d(r) && (this._dispatch(this._selfSubscribers?.get(r), t, i, s), this._subtreeSubscribers !== void 0))
+      for (const o of P(r))
+        this._dispatch(this._subtreeSubscribers?.get(o), t, i, s);
+    e.includeRuntime && this._dispatch(this._runtimeSubscribers, t, i, s);
+  }
+  _dispatchProducerLazily(e, t, s, i, r, o) {
+    const u = e.owner;
+    let c;
+    if (d(u)) {
+      const h = this._selfSubscribers?.get(u);
+      h?.first !== void 0 && (c = this._createProducerCause(e, t, s, i, o), this._dispatch(h, c, e, r));
+      const f = this._subtreeSubscribers;
+      if (f !== void 0)
+        for (let l = u; l !== null; ) {
+          const N = l.parent, O = f.get(l);
+          O?.first !== void 0 && (c ??= this._createProducerCause(e, t, s, i, o), this._dispatch(O, c, e, r)), l = N;
+        }
+    }
+    const a = e.includeRuntime ? this._runtimeSubscribers : void 0;
+    a?.first !== void 0 && (c ??= this._createProducerCause(e, t, s, i, o), this._dispatch(a, c, e, r));
+  }
+  _createProducerCause(e, t, s, i, r) {
+    const o = ++e.revision, u = r ? i === void 0 ? y(e.kind, e.source, e.owner, o, t, s) : {
+      kind: e.kind,
+      source: e.source,
+      sourceOwner: e.owner,
+      revision: o,
+      previous: t,
+      value: s,
+      events: Object.freeze([...i])
+    } : i === void 0 ? {
+      kind: e.kind,
+      source: e.source,
+      sourceOwner: e.owner,
+      revision: o
+    } : {
+      kind: e.kind,
+      source: e.source,
+      sourceOwner: e.owner,
+      revision: o,
+      events: Object.freeze([...i])
+    };
+    return this._setTransientCause(e, u), u;
+  }
+  _retainRuntimeSubscriber() {
+    if (this._runtimeSubscriberCount++, this._runtimeSubscriberCount !== 1)
+      return;
+    const e = [], t = [];
+    try {
+      for (const s of this._runtimeActivationProducers ?? [])
+        s.disposed || s.runtimeActivation !== void 0 || (s.runtimeActivation = x(s.activate?.()), e.push(s));
+      return;
+    } catch (s) {
+      t.push(s);
+    }
+    this._runtimeSubscriberCount = 0;
+    for (let s = e.length - 1; s >= 0; s--) {
+      const i = e[s], r = i.runtimeActivation;
+      i.runtimeActivation = void 0;
+      try {
+        r?.();
+      } catch (o) {
+        t.push(o);
+      }
+    }
+    throw t.length === 1 ? t[0] : new AggregateError(t, "[Raph] Runtime granule activation failed and rollback was incomplete.");
+  }
+  _releaseRuntimeSubscriber() {
+    this._runtimeSubscriberCount !== 0 && (this._runtimeSubscriberCount--, this._runtimeSubscriberCount === 0 && this._releaseRuntimeActivations());
+  }
+  _releaseRuntimeActivations() {
+    const e = [];
+    for (const t of this._runtimeActivationProducers ?? []) {
+      const s = t.runtimeActivation;
+      t.runtimeActivation = void 0;
+      try {
+        s?.();
+      } catch (i) {
+        e.push(i);
+      }
+    }
+    _(e, "[Raph] Runtime granule activation cleanup failed.");
+  }
+  /**
+   * Учитывает одно фактическое implicit-ребро графа от producer к consumer
+   * owner и возвращает его точное снятие. Вызывается hook-ом onDependency
+   * producers с отдельной записью; Runtime signal этого hook не имеет, и его
+   * рёбра проверка reparent читает прямо из графа.
+   *
+   * @internal
+   */
+  _linkImplicitDependency(e, t) {
+    const s = e.owner, i = t;
+    if (e.disposed || i.runtime !== this._runtime || !d(s) || !d(i) || s === i)
+      return;
+    const r = e.implicitConsumers ??= /* @__PURE__ */ new Map();
+    r.set(i, (r.get(i) ?? 0) + 1), (this._implicitProducers ??= /* @__PURE__ */ new Set()).add(e);
+    let u = !0;
+    return () => {
+      if (!u)
+        return;
+      u = !1;
+      const c = e.implicitConsumers?.get(i);
+      if (c !== void 0) {
+        if (c > 1) {
+          e.implicitConsumers.set(i, c - 1);
+          return;
+        }
+        e.implicitConsumers.delete(i), e.implicitConsumers.size === 0 && (e.implicitConsumers = void 0, this._implicitProducers?.delete(e), this._implicitProducers?.size === 0 && (this._implicitProducers = void 0));
+      }
+    };
+  }
+  _subscribeOne(e, t, s, i, r, o) {
+    if (t !== void 0 && !d(e))
+      throw new TypeError("[Raph] watch include applies only to a bare RaphNode source.");
+    if (e instanceof p) {
+      if (e._assertAlive(), this._assertRuntime(e.runtime), o.has(e))
+        throw new TypeError("[Raph] Aggregate sources cannot contain a cycle.");
+      o.add(e);
+      const u = [];
+      try {
+        for (const c of e.sources)
+          this._subscribeOne(c, void 0, s, u, r, o);
+        i.push(e._linkSubscription((c) => {
+          const a = [];
+          if (c !== void 0)
+            try {
+              s(c, e, !0);
+            } catch (h) {
+              a.push(h);
+            }
+          for (let h = u.length - 1; h >= 0; h--)
+            try {
+              u[h]();
+            } catch (f) {
+              a.push(f);
+            }
+          _(a, "[Raph] Aggregate member subscription disposal failed.");
+        }));
+      } catch (c) {
+        const a = [];
+        for (let h = u.length - 1; h >= 0; h--)
+          try {
+            u[h]();
+          } catch (f) {
+            a.push(f);
+          }
+        throw o.delete(e), a.length !== 0 ? new AggregateError(
+          [c, ...a],
+          "[Raph] Aggregate subscription registration and rollback failed."
+        ) : c;
+      }
+      o.delete(e);
+      return;
+    }
+    if (m(e)) {
+      this._subscribeNode(e.source, e.include, s, i, r);
+      return;
+    }
+    if (d(e)) {
+      this._subscribeNode(e, t ?? "self", s, i, r);
+      return;
+    }
+    if (g(e)) {
+      this._assertRuntime(e), i.push(C(r, e, () => {
+        const u = this._runtimeSubscribers ??= {}, c = { kind: "runtime", sink: s, source: e };
+        this._appendWorkEdge(u, c);
+        try {
+          this._retainRuntimeSubscriber();
+        } catch (a) {
+          throw c.source = void 0, this._detachWorkEdge(u, c), u.first === void 0 && (this._runtimeSubscribers = void 0), a;
+        }
+        return () => {
+          c.source !== void 0 && (c.source = void 0, this._detachWorkEdge(this._runtimeSubscribers, c), this._runtimeSubscribers?.first === void 0 && (this._runtimeSubscribers = void 0), this._releaseRuntimeSubscriber());
+        };
+      }));
+      return;
+    }
+    if (b(e)) {
+      const u = S(e);
+      if (u !== void 0) {
+        if (this._assertRuntime(u.runtime), u.disposed)
+          throw new w("[Raph] Producer is disposed.");
+        i.push(C(r, u, () => {
+          const c = u.subscribers ??= {}, a = { kind: "producer", sink: s, source: u };
+          this._appendWorkEdge(c, a);
+          try {
+            a.activationRelease = x(u.activate?.());
+          } catch (h) {
+            throw a.source = void 0, this._detachWorkEdge(c, a), c.first === void 0 && (u.subscribers = void 0), h;
+          }
+          return () => {
+            const h = a.activationRelease;
+            a.activationRelease = void 0;
+            const f = a.source;
+            f instanceof v && (a.source = void 0, this._detachWorkEdge(f.subscribers, a), f.subscribers?.first === void 0 && (f.subscribers = void 0)), h?.();
+          };
+        }));
+        return;
+      }
+    }
+    throw new TypeError("[Raph] Unsupported or ownerless granular watch source.");
+  }
+  _subscribeNode(e, t, s, i, r) {
+    if (this._assertRuntime(e.runtime), e._assertAlive(), t !== "self" && t !== "subtree")
+      throw new TypeError(`[Raph] Unsupported node include mode "${String(t)}".`);
+    const o = t === "self" ? e : e._subtreeSourceIdentity;
+    i.push(C(r, o, () => {
+      const u = t === "self" ? this._selfSubscribers ??= /* @__PURE__ */ new Map() : this._subtreeSubscribers ??= /* @__PURE__ */ new Map();
+      let c = u.get(e);
+      c === void 0 && (c = {}, u.set(e, c));
+      const a = { kind: t, sink: s, source: e };
+      return this._appendWorkEdge(c, a), this._createNodeEdgeRelease(a);
+    }));
+  }
+  _createNodeEdgeRelease(e) {
+    return () => {
+      const t = e.source;
+      if (!d(t))
+        return;
+      e.source = void 0;
+      const s = e.kind === "self" ? this._selfSubscribers : this._subtreeSubscribers, i = s?.get(t);
+      this._detachWorkEdge(i, e), i?.first === void 0 && (s?.delete(t), s?.size === 0 && (e.kind === "self" ? this._selfSubscribers = void 0 : this._subtreeSubscribers = void 0));
+    };
+  }
+  _linkSourceCleanup(e, t) {
+    const s = U(e);
+    if (s === void 0)
+      return;
+    const i = { cleanup: t, source: s };
+    if (s instanceof v) {
+      const r = s.memberships ??= {};
+      z(r, i);
+    } else if (s instanceof p)
+      s._linkDependent(i);
+    else {
+      const r = this._nodeMemberships ??= /* @__PURE__ */ new Map();
+      let o = r.get(s);
+      o === void 0 && (o = {}, r.set(s, o)), z(o, i);
+    }
+    return () => this._detachCleanupEdge(i);
+  }
+  _detachCleanupEdge(e) {
+    const t = e.source;
+    if (t === void 0)
+      return;
+    if (e.source = void 0, e.cleanup = void 0, t instanceof v) {
+      M(t.memberships, e), t.memberships?.first === void 0 && (t.memberships = void 0);
+      return;
+    }
+    if (t instanceof p) {
+      t._detachDependent(e);
+      return;
+    }
+    const s = this._nodeMemberships?.get(t);
+    M(s, e), s?.first === void 0 && (this._nodeMemberships?.delete(t), this._nodeMemberships?.size === 0 && (this._nodeMemberships = void 0));
+  }
+  _releaseCleanupList(e, t = !0) {
+    let s = e.first;
+    e.first = e.last = void 0;
+    const i = [];
+    for (; s !== void 0; ) {
+      const r = s.next, o = s.cleanup;
+      if (s.source = void 0, s.cleanup = void 0, s.previous = s.next = void 0, t)
+        try {
+          o?.();
+        } catch (u) {
+          i.push(u);
+        }
+      s = r;
+    }
+    _(i, "[Raph] Aggregate membership cleanup failed.");
+  }
+  _validateAggregateSources(e, t) {
+    for (const s of e) {
+      if (Array.isArray(s))
+        throw new TypeError("[Raph] Nested source arrays are not supported; create a named aggregate.");
+      if (s instanceof p) {
+        if (s._assertAlive(), this._assertRuntime(s.runtime), t.has(s))
+          throw new TypeError("[Raph] Aggregate sources cannot contain a cycle.");
+        t.add(s), this._validateAggregateSources(s.sources, t), t.delete(s);
+      } else if (m(s)) {
+        if (this._assertRuntime(s.source.runtime), s.source._assertAlive(), s.include !== "self" && s.include !== "subtree")
+          throw new TypeError(`[Raph] Unsupported node include mode "${String(s.include)}".`);
+      } else if (d(s))
+        this._assertRuntime(s.runtime), s._assertAlive();
+      else if (g(s))
+        this._assertRuntime(s);
+      else if (b(s)) {
+        const i = S(s);
+        if (i === void 0 || i.disposed)
+          throw new w("[Raph] Aggregate producer is disposed or ownerless.");
+        this._assertRuntime(i.runtime);
+      } else
+        throw new TypeError("[Raph] Unsupported aggregate source.");
+    }
+  }
+  _assertSourceVisibleTo(e, t, s) {
+    if (t instanceof p) {
+      if (this._assertProvisionalOwnerAccess(e, t.owner), s.has(t))
+        return;
+      s.add(t);
+      for (const r of t.sources)
+        this._assertSourceVisibleTo(e, r, s);
+      s.delete(t);
+      return;
+    }
+    if (m(t)) {
+      this._assertProvisionalOwnerAccess(e, t.source);
+      return;
+    }
+    if (d(t)) {
+      this._assertProvisionalOwnerAccess(e, t);
+      return;
+    }
+    if (g(t) || !b(t))
+      return;
+    const i = S(t);
+    i !== void 0 && this._assertProvisionalOwnerAccess(e, i.owner);
+  }
+  _assertProvisionalOwnerAccess(e, t) {
+    if (!(!d(t) || t._isPublished()) && !(d(e) && !e._isPublished() && D(e) === D(t)))
+      throw new Error(
+        `[Raph] Owner "${e.id}" cannot subscribe to provisional source owner "${t.id}".`
+      );
+  }
+  _dispatch(e, t, s, i = !0) {
+    let r = e?.first;
+    if (r === void 0)
+      return;
+    const o = e.last;
+    this._dispatchDepth++;
+    try {
+      for (; r !== void 0; ) {
+        const u = r.next;
+        if (r.source !== void 0 && r.sink(t, s, i), r === o)
+          break;
+        r = u;
+      }
+    } finally {
+      if (--this._dispatchDepth === 0 && this._detachedEdges !== void 0) {
+        for (const u of this._detachedEdges)
+          u.previous = u.next = void 0;
+        this._detachedEdges = void 0;
+      }
+    }
+  }
+  _appendWorkEdge(e, t) {
+    t.previous = e.last, e.last === void 0 ? e.first = t : e.last.next = t, e.last = t;
+  }
+  _detachWorkEdge(e, t) {
+    e !== void 0 && (t.previous === void 0 ? e.first = t.next : t.previous.next = t.next, t.next === void 0 ? e.last = t.previous : t.next.previous = t.previous, this._dispatchDepth === 0 ? t.previous = t.next = void 0 : (this._detachedEdges ??= []).push(t));
+  }
+  _releaseWorkList(e) {
+    let t = e.first;
+    const s = [];
+    for (; t !== void 0; ) {
+      const i = t.next, r = t.activationRelease;
+      t.activationRelease = void 0, t.source = void 0, this._detachWorkEdge(e, t);
+      try {
+        r?.();
+      } catch (o) {
+        s.push(o);
+      }
+      t = i;
+    }
+    _(s, "[Raph] Granular source activation cleanup failed.");
+  }
+  _releaseGranule(e, t) {
+    const s = e?.get(t);
+    s !== void 0 && (e.delete(t), this._releaseWorkList(s), e.size === 0 && (e === this._selfSubscribers && (this._selfSubscribers = void 0), e === this._subtreeSubscribers && (this._subtreeSubscribers = void 0)));
+  }
+  _setTransientCause(e, t) {
+    e.lastCause === void 0 && (e.transientNext = this._transientProducers, this._transientProducers = e), e.lastCause = t;
+  }
+  _producerHasDemand(e) {
+    if (d(e.owner) && !e.owner._isPublished())
+      return !1;
+    if (e.subscribers?.first !== void 0 || e.includeRuntime && this._runtimeSubscribers?.first !== void 0)
+      return !0;
+    const t = e.owner;
+    if (!d(t))
+      return !1;
+    if (this._selfSubscribers?.get(t)?.first !== void 0)
+      return !0;
+    if (this._subtreeSubscribers === void 0)
+      return !1;
+    for (const s of P(t))
+      if (this._subtreeSubscribers.get(s)?.first !== void 0)
+        return !0;
+    return !1;
+  }
+  _nodeTouchKey(e) {
+    const t = this._nodeTouchKeys ??= /* @__PURE__ */ new WeakMap();
+    let s = t.get(e);
+    return s === void 0 && (s = Object.freeze({}), t.set(e, s)), s;
+  }
+  _nodeHasDemand(e, t, s) {
+    if (this._runtimeSubscribers?.first !== void 0 || this._selfSubscribers?.get(e)?.first !== void 0)
+      return !0;
+    if (this._subtreeSubscribers === void 0)
+      return !1;
+    for (const i of t)
+      if (this._subtreeSubscribers.get(i)?.first !== void 0)
+        return !0;
+    for (const i of s)
+      if (this._subtreeSubscribers.get(i)?.first !== void 0)
+        return !0;
+    return !1;
+  }
+  _assertOwner(e) {
+    this._assertRuntime(e.runtime), e._assertAlive();
+  }
+  _assertRuntime(e) {
+    if (e !== this._runtime)
+      throw new j("[Raph] Granular source belongs to another runtime.");
+  }
+  _assertAlive() {
+    if (this._disposed)
+      throw new w("[Raph] Work graph is disposed.");
+  }
+}
+function D(n) {
+  let e = n;
+  for (; e.parent !== null && !e.parent._isPublished(); )
+    e = e.parent;
+  return e;
+}
+function P(n) {
+  const e = [];
+  for (let t = n; t !== null; t = t.parent)
+    e.push(t);
+  return e;
+}
+function E(n, e) {
+  for (let t = n; t !== null; t = t.parent)
+    if (t === e)
+      return !0;
+  return !1;
+}
+function L(n, e) {
+  for (let t = e; t !== null; t = t.parent)
+    if (t === n)
+      return !0;
+  return !1;
+}
+function I(n, e) {
+  return d(n) && E(n, e);
+}
+function $(n, e) {
+  let t = 0;
+  for (let o = n.parent; o !== null; o = o.parent)
+    t++;
+  let s = 0;
+  for (let o = e.parent; o !== null; o = o.parent)
+    s++;
+  let i = n, r = e;
+  for (; t > s; t--)
+    i = i.parent;
+  for (; s > t; s--)
+    r = r.parent;
+  for (; i !== r; )
+    i = i.parent, r = r.parent;
+  return i;
+}
+function T(n, e, t) {
+  throw new Error(
+    `[Raph] Cannot reparent "${n.id}": implicit dependency from "${e.id}" to "${t.id}" would become invalid; use watch().`
+  );
+}
+function H(n) {
+  return Object.freeze(n.map((e) => m(e) ? Object.freeze({ source: e.source, include: e.include }) : e));
+}
+G._valueCauseShapeAnchor = y(
+  "producer",
+  void 0,
+  void 0,
+  0,
+  void 0,
+  void 0
+);
+function y(n, e, t, s, i, r) {
+  return { kind: n, source: e, sourceOwner: t, revision: s, previous: i, value: r };
+}
+function W(n) {
+  return n instanceof p ? n : m(n) ? n.source : d(n) || g(n) ? n : b(n) ? S(n) : void 0;
+}
+function U(n) {
+  if (n instanceof p)
+    return n;
+  if (m(n))
+    return n.source;
+  if (d(n))
+    return n;
+  if (!g(n))
+    return b(n) ? S(n) : void 0;
+}
+function z(n, e) {
+  e.previous = n.last, n.last === void 0 ? n.first = e : n.last.next = e, n.last = e;
+}
+function K(n) {
+  n.aggregate?._detachSubscription(n);
+}
+function M(n, e) {
+  n !== void 0 && (e.previous === void 0 ? n.first = e.next : e.previous.next = e.next, e.next === void 0 ? n.last = e.previous : e.next.previous = e.previous, e.previous = e.next = void 0);
+}
+function C(n, e, t) {
+  let s = n.get(e);
+  s === void 0 && (s = { count: 0, dispose: t() }, n.set(e, s)), s.count++;
+  let i = !0;
+  return () => {
+    if (!i || (i = !1, --s.count !== 0))
+      return;
+    const r = s.dispose;
+    s.dispose = F, r();
+  };
+}
+function F() {
+}
+function x(n) {
+  return typeof n == "function" ? n : void 0;
+}
+function S(n) {
+  return n instanceof v ? n.source === n ? n : void 0 : R.get(n);
+}
+function m(n) {
+  return b(n) && "source" in n && d(n.source) && "include" in n;
+}
+function d(n) {
+  return b(n) && n._isNode === !0;
+}
+function g(n) {
+  return b(n) && "rootScope" in n && "definePhases" in n && "configuration" in n;
+}
+function b(n) {
+  return typeof n == "object" && n !== null;
+}
+export {
+  p as RaphAggregate,
+  v as RaphProducer,
+  G as RaphWorkGraph
+};