fetchium 0.0.0 → 0.1.1

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

@@ -0,0 +1,2457 @@
+import { notifier as at, relay as It, setScopeOwner as ye, reactiveMethod as pe, signal as Nt, context as Mt, getContext as ge, task as ve, reactiveSignal as _e, isSignal as me, watcher as we } from "signalium";
+import { registerCustomHash as Ee, hashValue as D } from "signalium/utils";
+import { d as kt } from "./shared-DcuVH8Pf.js";
+import { SyncQueryStore as Ce, MemoryPersistentStore as be } from "./stores/sync.js";
+var L = /* @__PURE__ */ ((n) => (n.Always = "always", n.Online = "online", n.OfflineFirst = "offlineFirst", n))(L || {}), l = /* @__PURE__ */ ((n) => (n[n.UNDEFINED = 1] = "UNDEFINED", n[n.NULL = 2] = "NULL", n[n.NUMBER = 4] = "NUMBER", n[n.STRING = 8] = "STRING", n[n.BOOLEAN = 16] = "BOOLEAN", n[n.OBJECT = 32] = "OBJECT", n[n.ARRAY = 64] = "ARRAY", n[n.ID = 128] = "ID", n[n.RECORD = 256] = "RECORD", n[n.UNION = 512] = "UNION", n[n.ENTITY = 1024] = "ENTITY", n[n.HAS_FORMAT = 4096] = "HAS_FORMAT", n[n.IS_EAGER_FORMAT = 8192] = "IS_EAGER_FORMAT", n[n.PARSE_RESULT = 16384] = "PARSE_RESULT", n[n.LIVE = 32768] = "LIVE", n))(l || {});
+const Q = /* @__PURE__ */ Symbol("array"), B = /* @__PURE__ */ Symbol("record"), Ft = /* @__PURE__ */ Symbol("QUERY_ID");
+var ct = /* @__PURE__ */ ((n) => (n[n.Array = 0] = "Array", n[n.Value = 1] = "Value", n))(ct || {});
+class j {
+  type;
+  entityDefs;
+  constraintFieldRefs;
+  sort;
+  valueType;
+  onCreate;
+  onUpdate;
+  onDelete;
+  constructor(t, e, i, s, r, o, a, c) {
+    this.type = t, this.entityDefs = e, this.constraintFieldRefs = i, this.sort = s, this.valueType = r, this.onCreate = o, this.onUpdate = a, this.onDelete = c;
+  }
+  static array(t, e, i) {
+    return new j(
+      0,
+      t,
+      e,
+      i,
+      void 0,
+      void 0,
+      void 0,
+      void 0
+    );
+  }
+  static value(t, e, i, s, r, o) {
+    return new j(
+      1,
+      t,
+      e,
+      void 0,
+      i,
+      s,
+      r,
+      o
+    );
+  }
+}
+const x = /* @__PURE__ */ new WeakMap();
+function k(n) {
+  return x.get(n);
+}
+var z = /* @__PURE__ */ ((n) => (n[n.Query = 0] = "Query", n[n.Entity = 1] = "Entity", n))(z || {});
+class xe {
+  constructor(t, e, i) {
+    this._onEvict = e, this._intervalId = setInterval(this._tick, t * 6e4 * i);
+  }
+  _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: i } = this;
+    for (const [s, r] of t)
+      i(s, r);
+    this._currentFlush = e, this._nextFlush = /* @__PURE__ */ new Map();
+  };
+  destroy() {
+    clearInterval(this._intervalId);
+  }
+}
+class Oe {
+  _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, i) {
+    if (e === 1 / 0) return;
+    if (e === 0) {
+      const { _nextTickEntries: o } = this;
+      o.set(t, i), this._nextTickScheduled || (this._nextTickScheduled = !0, setTimeout(this._flushNextTick, 0));
+      return;
+    }
+    const { _buckets: s } = this;
+    let r = s.get(e);
+    r || (r = new xe(e, this._onEvict, this._multiplier), s.set(e, r)), r.schedule(t, i);
+  }
+  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 [i, s] of t)
+      e(i, s);
+    t.clear();
+  };
+  destroy() {
+    const { _buckets: t, _nextTickEntries: e } = this;
+    for (const i of t.values())
+      i.destroy();
+    t.clear(), e.clear();
+  }
+}
+class Re {
+  schedule(t, e, i) {
+  }
+  cancel(t, e) {
+  }
+  destroy() {
+  }
+}
+const Y = /* @__PURE__ */ Symbol("fieldRef"), N = /* @__PURE__ */ Symbol("fieldRefPath"), ft = /* @__PURE__ */ Symbol("DEFINITION_TARGET"), G = /* @__PURE__ */ Symbol("CANCEL_PROXY"), Se = /\[([^\]]+)\]/g;
+function Tt(n) {
+  const t = {
+    [Y]: !0,
+    [N]: n
+  };
+  return new Proxy(t, Ae);
+}
+const Ae = {
+  get(n, t) {
+    if (t === Y) return !0;
+    if (t === N) return n[N];
+    if (t === Symbol.toPrimitive || t === "toString" || t === "valueOf") {
+      const i = n[N];
+      return () => `[${i.join(".")}]`;
+    }
+    if (typeof t == "symbol") return;
+    const e = n[N];
+    return Tt([...e, t]);
+  },
+  has(n, t) {
+    return t === Y || t === N;
+  }
+};
+function Pt(n) {
+  return typeof n == "object" && n !== null && n[Y] === !0;
+}
+function Lt(n) {
+  return n[N];
+}
+function jt(n) {
+  return new Proxy(n, {
+    set(t, e, i) {
+      return t[e] = i, !0;
+    },
+    get(t, e) {
+      return e === ft ? t : e === G ? () => {
+      } : typeof e == "symbol" ? t[e] : Tt([e]);
+    }
+  });
+}
+function De(n) {
+  const t = n[ft];
+  n[G]();
+  const e = {};
+  for (const r of Object.getOwnPropertyNames(t))
+    e[r] = t[r];
+  const i = {};
+  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 i) && (i[r] = o.value);
+    }
+    s = Object.getPrototypeOf(s);
+  }
+  return { fields: e, methods: i };
+}
+function ut(n, t) {
+  let e = t;
+  for (const i of n) {
+    if (e == null) return;
+    e = e[i];
+  }
+  return e;
+}
+function Ie(n, t) {
+  return n.replace(Se, (e, i) => {
+    const s = i.split("."), r = ut(s, t);
+    return r != null ? encodeURIComponent(String(r)) : "";
+  });
+}
+function W(n, t) {
+  if (Pt(n))
+    return ut(Lt(n), t);
+  if (typeof n == "string")
+    return Ie(n, t);
+  if (Array.isArray(n))
+    return n.map((e) => W(e, t));
+  if (typeof n == "object" && n !== null && Object.getPrototypeOf(n) === Object.prototype) {
+    const e = {};
+    for (const i of Object.keys(n))
+      e[i] = W(n[i], t);
+    return e;
+  }
+  return n;
+}
+function et(n, t, e) {
+  const i = n.fields, s = n.methods, r = { params: t }, o = {};
+  for (const [a, c] of Object.entries(i))
+    o[a] = W(c, r);
+  o.params = t, o.context = e;
+  for (const [a, c] of Object.entries(s))
+    o[a] = c.bind(o);
+  return o;
+}
+class qt {
+  static cache;
+  constructor() {
+    return jt(this);
+  }
+}
+const Ut = Object.entries, nt = Object.keys;
+function wt(n) {
+  return typeof n == "number" ? n | l.UNDEFINED : n instanceof _ ? (n.mask & l.UNDEFINED) !== 0 ? n : _.cloneWith(n, l.UNDEFINED) : n;
+}
+function Ne(n) {
+  return n instanceof _ && (n.mask & l.OBJECT) !== 0 && (n.mask & (l.ENTITY | l.ARRAY | l.UNION | l.RECORD | l.LIVE)) === 0;
+}
+function Vt(n, t, e) {
+  const i = /* @__PURE__ */ new Set();
+  for (const r of n)
+    if (r !== void 0)
+      for (const o of Object.keys(r))
+        i.add(o);
+  const s = {};
+  for (const r of i) {
+    let o = 0, a;
+    const c = [];
+    let f = !0;
+    for (const d of n) {
+      const u = d?.[r];
+      u !== void 0 ? (o++, a === void 0 && (a = u), Ne(u) ? c.push(u.shape) : (f = !1, c.push(void 0))) : (f = !1, c.push(void 0));
+    }
+    if (f && o > 0) {
+      const d = Vt(c, t), u = new _(l.OBJECT, d);
+      s[r] = o < t ? wt(u) : u;
+    } else
+      s[r] = o < t ? wt(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 data configuration (shared by LiveArray and LiveValue).
+   */
+  _liveConfig = void 0;
+  constructor(t, e, i, s, r, o) {
+    this.mask = t, this.shape = e, this.values = i, this.typenameField = s, this.typenameValue = r, this.idField = o;
+  }
+  static merge(t) {
+    if (t.length === 1) return t[0];
+    const e = t.length, i = t.map((c) => c.shape);
+    t[0].typenameValue;
+    const s = Vt(i, 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 _(
+      l.ENTITY | l.OBJECT,
+      s,
+      void 0,
+      o,
+      a,
+      r
+    );
+  }
+  static cloneWith(t, e) {
+    const i = new _(
+      e | 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 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 i = e.toLowerCase(), s = this.lowercaseMap.get(i);
+        if (s !== void 0)
+          throw new Error(
+            `Case-insensitive enum cannot have multiple values with the same lowercase form: '${s}' and '${e}' both become '${i}'`
+          );
+        this.lowercaseMap.set(i, 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 Me = 1128875347;
+Ee(H, (n) => {
+  let t = Me;
+  for (const e of n)
+    t += D(e);
+  return t >>> 0;
+});
+function lt(n, t) {
+  return new _(n, t);
+}
+function ke(n) {
+  return lt(l.ARRAY, n);
+}
+function Fe(n) {
+  return lt(l.RECORD | l.OBJECT, n);
+}
+function Te(n) {
+  return lt(l.PARSE_RESULT, n);
+}
+function Kt(n, t) {
+  let e = n, i, s, r;
+  for (const [o, a] of Ut(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 (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 & l.LIVE && (e |= l.LIVE);
+        break;
+    }
+  return new _(e, t, void 0, s, r, i);
+}
+function Pe(n) {
+  return Kt(l.OBJECT, n);
+}
+function Et(n, t, e) {
+  const i = n.mask;
+  if ((i & l.UNION) !== 0) {
+    const s = n;
+    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 [...nt(r), Q, B]) {
+        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 ((i & l.ARRAY) !== 0) {
+    if (t[Q] !== void 0)
+      throw new Error("Array shape already defined");
+    t[Q] = n.shape;
+  } else if ((i & l.RECORD) !== 0) {
+    if (t[B] !== void 0)
+      throw new Error("Record shape already defined");
+    t[B] = n.shape;
+  } else {
+    const s = n.typenameField, r = n.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] = n;
+  }
+  return e;
+}
+function dt(...n) {
+  const t = n;
+  let e = 0, i = 0, s, r, o, a, c = 0;
+  for (const d of t) {
+    if (typeof d == "number") {
+      e |= d;
+      continue;
+    }
+    if (d instanceof Set) {
+      if (r === void 0)
+        r = new Set(d);
+      else
+        for (const u of d)
+          r.add(u);
+      continue;
+    }
+    if (i++, c |= d.mask, i === 1) {
+      s = d;
+      continue;
+    }
+    i === 2 && (o = /* @__PURE__ */ Object.create(null), a = Et(s, o, a)), a = Et(d, o, a);
+  }
+  if (i === 0)
+    return r === void 0 ? e : e === 0 ? r : new _(e | l.UNION, void 0, r);
+  if (i === 1)
+    return _.cloneWith(s, e);
+  const f = e | c | l.UNION;
+  return new _(f, o, r, a);
+}
+function ht(n, t, e) {
+  const i = n;
+  if (typeof i == "number")
+    return i | t;
+  if (i instanceof Set)
+    return dt(n, t);
+  let s = e.get(i);
+  return s === void 0 && (s = _.cloneWith(i, t), e.set(i, s)), s;
+}
+const Le = /* @__PURE__ */ new WeakMap(), je = /* @__PURE__ */ new WeakMap(), qe = /* @__PURE__ */ new WeakMap();
+function Ue(n) {
+  return ht(n, l.UNDEFINED | l.NULL, qe);
+}
+function Ve(n) {
+  return ht(n, l.UNDEFINED, Le);
+}
+function Ke(n) {
+  return ht(n, l.NULL, je);
+}
+function $e(n) {
+  return n;
+}
+function Qe(n) {
+  return /* @__PURE__ */ new Set([n]);
+}
+const $t = ((...n) => new Set(n));
+$t.caseInsensitive = (...n) => new H(n);
+const Qt = 16;
+let Be = 0;
+const it = [], Bt = [], Yt = /* @__PURE__ */ new Map(), J = /* @__PURE__ */ new WeakSet();
+class q {
+  _raw;
+  _formatted;
+  _parsed;
+  _formatId;
+  constructor(t, e, i) {
+    this._raw = t, this._formatId = e, i ? (this._formatted = it[e](t), this._parsed = !0) : this._parsed = !1, J.add(this);
+  }
+  getValue() {
+    return this._parsed || (this._formatted = it[this._formatId](this._raw), this._parsed = !0), this._formatted;
+  }
+  toJSON() {
+    return this._parsed ? Bt[this._formatId](this._formatted) : this._raw;
+  }
+}
+function Ye(n) {
+  const t = Yt.get(n);
+  if (t === void 0)
+    throw new Error(`Format ${n} not registered`);
+  return t;
+}
+function Gt(n, t, e, i, s) {
+  const r = Be++;
+  it[r] = e, Bt[r] = i;
+  const o = s?.eager ?? !0, c = r << Qt | t | l.HAS_FORMAT | (o ? l.IS_EAGER_FORMAT : 0);
+  Yt.set(n, c);
+}
+Gt(
+  "date",
+  l.STRING,
+  (n) => {
+    const t = n.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+    if (!t)
+      throw new Error(`Invalid date string: ${n}. Expected YYYY-MM-DD format.`);
+    const [, e, i, s] = t, r = new Date(Date.UTC(parseInt(e, 10), parseInt(i, 10) - 1, parseInt(s, 10)));
+    if (isNaN(r.getTime()))
+      throw new Error(`Invalid date string: ${n}`);
+    return r;
+  },
+  (n) => {
+    const t = n.getUTCFullYear(), e = String(n.getUTCMonth() + 1).padStart(2, "0"), i = String(n.getUTCDate()).padStart(2, "0");
+    return `${t}-${e}-${i}`;
+  }
+);
+Gt(
+  "date-time",
+  l.STRING,
+  (n) => {
+    const t = new Date(n);
+    if (isNaN(t.getTime()))
+      throw new Error(`Invalid date-time string: ${n}`);
+    return t;
+  },
+  (n) => n.toISOString()
+);
+const Ct = /* @__PURE__ */ new WeakMap();
+function T(n) {
+  let t = Ct.get(n);
+  if (t === void 0) {
+    const e = new n(), i = e[ft] ?? e;
+    e[G] && e[G]();
+    const s = {};
+    for (const [f, d] of Ut(i))
+      s[f] = d;
+    const r = Object.getPrototypeOf(n.prototype);
+    if (r != null) {
+      const f = r.constructor;
+      if (f !== qt && typeof f == "function") {
+        const u = T(f).shape;
+        for (const y of nt(u))
+          if (y in s && s[y] !== u[y])
+            throw new Error(`Cannot extend: field '${y}' already exists in type definition`);
+      }
+    }
+    const o = {}, a = n.prototype;
+    for (const f of Object.getOwnPropertyNames(a))
+      f !== "constructor" && typeof a[f] == "function" && (o[f] = a[f]);
+    t = Kt(l.ENTITY | l.OBJECT, s), t._entityClass = n, nt(o).length > 0 && (t._methods = o), typeof o.__subscribe == "function" && (t._entityConfig = { hasSubscribe: !0 });
+    const c = n;
+    c.cache && (t._entityCache = c.cache), Ct.set(n, t);
+  }
+  return t;
+}
+function Ge(n) {
+  return T(n);
+}
+function Wt(n, t) {
+  if (t == null) return;
+  const e = /* @__PURE__ */ new Map();
+  if (Array.isArray(t))
+    for (const i of t) {
+      const [s, r] = i, a = T(s).typenameValue;
+      if (a === void 0) continue;
+      const c = [];
+      for (const [f, d] of Object.entries(r))
+        c.push([f, d]);
+      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 n) {
+      const a = o.typenameValue;
+      a !== void 0 && e.set(a, r);
+    }
+  }
+  return e.size > 0 ? e : void 0;
+}
+function zt(n) {
+  return Array.isArray(n) ? n.map((t) => T(t)) : [T(n)];
+}
+function We(n, t) {
+  const e = zt(n), i = e.length === 1 ? e[0] : dt(...e.map((o) => o)), s = l.ARRAY | l.LIVE, r = new _(s, i);
+  return r._liveConfig = j.array(
+    e,
+    Wt(e, t?.constraints),
+    t?.sort
+  ), r;
+}
+function ze(n, t, e) {
+  const i = zt(t), s = n, r = l.LIVE, o = new _(r, void 0);
+  return o._liveConfig = j.value(
+    i,
+    Wt(i, e?.constraints),
+    s,
+    e.onCreate,
+    e.onUpdate,
+    e.onDelete
+  ), o;
+}
+const He = {
+  format: Ye,
+  typename: $e,
+  const: Qe,
+  enum: $t,
+  id: l.ID | l.STRING | l.NUMBER,
+  string: l.STRING,
+  number: l.NUMBER,
+  boolean: l.BOOLEAN,
+  null: l.NULL,
+  undefined: l.UNDEFINED,
+  array: ke,
+  object: Pe,
+  record: Fe,
+  union: dt,
+  nullish: Ue,
+  optional: Ve,
+  nullable: Ke,
+  result: Te,
+  entity: Ge,
+  liveArray: We,
+  liveValue: ze
+};
+function P(n, t, e) {
+  return new TypeError(`Validation error at ${n}`);
+}
+const Ht = Array.isArray;
+function bt(n) {
+  if (n === null) return l.NULL;
+  switch (typeof n) {
+    case "number":
+      return l.NUMBER;
+    case "string":
+      return l.STRING;
+    case "boolean":
+      return l.BOOLEAN;
+    case "undefined":
+      return l.UNDEFINED;
+    case "object":
+      return Ht(n) ? l.ARRAY : l.OBJECT;
+    default:
+      throw new Error(`Invalid type: ${typeof n}`);
+  }
+}
+function Dn(n) {
+  return F(n);
+}
+function F(n) {
+  if (n === null || typeof n != "object")
+    return n;
+  if (Ht(n))
+    return n.map((e) => F(e));
+  if (n instanceof Date)
+    return new Date(n.getTime());
+  if (n instanceof Map) {
+    const e = /* @__PURE__ */ new Map();
+    for (const [i, s] of n)
+      e.set(F(i), F(s));
+    return e;
+  }
+  if (n instanceof Set) {
+    const e = /* @__PURE__ */ new Set();
+    for (const i of n)
+      e.add(F(i));
+    return e;
+  }
+  const t = {};
+  for (const e of Object.keys(n))
+    t[e] = F(n[e]);
+  return t;
+}
+const yt = Object.entries, Je = () => {
+};
+class st {
+  queryClient = void 0;
+  preloadedEntities = void 0;
+  warn = Je;
+  /** 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, i, s = !1) {
+    this.queryClient = t, this.preloadedEntities = e, this.warn = i, 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 Jt(n, t, e) {
+  return M(n, t, e, "");
+}
+function Xe(n, t, e) {
+  return pt(n, t, e);
+}
+function xt(n, t, e, i) {
+  const s = n >> Qt;
+  if ((n & l.IS_EAGER_FORMAT) !== 0)
+    try {
+      return new q(t, s, !0);
+    } catch (o) {
+      if ((n & l.UNDEFINED) !== 0) {
+        e.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, s, !1);
+}
+function M(n, t, e, i) {
+  const s = t;
+  if (s instanceof H) {
+    const c = s.get(n);
+    if (c === void 0) throw P(i);
+    return c;
+  }
+  if (s instanceof Set) {
+    if (!s.has(n)) throw P(i);
+    return n;
+  }
+  if (typeof s == "string") {
+    if (n == null) return s;
+    if (n !== s) throw P(i);
+    return n;
+  }
+  if (typeof s == "number") {
+    const c = bt(n);
+    if ((s & c) === 0) {
+      if ((s & l.UNDEFINED) !== 0) {
+        e.warn("Invalid value for optional type, defaulting to undefined", { value: n, path: i });
+        return;
+      }
+      throw P(i);
+    }
+    return (s & l.HAS_FORMAT) !== 0 && n !== null && n !== void 0 ? xt(s, n, e, i) : n;
+  }
+  const r = s.mask, o = s._liveConfig;
+  if (o !== void 0 && o.type === ct.Value)
+    return o.valueType !== void 0 ? M(n, o.valueType, e, i) : n;
+  if ((r & l.PARSE_RESULT) !== 0)
+    try {
+      return { success: !0, value: M(n, s.shape, e, i) };
+    } catch (c) {
+      return { success: !1, error: c instanceof Error ? c : new Error(String(c)) };
+    }
+  const a = bt(n);
+  if ((r & a) === 0 && !s.values?.has(n)) {
+    if ((r & l.UNDEFINED) !== 0) {
+      e.warn("Invalid value for optional type, defaulting to undefined", { value: n, path: i });
+      return;
+    }
+    throw P(i);
+  }
+  return a < l.OBJECT ? (r & l.HAS_FORMAT) !== 0 && n !== null && n !== void 0 ? xt(r, n, e, i) : n : (r & l.UNION) !== 0 ? Ze(a, n, s, e, i) : a === l.ARRAY ? Xt(n, s.shape, e, i) : (r & l.RECORD) !== 0 ? Zt(n, s.shape, e, i) : (r & l.ENTITY) !== 0 && e.queryClient !== void 0 ? pt(n, s, e) : te(n, s, e, i);
+}
+function Ze(n, t, e, i, s) {
+  if (n === l.ARRAY) {
+    const r = e.shape[Q];
+    return r === void 0 || typeof r == "number" ? t : Xt(t, r, i, s);
+  } else {
+    const r = e.typenameField, o = r ? t[r] : void 0;
+    if (o === void 0 || typeof o != "string") {
+      const c = e.shape[B];
+      if (c === void 0)
+        throw new Error(
+          `Typename field '${r}' is required for union discrimination but was not found in the data`
+        );
+      return Zt(t, c, i, s);
+    }
+    const a = e.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 ? pt(t, a, i) : te(t, a, i, s);
+  }
+}
+function Xt(n, t, e, i) {
+  const s = [];
+  for (let r = 0; r < n.length; r++)
+    try {
+      s.push(M(n[r], t, e, `${i}[${r}]`));
+    } catch (o) {
+      e.warn("Failed to parse array item, filtering out", {
+        index: r,
+        value: n[r],
+        error: o instanceof Error ? o.message : String(o)
+      });
+    }
+  return s;
+}
+function Zt(n, t, e, i) {
+  for (const [s, r] of yt(n))
+    n[s] = M(r, t, e, `${i}["${s}"]`);
+  return n;
+}
+function te(n, t, e, i) {
+  if (x.has(n))
+    return n;
+  const s = t.shape;
+  for (const [r, o] of yt(s))
+    n[r] = M(n[r], o, e, `${i}.${r}`);
+  return n;
+}
+function pt(n, t, e) {
+  const i = e.queryClient, s = e.preloadedEntities;
+  let r, o;
+  if (s !== void 0)
+    r = n.__entityRef, o = r;
+  else {
+    const p = n[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 = D([t.typenameValue, o]);
+  }
+  const a = e.seenByKey.get(r);
+  if (a !== void 0)
+    return a.data;
+  if (s !== void 0) {
+    const g = i.entityMap.getEntity(r)?.data ?? s.get(r);
+    if (g === void 0)
+      throw new Error(`Cached entity ${r} not found in preloaded map`);
+    n = g;
+  }
+  const c = {};
+  typeof t.idField == "symbol" && (c[t.idField] = o);
+  const f = i.entityMap.getEntity(r), d = e.isPartialEvent && f !== void 0, u = {
+    key: r,
+    shape: t,
+    data: c,
+    rawKeys: d ? new Set(Object.keys(n)) : void 0
+  };
+  e.seen.set(c, u), e.seenByKey.set(r, u);
+  const y = `[[${t.typenameValue}:${o}]]`, v = t.shape;
+  for (const [p, g] of yt(v))
+    d && !(p in n) || (c[p] = M(n[p], g, e, `${y}.${p}`));
+  return c;
+}
+function tn(n, t) {
+  return en(n, t.shape, t.typenameField);
+}
+function en(n, t, e) {
+  if (t === void 0) return !0;
+  for (const i of Object.keys(t)) {
+    if (i === e) continue;
+    const s = t[i];
+    if (s instanceof _) {
+      if ((s.mask & l.UNDEFINED) !== 0) continue;
+      if (!(i in n) || n[i] === void 0) return !1;
+    } else if (typeof s == "number") {
+      if ((s & l.UNDEFINED) !== 0) continue;
+      if (!(i in n) || n[i] === void 0) return !1;
+    } else if (!(i in n) || n[i] === void 0) return !1;
+  }
+  return !0;
+}
+const nn = Object.prototype, $ = /* @__PURE__ */ new WeakMap();
+function A(n) {
+  if (typeof n != "object" || n === null) return n;
+  if (J.has(n)) return A(n.getValue());
+  if (x.has(n)) return n;
+  if (Array.isArray(n)) {
+    let t = $.get(n);
+    return t === void 0 && (t = new Proxy(n, sn), $.set(n, t)), t;
+  }
+  if (Object.getPrototypeOf(n) === nn) {
+    let t = $.get(n);
+    return t === void 0 && (t = new Proxy(n, rn), $.set(n, t)), t;
+  }
+  return n;
+}
+const sn = {
+  get(n, t, e) {
+    if (typeof t == "string") {
+      const i = Number(t);
+      if (Number.isInteger(i) && i >= 0 && i < n.length)
+        return A(n[i]);
+    }
+    return Reflect.get(n, t, e);
+  },
+  set() {
+    return !1;
+  },
+  deleteProperty() {
+    return !1;
+  }
+}, rn = {
+  get(n, t, e) {
+    return typeof t == "string" ? A(n[t]) : Reflect.get(n, t, e);
+  },
+  set() {
+    return !1;
+  },
+  deleteProperty() {
+    return !1;
+  },
+  has(n, t) {
+    return t in n;
+  },
+  ownKeys(n) {
+    return Reflect.ownKeys(n);
+  },
+  getOwnPropertyDescriptor(n, t) {
+    return Object.getOwnPropertyDescriptor(n, t);
+  }
+};
+class on {
+  _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, i, s, r, o) {
+    this._notifier = at(), this._queryClient = o, this.key = t, this.typename = e, this.id = i, 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, z.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 e = this.entityRefs;
+    if (this.entityRefs = void 0, e)
+      for (const i of e.keys()) i.release();
+  }
+  setChildRefs(t, e) {
+    const i = this.entityRefs;
+    if (t !== void 0 && t.size > 0)
+      for (const s of t.keys())
+        (i === void 0 || !i.has(s)) && s.retain();
+    if (i !== void 0 && i.size > 0)
+      for (const s of i.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 i = this._proxies.get(e);
+    return i === void 0 && (i = cn(this, this.key, t, this._notifier, this._queryClient), this._proxies.set(e, i)), i;
+  }
+  get proxy() {
+    return this._proxies.values().next().value;
+  }
+  satisfiesDef(t) {
+    return this.satisfiedDefs.has(t) ? !0 : tn(this.data, t) ? (this.satisfiedDefs.add(t), !0) : !1;
+  }
+  save() {
+    this._queryClient.entityMap.save(this);
+  }
+  notify() {
+    this._notifier.notify();
+  }
+  consume() {
+    this._notifier.consume();
+  }
+}
+function an(n, t, e) {
+  const i = [];
+  for (const s of n) {
+    if (typeof s != "object" || s === null) continue;
+    const r = x.get(s);
+    if (r === void 0) continue;
+    const o = e.entityMap.getEntity(r);
+    o !== void 0 && o.satisfiesDef(t) && i.push(s);
+  }
+  return i;
+}
+function cn(n, t, e, i, s) {
+  const r = e.shape ?? {}, o = e, a = o._methods, c = o._entityClass, f = o._entityConfig, d = c ? c.prototype : qt.prototype;
+  e.typenameField;
+  const u = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map(), v = () => ({ __entityRef: t });
+  let p;
+  f?.hasSubscribe && a && "__subscribe" in a && (p = It((E) => {
+    const h = (C) => {
+      C.__eventSource = t, s.applyMutationEvent(C);
+    }, m = a.__subscribe.call(g, h);
+    return E.value = g, m;
+  }));
+  let g;
+  const w = Object.keys(r);
+  if (w.includes("__typename") || w.push("__typename"), a)
+    for (const E of Object.keys(a))
+      w.includes(E) || w.push(E);
+  let I, O = w;
+  function K() {
+    const E = n._extraMethods;
+    if (E !== I) {
+      if (I = E, O = w.slice(), E !== void 0)
+        for (const m of Object.keys(E))
+          O.includes(m) || O.push(m);
+      const h = n._extraGetters;
+      if (h !== void 0)
+        for (const m of Object.keys(h))
+          O.includes(m) || O.push(m);
+    }
+    return O;
+  }
+  const R = {
+    getPrototypeOf() {
+      return d;
+    },
+    get(E, h) {
+      if (typeof h == "symbol") return;
+      if (h === "toJSON") return v;
+      if (h === "__context") return s.getContext();
+      if (h === "__typename") return n.typename;
+      if (p?.value, i.consume(), typeof h == "string") {
+        const C = n._extraGetters;
+        if (C !== void 0 && h in C)
+          return C[h]();
+        const S = n._extraMethods;
+        if (S !== void 0 && h in S) {
+          let b = u.get(h);
+          return b || (b = S[h].bind(g), u.set(h, b)), b;
+        }
+        if (a && h in a) {
+          let b = u.get(h);
+          return b || (b = pe(g, a[h].bind(g)), u.set(h, b)), b;
+        }
+      }
+      const m = n.data[h];
+      if (typeof m == "object" && m !== null && J.has(m))
+        return A(m.getValue());
+      if (Array.isArray(m) && typeof h == "string") {
+        const C = r[h];
+        if (C instanceof _ && (C.mask & l.ARRAY) !== 0) {
+          const S = C.shape;
+          if (S instanceof _ && (S.mask & l.ENTITY) !== 0) {
+            const b = S.typenameValue;
+            if (b !== void 0) {
+              const _t = s.getEntityDefsForTypename(b);
+              if (_t !== void 0 && _t.length > 1) {
+                const X = y.get(h);
+                if (X !== void 0 && X.source === m)
+                  return A(X.filtered);
+                const mt = an(m, S, s);
+                return y.set(h, { source: m, filtered: mt }), A(mt);
+              }
+            }
+          }
+        }
+        return A(m);
+      }
+      return A(m);
+    },
+    set() {
+      return !1;
+    },
+    has(E, h) {
+      if (h === "__typename") return !0;
+      if (typeof h == "string") {
+        const m = n._extraGetters;
+        if (m && h in m) return !0;
+        const C = n._extraMethods;
+        if (C && h in C || a && h in a) return !0;
+      }
+      return h in r;
+    },
+    ownKeys() {
+      return K();
+    },
+    getOwnPropertyDescriptor(E, h) {
+      if (h === "__typename")
+        return { enumerable: !0, configurable: !0, value: n.typename, writable: !1 };
+      if (h in r)
+        return { enumerable: !0, configurable: !0, value: R.get(E, h, g), writable: !1 };
+      if (typeof h == "string") {
+        const m = n._extraGetters;
+        if (m && h in m)
+          return { enumerable: !0, configurable: !0, value: R.get(E, h, g), writable: !1 };
+        const C = n._extraMethods;
+        if (C && h in C)
+          return { enumerable: !0, configurable: !0, value: R.get(E, h, g), writable: !1 };
+        if (a && h in a)
+          return { enumerable: !1, configurable: !0, value: R.get(E, h, g), writable: !1 };
+      }
+    }
+  };
+  return g = new Proxy({}, R), x.set(g, t), ye(g, s), g;
+}
+class fn {
+  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, i, s) {
+    let r = this.instances.get(t);
+    if (r === void 0) {
+      const o = i.idField;
+      if (o === void 0)
+        throw new Error(`Entity id field is required ${i.typenameValue}`);
+      const a = e[o];
+      if (typeof a != "string" && typeof a != "number")
+        throw new Error(`Entity id must be string or number: ${i.typenameValue}`);
+      const c = i;
+      r = new on(t, i.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 i of t.entityRefs.keys()) e.add(i.key);
+    }
+    this.persistEntity(t.key, t.data, e);
+  }
+}
+class ee {
+  onlineSignal;
+  manualOverride = void 0;
+  eventListenersAttached = !1;
+  constructor(t) {
+    const e = t ?? this.detectOnlineStatus();
+    this.onlineSignal = Nt(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 = Nt(!0);
+  get isOnline() {
+    return !0;
+  }
+  setNetworkStatus(t) {
+  }
+  clearManualOverride() {
+  }
+  getOnlineSignal() {
+    return ne.onlineSignal;
+  }
+  destroy() {
+  }
+}
+const un = new ee(), In = Mt(un);
+function gt(n, t = typeof window > "u") {
+  let e;
+  n === !1 ? e = 0 : n === void 0 || n === !0 ? e = t ? 0 : 3 : typeof n == "number" ? e = n : e = n.retries;
+  const i = typeof n == "object" && n.retryDelay ? n.retryDelay : (s) => 1e3 * Math.pow(2, s);
+  return { retries: e, retryDelay: i };
+}
+class Nn {
+  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 jt(this);
+  }
+}
+const Ot = /* @__PURE__ */ new WeakMap();
+class V {
+  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, i = e.getConfig ? e.getConfig.call(t) : t.config, s = gt(i?.retry);
+    return { config: i, retryConfig: s };
+  }
+  static for(t) {
+    let e = Ot.get(t);
+    if (e !== void 0)
+      return e;
+    const i = new t(), s = De(i), r = String(s.methods.getIdentityKey.call(s.fields)), o = s.fields.result, a = o instanceof _ ? o : He.object(o), c = (a.mask & l.ENTITY) !== 0, f = t.cache, d = s.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 y = typeof u.prototype.sendNext == "function", v = c ? a : new _(
+      l.ENTITY | l.OBJECT,
+      a.shape,
+      void 0,
+      void 0,
+      r,
+      // typenameValue — unique per query class
+      Ft
+      // idField — symbol, injected onto payload before parse
+    );
+    return e = new V(
+      { id: r, shape: v, cache: f, rawFetchNext: d, hasSendNext: y, isEntityResult: c, controllerClass: u },
+      s
+    ), Ot.set(t, e), e;
+  }
+}
+const Mn = (n, t) => {
+  const e = V.for(n);
+  return vt(e, t);
+};
+function kn(n, ...t) {
+  const e = V.for(n), i = ge(bn);
+  if (i === void 0)
+    throw new Error("QueryClient not found");
+  const s = t[0];
+  return i.getQuery(e, s);
+}
+function ie(n, t) {
+  return new Promise((e, i) => {
+    if (t?.aborted) {
+      i(t.reason);
+      return;
+    }
+    const s = setTimeout(e, n);
+    t?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(s), i(t.reason);
+      },
+      { once: !0 }
+    );
+  });
+}
+async function rt(n, t, e) {
+  const i = Math.max(0, t.retries);
+  let s;
+  for (let r = 0; r <= i; r++) {
+    e?.throwIfAborted();
+    try {
+      return await n();
+    } catch (o) {
+      if (s = o, r >= i) throw o;
+      await ie(t.retryDelay(r), e);
+    }
+  }
+  throw s;
+}
+class ln {
+  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);
+  /** 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() {
+    return this._relayState;
+  }
+  constructor(t, e, i, s) {
+    this.def = t, this.queryClient = e, this.queryKey = i, this.params = s, this._extraMethods = { __refetch: this.refetch }, t.statics.hasSendNext && (this._extraMethods.__fetchNext = this.fetchNext);
+    const r = Dt(s);
+    this._queryId = r !== void 0 ? D(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._fetchNextAbort?.abort(), this._fetchNextAbort = void 0, this._fetchNextPromise = void 0, this.unsubscribe?.(), this.unsubscribe = void 0;
+          const f = this.config?.gcTime ?? kt;
+          this.queryClient.gcManager.schedule(this.queryKey, f, z.Query);
+        }, c = (f = !1) => {
+          const { wasPaused: d, isPaused: u, initialized: y } = this;
+          if (this.wasPaused = u, u && !d && y) {
+            a();
+            return;
+          }
+          const v = Dt(this.params), p = vt(this.def, v), g = p !== this.storageKey;
+          g && (this.currentParams = v, 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()) : 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, i = !1, s) {
+    const r = this.def;
+    return this.rootEntity = this.queryClient.parseAndApplyRootEntity(
+      t,
+      this._queryId,
+      r.statics.shape,
+      e,
+      i,
+      s
+    ), this.rootEntity._extraMethods === void 0 && (this.rootEntity._extraMethods = this._extraMethods, this.rootEntity._extraGetters = {
+      __hasNext: () => this.hasNext,
+      __isFetchingNext: () => this._fetchNextPromise !== 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 i;
+    try {
+      i = await t.loadCachedQuery(this.def, this.storageKey), i !== void 0 && (this.updatedAt = i.updatedAt, e.value = this.applyData(i.value, !1, !1, i.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 (i !== void 0 && this.setupSubscription(), i === void 0 || this.isStale) {
+          if (await ie(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, (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 e = this.getOrCreateExecutionContext(), i = this.queryClient.getController(t.statics.controllerClass), s = this._abortController?.signal ?? new AbortController().signal;
+    return rt(
+      async () => {
+        const r = await i.send(e, s);
+        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._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 e = this._fetchNextAbort.signal, i = this.getOrCreateExecutionContext();
+    i.resultData = this.rootEntity.data;
+    const s = this.queryClient.getController(t.statics.controllerClass);
+    return rt(
+      async () => {
+        const r = await s.sendNext(i, e);
+        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 ?? L.Online;
+    if (t === L.Always)
+      return !1;
+    const e = this.queryClient.networkManager.getOnlineSignal().value;
+    switch (t) {
+      case L.Online:
+        return !e;
+      case L.OfflineFirst:
+        return !e && this.updatedAt === void 0;
+      default:
+        return !1;
+    }
+  }
+}
+class dn {
+  def;
+  queryClient;
+  _inFlight = !1;
+  task;
+  constructor(t, e) {
+    this.def = t, this.queryClient = e, this.task = this.createTask();
+  }
+  createTask() {
+    return ve(
+      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), i = this.validateResponse(e);
+          return this.processEffects(t, i), i;
+        } finally {
+          this._inFlight = !1;
+        }
+      },
+      { desc: `Mutation(${this.def.id})` }
+    );
+  }
+  validateResponse(t) {
+    const e = this.def.responseShape;
+    if (!(e instanceof _))
+      return t;
+    const i = this.queryClient.getContext().log?.warn ?? (() => {
+    }), s = new st();
+    return s.reset(void 0, void 0, i), Jt(t, e, s);
+  }
+  // ======================================================
+  // Effects processing
+  // ======================================================
+  processEffects(t, e) {
+    let i;
+    if (this.def.hasGetEffects) {
+      const r = et(
+        this.def.captured,
+        t ?? {},
+        this.queryClient.getContext()
+      );
+      r.result = e, i = r.getEffects();
+    } else if (this.def.effects !== void 0) {
+      const r = { params: t, result: e };
+      i = W(this.def.effects, r);
+    }
+    if (i === void 0) return;
+    const s = this.queryClient;
+    Z(i.creates, "create", s), Z(i.updates, "update", s), Z(i.deletes, "delete", s), i.invalidates && s.invalidateQueries(i.invalidates);
+  }
+  // ======================================================
+  // Retry logic
+  // ======================================================
+  executeWithRetry(t) {
+    const e = gt(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 rt(async () => {
+      const s = new AbortController(), r = et(
+        this.def.captured,
+        t ?? {},
+        this.queryClient.getContext()
+      );
+      return await i.sendMutation(r, s.signal);
+    }, e);
+  }
+}
+function hn(n) {
+  return typeof n == "string" ? n : T(n).typenameValue;
+}
+function Z(n, t, e) {
+  if (n)
+    for (const [i, s] of n) {
+      const r = hn(i);
+      r !== void 0 && e.applyMutationEvent({ type: t, typename: r, data: s });
+    }
+}
+const se = "__eventSource";
+function re(n) {
+  return { field: n, segments: n.indexOf(".") !== -1 ? n.split(".") : void 0 };
+}
+function yn(n) {
+  return n.map(re);
+}
+function pn(n, t) {
+  if (t.segments === void 0) return n[t.field];
+  let e = n;
+  for (const i of t.segments) {
+    if (e == null) return;
+    e = e[i];
+  }
+  return e;
+}
+function oe(n, t) {
+  const e = [];
+  for (let i = 0; i < t.length; i++) {
+    const s = t[i], r = pn(n, s);
+    if (r === void 0) return;
+    e.push(s.field, r);
+  }
+  return D(e);
+}
+function gn(n, t) {
+  if (n === void 0) return;
+  const e = /* @__PURE__ */ new Map();
+  for (const [i, s] of n) {
+    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 d;
+      if (Pt(f)) {
+        const u = Lt(f);
+        d = ut(u, t);
+      } else
+        d = f;
+      if (d === void 0) {
+        a = !1;
+        break;
+      }
+      o.push(c, d);
+    }
+    a && e.set(i, D(o));
+  }
+  return e.size > 0 ? e : void 0;
+}
+function Rt(n, t) {
+  const e = n.get(t);
+  if (e !== void 0)
+    return e.map(([i]) => i).sort();
+}
+class vn {
+  fields;
+  fieldPaths;
+  _bindings = /* @__PURE__ */ new Map();
+  constructor(t) {
+    this.fields = t, this.fieldPaths = t.map(re);
+  }
+  register(t, e) {
+    let i = this._bindings.get(t);
+    i === void 0 && (i = /* @__PURE__ */ new Set(), this._bindings.set(t, i)), i.add(e);
+  }
+  unregister(t, e) {
+    const i = this._bindings.get(t);
+    i !== void 0 && (i.delete(e), i.size === 0 && this._bindings.delete(t));
+  }
+  getMatching(t) {
+    return this._bindings.get(t);
+  }
+  get isEmpty() {
+    return this._bindings.size === 0;
+  }
+}
+function St(n) {
+  return D(n);
+}
+class _n {
+  _groups = /* @__PURE__ */ new Map();
+  getOrCreateGroup(t) {
+    const e = St(t);
+    let i = this._groups.get(e);
+    return i === void 0 && (i = new vn(t), this._groups.set(e, i)), i;
+  }
+  register(t, e, i) {
+    this.getOrCreateGroup(e).register(t, i);
+  }
+  unregister(t, e, i) {
+    const s = St(e), r = this._groups.get(s);
+    r !== void 0 && (r.unregister(t, i), r.isEmpty && this._groups.delete(s));
+  }
+  registerBinding(t, e) {
+    const i = t._constraintHashes.get(e);
+    if (i === void 0) return;
+    const s = Rt(t._constraintFieldRefs, e);
+    s !== void 0 && this.register(i, s, t);
+  }
+  unregisterBinding(t, e) {
+    const i = t._constraintHashes.get(e);
+    if (i === void 0) return;
+    const s = Rt(t._constraintFieldRefs, e);
+    s !== void 0 && this.unregister(i, s, t);
+  }
+  routeEvent(t, e, i, s, r, o) {
+    for (const a of this._groups.values()) {
+      const c = oe(e, 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, s, r, o);
+    }
+  }
+}
+function At(n) {
+  const t = /* @__PURE__ */ new Set();
+  for (const e of n)
+    if (typeof e == "object" && e !== null) {
+      const i = k(e);
+      i !== void 0 && t.add(i);
+    }
+  return t;
+}
+class ae {
+  _queryClient;
+  _parent;
+  _constraintHashes;
+  _entityDefsByTypename;
+  _constraintFieldRefs;
+  instance;
+  constructor(t, e, i, s, r, o) {
+    this._queryClient = i, 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);
+    J.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, i, s, r) {
+    const o = this._entityDefsByTypename.get(t);
+    if (o === void 0) return;
+    const a = this._queryClient.entityMap.getEntity(e);
+    if (i === "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, i);
+  }
+  destroy() {
+    this._queryClient.unregisterLiveCollection(this);
+    const t = this._parent.liveCollections, e = t.indexOf(this);
+    e !== -1 && t.splice(e, 1);
+  }
+}
+class mn {
+  _notifier;
+  _items;
+  _keys;
+  _outputSignal;
+  _queryClient;
+  _parent;
+  constructor(t, e, i, s, r, o) {
+    this._notifier = at(), this._items = i, this._keys = At(i), this._queryClient = t, this._parent = e;
+    const a = s !== void 0 && r !== void 0, c = o !== void 0;
+    (a || c) && (this._outputSignal = _e(() => {
+      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 y = k(u);
+          if (y === void 0) {
+            d.push(u);
+            continue;
+          }
+          const v = t.entityMap.getEntity(y);
+          if (v === void 0) {
+            d.push(u);
+            continue;
+          }
+          v.consume(), oe(v.data, s) === r && d.push(u);
+        }
+        f = d;
+      }
+      return c && (f = (f === this._items ? f.slice() : f).sort(o)), f;
+    }));
+  }
+  onEvent(t, e, i, 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 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 e = this._findIndex(t);
+    e !== -1 && this._items.splice(e, 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 e = this._items, i = Array.isArray(t) ? t : [];
+    this._items = i, this._keys = At(i);
+    for (const s of i)
+      if (typeof s == "object" && s !== null) {
+        const r = k(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 = k(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 i = k(e);
+        i !== void 0 && this.add(i, e);
+      }
+  }
+  _findIndex(t) {
+    for (let e = 0; e < this._items.length; e++) {
+      const i = this._items[e];
+      if (typeof i == "object" && i !== null && k(i) === t)
+        return e;
+    }
+    return -1;
+  }
+}
+class wn {
+  _notifier;
+  _value;
+  _createdKeys;
+  _deletedKeys;
+  _queryClient;
+  _parent;
+  _onCreate;
+  _onUpdate;
+  _onDelete;
+  constructor(t, e, i, s, r, o) {
+    this._notifier = at(), this._value = i, 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, i, 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 ?? i);
+        break;
+      case "delete":
+        if (this._deletedKeys.has(t)) return;
+        this._deletedKeys.add(t), this._value = this._onDelete(this._value, e ?? 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 ce(n, t, e, i, s) {
+  let r = n.constraintFieldRefs;
+  if (r === void 0) {
+    r = /* @__PURE__ */ new Map();
+    for (const f of n.entityDefs) {
+      const d = f.typenameValue;
+      d !== void 0 && r.set(d, [[se, e.key]]);
+    }
+  }
+  const o = gn(r, i) ?? /* @__PURE__ */ new Map();
+  let a;
+  if (n.type === ct.Array) {
+    let f, d;
+    if (n.constraintFieldRefs !== void 0 && o.size > 0 && o.size === 1)
+      for (const [u] of n.constraintFieldRefs) {
+        const y = o.get(u);
+        if (y !== void 0) {
+          d = y;
+          const v = n.constraintFieldRefs.get(u);
+          v !== void 0 && (f = yn(v.map(([p]) => p)));
+          break;
+        }
+      }
+    a = new mn(
+      s,
+      e,
+      Array.isArray(t) ? t : [],
+      f,
+      d,
+      n.sort
+    );
+  } else
+    a = new wn(
+      s,
+      e,
+      t,
+      n.onCreate,
+      n.onUpdate,
+      n.onDelete
+    );
+  const c = new ae(
+    n.entityDefs,
+    r,
+    s,
+    e,
+    o,
+    a
+  );
+  return e.liveCollections.push(c), s.registerLiveCollection(c), c;
+}
+const fe = Object.entries, ue = Object.prototype;
+function tt(n, t, e, i = !1) {
+  const s = n.queryClient;
+  s.currentParseId++;
+  const r = n.seen, o = /* @__PURE__ */ new Map();
+  return { data: U(t, r, s, e, o, i), entityRefs: o };
+}
+function U(n, t, e, i, s, r) {
+  if (typeof n != "object" || n === null) return n;
+  const o = t.get(n);
+  if (o !== void 0)
+    return En(o, t, e, i, s, r);
+  if (Array.isArray(n)) {
+    for (let a = 0; a < n.length; a++) {
+      const c = n[a];
+      typeof c == "object" && c !== null && !(c instanceof q) && !x.has(c) && (n[a] = U(c, t, e, i, s, r));
+    }
+    return n;
+  }
+  if (Object.getPrototypeOf(n) === ue && !x.has(n)) {
+    const a = n;
+    for (const c of Object.keys(a)) {
+      const f = a[c];
+      typeof f == "object" && f !== null && !(f instanceof q) && !x.has(f) && (a[c] = U(f, t, e, i, s, r));
+    }
+  }
+  return n;
+}
+function le(n) {
+  return typeof n == "object" && n !== null && !(n instanceof q) && !x.has(n);
+}
+function En(n, t, e, i, s, r) {
+  const { key: o, data: a, shape: c, rawKeys: f } = n, d = c.shape, u = e.prepareEntity(o, a, c), y = u.data, v = y !== a, p = v && f !== void 0 && u.entityRefs !== void 0 ? new Map(u.entityRefs) : /* @__PURE__ */ new Map();
+  if (v ? (de(
+    d,
+    a,
+    y,
+    f,
+    u,
+    y,
+    t,
+    e,
+    i,
+    p,
+    r
+  ), u.notify()) : he(d, a, u, a, t, e, i, p, r), r && u.liveCollections.length > 0)
+    for (const w of u.liveCollections) {
+      const I = w.instance.getRawValue();
+      if (Array.isArray(I))
+        for (const O of I) {
+          if (typeof O != "object" || O === null) continue;
+          const K = x.get(O);
+          if (K === void 0) continue;
+          const R = e.entityMap.getEntity(K);
+          R !== void 0 && p.set(R, (p.get(R) ?? 0) + 1);
+        }
+    }
+  u.setChildRefs(p.size > 0 ? p : void 0, i);
+  const g = u.getProxy(c);
+  return s.set(u, (s.get(u) ?? 0) + 1), g;
+}
+function de(n, t, e, i, s, r, o, a, c, f, d) {
+  for (const [u, y] of fe(n))
+    if (!(i !== void 0 && !i.has(u)))
+      if (le(t[u]) && (t[u] = U(t[u], o, a, c, f, d)), y instanceof _ && y._liveConfig !== void 0) {
+        const v = e[u];
+        v instanceof ae ? d ? v.append(t[u]) : v.reset(t[u]) : e[u] = ce(
+          y._liveConfig,
+          t[u],
+          s,
+          r,
+          a
+        );
+      } else {
+        const v = t[u], p = e[u];
+        if (ot(v) && ot(p)) {
+          const g = y instanceof _ && y.shape !== void 0 ? y.shape : void 0;
+          if (g !== void 0)
+            de(
+              g,
+              v,
+              p,
+              void 0,
+              s,
+              r,
+              o,
+              a,
+              c,
+              f,
+              d
+            );
+          else
+            for (const w of Object.keys(v))
+              p[w] = v[w];
+          e[u] = p;
+        } else
+          e[u] = v;
+      }
+}
+function he(n, t, e, i, s, r, o, a, c) {
+  for (const [f, d] of fe(n))
+    if (f in t)
+      if (le(t[f]) && (t[f] = U(t[f], s, r, o, a, c)), d instanceof _ && d._liveConfig !== void 0)
+        t[f] = ce(
+          d._liveConfig,
+          t[f],
+          e,
+          i,
+          r
+        );
+      else {
+        const u = t[f];
+        if (ot(u)) {
+          const y = d instanceof _ && d.shape !== void 0 ? d.shape : void 0;
+          y !== void 0 && he(y, u, e, i, s, r, o, a, c);
+        }
+      }
+}
+function ot(n) {
+  return typeof n == "object" && n !== null && !Array.isArray(n) && Object.getPrototypeOf(n) === ue && !x.has(n);
+}
+function Fn(n) {
+  if (n !== void 0)
+    return typeof n == "string" ? n : typeof n == "function" ? n() : n.value;
+}
+function Cn(n) {
+  return me(n);
+}
+function Dt(n) {
+  if (n === void 0)
+    return;
+  const t = {};
+  for (const [e, i] of Object.entries(n))
+    Cn(i) ? t[e] = i.value : t[e] = i;
+  return t;
+}
+const vt = (n, t) => D([n.statics.id, t]);
+class Tn {
+  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: e = new Ce(new be()),
+      log: i,
+      evictionMultiplier: s,
+      controllers: r,
+      networkManager: o,
+      gcManager: a,
+      ...c
+    } = t;
+    this.isServer = typeof window > "u", this.store = e, this.context = { ...c, log: i ?? console, evictionMultiplier: s }, this.gcManager = t.gcManager ?? (this.isServer ? new Re() : new Oe(this.handleEviction, s)), this.networkManager = t.networkManager ?? new ee(), this.entityMap = new fn((u, y, v) => this.store.saveEntity(u, y, v));
+    for (const u of t.controllers ?? [])
+      this.controllers.set(u.constructor, u), u.register(this);
+    const f = this.networkManager.getOnlineSignal(), d = we(() => f.value);
+    this.networkUnsubscribe = d.addListener(
+      () => {
+        const u = f.value;
+        for (const y of this.controllers.values())
+          y.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 e = this.controllers.get(t);
+    if (!e) {
+      try {
+        e = 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, e), e.register(this);
+    }
+    return e;
+  }
+  getContext() {
+    return this.context;
+  }
+  // ======================================================
+  // Typename Registry (per-client)
+  // ======================================================
+  registerEntityDef(t) {
+    const e = t.typenameValue;
+    if (e === void 0 || t._entityClass === void 0) return;
+    const i = this.typenameRegistry.get(e);
+    if (i !== void 0) {
+      if (i.indexOf(t) !== -1) return;
+      i.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 i = this.typenameRegistry.get(t);
+    if (i !== void 0)
+      return e = _.merge(i), this.mergedDefCache.set(t, e), e;
+  }
+  saveQueryData(t, e, i, 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, i, s, o);
+  }
+  activateQuery(t) {
+    const { def: e, queryKey: i, storageKey: s, config: r } = t;
+    this.store.activateQuery(e, s);
+    const o = r?.gcTime ?? kt;
+    this.gcManager.cancel(i, 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 i = vt(t, e);
+    let s = this.queryInstances.get(i);
+    return s === void 0 && (s = new ln(t, this, i, e), this.queryInstances.set(i, 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 i = this.mutationInstances.get(e);
+    return i === void 0 && (i = new dn(t, this), this.mutationInstances.set(e, 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, e, i) {
+    const s = this.context.log?.warn ?? (() => {
+    }), r = new st();
+    return r.reset(this, i, s), { data: Jt(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, i = !1) {
+    return tt(t.ctx, t.data, e, 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, e, i, s, r = !1, o) {
+    typeof i.idField == "symbol" && typeof t == "object" && t !== null && !("__entityRef" in t) && (t[Ft] = e);
+    const a = this.parseData(t, i, o), c = tt(a.ctx, a.data, s, r), f = x.get(c.data);
+    return this.entityMap.getEntity(f);
+  }
+  prepareEntity(t, e, i) {
+    return this.registerEntityDef(i), this.entityMap.getOrCreateEntity(t, e, i, this);
+  }
+  // ======================================================
+  // Mutation Events
+  // ======================================================
+  applyMutationEvent(t) {
+    const { type: e, typename: i } = t, s = this.getMergedDef(i);
+    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 = D([i, a]), f = t.__eventSource, d = typeof o == "object" && o !== null ? o : {}, u = this.entityMap.getEntity(c);
+    if (e === "delete") {
+      const g = u !== void 0 ? u.data : d;
+      this.routeEvent(i, g, c, e, f, void 0, g);
+      return;
+    }
+    try {
+      const g = this.context.log?.warn ?? (() => {
+      }), w = new st();
+      w.reset(
+        this,
+        void 0,
+        g,
+        /* isPartialEvent */
+        !0
+      );
+      const I = Xe(d, s, w);
+      tt(w, I, !0);
+    } catch (g) {
+      if (this.context.log?.warn?.("Failed to apply mutation event", g), u === void 0) {
+        const w = this.entityMap.getEntity(c);
+        w !== void 0 && w.evict();
+      }
+      return;
+    }
+    const y = this.entityMap.getEntity(c);
+    if (y === void 0) return;
+    this.entityMap.save(y);
+    const v = u === void 0;
+    let p = !1;
+    this.routeEvent(i, y.data, c, e, f, () => {
+      p = !0;
+    }), v && !p && y.evict();
+  }
+  // ======================================================
+  // Query Invalidation
+  // ======================================================
+  invalidateQueries(t) {
+    for (const e of t) {
+      const i = Array.isArray(e), s = i ? e[0] : e, r = i ? e[1] : void 0, a = V.for(s).statics.id;
+      for (const [, c] of this.queryInstances)
+        c.def.statics.id === a && (r === void 0 || xn(c.resolvedParams, r)) && c.markStale();
+    }
+  }
+  // ======================================================
+  // In-Memory GC
+  // ======================================================
+  handleEviction = (t, e) => {
+    if (e === z.Query) {
+      const s = this.queryInstances.get(t);
+      if (s === void 0) return;
+      s.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 e = this.constraintRegistry.get(t);
+    return e === void 0 && (e = new _n(), this.constraintRegistry.set(t, e)), e;
+  }
+  registerLiveCollection(t) {
+    for (const [e, i] of t._entityDefsByTypename)
+      this.registerEntityDef(i), this.getOrCreateMatcher(e).registerBinding(t, e);
+  }
+  unregisterLiveCollection(t) {
+    for (const e of t._entityDefsByTypename.keys()) {
+      const i = this.constraintRegistry.get(e);
+      i !== void 0 && i.unregisterBinding(t, e);
+    }
+  }
+  routeEvent(t, e, i, s, r, o, a) {
+    const c = this.constraintRegistry.get(t);
+    if (c === void 0) return;
+    const f = r !== void 0 ? { ...e, [se]: r } : e;
+    c.routeEvent(t, f, i, s, 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 bn = Mt(void 0);
+function xn(n, t) {
+  if (n === void 0) return !1;
+  for (const e in t)
+    if (n[e] !== t[e]) return !1;
+  return !0;
+}
+export {
+  Q as A,
+  qt as E,
+  Oe as G,
+  j as L,
+  l as M,
+  ee as N,
+  Ft as Q,
+  B as R,
+  _ as V,
+  ct as a,
+  In as b,
+  L as c,
+  Re as d,
+  ne as e,
+  Nn as f,
+  Tn as g,
+  bn as h,
+  un as i,
+  Dn as j,
+  kn as k,
+  jt as l,
+  De as m,
+  W as n,
+  Fn as o,
+  Mn as q,
+  Gt as r,
+  He as t
+};
+//# sourceMappingURL=QueryClient-YqnBxFy1.js.map