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

package/dist/debug/runtime/RaphRuntimeBase.js

@@ -0,0 +1,941 @@
+import { RaphDisposedError as O, RaphCrossRuntimeError as g, RaphActionError as L } from "./errors.js";
+import { parentGraph as j } from "./ownership/parentGraph.js";
+import { RaphNode as F, createProvisionalNode as M } from "./ownership/RaphNode.js";
+import { RaphScope as T } from "./ownership/RaphScope.js";
+import { throwDisposalErrors as R } from "./ownership/throwDisposalErrors.js";
+import { RaphSchedulerType as f } from "./phases/phase.types.js";
+import { RaphFrameLoop as $ } from "./phases/RaphFrameLoop.js";
+import { RaphPhasePipeline as U } from "./phases/RaphPhasePipeline.js";
+import { RaphPhaseTaskRecord as K, TASK_ACTIVE as x, TASK_TASKLESS as z, GROUP_NODES as D, TASK_PENDING as C, TASK_REQUESTED as V } from "./phases/RaphPhaseTaskRecord.js";
+import { createPhaseWatch as Y } from "./phases/RaphPhaseWatch.js";
+import { enqueueSweeper as H, dequeueSweeper as I, postponeFirstSweeper as Q } from "./reactivity/disposal-sweep.utils.js";
+import { RaphWorkGraph as X } from "./reactivity/RaphWorkGraph.js";
+import { RuntimeReactivity as J } from "./reactivity/RuntimeReactivity.js";
+let Z = 0;
+function ve(_) {
+  const e = _.id ?? `runtime-${Z++}`, t = _.adaptiveDependencyIndex ?? !1, s = _.enforceActions ?? !1, i = _.scheduler ?? f.Sync;
+  if (!ie(i))
+    throw new Error(`[Raph] Unsupported scheduler "${String(i)}".`);
+  return Object.freeze({ id: e, adaptiveDependencyIndex: t, enforceActions: s, scheduler: i });
+}
+const m = Object.freeze({}), N = 2 ** 32 - 1 - D, k = /* @__PURE__ */ new Set();
+let P = !1;
+function B() {
+  let _ = 0, e;
+  for (const s of k) {
+    const i = s.deref();
+    if (i === void 0 || i.disposed) {
+      k.delete(s);
+      continue;
+    }
+    _++, e = i;
+  }
+  const t = _ > 1;
+  if (t !== P) {
+    if (!t && e !== void 0) {
+      const s = e._getReactivity();
+      if (s.getActiveOwner() !== void 0 || s.getActiveConsumerOwner() !== void 0)
+        return;
+    }
+    P = t;
+    for (const s of k)
+      s.deref()?._applyObjectReadPolicy(t);
+  }
+}
+class W {
+  reactiveObjects;
+  selectors;
+  _reactiveObjects;
+  mode = "runtime";
+  configuration;
+  rootScope;
+  root;
+  frameTick;
+  _reactivity;
+  _signalLifecycle;
+  _workGraph;
+  _frameTickSignal;
+  _phases;
+  _frameLoop;
+  _debugController;
+  _parentGraph;
+  _topOwners = /* @__PURE__ */ new Set();
+  _ownerRegistrations = 0;
+  _ownersReleased = !1;
+  _batchDepth = 0;
+  _mutationDepth = 0;
+  _kernelBatchDepth = 0;
+  _ownerDisposalDepth = 0;
+  _disposingNodes = [];
+  _ownerDisposals = 0;
+  _disposalSweepers;
+  _nextDisposalSweep = Number.POSITIVE_INFINITY;
+  _actionDepth = 0;
+  _actionCounter = 0;
+  _traceCauseStack = [];
+  _phaseTraceOperations;
+  _executionRequested = !1;
+  _disposed = !1;
+  _disposedListeners = /* @__PURE__ */ new Set();
+  _checkedObjectPolicy;
+  _fastObjectPolicy;
+  constructor(e, t, s, i) {
+    const { id: o, adaptiveDependencyIndex: r, enforceActions: c } = e;
+    this.configuration = e, this.reactiveObjects = s !== void 0, this.selectors = i !== void 0, this._reactiveObjects = s, this._debugController = t;
+    const n = `[Raph] Runtime "${o}" is disposed.`;
+    if (this._signalLifecycle = {
+      owner: this,
+      assertDependencyAllowed: (h, a) => {
+        this._assertImplicitDependency(h, a);
+      },
+      ...c ? { assertWriteAllowed: () => this._assertWriteAllowed() } : {},
+      throwDisposed: () => {
+        throw new O(n);
+      },
+      throwCrossRuntime: (h) => this._throwCrossRuntime(h)
+    }, this._reactivity = new J(this._signalLifecycle, { adaptiveDependencyIndex: r }, i), this._workGraph = new X(this), this.rootScope = new T(`${o}:root-scope`, this), this.root = new F(null, { id: `${o}:root` }, this), s !== void 0) {
+      const h = () => this._assertWriteAllowed(), a = (l) => this._runWrite(l), p = (l) => {
+        throw l instanceof W && this._throwCrossRuntime(l), new g(
+          "[Raph] Reactive object belongs to another reactivity engine."
+        );
+      };
+      this._checkedObjectPolicy = Object.freeze({
+        owner: this,
+        assertRead: () => this._assertTrackedRead(),
+        assertWrite: h,
+        runWrite: a,
+        writeBoundary: this,
+        throwForeign: p
+      }), this._fastObjectPolicy = Object.freeze({
+        owner: this,
+        assertRead: void 0,
+        assertWrite: h,
+        runWrite: a,
+        writeBoundary: this,
+        throwForeign: p
+      });
+    }
+    k.add(new WeakRef(this)), B(), this._applyObjectReadPolicy(P);
+    const u = this._reactivity.signalForOwner(0, this.rootScope, "frame", !1);
+    this._frameTickSignal = u, this.frameTick = this._workGraph.attachProducer(u, {
+      get: () => u.get(),
+      peek: () => u.peek()
+    });
+  }
+  _getReactivity() {
+    return this._reactivity;
+  }
+  _getWorkGraph() {
+    return this._workGraph;
+  }
+  get id() {
+    return this.configuration.id;
+  }
+  get disposed() {
+    return this._disposed;
+  }
+  get graph() {
+    return this._parentGraph ??= j();
+  }
+  get loopEnabled() {
+    return this._frameLoop?.running ?? !1;
+  }
+  get frame() {
+    return this._phases?.frame ?? { now: 0, delta: 0, elapsed: 0, frame: 0 };
+  }
+  get phases() {
+    return this._phases?.phases ?? [];
+  }
+  signal(e, t = this.rootScope) {
+    return this._assertOwnerRuntime(t), this._reactivity.signalForOwner(e, t);
+  }
+  reactive(e) {
+    if (this._assertAlive(), this._reactiveObjects === void 0)
+      throw new TypeError("[Raph] Reactive objects require the full execution profile.");
+    return this._reactiveObjects.reactive(this._reactivity, e);
+  }
+  computed(e, t = this.rootScope) {
+    this._assertOwnerRuntime(t);
+    const s = this._workGraph.createProducer(t), i = typeof e == "function" ? e : e.get, o = this._reactivity.computedForOwner(
+      () => this._runTracked(t, i),
+      t,
+      this._workGraph.producerHooks(s)
+    );
+    if (this._workGraph.setProducerActivation(s, () => {
+      o.peek();
+    }), typeof e == "function")
+      return this._workGraph.attachProducer(s, o);
+    const r = this._attachWritableComputed(o, e.set, t);
+    return this._workGraph.attachProducer(s, r);
+  }
+  effect(e, t, s, i = m) {
+    return ee(
+      this._effectRegistration(e, t, s, i)
+    );
+  }
+  _effectRegistration(e, t, s, i = m, o = !1, r = !1, c, n) {
+    this._disposed || e.runtime !== this ? this._assertOwnerRuntime(e) : e._assertAlive();
+    const u = this._phases ?? this._execution;
+    if (typeof s != "function")
+      throw new TypeError("[Raph] Phase callback must be a function.");
+    const h = u._resolvedState, a = h !== void 0 && t === u._resolvedInput ? h : u.resolvePhase(t), p = i.priority ?? 0;
+    if (!Number.isFinite(p))
+      throw new TypeError("[Raph] Effect priority must be finite.");
+    const l = i.initial ?? "scheduled";
+    if (l !== "scheduled" && l !== "sync")
+      throw new TypeError(`[Raph] Unsupported effect initial mode "${String(l)}".`);
+    a.bindings++;
+    const d = new K(a, i.priority ?? 0, e, s);
+    r && (d.state = x | z);
+    const w = this._reactivity, v = i.initial === "sync", S = v && this.configuration.scheduler !== f.Sync;
+    let A = "Effect registration and cleanup failed.", b = !1;
+    try {
+      o && d.pause();
+      const y = w._allocateTaskEffect(w._phaseBody, d);
+      if (d.node = y, S && u._queue(d, !1), b = !0, !S && !o && !w._isBatching() && u._canDeliverFirst(d)) {
+        w._requestTaskEffect(y, !1);
+        try {
+          u._deliverFirst(d);
+        } catch (G) {
+          w._failTaskEffectSchedule(y, G);
+        }
+      } else
+        w._requestTaskEffect(y, !S);
+      if (n?.())
+        return d.dispose(), d;
+      b = !1, A = "[Raph] Resource registration and cleanup failed.", (d.state & x) !== 0 && d.node !== void 0 ? e._adoptRecord(d) : (e._assertAlive(), d.dispose()), A = "[Raph] Phase effect registration and rollback failed.", b = !0, v ? u._running ? this._executionRequested = !1 : (this._disposed && this._assertAlive(), this._executionRequested = !1, u.flush()) : this._requestExecution(), n?.() && d.dispose();
+    } catch (y) {
+      this._rollbackRegistration(
+        d,
+        y,
+        A,
+        b ? c : void 0
+      );
+    }
+    return d;
+  }
+  _effectGroupRegistration(e, t, s, i, o, r = m, c = !1) {
+    this._assertOwnerRuntime(e);
+    const n = this._execution, u = i, h = this._validatePhaseBinding(n, t, u, r);
+    if (!Number.isInteger(s) || s < 1)
+      throw new RangeError("[Raph] Effect group slot count must be a positive integer.");
+    if (s > N)
+      throw new RangeError(`[Raph] Effect group slot count must not exceed ${N}.`);
+    const a = n.bindGroup(h, e, u, o, s, r.priority ?? 0);
+    try {
+      c && a.pause();
+      const p = a.group, l = this._reactivity, d = l._phaseBody, w = D + s;
+      for (let v = D; v < w; v++)
+        p[v] = l._allocateTaskEffect(d, a);
+      e._adoptRecord(a);
+    } catch (p) {
+      this._rollbackRegistration(a, p, "[Raph] Resource registration and cleanup failed.");
+    }
+    return a;
+  }
+  _startGroupSlot(e, t, s, i) {
+    const o = e.group;
+    if (o === void 0) {
+      e.consumerOwner._assertAlive();
+      return;
+    }
+    const r = t >= 0 ? o[D + t] : void 0;
+    if (r === void 0)
+      throw new RangeError(`[Raph] Effect group has no slot ${String(t)}.`);
+    if (s !== "scheduled" && s !== "sync")
+      throw new TypeError(`[Raph] Unsupported effect initial mode "${String(s)}".`);
+    if (r === null || r.firstDep !== null)
+      return;
+    const c = e.phaseState.pipeline, n = s === "sync", u = n && this.configuration.scheduler !== f.Sync;
+    let h = !1;
+    try {
+      h = !0, this._reactivity._requestTaskEffect(r, !1), u ? e.state & C || c._queue(e, !1) : e.schedule(), h = !1, e.state & (C | V) || e.consumerOwner._assertAlive(), n ? c._running ? this._executionRequested = !1 : (h = !0, this.flush(), h = !1, e.state & x || e.consumerOwner._assertAlive()) : (h = !0, this._requestExecution());
+    } catch (a) {
+      let p = a;
+      try {
+        this._reactivity._disposeTaskEffect(r);
+      } catch (l) {
+        p = new AggregateError(
+          [a, l],
+          "[Raph] Phase effect registration and rollback failed."
+        );
+      }
+      throw h && i !== void 0 && i(p), p;
+    }
+  }
+  watch(e, t, s, i, o = m) {
+    const r = this._watchRegistration(e, t, s, i, o).watch;
+    return r === void 0 ? q : te(r);
+  }
+  _watchRegistration(e, t, s, i, o = m, r = !1, c, n) {
+    this._assertOwnerRuntime(e);
+    const u = this._execution, h = this._validatePhaseBinding(u, s, i, o, !0);
+    this._workGraph.assertSubscriptionAllowed(e, t);
+    const a = u.bindTask(h, e, i, o.priority ?? 0), p = Y((d) => this._runUntracked(d), a);
+    a.watch = p, r && a.pause();
+    try {
+      if (p.source = this._workGraph.subscribe(
+        t,
+        o.include,
+        (d, w, v) => p.record?.enqueue(d, w, v)
+      ), n?.())
+        return a.dispose(), a;
+    } catch (d) {
+      throw a.dispose(), d;
+    }
+    try {
+      e._adoptRecord(a);
+    } catch (d) {
+      this._rollbackRegistration(a, d, "[Raph] Resource registration and cleanup failed.");
+    }
+    const l = o.initial ?? "scheduled";
+    try {
+      l !== "none" && a.schedule(), l === "sync" && this.flush(), n?.() && a.dispose();
+    } catch (d) {
+      this._rollbackRegistration(
+        a,
+        d,
+        "[Raph] Phase watch registration and rollback failed.",
+        c
+      );
+    }
+    return a;
+  }
+  aggregate(e, t) {
+    return this._assertOwnerRuntime(e), this._workGraph.createAggregate(e, t);
+  }
+  batch(e) {
+    return this._batch(e, !0);
+  }
+  _batchReactive(e) {
+    return this._batch(e, !1);
+  }
+  _batch(e, t) {
+    this._assertAlive(), this._batchDepth++;
+    let s, i, o = !1;
+    try {
+      s = this._reactivity.batch(() => t ? this._runDataBatch(e) : e());
+    } catch (r) {
+      o = !0, i = r;
+    }
+    return this._closeBatch(o, i), s;
+  }
+  _closeBatch(e, t) {
+    if (this._batchDepth--, this._executionBoundaryOpen()) {
+      if (e)
+        throw t;
+      return;
+    }
+    const s = this._finishExecutionBoundary();
+    if (e)
+      throw s !== void 0 ? new AggregateError(
+        [t, ...s],
+        "[Raph] Batch and scheduled phase execution failed."
+      ) : t;
+    s !== void 0 && R(s, "[Raph] Batch phase execution failed.");
+  }
+  _applyBatch(e, t, s) {
+    this._assertAlive();
+    const i = this._reactivity;
+    this._batchDepth++, i._startBatch();
+    let o, r, c = !1;
+    try {
+      o = i._applyUntrackedWithOwner(e, t, s);
+    } catch (n) {
+      c = !0, r = n;
+    }
+    try {
+      i._endBatch();
+    } catch (n) {
+      r = c ? new AggregateError([r, n], "Batch operation and effect queue processing failed.") : n, c = !0;
+    }
+    return this._closeBatch(c, r), o;
+  }
+  action(e, t, s) {
+    const i = typeof e == "function" ? e : t, o = typeof e == "function" ? t instanceof T ? t : this.rootScope : s ?? this.rootScope, r = typeof e == "string" ? e : `action#${++this._actionCounter}`;
+    if (this._assertOwnerRuntime(o), typeof i != "function")
+      throw new TypeError("[Raph] Action operation must be a function.");
+    if (!r.trim())
+      throw new Error("[Raph] Action name must not be empty.");
+    return (...c) => this._invokeAction(r, o, i, c);
+  }
+  /**
+   * Общее исполнение public action и class methods, без второго массива аргументов.
+   * @internal
+   */
+  _invokeAction(e, t, s, i, o) {
+    t._assertAlive();
+    const r = this._debugController, c = this._traceCauseStack, n = r?.nextOperationId("action"), h = (c.length === 0 ? void 0 : c[c.length - 1]) ?? n;
+    n !== void 0 && r?.record({
+      ...h === void 0 ? {} : { causeId: h },
+      kind: "action",
+      name: e,
+      ...n === void 0 ? {} : { operationId: n },
+      status: "start"
+    }), h !== void 0 && c.push(h), this._actionDepth++;
+    try {
+      const a = this._applyBatch(s, i, o);
+      return r?.traces("action") && r?.record({
+        ...h === void 0 ? {} : { causeId: h },
+        kind: "action",
+        name: e,
+        ...n === void 0 ? {} : { operationId: n },
+        status: "end"
+      }), a;
+    } catch (a) {
+      throw this._debugController?.record({
+        ...h === void 0 ? {} : { causeId: h },
+        details: { message: E(a) },
+        kind: "action",
+        name: e,
+        ...n === void 0 ? {} : { operationId: n },
+        status: "error"
+      }), this._debugController?.record({
+        ...h === void 0 ? {} : { causeId: h },
+        details: { message: E(a) },
+        kind: "error",
+        name: `action:${e}`,
+        ...n === void 0 ? {} : { operationId: n },
+        status: "error"
+      }), a;
+    } finally {
+      this._actionDepth--, h !== void 0 && c.pop();
+    }
+  }
+  untracked(e) {
+    return this._assertAlive(), this._runUntracked(e);
+  }
+  /**
+   * Выполняет операцию вне owner context и сообщает, было ли в ней отслеживаемое
+   * чтение. Ни одной зависимости операция не оставляет. Renderer так проверяет,
+   * что значение зависит только от переданных данных и не требует effect.
+   * @internal
+   */
+  _probeReads(e) {
+    return this._assertAlive(), this._reactivity._probeReadsWithOwner(e);
+  }
+  scope(e) {
+    return this._assertAlive(), new T(e, this);
+  }
+  node(e, t) {
+    this._assertAlive(), this._enterWrite();
+    let s;
+    try {
+      s = this._createCommittedNode(e, t);
+    } catch (i) {
+      throw this._failWrite(i);
+    }
+    return this._exitWrite(), s._assertAlive(), s;
+  }
+  _createCommittedNode(e, t) {
+    const s = e.parent ?? this.root, i = M(s, e, this);
+    try {
+      const o = t?.(i);
+      return i._assertAlive(), s._assertAlive(), i._setApi(o), i._publishCreation(), i;
+    } catch (o) {
+      try {
+        i.dispose();
+      } catch (r) {
+        throw new AggregateError([o, r], `[Raph] Node "${i.id}" setup and cleanup failed.`);
+      }
+      throw o;
+    }
+  }
+  getNode(e) {
+    return this._assertAlive(), this.root._findNode(e);
+  }
+  definePhases(e) {
+    this._execution.definePhases(e);
+  }
+  addPhase(e) {
+    this._execution.addPhase(e);
+  }
+  clearPhases() {
+    this._assertAlive(), this._phases?.clearPhases();
+  }
+  requestExecution() {
+    this._assertAlive(), this._phases?.request();
+  }
+  flush() {
+    this._assertAlive(), this._executionRequested = !1, this._phases?.flush();
+  }
+  afterFlush() {
+    return this._assertAlive(), this._phases?.afterFlush() ?? Promise.resolve();
+  }
+  acquireLoop(e) {
+    return this._assertAlive(), this._clock.acquire(e);
+  }
+  startLoop() {
+    this._assertAlive(), this._clock.start();
+  }
+  stopLoop() {
+    this._frameLoop?.stop();
+  }
+  dispose() {
+    if (this._disposed)
+      return;
+    this._disposed = !0, this._checkedObjectPolicy !== void 0 && this._reactiveObjects?.configure(this._reactivity, this._checkedObjectPolicy), B(), this._executionRequested = !1, this._signalLifecycle.owner = void 0;
+    const e = [];
+    try {
+      this._frameLoop?.dispose();
+    } catch (r) {
+      e.push(r);
+    }
+    this._frameLoop = void 0;
+    try {
+      this._phases?.dispose();
+    } catch (r) {
+      e.push(r);
+    }
+    this._phases = void 0;
+    try {
+      this.root.dispose();
+    } catch (r) {
+      e.push(r);
+    }
+    const t = this._collectOwners().sort(se);
+    for (const r of t)
+      if (!(r === this.root || r === this.rootScope || r.disposed))
+        try {
+          r.dispose();
+        } catch (c) {
+          e.push(c);
+        }
+    try {
+      this.rootScope.dispose();
+    } catch (r) {
+      e.push(r);
+    }
+    const s = `[Raph] Runtime "${this.id}" is disposed.`, i = () => {
+      throw new O(s);
+    };
+    try {
+      this._reactiveObjects?.dispose(this._reactivity, {
+        assertRead: i,
+        assertWrite: i,
+        throwForeign: i
+      });
+    } catch (r) {
+      e.push(r);
+    }
+    this._topOwners.clear(), this._ownersReleased = !0, this._disposeDataSources(e);
+    try {
+      this._workGraph.dispose();
+    } catch (r) {
+      e.push(r);
+    }
+    this._detachDataPlane(e);
+    const o = [...this._disposedListeners];
+    this._disposedListeners.clear();
+    for (const r of o)
+      try {
+        r();
+      } catch (c) {
+        e.push(c);
+      }
+    R(e, `[Raph] Runtime "${this.id}" disposal failed.`);
+  }
+  _onDisposed(e) {
+    return this._disposed ? (e(), () => {
+    }) : (this._disposedListeners.add(e), () => {
+      this._disposedListeners.delete(e);
+    });
+  }
+  _notifyNodeStructure(e, t, s, i) {
+    if (!this._workGraph._hasStructuralDemand(e)) {
+      this._touchMutationBoundary();
+      return;
+    }
+    this._runNodeMutation(() => {
+      this._workGraph.notifyNode(e, "structure", { structure: t, oldAncestors: s, newAncestors: i });
+    });
+  }
+  _hasNodeStructureDemand(e) {
+    return this._workGraph._hasStructuralDemand(e);
+  }
+  _hasNodeSubscribers() {
+    return this._workGraph._hasNodeSubscribers();
+  }
+  _notifyNodeTouch(e, t) {
+    this._runNodeMutation(() => this._workGraph.notifyNode(e, "touch", { metadata: t }));
+  }
+  _assertNodeReparentAllowed(e, t) {
+    this._workGraph.assertReparentAllowed(e, t);
+  }
+  _releaseNode(e) {
+    this._workGraph.releaseNode(e);
+  }
+  _runNodeMutation(e) {
+    return this._runWrite(e);
+  }
+  _touchMutationBoundary() {
+    if (this.configuration.scheduler === f.Sync && (this._executionRequested = !0), this._executionBoundaryOpen())
+      return;
+    const e = this._finishExecutionBoundary();
+    e !== void 0 && R(e, "[Raph] Mutation phase execution failed.");
+  }
+  _runPhaseTransition(e) {
+    return this._runWrite(e, !1);
+  }
+  _beginOwnerDisposal(e) {
+    this._disposingNodes[this._ownerDisposalDepth++] = e;
+  }
+  _endOwnerDisposal() {
+    const e = this._ownerDisposalDepth;
+    e !== 0 && (this._ownerDisposalDepth = e - 1, this._disposingNodes[e - 1] = void 0, this._ownerDisposals >= this._nextDisposalSweep && e === 1 && this._sweepAfterDisposals(), this._clearTransientCausesIfSettled(), this._disposed || this._requestExecution());
+  }
+  _ownerDisposalCount() {
+    return this._ownerDisposals;
+  }
+  _addDisposalSweeper(e, t) {
+    const s = this._disposalSweepers;
+    if (s === void 0) {
+      e._sweepSlot = 0, e._sweepDue = t, this._disposalSweepers = [e], this._nextDisposalSweep = t;
+      return;
+    }
+    H(s, e, t), this._nextDisposalSweep = s[0]._sweepDue;
+  }
+  _removeDisposalSweeper(e) {
+    const t = this._disposalSweepers;
+    t === void 0 || !I(t, e) || (t.length === 0 ? (this._disposalSweepers = void 0, this._nextDisposalSweep = Number.POSITIVE_INFINITY) : this._nextDisposalSweep = t[0]._sweepDue);
+  }
+  _sweepAfterDisposals() {
+    const e = this._disposalSweepers;
+    if (e === void 0)
+      return;
+    const t = this._ownerDisposals;
+    if (e.length === 1) {
+      const s = e[0], i = s._afterOwnerDisposals(t);
+      i > t ? (s._sweepDue = i, this._nextDisposalSweep = i) : (s._sweepSlot = -1, this._disposalSweepers = void 0, this._nextDisposalSweep = Number.POSITIVE_INFINITY);
+      return;
+    }
+    for (let s = e[0]; s._sweepDue <= t; s = e[0]) {
+      const i = s._afterOwnerDisposals(t);
+      if (i > t)
+        Q(e, i);
+      else if (I(e, s), e.length === 0) {
+        this._disposalSweepers = void 0, this._nextDisposalSweep = Number.POSITIVE_INFINITY;
+        return;
+      }
+    }
+    this._nextDisposalSweep = e[0]._sweepDue;
+  }
+  _ownerDisposalActive() {
+    return this._ownerDisposalDepth !== 0;
+  }
+  _registerOwner(e) {
+    return this._assertAlive(), e._isNode || this._topOwners.add(e), ++this._ownerRegistrations;
+  }
+  _unregisterOwner(e) {
+    e._isNode || this._topOwners.delete(e), this._ownerDisposals++;
+  }
+  _addTopOwner(e) {
+    this._topOwners.add(e);
+  }
+  _removeTopOwner(e) {
+    this._topOwners.delete(e);
+  }
+  _assertOwnerRuntime(e) {
+    if (this._assertAlive(), e.runtime !== this)
+      throw new g("[Raph] Owner belongs to another runtime.");
+    e._assertAlive();
+  }
+  _beginKernelBatch() {
+    this._disposed || this._kernelBatchDepth++;
+  }
+  _endKernelBatch() {
+    this._kernelBatchDepth !== 0 && (this._kernelBatchDepth--, this._clearTransientCausesIfSettled(), this._disposed || this._requestExecution());
+  }
+  _registerMachineDebug(e) {
+    return this._assertAlive(), this._debugController?.registerMachine(e) ?? q;
+  }
+  _hasMachineDebug(e) {
+    return this._debugController?.hasMachine(e) ?? !1;
+  }
+  _traces(e) {
+    return this._debugController?.traces(e) ?? !1;
+  }
+  _currentTraceCauseId() {
+    return this._traceCauseStack.at(-1);
+  }
+  _nextTraceOperation(e) {
+    return this._debugController?.nextOperationId(e);
+  }
+  _hasActiveReactiveContext() {
+    return this._assertAlive(), this._reactivity.hasActiveContext();
+  }
+  _recordTrace(e) {
+    this._debugController?.record(e);
+  }
+  _runWithTraceCause(e, t) {
+    if (e === void 0)
+      return t();
+    this._traceCauseStack.push(e);
+    try {
+      return t();
+    } finally {
+      this._traceCauseStack.pop();
+    }
+  }
+  _validatePhaseBinding(e, t, s, i, o = !1) {
+    if (typeof s != "function")
+      throw new TypeError("[Raph] Phase callback must be a function.");
+    const r = e.resolvePhase(t), c = i.priority ?? 0;
+    if (!Number.isFinite(c))
+      throw new TypeError("[Raph] Effect priority must be finite.");
+    const n = i.initial ?? "scheduled";
+    if (n !== "scheduled" && n !== "sync" && !(o && n === "none"))
+      throw new TypeError(`[Raph] Unsupported effect initial mode "${String(n)}".`);
+    return r;
+  }
+  _rollbackRegistration(e, t, s, i) {
+    let o = t;
+    try {
+      e.dispose();
+    } catch (r) {
+      o = new AggregateError([t, r], s);
+    }
+    throw i !== void 0 && i(o), o;
+  }
+  _liveOwnerCount() {
+    return this._ownersReleased ? 0 : this._ownerRegistrations - this._ownerDisposals;
+  }
+  _collectOwners() {
+    const e = [];
+    if (this._ownersReleased)
+      return e;
+    const t = this._topOwners;
+    for (const o of t)
+      e.push(o), o._isNode && o._collectDescendants(e);
+    const s = this._disposingNodes, i = this._ownerDisposalDepth;
+    for (let o = 0; o < i; o++) {
+      const r = s[o];
+      r === void 0 || r._isLinked() || t.has(r) || (e.push(r), r._collectDescendants(e));
+    }
+    return e;
+  }
+  get _execution() {
+    return this._assertAlive(), this._phases !== void 0 ? this._phases : (this._phases = new U(
+      this.configuration.scheduler,
+      this._reactivity,
+      (e) => this._workGraph.causeForToken(e),
+      () => {
+        const e = this._mutationDepth !== 0 || this._batchDepth !== 0 || this._kernelBatchDepth !== 0 || this._ownerDisposalDepth !== 0 || this._reactivity._isFlushingEffects();
+        return e && this.configuration.scheduler === f.Sync && (this._executionRequested = !0), e;
+      }
+    ), this._syncPhaseTrace(), this._phases);
+  }
+  _phaseTraceListener;
+  _syncPhaseTrace() {
+    if (this._phases === void 0)
+      return;
+    const t = this._phaseTraceOperations !== void 0 || this._debugController?.traces("phase") ? this._phaseTraceListener ??= this._tracePhase.bind(this) : void 0;
+    this._phases._setPhaseTrace(t);
+  }
+  _tracePhase(e, t, s) {
+    if (this._phaseTraceOperations === void 0 && !this._debugController?.traces("phase"))
+      return;
+    let i;
+    t === "start" ? (i = this._debugController?.nextOperationId("phase"), i !== void 0 && (this._phaseTraceOperations ??= /* @__PURE__ */ new Map()).set(e, i)) : (i = this._phaseTraceOperations?.get(e), this._phaseTraceOperations?.delete(e), this._phaseTraceOperations?.size === 0 && (this._phaseTraceOperations = void 0)), this._debugController?.record({
+      ...i === void 0 ? {} : { causeId: i },
+      ...s === void 0 ? {} : { details: { message: E(s) } },
+      kind: "phase",
+      name: e,
+      ...i === void 0 ? {} : { operationId: i },
+      status: t
+    }), this._phaseTraceOperations === void 0 && !this._debugController?.traces("phase") && this._phases?._setPhaseTrace(void 0);
+  }
+  get _clock() {
+    return this._frameLoop ??= new $(() => this._tickFrameLoop());
+  }
+  _tickFrameLoop() {
+    this._disposed || this._setFrameTick(this._frameTickSignal.peek() + 1);
+  }
+  _setFrameTick(e) {
+    this._enterWrite();
+    try {
+      this._frameTickSignal._writeInBoundary(e);
+    } catch (t) {
+      throw this._failWrite(t);
+    }
+    this._exitWrite();
+  }
+  _attachWritableComputed(e, t, s) {
+    let i = t;
+    this._own(() => {
+      i = void 0;
+    }, s);
+    const o = e;
+    return o.set = (r) => {
+      s._assertAlive(), this._assertWriteAllowed(), this._runWrite(() => i(r));
+    }, o;
+  }
+  _own(e, t) {
+    try {
+      return t._adoptResource(e);
+    } catch (s) {
+      try {
+        e();
+      } catch (i) {
+        throw new AggregateError([s, i], "[Raph] Resource registration and cleanup failed.");
+      }
+      throw s;
+    }
+  }
+  _runTracked(e, t) {
+    return this._reactivity.runWithOwner(this._signalLifecycle, e, t);
+  }
+  _runUntracked(e) {
+    return this._reactivity.untrackedWithOwner(e);
+  }
+  _runWrite(e, t = !0) {
+    t && this.configuration.scheduler === f.Sync && (this._executionRequested = !0), this._mutationDepth++;
+    let s, i, o = !1;
+    try {
+      s = e();
+    } catch (c) {
+      o = !0, i = c;
+    }
+    if (this._mutationDepth--, this._executionBoundaryOpen()) {
+      if (o)
+        throw i;
+      return s;
+    }
+    const r = this._finishExecutionBoundary();
+    if (o)
+      throw r !== void 0 ? new AggregateError(
+        [i, ...r],
+        "[Raph] Mutation and scheduled phase execution failed."
+      ) : i;
+    return r !== void 0 && R(r, "[Raph] Mutation phase execution failed."), s;
+  }
+  /** @internal */
+  _isWriteBatchOpen() {
+    return this._batchDepth !== 0 && this._reactivity._isBatching();
+  }
+  // Raph Top-1: граница записи сама не запрашивает flush. Работу, поставленную
+  // внутри неё, запрос отмечает через _deferSync pipeline; при закрытии внешней
+  // границы flush выполняется только если у pipeline есть ожидающая работа.
+  // Запись внутри batch, action или другой открытой границы проверяет ожидающую
+  // работу при своём закрытии: внешняя граница, закрываясь, доставляет и
+  // отложенные через defer() задачи, поставленные до этой записи.
+  _enterWrite() {
+    this._mutationDepth++;
+  }
+  _exitWrite() {
+    if (this._mutationDepth--, this._requestPendingExecution(), this._executionBoundaryOpen())
+      return;
+    const e = this._finishExecutionBoundary();
+    e !== void 0 && R(e, "[Raph] Mutation phase execution failed.");
+  }
+  _failWrite(e) {
+    if (this._mutationDepth--, this._requestPendingExecution(), this._executionBoundaryOpen())
+      return e;
+    const t = this._finishExecutionBoundary();
+    return t === void 0 ? e : new AggregateError(
+      [e, ...t],
+      "[Raph] Mutation and scheduled phase execution failed."
+    );
+  }
+  _requestPendingExecution() {
+    !this._executionRequested && this.configuration.scheduler === f.Sync && this._phases?._hasPendingWork() === !0 && (this._executionRequested = !0);
+  }
+  _executionBoundaryOpen() {
+    return this._mutationDepth !== 0 || this._batchDepth !== 0 || this._kernelBatchDepth !== 0 || this._ownerDisposalDepth !== 0;
+  }
+  _finishExecutionBoundary() {
+    let e;
+    try {
+      this._clearTransientCausesIfSettled();
+    } catch (t) {
+      e = [t];
+    }
+    try {
+      this._requestExecution();
+    } catch (t) {
+      e === void 0 ? e = [t] : e.push(t);
+    }
+    return e;
+  }
+  _clearTransientCausesIfSettled() {
+    this._mutationDepth === 0 && this._batchDepth === 0 && this._kernelBatchDepth === 0 && this._ownerDisposalDepth === 0 && !this._reactivity._isFlushingEffects() && this._workGraph.clearTransientCauses();
+  }
+  _requestExecution() {
+    this._disposed || this.configuration.scheduler !== f.Sync || this._mutationDepth !== 0 || this._batchDepth !== 0 || this._kernelBatchDepth !== 0 || this._ownerDisposalDepth !== 0 || this._reactivity._isFlushingEffects() || this._executionRequested && (this._executionRequested = !1, this._phases?.flush());
+  }
+  /** @internal */
+  _applyObjectReadPolicy(e) {
+    this._disposed || this._checkedObjectPolicy === void 0 || this._reactiveObjects?.configure(this._reactivity, e ? this._checkedObjectPolicy : this._fastObjectPolicy);
+  }
+  _assertTrackedRead() {
+    this._assertAlive();
+    const e = this._reactivity.getActiveOwner();
+    if (e !== void 0 && e !== this && this._throwCrossRuntime(e), e === void 0) {
+      const t = this._reactivity.getActiveConsumerOwner();
+      if (t !== void 0 && t.runtime !== this)
+        throw new g("[Raph] Implicit dependency crosses runtime boundaries.");
+    }
+  }
+  _assertSourceReadable(e) {
+    this._assertAlive();
+    const t = this._reactivity.getActiveOwner();
+    t !== void 0 && t !== this && this._throwCrossRuntime(t);
+    const s = this._reactivity.getActiveConsumerOwner();
+    s !== void 0 && this._assertImplicitDependency(e, s), e._assertAlive();
+  }
+  _assertImplicitDependency(e, t) {
+    if (e.runtime !== this || t.runtime !== this)
+      throw new g("[Raph] Implicit dependency crosses runtime boundaries.");
+    if (!(e === this.rootScope || e === t) && !(e._isNode && t._isNode && t._hasAncestor(e)))
+      throw new Error(
+        `[Raph] Implicit dependency from "${t.id}" to "${e.id}" is not allowed; use watch().`
+      );
+  }
+  _assertWriteAllowed() {
+    if (this._assertAlive(), this.configuration.enforceActions && this._batchDepth === 0)
+      throw new L("[Raph] Writes are allowed only inside action() or batch().");
+  }
+  _throwCrossRuntime(e) {
+    throw new g(
+      `[Raph] Runtime "${this.id}" cannot be tracked by runtime "${e.id}".`
+    );
+  }
+  _assertAlive() {
+    if (this._disposed)
+      throw new O(`[Raph] Runtime "${this.id}" is disposed.`);
+  }
+  _runDataBatch(e) {
+    return e();
+  }
+  _disposeDataSources(e) {
+  }
+  _detachDataPlane(e) {
+  }
+}
+function ee(_) {
+  let e = _;
+  return () => {
+    const t = e;
+    t !== void 0 && (e = void 0, t.dispose());
+  };
+}
+function te(_) {
+  return () => {
+    _.record?.dispose();
+  };
+}
+function q() {
+}
+function se(_, e) {
+  return e._order - _._order;
+}
+function ie(_) {
+  return _ === f.Sync || _ === f.Microtask || _ === f.AnimationFrame;
+}
+function E(_) {
+  return _ instanceof Error ? _.message : String(_);
+}
+export {
+  W as RaphRuntimeBase,
+  ve as resolveRuntimeConfiguration
+};