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

package/dist/debug/reactivity/reactive-object.js

@@ -1,4 +1,18 @@
-const R = Symbol("raph.reactive-object.identity"), x = /* @__PURE__ */ new Set([
+class R {
+  constructor(t, e) {
+    this._key = t, this._source = e;
+  }
+  get(t) {
+    return this._key === t ? this._source : void 0;
+  }
+  set(t, e) {
+    return /* @__PURE__ */ new Map([[this._key, this._source], [t, e]]);
+  }
+  entries() {
+    return [[this._key, this._source]].values();
+  }
+}
+const D = Symbol("raph.reactive-object.identity"), _ = 0, I = 1, p = 2, H = /* @__PURE__ */ new Set([
   "copyWithin",
   "fill",
   "pop",
@@ -8,40 +22,121 @@ const R = Symbol("raph.reactive-object.identity"), x = /* @__PURE__ */ new Set([
   "sort",
   "splice",
   "unshift"
-]), f = /* @__PURE__ */ new WeakMap(), _ = /* @__PURE__ */ new WeakMap(), l = /* @__PURE__ */ new WeakMap(), T = Object.freeze({}), O = Object.freeze({
-  assertRead: p,
-  assertWrite: p,
-  throwForeign: p
+]), E = 0, T = 1, P = 2, S = 3, C = 4;
+function V(o, t, e) {
+  switch (t) {
+    case "push":
+      return function(i) {
+        const n = o._fastArrayTarget(this);
+        return n === void 0 || arguments.length !== 1 ? Reflect.apply(e, this, arguments) : o._arrayWrite(E, n, i, void 0, void 0, 1);
+      };
+    case "pop":
+      return function() {
+        const i = o._fastArrayTarget(this);
+        return i === void 0 || arguments.length !== 0 ? Reflect.apply(e, this, arguments) : o._arrayWrite(T, i, void 0, void 0, void 0, 0);
+      };
+    case "shift":
+      return function() {
+        const i = o._fastArrayTarget(this);
+        return i === void 0 || arguments.length !== 0 ? Reflect.apply(e, this, arguments) : o._arrayWrite(P, i, void 0, void 0, void 0, 0);
+      };
+    case "unshift":
+      return function(i) {
+        const n = o._fastArrayTarget(this);
+        return n === void 0 || arguments.length !== 1 ? Reflect.apply(e, this, arguments) : o._arrayWrite(S, n, i, void 0, void 0, 1);
+      };
+    case "splice":
+      return function(i, n, s) {
+        const a = arguments.length, c = o._fastArrayTarget(this), h = a >= 1 && a <= 3 && typeof i == "number" && (a === 1 || typeof n == "number");
+        return c === void 0 || !h ? Reflect.apply(e, this, arguments) : o._arrayWrite(C, c, i, n, s, a);
+      };
+    default:
+      return e;
+  }
+}
+const f = /* @__PURE__ */ new WeakMap(), m = /* @__PURE__ */ new WeakMap(), A = /* @__PURE__ */ new WeakMap();
+let j = 0;
+class N {
+  owner;
+  proxy = void 0;
+  tracking = void 0;
+  extension = void 0;
+  /** Plain view слоя observable и его глубина. */
+  view = void 0;
+  deep = !1;
+  constructor(t) {
+    this.owner = t;
+  }
+}
+let O;
+class q {
+  constructor(t) {
+    return t;
+  }
+}
+class g extends q {
+  #t;
+  static read(t) {
+    return #t in t ? t.#t : O?.get(t);
+  }
+  static write(t, e) {
+    if (#t in t) {
+      t.#t = e;
+      return;
+    }
+    if (Object.isExtensible(t)) {
+      const r = new g(t);
+      r.#t = e;
+      return;
+    }
+    (O ??= /* @__PURE__ */ new WeakMap()).set(t, e);
+  }
+}
+const B = Object.freeze({}), F = Object.freeze({
+  assertRead: v,
+  assertWrite: v,
+  throwForeign: v
 });
-function P(s, e) {
-  _.set(s, e);
+function U(o, t) {
+  m.set(o, t);
+  const e = f.get(o);
+  e !== void 0 && !e.disposed && e._setPolicy(t);
 }
-function W(s, e = O) {
-  _.delete(s);
-  const t = f.get(s);
-  t !== void 0 && (f.delete(s), t.dispose(e));
+function z(o, t = F) {
+  m.delete(o);
+  const e = f.get(o);
+  e !== void 0 && (f.delete(o), e.dispose(t));
 }
-function m(s, e, t) {
-  const r = w(e), i = f.get(s);
+function $(o, t, e) {
+  const r = x(t), i = f.get(o);
   if (r !== void 0) {
     if (r.context === i)
-      return e;
-    throw (_.get(s) ?? T).throwForeign?.(r.context.owner), new TypeError("[Raph] Reactive object belongs to another reactivity engine.");
+      return t;
+    throw (m.get(o) ?? B).throwForeign?.(r.context.owner), new TypeError("[Raph] Reactive object belongs to another reactivity engine.");
   }
-  return D(e), (i ?? A(s, t)).wrap(e);
+  return M(t), (i ?? L(o, e)).wrap(t);
 }
-class j {
-  _rawToProxy = /* @__PURE__ */ new WeakMap();
-  _rawToTracking = /* @__PURE__ */ new WeakMap();
+class Y {
+  // Записи raw для context без Runtime; у context Runtime — undefined.
+  _admins;
   _arrayMethods = /* @__PURE__ */ new Map();
   _bridge;
   _policy;
   _writeDepth = 0;
+  // Граница, открытая _openWrite(); не undefined только между open и close.
+  _openBridge;
+  _openBoundary;
   _disposed = !1;
+  _extendedHandlers;
+  // Proxy и raw последнего чтения мутатора массива; сбрасываются при вызове.
+  _mutatorProxy;
+  _mutatorTarget;
+  // Цели, чьё поле стало non-configurable через defineProperty trap этого context.
+  _lockedTargets;
   _handler;
   _weakSelf;
-  constructor(e, t) {
-    this._bridge = e, this._policy = t, this._weakSelf = new WeakRef(this), this._handler = {
+  constructor(t, e) {
+    this._bridge = t, this._policy = e, this._weakSelf = new WeakRef(this), e.owner === void 0 && (this._admins = /* @__PURE__ */ new WeakMap(), j++), this._handler = {
       defineProperty: (r, i, n) => this._define(r, i, n),
       deleteProperty: (r, i) => this._delete(r, i),
       get: (r, i, n) => this._get(r, i, n),
@@ -53,213 +148,555 @@ class j {
   get owner() {
     return this._policy.owner;
   }
+  _setPolicy(t) {
+    this._policy = t;
+  }
   get disposed() {
     return this._disposed;
   }
-  wrap(e) {
-    const t = w(e);
-    if (t !== void 0) {
-      if (t.context === this)
-        return e;
-      throw this._policy.throwForeign?.(t.context.owner), new TypeError("[Raph] Reactive object belongs to another reactivity engine.");
-    }
-    D(e);
-    const r = v(e);
+  support() {
+    const t = {
+      bridge: this._requireBridge(),
+      wrap: (e, r, i) => {
+        const n = this._ownAdmin(e), s = n?.extension;
+        if (s !== void 0) {
+          if (this._policy.assertRead?.(), s.extension !== r || s.deep !== i)
+            throw new TypeError("[Raph] Observable depth is already fixed for this value.");
+          return n.proxy;
+        }
+        const a = this._extensionHandler(r, i), c = this.wrap(e, a), h = this._ownAdmin(e);
+        return h !== void 0 && (h.extension = a), c;
+      },
+      observedView: (e) => {
+        const r = this._ownAdmin(e);
+        return r?.view === void 0 ? void 0 : r;
+      },
+      setObservedView: (e, r, i) => {
+        const n = this._ownAdmin(e);
+        n !== void 0 && (n.view = r, n.deep = i);
+      },
+      claim: (e) => this.claim(e),
+      unwrap: (e) => this._unwrap(e),
+      identity: (e) => ({ context: this, raw: e }),
+      hasView: (e) => this._ownAdmin(e)?.proxy !== void 0,
+      write: (e) => this._write(e),
+      openWrite: () => this._openWrite(),
+      closeWrite: () => this._closeWrite(),
+      failWrite: (e) => this._failOpenWrite(e),
+      tryDirectWrite: () => (this._policy.assertWrite?.(), this._writeDepth !== 0 || this._policy.writeBoundary?._isWriteBatchOpen() === !0)
+    };
+    return Object.defineProperty(t, "policy", { enumerable: !0, get: () => this._policy }), t;
+  }
+  claim(t) {
+    this._policy.assertRead?.(), this._claimAdmin(t);
+  }
+  /** Запись raw, принадлежащая этому context, либо undefined. */
+  _ownAdmin(t) {
+    const e = this._admins;
+    if (e !== void 0)
+      return e.get(t);
+    const r = g.read(t);
+    return r !== void 0 && r.owner === this._weakSelf ? r : void 0;
+  }
+  /**
+   * Запись raw этого context. Запись освобождённого или собранного владельца
+   * заменяется новой; живой чужой владелец отклоняет raw.
+   */
+  _claimAdmin(t) {
+    const e = this._ownAdmin(t);
+    if (e !== void 0)
+      return e;
+    const r = W(t);
     if (r !== void 0 && r !== this && !r.disposed)
       throw this._policy.throwForeign?.(r.owner), new TypeError("[Raph] Raw reactive object belongs to another reactivity engine.");
-    const i = this._rawToProxy.get(e);
-    if (i !== void 0)
-      return i;
-    const n = new Proxy(e, this._handler);
-    return l.set(e, this._weakSelf), this._rawToProxy.set(e, n), n;
-  }
-  dispose(e) {
-    this._disposed = !0, this._policy = e, this._bridge = void 0, this._rawToProxy = /* @__PURE__ */ new WeakMap(), this._rawToTracking = /* @__PURE__ */ new WeakMap(), this._arrayMethods.clear();
-  }
-  _get(e, t, r) {
-    if (t === R)
-      return { context: this, raw: e };
+    const i = new N(this._weakSelf), n = this._admins;
+    return n === void 0 ? g.write(t, i) : (n.set(t, i), A.set(t, this._weakSelf)), i;
+  }
+  wrap(t, e) {
+    const r = x(t);
+    if (r !== void 0) {
+      if (r.context === this)
+        return t;
+      throw this._policy.throwForeign?.(r.context.owner), new TypeError("[Raph] Reactive object belongs to another reactivity engine.");
+    }
+    M(t);
+    const i = this._claimAdmin(t), n = i.proxy;
+    if (n !== void 0)
+      return n;
+    const s = new Proxy(t, e?.handler ?? this._handler);
+    return i.proxy = s, s;
+  }
+  dispose(t) {
+    if (this._disposed = !0, this._policy = t, this._bridge = void 0, this._admins !== void 0 && (this._admins = /* @__PURE__ */ new WeakMap()), this._arrayMethods.clear(), this._lockedTargets = void 0, this._mutatorProxy = void 0, this._mutatorTarget = void 0, this._extendedHandlers !== void 0) {
+      for (const e of this._extendedHandlers.values())
+        e.deep !== void 0 && (e.deep.extension = void 0), e.shallow !== void 0 && (e.shallow.extension = void 0);
+      this._extendedHandlers = void 0;
+    }
+  }
+  _extensionHandler(t, e) {
+    const r = this._extendedHandlers ??= /* @__PURE__ */ new Map();
+    let i = r.get(t);
+    i === void 0 && r.set(t, i = {});
+    const n = e ? "deep" : "shallow";
+    let s = i[n];
+    if (s === void 0) {
+      const a = Object.create(this._handler), c = { extension: t, deep: e, handler: a };
+      a.get = (h, l, u) => this._get(h, l, u, c), i[n] = s = c;
+    }
+    return s;
+  }
+  _get(t, e, r, i) {
+    if (e === D)
+      return { context: this, raw: t };
     this._policy.assertRead?.();
-    const i = Reflect.get(e, t, r);
-    return this._trackValue(e, t), Array.isArray(e) && x.has(t) && i === Array.prototype[t] ? this._arrayMutator(t) : d(i) ? this.wrap(i) : i;
-  }
-  _set(e, t, r) {
-    return this._write(() => {
-      const i = this._unwrap(r), n = Object.hasOwn(e, t), o = Reflect.get(e, t, e), c = Array.isArray(e) ? e.length : 0;
-      if (n && o === i)
-        return !0;
-      if (!Reflect.set(e, t, i, e))
-        return !1;
-      const h = this._rawToTracking.get(e);
-      return h === void 0 || (this._trigger(h.valueDeps?.get(t)), n || (this._trigger(h.hasDeps?.get(t)), this._trigger(h.iterateDep)), this._triggerArrayShape(e, t, i, c, h)), !0;
-    });
+    const n = Reflect.get(t, e, r);
+    if (this._trackValue(t, e), n === null || typeof n != "object")
+      return typeof n == "function" && Array.isArray(t) && H.has(e) && n === Array.prototype[e] ? (this._mutatorProxy = r, this._mutatorTarget = t, this._arrayMutator(e)) : n;
+    const s = i ?? this._ownAdmin(t)?.extension;
+    if (s !== void 0) {
+      if (!Object.isExtensible(t) || this._lockedTargets?.has(t) === !0) {
+        const a = Object.getOwnPropertyDescriptor(t, e);
+        if (a?.configurable === !1 && a.writable === !1 && "value" in a)
+          return n;
+      }
+      return s.extension.readValue(n, s.deep);
+    }
+    return w(n) ? this.wrap(n) : n;
   }
-  _define(e, t, r) {
-    return this._write(() => {
-      const i = Object.hasOwn(e, t), n = Reflect.getOwnPropertyDescriptor(e, t), o = Reflect.get(e, t, e), c = Array.isArray(e) ? e.length : 0, a = "value" in r ? { ...r, value: this._unwrap(r.value) } : r;
-      if (!Reflect.defineProperty(e, t, a))
-        return !1;
-      const u = this._rawToTracking.get(e);
-      if (u === void 0)
-        return !0;
-      const y = Reflect.getOwnPropertyDescriptor(e, t), b = Reflect.get(e, t, e);
-      return (!i || o !== b || !M(n, y)) && this._trigger(u.valueDeps?.get(t)), i ? n?.enumerable !== y?.enumerable && this._trigger(u.iterateDep) : (this._trigger(u.hasDeps?.get(t)), this._trigger(u.iterateDep)), this._triggerArrayShape(
-        e,
-        t,
-        b,
-        c,
-        u
-      ), !0;
-    });
+  _set(t, e, r) {
+    const i = this._openWrite();
+    if (i === _)
+      return this._applySet(t, e, r);
+    if (i === p)
+      return this._writeThroughPolicy(() => this._applySet(t, e, r));
+    let n;
+    try {
+      n = this._applySet(t, e, r);
+    } catch (s) {
+      throw this._failOpenWrite(s);
+    }
+    return this._closeWrite(), n;
   }
-  _delete(e, t) {
-    return this._write(() => {
-      if (!Object.hasOwn(e, t))
-        return !0;
-      if (!Reflect.deleteProperty(e, t))
-        return !1;
-      const i = this._rawToTracking.get(e);
-      return i !== void 0 && (this._trigger(i.valueDeps?.get(t)), this._trigger(i.hasDeps?.get(t)), this._trigger(i.iterateDep)), !0;
-    });
+  _applySet(t, e, r) {
+    const i = this._unwrap(r), n = Object.hasOwn(t, e), s = Reflect.get(t, e, t), a = Array.isArray(t) ? t.length : 0;
+    if (n && s === i)
+      return !0;
+    if (!Reflect.set(t, e, i, t))
+      return !1;
+    const h = this._ownAdmin(t)?.tracking;
+    return h === void 0 || (this._trigger(h.valueDeps?.get(e)), n || (this._trigger(h.hasDeps?.get(e)), this._trigger(h.iterateDep)), this._triggerArrayShape(t, e, i, a, h)), !0;
   }
-  _has(e, t) {
-    return this._policy.assertRead?.(), this._trackHas(e, t), Reflect.has(e, t);
+  _define(t, e, r) {
+    const i = this._openWrite();
+    if (i === _)
+      return this._applyDefine(t, e, r);
+    if (i === p)
+      return this._writeThroughPolicy(() => this._applyDefine(t, e, r));
+    let n;
+    try {
+      n = this._applyDefine(t, e, r);
+    } catch (s) {
+      throw this._failOpenWrite(s);
+    }
+    return this._closeWrite(), n;
   }
-  _ownKeys(e) {
-    return this._policy.assertRead?.(), this._trackIterate(e), Reflect.ownKeys(e);
+  _applyDefine(t, e, r) {
+    const i = Object.hasOwn(t, e), n = Reflect.getOwnPropertyDescriptor(t, e), s = Reflect.get(t, e, t), a = Array.isArray(t) ? t.length : 0, c = "value" in r ? { ...r, value: this._unwrap(r.value) } : r;
+    if (!Reflect.defineProperty(t, e, c))
+      return !1;
+    (n?.configurable === !1 || Reflect.getOwnPropertyDescriptor(t, e)?.configurable === !1) && (this._lockedTargets ??= /* @__PURE__ */ new WeakSet()).add(t);
+    const l = this._ownAdmin(t)?.tracking;
+    if (l === void 0)
+      return !0;
+    const u = Reflect.getOwnPropertyDescriptor(t, e), d = Reflect.get(t, e, t);
+    return (!i || s !== d || !K(n, u)) && this._trigger(l.valueDeps?.get(e)), i ? n?.enumerable !== u?.enumerable && this._trigger(l.iterateDep) : (this._trigger(l.hasDeps?.get(e)), this._trigger(l.iterateDep)), this._triggerArrayShape(
+      t,
+      e,
+      d,
+      a,
+      l
+    ), !0;
   }
-  _arrayMutator(e) {
-    const t = this._arrayMethods.get(e);
-    if (t !== void 0)
-      return t;
-    const r = (n) => this._write(n), i = function(...n) {
+  _delete(t, e) {
+    const r = this._openWrite();
+    if (r === _)
+      return this._applyDelete(t, e);
+    if (r === p)
+      return this._writeThroughPolicy(() => this._applyDelete(t, e));
+    let i;
+    try {
+      i = this._applyDelete(t, e);
+    } catch (n) {
+      throw this._failOpenWrite(n);
+    }
+    return this._closeWrite(), i;
+  }
+  _applyDelete(t, e) {
+    if (!Object.hasOwn(t, e))
+      return !0;
+    if (!Reflect.deleteProperty(t, e))
+      return !1;
+    const i = this._ownAdmin(t)?.tracking;
+    return i !== void 0 && (this._trigger(i.valueDeps?.get(e)), this._trigger(i.hasDeps?.get(e)), this._trigger(i.iterateDep)), !0;
+  }
+  _has(t, e) {
+    return this._policy.assertRead?.(), this._trackHas(t, e), Reflect.has(t, e);
+  }
+  _ownKeys(t) {
+    return this._policy.assertRead?.(), this._trackIterate(t), Reflect.ownKeys(t);
+  }
+  _arrayMutator(t) {
+    const e = this._arrayMethods.get(t);
+    if (e !== void 0)
+      return e;
+    const r = (s) => this._write(s), n = V(this, t, function(...s) {
       return r(() => Reflect.apply(
-        Array.prototype[e],
+        Array.prototype[t],
         this,
-        n
+        s
       ));
-    };
-    return this._arrayMethods.set(e, i), i;
+    });
+    return this._arrayMethods.set(t, n), n;
+  }
+  /**
+   * Raw массива для специализированного мутатора: только сразу после чтения
+   * метода через этот Proxy, вне отслеживания и для обычного Array.prototype.
+   * Иначе мутатор идёт прежним путём через ловушки Proxy.
+   *
+   * @internal
+   */
+  _fastArrayTarget(t) {
+    const e = this._mutatorProxy, r = this._mutatorTarget;
+    if (this._mutatorProxy = void 0, this._mutatorTarget = void 0, r === void 0 || e !== t || Object.getPrototypeOf(r) !== Array.prototype)
+      return;
+    const i = this._bridge;
+    return i === void 0 || i.isTracking() ? void 0 : r;
+  }
+  /**
+   * Выполняет специализированный мутатор в границе записи без closure.
+   *
+   * @internal
+   */
+  _arrayWrite(t, e, r, i, n, s) {
+    const a = this._openWrite();
+    if (a === _)
+      return this._arrayOperation(t, e, r, i, n, s);
+    if (a === p)
+      return this._writeThroughPolicy(() => this._arrayOperation(t, e, r, i, n, s));
+    let c;
+    try {
+      c = this._arrayOperation(t, e, r, i, n, s);
+    } catch (h) {
+      throw this._failOpenWrite(h);
+    }
+    return this._closeWrite(), c;
+  }
+  // Операции повторяют шаги Array.prototype над raw теми же _applySet/_applyDelete,
+  // которые вызывали ловушки Proxy: уведомления и их порядок сохраняются.
+  _arrayOperation(t, e, r, i, n, s) {
+    switch (t) {
+      case E: {
+        const a = e.length;
+        return this._setArrayEntry(e, String(a), r), this._setArrayEntry(e, "length", a + 1), a + 1;
+      }
+      case T: {
+        const a = e.length;
+        if (a === 0) {
+          this._setArrayEntry(e, "length", 0);
+          return;
+        }
+        const c = String(a - 1), h = e[a - 1];
+        return this._deleteArrayEntry(e, c), this._setArrayEntry(e, "length", a - 1), this._viewOf(e, c, h);
+      }
+      case P: {
+        const a = e.length;
+        if (a === 0) {
+          this._setArrayEntry(e, "length", 0);
+          return;
+        }
+        const c = e[0];
+        for (let h = 1; h < a; h++)
+          this._moveArrayEntry(e, h, h - 1);
+        return this._deleteArrayEntry(e, String(a - 1)), this._setArrayEntry(e, "length", a - 1), this._viewOf(e, "0", c);
+      }
+      case S: {
+        const a = e.length;
+        for (let c = a; c > 0; c--)
+          this._moveArrayEntry(e, c - 1, c);
+        return this._setArrayEntry(e, "0", r), this._setArrayEntry(e, "length", a + 1), a + 1;
+      }
+      default:
+        return this._splice(e, r, i, n, s);
+    }
+  }
+  // Array.prototype.splice для числовых аргументов и не более одного элемента.
+  _splice(t, e, r, i, n) {
+    const s = t.length, a = Number.isNaN(e) ? 0 : Math.trunc(e), c = a < 0 ? Math.max(s + a, 0) : Math.min(a, s), h = n > 2 ? 1 : 0;
+    let l = 0;
+    if (n === 1)
+      l = s - c;
+    else if (n > 1) {
+      const d = Number.isNaN(r) ? 0 : Math.trunc(r);
+      l = Math.min(Math.max(d, 0), s - c);
+    }
+    const u = [];
+    for (let d = 0; d < l; d++) {
+      const b = c + d;
+      b in t && (u[d] = this._viewOf(t, String(b), t[b]));
+    }
+    if (u.length = l, h < l) {
+      for (let d = c; d < s - l; d++)
+        this._moveArrayEntry(t, d + l, d + h);
+      for (let d = s; d > s - l + h; d--)
+        this._deleteArrayEntry(t, String(d - 1));
+    } else if (h > l)
+      for (let d = s - l; d > c; d--)
+        this._moveArrayEntry(t, d + l - 1, d + h - 1);
+    return h === 1 && this._setArrayEntry(t, String(c), i), this._setArrayEntry(t, "length", s - l + h), u;
   }
-  _trackValue(e, t) {
+  // HasProperty(from) ? Set(to, Get(from)) : DeletePropertyOrThrow(to).
+  _moveArrayEntry(t, e, r) {
+    e in t ? this._setArrayEntry(t, String(r), t[e]) : this._deleteArrayEntry(t, String(r));
+  }
+  _setArrayEntry(t, e, r) {
+    if (!this._applySet(t, e, r))
+      throw new TypeError(`[Raph] Cannot assign array property "${e}".`);
+  }
+  _deleteArrayEntry(t, e) {
+    if (!this._applyDelete(t, e))
+      throw new TypeError(`[Raph] Cannot delete array property "${e}".`);
+  }
+  // Значение элемента так же, как его вернула бы ловушка get (без отслеживания).
+  _viewOf(t, e, r) {
+    if (r === null || typeof r != "object")
+      return r;
+    const i = this._ownAdmin(t)?.extension;
+    if (i !== void 0) {
+      if (!Object.isExtensible(t) || this._lockedTargets?.has(t) === !0) {
+        const n = Object.getOwnPropertyDescriptor(t, e);
+        if (n?.configurable === !1 && n.writable === !1 && "value" in n)
+          return r;
+      }
+      return i.extension.readValue(r, i.deep);
+    }
+    return w(r) ? this.wrap(r) : r;
+  }
+  _trackValue(t, e) {
     const r = this._requireBridge();
     if (!r.isTracking())
       return;
-    const i = this._ensureTracking(e), n = i.valueDeps ??= /* @__PURE__ */ new Map();
-    let o = n.get(t);
-    o === void 0 && (o = r.create(), n.set(t, o)), r.track(o);
+    const i = this._ensureTracking(t), n = i.valueDeps;
+    let s = n?.get(e);
+    if (s === void 0) {
+      s = r.create(), i.valueDeps = n === void 0 ? new R(e, s) : n.set(e, s);
+      const a = Array.isArray(t) ? y(e) : -1;
+      a >= 0 && (i.maxValueIndex = Math.max(i.maxValueIndex ?? -1, a));
+    }
+    r.track(s);
   }
-  _trackHas(e, t) {
+  _trackHas(t, e) {
     const r = this._requireBridge();
     if (!r.isTracking())
       return;
-    const i = this._ensureTracking(e), n = i.hasDeps ??= /* @__PURE__ */ new Map();
-    let o = n.get(t);
-    o === void 0 && (o = r.create(), n.set(t, o)), r.track(o);
+    const i = this._ensureTracking(t), n = i.hasDeps;
+    let s = n?.get(e);
+    if (s === void 0) {
+      s = r.create(), i.hasDeps = n === void 0 ? new R(e, s) : n.set(e, s);
+      const a = Array.isArray(t) ? y(e) : -1;
+      a >= 0 && (i.maxHasIndex = Math.max(i.maxHasIndex ?? -1, a));
+    }
+    r.track(s);
   }
-  _trackIterate(e) {
-    const t = this._requireBridge();
-    if (!t.isTracking())
+  _trackIterate(t) {
+    const e = this._requireBridge();
+    if (!e.isTracking())
       return;
-    const r = this._ensureTracking(e), i = r.iterateDep ??= t.create();
-    t.track(i);
+    const r = this._ensureTracking(t), i = r.iterateDep ??= e.create();
+    e.track(i);
   }
-  _ensureTracking(e) {
-    let t = this._rawToTracking.get(e);
-    return t === void 0 && (t = {}, this._rawToTracking.set(e, t)), t;
+  _ensureTracking(t) {
+    const e = this._claimAdmin(t);
+    return e.tracking ??= {};
   }
-  _trigger(e) {
-    e !== void 0 && this._requireBridge().trigger(e);
+  _trigger(t) {
+    t !== void 0 && this._requireBridge().trigger(t);
   }
-  _triggerArrayShape(e, t, r, i, n) {
-    if (!Array.isArray(e))
+  _triggerArrayShape(t, e, r, i, n) {
+    if (!Array.isArray(t))
       return;
-    if (g(t) && Number(t) >= i) {
+    if (y(e) >= i) {
       this._trigger(n.valueDeps?.get("length"));
       return;
     }
-    if (t !== "length" || Number(r) >= i)
+    if (e !== "length" || Number(r) >= i)
       return;
-    const o = Number(r);
-    for (const [c, a] of n.valueDeps?.entries() ?? [])
-      g(c) && Number(c) >= o && this._trigger(a);
-    for (const [c, a] of n.hasDeps?.entries() ?? [])
-      g(c) && Number(c) >= o && this._trigger(a);
+    const s = Number(r);
+    if (n.maxValueIndex !== void 0 && n.maxValueIndex >= s)
+      for (const [a, c] of n.valueDeps.entries())
+        y(a) >= s && this._trigger(c);
+    if (n.maxHasIndex !== void 0 && n.maxHasIndex >= s)
+      for (const [a, c] of n.hasDeps.entries())
+        y(a) >= s && this._trigger(c);
     this._trigger(n.iterateDep);
   }
-  _write(e) {
-    if (this._policy.assertWrite?.(), this._writeDepth !== 0)
-      return e();
-    const t = () => {
+  _write(t) {
+    const e = this._openWrite();
+    if (e === _)
+      return t();
+    if (e === p)
+      return this._writeThroughPolicy(t);
+    let r;
+    try {
+      r = t();
+    } catch (i) {
+      throw this._failOpenWrite(i);
+    }
+    return this._closeWrite(), r;
+  }
+  /**
+   * Проверяет право записи и открывает внешнюю границу без closure операции.
+   * WRITE_OPENED обязывает вызывающего завершить её через _closeWrite() или
+   * _failOpenWrite(). Пока граница открыта, _writeDepth не равен нулю, поэтому
+   * вложенная запись получает WRITE_NESTED и сохранённые поля не перезаписывает.
+   */
+  _openWrite() {
+    this._policy.assertWrite?.();
+    const t = this._policy.writeBoundary;
+    if (this._writeDepth !== 0 || t?._isWriteBatchOpen())
+      return _;
+    if (t === void 0 && this._policy.runWrite !== void 0)
+      return p;
+    const e = this._requireBridge();
+    return t?._enterWrite(), ++this._writeDepth, e.startBatch(), this._openBridge = e, this._openBoundary = t, I;
+  }
+  _closeWrite() {
+    const t = this._openBridge, e = this._openBoundary;
+    this._openBridge = void 0, this._openBoundary = void 0;
+    let r, i = !1;
+    try {
+      t.endBatch();
+    } catch (n) {
+      i = !0, r = n;
+    }
+    if (--this._writeDepth, i)
+      throw e === void 0 ? r : e._failWrite(r);
+    e?._exitWrite();
+  }
+  /** Закрывает открытую границу после сбоя операции и возвращает ошибку для throw. */
+  _failOpenWrite(t) {
+    const e = this._openBridge, r = this._openBoundary;
+    this._openBridge = void 0, this._openBoundary = void 0;
+    let i = t;
+    try {
+      e.endBatch();
+    } catch (n) {
+      i = new AggregateError([t, n], "[Raph] Batch operation and effect flush failed.");
+    }
+    return --this._writeDepth, r === void 0 ? i : r._failWrite(i);
+  }
+  _writeThroughPolicy(t) {
+    const e = () => {
       ++this._writeDepth;
       try {
-        return this._requireBridge().batch(e);
+        return this._requireBridge().batch(t);
       } finally {
         --this._writeDepth;
       }
     };
-    return this._policy.runWrite === void 0 ? t() : this._policy.runWrite(t);
+    return this._policy.runWrite === void 0 ? e() : this._policy.runWrite(e);
   }
-  _unwrap(e) {
-    const t = w(e);
-    if (t === void 0) {
-      if (d(e)) {
-        const r = v(e);
+  _unwrap(t) {
+    const e = x(t);
+    if (e === void 0) {
+      if (t !== null && typeof t == "object") {
+        const r = W(t);
         if (r !== void 0 && r !== this && !r.disposed)
           throw this._policy.throwForeign?.(r.owner), new TypeError("[Raph] Raw reactive object belongs to another reactivity engine.");
       }
-      return e;
+      return t;
     }
-    if (t.context !== this)
-      throw this._policy.throwForeign?.(t.context.owner), new TypeError("[Raph] Reactive object belongs to another reactivity engine.");
-    return t.raw;
+    if (e.context !== this)
+      throw this._policy.throwForeign?.(e.context.owner), new TypeError("[Raph] Reactive object belongs to another reactivity engine.");
+    return e.raw;
   }
   _requireBridge() {
-    const e = this._bridge;
-    return e === void 0 && p(), e;
+    const t = this._bridge;
+    return t === void 0 && v(), t;
   }
 }
-function A(s, e) {
-  const t = new j(
-    e(),
-    _.get(s) ?? T
+function k(o) {
+  const t = f.get(o);
+  if (t === void 0)
+    throw new Error("[Raph] Reactive object context must be initialized first.");
+  return t.support();
+}
+function J(o) {
+  return w(o);
+}
+function L(o, t) {
+  const e = new Y(
+    t(),
+    m.get(o) ?? B
   );
-  return f.set(s, t), t;
+  return f.set(o, e), e;
 }
-function v(s) {
-  const e = l.get(s), t = e?.deref();
-  return e !== void 0 && t === void 0 && l.delete(s), t;
+function W(o) {
+  const t = g.read(o)?.owner.deref();
+  if (t !== void 0 && !t.disposed || j === 0)
+    return t;
+  const e = A.get(o), r = e?.deref();
+  return e !== void 0 && r === void 0 && A.delete(o), r !== void 0 && !r.disposed ? r : t ?? r;
 }
-function w(s) {
-  if (!(s === null || typeof s != "object"))
-    return Reflect.get(s, R);
+function x(o) {
+  if (!(o === null || typeof o != "object"))
+    return Reflect.get(o, D);
 }
-function d(s) {
-  if (s === null || typeof s != "object")
+function w(o) {
+  if (o === null || typeof o != "object")
     return !1;
-  if (Array.isArray(s))
+  if (Array.isArray(o))
     return !0;
-  const e = Object.getPrototypeOf(s);
-  return e === Object.prototype || e === null;
+  const t = Object.getPrototypeOf(o);
+  return t === Object.prototype || t === null;
 }
-function D(s) {
-  if (!d(s))
+function M(o) {
+  if (!w(o))
     throw new TypeError("[Raph] reactive() accepts only plain objects and arrays.");
 }
-function g(s) {
-  if (typeof s != "string" || s === "")
-    return !1;
-  const e = Number(s);
-  return Number.isInteger(e) && e >= 0 && e < 4294967295 && String(e) === s;
+function y(o) {
+  if (typeof o != "string")
+    return -1;
+  const t = o.length;
+  if (t === 0 || t > 10)
+    return -1;
+  const e = o.charCodeAt(0) - 48;
+  if (e < 0 || e > 9)
+    return -1;
+  if (e === 0)
+    return t === 1 ? 0 : -1;
+  let r = e;
+  for (let i = 1; i < t; i++) {
+    const n = o.charCodeAt(i) - 48;
+    if (n < 0 || n > 9)
+      return -1;
+    r = r * 10 + n;
+  }
+  return r < 4294967295 ? r : -1;
 }
-function M(s, e) {
-  return s === e ? !0 : s === void 0 || e === void 0 ? !1 : s.configurable === e.configurable && s.enumerable === e.enumerable && s.get === e.get && s.set === e.set && s.value === e.value && s.writable === e.writable;
+function K(o, t) {
+  return o === t ? !0 : o === void 0 || t === void 0 ? !1 : o.configurable === t.configurable && o.enumerable === t.enumerable && o.get === t.get && o.set === t.set && o.value === t.value && o.writable === t.writable;
 }
-function p() {
+function v() {
   throw new Error("[Raph] Reactive object owner is disposed.");
 }
 export {
-  P as configureReactiveObjectPolicy,
-  W as disposeReactiveObjectContext,
-  m as reactiveObject
+  D as REACTIVE_OBJECT_IDENTITY,
+  p as WRITE_CALLBACK,
+  _ as WRITE_NESTED,
+  I as WRITE_OPENED,
+  U as configureReactiveObjectPolicy,
+  z as disposeReactiveObjectContext,
+  k as getReactiveObjectSupport,
+  J as isPlainReactiveValue,
+  $ as reactiveObject
 };