fetchium 0.0.0 → 0.1.0

package/dist/esm/production/QueryClient-BP0Z1rQV.js

@@ -0,0 +1,2453 @@
+import { notifier as at, relay as It, setScopeOwner as pe, reactiveMethod as ge, signal as Mt, context as Tt, getContext as ve, task as _e, reactiveSignal as me, isSignal as Ee } from "signalium";
+import { registerCustomHash as we, hashValue as A } from "signalium/utils";
+import { D as Ft } from "./shared-Dq2yW78d.js";
+var q = /* @__PURE__ */ ((i) => (i.Always = "always", i.Online = "online", i.OfflineFirst = "offlineFirst", i))(q || {}), u = /* @__PURE__ */ ((i) => (i[i.UNDEFINED = 1] = "UNDEFINED", i[i.NULL = 2] = "NULL", i[i.NUMBER = 4] = "NUMBER", i[i.STRING = 8] = "STRING", i[i.BOOLEAN = 16] = "BOOLEAN", i[i.OBJECT = 32] = "OBJECT", i[i.ARRAY = 64] = "ARRAY", i[i.ID = 128] = "ID", i[i.RECORD = 256] = "RECORD", i[i.UNION = 512] = "UNION", i[i.ENTITY = 1024] = "ENTITY", i[i.HAS_FORMAT = 4096] = "HAS_FORMAT", i[i.IS_EAGER_FORMAT = 8192] = "IS_EAGER_FORMAT", i[i.PARSE_RESULT = 16384] = "PARSE_RESULT", i[i.LIVE = 32768] = "LIVE", i))(u || {});
+const B = /* @__PURE__ */ Symbol("array"), Q = /* @__PURE__ */ Symbol("record"), kt = /* @__PURE__ */ Symbol("QUERY_ID");
+var ct = /* @__PURE__ */ ((i) => (i[i.Array = 0] = "Array", i[i.Value = 1] = "Value", i))(ct || {});
+class U {
+  type;
+  entityDefs;
+  constraintFieldRefs;
+  sort;
+  valueType;
+  onCreate;
+  onUpdate;
+  onDelete;
+  constructor(t, e, n, s, r, o, a, c) {
+    this.type = t, this.entityDefs = e, this.constraintFieldRefs = n, this.sort = s, this.valueType = r, this.onCreate = o, this.onUpdate = a, this.onDelete = c;
+  }
+  static array(t, e, n) {
+    return new U(
+      0,
+      t,
+      e,
+      n,
+      void 0,
+      void 0,
+      void 0,
+      void 0
+    );
+  }
+  static value(t, e, n, s, r, o) {
+    return new U(
+      1,
+      t,
+      e,
+      void 0,
+      n,
+      s,
+      r,
+      o
+    );
+  }
+}
+const O = /* @__PURE__ */ new WeakMap();
+function F(i) {
+  return O.get(i);
+}
+var W = /* @__PURE__ */ ((i) => (i[i.Query = 0] = "Query", i[i.Entity = 1] = "Entity", i))(W || {});
+class be {
+  constructor(t, e, n) {
+    this._onEvict = e, this._intervalId = setInterval(this._tick, t * 6e4 * n);
+  }
+  _currentFlush = /* @__PURE__ */ new Map();
+  _nextFlush = /* @__PURE__ */ new Map();
+  _intervalId;
+  schedule(t, e) {
+    this._nextFlush.set(t, e);
+  }
+  cancel(t) {
+    this._currentFlush.delete(t), this._nextFlush.delete(t);
+  }
+  _tick = () => {
+    const { _currentFlush: t, _nextFlush: e, _onEvict: n } = this;
+    for (const [s, r] of t)
+      n(s, r);
+    this._currentFlush = e, this._nextFlush = /* @__PURE__ */ new Map();
+  };
+  destroy() {
+    clearInterval(this._intervalId);
+  }
+}
+class Ce {
+  _buckets = /* @__PURE__ */ new Map();
+  _nextTickEntries = /* @__PURE__ */ new Map();
+  _nextTickScheduled = !1;
+  _onEvict;
+  _multiplier;
+  constructor(t, e = 1) {
+    this._onEvict = t, this._multiplier = e;
+  }
+  schedule(t, e, n) {
+    if (e === 1 / 0) return;
+    if (e === 0) {
+      const { _nextTickEntries: o } = this;
+      o.set(t, n), this._nextTickScheduled || (this._nextTickScheduled = !0, setTimeout(this._flushNextTick, 0));
+      return;
+    }
+    const { _buckets: s } = this;
+    let r = s.get(e);
+    r || (r = new be(e, this._onEvict, this._multiplier), s.set(e, r)), r.schedule(t, n);
+  }
+  cancel(t, e) {
+    if (e !== 1 / 0) {
+      if (e === 0) {
+        this._nextTickEntries.delete(t);
+        return;
+      }
+      this._buckets.get(e)?.cancel(t);
+    }
+  }
+  _flushNextTick = () => {
+    const { _nextTickEntries: t, _onEvict: e } = this;
+    this._nextTickScheduled = !1;
+    for (const [n, s] of t)
+      e(n, s);
+    t.clear();
+  };
+  destroy() {
+    const { _buckets: t, _nextTickEntries: e } = this;
+    for (const n of t.values())
+      n.destroy();
+    t.clear(), e.clear();
+  }
+}
+class xe {
+  schedule(t, e, n) {
+  }
+  cancel(t, e) {
+  }
+  destroy() {
+  }
+}
+const Y = /* @__PURE__ */ Symbol("fieldRef"), M = /* @__PURE__ */ Symbol("fieldRefPath"), ft = /* @__PURE__ */ Symbol("DEFINITION_TARGET"), G = /* @__PURE__ */ Symbol("CANCEL_PROXY"), Re = /\[([^\]]+)\]/g;
+function Pt(i) {
+  const t = {
+    [Y]: !0,
+    [M]: i
+  };
+  return new Proxy(t, Oe);
+}
+const Oe = {
+  get(i, t) {
+    if (t === Y) return !0;
+    if (t === M) return i[M];
+    if (t === Symbol.toPrimitive || t === "toString" || t === "valueOf") {
+      const n = i[M];
+      return () => `[${n.join(".")}]`;
+    }
+    if (typeof t == "symbol") return;
+    const e = i[M];
+    return Pt([...e, t]);
+  },
+  has(i, t) {
+    return t === Y || t === M;
+  }
+};
+function Lt(i) {
+  return typeof i == "object" && i !== null && i[Y] === !0;
+}
+function jt(i) {
+  return i[M];
+}
+function qt(i) {
+  return new Proxy(i, {
+    set(t, e, n) {
+      return t[e] = n, !0;
+    },
+    get(t, e) {
+      return e === ft ? t : e === G ? () => {
+      } : typeof e == "symbol" ? t[e] : Pt([e]);
+    }
+  });
+}
+function Se(i) {
+  const t = i[ft];
+  i[G]();
+  const e = {};
+  for (const r of Object.getOwnPropertyNames(t))
+    e[r] = t[r];
+  const n = {};
+  let s = Object.getPrototypeOf(t);
+  for (; s && s !== Object.prototype; ) {
+    for (const r of Object.getOwnPropertyNames(s)) {
+      if (r === "constructor") continue;
+      const o = Object.getOwnPropertyDescriptor(s, r);
+      typeof o.value == "function" && !(r in n) && (n[r] = o.value);
+    }
+    s = Object.getPrototypeOf(s);
+  }
+  return { fields: e, methods: n };
+}
+function ut(i, t) {
+  let e = t;
+  for (const n of i) {
+    if (e == null) return;
+    e = e[n];
+  }
+  return e;
+}
+function Ne(i, t) {
+  return i.replace(Re, (e, n) => {
+    const s = n.split("."), r = ut(s, t);
+    return r != null ? encodeURIComponent(String(r)) : "";
+  });
+}
+function P(i, t) {
+  if (Lt(i))
+    return ut(jt(i), t);
+  if (typeof i == "string")
+    return Ne(i, t);
+  if (Array.isArray(i))
+    return i.map((e) => P(e, t));
+  if (typeof i == "object" && i !== null && Object.getPrototypeOf(i) === Object.prototype) {
+    const e = {};
+    for (const n of Object.keys(i))
+      e[n] = P(i[n], t);
+    return e;
+  }
+  return i;
+}
+function et(i, t, e) {
+  const n = i.fields, s = i.methods, r = { params: t }, o = {};
+  for (const [a, c] of Object.entries(n))
+    o[a] = P(c, r);
+  o.params = t, o.context = e;
+  for (const [a, c] of Object.entries(s))
+    o[a] = c.bind(o);
+  return o;
+}
+class Ut {
+  static cache;
+  constructor() {
+    return qt(this);
+  }
+}
+const Vt = Object.entries, it = Object.keys;
+function Et(i) {
+  return typeof i == "number" ? i | u.UNDEFINED : i instanceof _ ? (i.mask & u.UNDEFINED) !== 0 ? i : _.cloneWith(i, u.UNDEFINED) : i;
+}
+function De(i) {
+  return i instanceof _ && (i.mask & u.OBJECT) !== 0 && (i.mask & (u.ENTITY | u.ARRAY | u.UNION | u.RECORD | u.LIVE)) === 0;
+}
+function Kt(i, t, e) {
+  const n = /* @__PURE__ */ new Set();
+  for (const r of i)
+    if (r !== void 0)
+      for (const o of Object.keys(r))
+        n.add(o);
+  const s = {};
+  for (const r of n) {
+    let o = 0, a;
+    const c = [];
+    let f = !0;
+    for (const l of i) {
+      const d = l?.[r];
+      d !== void 0 ? (o++, a === void 0 && (a = d), De(d) ? c.push(d.shape) : (f = !1, c.push(void 0))) : (f = !1, c.push(void 0));
+    }
+    if (f && o > 0) {
+      const l = Kt(c, t), d = new _(u.OBJECT, l);
+      s[r] = o < t ? Et(d) : d;
+    } else
+      s[r] = o < t ? Et(a) : a;
+  }
+  return s;
+}
+class _ {
+  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 collection configuration (shared by LiveArray and LiveValue).
+   */
+  _liveConfig = void 0;
+  constructor(t, e, n, s, r, o) {
+    this.mask = t, this.shape = e, this.values = n, this.typenameField = s, this.typenameValue = r, this.idField = o;
+  }
+  static merge(t) {
+    if (t.length === 1) return t[0];
+    const e = t.length, n = t.map((c) => c.shape);
+    t[0].typenameValue;
+    const s = Kt(n, e);
+    let r, o, a;
+    for (const c of t) {
+      if (r === void 0 && c.idField !== void 0)
+        r = c.idField;
+      else if (r !== void 0 && c.idField !== void 0 && c.idField !== r)
+        throw new Error(
+          `[fetchium] Entity typename '${c.typenameValue}' has conflicting id fields: '${String(r)}' vs '${String(c.idField)}'`
+        );
+      o === void 0 && (o = c.typenameField), a === void 0 && (a = c.typenameValue);
+    }
+    return new _(
+      u.ENTITY | u.OBJECT,
+      s,
+      void 0,
+      o,
+      a,
+      r
+    );
+  }
+  static cloneWith(t, e) {
+    const n = new _(
+      e | t.mask,
+      t.shape,
+      t.values,
+      t.typenameField,
+      t.typenameValue,
+      t.idField
+    );
+    return n._methods = t._methods, n._entityConfig = t._entityConfig, n._entityClass = t._entityClass, n._entityCache = t._entityCache, n._liveConfig = t._liveConfig, n;
+  }
+}
+class H extends Set {
+  lowercaseMap;
+  // lowercase -> canonical (strings only)
+  constructor(t) {
+    super(t), this.lowercaseMap = /* @__PURE__ */ new Map();
+    for (const e of t)
+      if (typeof e == "string") {
+        const n = e.toLowerCase(), s = this.lowercaseMap.get(n);
+        if (s !== void 0)
+          throw new Error(
+            `Case-insensitive enum cannot have multiple values with the same lowercase form: '${s}' and '${e}' both become '${n}'`
+          );
+        this.lowercaseMap.set(n, e);
+      }
+  }
+  /**
+   * 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 Ae = 1128875347;
+we(H, (i) => {
+  let t = Ae;
+  for (const e of i)
+    t += A(e);
+  return t >>> 0;
+});
+function dt(i, t) {
+  return new _(i, t);
+}
+function Ie(i) {
+  return dt(u.ARRAY, i);
+}
+function Me(i) {
+  return dt(u.RECORD | u.OBJECT, i);
+}
+function Te(i) {
+  return dt(u.PARSE_RESULT, i);
+}
+function $t(i, t) {
+  let e = i, n, s, r;
+  for (const [o, a] of Vt(t))
+    switch (typeof a) {
+      case "number":
+        if ((a & u.ID) !== 0) {
+          if (n !== void 0)
+            throw new Error(`Duplicate id field: ${o}`);
+          n = o;
+        }
+        break;
+      case "string":
+        if (s !== void 0 && s !== o)
+          throw new Error(`Duplicate typename field: ${o}`);
+        s = o, r = a;
+        break;
+      case "object":
+        if (a instanceof H || a instanceof Set)
+          break;
+        a.mask & u.LIVE && (e |= u.LIVE);
+        break;
+    }
+  return new _(e, t, void 0, s, r, n);
+}
+function Fe(i) {
+  return $t(u.OBJECT, i);
+}
+function wt(i, t, e) {
+  const n = i.mask;
+  if ((n & u.UNION) !== 0) {
+    const s = i;
+    if (s.typenameField !== void 0) {
+      if (e !== void 0 && e !== s.typenameField)
+        throw new Error(
+          `Union typename field conflict: Cannot merge unions with different typename fields ('${e}' vs '${s.typenameField}')`
+        );
+      e = s.typenameField;
+    }
+    const r = s.shape;
+    if (r !== void 0)
+      for (const o of [...it(r), B, Q]) {
+        const a = r[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 ((n & u.ARRAY) !== 0) {
+    if (t[B] !== void 0)
+      throw new Error("Array shape already defined");
+    t[B] = i.shape;
+  } else if ((n & u.RECORD) !== 0) {
+    if (t[Q] !== void 0)
+      throw new Error("Record shape already defined");
+    t[Q] = i.shape;
+  } else {
+    const s = i.typenameField, r = i.typenameValue;
+    if (r === void 0)
+      throw new Error(
+        "Object definitions must have a typename to be in a union with other objects, records, or arrays"
+      );
+    if (e !== void 0 && s !== e)
+      throw new Error("Object definitions must have the same typename field to be in the same union");
+    e = s, t[r] = i;
+  }
+  return e;
+}
+function lt(...i) {
+  const t = i;
+  let e = 0, n = 0, s, r, o, a, c = 0;
+  for (const l of t) {
+    if (typeof l == "number") {
+      e |= l;
+      continue;
+    }
+    if (l instanceof Set) {
+      if (r === void 0)
+        r = new Set(l);
+      else
+        for (const d of l)
+          r.add(d);
+      continue;
+    }
+    if (n++, c |= l.mask, n === 1) {
+      s = l;
+      continue;
+    }
+    n === 2 && (o = /* @__PURE__ */ Object.create(null), a = wt(s, o, a)), a = wt(l, o, a);
+  }
+  if (n === 0)
+    return r === void 0 ? e : e === 0 ? r : new _(e | u.UNION, void 0, r);
+  if (n === 1)
+    return _.cloneWith(s, e);
+  const f = e | c | u.UNION;
+  return new _(f, o, r, a);
+}
+function ht(i, t, e) {
+  const n = i;
+  if (typeof n == "number")
+    return n | t;
+  if (n instanceof Set)
+    return lt(i, t);
+  let s = e.get(n);
+  return s === void 0 && (s = _.cloneWith(n, t), e.set(n, s)), s;
+}
+const ke = /* @__PURE__ */ new WeakMap(), Pe = /* @__PURE__ */ new WeakMap(), Le = /* @__PURE__ */ new WeakMap();
+function je(i) {
+  return ht(i, u.UNDEFINED | u.NULL, Le);
+}
+function qe(i) {
+  return ht(i, u.UNDEFINED, ke);
+}
+function Ue(i) {
+  return ht(i, u.NULL, Pe);
+}
+function Ve(i) {
+  return i;
+}
+function Ke(i) {
+  return /* @__PURE__ */ new Set([i]);
+}
+const Bt = ((...i) => new Set(i));
+Bt.caseInsensitive = (...i) => new H(i);
+const Qt = 16;
+let $e = 0;
+const nt = [], Yt = [], Gt = /* @__PURE__ */ new Map(), z = /* @__PURE__ */ new WeakSet();
+class V {
+  _raw;
+  _formatted;
+  _parsed;
+  _formatId;
+  constructor(t, e, n) {
+    this._raw = t, this._formatId = e, n ? (this._formatted = nt[e](t), this._parsed = !0) : this._parsed = !1, z.add(this);
+  }
+  getValue() {
+    return this._parsed || (this._formatted = nt[this._formatId](this._raw), this._parsed = !0), this._formatted;
+  }
+  toJSON() {
+    return this._parsed ? Yt[this._formatId](this._formatted) : this._raw;
+  }
+}
+function Be(i) {
+  const t = Gt.get(i);
+  if (t === void 0)
+    throw new Error(`Format ${i} not registered`);
+  return t;
+}
+function Wt(i, t, e, n, s) {
+  const r = $e++;
+  nt[r] = e, Yt[r] = n;
+  const o = s?.eager ?? !0, c = r << Qt | t | u.HAS_FORMAT | (o ? u.IS_EAGER_FORMAT : 0);
+  Gt.set(i, c);
+}
+Wt(
+  "date",
+  u.STRING,
+  (i) => {
+    const t = i.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+    if (!t)
+      throw new Error(`Invalid date string: ${i}. Expected YYYY-MM-DD format.`);
+    const [, e, n, s] = t, r = new Date(Date.UTC(parseInt(e, 10), parseInt(n, 10) - 1, parseInt(s, 10)));
+    if (isNaN(r.getTime()))
+      throw new Error(`Invalid date string: ${i}`);
+    return r;
+  },
+  (i) => {
+    const t = i.getUTCFullYear(), e = String(i.getUTCMonth() + 1).padStart(2, "0"), n = String(i.getUTCDate()).padStart(2, "0");
+    return `${t}-${e}-${n}`;
+  }
+);
+Wt(
+  "date-time",
+  u.STRING,
+  (i) => {
+    const t = new Date(i);
+    if (isNaN(t.getTime()))
+      throw new Error(`Invalid date-time string: ${i}`);
+    return t;
+  },
+  (i) => i.toISOString()
+);
+const bt = /* @__PURE__ */ new WeakMap();
+function L(i) {
+  let t = bt.get(i);
+  if (t === void 0) {
+    const e = new i(), n = e[ft] ?? e;
+    e[G] && e[G]();
+    const s = {};
+    for (const [f, l] of Vt(n))
+      s[f] = l;
+    const r = Object.getPrototypeOf(i.prototype);
+    if (r != null) {
+      const f = r.constructor;
+      if (f !== Ut && typeof f == "function") {
+        const d = L(f).shape;
+        for (const y of it(d))
+          if (y in s && s[y] !== d[y])
+            throw new Error(`Cannot extend: field '${y}' already exists in type definition`);
+      }
+    }
+    const o = {}, a = i.prototype;
+    for (const f of Object.getOwnPropertyNames(a))
+      f !== "constructor" && typeof a[f] == "function" && (o[f] = a[f]);
+    t = $t(u.ENTITY | u.OBJECT, s), t._entityClass = i, it(o).length > 0 && (t._methods = o), typeof o.__subscribe == "function" && (t._entityConfig = { hasSubscribe: !0 });
+    const c = i;
+    c.cache && (t._entityCache = c.cache), bt.set(i, t);
+  }
+  return t;
+}
+function Qe(i) {
+  return L(i);
+}
+function Ht(i, t) {
+  if (t == null) return;
+  const e = /* @__PURE__ */ new Map();
+  if (Array.isArray(t))
+    for (const n of t) {
+      const [s, r] = n, a = L(s).typenameValue;
+      if (a === void 0) continue;
+      const c = [];
+      for (const [f, l] of Object.entries(r))
+        c.push([f, l]);
+      c.length > 0 && e.set(a, c);
+    }
+  else {
+    const s = Object.entries(t);
+    if (s.length === 0) return;
+    const r = s.map(([o, a]) => [o, a]);
+    for (const o of i) {
+      const a = o.typenameValue;
+      a !== void 0 && e.set(a, r);
+    }
+  }
+  return e.size > 0 ? e : void 0;
+}
+function zt(i) {
+  return Array.isArray(i) ? i.map((t) => L(t)) : [L(i)];
+}
+function Ye(i, t) {
+  const e = zt(i), n = e.length === 1 ? e[0] : lt(...e.map((o) => o)), s = u.ARRAY | u.LIVE, r = new _(s, n);
+  return r._liveConfig = U.array(
+    e,
+    Ht(e, t?.constraints),
+    t?.sort
+  ), r;
+}
+function Ge(i, t, e) {
+  const n = zt(t), s = i, r = u.LIVE, o = new _(r, void 0);
+  return o._liveConfig = U.value(
+    n,
+    Ht(n, e?.constraints),
+    s,
+    e.onCreate,
+    e.onUpdate,
+    e.onDelete
+  ), o;
+}
+const We = {
+  format: Be,
+  typename: Ve,
+  const: Ke,
+  enum: Bt,
+  id: u.ID | u.STRING | u.NUMBER,
+  string: u.STRING,
+  number: u.NUMBER,
+  boolean: u.BOOLEAN,
+  null: u.NULL,
+  undefined: u.UNDEFINED,
+  array: Ie,
+  object: Fe,
+  record: Me,
+  union: lt,
+  nullish: je,
+  optional: qe,
+  nullable: Ue,
+  result: Te,
+  entity: Qe,
+  liveArray: Ye,
+  liveValue: Ge
+};
+function j(i, t, e) {
+  return new TypeError(`Validation error at ${i}`);
+}
+const Jt = Array.isArray;
+function Ct(i) {
+  if (i === null) return u.NULL;
+  switch (typeof i) {
+    case "number":
+      return u.NUMBER;
+    case "string":
+      return u.STRING;
+    case "boolean":
+      return u.BOOLEAN;
+    case "undefined":
+      return u.UNDEFINED;
+    case "object":
+      return Jt(i) ? u.ARRAY : u.OBJECT;
+    default:
+      throw new Error(`Invalid type: ${typeof i}`);
+  }
+}
+function Ri(i) {
+  return k(i);
+}
+function k(i) {
+  if (i === null || typeof i != "object")
+    return i;
+  if (Jt(i))
+    return i.map((e) => k(e));
+  if (i instanceof Date)
+    return new Date(i.getTime());
+  if (i instanceof Map) {
+    const e = /* @__PURE__ */ new Map();
+    for (const [n, s] of i)
+      e.set(k(n), k(s));
+    return e;
+  }
+  if (i instanceof Set) {
+    const e = /* @__PURE__ */ new Set();
+    for (const n of i)
+      e.add(k(n));
+    return e;
+  }
+  const t = {};
+  for (const e of Object.keys(i))
+    t[e] = k(i[e]);
+  return t;
+}
+const yt = Object.entries, He = () => {
+};
+class st {
+  queryClient = void 0;
+  preloadedEntities = void 0;
+  warn = He;
+  /** 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, e, n, s = !1) {
+    this.queryClient = t, this.preloadedEntities = e, this.warn = n, this.isPartialEvent = s, t !== void 0 && (this.seen === void 0 ? (this.seen = /* @__PURE__ */ new Map(), this.seenByKey = /* @__PURE__ */ new Map()) : (this.seen.clear(), this.seenByKey.clear()));
+  }
+}
+function Xt(i, t, e) {
+  return T(i, t, e, "");
+}
+function ze(i, t, e) {
+  return pt(i, t, e);
+}
+function xt(i, t, e, n) {
+  const s = i >> Qt;
+  if ((i & u.IS_EAGER_FORMAT) !== 0)
+    try {
+      return new V(t, s, !0);
+    } catch (o) {
+      if ((i & u.UNDEFINED) !== 0) {
+        e.warn("Invalid formatted value for optional type, defaulting to undefined", {
+          value: t,
+          path: n,
+          error: o instanceof Error ? o.message : String(o)
+        });
+        return;
+      }
+      throw o;
+    }
+  return new V(t, s, !1);
+}
+function T(i, t, e, n) {
+  const s = t;
+  if (s instanceof H) {
+    const c = s.get(i);
+    if (c === void 0) throw j(n);
+    return c;
+  }
+  if (s instanceof Set) {
+    if (!s.has(i)) throw j(n);
+    return i;
+  }
+  if (typeof s == "string") {
+    if (i == null) return s;
+    if (i !== s) throw j(n);
+    return i;
+  }
+  if (typeof s == "number") {
+    const c = Ct(i);
+    if ((s & c) === 0) {
+      if ((s & u.UNDEFINED) !== 0) {
+        e.warn("Invalid value for optional type, defaulting to undefined", { value: i, path: n });
+        return;
+      }
+      throw j(n);
+    }
+    return (s & u.HAS_FORMAT) !== 0 && i !== null && i !== void 0 ? xt(s, i, e, n) : i;
+  }
+  const r = s.mask, o = s._liveConfig;
+  if (o !== void 0 && o.type === ct.Value)
+    return o.valueType !== void 0 ? T(i, o.valueType, e, n) : i;
+  if ((r & u.PARSE_RESULT) !== 0)
+    try {
+      return { success: !0, value: T(i, s.shape, e, n) };
+    } catch (c) {
+      return { success: !1, error: c instanceof Error ? c : new Error(String(c)) };
+    }
+  const a = Ct(i);
+  if ((r & a) === 0 && !s.values?.has(i)) {
+    if ((r & u.UNDEFINED) !== 0) {
+      e.warn("Invalid value for optional type, defaulting to undefined", { value: i, path: n });
+      return;
+    }
+    throw j(n);
+  }
+  return a < u.OBJECT ? (r & u.HAS_FORMAT) !== 0 && i !== null && i !== void 0 ? xt(r, i, e, n) : i : (r & u.UNION) !== 0 ? Je(a, i, s, e, n) : a === u.ARRAY ? Zt(i, s.shape, e, n) : (r & u.RECORD) !== 0 ? te(i, s.shape, e, n) : (r & u.ENTITY) !== 0 && e.queryClient !== void 0 ? pt(i, s, e) : ee(i, s, e, n);
+}
+function Je(i, t, e, n, s) {
+  if (i === u.ARRAY) {
+    const r = e.shape[B];
+    return r === void 0 || typeof r == "number" ? t : Zt(t, r, n, s);
+  } else {
+    const r = e.typenameField, o = r ? t[r] : void 0;
+    if (o === void 0 || typeof o != "string") {
+      const c = e.shape[Q];
+      if (c === void 0)
+        throw new Error(
+          `Typename field '${r}' is required for union discrimination but was not found in the data`
+        );
+      return te(t, c, n, s);
+    }
+    const a = e.shape[o];
+    if (a === void 0 || typeof a == "number")
+      throw new Error(`Unknown typename '${o}' in union`);
+    return a.mask & u.ENTITY && n.queryClient !== void 0 ? pt(t, a, n) : ee(t, a, n, s);
+  }
+}
+function Zt(i, t, e, n) {
+  const s = [];
+  for (let r = 0; r < i.length; r++)
+    try {
+      s.push(T(i[r], t, e, `${n}[${r}]`));
+    } catch (o) {
+      e.warn("Failed to parse array item, filtering out", {
+        index: r,
+        value: i[r],
+        error: o instanceof Error ? o.message : String(o)
+      });
+    }
+  return s;
+}
+function te(i, t, e, n) {
+  for (const [s, r] of yt(i))
+    i[s] = T(r, t, e, `${n}["${s}"]`);
+  return i;
+}
+function ee(i, t, e, n) {
+  if (O.has(i))
+    return i;
+  const s = t.shape;
+  for (const [r, o] of yt(s))
+    i[r] = T(i[r], o, e, `${n}.${r}`);
+  return i;
+}
+function pt(i, t, e) {
+  const n = e.queryClient, s = e.preloadedEntities;
+  let r, o;
+  if (s !== void 0)
+    r = i.__entityRef, o = r;
+  else {
+    const p = i[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, r = A([t.typenameValue, o]);
+  }
+  const a = e.seenByKey.get(r);
+  if (a !== void 0)
+    return a.data;
+  if (s !== void 0) {
+    const g = n.entityMap.getEntity(r)?.data ?? s.get(r);
+    if (g === void 0)
+      throw new Error(`Cached entity ${r} not found in preloaded map`);
+    i = g;
+  }
+  const c = {};
+  typeof t.idField == "symbol" && (c[t.idField] = o);
+  const f = n.entityMap.getEntity(r), l = e.isPartialEvent && f !== void 0, d = {
+    key: r,
+    shape: t,
+    data: c,
+    rawKeys: l ? new Set(Object.keys(i)) : void 0
+  };
+  e.seen.set(c, d), e.seenByKey.set(r, d);
+  const y = `[[${t.typenameValue}:${o}]]`, v = t.shape;
+  for (const [p, g] of yt(v))
+    l && !(p in i) || (c[p] = T(i[p], g, e, `${y}.${p}`));
+  return c;
+}
+function Xe(i, t) {
+  return Ze(i, t.shape, t.typenameField);
+}
+function Ze(i, t, e) {
+  if (t === void 0) return !0;
+  for (const n of Object.keys(t)) {
+    if (n === e) continue;
+    const s = t[n];
+    if (s instanceof _) {
+      if ((s.mask & u.UNDEFINED) !== 0) continue;
+      if (!(n in i) || i[n] === void 0) return !1;
+    } else if (typeof s == "number") {
+      if ((s & u.UNDEFINED) !== 0) continue;
+      if (!(n in i) || i[n] === void 0) return !1;
+    } else if (!(n in i) || i[n] === void 0) return !1;
+  }
+  return !0;
+}
+const ti = Object.prototype, $ = /* @__PURE__ */ new WeakMap();
+function D(i) {
+  if (typeof i != "object" || i === null) return i;
+  if (z.has(i)) return D(i.getValue());
+  if (O.has(i)) return i;
+  if (Array.isArray(i)) {
+    let t = $.get(i);
+    return t === void 0 && (t = new Proxy(i, ei), $.set(i, t)), t;
+  }
+  if (Object.getPrototypeOf(i) === ti) {
+    let t = $.get(i);
+    return t === void 0 && (t = new Proxy(i, ii), $.set(i, t)), t;
+  }
+  return i;
+}
+const ei = {
+  get(i, t, e) {
+    if (typeof t == "string") {
+      const n = Number(t);
+      if (Number.isInteger(n) && n >= 0 && n < i.length)
+        return D(i[n]);
+    }
+    return Reflect.get(i, t, e);
+  },
+  set() {
+    return !1;
+  },
+  deleteProperty() {
+    return !1;
+  }
+}, ii = {
+  get(i, t, e) {
+    return typeof t == "string" ? D(i[t]) : Reflect.get(i, t, e);
+  },
+  set() {
+    return !1;
+  },
+  deleteProperty() {
+    return !1;
+  },
+  has(i, t) {
+    return t in i;
+  },
+  ownKeys(i) {
+    return Reflect.ownKeys(i);
+  },
+  getOwnPropertyDescriptor(i, t) {
+    return Object.getOwnPropertyDescriptor(i, t);
+  }
+};
+class ni {
+  _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, e, n, s, r, o) {
+    this._notifier = at(), this._queryClient = o, this.key = t, this.typename = e, this.id = n, this.idField = s, this.data = r, 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 || this.refCount < 0)
+      return;
+    const t = this._entityCache?.gcTime;
+    t !== void 0 ? this._queryClient.gcManager.schedule(this.key, t, W.Entity) : this.evict();
+  }
+  evict() {
+    const t = this.liveCollections.slice();
+    this.liveCollections.length = 0;
+    for (const n of t) n.destroy();
+    this._queryClient.entityMap.remove(this.key);
+    const e = this.entityRefs;
+    if (this.entityRefs = void 0, e)
+      for (const n of e.keys()) n.release();
+  }
+  setChildRefs(t, e) {
+    const n = this.entityRefs;
+    if (t !== void 0 && t.size > 0)
+      for (const s of t.keys())
+        (n === void 0 || !n.has(s)) && s.retain();
+    if (n !== void 0 && n.size > 0)
+      for (const s of n.keys())
+        (t === void 0 || !t.has(s)) && s.release();
+    this.entityRefs = t, e && this.save();
+  }
+  addChildRef(t) {
+    this.entityRefs === void 0 && (this.entityRefs = /* @__PURE__ */ new Map());
+    const e = this.entityRefs.get(t) ?? 0;
+    this.entityRefs.set(t, e + 1), e === 0 && t.retain(), this.save();
+  }
+  removeChildRef(t) {
+    if (this.entityRefs === void 0) return;
+    const e = this.entityRefs.get(t);
+    e !== void 0 && (e <= 1 ? (this.entityRefs.delete(t), t.release()) : this.entityRefs.set(t, e - 1), this.save());
+  }
+  getProxy(t) {
+    const e = t;
+    let n = this._proxies.get(e);
+    return n === void 0 && (n = ri(this, this.key, t, this._notifier, this._queryClient), this._proxies.set(e, n)), n;
+  }
+  get proxy() {
+    return this._proxies.values().next().value;
+  }
+  satisfiesDef(t) {
+    return this.satisfiedDefs.has(t) ? !0 : Xe(this.data, t) ? (this.satisfiedDefs.add(t), !0) : !1;
+  }
+  save() {
+    this._queryClient.entityMap.save(this);
+  }
+  notify() {
+    this._notifier.notify();
+  }
+  consume() {
+    this._notifier.consume();
+  }
+}
+function si(i, t, e) {
+  const n = [];
+  for (const s of i) {
+    if (typeof s != "object" || s === null) continue;
+    const r = O.get(s);
+    if (r === void 0) continue;
+    const o = e.entityMap.getEntity(r);
+    o !== void 0 && o.satisfiesDef(t) && n.push(s);
+  }
+  return n;
+}
+function ri(i, t, e, n, s) {
+  const r = e.shape ?? {}, o = e, a = o._methods, c = o._entityClass, f = o._entityConfig, l = c ? c.prototype : Ut.prototype;
+  e.typenameField;
+  const d = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map(), v = () => ({ __entityRef: t });
+  let p;
+  f?.hasSubscribe && a && "__subscribe" in a && (p = It((w) => {
+    const h = (b) => {
+      b.__eventSource = t, s.applyMutationEvent(b);
+    }, m = a.__subscribe.call(g, h);
+    return w.value = g, m;
+  }));
+  let g;
+  const E = Object.keys(r);
+  if (E.includes("__typename") || E.push("__typename"), a)
+    for (const w of Object.keys(a))
+      E.includes(w) || E.push(w);
+  let S, C = E;
+  function I() {
+    const w = i._extraMethods;
+    if (w !== S) {
+      if (S = w, C = E.slice(), w !== void 0)
+        for (const m of Object.keys(w))
+          C.includes(m) || C.push(m);
+      const h = i._extraGetters;
+      if (h !== void 0)
+        for (const m of Object.keys(h))
+          C.includes(m) || C.push(m);
+    }
+    return C;
+  }
+  const x = {
+    getPrototypeOf() {
+      return l;
+    },
+    get(w, h) {
+      if (typeof h == "symbol") return;
+      if (h === "toJSON") return v;
+      if (h === "__context") return s.getContext();
+      if (h === "__typename") return i.typename;
+      if (p?.value, n.consume(), typeof h == "string") {
+        const b = i._extraGetters;
+        if (b !== void 0 && h in b)
+          return b[h]();
+        const N = i._extraMethods;
+        if (N !== void 0 && h in N) {
+          let R = d.get(h);
+          return R || (R = N[h].bind(g), d.set(h, R)), R;
+        }
+        if (a && h in a) {
+          let R = d.get(h);
+          return R || (R = ge(g, a[h].bind(g)), d.set(h, R)), R;
+        }
+      }
+      const m = i.data[h];
+      if (typeof m == "object" && m !== null && z.has(m))
+        return D(m.getValue());
+      if (Array.isArray(m) && typeof h == "string") {
+        const b = r[h];
+        if (b instanceof _ && (b.mask & u.ARRAY) !== 0) {
+          const N = b.shape;
+          if (N instanceof _ && (N.mask & u.ENTITY) !== 0) {
+            const R = N.typenameValue;
+            if (R !== void 0) {
+              const _t = s.getEntityDefsForTypename(R);
+              if (_t !== void 0 && _t.length > 1) {
+                const X = y.get(h);
+                if (X !== void 0 && X.source === m)
+                  return D(X.filtered);
+                const mt = si(m, N, s);
+                return y.set(h, { source: m, filtered: mt }), D(mt);
+              }
+            }
+          }
+        }
+        return D(m);
+      }
+      return D(m);
+    },
+    set() {
+      return !1;
+    },
+    has(w, h) {
+      if (h === "__typename") return !0;
+      if (typeof h == "string") {
+        const m = i._extraGetters;
+        if (m && h in m) return !0;
+        const b = i._extraMethods;
+        if (b && h in b || a && h in a) return !0;
+      }
+      return h in r;
+    },
+    ownKeys() {
+      return I();
+    },
+    getOwnPropertyDescriptor(w, h) {
+      if (h === "__typename")
+        return { enumerable: !0, configurable: !0, value: i.typename, writable: !1 };
+      if (h in r)
+        return { enumerable: !0, configurable: !0, value: x.get(w, h, g), writable: !1 };
+      if (typeof h == "string") {
+        const m = i._extraGetters;
+        if (m && h in m)
+          return { enumerable: !0, configurable: !0, value: x.get(w, h, g), writable: !1 };
+        const b = i._extraMethods;
+        if (b && h in b)
+          return { enumerable: !0, configurable: !0, value: x.get(w, h, g), writable: !1 };
+        if (a && h in a)
+          return { enumerable: !1, configurable: !0, value: x.get(w, h, g), writable: !1 };
+      }
+    }
+  };
+  return g = new Proxy({}, x), O.set(g, t), pe(g, s), g;
+}
+class oi {
+  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, e, n, s) {
+    let r = this.instances.get(t);
+    if (r === void 0) {
+      const o = n.idField;
+      if (o === void 0)
+        throw new Error(`Entity id field is required ${n.typenameValue}`);
+      const a = e[o];
+      if (typeof a != "string" && typeof a != "number")
+        throw new Error(`Entity id must be string or number: ${n.typenameValue}`);
+      const c = n;
+      r = new ni(t, n.typenameValue, a, o, e, s), r._entityCache = c._entityCache, this.instances.set(t, r);
+    }
+    return r.parseId = s.currentParseId, r;
+  }
+  remove(t) {
+    this.instances.delete(t);
+  }
+  save(t) {
+    let e;
+    if (t.entityRefs) {
+      e = /* @__PURE__ */ new Set();
+      for (const n of t.entityRefs.keys()) e.add(n.key);
+    }
+    this.persistEntity(t.key, t.data, e);
+  }
+}
+class ie {
+  onlineSignal;
+  manualOverride = void 0;
+  eventListenersAttached = !1;
+  constructor(t) {
+    const e = t ?? this.detectOnlineStatus();
+    this.onlineSignal = Mt(e), 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 ne {
+  static onlineSignal = Mt(!0);
+  get isOnline() {
+    return !0;
+  }
+  setNetworkStatus(t) {
+  }
+  clearManualOverride() {
+  }
+  getOnlineSignal() {
+    return ne.onlineSignal;
+  }
+  destroy() {
+  }
+}
+const ai = new ie(), Oi = Tt(ai);
+function gt(i, t = typeof window > "u") {
+  let e;
+  i === !1 ? e = 0 : i === void 0 || i === !0 ? e = t ? 0 : 3 : typeof i == "number" ? e = i : e = i.retries;
+  const n = typeof i == "object" && i.retryDelay ? i.retryDelay : (s) => 1e3 * Math.pow(2, s);
+  return { retries: e, retryDelay: n };
+}
+class ci {
+  static cache;
+  params;
+  config;
+  constructor() {
+    return qt(this);
+  }
+}
+class Si extends ci {
+  method = "GET";
+  path;
+  searchParams;
+  body;
+  headers;
+  requestOptions;
+  loadNext;
+  getStorageKey() {
+    return `${this.method ?? "GET"}:${this.path ?? ""}`;
+  }
+  async send() {
+    return this.executeRequest();
+  }
+  resolveLoadNext() {
+    const e = (this.getLoadNext ? this.getLoadNext() : void 0) ?? this.rawLoadNext;
+    if (e === void 0) return;
+    const n = {
+      params: this.params ?? {},
+      result: this.resultData
+    };
+    return {
+      url: e.url !== void 0 ? P(e.url, n) : void 0,
+      searchParams: e.searchParams !== void 0 ? P(e.searchParams, n) : void 0
+    };
+  }
+  hasNext() {
+    const t = this.resolveLoadNext();
+    if (t === void 0) return !1;
+    if (t.url !== void 0 && t.url !== null)
+      return !0;
+    if (t.searchParams !== void 0) {
+      const e = Object.keys(t.searchParams);
+      if (e.length === 0) return !1;
+      for (const n of e)
+        if (t.searchParams[n] === void 0 || t.searchParams[n] === null)
+          return !1;
+      return !0;
+    }
+    return !1;
+  }
+  async sendNext() {
+    const t = this.resolveLoadNext();
+    if (t === void 0)
+      throw new Error("loadNext is not configured for this query");
+    return this.executeRequest(t);
+  }
+  async executeRequest(t) {
+    const e = t?.url ?? (this.getPath ? this.getPath() : this.path), n = this.getMethod ? this.getMethod() : this.method, s = this.getSearchParams ? this.getSearchParams() : this.searchParams, r = t?.searchParams ? { ...s, ...t.searchParams } : s, o = this.getBody ? this.getBody() : this.body, a = this.getRequestOptions ? this.getRequestOptions() : this.requestOptions;
+    if (!e)
+      throw new Error("RESTQuery requires a path. Define `path` as a field or override `getPath()`.");
+    let c = e;
+    if (r) {
+      const S = new URLSearchParams();
+      for (const I in r) {
+        const x = r[I];
+        x != null && S.append(I, String(x));
+      }
+      const C = S.toString();
+      C && (c += "?" + C);
+    }
+    const f = Dt(a?.baseUrl) ?? Dt(this.context.baseUrl), l = f ? `${f}${c}` : c, { baseUrl: d, signal: y, ...v } = a ?? {}, g = o || this.headers ? {
+      ...o ? { "Content-Type": "application/json" } : void 0,
+      ...this.headers
+    } : void 0, E = await this.context.fetch(l, {
+      method: n,
+      headers: g,
+      body: o ? JSON.stringify(o) : void 0,
+      signal: this.signal,
+      ...v
+    });
+    return this.response = E, E.json();
+  }
+}
+const Rt = /* @__PURE__ */ new WeakMap();
+class J {
+  constructor(t, e) {
+    this.captured = e, this.statics = t;
+  }
+  statics;
+  createExecutionContext(t, e) {
+    return et(this.captured, t, e);
+  }
+  resolveOptions(t) {
+    const { methods: e } = this.captured, n = e.getConfig ? e.getConfig.call(t) : t.config, s = gt(n?.retry);
+    return { config: n, retryConfig: s };
+  }
+  static for(t) {
+    let e = Rt.get(t);
+    if (e !== void 0)
+      return e;
+    const n = new t(), s = Se(n), r = String(s.methods.getStorageKey.call(s.fields)), o = s.fields.result, a = o instanceof _ ? o : We.object(o), c = (a.mask & u.ENTITY) !== 0, f = t.cache, l = s.fields.loadNext, d = typeof s.methods.sendNext == "function", y = c ? a : new _(
+      u.ENTITY | u.OBJECT,
+      a.shape,
+      void 0,
+      void 0,
+      r,
+      // typenameValue — unique per query class
+      kt
+      // idField — symbol, injected onto payload before parse
+    );
+    return e = new J(
+      { id: r, shape: y, cache: f, rawLoadNext: l, hasSendNext: d, isEntityResult: c },
+      s
+    ), Rt.set(t, e), e;
+  }
+}
+const Ni = (i, t) => {
+  const e = J.for(i);
+  return vt(e, t);
+};
+function Di(i, ...t) {
+  const e = J.for(i), n = ve(wi);
+  if (n === void 0)
+    throw new Error("QueryClient not found");
+  const s = t[0];
+  return n.getQuery(e, s);
+}
+function se(i, t) {
+  return new Promise((e, n) => {
+    if (t?.aborted) {
+      n(t.reason);
+      return;
+    }
+    const s = setTimeout(e, i);
+    t?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(s), n(t.reason);
+      },
+      { once: !0 }
+    );
+  });
+}
+async function rt(i, t, e) {
+  const n = Math.max(0, t.retries);
+  let s;
+  for (let r = 0; r <= n; r++) {
+    e?.throwIfAborted();
+    try {
+      return await i();
+    } catch (o) {
+      if (s = o, r >= n) throw o;
+      await se(t.retryDelay(r), e);
+    }
+  }
+  throw s;
+}
+class fi {
+  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 = gt(void 0);
+  /** The raw fetch Response from the most recent successful fetch. */
+  _lastResponse = 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, __loadNext) 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() {
+    return this._relayState;
+  }
+  constructor(t, e, n, s) {
+    this.def = t, this.queryClient = e, this.queryKey = n, this.params = s, this._extraMethods = { __refetch: this.refetch }, t.statics.hasSendNext && (this._extraMethods.__loadNext = this.loadNext);
+    const r = At(s);
+    this._queryId = r !== void 0 ? A(r) : 0, this.relay = It(
+      (o) => {
+        this._relayState = o;
+        const a = () => {
+          clearTimeout(this.debounceTimer), this.debounceTimer = void 0, this._abortController?.abort(), this._abortController = void 0, this._loadNextAbort?.abort(), this._loadNextAbort = void 0, this._loadNextPromise = void 0, this.unsubscribe?.(), this.unsubscribe = void 0;
+          const f = this.config?.gcTime ?? Ft;
+          this.queryClient.gcManager.schedule(this.queryKey, f, W.Query);
+        }, c = (f = !1) => {
+          const { wasPaused: l, isPaused: d, initialized: y } = this;
+          if (this.wasPaused = d, d && !l && y) {
+            a();
+            return;
+          }
+          const v = At(this.params), p = vt(this.def, v), g = p !== this.storageKey;
+          g && (this.currentParams = v, this.storageKey = p), this.getOrCreateExecutionContext(), this.initialized ? l || f ? (this.queryClient.activateQuery(this), f && this.updatedAt !== void 0 && this.setupSubscription(), (this.config?.refreshStaleOnReconnect ?? !0) && this.isStale && this.runDebounced()) : g && (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, e, n = !1, s) {
+    const r = this.def;
+    return this.rootEntity = this.queryClient.parseAndApplyRootEntity(
+      t,
+      this._queryId,
+      r.statics.shape,
+      e,
+      n,
+      s
+    ), this.rootEntity._extraMethods === void 0 && (this.rootEntity._extraMethods = this._extraMethods, this.rootEntity._extraGetters = {
+      __hasNext: () => this.hasNext,
+      __isLoadingNext: () => this._loadNextPromise !== void 0
+    }), this.rootEntity.getProxy(r.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, e = this.relayState;
+    this.initialized = !0;
+    let n;
+    try {
+      n = await t.loadCachedQuery(this.def, this.storageKey), n !== void 0 && (this.updatedAt = n.updatedAt, e.value = this.applyData(n.value, !1, !1, n.preloadedEntities));
+    } catch (s) {
+      t.store.deleteQuery(this.storageKey), t.getContext().log?.warn?.("Failed to initialize query, the query cache may be corrupted or invalid", s);
+    }
+    if (!this.isPaused)
+      try {
+        if (n !== void 0 && this.setupSubscription(), n === void 0 || this.isStale) {
+          if (await se(0), this.isPaused) return;
+          this.runQueryImmediately();
+        }
+      } catch (s) {
+        e.setError(s);
+      }
+  }
+  setupSubscription() {
+    this.unsubscribe?.(), this.unsubscribe = void 0;
+    const t = this.config?.subscribe;
+    if (!t) return;
+    const e = this._executionCtx;
+    this.unsubscribe = t.call(e, (n) => {
+      n.__eventSource = this.queryKey, this.queryClient.applyMutationEvent(n);
+    });
+  }
+  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.rawLoadNext = this.def.statics.rawLoadNext), this._executionCtx.response = this._lastResponse, 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 e = this.getOrCreateExecutionContext(), { send: n } = t.captured.methods, s = this._abortController?.signal;
+    return e.signal = s, rt(
+      async () => {
+        const r = await n.call(e);
+        this._lastResponse = e.response, this._executionCtx.response = this._lastResponse, this.resolveAndApplyOptions(), this.updatedAt = Date.now();
+        const o = this.applyData(r, !0);
+        return this.saveQueryMetadata(), this.unsubscribe === void 0 && this.setupSubscription(), o;
+      },
+      this.retryConfig,
+      s
+    );
+  }
+  runQueryImmediately() {
+    this._abortController?.abort(), this._abortController = new AbortController(), this._loadNextAbort?.abort(), this._loadNextAbort = void 0, this._loadNextPromise = 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);
+  /** In-flight loadNext promise for deduplication. */
+  _loadNextPromise = void 0;
+  /** Controller for aborting in-flight loadNext requests. */
+  _loadNextAbort = void 0;
+  loadNext = () => {
+    if (this.updatedAt === void 0)
+      throw new Error("Cannot call __loadNext before initial data has loaded");
+    return this._loadNextPromise !== void 0 ? this._loadNextPromise : (queueMicrotask(() => this.rootEntity?.notify()), this._loadNextPromise = this.runLoadNext().then(
+      (t) => (this._loadNextPromise = void 0, this.rootEntity?.notify(), t),
+      (t) => {
+        throw this._loadNextPromise = void 0, this.rootEntity?.notify(), t;
+      }
+    ), this._loadNextPromise);
+  };
+  get hasNext() {
+    if (this.rootEntity === void 0 || !this._executionCtx) return !1;
+    const t = this.def.captured.methods.hasNext;
+    return t ? (this._executionCtx.resultData = this.rootEntity.data, t.call(this._executionCtx)) : !1;
+  }
+  async runLoadNext() {
+    const t = this.def;
+    this._loadNextAbort = new AbortController();
+    const e = this._loadNextAbort.signal, n = this.getOrCreateExecutionContext();
+    n.signal = e, n.resultData = this.rootEntity.data;
+    const s = t.captured.methods.sendNext;
+    return rt(
+      async () => {
+        const r = await s.call(n);
+        this._lastResponse = n.response, this._executionCtx.response = this._lastResponse, this.resolveAndApplyOptions(), this.updatedAt = Date.now();
+        const o = this.applyData(r, !0, !0);
+        return this.saveQueryMetadata(), o;
+      },
+      this.retryConfig,
+      e
+    );
+  }
+  // ======================================================
+  // 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 ?? q.Online;
+    if (t === q.Always)
+      return !1;
+    const e = this.queryClient.networkManager.getOnlineSignal().value;
+    switch (t) {
+      case q.Online:
+        return !e;
+      case q.OfflineFirst:
+        return !e && this.updatedAt === void 0;
+      default:
+        return !1;
+    }
+  }
+}
+class ui {
+  def;
+  queryClient;
+  _lastResponse;
+  _inFlight = !1;
+  task;
+  constructor(t, e) {
+    this.def = t, this.queryClient = e, this.task = this.createTask();
+  }
+  createTask() {
+    return _e(
+      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 e = await this.executeWithRetry(t), n = this.validateResponse(e);
+          return this.processEffects(t, n), n;
+        } finally {
+          this._inFlight = !1;
+        }
+      },
+      { desc: `Mutation(${this.def.id})` }
+    );
+  }
+  validateResponse(t) {
+    const e = this.def.responseShape;
+    if (!(e instanceof _))
+      return t;
+    const n = this.queryClient.getContext().log?.warn ?? (() => {
+    }), s = new st();
+    return s.reset(void 0, void 0, n), Xt(t, e, s);
+  }
+  // ======================================================
+  // Effects processing
+  // ======================================================
+  processEffects(t, e) {
+    let n;
+    if (this.def.hasGetEffects) {
+      const r = et(
+        this.def.captured,
+        t ?? {},
+        this.queryClient.getContext()
+      );
+      r.result = e, r.response = this._lastResponse, n = r.getEffects();
+    } else if (this.def.effects !== void 0) {
+      const r = { params: t, result: e };
+      n = P(this.def.effects, r);
+    }
+    if (n === void 0) return;
+    const s = this.queryClient;
+    Z(n.creates, "create", s), Z(n.updates, "update", s), Z(n.deletes, "delete", s);
+  }
+  // ======================================================
+  // Retry logic
+  // ======================================================
+  executeWithRetry(t) {
+    const e = gt(this.def.config?.retry, !0);
+    return rt(async () => {
+      const n = et(
+        this.def.captured,
+        t ?? {},
+        this.queryClient.getContext()
+      ), s = await this.def.captured.methods.send.call(n);
+      return this._lastResponse = n.response, s;
+    }, e);
+  }
+}
+function di(i) {
+  return typeof i == "string" ? i : L(i).typenameValue;
+}
+function Z(i, t, e) {
+  if (i)
+    for (const [n, s] of i) {
+      const r = di(n);
+      r !== void 0 && e.applyMutationEvent({ type: t, typename: r, data: s });
+    }
+}
+const re = "__eventSource";
+function oe(i) {
+  return { field: i, segments: i.indexOf(".") !== -1 ? i.split(".") : void 0 };
+}
+function li(i) {
+  return i.map(oe);
+}
+function hi(i, t) {
+  if (t.segments === void 0) return i[t.field];
+  let e = i;
+  for (const n of t.segments) {
+    if (e == null) return;
+    e = e[n];
+  }
+  return e;
+}
+function ae(i, t) {
+  const e = [];
+  for (let n = 0; n < t.length; n++) {
+    const s = t[n], r = hi(i, s);
+    if (r === void 0) return;
+    e.push(s.field, r);
+  }
+  return A(e);
+}
+function yi(i, t) {
+  if (i === void 0) return;
+  const e = /* @__PURE__ */ new Map();
+  for (const [n, s] of i) {
+    const r = s.slice().sort((c, f) => c[0] < f[0] ? -1 : c[0] > f[0] ? 1 : 0), o = [];
+    let a = !0;
+    for (const [c, f] of r) {
+      let l;
+      if (Lt(f)) {
+        const d = jt(f);
+        l = ut(d, t);
+      } else
+        l = f;
+      if (l === void 0) {
+        a = !1;
+        break;
+      }
+      o.push(c, l);
+    }
+    a && e.set(n, A(o));
+  }
+  return e.size > 0 ? e : void 0;
+}
+function Ot(i, t) {
+  const e = i.get(t);
+  if (e !== void 0)
+    return e.map(([n]) => n).sort();
+}
+class pi {
+  fields;
+  fieldPaths;
+  _bindings = /* @__PURE__ */ new Map();
+  constructor(t) {
+    this.fields = t, this.fieldPaths = t.map(oe);
+  }
+  register(t, e) {
+    let n = this._bindings.get(t);
+    n === void 0 && (n = /* @__PURE__ */ new Set(), this._bindings.set(t, n)), n.add(e);
+  }
+  unregister(t, e) {
+    const n = this._bindings.get(t);
+    n !== void 0 && (n.delete(e), n.size === 0 && this._bindings.delete(t));
+  }
+  getMatching(t) {
+    return this._bindings.get(t);
+  }
+  get isEmpty() {
+    return this._bindings.size === 0;
+  }
+}
+function St(i) {
+  return A(i);
+}
+class gi {
+  _groups = /* @__PURE__ */ new Map();
+  getOrCreateGroup(t) {
+    const e = St(t);
+    let n = this._groups.get(e);
+    return n === void 0 && (n = new pi(t), this._groups.set(e, n)), n;
+  }
+  register(t, e, n) {
+    this.getOrCreateGroup(e).register(t, n);
+  }
+  unregister(t, e, n) {
+    const s = St(e), r = this._groups.get(s);
+    r !== void 0 && (r.unregister(t, n), r.isEmpty && this._groups.delete(s));
+  }
+  registerBinding(t, e) {
+    const n = t._constraintHashes.get(e);
+    if (n === void 0) return;
+    const s = Ot(t._constraintFieldRefs, e);
+    s !== void 0 && this.register(n, s, t);
+  }
+  unregisterBinding(t, e) {
+    const n = t._constraintHashes.get(e);
+    if (n === void 0) return;
+    const s = Ot(t._constraintFieldRefs, e);
+    s !== void 0 && this.unregister(n, s, t);
+  }
+  routeEvent(t, e, n, s, r, o) {
+    for (const a of this._groups.values()) {
+      const c = ae(e, a.fieldPaths);
+      if (c === void 0) continue;
+      const f = a.getMatching(c);
+      if (f !== void 0)
+        for (const l of f)
+          l.onEvent(t, n, s, r, o);
+    }
+  }
+}
+function Nt(i) {
+  const t = /* @__PURE__ */ new Set();
+  for (const e of i)
+    if (typeof e == "object" && e !== null) {
+      const n = F(e);
+      n !== void 0 && t.add(n);
+    }
+  return t;
+}
+class ce {
+  _queryClient;
+  _parent;
+  _constraintHashes;
+  _entityDefsByTypename;
+  _constraintFieldRefs;
+  instance;
+  constructor(t, e, n, s, r, o) {
+    this._queryClient = n, this._parent = s, this._constraintHashes = r, this._constraintFieldRefs = e, 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, e, n, s, r) {
+    const o = this._entityDefsByTypename.get(t);
+    if (o === void 0) return;
+    const a = this._queryClient.entityMap.getEntity(e);
+    if (n === "delete") {
+      const f = a !== void 0 ? a.getProxy(o) : r;
+      f !== void 0 && (this.instance.onEvent(e, f, r ?? a?.data ?? {}, "delete"), s?.());
+      return;
+    }
+    if (a === void 0 || !a.satisfiesDef(o)) return;
+    s?.();
+    const c = a.getProxy(o);
+    this.instance.onEvent(e, c, a.data, n);
+  }
+  destroy() {
+    this._queryClient.unregisterLiveCollection(this);
+    const t = this._parent.liveCollections, e = t.indexOf(this);
+    e !== -1 && t.splice(e, 1);
+  }
+}
+class vi {
+  _notifier;
+  _items;
+  _keys;
+  _outputSignal;
+  _queryClient;
+  _parent;
+  constructor(t, e, n, s, r, o) {
+    this._notifier = at(), this._items = n, this._keys = Nt(n), this._queryClient = t, this._parent = e;
+    const a = s !== void 0 && r !== void 0, c = o !== void 0;
+    (a || c) && (this._outputSignal = me(() => {
+      this._notifier.consume();
+      let f = this._items;
+      if (a) {
+        const l = [];
+        for (const d of f) {
+          if (typeof d != "object" || d === null) {
+            l.push(d);
+            continue;
+          }
+          const y = F(d);
+          if (y === void 0) {
+            l.push(d);
+            continue;
+          }
+          const v = t.entityMap.getEntity(y);
+          if (v === void 0) {
+            l.push(d);
+            continue;
+          }
+          v.consume(), ae(v.data, s) === r && l.push(d);
+        }
+        f = l;
+      }
+      return c && (f = (f === this._items ? f.slice() : f).sort(o)), f;
+    }));
+  }
+  onEvent(t, e, n, s) {
+    switch (s) {
+      case "create":
+        this.add(t, e);
+        break;
+      case "update":
+        !this.has(t) && e !== void 0 && this.add(t, e);
+        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, e) {
+    if (this._keys.has(t)) return !1;
+    this._keys.add(t), this._items.push(e);
+    const n = this._queryClient.entityMap.getEntity(t);
+    return n !== void 0 && (this._parent.addChildRef(n), n.save()), this._notifier.notify(), !0;
+  }
+  remove(t) {
+    if (!this._keys.has(t)) return !1;
+    this._keys.delete(t);
+    const e = this._findIndex(t);
+    e !== -1 && this._items.splice(e, 1);
+    const n = this._queryClient.entityMap.getEntity(t);
+    return n !== void 0 && this._parent.removeChildRef(n), this._notifier.notify(), !0;
+  }
+  has(t) {
+    return this._keys.has(t);
+  }
+  reset(t) {
+    const e = this._items, n = Array.isArray(t) ? t : [];
+    this._items = n, this._keys = Nt(n);
+    for (const s of n)
+      if (typeof s == "object" && s !== null) {
+        const r = F(s);
+        if (r !== void 0) {
+          const o = this._queryClient.entityMap.getEntity(r);
+          o !== void 0 && this._parent.addChildRef(o);
+        }
+      }
+    for (const s of e)
+      if (typeof s == "object" && s !== null) {
+        const r = F(s);
+        if (r !== void 0) {
+          const o = this._queryClient.entityMap.getEntity(r);
+          o !== void 0 && this._parent.removeChildRef(o);
+        }
+      }
+    this._notifier.notify();
+  }
+  append(t) {
+    if (Array.isArray(t))
+      for (const e of t) {
+        if (typeof e != "object" || e === null) continue;
+        const n = F(e);
+        n !== void 0 && this.add(n, e);
+      }
+  }
+  _findIndex(t) {
+    for (let e = 0; e < this._items.length; e++) {
+      const n = this._items[e];
+      if (typeof n == "object" && n !== null && F(n) === t)
+        return e;
+    }
+    return -1;
+  }
+}
+class _i {
+  _notifier;
+  _value;
+  _createdKeys;
+  _deletedKeys;
+  _queryClient;
+  _parent;
+  _onCreate;
+  _onUpdate;
+  _onDelete;
+  constructor(t, e, n, s, r, o) {
+    this._notifier = at(), this._value = n, this._createdKeys = /* @__PURE__ */ new Set(), this._deletedKeys = /* @__PURE__ */ new Set(), this._queryClient = t, this._parent = e, this._onCreate = s, this._onUpdate = r, this._onDelete = o;
+  }
+  onEvent(t, e, n, s) {
+    switch (s) {
+      case "create":
+        if (this._createdKeys.has(t)) return;
+        this._createdKeys.add(t), this._value = this._onCreate(this._value, e);
+        break;
+      case "update":
+        this._value = this._onUpdate(this._value, e ?? n);
+        break;
+      case "delete":
+        if (this._deletedKeys.has(t)) return;
+        this._deletedKeys.add(t), this._value = this._onDelete(this._value, e ?? n);
+        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 fe(i, t, e, n, s) {
+  let r = i.constraintFieldRefs;
+  if (r === void 0) {
+    r = /* @__PURE__ */ new Map();
+    for (const f of i.entityDefs) {
+      const l = f.typenameValue;
+      l !== void 0 && r.set(l, [[re, e.key]]);
+    }
+  }
+  const o = yi(r, n) ?? /* @__PURE__ */ new Map();
+  let a;
+  if (i.type === ct.Array) {
+    let f, l;
+    if (i.constraintFieldRefs !== void 0 && o.size > 0 && o.size === 1)
+      for (const [d] of i.constraintFieldRefs) {
+        const y = o.get(d);
+        if (y !== void 0) {
+          l = y;
+          const v = i.constraintFieldRefs.get(d);
+          v !== void 0 && (f = li(v.map(([p]) => p)));
+          break;
+        }
+      }
+    a = new vi(
+      s,
+      e,
+      Array.isArray(t) ? t : [],
+      f,
+      l,
+      i.sort
+    );
+  } else
+    a = new _i(
+      s,
+      e,
+      t,
+      i.onCreate,
+      i.onUpdate,
+      i.onDelete
+    );
+  const c = new ce(
+    i.entityDefs,
+    r,
+    s,
+    e,
+    o,
+    a
+  );
+  return e.liveCollections.push(c), s.registerLiveCollection(c), c;
+}
+const ue = Object.entries, de = Object.prototype;
+function tt(i, t, e, n = !1) {
+  const s = i.queryClient;
+  s.currentParseId++;
+  const r = i.seen, o = /* @__PURE__ */ new Map();
+  return { data: K(t, r, s, e, o, n), entityRefs: o };
+}
+function K(i, t, e, n, s, r) {
+  if (typeof i != "object" || i === null) return i;
+  const o = t.get(i);
+  if (o !== void 0)
+    return mi(o, t, e, n, s, r);
+  if (Array.isArray(i)) {
+    for (let a = 0; a < i.length; a++) {
+      const c = i[a];
+      typeof c == "object" && c !== null && !(c instanceof V) && !O.has(c) && (i[a] = K(c, t, e, n, s, r));
+    }
+    return i;
+  }
+  if (Object.getPrototypeOf(i) === de && !O.has(i)) {
+    const a = i;
+    for (const c of Object.keys(a)) {
+      const f = a[c];
+      typeof f == "object" && f !== null && !(f instanceof V) && !O.has(f) && (a[c] = K(f, t, e, n, s, r));
+    }
+  }
+  return i;
+}
+function le(i) {
+  return typeof i == "object" && i !== null && !(i instanceof V) && !O.has(i);
+}
+function mi(i, t, e, n, s, r) {
+  const { key: o, data: a, shape: c, rawKeys: f } = i, l = c.shape, d = e.prepareEntity(o, a, c), y = d.data, v = y !== a, p = v && f !== void 0 && d.entityRefs !== void 0 ? new Map(d.entityRefs) : /* @__PURE__ */ new Map();
+  if (v ? (he(
+    l,
+    a,
+    y,
+    f,
+    d,
+    y,
+    t,
+    e,
+    n,
+    p,
+    r
+  ), d.notify()) : ye(l, a, d, a, t, e, n, p, r), r && d.liveCollections.length > 0)
+    for (const E of d.liveCollections) {
+      const S = E.instance.getRawValue();
+      if (Array.isArray(S))
+        for (const C of S) {
+          if (typeof C != "object" || C === null) continue;
+          const I = O.get(C);
+          if (I === void 0) continue;
+          const x = e.entityMap.getEntity(I);
+          x !== void 0 && p.set(x, (p.get(x) ?? 0) + 1);
+        }
+    }
+  d.setChildRefs(p.size > 0 ? p : void 0, n);
+  const g = d.getProxy(c);
+  return s.set(d, (s.get(d) ?? 0) + 1), g;
+}
+function he(i, t, e, n, s, r, o, a, c, f, l) {
+  for (const [d, y] of ue(i))
+    if (!(n !== void 0 && !n.has(d)))
+      if (le(t[d]) && (t[d] = K(t[d], o, a, c, f, l)), y instanceof _ && y._liveConfig !== void 0) {
+        const v = e[d];
+        v instanceof ce ? l ? v.append(t[d]) : v.reset(t[d]) : e[d] = fe(
+          y._liveConfig,
+          t[d],
+          s,
+          r,
+          a
+        );
+      } else {
+        const v = t[d], p = e[d];
+        if (ot(v) && ot(p)) {
+          const g = y instanceof _ && y.shape !== void 0 ? y.shape : void 0;
+          if (g !== void 0)
+            he(
+              g,
+              v,
+              p,
+              void 0,
+              s,
+              r,
+              o,
+              a,
+              c,
+              f,
+              l
+            );
+          else
+            for (const E of Object.keys(v))
+              p[E] = v[E];
+          e[d] = p;
+        } else
+          e[d] = v;
+      }
+}
+function ye(i, t, e, n, s, r, o, a, c) {
+  for (const [f, l] of ue(i))
+    if (f in t)
+      if (le(t[f]) && (t[f] = K(t[f], s, r, o, a, c)), l instanceof _ && l._liveConfig !== void 0)
+        t[f] = fe(
+          l._liveConfig,
+          t[f],
+          e,
+          n,
+          r
+        );
+      else {
+        const d = t[f];
+        if (ot(d)) {
+          const y = l instanceof _ && l.shape !== void 0 ? l.shape : void 0;
+          y !== void 0 && ye(y, d, e, n, s, r, o, a, c);
+        }
+      }
+}
+function ot(i) {
+  return typeof i == "object" && i !== null && !Array.isArray(i) && Object.getPrototypeOf(i) === de && !O.has(i);
+}
+function Dt(i) {
+  if (i !== void 0)
+    return typeof i == "string" ? i : typeof i == "function" ? i() : i.value;
+}
+function Ei(i) {
+  return Ee(i);
+}
+function At(i) {
+  if (i === void 0)
+    return;
+  const t = {};
+  for (const [e, n] of Object.entries(i))
+    Ei(n) ? t[e] = n.value : t[e] = n;
+  return t;
+}
+const vt = (i, t) => A([i.statics.id, t]);
+class Ai {
+  constructor(t, e = { fetch, log: console }, n, s) {
+    this.context = e, this.isServer = typeof window > "u", this.store = t, this.gcManager = s ?? (this.isServer ? new xe() : new Ce(this.handleEviction, this.context.evictionMultiplier)), this.networkManager = n ?? new ie(), this.entityMap = new oi((r, o, a) => this.store.saveEntity(r, o, a)), this.store.purgeStaleQueries?.();
+  }
+  entityMap;
+  queryInstances = /* @__PURE__ */ new Map();
+  mutationInstances = /* @__PURE__ */ new Map();
+  gcManager;
+  networkManager;
+  isServer;
+  store;
+  currentParseId = 0;
+  typenameRegistry = /* @__PURE__ */ new Map();
+  constraintRegistry = /* @__PURE__ */ new Map();
+  mergedDefCache = /* @__PURE__ */ new Map();
+  getContext() {
+    return this.context;
+  }
+  // ======================================================
+  // Typename Registry (per-client)
+  // ======================================================
+  registerEntityDef(t) {
+    const e = t.typenameValue;
+    if (e === void 0 || t._entityClass === void 0) return;
+    const n = this.typenameRegistry.get(e);
+    if (n !== void 0) {
+      if (n.indexOf(t) !== -1) return;
+      n.push(t), this.mergedDefCache.delete(e), this.getMergedDef(e);
+    } else
+      this.typenameRegistry.set(e, [t]);
+  }
+  getEntityDefsForTypename(t) {
+    return this.typenameRegistry.get(t);
+  }
+  getMergedDef(t) {
+    let e = this.mergedDefCache.get(t);
+    if (e !== void 0) return e;
+    const n = this.typenameRegistry.get(t);
+    if (n !== void 0)
+      return e = _.merge(n), this.mergedDefCache.set(t, e), e;
+  }
+  saveQueryData(t, e, n, s, r) {
+    const o = r !== void 0 && r.size > 0 ? new Set([...r.keys()].map((a) => a.key)) : void 0;
+    this.store.saveQuery(t, e, n, s, o);
+  }
+  activateQuery(t) {
+    const { def: e, queryKey: n, storageKey: s, config: r } = t;
+    this.store.activateQuery(e, s);
+    const o = r?.gcTime ?? Ft;
+    this.gcManager.cancel(n, o);
+  }
+  loadCachedQuery(t, e) {
+    return this.store.loadQuery(t, e);
+  }
+  /**
+   * Loads a query from the document store and returns a QueryResult
+   * that triggers fetches and prepopulates with cached data
+   */
+  getQuery(t, e) {
+    const n = vt(t, e);
+    let s = this.queryInstances.get(n);
+    return s === void 0 && (s = new fi(t, this, n, e), this.queryInstances.set(n, s)), s.relay;
+  }
+  /**
+   * Gets or creates a MutationResult for the given mutation definition.
+   * Mutations are cached by their definition ID.
+   */
+  getMutation(t) {
+    const e = t.id;
+    let n = this.mutationInstances.get(e);
+    return n === void 0 && (n = new ui(t, this), this.mutationInstances.set(e, n)), n.task;
+  }
+  /**
+   * Parse data: validates, formats, produces parsed entity data objects.
+   * Does NOT touch the entity store. Call applyRefs() after to commit entities.
+   */
+  parseData(t, e, n) {
+    const s = this.context.log?.warn ?? (() => {
+    }), r = new st();
+    return r.reset(this, n, s), { data: Xt(t, e, r), ctx: r };
+  }
+  /**
+   * 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, e = !0, n = !1) {
+    return tt(t.ctx, t.data, e, n);
+  }
+  /**
+   * 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, e, n, s, r = !1, o) {
+    typeof n.idField == "symbol" && typeof t == "object" && t !== null && !("__entityRef" in t) && (t[kt] = e);
+    const a = this.parseData(t, n, o), c = tt(a.ctx, a.data, s, r), f = O.get(c.data);
+    return this.entityMap.getEntity(f);
+  }
+  prepareEntity(t, e, n) {
+    return this.registerEntityDef(n), this.entityMap.getOrCreateEntity(t, e, n, this);
+  }
+  // ======================================================
+  // Mutation Events
+  // ======================================================
+  applyMutationEvent(t) {
+    const { type: e, typename: n } = t, s = this.getMergedDef(n);
+    if (s === void 0) return;
+    const r = s.idField;
+    if (r === void 0 || typeof r == "symbol") return;
+    const o = t.data, a = t.id !== void 0 ? t.id : e === "delete" && (typeof o == "string" || typeof o == "number") ? o : o[r];
+    if (a === void 0) return;
+    const c = A([n, a]), f = t.__eventSource, l = typeof o == "object" && o !== null ? o : {}, d = this.entityMap.getEntity(c);
+    if (e === "delete") {
+      const g = d !== void 0 ? d.data : l;
+      this.routeEvent(n, g, c, e, f, void 0, g);
+      return;
+    }
+    try {
+      const g = this.context.log?.warn ?? (() => {
+      }), E = new st();
+      E.reset(
+        this,
+        void 0,
+        g,
+        /* isPartialEvent */
+        !0
+      );
+      const S = ze(l, s, E);
+      tt(E, S, !0);
+    } catch (g) {
+      if (this.context.log?.warn?.("Failed to apply mutation event", g), d === void 0) {
+        const E = this.entityMap.getEntity(c);
+        E !== void 0 && E.evict();
+      }
+      return;
+    }
+    const y = this.entityMap.getEntity(c);
+    if (y === void 0) return;
+    this.entityMap.save(y);
+    const v = d === void 0;
+    let p = !1;
+    this.routeEvent(n, y.data, c, e, f, () => {
+      p = !0;
+    }), v && !p && y.evict();
+  }
+  // ======================================================
+  // In-Memory GC
+  // ======================================================
+  handleEviction = (t, e) => {
+    if (e === W.Query) {
+      const s = this.queryInstances.get(t);
+      if (s === void 0) return;
+      s.rootEntity?.evict(), this.queryInstances.delete(t);
+      return;
+    }
+    const n = this.entityMap.getEntity(t);
+    n !== void 0 && n.evict();
+  };
+  // ======================================================
+  // Constraint Registry (Live Collections)
+  // ======================================================
+  getOrCreateMatcher(t) {
+    let e = this.constraintRegistry.get(t);
+    return e === void 0 && (e = new gi(), this.constraintRegistry.set(t, e)), e;
+  }
+  registerLiveCollection(t) {
+    for (const [e, n] of t._entityDefsByTypename)
+      this.registerEntityDef(n), this.getOrCreateMatcher(e).registerBinding(t, e);
+  }
+  unregisterLiveCollection(t) {
+    for (const e of t._entityDefsByTypename.keys()) {
+      const n = this.constraintRegistry.get(e);
+      n !== void 0 && n.unregisterBinding(t, e);
+    }
+  }
+  routeEvent(t, e, n, s, r, o, a) {
+    const c = this.constraintRegistry.get(t);
+    if (c === void 0) return;
+    const f = r !== void 0 ? { ...e, [re]: r } : e;
+    c.routeEvent(t, f, n, s, o, a);
+  }
+  destroy() {
+    this.gcManager.destroy(), this.networkManager.destroy(), this.queryInstances.clear(), this.mutationInstances.clear(), this.constraintRegistry.clear(), this.typenameRegistry.clear(), this.mergedDefCache.clear();
+  }
+}
+const wi = Tt(void 0);
+export {
+  B as A,
+  Ut as E,
+  Ce as G,
+  ct as L,
+  u as M,
+  ie as N,
+  wi as Q,
+  Si as R,
+  _ as V,
+  Ai as a,
+  Wt as b,
+  qt as c,
+  ci as d,
+  Se as e,
+  Di as f,
+  Ri as g,
+  ne as h,
+  ai as i,
+  Oi as j,
+  xe as k,
+  q as l,
+  Q as m,
+  kt as n,
+  U as o,
+  Ni as q,
+  Dt as r,
+  We as t
+};
+//# sourceMappingURL=QueryClient-BP0Z1rQV.js.map