@raphy-js/raph 1.0.0-dev.2

package/dist/debug/path/RaphKernel.js

@@ -0,0 +1,636 @@
+var F = Object.defineProperty;
+var R = (f, e, t) => e in f ? F(f, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : f[e] = t;
+var p = (f, e, t) => R(f, typeof e != "symbol" ? e + "" : e, t);
+import { AdapterPathStore as b } from "./AdapterPathStore.js";
+import { DefaultDataAdapter as O } from "./data-adapter.js";
+import { parseDataPath as k, DataPath as W } from "./data-path.js";
+import { validateFullFilter as S, cloneMaterializedValue as z, validateFullCollection as K, collectionIndex as w, collectionError as M, indexesAreStale as P, validateIncrementalCollection as q, collectionKeys as C, keyedPath as A, filterError as I, validateIncrementalFilter as N } from "./derived-collection.js";
+import { DerivedRegistry as $ } from "./DerivedRegistry.js";
+import { MetaController as j } from "./MetaController.js";
+import { PathStore as L } from "./PathStore.js";
+import { RaphDerivedHandle as B, RaphDerivedTargetWriteError as H } from "./RaphDerivedHandle.js";
+const x = class x {
+  /**
+   * Создаёт data/meta owner с независимым lifecycle и derived registry.
+   */
+  constructor(e = {}) {
+    // Публикует стабильную identity data/meta owner.
+    p(this, "id");
+    // Лениво создают независимые data, derived, runtime и metadata controllers.
+    p(this, "_paths");
+    p(this, "_derivedController");
+    p(this, "_runtimes");
+    p(this, "_metaController");
+    // Защищают transaction stabilization и записи в derived targets.
+    p(this, "_transactionDepth", 0);
+    p(this, "_stabilizing", !1);
+    p(this, "_derivedWriteDepth", 0);
+    if (this.id = e.id ?? `kernel-${x._kernelCounter++}`, e.adapter !== void 0) {
+      if (e.initial !== void 0 || e.adapterOptions !== void 0)
+        throw new TypeError("[Raph] A custom adapter cannot be combined with initial or adapterOptions.");
+      this._paths = new b(e.adapter);
+    } else if (e.adapterOptions !== void 0)
+      this._paths = new b(new O(
+        e.initial,
+        e.adapterOptions
+      ));
+    else {
+      const t = this._paths = new L();
+      e.initial !== void 0 && t.set("", e.initial);
+    }
+  }
+  /**
+   * Показывает, освобождён ли Kernel.
+   */
+  get disposed() {
+    return this._paths === void 0;
+  }
+  /**
+   * Формирует диагностический снимок materialized derived registry.
+   */
+  getDerivedSnapshot() {
+    var t;
+    const e = this._derivedController;
+    return {
+      registrations: (e == null ? void 0 : e.size) ?? 0,
+      errors: [...(e == null ? void 0 : e.values()) ?? []].filter((r) => r.status === "error").length,
+      pending: ((t = e == null ? void 0 : e.pending) == null ? void 0 : t.size) ?? 0,
+      stabilizing: this._stabilizing
+    };
+  }
+  /**
+   * Возвращает лениво созданный metadata facade.
+   */
+  get meta() {
+    return this._metadata.facade;
+  }
+  get(e, t) {
+    return this._store.get(e ?? "", t);
+  }
+  peek(e, t) {
+    return this._store.peek(e ?? "", t);
+  }
+  /**
+   * Проверяет наличие значения по указанному пути.
+   */
+  has(e, t) {
+    return this._store.has(e, t);
+  }
+  /**
+   * Записывает значение и публикует соответствующее изменение.
+   */
+  set(e, t, r) {
+    var s;
+    this._assertWritablePath("set", e, t, r);
+    const i = this._store;
+    if ((((s = this._metaController) == null ? void 0 : s.size) ?? 0) === 0) {
+      if (this._derivedController === void 0) {
+        i.set(e, t, r);
+        return;
+      }
+      this._mutateDerived(i, "set", e, t, r);
+      return;
+    }
+    this._mutateWithMetaLifecycle(() => {
+      this._derivedController === void 0 ? i.set(e, t, r) : this._mutateDerived(i, "set", e, t, r), this._pruneMissingMetaOwners(e, "owner-replaced", r);
+    });
+  }
+  /**
+   * Объединяет значение по пути и публикует соответствующее изменение.
+   */
+  merge(e, t, r) {
+    var s;
+    this._assertWritablePath("merge", e, t, r);
+    const i = this._store;
+    if ((((s = this._metaController) == null ? void 0 : s.size) ?? 0) === 0) {
+      if (this._derivedController === void 0) {
+        i.merge(e, t, r);
+        return;
+      }
+      this._mutateDerived(i, "merge", e, t, r);
+      return;
+    }
+    this._mutateWithMetaLifecycle(() => {
+      this._derivedController === void 0 ? i.merge(e, t, r) : this._mutateDerived(i, "merge", e, t, r), this._pruneMissingMetaOwners(e, "owner-replaced", r);
+    });
+  }
+  /**
+   * Удаляет значение по пути и публикует изменение при наличии данных.
+   */
+  delete(e, t) {
+    var i;
+    this._assertWritablePath("delete", e, void 0, t);
+    const r = this._store;
+    if ((((i = this._metaController) == null ? void 0 : i.size) ?? 0) === 0) {
+      if (this._derivedController === void 0) {
+        r.delete(e, t);
+        return;
+      }
+      this._mutateDerived(r, "delete", e, void 0, t);
+      return;
+    }
+    r.has(e, t) && this._mutateWithMetaLifecycle(() => {
+      this._derivedController === void 0 ? r.delete(e, t) : this._mutateDerived(r, "delete", e, void 0, t);
+      const s = this._metaPath(e, t);
+      this._metaController.deleteSubtree(s, "owner-delete"), this._pruneMissingMetaOwners(s, "owner-delete");
+    });
+  }
+  /**
+   * Выполняет операцию в общей синхронной transaction boundary.
+   */
+  transaction(e) {
+    var c, l, v, _;
+    const t = this._store;
+    if (this._derivedController === void 0 && !((c = this._metaController) != null && c.hasWatchers))
+      return t.transaction(e);
+    const r = this._transactionDepth === 0 && ((l = this._metaController) != null && l.hasDeferredWatchers) && this._runtimes !== void 0 ? [...this._runtimes] : void 0;
+    if (r !== void 0)
+      for (const o of r)
+        (v = o._beginKernelTransaction) == null || v.call(o);
+    let i, s, a = !1;
+    try {
+      i = t.transaction(() => this._runDerivedTransaction(e));
+    } catch (o) {
+      a = !0, s = o;
+    }
+    const d = [];
+    if (a && d.push(s), r !== void 0)
+      for (const o of r)
+        try {
+          (_ = o._endKernelTransaction) == null || _.call(o);
+        } catch (m) {
+          d.push(m);
+        }
+    if (d.length === 1)
+      throw d[0];
+    if (d.length > 1)
+      throw new AggregateError(d, "[Raph] Kernel transaction execution failed.");
+    return i;
+  }
+  /**
+   * Подписывает callback на подходящие изменения и возвращает disposer.
+   */
+  watch(e, t) {
+    return this._store.watch(e, t);
+  }
+  /**
+   * Возвращает metadata указанного data-owner.
+   */
+  getMeta(e, t, r) {
+    var i;
+    return this._store, t !== void 0 && this._assertMetaNamespace(t), (i = this._metaController) == null ? void 0 : i.get(this._metaPath(e, r), t);
+  }
+  /**
+   * Проверяет наличие metadata у указанного data-owner.
+   */
+  hasMeta(e, t, r) {
+    var i;
+    return this._store, t !== void 0 && this._assertMetaNamespace(t), ((i = this._metaController) == null ? void 0 : i.has(this._metaPath(e, r), t)) ?? !1;
+  }
+  /**
+   * Записывает metadata указанного data-owner.
+   */
+  setMeta(e, t, r, i) {
+    this._assertMetaNamespace(t);
+    const s = this._exactMetaPath(e, i);
+    this._assertMetaOwner(s), this._metadata.set(s, t, r, i);
+  }
+  /**
+   * Объединяет metadata указанного data-owner.
+   */
+  mergeMeta(e, t, r, i) {
+    this._assertMetaNamespace(t);
+    const s = this._exactMetaPath(e, i);
+    this._assertMetaOwner(s), this._metadata.merge(s, t, r, i);
+  }
+  /**
+   * Удаляет metadata указанного data-owner.
+   */
+  deleteMeta(e, t, r) {
+    var s;
+    t !== void 0 && this._assertMetaNamespace(t);
+    const i = this._exactMetaPath(e, r);
+    (s = this._metaController) == null || s.delete(i, t, r);
+  }
+  /**
+   * Подписывает runtime adapter на metadata-события Kernel.
+   * @internal
+   */
+  _watchMeta(e, t, r = {}, i) {
+    return this._store, r.namespace !== void 0 && this._assertMetaNamespace(r.namespace), this._metadata.watch(e, t, r, i);
+  }
+  /**
+   * Создаёт управляемое derived-представление source path в target path.
+   */
+  derive(e) {
+    var l, v, _;
+    if (this._store, e.strategy !== void 0 && e.strategy.kind !== "full" && e.strategy.kind !== "collection-by-key" && e.strategy.kind !== "filter-by-key")
+      throw new Error(`[Raph] Unsupported derived strategy "${String(e.strategy.kind)}".`);
+    if (e.id !== void 0 && ((l = this._derivedController) != null && l.has(e.id)))
+      throw new Error(`[Raph] Duplicate derived id "${e.id}".`);
+    const t = k(e.from), r = k(e.to);
+    if (T(t, r))
+      throw new Error("[Raph] Derived source and target must not overlap.");
+    const i = this._derivedController ?? new $(), s = e.id ?? i.nextId(), a = {
+      ...e,
+      from: t.canonical,
+      to: r.canonical
+    }, d = new B(this, s, a), c = ((v = e.strategy) == null ? void 0 : v.kind) === "collection-by-key" || ((_ = e.strategy) == null ? void 0 : _.kind) === "filter-by-key" ? e.strategy : void 0;
+    this._derivedController = i, i.register(d, t, c);
+    try {
+      e.immediate !== !1 && d.recompute();
+    } catch (o) {
+      throw this._removeDerived(d), d._disposeFromKernel(), o;
+    }
+    return d;
+  }
+  /**
+   * Регистрирует runtime, разделяющий этот Kernel.
+   * @internal
+   */
+  _attachRuntime(e) {
+    this._store, (this._runtimes ?? (this._runtimes = /* @__PURE__ */ new Set())).add(e);
+  }
+  /**
+   * Удаляет runtime из shared Kernel registry.
+   * @internal
+   */
+  _detachRuntime(e) {
+    const t = this._runtimes;
+    t !== void 0 && (t.delete(e), t.size === 0 && (this._runtimes = void 0));
+  }
+  /**
+   * Освобождает shared runtimes, derived handles и data/meta state Kernel.
+   */
+  dispose() {
+    var t, r;
+    if (this._paths === void 0)
+      return;
+    const e = [];
+    if (this._runtimes !== void 0)
+      for (const i of [...this._runtimes])
+        try {
+          i.dispose();
+        } catch (s) {
+          e.push(s);
+        }
+    if (this._runtimes = void 0, (t = this._derivedController) == null || t.dispose(), this._derivedController = void 0, (r = this._metaController) == null || r.dispose(), this._metaController = void 0, this._paths = void 0, e.length === 1)
+      throw e[0];
+    if (e.length > 1)
+      throw new AggregateError(e, `[Raph] Kernel "${this.id}" disposal failed.`);
+  }
+  /**
+   * Пересчитывает указанный derived handle через его стратегию.
+   * @internal
+   */
+  _recomputeDerived(e) {
+    if (!(e.paused || e.disposed))
+      try {
+        this._recomputeDerivedFull(e), e._recordSuccess();
+      } catch (t) {
+        throw e._recordFailure(t), t;
+      }
+  }
+  /**
+   * Удаляет derived handle из registry и освобождает его routes.
+   * @internal
+   */
+  _removeDerived(e) {
+    const t = this._derivedController;
+    t !== void 0 && (t.remove(e), t.size === 0 && (this._derivedController = void 0));
+  }
+  get _store() {
+    const e = this._paths;
+    if (e !== void 0)
+      return e;
+    throw new Error(`[Raph] Kernel "${this.id}" is disposed.`);
+  }
+  get _metadata() {
+    return this._store, this._metaController ?? (this._metaController = new j(
+      this,
+      (e) => this.has(e),
+      () => this._transactionDepth !== 0 || this._stabilizing
+    ));
+  }
+  _assertWritablePath(e, t, r, i) {
+    const s = this._derivedController;
+    if (s === void 0 || this._derivedWriteDepth !== 0)
+      return;
+    const a = k(t, i);
+    for (const d of s.values()) {
+      const c = k(d.options.to);
+      if (!T(a, c))
+        continue;
+      const l = a.segments.length < c.segments.length;
+      if (!(e === "merge" && l && !U(r, c.segments[a.segments.length])))
+        throw new H(a.canonical);
+    }
+  }
+  _writeDerivedTarget(e, t) {
+    this._derivedWriteDepth++;
+    try {
+      this.set(e, t);
+    } finally {
+      this._derivedWriteDepth--;
+    }
+  }
+  _mutateDerived(e, t, r, i, s) {
+    const a = k(r, s);
+    t === "delete" && !e.has(r, s) || e.transaction(() => {
+      t === "set" ? e.set(r, i, s) : t === "merge" ? e.merge(r, i, s) : e.delete(r, s), this._queueDerived(a), this._transactionDepth === 0 && !this._stabilizing && this._stabilizeDerived();
+    });
+  }
+  _runDerivedTransaction(e) {
+    var v;
+    let t = !1, r, i = !1, s, a = !1, d, c;
+    this._transactionDepth++;
+    try {
+      c = e();
+    } catch (_) {
+      t = !0, r = _;
+    } finally {
+      if (this._transactionDepth--, this._transactionDepth === 0) {
+        if (!this._stabilizing)
+          try {
+            this._stabilizeDerived();
+          } catch (_) {
+            i = !0, s = _;
+          }
+        try {
+          (v = this._metaController) == null || v.publish();
+        } catch (_) {
+          a = !0, d = _;
+        }
+      }
+    }
+    const l = [];
+    if (t && l.push(r), i && l.push(s), a && l.push(d), l.length > 1)
+      throw new AggregateError(
+        l,
+        "[Raph] Kernel transaction publication failed."
+      );
+    if (l.length === 1)
+      throw l[0];
+    return c;
+  }
+  _mutateWithMetaLifecycle(e) {
+    if (this._transactionDepth !== 0 || this._stabilizing) {
+      e();
+      return;
+    }
+    this.transaction(e);
+  }
+  _pruneMissingMetaOwners(e, t, r) {
+    var i;
+    (i = this._metaController) == null || i.pruneMissing(this._metaPath(e, r), t);
+  }
+  _metaPath(e, t) {
+    return W.from(e, t);
+  }
+  _exactMetaPath(e, t) {
+    const r = this._metaPath(e, t);
+    if (r.segments().some((i) => i.kind === "wildcard"))
+      throw new Error("[RaphMeta] wildcard paths are read-only observation masks.");
+    return r;
+  }
+  _assertMetaNamespace(e) {
+    if (this._store, !e.trim())
+      throw new Error("[RaphMeta] namespace must not be empty.");
+  }
+  _assertMetaOwner(e) {
+    if (!this.has(e))
+      throw new Error(`[RaphMeta] Owner data path does not exist: "${e}".`);
+  }
+  _queueDerived(e) {
+    var t;
+    (t = this._derivedController) == null || t.queue(e);
+  }
+  _queueDerivedReplacement(e, t) {
+    var r;
+    (r = this._derivedController) == null || r.queueReplacement(e, t);
+  }
+  _replaceDerivedTarget(e, t, r) {
+    const i = k(e);
+    this._store.set(i.canonical, t), this._queueDerivedReplacement(i, r);
+  }
+  _stabilizeDerived() {
+    const e = this._derivedController, t = e == null ? void 0 : e.pending;
+    if (t === void 0 || t.size === 0)
+      return;
+    this._stabilizing = !0;
+    let r = 0;
+    try {
+      for (; t.size !== 0; ) {
+        const i = t.values().next().value;
+        if (t.delete(i), !(i.paused || i.disposed)) {
+          try {
+            this._recomputePendingDerived(i), i._recordSuccess();
+          } catch (s) {
+            throw i._recordFailure(s), s;
+          }
+          if (++r > 1e4)
+            throw new Error("[Raph] Derived stabilization exceeded 10000 recomputations.");
+        }
+      }
+    } catch (i) {
+      throw t.clear(), i;
+    } finally {
+      this._stabilizing = !1, e == null || e.clearPendingIfEmpty();
+    }
+  }
+  _recomputePendingDerived(e) {
+    var r;
+    const t = (r = this._derivedController) == null ? void 0 : r.state(e);
+    if (t === void 0 || !t.initialized || t.full) {
+      this._recomputeDerivedFull(e);
+      return;
+    }
+    t.kind === "filter-by-key" ? this._recomputeDerivedFilter(e, t) : this._recomputeDerivedCollection(e, t);
+  }
+  _recomputeDerivedFull(e) {
+    var c;
+    const t = (c = this._derivedController) == null ? void 0 : c.state(e);
+    t !== void 0 && (t.full = !0);
+    const r = this.get(e.options.from), i = e.options.compute(r);
+    let s = i, a, d;
+    t !== void 0 && (r === void 0 && (i === void 0 || Array.isArray(i) && i.length === 0) ? (a = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map()) : (t.kind === "filter-by-key" ? (S(e.id, t.key, r, i), s = z(i)) : K(e.id, t.key, r, i), a = w(r, t.key, "source"), d = w(s, t.key, "output"))), this._writeDerivedTarget(e.options.to, s), t !== void 0 && (t.sourceIndex = a, t.targetIndex = d, t.initialized = !0, t.full = !1, t.keys.clear());
+  }
+  _recomputeDerivedCollection(e, t) {
+    t.full = !0;
+    const r = this.get(e.options.from), i = this.get(e.options.to);
+    if (!Array.isArray(r) || !Array.isArray(i))
+      throw M(e.id, "requires array source and target");
+    (t.sourceIndex === void 0 || P(r, t.key, t.sourceIndex, t.keys)) && (t.sourceIndex = w(r, t.key, "source"));
+    const s = t.targetIndex;
+    if (s === void 0)
+      throw M(e.id, "has no materialized target index");
+    const a = [], d = [];
+    for (const o of t.keys) {
+      const m = t.sourceIndex.get(o);
+      m === void 0 ? d.push(o) : a.push({ key: o, index: m, item: r[m] });
+    }
+    a.sort((o, m) => o.index - m.index);
+    const c = a.map((o) => o.item), l = c.length === 0 ? [] : e.options.compute(c);
+    q(
+      e.id,
+      t.key,
+      a.map((o) => o.key),
+      l
+    );
+    const v = l;
+    if (d.length !== 0 || a.some((o) => !s.has(o.key))) {
+      const o = /* @__PURE__ */ new Map();
+      for (let u = 0; u < a.length; u++)
+        o.set(a[u].key, v[u]);
+      const m = /* @__PURE__ */ new Map();
+      for (const [u, g] of s)
+        m.set(u, i[g]);
+      const n = C(r, t.key, "source"), h = [];
+      h.length = n.length;
+      for (let u = 0; u < n.length; u++) {
+        const g = n[u];
+        if (g === void 0)
+          continue;
+        const D = o.has(g) ? o.get(g) : m.get(g);
+        if (D === void 0)
+          throw M(e.id, `is missing target item for key "${String(g)}"`);
+        h[u] = D;
+      }
+      const y = w(h, t.key, "target");
+      this._replaceDerivedTarget(e.options.to, h, t.keys), t.targetIndex = y;
+    } else
+      for (let o = 0; o < a.length; o++)
+        this._writeDerivedTarget(
+          A(e.options.to, t.key, a[o].key),
+          v[o]
+        );
+    t.keys.clear(), t.full = !1;
+  }
+  _recomputeDerivedFilter(e, t) {
+    t.full = !0;
+    const r = this.get(e.options.from), i = this.get(e.options.to);
+    if (!Array.isArray(r) || !Array.isArray(i))
+      throw I(e.id, "requires array source and target");
+    (t.sourceIndex === void 0 || P(r, t.key, t.sourceIndex, t.keys)) && (t.sourceIndex = w(r, t.key, "source"));
+    const s = t.targetIndex;
+    if (s === void 0)
+      throw I(e.id, "has no materialized target index");
+    const a = [];
+    for (const n of t.keys) {
+      const h = t.sourceIndex.get(n);
+      h !== void 0 && a.push({ key: n, index: h, item: r[h] });
+    }
+    a.sort((n, h) => n.index - h.index);
+    const d = a.map((n) => n.item), c = d.length === 0 ? [] : e.options.compute(d);
+    N(
+      e.id,
+      t.key,
+      a.map((n) => n.key),
+      c
+    );
+    const l = /* @__PURE__ */ new Map(), v = c, _ = C(v, t.key, "output");
+    for (let n = 0; n < _.length; n++) {
+      const h = _[n];
+      h !== void 0 && l.set(h, z(v[n]));
+    }
+    const o = /* @__PURE__ */ new Set();
+    let m = !1;
+    for (const n of t.keys) {
+      const h = s.has(n), y = l.has(n);
+      !h && !y || (o.add(n), h !== y && (m = !0));
+    }
+    if (m && t.keys.size === 1 && i.length === s.size && this._patchSingleFilterMembership(
+      e,
+      t,
+      i,
+      s,
+      l,
+      o
+    )) {
+      t.keys.clear(), t.full = !1;
+      return;
+    }
+    if (m) {
+      const n = /* @__PURE__ */ new Map();
+      for (const [u, g] of s)
+        n.set(u, i[g]);
+      const h = [];
+      for (const u of C(r, t.key, "source"))
+        if (u !== void 0) {
+          if (t.keys.has(u)) {
+            l.has(u) && h.push(l.get(u));
+            continue;
+          }
+          n.has(u) && h.push(n.get(u));
+        }
+      const y = w(h, t.key, "target");
+      this._replaceDerivedTarget(e.options.to, h, o), t.targetIndex = y;
+    } else
+      for (const [n, h] of l)
+        this._writeDerivedTarget(A(e.options.to, t.key, n), h);
+    t.keys.clear(), t.full = !1;
+  }
+  _patchSingleFilterMembership(e, t, r, i, s, a) {
+    const d = t.sourceIndex;
+    if (d === void 0)
+      return !1;
+    const c = t.keys.values().next().value;
+    if (c === void 0)
+      return !1;
+    const l = i.get(c), v = s.has(c);
+    if (l !== void 0 === v)
+      return !1;
+    const _ = r.slice();
+    let o;
+    if (l !== void 0)
+      o = l, _.splice(o, 1);
+    else {
+      const m = d.get(c);
+      if (m === void 0)
+        return !1;
+      let n = 0, h = _.length;
+      for (; n < h; ) {
+        const y = n + h >>> 1, u = _[y];
+        if (typeof u != "object" || u === null || Array.isArray(u))
+          return !1;
+        const g = u[t.key];
+        if (typeof g != "string" && typeof g != "number")
+          return !1;
+        const D = d.get(g);
+        if (D === void 0)
+          return !1;
+        D < m ? n = y + 1 : h = y;
+      }
+      o = n, _.splice(o, 0, s.get(c));
+    }
+    if (this._replaceDerivedTarget(e.options.to, _, a), l !== void 0) {
+      i.delete(c);
+      for (const [m, n] of i)
+        n > o && i.set(m, n - 1);
+    } else {
+      for (const [m, n] of i)
+        n >= o && i.set(m, n + 1);
+      i.set(c, o);
+    }
+    return !0;
+  }
+};
+// Формирует локальный id для Kernel без явно заданного имени.
+p(x, "_kernelCounter", 0);
+let E = x;
+function T(f, e) {
+  const t = Math.min(f.segments.length, e.segments.length);
+  for (let r = 0; r < t; r++)
+    if (!V(f.segments[r], e.segments[r]))
+      return !1;
+  return !0;
+}
+function U(f, e) {
+  return typeof f != "object" || f === null || Array.isArray(f) || e.kind !== "key" ? !0 : Object.hasOwn(f, e.key);
+}
+function V(f, e) {
+  return f.kind !== e.kind ? !1 : f.kind === "key" && e.kind === "key" ? f.key === e.key : f.kind === "index" && e.kind === "index" ? f.index === e.index : f.kind === "selector" && e.kind === "selector" && f.key === e.key && Object.is(f.value, e.value);
+}
+export {
+  E as RaphKernel
+};

package/dist/debug/path/RaphMeta.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class s{constructor(r,a={}){this._kernel=r,this._binding=a}get(r,a,t){var e,i;return(i=(e=this._binding).assertReadable)==null||i.call(e),this._kernel.getMeta(r,a,t)}has(r,a,t){var e,i;return(i=(e=this._binding).assertReadable)==null||i.call(e),this._kernel.hasMeta(r,a,t)}set(r,a,t,e){var i,h;(h=(i=this._binding).assertWritable)==null||h.call(i),this._write(()=>this._kernel.setMeta(r,a,t,e),(e==null?void 0:e.invalidate)??!0)}merge(r,a,t,e){var i,h;(h=(i=this._binding).assertWritable)==null||h.call(i),this._write(()=>this._kernel.mergeMeta(r,a,t,e),(e==null?void 0:e.invalidate)??!0)}delete(r,a,t){var e,i;(i=(e=this._binding).assertWritable)==null||i.call(e),this._write(()=>this._kernel.deleteMeta(r,a,t),(t==null?void 0:t.invalidate)??!0)}watch(r,a,t={}){var e,i;if((i=(e=this._binding).assertReadable)==null||i.call(e),this._binding.watch===void 0)throw new Error("[RaphMeta] watch requires a runtime-bound Meta facade.");return this._binding.watch(r,a,t)}_write(r,a){const t=this._binding.runWrite;t===void 0?r():t(r,a)}}exports.RaphMeta=s;

package/dist/debug/path/RaphMeta.js

@@ -0,0 +1,68 @@
+class n {
+  /**
+   * Создаёт metadata facade поверх указанного Kernel.
+   */
+  constructor(r, a = {}) {
+    this._kernel = r, this._binding = a;
+  }
+  /**
+   * Возвращает значение по пути без создания отсутствующих данных.
+   */
+  get(r, a, t) {
+    var e, i;
+    return (i = (e = this._binding).assertReadable) == null || i.call(e), this._kernel.getMeta(r, a, t);
+  }
+  /**
+   * Проверяет наличие значения по указанному пути.
+   */
+  has(r, a, t) {
+    var e, i;
+    return (i = (e = this._binding).assertReadable) == null || i.call(e), this._kernel.hasMeta(r, a, t);
+  }
+  /**
+   * Записывает значение и публикует соответствующее изменение.
+   */
+  set(r, a, t, e) {
+    var i, h;
+    (h = (i = this._binding).assertWritable) == null || h.call(i), this._write(
+      () => this._kernel.setMeta(r, a, t, e),
+      (e == null ? void 0 : e.invalidate) ?? !0
+    );
+  }
+  /**
+   * Объединяет значение по пути и публикует соответствующее изменение.
+   */
+  merge(r, a, t, e) {
+    var i, h;
+    (h = (i = this._binding).assertWritable) == null || h.call(i), this._write(
+      () => this._kernel.mergeMeta(r, a, t, e),
+      (e == null ? void 0 : e.invalidate) ?? !0
+    );
+  }
+  /**
+   * Удаляет значение по пути и публикует изменение при наличии данных.
+   */
+  delete(r, a, t) {
+    var e, i;
+    (i = (e = this._binding).assertWritable) == null || i.call(e), this._write(
+      () => this._kernel.deleteMeta(r, a, t),
+      (t == null ? void 0 : t.invalidate) ?? !0
+    );
+  }
+  /**
+   * Подписывает callback на metadata-изменения и возвращает disposer.
+   */
+  watch(r, a, t = {}) {
+    var e, i;
+    if ((i = (e = this._binding).assertReadable) == null || i.call(e), this._binding.watch === void 0)
+      throw new Error("[RaphMeta] watch requires a runtime-bound Meta facade.");
+    return this._binding.watch(r, a, t);
+  }
+  _write(r, a) {
+    const t = this._binding.runWrite;
+    t === void 0 ? r() : t(r, a);
+  }
+}
+export {
+  n as RaphMeta
+};