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

package/dist/debug/runtime/ownership/RaphNode.js

@@ -0,0 +1,665 @@
+import { throwDisposalFailure as S, unroutedDisposalFailure as u, combineDisposalFailures as w } from "../../reactivity/disposal.js";
+import { RaphCrossRuntimeError as v } from "../errors.js";
+import { RaphProducer as x } from "../reactivity/RaphWorkGraph.js";
+import { RaphScope as A } from "./RaphScope.js";
+let O = 0;
+const C = Symbol("RaphProvisionalNode"), N = Object.freeze({}), I = "[Raph] Child order must contain every direct child exactly once.", f = "[Raph] Child order can contain only direct children of the node.";
+let p, c;
+class o extends A {
+  #i;
+  constructor(i, t = {}, e, r) {
+    const s = e ?? (i instanceof o ? i.runtime : i ?? void 0);
+    if (s === void 0)
+      throw new Error("[RaphNode] A root node requires an explicit runtime.");
+    const n = i instanceof o ? i : i?.root ?? null;
+    if (n !== null && n.runtime !== s)
+      throw new v("[Raph] Parent belongs to another runtime.");
+    const l = t.priority ?? 0, h = t.id, a = t.meta, y = a === void 0 ? void 0 : { ...a }, m = t.type ?? "default";
+    n?._assertAlive(), b(l), super(h ?? O++, s);
+    const g = r === C;
+    if (this.priority = l, this._parent = n, this._prevSibling = null, this._nextSibling = null, this._firstChild = null, this._lastChild = null, this._childCount = 0, this._childArray = void 0, this._published = n === null || !g && n._published, this.#i = N, new.target !== o && Object.defineProperty(this, "api", {
+      configurable: !0,
+      enumerable: !0,
+      value: this.#i,
+      writable: !0
+    }), this._meta = y, this.type = m, this._subtreeIdentity = void 0, n !== null) {
+      if (n._appendChild(this), !this._published)
+        return;
+      s._hasNodeStructureDemand(this) ? s._notifyNodeStructure(this, {
+        node: this,
+        newIndex: n._childCount - 1,
+        newParent: n
+      }, [], d(this)) : s._touchMutationBoundary(), this._assertAlive();
+    } else
+      s._addTopOwner(this);
+  }
+  /**
+   * Возвращает id; номер id по умолчанию превращается в `node-N` при первом чтении.
+   */
+  get id() {
+    const i = this._id;
+    return typeof i == "string" ? i : this._id = `node-${i}`;
+  }
+  /**
+   * Возвращает изменяемую metadata node; объект создаётся при первом чтении.
+   */
+  get meta() {
+    return this._meta ??= {};
+  }
+  set meta(i) {
+    this._meta = i;
+  }
+  /**
+   * Возвращает api, зафиксированный после setup; присваивание снаружи запрещено.
+   */
+  get api() {
+    return this.#i;
+  }
+  /**
+   * Отличает subtree granule от self granule; identity создаётся по запросу.
+   * @internal
+   */
+  get _subtreeSourceIdentity() {
+    return this._subtreeIdentity ??= Object.freeze({});
+  }
+  get node() {
+    return this;
+  }
+  get parent() {
+    return this._parent;
+  }
+  /**
+   * Возвращает прямых детей в их порядке. Массив действителен до следующей
+   * структурной mutation этой node; после неё порядок даёт новое чтение.
+   *
+   * Добавление в конец, удаление последнего child и `reorderChildren`
+   * обновляют уже выданный массив на месте. После удаления любого другого
+   * child — первого или из середины — выданный массив либо остаётся прежним, и
+   * следующее чтение строит новый, либо обновляется на месте — второе
+   * происходит, пока у Runtime есть подписчик на node.
+   *
+   * `moveChild` и `_swapChildren` следуют тому же правилу, что и удаление не
+   * последнего child: без подписчика на node выданный массив остаётся прежним,
+   * с подписчиком получает новый порядок на месте. `_disposeChildren` забывает
+   * выданный массив, если набор начинается с первого child списка: массив
+   * хранит состав на начало удаления. Набор, который начинается с другого
+   * child, следует правилу отдельных удалений.
+   *
+   * Собственный dispose node выданный массив не обновляет: пока node удаляет
+   * своих детей, он хранит их состав на начало удаления, а после удаления
+   * последнего child становится пустым. Оставшихся детей в это время даёт
+   * новое чтение; выданный им массив остаётся массивом node до конца удаления:
+   * дети выходят из него на месте и при отсутствии подписчика на node, а после
+   * последнего child он тоже пуст.
+   */
+  get children() {
+    return this._childArray ?? this._materializeChildren();
+  }
+  addChild(i) {
+    if (this._assertAlive(), i._assertAlive(), i.runtime !== this.runtime)
+      throw new v("[Raph] Child belongs to another runtime.");
+    if (this === i)
+      throw new Error("[Raph] A node cannot become its own ancestor.");
+    if (!i._published || !this._published)
+      throw new Error("[Raph] A provisional node cannot be reparented before setup commits.");
+    for (let t = this; t !== null; t = t.parent)
+      if (t === i)
+        throw new Error("[Raph] A node cannot become its own ancestor.");
+    return i.parent === this ? !0 : this.runtime._runNodeMutation(() => {
+      const t = this.runtime;
+      t._assertNodeReparentAllowed(i, this);
+      const e = i._parent;
+      if (!t._hasNodeStructureDemand(i))
+        return e !== null && i._unlinkFrom(e, -1), i._parent = this, this._appendChild(i), e === null && t._removeTopOwner(i), !0;
+      const r = d(i), s = e === null ? -1 : i._indexIn(e);
+      e !== null && i._unlinkFrom(e, s), i._parent = this;
+      const n = this._childCount;
+      return this._appendChild(i), e === null && t._removeTopOwner(i), t._notifyNodeStructure(i, {
+        node: i,
+        ...e === null ? {} : { oldParent: e },
+        ...s < 0 ? {} : { oldIndex: s },
+        newParent: this,
+        newIndex: n
+      }, r, d(i)), !0;
+    });
+  }
+  /**
+   * Ставит прямых детей в порядок `nodes`: в нём каждый прямой child ровно
+   * один раз. Без подписчика на node порядок проверяется и применяется по
+   * связям между siblings, без Set и Map.
+   *
+   * Каждый элемент `nodes` читается один раз, до проверки. Чтение, которое само
+   * меняет дерево — элемент Proxy либо accessor, — не оставляет списки в
+   * промежуточном состоянии: порядок проверяется по составу детей после чтения.
+   */
+  reorderChildren(i) {
+    this._assertAlive(), this._applyChildOrder(i) || this._rejectChildOrder(i);
+  }
+  /**
+   * Ставит прямого child перед прямым child `before` либо в конец списка, если
+   * `before === null`. Без подписчика на node меняются только связи самого
+   * child и его соседей: цена не зависит от числа детей. С подписчиком каждый
+   * child, чей индекс изменился, получает тот же structure cause, что и после
+   * `reorderChildren` с итоговым порядком.
+   */
+  moveChild(i, t) {
+    if (this._assertAlive(), i._assertAlive(), t !== null && t._assertAlive(), i._parent !== this || t !== null && t._parent !== this)
+      throw new Error(f);
+    const e = this.runtime;
+    if (i === t || i._nextSibling === t) {
+      e._touchMutationBoundary();
+      return;
+    }
+    const r = e._hasNodeSubscribers() ? this._indexChildren() : void 0;
+    if (this._relinkBefore(i, t), r !== void 0) {
+      this._publishChildOrder(r);
+      return;
+    }
+    this._childArray = void 0, e._touchMutationBoundary();
+  }
+  /**
+   * Меняет местами двух прямых детей. Без подписчика на node правятся только
+   * связи этих детей и их соседей; с подписчиком оба child получают те же
+   * structure causes, что и после `reorderChildren` с итоговым порядком.
+   *
+   * @internal
+   */
+  _swapChildren(i, t) {
+    if (this._assertAlive(), i._assertAlive(), t._assertAlive(), i._parent !== this || t._parent !== this)
+      throw new Error(f);
+    const e = this.runtime;
+    if (i === t) {
+      e._touchMutationBoundary();
+      return;
+    }
+    const r = e._hasNodeSubscribers() ? this._indexChildren() : void 0, s = i._nextSibling, n = t._nextSibling;
+    if (s === t ? this._relinkBefore(t, i) : n === i ? this._relinkBefore(i, t) : (this._relinkBefore(i, n), this._relinkBefore(t, s)), r !== void 0) {
+      this._publishChildOrder(r);
+      return;
+    }
+    this._childArray = void 0, e._touchMutationBoundary();
+  }
+  _disposeChildren(i, t = 0, e = i === void 0 ? 0 : i.length) {
+    let r = i;
+    if (r === void 0 && (r = this._childArray ?? this._collectChildren(), e = r.length), t >= e)
+      return;
+    const s = this._childArray;
+    s !== void 0 && (s === r || this._firstChild === r[t].node) && (this._childArray = void 0);
+    const n = this.runtime;
+    let l;
+    n._beginOwnerDisposal();
+    for (let h = t; h < e; h++)
+      try {
+        r[h].node.dispose();
+      } catch (a) {
+        (l ??= []).push(a);
+      }
+    try {
+      n._endOwnerDisposal();
+    } catch (h) {
+      (l ??= []).push(h);
+    }
+    return l;
+  }
+  options(i) {
+    this._assertAlive(), i.meta !== void 0 && (this._meta = { ...i.meta }), i.priority !== void 0 && (b(i.priority), this.priority = i.priority), i.type !== void 0 && (this.type = i.type), this.touch(Object.freeze({ options: Object.freeze({ ...i }) }));
+  }
+  /** Invalidates coarse self/subtree/runtime granules for non-reactive state. */
+  touch(i) {
+    this._assertAlive(), this.runtime._runNodeMutation(() => this.runtime._notifyNodeTouch(this, i));
+  }
+  remove() {
+    this.dispose();
+  }
+  dispose() {
+    S(c.call(this));
+  }
+  /** Calls actual public dispatch once; only native disposal can return provenance. @internal */
+  _disposeForOwner() {
+    try {
+      const i = this.dispose;
+      if (i === p)
+        return c.call(this);
+      i.call(this);
+      return;
+    } catch (i) {
+      return u(i);
+    }
+  }
+  /** Result of this exact framework call, without changing raw public disposal. @internal */
+  _disposeWithOutcome() {
+    if (this._disposed || this._disposing)
+      return;
+    this._disposing = !0;
+    const i = this.runtime;
+    i._beginOwnerDisposal(this);
+    let t;
+    try {
+      if (this._firstChild !== null) {
+        const r = this._takeChildSnapshot();
+        for (let s = 0; s < r.length; s++) {
+          const n = r[s];
+          try {
+            const l = n.dispose;
+            if (l === p) {
+              const h = c.call(n);
+              h !== void 0 && (t ??= []).push(h);
+            } else
+              l.call(n);
+          } catch (l) {
+            (t ??= []).push(u(l));
+          }
+        }
+        this._resetChildList(r);
+      }
+      const e = this._parent;
+      if (this._published && i._hasNodeStructureDemand(this)) {
+        const r = d(this), s = e === null ? -1 : this._indexIn(e);
+        e !== null && (this._unlinkFrom(e, s), this._parent = null);
+        try {
+          i._notifyNodeStructure(this, {
+            node: this,
+            ...e === null ? {} : { oldParent: e },
+            ...s < 0 ? {} : { oldIndex: s }
+          }, r, []);
+        } catch (n) {
+          (t ??= []).push(u(n));
+        }
+      } else if (e !== null && (this._unlinkFrom(e, -1), this._parent = null), this._published)
+        try {
+          i._touchMutationBoundary();
+        } catch (r) {
+          (t ??= []).push(u(r));
+        }
+      try {
+        const r = super._disposeScopeForOwner(super.dispose);
+        r !== void 0 && (t ??= []).push(r);
+      } catch (r) {
+        (t ??= []).push(u(r));
+      }
+      e === null && i._removeTopOwner(this), this._published = !1;
+      try {
+        i._releaseNode(this);
+      } catch (r) {
+        (t ??= []).push(u(r));
+      }
+    } finally {
+      try {
+        i._endOwnerDisposal();
+      } catch (e) {
+        (t ??= []).push(u(e));
+      }
+    }
+    if (t !== void 0)
+      return w(t, `[Raph] Node "${this.id}" disposal failed.`);
+  }
+  /**
+   * Фиксирует api после setup; object api замораживается, как и раньше.
+   * Исключение — Runtime signal, возвращённый как api: значение, запись графа
+   * и связи подписчиков лежат в его собственных полях, поэтому заморозка
+   * лишила бы его записи, отслеживаемого чтения, watch и освобождения вместе
+   * с владельцем.
+   * @internal
+   */
+  _setApi(i) {
+    this.#i = typeof i == "object" && i !== null && !(i instanceof x) ? Object.freeze(i) : i, Object.hasOwn(this, "api") && Object.defineProperty(this, "api", {
+      configurable: !1,
+      enumerable: !0,
+      value: this.#i,
+      writable: !1
+    });
+  }
+  /** Publishes a fully initialized provisional subtree. @internal */
+  _publishCreation() {
+    if (this._published)
+      return;
+    const i = this._parent;
+    if (!(i === null || !i._published)) {
+      this._published = !0;
+      try {
+        const t = this.runtime;
+        t._hasNodeStructureDemand(this) ? t._notifyNodeStructure(this, {
+          node: this,
+          newIndex: this._indexIn(i),
+          newParent: i
+        }, [], d(this)) : t._touchMutationBoundary();
+        for (let e = this._firstChild; e !== null; e = e._nextSibling)
+          e._publishCreation();
+      } catch (t) {
+        throw this._published = !1, t;
+      }
+    }
+  }
+  /** @internal */
+  _isPublished() {
+    return this._published;
+  }
+  /**
+   * Сообщает, стоит ли node в списке детей своего parent. Node без parent и
+   * node, чей parent уже сбросил свой список, в нём не стоят.
+   *
+   * @internal
+   */
+  _isLinked() {
+    const i = this._parent;
+    return i !== null && (this._prevSibling !== null || i._firstChild === this);
+  }
+  /**
+   * Добавляет в `into` всех потомков node по связям списков детей: каждый
+   * child сразу за своим parent, дети — в порядке списка. Обход не строит
+   * массивы `children` и не зависит от глубины стека.
+   *
+   * @internal
+   */
+  _collectDescendants(i) {
+    let t = this;
+    for (; ; ) {
+      let e = t._firstChild;
+      for (; e === null; ) {
+        if (t === this)
+          return;
+        e = t._nextSibling, e === null && (t = t._parent);
+      }
+      t = e, i.push(t);
+    }
+  }
+  /**
+   * Прибавляет к `totals` число ресурсов и sources самой node и всех её
+   * потомков. Обход тот же, что у `_collectDescendants`, но владельцев он не
+   * собирает: подсчёт для diagnostics не выделяет память по числу владельцев.
+   *
+   * @internal
+   */
+  _countSubtree(i) {
+    let t = this;
+    for (; ; ) {
+      i.resources += t._debugResourceCount(), i.sources += t._debugSourceCount();
+      let e = t._firstChild;
+      for (; e === null; ) {
+        if (t === this)
+          return;
+        e = t._nextSibling, e === null && (t = t._parent);
+      }
+      t = e;
+    }
+  }
+  /**
+   * Ищет node по id в своём поддереве. Порядок обхода прежний: сама node,
+   * затем дети от последнего к первому, каждый вместе со своим поддеревом.
+   *
+   * @internal
+   */
+  _findNode(i) {
+    let t = this;
+    for (; ; ) {
+      if (t.id === i)
+        return t;
+      let e = t._lastChild;
+      for (; e === null; ) {
+        if (t === this)
+          return;
+        e = t._prevSibling, e === null && (t = t._parent);
+      }
+      t = e;
+    }
+  }
+  /**
+   * Применяет порядок детей `nodes`. Возвращает `false` и оставляет список
+   * прежним, если `nodes` не содержит каждого живого прямого child ровно один
+   * раз. Прежние индексы собираются только при подписчике на node: без него
+   * structure cause никто не получит.
+   */
+  _applyChildOrder(i) {
+    const t = i.length;
+    if (t !== this._childCount)
+      return !1;
+    const e = [];
+    for (let l = 0; l < t; l++)
+      e.push(i[l]);
+    if (t !== this._childCount)
+      return !1;
+    const r = this.runtime, s = r._hasNodeSubscribers() ? this._indexChildren() : void 0;
+    if (!this._relinkChildren(e))
+      return !1;
+    const n = this._childArray;
+    if (n !== void 0 && n !== i)
+      for (let l = 0; l < t; l++)
+        n[l] = e[l];
+    return s === void 0 ? r._touchMutationBoundary() : this._notifyChildOrder(e, s), !0;
+  }
+  /**
+   * Проверяет порядок и переставляет связи за три прохода без Set и Map.
+   * Сначала каждый child списка получает метку: его `_prevSibling` указывает на
+   * parent, чего у прямого child не бывает. Затем метка снимается у каждой node
+   * из `nodes`: node без метки — чужая, удаляемая либо повторная. При отказе
+   * и при ошибке чтения `nodes` связи `_prevSibling` восстанавливаются по
+   * нетронутым `_nextSibling`.
+   *
+   * `nodes` — собственная копия порядка: её чтение не исполняет чужой код, и
+   * между расстановкой меток и их снятием дерево никто не меняет.
+   */
+  _relinkChildren(i) {
+    for (let n = this._firstChild; n !== null; n = n._nextSibling)
+      n._prevSibling = this;
+    const t = i.length;
+    let e = null, r = 0;
+    try {
+      for (; r < t; r++) {
+        const n = i[r];
+        if (n?._parent !== this || n._prevSibling !== this || n._disposing)
+          break;
+        n._prevSibling = e, e = n;
+      }
+    } finally {
+      if (r !== t) {
+        let n = null;
+        for (let l = this._firstChild; l !== null; l = l._nextSibling)
+          l._prevSibling = n, n = l;
+      }
+    }
+    if (r !== t)
+      return !1;
+    let s = null;
+    for (let n = e; n !== null; n = n._prevSibling)
+      n._nextSibling = s, s = n;
+    return this._firstChild = s, this._lastChild = e, !0;
+  }
+  /**
+   * Сообщает причину отказа порядка `nodes` теми же ошибками и в том же
+   * порядке, что и прежняя проверка; Set нужен только здесь.
+   */
+  _rejectChildOrder(i) {
+    if (i.length === this._childCount && new Set(i).size === i.length) {
+      for (const t of i)
+        if (t._assertAlive(), t._parent !== this)
+          throw new Error(f);
+    }
+    throw new Error(I);
+  }
+  /**
+   * Запоминает индекс каждого child до перестановки; нужен только для
+   * structure causes.
+   */
+  _indexChildren() {
+    const i = /* @__PURE__ */ new Map();
+    let t = 0;
+    for (let e = this._firstChild; e !== null; e = e._nextSibling)
+      i.set(e, t++);
+    return i;
+  }
+  /**
+   * Завершает перестановку связей при подписчике на node: массив детей
+   * получает новый порядок на месте либо строится, и каждый child со
+   * сменившимся индексом получает structure cause.
+   */
+  _publishChildOrder(i) {
+    let t = this._childArray;
+    if (t === void 0)
+      t = this._materializeChildren();
+    else {
+      let e = 0;
+      for (let r = this._firstChild; r !== null; r = r._nextSibling)
+        t[e++] = r;
+    }
+    this._notifyChildOrder(t, i);
+  }
+  /**
+   * Публикует structure cause каждому child, чей индекс изменился, в новом
+   * порядке детей и одной границей mutation.
+   */
+  _notifyChildOrder(i, t) {
+    const e = this.runtime;
+    e._runNodeMutation(() => {
+      for (let r = 0; r < i.length; r++) {
+        const s = i[r], n = t.get(s);
+        if (n === r)
+          continue;
+        const l = d(s);
+        e._notifyNodeStructure(s, {
+          node: s,
+          oldParent: this,
+          newParent: this,
+          oldIndex: n,
+          newIndex: r
+        }, l, l);
+      }
+    });
+  }
+  /**
+   * Переставляет child перед `before` либо в конец списка, меняя только связи
+   * child и его соседей. Вызывающий гарантирует, что оба — дети этой node и
+   * что child ещё не стоит перед `before`.
+   */
+  _relinkBefore(i, t) {
+    const e = i._prevSibling, r = i._nextSibling;
+    e === null ? this._firstChild = r : e._nextSibling = r, r === null ? this._lastChild = e : r._prevSibling = e;
+    const s = t === null ? this._lastChild : t._prevSibling;
+    i._prevSibling = s, i._nextSibling = t, s === null ? this._firstChild = i : s._nextSibling = i, t === null ? this._lastChild = i : t._prevSibling = i;
+  }
+  /**
+   * Строит массив детей по связям и запоминает его для следующих чтений.
+   */
+  _materializeChildren() {
+    return this._childArray = this._collectChildren();
+  }
+  /**
+   * Собирает детей по связям в новый массив, не запоминая его.
+   */
+  _collectChildren() {
+    const i = [];
+    for (let t = this._firstChild; t !== null; t = t._nextSibling)
+      i.push(t);
+    return i;
+  }
+  /**
+   * Очищает и забывает выданный массив детей, если он есть.
+   */
+  _clearChildArray() {
+    const i = this._childArray;
+    i !== void 0 && (i.length = 0, this._childArray = void 0);
+  }
+  /**
+   * Добавляет child в конец списка; уже выданный массив получает его через push.
+   */
+  _appendChild(i) {
+    const t = this._lastChild;
+    i._prevSibling = t, t === null ? this._firstChild = i : t._nextSibling = i, this._lastChild = i, this._childCount++;
+    const e = this._childArray;
+    e !== void 0 && e.push(i);
+  }
+  /**
+   * Возвращает позицию node среди детей `parent` либо -1, если `parent` уже
+   * сбросил свой список и node в нём не состоит. Нужна только для structure
+   * cause. Первый и последний child определяются по связям, остальные — через
+   * `indexOf` по массиву детей, как и раньше; массив строится один раз и затем
+   * поддерживается, поэтому обход связей на каждый запрос не повторяется.
+   */
+  _indexIn(i) {
+    return this._prevSibling === null ? i._firstChild === this ? 0 : -1 : i._lastChild === this ? i._childCount - 1 : (i._childArray ?? i._materializeChildren()).indexOf(this);
+  }
+  /**
+   * Вынимает node из списка `parent` и обнуляет её связи, чтобы удержанная node
+   * не удерживала соседей. Связи правятся за постоянное время.
+   *
+   * Уже выданный массив теряет последний child через pop. Любой другой child —
+   * первый или из середины — вырезается на месте, только если его `index`
+   * известен (>= 0) либо у Runtime есть подписчик на node: тогда массив ещё
+   * понадобится для индексов и перестраивать его по связям после каждого
+   * удаления дороже. Иначе массив не правится, а отбрасывается, и следующее
+   * чтение `children` строит новый: очистка списка от первого child к
+   * последнему не сдвигает массив на каждое удаление.
+   *
+   * Пока parent удаляет собственных детей, массив не отбрасывается: его мог
+   * запросить только cleanup уже удаляемого child, и `_resetChildList` обязан
+   * очистить именно его. Отброшенный массив остался бы у cleanup с удалёнными
+   * детьми внутри.
+   */
+  _unlinkFrom(i, t) {
+    const e = this._prevSibling, r = this._nextSibling;
+    if (e === null) {
+      if (i._firstChild !== this)
+        return;
+      i._firstChild = r;
+    } else
+      e._nextSibling = r, this._prevSibling = null;
+    r === null ? i._lastChild = e : (r._prevSibling = e, this._nextSibling = null), i._childCount--;
+    const s = i._childArray;
+    if (s !== void 0)
+      if (r === null)
+        s.pop();
+      else if (t < 0 && !i._disposing && !this.runtime._hasNodeSubscribers())
+        i._childArray = void 0;
+      else if (e === null)
+        s.shift();
+      else {
+        const n = t >= 0 ? t : s.indexOf(this);
+        n >= 0 ? s.splice(n, 1) : i._childArray = void 0;
+      }
+  }
+  /**
+   * Возвращает snapshot детей для их удаления. Уже выданный массив
+   * переиспользуется без копии и на время удаления перестаёт быть массивом
+   * node: дети выходят из списка только через связи, snapshot не сдвигается, и
+   * удаление не платит за `shift` на каждого child. Иначе snapshot строится по
+   * связям.
+   */
+  _takeChildSnapshot() {
+    const i = this._childArray;
+    return i === void 0 ? this._collectChildren() : (this._childArray = void 0, i);
+  }
+  /**
+   * Сбрасывает собственный список после удаления детей. `snapshot` мог быть
+   * выданным массивом: как и раньше, у удалённой node он остаётся пустым.
+   * Массив, запрошенный во время удаления, очищается так же: `_unlinkFrom` не
+   * отбрасывает его, пока node удаляет своих детей.
+   */
+  _resetChildList(i) {
+    i.length = 0, this._clearChildArray();
+    let t = this._firstChild;
+    for (; t !== null; ) {
+      const e = t._nextSibling;
+      t._prevSibling = null, t._nextSibling = null, t = e;
+    }
+    this._firstChild = null, this._lastChild = null, this._childCount = 0;
+  }
+}
+function E(_, i, t) {
+  return new o(_, i, t, C);
+}
+o.prototype._isNode = !0;
+function d(_) {
+  const i = [];
+  for (let t = _; t !== null; t = t.parent)
+    i.push(t);
+  return i;
+}
+function b(_) {
+  if (!Number.isFinite(_))
+    throw new TypeError("[Raph] Node priority must be finite.");
+}
+p = o.prototype.dispose;
+c = o.prototype._disposeWithOutcome;
+export {
+  o as RaphNode,
+  E as createProvisionalNode
+};

package/dist/debug/runtime/ownership/RaphScope.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("../../reactivity/disposal.cjs"),c=require("../../reactivity/scope.cjs"),p=require("../errors.cjs");let l,u;class n extends c.ScopeOwner{constructor(e,t){super(),this._id=e,this.runtime=t,this._order=t._registerOwner(this)}get id(){return this._id}get node(){}signal(e){return this._assertAlive(),this.runtime.signal(e,this)}computed(e){return this._assertAlive(),typeof e=="function"?this.runtime.computed(e,this):this.runtime.computed(e,this)}selector(e,t){const i=this.runtime;return i._assertOwnerRuntime(this),i._getReactivity().selectorForOwner(e,this,t).select}effect(e,t,i){return this._assertAlive(),this.runtime.effect(this,e,t,i)}bindEffect(e,t,i){this._assertAlive(),this.runtime._effectRegistration(this,e,t,i,!1,!0)}effectGroup(e,t,i,s,r){return this._assertAlive(),this.runtime._effectGroupRegistration(this,e,t,i,s,r)}watch(e,t,i,s){return this._assertAlive(),this.runtime.watch(this,e,t,i,s)}_registerEffect(e,t,i,s,r,h){this._assertAlive(),this.runtime._effectRegistration(this,e,t,i,!1,s,r,h)}_registerWatch(e,t,i,s,r,h){this._assertAlive(),this.runtime._watchRegistration(this,e,t,i,s,!1,r,h)}_registerEffectGroup(e,t,i,s,r){return this._assertAlive(),this.runtime._effectGroupRegistration(this,e,t,i,s,r)}aggregate(e){return this._assertAlive(),this.runtime.aggregate(this,e)}action(e,t){return this._assertAlive(),typeof e=="function"?this.runtime.action(e,this):this.runtime.action(e,t,this)}own(e){return this._disposed||this._disposing?(e(),a):this._ownCleanup(e)}dispose(){o.throwDisposalFailure(u.call(this))}_disposeScopeForOwner(e){try{if(e===l)return u.call(this);e.call(this);return}catch(t){return o.unroutedDisposalFailure(t)}}_disposeWithOutcome(){if(this._disposed)return;this._disposed=!0,this._disposing=!0;const e=this.runtime,t=!e._ownerDisposalActive();t&&e._beginOwnerDisposal();let i;try{const s=this._releaseOwned();s!==void 0&&(i=[o.combineDisposalFailures(s,"ScopeNode disposal failed.")])}finally{this._disposing=!1;try{e._unregisterOwner(this)}catch(s){(i??=[]).push(o.unroutedDisposalFailure(s))}if(t)try{e._endOwnerDisposal()}catch(s){(i??=[]).push(o.unroutedDisposalFailure(s))}}if(i!==void 0)return o.combineDisposalFailures(i,`[Raph] Scope "${this.id}" disposal failed.`)}_ownCompletedCleanup(e){return this._disposed||this._disposing?(o.throwDisposalFailure(e()),a):this._ownCompleted(e)}_adoptResource(e){return this._assertAlive(),this._ownCleanup(e)}_adoptRecord(e){this._assertAlive(),this._ownRecord(e)}_adoptSource(e){return this._assertAlive(),this._ownSourceFinalizer(e.dispose),e.source}_adoptSourceEntry(e){this._assertAlive(),this._ownSourceEntry(e)}_assertAlive(){if(this._disposed||this._disposing)throw new p.RaphDisposedError(`[Raph] Owner "${this.id}" is disposed.`)}}n.prototype._isNode=!1;function a(){}l=n.prototype.dispose;u=n.prototype._disposeWithOutcome;exports.RaphScope=n;