@raphy-js/raph 1.0.0-dev.2

package/dist/debug/runtime/RaphRuntime.js

@@ -0,0 +1,700 @@
+var W = Object.defineProperty;
+var b = (a, t, e) => t in a ? W(a, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : a[t] = e;
+var h = (a, t, e) => b(a, typeof t != "symbol" ? t + "" : t, e);
+import { RaphDisposedError as R, RaphCrossRuntimeError as k, RaphActionError as T } from "./errors.js";
+import { parentGraph as x } from "./parent-graph.js";
+import { PathHandle as L } from "./PathHandle.js";
+import { RaphSchedulerType as d } from "./phase.types.js";
+import { RaphNode as m } from "./RaphNode.js";
+import { parseDataPath as q, DataPath as A } from "../path/data-path.js";
+import { RaphKernel as O } from "../path/RaphKernel.js";
+import { RaphMeta as M } from "../path/RaphMeta.js";
+import { watchWithReactivity as $ } from "../reactivity/watch.js";
+import { throwDisposalErrors as D } from "./disposal.js";
+import { createOwnerSnapshot as y } from "./RaphDebug.js";
+import { RaphFrameLoop as H } from "./RaphFrameLoop.js";
+import { RaphPhasePipeline as F } from "./RaphPhasePipeline.js";
+import { RaphScope as S } from "./RaphScope.js";
+import { RuntimeReactivity as U } from "./RuntimeReactivity.js";
+import { RuntimeWatch as g } from "./RuntimeWatch.js";
+const v = class v {
+  /**
+   * Создаёт изолированный execution graph поверх собственного или shared Kernel.
+   */
+  constructor(t = {}) {
+    // Публикуют immutable configuration и корневых lifecycle owners.
+    h(this, "configuration");
+    h(this, "rootScope");
+    h(this, "root");
+    // Владеют изолированным reactive graph и его runtime policy.
+    h(this, "_reactivity");
+    h(this, "_signalLifecycle");
+    // Лениво создают adapters и diagnostics только по запросу consumer.
+    h(this, "_pathHandles");
+    h(this, "_meta");
+    h(this, "_phases");
+    h(this, "_frameLoop");
+    h(this, "_frameRevision");
+    h(this, "_frameRevisionValue", !1);
+    h(this, "_debug");
+    h(this, "_parentGraph");
+    // Регистрируют всех lifecycle owners runtime.
+    h(this, "_owners", /* @__PURE__ */ new Set());
+    // Координируют вложенные write boundaries и execution requests.
+    h(this, "_transactionDepth", 0);
+    h(this, "_mutationDepth", 0);
+    h(this, "_kernelTransactionDepth", 0);
+    h(this, "_actionDepth", 0);
+    h(this, "_executionRequested", !1);
+    // Хранят окончательное состояние runtime и dispose listeners.
+    h(this, "_disposed", !1);
+    h(this, "_disposedListeners", /* @__PURE__ */ new Set());
+    const e = t.id ?? `runtime-${v._runtimeCounter++}`, s = t.enforceActions ?? !1, i = t.scheduler ?? d.Sync;
+    if (!I(i))
+      throw new Error(`[Raph] Unsupported scheduler "${String(i)}".`);
+    const r = t.kernel ?? new O({ id: `${e}-kernel` });
+    this.configuration = Object.freeze({ id: e, kernel: r, enforceActions: s, scheduler: i });
+    const o = `[Raph] Runtime "${e}" is disposed.`;
+    this._signalLifecycle = {
+      owner: this,
+      runWrite: (n) => this._runWrite(n),
+      ...s ? { assertWriteAllowed: () => this._assertWriteAllowed() } : {},
+      throwDisposed: () => {
+        throw new R(o);
+      },
+      throwCrossRuntime: (n) => this._throwCrossRuntime(n)
+    }, this._reactivity = new U(this._signalLifecycle), r._attachRuntime(this), this.rootScope = new S(`${e}:root-scope`, this), this.root = new m(null, { id: `${e}:root` }, this);
+  }
+  /**
+   * Возвращает внутренний runtime reactivity adapter.
+   * @internal
+   */
+  _getReactivity() {
+    return this._reactivity;
+  }
+  /**
+   * Возвращает стабильный идентификатор runtime.
+   */
+  get id() {
+    return this.configuration.id;
+  }
+  /**
+   * Возвращает data/meta Kernel этого runtime.
+   */
+  get kernel() {
+    return this.configuration.kernel;
+  }
+  /**
+   * Возвращает лениво созданный runtime-owned metadata facade.
+   */
+  get meta() {
+    return this._assertAlive(), this._meta ?? (this._meta = new M(this.kernel, {
+      assertReadable: () => this._assertAlive(),
+      assertWritable: () => this._assertWriteAllowed(),
+      runWrite: (t, e) => this._runWrite(t, e),
+      watch: (t, e, s) => this._own(
+        this._watchMeta(t, e, s),
+        this.rootScope
+      )
+    }));
+  }
+  /**
+   * Показывает, освобождён ли runtime.
+   */
+  get disposed() {
+    return this._disposed;
+  }
+  /**
+   * Возвращает лениво созданное read-only представление ownership graph.
+   */
+  get graph() {
+    return this._parentGraph ?? (this._parentGraph = x());
+  }
+  /**
+   * Показывает, удерживается ли автоматический frame-loop.
+   */
+  get loopEnabled() {
+    var t;
+    return ((t = this._frameLoop) == null ? void 0 : t.running) ?? !1;
+  }
+  /**
+   * Возвращает последний frame context runtime pipeline.
+   */
+  get frame() {
+    var t;
+    return ((t = this._phases) == null ? void 0 : t.frame) ?? { now: 0, delta: 0, elapsed: 0, frame: 0 };
+  }
+  /**
+   * Возвращает текущее определение runtime phases.
+   */
+  get phases() {
+    var t;
+    return ((t = this._phases) == null ? void 0 : t.phases) ?? [];
+  }
+  /**
+   * Формирует диагностический снимок materialized derived registry.
+   */
+  getDerivedSnapshot() {
+    return this.kernel.getDerivedSnapshot();
+  }
+  /**
+   * Возвращает лениво созданную read-only диагностику runtime и ownership tree.
+   */
+  get debug() {
+    return this._debug ?? (this._debug = Object.freeze({
+      snapshot: () => this._createDebugSnapshot(),
+      getTree: () => y(this.root)
+    }));
+  }
+  /**
+   * Создаёт writable signal, принадлежащий указанному owner.
+   */
+  signal(t, e = this.rootScope) {
+    return this._assertOwnerRuntime(e), this._reactivity.signalForOwner(t, e);
+  }
+  computed(t, e = this.rootScope) {
+    this._assertOwnerRuntime(e);
+    const s = typeof t == "function" ? t : t.get, i = this._reactivity.computedForOwner(
+      () => this._runTracked(s),
+      e
+    );
+    return typeof t == "function" ? i : this._attachWritableComputed(i, t.set, e);
+  }
+  effect(t, e, s = {}, i = this.rootScope) {
+    const r = typeof t == "string" ? e : t, o = typeof t == "string" ? i : e ?? this.rootScope;
+    if (this._assertOwnerRuntime(o), typeof t == "string") {
+      const n = t.trim(), c = this._execution;
+      c.requirePhase(n);
+      const p = s.priority ?? 0, u = s.initial ?? "scheduled";
+      if (!Number.isFinite(p))
+        throw new TypeError("[Raph] Effect priority must be finite.");
+      if (u !== "scheduled" && u !== "sync")
+        throw new TypeError(`[Raph] Unsupported effect initial mode "${String(u)}".`);
+      u === "sync" && c.lockConfiguration();
+      const l = c.phaseMode(n) === "always" ? this._frameRevision ?? (this._frameRevision = this._reactivity.signal(!1)) : void 0, w = this._reactivity.withEffectBinding(
+        (_) => c.bindEffect(
+          n,
+          p,
+          _,
+          o instanceof m ? o : void 0
+        ),
+        u,
+        () => this._reactivity.effect(() => (l == null || l.get(), this._runTracked(r)))
+      );
+      return this._own(w, o);
+    }
+    return this._own(
+      this._reactivity._effectImmediate(() => this._runTracked(r)),
+      o
+    );
+  }
+  watch(t, e, s = {}, i = this.rootScope) {
+    return this._assertOwnerRuntime(i), z(t) ? this._own(this._watchPath(t, e), i) : this._own(
+      $(
+        this._reactivity._effectImmediate,
+        this._reactivity.untracked,
+        t,
+        e,
+        s,
+        (r) => this._runTracked(r)
+      ),
+      i
+    );
+  }
+  /**
+   * Возвращает кешируемый runtime-owned handle canonical path.
+   */
+  path(t, e = {}) {
+    this._assertAlive();
+    const s = q(t, e), i = this._pathHandles ?? (this._pathHandles = /* @__PURE__ */ new Map()), r = i.get(s.canonical);
+    if (r !== void 0)
+      return r;
+    const o = new L(
+      this.kernel,
+      s,
+      e,
+      (n) => this._releasePathHandle(n),
+      this._reactivity,
+      () => this._assertAlive(),
+      () => this._assertTrackedRead(),
+      this.configuration.enforceActions ? () => this._assertWriteAllowed() : void 0,
+      (n) => this._runWrite(n)
+    );
+    return i.set(s.canonical, o), o;
+  }
+  get(t, e) {
+    this._assertTrackedRead();
+    const s = t ?? "";
+    return this._reactivity._isTracking() ? this.path(s, e)._getTracked() : this.kernel.get(s, e);
+  }
+  peek(t, e) {
+    return this._assertAlive(), this.kernel.peek(t ?? "", e);
+  }
+  /**
+   * Проверяет наличие значения Kernel по пути.
+   */
+  has(t, e) {
+    return this._assertAlive(), this.kernel.has(t, e);
+  }
+  /**
+   * Записывает значение Kernel внутри runtime write policy.
+   */
+  set(t, e, s) {
+    this._assertWriteAllowed(), this._runWrite(() => this.kernel.set(t, e, s));
+  }
+  /**
+   * Объединяет значение Kernel внутри runtime write policy.
+   */
+  merge(t, e, s) {
+    this._assertWriteAllowed(), this._runWrite(() => this.kernel.merge(t, e, s));
+  }
+  /**
+   * Удаляет значение Kernel внутри runtime write policy.
+   */
+  delete(t, e) {
+    this._assertWriteAllowed(), this._runWrite(() => this.kernel.delete(t, e));
+  }
+  /**
+   * Выполняет операцию в общей синхронной transaction boundary.
+   */
+  transaction(t) {
+    this._assertAlive(), this._transactionDepth++;
+    try {
+      return this._reactivity.batch(() => this.kernel.transaction(t));
+    } finally {
+      this._transactionDepth--, this._requestExecution();
+    }
+  }
+  /**
+   * Создаёт именованную action boundary для разрешённых записей.
+   */
+  action(t, e, s = this.rootScope) {
+    if (this._assertOwnerRuntime(s), !t.trim())
+      throw new Error("[Raph] Action name must not be empty.");
+    return (...i) => (s._assertAlive(), this.runInAction(t, () => e(...i)));
+  }
+  /**
+   * Выполняет операцию внутри action boundary.
+   */
+  runInAction(t, e) {
+    this._assertAlive(), this._actionDepth++;
+    try {
+      return this.transaction(() => this._runUntracked(e));
+    } finally {
+      this._actionDepth--;
+    }
+  }
+  /**
+   * Выполняет операцию без регистрации реактивных зависимостей.
+   */
+  untracked(t) {
+    return this._assertAlive(), this._reactivity.untrackedWithOwner(t);
+  }
+  /**
+   * Создаёт дочерний lifecycle scope.
+   */
+  scope(t) {
+    return this._assertAlive(), new S(t, this);
+  }
+  /**
+   * Создаёт дочерний execution node.
+   */
+  node(t, e) {
+    this._assertAlive();
+    const s = t.parent ?? this.root, i = new m(s, t, this);
+    try {
+      return i._setApi(e(i)), i;
+    } catch (r) {
+      try {
+        i.dispose();
+      } catch (o) {
+        throw new AggregateError(
+          [r, o],
+          `[Raph] Node "${i.id}" setup and cleanup failed.`
+        );
+      }
+      throw r;
+    }
+  }
+  /**
+   * Находит принадлежащий runtime node по id для диагностики.
+   */
+  getNode(t) {
+    this._assertAlive();
+    const e = [this.root];
+    for (; e.length !== 0; ) {
+      const s = e.pop();
+      if (s.id === t)
+        return s;
+      e.push(...s.children);
+    }
+  }
+  /**
+   * Заменяет полное определение phase pipeline до его первого выполнения.
+   */
+  definePhases(t) {
+    this._execution.definePhases(t);
+  }
+  /**
+   * Добавляет phase до первого выполнения pipeline.
+   */
+  addPhase(t) {
+    this._execution.addPhase(t);
+  }
+  /**
+   * Удаляет пользовательские phases до первого выполнения pipeline.
+   */
+  clearPhases() {
+    var t;
+    this._assertAlive(), (t = this._phases) == null || t.clearPhases();
+  }
+  /**
+   * Регистрирует path observer в phase pipeline.
+   */
+  observeData(t, e, s) {
+    return this._assertOwnerRuntime(t), this._own(this._execution.observeData(t, e, s), t);
+  }
+  /**
+   * Регистрирует tracked executor указанной phase.
+   */
+  track(t, e, s = {}) {
+    return this._assertOwnerRuntime(t), this._own(this._execution.track(t, e, s), t);
+  }
+  /**
+   * Помечает node для выполнения в pipeline.
+   */
+  invalidateNode(t, e) {
+    this._assertOwnerRuntime(t), this._execution.invalidate(t, e);
+  }
+  /**
+   * Синхронно выполняет все готовые очереди pipeline.
+   */
+  flush() {
+    var t;
+    this._assertAlive(), this._executionRequested = !1, (t = this._phases) == null || t.flush();
+  }
+  /**
+   * Получает lease автоматического frame-loop.
+   */
+  acquireLoop(t) {
+    return this._assertAlive(), this._clock.acquire(t);
+  }
+  /**
+   * Запускает manual lease автоматического frame-loop.
+   */
+  startLoop() {
+    this._assertAlive(), this._clock.start();
+  }
+  /**
+   * Останавливает manual lease автоматического frame-loop.
+   */
+  stopLoop() {
+    var t;
+    (t = this._frameLoop) == null || t.stop();
+  }
+  /**
+   * Создаёт управляемое derived-представление source path в target path.
+   */
+  derive(t) {
+    this._assertAlive();
+    const e = t.compute, s = this.kernel.derive({
+      ...t,
+      compute: (i) => this._runUntracked(() => e(i))
+    });
+    return this._own(() => s.dispose(), this.rootScope), s;
+  }
+  /**
+   * Освобождает execution graph и отсоединяет runtime от shared Kernel.
+   */
+  dispose() {
+    var r, o;
+    if (this._disposed)
+      return;
+    this._disposed = !0, this._executionRequested = !1, this._signalLifecycle.owner = void 0;
+    const t = [], e = [...this._owners];
+    try {
+      (r = this._frameLoop) == null || r.dispose();
+    } catch (n) {
+      t.push(n);
+    }
+    this._frameLoop = void 0;
+    try {
+      (o = this._phases) == null || o.dispose();
+    } catch (n) {
+      t.push(n);
+    }
+    this._phases = void 0;
+    try {
+      this.root.dispose();
+    } catch (n) {
+      t.push(n);
+    }
+    for (const n of e.reverse())
+      if (!(n === this.root || n === this.rootScope || n.disposed))
+        try {
+          n.dispose();
+        } catch (c) {
+          t.push(c);
+        }
+    try {
+      this.rootScope.dispose();
+    } catch (n) {
+      t.push(n);
+    }
+    this._owners.clear(), this._meta = void 0, this._frameRevision = void 0;
+    const s = this._pathHandles;
+    if (this._pathHandles = void 0, s !== void 0) {
+      for (const n of s.values())
+        try {
+          n.dispose();
+        } catch (c) {
+          t.push(c);
+        }
+      s.clear();
+    }
+    try {
+      this.kernel._detachRuntime(this);
+    } catch (n) {
+      t.push(n);
+    }
+    const i = [...this._disposedListeners];
+    this._disposedListeners.clear();
+    for (const n of i)
+      try {
+        n();
+      } catch (c) {
+        t.push(c);
+      }
+    D(t, `[Raph] Runtime "${this.id}" disposal failed.`);
+  }
+  /**
+   * Регистрирует listener освобождения runtime.
+   * @internal
+   */
+  _onDisposed(t) {
+    return this._disposed ? (t(), () => {
+    }) : (this._disposedListeners.add(t), () => {
+      this._disposedListeners.delete(t);
+    });
+  }
+  _watchPath(t, e) {
+    const s = new g((r) => this._runUntracked(r)), i = this.kernel.watch(t, (r) => {
+      s.deliver(() => e(r));
+    });
+    return () => s.stop(i);
+  }
+  _createDebugSnapshot() {
+    var s, i, r;
+    const t = ((s = this._frameLoop) == null ? void 0 : s._debugState()) ?? { running: !1, manual: !1, leases: 0 }, e = [...this._owners].filter((o) => o !== this.rootScope && !(o instanceof m)).map(y);
+    return Object.freeze({
+      id: this.id,
+      disposed: this._disposed,
+      pending: !this._disposed && (this._executionRequested || (((i = this._phases) == null ? void 0 : i._debugPending()) ?? !1)),
+      transactionDepth: this._transactionDepth,
+      kernelTransactionDepth: this._kernelTransactionDepth,
+      owners: this._owners.size,
+      pathHandles: ((r = this._pathHandles) == null ? void 0 : r.size) ?? 0,
+      rootScope: y(this.rootScope),
+      scopes: Object.freeze(e),
+      root: y(this.root),
+      frameLoop: Object.freeze(t)
+    });
+  }
+  _watchMeta(t, e, s) {
+    if (s.phase !== void 0)
+      return this._watchMetaInPhase(t, e, s);
+    if (s.priority !== void 0)
+      throw new TypeError("[RaphMeta] watch priority requires a phase.");
+    const i = new g((o) => this._runUntracked(o)), r = this.kernel._watchMeta(t, (o) => {
+      i.deliver(() => e(o));
+    }, s);
+    return () => i.stop(r);
+  }
+  _watchMetaInPhase(t, e, s) {
+    const i = s.phase.trim(), r = this._execution;
+    r.requirePhase(i);
+    const o = s.priority ?? 0;
+    if (!Number.isFinite(o))
+      throw new TypeError("[RaphMeta] watch priority must be finite.");
+    const n = r.retainPhase(i), c = new g((_) => this._runUntracked(_));
+    let p = [], u;
+    const l = () => {
+      u = void 0;
+      const _ = p;
+      p = [], c.deliver(() => e({ events: _ }));
+    };
+    let w;
+    try {
+      w = this.kernel._watchMeta(t, ({ events: _ }) => {
+        c.stopped || (p.push(..._), u === void 0 && (u = r.queueEffect(i, o, l, !1)));
+      }, s, (_) => {
+        !c.stopped && _ && u !== void 0 && r.request();
+      });
+    } catch (_) {
+      throw n(), _;
+    }
+    return () => {
+      if (c.stopped)
+        return;
+      const _ = [];
+      try {
+        c.stop(w);
+      } catch (f) {
+        _.push(f);
+      }
+      try {
+        u == null || u();
+      } catch (f) {
+        _.push(f);
+      }
+      try {
+        n();
+      } catch (f) {
+        _.push(f);
+      }
+      u = void 0, p = [], D(_, "[RaphMeta] Phase watch disposal failed.");
+    };
+  }
+  _releasePathHandle(t) {
+    const e = this._pathHandles;
+    (e == null ? void 0 : e.get(t.path)) === t && (e.delete(t.path), e.size === 0 && (this._pathHandles = void 0));
+  }
+  get _execution() {
+    return this._assertAlive(), this._phases ?? (this._phases = new F(
+      this.kernel,
+      this.root,
+      this.configuration.scheduler,
+      (t) => this._runUntracked(t),
+      () => {
+        const t = this._mutationDepth !== 0 || this._transactionDepth !== 0 || this._kernelTransactionDepth !== 0 || this._reactivity._isFlushingEffects();
+        return t && this.configuration.scheduler === d.Sync && (this._executionRequested = !0), t;
+      }
+    ));
+  }
+  get _clock() {
+    return this._frameLoop ?? (this._frameLoop = new H(() => this._tickFrameLoop()));
+  }
+  _tickFrameLoop() {
+    var t;
+    this._disposed || (this._frameRevision !== void 0 && (this._frameRevisionValue = !this._frameRevisionValue, this._frameRevision.set(this._frameRevisionValue)), (t = this._phases) == null || t.requestAlwaysPhases(), this._requestExecution());
+  }
+  _attachWritableComputed(t, e, s) {
+    let i = e;
+    this._own(() => {
+      i = void 0;
+    }, s);
+    const r = t;
+    return r.set = (o) => {
+      s._assertAlive(), this._assertWriteAllowed(), i(o);
+    }, r;
+  }
+  _own(t, e) {
+    try {
+      return e._adoptResource(t);
+    } catch (s) {
+      try {
+        t();
+      } catch (i) {
+        throw new AggregateError(
+          [s, i],
+          "[Raph] Resource registration and cleanup failed."
+        );
+      }
+      throw s;
+    }
+  }
+  /**
+   * Регистрирует lifecycle owner в runtime registry.
+   * @internal
+   */
+  _registerOwner(t) {
+    this._assertAlive(), this._owners.add(t);
+  }
+  /**
+   * Удаляет lifecycle owner из runtime registry.
+   * @internal
+   */
+  _unregisterOwner(t) {
+    this._owners.delete(t);
+  }
+  /**
+   * Проверяет, что owner принадлежит этому живому runtime.
+   * @internal
+   */
+  _assertOwnerRuntime(t) {
+    if (this._assertAlive(), t.runtime !== this)
+      throw new k("[Raph] Owner belongs to another runtime.");
+    t._assertAlive();
+  }
+  _runTracked(t) {
+    return this._reactivity.runWithOwner(this._signalLifecycle, t);
+  }
+  _runUntracked(t) {
+    return this._reactivity.untrackedWithOwner(t);
+  }
+  _runWrite(t, e = !0) {
+    e && this.configuration.scheduler === d.Sync && (this._executionRequested = !0), this._mutationDepth++;
+    try {
+      return t();
+    } finally {
+      this._mutationDepth--, this._requestExecution();
+    }
+  }
+  _requestExecution() {
+    var t;
+    this.configuration.scheduler !== d.Sync || this._mutationDepth !== 0 || this._transactionDepth !== 0 || this._kernelTransactionDepth !== 0 || this._reactivity._isFlushingEffects() || this._executionRequested && (this._executionRequested = !1, (t = this._phases) == null || t.flush());
+  }
+  /**
+   * Открывает shared Kernel transaction для runtime.
+   * @internal
+   */
+  _beginKernelTransaction() {
+    this._disposed || this._kernelTransactionDepth++;
+  }
+  /**
+   * Закрывает shared Kernel transaction и запускает отложенное выполнение.
+   * @internal
+   */
+  _endKernelTransaction() {
+    this._kernelTransactionDepth !== 0 && (this._kernelTransactionDepth--, this._disposed || this._requestExecution());
+  }
+  _assertTrackedRead() {
+    this._assertAlive();
+    const t = this._reactivity.getActiveOwner();
+    t !== void 0 && t !== this && this._throwCrossRuntime(t);
+  }
+  _assertWriteAllowed() {
+    if (this._assertAlive(), this.configuration.enforceActions && this._actionDepth === 0 && this._transactionDepth === 0)
+      throw new T(
+        "[Raph] Writes are allowed only inside action() or transaction()."
+      );
+  }
+  _throwCrossRuntime(t) {
+    throw new k(
+      `[Raph] Runtime "${this.id}" cannot be tracked by runtime "${t.id}".`
+    );
+  }
+  _throwDisposed() {
+    throw new R(`[Raph] Runtime "${this.id}" is disposed.`);
+  }
+  _assertAlive() {
+    this._disposed && this._throwDisposed();
+  }
+};
+// Формирует локальный id для runtime без явно заданного имени.
+h(v, "_runtimeCounter", 0);
+let P = v;
+function z(a) {
+  return typeof a == "string" || a instanceof A || E(a) ? !0 : Array.isArray(a) && a.every(
+    (t) => typeof t == "string" || t instanceof A || E(t)
+  );
+}
+function E(a) {
+  return typeof a == "object" && a !== null && "segs" in a && a.segs !== void 0 && Array.isArray(a.segs);
+}
+function I(a) {
+  return a === d.Sync || a === d.Microtask || a === d.AnimationFrame;
+}
+export {
+  P as RaphRuntime
+};

package/dist/debug/runtime/RaphScope.cjs

@@ -0,0 +1 @@
+"use strict";var n=Object.defineProperty;var o=(s,i,t)=>i in s?n(s,i,{enumerable:!0,configurable:!0,writable:!0,value:t}):s[i]=t;var h=(s,i,t)=>o(s,typeof i!="symbol"?i+"":i,t);Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const u=require("../reactivity/scope.cjs"),c=require("./errors.cjs");class d extends u.ScopeNode{constructor(t,e){super(e._getReactivity());h(this,"id");h(this,"runtime");this.id=t,this.runtime=e,e._registerOwner(this)}signal(t){return this._assertAlive(),this.runtime.signal(t,this)}computed(t){return this._assertAlive(),typeof t=="function"?this.runtime.computed(t,this):this.runtime.computed(t,this)}effect(t,e,r){return this._assertAlive(),typeof t=="string"?this.runtime.effect(t,e,r,this):this.runtime.effect(t,this)}watch(t,e,r){return this._assertAlive(),this.runtime.watch(t,e,r,this)}action(t,e){return this._assertAlive(),this.runtime.action(t,e,this)}_afterDispose(){this.runtime._unregisterOwner(this)}_disposalMessage(){return`[Raph] Scope "${this.id}" disposal failed.`}_assertAlive(){if(this._disposed||this._disposing)throw new c.RaphDisposedError(`[Raph] Owner "${this.id}" is disposed.`)}}exports.RaphScope=d;