mvc-kit 2.2.2 → 2.3.0

package/dist/mvc-kit.js

@@ -1,67 +1,67 @@
-import { E as y } from "./singleton-C8_FRbA7.js";
-import { h as N, s as V, t as B, a as L } from "./singleton-C8_FRbA7.js";
-class w extends Error {
-  constructor(t, e) {
-    super(e ?? `HTTP ${t}`), this.status = t, this.name = "HttpError";
+import { E as w } from "./singleton-CaEXSbYg.js";
+import { h as N, s as $, t as L, a as B } from "./singleton-CaEXSbYg.js";
+class C extends Error {
+  constructor(t, s) {
+    super(s ?? `HTTP ${t}`), this.status = t, this.name = "HttpError";
   }
 }
-function v(n) {
-  return n instanceof Error && n.name === "AbortError";
+function y(r) {
+  return r instanceof Error && r.name === "AbortError";
 }
-function C(n) {
-  return n === 401 ? "unauthorized" : n === 403 ? "forbidden" : n === 404 ? "not_found" : n === 422 ? "validation" : n === 429 ? "rate_limited" : n >= 500 ? "server_error" : "unknown";
+function S(r) {
+  return r === 401 ? "unauthorized" : r === 403 ? "forbidden" : r === 404 ? "not_found" : r === 422 ? "validation" : r === 429 ? "rate_limited" : r >= 500 ? "server_error" : "unknown";
 }
-function T(n) {
-  return typeof n == "object" && n !== null && typeof n.status == "number" && typeof n.statusText == "string" && !(n instanceof Error);
+function T(r) {
+  return typeof r == "object" && r !== null && typeof r.status == "number" && typeof r.statusText == "string" && !(r instanceof Error);
 }
-function O(n) {
-  return n instanceof Error && n.name === "AbortError" ? {
+function E(r) {
+  return r instanceof Error && r.name === "AbortError" ? {
     code: "abort",
     message: "Request was aborted",
-    original: n
-  } : n instanceof w ? {
-    code: C(n.status),
-    message: n.message,
-    status: n.status,
-    original: n
-  } : T(n) ? {
-    code: C(n.status),
-    message: n.statusText || `HTTP ${n.status}`,
-    status: n.status,
-    original: n
-  } : n instanceof TypeError && n.message.toLowerCase().includes("fetch") ? {
+    original: r
+  } : r instanceof C ? {
+    code: S(r.status),
+    message: r.message,
+    status: r.status,
+    original: r
+  } : T(r) ? {
+    code: S(r.status),
+    message: r.statusText || `HTTP ${r.status}`,
+    status: r.status,
+    original: r
+  } : r instanceof TypeError && r.message.toLowerCase().includes("fetch") ? {
     code: "network",
-    message: n.message,
-    original: n
-  } : n instanceof Error && n.name === "TimeoutError" ? {
+    message: r.message,
+    original: r
+  } : r instanceof Error && r.name === "TimeoutError" ? {
     code: "timeout",
-    message: n.message,
-    original: n
-  } : n instanceof Error ? {
+    message: r.message,
+    original: r
+  } : r instanceof Error ? {
     code: "unknown",
-    message: n.message,
-    original: n
+    message: r.message,
+    original: r
   } : {
     code: "unknown",
-    message: String(n),
-    original: n
+    message: String(r),
+    original: r
   };
 }
-const _ = typeof __MVC_KIT_DEV__ < "u" && __MVC_KIT_DEV__;
-function E(n) {
-  return n !== null && typeof n == "object" && typeof n.subscribe == "function";
+const d = typeof __MVC_KIT_DEV__ < "u" && __MVC_KIT_DEV__;
+function O(r) {
+  return r !== null && typeof r == "object" && typeof r.subscribe == "function";
 }
-function g(n, t, e) {
-  let s = Object.getPrototypeOf(n);
-  for (; s && s !== t; ) {
-    const i = Object.getOwnPropertyDescriptors(s);
-    for (const [o, a] of Object.entries(i))
-      o !== "constructor" && e(o, a, s);
-    s = Object.getPrototypeOf(s);
+function b(r, t, s) {
+  let e = Object.getPrototypeOf(r);
+  for (; e && e !== t; ) {
+    const i = Object.getOwnPropertyDescriptors(e);
+    for (const [n, a] of Object.entries(i))
+      n !== "constructor" && s(n, a, e);
+    e = Object.getPrototypeOf(e);
   }
 }
-const A = Object.freeze({ loading: !1, error: null, errorCode: null }), S = ["async", "subscribeAsync"], z = /* @__PURE__ */ new Set(["onInit", "onSet", "onDispose"]);
-class b {
+const z = Object.freeze({ loading: !1, error: null, errorCode: null }), v = ["async", "subscribeAsync"], A = /* @__PURE__ */ new Set(["onInit", "onSet", "onDispose"]);
+class m {
   _state;
   _initialState;
   _disposed = !1;
@@ -82,25 +82,32 @@ class b {
   _asyncListeners = /* @__PURE__ */ new Set();
   _asyncProxy = null;
   _activeOps = null;
+  /** DEV-only timeout (ms) for detecting ghost async operations after dispose. */
   static GHOST_TIMEOUT = 3e3;
   constructor(t) {
     this._state = Object.freeze({ ...t }), this._initialState = this._state, this._guardReservedKeys();
   }
+  /** Current frozen state object. */
   get state() {
     return this._state;
   }
+  /** Whether this instance has been disposed. */
   get disposed() {
     return this._disposed;
   }
+  /** Whether init() has been called. */
   get initialized() {
     return this._initialized;
   }
+  /** AbortSignal that fires when this instance is disposed. Lazily created. */
   get disposeSignal() {
     return this._abortController || (this._abortController = new AbortController()), this._abortController.signal;
   }
+  /** Lazily-created typed EventBus for emitting and subscribing to events. */
   get events() {
-    return this._eventBus || (this._eventBus = new y()), this._eventBus;
+    return this._eventBus || (this._eventBus = new w()), this._eventBus;
   }
+  /** Initializes the instance. Called automatically by React hooks after mount. */
   init() {
     if (!(this._initialized || this._disposed))
       return this._initialized = !0, this._trackSubscribables(), this._installStateProxy(), this._memoizeGetters(), this._wrapMethods(), this.onInit?.();
@@ -117,31 +124,38 @@ class b {
    */
   set(t) {
     if (this._disposed) return;
-    if (_ && this._stateTracking) {
+    if (d && this._stateTracking) {
       console.error(
         "[mvc-kit] set() called inside a getter. Getters must be pure — they read state and return a value. They must never call set(), which would cause an infinite render loop. Move this logic to an action method."
       );
       return;
     }
-    const e = typeof t == "function" ? t(this._state) : t;
-    if (!Object.keys(e).some(
-      (c) => e[c] !== this._state[c]
+    const s = typeof t == "function" ? t(this._state) : t;
+    if (!Object.keys(s).some(
+      (o) => s[o] !== this._state[o]
     ))
       return;
-    const o = this._state, a = Object.freeze({ ...o, ...e });
-    this._state = a, this._revision++, this.onSet?.(o, a);
-    for (const c of this._listeners)
-      c(a, o);
+    const n = this._state, a = Object.freeze({ ...n, ...s });
+    this._state = a, this._revision++, this.onSet?.(n, a);
+    for (const o of this._listeners)
+      o(a, n);
   }
-  emit(t, e) {
-    (this._eventBus?.disposed ?? this._disposed) || this.events.emit(t, e);
+  /**
+   * Emits a typed event via the internal EventBus.
+   * Safe to call during dispose cleanup callbacks.
+   * @protected
+   */
+  emit(t, s) {
+    (this._eventBus?.disposed ?? this._disposed) || this.events.emit(t, s);
   }
+  /** Subscribes to state changes. Returns an unsubscribe function. */
   subscribe(t) {
     return this._disposed ? () => {
     } : (this._listeners.add(t), () => {
       this._listeners.delete(t);
     });
   }
+  /** Tears down the instance, releasing all subscriptions and resources. */
   dispose() {
     if (!this._disposed) {
       if (this._disposed = !0, this._teardownSubscriptions(), this._abortController?.abort(), this._cleanups) {
@@ -151,43 +165,56 @@ class b {
       this._eventBus?.dispose(), this.onDispose?.(), this._listeners.clear();
     }
   }
+  /**
+   * Resets state to initial values (or provided state), aborts in-flight work,
+   * clears async tracking, and re-runs onInit().
+   */
   reset(t) {
     if (!this._disposed) {
       this._abortController?.abort(), this._abortController = null, this._teardownSubscriptions(), this._state = t ? Object.freeze({ ...t }) : this._initialState, this._revision++, this._asyncStates.clear(), this._asyncSnapshots.clear(), this._notifyAsync(), this._trackSubscribables();
-      for (const e of this._listeners)
-        e(this._state, this._state);
+      for (const s of this._listeners)
+        s(this._state, this._state);
       return this.onInit?.();
     }
   }
+  /**
+   * Registers a cleanup function to be called on dispose. Used internally for things like method wrapper
+   * cleanup and event bus disposal, but can also be used by subclasses for custom cleanup logic.
+   * @param fn
+   * @protected
+   */
   addCleanup(t) {
     this._cleanups || (this._cleanups = []), this._cleanups.push(t);
   }
-  subscribeTo(t, e) {
-    const s = t.subscribe(e);
-    return this._subscriptionCleanups || (this._subscriptionCleanups = []), this._subscriptionCleanups.push(s), s;
+  /** Subscribes to an external Subscribable with automatic cleanup on dispose. @protected */
+  subscribeTo(t, s) {
+    const e = t.subscribe(s);
+    return this._subscriptionCleanups || (this._subscriptionCleanups = []), this._subscriptionCleanups.push(e), e;
   }
   // ── Async tracking API ──────────────────────────────────────────
+  /** Proxy providing `TaskState` (loading, error, errorCode) per async method. */
   get async() {
     if (!this._asyncProxy) {
       const t = this;
       this._asyncProxy = new Proxy({}, {
-        get(e, s) {
-          return t._asyncSnapshots.get(s) ?? A;
+        get(s, e) {
+          return t._asyncSnapshots.get(e) ?? z;
         },
-        has(e, s) {
-          return t._asyncSnapshots.has(s);
+        has(s, e) {
+          return t._asyncSnapshots.has(e);
         },
         ownKeys() {
           return Array.from(t._asyncSnapshots.keys());
         },
-        getOwnPropertyDescriptor(e, s) {
-          if (t._asyncSnapshots.has(s))
-            return { configurable: !0, enumerable: !0, value: t._asyncSnapshots.get(s) };
+        getOwnPropertyDescriptor(s, e) {
+          if (t._asyncSnapshots.has(e))
+            return { configurable: !0, enumerable: !0, value: t._asyncSnapshots.get(e) };
         }
       });
     }
     return this._asyncProxy;
   }
+  /** Subscribes to async state changes. Used by `useAsync` for React integration. */
   subscribeAsync(t) {
     return this._disposed ? () => {
     } : (this._asyncListeners.add(t), () => {
@@ -207,95 +234,95 @@ class b {
     }
   }
   _guardReservedKeys() {
-    g(this, b.prototype, (t) => {
-      if (S.includes(t))
+    b(this, m.prototype, (t) => {
+      if (v.includes(t))
         throw new Error(
           `[mvc-kit] "${t}" is a reserved property on ViewModel and cannot be overridden.`
         );
     });
   }
   _wrapMethods() {
-    for (const i of S)
+    for (const i of v)
       if (Object.getOwnPropertyDescriptor(this, i)?.value !== void 0)
         throw new Error(
           `[mvc-kit] "${i}" is a reserved property on ViewModel and cannot be overridden.`
         );
-    const t = this, e = /* @__PURE__ */ new Set(), s = [];
-    _ && (this._activeOps = /* @__PURE__ */ new Map()), g(this, b.prototype, (i, o) => {
-      if (o.get || o.set || typeof o.value != "function" || i.startsWith("_") || z.has(i) || e.has(i)) return;
-      e.add(i);
-      const a = o.value;
-      let c = !1;
-      const d = function(...f) {
+    const t = this, s = /* @__PURE__ */ new Set(), e = [];
+    d && (this._activeOps = /* @__PURE__ */ new Map()), b(this, m.prototype, (i, n) => {
+      if (n.get || n.set || typeof n.value != "function" || i.startsWith("_") || A.has(i) || s.has(i)) return;
+      s.add(i);
+      const a = n.value;
+      let o = !1;
+      const l = function(...h) {
         if (t._disposed) {
-          _ && console.warn(`[mvc-kit] "${i}" called after dispose — ignored.`);
+          d && console.warn(`[mvc-kit] "${i}" called after dispose — ignored.`);
           return;
         }
-        _ && !t._initialized && console.warn(
+        d && !t._initialized && console.warn(
           `[mvc-kit] "${i}" called before init(). Async tracking is active only after init().`
         );
-        let h;
+        let u;
         try {
-          h = a.apply(t, f);
-        } catch (l) {
-          throw l;
+          u = a.apply(t, h);
+        } catch (_) {
+          throw _;
         }
-        if (!h || typeof h.then != "function")
-          return c || (c = !0, t._asyncStates.delete(i), t._asyncSnapshots.delete(i), t[i] = a.bind(t)), h;
-        let r = t._asyncStates.get(i);
-        return r || (r = { loading: !1, error: null, errorCode: null, count: 0 }, t._asyncStates.set(i, r)), r.count++, r.loading = !0, r.error = null, r.errorCode = null, t._asyncSnapshots.set(i, Object.freeze({ loading: !0, error: null, errorCode: null })), t._notifyAsync(), _ && t._activeOps && t._activeOps.set(i, (t._activeOps.get(i) ?? 0) + 1), h.then(
-          (l) => {
-            if (t._disposed) return l;
-            if (r.count--, r.loading = r.count > 0, t._asyncSnapshots.set(
+        if (!u || typeof u.then != "function")
+          return o || (o = !0, t._asyncStates.delete(i), t._asyncSnapshots.delete(i), t[i] = a.bind(t)), u;
+        let c = t._asyncStates.get(i);
+        return c || (c = { loading: !1, error: null, errorCode: null, count: 0 }, t._asyncStates.set(i, c)), c.count++, c.loading = !0, c.error = null, c.errorCode = null, t._asyncSnapshots.set(i, Object.freeze({ loading: !0, error: null, errorCode: null })), t._notifyAsync(), d && t._activeOps && t._activeOps.set(i, (t._activeOps.get(i) ?? 0) + 1), u.then(
+          (_) => {
+            if (t._disposed) return _;
+            if (c.count--, c.loading = c.count > 0, t._asyncSnapshots.set(
               i,
-              Object.freeze({ loading: r.loading, error: r.error, errorCode: r.errorCode })
-            ), t._notifyAsync(), _ && t._activeOps) {
-              const u = (t._activeOps.get(i) ?? 1) - 1;
-              u <= 0 ? t._activeOps.delete(i) : t._activeOps.set(i, u);
+              Object.freeze({ loading: c.loading, error: c.error, errorCode: c.errorCode })
+            ), t._notifyAsync(), d && t._activeOps) {
+              const f = (t._activeOps.get(i) ?? 1) - 1;
+              f <= 0 ? t._activeOps.delete(i) : t._activeOps.set(i, f);
             }
-            return l;
+            return _;
           },
-          (l) => {
-            if (v(l)) {
-              if (t._disposed || (r.count--, r.loading = r.count > 0, t._asyncSnapshots.set(
+          (_) => {
+            if (y(_)) {
+              if (t._disposed || (c.count--, c.loading = c.count > 0, t._asyncSnapshots.set(
                 i,
-                Object.freeze({ loading: r.loading, error: r.error, errorCode: r.errorCode })
-              ), t._notifyAsync()), _ && t._activeOps) {
+                Object.freeze({ loading: c.loading, error: c.error, errorCode: c.errorCode })
+              ), t._notifyAsync()), d && t._activeOps) {
                 const p = (t._activeOps.get(i) ?? 1) - 1;
                 p <= 0 ? t._activeOps.delete(i) : t._activeOps.set(i, p);
               }
               return;
             }
             if (t._disposed) return;
-            r.count--, r.loading = r.count > 0;
-            const u = O(l);
-            if (r.error = u.message, r.errorCode = u.code, t._asyncSnapshots.set(
+            c.count--, c.loading = c.count > 0;
+            const f = E(_);
+            if (c.error = f.message, c.errorCode = f.code, t._asyncSnapshots.set(
               i,
-              Object.freeze({ loading: r.loading, error: u.message, errorCode: u.code })
-            ), t._notifyAsync(), _ && t._activeOps) {
+              Object.freeze({ loading: c.loading, error: f.message, errorCode: f.code })
+            ), t._notifyAsync(), d && t._activeOps) {
               const p = (t._activeOps.get(i) ?? 1) - 1;
               p <= 0 ? t._activeOps.delete(i) : t._activeOps.set(i, p);
             }
-            throw l;
+            throw _;
           }
         );
       };
-      s.push(i), t[i] = d;
-    }), s.length > 0 && this.addCleanup(() => {
-      const i = _ && t._activeOps ? new Map(t._activeOps) : null;
-      for (const o of s)
-        _ ? t[o] = () => {
-          console.warn(`[mvc-kit] "${o}" called after dispose — ignored.`);
-        } : t[o] = () => {
+      e.push(i), t[i] = l;
+    }), e.length > 0 && this.addCleanup(() => {
+      const i = d && t._activeOps ? new Map(t._activeOps) : null;
+      for (const n of e)
+        d ? t[n] = () => {
+          console.warn(`[mvc-kit] "${n}" called after dispose — ignored.`);
+        } : t[n] = () => {
         };
-      t._asyncListeners.clear(), t._asyncStates.clear(), t._asyncSnapshots.clear(), _ && i && i.size > 0 && t._scheduleGhostCheck(i);
+      t._asyncListeners.clear(), t._asyncStates.clear(), t._asyncSnapshots.clear(), d && i && i.size > 0 && t._scheduleGhostCheck(i);
     });
   }
   _scheduleGhostCheck(t) {
-    _ && setTimeout(() => {
-      for (const [e, s] of t)
+    d && setTimeout(() => {
+      for (const [s, e] of t)
         console.warn(
-          `[mvc-kit] Ghost async operation detected: "${e}" had ${s} pending call(s) when the ViewModel was disposed. Consider using disposeSignal to cancel in-flight work.`
+          `[mvc-kit] Ghost async operation detected: "${s}" had ${e} pending call(s) when the ViewModel was disposed. Consider using disposeSignal to cancel in-flight work.`
         );
     }, this.constructor.GHOST_TIMEOUT);
   }
@@ -312,13 +339,13 @@ class b {
    */
   _installStateProxy() {
     const t = new Proxy({}, {
-      get: (e, s) => (this._stateTracking?.add(s), this._state[s]),
+      get: (s, e) => (this._stateTracking?.add(e), this._state[e]),
       ownKeys: () => Reflect.ownKeys(this._state),
-      getOwnPropertyDescriptor: (e, s) => Reflect.getOwnPropertyDescriptor(this._state, s),
+      getOwnPropertyDescriptor: (s, e) => Reflect.getOwnPropertyDescriptor(this._state, e),
       set: () => {
         throw new Error("Cannot mutate state directly. Use set() instead.");
       },
-      has: (e, s) => s in this._state
+      has: (s, e) => e in this._state
     });
     Object.defineProperty(this, "state", {
       get: () => this._stateTracking ? t : this._state,
@@ -343,21 +370,21 @@ class b {
    */
   _trackSubscribables() {
     for (const t of Object.getOwnPropertyNames(this)) {
-      const e = this[t];
-      if (!E(e)) continue;
-      const s = {
-        source: e,
+      const s = this[t];
+      if (!O(s)) continue;
+      const e = {
+        source: s,
         revision: 0,
-        unsubscribe: e.subscribe(() => {
+        unsubscribe: s.subscribe(() => {
           if (!this._disposed) {
-            s.revision++, this._revision++, this._state = Object.freeze({ ...this._state });
+            e.revision++, this._revision++, this._state = Object.freeze({ ...this._state });
             for (const i of this._listeners)
               i(this._state, this._state);
           }
         })
       };
-      this._trackedSources.set(t, s), Object.defineProperty(this, t, {
-        get: () => (this._sourceTracking?.set(t, s), e),
+      this._trackedSources.set(t, e), Object.defineProperty(this, t, {
+        get: () => (this._sourceTracking?.set(t, e), s),
         configurable: !0,
         enumerable: !1
       });
@@ -373,8 +400,8 @@ class b {
    */
   _memoizeGetters() {
     const t = /* @__PURE__ */ new Set();
-    g(this, b.prototype, (e, s) => {
-      !s.get || t.has(e) || (t.add(e), this._wrapGetter(e, s.get));
+    b(this, m.prototype, (s, e) => {
+      !e.get || t.has(s) || (t.add(s), this._wrapGetter(s, e.get));
     });
   }
   /**
@@ -387,58 +414,58 @@ class b {
    *   Tier 2 (medium): revision changed but this getter's deps didn't → return cached
    *   Tier 3 (slow):   at least one dep changed → full recompute with tracking
    */
-  _wrapGetter(t, e) {
-    let s, i = -1, o, a, c;
+  _wrapGetter(t, s) {
+    let e, i = -1, n, a, o;
     Object.defineProperty(this, t, {
       get: () => {
         if (this._disposed || i === this._revision)
-          return s;
-        if (o && a) {
-          let r = !0;
-          for (const [l, u] of a)
-            if (this._state[l] !== u) {
-              r = !1;
+          return e;
+        if (n && a) {
+          let c = !0;
+          for (const [_, f] of a)
+            if (this._state[_] !== f) {
+              c = !1;
               break;
             }
-          if (r && c)
-            for (const [l, u] of c) {
-              const p = this._trackedSources.get(l);
-              if (p && p.revision !== u) {
-                r = !1;
+          if (c && o)
+            for (const [_, f] of o) {
+              const p = this._trackedSources.get(_);
+              if (p && p.revision !== f) {
+                c = !1;
                 break;
               }
             }
-          if (r)
-            return i = this._revision, s;
+          if (c)
+            return i = this._revision, e;
         }
-        const d = this._stateTracking, f = this._sourceTracking;
+        const l = this._stateTracking, h = this._sourceTracking;
         this._stateTracking = /* @__PURE__ */ new Set(), this._sourceTracking = /* @__PURE__ */ new Map();
         try {
-          s = e.call(this);
-        } catch (r) {
-          throw this._stateTracking = d, this._sourceTracking = f, r;
+          e = s.call(this);
+        } catch (c) {
+          throw this._stateTracking = l, this._sourceTracking = h, c;
         }
-        o = this._stateTracking;
-        const h = this._sourceTracking;
-        if (this._stateTracking = d, this._sourceTracking = f, d)
-          for (const r of o) d.add(r);
-        if (f)
-          for (const [r, l] of h)
-            f.set(r, l);
+        n = this._stateTracking;
+        const u = this._sourceTracking;
+        if (this._stateTracking = l, this._sourceTracking = h, l)
+          for (const c of n) l.add(c);
+        if (h)
+          for (const [c, _] of u)
+            h.set(c, _);
         a = /* @__PURE__ */ new Map();
-        for (const r of o)
-          a.set(r, this._state[r]);
-        c = /* @__PURE__ */ new Map();
-        for (const [r, l] of h)
-          c.set(r, l.revision);
-        return i = this._revision, s;
+        for (const c of n)
+          a.set(c, this._state[c]);
+        o = /* @__PURE__ */ new Map();
+        for (const [c, _] of u)
+          o.set(c, _.revision);
+        return i = this._revision, e;
       },
       configurable: !0,
       enumerable: !0
     });
   }
 }
-class M {
+class j {
   _state;
   _committed;
   _disposed = !1;
@@ -447,9 +474,10 @@ class M {
   _abortController = null;
   _cleanups = null;
   constructor(t) {
-    const e = Object.freeze({ ...t });
-    this._state = e, this._committed = e;
+    const s = Object.freeze({ ...t });
+    this._state = s, this._committed = s;
   }
+  /** Current frozen state object. */
   get state() {
     return this._state;
   }
@@ -477,31 +505,39 @@ class M {
   get valid() {
     return Object.keys(this.errors).length === 0;
   }
+  /** Whether this instance has been disposed. */
   get disposed() {
     return this._disposed;
   }
+  /** Whether init() has been called. */
   get initialized() {
     return this._initialized;
   }
+  /** AbortSignal that fires when this instance is disposed. Lazily created. */
   get disposeSignal() {
     return this._abortController || (this._abortController = new AbortController()), this._abortController.signal;
   }
+  /** Initializes the instance. Called automatically by React hooks after mount. */
   init() {
     if (!(this._initialized || this._disposed))
       return this._initialized = !0, this.onInit?.();
   }
+  /**
+   * Merges partial state with validation. No-op if no values changed by reference.
+   * @protected
+   */
   set(t) {
     if (this._disposed)
       throw new Error("Cannot set state on disposed Model");
-    const e = typeof t == "function" ? t(this._state) : t;
-    if (!Object.keys(e).some(
-      (c) => e[c] !== this._state[c]
+    const s = typeof t == "function" ? t(this._state) : t;
+    if (!Object.keys(s).some(
+      (o) => s[o] !== this._state[o]
     ))
       return;
-    const o = this._state, a = Object.freeze({ ...o, ...e });
-    this._state = a, this.onSet?.(o, a);
-    for (const c of this._listeners)
-      c(a, o);
+    const n = this._state, a = Object.freeze({ ...n, ...s });
+    this._state = a, this.onSet?.(n, a);
+    for (const o of this._listeners)
+      o(a, n);
   }
   /**
    * Mark current state as the new baseline (not dirty).
@@ -521,15 +557,17 @@ class M {
       return;
     const t = this._state;
     this._state = this._committed, this.onSet?.(t, this._state);
-    for (const e of this._listeners)
-      e(this._state, t);
+    for (const s of this._listeners)
+      s(this._state, t);
   }
+  /** Subscribes to state changes. Returns an unsubscribe function. */
   subscribe(t) {
     return this._disposed ? () => {
     } : (this._listeners.add(t), () => {
       this._listeners.delete(t);
     });
   }
+  /** Tears down the instance, releasing all subscriptions and resources. */
   dispose() {
     if (!this._disposed) {
       if (this._disposed = !0, this._abortController?.abort(), this._cleanups) {
@@ -546,32 +584,54 @@ class M {
   validate(t) {
     return {};
   }
+  /** Registers a cleanup function to be called on dispose. @protected */
   addCleanup(t) {
     this._cleanups || (this._cleanups = []), this._cleanups.push(t);
   }
-  subscribeTo(t, e) {
-    const s = t.subscribe(e);
-    return this.addCleanup(s), s;
+  /** Subscribes to an external Subscribable with automatic cleanup on dispose. @protected */
+  subscribeTo(t, s) {
+    const e = t.subscribe(s);
+    return this.addCleanup(e), e;
   }
-  shallowEqual(t, e) {
-    const s = Object.keys(t), i = Object.keys(e);
-    if (s.length !== i.length)
+  shallowEqual(t, s) {
+    const e = Object.keys(t), i = Object.keys(s);
+    if (e.length !== i.length)
       return !1;
-    for (const o of s)
-      if (t[o] !== e[o])
+    for (const n of e)
+      if (t[n] !== s[n])
         return !1;
     return !0;
   }
 }
-class x {
+const x = typeof __MVC_KIT_DEV__ < "u" && __MVC_KIT_DEV__;
+class D {
+  /** Maximum number of items before FIFO eviction. 0 = unlimited. */
+  static MAX_SIZE = 0;
+  /** Time-to-live in milliseconds. 0 = no expiry. */
+  static TTL = 0;
   _items = [];
   _disposed = !1;
   _listeners = /* @__PURE__ */ new Set();
   _index = /* @__PURE__ */ new Map();
   _abortController = null;
   _cleanups = null;
+  _timestamps = null;
+  _evictionTimer = null;
   constructor(t = []) {
-    this._items = Object.freeze([...t]), this.rebuildIndex();
+    let s = [...t];
+    if (this._ttl > 0) {
+      this._timestamps = /* @__PURE__ */ new Map();
+      const e = Date.now();
+      for (const i of s)
+        this._timestamps.set(i.id, e);
+    }
+    if (this._maxSize > 0 && s.length > this._maxSize) {
+      const e = s.length - this._maxSize, i = s.slice(0, e);
+      s = s.slice(e);
+      for (const n of i)
+        this._timestamps?.delete(n.id);
+    }
+    this._items = Object.freeze(s), this.rebuildIndex(), this._scheduleEvictionTimer();
   }
   /**
    * Alias for Subscribable compatibility.
@@ -579,32 +639,87 @@ class x {
   get state() {
     return this._items;
   }
+  /** The raw readonly array of items. */
   get items() {
     return this._items;
   }
+  /** Number of items in the collection. */
   get length() {
     return this._items.length;
   }
+  /** Whether this instance has been disposed. */
   get disposed() {
     return this._disposed;
   }
+  /** AbortSignal that fires when this instance is disposed. Lazily created. */
   get disposeSignal() {
     return this._abortController || (this._abortController = new AbortController()), this._abortController.signal;
   }
+  // ── Config Accessors ──
+  get _maxSize() {
+    return this.constructor.MAX_SIZE;
+  }
+  get _ttl() {
+    return this.constructor.TTL;
+  }
   // ── CRUD Methods (notify listeners) ──
   /**
-   * Add one or more items.
+   * Add one or more items. Items with existing IDs are silently skipped.
    */
   add(...t) {
     if (this._disposed)
       throw new Error("Cannot add to disposed Collection");
     if (t.length === 0)
       return;
+    const s = /* @__PURE__ */ new Set(), e = [];
+    for (const a of t)
+      !this._index.has(a.id) && !s.has(a.id) && (e.push(a), s.add(a.id));
+    if (e.length === 0) return;
+    const i = this._items;
+    let n = [...i, ...e];
+    for (const a of e)
+      this._index.set(a.id, a);
+    if (this._timestamps) {
+      const a = Date.now();
+      for (const o of e)
+        this._timestamps.set(o.id, a);
+    }
+    this._maxSize > 0 && n.length > this._maxSize && (n = this._evictForCapacity(n)), this._items = Object.freeze(n), this.notify(i), this._scheduleEvictionTimer();
+  }
+  /**
+   * Add or replace items by ID. Existing items are replaced in-place
+   * (preserving array position); new items are appended. Deduplicates
+   * input — last occurrence wins. No-op if nothing changed (reference
+   * comparison).
+   */
+  upsert(...t) {
+    if (this._disposed)
+      throw new Error("Cannot upsert on disposed Collection");
+    if (t.length === 0) return;
+    const s = /* @__PURE__ */ new Map();
+    for (const l of t)
+      s.set(l.id, l);
     const e = this._items;
-    this._items = Object.freeze([...e, ...t]);
-    for (const s of t)
-      this._index.set(s.id, s);
-    this.notify(e);
+    let i = !1;
+    const n = /* @__PURE__ */ new Set(), a = [];
+    for (const l of e)
+      if (s.has(l.id)) {
+        const h = s.get(l.id);
+        h !== l && (i = !0), a.push(h), n.add(l.id);
+      } else
+        a.push(l);
+    for (const [l, h] of s)
+      n.has(l) || (a.push(h), i = !0);
+    if (!i) return;
+    if (this._timestamps) {
+      const l = Date.now();
+      for (const [h] of s)
+        this._timestamps.set(h, l);
+    }
+    for (const [l, h] of s)
+      this._index.set(l, h);
+    let o = a;
+    this._maxSize > 0 && o.length > this._maxSize && (o = this._evictForCapacity(o)), this._items = Object.freeze(o), this.notify(e), this._scheduleEvictionTimer();
   }
   /**
    * Remove items by id(s).
@@ -614,29 +729,29 @@ class x {
       throw new Error("Cannot remove from disposed Collection");
     if (t.length === 0)
       return;
-    const e = new Set(t), s = this._items.filter((o) => !e.has(o.id));
-    if (s.length === this._items.length)
+    const s = new Set(t), e = this._items.filter((n) => !s.has(n.id));
+    if (e.length === this._items.length)
       return;
     const i = this._items;
-    this._items = Object.freeze(s);
-    for (const o of t)
-      this._index.delete(o);
-    this.notify(i);
+    this._items = Object.freeze(e);
+    for (const n of t)
+      this._index.delete(n), this._timestamps?.delete(n);
+    this.notify(i), this._scheduleEvictionTimer();
   }
   /**
    * Update an item by id with partial changes.
    */
-  update(t, e) {
+  update(t, s) {
     if (this._disposed)
       throw new Error("Cannot update disposed Collection");
-    const s = this._items.findIndex((h) => h.id === t);
-    if (s === -1)
+    const e = this._items.findIndex((u) => u.id === t);
+    if (e === -1)
       return;
-    const i = this._items[s], o = { ...i, ...e, id: t };
-    if (!Object.keys(e).some((h) => e[h] !== i[h]))
+    const i = this._items[e], n = { ...i, ...s, id: t };
+    if (!Object.keys(s).some((u) => s[u] !== i[u]))
       return;
-    const d = this._items, f = [...d];
-    f[s] = o, this._items = Object.freeze(f), this._index.set(t, o), this.notify(d);
+    const l = this._items, h = [...l];
+    h[e] = n, this._items = Object.freeze(h), this._index.set(t, n), this.notify(l);
   }
   /**
    * Replace all items.
@@ -644,8 +759,15 @@ class x {
   reset(t) {
     if (this._disposed)
       throw new Error("Cannot reset disposed Collection");
-    const e = this._items;
-    this._items = Object.freeze([...t]), this.rebuildIndex(), this.notify(e);
+    const s = this._items;
+    if (this._timestamps) {
+      this._timestamps.clear();
+      const i = Date.now();
+      for (const n of t)
+        this._timestamps.set(n.id, i);
+    }
+    let e = [...t];
+    this._maxSize > 0 && e.length > this._maxSize && (e = this._evictForCapacity(e)), this._items = Object.freeze(e), this.rebuildIndex(), this.notify(s), this._scheduleEvictionTimer();
   }
   /**
    * Remove all items.
@@ -656,7 +778,7 @@ class x {
     if (this._items.length === 0)
       return;
     const t = this._items;
-    this._items = Object.freeze([]), this._index.clear(), this.notify(t);
+    this._items = Object.freeze([]), this._index.clear(), this._timestamps?.clear(), this._clearEvictionTimer(), this.notify(t);
   }
   /**
    * Snapshot current state, apply callback mutations, and return a rollback function.
@@ -665,14 +787,14 @@ class x {
   optimistic(t) {
     if (this._disposed)
       throw new Error("Cannot perform optimistic update on disposed Collection");
-    const e = this._items;
+    const s = this._items, e = this._timestamps ? new Map(this._timestamps) : null;
     t();
-    let s = !1;
+    let i = !1;
     return () => {
-      if (s || this._disposed) return;
-      s = !0;
-      const i = this._items;
-      this._items = e, this.rebuildIndex(), this.notify(i);
+      if (i || this._disposed) return;
+      i = !0;
+      const n = this._items;
+      this._items = s, e && (this._timestamps = e), this.rebuildIndex(), this.notify(n), this._scheduleEvictionTimer();
     };
   }
   // ── Query Methods (pure, no notification) ──
@@ -713,52 +835,129 @@ class x {
     return this._items.map(t);
   }
   // ── Subscribable interface ──
+  /** Subscribes to state changes. Returns an unsubscribe function. */
   subscribe(t) {
     return this._disposed ? () => {
     } : (this._listeners.add(t), () => {
       this._listeners.delete(t);
     });
   }
+  /** Tears down the instance, releasing all subscriptions and resources. */
   dispose() {
     if (!this._disposed) {
-      if (this._disposed = !0, this._abortController?.abort(), this._cleanups) {
+      if (this._disposed = !0, this._clearEvictionTimer(), this._abortController?.abort(), this._cleanups) {
         for (const t of this._cleanups) t();
         this._cleanups = null;
       }
-      this.onDispose?.(), this._listeners.clear(), this._index.clear();
+      this.onDispose?.(), this._listeners.clear(), this._index.clear(), this._timestamps?.clear();
     }
   }
+  /** Registers a cleanup function to be called on dispose. @protected */
   addCleanup(t) {
     this._cleanups || (this._cleanups = []), this._cleanups.push(t);
   }
   notify(t) {
-    for (const e of this._listeners)
-      e(this._items, t);
+    for (const s of this._listeners)
+      s(this._items, t);
   }
   rebuildIndex() {
     this._index.clear();
     for (const t of this._items)
       this._index.set(t.id, t);
   }
+  // ── Eviction Internals ──
+  _evictForCapacity(t) {
+    const s = t.length - this._maxSize;
+    if (s <= 0) return t;
+    const e = t.slice(0, s), i = this._applyOnEvict(e, "capacity");
+    if (i === !1 || i.length === 0) return t;
+    const n = new Set(i.map((o) => o.id)), a = t.filter((o) => !n.has(o.id));
+    for (const o of i)
+      this._index.delete(o.id), this._timestamps?.delete(o.id);
+    return a;
+  }
+  _applyOnEvict(t, s) {
+    if (!this.onEvict) return t;
+    const e = this.onEvict(t, s);
+    if (e === !1) {
+      if (x && s === "capacity" && this._maxSize > 0) {
+        const i = this._items.length + t.length;
+        i > this._maxSize * 2 && console.warn(
+          `[mvc-kit] Collection exceeded 2x MAX_SIZE (${i}/${this._maxSize}). onEvict is vetoing eviction — this may cause unbounded growth.`
+        );
+      }
+      return !1;
+    }
+    if (Array.isArray(e)) {
+      const i = new Set(t.map((n) => n.id));
+      return e.filter((n) => i.has(n.id));
+    }
+    return t;
+  }
+  _sweepExpired() {
+    if (this._disposed || !this._timestamps || this._ttl <= 0) return;
+    const t = Date.now(), s = this._ttl, e = [];
+    for (const o of this._items) {
+      const l = this._timestamps.get(o.id);
+      l !== void 0 && t - l >= s && e.push(o);
+    }
+    if (e.length === 0) {
+      this._scheduleEvictionTimer();
+      return;
+    }
+    const i = this._applyOnEvict(e, "ttl");
+    if (i === !1) {
+      this._scheduleEvictionTimer();
+      return;
+    }
+    if (i.length === 0) {
+      this._scheduleEvictionTimer();
+      return;
+    }
+    const n = new Set(i.map((o) => o.id)), a = this._items;
+    this._items = Object.freeze(
+      a.filter((o) => !n.has(o.id))
+    );
+    for (const o of i)
+      this._index.delete(o.id), this._timestamps.delete(o.id);
+    this.notify(a), this._scheduleEvictionTimer();
+  }
+  _scheduleEvictionTimer() {
+    if (this._clearEvictionTimer(), this._disposed || !this._timestamps || this._ttl <= 0 || this._timestamps.size === 0) return;
+    const t = Date.now(), s = this._ttl;
+    let e = 1 / 0;
+    for (const n of this._timestamps.values())
+      n < e && (e = n);
+    const i = Math.max(0, e + s - t);
+    this._evictionTimer = setTimeout(() => this._sweepExpired(), i);
+  }
+  _clearEvictionTimer() {
+    this._evictionTimer !== null && (clearTimeout(this._evictionTimer), this._evictionTimer = null);
+  }
 }
-class D {
+class I {
   _disposed = !1;
   _initialized = !1;
   _abortController = null;
   _cleanups = null;
+  /** Whether this instance has been disposed. */
   get disposed() {
     return this._disposed;
   }
+  /** Whether init() has been called. */
   get initialized() {
     return this._initialized;
   }
+  /** AbortSignal that fires when this instance is disposed. Lazily created. */
   get disposeSignal() {
     return this._abortController || (this._abortController = new AbortController()), this._abortController.signal;
   }
+  /** Initializes the instance. Called automatically by React hooks after mount. */
   init() {
     if (!(this._initialized || this._disposed))
       return this._initialized = !0, this.onInit?.();
   }
+  /** Tears down the instance, releasing all subscriptions and resources. */
   dispose() {
     if (!this._disposed) {
       if (this._disposed = !0, this._abortController?.abort(), this._cleanups) {
@@ -768,12 +967,14 @@ class D {
       this.onDispose?.();
     }
   }
+  /** Registers a cleanup function to be called on dispose. @protected */
   addCleanup(t) {
     this._cleanups || (this._cleanups = []), this._cleanups.push(t);
   }
-  subscribeTo(t, e) {
-    const s = t.subscribe(e);
-    return this.addCleanup(s), s;
+  /** Subscribes to an external Subscribable with automatic cleanup on dispose. @protected */
+  subscribeTo(t, s) {
+    const e = t.subscribe(s);
+    return this.addCleanup(e), e;
   }
 }
 class P {
@@ -781,19 +982,24 @@ class P {
   _initialized = !1;
   _abortController = null;
   _cleanups = null;
+  /** Whether this instance has been disposed. */
   get disposed() {
     return this._disposed;
   }
+  /** Whether init() has been called. */
   get initialized() {
     return this._initialized;
   }
+  /** AbortSignal that fires when this instance is disposed. Lazily created. */
   get disposeSignal() {
     return this._abortController || (this._abortController = new AbortController()), this._abortController.signal;
   }
+  /** Initializes the instance. Called automatically by React hooks after mount. */
   init() {
     if (!(this._initialized || this._disposed))
       return this._initialized = !0, this.onInit?.();
   }
+  /** Tears down the instance, releasing all subscriptions and resources. */
   dispose() {
     if (!this._disposed) {
       if (this._disposed = !0, this._abortController?.abort(), this._cleanups) {
@@ -803,21 +1009,26 @@ class P {
       this.onDispose?.();
     }
   }
+  /** Registers a cleanup function to be called on dispose. @protected */
   addCleanup(t) {
     this._cleanups || (this._cleanups = []), this._cleanups.push(t);
   }
 }
-const m = typeof __MVC_KIT_DEV__ < "u" && __MVC_KIT_DEV__, k = Object.freeze({
+const g = typeof __MVC_KIT_DEV__ < "u" && __MVC_KIT_DEV__, k = Object.freeze({
   connected: !1,
   reconnecting: !1,
   attempt: 0,
   error: null
 });
-class I {
+class R {
   // Static config (subclass overrides)
+  /** Base delay (ms) for reconnection backoff. */
   static RECONNECT_BASE = 1e3;
+  /** Maximum delay cap (ms) for reconnection backoff. */
   static RECONNECT_MAX = 3e4;
+  /** Exponential backoff multiplier for reconnection delay. */
   static RECONNECT_FACTOR = 2;
+  /** Maximum number of reconnection attempts before giving up. */
   static MAX_ATTEMPTS = 1 / 0;
   // ── Internal state ──────────────────────────────────────────────
   _status = k;
@@ -831,9 +1042,11 @@ class I {
   _reconnectTimer = null;
   _cleanups = null;
   // ── Subscribable<ChannelStatus> ─────────────────────────────────
+  /** Current connection status. */
   get state() {
     return this._status;
   }
+  /** Subscribes to connection status changes. Returns an unsubscribe function. */
   subscribe(t) {
     return this._disposed ? () => {
     } : (this._listeners.add(t), () => {
@@ -841,19 +1054,24 @@ class I {
     });
   }
   // ── Disposable / Initializable ──────────────────────────────────
+  /** Whether this instance has been disposed. */
   get disposed() {
     return this._disposed;
   }
+  /** Whether init() has been called. */
   get initialized() {
     return this._initialized;
   }
+  /** AbortSignal that fires when this instance is disposed. Lazily created. */
   get disposeSignal() {
     return this._abortController || (this._abortController = new AbortController()), this._abortController.signal;
   }
+  /** Initializes the instance. Called automatically by React hooks after mount. */
   init() {
     if (!(this._initialized || this._disposed))
       return this._initialized = !0, this.onInit?.();
   }
+  /** Tears down the instance, releasing all subscriptions and resources. */
   dispose() {
     if (!this._disposed) {
       this._disposed = !0, this._connState = 4, this._reconnectTimer !== null && (clearTimeout(this._reconnectTimer), this._reconnectTimer = null), this._connectAbort?.abort(), this._connectAbort = null, this._abortController?.abort();
@@ -869,13 +1087,15 @@ class I {
     }
   }
   // ── Connection control ──────────────────────────────────────────
+  /** Initiates a connection with automatic reconnection on failure. */
   connect() {
     if (this._disposed) {
-      m && console.warn("[mvc-kit] connect() called after dispose — ignored.");
+      g && console.warn("[mvc-kit] connect() called after dispose — ignored.");
       return;
     }
-    m && !this._initialized && console.warn("[mvc-kit] connect() called before init()."), !(this._connState === 1 || this._connState === 2) && (this._reconnectTimer !== null && (clearTimeout(this._reconnectTimer), this._reconnectTimer = null), this._attemptConnect(0));
+    g && !this._initialized && console.warn("[mvc-kit] connect() called before init()."), !(this._connState === 1 || this._connState === 2) && (this._reconnectTimer !== null && (clearTimeout(this._reconnectTimer), this._reconnectTimer = null), this._attemptConnect(0));
   }
+  /** Closes the connection and cancels any pending reconnection. */
   disconnect() {
     if (!this._disposed) {
       if (this._reconnectTimer !== null && (clearTimeout(this._reconnectTimer), this._reconnectTimer = null), this._connectAbort?.abort(), this._connectAbort = null, this._connState === 2 || this._connState === 1) {
@@ -890,77 +1110,84 @@ class I {
     }
   }
   // ── Subclass signals ────────────────────────────────────────────
-  receive(t, e) {
+  /** Call from subclass when a message arrives from the transport. @protected */
+  receive(t, s) {
     if (this._disposed) {
-      m && console.warn(`[mvc-kit] receive("${String(t)}") called after dispose — ignored.`);
+      g && console.warn(`[mvc-kit] receive("${String(t)}") called after dispose — ignored.`);
       return;
     }
-    const s = this._handlers.get(t);
-    if (s)
-      for (const i of s)
-        i(e);
+    const e = this._handlers.get(t);
+    if (e)
+      for (const i of e)
+        i(s);
   }
+  /** Call from subclass when the transport connection drops unexpectedly. Triggers reconnection. @protected */
   disconnected() {
     this._disposed || this._connState !== 2 && this._connState !== 1 || (this._connectAbort?.abort(), this._connectAbort = null, this._connState = 3, this._scheduleReconnect(1));
   }
   // ── Consumer API ────────────────────────────────────────────────
-  on(t, e) {
+  /** Subscribes to a specific message type. Returns an unsubscribe function. */
+  on(t, s) {
     if (this._disposed) return () => {
     };
-    let s = this._handlers.get(t);
-    return s || (s = /* @__PURE__ */ new Set(), this._handlers.set(t, s)), s.add(e), () => {
-      s.delete(e);
+    let e = this._handlers.get(t);
+    return e || (e = /* @__PURE__ */ new Set(), this._handlers.set(t, e)), e.add(s), () => {
+      e.delete(s);
     };
   }
-  once(t, e) {
-    const s = this.on(t, (i) => {
-      s(), e(i);
+  /** Subscribes to a message type, auto-removing the handler after the first invocation. */
+  once(t, s) {
+    const e = this.on(t, (i) => {
+      e(), s(i);
     });
-    return s;
+    return e;
   }
   // ── Infrastructure ──────────────────────────────────────────────
+  /** Registers a cleanup function to be called on dispose. @protected */
   addCleanup(t) {
     this._cleanups || (this._cleanups = []), this._cleanups.push(t);
   }
-  subscribeTo(t, e) {
-    const s = t.subscribe(e);
-    return this.addCleanup(s), s;
+  /** Subscribes to an external Subscribable with automatic cleanup on dispose. @protected */
+  subscribeTo(t, s) {
+    const e = t.subscribe(s);
+    return this.addCleanup(e), e;
   }
   // ── Backoff ─────────────────────────────────────────────────────
+  /** Computes the reconnect backoff delay with jitter for the given attempt number. @protected */
   _calculateDelay(t) {
-    const e = this.constructor, s = Math.min(
-      e.RECONNECT_BASE * Math.pow(e.RECONNECT_FACTOR, t),
-      e.RECONNECT_MAX
+    const s = this.constructor, e = Math.min(
+      s.RECONNECT_BASE * Math.pow(s.RECONNECT_FACTOR, t),
+      s.RECONNECT_MAX
     );
-    return Math.random() * s;
+    return Math.random() * e;
   }
   // ── Internals ───────────────────────────────────────────────────
   _setStatus(t) {
-    const e = this._status;
-    if (!(e.connected === t.connected && e.reconnecting === t.reconnecting && e.attempt === t.attempt && e.error === t.error)) {
+    const s = this._status;
+    if (!(s.connected === t.connected && s.reconnecting === t.reconnecting && s.attempt === t.attempt && s.error === t.error)) {
       this._status = Object.freeze(t);
-      for (const s of this._listeners)
-        s(this._status, e);
+      for (const e of this._listeners)
+        e(this._status, s);
     }
   }
   _attemptConnect(t) {
     if (this._disposed) return;
     this._connState = 1, this._connectAbort?.abort(), this._connectAbort = new AbortController();
-    const e = this._abortController ? AbortSignal.any([this._abortController.signal, this._connectAbort.signal]) : this._connectAbort.signal;
+    const s = this._abortController ? AbortSignal.any([this._abortController.signal, this._connectAbort.signal]) : this._connectAbort.signal;
     this._setStatus({
       connected: !1,
       reconnecting: t > 0,
       attempt: t,
       error: null
     });
-    let s;
+    let e;
     try {
-      s = this.open(e);
+      e = this.open(s);
     } catch (i) {
       this._onOpenFailed(t, i);
       return;
     }
-    s && typeof s.then == "function" ? s.then(
+    e && typeof e.then == "function" ? e.then(
       () => this._onOpenSucceeded(),
       (i) => this._onOpenFailed(t, i)
     ) : this._onOpenSucceeded();
@@ -973,47 +1200,47 @@ class I {
       error: null
     }));
   }
-  _onOpenFailed(t, e) {
-    this._disposed || this._connState !== 0 && (this._connectAbort?.abort(), this._connectAbort = null, this._connState = 3, this._scheduleReconnect(t + 1, e));
+  _onOpenFailed(t, s) {
+    this._disposed || this._connState !== 0 && (this._connectAbort?.abort(), this._connectAbort = null, this._connState = 3, this._scheduleReconnect(t + 1, s));
   }
-  _scheduleReconnect(t, e) {
-    const s = this.constructor;
-    if (t > s.MAX_ATTEMPTS) {
+  _scheduleReconnect(t, s) {
+    const e = this.constructor;
+    if (t > e.MAX_ATTEMPTS) {
       this._connState = 0, this._setStatus({
         connected: !1,
         reconnecting: !1,
         attempt: t,
-        error: e instanceof Error ? e.message : "Max reconnection attempts reached"
+        error: s instanceof Error ? s.message : "Max reconnection attempts reached"
       });
       return;
     }
-    const i = e instanceof Error ? e.message : e ? String(e) : null;
+    const i = s instanceof Error ? s.message : s ? String(s) : null;
     this._setStatus({
       connected: !1,
       reconnecting: !0,
       attempt: t,
       error: i
     });
-    const o = this._calculateDelay(t - 1);
+    const n = this._calculateDelay(t - 1);
     this._reconnectTimer = setTimeout(() => {
       this._reconnectTimer = null, this._attemptConnect(t);
-    }, o);
+    }, n);
   }
 }
 export {
-  I as Channel,
-  x as Collection,
-  D as Controller,
-  y as EventBus,
-  w as HttpError,
-  M as Model,
+  R as Channel,
+  D as Collection,
+  I as Controller,
+  w as EventBus,
+  C as HttpError,
+  j as Model,
   P as Service,
-  b as ViewModel,
-  O as classifyError,
+  m as ViewModel,
+  E as classifyError,
   N as hasSingleton,
-  v as isAbortError,
-  V as singleton,
-  B as teardown,
-  L as teardownAll
+  y as isAbortError,
+  $ as singleton,
+  L as teardown,
+  B as teardownAll
 };
 //# sourceMappingURL=mvc-kit.js.map