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

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

@@ -1,30 +1,45 @@
-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;
+import { RaphPhaseProcessError as R, RaphDisposedError as I } from "../errors.js";
+import { throwDisposalErrors as z } from "../ownership/throwDisposalErrors.js";
+import { EMPTY_FRAME as B, RaphPhaseTaskRecord as $, GROUP_NODES as y, GROUP_CONTEXT as M, GROUP_CURSOR as N, TASK_ACTIVE as f, TASK_TASKLESS as G, TASK_PENDING as w, TASK_RESOLUTION as b, TASK_UNRESOLVED as j, TASK_CANCEL as m, TASK_RUN as q, TASK_IN_DELIVERY as p, TASK_CAUSES_DELIVERED as k, TASK_EXECUTED as H, TASK_PAUSED as A, TASK_REQUESTED as g, TASK_DEFER as W, TASK_DISCARD_ACKNOWLEDGED as C, TASK_DEFERRED as E } from "./RaphPhaseTaskRecord.js";
+class Q {
+  constructor(e, t) {
+    this.name = e, this.pipeline = t, this.queue = [], this.spare = [], this.bindings = 0;
   }
+}
+const V = 1e4, X = 1e4, P = f | A, x = p | b;
+class te {
+  constructor(e, t, s, i = () => !1, a) {
+    this._scheduler = e, this._reactivity = t, this._resolveCause = s, this._deferSync = i, this._tracePhase = a;
+  }
+  _phases = [];
+  _phaseByName = /* @__PURE__ */ new Map();
+  // Последнее разрешённое имя phase в том виде, в каком его передал вызывающий.
+  _resolvedInput;
+  _resolvedState;
+  // Число записей во всех живых очередях.
+  _queuedCount = 0;
+  _deferred = /* @__PURE__ */ new Set();
+  _idleWaiters = /* @__PURE__ */ new Set();
+  _taskSequence = 0;
+  _scheduled = !1;
+  _scheduleToken = 0;
+  _frameHandle;
+  _frameHandleKind;
+  _configurationLocked = !1;
+  /**
+   * Flush исполняется сейчас: новая работа попадёт в его следующий проход.
+   *
+   * @internal
+   */
+  _running = !1;
+  // Значение flags записи slot, которая не запланирована: slot с таким же
+  // значением доставка группы пропускает, не обращаясь к engine.
+  _idleSlotFlags = -1;
+  _disposed = !1;
+  _firstFrameAt;
+  _lastFrameAt;
+  _frameNumber = 0;
+  _frame = B;
   get frame() {
     return this._frame;
   }
@@ -34,22 +49,26 @@ class R {
   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();
+    const t = this._phaseByName, s = /* @__PURE__ */ new Map(), i = [];
+    for (const a of e) {
+      const n = a.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")
+      if (a.process !== void 0 && typeof a.process != "function")
         throw new TypeError(`[Raph] Phase "${n}" process must be a function.`);
-      const a = Object.freeze({
+      const o = Object.freeze({
         name: n,
-        ...i.process === void 0 ? {} : { process: i.process }
-      }), r = { index: t.length, phase: a };
-      t.push(r), s.set(n, r);
+        ...a.process === void 0 ? {} : { process: a.process }
+      }), r = {
+        index: i.length,
+        phase: o,
+        state: t.get(n)?.state ?? new Q(n, this)
+      };
+      i.push(r), s.set(n, r);
     }
-    this._assertRetainedPhases(s), this._phases = t, this._phaseByName = s;
+    this._assertRetainedPhases(s), this._phases = i, this._phaseByName = s, this._resolvedInput = void 0, this._resolvedState = void 0;
   }
   addPhase(e) {
     this.definePhases([...this.phases, e]);
@@ -57,164 +76,160 @@ class R {
   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;
+  /**
+   * Находит состояние объявленной phase по имени, которое передал вызывающий.
+   * Подряд идущие bindings одной phase попадают в кэш из одной записи; точное
+   * имя находится без `trim()`, и только имя с пробелами по краям нормализуется.
+   */
+  resolvePhase(e) {
+    this._assertAlive();
+    const t = this._resolvedState;
+    if (t !== void 0 && e === this._resolvedInput)
+      return t;
+    let s = this._phaseByName.get(e);
+    if (s === void 0) {
+      const i = e.trim();
+      if (i !== e && (s = this._phaseByName.get(i)), s === void 0)
+        throw new Error(`[Raph] Phase "${i}" is not defined.`);
+    }
+    return this._resolvedInput = e, this._resolvedState = s.state;
+  }
+  /**
+   * Создаёт постоянную запись одного binding. Вызывающий уже разрешил phase
+   * и проверил priority, поэтому горячий путь регистрации проверяет их один раз.
+   * Запись ничего не выполняет, пока вызывающий не подключит engine effect
+   * (`node`) или watch lifecycle (`watch`).
+   */
+  bindTask(e, t, s, i) {
+    return e.bindings++, new $(e, i, t, s);
+  }
+  /**
+   * Создаёт постоянную запись группы из `count` slots: одна запись binding и
+   * её состояние с местом под запись графа каждого slot. Вызывающий уже
+   * разрешил phase и проверил priority и `count`; записи графа он подключает
+   * сам через _allocateTaskEffect() и кладёт в состояние по порядку slots.
+   * Slot ничего не исполняет, пока его запись не запланирована.
+   *
+   * `runSlot` занимает место callback записи: его показывает `task.effect`
+   * группы, а вызывает только общее тело записей engine — с состоянием
+   * группы, где лежат её context и номер slot. Поэтому запись группы несёт
+   * `TASK_TASKLESS`: вместо task тело получает поле `group`.
+   */
+  bindGroup(e, t, s, i, a, n) {
+    const o = new Array(y + a);
+    o[M] = i, o[N] = 0, e.bindings++;
+    const r = new $(e, n, t, s);
+    return r.state = f | G, r.group = o, r;
   }
   request() {
-    this._assertAlive(), this._hasQueued() && this._schedule();
+    this._assertAlive(), this._queuedCount !== 0 && 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 });
+    return this._assertAlive(), !this._running && !this._scheduled && !this._hasPending() ? Promise.resolve() : new Promise((e, t) => {
+      this._idleWaiters.add({ reject: t, 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()) {
+    if (this._queuedCount === 0 && this._deferred.size !== 0 && this._activateDeferred(), this._queuedCount === 0) {
       this._settleIdleWaiters(void 0, !1);
       return;
     }
     this._configurationLocked = !0, this._running = !0;
-    const e = [], s = this._nextFrame();
-    let t = 0;
+    const e = [], t = this._nextFrame();
+    let s = 0, i;
     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}.` : ""}`));
+      for (; this._queuedCount !== 0; ) {
+        if (++s > V) {
+          const n = this._describeQueued();
+          this._cancelAllQueued(!0, e), e.push(new Error(`[Raph] Phase flush exceeded 10000 passes.${n ? ` Pending: ${n}.` : ""}`));
           break;
         }
-        for (const h of this._phases) {
+        for (const n of this._phases) {
           if (this._disposed)
             break;
-          const f = this._takePhase(h.phase.name);
-          if (f.length === 0)
+          const o = n.state, r = o.queue;
+          if (r.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);
+          o.queue = o.spare, o.spare = i = r, this._queuedCount -= r.length;
+          const d = e.length;
+          this._tracePhase?.(n.phase.name, "start");
+          let l = 0, _ = !0, c;
+          for (const u of r) {
+            const v = u.state;
+            if (!(v & f) || u.consumerOwner.disposed) {
+              u.state = v & ~w, 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;
+            this._beginDelivery(u, t), c !== void 0 && (u.priority > c.priority || u.priority === c.priority && u.sequence < c.sequence) && (_ = !1), c = u, r[l++] = u;
           }
-          if (f.length = _, f.length === 0)
+          if (r.length = l, r.length === 0) {
+            i = void 0;
             continue;
-          c || f.sort(T);
-          const k = h.phase.process;
-          if (k === void 0)
-            for (const u of f)
+          }
+          _ || r.sort(Y);
+          const D = n.phase.process;
+          if (D === void 0)
+            for (const u of r)
               try {
-                this._runDelivery(u);
+                this._runDelivery(u, e);
               } catch (v) {
                 e.push(v);
               }
           else {
             const u = [];
-            for (const w of f)
-              u.push(w.task);
+            for (const K of r)
+              u.push(K.task);
             const v = Object.freeze({
-              phase: h.phase.name,
-              frame: s,
+              phase: n.phase.name,
+              frame: t,
               tasks: Object.freeze(u)
             });
             try {
-              this._runUntracked(() => k(v));
-            } catch (w) {
-              e.push(w);
+              this._reactivity.untrackedWithOwner(() => D(v));
+            } catch (K) {
+              e.push(K);
             }
           }
-          let y = 0;
-          for (const u of f) {
-            if (u.resolution === "unresolved") {
-              y++;
+          let T = 0;
+          for (const u of r) {
+            if ((u.state & b) === j) {
+              T++;
               try {
                 this._deferDelivery(u);
               } catch (v) {
-                u.resolution = "cancel", this._acknowledgeDiscard(u, !0, e), e.push(v);
+                u.state |= m, 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);
+              (u.state & b) !== q && this._acknowledgeDiscard(u, !0, e), u.state = (u.state | m) & ~p, S(u), 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,
+          r.length = 0, i = void 0, T !== 0 && e.push(new R(
+            `[Raph] Phase "${n.phase.name}" left ${T} task(s) unresolved; they were deferred.`
+          )), e.length === d ? this._tracePhase?.(n.phase.name, "end") : this._tracePhase?.(
+            n.phase.name,
             "error",
             e[e.length - 1]
           );
         }
       }
-    } catch (h) {
-      e.push(h), this._cancelAllQueued(!0, e), this._cancelAllDeferred(!0, e);
+    } catch (n) {
+      e.push(n), i !== void 0 && (i.length = 0), this._cancelAllQueued(!0, e), this._cancelAllDeferred(!0, e);
     } finally {
       this._running = !1;
     }
     try {
       this._deferred.size !== 0 && this._scheduleDeferredTurn();
-    } catch (h) {
-      e.push(h);
+    } catch (n) {
+      e.push(n);
     }
-    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;
+    const a = e.length === 1 ? e[0] : e.length > 1 ? new AggregateError(e, "[Raph] Multiple phase tasks failed.") : void 0;
+    if (e.length !== 0)
+      throw this._settleIdleWaiters(a, !0), a;
     this._settleIdleWaiters(void 0, !1);
   }
   dispose() {
@@ -223,207 +238,396 @@ class R {
     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);
+    for (const s of e)
+      s.state &= ~f;
+    this._phases = [], this._phaseByName.clear(), this._resolvedInput = void 0, this._resolvedState = void 0;
+    const t = new I("[Raph] Phase pipeline is disposed.");
+    this._settleIdleWaiters(t, !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)
+      const s = t.state.queue.filter(
+        (a) => (a.state & f) !== 0 && !a.consumerOwner.disposed
+      );
+      if (s.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}${_}` : ""}`;
+      const i = s.slice(0, 3).map((a) => {
+        const n = a.consumerOwner.node, o = n === void 0 ? void 0 : n.componentId, r = n === void 0 ? a.consumerOwner.id : `${a.consumerOwner.id}/${n.constructor.name}/${n.type}${typeof o == "string" ? `/${o}` : ""}`, d = a.firstCause?.sourceOwner?.node, l = d === void 0 ? "" : `<=${d.id}/${d.constructor.name}`;
+        return `${r}${a.firstCause ? `:${a.firstCause.kind}${l}` : ""}`;
       }).join(", ");
-      e.push(`${t.phase.name}=${i.length}${n ? ` [${n}]` : ""}`);
+      e.push(`${t.phase.name}=${s.length}${i ? ` [${i}]` : ""}`);
     }
     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;
+  /**
+   * Открывает доставку одной записью `state`. Накопленные причины остаются на
+   * своих местах и становятся причинами доставки под TASK_CAUSES_DELIVERED:
+   * ничего не копируется, а массив для `task.causes` строится, только если его
+   * прочитают. Frame доставки получает только запись с facade: без facade его
+   * нечем прочитать, а запись ссылки на новый frame в каждую доставленную
+   * запись стоит write barrier.
+   *
+   * Запись попадает сюда только из живой очереди, а в ней нет записей с
+   * открытой доставкой, поэтому причин прошлой доставки здесь не бывает.
+   */
+  _beginDelivery(e, t) {
+    const s = e.state & -1893 | p;
+    e.state = e.firstCause === void 0 ? s : s | k, e.facade !== void 0 && (e.frame = t);
+  }
+  /**
+   * Исполняет открытую доставку binding. `failures` передаёт default runner:
+   * группа складывает туда сбой каждого slot отдельно. Без него сбои slots
+   * бросаются вызывающему — `task.run()` внутри `process` — после прохода: один
+   * как есть, несколько одним AggregateError.
+   *
+   * @internal
+   */
+  _runDelivery(e, t) {
+    const s = e.state;
+    if ((s & P) !== f || e.consumerOwner.disposed) {
+      e.state = s | 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]);
+    (s & x) !== p && O(), e.state = s | q;
+    const i = e.detail;
+    i !== void 0 && (i.deferCount = 0);
+    const a = this._reactivity, n = e.node;
+    if (n !== void 0) {
+      a._beginTaskEffectRun(n) && (e.state |= H, a._runTaskEffectUntracked(n));
       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";
+    const o = e.group;
+    if (o === void 0) {
+      const _ = e.watch;
+      _ !== void 0 && a.untrackedWithOwner(_.deliver);
       return;
     }
-    this._assertDelivery(e), e.resolution = "run", e.deferCount = 0, this._runUntracked(e.runner);
+    const r = o.length;
+    let d = this._idleSlotFlags, l;
+    for (let _ = y; _ < r; _++) {
+      const c = o[_];
+      if (c === null || c.flags === d)
+        continue;
+      if (!a._beginTaskEffectRun(c)) {
+        c.evaluate !== void 0 && (this._idleSlotFlags = d = c.flags);
+        continue;
+      }
+      o[N] = _ - y;
+      try {
+        a._runTaskEffectUntracked(c);
+      } catch (T) {
+        t !== void 0 ? t.push(T) : (l ??= []).push(T);
+      }
+      const D = e.state;
+      if (!(D & f))
+        break;
+      if (D & A) {
+        _ + 1 < r && (this._restoreDeliveryCausesBeforePending(e), e.state |= g);
+        break;
+      }
+    }
+    if (l !== void 0)
+      throw l.length === 1 ? l[0] : new AggregateError(l, "[Raph] Effect group delivery failed.");
   }
+  /** @internal */
   _deferDelivery(e) {
-    if (!e.active || e.paused || e.consumerOwner.disposed) {
-      e.resolution = "cancel";
+    const t = e.state;
+    if ((t & P) !== f || e.consumerOwner.disposed) {
+      e.state = t | m;
       return;
     }
-    if (this._assertDelivery(e), e.resolution = "defer", ++e.deferCount > K) {
-      e.resolution = "cancel";
+    if ((t & x) !== p && O(), e.state = t | W, ++e.detailed().deferCount > X) {
+      e.state |= m;
       const s = [];
       throw this._acknowledgeDiscard(e, !0, s), s.length !== 0 ? new AggregateError(
-        [new g(
+        [new R(
           `[Raph] Phase task in "${e.phase}" exceeded 10000 deferred deliveries.`
         ), ...s],
         "[Raph] Phase task defer limit and recovery failed."
-      ) : new g(
+      ) : new R(
         `[Raph] Phase task in "${e.phase}" exceeded 10000 deferred deliveries.`
       );
     }
   }
+  /** @internal */
   _cancelDelivery(e) {
-    if (!e.active || e.consumerOwner.disposed) {
-      e.resolution = "cancel";
+    const t = e.state;
+    if (!(t & f) || e.consumerOwner.disposed) {
+      e.state = t | m;
       return;
     }
-    this._assertDelivery(e);
+    (t & x) !== p && O();
     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;
+    let i = e.state | m;
+    i & C && (i = F(e) ? i | g : i & ~g), e.state = i;
+    const a = e.detail;
+    a !== void 0 && (a.deferCount = 0);
   }
   _finishDelivery(e) {
-    var t;
-    if (!e.inDelivery)
+    const t = e.state;
+    if (!(t & p))
       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;
+    const s = t & b;
+    if (e.state = t & ~p, !(t & f) || e.consumerOwner.disposed) {
+      S(e);
       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;
+    if (t & A) {
+      s !== q && !(s === m && (t & C) !== 0) && (this._restoreDeliveryCausesBeforePending(e), e.state |= g), S(e);
       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();
+    if (s === W) {
+      this._restoreDeliveryCausesBeforePending(e), e.state |= E, this._deferred.add(e), S(e);
+      return;
+    }
+    if (S(e), (e.state & g) !== 0 || e.firstCause !== void 0) {
+      const i = e.node;
+      if (i !== void 0)
+        this._reactivity._rearmTaskEffect(i);
+      else {
+        const a = e.group;
+        a !== void 0 && this._rearmGroup(a), this._queue(e);
+      }
     }
   }
-  _appendCause(e, s, t) {
-    if (!e.active)
-      return;
-    const i = e.firstCause;
-    if (i === void 0) {
-      e.firstCause = s, e.firstCauseKey = t;
-      return;
+  /**
+   * Делает исполняемыми slots группы, которые остались запланированными после
+   * доставки: slot, изменивший собственную зависимость, и slot, чью зависимость
+   * изменили после его запуска. Slot, который не запланирован, не трогается:
+   * он уже прочитал актуальные значения и в следующей доставке не исполняется.
+   * Запись, сделанную до запуска slot в той же доставке, slot читает в ней же:
+   * прямую запись engine переводит в обязательный запуск, отложенную находит
+   * проверка зависимостей. Отдельный binding после такой записи исполняется
+   * ещё раз следующим проходом; slot повторно не исполняется.
+   *
+   * Запись без зависимостей пропускается. Запланированной она бывает в двух
+   * случаях: slot запущен во время доставки и ждёт первого запуска — тогда она
+   * исполняема с момента создания; либо повторно запущен slot, который уже
+   * исполнился и ничего не прочитал, — тогда исполнять его нечем.
+   */
+  _rearmGroup(e) {
+    const t = this._reactivity;
+    for (let s = y; s < e.length; s++) {
+      const i = e[s];
+      i !== null && i.firstDep !== null && t._beginTaskEffectRun(i) && t._rearmTaskEffect(i);
     }
-    if (e.firstCauseKey === t) {
-      e.firstCause = b(i, s);
-      return;
+  }
+  /** @internal */
+  _notifyTask(e, t) {
+    const s = this._resolveCause(t);
+    if (s !== void 0) {
+      const i = s.kind === "structure" ? s.source : t;
+      this._appendCause(e, s, i);
     }
-    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)
+  /** @internal */
+  _appendCause(e, t, s) {
+    const i = e.state;
+    if (!(i & f))
       return;
-    if (e.paused) {
-      e.requested = !0;
+    i & k && this._splitDeliveredCauses(e);
+    const a = e.firstCause;
+    if (a === void 0) {
+      e.firstCause = t, e.firstCauseKey = s;
       return;
     }
-    if (e.inDelivery) {
-      e.requested = !0;
+    if (e.firstCauseKey === s) {
+      e.firstCause = U(a, t);
       return;
     }
-    if (e.pending) {
-      s && this._schedule();
-      return;
+    const n = e.detailed().extraCauses ??= /* @__PURE__ */ new Map(), o = n.get(s);
+    n.set(s, o === void 0 ? t : U(o, t));
+  }
+  /**
+   * Переносит причины открытой доставки с места ожидающих в detail, без
+   * копирования, и освобождает это место. После вызова запись хранит оба
+   * набора раздельно: ожидающие причины — в своих полях, причины доставки — в
+   * detail. Массив, уже построенный для `task.causes`, остаётся тем же.
+   */
+  _splitDeliveredCauses(e) {
+    const t = e.detailed(), s = t.extraCauses;
+    t.deliveryFirstCause = e.firstCause, t.deliveryFirstCauseKey = e.firstCauseKey, t.deliveryExtraCauses = s === void 0 || s.size === 0 ? void 0 : s, t.extraCauses = void 0, e.firstCause = void 0, e.firstCauseKey = void 0, e.state &= ~k;
+  }
+  /** @internal */
+  _queue(e, t = !0) {
+    const s = e.state;
+    if (!(!(s & f) || e.consumerOwner.disposed || this._disposed)) {
+      if (s & (A | p)) {
+        e.state = s | g;
+        return;
+      }
+      if (s & w) {
+        t && this._schedule();
+        return;
+      }
+      s & E || (e.state = s & ~C | w, e.sequence = this._taskSequence++, e.phaseState.queue.push(e), this._queuedCount++, t && this._schedule());
     }
-    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();
   }
+  /** @internal */
   _disposeTask(e) {
-    var i;
-    if (!e.active)
+    const t = e.state;
+    if (!(t & f))
       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 s = t & -270;
+    e.state = t & p ? s | m : s, e.firstCause = void 0, e.firstCauseKey = void 0;
+    const i = e.detail;
+    i !== void 0 && (i.extraCauses?.clear(), i.extraCauses = void 0, L(i)), t & E && this._deferred.delete(e), t & w && this._unqueue(e), e.phaseState.bindings--, this._hasPending() || this._cancelScheduled(), this._settleIdleWaiters(void 0, !1);
+  }
+  /**
+   * Полностью освобождает один binding; каждый шаг идемпотентен, поэтому
+   * владелец, engine и пользователь могут прийти сюда в любом порядке и
+   * повторно войти в метод.
+   *
+   * @internal
+   */
+  _disposeBinding(e) {
+    const t = e.group;
+    if (t !== void 0 && this._forgetStoppedSlots(t))
+      return;
+    e.scopeParent !== void 0 && e.consumerOwner._releaseRecord(e);
+    const s = e.node;
+    if (s !== void 0)
+      e.node = void 0, this._reactivity._disposeTaskEffect(s);
+    else {
+      if (t !== void 0) {
+        e.group = void 0, this._disposeGroup(e, t);
+        return;
+      }
+      const i = e.watch;
+      i !== void 0 && (e.watch = void 0, i.stop(() => this._releaseWatch(e, i)));
+    }
+    this._disposeTask(e);
+  }
+  /**
+   * Убирает из состояния группы slots, записи графа которых уже остановлены, и
+   * сообщает, остались ли при этом живые slots.
+   *
+   * Запись одного slot останавливается отдельно от группы в трёх случаях: упал
+   * cleanup перед повторным запуском slot; перезапускается или останавливается
+   * effect, внутри тела которого группа зарегистрирована; провалился запуск
+   * slot через `start()`. Engine сообщает о каждой такой остановке через task
+   * hook, общий для всех slots, и запись в этот момент уже остановлена. Группа
+   * тогда теряет только этот slot, как owner потерял бы один из отдельных
+   * bindings; запись binding освобождается, когда остановлен последний slot.
+   *
+   * Вызов владельца или effect scope остановленных записей не находит: место
+   * остановленного slot уже занято `null`.
+   *
+   * @returns true, если вызов был сообщением engine и живые slots остались.
+   */
+  _forgetStoppedSlots(e) {
+    let t = !1, s = !1;
+    for (let i = y; i < e.length; i++) {
+      const a = e[i];
+      a != null && (a.evaluate === void 0 ? (e[i] = null, t = !0) : s = !0);
     }
-    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);
+    return t && s;
+  }
+  /**
+   * Останавливает записи графа всех slots группы в порядке, обратном порядку
+   * slots: так владелец освобождал бы отдельные bindings. Сбой cleanup одного
+   * slot не мешает остановить остальные.
+   *
+   * Группа — один ресурс, поэтому порядок и вид ошибки не зависят от того, кто
+   * её освобождает. Effect scope отдельные bindings освободил бы в порядке
+   * регистрации и сложил бы их сбои в собственный список; группу он
+   * освобождает в обратном порядке slots и получает несколько сбоев одним
+   * AggregateError. Владелец получает тот же AggregateError как один сбой
+   * ресурса вместо отдельных сбоев bindings.
+   *
+   * Остановка первой же записи повторно входит в _disposeBinding() через task
+   * hook engine: вложенный вызов уже не находит состояния группы и освобождает
+   * состояние pipeline до cleanup slots. Группа без живых slots освобождает
+   * его здесь.
+   */
+  _disposeGroup(e, t) {
+    const s = this._reactivity;
+    let i;
+    for (let a = t.length - 1; a >= y; a--) {
+      const n = t[a];
+      if (n != null)
+        try {
+          s._disposeTaskEffect(n);
+        } catch (o) {
+          (i ??= []).push(o);
+        }
+    }
+    try {
+      this._disposeTask(e);
+    } catch (a) {
+      (i ??= []).push(a);
+    }
+    if (i !== void 0)
+      throw i.length === 1 ? i[0] : new AggregateError(i, "[Raph] Effect group disposal failed.");
+  }
+  /**
+   * Освобождает подписку и состояние pipeline остановленного watch.
+   */
+  _releaseWatch(e, t) {
+    const s = [], i = t.source;
+    if (t.source = void 0, t.record = void 0, i !== void 0)
+      try {
+        i();
+      } catch (a) {
+        s.push(a);
+      }
+    try {
+      this._disposeTask(e);
+    } catch (a) {
+      s.push(a);
+    }
+    z(s, "[Raph] Phase watch disposal failed.");
   }
+  /** @internal */
   _pauseTask(e) {
-    if (!e.active || e.paused)
+    const t = e.state;
+    if ((t & P) !== f)
       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);
-  }
+    const s = t & b, i = (t | A) & -13;
+    e.state = (t & (w | E)) !== 0 || (t & p) !== 0 && s !== q && !(s === m && (t & C) !== 0) ? i | g : i, t & E && this._deferred.delete(e), t & w && this._unqueue(e), this._hasPending() || this._cancelScheduled(), this._settleIdleWaiters(void 0, !1);
+  }
+  /**
+   * Убирает ожидающую запись из живой очереди её phase. Запись, которую flush
+   * уже забрал на разбор, в живой очереди не находится и счётчик не меняет.
+   */
+  _unqueue(e) {
+    const t = e.phaseState.queue, s = t.indexOf(e);
+    s >= 0 && (t.splice(s, 1), this._queuedCount--);
+  }
+  /** @internal */
   _resumeTask(e) {
-    !e.active || !e.paused || e.consumerOwner.disposed || (e.paused = !1, (e.requested || C(e)) && (e.requested = !1, this._queue(e)));
-  }
+    const t = e.state;
+    (t & P) !== P || e.consumerOwner.disposed || ((t & g) !== 0 || F(e) ? (e.state = t & -67, this._queue(e)) : e.state = t & ~A);
+  }
+  /**
+   * Возвращает причины открытой доставки в ожидающие, впереди причин, которые
+   * пришли после её открытия; причины одного source сливаются. Причины доставки
+   * при этом остаются причинами доставки до её конца, поэтому сначала они
+   * отделяются от ожидающих.
+   */
   _restoreDeliveryCausesBeforePending(e) {
-    const s = e.deliveryCauses;
-    if (s.length === 0)
+    e.state & k && this._splitDeliveredCauses(e);
+    const t = e.detail;
+    if (t === void 0)
+      return;
+    const s = t.deliveryFirstCause;
+    if (s === void 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);
+    const i = e.firstCause, a = e.firstCauseKey, n = t.extraCauses;
+    e.firstCause = void 0, e.firstCauseKey = void 0, t.extraCauses = void 0, this._appendCause(e, s, t.deliveryFirstCauseKey);
+    const o = t.deliveryExtraCauses;
+    if (o !== void 0)
+      for (const [r, d] of o)
+        this._appendCause(e, d, r);
+    if (i !== void 0 && (this._appendCause(e, i, a), n !== void 0))
+      for (const [r, d] of n)
+        this._appendCause(e, d, r);
   }
   _schedule() {
     if (this._running || this._scheduled || this._disposed)
@@ -435,153 +639,210 @@ class R {
       return;
     }
     this._scheduled = !0;
-    const e = ++this._scheduleToken, s = () => {
+    const e = ++this._scheduleToken, t = () => {
       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);
+      queueMicrotask(t);
       return;
     }
-    typeof globalThis.requestAnimationFrame == "function" ? (this._frameHandleKind = "animation-frame", this._frameHandle = globalThis.requestAnimationFrame(s)) : (this._frameHandleKind = "timeout", this._frameHandle = setTimeout(s, 16));
+    typeof globalThis.requestAnimationFrame == "function" ? (this._frameHandleKind = "animation-frame", this._frameHandle = globalThis.requestAnimationFrame(t)) : (this._frameHandleKind = "timeout", this._frameHandle = setTimeout(t, 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));
+    const e = ++this._scheduleToken, t = () => {
+      this._disposed || !this._scheduled || e !== this._scheduleToken || (this._scheduled = !1, this._frameHandle = void 0, this._frameHandleKind = void 0, this._activateDeferred(), this._queuedCount !== 0 ? 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);
+    this._scheduler === "animationFrame" ? typeof globalThis.requestAnimationFrame == "function" ? (this._frameHandleKind = "animation-frame", this._frameHandle = globalThis.requestAnimationFrame(t)) : (this._frameHandleKind = "timeout", this._frameHandle = setTimeout(t, 16)) : queueMicrotask(t);
   }
   _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);
+    this._scheduled && (this._scheduled = !1, this._scheduleToken++, this._frameHandleKind === "animation-frame" && this._frameHandle !== void 0 ? globalThis.cancelAnimationFrame?.(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);
+    for (const t of e)
+      t.state &= ~E, this._queue(t, !1);
   }
   _nextFrame() {
-    var t;
-    const e = ((t = globalThis.performance) == null ? void 0 : t.now()) ?? Date.now();
+    const e = globalThis.performance?.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({
+    const t = 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;
+    return this._lastFrameAt = e, this._frame = t;
   }
   _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;
+    for (const t of this._phases) {
+      const s = t.state;
+      if (s.bindings !== 0 && !e.has(s.name))
+        throw new Error(`[Raph] Cannot remove phase "${s.name}" while it is still bound.`);
+    }
+    for (const t of this._phases) {
+      const s = t.state;
+      if (s.queue.length !== 0 && !e.has(s.name))
+        throw new Error(`[Raph] Cannot remove phase "${s.name}" while it has pending work.`);
+    }
   }
   _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];
+    return this._queuedCount !== 0 || this._deferred.size !== 0;
+  }
+  _cancelAllQueued(e, t = []) {
+    if (this._queuedCount === 0)
+      return;
+    const s = [];
+    for (const i of this._phases) {
+      const a = i.state.queue;
+      for (const n of a)
+        s.push(n);
+      a.length = 0;
+    }
+    this._queuedCount = 0;
+    for (const i of s)
+      i.state &= ~w, e && this._acknowledgeDiscard(i, !0, t), this._clearPendingDelivery(i);
+  }
+  _cancelAllDeferred(e, t = []) {
+    const s = [...this._deferred];
     this._deferred.clear();
-    for (const i of t)
-      i.deferred = !1, e && this._acknowledgeDiscard(i, !0, s), this._clearPendingDelivery(i);
+    for (const i of s)
+      i.state &= ~E, e && this._acknowledgeDiscard(i, !0, t), this._clearPendingDelivery(i);
   }
-  _acknowledgeDiscard(e, s, t) {
-    if (e.discardAcknowledged)
+  _acknowledgeDiscard(e, t, s) {
+    const i = e.state;
+    if (i & C)
       return;
-    const i = e.binding, n = i == null ? void 0 : i.cancelPending;
-    if (n === void 0) {
-      e.discardAcknowledged = !0;
+    const a = e.node, n = e.group;
+    if (a === void 0 && n === void 0 || !(i & f)) {
+      e.state = i | C;
       return;
     }
     try {
-      if (n()) {
-        e.discardAcknowledged = !0;
+      if (a !== void 0 ? (i & H) !== 0 && this._reactivity._cancelTaskEffect(a) : this._cancelGroup(e, n, t)) {
+        e.state |= C;
         return;
       }
-      if (!s) {
-        t.push(new g(
+      if (!t) {
+        s.push(new R(
           `[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;
+      e.dispose(), e.state |= C;
+    } catch (o) {
+      s.push(o);
+    }
+  }
+  /**
+   * Гасит ожидающую доставку slots группы.
+   *
+   * Slot, чей первый запуск ещё впереди, погасить нельзя: он не собрал
+   * зависимости, и после отмены его ничто не разбудит. Такой slot узнаётся по
+   * запланированной записи без единой зависимости: запись, которая уже
+   * исполнялась и ничего не прочитала, больше не планируется. Обычная отмена
+   * тогда не трогает ни один slot и возвращает false; fatal discard
+   * останавливает такие slots окончательно и гасит остальные.
+   *
+   * Обычная отмена отказывается только от того, что доставка знала при
+   * открытии. Причина, пришедшая группе после открытия доставки, означает
+   * запись, которую запланированный slot ещё не прочитал. Гашение снимает с
+   * записи slot и отметку планирования, и требование запуска, которое engine
+   * поставил при прямой записи, поэтому slots, ждавшие запуска, после гашения
+   * снова требуют его, как отдельный binding, отменённый при новой причине.
+   * Группа тогда доставляется ещё раз с новыми причинами. Fatal discard гасит
+   * всё.
+   *
+   * @returns false, если доставку нельзя отменить либо живых slots не осталось.
+   */
+  _cancelGroup(e, t, s) {
+    const i = this._reactivity;
+    let a = !1;
+    for (let r = y; r < t.length; r++) {
+      const d = t[r];
+      d === null || d.firstDep !== null || !i._beginTaskEffectRun(d) || (s ? i._disposeTaskEffect(d) : (i._requestTaskEffect(d, !1), a = !0));
+    }
+    if (a)
+      return !1;
+    const n = !s && F(e);
+    let o = !1;
+    for (let r = y; r < t.length; r++) {
+      const d = t[r];
+      if (d === null)
+        continue;
+      if (d.firstDep === null) {
+        o = o || d.evaluate !== void 0;
+        continue;
       }
-      a(), e.discardAcknowledged = !0;
-    } catch (a) {
-      t.push(a);
+      const l = n && i._beginTaskEffectRun(d);
+      i._cancelTaskEffect(d) && (o = !0, l && i._rearmTaskEffect(d));
     }
+    return o;
   }
+  /**
+   * Сбрасывает ожидающую работу записи, снятой с очереди либо из отложенных.
+   * Такая запись не находится в доставке, поэтому её причины ожидающие.
+   */
   _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;
+    e.state &= ~g, e.firstCause = void 0, e.firstCauseKey = void 0;
+    const t = e.detail;
+    t !== void 0 && (t.extraCauses?.clear(), t.extraCauses = void 0);
   }
-  _settleIdleWaiters(e, s) {
-    if (!s && (this._running || this._scheduled || this._hasPending()))
+  _settleIdleWaiters(e, t) {
+    const s = this._idleWaiters;
+    if (s.size === 0 || !t && (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);
+    const i = [...s];
+    s.clear();
+    for (const a of i)
+      t ? a.reject(e) : a.resolve();
   }
   _assertAlive() {
     if (this._disposed)
-      throw new P("[Raph] Phase pipeline is disposed.");
+      throw new I("[Raph] Phase pipeline is disposed.");
+  }
+}
+function Y(h, e) {
+  return e.priority - h.priority || h.sequence - e.sequence;
+}
+function F(h) {
+  return h.firstCause !== void 0 && !(h.state & k);
+}
+function S(h) {
+  const e = h.state, t = h.detail;
+  if (e & k) {
+    h.state = e & ~k, h.firstCause = void 0, h.firstCauseKey = void 0, t !== void 0 && (t.extraCauses = void 0, t.deliveryCauses = void 0);
+    return;
   }
+  t !== void 0 && t.deliveryFirstCause !== void 0 && L(t);
 }
-function T(l, e) {
-  return e.priority - l.priority || l.sequence - e.sequence;
+function L(h) {
+  h.deliveryFirstCause = void 0, h.deliveryFirstCauseKey = void 0, h.deliveryExtraCauses = void 0, h.deliveryCauses = void 0;
 }
-function C(l) {
-  return l.firstCause !== void 0;
+function O() {
+  throw new R("[Raph] Phase task delivery is already resolved.");
 }
-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({
+function U(h, e) {
+  const t = h.events === void 0 ? e.events : e.events === void 0 ? h.events : Object.freeze([...h.events, ...e.events]), s = h.structure === void 0 ? e.structure : e.structure === void 0 ? h.structure : Object.freeze({
     node: e.structure.node,
-    oldParent: l.structure.oldParent,
-    oldIndex: l.structure.oldIndex,
+    oldParent: h.structure.oldParent,
+    oldIndex: h.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 }
+    previous: h.previous,
+    ...t === void 0 ? {} : { events: t },
+    ...s === void 0 ? {} : { structure: s }
   });
 }
 export {
-  R as RaphPhasePipeline
+  te as RaphPhasePipeline,
+  Q as RaphPhaseState
 };