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

package/dist/debug/runtime/phases/RaphPhasePipeline.js

@@ -0,0 +1,587 @@
+var D = Object.defineProperty;
+var A = (l, e, s) => e in l ? D(l, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : l[e] = s;
+var d = (l, e, s) => A(l, typeof e != "symbol" ? e + "" : e, s);
+import { RaphPhaseProcessError as g, RaphDisposedError as P } from "../errors.js";
+const m = Object.freeze([]), q = Object.freeze({ now: 0, delta: 0, elapsed: 0, frame: 0 }), x = 1e4, K = 1e4, O = Symbol("RaphPhaseTaskRecord");
+class R {
+  constructor(e, s, t, i = () => !1, n) {
+    d(this, "_phases", []);
+    d(this, "_phaseByName", /* @__PURE__ */ new Map());
+    d(this, "_phaseBindings", /* @__PURE__ */ new Map());
+    d(this, "_queues", /* @__PURE__ */ new Map());
+    d(this, "_deferred", /* @__PURE__ */ new Set());
+    d(this, "_idleWaiters", /* @__PURE__ */ new Set());
+    d(this, "_taskSequence", 0);
+    d(this, "_scheduled", !1);
+    d(this, "_scheduleToken", 0);
+    d(this, "_frameHandle");
+    d(this, "_frameHandleKind");
+    d(this, "_configurationLocked", !1);
+    d(this, "_running", !1);
+    d(this, "_disposed", !1);
+    d(this, "_firstFrameAt");
+    d(this, "_lastFrameAt");
+    d(this, "_frameNumber", 0);
+    d(this, "_frame", q);
+    this._scheduler = e, this._runUntracked = s, this._resolveCause = t, this._deferSync = i, this._tracePhase = n;
+  }
+  get frame() {
+    return this._frame;
+  }
+  get phases() {
+    return this._phases.map((e) => e.phase);
+  }
+  definePhases(e) {
+    if (this._assertAlive(), this._configurationLocked || this._firstFrameAt !== void 0)
+      throw new Error("[Raph] Cannot redefine phases after phase pipeline execution has started.");
+    const s = /* @__PURE__ */ new Map(), t = [];
+    for (const i of e) {
+      const n = i.name.trim();
+      if (!n)
+        throw new Error("[Raph] Phase name must not be empty.");
+      if (s.has(n))
+        throw new Error(`[Raph] Duplicate phase name "${n}".`);
+      if (i.process !== void 0 && typeof i.process != "function")
+        throw new TypeError(`[Raph] Phase "${n}" process must be a function.`);
+      const a = Object.freeze({
+        name: n,
+        ...i.process === void 0 ? {} : { process: i.process }
+      }), r = { index: t.length, phase: a };
+      t.push(r), s.set(n, r);
+    }
+    this._assertRetainedPhases(s), this._phases = t, this._phaseByName = s;
+  }
+  addPhase(e) {
+    this.definePhases([...this.phases, e]);
+  }
+  clearPhases() {
+    this.definePhases([]);
+  }
+  requirePhase(e) {
+    if (this._assertAlive(), !this._phaseByName.has(e))
+      throw new Error(`[Raph] Phase "${e}" is not defined.`);
+  }
+  bindTask(e, s, t, i, n) {
+    const a = e.trim();
+    if (this.requirePhase(a), !Number.isFinite(i))
+      throw new TypeError("[Raph] Effect priority must be finite.");
+    this._phaseBindings.set(a, (this._phaseBindings.get(a) ?? 0) + 1);
+    const r = {}, h = this._createTask(r);
+    Object.assign(r, {
+      active: !0,
+      paused: !1,
+      pending: !1,
+      deferred: !1,
+      inDelivery: !1,
+      discardAcknowledged: !1,
+      requested: !1,
+      resolution: "unresolved",
+      deferCount: 0,
+      sequence: 0,
+      phase: a,
+      priority: i,
+      consumerOwner: s,
+      effect: t,
+      runner: n,
+      task: h,
+      deliveryCauses: m,
+      frame: q
+    });
+    const f = {
+      dependencyOwner: s,
+      allowScheduleDuringRun: !0,
+      task: h,
+      notify: (o) => {
+        const _ = this._resolveCause(o);
+        if (_ !== void 0) {
+          const c = _.kind === "structure" ? _.source : o;
+          this._appendCause(r, _, c);
+        }
+      },
+      schedule: () => this._queue(r),
+      enqueue: (o, _ = o.source, c = !0) => {
+        this._appendCause(r, o, _), this._queue(r, c);
+      },
+      pause: () => this._pauseTask(r),
+      resume: () => this._resumeTask(r),
+      dispose: () => this._disposeTask(r)
+    };
+    return r.binding = f, f;
+  }
+  request() {
+    this._assertAlive(), this._hasQueued() && this._schedule();
+  }
+  afterFlush() {
+    return this._assertAlive(), !this._running && !this._scheduled && !this._hasPending() ? Promise.resolve() : new Promise((e, s) => {
+      this._idleWaiters.add({ reject: s, resolve: e });
+    });
+  }
+  flush() {
+    var n, a, r;
+    if (this._assertAlive(), this._cancelScheduled(), this._running)
+      return;
+    if (!this._hasQueued() && this._deferred.size !== 0 && this._activateDeferred(), !this._hasQueued()) {
+      this._settleIdleWaiters(void 0, !1);
+      return;
+    }
+    this._configurationLocked = !0, this._running = !0;
+    const e = [], s = this._nextFrame();
+    let t = 0;
+    try {
+      for (; this._hasQueued(); ) {
+        if (++t > x) {
+          const h = this._describeQueued();
+          this._cancelAllQueued(!0, e), e.push(new Error(`[Raph] Phase flush exceeded 10000 passes.${h ? ` Pending: ${h}.` : ""}`));
+          break;
+        }
+        for (const h of this._phases) {
+          if (this._disposed)
+            break;
+          const f = this._takePhase(h.phase.name);
+          if (f.length === 0)
+            continue;
+          const o = e.length;
+          (n = this._tracePhase) == null || n.call(this, h.phase.name, "start");
+          let _ = 0, c = !0, p;
+          for (const u of f) {
+            if (u.pending = !1, !u.active || u.consumerOwner.disposed) {
+              this._disposeTask(u);
+              continue;
+            }
+            this._beginDelivery(u, s), p !== void 0 && (u.priority > p.priority || u.priority === p.priority && u.sequence < p.sequence) && (c = !1), p = u, f[_++] = u;
+          }
+          if (f.length = _, f.length === 0)
+            continue;
+          c || f.sort(T);
+          const k = h.phase.process;
+          if (k === void 0)
+            for (const u of f)
+              try {
+                this._runDelivery(u);
+              } catch (v) {
+                e.push(v);
+              }
+          else {
+            const u = [];
+            for (const w of f)
+              u.push(w.task);
+            const v = Object.freeze({
+              phase: h.phase.name,
+              frame: s,
+              tasks: Object.freeze(u)
+            });
+            try {
+              this._runUntracked(() => k(v));
+            } catch (w) {
+              e.push(w);
+            }
+          }
+          let y = 0;
+          for (const u of f) {
+            if (u.resolution === "unresolved") {
+              y++;
+              try {
+                this._deferDelivery(u);
+              } catch (v) {
+                u.resolution = "cancel", this._acknowledgeDiscard(u, !0, e), e.push(v);
+              }
+            }
+            try {
+              this._finishDelivery(u);
+            } catch (v) {
+              u.resolution !== "run" && this._acknowledgeDiscard(u, !0, e), u.resolution = "cancel", u.inDelivery = !1, u.deliveryFirstCauseKey = void 0, u.deliveryExtraCauseKeys = void 0, u.deliveryCauses = m, e.push(v);
+            }
+          }
+          y !== 0 && e.push(new g(
+            `[Raph] Phase "${h.phase.name}" left ${y} task(s) unresolved; they were deferred.`
+          )), e.length === o ? (a = this._tracePhase) == null || a.call(this, h.phase.name, "end") : (r = this._tracePhase) == null || r.call(
+            this,
+            h.phase.name,
+            "error",
+            e[e.length - 1]
+          );
+        }
+      }
+    } catch (h) {
+      e.push(h), this._cancelAllQueued(!0, e), this._cancelAllDeferred(!0, e);
+    } finally {
+      this._running = !1;
+    }
+    try {
+      this._deferred.size !== 0 && this._scheduleDeferredTurn();
+    } catch (h) {
+      e.push(h);
+    }
+    const i = e.length === 1 ? e[0] : e.length > 1 ? new AggregateError(e, "[Raph] Multiple phase tasks failed.") : void 0;
+    if (i !== void 0)
+      throw this._settleIdleWaiters(i, !0), i;
+    this._settleIdleWaiters(void 0, !1);
+  }
+  dispose() {
+    if (this._disposed)
+      return;
+    this._disposed = !0, this._cancelScheduled(), this._cancelAllQueued(!1);
+    const e = [...this._deferred];
+    this._cancelAllDeferred(!1);
+    for (const t of e)
+      t.active = !1;
+    this._phaseBindings.clear(), this._phases = [], this._phaseByName.clear();
+    const s = new P("[Raph] Phase pipeline is disposed.");
+    this._settleIdleWaiters(s, !0);
+  }
+  _debugPending() {
+    return this._scheduled || this._running || this._hasPending();
+  }
+  _describeQueued() {
+    var s;
+    const e = [];
+    for (const t of this._phases) {
+      const i = ((s = this._queues.get(t.phase.name)) == null ? void 0 : s.filter((a) => a.active && !a.consumerOwner.disposed)) ?? [];
+      if (i.length === 0)
+        continue;
+      const n = i.slice(0, 3).map((a) => {
+        var c, p;
+        const r = a.consumerOwner.node, h = r === void 0 ? void 0 : r.componentId, f = r === void 0 ? a.consumerOwner.id : `${a.consumerOwner.id}/${r.constructor.name}/${r.type}${typeof h == "string" ? `/${h}` : ""}`, o = (p = (c = a.firstCause) == null ? void 0 : c.sourceOwner) == null ? void 0 : p.node, _ = o === void 0 ? "" : `<=${o.id}/${o.constructor.name}`;
+        return `${f}${a.firstCause ? `:${a.firstCause.kind}${_}` : ""}`;
+      }).join(", ");
+      e.push(`${t.phase.name}=${i.length}${n ? ` [${n}]` : ""}`);
+    }
+    return e.join("; ");
+  }
+  _createTask(e) {
+    const s = {
+      get phase() {
+        return e.phase;
+      },
+      get consumerOwner() {
+        return e.consumerOwner;
+      },
+      get effect() {
+        return e.effect;
+      },
+      get causes() {
+        return e.deliveryCauses;
+      },
+      get frame() {
+        return e.frame;
+      },
+      get priority() {
+        return e.priority;
+      },
+      get sequence() {
+        return e.sequence;
+      },
+      run: () => this._runDelivery(e),
+      defer: () => this._deferDelivery(e),
+      cancel: () => this._cancelDelivery(e)
+    };
+    return Object.defineProperty(s, O, { value: e }), Object.freeze(s);
+  }
+  _beginDelivery(e, s) {
+    e.pending = !1, e.inDelivery = !0, e.discardAcknowledged = !1, e.requested = !1, e.resolution = "unresolved", e.frame = s;
+    const t = e.firstCause;
+    if (t === void 0) {
+      e.deliveryFirstCauseKey = void 0, e.deliveryExtraCauseKeys = void 0, e.deliveryCauses = m;
+      return;
+    }
+    const i = e.extraCauses;
+    if (e.deliveryFirstCauseKey = e.firstCauseKey, e.firstCause = void 0, e.firstCauseKey = void 0, e.extraCauses = void 0, i === void 0 || i.size === 0) {
+      e.deliveryExtraCauseKeys = void 0, e.deliveryCauses = Object.freeze([t]);
+      return;
+    }
+    e.deliveryExtraCauseKeys = Object.freeze([...i.keys()]), e.deliveryCauses = Object.freeze([t, ...i.values()]);
+  }
+  _runDelivery(e) {
+    if (!e.active || e.paused || e.consumerOwner.disposed) {
+      e.resolution = "cancel";
+      return;
+    }
+    this._assertDelivery(e), e.resolution = "run", e.deferCount = 0, this._runUntracked(e.runner);
+  }
+  _deferDelivery(e) {
+    if (!e.active || e.paused || e.consumerOwner.disposed) {
+      e.resolution = "cancel";
+      return;
+    }
+    if (this._assertDelivery(e), e.resolution = "defer", ++e.deferCount > K) {
+      e.resolution = "cancel";
+      const s = [];
+      throw this._acknowledgeDiscard(e, !0, s), s.length !== 0 ? new AggregateError(
+        [new g(
+          `[Raph] Phase task in "${e.phase}" exceeded 10000 deferred deliveries.`
+        ), ...s],
+        "[Raph] Phase task defer limit and recovery failed."
+      ) : new g(
+        `[Raph] Phase task in "${e.phase}" exceeded 10000 deferred deliveries.`
+      );
+    }
+  }
+  _cancelDelivery(e) {
+    if (!e.active || e.consumerOwner.disposed) {
+      e.resolution = "cancel";
+      return;
+    }
+    this._assertDelivery(e);
+    const s = [];
+    if (this._acknowledgeDiscard(e, !1, s), s.length !== 0)
+      throw s.length === 1 ? s[0] : new AggregateError(s, "[Raph] Phase task cancellation failed.");
+    e.discardAcknowledged && (e.requested = C(e)), e.resolution = "cancel", e.deferCount = 0;
+  }
+  _finishDelivery(e) {
+    var t;
+    if (!e.inDelivery)
+      return;
+    const s = e.resolution;
+    if (e.inDelivery = !1, !e.active || e.consumerOwner.disposed) {
+      e.deliveryFirstCauseKey = void 0, e.deliveryExtraCauseKeys = void 0, e.deliveryCauses = m;
+      return;
+    }
+    if (e.paused) {
+      s !== "run" && !(s === "cancel" && e.discardAcknowledged) && (this._restoreDeliveryCausesBeforePending(e), e.requested = !0), e.deliveryFirstCauseKey = void 0, e.deliveryExtraCauseKeys = void 0, e.deliveryCauses = m;
+      return;
+    }
+    if (s === "defer" && (this._restoreDeliveryCausesBeforePending(e), e.deferred = !0, this._deferred.add(e)), e.deliveryFirstCauseKey = void 0, e.deliveryExtraCauseKeys = void 0, e.deliveryCauses = m, s !== "defer" && (e.requested || C(e))) {
+      const i = (t = e.binding) == null ? void 0 : t.rearmPending;
+      i === void 0 ? this._queue(e) : i();
+    }
+  }
+  _appendCause(e, s, t) {
+    if (!e.active)
+      return;
+    const i = e.firstCause;
+    if (i === void 0) {
+      e.firstCause = s, e.firstCauseKey = t;
+      return;
+    }
+    if (e.firstCauseKey === t) {
+      e.firstCause = b(i, s);
+      return;
+    }
+    const n = e.extraCauses ?? (e.extraCauses = /* @__PURE__ */ new Map()), a = n.get(t);
+    n.set(t, a === void 0 ? s : b(a, s));
+  }
+  _queue(e, s = !0) {
+    if (!e.active || e.consumerOwner.disposed || this._disposed)
+      return;
+    if (e.paused) {
+      e.requested = !0;
+      return;
+    }
+    if (e.inDelivery) {
+      e.requested = !0;
+      return;
+    }
+    if (e.pending) {
+      s && this._schedule();
+      return;
+    }
+    if (e.deferred)
+      return;
+    e.discardAcknowledged = !1, e.pending = !0, e.sequence = this._taskSequence++;
+    let t = this._queues.get(e.phase);
+    t === void 0 && (t = [], this._queues.set(e.phase, t)), t.push(e), s && this._schedule();
+  }
+  _disposeTask(e) {
+    var i;
+    if (!e.active)
+      return;
+    e.active = !1, e.binding !== void 0 && (delete e.binding.cancelPending, delete e.binding.rearmPending, delete e.binding.abort, delete e.binding), e.pending = !1, e.deferred = !1, e.inDelivery && (e.resolution = "cancel"), e.firstCause = void 0, e.firstCauseKey = void 0, (i = e.extraCauses) == null || i.clear(), e.extraCauses = void 0, e.deliveryFirstCauseKey = void 0, e.deliveryExtraCauseKeys = void 0, e.deliveryCauses = m, this._deferred.delete(e);
+    const s = this._queues.get(e.phase);
+    if (s !== void 0) {
+      const n = s.indexOf(e);
+      n >= 0 && s.splice(n, 1), s.length === 0 && this._queues.delete(e.phase);
+    }
+    const t = (this._phaseBindings.get(e.phase) ?? 1) - 1;
+    t === 0 ? this._phaseBindings.delete(e.phase) : this._phaseBindings.set(e.phase, t), this._hasPending() || this._cancelScheduled(), this._settleIdleWaiters(void 0, !1);
+  }
+  _pauseTask(e) {
+    if (!e.active || e.paused)
+      return;
+    e.paused = !0, e.requested = e.requested || e.pending || e.deferred || e.inDelivery && e.resolution !== "run" && !(e.resolution === "cancel" && e.discardAcknowledged), e.pending = !1, e.deferred && (e.deferred = !1, this._deferred.delete(e));
+    const s = this._queues.get(e.phase);
+    if (s !== void 0) {
+      const t = s.indexOf(e);
+      t >= 0 && s.splice(t, 1), s.length === 0 && this._queues.delete(e.phase);
+    }
+    this._hasPending() || this._cancelScheduled(), this._settleIdleWaiters(void 0, !1);
+  }
+  _resumeTask(e) {
+    !e.active || !e.paused || e.consumerOwner.disposed || (e.paused = !1, (e.requested || C(e)) && (e.requested = !1, this._queue(e)));
+  }
+  _restoreDeliveryCausesBeforePending(e) {
+    const s = e.deliveryCauses;
+    if (s.length === 0)
+      return;
+    const t = e.firstCause, i = e.firstCauseKey, n = e.extraCauses;
+    e.firstCause = void 0, e.firstCauseKey = void 0, e.extraCauses = void 0, this._appendCause(e, s[0], e.deliveryFirstCauseKey);
+    const a = e.deliveryExtraCauseKeys;
+    for (let r = 1; r < s.length; r++)
+      this._appendCause(e, s[r], a[r - 1]);
+    if (t !== void 0 && (this._appendCause(e, t, i), n !== void 0))
+      for (const [r, h] of n)
+        this._appendCause(e, h, r);
+  }
+  _takePhase(e) {
+    const s = this._queues.get(e);
+    return s === void 0 ? [] : (this._queues.delete(e), s);
+  }
+  _schedule() {
+    if (this._running || this._scheduled || this._disposed)
+      return;
+    if (this._scheduler === "sync") {
+      if (this._deferSync())
+        return;
+      this.flush();
+      return;
+    }
+    this._scheduled = !0;
+    const e = ++this._scheduleToken, s = () => {
+      this._disposed || !this._scheduled || e !== this._scheduleToken || (this._scheduled = !1, this._frameHandle = void 0, this._frameHandleKind = void 0, this.flush());
+    };
+    if (this._scheduler === "microtask") {
+      queueMicrotask(s);
+      return;
+    }
+    typeof globalThis.requestAnimationFrame == "function" ? (this._frameHandleKind = "animation-frame", this._frameHandle = globalThis.requestAnimationFrame(s)) : (this._frameHandleKind = "timeout", this._frameHandle = setTimeout(s, 16));
+  }
+  _scheduleDeferredTurn() {
+    if (this._scheduled || this._disposed)
+      return;
+    this._scheduled = !0;
+    const e = ++this._scheduleToken, s = () => {
+      this._disposed || !this._scheduled || e !== this._scheduleToken || (this._scheduled = !1, this._frameHandle = void 0, this._frameHandleKind = void 0, this._activateDeferred(), this._hasQueued() ? this.flush() : this._settleIdleWaiters(void 0, !1));
+    };
+    this._scheduler === "animationFrame" ? typeof globalThis.requestAnimationFrame == "function" ? (this._frameHandleKind = "animation-frame", this._frameHandle = globalThis.requestAnimationFrame(s)) : (this._frameHandleKind = "timeout", this._frameHandle = setTimeout(s, 16)) : queueMicrotask(s);
+  }
+  _cancelScheduled() {
+    var e;
+    this._scheduled && (this._scheduled = !1, this._scheduleToken++, this._frameHandleKind === "animation-frame" && this._frameHandle !== void 0 ? (e = globalThis.cancelAnimationFrame) == null || e.call(globalThis, this._frameHandle) : this._frameHandleKind === "timeout" && this._frameHandle !== void 0 && clearTimeout(this._frameHandle), this._frameHandle = void 0, this._frameHandleKind = void 0);
+  }
+  _activateDeferred() {
+    const e = [...this._deferred];
+    this._deferred.clear();
+    for (const s of e)
+      s.deferred = !1, this._queue(s, !1);
+  }
+  _nextFrame() {
+    var t;
+    const e = ((t = globalThis.performance) == null ? void 0 : t.now()) ?? Date.now();
+    if (this._firstFrameAt === void 0 || this._lastFrameAt === void 0)
+      return this._firstFrameAt = e, this._lastFrameAt = e, this._frame = Object.freeze({ now: e, delta: 0, elapsed: 0, frame: 0 });
+    this._frameNumber++;
+    const s = Object.freeze({
+      now: e,
+      delta: Math.min(Math.max(e - this._lastFrameAt, 0), 100),
+      elapsed: Math.max(e - this._firstFrameAt, 0),
+      frame: this._frameNumber
+    });
+    return this._lastFrameAt = e, this._frame = s;
+  }
+  _assertRetainedPhases(e) {
+    for (const s of this._phaseBindings.keys())
+      if (!e.has(s))
+        throw new Error(`[Raph] Cannot remove phase "${s}" while it is still bound.`);
+    for (const s of this._queues.keys())
+      if (!e.has(s))
+        throw new Error(`[Raph] Cannot remove phase "${s}" while it has pending work.`);
+  }
+  _assertDelivery(e) {
+    if (!e.active || !e.inDelivery || e.resolution !== "unresolved")
+      throw new g("[Raph] Phase task delivery is already resolved.");
+  }
+  _hasQueued() {
+    for (const e of this._queues.values())
+      if (e.some((s) => s.active && s.pending))
+        return !0;
+    return !1;
+  }
+  _hasPending() {
+    return this._hasQueued() || this._deferred.size !== 0;
+  }
+  _cancelAllQueued(e, s = []) {
+    const t = /* @__PURE__ */ new Set();
+    for (const i of this._queues.values())
+      for (const n of i)
+        t.add(n);
+    this._queues.clear();
+    for (const i of t)
+      i.pending = !1, e && this._acknowledgeDiscard(i, !0, s), this._clearPendingDelivery(i);
+  }
+  _cancelAllDeferred(e, s = []) {
+    const t = [...this._deferred];
+    this._deferred.clear();
+    for (const i of t)
+      i.deferred = !1, e && this._acknowledgeDiscard(i, !0, s), this._clearPendingDelivery(i);
+  }
+  _acknowledgeDiscard(e, s, t) {
+    if (e.discardAcknowledged)
+      return;
+    const i = e.binding, n = i == null ? void 0 : i.cancelPending;
+    if (n === void 0) {
+      e.discardAcknowledged = !0;
+      return;
+    }
+    try {
+      if (n()) {
+        e.discardAcknowledged = !0;
+        return;
+      }
+      if (!s) {
+        t.push(new g(
+          `[Raph] Initial effect delivery in "${e.phase}" cannot be cancelled before dependency collection.`
+        ));
+        return;
+      }
+      const a = i == null ? void 0 : i.abort;
+      if (a === void 0) {
+        t.push(new g(
+          `[Raph] Initial effect delivery in "${e.phase}" could not be aborted safely.`
+        ));
+        return;
+      }
+      a(), e.discardAcknowledged = !0;
+    } catch (a) {
+      t.push(a);
+    }
+  }
+  _clearPendingDelivery(e) {
+    var s;
+    e.requested = !1, e.firstCause = void 0, e.firstCauseKey = void 0, (s = e.extraCauses) == null || s.clear(), e.extraCauses = void 0;
+  }
+  _settleIdleWaiters(e, s) {
+    if (!s && (this._running || this._scheduled || this._hasPending()))
+      return;
+    const t = [...this._idleWaiters];
+    this._idleWaiters.clear();
+    for (const i of t)
+      e === void 0 ? i.resolve() : i.reject(e);
+  }
+  _assertAlive() {
+    if (this._disposed)
+      throw new P("[Raph] Phase pipeline is disposed.");
+  }
+}
+function T(l, e) {
+  return e.priority - l.priority || l.sequence - e.sequence;
+}
+function C(l) {
+  return l.firstCause !== void 0;
+}
+function b(l, e) {
+  const s = l.events === void 0 ? e.events : e.events === void 0 ? l.events : Object.freeze([...l.events, ...e.events]), t = l.structure === void 0 ? e.structure : e.structure === void 0 ? l.structure : Object.freeze({
+    node: e.structure.node,
+    oldParent: l.structure.oldParent,
+    oldIndex: l.structure.oldIndex,
+    newParent: e.structure.newParent,
+    newIndex: e.structure.newIndex
+  });
+  return Object.freeze({
+    ...e,
+    previous: l.previous,
+    ...s === void 0 ? {} : { events: s },
+    ...t === void 0 ? {} : { structure: t }
+  });
+}
+export {
+  R as RaphPhasePipeline
+};

package/dist/debug/runtime/phases/orderPhaseTasks.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function u(o,r){const i=r.direction??"parents-first",s=o.map(n=>{const t=r.node(n);return{node:t,path:t==null?void 0:k(t),task:n}}),e=l(s);return s.sort((n,t)=>{if(n.path===void 0||t.path===void 0)return n.path!==t.path?n.path===void 0?1:-1:t.task.priority-n.task.priority||n.task.sequence-t.task.sequence;const c=d(n.path,t.path,e,i==="children-first");return c!==0?c:t.task.priority-n.task.priority||n.task.sequence-t.task.sequence}),s.map(n=>n.task)}function d(o,r,i,s){if(o[o.length-1]===r[r.length-1])return 0;let e=0;const n=Math.min(o.length,r.length);for(;e<n&&o[e]===r[e];)e++;if(e===o.length)return s?1:-1;if(e===r.length)return s?-1:1;const t=o[e],c=r[e];if(t.priority!==c.priority)return c.priority-t.priority;const a=i.get(t),p=i.get(c);return a!==void 0&&p!==void 0?a-p:t.id.localeCompare(c.id)}function l(o){const r=new Set;for(const s of o){const e=s.path;if(e!==void 0)for(let n=0;n+1<e.length;n++)r.add(e[n])}const i=new Map;for(const s of r){const e=s.children;for(let n=0;n<e.length;n++)i.set(e[n],n)}return i}function k(o){const r=[];for(let i=o;i!==null;i=i.parent)r.push(i);return r.reverse(),r}exports.orderPhaseTasks=u;

package/dist/debug/runtime/phases/orderPhaseTasks.js

@@ -0,0 +1,59 @@
+function k(o, r) {
+  const i = r.direction ?? "parents-first", s = o.map((n) => {
+    const t = r.node(n);
+    return { node: t, path: t == null ? void 0 : l(t), task: n };
+  }), e = d(s);
+  return s.sort((n, t) => {
+    if (n.path === void 0 || t.path === void 0)
+      return n.path !== t.path ? n.path === void 0 ? 1 : -1 : t.task.priority - n.task.priority || n.task.sequence - t.task.sequence;
+    const c = u(
+      n.path,
+      t.path,
+      e,
+      i === "children-first"
+    );
+    return c !== 0 ? c : t.task.priority - n.task.priority || n.task.sequence - t.task.sequence;
+  }), s.map((n) => n.task);
+}
+function u(o, r, i, s) {
+  if (o[o.length - 1] === r[r.length - 1])
+    return 0;
+  let e = 0;
+  const n = Math.min(o.length, r.length);
+  for (; e < n && o[e] === r[e]; )
+    e++;
+  if (e === o.length)
+    return s ? 1 : -1;
+  if (e === r.length)
+    return s ? -1 : 1;
+  const t = o[e], c = r[e];
+  if (t.priority !== c.priority)
+    return c.priority - t.priority;
+  const a = i.get(t), p = i.get(c);
+  return a !== void 0 && p !== void 0 ? a - p : t.id.localeCompare(c.id);
+}
+function d(o) {
+  const r = /* @__PURE__ */ new Set();
+  for (const s of o) {
+    const e = s.path;
+    if (e !== void 0)
+      for (let n = 0; n + 1 < e.length; n++)
+        r.add(e[n]);
+  }
+  const i = /* @__PURE__ */ new Map();
+  for (const s of r) {
+    const e = s.children;
+    for (let n = 0; n < e.length; n++)
+      i.set(e[n], n);
+  }
+  return i;
+}
+function l(o) {
+  const r = [];
+  for (let i = o; i !== null; i = i.parent)
+    r.push(i);
+  return r.reverse(), r;
+}
+export {
+  k as orderPhaseTasks
+};

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

@@ -0,0 +1 @@
+"use strict";var p=Object.defineProperty;var u=(a,s,t)=>s in a?p(a,s,{enumerable:!0,configurable:!0,writable:!0,value:t}):a[s]=t;var i=(a,s,t)=>u(a,typeof s!="symbol"?s+"":s,t);Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const k=require("../../path/data-path.utils.cjs"),f=require("../errors.cjs"),w=require("../ownership/throwDisposalErrors.cjs");class A{constructor(s,t,h,r,e,o,n,d,v,c,l){i(this,"path");i(this,"options");i(this,"_revision");i(this,"_disposeRevision");i(this,"_isTracking");i(this,"_store");i(this,"_release");i(this,"_masks");i(this,"_assertOwnerAlive");i(this,"_assertTrackedRead");i(this,"_assertWriteAllowed");i(this,"_runWrite");i(this,"_notifyEvents");i(this,"_hasRevisionSubscribers");i(this,"_stop");i(this,"_activationLeases",0);i(this,"_trackedActivation",!1);i(this,"_disposed",!1);const _=e._ownedSignal(0,c);this._store=s,this._revision=_.source,this._disposeRevision=_.dispose,this._isTracking=e._isTracking,this.path=t.canonical,this.options=h,this._release=r,this._masks=k.pathRelationMasks(t),this._assertOwnerAlive=o,this._assertTrackedRead=n,this._assertWriteAllowed=d,this._runWrite=v,this._notifyEvents=l,this._hasRevisionSubscribers=_.hasSubscribers}get disposed(){return this._disposed}get(){var s;return this._assertAlive(),(s=this._assertTrackedRead)==null||s.call(this),this._isTracking()?this._readTracked():this._store.peek(this.path)}peek(){return this._assertAlive(),this._store.peek(this.path)}set(s){var t;this._assertAlive(),(t=this._assertWriteAllowed)==null||t.call(this),this._write(()=>this._store.set(this.path,s))}merge(s){var t;this._assertAlive(),(t=this._assertWriteAllowed)==null||t.call(this),this._write(()=>this._store.merge(this.path,s))}delete(){var s;this._assertAlive(),(s=this._assertWriteAllowed)==null||s.call(this),this._write(()=>this._store.delete(this.path))}has(){return this._assertAlive(),this._store.has(this.path)}dispose(){if(this._disposed)return;const s=this._runWrite;s===void 0?this._disposeNow():s(()=>this._disposeNow())}_disposeNow(){if(this._disposed)return;this._disposed=!0;const s=[],t=this._stop;this._stop=void 0;const h=this._disposeRevision;this._disposeRevision=void 0;const r=this._release;this._release=void 0,this._revision=void 0,this._isTracking=void 0,this._store=void 0,this._assertOwnerAlive=void 0,this._assertTrackedRead=void 0,this._assertWriteAllowed=void 0,this._runWrite=void 0,this._notifyEvents=void 0,this._hasRevisionSubscribers=void 0,this._activationLeases=0,this._trackedActivation=!1;try{t==null||t()}catch(e){s.push(e)}try{h==null||h()}catch(e){s.push(e)}try{r==null||r(this)}catch(e){s.push(e)}w.throwDisposalErrors(s,`[Raph] Path handle "${this.path}" disposal failed.`)}_getTracked(){var s;return this._assertAlive(),(s=this._assertTrackedRead)==null||s.call(this),this._readTracked()}_activate(){this._assertAlive(),this._activationLeases++;try{this._observe()}catch(t){throw this._activationLeases--,t}let s=!0;return()=>{s&&(s=!1,this._activationLeases!==0&&this._activationLeases--,this._releaseObserverIfIdle())}}_readTracked(){return this._trackedActivation=!0,this._observe(),this._revision.get(),this._store.get(this.path)}_observe(){this._stop??(this._stop=this._store.watch(this._masks,s=>{const t=()=>{var e,o;if(this._disposed)return;const r=this._revision;r!==void 0&&((o=this._notifyEvents)==null||o.call(this,s,((e=this._hasRevisionSubscribers)==null?void 0:e.call(this))??!1),!(this._disposed||this._revision!==r)&&r.set(r.peek()+1))},h=this._runWrite;h===void 0?t():h(t)}))}_releaseObserverIfIdle(){if(this._disposed||this._trackedActivation||this._activationLeases!==0)return;const s=this._stop;this._stop=void 0,s==null||s()}_write(s){const t=this._runWrite;t===void 0?s():t(s)}_assertAlive(){var s;if(this._disposed)throw new f.RaphDisposedError(`[Raph] Path handle "${this.path}" is disposed.`);(s=this._assertOwnerAlive)==null||s.call(this)}}exports.PathHandle=A;