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

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

@@ -0,0 +1,848 @@
+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;
+  }
+  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 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 (a.process !== void 0 && typeof a.process != "function")
+        throw new TypeError(`[Raph] Phase "${n}" process must be a function.`);
+      const o = Object.freeze({
+        name: n,
+        ...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 = i, this._phaseByName = s, this._resolvedInput = void 0, this._resolvedState = void 0;
+  }
+  addPhase(e) {
+    this.definePhases([...this.phases, e]);
+  }
+  clearPhases() {
+    this.definePhases([]);
+  }
+  /**
+   * Находит состояние объявленной 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._queuedCount !== 0 && this._schedule();
+  }
+  afterFlush() {
+    return this._assertAlive(), !this._running && !this._scheduled && !this._hasPending() ? Promise.resolve() : new Promise((e, t) => {
+      this._idleWaiters.add({ reject: t, resolve: e });
+    });
+  }
+  flush() {
+    if (this._assertAlive(), this._cancelScheduled(), this._running)
+      return;
+    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 = [], t = this._nextFrame();
+    let s = 0, i;
+    try {
+      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 n of this._phases) {
+          if (this._disposed)
+            break;
+          const o = n.state, r = o.queue;
+          if (r.length === 0)
+            continue;
+          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, t), c !== void 0 && (u.priority > c.priority || u.priority === c.priority && u.sequence < c.sequence) && (_ = !1), c = u, r[l++] = u;
+          }
+          if (r.length = l, r.length === 0) {
+            i = void 0;
+            continue;
+          }
+          _ || r.sort(Y);
+          const D = n.phase.process;
+          if (D === void 0)
+            for (const u of r)
+              try {
+                this._runDelivery(u, e);
+              } catch (v) {
+                e.push(v);
+              }
+          else {
+            const u = [];
+            for (const K of r)
+              u.push(K.task);
+            const v = Object.freeze({
+              phase: n.phase.name,
+              frame: t,
+              tasks: Object.freeze(u)
+            });
+            try {
+              this._reactivity.untrackedWithOwner(() => D(v));
+            } catch (K) {
+              e.push(K);
+            }
+          }
+          let T = 0;
+          for (const u of r) {
+            if ((u.state & b) === j) {
+              T++;
+              try {
+                this._deferDelivery(u);
+              } catch (v) {
+                u.state |= m, this._acknowledgeDiscard(u, !0, e), e.push(v);
+              }
+            }
+            try {
+              this._finishDelivery(u);
+            } catch (v) {
+              (u.state & b) !== q && this._acknowledgeDiscard(u, !0, e), u.state = (u.state | m) & ~p, S(u), e.push(v);
+            }
+          }
+          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 (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 (n) {
+      e.push(n);
+    }
+    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() {
+    if (this._disposed)
+      return;
+    this._disposed = !0, this._cancelScheduled(), this._cancelAllQueued(!1);
+    const e = [...this._deferred];
+    this._cancelAllDeferred(!1);
+    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() {
+    const e = [];
+    for (const t of this._phases) {
+      const s = t.state.queue.filter(
+        (a) => (a.state & f) !== 0 && !a.consumerOwner.disposed
+      );
+      if (s.length === 0)
+        continue;
+      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}=${s.length}${i ? ` [${i}]` : ""}`);
+    }
+    return e.join("; ");
+  }
+  /**
+   * Открывает доставку одной записью `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;
+    }
+    (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;
+    }
+    const o = e.group;
+    if (o === void 0) {
+      const _ = e.watch;
+      _ !== void 0 && a.untrackedWithOwner(_.deliver);
+      return;
+    }
+    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) {
+    const t = e.state;
+    if ((t & P) !== f || e.consumerOwner.disposed) {
+      e.state = t | m;
+      return;
+    }
+    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 R(
+          `[Raph] Phase task in "${e.phase}" exceeded 10000 deferred deliveries.`
+        ), ...s],
+        "[Raph] Phase task defer limit and recovery failed."
+      ) : new R(
+        `[Raph] Phase task in "${e.phase}" exceeded 10000 deferred deliveries.`
+      );
+    }
+  }
+  /** @internal */
+  _cancelDelivery(e) {
+    const t = e.state;
+    if (!(t & f) || e.consumerOwner.disposed) {
+      e.state = t | m;
+      return;
+    }
+    (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.");
+    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) {
+    const t = e.state;
+    if (!(t & p))
+      return;
+    const s = t & b;
+    if (e.state = t & ~p, !(t & f) || e.consumerOwner.disposed) {
+      S(e);
+      return;
+    }
+    if (t & A) {
+      s !== q && !(s === m && (t & C) !== 0) && (this._restoreDeliveryCausesBeforePending(e), e.state |= g), S(e);
+      return;
+    }
+    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);
+      }
+    }
+  }
+  /**
+   * Делает исполняемыми 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);
+    }
+  }
+  /** @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);
+    }
+  }
+  /** @internal */
+  _appendCause(e, t, s) {
+    const i = e.state;
+    if (!(i & f))
+      return;
+    i & k && this._splitDeliveredCauses(e);
+    const a = e.firstCause;
+    if (a === void 0) {
+      e.firstCause = t, e.firstCauseKey = s;
+      return;
+    }
+    if (e.firstCauseKey === s) {
+      e.firstCause = U(a, t);
+      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());
+    }
+  }
+  /** @internal */
+  _disposeTask(e) {
+    const t = e.state;
+    if (!(t & f))
+      return;
+    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);
+    }
+    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) {
+    const t = e.state;
+    if ((t & P) !== f)
+      return;
+    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) {
+    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) {
+    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 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)
+      return;
+    if (this._scheduler === "sync") {
+      if (this._deferSync())
+        return;
+      this.flush();
+      return;
+    }
+    this._scheduled = !0;
+    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(t);
+      return;
+    }
+    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, 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(t)) : (this._frameHandleKind = "timeout", this._frameHandle = setTimeout(t, 16)) : queueMicrotask(t);
+  }
+  _cancelScheduled() {
+    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 t of e)
+      t.state &= ~E, this._queue(t, !1);
+  }
+  _nextFrame() {
+    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 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 = t;
+  }
+  _assertRetainedPhases(e) {
+    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._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 s)
+      i.state &= ~E, e && this._acknowledgeDiscard(i, !0, t), this._clearPendingDelivery(i);
+  }
+  _acknowledgeDiscard(e, t, s) {
+    const i = e.state;
+    if (i & C)
+      return;
+    const a = e.node, n = e.group;
+    if (a === void 0 && n === void 0 || !(i & f)) {
+      e.state = i | C;
+      return;
+    }
+    try {
+      if (a !== void 0 ? (i & H) !== 0 && this._reactivity._cancelTaskEffect(a) : this._cancelGroup(e, n, t)) {
+        e.state |= C;
+        return;
+      }
+      if (!t) {
+        s.push(new R(
+          `[Raph] Initial effect delivery in "${e.phase}" cannot be cancelled before dependency collection.`
+        ));
+        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;
+      }
+      const l = n && i._beginTaskEffectRun(d);
+      i._cancelTaskEffect(d) && (o = !0, l && i._rearmTaskEffect(d));
+    }
+    return o;
+  }
+  /**
+   * Сбрасывает ожидающую работу записи, снятой с очереди либо из отложенных.
+   * Такая запись не находится в доставке, поэтому её причины ожидающие.
+   */
+  _clearPendingDelivery(e) {
+    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, t) {
+    const s = this._idleWaiters;
+    if (s.size === 0 || !t && (this._running || this._scheduled || this._hasPending()))
+      return;
+    const i = [...s];
+    s.clear();
+    for (const a of i)
+      t ? a.reject(e) : a.resolve();
+  }
+  _assertAlive() {
+    if (this._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 L(h) {
+  h.deliveryFirstCause = void 0, h.deliveryFirstCauseKey = void 0, h.deliveryExtraCauses = void 0, h.deliveryCauses = void 0;
+}
+function O() {
+  throw new R("[Raph] Phase task delivery is already resolved.");
+}
+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: h.structure.oldParent,
+    oldIndex: h.structure.oldIndex,
+    newParent: e.structure.newParent,
+    newIndex: e.structure.newIndex
+  });
+  return Object.freeze({
+    ...e,
+    previous: h.previous,
+    ...t === void 0 ? {} : { events: t },
+    ...s === void 0 ? {} : { structure: s }
+  });
+}
+export {
+  te as RaphPhasePipeline,
+  Q as RaphPhaseState
+};