@raphy-js/raph 1.0.0-dev.18

package/dist/debug/path/RaphKernel.js

@@ -0,0 +1,687 @@
+var F = Object.defineProperty;
+var O = (_, e, t) => e in _ ? F(_, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : _[e] = t;
+var y = (_, e, t) => O(_, typeof e != "symbol" ? e + "" : e, t);
+import { parseDataPath as w } from "./data-path.utils.js";
+import { DataPath as T } from "./DataPath.js";
+import { validateFullFilter as S, cloneMaterializedValue as C, validateFullCollection as W, collectionIndex as k, collectionError as b, indexesAreStale as z, validateIncrementalCollection as B, collectionKeys as x, keyedPath as A, filterError as P, validateIncrementalFilter as K } from "./derived/derived-collection.utils.js";
+import { DerivedRegistry as q } from "./derived/DerivedRegistry.js";
+import { RaphDerivedHandle as N, RaphDerivedTargetWriteError as $ } from "./derived/RaphDerivedHandle.js";
+import { MetaController as j } from "./meta/MetaController.js";
+import { AdapterPathStore as R } from "./storage/AdapterPathStore.js";
+import { DefaultDataAdapter as L } from "./storage/DefaultDataAdapter.js";
+import { PathStore as H } from "./storage/PathStore.js";
+const M = class M {
+  /**
+   * Создаёт data/meta owner с независимым lifecycle и derived registry.
+   */
+  constructor(e = {}) {
+    // Публикует стабильную identity data/meta owner.
+    y(this, "id");
+    // Лениво создают независимые data, derived, runtime и metadata controllers.
+    y(this, "_paths");
+    y(this, "_derivedController");
+    y(this, "_runtimes");
+    y(this, "_metaController");
+    // Защищают batch stabilization и записи в derived targets.
+    y(this, "_batchDepth", 0);
+    y(this, "_runtimeMutationDepth", 0);
+    y(this, "_stabilizing", !1);
+    y(this, "_derivedWriteDepth", 0);
+    if (this.id = e.id ?? `kernel-${M._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 R(e.adapter);
+    } else if (e.adapterOptions !== void 0)
+      this._paths = new R(new L(
+        e.initial,
+        e.adapterOptions
+      ));
+    else {
+      const t = this._paths = new H();
+      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;
+    if (this._runtimeMutationDepth === 0 && this._runtimes !== void 0) {
+      this._withAttachedRuntimeBoundary(() => this.set(e, t, r));
+      return;
+    }
+    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;
+    if (this._runtimeMutationDepth === 0 && this._runtimes !== void 0) {
+      this._withAttachedRuntimeBoundary(() => this.merge(e, t, r));
+      return;
+    }
+    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;
+    if (this._runtimeMutationDepth === 0 && this._runtimes !== void 0) {
+      this._withAttachedRuntimeBoundary(() => this.delete(e, t));
+      return;
+    }
+    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");
+    });
+  }
+  /**
+   * Выполняет операцию в общей синхронной batch boundary.
+   */
+  batch(e) {
+    var o;
+    if (this._runtimeMutationDepth === 0 && this._runtimes !== void 0)
+      return this._withAttachedRuntimeBoundary(() => this.batch(e));
+    const t = this._store;
+    if (this._derivedController === void 0 && !((o = this._metaController) != null && o.hasWatchers))
+      return t.batch(e);
+    let r, i, s = !1;
+    try {
+      r = t.batch(() => this._runDerivedBatch(e));
+    } catch (h) {
+      s = !0, i = h;
+    }
+    if (s)
+      throw i;
+    return r;
+  }
+  /**
+   * Подписывает 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) {
+    if (this._runtimeMutationDepth === 0 && this._runtimes !== void 0) {
+      this._withAttachedRuntimeBoundary(() => this.setMeta(e, t, r, i));
+      return;
+    }
+    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) {
+    if (this._runtimeMutationDepth === 0 && this._runtimes !== void 0) {
+      this._withAttachedRuntimeBoundary(() => this.mergeMeta(e, t, r, i));
+      return;
+    }
+    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;
+    if (this._runtimeMutationDepth === 0 && this._runtimes !== void 0) {
+      this._withAttachedRuntimeBoundary(() => this.deleteMeta(e, t, r));
+      return;
+    }
+    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 d, u, m;
+    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 && ((d = this._derivedController) != null && d.has(e.id)))
+      throw new Error(`[Raph] Duplicate derived id "${e.id}".`);
+    const t = w(e.from), r = w(e.to);
+    if (E(t, r))
+      throw new Error("[Raph] Derived source and target must not overlap.");
+    const i = this._derivedController ?? new q(), s = e.id ?? i.nextId(), o = {
+      ...e,
+      from: t.canonical,
+      to: r.canonical
+    }, h = new N(this, s, o), l = ((u = e.strategy) == null ? void 0 : u.kind) === "collection-by-key" || ((m = e.strategy) == null ? void 0 : m.kind) === "filter-by-key" ? e.strategy : void 0;
+    this._derivedController = i, i.register(h, t, l);
+    try {
+      e.immediate !== !1 && h.recompute();
+    } catch (a) {
+      throw this._removeDerived(h), h._disposeFromKernel(), a;
+    }
+    return h;
+  }
+  /**
+   * Регистрирует 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._batchDepth !== 0 || this._stabilizing
+    ));
+  }
+  /** Keeps every attached Runtime quiescent until one Kernel publication completes. */
+  _withAttachedRuntimeBoundary(e) {
+    var h, l, d;
+    const t = this._runtimes === void 0 ? [] : [...this._runtimes];
+    if (t.length === 0)
+      return e();
+    const r = [], i = [];
+    let s, o = !1;
+    this._runtimeMutationDepth++;
+    try {
+      for (const u of t)
+        (h = u._beginKernelBatch) == null || h.call(u), r.push(u);
+      try {
+        s = e();
+      } catch (u) {
+        o = !0, i.push(u);
+      }
+    } catch (u) {
+      o = !0, i.push(u);
+    } finally {
+      this._runtimeMutationDepth--;
+      for (let u = r.length - 1; u >= 0; u--)
+        try {
+          (d = (l = r[u])._endKernelBatch) == null || d.call(l);
+        } catch (m) {
+          i.push(m);
+        }
+    }
+    if (i.length === 1)
+      throw i[0];
+    if (i.length > 1)
+      throw new AggregateError(
+        i,
+        o ? "[Raph] Kernel mutation and Runtime publication failed." : "[Raph] Runtime publication failed after a Kernel mutation."
+      );
+    return s;
+  }
+  _assertWritablePath(e, t, r, i) {
+    const s = this._derivedController;
+    if (s === void 0 || this._derivedWriteDepth !== 0)
+      return;
+    const o = w(t, i);
+    for (const h of s.values()) {
+      const l = w(h.options.to);
+      if (!E(o, l))
+        continue;
+      const d = o.segments.length < l.segments.length;
+      if (!(e === "merge" && d && !U(r, l.segments[o.segments.length])))
+        throw new $(o.canonical);
+    }
+  }
+  _writeDerivedTarget(e, t) {
+    this._derivedWriteDepth++;
+    try {
+      this.set(e, t);
+    } finally {
+      this._derivedWriteDepth--;
+    }
+  }
+  _mutateDerived(e, t, r, i, s) {
+    const o = w(r, s);
+    t === "delete" && !e.has(r, s) || e.batch(() => {
+      t === "set" ? e.set(r, i, s) : t === "merge" ? e.merge(r, i, s) : e.delete(r, s), this._queueDerived(o), this._batchDepth === 0 && !this._stabilizing && this._stabilizeDerived();
+    });
+  }
+  _runDerivedBatch(e) {
+    var u;
+    let t = !1, r, i = !1, s, o = !1, h, l;
+    this._batchDepth++;
+    try {
+      l = e();
+    } catch (m) {
+      t = !0, r = m;
+    } finally {
+      if (this._batchDepth--, this._batchDepth === 0) {
+        if (!this._stabilizing)
+          try {
+            this._stabilizeDerived();
+          } catch (m) {
+            i = !0, s = m;
+          }
+        try {
+          (u = this._metaController) == null || u.publish();
+        } catch (m) {
+          o = !0, h = m;
+        }
+      }
+    }
+    const d = [];
+    if (t && d.push(r), i && d.push(s), o && d.push(h), d.length > 1)
+      throw new AggregateError(
+        d,
+        "[Raph] Kernel batch publication failed."
+      );
+    if (d.length === 1)
+      throw d[0];
+    return l;
+  }
+  _mutateWithMetaLifecycle(e) {
+    if (this._batchDepth !== 0 || this._stabilizing) {
+      e();
+      return;
+    }
+    this.batch(e);
+  }
+  _pruneMissingMetaOwners(e, t, r) {
+    var i;
+    (i = this._metaController) == null || i.pruneMissing(this._metaPath(e, r), t);
+  }
+  _metaPath(e, t) {
+    return T.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 = w(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 l;
+    const t = (l = this._derivedController) == null ? void 0 : l.state(e);
+    t !== void 0 && (t.full = !0);
+    const r = this.get(e.options.from), i = e.options.compute(r);
+    let s = i, o, h;
+    t !== void 0 && (r === void 0 && (i === void 0 || Array.isArray(i) && i.length === 0) ? (o = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ new Map()) : (t.kind === "filter-by-key" ? (S(e.id, t.key, r, i), s = C(i)) : W(e.id, t.key, r, i), o = k(r, t.key, "source"), h = k(s, t.key, "output"))), this._writeDerivedTarget(e.options.to, s), t !== void 0 && (t.sourceIndex = o, t.targetIndex = h, 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 b(e.id, "requires array source and target");
+    (t.sourceIndex === void 0 || z(r, t.key, t.sourceIndex, t.keys)) && (t.sourceIndex = k(r, t.key, "source"));
+    const s = t.targetIndex;
+    if (s === void 0)
+      throw b(e.id, "has no materialized target index");
+    const o = [], h = [];
+    for (const a of t.keys) {
+      const g = t.sourceIndex.get(a);
+      g === void 0 ? h.push(a) : o.push({ key: a, index: g, item: r[g] });
+    }
+    o.sort((a, g) => a.index - g.index);
+    const l = o.map((a) => a.item), d = l.length === 0 ? [] : e.options.compute(l);
+    B(
+      e.id,
+      t.key,
+      o.map((a) => a.key),
+      d
+    );
+    const u = d;
+    if (h.length !== 0 || o.some((a) => !s.has(a.key))) {
+      const a = /* @__PURE__ */ new Map();
+      for (let f = 0; f < o.length; f++)
+        a.set(o[f].key, u[f]);
+      const g = /* @__PURE__ */ new Map();
+      for (const [f, v] of s)
+        g.set(f, i[v]);
+      const n = x(r, t.key, "source"), c = [];
+      c.length = n.length;
+      for (let f = 0; f < n.length; f++) {
+        const v = n[f];
+        if (v === void 0)
+          continue;
+        const D = a.has(v) ? a.get(v) : g.get(v);
+        if (D === void 0)
+          throw b(e.id, `is missing target item for key "${String(v)}"`);
+        c[f] = D;
+      }
+      const p = k(c, t.key, "target");
+      this._replaceDerivedTarget(e.options.to, c, t.keys), t.targetIndex = p;
+    } else
+      for (let a = 0; a < o.length; a++)
+        this._writeDerivedTarget(
+          A(e.options.to, t.key, o[a].key),
+          u[a]
+        );
+    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 P(e.id, "requires array source and target");
+    (t.sourceIndex === void 0 || z(r, t.key, t.sourceIndex, t.keys)) && (t.sourceIndex = k(r, t.key, "source"));
+    const s = t.targetIndex;
+    if (s === void 0)
+      throw P(e.id, "has no materialized target index");
+    const o = [];
+    for (const n of t.keys) {
+      const c = t.sourceIndex.get(n);
+      c !== void 0 && o.push({ key: n, index: c, item: r[c] });
+    }
+    o.sort((n, c) => n.index - c.index);
+    const h = o.map((n) => n.item), l = h.length === 0 ? [] : e.options.compute(h);
+    K(
+      e.id,
+      t.key,
+      o.map((n) => n.key),
+      l
+    );
+    const d = /* @__PURE__ */ new Map(), u = l, m = x(u, t.key, "output");
+    for (let n = 0; n < m.length; n++) {
+      const c = m[n];
+      c !== void 0 && d.set(c, C(u[n]));
+    }
+    const a = /* @__PURE__ */ new Set();
+    let g = !1;
+    for (const n of t.keys) {
+      const c = s.has(n), p = d.has(n);
+      !c && !p || (a.add(n), c !== p && (g = !0));
+    }
+    if (g && t.keys.size === 1 && i.length === s.size && this._patchSingleFilterMembership(
+      e,
+      t,
+      i,
+      s,
+      d,
+      a
+    )) {
+      t.keys.clear(), t.full = !1;
+      return;
+    }
+    if (g) {
+      const n = /* @__PURE__ */ new Map();
+      for (const [f, v] of s)
+        n.set(f, i[v]);
+      const c = [];
+      for (const f of x(r, t.key, "source"))
+        if (f !== void 0) {
+          if (t.keys.has(f)) {
+            d.has(f) && c.push(d.get(f));
+            continue;
+          }
+          n.has(f) && c.push(n.get(f));
+        }
+      const p = k(c, t.key, "target");
+      this._replaceDerivedTarget(e.options.to, c, a), t.targetIndex = p;
+    } else
+      for (const [n, c] of d)
+        this._writeDerivedTarget(A(e.options.to, t.key, n), c);
+    t.keys.clear(), t.full = !1;
+  }
+  _patchSingleFilterMembership(e, t, r, i, s, o) {
+    const h = t.sourceIndex;
+    if (h === void 0)
+      return !1;
+    const l = t.keys.values().next().value;
+    if (l === void 0)
+      return !1;
+    const d = i.get(l), u = s.has(l);
+    if (d !== void 0 === u)
+      return !1;
+    const m = r.slice();
+    let a;
+    if (d !== void 0)
+      a = d, m.splice(a, 1);
+    else {
+      const g = h.get(l);
+      if (g === void 0)
+        return !1;
+      let n = 0, c = m.length;
+      for (; n < c; ) {
+        const p = n + c >>> 1, f = m[p];
+        if (typeof f != "object" || f === null || Array.isArray(f))
+          return !1;
+        const v = f[t.key];
+        if (typeof v != "string" && typeof v != "number")
+          return !1;
+        const D = h.get(v);
+        if (D === void 0)
+          return !1;
+        D < g ? n = p + 1 : c = p;
+      }
+      a = n, m.splice(a, 0, s.get(l));
+    }
+    if (this._replaceDerivedTarget(e.options.to, m, o), d !== void 0) {
+      i.delete(l);
+      for (const [g, n] of i)
+        n > a && i.set(g, n - 1);
+    } else {
+      for (const [g, n] of i)
+        n >= a && i.set(g, n + 1);
+      i.set(l, a);
+    }
+    return !0;
+  }
+};
+// Формирует локальный id для Kernel без явно заданного имени.
+y(M, "_kernelCounter", 0);
+let I = M;
+function E(_, e) {
+  const t = Math.min(_.segments.length, e.segments.length);
+  for (let r = 0; r < t; r++)
+    if (!V(_.segments[r], e.segments[r]))
+      return !1;
+  return !0;
+}
+function U(_, e) {
+  return typeof _ != "object" || _ === null || Array.isArray(_) || e.kind !== "key" ? !0 : Object.hasOwn(_, e.key);
+}
+function V(_, e) {
+  return _.kind !== e.kind ? !1 : _.kind === "key" && e.kind === "key" ? _.key === e.key : _.kind === "index" && e.kind === "index" ? _.index === e.index : _.kind === "selector" && e.kind === "selector" && _.key === e.key && Object.is(_.value, e.value);
+}
+export {
+  I as RaphKernel
+};

package/dist/debug/path/data-path.types.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/debug/path/data-path.types.js

@@ -0,0 +1 @@
+

package/dist/debug/path/data-path.utils.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const c=require("./DataPath.cjs"),f=2e4;let n,s;function u(e,t){if(!(t!=null&&t.vars)){const r=n==null?void 0:n.get(e);if(r!==void 0)return r}if(typeof e!="string")return g(e,t);const a=c.DataPath._parseExactString(e,t);if(!(t!=null&&t.vars)){const r=n??(n=new Map);r.size>=f&&r.clear(),r.set(e,a)}return a}function i(e){const t=s==null?void 0:s.get(e);if(t!==void 0)return t;if(typeof e!="string")return h(e);const a=c.DataPath._parseMaskString(e),r=s??(s=new Map);return r.size>=f&&r.clear(),r.set(e,a),a}function l(e){if(e.segments.length===0)return["*"];const t=[`${e.canonical}.*`];for(let a=1;a<e.segments.length;a++)t.push(c.DataPath._renderSegments(e.segments.slice(0,a)));return t}function g(e,t){const a=c.DataPath.from(e,t)._asExact();if(e instanceof c.DataPath&&!(t!=null&&t.vars)){const r=n??(n=new Map);r.size>=f&&r.clear(),r.set(e,a)}return a}function h(e){const t=c.DataPath.from(e)._asMask();if(e instanceof c.DataPath){const a=s??(s=new Map);a.size>=f&&a.clear(),a.set(e,t)}return t}exports.parseDataPath=u;exports.parsePathMask=i;exports.pathRelationMasks=l;