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

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

@@ -0,0 +1,995 @@
+var $ = Object.defineProperty;
+var U = (u, e, t) => e in u ? $(u, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : u[e] = t;
+var d = (u, e, t) => U(u, typeof e != "symbol" ? e + "" : e, t);
+import { RaphDisposedError as A, RaphCrossRuntimeError as H } from "../errors.js";
+import { throwDisposalErrors as v } from "../ownership/throwDisposalErrors.js";
+const G = Symbol("RaphProducerRecord"), m = /* @__PURE__ */ new WeakMap(), M = Object.freeze([]), C = Object.freeze([]);
+class b {
+  /** @internal */
+  constructor(e, t) {
+    d(this, "_sources");
+    d(this, "_disposed", !1);
+    d(this, "_releaseOwner");
+    d(this, "_memberReleases");
+    d(this, "_firstSubscription");
+    d(this, "_lastSubscription");
+    d(this, "_firstDependent");
+    d(this, "_lastDependent");
+    d(this, "_revision", 0);
+    d(this, "_finalCause");
+    this.owner = e, this._sources = F(t);
+  }
+  /** @internal */
+  static _create(e, t) {
+    return new b(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);
+        }
+    }
+    v(s, "[Raph] Aggregate disposal failed.");
+  }
+  /** @internal */
+  _assertAlive() {
+    if (this._disposed || this.owner.disposed)
+      throw new A("[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) => L(s) !== e);
+    t.length !== this._sources.length && (this._sources = t.length === 0 ? M : Object.freeze(t));
+  }
+  /** @internal */
+  _disposeOwned() {
+    if (this._disposed)
+      return;
+    this._disposed = !0, this._releaseOwner = void 0;
+    const e = f(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, r = s.dispose;
+      s.aggregate = void 0, s.dispose = void 0, s.previous = s.next = void 0;
+      try {
+        r == null || r(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 (r) {
+          t.push(r);
+        }
+    this._sources = M;
+    let n = this._firstDependent;
+    for (this._firstDependent = this._lastDependent = void 0; n !== void 0; ) {
+      const o = n.next, r = n.cleanup;
+      n.source = void 0, n.cleanup = void 0, n.previous = n.next = void 0;
+      try {
+        r == null || r();
+      } catch (c) {
+        t.push(c);
+      }
+      n = o;
+    }
+    v(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, () => Y(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 ?? (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 == null || t();
+  }
+}
+class V {
+  constructor(e) {
+    d(this, "_selfSubscribers");
+    d(this, "_subtreeSubscribers");
+    d(this, "_runtimeSubscribers");
+    d(this, "_runtimeSubscriberCount", 0);
+    d(this, "_runtimeActivationProducers");
+    d(this, "_nodeMemberships");
+    d(this, "_nodeRevisions");
+    d(this, "_nodeTouchKeys");
+    d(this, "_implicitProducers");
+    d(this, "_transientProducers");
+    d(this, "_dispatchDepth", 0);
+    d(this, "_detachedEdges");
+    d(this, "_disposed", !1);
+    this._runtime = e;
+  }
+  createProducer(e, t = "producer", s = {}) {
+    return this._assertAlive(), {
+      [G]: !0,
+      runtime: this._runtime,
+      owner: e,
+      kind: t,
+      includeRuntime: s.includeRuntime ?? !0,
+      revision: 0,
+      disposed: !1
+    };
+  }
+  attachProducer(e, t) {
+    return e.alias !== void 0 && m.delete(e.alias), e.source = t, e.alias = t, m.set(t, e), t;
+  }
+  setProducerActivation(e, t, s = !1) {
+    if (e.disposed)
+      throw new A("[Raph] Producer is disposed.");
+    if (e.activate = t, !s)
+      return;
+    const i = this._runtimeActivationProducers ?? (this._runtimeActivationProducers = /* @__PURE__ */ new Set());
+    if (i.add(e), this._runtimeSubscriberCount !== 0)
+      try {
+        e.runtimeActivation = D(t());
+      } catch (n) {
+        throw i.delete(e), i.size === 0 && (this._runtimeActivationProducers = void 0), n;
+      }
+  }
+  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)
+    };
+  }
+  causeForToken(e) {
+    if (!(!E(e) || e.runtime !== this._runtime))
+      return e.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, n = !0, o = !1, r = !1) {
+    var a, h;
+    if (this._disposed || e.disposed || e.source === void 0 || f(e.owner) && !e.owner._isPublished() || !r && i === void 0 && e.lastCause !== void 0)
+      return;
+    if (!o && ((a = e.subscribers) == null ? void 0 : a.first) === void 0 && (!e.includeRuntime || ((h = this._runtimeSubscribers) == null ? void 0 : h.first) === void 0)) {
+      this._dispatchProducerLazily(e, t, s, i, n, r);
+      return;
+    }
+    const c = Object.freeze({
+      kind: e.kind,
+      source: e.source,
+      sourceOwner: e.owner,
+      revision: ++e.revision,
+      ...r ? { previous: t, value: s } : {},
+      ...i === void 0 ? {} : { events: Object.freeze([...i]) }
+    });
+    this._setTransientCause(e, c), this._dispatchProducer(e, c, n);
+  }
+  notifyProducerEvents(e, t, s = !0, i = !1) {
+    var o, r;
+    if (this._disposed || e.disposed || e.source === void 0 || f(e.owner) && !e.owner._isPublished())
+      return;
+    if (!i && ((o = e.subscribers) == null ? void 0 : o.first) === void 0 && (!e.includeRuntime || ((r = this._runtimeSubscribers) == null ? void 0 : r.first) === void 0)) {
+      this._dispatchProducerLazily(e, void 0, void 0, t, s, !1);
+      return;
+    }
+    const n = Object.freeze({
+      kind: e.kind,
+      source: e.source,
+      sourceOwner: e.owner,
+      revision: ++e.revision,
+      events: Object.freeze([...t])
+    });
+    this._setTransientCause(e, n), this._dispatchProducer(e, n, s);
+  }
+  notifyNode(e, t, s = {}) {
+    var l, _, p, O, g, z;
+    if (this._disposed || !e._isPublished() || ((l = this._runtimeSubscribers) == null ? void 0 : l.first) === void 0 && ((p = (_ = this._selfSubscribers) == null ? void 0 : _.get(e)) == null ? void 0 : p.first) === void 0 && this._subtreeSubscribers === void 0)
+      return;
+    const i = s.oldAncestors === void 0 && s.newAncestors === void 0 ? this._subtreeSubscribers === void 0 ? C : k(e) : void 0, n = s.oldAncestors ?? i ?? C, o = s.newAncestors ?? i ?? C;
+    if (!this._nodeHasDemand(e, n, o))
+      return;
+    const r = this._nodeRevisions ?? (this._nodeRevisions = /* @__PURE__ */ new WeakMap()), c = (r.get(e) ?? 0) + 1;
+    r.set(e, c);
+    const a = Object.freeze({
+      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((O = this._selfSubscribers) == null ? void 0 : O.get(e), a, h), i !== void 0)
+      for (const R of i)
+        this._dispatch((g = this._subtreeSubscribers) == null ? void 0 : g.get(R), a, h);
+    else {
+      const R = /* @__PURE__ */ new Set();
+      for (const y of n)
+        R.add(y);
+      for (const y of o)
+        R.add(y);
+      for (const y of R)
+        this._dispatch((z = this._subtreeSubscribers) == null ? void 0 : z.get(y), 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 = b._create(e, t), i = [], n = /* @__PURE__ */ new Set();
+    try {
+      for (const o of s.sources) {
+        const r = L(o);
+        if (r === void 0 || n.has(r))
+          continue;
+        n.add(r);
+        const c = this._linkSourceCleanup(o, () => s._removeMember(r));
+        c !== void 0 && i.push(c);
+      }
+      return s._bindMembers(i), s._bindOwner(e._adoptResource(() => s._disposeOwned())), s;
+    } catch (o) {
+      const r = [];
+      for (let c = i.length - 1; c >= 0; c--)
+        try {
+          i[c]();
+        } catch (a) {
+          r.push(a);
+        }
+      throw r.length !== 0 ? new AggregateError(
+        [o, ...r],
+        "[Raph] Aggregate registration and rollback failed."
+      ) : o;
+    }
+  }
+  subscribe(e, t, s) {
+    this._assertAlive();
+    const i = [], n = /* @__PURE__ */ new WeakMap();
+    try {
+      this._subscribeOne(e, t, s, i, n, /* @__PURE__ */ new Set());
+    } catch (r) {
+      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(
+        [r, ...c],
+        "[Raph] Granular subscription registration and rollback failed."
+      ) : r;
+    }
+    let o = !0;
+    return () => {
+      if (!o)
+        return;
+      o = !1;
+      const r = [];
+      for (let c = i.length - 1; c >= 0; c--)
+        try {
+          i[c]();
+        } catch (a) {
+          r.push(a);
+        }
+      v(r, "[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. */
+  assertReparentAllowed(e, t) {
+    const s = this._implicitProducers;
+    if (s !== void 0)
+      for (const i of s) {
+        const n = i.owner;
+        if (!f(n))
+          continue;
+        const o = i.implicitConsumers;
+        if (o !== void 0) {
+          for (const r of o.keys())
+            if (j(r, e) && !j(n, e) && !K(n, t))
+              throw new Error(
+                `[Raph] Cannot reparent "${e.id}": implicit dependency from "${r.id}" to "${n.id}" would become invalid; use watch().`
+              );
+        }
+      }
+  }
+  releaseNode(e) {
+    var s, i;
+    this._releaseGranule(this._selfSubscribers, e), this._releaseGranule(this._subtreeSubscribers, e);
+    const t = (s = this._nodeMemberships) == null ? void 0 : s.get(e);
+    if (t !== void 0) {
+      this._nodeMemberships.delete(e);
+      try {
+        this._releaseCleanupList(t);
+      } finally {
+        ((i = this._nodeMemberships) == null ? void 0 : i.size) === 0 && (this._nodeMemberships = void 0);
+      }
+    }
+  }
+  dispose() {
+    var t;
+    if (this._disposed)
+      return;
+    this._disposed = !0;
+    const e = [];
+    if (this.clearTransientCauses(), this._implicitProducers !== void 0) {
+      for (const s of this._implicitProducers)
+        s.implicitConsumers = void 0;
+      this._implicitProducers.clear(), this._implicitProducers = void 0;
+    }
+    try {
+      this._releaseRuntimeActivations();
+    } catch (s) {
+      e.push(s);
+    }
+    if ((t = this._runtimeActivationProducers) == null || t.clear(), this._runtimeActivationProducers = void 0, this._runtimeSubscriberCount = 0, this._selfSubscribers !== void 0)
+      for (const s of [...this._selfSubscribers.keys()])
+        this._releaseGranule(this._selfSubscribers, s);
+    if (this._subtreeSubscribers !== void 0)
+      for (const s of [...this._subtreeSubscribers.keys()])
+        this._releaseGranule(this._subtreeSubscribers, s);
+    if (this._nodeMemberships !== void 0) {
+      for (const s of this._nodeMemberships.values())
+        this._releaseCleanupList(s, !1);
+      this._nodeMemberships.clear(), this._nodeMemberships = void 0;
+    }
+    if (this._runtimeSubscribers !== void 0) {
+      try {
+        this._releaseWorkList(this._runtimeSubscribers);
+      } catch (s) {
+        e.push(s);
+      }
+      this._runtimeSubscribers = void 0;
+    }
+    v(e, "[Raph] Work graph disposal failed.");
+  }
+  _disposeProducer(e, t = !1) {
+    var r, c;
+    if (e.disposed)
+      return;
+    const s = e.source, i = !f(e.owner) || e.owner._isPublished();
+    let n;
+    if (s !== void 0 && i && (t || this._producerHasDemand(e))) {
+      const a = Object.freeze({
+        kind: "structure",
+        source: s,
+        sourceOwner: e.owner,
+        revision: ++e.revision,
+        metadata: Object.freeze({ disposed: !0 })
+      });
+      this._setTransientCause(e, a);
+      try {
+        this._dispatchProducer(e, a, !0, s);
+      } catch (h) {
+        (n ?? (n = [])).push(h);
+      }
+    }
+    e.disposed = !0;
+    const o = e.runtimeActivation;
+    e.runtimeActivation = void 0, (r = this._runtimeActivationProducers) == null || r.delete(e), ((c = this._runtimeActivationProducers) == null ? void 0 : c.size) === 0 && (this._runtimeActivationProducers = void 0);
+    try {
+      o == null || o();
+    } catch (a) {
+      (n ?? (n = [])).push(a);
+    }
+    if (e.memberships !== void 0) {
+      try {
+        this._releaseCleanupList(e.memberships);
+      } catch (a) {
+        (n ?? (n = [])).push(a);
+      }
+      e.memberships = void 0;
+    }
+    if (e.alias !== void 0 && m.delete(e.alias), e.alias = void 0, e.subscribers !== void 0)
+      try {
+        this._releaseWorkList(e.subscribers);
+      } catch (a) {
+        (n ?? (n = [])).push(a);
+      } finally {
+        e.subscribers = void 0;
+      }
+    e.activate = void 0, e.source = void 0, n !== void 0 && v(n, "[Raph] Runtime producer disposal failed.");
+  }
+  _dispatchProducer(e, t, s = !0, i = e) {
+    var o, r;
+    this._dispatch(e.subscribers, t, i, s);
+    const n = e.owner;
+    if (f(n)) {
+      this._dispatch((o = this._selfSubscribers) == null ? void 0 : o.get(n), t, i, s);
+      for (const c of k(n))
+        this._dispatch((r = this._subtreeSubscribers) == null ? void 0 : r.get(c), t, i, s);
+    }
+    e.includeRuntime && this._dispatch(this._runtimeSubscribers, t, i, s);
+  }
+  _dispatchProducerLazily(e, t, s, i, n, o) {
+    var h;
+    const r = e.owner;
+    let c;
+    if (f(r)) {
+      const l = (h = this._selfSubscribers) == null ? void 0 : h.get(r);
+      (l == null ? void 0 : l.first) !== void 0 && (c = this._createProducerCause(e, t, s, i, o), this._dispatch(l, c, e, n));
+      const _ = this._subtreeSubscribers;
+      if (_ !== void 0)
+        for (let p = r; p !== null; ) {
+          const O = p.parent, g = _.get(p);
+          (g == null ? void 0 : g.first) !== void 0 && (c ?? (c = this._createProducerCause(e, t, s, i, o)), this._dispatch(g, c, e, n)), p = O;
+        }
+    }
+    const a = e.includeRuntime ? this._runtimeSubscribers : void 0;
+    (a == null ? void 0 : a.first) !== void 0 && (c ?? (c = this._createProducerCause(e, t, s, i, o)), this._dispatch(a, c, e, n));
+  }
+  _createProducerCause(e, t, s, i, n) {
+    const o = ++e.revision, r = Object.freeze(n ? i === void 0 ? {
+      kind: e.kind,
+      source: e.source,
+      sourceOwner: e.owner,
+      revision: o,
+      previous: t,
+      value: 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, r), r;
+  }
+  _retainRuntimeSubscriber() {
+    var s;
+    if (this._runtimeSubscriberCount++, this._runtimeSubscriberCount !== 1)
+      return;
+    const e = [], t = [];
+    try {
+      for (const i of this._runtimeActivationProducers ?? [])
+        i.disposed || i.runtimeActivation !== void 0 || (i.runtimeActivation = D((s = i.activate) == null ? void 0 : s.call(i)), e.push(i));
+      return;
+    } catch (i) {
+      t.push(i);
+    }
+    this._runtimeSubscriberCount = 0;
+    for (let i = e.length - 1; i >= 0; i--) {
+      const n = e[i], o = n.runtimeActivation;
+      n.runtimeActivation = void 0;
+      try {
+        o == null || o();
+      } catch (r) {
+        t.push(r);
+      }
+    }
+    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 == null || s();
+      } catch (i) {
+        e.push(i);
+      }
+    }
+    v(e, "[Raph] Runtime granule activation cleanup failed.");
+  }
+  _linkImplicitDependency(e, t) {
+    const s = e.owner, i = t;
+    if (e.disposed || i.runtime !== this._runtime || !f(s) || !f(i) || s === i)
+      return;
+    const n = e.implicitConsumers ?? (e.implicitConsumers = /* @__PURE__ */ new Map());
+    n.set(i, (n.get(i) ?? 0) + 1), (this._implicitProducers ?? (this._implicitProducers = /* @__PURE__ */ new Set())).add(e);
+    let r = !0;
+    return () => {
+      var a, h, l;
+      if (!r)
+        return;
+      r = !1;
+      const c = (a = e.implicitConsumers) == null ? void 0 : a.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, (h = this._implicitProducers) == null || h.delete(e), ((l = this._implicitProducers) == null ? void 0 : l.size) === 0 && (this._implicitProducers = void 0));
+      }
+    };
+  }
+  _subscribeOne(e, t, s, i, n, o) {
+    if (t !== void 0 && !f(e))
+      throw new TypeError("[Raph] watch include applies only to a bare RaphNode source.");
+    if (e instanceof b) {
+      if (e._assertAlive(), this._assertRuntime(e.runtime), o.has(e))
+        throw new TypeError("[Raph] Aggregate sources cannot contain a cycle.");
+      o.add(e);
+      const r = [];
+      try {
+        for (const c of e.sources)
+          this._subscribeOne(c, void 0, s, r, n, 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 = r.length - 1; h >= 0; h--)
+            try {
+              r[h]();
+            } catch (l) {
+              a.push(l);
+            }
+          v(a, "[Raph] Aggregate member subscription disposal failed.");
+        }));
+      } catch (c) {
+        const a = [];
+        for (let h = r.length - 1; h >= 0; h--)
+          try {
+            r[h]();
+          } catch (l) {
+            a.push(l);
+          }
+        throw o.delete(e), a.length !== 0 ? new AggregateError(
+          [c, ...a],
+          "[Raph] Aggregate subscription registration and rollback failed."
+        ) : c;
+      }
+      o.delete(e);
+      return;
+    }
+    if (S(e)) {
+      this._subscribeNode(e.source, e.include, s, i, n);
+      return;
+    }
+    if (f(e)) {
+      this._subscribeNode(e, t ?? "self", s, i, n);
+      return;
+    }
+    if (P(e)) {
+      this._assertRuntime(e), i.push(x(n, e, () => {
+        const r = this._runtimeSubscribers ?? (this._runtimeSubscribers = {}), c = { kind: "runtime", sink: s, source: e };
+        this._appendWorkEdge(r, c);
+        try {
+          this._retainRuntimeSubscriber();
+        } catch (a) {
+          throw c.source = void 0, this._detachWorkEdge(r, c), r.first === void 0 && (this._runtimeSubscribers = void 0), a;
+        }
+        return () => {
+          var a;
+          c.source !== void 0 && (c.source = void 0, this._detachWorkEdge(this._runtimeSubscribers, c), ((a = this._runtimeSubscribers) == null ? void 0 : a.first) === void 0 && (this._runtimeSubscribers = void 0), this._releaseRuntimeSubscriber());
+        };
+      }));
+      return;
+    }
+    if (w(e)) {
+      const r = m.get(e);
+      if (r !== void 0) {
+        if (this._assertRuntime(r.runtime), r.disposed)
+          throw new A("[Raph] Producer is disposed.");
+        i.push(x(n, r, () => {
+          var h;
+          const c = r.subscribers ?? (r.subscribers = {}), a = { kind: "producer", sink: s, source: r };
+          this._appendWorkEdge(c, a);
+          try {
+            a.activationRelease = D((h = r.activate) == null ? void 0 : h.call(r));
+          } catch (l) {
+            throw a.source = void 0, this._detachWorkEdge(c, a), c.first === void 0 && (r.subscribers = void 0), l;
+          }
+          return () => {
+            var p;
+            const l = a.activationRelease;
+            a.activationRelease = void 0;
+            const _ = a.source;
+            E(_) && (a.source = void 0, this._detachWorkEdge(_.subscribers, a), ((p = _.subscribers) == null ? void 0 : p.first) === void 0 && (_.subscribers = void 0)), l == null || l();
+          };
+        }));
+        return;
+      }
+    }
+    throw new TypeError("[Raph] Unsupported or ownerless granular watch source.");
+  }
+  _subscribeNode(e, t, s, i, n) {
+    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(x(n, o, () => {
+      const r = t === "self" ? this._selfSubscribers ?? (this._selfSubscribers = /* @__PURE__ */ new Map()) : this._subtreeSubscribers ?? (this._subtreeSubscribers = /* @__PURE__ */ new Map());
+      let c = r.get(e);
+      c === void 0 && (c = {}, r.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 (!f(t))
+        return;
+      e.source = void 0;
+      const s = e.kind === "self" ? this._selfSubscribers : this._subtreeSubscribers, i = s == null ? void 0 : s.get(t);
+      this._detachWorkEdge(i, e), (i == null ? void 0 : i.first) === void 0 && (s == null || s.delete(t), (s == null ? void 0 : s.size) === 0 && (e.kind === "self" ? this._selfSubscribers = void 0 : this._subtreeSubscribers = void 0));
+    };
+  }
+  _linkSourceCleanup(e, t) {
+    const s = I(e);
+    if (s === void 0)
+      return;
+    const i = { cleanup: t, source: s };
+    if (E(s)) {
+      const n = s.memberships ?? (s.memberships = {});
+      W(n, i);
+    } else if (s instanceof b)
+      s._linkDependent(i);
+    else {
+      const n = this._nodeMemberships ?? (this._nodeMemberships = /* @__PURE__ */ new Map());
+      let o = n.get(s);
+      o === void 0 && (o = {}, n.set(s, o)), W(o, i);
+    }
+    return () => this._detachCleanupEdge(i);
+  }
+  _detachCleanupEdge(e) {
+    var i, n, o, r;
+    const t = e.source;
+    if (t === void 0)
+      return;
+    if (e.source = void 0, e.cleanup = void 0, E(t)) {
+      N(t.memberships, e), ((i = t.memberships) == null ? void 0 : i.first) === void 0 && (t.memberships = void 0);
+      return;
+    }
+    if (t instanceof b) {
+      t._detachDependent(e);
+      return;
+    }
+    const s = (n = this._nodeMemberships) == null ? void 0 : n.get(t);
+    N(s, e), (s == null ? void 0 : s.first) === void 0 && ((o = this._nodeMemberships) == null || o.delete(t), ((r = this._nodeMemberships) == null ? void 0 : r.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 n = s.next, o = s.cleanup;
+      if (s.source = void 0, s.cleanup = void 0, s.previous = s.next = void 0, t)
+        try {
+          o == null || o();
+        } catch (r) {
+          i.push(r);
+        }
+      s = n;
+    }
+    v(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 b) {
+        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 (S(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 (f(s))
+        this._assertRuntime(s.runtime), s._assertAlive();
+      else if (P(s))
+        this._assertRuntime(s);
+      else if (w(s)) {
+        const i = m.get(s);
+        if (i === void 0 || i.disposed)
+          throw new A("[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 b) {
+      if (this._assertProvisionalOwnerAccess(e, t.owner), s.has(t))
+        return;
+      s.add(t);
+      for (const n of t.sources)
+        this._assertSourceVisibleTo(e, n, s);
+      s.delete(t);
+      return;
+    }
+    if (S(t)) {
+      this._assertProvisionalOwnerAccess(e, t.source);
+      return;
+    }
+    if (f(t)) {
+      this._assertProvisionalOwnerAccess(e, t);
+      return;
+    }
+    if (P(t) || !w(t))
+      return;
+    const i = m.get(t);
+    i !== void 0 && this._assertProvisionalOwnerAccess(e, i.owner);
+  }
+  _assertProvisionalOwnerAccess(e, t) {
+    if (!(!f(t) || t._isPublished()) && !(f(e) && !e._isPublished() && T(e) === T(t)))
+      throw new Error(
+        `[Raph] Owner "${e.id}" cannot subscribe to provisional source owner "${t.id}".`
+      );
+  }
+  _dispatch(e, t, s, i = !0) {
+    let n = e == null ? void 0 : e.first;
+    if (n === void 0)
+      return;
+    const o = e.last;
+    this._dispatchDepth++;
+    try {
+      for (; n !== void 0; ) {
+        const r = n.next;
+        if (n.source !== void 0 && n.sink(t, s, i), n === o)
+          break;
+        n = r;
+      }
+    } finally {
+      if (--this._dispatchDepth === 0 && this._detachedEdges !== void 0) {
+        for (const r of this._detachedEdges)
+          r.previous = r.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 ?? (this._detachedEdges = [])).push(t));
+  }
+  _releaseWorkList(e) {
+    let t = e.first;
+    const s = [];
+    for (; t !== void 0; ) {
+      const i = t.next, n = t.activationRelease;
+      t.activationRelease = void 0, t.source = void 0, this._detachWorkEdge(e, t);
+      try {
+        n == null || n();
+      } catch (o) {
+        s.push(o);
+      }
+      t = i;
+    }
+    v(s, "[Raph] Granular source activation cleanup failed.");
+  }
+  _releaseGranule(e, t) {
+    const s = e == null ? void 0 : 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) {
+    var s, i, n, o, r;
+    if (f(e.owner) && !e.owner._isPublished())
+      return !1;
+    if (((s = e.subscribers) == null ? void 0 : s.first) !== void 0 || e.includeRuntime && ((i = this._runtimeSubscribers) == null ? void 0 : i.first) !== void 0)
+      return !0;
+    const t = e.owner;
+    if (!f(t))
+      return !1;
+    if (((o = (n = this._selfSubscribers) == null ? void 0 : n.get(t)) == null ? void 0 : o.first) !== void 0)
+      return !0;
+    if (this._subtreeSubscribers === void 0)
+      return !1;
+    for (const c of k(t))
+      if (((r = this._subtreeSubscribers.get(c)) == null ? void 0 : r.first) !== void 0)
+        return !0;
+    return !1;
+  }
+  _nodeTouchKey(e) {
+    const t = this._nodeTouchKeys ?? (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) {
+    var i, n, o, r, c;
+    if (((i = this._runtimeSubscribers) == null ? void 0 : i.first) !== void 0 || ((o = (n = this._selfSubscribers) == null ? void 0 : n.get(e)) == null ? void 0 : o.first) !== void 0)
+      return !0;
+    if (this._subtreeSubscribers === void 0)
+      return !1;
+    for (const a of t)
+      if (((r = this._subtreeSubscribers.get(a)) == null ? void 0 : r.first) !== void 0)
+        return !0;
+    for (const a of s)
+      if (((c = this._subtreeSubscribers.get(a)) == null ? void 0 : c.first) !== void 0)
+        return !0;
+    return !1;
+  }
+  _assertOwner(e) {
+    this._assertRuntime(e.runtime), e._assertAlive();
+  }
+  _assertRuntime(e) {
+    if (e !== this._runtime)
+      throw new H("[Raph] Granular source belongs to another runtime.");
+  }
+  _assertAlive() {
+    if (this._disposed)
+      throw new A("[Raph] Work graph is disposed.");
+  }
+}
+function T(u) {
+  let e = u;
+  for (; e.parent !== null && !e.parent._isPublished(); )
+    e = e.parent;
+  return e;
+}
+function k(u) {
+  const e = [];
+  for (let t = u; t !== null; t = t.parent)
+    e.push(t);
+  return e;
+}
+function j(u, e) {
+  for (let t = u; t !== null; t = t.parent)
+    if (t === e)
+      return !0;
+  return !1;
+}
+function K(u, e) {
+  for (let t = e; t !== null; t = t.parent)
+    if (t === u)
+      return !0;
+  return !1;
+}
+function F(u) {
+  return Object.freeze(u.map((e) => S(e) ? Object.freeze({ source: e.source, include: e.include }) : e));
+}
+function L(u) {
+  return u instanceof b ? u : S(u) ? u.source : f(u) || P(u) ? u : w(u) ? m.get(u) : void 0;
+}
+function I(u) {
+  if (u instanceof b)
+    return u;
+  if (S(u))
+    return u.source;
+  if (f(u))
+    return u;
+  if (!P(u))
+    return w(u) ? m.get(u) : void 0;
+}
+function W(u, e) {
+  e.previous = u.last, u.last === void 0 ? u.first = e : u.last.next = e, u.last = e;
+}
+function Y(u) {
+  var e;
+  (e = u.aggregate) == null || e._detachSubscription(u);
+}
+function N(u, e) {
+  u !== void 0 && (e.previous === void 0 ? u.first = e.next : e.previous.next = e.next, e.next === void 0 ? u.last = e.previous : e.next.previous = e.previous, e.previous = e.next = void 0);
+}
+function x(u, e, t) {
+  let s = u.get(e);
+  s === void 0 && (s = { count: 0, dispose: t() }, u.set(e, s)), s.count++;
+  let i = !0;
+  return () => {
+    if (!i || (i = !1, --s.count !== 0))
+      return;
+    const n = s.dispose;
+    s.dispose = q, n();
+  };
+}
+function q() {
+}
+function D(u) {
+  return typeof u == "function" ? u : void 0;
+}
+function E(u) {
+  return typeof u == "object" && u !== null && u[G] === !0;
+}
+function S(u) {
+  return w(u) && "source" in u && f(u.source) && "include" in u;
+}
+function f(u) {
+  return w(u) && "_subtreeSourceIdentity" in u && "runtime" in u && "children" in u;
+}
+function P(u) {
+  return w(u) && "rootScope" in u && "definePhases" in u && "configuration" in u;
+}
+function w(u) {
+  return typeof u == "object" && u !== null;
+}
+export {
+  b as RaphAggregate,
+  V as RaphWorkGraph
+};