@raphy-js/raph 1.0.1-dev.20 → 1.0.1-dev.25

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

@@ -1,44 +1,66 @@
-var y = Object.defineProperty;
-var b = (o, h, t) => h in o ? y(o, h, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[h] = t;
-var l = (o, h, t) => b(o, typeof h != "symbol" ? h + "" : h, t);
-import { RaphCrossRuntimeError as a } from "../errors.js";
-import { RaphScope as w } from "./RaphScope.js";
-import { throwDisposalErrors as v } from "./throwDisposalErrors.js";
-let g = 0;
-const _ = Symbol("RaphProvisionalNode");
-class c extends w {
-  constructor(t, e = {}, i, r) {
-    const s = i ?? (t instanceof c ? t.runtime : t ?? void 0);
+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 = t instanceof c ? t : (t == null ? void 0 : t.root) ?? null;
+    const n = i instanceof o ? i : i?.root ?? null;
     if (n !== null && n.runtime !== s)
-      throw new a("[Raph] Parent belongs to another runtime.");
-    n == null || n._assertAlive();
-    const d = e.priority ?? 0;
-    p(d);
-    super(e.id ?? `node-${g++}`, s);
-    l(this, "priority");
-    l(this, "_parent");
-    l(this, "_children", []);
-    l(this, "_published");
-    l(this, "api");
-    l(this, "meta");
-    l(this, "type");
-    /** Distinguishes a subtree granule from the node's self granule. @internal */
-    l(this, "_subtreeSourceIdentity", Object.freeze({}));
-    this.priority = d, this._parent = n, this.meta = { ...e.meta }, this.type = e.type ?? "default", this.api = Object.freeze({});
-    const f = r === _;
-    if (this._published = n === null || !f && n._published, n !== null) {
-      const m = n._children.length;
-      if (n._children.push(this), !this._published)
+      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._notifyNodeStructure(this, {
+      s._hasNodeStructureDemand(this) ? s._notifyNodeStructure(this, {
         node: this,
-        newIndex: m,
+        newIndex: n._childCount - 1,
         newParent: n
-      }, [], u(this)), this._assertAlive();
-    }
+      }, [], 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;
@@ -46,118 +68,244 @@ class c extends w {
   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._children;
+    return this._childArray ?? this._materializeChildren();
   }
-  addChild(t) {
-    if (this._assertAlive(), t._assertAlive(), t.runtime !== this.runtime)
-      throw new a("[Raph] Child belongs to another runtime.");
-    if (this === t)
+  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 (!t._published || !this._published)
+    if (!i._published || !this._published)
       throw new Error("[Raph] A provisional node cannot be reparented before setup commits.");
-    for (let e = this; e !== null; e = e.parent)
-      if (e === t)
+    for (let t = this; t !== null; t = t.parent)
+      if (t === i)
         throw new Error("[Raph] A node cannot become its own ancestor.");
-    return t.parent === this ? !0 : this.runtime._runNodeMutation(() => {
-      this.runtime._assertNodeReparentAllowed(t, this);
-      const e = u(t), i = t._parent, r = i == null ? void 0 : i._children.indexOf(t);
-      i !== null && r !== void 0 && r >= 0 && i._children.splice(r, 1), t._parent = this;
-      const s = this._children.length;
-      return this._children.push(t), this.runtime._notifyNodeStructure(t, {
-        node: t,
-        ...i === null ? {} : { oldParent: i },
-        ...r === void 0 || r < 0 ? {} : { oldIndex: r },
+    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: s
-      }, e, u(t)), !0;
+        newIndex: n
+      }, r, d(i)), !0;
     });
   }
-  reorderChildren(t) {
-    if (this._assertAlive(), t.length !== this._children.length || new Set(t).size !== t.length)
-      throw new Error("[Raph] Child order must contain every direct child exactly once.");
-    for (const e of t)
-      if (e._assertAlive(), e._parent !== this)
-        throw new Error("[Raph] Child order can contain only direct children of the node.");
-    this.runtime._runNodeMutation(() => {
-      const e = new Map(this._children.map((i, r) => [i, r]));
-      this._children.splice(0, this._children.length, ...t);
-      for (let i = 0; i < t.length; i++) {
-        const r = t[i], s = e.get(r);
-        if (s === i)
-          continue;
-        const n = u(r);
-        this.runtime._notifyNodeStructure(r, {
-          node: r,
-          oldParent: this,
-          newParent: this,
-          oldIndex: s,
-          newIndex: i
-        }, n, n);
+  /**
+   * Ставит прямых детей в порядок `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(t) {
-    this._assertAlive(), t.meta !== void 0 && (this.meta = { ...t.meta }), t.priority !== void 0 && (p(t.priority), this.priority = t.priority), t.type !== void 0 && (this.type = t.type), this.touch(Object.freeze({ options: Object.freeze({ ...t }) }));
+  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(t) {
-    this._assertAlive(), this.runtime._runNodeMutation(() => this.runtime._notifyNodeTouch(this, t));
+  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, this.runtime._beginOwnerDisposal();
-    const t = [];
+    this._disposing = !0;
+    const i = this.runtime;
+    i._beginOwnerDisposal(this);
+    let t;
     try {
-      for (const s of [...this._children])
-        try {
-          s.dispose();
-        } catch (n) {
-          t.push(n);
+      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._children.length = 0;
-      const e = this._parent, i = u(this), r = e == null ? void 0 : e._children.indexOf(this);
-      if (e !== null && r !== void 0 && r >= 0 && e._children.splice(r, 1), this._parent = null, this._published)
+        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 {
-          this.runtime._notifyNodeStructure(this, {
+          i._notifyNodeStructure(this, {
             node: this,
             ...e === null ? {} : { oldParent: e },
-            ...r === void 0 || r < 0 ? {} : { oldIndex: r }
-          }, i, []);
-        } catch (s) {
-          t.push(s);
+            ...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 {
-        super.dispose();
-      } catch (s) {
-        t.push(s);
+        const r = super._disposeScopeForOwner(super.dispose);
+        r !== void 0 && (t ??= []).push(r);
+      } catch (r) {
+        (t ??= []).push(u(r));
       }
-      this._published = !1;
+      e === null && i._removeTopOwner(this), this._published = !1;
       try {
-        this.runtime._releaseNode(this);
-      } catch (s) {
-        t.push(s);
+        i._releaseNode(this);
+      } catch (r) {
+        (t ??= []).push(u(r));
       }
     } finally {
       try {
-        this.runtime._endOwnerDisposal();
+        i._endOwnerDisposal();
       } catch (e) {
-        t.push(e);
+        (t ??= []).push(u(e));
       }
     }
-    v(t, `[Raph] Node "${this.id}" disposal failed.`);
+    if (t !== void 0)
+      return w(t, `[Raph] Node "${this.id}" disposal failed.`);
   }
-  /** @internal */
-  _setApi(t) {
-    const e = typeof t == "object" && t !== null ? Object.freeze(t) : t;
-    Object.defineProperty(this, "api", {
+  /**
+   * Фиксирует 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: e,
+      value: this.#i,
       writable: !1
     });
   }
@@ -165,42 +313,353 @@ class c extends w {
   _publishCreation() {
     if (this._published)
       return;
-    const t = this._parent;
-    if (t === null || !t._published)
-      return;
-    this._published = !0;
-    const e = t._children.indexOf(this);
-    try {
-      this.runtime._notifyNodeStructure(this, {
-        node: this,
-        newIndex: e,
-        newParent: t
-      }, [], u(this));
-      for (const i of this._children)
-        i._publishCreation();
-    } catch (i) {
-      throw this._published = !1, i;
+    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 O(o, h, t) {
-  return new c(o, h, t, _);
+function E(_, i, t) {
+  return new o(_, i, t, C);
 }
-function u(o) {
-  const h = [];
-  for (let t = o; t !== null; t = t.parent)
-    h.push(t);
-  return h;
+o.prototype._isNode = !0;
+function d(_) {
+  const i = [];
+  for (let t = _; t !== null; t = t.parent)
+    i.push(t);
+  return i;
 }
-function p(o) {
-  if (!Number.isFinite(o))
+function b(_) {
+  if (!Number.isFinite(_))
     throw new TypeError("[Raph] Node priority must be finite.");
 }
+p = o.prototype.dispose;
+c = o.prototype._disposeWithOutcome;
 export {
-  c as RaphNode,
-  O as createProvisionalNode
+  o as RaphNode,
+  E as createProvisionalNode
 };