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

package/dist/debug/api/Raph.js

@@ -1,419 +1,420 @@
-var g = Object.defineProperty;
-var w = (u, t, e) => t in u ? g(u, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : u[t] = e;
-var r = (u, t, e) => w(u, typeof t != "symbol" ? t + "" : t, e);
-import "../path/data-adapter.js";
-import "../path/data-path.js";
-import { filterByKey as R, collectionByKey as p, full as v } from "../path/derived-strategies.js";
-import "../path/RaphDerivedHandle.js";
-import { RaphKernel as o } from "../path/RaphKernel.js";
-import "../path/RaphMeta.js";
-import "../runtime/errors.js";
-import "../runtime/parent-graph.js";
-import "../runtime/PathHandle.js";
-import { RaphSchedulerType as c } from "../runtime/phase.types.js";
-import "../runtime/RaphNode.js";
-import { RaphRuntime as d } from "../runtime/RaphRuntime.js";
-import "../runtime/RaphScope.js";
-import { RaphConfigurationError as a, RaphModeError as f, RaphDefaultRuntimeError as l } from "./errors.js";
-import { RaphReactivity as D } from "../reactivity/engine.js";
-function n() {
-  throw new a(
-    "[Raph] Facade is not configured. Call Raph.configure({ mode }) first."
-  );
-}
-class s {
-  /**
-   * Показывает, завершена ли явная конфигурация facade.
-   */
-  static get configured() {
-    return this._state === "configured";
+import { filterByKey as h, collectionByKey as _, full as d } from "../path/derived/derived-strategy.utils.js";
+import { RaphSchedulerType as f } from "../runtime/phases/phase.types.js";
+import { RaphRuntime as p } from "../runtime/RaphRuntime.js";
+import { RaphConfigurationError as c, RaphCapabilityError as n } from "./errors.js";
+import { RaphFacadeSession as m } from "./RaphFacadeSession.js";
+import { RaphReactivityInstance as a } from "./RaphReactivityInstance.js";
+class g {
+  constructor(e) {
+    this._session = e;
   }
-  /**
-   * Возвращает выбранный режим либо `undefined` до конфигурации.
-   */
-  static get mode() {
-    return this._mode;
+  // ---------------------------------------------
+  // PUBLIC API
+  // ---------------------------------------------
+  get configured() {
+    return !0;
   }
-  /**
-   * Однократно выбирает backend и устанавливает публичные операции facade.
-   */
-  static configure(t) {
-    if (this._state !== "unconfigured")
-      throw new a(
-        `[Raph] Cannot configure facade while it is ${this._state}.`
+  get defaultInstanceId() {
+    return this._session.defaultInstanceId;
+  }
+  get kernel() {
+    return this._runtime().kernel;
+  }
+  get meta() {
+    return this._runtime().meta;
+  }
+  get debug() {
+    return this._runtime().debug;
+  }
+  get root() {
+    return this._runtime().root;
+  }
+  get rootScope() {
+    return this._runtime().rootScope;
+  }
+  get frameTick() {
+    return this._runtime().frameTick;
+  }
+  get frame() {
+    return this._runtime().frame;
+  }
+  get phases() {
+    return this._runtime().phases;
+  }
+  get loopEnabled() {
+    return this._runtime().loopEnabled;
+  }
+  instance(e) {
+    return this._session.instance(e);
+  }
+  getInstance(e) {
+    return this._session.getInstance(e);
+  }
+  hasInstance(e) {
+    return this._session.hasInstance(e);
+  }
+  disposeInstance(e) {
+    return this._session.disposeInstance(e);
+  }
+  runtime(e) {
+    return this._session.runtime(e);
+  }
+  reactivity(e) {
+    return this._session.reactivity(e);
+  }
+  createRuntime(e = {}) {
+    return this._session.createRuntime(e);
+  }
+  createReactivity(e = {}) {
+    return this._session.createReactivity(e);
+  }
+  createKernel(e = {}) {
+    return this._session.createKernel(e);
+  }
+  signal(e) {
+    return this._reactive().signal(e);
+  }
+  reactive(e) {
+    return this._reactive().reactive(e);
+  }
+  computed(e) {
+    const t = this._reactive();
+    return t instanceof p, t.computed(e);
+  }
+  effect(e, t, r) {
+    const i = this._session.instance();
+    if (i instanceof a) {
+      if (typeof e != "function" || t !== void 0)
+        throw o("phase effect", i);
+      return i.effect(e);
+    }
+    if (typeof e != "string" || t === void 0)
+      throw new n("[Raph] Runtime effects require an explicit phase.");
+    return i.effect(i.rootScope, e, t, r);
+  }
+  watch(e, t, r, i) {
+    const s = this._session.instance();
+    if (s instanceof a) {
+      if (typeof t != "function")
+        throw o("phase watch", s);
+      return s.watch(
+        e,
+        t,
+        r
       );
-    this._state = "configuring";
-    try {
-      if (this._validateConfigureOptions(t), t.mode === "reactivity")
-        this._configureReactivity(new D());
-      else if (t.mode === "runtime")
-        this._configureRuntime(t);
-      else
-        throw new a("[Raph] Unsupported facade mode.");
-      this._mode = t.mode, this._state = "configured";
-    } catch (e) {
-      const i = [e], h = [...this._runtimeOrder].reverse();
-      this._clearSession();
-      for (const m of h)
-        try {
-          m.dispose();
-        } catch (_) {
-          i.push(_);
-        }
-      throw i.length === 1 ? e : new AggregateError(i, "[Raph] Facade configuration and cleanup failed.");
     }
+    if (typeof t != "string" || typeof r != "function")
+      throw new n("[Raph] Runtime watches require an explicit phase.");
+    return s.watch(
+      s.rootScope,
+      e,
+      t,
+      r,
+      i
+    );
+  }
+  batch(e) {
+    return this._reactive().batch(e);
+  }
+  untracked(e) {
+    return this._reactive().untracked(e);
+  }
+  scope(e) {
+    const t = this._session.instance();
+    if (t instanceof a) {
+      if (e !== void 0)
+        throw o("named Runtime scope", t);
+      return t.scope();
+    }
+    if (e === void 0)
+      throw new n("[Raph] Runtime scopes require an explicit id.");
+    return t.scope(e);
   }
-  /**
-   * Освобождает принадлежащие facade runtimes и возвращает его в исходное состояние.
-   */
-  static reset() {
-    if (this._state === "unconfigured")
-      return;
-    if (this._state !== "configured")
-      throw new a(`[Raph] Cannot reset facade while it is ${this._state}.`);
-    this._state = "resetting";
-    const t = [...this._runtimeOrder].reverse();
-    this._clearBindings(), this._runtimes = /* @__PURE__ */ new Map(), this._runtimeOrder = [], this._defaultRuntime = void 0;
-    const e = [];
-    for (const i of t)
-      try {
-        i.dispose();
-      } catch (h) {
-        e.push(h);
-      }
-    if (this._clearSession(), e.length === 1)
-      throw e[0];
-    if (e.length > 1)
-      throw new AggregateError(e, "[Raph] Facade reset failed.");
+  action(e, t) {
+    return typeof e == "function" ? this._runtime().action(e) : this._runtime().action(e, t);
   }
-  /**
-   * Возвращает default runtime текущей runtime-сессии.
-   */
-  static get runtime() {
-    return this._requireDefault();
+  definePhases(e) {
+    this._runtime().definePhases(e);
+  }
+  addPhase(e) {
+    this._runtime().addPhase(e);
   }
+  clearPhases() {
+    this._runtime().clearPhases();
+  }
+  requestExecution() {
+    this._runtime().requestExecution();
+  }
+  flush() {
+    this._runtime().flush();
+  }
+  afterFlush() {
+    return this._runtime().afterFlush();
+  }
+  acquireLoop(e) {
+    return this._runtime().acquireLoop(e);
+  }
+  startLoop() {
+    this._runtime().startLoop();
+  }
+  stopLoop() {
+    this._runtime().stopLoop();
+  }
+  aggregate(e) {
+    const t = this._runtime();
+    return t.aggregate(t.rootScope, e);
+  }
+  node(e, t) {
+    return this._runtime().node(e, t);
+  }
+  getNode(e) {
+    return this._runtime().getNode(e);
+  }
+  derive(e) {
+    return this._runtime().derive(e);
+  }
+  getDerivedSnapshot() {
+    return this._runtime().getDerivedSnapshot();
+  }
+  path(e, t = {}) {
+    return this._runtime().path(e, t);
+  }
+  get(e, t) {
+    return e === void 0 ? this._runtime().get() : this._runtime().get(e, t);
+  }
+  peek(e, t) {
+    return e === void 0 ? this._runtime().peek() : this._runtime().peek(e, t);
+  }
+  has(e, t) {
+    return this._runtime().has(e, t);
+  }
+  set(e, t, r) {
+    this._runtime().set(e, t, r);
+  }
+  merge(e, t, r) {
+    this._runtime().merge(e, t, r);
+  }
+  delete(e, t) {
+    this._runtime().delete(e, t);
+  }
+  // ---------------------------------------------
+  // INTERNAL
+  // ---------------------------------------------
   /**
-   * Возвращает metadata facade default runtime.
+   * Освобождает точную session generation для global reset.
+   * @internal
    */
+  _dispose() {
+    this._session.dispose();
+  }
+  // ---------------------------------------------
+  // PRIVATE
+  // ---------------------------------------------
+  _runtime() {
+    return this._session.runtime();
+  }
+  _reactive() {
+    return this._session.instance();
+  }
+}
+class I {
+  static _handle;
+  constructor() {
+  }
+  // ---------------------------------------------
+  // PUBLIC API
+  // ---------------------------------------------
+  static get configured() {
+    return this._handle !== void 0;
+  }
+  static get defaultInstanceId() {
+    return this._require().defaultInstanceId;
+  }
+  static get kernel() {
+    return this._require().kernel;
+  }
   static get meta() {
-    return this._requireDefault().meta;
+    return this._require().meta;
   }
-  /**
-   * Возвращает диагностический facade default runtime.
-   */
   static get debug() {
-    return this._requireDefault().debug;
+    return this._require().debug;
   }
-  /**
-   * Возвращает корневой node default runtime.
-   */
   static get root() {
-    return this._requireDefault().root;
+    return this._require().root;
   }
-  /**
-   * Формирует снимок materialized derived default runtime.
-   */
-  static getDerivedSnapshot() {
-    return this._requireDefault().getDerivedSnapshot();
+  static get rootScope() {
+    return this._require().rootScope;
   }
-  /**
-   * Создаёт независимый path/kernel owner в runtime-режиме.
-   */
-  static createKernel(t = {}) {
-    return this._requireMode("runtime"), new o(t);
+  static get frameTick() {
+    return this._require().frameTick;
   }
-  /**
-   * Создаёт и регистрирует принадлежащий facade runtime.
-   */
-  static createRuntime(t = {}) {
-    this._requireMode("runtime");
-    const e = this._resolveRuntimeId(t.id);
-    if (this._runtimes.has(e))
-      throw new a(`[Raph] Runtime id "${e}" is already registered.`);
-    const i = new d({
-      ...this._runtimeDefaults,
-      ...t,
-      id: e
-    });
-    return this._registerRuntime(i), i;
+  static get frame() {
+    return this._require().frame;
   }
-  /**
-   * Возвращает зарегистрированный runtime без ошибки при его отсутствии.
-   */
-  static getRuntime(t) {
-    return this._requireMode("runtime"), this._validateRuntimeId(t), this._runtimes.get(t);
+  static get phases() {
+    return this._require().phases;
   }
-  /**
-   * Возвращает зарегистрированный runtime либо отклоняет неизвестный id.
-   */
-  static requireRuntime(t) {
-    const e = this.getRuntime(t);
-    if (e === void 0)
-      throw new a(`[Raph] Runtime "${t}" is not registered.`);
-    return e;
+  static get loopEnabled() {
+    return this._require().loopEnabled;
   }
-  /**
-   * Проверяет наличие runtime в registry текущей сессии.
-   */
-  static hasRuntime(t) {
-    return this.getRuntime(t) !== void 0;
+  static configure(e) {
+    if (this._handle !== void 0)
+      throw new c("[Raph] Facade is already configured.");
+    const t = new g(m.create(e));
+    return this._handle = t, t;
   }
-  /**
-   * Освобождает зарегистрированный runtime с указанным id.
-   */
-  static disposeRuntime(t) {
-    const e = this.getRuntime(t);
-    return e === void 0 ? !1 : (e.dispose(), !0);
+  static reset() {
+    const e = this._handle;
+    e !== void 0 && (this._handle = void 0, e._dispose());
   }
-  /**
-   * Заменяет phases default runtime до первого выполнения pipeline.
-   */
-  static definePhases(t) {
-    this._requireDefault().definePhases(t);
+  static instance(e) {
+    return this._require().instance(e);
   }
-  /**
-   * Добавляет phase в default runtime до первого выполнения pipeline.
-   */
-  static addPhase(t) {
-    this._requireDefault().addPhase(t);
+  static getInstance(e) {
+    return this._require().getInstance(e);
   }
-  /**
-   * Удаляет phases default runtime до первого выполнения pipeline.
-   */
-  static clearPhases() {
-    this._requireDefault().clearPhases();
+  static hasInstance(e) {
+    return this._require().hasInstance(e);
   }
-  /**
-   * Синхронно выполняет накопленную работу default runtime.
-   */
-  static flush() {
-    this._requireDefault().flush();
+  static disposeInstance(e) {
+    return this._require().disposeInstance(e);
   }
-  /**
-   * Удерживает frame loop активным от имени указанного owner.
-   */
-  static acquireLoop(t) {
-    return this._requireDefault().acquireLoop(t);
+  static runtime(e) {
+    return this._require().runtime(e);
   }
-  /**
-   * Явно запускает frame loop default runtime.
-   */
-  static startLoop() {
-    this._requireDefault().startLoop();
+  static reactivity(e) {
+    return this._require().reactivity(e);
   }
-  /**
-   * Снимает явный запуск frame loop default runtime.
-   */
-  static stopLoop() {
-    this._requireDefault().stopLoop();
+  static createRuntime(e = {}) {
+    return this._require().createRuntime(e);
   }
-  /**
-   * Создаёт принадлежащий default runtime node и выполняет его setup.
-   */
-  static node(t, e) {
-    return this._requireDefault().node(t, e);
+  static createReactivity(e = {}) {
+    return this._require().createReactivity(e);
   }
-  /**
-   * Регистрирует materialized path dependency в default runtime.
-   */
-  static derive(t) {
-    return this._requireDefault().derive(t);
+  static createKernel(e = {}) {
+    return this._require().createKernel(e);
   }
-  /**
-   * Создаёт lifecycle-aware handle указанного data path.
-   */
-  static path(t, e = {}) {
-    return this._requireDefault().path(t, e);
+  static signal(e) {
+    return this._require().signal(e);
   }
-  static get(t, e) {
-    const i = this._requireDefault();
-    return t === void 0 ? i.get() : i.get(t, e);
+  static reactive(e) {
+    return this._require().reactive(e);
   }
-  static peek(t, e) {
-    const i = this._requireDefault();
-    return t === void 0 ? i.peek() : i.peek(t, e);
+  static computed(e) {
+    return typeof e == "function" ? this._require().computed(e) : this._require().computed(e);
   }
-  /**
-   * Проверяет наличие значения по указанному path.
-   */
-  static has(t, e) {
-    return this._requireDefault().has(t, e);
+  static effect(e, t, r) {
+    return typeof e == "function" ? this._require().effect(e) : this._require().effect(e, t, r);
   }
-  /**
-   * Заменяет значение по указанному path.
-   */
-  static set(t, e, i) {
-    this._requireDefault().set(t, e, i);
+  static watch(e, t, r, i) {
+    const s = this._require();
+    return typeof t == "string" ? s.watch(
+      e,
+      t,
+      r,
+      i
+    ) : s.watch(
+      e,
+      t,
+      r
+    );
   }
-  /**
-   * Объединяет значение с существующим объектом по указанному path.
-   */
-  static merge(t, e, i) {
-    this._requireDefault().merge(t, e, i);
+  static batch(e) {
+    return this._require().batch(e);
   }
-  /**
-   * Удаляет значение по указанному path.
-   */
-  static delete(t, e) {
-    this._requireDefault().delete(t, e);
+  static untracked(e) {
+    return this._require().untracked(e);
   }
-  /**
-   * Выполняет несколько mutations как одну реактивную транзакцию.
-   */
-  static transaction(t) {
-    return this._requireDefault().transaction(t);
+  static scope(e) {
+    return e === void 0 ? this._require().scope() : this._require().scope(e);
   }
-  /**
-   * Оборачивает операцию в именованную action текущего runtime.
-   */
-  static action(t, e) {
-    return this._requireDefault().action(t, e);
+  static action(e, t) {
+    return typeof e == "function" ? this._require().action(e) : this._require().action(e, t);
   }
-  /**
-   * Немедленно выполняет именованную action текущего runtime.
-   */
-  static runInAction(t, e) {
-    return this._requireDefault().runInAction(t, e);
-  }
-  static _configureReactivity(t) {
-    this._reactivity = t, this.signal = t.signal, this.computed = t.computed, this.effect = ((e) => {
-      if (typeof e != "function")
-        throw new f("[Raph] Phase effects require runtime mode.");
-      return t.effect(e);
-    }), this.watch = t.watch, this.batch = t.batch, this.untracked = t.untracked, this.scope = t.scope;
-  }
-  static _configureRuntime(t) {
-    if (this._runtimeDefaults = {
-      ...t.scheduler === void 0 ? {} : { scheduler: t.scheduler },
-      ...t.enforceActions === void 0 ? {} : { enforceActions: t.enforceActions }
-    }, t.createDefaultRuntime === !1) {
-      this._installMissingDefaultBindings();
-      return;
-    }
-    const e = t.defaultRuntimeId ?? "default";
-    this._validateRuntimeId(e);
-    const i = new d({
-      ...this._runtimeDefaults,
-      ...t.kernel === void 0 ? {} : { kernel: t.kernel },
-      id: e
-    });
-    this._registerRuntime(i), t.phases !== void 0 && i.definePhases(t.phases), this._defaultRuntime = i, this._bindRuntime(i);
-  }
-  static _bindRuntime(t) {
-    this.signal = t.signal.bind(t), this.computed = t.computed.bind(t), this.effect = t.effect.bind(t), this.watch = t.watch.bind(t), this.batch = t.transaction.bind(t), this.untracked = t.untracked.bind(t), this.scope = t.scope.bind(t);
-  }
-  static _registerRuntime(t) {
-    this._runtimes.set(t.id, t), this._runtimeOrder.push(t), t._onDisposed(() => {
-      this._runtimes.get(t.id) === t && this._runtimes.delete(t.id);
-      const e = this._runtimeOrder.indexOf(t);
-      e >= 0 && this._runtimeOrder.splice(e, 1), this._defaultRuntime === t && (this._defaultRuntime = void 0, this._state === "configured" && this._installMissingDefaultBindings());
-    });
-  }
-  static _requireDefault() {
-    this._requireMode("runtime");
-    const t = this._defaultRuntime;
-    if (t === void 0)
-      throw new l("[Raph] Runtime mode has no default Runtime.");
-    return t;
-  }
-  static _requireMode(t) {
-    if (this._state !== "configured" && n(), this._mode !== t)
-      throw new f(`[Raph] Operation requires ${t} mode.`);
-  }
-  static _resolveRuntimeId(t) {
-    if (t !== void 0)
-      return this._validateRuntimeId(t), t;
-    let e;
-    do
-      e = `runtime-${this._runtimeCounter++}`;
-    while (this._runtimes.has(e));
-    return e;
+  static definePhases(e) {
+    this._require().definePhases(e);
   }
-  static _validateRuntimeId(t) {
-    if (typeof t != "string" || t.length === 0 || t.trim() !== t)
-      throw new a(
-        "[Raph] Runtime id must be a non-empty string without surrounding whitespace."
-      );
+  static addPhase(e) {
+    this._require().addPhase(e);
   }
-  static _validateConfigureOptions(t) {
-    if (typeof t != "object" || t === null)
-      throw new a("[Raph] Configure options must be an object.");
-    if (t.mode === "reactivity") {
-      this._assertKnownOptions(t, /* @__PURE__ */ new Set(["mode"]));
-      return;
-    }
-    if (t.mode !== "runtime")
-      throw new a("[Raph] Unsupported facade mode.");
-    if (this._assertKnownOptions(t, /* @__PURE__ */ new Set([
-      "mode",
-      "createDefaultRuntime",
-      "defaultRuntimeId",
-      "kernel",
-      "phases",
-      "scheduler",
-      "enforceActions"
-    ])), t.createDefaultRuntime !== void 0 && t.createDefaultRuntime !== !0 && t.createDefaultRuntime !== !1)
-      throw new a("[Raph] createDefaultRuntime must be boolean.");
-    if (t.scheduler !== void 0 && !q(t.scheduler))
-      throw new a(
-        `[Raph] Unsupported scheduler "${String(t.scheduler)}".`
-      );
-    if (t.enforceActions !== void 0 && typeof t.enforceActions != "boolean")
-      throw new a("[Raph] enforceActions must be boolean.");
-    if (t.createDefaultRuntime === !1) {
-      if (t.defaultRuntimeId !== void 0 || t.kernel !== void 0 || t.phases !== void 0)
-        throw new a(
-          "[Raph] Registry-only mode cannot receive defaultRuntimeId, kernel or phases."
-        );
-      return;
-    }
-    if (t.defaultRuntimeId !== void 0 && this._validateRuntimeId(t.defaultRuntimeId), t.kernel !== void 0 && !(t.kernel instanceof o))
-      throw new a("[Raph] kernel must be a RaphKernel instance.");
-    if (t.phases !== void 0 && !Array.isArray(t.phases))
-      throw new a("[Raph] phases must be an array.");
+  static clearPhases() {
+    this._require().clearPhases();
   }
-  static _assertKnownOptions(t, e) {
-    for (const i of Object.keys(t))
-      if (!e.has(i))
-        throw new a(`[Raph] Unsupported configure option "${i}".`);
+  static requestExecution() {
+    this._require().requestExecution();
   }
-  static _installMissingDefaultBindings() {
-    const t = () => {
-      throw new l("[Raph] Runtime mode has no default Runtime.");
-    };
-    this.signal = t, this.computed = t, this.effect = t, this.watch = t, this.batch = t, this.untracked = t, this.scope = t;
+  static flush() {
+    this._require().flush();
   }
-  static _clearBindings() {
-    this.signal = n, this.computed = n, this.effect = n, this.watch = n, this.batch = n, this.untracked = n, this.scope = n;
+  static afterFlush() {
+    return this._require().afterFlush();
   }
-  static _clearSession() {
-    this._clearBindings(), this._state = "unconfigured", this._mode = void 0, this._defaultRuntime = void 0, this._reactivity = void 0, this._runtimes = /* @__PURE__ */ new Map(), this._runtimeOrder = [], this._runtimeDefaults = {};
+  static acquireLoop(e) {
+    return this._require().acquireLoop(e);
   }
-  /**
-   * Запрещает создание экземпляров статического facade.
-   */
-  constructor() {
+  static startLoop() {
+    this._require().startLoop();
+  }
+  static stopLoop() {
+    this._require().stopLoop();
+  }
+  static aggregate(e) {
+    return this._require().aggregate(e);
+  }
+  static node(e, t) {
+    return this._require().node(e, t);
+  }
+  static getNode(e) {
+    return this._require().getNode(e);
+  }
+  static derive(e) {
+    return this._require().derive(e);
+  }
+  static getDerivedSnapshot() {
+    return this._require().getDerivedSnapshot();
+  }
+  static path(e, t = {}) {
+    return this._require().path(e, t);
+  }
+  static get(e, t) {
+    return e === void 0 ? this._require().get() : this._require().get(e, t);
+  }
+  static peek(e, t) {
+    return e === void 0 ? this._require().peek() : this._require().peek(e, t);
+  }
+  static has(e, t) {
+    return this._require().has(e, t);
+  }
+  static set(e, t, r) {
+    this._require().set(e, t, r);
+  }
+  static merge(e, t, r) {
+    this._require().merge(e, t, r);
+  }
+  static delete(e, t) {
+    this._require().delete(e, t);
+  }
+  static Scheduler = f;
+  static DerivedStrategy = Object.freeze({
+    full: d,
+    collectionByKey: _,
+    filterByKey: h
+  });
+  // ---------------------------------------------
+  // PRIVATE
+  // ---------------------------------------------
+  static _require() {
+    const e = this._handle;
+    if (e === void 0)
+      throw new c("[Raph] Facade is not configured. Call Raph.configure(...) first.");
+    return e;
   }
 }
-// Хранят lifecycle facade, выбранный backend и принадлежащий сессии runtime registry.
-r(s, "_state", "unconfigured"), r(s, "_mode"), r(s, "_defaultRuntime"), r(s, "_reactivity"), r(s, "_runtimes", /* @__PURE__ */ new Map()), r(s, "_runtimeOrder", []), r(s, "_runtimeCounter", 0), r(s, "_runtimeDefaults", {}), // Публикуют операции выбранного backend после успешной конфигурации facade.
-r(s, "signal", n), r(s, "computed", n), r(s, "effect", n), r(s, "watch", n), r(s, "batch", n), r(s, "untracked", n), r(s, "scope", n), // ---------------------------------------------
-// SUGAR
-// ---------------------------------------------
-/**
- * Предоставляет режимы scheduler без отдельного импорта константы.
- */
-r(s, "Scheduler", c), /**
- * Предоставляет стратегии materialized derived рядом с facade API.
- */
-r(s, "DerivedStrategy", Object.freeze({
-  full: v,
-  collectionByKey: p,
-  filterByKey: R
-}));
-function q(u) {
-  return u === c.Sync || u === c.Microtask || u === c.AnimationFrame;
+function o(u, e) {
+  return new n(
+    `[Raph] ${u} is unavailable for reactivity instance "${e.id}".`
+  );
 }
 export {
-  s as Raph
+  I as Raph
 };