fetchium 0.1.0 → 0.1.1

package/dist/esm/development/QueryClient-Dtde3pss.js

@@ -0,0 +1,2572 @@
+import { notifier as ft, relay as Tt, setScopeOwner as we, reactiveMethod as Ee, signal as Pt, context as jt, getContext as be, task as Ce, reactiveSignal as Se, isSignal as Oe, watcher as Re } from "signalium";
+import { registerCustomHash as xe, hashValue as N } from "signalium/utils";
+import { d as $t } from "./shared-DcuVH8Pf.js";
+import { SyncQueryStore as Ae, MemoryPersistentStore as Ne } from "./stores/sync.js";
+var V = /* @__PURE__ */ ((e) => (e.Always = "always", e.Online = "online", e.OfflineFirst = "offlineFirst", e))(V || {}), l = /* @__PURE__ */ ((e) => (e[e.UNDEFINED = 1] = "UNDEFINED", e[e.NULL = 2] = "NULL", e[e.NUMBER = 4] = "NUMBER", e[e.STRING = 8] = "STRING", e[e.BOOLEAN = 16] = "BOOLEAN", e[e.OBJECT = 32] = "OBJECT", e[e.ARRAY = 64] = "ARRAY", e[e.ID = 128] = "ID", e[e.RECORD = 256] = "RECORD", e[e.UNION = 512] = "UNION", e[e.ENTITY = 1024] = "ENTITY", e[e.HAS_FORMAT = 4096] = "HAS_FORMAT", e[e.IS_EAGER_FORMAT = 8192] = "IS_EAGER_FORMAT", e[e.PARSE_RESULT = 16384] = "PARSE_RESULT", e[e.LIVE = 32768] = "LIVE", e))(l || {});
+const D = /* @__PURE__ */ Symbol("array"), F = /* @__PURE__ */ Symbol("record"), Lt = /* @__PURE__ */ Symbol("QUERY_ID");
+var ut = /* @__PURE__ */ ((e) => (e[e.Array = 0] = "Array", e[e.Value = 1] = "Value", e))(ut || {});
+class B {
+  type;
+  entityDefs;
+  constraintFieldRefs;
+  sort;
+  valueType;
+  onCreate;
+  onUpdate;
+  onDelete;
+  constructor(t, n, i, r, s, o, a, c) {
+    this.type = t, this.entityDefs = n, this.constraintFieldRefs = i, this.sort = r, this.valueType = s, this.onCreate = o, this.onUpdate = a, this.onDelete = c;
+  }
+  static array(t, n, i) {
+    return new B(
+      0,
+      t,
+      n,
+      i,
+      void 0,
+      void 0,
+      void 0,
+      void 0
+    );
+  }
+  static value(t, n, i, r, s, o) {
+    return new B(
+      1,
+      t,
+      n,
+      void 0,
+      i,
+      r,
+      s,
+      o
+    );
+  }
+}
+const S = /* @__PURE__ */ new WeakMap();
+function T(e) {
+  return S.get(e);
+}
+var X = /* @__PURE__ */ ((e) => (e[e.Query = 0] = "Query", e[e.Entity = 1] = "Entity", e))(X || {});
+class Ie {
+  constructor(t, n, i) {
+    this._onEvict = n, this._intervalId = setInterval(this._tick, t * 6e4 * i);
+  }
+  _currentFlush = /* @__PURE__ */ new Map();
+  _nextFlush = /* @__PURE__ */ new Map();
+  _intervalId;
+  schedule(t, n) {
+    this._nextFlush.set(t, n);
+  }
+  cancel(t) {
+    this._currentFlush.delete(t), this._nextFlush.delete(t);
+  }
+  _tick = () => {
+    const { _currentFlush: t, _nextFlush: n, _onEvict: i } = this;
+    for (const [r, s] of t)
+      i(r, s);
+    this._currentFlush = n, this._nextFlush = /* @__PURE__ */ new Map();
+  };
+  destroy() {
+    clearInterval(this._intervalId);
+  }
+}
+class De {
+  _buckets = /* @__PURE__ */ new Map();
+  _nextTickEntries = /* @__PURE__ */ new Map();
+  _nextTickScheduled = !1;
+  _onEvict;
+  _multiplier;
+  constructor(t, n = 1) {
+    this._onEvict = t, this._multiplier = n;
+  }
+  schedule(t, n, i) {
+    if (n === 1 / 0) return;
+    if (n === 0) {
+      const { _nextTickEntries: o } = this;
+      o.set(t, i), this._nextTickScheduled || (this._nextTickScheduled = !0, setTimeout(this._flushNextTick, 0));
+      return;
+    }
+    const { _buckets: r } = this;
+    let s = r.get(n);
+    s || (s = new Ie(n, this._onEvict, this._multiplier), r.set(n, s)), s.schedule(t, i);
+  }
+  cancel(t, n) {
+    if (n !== 1 / 0) {
+      if (n === 0) {
+        this._nextTickEntries.delete(t);
+        return;
+      }
+      this._buckets.get(n)?.cancel(t);
+    }
+  }
+  _flushNextTick = () => {
+    const { _nextTickEntries: t, _onEvict: n } = this;
+    this._nextTickScheduled = !1;
+    for (const [i, r] of t)
+      n(i, r);
+    t.clear();
+  };
+  destroy() {
+    const { _buckets: t, _nextTickEntries: n } = this;
+    for (const i of t.values())
+      i.destroy();
+    t.clear(), n.clear();
+  }
+}
+class Fe {
+  schedule(t, n, i) {
+  }
+  cancel(t, n) {
+  }
+  destroy() {
+  }
+}
+const W = /* @__PURE__ */ Symbol("fieldRef"), I = /* @__PURE__ */ Symbol("fieldRefPath"), lt = /* @__PURE__ */ Symbol("DEFINITION_TARGET"), z = /* @__PURE__ */ Symbol("CANCEL_PROXY"), Me = /\[([^\]]+)\]/g;
+function Ut(e) {
+  const t = {
+    [W]: !0,
+    [I]: e
+  };
+  return new Proxy(t, ke);
+}
+const ke = {
+  get(e, t) {
+    if (t === W) return !0;
+    if (t === I) return e[I];
+    if (t === Symbol.toPrimitive || t === "toString" || t === "valueOf") {
+      const i = e[I];
+      return () => `[${i.join(".")}]`;
+    }
+    if (typeof t == "symbol") return;
+    const n = e[I];
+    return Ut([...n, t]);
+  },
+  has(e, t) {
+    return t === W || t === I;
+  }
+};
+function qt(e) {
+  return typeof e == "object" && e !== null && e[W] === !0;
+}
+function Vt(e) {
+  return e[I];
+}
+function Kt(e) {
+  let t = !1;
+  return new Proxy(e, {
+    set(n, i, r) {
+      return n[i] = r, !0;
+    },
+    get(n, i) {
+      if (t)
+        throw new Error("Definition proxy accessed after extraction. Avoid arrow functions that capture `this`.");
+      return i === lt ? n : i === z ? () => {
+        t = !0;
+      } : typeof i == "symbol" ? n[i] : Ut([i]);
+    }
+  });
+}
+function Te(e) {
+  const t = e[lt];
+  e[z]();
+  const n = {};
+  for (const s of Object.getOwnPropertyNames(t))
+    n[s] = t[s];
+  const i = {};
+  let r = Object.getPrototypeOf(t);
+  for (; r && r !== Object.prototype; ) {
+    for (const s of Object.getOwnPropertyNames(r)) {
+      if (s === "constructor") continue;
+      const o = Object.getOwnPropertyDescriptor(r, s);
+      typeof o.value == "function" && !(s in i) && (i[s] = o.value);
+    }
+    r = Object.getPrototypeOf(r);
+  }
+  return { fields: n, methods: i };
+}
+function dt(e, t) {
+  let n = t;
+  for (const i of e) {
+    if (n == null) return;
+    n = n[i];
+  }
+  return n;
+}
+function Pe(e, t) {
+  return e.replace(Me, (n, i) => {
+    const r = i.split("."), s = dt(r, t);
+    return s != null ? encodeURIComponent(String(s)) : "";
+  });
+}
+function J(e, t) {
+  if (qt(e))
+    return dt(Vt(e), t);
+  if (typeof e == "string")
+    return Pe(e, t);
+  if (Array.isArray(e))
+    return e.map((n) => J(n, t));
+  if (typeof e == "object" && e !== null && Object.getPrototypeOf(e) === Object.prototype) {
+    const n = {};
+    for (const i of Object.keys(e))
+      n[i] = J(e[i], t);
+    return n;
+  }
+  return e;
+}
+function it(e, t, n) {
+  const i = e.fields, r = e.methods, s = { params: t }, o = {};
+  for (const [a, c] of Object.entries(i))
+    o[a] = J(c, s);
+  o.params = t, o.context = n;
+  for (const [a, c] of Object.entries(r))
+    o[a] = c.bind(o);
+  return o;
+}
+class Bt {
+  static cache;
+  constructor() {
+    return Kt(this);
+  }
+}
+const Qt = Object.entries, rt = Object.keys;
+let Yt = () => {
+};
+{
+  const t = (i, r) => {
+    if (i.size !== r.size) return !1;
+    for (const s of i)
+      if (!r.has(s)) return !1;
+    return !0;
+  }, n = (i, r) => {
+    if (i === r) return !0;
+    if (typeof i != typeof r) return !1;
+    if (typeof i == "number") {
+      const s = r;
+      if ((i & 65535) !== (s & 65535)) return !1;
+      const o = i >> 16, a = s >> 16;
+      return !(o !== 0 && a !== 0 && o !== a);
+    }
+    if (typeof i == "string") return i === r;
+    if (i instanceof Set && r instanceof Set)
+      return t(i, r);
+    if (i instanceof m && r instanceof m) {
+      const s = i.mask, o = r.mask;
+      if ((s & 65535) !== (o & 65535)) return !1;
+      const a = s >> 16, c = o >> 16;
+      if (a !== 0 && c !== 0 && a !== c) return !1;
+      if (i.shape === r.shape) return !0;
+      if (i.shape !== void 0 && r.shape !== void 0 && typeof i.shape == "object" && typeof r.shape == "object") {
+        const f = i.shape, d = r.shape;
+        for (const u of Object.keys(f))
+          if (u in d && !n(f[u], d[u])) return !1;
+        for (const u of Object.keys(d))
+          if (u in f && !n(f[u], d[u])) return !1;
+      }
+      return !0;
+    }
+    return !1;
+  };
+  Yt = (i, r, s, o) => {
+    if (!n(s, o))
+      throw new Error(
+        `[fetchium] Entity typename '${i}' has incompatible type for field '${r}' across different entity definitions`
+      );
+  };
+}
+function Ct(e) {
+  return typeof e == "number" ? e | l.UNDEFINED : e instanceof m ? (e.mask & l.UNDEFINED) !== 0 ? e : m.cloneWith(e, l.UNDEFINED) : e;
+}
+function St(e) {
+  return e instanceof m && (e.mask & l.OBJECT) !== 0 && (e.mask & (l.ENTITY | l.ARRAY | l.UNION | l.RECORD | l.LIVE)) === 0;
+}
+function Gt(e, t, n) {
+  const i = /* @__PURE__ */ new Set();
+  for (const s of e)
+    if (s !== void 0)
+      for (const o of Object.keys(s))
+        i.add(o);
+  const r = {};
+  for (const s of i) {
+    let o = 0, a;
+    const c = [];
+    let f = !0;
+    for (const d of e) {
+      const u = d?.[s];
+      u !== void 0 ? (o++, a === void 0 && (a = u), a !== void 0 && u !== a && !St(u) && Yt(n, s, a, u), St(u) ? c.push(u.shape) : (f = !1, c.push(void 0))) : (f = !1, c.push(void 0));
+    }
+    if (f && o > 0) {
+      const d = Gt(c, t, n), u = new m(l.OBJECT, d);
+      r[s] = o < t ? Ct(u) : u;
+    } else
+      r[s] = o < t ? Ct(a) : a;
+  }
+  return r;
+}
+class m {
+  mask;
+  shape;
+  typenameField = void 0;
+  typenameValue = void 0;
+  idField = void 0;
+  values = void 0;
+  /**
+   * Methods object for entity definitions.
+   * Shared across all proxies, but each proxy binds its own reactive method wrappers.
+   */
+  _methods = void 0;
+  /**
+   * Entity configuration including stream options.
+   */
+  _entityConfig = void 0;
+  /**
+   * The original Entity class for this definition.
+   * Used by createEntityProxy to set the proxy prototype so `instanceof` works.
+   */
+  _entityClass = void 0;
+  /**
+   * Entity cache options (e.g. gcTime for in-memory eviction).
+   */
+  _entityCache = void 0;
+  /**
+   * Live data configuration (shared by LiveArray and LiveValue).
+   */
+  _liveConfig = void 0;
+  constructor(t, n, i, r, s, o) {
+    this.mask = t, this.shape = n, this.values = i, this.typenameField = r, this.typenameValue = s, this.idField = o;
+  }
+  static merge(t) {
+    if (t.length === 1) return t[0];
+    const n = t.length, i = t.map((f) => f.shape), r = t[0].typenameValue ?? "(unknown)", s = Gt(i, n, r);
+    let o, a, c;
+    for (const f of t) {
+      if (o === void 0 && f.idField !== void 0)
+        o = f.idField;
+      else if (o !== void 0 && f.idField !== void 0 && f.idField !== o)
+        throw new Error(
+          `[fetchium] Entity typename '${f.typenameValue}' has conflicting id fields: '${String(o)}' vs '${String(f.idField)}'`
+        );
+      a === void 0 && (a = f.typenameField), c === void 0 && (c = f.typenameValue);
+    }
+    return new m(
+      l.ENTITY | l.OBJECT,
+      s,
+      void 0,
+      a,
+      c,
+      o
+    );
+  }
+  static cloneWith(t, n) {
+    const i = new m(
+      n | t.mask,
+      t.shape,
+      t.values,
+      t.typenameField,
+      t.typenameValue,
+      t.idField
+    );
+    return i._methods = t._methods, i._entityConfig = t._entityConfig, i._entityClass = t._entityClass, i._entityCache = t._entityCache, i._liveConfig = t._liveConfig, i;
+  }
+}
+class $ extends Set {
+  lowercaseMap;
+  // lowercase -> canonical (strings only)
+  constructor(t) {
+    super(t), this.lowercaseMap = /* @__PURE__ */ new Map();
+    for (const n of t)
+      if (typeof n == "string") {
+        const i = n.toLowerCase(), r = this.lowercaseMap.get(i);
+        if (r !== void 0)
+          throw new Error(
+            `Case-insensitive enum cannot have multiple values with the same lowercase form: '${r}' and '${n}' both become '${i}'`
+          );
+        this.lowercaseMap.set(i, n);
+      }
+  }
+  /**
+   * Check if a value exists in the set (case-insensitively for strings).
+   * Used for backwards compatibility with Set-based checks.
+   */
+  has(t) {
+    return this.get(t) !== void 0;
+  }
+  /**
+   * Get the canonical value for a given input.
+   * For strings, performs case-insensitive lookup and returns the canonical casing.
+   * For numbers/booleans, performs exact match.
+   * Returns undefined if no match is found.
+   */
+  get(t) {
+    if (typeof t == "string")
+      return this.lowercaseMap.get(t.toLowerCase());
+    if (super.has(t))
+      return t;
+  }
+}
+const je = 1128875347;
+xe($, (e) => {
+  let t = je;
+  for (const n of e)
+    t += N(n);
+  return t >>> 0;
+});
+function ht(e, t) {
+  return new m(e, t);
+}
+function $e(e) {
+  return ht(l.ARRAY, e);
+}
+function Le(e) {
+  return ht(l.RECORD | l.OBJECT, e);
+}
+function Ue(e) {
+  return ht(l.PARSE_RESULT, e);
+}
+function Ht(e, t) {
+  let n = e, i, r, s;
+  for (const [o, a] of Qt(t))
+    switch (typeof a) {
+      case "number":
+        if ((a & l.ID) !== 0) {
+          if (i !== void 0)
+            throw new Error(`Duplicate id field: ${o}`);
+          i = o;
+        }
+        break;
+      case "string":
+        if (r !== void 0 && r !== o)
+          throw new Error(`Duplicate typename field: ${o}`);
+        r = o, s = a;
+        break;
+      case "object":
+        if (a instanceof $ || a instanceof Set)
+          break;
+        a.mask & l.LIVE && (n |= l.LIVE);
+        break;
+    }
+  return new m(n, t, void 0, r, s, i);
+}
+function qe(e) {
+  return Ht(l.OBJECT, e);
+}
+function Ot(e, t, n) {
+  const i = e.mask;
+  if ((i & l.UNION) !== 0) {
+    const r = e;
+    if (r.typenameField !== void 0) {
+      if (n !== void 0 && n !== r.typenameField)
+        throw new Error(
+          `Union typename field conflict: Cannot merge unions with different typename fields ('${n}' vs '${r.typenameField}')`
+        );
+      n = r.typenameField;
+    }
+    const s = r.shape;
+    if (s !== void 0)
+      for (const o of [...rt(s), D, F]) {
+        const a = s[o];
+        if (t[o] !== void 0 && t[o] !== a)
+          throw new Error(
+            `Union merge conflict: Duplicate typename value '${String(o)}' found when merging nested unions (${String(t[o])} vs ${String(a)})`
+          );
+        t[o] = a;
+      }
+  } else if ((i & l.ARRAY) !== 0) {
+    if (t[D] !== void 0)
+      throw new Error("Array shape already defined");
+    t[D] = e.shape;
+  } else if ((i & l.RECORD) !== 0) {
+    if (t[F] !== void 0)
+      throw new Error("Record shape already defined");
+    t[F] = e.shape;
+  } else {
+    const r = e.typenameField, s = e.typenameValue;
+    if (s === void 0)
+      throw new Error(
+        "Object definitions must have a typename to be in a union with other objects, records, or arrays"
+      );
+    if (n !== void 0 && r !== n)
+      throw new Error("Object definitions must have the same typename field to be in the same union");
+    n = r, t[s] = e;
+  }
+  return n;
+}
+function yt(...e) {
+  const t = e;
+  let n = 0, i = 0, r, s, o, a, c = 0;
+  for (const d of t) {
+    if (typeof d == "number") {
+      n |= d;
+      continue;
+    }
+    if (d instanceof Set) {
+      if (s === void 0)
+        s = new Set(d);
+      else
+        for (const u of d)
+          s.add(u);
+      continue;
+    }
+    if (i++, c |= d.mask, i === 1) {
+      r = d;
+      continue;
+    }
+    i === 2 && (o = /* @__PURE__ */ Object.create(null), a = Ot(r, o, a)), a = Ot(d, o, a);
+  }
+  if (i === 0)
+    return s === void 0 ? n : n === 0 ? s : new m(n | l.UNION, void 0, s);
+  if (i === 1)
+    return m.cloneWith(r, n);
+  const f = n | c | l.UNION;
+  return new m(f, o, s, a);
+}
+function pt(e, t, n) {
+  const i = e;
+  if (typeof i == "number")
+    return i | t;
+  if (i instanceof Set)
+    return yt(e, t);
+  let r = n.get(i);
+  return r === void 0 && (r = m.cloneWith(i, t), n.set(i, r)), r;
+}
+const Ve = /* @__PURE__ */ new WeakMap(), Ke = /* @__PURE__ */ new WeakMap(), Be = /* @__PURE__ */ new WeakMap();
+function Qe(e) {
+  return pt(e, l.UNDEFINED | l.NULL, Be);
+}
+function Ye(e) {
+  return pt(e, l.UNDEFINED, Ve);
+}
+function Ge(e) {
+  return pt(e, l.NULL, Ke);
+}
+function He(e) {
+  return e;
+}
+function We(e) {
+  return /* @__PURE__ */ new Set([e]);
+}
+const Wt = ((...e) => new Set(e));
+Wt.caseInsensitive = (...e) => new $(e);
+const gt = 16;
+let ze = 0;
+const st = [], zt = [], Jt = /* @__PURE__ */ new Map(), Xt = /* @__PURE__ */ new Map(), Z = /* @__PURE__ */ new WeakSet();
+class Q {
+  _raw;
+  _formatted;
+  _parsed;
+  _formatId;
+  constructor(t, n, i) {
+    this._raw = t, this._formatId = n, i ? (this._formatted = st[n](t), this._parsed = !0) : this._parsed = !1, Z.add(this);
+  }
+  getValue() {
+    return this._parsed || (this._formatted = st[this._formatId](this._raw), this._parsed = !0), this._formatted;
+  }
+  toJSON() {
+    return this._parsed ? zt[this._formatId](this._formatted) : this._raw;
+  }
+}
+function Je(e) {
+  const t = Jt.get(e);
+  if (t === void 0)
+    throw new Error(`Format ${e} not registered`);
+  return t;
+}
+function Rt(e) {
+  const t = e >> gt;
+  return Xt.get(t);
+}
+function Zt(e, t, n, i, r) {
+  const s = ze++;
+  st[s] = n, zt[s] = i, Xt.set(s, e);
+  const o = r?.eager ?? !0, c = s << gt | t | l.HAS_FORMAT | (o ? l.IS_EAGER_FORMAT : 0);
+  Jt.set(e, c);
+}
+Zt(
+  "date",
+  l.STRING,
+  (e) => {
+    const t = e.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+    if (!t)
+      throw new Error(`Invalid date string: ${e}. Expected YYYY-MM-DD format.`);
+    const [, n, i, r] = t, s = new Date(Date.UTC(parseInt(n, 10), parseInt(i, 10) - 1, parseInt(r, 10)));
+    if (isNaN(s.getTime()))
+      throw new Error(`Invalid date string: ${e}`);
+    return s;
+  },
+  (e) => {
+    const t = e.getUTCFullYear(), n = String(e.getUTCMonth() + 1).padStart(2, "0"), i = String(e.getUTCDate()).padStart(2, "0");
+    return `${t}-${n}-${i}`;
+  }
+);
+Zt(
+  "date-time",
+  l.STRING,
+  (e) => {
+    const t = new Date(e);
+    if (isNaN(t.getTime()))
+      throw new Error(`Invalid date-time string: ${e}`);
+    return t;
+  },
+  (e) => e.toISOString()
+);
+const xt = /* @__PURE__ */ new WeakMap();
+function j(e) {
+  let t = xt.get(e);
+  if (t === void 0) {
+    const n = new e(), i = n[lt] ?? n;
+    n[z] && n[z]();
+    const r = {};
+    for (const [f, d] of Qt(i)) {
+      if (!(typeof d == "number" || typeof d == "string" || d instanceof Set || d instanceof m || d instanceof $))
+        throw new Error(
+          `[fetchium] Entity '${e.name}' field '${f}' has an invalid type definition. All entity fields must be type definitions (e.g. t.string, t.number, t.entity(...), etc). Got: ${typeof d == "object" ? d?.constructor?.name ?? typeof d : typeof d}`
+        );
+      r[f] = d;
+    }
+    const s = Object.getPrototypeOf(e.prototype);
+    if (s != null) {
+      const f = s.constructor;
+      if (f !== Bt && typeof f == "function") {
+        const u = j(f).shape;
+        for (const h of rt(u))
+          if (h in r && r[h] !== u[h])
+            throw new Error(`Cannot extend: field '${h}' already exists in type definition`);
+      }
+    }
+    const o = {}, a = e.prototype;
+    for (const f of Object.getOwnPropertyNames(a))
+      f !== "constructor" && typeof a[f] == "function" && (o[f] = a[f]);
+    t = Ht(l.ENTITY | l.OBJECT, r), t._entityClass = e, rt(o).length > 0 && (t._methods = o), typeof o.__subscribe == "function" && (t._entityConfig = { hasSubscribe: !0 });
+    const c = e;
+    c.cache && (t._entityCache = c.cache), xt.set(e, t);
+  }
+  return t;
+}
+function Xe(e) {
+  return j(e);
+}
+function te(e, t) {
+  if (t == null) return;
+  const n = /* @__PURE__ */ new Map();
+  if (Array.isArray(t))
+    for (const i of t) {
+      const [r, s] = i, a = j(r).typenameValue;
+      if (a === void 0) continue;
+      const c = [];
+      for (const [f, d] of Object.entries(s))
+        c.push([f, d]);
+      c.length > 0 && n.set(a, c);
+    }
+  else {
+    const r = Object.entries(t);
+    if (r.length === 0) return;
+    const s = r.map(([o, a]) => [o, a]);
+    for (const o of e) {
+      const a = o.typenameValue;
+      a !== void 0 && n.set(a, s);
+    }
+  }
+  return n.size > 0 ? n : void 0;
+}
+function ee(e) {
+  return Array.isArray(e) ? e.map((t) => j(t)) : [j(e)];
+}
+function Ze(e, t) {
+  const n = ee(e), i = n.length === 1 ? n[0] : yt(...n.map((o) => o)), r = l.ARRAY | l.LIVE, s = new m(r, i);
+  return s._liveConfig = B.array(
+    n,
+    te(n, t?.constraints),
+    t?.sort
+  ), s;
+}
+function tn(e, t, n) {
+  const i = ee(t), r = e, s = l.LIVE, o = new m(s, void 0);
+  return o._liveConfig = B.value(
+    i,
+    te(i, n?.constraints),
+    r,
+    n.onCreate,
+    n.onUpdate,
+    n.onDelete
+  ), o;
+}
+const en = {
+  format: Je,
+  typename: He,
+  const: We,
+  enum: Wt,
+  id: l.ID | l.STRING | l.NUMBER,
+  string: l.STRING,
+  number: l.NUMBER,
+  boolean: l.BOOLEAN,
+  null: l.NULL,
+  undefined: l.UNDEFINED,
+  array: $e,
+  object: qe,
+  record: Le,
+  union: yt,
+  nullish: Qe,
+  optional: Ye,
+  nullable: Ge,
+  result: Ue,
+  entity: Xe,
+  liveArray: Ze,
+  liveValue: tn
+};
+function K(e) {
+  if (e instanceof $)
+    return Array.from(e).map((i) => typeof i == "string" ? `"${i}"` : String(i)).join(" | ");
+  if (e instanceof Set)
+    return Array.from(e).map((i) => typeof i == "string" ? `"${i}"` : String(i)).join(" | ");
+  if (typeof e == "string")
+    return `"${e}"`;
+  if (typeof e == "boolean")
+    return String(e);
+  if (typeof e == "number") {
+    if ((e & l.HAS_FORMAT) !== 0) {
+      const r = Rt(e);
+      if (r)
+        return `"${r}"`;
+    }
+    const i = [];
+    return e & l.UNDEFINED && i.push("undefined"), e & l.NULL && i.push("null"), e & l.NUMBER && i.push("number"), e & l.STRING && i.push("string"), e & l.BOOLEAN && i.push("boolean"), e & l.OBJECT && i.push("object"), e & l.ARRAY && i.push("array"), i.length === 0 ? "unknown" : i.length === 1 ? i[0] : i.join(" | ");
+  }
+  let t = e.mask;
+  if (t & l.UNION) {
+    const n = e, i = [];
+    if (n.values !== void 0 && n.values.size > 0)
+      for (const s of n.values) {
+        const o = typeof s == "string" ? `"${s}"` : String(s);
+        i.push(o);
+      }
+    if (n.shape !== void 0) {
+      n.shape[D] !== void 0 && i.push(`Array<${K(n.shape[D])}>`), n.shape[F] !== void 0 && i.push(`Record<string, ${K(n.shape[F])}>`);
+      for (const [s, o] of Object.entries(n.shape))
+        s !== D && s !== F && i.push(s);
+    }
+    if (t = n.mask, (t & l.HAS_FORMAT) !== 0) {
+      const s = Rt(t);
+      s && i.push(`"${s}"`);
+    }
+    return t & l.UNDEFINED && i.push("undefined"), t & l.NULL && i.push("null"), t & l.NUMBER && i.push("number"), t & l.STRING && i.push("string"), t & l.BOOLEAN && i.push("boolean"), i.length === 0 ? "union" : i.join(" | ");
+  }
+  if (t & l.ENTITY)
+    return `Entity<${e.typenameValue}>`;
+  if (t & l.ARRAY) {
+    const n = e.shape;
+    return `Array<${K(n)}>`;
+  }
+  if (t & l.RECORD) {
+    const n = e.shape;
+    return `Record<string, ${K(n)}>`;
+  }
+  if (t & l.OBJECT) {
+    const n = e.typenameValue;
+    return n ? `Object<${n}>` : "object";
+  }
+  return "unknown";
+}
+function q(e, t, n) {
+  return new TypeError(
+    `Validation error at ${e}: expected ${K(t)}, got ${typeof n == "object" ? n === null ? "null" : Array.isArray(n) ? "array" : "object" : typeof n}`
+  );
+}
+const ne = Array.isArray;
+function At(e) {
+  if (e === null) return l.NULL;
+  switch (typeof e) {
+    case "number":
+      return l.NUMBER;
+    case "string":
+      return l.STRING;
+    case "boolean":
+      return l.BOOLEAN;
+    case "undefined":
+      return l.UNDEFINED;
+    case "object":
+      return ne(e) ? l.ARRAY : l.OBJECT;
+    default:
+      throw new Error(`Invalid type: ${typeof e}`);
+  }
+}
+function kn(e) {
+  return P(e);
+}
+function P(e) {
+  if (e === null || typeof e != "object")
+    return e;
+  if (ne(e))
+    return e.map((n) => P(n));
+  if (e instanceof Date)
+    return new Date(e.getTime());
+  if (e instanceof Map) {
+    const n = /* @__PURE__ */ new Map();
+    for (const [i, r] of e)
+      n.set(P(i), P(r));
+    return n;
+  }
+  if (e instanceof Set) {
+    const n = /* @__PURE__ */ new Set();
+    for (const i of e)
+      n.add(P(i));
+    return n;
+  }
+  const t = {};
+  for (const n of Object.keys(e))
+    t[n] = P(e[n]);
+  return t;
+}
+const mt = Object.entries, nn = () => {
+};
+class ot {
+  queryClient = void 0;
+  preloadedEntities = void 0;
+  warn = nn;
+  /** When true, missing optional fields on existing entities are set to
+   *  undefined. False for mutation events (truly partial payloads). */
+  isPartialEvent = !1;
+  seen = void 0;
+  seenByKey = void 0;
+  reset(t, n, i, r = !1) {
+    this.queryClient = t, this.preloadedEntities = n, this.warn = i, this.isPartialEvent = r, t !== void 0 && (this.seen === void 0 ? (this.seen = /* @__PURE__ */ new Map(), this.seenByKey = /* @__PURE__ */ new Map()) : (this.seen.clear(), this.seenByKey.clear()));
+  }
+}
+function ie(e, t, n) {
+  return M(e, t, n, "");
+}
+function rn(e, t, n) {
+  return vt(e, t, n);
+}
+function Nt(e, t, n, i) {
+  const r = e >> gt;
+  if ((e & l.IS_EAGER_FORMAT) !== 0)
+    try {
+      return new Q(t, r, !0);
+    } catch (o) {
+      if ((e & l.UNDEFINED) !== 0) {
+        n.warn("Invalid formatted value for optional type, defaulting to undefined", {
+          value: t,
+          path: i,
+          error: o instanceof Error ? o.message : String(o)
+        });
+        return;
+      }
+      throw o;
+    }
+  return new Q(t, r, !1);
+}
+function M(e, t, n, i) {
+  const r = t;
+  if (r instanceof $) {
+    const c = r.get(e);
+    if (c === void 0) throw q(i, r, e);
+    return c;
+  }
+  if (r instanceof Set) {
+    if (!r.has(e)) throw q(i, r, e);
+    return e;
+  }
+  if (typeof r == "string") {
+    if (e == null) return r;
+    if (e !== r) throw q(i, r, e);
+    return e;
+  }
+  if (typeof r == "number") {
+    const c = At(e);
+    if ((r & c) === 0) {
+      if ((r & l.UNDEFINED) !== 0) {
+        n.warn("Invalid value for optional type, defaulting to undefined", { value: e, path: i });
+        return;
+      }
+      throw q(i, r, e);
+    }
+    return (r & l.HAS_FORMAT) !== 0 && e !== null && e !== void 0 ? Nt(r, e, n, i) : e;
+  }
+  const s = r.mask, o = r._liveConfig;
+  if (o !== void 0 && o.type === ut.Value)
+    return o.valueType !== void 0 ? M(e, o.valueType, n, i) : e;
+  if ((s & l.PARSE_RESULT) !== 0)
+    try {
+      return { success: !0, value: M(e, r.shape, n, i) };
+    } catch (c) {
+      return { success: !1, error: c instanceof Error ? c : new Error(String(c)) };
+    }
+  const a = At(e);
+  if ((s & a) === 0 && !r.values?.has(e)) {
+    if ((s & l.UNDEFINED) !== 0) {
+      n.warn("Invalid value for optional type, defaulting to undefined", { value: e, path: i });
+      return;
+    }
+    throw q(i, s, e);
+  }
+  return a < l.OBJECT ? (s & l.HAS_FORMAT) !== 0 && e !== null && e !== void 0 ? Nt(s, e, n, i) : e : (s & l.UNION) !== 0 ? sn(a, e, r, n, i) : a === l.ARRAY ? re(e, r.shape, n, i) : (s & l.RECORD) !== 0 ? se(e, r.shape, n, i) : (s & l.ENTITY) !== 0 && n.queryClient !== void 0 ? vt(e, r, n) : oe(e, r, n, i);
+}
+function sn(e, t, n, i, r) {
+  if (e === l.ARRAY) {
+    const s = n.shape[D];
+    return s === void 0 || typeof s == "number" ? t : re(t, s, i, r);
+  } else {
+    const s = n.typenameField, o = s ? t[s] : void 0;
+    if (o === void 0 || typeof o != "string") {
+      const c = n.shape[F];
+      if (c === void 0)
+        throw new Error(
+          `Typename field '${s}' is required for union discrimination but was not found in the data`
+        );
+      return se(t, c, i, r);
+    }
+    const a = n.shape[o];
+    if (a === void 0 || typeof a == "number")
+      throw new Error(`Unknown typename '${o}' in union`);
+    return a.mask & l.ENTITY && i.queryClient !== void 0 ? vt(t, a, i) : oe(t, a, i, r);
+  }
+}
+function re(e, t, n, i) {
+  const r = [];
+  for (let s = 0; s < e.length; s++)
+    try {
+      r.push(M(e[s], t, n, `${i}[${s}]`));
+    } catch (o) {
+      n.warn("Failed to parse array item, filtering out", {
+        index: s,
+        value: e[s],
+        error: o instanceof Error ? o.message : String(o)
+      });
+    }
+  return r;
+}
+function se(e, t, n, i) {
+  for (const [r, s] of mt(e))
+    e[r] = M(s, t, n, `${i}["${r}"]`);
+  return e;
+}
+function oe(e, t, n, i) {
+  if (S.has(e))
+    return e;
+  const r = t.shape;
+  for (const [s, o] of mt(r))
+    e[s] = M(e[s], o, n, `${i}.${s}`);
+  return e;
+}
+function vt(e, t, n) {
+  const i = n.queryClient, r = n.preloadedEntities;
+  let s, o;
+  if (r !== void 0)
+    s = e.__entityRef, o = s;
+  else {
+    const p = e[t.idField];
+    if (p == null || typeof p != "string" && typeof p != "number")
+      throw new Error(`Entity id must be a string or number: ${t.typenameValue} (got ${typeof p})`);
+    o = p, s = N([t.typenameValue, o]);
+  }
+  const a = n.seenByKey.get(s);
+  if (a !== void 0)
+    return a.data;
+  if (r !== void 0) {
+    const w = i.entityMap.getEntity(s)?.data ?? r.get(s);
+    if (w === void 0)
+      throw new Error(`Cached entity ${s} not found in preloaded map`);
+    e = w;
+  }
+  const c = {};
+  typeof t.idField == "symbol" && (c[t.idField] = o);
+  const f = i.entityMap.getEntity(s), d = n.isPartialEvent && f !== void 0, u = {
+    key: s,
+    shape: t,
+    data: c,
+    rawKeys: d ? new Set(Object.keys(e)) : void 0
+  };
+  n.seen.set(c, u), n.seenByKey.set(s, u);
+  const h = `[[${t.typenameValue}:${o}]]`, g = t.shape;
+  for (const [p, w] of mt(g))
+    d && !(p in e) || (c[p] = M(e[p], w, n, `${h}.${p}`));
+  return c;
+}
+function on(e, t) {
+  return an(e, t.shape, t.typenameField);
+}
+function an(e, t, n) {
+  if (t === void 0) return !0;
+  for (const i of Object.keys(t)) {
+    if (i === n) continue;
+    const r = t[i];
+    if (r instanceof m) {
+      if ((r.mask & l.UNDEFINED) !== 0) continue;
+      if (!(i in e) || e[i] === void 0) return !1;
+    } else if (typeof r == "number") {
+      if ((r & l.UNDEFINED) !== 0) continue;
+      if (!(i in e) || e[i] === void 0) return !1;
+    } else if (!(i in e) || e[i] === void 0) return !1;
+  }
+  return !0;
+}
+const cn = Object.prototype, H = /* @__PURE__ */ new WeakMap();
+function A(e) {
+  if (typeof e != "object" || e === null) return e;
+  if (Z.has(e)) return A(e.getValue());
+  if (S.has(e)) return e;
+  if (Array.isArray(e)) {
+    let t = H.get(e);
+    return t === void 0 && (t = new Proxy(e, fn), H.set(e, t)), t;
+  }
+  if (Object.getPrototypeOf(e) === cn) {
+    let t = H.get(e);
+    return t === void 0 && (t = new Proxy(e, un), H.set(e, t)), t;
+  }
+  return e;
+}
+const fn = {
+  get(e, t, n) {
+    if (typeof t == "string") {
+      const i = Number(t);
+      if (Number.isInteger(i) && i >= 0 && i < e.length)
+        return A(e[i]);
+    }
+    return Reflect.get(e, t, n);
+  },
+  set() {
+    throw new Error("Cannot mutate a read-only array");
+  },
+  deleteProperty() {
+    throw new Error("Cannot mutate a read-only array");
+  }
+}, un = {
+  get(e, t, n) {
+    return typeof t == "string" ? A(e[t]) : Reflect.get(e, t, n);
+  },
+  set() {
+    throw new Error("Cannot mutate a read-only object");
+  },
+  deleteProperty() {
+    throw new Error("Cannot mutate a read-only object");
+  },
+  has(e, t) {
+    return t in e;
+  },
+  ownKeys(e) {
+    return Reflect.ownKeys(e);
+  },
+  getOwnPropertyDescriptor(e, t) {
+    return Object.getOwnPropertyDescriptor(e, t);
+  }
+};
+class ln {
+  _notifier;
+  _queryClient;
+  _proxies = /* @__PURE__ */ new Map();
+  key;
+  typename;
+  id;
+  idField;
+  data;
+  refCount = 0;
+  entityRefs;
+  liveCollections = [];
+  satisfiedDefs = /* @__PURE__ */ new WeakSet();
+  parseId = -1;
+  _entityCache;
+  _extraMethods;
+  _extraGetters;
+  constructor(t, n, i, r, s, o) {
+    this._notifier = ft(), this._queryClient = o, this.key = t, this.typename = n, this.id = i, this.idField = r, this.data = s, this.entityRefs = void 0;
+  }
+  retain() {
+    this.refCount++;
+    const t = this._entityCache?.gcTime;
+    t !== void 0 && this._queryClient.gcManager.cancel(this.key, t);
+  }
+  release() {
+    if (--this.refCount > 0) return;
+    if (this.refCount < 0)
+      throw new Error(`Entity ${this.typename}:${this.id} released more times than retained`);
+    const t = this._entityCache?.gcTime;
+    t !== void 0 ? this._queryClient.gcManager.schedule(this.key, t, X.Entity) : this.evict();
+  }
+  evict() {
+    const t = this.liveCollections.slice();
+    this.liveCollections.length = 0;
+    for (const i of t) i.destroy();
+    this._queryClient.entityMap.remove(this.key);
+    const n = this.entityRefs;
+    if (this.entityRefs = void 0, n)
+      for (const i of n.keys()) i.release();
+  }
+  setChildRefs(t, n) {
+    const i = this.entityRefs;
+    if (t !== void 0 && t.size > 0)
+      for (const r of t.keys())
+        (i === void 0 || !i.has(r)) && r.retain();
+    if (i !== void 0 && i.size > 0)
+      for (const r of i.keys())
+        (t === void 0 || !t.has(r)) && r.release();
+    this.entityRefs = t, n && this.save();
+  }
+  addChildRef(t) {
+    this.entityRefs === void 0 && (this.entityRefs = /* @__PURE__ */ new Map());
+    const n = this.entityRefs.get(t) ?? 0;
+    this.entityRefs.set(t, n + 1), n === 0 && t.retain(), this.save();
+  }
+  removeChildRef(t) {
+    if (this.entityRefs === void 0) return;
+    const n = this.entityRefs.get(t);
+    n !== void 0 && (n <= 1 ? (this.entityRefs.delete(t), t.release()) : this.entityRefs.set(t, n - 1), this.save());
+  }
+  getProxy(t) {
+    const n = t;
+    let i = this._proxies.get(n);
+    return i === void 0 && (i = hn(this, this.key, t, this._notifier, this._queryClient), this._proxies.set(n, i)), i;
+  }
+  get proxy() {
+    return this._proxies.values().next().value;
+  }
+  satisfiesDef(t) {
+    return this.satisfiedDefs.has(t) ? !0 : on(this.data, t) ? (this.satisfiedDefs.add(t), !0) : !1;
+  }
+  save() {
+    this._queryClient.entityMap.save(this);
+  }
+  notify() {
+    this._notifier.notify();
+  }
+  consume() {
+    this._notifier.consume();
+  }
+}
+function dn(e, t, n) {
+  const i = [];
+  for (const r of e) {
+    if (typeof r != "object" || r === null) continue;
+    const s = S.get(r);
+    if (s === void 0) continue;
+    const o = n.entityMap.getEntity(s);
+    o !== void 0 && o.satisfiesDef(t) && i.push(r);
+  }
+  return i;
+}
+function hn(e, t, n, i, r) {
+  const s = n.shape ?? {}, o = n, a = o._methods, c = o._entityClass, f = o._entityConfig, d = c ? c.prototype : Bt.prototype, u = n.typenameField, h = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new Map(), p = () => ({ __entityRef: t });
+  let w;
+  f?.hasSubscribe && a && "__subscribe" in a && (w = Tt((E) => {
+    const y = (b) => {
+      b.__eventSource = t, r.applyMutationEvent(b);
+    }, _ = a.__subscribe.call(v, y);
+    return E.value = v, _;
+  }));
+  let v;
+  if (u && !(u in s))
+    throw new Error(`typenameField "${u}" must be declared in the entity shape`);
+  const O = Object.keys(s);
+  if (O.includes("__typename") || O.push("__typename"), a)
+    for (const E of Object.keys(a))
+      O.includes(E) || O.push(E);
+  let k, R = O;
+  function L() {
+    const E = e._extraMethods;
+    if (E !== k) {
+      if (k = E, R = O.slice(), E !== void 0)
+        for (const _ of Object.keys(E))
+          R.includes(_) || R.push(_);
+      const y = e._extraGetters;
+      if (y !== void 0)
+        for (const _ of Object.keys(y))
+          R.includes(_) || R.push(_);
+    }
+    return R;
+  }
+  const U = {
+    getPrototypeOf() {
+      return d;
+    },
+    get(E, y) {
+      if (typeof y == "symbol") return;
+      if (y === "toJSON") return p;
+      if (y === "__context") return r.getContext();
+      if (y === "__typename") return e.typename;
+      if (w?.value, i.consume(), typeof y == "string") {
+        const b = e._extraGetters;
+        if (b !== void 0 && y in b)
+          return b[y]();
+        const x = e._extraMethods;
+        if (x !== void 0 && y in x) {
+          let C = h.get(y);
+          return C || (C = x[y].bind(v), h.set(y, C)), C;
+        }
+        if (a && y in a) {
+          let C = h.get(y);
+          return C || (C = Ee(v, a[y].bind(v)), h.set(y, C)), C;
+        }
+      }
+      const _ = e.data[y];
+      if (typeof _ == "object" && _ !== null && Z.has(_))
+        return A(_.getValue());
+      if (Array.isArray(_) && typeof y == "string") {
+        const b = s[y];
+        if (b instanceof m && (b.mask & l.ARRAY) !== 0) {
+          const x = b.shape;
+          if (x instanceof m && (x.mask & l.ENTITY) !== 0) {
+            const C = x.typenameValue;
+            if (C !== void 0) {
+              const Et = r.getEntityDefsForTypename(C);
+              if (Et !== void 0 && Et.length > 1) {
+                const tt = g.get(y);
+                if (tt !== void 0 && tt.source === _)
+                  return A(tt.filtered);
+                const bt = dn(_, x, r);
+                return g.set(y, { source: _, filtered: bt }), A(bt);
+              }
+            }
+          }
+        }
+        return A(_);
+      }
+      return A(_);
+    },
+    set() {
+      throw new Error("Entity properties are read-only");
+    },
+    has(E, y) {
+      if (y === "__typename") return !0;
+      if (typeof y == "string") {
+        const _ = e._extraGetters;
+        if (_ && y in _) return !0;
+        const b = e._extraMethods;
+        if (b && y in b || a && y in a) return !0;
+      }
+      return y in s;
+    },
+    ownKeys() {
+      return L();
+    },
+    getOwnPropertyDescriptor(E, y) {
+      if (y === "__typename")
+        return { enumerable: !0, configurable: !0, value: e.typename, writable: !1 };
+      if (y in s)
+        return { enumerable: !0, configurable: !0, value: U.get(E, y, v), writable: !1 };
+      if (typeof y == "string") {
+        const _ = e._extraGetters;
+        if (_ && y in _)
+          return { enumerable: !0, configurable: !0, value: U.get(E, y, v), writable: !1 };
+        const b = e._extraMethods;
+        if (b && y in b)
+          return { enumerable: !0, configurable: !0, value: U.get(E, y, v), writable: !1 };
+        if (a && y in a)
+          return { enumerable: !1, configurable: !0, value: U.get(E, y, v), writable: !1 };
+      }
+    }
+  };
+  return v = new Proxy({}, U), S.set(v, t), we(v, r), v;
+}
+class yn {
+  instances = /* @__PURE__ */ new Map();
+  persistEntity;
+  constructor(t) {
+    this.persistEntity = t;
+  }
+  hasEntity(t) {
+    return this.instances.has(t);
+  }
+  getEntity(t) {
+    return this.instances.get(t);
+  }
+  getOrCreateEntity(t, n, i, r) {
+    let s = this.instances.get(t);
+    if (s === void 0) {
+      const o = i.idField;
+      if (o === void 0)
+        throw new Error(`Entity id field is required ${i.typenameValue}`);
+      const a = n[o];
+      if (typeof a != "string" && typeof a != "number")
+        throw new Error(`Entity id must be string or number: ${i.typenameValue}`);
+      const c = i;
+      s = new ln(t, i.typenameValue, a, o, n, r), s._entityCache = c._entityCache, this.instances.set(t, s);
+    }
+    return s.parseId = r.currentParseId, s;
+  }
+  remove(t) {
+    this.instances.delete(t);
+  }
+  save(t) {
+    let n;
+    if (t.entityRefs) {
+      n = /* @__PURE__ */ new Set();
+      for (const i of t.entityRefs.keys()) n.add(i.key);
+    }
+    this.persistEntity(t.key, t.data, n);
+  }
+}
+class ae {
+  onlineSignal;
+  manualOverride = void 0;
+  eventListenersAttached = !1;
+  constructor(t) {
+    const n = t ?? this.detectOnlineStatus();
+    this.onlineSignal = Pt(n), this.canAttachListeners() && this.attachEventListeners();
+  }
+  /**
+   * Returns true if the network is currently online
+   */
+  get isOnline() {
+    return this.manualOverride !== void 0 ? this.manualOverride : this.onlineSignal.value;
+  }
+  /**
+   * Manually set the network status (useful for testing)
+   */
+  setNetworkStatus(t) {
+    this.manualOverride = t, this.onlineSignal.value = t;
+  }
+  /**
+   * Clear manual override and return to automatic detection
+   */
+  clearManualOverride() {
+    this.manualOverride = void 0, this.onlineSignal.value = this.detectOnlineStatus();
+  }
+  /**
+   * Get the reactive signal for online status
+   * This allows reactive functions to depend on network status
+   */
+  getOnlineSignal() {
+    return this.onlineSignal;
+  }
+  /**
+   * Detect current online status from the environment
+   */
+  detectOnlineStatus() {
+    return typeof navigator < "u" && "onLine" in navigator ? navigator.onLine : !0;
+  }
+  /**
+   * Check if we can attach event listeners (browser or React Native)
+   */
+  canAttachListeners() {
+    return typeof window < "u" && typeof window.addEventListener == "function";
+  }
+  /**
+   * Remove event listeners and clean up resources.
+   */
+  destroy() {
+    this.eventListenersAttached && this.handleOnline && this.handleOffline && (window.removeEventListener("online", this.handleOnline), window.removeEventListener("offline", this.handleOffline), this.eventListenersAttached = !1);
+  }
+  handleOnline = void 0;
+  handleOffline = void 0;
+  /**
+   * Attach event listeners for online/offline events
+   */
+  attachEventListeners() {
+    this.eventListenersAttached || (this.handleOnline = () => {
+      this.manualOverride === void 0 && (this.onlineSignal.value = !0);
+    }, this.handleOffline = () => {
+      this.manualOverride === void 0 && (this.onlineSignal.value = !1);
+    }, window.addEventListener("online", this.handleOnline), window.addEventListener("offline", this.handleOffline), this.eventListenersAttached = !0);
+  }
+}
+class ce {
+  static onlineSignal = Pt(!0);
+  get isOnline() {
+    return !0;
+  }
+  setNetworkStatus(t) {
+  }
+  clearManualOverride() {
+  }
+  getOnlineSignal() {
+    return ce.onlineSignal;
+  }
+  destroy() {
+  }
+}
+const pn = new ae(), Tn = jt(pn);
+function _t(e, t = typeof window > "u") {
+  let n;
+  e === !1 ? n = 0 : e === void 0 || e === !0 ? n = t ? 0 : 3 : typeof e == "number" ? n = e : n = e.retries;
+  const i = typeof e == "object" && e.retryDelay ? e.retryDelay : (r) => 1e3 * Math.pow(2, r);
+  return { retries: n, retryDelay: i };
+}
+class Pn {
+  static cache;
+  /**
+   * The controller class responsible for sending requests for this query type.
+   * Must be set on each concrete Query subclass (or inherited from a base like RESTQuery).
+   */
+  static controller;
+  params;
+  config;
+  constructor() {
+    return Kt(this);
+  }
+}
+const It = /* @__PURE__ */ new WeakMap();
+class G {
+  constructor(t, n) {
+    this.captured = n, this.statics = t;
+  }
+  statics;
+  createExecutionContext(t, n) {
+    return it(this.captured, t, n);
+  }
+  resolveOptions(t) {
+    const { methods: n } = this.captured, i = n.getConfig ? n.getConfig.call(t) : t.config, r = _t(i?.retry);
+    return { config: i, retryConfig: r };
+  }
+  static for(t) {
+    let n = It.get(t);
+    if (n !== void 0)
+      return n;
+    const i = new t(), r = Te(i), s = String(r.methods.getIdentityKey.call(r.fields)), o = r.fields.result, a = o instanceof m ? o : en.object(o), c = (a.mask & l.ENTITY) !== 0, f = t.cache, d = r.fields.fetchNext, u = t.controller;
+    if (!u)
+      throw new Error(
+        `Query class "${t.name}" must define a static \`controller\` property. Extend RESTQuery (from fetchium/rest) or set \`static controller = MyController\` on your query class.`
+      );
+    const h = typeof u.prototype.sendNext == "function", g = c ? a : new m(
+      l.ENTITY | l.OBJECT,
+      a.shape,
+      void 0,
+      void 0,
+      s,
+      // typenameValue — unique per query class
+      Lt
+      // idField — symbol, injected onto payload before parse
+    );
+    return n = new G(
+      { id: s, shape: g, cache: f, rawFetchNext: d, hasSendNext: h, isEntityResult: c, controllerClass: u },
+      r
+    ), It.set(t, n), n;
+  }
+}
+const jn = (e, t) => {
+  const n = G.for(e);
+  return wt(n, t);
+};
+function $n(e, ...t) {
+  const n = G.for(e), i = be(An);
+  if (i === void 0)
+    throw new Error("QueryClient not found");
+  const r = t[0];
+  return i.getQuery(n, r);
+}
+function fe(e, t) {
+  return new Promise((n, i) => {
+    if (t?.aborted) {
+      i(t.reason);
+      return;
+    }
+    const r = setTimeout(n, e);
+    t?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(r), i(t.reason);
+      },
+      { once: !0 }
+    );
+  });
+}
+async function at(e, t, n) {
+  if (t.retries < 0)
+    throw new Error("retries must be non-negative");
+  const i = Math.max(0, t.retries);
+  let r;
+  for (let s = 0; s <= i; s++) {
+    n?.throwIfAborted();
+    try {
+      return await e();
+    } catch (o) {
+      if (r = o, s >= i) throw o;
+      await fe(t.retryDelay(s), n);
+    }
+  }
+  throw r;
+}
+class gn {
+  def;
+  queryKey;
+  storageKey = -1;
+  /** The public-facing ReactivePromise returned to consumers. */
+  relay;
+  queryClient;
+  initialized = !1;
+  updatedAt = void 0;
+  params = void 0;
+  unsubscribe = void 0;
+  _relayState = void 0;
+  wasPaused = !1;
+  currentParams = void 0;
+  debounceTimer = void 0;
+  /** Resolved per-instance options (depend on actual params). */
+  config = void 0;
+  retryConfig = _t(void 0);
+  /** Controller for aborting in-flight fetches and retry waits. */
+  _abortController = void 0;
+  /** Cached execution context, recreated only when storageKey (params) changes. */
+  _executionCtx = void 0;
+  _executionCtxKey = -1;
+  /** Root entity that holds parsed data, proxy, child refs, and bindings.
+   *  For entity results, this is undefined until the first apply discovers it. */
+  rootEntity;
+  /** Extra methods (__refetch, __fetchNext) attached to the root entity proxy. */
+  _extraMethods = {};
+  /** Query id injected as QUERY_ID on non-entity payloads. */
+  _queryId = 0;
+  get key() {
+    return this.queryKey;
+  }
+  get relayState() {
+    if (!this._relayState)
+      throw new Error("Relay state not initialized");
+    return this._relayState;
+  }
+  constructor(t, n, i, r) {
+    this.def = t, this.queryClient = n, this.queryKey = i, this.params = r, this._extraMethods = { __refetch: this.refetch }, t.statics.hasSendNext && (this._extraMethods.__fetchNext = this.fetchNext);
+    const s = kt(r);
+    this._queryId = s !== void 0 ? N(s) : 0, this.relay = Tt(
+      (o) => {
+        this._relayState = o;
+        const a = () => {
+          clearTimeout(this.debounceTimer), this.debounceTimer = void 0, this._abortController?.abort(), this._abortController = void 0, this._fetchNextAbort?.abort(), this._fetchNextAbort = void 0, this._fetchNextPromise = void 0, this.unsubscribe?.(), this.unsubscribe = void 0;
+          const f = this.config?.gcTime ?? $t;
+          this.queryClient.gcManager.schedule(this.queryKey, f, X.Query);
+        }, c = (f = !1) => {
+          const { wasPaused: d, isPaused: u, initialized: h } = this;
+          if (this.wasPaused = u, u && !d && h) {
+            a();
+            return;
+          }
+          const g = kt(this.params), p = wt(this.def, g), w = p !== this.storageKey;
+          w && (this.currentParams = g, this.storageKey = p), this.getOrCreateExecutionContext(), this.initialized ? d || f ? (this.queryClient.activateQuery(this), f && this.updatedAt !== void 0 && this.setupSubscription(), (this.config?.refreshStaleOnReconnect ?? !0) && this.isStale && this.runDebounced()) : w && (this.setupSubscription(), this.runDebounced()) : (this.queryClient.activateQuery(this), this.initialize());
+        };
+        return c(!0), {
+          update: c,
+          deactivate: a
+        };
+      },
+      { desc: `Query(${t.statics.id})` }
+    );
+  }
+  /** Apply raw data (fresh or cached) to the root entity and return the proxy. */
+  applyData(t, n, i = !1, r) {
+    const s = this.def;
+    return this.rootEntity = this.queryClient.parseAndApplyRootEntity(
+      t,
+      this._queryId,
+      s.statics.shape,
+      n,
+      i,
+      r
+    ), this.rootEntity._extraMethods === void 0 && (this.rootEntity._extraMethods = this._extraMethods, this.rootEntity._extraGetters = {
+      __hasNext: () => this.hasNext,
+      __isFetchingNext: () => this._fetchNextPromise !== void 0
+    }), this.rootEntity.getProxy(s.statics.shape);
+  }
+  /** Save query metadata (the __entityRef pointer, updatedAt, ref set). */
+  saveQueryMetadata() {
+    if (this.rootEntity === void 0 || this.updatedAt === void 0) return;
+    const t = new Map(this.rootEntity.entityRefs ?? []);
+    t.set(this.rootEntity, 1), this.queryClient.saveQueryData(
+      this.def,
+      this.storageKey,
+      { __entityRef: this.rootEntity.key },
+      this.updatedAt,
+      t
+    );
+  }
+  async initialize() {
+    const t = this.queryClient, n = this.relayState;
+    this.initialized = !0;
+    let i;
+    try {
+      i = await t.loadCachedQuery(this.def, this.storageKey), i !== void 0 && (this.updatedAt = i.updatedAt, n.value = this.applyData(i.value, !1, !1, i.preloadedEntities));
+    } catch (r) {
+      t.store.deleteQuery(this.storageKey), t.getContext().log?.warn?.("Failed to initialize query, the query cache may be corrupted or invalid", r);
+    }
+    if (!this.isPaused)
+      try {
+        if (i !== void 0 && this.setupSubscription(), i === void 0 || this.isStale) {
+          if (await fe(0), this.isPaused) return;
+          this.runQueryImmediately();
+        }
+      } catch (r) {
+        n.setError(r);
+      }
+  }
+  setupSubscription() {
+    this.unsubscribe?.(), this.unsubscribe = void 0;
+    const t = this.config?.subscribe;
+    if (!t) return;
+    const n = this._executionCtx;
+    this.unsubscribe = t.call(n, (i) => {
+      i.__eventSource = this.queryKey, this.queryClient.applyMutationEvent(i);
+    });
+  }
+  getOrCreateExecutionContext() {
+    return (this._executionCtx === void 0 || this._executionCtxKey !== this.storageKey) && (this._executionCtxKey = this.storageKey, this._executionCtx = this.def.createExecutionContext(
+      this.currentParams ?? {},
+      this.queryClient.getContext()
+    ), this._executionCtx.refetch = () => this.refetch(), this._executionCtx.rawFetchNext = this.def.statics.rawFetchNext), this.resolveAndApplyOptions(), this._executionCtx;
+  }
+  resolveAndApplyOptions() {
+    const t = this.def.resolveOptions(this._executionCtx);
+    this.config = t.config, this.retryConfig = t.retryConfig;
+  }
+  async runQuery() {
+    const t = this.def;
+    if (this.isPaused)
+      throw new Error("Query is paused due to network status");
+    const n = this.getOrCreateExecutionContext(), i = this.queryClient.getController(t.statics.controllerClass), r = this._abortController?.signal ?? new AbortController().signal;
+    return at(
+      async () => {
+        const s = await i.send(n, r);
+        this.updatedAt = Date.now();
+        const o = this.applyData(s, !0);
+        return this.saveQueryMetadata(), this.unsubscribe === void 0 && this.setupSubscription(), o;
+      },
+      this.retryConfig,
+      r
+    );
+  }
+  runQueryImmediately() {
+    this._abortController?.abort(), this._abortController = new AbortController(), this._fetchNextAbort?.abort(), this._fetchNextAbort = void 0, this._fetchNextPromise = void 0, this.relayState.setPromise(this.runQuery());
+  }
+  runDebounced() {
+    if (this.relayState.isPending) return;
+    const t = this.config?.debounce ?? 0;
+    clearTimeout(this.debounceTimer), this.debounceTimer = setTimeout(() => {
+      this.debounceTimer = void 0, this.runQueryImmediately();
+    }, t);
+  }
+  // ======================================================
+  // Public methods
+  // ======================================================
+  refetch = () => this.relayState.isPending ? this.relay : (this.runQueryImmediately(), this.relay);
+  markStale() {
+    this.updatedAt = 0;
+  }
+  get resolvedParams() {
+    return this.currentParams;
+  }
+  /** In-flight fetchNext promise for deduplication. */
+  _fetchNextPromise = void 0;
+  /** Controller for aborting in-flight fetchNext requests. */
+  _fetchNextAbort = void 0;
+  fetchNext = () => {
+    if (this.updatedAt === void 0)
+      throw new Error("Cannot call __fetchNext before initial data has loaded");
+    return this._fetchNextPromise !== void 0 ? this._fetchNextPromise : (queueMicrotask(() => this.rootEntity?.notify()), this._fetchNextPromise = this.runFetchNext().then(
+      (t) => (this._fetchNextPromise = void 0, this.rootEntity?.notify(), t),
+      (t) => {
+        throw this._fetchNextPromise = void 0, this.rootEntity?.notify(), t;
+      }
+    ), this._fetchNextPromise);
+  };
+  get hasNext() {
+    if (this.rootEntity === void 0 || !this._executionCtx) return !1;
+    const t = this.queryClient.getController(this.def.statics.controllerClass);
+    return t.hasNext ? (this._executionCtx.resultData = this.rootEntity.data, t.hasNext(this._executionCtx)) : !1;
+  }
+  async runFetchNext() {
+    const t = this.def;
+    this._fetchNextAbort = new AbortController();
+    const n = this._fetchNextAbort.signal, i = this.getOrCreateExecutionContext();
+    i.resultData = this.rootEntity.data;
+    const r = this.queryClient.getController(t.statics.controllerClass);
+    return at(
+      async () => {
+        const s = await r.sendNext(i, n);
+        this.updatedAt = Date.now();
+        const o = this.applyData(s, !0, !0);
+        return this.saveQueryMetadata(), o;
+      },
+      this.retryConfig,
+      n
+    );
+  }
+  // ======================================================
+  // Internal computed properties
+  // ======================================================
+  get isStale() {
+    if (this.updatedAt === void 0)
+      return !0;
+    const t = this.config?.staleTime ?? 0;
+    return Date.now() - this.updatedAt >= t;
+  }
+  get isPaused() {
+    const t = this.config?.networkMode ?? V.Online;
+    if (t === V.Always)
+      return !1;
+    const n = this.queryClient.networkManager.getOnlineSignal().value;
+    switch (t) {
+      case V.Online:
+        return !n;
+      case V.OfflineFirst:
+        return !n && this.updatedAt === void 0;
+      default:
+        return !1;
+    }
+  }
+}
+class mn {
+  def;
+  queryClient;
+  _inFlight = !1;
+  task;
+  constructor(t, n) {
+    this.def = t, this.queryClient = n, this.task = this.createTask();
+  }
+  createTask() {
+    return Ce(
+      async (t) => {
+        if (this._inFlight)
+          throw new Error("A mutation is already in progress. Await the previous call before starting a new one.");
+        this._inFlight = !0;
+        try {
+          const n = await this.executeWithRetry(t), i = this.validateResponse(n);
+          return this.processEffects(t, i), i;
+        } finally {
+          this._inFlight = !1;
+        }
+      },
+      { desc: `Mutation(${this.def.id})` }
+    );
+  }
+  validateResponse(t) {
+    const n = this.def.responseShape;
+    if (!(n instanceof m))
+      return t;
+    const i = this.queryClient.getContext().log?.warn ?? (() => {
+    }), r = new ot();
+    return r.reset(void 0, void 0, i), ie(t, n, r);
+  }
+  // ======================================================
+  // Effects processing
+  // ======================================================
+  processEffects(t, n) {
+    let i;
+    if (this.def.hasGetEffects) {
+      const s = it(
+        this.def.captured,
+        t ?? {},
+        this.queryClient.getContext()
+      );
+      s.result = n, i = s.getEffects();
+    } else if (this.def.effects !== void 0) {
+      const s = { params: t, result: n };
+      i = J(this.def.effects, s);
+    }
+    if (i === void 0) return;
+    const r = this.queryClient;
+    et(i.creates, "create", r), et(i.updates, "update", r), et(i.deletes, "delete", r), i.invalidates && r.invalidateQueries(i.invalidates);
+  }
+  // ======================================================
+  // Retry logic
+  // ======================================================
+  executeWithRetry(t) {
+    const n = _t(this.def.config?.retry, !0), i = this.queryClient.getController(this.def.controllerClass);
+    if (!i.sendMutation)
+      throw new Error(
+        `Controller "${this.def.controllerClass.name}" does not implement sendMutation(). Add a sendMutation() method to handle mutations.`
+      );
+    return at(async () => {
+      const r = new AbortController(), s = it(
+        this.def.captured,
+        t ?? {},
+        this.queryClient.getContext()
+      );
+      return await i.sendMutation(s, r.signal);
+    }, n);
+  }
+}
+function vn(e) {
+  return typeof e == "string" ? e : j(e).typenameValue;
+}
+function et(e, t, n) {
+  if (e)
+    for (const [i, r] of e) {
+      const s = vn(i);
+      s !== void 0 && n.applyMutationEvent({ type: t, typename: s, data: r });
+    }
+}
+const ue = "__eventSource";
+function le(e) {
+  return { field: e, segments: e.indexOf(".") !== -1 ? e.split(".") : void 0 };
+}
+function _n(e) {
+  return e.map(le);
+}
+function wn(e, t) {
+  if (t.segments === void 0) return e[t.field];
+  let n = e;
+  for (const i of t.segments) {
+    if (n == null) return;
+    n = n[i];
+  }
+  return n;
+}
+function de(e, t) {
+  const n = [];
+  for (let i = 0; i < t.length; i++) {
+    const r = t[i], s = wn(e, r);
+    if (s === void 0) return;
+    n.push(r.field, s);
+  }
+  return N(n);
+}
+function En(e, t) {
+  if (e === void 0) return;
+  const n = /* @__PURE__ */ new Map();
+  for (const [i, r] of e) {
+    const s = r.slice().sort((c, f) => c[0] < f[0] ? -1 : c[0] > f[0] ? 1 : 0), o = [];
+    let a = !0;
+    for (const [c, f] of s) {
+      let d;
+      if (qt(f)) {
+        const u = Vt(f);
+        d = dt(u, t);
+      } else
+        d = f;
+      if (d === void 0) {
+        a = !1;
+        break;
+      }
+      o.push(c, d);
+    }
+    a && n.set(i, N(o));
+  }
+  return n.size > 0 ? n : void 0;
+}
+function Dt(e, t) {
+  const n = e.get(t);
+  if (n !== void 0)
+    return n.map(([i]) => i).sort();
+}
+class bn {
+  fields;
+  fieldPaths;
+  _bindings = /* @__PURE__ */ new Map();
+  constructor(t) {
+    this.fields = t, this.fieldPaths = t.map(le);
+  }
+  register(t, n) {
+    let i = this._bindings.get(t);
+    i === void 0 && (i = /* @__PURE__ */ new Set(), this._bindings.set(t, i)), i.add(n);
+  }
+  unregister(t, n) {
+    const i = this._bindings.get(t);
+    i !== void 0 && (i.delete(n), i.size === 0 && this._bindings.delete(t));
+  }
+  getMatching(t) {
+    return this._bindings.get(t);
+  }
+  get isEmpty() {
+    return this._bindings.size === 0;
+  }
+}
+function Ft(e) {
+  return N(e);
+}
+class Cn {
+  _groups = /* @__PURE__ */ new Map();
+  getOrCreateGroup(t) {
+    const n = Ft(t);
+    let i = this._groups.get(n);
+    return i === void 0 && (i = new bn(t), this._groups.set(n, i)), i;
+  }
+  register(t, n, i) {
+    this.getOrCreateGroup(n).register(t, i);
+  }
+  unregister(t, n, i) {
+    const r = Ft(n), s = this._groups.get(r);
+    s !== void 0 && (s.unregister(t, i), s.isEmpty && this._groups.delete(r));
+  }
+  registerBinding(t, n) {
+    const i = t._constraintHashes.get(n);
+    if (i === void 0) return;
+    const r = Dt(t._constraintFieldRefs, n);
+    r !== void 0 && this.register(i, r, t);
+  }
+  unregisterBinding(t, n) {
+    const i = t._constraintHashes.get(n);
+    if (i === void 0) return;
+    const r = Dt(t._constraintFieldRefs, n);
+    r !== void 0 && this.unregister(i, r, t);
+  }
+  routeEvent(t, n, i, r, s, o) {
+    for (const a of this._groups.values()) {
+      const c = de(n, a.fieldPaths);
+      if (c === void 0) continue;
+      const f = a.getMatching(c);
+      if (f !== void 0)
+        for (const d of f)
+          d.onEvent(t, i, r, s, o);
+    }
+  }
+}
+function Mt(e) {
+  const t = /* @__PURE__ */ new Set();
+  for (const n of e)
+    if (typeof n == "object" && n !== null) {
+      const i = T(n);
+      i !== void 0 && t.add(i);
+    }
+  return t;
+}
+class he {
+  _queryClient;
+  _parent;
+  _constraintHashes;
+  _entityDefsByTypename;
+  _constraintFieldRefs;
+  instance;
+  constructor(t, n, i, r, s, o) {
+    this._queryClient = i, this._parent = r, this._constraintHashes = s, this._constraintFieldRefs = n, this.instance = o, this._entityDefsByTypename = /* @__PURE__ */ new Map();
+    for (const a of t)
+      a.typenameValue !== void 0 && this._entityDefsByTypename.set(a.typenameValue, a);
+    Z.add(this);
+  }
+  getValue() {
+    return this.instance.getValue();
+  }
+  toJSON() {
+    return this.instance.getRawValue();
+  }
+  reset(t) {
+    this.instance.reset(t);
+  }
+  append(t) {
+    this.instance.append(t);
+  }
+  /**
+   * Handle an entity event. The entity has already been created/updated at the
+   * root level by applyMutationEvent. The binding just checks if the entity's
+   * current data satisfies this binding's shape and forwards to the instance.
+   */
+  onEvent(t, n, i, r, s) {
+    const o = this._entityDefsByTypename.get(t);
+    if (o === void 0) return;
+    const a = this._queryClient.entityMap.getEntity(n);
+    if (i === "delete") {
+      const f = a !== void 0 ? a.getProxy(o) : s;
+      f !== void 0 && (this.instance.onEvent(n, f, s ?? a?.data ?? {}, "delete"), r?.());
+      return;
+    }
+    if (a === void 0 || !a.satisfiesDef(o)) return;
+    r?.();
+    const c = a.getProxy(o);
+    this.instance.onEvent(n, c, a.data, i);
+  }
+  destroy() {
+    this._queryClient.unregisterLiveCollection(this);
+    const t = this._parent.liveCollections, n = t.indexOf(this);
+    n !== -1 && t.splice(n, 1);
+  }
+}
+class Sn {
+  _notifier;
+  _items;
+  _keys;
+  _outputSignal;
+  _queryClient;
+  _parent;
+  constructor(t, n, i, r, s, o) {
+    this._notifier = ft(), this._items = i, this._keys = Mt(i), this._queryClient = t, this._parent = n;
+    const a = r !== void 0 && s !== void 0, c = o !== void 0;
+    (a || c) && (this._outputSignal = Se(() => {
+      this._notifier.consume();
+      let f = this._items;
+      if (a) {
+        const d = [];
+        for (const u of f) {
+          if (typeof u != "object" || u === null) {
+            d.push(u);
+            continue;
+          }
+          const h = T(u);
+          if (h === void 0) {
+            d.push(u);
+            continue;
+          }
+          const g = t.entityMap.getEntity(h);
+          if (g === void 0) {
+            d.push(u);
+            continue;
+          }
+          g.consume(), de(g.data, r) === s && d.push(u);
+        }
+        f = d;
+      }
+      return c && (f = (f === this._items ? f.slice() : f).sort(o)), f;
+    }));
+  }
+  onEvent(t, n, i, r) {
+    switch (r) {
+      case "create":
+        this.add(t, n);
+        break;
+      case "update":
+        !this.has(t) && n !== void 0 && this.add(t, n);
+        break;
+      case "delete":
+        this.remove(t);
+        break;
+    }
+  }
+  getValue() {
+    return this._outputSignal !== void 0 ? this._outputSignal.value : (this._notifier.consume(), this._items);
+  }
+  getRawValue() {
+    return this._items;
+  }
+  add(t, n) {
+    if (this._keys.has(t)) return !1;
+    this._keys.add(t), this._items.push(n);
+    const i = this._queryClient.entityMap.getEntity(t);
+    return i !== void 0 && (this._parent.addChildRef(i), i.save()), this._notifier.notify(), !0;
+  }
+  remove(t) {
+    if (!this._keys.has(t)) return !1;
+    this._keys.delete(t);
+    const n = this._findIndex(t);
+    n !== -1 && this._items.splice(n, 1);
+    const i = this._queryClient.entityMap.getEntity(t);
+    return i !== void 0 && this._parent.removeChildRef(i), this._notifier.notify(), !0;
+  }
+  has(t) {
+    return this._keys.has(t);
+  }
+  reset(t) {
+    const n = this._items, i = Array.isArray(t) ? t : [];
+    this._items = i, this._keys = Mt(i);
+    for (const r of i)
+      if (typeof r == "object" && r !== null) {
+        const s = T(r);
+        if (s !== void 0) {
+          const o = this._queryClient.entityMap.getEntity(s);
+          o !== void 0 && this._parent.addChildRef(o);
+        }
+      }
+    for (const r of n)
+      if (typeof r == "object" && r !== null) {
+        const s = T(r);
+        if (s !== void 0) {
+          const o = this._queryClient.entityMap.getEntity(s);
+          o !== void 0 && this._parent.removeChildRef(o);
+        }
+      }
+    this._notifier.notify();
+  }
+  append(t) {
+    if (Array.isArray(t))
+      for (const n of t) {
+        if (typeof n != "object" || n === null) continue;
+        const i = T(n);
+        i !== void 0 && this.add(i, n);
+      }
+  }
+  _findIndex(t) {
+    for (let n = 0; n < this._items.length; n++) {
+      const i = this._items[n];
+      if (typeof i == "object" && i !== null && T(i) === t)
+        return n;
+    }
+    return -1;
+  }
+}
+class On {
+  _notifier;
+  _value;
+  _createdKeys;
+  _deletedKeys;
+  _queryClient;
+  _parent;
+  _onCreate;
+  _onUpdate;
+  _onDelete;
+  constructor(t, n, i, r, s, o) {
+    this._notifier = ft(), this._value = i, this._createdKeys = /* @__PURE__ */ new Set(), this._deletedKeys = /* @__PURE__ */ new Set(), this._queryClient = t, this._parent = n, this._onCreate = r, this._onUpdate = s, this._onDelete = o;
+  }
+  onEvent(t, n, i, r) {
+    switch (r) {
+      case "create":
+        if (this._createdKeys.has(t)) return;
+        this._createdKeys.add(t), this._value = this._onCreate(this._value, n);
+        break;
+      case "update":
+        this._value = this._onUpdate(this._value, n ?? i);
+        break;
+      case "delete":
+        if (this._deletedKeys.has(t)) return;
+        this._deletedKeys.add(t), this._value = this._onDelete(this._value, n ?? i);
+        break;
+    }
+    this._notifier.notify();
+  }
+  getValue() {
+    return this._notifier.consume(), this._value;
+  }
+  getRawValue() {
+    return this._value;
+  }
+  reset(t) {
+    this._value = t, this._createdKeys.clear(), this._deletedKeys.clear(), this._notifier.notify();
+  }
+  append(t) {
+  }
+}
+function ye(e, t, n, i, r) {
+  let s = e.constraintFieldRefs;
+  if (s === void 0) {
+    s = /* @__PURE__ */ new Map();
+    for (const f of e.entityDefs) {
+      const d = f.typenameValue;
+      d !== void 0 && s.set(d, [[ue, n.key]]);
+    }
+  }
+  const o = En(s, i) ?? /* @__PURE__ */ new Map();
+  let a;
+  if (e.type === ut.Array) {
+    let f, d;
+    if (e.constraintFieldRefs !== void 0 && o.size > 0 && o.size === 1)
+      for (const [u] of e.constraintFieldRefs) {
+        const h = o.get(u);
+        if (h !== void 0) {
+          d = h;
+          const g = e.constraintFieldRefs.get(u);
+          g !== void 0 && (f = _n(g.map(([p]) => p)));
+          break;
+        }
+      }
+    a = new Sn(
+      r,
+      n,
+      Array.isArray(t) ? t : [],
+      f,
+      d,
+      e.sort
+    );
+  } else
+    a = new On(
+      r,
+      n,
+      t,
+      e.onCreate,
+      e.onUpdate,
+      e.onDelete
+    );
+  const c = new he(
+    e.entityDefs,
+    s,
+    r,
+    n,
+    o,
+    a
+  );
+  return n.liveCollections.push(c), r.registerLiveCollection(c), c;
+}
+const pe = Object.entries, ge = Object.prototype;
+function nt(e, t, n, i = !1) {
+  const r = e.queryClient;
+  r.currentParseId++;
+  const s = e.seen, o = /* @__PURE__ */ new Map();
+  return { data: Y(t, s, r, n, o, i), entityRefs: o };
+}
+function Y(e, t, n, i, r, s) {
+  if (typeof e != "object" || e === null) return e;
+  const o = t.get(e);
+  if (o !== void 0)
+    return Rn(o, t, n, i, r, s);
+  if (Array.isArray(e)) {
+    for (let a = 0; a < e.length; a++) {
+      const c = e[a];
+      typeof c == "object" && c !== null && !(c instanceof Q) && !S.has(c) && (e[a] = Y(c, t, n, i, r, s));
+    }
+    return e;
+  }
+  if (Object.getPrototypeOf(e) === ge && !S.has(e)) {
+    const a = e;
+    for (const c of Object.keys(a)) {
+      const f = a[c];
+      typeof f == "object" && f !== null && !(f instanceof Q) && !S.has(f) && (a[c] = Y(f, t, n, i, r, s));
+    }
+  }
+  return e;
+}
+function me(e) {
+  return typeof e == "object" && e !== null && !(e instanceof Q) && !S.has(e);
+}
+function Rn(e, t, n, i, r, s) {
+  const { key: o, data: a, shape: c, rawKeys: f } = e, d = c.shape, u = n.prepareEntity(o, a, c), h = u.data, g = h !== a, p = g && f !== void 0 && u.entityRefs !== void 0 ? new Map(u.entityRefs) : /* @__PURE__ */ new Map();
+  if (g ? (ve(
+    d,
+    a,
+    h,
+    f,
+    u,
+    h,
+    t,
+    n,
+    i,
+    p,
+    s
+  ), u.notify()) : _e(d, a, u, a, t, n, i, p, s), s && u.liveCollections.length > 0)
+    for (const v of u.liveCollections) {
+      const O = v.instance.getRawValue();
+      if (Array.isArray(O))
+        for (const k of O) {
+          if (typeof k != "object" || k === null) continue;
+          const R = S.get(k);
+          if (R === void 0) continue;
+          const L = n.entityMap.getEntity(R);
+          L !== void 0 && p.set(L, (p.get(L) ?? 0) + 1);
+        }
+    }
+  u.setChildRefs(p.size > 0 ? p : void 0, i);
+  const w = u.getProxy(c);
+  return r.set(u, (r.get(u) ?? 0) + 1), w;
+}
+function ve(e, t, n, i, r, s, o, a, c, f, d) {
+  for (const [u, h] of pe(e))
+    if (!(i !== void 0 && !i.has(u)))
+      if (me(t[u]) && (t[u] = Y(t[u], o, a, c, f, d)), h instanceof m && h._liveConfig !== void 0) {
+        const g = n[u];
+        g instanceof he ? d ? g.append(t[u]) : g.reset(t[u]) : n[u] = ye(
+          h._liveConfig,
+          t[u],
+          r,
+          s,
+          a
+        );
+      } else {
+        const g = t[u], p = n[u];
+        if (ct(g) && ct(p)) {
+          const w = h instanceof m && h.shape !== void 0 ? h.shape : void 0;
+          if (w !== void 0)
+            ve(
+              w,
+              g,
+              p,
+              void 0,
+              r,
+              s,
+              o,
+              a,
+              c,
+              f,
+              d
+            );
+          else
+            for (const v of Object.keys(g))
+              p[v] = g[v];
+          n[u] = p;
+        } else
+          n[u] = g;
+      }
+}
+function _e(e, t, n, i, r, s, o, a, c) {
+  for (const [f, d] of pe(e))
+    if (f in t)
+      if (me(t[f]) && (t[f] = Y(t[f], r, s, o, a, c)), d instanceof m && d._liveConfig !== void 0)
+        t[f] = ye(
+          d._liveConfig,
+          t[f],
+          n,
+          i,
+          s
+        );
+      else {
+        const u = t[f];
+        if (ct(u)) {
+          const h = d instanceof m && d.shape !== void 0 ? d.shape : void 0;
+          h !== void 0 && _e(h, u, n, i, r, s, o, a, c);
+        }
+      }
+}
+function ct(e) {
+  return typeof e == "object" && e !== null && !Array.isArray(e) && Object.getPrototypeOf(e) === ge && !S.has(e);
+}
+function Ln(e) {
+  if (e !== void 0)
+    return typeof e == "string" ? e : typeof e == "function" ? e() : e.value;
+}
+function xn(e) {
+  return Oe(e);
+}
+function kt(e) {
+  if (e === void 0)
+    return;
+  const t = {};
+  for (const [n, i] of Object.entries(e))
+    xn(i) ? t[n] = i.value : t[n] = i;
+  return t;
+}
+const wt = (e, t) => N([e.statics.id, t]);
+class Un {
+  entityMap;
+  queryInstances = /* @__PURE__ */ new Map();
+  mutationInstances = /* @__PURE__ */ new Map();
+  gcManager;
+  networkManager;
+  isServer;
+  store;
+  currentParseId = 0;
+  context;
+  typenameRegistry = /* @__PURE__ */ new Map();
+  constraintRegistry = /* @__PURE__ */ new Map();
+  mergedDefCache = /* @__PURE__ */ new Map();
+  controllers = /* @__PURE__ */ new Map();
+  networkUnsubscribe;
+  constructor(t = {}) {
+    const {
+      store: n = new Ae(new Ne()),
+      log: i,
+      evictionMultiplier: r,
+      controllers: s,
+      networkManager: o,
+      gcManager: a,
+      ...c
+    } = t;
+    this.isServer = typeof window > "u", this.store = n, this.context = { ...c, log: i ?? console, evictionMultiplier: r }, this.gcManager = t.gcManager ?? (this.isServer ? new Fe() : new De(this.handleEviction, r)), this.networkManager = t.networkManager ?? new ae(), this.entityMap = new yn((u, h, g) => this.store.saveEntity(u, h, g));
+    for (const u of t.controllers ?? [])
+      this.controllers.set(u.constructor, u), u.register(this);
+    const f = this.networkManager.getOnlineSignal(), d = Re(() => f.value);
+    this.networkUnsubscribe = d.addListener(
+      () => {
+        const u = f.value;
+        for (const h of this.controllers.values())
+          h.onNetworkStatusChange?.(u);
+      },
+      { skipInitial: !0 }
+    ), this.store.purgeStaleQueries?.();
+  }
+  /**
+   * Returns the registered controller instance for the given controller class.
+   * Throws if no controller of that class has been registered.
+   */
+  getController(t) {
+    let n = this.controllers.get(t);
+    if (!n) {
+      try {
+        n = new t();
+      } catch {
+        throw new Error(
+          `No controller registered for ${t.name} and auto-instantiation failed. Pass an instance via QueryClient config: new QueryClient({ store, controllers: [new ${t.name}(...)] })`
+        );
+      }
+      this.controllers.set(t, n), n.register(this);
+    }
+    return n;
+  }
+  getContext() {
+    return this.context;
+  }
+  // ======================================================
+  // Typename Registry (per-client)
+  // ======================================================
+  registerEntityDef(t) {
+    const n = t.typenameValue;
+    if (n === void 0 || t._entityClass === void 0) return;
+    const i = this.typenameRegistry.get(n);
+    if (i !== void 0) {
+      if (i.indexOf(t) !== -1) return;
+      i.push(t), this.mergedDefCache.delete(n), this.getMergedDef(n);
+    } else
+      this.typenameRegistry.set(n, [t]);
+  }
+  getEntityDefsForTypename(t) {
+    return this.typenameRegistry.get(t);
+  }
+  getMergedDef(t) {
+    let n = this.mergedDefCache.get(t);
+    if (n !== void 0) return n;
+    const i = this.typenameRegistry.get(t);
+    if (i !== void 0)
+      return n = m.merge(i), this.mergedDefCache.set(t, n), n;
+  }
+  saveQueryData(t, n, i, r, s) {
+    const o = s !== void 0 && s.size > 0 ? new Set([...s.keys()].map((a) => a.key)) : void 0;
+    this.store.saveQuery(t, n, i, r, o);
+  }
+  activateQuery(t) {
+    const { def: n, queryKey: i, storageKey: r, config: s } = t;
+    this.store.activateQuery(n, r);
+    const o = s?.gcTime ?? $t;
+    this.gcManager.cancel(i, o);
+  }
+  loadCachedQuery(t, n) {
+    return this.store.loadQuery(t, n);
+  }
+  /**
+   * Loads a query from the document store and returns a QueryResult
+   * that triggers fetches and prepopulates with cached data
+   */
+  getQuery(t, n) {
+    const i = wt(t, n);
+    let r = this.queryInstances.get(i);
+    return r === void 0 && (r = new gn(t, this, i, n), this.queryInstances.set(i, r)), r.relay;
+  }
+  /**
+   * Gets or creates a MutationResult for the given mutation definition.
+   * Mutations are cached by their definition ID.
+   */
+  getMutation(t) {
+    const n = t.id;
+    let i = this.mutationInstances.get(n);
+    return i === void 0 && (i = new mn(t, this), this.mutationInstances.set(n, i)), i.task;
+  }
+  /**
+   * Parse data: validates, formats, produces parsed entity data objects.
+   * Does NOT touch the entity store. Call applyRefs() after to commit entities.
+   */
+  parseData(t, n, i) {
+    const r = this.context.log?.warn ?? (() => {
+    }), s = new ot();
+    return s.reset(this, i, r), { data: ie(t, n, s), ctx: s };
+  }
+  /**
+   * Apply entities from parseData() via a single depth-first walk: creates/
+   * updates EntityInstances, replaces parsed data with proxies, counts child
+   * refs. Returns the reified data and root-level entity refs.
+   */
+  applyRefs(t, n = !0, i = !1) {
+    return nt(t.ctx, t.data, n, i);
+  }
+  /**
+   * Parse and apply data as a root entity. For non-entity results, injects
+   * QUERY_ID onto the payload. Returns the root EntityInstance (created or
+   * found in the store by the standard entity pipeline).
+   */
+  parseAndApplyRootEntity(t, n, i, r, s = !1, o) {
+    typeof i.idField == "symbol" && typeof t == "object" && t !== null && !("__entityRef" in t) && (t[Lt] = n);
+    const a = this.parseData(t, i, o), c = nt(a.ctx, a.data, r, s), f = S.get(c.data);
+    return this.entityMap.getEntity(f);
+  }
+  prepareEntity(t, n, i) {
+    return this.registerEntityDef(i), this.entityMap.getOrCreateEntity(t, n, i, this);
+  }
+  // ======================================================
+  // Mutation Events
+  // ======================================================
+  applyMutationEvent(t) {
+    const { type: n, typename: i } = t, r = this.getMergedDef(i);
+    if (r === void 0) return;
+    const s = r.idField;
+    if (s === void 0 || typeof s == "symbol") return;
+    const o = t.data, a = t.id !== void 0 ? t.id : n === "delete" && (typeof o == "string" || typeof o == "number") ? o : o[s];
+    if (a === void 0) return;
+    const c = N([i, a]), f = t.__eventSource, d = typeof o == "object" && o !== null ? o : {}, u = this.entityMap.getEntity(c);
+    if (n === "delete") {
+      const w = u !== void 0 ? u.data : d;
+      this.routeEvent(i, w, c, n, f, void 0, w);
+      return;
+    }
+    try {
+      const w = this.context.log?.warn ?? (() => {
+      }), v = new ot();
+      v.reset(
+        this,
+        void 0,
+        w,
+        /* isPartialEvent */
+        !0
+      );
+      const O = rn(d, r, v);
+      nt(v, O, !0);
+    } catch (w) {
+      if (this.context.log?.warn?.("Failed to apply mutation event", w), u === void 0) {
+        const v = this.entityMap.getEntity(c);
+        v !== void 0 && v.evict();
+      }
+      return;
+    }
+    const h = this.entityMap.getEntity(c);
+    if (h === void 0) return;
+    this.entityMap.save(h);
+    const g = u === void 0;
+    let p = !1;
+    this.routeEvent(i, h.data, c, n, f, () => {
+      p = !0;
+    }), g && !p && h.evict();
+  }
+  // ======================================================
+  // Query Invalidation
+  // ======================================================
+  invalidateQueries(t) {
+    for (const n of t) {
+      const i = Array.isArray(n), r = i ? n[0] : n, s = i ? n[1] : void 0, a = G.for(r).statics.id;
+      for (const [, c] of this.queryInstances)
+        c.def.statics.id === a && (s === void 0 || Nn(c.resolvedParams, s)) && c.markStale();
+    }
+  }
+  // ======================================================
+  // In-Memory GC
+  // ======================================================
+  handleEviction = (t, n) => {
+    if (n === X.Query) {
+      const r = this.queryInstances.get(t);
+      if (r === void 0) return;
+      r.rootEntity?.evict(), this.queryInstances.delete(t);
+      return;
+    }
+    const i = this.entityMap.getEntity(t);
+    i !== void 0 && i.evict();
+  };
+  // ======================================================
+  // Constraint Registry (Live Data)
+  // ======================================================
+  getOrCreateMatcher(t) {
+    let n = this.constraintRegistry.get(t);
+    return n === void 0 && (n = new Cn(), this.constraintRegistry.set(t, n)), n;
+  }
+  registerLiveCollection(t) {
+    for (const [n, i] of t._entityDefsByTypename)
+      this.registerEntityDef(i), this.getOrCreateMatcher(n).registerBinding(t, n);
+  }
+  unregisterLiveCollection(t) {
+    for (const n of t._entityDefsByTypename.keys()) {
+      const i = this.constraintRegistry.get(n);
+      i !== void 0 && i.unregisterBinding(t, n);
+    }
+  }
+  routeEvent(t, n, i, r, s, o, a) {
+    const c = this.constraintRegistry.get(t);
+    if (c === void 0) return;
+    const f = s !== void 0 ? { ...n, [ue]: s } : n;
+    c.routeEvent(t, f, i, r, o, a);
+  }
+  destroy() {
+    this.networkUnsubscribe?.(), this.gcManager.destroy(), this.networkManager.destroy();
+    for (const t of this.controllers.values())
+      t.destroy?.();
+    this.controllers.clear(), this.queryInstances.clear(), this.mutationInstances.clear(), this.constraintRegistry.clear(), this.typenameRegistry.clear(), this.mergedDefCache.clear();
+  }
+}
+const An = jt(void 0);
+function Nn(e, t) {
+  if (e === void 0) return !1;
+  for (const n in t)
+    if (e[n] !== t[n]) return !1;
+  return !0;
+}
+export {
+  D as A,
+  Bt as E,
+  De as G,
+  B as L,
+  l as M,
+  ae as N,
+  Lt as Q,
+  F as R,
+  m as V,
+  ut as a,
+  Tn as b,
+  V as c,
+  Fe as d,
+  ce as e,
+  Pn as f,
+  Un as g,
+  An as h,
+  pn as i,
+  kn as j,
+  $n as k,
+  Kt as l,
+  Te as m,
+  J as n,
+  Ln as o,
+  jn as q,
+  Zt as r,
+  en as t
+};
+//# sourceMappingURL=QueryClient-Dtde3pss.js.map