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

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

@@ -1,20 +1,28 @@
-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 {
+import { RaphPhaseProcessError as K, RaphDisposedError as H } from "../errors.js";
+import { throwDisposalErrors as Q } from "../ownership/throwDisposalErrors.js";
+import { EMPTY_FRAME as V, RaphPhaseTaskRecord as W, GROUP_NODES as k, GROUP_CONTEXT as X, GROUP_CURSOR as L, TASK_ACTIVE as _, TASK_TASKLESS as Y, TASK_PAUSED as P, TASK_IN_DELIVERY as p, TASK_PENDING as g, TASK_DEFERRED as T, TASK_DISCARD_ACKNOWLEDGED as y, TASK_CAUSES_DELIVERED as w, TASK_RESOLUTION as D, TASK_RUN as q, TASK_CANCEL as m, TASK_UNRESOLVED as J, TASK_EXECUTED as U, TASK_REQUESTED as C, TASK_DEFER as j } from "./RaphPhaseTaskRecord.js";
+class Z {
   constructor(e, t) {
-    this.name = e, this.pipeline = t, this.queue = [], this.spare = [], this.bindings = 0;
+    this.name = e, this.pipeline = t, this.first = void 0, this.queue = [], this.spare = [], this.bindings = 0;
   }
 }
-const V = 1e4, X = 1e4, P = f | A, x = p | b;
-class te {
+const ee = 1e4, te = 1e4, B = g | y | C | D | w, x = _ | P, N = p | D;
+class re {
   constructor(e, t, s, i = () => !1, a) {
     this._scheduler = e, this._reactivity = t, this._resolveCause = s, this._deferSync = i, this._tracePhase = a;
+    const n = globalThis.performance;
+    this._now = n === void 0 ? Date.now : n.now.bind(n);
   }
   _phases = [];
   _phaseByName = /* @__PURE__ */ new Map();
-  // Последнее разрешённое имя phase в том виде, в каком его передал вызывающий.
+  /**
+   * Последнее разрешённое имя phase в том виде, в каком его передал вызывающий,
+   * и его состояние. Регистрация binding читает этот кэш сама, без вызова
+   * resolvePhase().
+   * @internal
+   */
   _resolvedInput;
+  /** @internal */
   _resolvedState;
   // Число записей во всех живых очередях.
   _queuedCount = 0;
@@ -36,18 +44,53 @@ class te {
   // значением доставка группы пропускает, не обращаясь к engine.
   _idleSlotFlags = -1;
   _disposed = !1;
-  _firstFrameAt;
-  _lastFrameAt;
-  _frameNumber = 0;
-  _frame = B;
+  // Отметки времени всегда числовые; первый кадр определяется счётчиком.
+  _firstFrameAt = Number.NaN;
+  _lastFrameAt = Number.NaN;
+  _frameNumber = -1;
+  _frame = V;
+  _publicFrames = !1;
+  // Raph Top-1: пока ни один frame не прочитан, flush не вызывает clock и не
+  // создаёт снимок; true значит, что текущий flush ещё не получил свой frame.
+  _frameStale = !1;
+  // Снимок, который получили доставки до первого чтения, и кадр, которым его
+  // заменило первое чтение: все такие доставки видят этот кадр.
+  _unmeasuredFrame;
+  _firstReadFrame;
+  _readPublicFrame = this._exposeCurrentFrame;
+  _now;
+  /** @internal */
+  _setPhaseTrace(e) {
+    this._tracePhase = e;
+  }
   get frame() {
+    return this._readPublicFrame();
+  }
+  _readCurrentFrame() {
     return this._frame;
   }
+  _exposeCurrentFrame() {
+    return this._exposeFrame(this._frame);
+  }
+  /**
+   * Доставка может удерживать ещё не опубликованный снимок.
+   * @internal
+   */
+  _frameForDelivery() {
+    return this._frame;
+  }
+  /**
+   * Первое чтение включает заморозку всех последующих кадров.
+   * @internal
+   */
+  _exposeFrame(e) {
+    return this._publicFrames || (this._frameStale && (this._unmeasuredFrame = this._frame, this._materializeFrame(), this._firstReadFrame = this._frame), this._publicFrames = !0, Object.freeze(this._frame), this._readPublicFrame = this._readCurrentFrame), e === this._unmeasuredFrame ? this._firstReadFrame : e === this._frame ? e : Object.freeze(e);
+  }
   get phases() {
     return this._phases.map((e) => e.phase);
   }
   definePhases(e) {
-    if (this._assertAlive(), this._configurationLocked || this._firstFrameAt !== void 0)
+    if (this._assertAlive(), this._configurationLocked || this._frameNumber !== -1)
       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) {
@@ -58,15 +101,15 @@ class te {
         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({
+      const r = Object.freeze({
         name: n,
         ...a.process === void 0 ? {} : { process: a.process }
-      }), r = {
+      }), h = {
         index: i.length,
-        phase: o,
-        state: t.get(n)?.state ?? new Q(n, this)
+        phase: r,
+        state: t.get(n)?.state ?? new Z(n, this)
       };
-      i.push(r), s.set(n, r);
+      i.push(h), s.set(n, h);
     }
     this._assertRetainedPhases(s), this._phases = i, this._phaseByName = s, this._resolvedInput = void 0, this._resolvedState = void 0;
   }
@@ -101,7 +144,7 @@ class te {
    * (`node`) или watch lifecycle (`watch`).
    */
   bindTask(e, t, s, i) {
-    return e.bindings++, new $(e, i, t, s);
+    return e.bindings++, new W(e, i, t, s);
   }
   /**
    * Создаёт постоянную запись группы из `count` slots: одна запись binding и
@@ -116,10 +159,10 @@ class te {
    * `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;
+    const r = new Array(k + a);
+    r[X] = i, r[L] = 0, e.bindings++;
+    const h = new W(e, n, t, s);
+    return h.state = _ | Y, h.group = r, h;
   }
   request() {
     this._assertAlive(), this._queuedCount !== 0 && this._schedule();
@@ -130,107 +173,158 @@ class te {
     });
   }
   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;
+    if (this._assertAlive(), this._scheduled && this._cancelScheduled(), !this._running) {
+      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, this._drain(this._publicFrames ? this._nextFrame() : this._skipFrame());
     }
-    this._configurationLocked = !0, this._running = !0;
-    const e = [], t = this._nextFrame();
-    let s = 0, i;
+  }
+  /**
+   * Raph Top-1: первая доставка нового binding в простаивающем sync pipeline.
+   * Запись встаёт в очередь так же, как через `_queue()`, и разбирается тем же
+   * проходом flush, но без цепочки engine schedule → `_schedule()` → пролог
+   * flush. False значит, что pipeline не простаивает: тогда вызывающий
+   * планирует запись обычным путём.
+   *
+   * @internal
+   */
+  _canDeliverFirst(e) {
+    return !(this._scheduler !== "sync" || this._running || this._scheduled || this._disposed || this._queuedCount !== 0 || this._deferred.size !== 0 || (e.state & (P | p | g | T)) !== 0 || !(e.state & _) || e.consumerOwner.disposed || this._deferSync());
+  }
+  /**
+   * Выполняет первую доставку после положительного `_canDeliverFirst()`.
+   *
+   * @internal
+   */
+  _deliverFirst(e) {
+    e.state = e.state & ~y | g, e.sequence = this._taskSequence++, e.phaseState.first = e, this._queuedCount++, this._configurationLocked = !0, this._running = !0, this._drain(this._publicFrames ? this._nextFrame() : this._skipFrame());
+  }
+  /** Основной проход flush: `_running` уже выставлен, frame выбран. */
+  _drain(e) {
+    let t, s = 0, i;
     try {
       for (; this._queuedCount !== 0; ) {
-        if (++s > V) {
+        if (++s > ee) {
           const n = this._describeQueued();
-          this._cancelAllQueued(!0, e), e.push(new Error(`[Raph] Phase flush exceeded 10000 passes.${n ? ` Pending: ${n}.` : ""}`));
+          this._cancelAllQueued(!0, t ??= []), t.push(new Error(`[Raph] Phase flush exceeded 10000 passes.${n ? ` Pending: ${n}.` : ""}`));
           break;
         }
-        for (const n of this._phases) {
+        const a = this._phases;
+        for (let n = 0; n < a.length; n++) {
+          const r = a[n];
           if (this._disposed)
             break;
-          const o = n.state, r = o.queue;
-          if (r.length === 0)
+          const h = r.state, l = h.first;
+          if (l === void 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);
+          const d = h.queue;
+          h.first = void 0;
+          const v = d.length === 0 && r.phase.process === void 0;
+          v || (h.queue = h.spare, h.spare = i = d), this._queuedCount -= d.length + 1;
+          const E = t?.length ?? 0;
+          if (this._tracePhase?.(r.phase.name, "start"), v) {
+            const u = l, o = u.state;
+            if (!(o & _) || u.consumerOwner._disposed) {
+              u.state = o & ~g, this._disposeTask(u), i = void 0;
               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;
+            const c = o & ~B | p;
+            u.state = u.firstCause === void 0 ? c : c | w, u.facade !== void 0 && (u.frame = e);
+            try {
+              u.group !== void 0 && (t ??= []), this._runDelivery(u, t);
+            } catch (F) {
+              (t ??= []).push(F);
+            }
+            try {
+              this._finishDelivery(u);
+            } catch (F) {
+              (u.state & D) !== q && this._acknowledgeDiscard(u, !0, t ??= []), u.state = (u.state | m) & ~p, S(u), t ??= [], t.push(F);
+            }
+            i = void 0, (t?.length ?? 0) === E ? this._tracePhase?.(r.phase.name, "end") : this._tracePhase?.(r.phase.name, "error", t[t.length - 1]);
+            continue;
           }
-          if (r.length = l, r.length === 0) {
+          d.unshift(l), t ??= [];
+          let b = 0, A = !0, R;
+          for (let u = 0; u < d.length; u++) {
+            const o = d[u], c = o.state;
+            if (!(c & _) || o.consumerOwner._disposed) {
+              o.state = c & ~g, this._disposeTask(o);
+              continue;
+            }
+            const F = c & ~B | p;
+            o.state = o.firstCause === void 0 ? F : F | w, o.facade !== void 0 && (o.frame = e), R !== void 0 && (o.priority > R.priority || o.priority === R.priority && o.sequence < R.sequence) && (A = !1), R = o, d[b++] = o;
+          }
+          if (d.length = b, d.length === 0) {
             i = void 0;
             continue;
           }
-          _ || r.sort(Y);
-          const D = n.phase.process;
-          if (D === void 0)
-            for (const u of r)
+          A || d.sort(se);
+          const z = r.phase.process;
+          if (z === void 0)
+            for (let u = 0; u < d.length; u++)
               try {
-                this._runDelivery(u, e);
-              } catch (v) {
-                e.push(v);
+                this._runDelivery(d[u], t);
+              } catch (o) {
+                t.push(o);
               }
           else {
             const u = [];
-            for (const K of r)
-              u.push(K.task);
-            const v = Object.freeze({
-              phase: n.phase.name,
-              frame: t,
+            for (let c = 0; c < d.length; c++)
+              u.push(d[c].task);
+            const o = Object.freeze({
+              phase: r.phase.name,
+              frame: this.frame,
               tasks: Object.freeze(u)
             });
             try {
-              this._reactivity.untrackedWithOwner(() => D(v));
-            } catch (K) {
-              e.push(K);
+              this._reactivity.untrackedWithOwner(() => z(o));
+            } catch (c) {
+              t.push(c);
             }
           }
-          let T = 0;
-          for (const u of r) {
-            if ((u.state & b) === j) {
-              T++;
+          let O = 0;
+          for (let u = 0; u < d.length; u++) {
+            const o = d[u];
+            if ((o.state & D) === J) {
+              O++;
               try {
-                this._deferDelivery(u);
-              } catch (v) {
-                u.state |= m, this._acknowledgeDiscard(u, !0, e), e.push(v);
+                this._deferDelivery(o);
+              } catch (c) {
+                o.state |= m, this._acknowledgeDiscard(o, !0, t), t.push(c);
               }
             }
             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);
+              this._finishDelivery(o);
+            } catch (c) {
+              (o.state & D) !== q && this._acknowledgeDiscard(o, !0, t), o.state = (o.state | m) & ~p, S(o), t.push(c);
             }
           }
-          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,
+          d.length = 0, i = void 0, O !== 0 && t.push(new K(
+            `[Raph] Phase "${r.phase.name}" left ${O} task(s) unresolved; they were deferred.`
+          )), t.length === E ? this._tracePhase?.(r.phase.name, "end") : this._tracePhase?.(
+            r.phase.name,
             "error",
-            e[e.length - 1]
+            t[t.length - 1]
           );
         }
       }
-    } catch (n) {
-      e.push(n), i !== void 0 && (i.length = 0), this._cancelAllQueued(!0, e), this._cancelAllDeferred(!0, e);
+    } catch (a) {
+      (t ??= []).push(a), i !== void 0 && (i.length = 0), this._cancelAllQueued(!0, t), this._cancelAllDeferred(!0, t);
     } finally {
       this._running = !1;
     }
     try {
       this._deferred.size !== 0 && this._scheduleDeferredTurn();
-    } catch (n) {
-      e.push(n);
+    } catch (a) {
+      (t ??= []).push(a);
     }
-    const a = e.length === 1 ? e[0] : e.length > 1 ? new AggregateError(e, "[Raph] Multiple phase tasks failed.") : void 0;
-    if (e.length !== 0)
+    if (t !== void 0 && t.length !== 0) {
+      const a = t.length === 1 ? t[0] : new AggregateError(t, "[Raph] Multiple phase tasks failed.");
       throw this._settleIdleWaiters(a, !0), a;
-    this._settleIdleWaiters(void 0, !1);
+    }
+    this._idleWaiters.size !== 0 && this._settleIdleWaiters(void 0, !1);
   }
   dispose() {
     if (this._disposed)
@@ -239,9 +333,9 @@ class te {
     const e = [...this._deferred];
     this._cancelAllDeferred(!1);
     for (const s of e)
-      s.state &= ~f;
+      s.state &= ~_;
     this._phases = [], this._phaseByName.clear(), this._resolvedInput = void 0, this._resolvedState = void 0;
-    const t = new I("[Raph] Phase pipeline is disposed.");
+    const t = new H("[Raph] Phase pipeline is disposed.");
     this._settleIdleWaiters(t, !0);
   }
   _debugPending() {
@@ -250,34 +344,19 @@ class te {
   _describeQueued() {
     const e = [];
     for (const t of this._phases) {
-      const s = t.state.queue.filter(
-        (a) => (a.state & f) !== 0 && !a.consumerOwner.disposed
+      const s = t.state.first, i = (s === void 0 ? [] : [s, ...t.state.queue]).filter(
+        (n) => (n.state & _) !== 0 && !n.consumerOwner.disposed
       );
-      if (s.length === 0)
+      if (i.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}` : ""}`;
+      const a = i.slice(0, 3).map((n) => {
+        const r = n.consumerOwner.node, h = r === void 0 ? void 0 : r.componentId, l = r === void 0 ? n.consumerOwner.id : `${n.consumerOwner.id}/${r.constructor.name}/${r.type}${typeof h == "string" ? `/${h}` : ""}`, d = n.firstCause?.sourceOwner?.node, v = d === void 0 ? "" : `<=${d.id}/${d.constructor.name}`;
+        return `${l}${n.firstCause ? `:${n.firstCause.kind}${v}` : ""}`;
       }).join(", ");
-      e.push(`${t.phase.name}=${s.length}${i ? ` [${i}]` : ""}`);
+      e.push(`${t.phase.name}=${i.length}${a ? ` [${a}]` : ""}`);
     }
     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
@@ -288,67 +367,67 @@ class te {
    */
   _runDelivery(e, t) {
     const s = e.state;
-    if ((s & P) !== f || e.consumerOwner.disposed) {
+    if ((s & x) !== _ || e.consumerOwner._disposed) {
       e.state = s | m;
       return;
     }
-    (s & x) !== p && O(), e.state = s | q;
+    (s & N) !== p && $(), 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));
+      a._beginTaskEffectRun(n) && (e.state |= U, a._runTaskEffectUntracked(n));
       return;
     }
-    const o = e.group;
-    if (o === void 0) {
-      const _ = e.watch;
-      _ !== void 0 && a.untrackedWithOwner(_.deliver);
+    const r = e.group;
+    if (r === void 0) {
+      const v = e.watch;
+      v !== void 0 && a.untrackedWithOwner(v.deliver);
       return;
     }
-    const r = o.length;
-    let d = this._idleSlotFlags, l;
-    for (let _ = y; _ < r; _++) {
-      const c = o[_];
-      if (c === null || c.flags === d)
+    const h = r.length;
+    let l = this._idleSlotFlags, d;
+    for (let v = k; v < h; v++) {
+      const E = r[v];
+      if (E === null || E.flags === l)
         continue;
-      if (!a._beginTaskEffectRun(c)) {
-        c.evaluate !== void 0 && (this._idleSlotFlags = d = c.flags);
+      if (!a._beginTaskEffectRun(E)) {
+        E.evaluate !== void 0 && (this._idleSlotFlags = l = E.flags);
         continue;
       }
-      o[N] = _ - y;
+      r[L] = v - k;
       try {
-        a._runTaskEffectUntracked(c);
-      } catch (T) {
-        t !== void 0 ? t.push(T) : (l ??= []).push(T);
+        a._runTaskEffectUntracked(E);
+      } catch (A) {
+        t !== void 0 ? t.push(A) : (d ??= []).push(A);
       }
-      const D = e.state;
-      if (!(D & f))
+      const b = e.state;
+      if (!(b & _))
         break;
-      if (D & A) {
-        _ + 1 < r && (this._restoreDeliveryCausesBeforePending(e), e.state |= g);
+      if (b & P) {
+        v + 1 < h && (this._restoreDeliveryCausesBeforePending(e), e.state |= C);
         break;
       }
     }
-    if (l !== void 0)
-      throw l.length === 1 ? l[0] : new AggregateError(l, "[Raph] Effect group delivery failed.");
+    if (d !== void 0)
+      throw d.length === 1 ? d[0] : new AggregateError(d, "[Raph] Effect group delivery failed.");
   }
   /** @internal */
   _deferDelivery(e) {
     const t = e.state;
-    if ((t & P) !== f || e.consumerOwner.disposed) {
+    if ((t & x) !== _ || e.consumerOwner.disposed) {
       e.state = t | m;
       return;
     }
-    if ((t & x) !== p && O(), e.state = t | W, ++e.detailed().deferCount > X) {
+    if ((t & N) !== p && $(), e.state = t | j, ++e.detailed().deferCount > te) {
       e.state |= m;
       const s = [];
       throw this._acknowledgeDiscard(e, !0, s), s.length !== 0 ? new AggregateError(
-        [new R(
+        [new K(
           `[Raph] Phase task in "${e.phase}" exceeded 10000 deferred deliveries.`
         ), ...s],
         "[Raph] Phase task defer limit and recovery failed."
-      ) : new R(
+      ) : new K(
         `[Raph] Phase task in "${e.phase}" exceeded 10000 deferred deliveries.`
       );
     }
@@ -356,16 +435,16 @@ class te {
   /** @internal */
   _cancelDelivery(e) {
     const t = e.state;
-    if (!(t & f) || e.consumerOwner.disposed) {
+    if (!(t & _) || e.consumerOwner.disposed) {
       e.state = t | m;
       return;
     }
-    (t & x) !== p && O();
+    (t & N) !== p && $();
     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;
+    i & y && (i = I(e) ? i | C : i & ~C), e.state = i;
     const a = e.detail;
     a !== void 0 && (a.deferCount = 0);
   }
@@ -373,20 +452,20 @@ class te {
     const t = e.state;
     if (!(t & p))
       return;
-    const s = t & b;
-    if (e.state = t & ~p, !(t & f) || e.consumerOwner.disposed) {
+    const s = t & D;
+    if (e.state = t & ~p, !(t & _) || e.consumerOwner._disposed) {
       S(e);
       return;
     }
-    if (t & A) {
-      s !== q && !(s === m && (t & C) !== 0) && (this._restoreDeliveryCausesBeforePending(e), e.state |= g), S(e);
+    if (t & P) {
+      s !== q && !(s === m && (t & y) !== 0) && (this._restoreDeliveryCausesBeforePending(e), e.state |= C), S(e);
       return;
     }
-    if (s === W) {
-      this._restoreDeliveryCausesBeforePending(e), e.state |= E, this._deferred.add(e), S(e);
+    if (s === j) {
+      this._restoreDeliveryCausesBeforePending(e), e.state |= T, this._deferred.add(e), S(e);
       return;
     }
-    if (S(e), (e.state & g) !== 0 || e.firstCause !== void 0) {
+    if (((e.state & w) !== 0 || e.detail !== void 0) && S(e), (e.state & C) !== 0 || e.firstCause !== void 0) {
       const i = e.node;
       if (i !== void 0)
         this._reactivity._rearmTaskEffect(i);
@@ -413,7 +492,7 @@ class te {
    */
   _rearmGroup(e) {
     const t = this._reactivity;
-    for (let s = y; s < e.length; s++) {
+    for (let s = k; s < e.length; s++) {
       const i = e[s];
       i !== null && i.firstDep !== null && t._beginTaskEffectRun(i) && t._rearmTaskEffect(i);
     }
@@ -429,20 +508,20 @@ class te {
   /** @internal */
   _appendCause(e, t, s) {
     const i = e.state;
-    if (!(i & f))
+    if (!(i & _))
       return;
-    i & k && this._splitDeliveredCauses(e);
+    i & w && 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);
+      e.firstCause = G(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));
+    const n = e.detailed().extraCauses ??= /* @__PURE__ */ new Map(), r = n.get(s);
+    n.set(s, r === void 0 ? t : G(r, t));
   }
   /**
    * Переносит причины открытой доставки с места ожидающих в detail, без
@@ -452,32 +531,36 @@ class te {
    */
   _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;
+    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 &= ~w;
   }
   /** @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 (!(s & _) || e.consumerOwner._disposed || this._disposed)
+      return;
+    if (s & (P | p)) {
+      e.state = s | C;
+      return;
     }
+    if (s & g) {
+      t && this._schedule();
+      return;
+    }
+    if (s & T)
+      return;
+    e.state = s & ~y | g, e.sequence = this._taskSequence++;
+    const i = e.phaseState;
+    i.first === void 0 ? i.first = e : i.queue.push(e), this._queuedCount++, t && this._schedule();
   }
   /** @internal */
   _disposeTask(e) {
     const t = e.state;
-    if (!(t & f))
+    if (!(t & _))
       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);
+    i !== void 0 && (i.extraCauses?.clear(), i.extraCauses = void 0, M(i)), t & T && this._deferred.delete(e), t & g && this._unqueue(e), e.phaseState.bindings--, this._scheduled && this._queuedCount === 0 && this._deferred.size === 0 && this._cancelScheduled(), this._idleWaiters.size !== 0 && this._settleIdleWaiters(void 0, !1);
   }
   /**
    * Полностью освобождает один binding; каждый шаг идемпотентен, поэтому
@@ -500,9 +583,13 @@ class te {
         return;
       }
       const i = e.watch;
-      i !== void 0 && (e.watch = void 0, i.stop(() => this._releaseWatch(e, i)));
+      i !== void 0 && (e.watch = void 0, this._stopPhaseWatch(e, i));
     }
-    this._disposeTask(e);
+    e.state & _ && this._disposeTask(e);
+  }
+  /** Callback создаётся только на пути explicit watch после очистки record.watch. */
+  _stopPhaseWatch(e, t) {
+    t.stop(() => this._releaseWatch(e, t));
   }
   /**
    * Убирает из состояния группы slots, записи графа которых уже остановлены, и
@@ -523,7 +610,7 @@ class te {
    */
   _forgetStoppedSlots(e) {
     let t = !1, s = !1;
-    for (let i = y; i < e.length; i++) {
+    for (let i = k; i < e.length; i++) {
       const a = e[i];
       a != null && (a.evaluate === void 0 ? (e[i] = null, t = !0) : s = !0);
     }
@@ -549,13 +636,13 @@ class te {
   _disposeGroup(e, t) {
     const s = this._reactivity;
     let i;
-    for (let a = t.length - 1; a >= y; a--) {
+    for (let a = t.length - 1; a >= k; a--) {
       const n = t[a];
       if (n != null)
         try {
           s._disposeTaskEffect(n);
-        } catch (o) {
-          (i ??= []).push(o);
+        } catch (r) {
+          (i ??= []).push(r);
         }
     }
     try {
@@ -582,28 +669,33 @@ class te {
     } catch (a) {
       s.push(a);
     }
-    z(s, "[Raph] Phase watch disposal failed.");
+    Q(s, "[Raph] Phase watch disposal failed.");
   }
   /** @internal */
   _pauseTask(e) {
     const t = e.state;
-    if ((t & P) !== f)
+    if ((t & x) !== _)
       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);
+    const s = t & D, i = (t | P) & -13;
+    e.state = (t & (g | T)) !== 0 || (t & p) !== 0 && s !== q && !(s === m && (t & y) !== 0) ? i | C : i, t & T && this._deferred.delete(e), t & g && 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--);
+    const t = e.phaseState, s = t.queue;
+    if (t.first === e) {
+      t.first = s.shift(), this._queuedCount--;
+      return;
+    }
+    const i = s.indexOf(e);
+    i >= 0 && (s.splice(i, 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);
+    (t & x) !== x || e.consumerOwner.disposed || ((t & C) !== 0 || I(e) ? (e.state = t & -67, this._queue(e)) : e.state = t & ~P);
   }
   /**
    * Возвращает причины открытой доставки в ожидающие, впереди причин, которые
@@ -612,7 +704,7 @@ class te {
    * отделяются от ожидающих.
    */
   _restoreDeliveryCausesBeforePending(e) {
-    e.state & k && this._splitDeliveredCauses(e);
+    e.state & w && this._splitDeliveredCauses(e);
     const t = e.detail;
     if (t === void 0)
       return;
@@ -621,13 +713,13 @@ class te {
       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);
+    const r = t.deliveryExtraCauses;
+    if (r !== void 0)
+      for (const [h, l] of r)
+        this._appendCause(e, l, h);
     if (i !== void 0 && (this._appendCause(e, i, a), n !== void 0))
-      for (const [r, d] of n)
-        this._appendCause(e, d, r);
+      for (const [h, l] of n)
+        this._appendCause(e, l, h);
   }
   _schedule() {
     if (this._running || this._scheduled || this._disposed)
@@ -664,20 +756,36 @@ class te {
     const e = [...this._deferred];
     this._deferred.clear();
     for (const t of e)
-      t.state &= ~E, this._queue(t, !1);
+      t.state &= ~T, this._queue(t, !1);
+  }
+  /** Flush без читателей frame: только номер кадра, без clock и снимка. */
+  _skipFrame() {
+    return this._frameNumber++, this._frameStale = !0, this._frame;
+  }
+  /**
+   * Вычисляет текущий кадр при первом чтении. История до него не записывалась,
+   * поэтому кадр считается первым измеренным: delta и elapsed равны нулю.
+   */
+  _materializeFrame() {
+    const e = this._now();
+    this._frameStale = !1, this._firstFrameAt = e, this._lastFrameAt = e, this._frame = { now: e, delta: 0, elapsed: 0, frame: this._frameNumber };
   }
   _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._frameStale = !1;
+    const e = this._now();
+    if (this._frameNumber === -1) {
+      this._firstFrameAt = e, this._lastFrameAt = e, this._frameNumber = 0;
+      const s = { now: e, delta: 0, elapsed: 0, frame: 0 };
+      return this._frame = this._publicFrames ? Object.freeze(s) : s;
+    }
     this._frameNumber++;
-    const t = Object.freeze({
+    const t = {
       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;
+    };
+    return this._lastFrameAt = e, this._frame = this._publicFrames ? Object.freeze(t) : t;
   }
   _assertRetainedPhases(e) {
     for (const t of this._phases) {
@@ -687,56 +795,67 @@ class te {
     }
     for (const t of this._phases) {
       const s = t.state;
-      if (s.queue.length !== 0 && !e.has(s.name))
+      if (s.first !== void 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;
   }
+  /**
+   * Есть ли то, что изменит flush(): очередь, отложенные записи, запланированный
+   * turn или ожидающие afterFlush(). Без этого flush() ничего не делает.
+   *
+   * @internal
+   */
+  _hasPendingWork() {
+    return this._queuedCount !== 0 || this._deferred.size !== 0 || this._scheduled || this._idleWaiters.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;
+      const a = i.state;
+      a.first !== void 0 && (s.push(a.first), a.first = void 0);
+      const n = a.queue;
+      for (const r of n)
+        s.push(r);
+      n.length = 0;
     }
     this._queuedCount = 0;
     for (const i of s)
-      i.state &= ~w, e && this._acknowledgeDiscard(i, !0, t), this._clearPendingDelivery(i);
+      i.state &= ~g, 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);
+      i.state &= ~T, e && this._acknowledgeDiscard(i, !0, t), this._clearPendingDelivery(i);
   }
   _acknowledgeDiscard(e, t, s) {
     const i = e.state;
-    if (i & C)
+    if (i & y)
       return;
     const a = e.node, n = e.group;
-    if (a === void 0 && n === void 0 || !(i & f)) {
-      e.state = i | C;
+    if (a === void 0 && n === void 0 || !(i & _)) {
+      e.state = i | y;
       return;
     }
     try {
-      if (a !== void 0 ? (i & H) !== 0 && this._reactivity._cancelTaskEffect(a) : this._cancelGroup(e, n, t)) {
-        e.state |= C;
+      if (a !== void 0 ? (i & U) !== 0 && this._reactivity._cancelTaskEffect(a) : this._cancelGroup(e, n, t)) {
+        e.state |= y;
         return;
       }
       if (!t) {
-        s.push(new R(
+        s.push(new K(
           `[Raph] Initial effect delivery in "${e.phase}" cannot be cancelled before dependency collection.`
         ));
         return;
       }
-      e.dispose(), e.state |= C;
-    } catch (o) {
-      s.push(o);
+      e.dispose(), e.state |= y;
+    } catch (r) {
+      s.push(r);
     }
   }
   /**
@@ -763,33 +882,33 @@ class te {
   _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));
+    for (let h = k; h < t.length; h++) {
+      const l = t[h];
+      l === null || l.firstDep !== null || !i._beginTaskEffectRun(l) || (s ? i._disposeTaskEffect(l) : (i._requestTaskEffect(l, !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)
+    const n = !s && I(e);
+    let r = !1;
+    for (let h = k; h < t.length; h++) {
+      const l = t[h];
+      if (l === null)
         continue;
-      if (d.firstDep === null) {
-        o = o || d.evaluate !== void 0;
+      if (l.firstDep === null) {
+        r = r || l.evaluate !== void 0;
         continue;
       }
-      const l = n && i._beginTaskEffectRun(d);
-      i._cancelTaskEffect(d) && (o = !0, l && i._rearmTaskEffect(d));
+      const d = n && i._beginTaskEffectRun(l);
+      i._cancelTaskEffect(l) && (r = !0, d && i._rearmTaskEffect(l));
     }
-    return o;
+    return r;
   }
   /**
    * Сбрасывает ожидающую работу записи, снятой с очереди либо из отложенных.
    * Такая запись не находится в доставке, поэтому её причины ожидающие.
    */
   _clearPendingDelivery(e) {
-    e.state &= ~g, e.firstCause = void 0, e.firstCauseKey = void 0;
+    e.state &= ~C, e.firstCause = void 0, e.firstCauseKey = void 0;
     const t = e.detail;
     t !== void 0 && (t.extraCauses?.clear(), t.extraCauses = void 0);
   }
@@ -804,45 +923,45 @@ class te {
   }
   _assertAlive() {
     if (this._disposed)
-      throw new I("[Raph] Phase pipeline is disposed.");
+      throw new H("[Raph] Phase pipeline is disposed.");
   }
 }
-function Y(h, e) {
-  return e.priority - h.priority || h.sequence - e.sequence;
+function se(f, e) {
+  return e.priority - f.priority || f.sequence - e.sequence;
 }
-function F(h) {
-  return h.firstCause !== void 0 && !(h.state & k);
+function I(f) {
+  return f.firstCause !== void 0 && !(f.state & w);
 }
-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);
+function S(f) {
+  const e = f.state, t = f.detail;
+  if (e & w) {
+    f.state = e & ~w, f.firstCause = void 0, f.firstCauseKey = void 0, t !== void 0 && (t.extraCauses = void 0, t.deliveryCauses = void 0);
     return;
   }
-  t !== void 0 && t.deliveryFirstCause !== void 0 && L(t);
+  t !== void 0 && t.deliveryFirstCause !== void 0 && M(t);
 }
-function L(h) {
-  h.deliveryFirstCause = void 0, h.deliveryFirstCauseKey = void 0, h.deliveryExtraCauses = void 0, h.deliveryCauses = void 0;
+function M(f) {
+  f.deliveryFirstCause = void 0, f.deliveryFirstCauseKey = void 0, f.deliveryExtraCauses = void 0, f.deliveryCauses = void 0;
 }
-function O() {
-  throw new R("[Raph] Phase task delivery is already resolved.");
+function $() {
+  throw new K("[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({
+function G(f, e) {
+  const t = f.events === void 0 ? e.events : e.events === void 0 ? f.events : Object.freeze([...f.events, ...e.events]), s = f.structure === void 0 ? e.structure : e.structure === void 0 ? f.structure : Object.freeze({
     node: e.structure.node,
-    oldParent: h.structure.oldParent,
-    oldIndex: h.structure.oldIndex,
+    oldParent: f.structure.oldParent,
+    oldIndex: f.structure.oldIndex,
     newParent: e.structure.newParent,
     newIndex: e.structure.newIndex
   });
   return Object.freeze({
     ...e,
-    previous: h.previous,
+    previous: f.previous,
     ...t === void 0 ? {} : { events: t },
     ...s === void 0 ? {} : { structure: s }
   });
 }
 export {
-  te as RaphPhasePipeline,
-  Q as RaphPhaseState
+  re as RaphPhasePipeline,
+  Z as RaphPhaseState
 };