@instantdb/resumable-stream 0.0.0

package/dist/standalone/index.js

@@ -0,0 +1,3402 @@
+var En = Object.defineProperty;
+var Pt = (e) => {
+  throw TypeError(e);
+};
+var _n = (e, t, n) => t in e ? En(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var d = (e, t, n) => _n(e, typeof t != "symbol" ? t + "" : t, n), st = (e, t, n) => t.has(e) || Pt("Cannot " + n);
+var b = (e, t, n) => (st(e, t, "read from private field"), n ? n.call(e) : t.get(e)), G = (e, t, n) => t.has(e) ? Pt("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, n), oe = (e, t, n, i) => (st(e, t, "write to private field"), i ? i.call(e, n) : t.set(e, n), n), H = (e, t, n) => (st(e, t, "access private method"), n);
+const Cn = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
+function Te(e) {
+  return typeof e == "string" && Cn.test(e);
+}
+const M = [];
+for (let e = 0; e < 256; ++e)
+  M.push((e + 256).toString(16).slice(1));
+function xn(e, t = 0) {
+  return (M[e[t + 0]] + M[e[t + 1]] + M[e[t + 2]] + M[e[t + 3]] + "-" + M[e[t + 4]] + M[e[t + 5]] + "-" + M[e[t + 6]] + M[e[t + 7]] + "-" + M[e[t + 8]] + M[e[t + 9]] + "-" + M[e[t + 10]] + M[e[t + 11]] + M[e[t + 12]] + M[e[t + 13]] + M[e[t + 14]] + M[e[t + 15]]).toLowerCase();
+}
+let rt;
+const Tn = new Uint8Array(16);
+function Rn() {
+  if (!rt) {
+    if (typeof crypto > "u" || !crypto.getRandomValues)
+      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+    rt = crypto.getRandomValues.bind(crypto);
+  }
+  return rt(Tn);
+}
+const An = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), jt = { randomUUID: An };
+function Pn(e, t, n) {
+  var s;
+  if (jt.randomUUID && !e)
+    return jt.randomUUID();
+  e = e || {};
+  const i = e.random ?? ((s = e.rng) == null ? void 0 : s.call(e)) ?? Rn();
+  if (i.length < 16)
+    throw new Error("Random bytes length must be >= 16");
+  return i[6] = i[6] & 15 | 64, i[8] = i[8] & 63 | 128, xn(i);
+}
+const T = {
+  Remove: "remove",
+  Replace: "replace",
+  Add: "add"
+}, Xt = Symbol.for("__MUTATIVE_PROXY_DRAFT__"), Je = Symbol.iterator, Z = {
+  mutable: "mutable",
+  immutable: "immutable"
+}, _t = {};
+function Ne(e, t) {
+  return e instanceof Map ? e.has(t) : Object.prototype.hasOwnProperty.call(e, t);
+}
+function Mt(e, t) {
+  if (t in e) {
+    let n = Reflect.getPrototypeOf(e);
+    for (; n; ) {
+      const i = Reflect.getOwnPropertyDescriptor(n, t);
+      if (i)
+        return i;
+      n = Reflect.getPrototypeOf(n);
+    }
+  }
+}
+function Yt(e) {
+  return Object.getPrototypeOf(e) === Set.prototype;
+}
+function Zt(e) {
+  return Object.getPrototypeOf(e) === Map.prototype;
+}
+function Q(e) {
+  var t;
+  return (t = e.copy) !== null && t !== void 0 ? t : e.original;
+}
+function lt(e) {
+  return !!k(e);
+}
+function k(e) {
+  return typeof e != "object" ? null : e == null ? void 0 : e[Xt];
+}
+function Ct(e) {
+  var t;
+  const n = k(e);
+  return n ? (t = n.copy) !== null && t !== void 0 ? t : n.original : e;
+}
+function Ie(e, t) {
+  if (!e || typeof e != "object")
+    return !1;
+  let n;
+  return Object.getPrototypeOf(e) === Object.prototype || Array.isArray(e) || e instanceof Map || e instanceof Set || !!(t != null && t.mark) && ((n = t.mark(e, Z)) === Z.immutable || typeof n == "function");
+}
+function en(e, t = []) {
+  if (Object.hasOwnProperty.call(e, "key")) {
+    const n = e.parent.copy, i = k(he(n, e.key));
+    if (i !== null && (i == null ? void 0 : i.original) !== e.original)
+      return null;
+    const s = e.parent.type === 3, r = s ? Array.from(e.parent.setMap.keys()).indexOf(e.key) : e.key;
+    if (!(s && n.size > r || Ne(n, r)))
+      return null;
+    t.push(r);
+  }
+  if (e.parent)
+    return en(e.parent, t);
+  t.reverse();
+  try {
+    jn(e.copy, t);
+  } catch {
+    return null;
+  }
+  return t;
+}
+function ze(e) {
+  return Array.isArray(e) ? 1 : e instanceof Map ? 2 : e instanceof Set ? 3 : 0;
+}
+function he(e, t) {
+  return ze(e) === 2 ? e.get(t) : e[t];
+}
+function xt(e, t, n) {
+  ze(e) === 2 ? e.set(t, n) : e[t] = n;
+}
+function ot(e, t) {
+  const n = k(e);
+  return (n ? Q(n) : e)[t];
+}
+function we(e, t) {
+  return e === t ? e !== 0 || 1 / e === 1 / t : e !== e && t !== t;
+}
+function be(e, t) {
+  return t ? e : [""].concat(e).map((n) => {
+    const i = `${n}`;
+    return i.indexOf("/") === -1 && i.indexOf("~") === -1 ? i : i.replace(/~/g, "~0").replace(/\//g, "~1");
+  }).join("/");
+}
+function jn(e, t) {
+  for (let n = 0; n < t.length - 1; n += 1) {
+    const i = t[n];
+    if (e = he(ze(e) === 3 ? Array.from(e) : e, i), typeof e != "object")
+      throw new Error(`Cannot resolve patch at '${t.join("/")}'.`);
+  }
+  return e;
+}
+function Mn(e) {
+  const t = Object.create(Object.getPrototypeOf(e));
+  return Reflect.ownKeys(e).forEach((n) => {
+    let i = Reflect.getOwnPropertyDescriptor(e, n);
+    if (i.enumerable && i.configurable && i.writable) {
+      t[n] = e[n];
+      return;
+    }
+    i.writable || (i.writable = !0, i.configurable = !0), (i.get || i.set) && (i = {
+      configurable: !0,
+      writable: !0,
+      enumerable: i.enumerable,
+      value: e[n]
+    }), Reflect.defineProperty(t, n, i);
+  }), t;
+}
+const Un = Object.prototype.propertyIsEnumerable;
+function Dn(e, t) {
+  let n;
+  if (Array.isArray(e))
+    return Array.prototype.concat.call(e);
+  if (e instanceof Set) {
+    if (!Yt(e)) {
+      const i = Object.getPrototypeOf(e).constructor;
+      return new i(e.values());
+    }
+    return Set.prototype.difference ? Set.prototype.difference.call(e, /* @__PURE__ */ new Set()) : new Set(e.values());
+  } else if (e instanceof Map) {
+    if (!Zt(e)) {
+      const i = Object.getPrototypeOf(e).constructor;
+      return new i(e);
+    }
+    return new Map(e);
+  } else if (t != null && t.mark && (n = t.mark(e, Z), n !== void 0) && n !== Z.mutable) {
+    if (n === Z.immutable)
+      return Mn(e);
+    if (typeof n == "function") {
+      if (t.enablePatches || t.enableAutoFreeze)
+        throw new Error("You can't use mark and patches or auto freeze together.");
+      return n();
+    }
+    throw new Error(`Unsupported mark result: ${n}`);
+  } else if (typeof e == "object" && Object.getPrototypeOf(e) === Object.prototype) {
+    const i = {};
+    return Object.keys(e).forEach((s) => {
+      i[s] = e[s];
+    }), Object.getOwnPropertySymbols(e).forEach((s) => {
+      Un.call(e, s) && (i[s] = e[s]);
+    }), i;
+  } else
+    throw new Error("Please check mark() to ensure that it is a stable marker draftable function.");
+}
+function W(e) {
+  e.copy || (e.copy = Dn(e.original, e.options));
+}
+function Me(e) {
+  if (!Ie(e))
+    return Ct(e);
+  if (Array.isArray(e))
+    return e.map(Me);
+  if (e instanceof Map) {
+    const n = Array.from(e.entries()).map(([i, s]) => [
+      i,
+      Me(s)
+    ]);
+    if (!Zt(e)) {
+      const i = Object.getPrototypeOf(e).constructor;
+      return new i(n);
+    }
+    return new Map(n);
+  }
+  if (e instanceof Set) {
+    const n = Array.from(e).map(Me);
+    if (!Yt(e)) {
+      const i = Object.getPrototypeOf(e).constructor;
+      return new i(n);
+    }
+    return new Set(n);
+  }
+  const t = Object.create(Object.getPrototypeOf(e));
+  for (const n in e)
+    t[n] = Me(e[n]);
+  return t;
+}
+function Qe(e) {
+  return lt(e) ? Me(e) : e;
+}
+function te(e) {
+  var t;
+  e.assignedMap = (t = e.assignedMap) !== null && t !== void 0 ? t : /* @__PURE__ */ new Map(), e.operated || (e.operated = !0, e.parent && te(e.parent));
+}
+function Nn(e, t) {
+  const n = ze(e);
+  if (n === 0)
+    Reflect.ownKeys(e).forEach((i) => {
+      t(i, e[i], e);
+    });
+  else if (n === 1) {
+    let i = 0;
+    for (const s of e)
+      t(i, s, e), i += 1;
+  } else
+    e.forEach((i, s) => t(s, i, e));
+}
+function tn(e, t, n) {
+  if (lt(e) || !Ie(e, n) || t.has(e) || Object.isFrozen(e))
+    return;
+  const i = e instanceof Set, s = i ? /* @__PURE__ */ new Map() : void 0;
+  if (t.add(e), Nn(e, (r, o) => {
+    var a;
+    if (lt(o)) {
+      const u = k(o);
+      W(u);
+      const c = !((a = u.assignedMap) === null || a === void 0) && a.size || u.operated ? u.copy : u.original;
+      xt(i ? s : e, r, c);
+    } else
+      tn(o, t, n);
+  }), s) {
+    const r = e, o = Array.from(r);
+    r.clear(), o.forEach((a) => {
+      r.add(s.has(a) ? s.get(a) : a);
+    });
+  }
+}
+function Ln(e, t) {
+  const n = e.type === 3 ? e.setMap : e.copy;
+  e.finalities.revoke.length > 1 && e.assignedMap.get(t) && n && tn(he(n, t), e.finalities.handledSet, e.options);
+}
+function dt(e) {
+  e.type === 3 && e.copy && (e.copy.clear(), e.setMap.forEach((t) => {
+    e.copy.add(Ct(t));
+  }));
+}
+function ht(e, t, n, i) {
+  if (e.operated && e.assignedMap && e.assignedMap.size > 0 && !e.finalized) {
+    if (n && i) {
+      const r = en(e);
+      r && t(e, r, n, i);
+    }
+    e.finalized = !0;
+  }
+}
+function Tt(e, t, n, i) {
+  const s = k(n);
+  s && (s.callbacks || (s.callbacks = []), s.callbacks.push((r, o) => {
+    var a;
+    const u = e.type === 3 ? e.setMap : e.copy;
+    if (we(he(u, t), n)) {
+      let c = s.original;
+      s.copy && (c = s.copy), dt(e), ht(e, i, r, o), e.options.enableAutoFreeze && (e.options.updatedValues = (a = e.options.updatedValues) !== null && a !== void 0 ? a : /* @__PURE__ */ new WeakMap(), e.options.updatedValues.set(c, s.original)), xt(u, t, c);
+    }
+  }), e.options.enableAutoFreeze && s.finalities !== e.finalities && (e.options.enableAutoFreeze = !1)), Ie(n, e.options) && e.finalities.draft.push(() => {
+    const r = e.type === 3 ? e.setMap : e.copy;
+    we(he(r, t), n) && Ln(e, t);
+  });
+}
+function Wn(e, t, n, i, s) {
+  let { original: r, assignedMap: o, options: a } = e, u = e.copy;
+  u.length < r.length && ([r, u] = [u, r], [n, i] = [i, n]);
+  for (let c = 0; c < r.length; c += 1)
+    if (o.get(c.toString()) && u[c] !== r[c]) {
+      const l = t.concat([c]), f = be(l, s);
+      n.push({
+        op: T.Replace,
+        path: f,
+        // If it is a draft, it needs to be deep cloned, and it may also be non-draft.
+        value: Qe(u[c])
+      }), i.push({
+        op: T.Replace,
+        path: f,
+        // If it is a draft, it needs to be deep cloned, and it may also be non-draft.
+        value: Qe(r[c])
+      });
+    }
+  for (let c = r.length; c < u.length; c += 1) {
+    const l = t.concat([c]), f = be(l, s);
+    n.push({
+      op: T.Add,
+      path: f,
+      // If it is a draft, it needs to be deep cloned, and it may also be non-draft.
+      value: Qe(u[c])
+    });
+  }
+  if (r.length < u.length) {
+    const { arrayLengthAssignment: c = !0 } = a.enablePatches;
+    if (c) {
+      const l = t.concat(["length"]), f = be(l, s);
+      i.push({
+        op: T.Replace,
+        path: f,
+        value: r.length
+      });
+    } else
+      for (let l = u.length; r.length < l; l -= 1) {
+        const f = t.concat([l - 1]), m = be(f, s);
+        i.push({
+          op: T.Remove,
+          path: m
+        });
+      }
+  }
+}
+function Fn({ original: e, copy: t, assignedMap: n }, i, s, r, o) {
+  n.forEach((a, u) => {
+    const c = he(e, u), l = Qe(he(t, u)), f = a ? Ne(e, u) ? T.Replace : T.Add : T.Remove;
+    if (we(c, l) && f === T.Replace)
+      return;
+    const m = i.concat(u), p = be(m, o);
+    s.push(f === T.Remove ? { op: f, path: p } : { op: f, path: p, value: l }), r.push(f === T.Add ? { op: T.Remove, path: p } : f === T.Remove ? { op: T.Add, path: p, value: c } : { op: T.Replace, path: p, value: c });
+  });
+}
+function zn({ original: e, copy: t }, n, i, s, r) {
+  let o = 0;
+  e.forEach((a) => {
+    if (!t.has(a)) {
+      const u = n.concat([o]), c = be(u, r);
+      i.push({
+        op: T.Remove,
+        path: c,
+        value: a
+      }), s.unshift({
+        op: T.Add,
+        path: c,
+        value: a
+      });
+    }
+    o += 1;
+  }), o = 0, t.forEach((a) => {
+    if (!e.has(a)) {
+      const u = n.concat([o]), c = be(u, r);
+      i.push({
+        op: T.Add,
+        path: c,
+        value: a
+      }), s.unshift({
+        op: T.Remove,
+        path: c,
+        value: a
+      });
+    }
+    o += 1;
+  });
+}
+function Fe(e, t, n, i) {
+  const { pathAsArray: s = !0 } = e.options.enablePatches;
+  switch (e.type) {
+    case 0:
+    case 2:
+      return Fn(e, t, n, i, s);
+    case 1:
+      return Wn(e, t, n, i, s);
+    case 3:
+      return zn(e, t, n, i, s);
+  }
+}
+const qe = (e, t, n = !1) => {
+  if (typeof e == "object" && e !== null && (!Ie(e, t) || n))
+    throw new Error("Strict mode: Mutable data cannot be accessed directly, please use 'unsafe(callback)' wrap.");
+}, pt = {
+  get size() {
+    return Q(k(this)).size;
+  },
+  has(e) {
+    return Q(k(this)).has(e);
+  },
+  set(e, t) {
+    const n = k(this), i = Q(n);
+    return (!i.has(e) || !we(i.get(e), t)) && (W(n), te(n), n.assignedMap.set(e, !0), n.copy.set(e, t), Tt(n, e, t, Fe)), this;
+  },
+  delete(e) {
+    if (!this.has(e))
+      return !1;
+    const t = k(this);
+    return W(t), te(t), t.original.has(e) ? t.assignedMap.set(e, !1) : t.assignedMap.delete(e), t.copy.delete(e), !0;
+  },
+  clear() {
+    const e = k(this);
+    if (this.size) {
+      W(e), te(e), e.assignedMap = /* @__PURE__ */ new Map();
+      for (const [t] of e.original)
+        e.assignedMap.set(t, !1);
+      e.copy.clear();
+    }
+  },
+  forEach(e, t) {
+    const n = k(this);
+    Q(n).forEach((i, s) => {
+      e.call(t, this.get(s), s, this);
+    });
+  },
+  get(e) {
+    var t, n;
+    const i = k(this), s = Q(i).get(e), r = ((n = (t = i.options).mark) === null || n === void 0 ? void 0 : n.call(t, s, Z)) === Z.mutable;
+    if (i.options.strict && qe(s, i.options, r), r || i.finalized || !Ie(s, i.options) || s !== i.original.get(e))
+      return s;
+    const o = _t.createDraft({
+      original: s,
+      parentDraft: i,
+      key: e,
+      finalities: i.finalities,
+      options: i.options
+    });
+    return W(i), i.copy.set(e, o), o;
+  },
+  keys() {
+    return Q(k(this)).keys();
+  },
+  values() {
+    const e = this.keys();
+    return {
+      [Je]: () => this.values(),
+      next: () => {
+        const t = e.next();
+        return t.done ? t : {
+          done: !1,
+          value: this.get(t.value)
+        };
+      }
+    };
+  },
+  entries() {
+    const e = this.keys();
+    return {
+      [Je]: () => this.entries(),
+      next: () => {
+        const t = e.next();
+        if (t.done)
+          return t;
+        const n = this.get(t.value);
+        return {
+          done: !1,
+          value: [t.value, n]
+        };
+      }
+    };
+  },
+  [Je]() {
+    return this.entries();
+  }
+}, Vn = Reflect.ownKeys(pt), Ut = (e, t, { isValuesIterator: n }) => () => {
+  var i, s;
+  const r = t.next();
+  if (r.done)
+    return r;
+  const o = r.value;
+  let a = e.setMap.get(o);
+  const u = k(a), c = ((s = (i = e.options).mark) === null || s === void 0 ? void 0 : s.call(i, a, Z)) === Z.mutable;
+  if (e.options.strict && qe(o, e.options, c), !c && !u && Ie(o, e.options) && !e.finalized && e.original.has(o)) {
+    const l = _t.createDraft({
+      original: o,
+      parentDraft: e,
+      key: o,
+      finalities: e.finalities,
+      options: e.options
+    });
+    e.setMap.set(o, l), a = l;
+  } else u && (a = u.proxy);
+  return {
+    done: !1,
+    value: n ? a : [a, a]
+  };
+}, Ke = {
+  get size() {
+    return k(this).setMap.size;
+  },
+  has(e) {
+    const t = k(this);
+    if (t.setMap.has(e))
+      return !0;
+    W(t);
+    const n = k(e);
+    return !!(n && t.setMap.has(n.original));
+  },
+  add(e) {
+    const t = k(this);
+    return this.has(e) || (W(t), te(t), t.assignedMap.set(e, !0), t.setMap.set(e, e), Tt(t, e, e, Fe)), this;
+  },
+  delete(e) {
+    if (!this.has(e))
+      return !1;
+    const t = k(this);
+    W(t), te(t);
+    const n = k(e);
+    return n && t.setMap.has(n.original) ? (t.assignedMap.set(n.original, !1), t.setMap.delete(n.original)) : (!n && t.setMap.has(e) ? t.assignedMap.set(e, !1) : t.assignedMap.delete(e), t.setMap.delete(e));
+  },
+  clear() {
+    if (!this.size)
+      return;
+    const e = k(this);
+    W(e), te(e);
+    for (const t of e.original)
+      e.assignedMap.set(t, !1);
+    e.setMap.clear();
+  },
+  values() {
+    const e = k(this);
+    W(e);
+    const t = e.setMap.keys();
+    return {
+      [Symbol.iterator]: () => this.values(),
+      next: Ut(e, t, { isValuesIterator: !0 })
+    };
+  },
+  entries() {
+    const e = k(this);
+    W(e);
+    const t = e.setMap.keys();
+    return {
+      [Symbol.iterator]: () => this.entries(),
+      next: Ut(e, t, {
+        isValuesIterator: !1
+      })
+    };
+  },
+  keys() {
+    return this.values();
+  },
+  [Je]() {
+    return this.values();
+  },
+  forEach(e, t) {
+    const n = this.values();
+    let i = n.next();
+    for (; !i.done; )
+      e.call(t, i.value, i.value, this), i = n.next();
+  }
+};
+Set.prototype.difference && Object.assign(Ke, {
+  intersection(e) {
+    return Set.prototype.intersection.call(new Set(this.values()), e);
+  },
+  union(e) {
+    return Set.prototype.union.call(new Set(this.values()), e);
+  },
+  difference(e) {
+    return Set.prototype.difference.call(new Set(this.values()), e);
+  },
+  symmetricDifference(e) {
+    return Set.prototype.symmetricDifference.call(new Set(this.values()), e);
+  },
+  isSubsetOf(e) {
+    return Set.prototype.isSubsetOf.call(new Set(this.values()), e);
+  },
+  isSupersetOf(e) {
+    return Set.prototype.isSupersetOf.call(new Set(this.values()), e);
+  },
+  isDisjointFrom(e) {
+    return Set.prototype.isDisjointFrom.call(new Set(this.values()), e);
+  }
+});
+const Jn = Reflect.ownKeys(Ke), nn = /* @__PURE__ */ new WeakSet(), sn = {
+  get(e, t, n) {
+    var i, s;
+    const r = (i = e.copy) === null || i === void 0 ? void 0 : i[t];
+    if (r && nn.has(r))
+      return r;
+    if (t === Xt)
+      return e;
+    let o;
+    if (e.options.mark) {
+      const c = t === "size" && (e.original instanceof Map || e.original instanceof Set) ? Reflect.get(e.original, t) : Reflect.get(e.original, t, n);
+      if (o = e.options.mark(c, Z), o === Z.mutable)
+        return e.options.strict && qe(c, e.options, !0), c;
+    }
+    const a = Q(e);
+    if (a instanceof Map && Vn.includes(t)) {
+      if (t === "size")
+        return Object.getOwnPropertyDescriptor(pt, "size").get.call(e.proxy);
+      const c = pt[t];
+      if (c)
+        return c.bind(e.proxy);
+    }
+    if (a instanceof Set && Jn.includes(t)) {
+      if (t === "size")
+        return Object.getOwnPropertyDescriptor(Ke, "size").get.call(e.proxy);
+      const c = Ke[t];
+      if (c)
+        return c.bind(e.proxy);
+    }
+    if (!Ne(a, t)) {
+      const c = Mt(a, t);
+      return c ? "value" in c ? c.value : (
+        // !case: support for getter
+        (s = c.get) === null || s === void 0 ? void 0 : s.call(e.proxy)
+      ) : void 0;
+    }
+    const u = a[t];
+    if (e.options.strict && qe(u, e.options), e.finalized || !Ie(u, e.options))
+      return u;
+    if (u === ot(e.original, t)) {
+      if (W(e), e.copy[t] = rn({
+        original: e.original[t],
+        parentDraft: e,
+        key: e.type === 1 ? Number(t) : t,
+        finalities: e.finalities,
+        options: e.options
+      }), typeof o == "function") {
+        const c = k(e.copy[t]);
+        return W(c), te(c), c.copy;
+      }
+      return e.copy[t];
+    }
+    return u;
+  },
+  set(e, t, n) {
+    var i;
+    if (e.type === 3 || e.type === 2)
+      throw new Error("Map/Set draft does not support any property assignment.");
+    let s;
+    if (e.type === 1 && t !== "length" && !(Number.isInteger(s = Number(t)) && s >= 0 && (t === 0 || s === 0 || String(s) === String(t))))
+      throw new Error("Only supports setting array indices and the 'length' property.");
+    const r = Mt(Q(e), t);
+    if (r != null && r.set)
+      return r.set.call(e.proxy, n), !0;
+    const o = ot(Q(e), t), a = k(o);
+    return a && we(a.original, n) ? (e.copy[t] = n, e.assignedMap = (i = e.assignedMap) !== null && i !== void 0 ? i : /* @__PURE__ */ new Map(), e.assignedMap.set(t, !1), !0) : (we(n, o) && (n !== void 0 || Ne(e.original, t)) || (W(e), te(e), Ne(e.original, t) && we(n, e.original[t]) ? e.assignedMap.delete(t) : e.assignedMap.set(t, !0), e.copy[t] = n, Tt(e, t, n, Fe)), !0);
+  },
+  has(e, t) {
+    return t in Q(e);
+  },
+  ownKeys(e) {
+    return Reflect.ownKeys(Q(e));
+  },
+  getOwnPropertyDescriptor(e, t) {
+    const n = Q(e), i = Reflect.getOwnPropertyDescriptor(n, t);
+    return i && {
+      writable: !0,
+      configurable: e.type !== 1 || t !== "length",
+      enumerable: i.enumerable,
+      value: n[t]
+    };
+  },
+  getPrototypeOf(e) {
+    return Reflect.getPrototypeOf(e.original);
+  },
+  setPrototypeOf() {
+    throw new Error("Cannot call 'setPrototypeOf()' on drafts");
+  },
+  defineProperty() {
+    throw new Error("Cannot call 'defineProperty()' on drafts");
+  },
+  deleteProperty(e, t) {
+    var n;
+    return e.type === 1 ? sn.set.call(this, e, t, void 0, e.proxy) : (ot(e.original, t) !== void 0 || t in e.original ? (W(e), te(e), e.assignedMap.set(t, !1)) : (e.assignedMap = (n = e.assignedMap) !== null && n !== void 0 ? n : /* @__PURE__ */ new Map(), e.assignedMap.delete(t)), e.copy && delete e.copy[t], !0);
+  }
+};
+function rn(e) {
+  const { original: t, parentDraft: n, key: i, finalities: s, options: r } = e, o = ze(t), a = {
+    type: o,
+    finalized: !1,
+    parent: n,
+    original: t,
+    copy: null,
+    proxy: null,
+    finalities: s,
+    options: r,
+    // Mapping of draft Set items to their corresponding draft values.
+    setMap: o === 3 ? new Map(t.entries()) : void 0
+  };
+  (i || "key" in e) && (a.key = i);
+  const { proxy: u, revoke: c } = Proxy.revocable(o === 1 ? Object.assign([], a) : a, sn);
+  if (s.revoke.push(c), nn.add(u), a.proxy = u, n) {
+    const l = n;
+    l.finalities.draft.push((f, m) => {
+      var p, I;
+      const g = k(u);
+      let h = l.type === 3 ? l.setMap : l.copy;
+      const $ = he(h, i), w = k($);
+      if (w) {
+        let O = w.original;
+        w.operated && (O = Ct($)), dt(w), ht(w, Fe, f, m), l.options.enableAutoFreeze && (l.options.updatedValues = (p = l.options.updatedValues) !== null && p !== void 0 ? p : /* @__PURE__ */ new WeakMap(), l.options.updatedValues.set(O, w.original)), xt(h, i, O);
+      }
+      (I = g.callbacks) === null || I === void 0 || I.forEach((O) => {
+        O(f, m);
+      });
+    });
+  } else {
+    const l = k(u);
+    l.finalities.draft.push((f, m) => {
+      dt(l), ht(l, Fe, f, m);
+    });
+  }
+  return u;
+}
+_t.createDraft = rn;
+Object.prototype.constructor.toString();
+function Ee() {
+  return Pn();
+}
+function Qn(e, t) {
+  return e.localeCompare(t);
+}
+function Gn() {
+  let e = Qn;
+  if (typeof Intl == "object" && Intl.hasOwnProperty("Collator"))
+    try {
+      e = Intl.Collator("en-US").compare;
+    } catch {
+    }
+  return e;
+}
+Gn();
+function Hn() {
+  const t = {
+    __etype: 1,
+    __ops: 1,
+    create: 1,
+    update: 1,
+    link: 1,
+    unlink: 1,
+    delete: 1,
+    merge: 1,
+    ruleParams: 1
+  };
+  return new Set(Object.keys(t));
+}
+const Bn = Hn();
+function Ge(e, t, n) {
+  const i = {
+    __etype: e,
+    __ops: n
+  };
+  return new Proxy(i, {
+    get: (s, r) => {
+      if (r === "__ops")
+        return n;
+      if (r === "__etype")
+        return e;
+      if (Bn.has(r))
+        return (o, a) => Ge(e, t, [
+          ...n,
+          a ? [r, e, t, o, a] : [r, e, t, o]
+        ]);
+    }
+  });
+}
+function qn(e, t) {
+  return `lookup__${e}__${JSON.stringify(t)}`;
+}
+function on(e) {
+  return e.startsWith("lookup__");
+}
+function Dt(e) {
+  const [t, n, ...i] = e.split("__");
+  return [n, JSON.parse(i.join("__"))];
+}
+function Kn(e) {
+  return new Proxy({
+    __etype: e
+  }, {
+    get(t, n) {
+      if (n === "lookup")
+        return (s, r) => Ge(e, Dt(qn(s, r)), []);
+      if (n === "__etype")
+        return e;
+      const i = n;
+      return on(i) ? Ge(e, Dt(i), []) : Ge(e, i, []);
+    }
+  });
+}
+function an() {
+  return new Proxy({}, {
+    get(e, t) {
+      return Kn(t);
+    }
+  });
+}
+an();
+function Xn(e) {
+  return e.__ops;
+}
+class B extends Error {
+  constructor(n, i) {
+    super(n);
+    d(this, "hint");
+    this.hint = i;
+    const s = new.target.prototype;
+    Object.setPrototypeOf && Object.setPrototypeOf(this, s), Error.captureStackTrace && Error.captureStackTrace(this, B), this.name = "InstantError";
+  }
+  get [Symbol.toStringTag]() {
+    return "InstantError";
+  }
+}
+class Se extends B {
+  constructor(n) {
+    var r;
+    const i = ((r = n.body) == null ? void 0 : r.message) || `API Error (${n.status})`;
+    super(i, n.body.hint);
+    d(this, "body");
+    d(this, "status");
+    const s = new.target.prototype;
+    Object.setPrototypeOf && Object.setPrototypeOf(this, s), Error.captureStackTrace && Error.captureStackTrace(this, Se), this.name = "InstantAPIError", this.status = n.status, this.body = n.body;
+  }
+  get [Symbol.toStringTag]() {
+    return "InstantAPIError";
+  }
+}
+typeof window < "u" && typeof window.localStorage < "u" && (window.localStorage.getItem("devBackend"), window.localStorage.getItem("__instantLogging"), window.localStorage.getItem("__devtoolLocalDash"));
+const Re = "v0.22.145";
+class ce {
+  constructor(t, n, i, s = { indexed: !1, unique: !1 }) {
+    d(this, "valueType");
+    d(this, "required");
+    d(this, "isIndexed");
+    d(this, "config");
+    d(this, "metadata", {});
+    this.valueType = t, this.required = n, this.isIndexed = i, this.config = s;
+  }
+  /**
+   * @deprecated Only use this temporarily for attributes that you want
+   * to treat as required in frontend code but can’t yet mark as required
+   * and enforced for backend
+   */
+  clientRequired() {
+    return new ce(this.valueType, !1, this.isIndexed, this.config);
+  }
+  optional() {
+    return new ce(this.valueType, !1, this.isIndexed, this.config);
+  }
+  unique() {
+    return new ce(this.valueType, this.required, this.isIndexed, {
+      ...this.config,
+      unique: !0
+    });
+  }
+  indexed() {
+    return new ce(this.valueType, this.required, !0, {
+      ...this.config,
+      indexed: !0
+    });
+  }
+}
+class E extends Error {
+  constructor(t, n) {
+    const i = n ? `At path '${n}': ${t}` : t;
+    super(i), this.name = "QueryValidationError";
+  }
+}
+const Nt = [
+  "where",
+  "order",
+  "limit",
+  "last",
+  "first",
+  "offset",
+  "after",
+  "before",
+  "fields",
+  "aggregate"
+], Yn = (e) => e.valueType || "unknown", cn = (e, t, n = !1) => {
+  if (n || e == null)
+    return !0;
+  switch (t) {
+    case "string":
+      return typeof e == "string";
+    case "number":
+      return typeof e == "number" && !isNaN(e);
+    case "boolean":
+      return typeof e == "boolean";
+    case "date":
+      return e instanceof Date || typeof e == "string" || typeof e == "number";
+    default:
+      return !0;
+  }
+}, Zn = (e, t, n, i, s, r, o) => {
+  const a = r.valueType === "json", u = (c, l, f) => {
+    if (!cn(f, l, a))
+      throw new E(`Invalid value for operator '${c}' on attribute '${i}' in entity '${s}'. Expected ${l}, but received: ${typeof f}`, o);
+  };
+  switch (e) {
+    case "in":
+    case "$in":
+      if (!Array.isArray(t))
+        throw new E(`Operator '${e}' for attribute '${i}' in entity '${s}' must be an array, but received: ${typeof t}`, o);
+      for (const c of t)
+        u(e, n, c);
+      break;
+    case "$not":
+    case "$ne":
+    case "$gt":
+    case "$lt":
+    case "$gte":
+    case "$lte":
+      u(e, n, t);
+      break;
+    case "$like":
+    case "$ilike":
+      if (u(e, "string", t), e === "$ilike" && !r.isIndexed)
+        throw new E(`Operator '${e}' can only be used with indexed attributes, but '${i}' in entity '${s}' is not indexed`, o);
+      break;
+    case "$isNull":
+      u(e, "boolean", t);
+      break;
+    default:
+      throw new E(`Unknown operator '${e}' for attribute '${i}' in entity '${s}'`, o);
+  }
+}, _e = (e, t, n, i, s) => {
+  const r = Yn(n), o = n.valueType === "json";
+  if (typeof e == "object" && e !== null && !Array.isArray(e)) {
+    if (o)
+      return;
+    const u = e;
+    for (const [c, l] of Object.entries(u))
+      Zn(c, l, r, t, i, n, `${s}.${c}`);
+  } else if (!cn(e, r, o))
+    throw new E(`Invalid value for attribute '${t}' in entity '${i}'. Expected ${r}, but received: ${typeof e}`, s);
+}, ei = (e, t, n, i, s) => {
+  const r = e.split(".");
+  if (r.length < 2)
+    throw new E(`Invalid dot notation path '${e}'. Must contain at least one dot.`, s);
+  let o = n;
+  for (let l = 0; l < r.length - 1; l++) {
+    const f = r[l], m = i.entities[o];
+    if (!m)
+      throw new E(`Entity '${o}' does not exist in schema while traversing dot notation path '${e}'.`, s);
+    const p = m.links[f];
+    if (!p) {
+      const I = Object.keys(m.links);
+      throw new E(`Link '${f}' does not exist on entity '${o}' in dot notation path '${e}'. Available links: ${I.length > 0 ? I.join(", ") : "none"}`, s);
+    }
+    o = p.entityName;
+  }
+  const a = r[r.length - 1], u = i.entities[o];
+  if (!u)
+    throw new E(`Target entity '${o}' does not exist in schema for dot notation path '${e}'.`, s);
+  if (a === "id") {
+    if (typeof t == "string" && !Te(t))
+      throw new E(`Invalid value for id field in entity '${o}'. Expected a UUID, but received: ${t}`, s);
+    _e(t, e, new ce("string", !1, !0), n, s);
+    return;
+  }
+  const c = u.attrs[a];
+  if (Object.keys(u.links).includes(a)) {
+    if (typeof t == "string" && !Te(t))
+      throw new E(`Invalid value for link '${a}' in entity '${o}'. Expected a UUID, but received: ${t}`, s);
+    _e(t, e, new ce("string", !1, !0), n, s);
+    return;
+  }
+  if (!c) {
+    const l = Object.keys(u.attrs);
+    throw new E(`Attribute '${a}' does not exist on entity '${o}' in dot notation path '${e}'. Available attributes: ${l.length > 0 ? l.join(", ") + ", id" : "id"}`, s);
+  }
+  _e(t, e, c, n, s);
+}, un = (e, t, n, i) => {
+  for (const [s, r] of Object.entries(e)) {
+    if (s === "or" || s === "and") {
+      if (Array.isArray(r))
+        for (const c of r)
+          typeof c == "object" && c !== null && un(c, t, n, `${i}.${s}[${c}]`);
+      continue;
+    }
+    if (s === "id") {
+      _e(r, "id", new ce("string", !1, !0), t, `${i}.id`);
+      continue;
+    }
+    if (s.includes(".")) {
+      ei(s, r, t, n, `${i}.${s}`);
+      continue;
+    }
+    const o = n.entities[t];
+    if (!o)
+      continue;
+    const a = o.attrs[s], u = o.links[s];
+    if (!a && !u) {
+      const c = Object.keys(o.attrs), l = Object.keys(o.links);
+      throw new E(`Attribute or link '${s}' does not exist on entity '${t}'. Available attributes: ${c.length > 0 ? c.join(", ") : "none"}. Available links: ${l.length > 0 ? l.join(", ") : "none"}`, `${i}.${s}`);
+    }
+    if (a)
+      _e(r, s, a, t, `${i}.${s}`);
+    else if (u) {
+      if (typeof r == "string" && !Te(r))
+        throw new E(`Invalid value for link '${s}' in entity '${t}'. Expected a UUID, but received: ${r}`, `${i}.${s}`);
+      const c = new ce("string", !1, !0);
+      _e(r, s, c, t, `${i}.${s}`);
+    }
+  }
+}, ti = (e, t, n, i, s = 0) => {
+  for (const o of Object.keys(e))
+    if (!Nt.includes(o))
+      throw new E(`Invalid query parameter '${o}' in $ object. Valid parameters are: ${Nt.join(", ")}. Found: ${o}`, i);
+  const r = [
+    // 'limit', // only supported client side
+    "offset",
+    "before",
+    "after",
+    "first",
+    "last"
+  ];
+  for (const o of r)
+    if (e[o] !== void 0 && s > 0)
+      throw new E(`'${o}' can only be used on top-level namespaces. It cannot be used in nested queries.`, i);
+  if (e.where && n) {
+    if (typeof e.where != "object" || e.where === null)
+      throw new E(`'where' clause must be an object in entity '${t}', but received: ${typeof e.where}`, i ? `${i}.where` : void 0);
+    un(e.where, t, n, i ? `${i}.where` : "where");
+  }
+}, fn = (e, t, n, i, s = 0) => {
+  var r;
+  if (!e || typeof e != "object")
+    throw new E(`Query part for entity '${t}' must be an object, but received: ${typeof e}`, i);
+  for (const o of Object.keys(e))
+    if (o !== "$") {
+      if (n && !(o in n.entities[t].links)) {
+        const u = Object.keys(n.entities[t].links);
+        throw new E(`Link '${o}' does not exist on entity '${t}'. Available links: ${u.length > 0 ? u.join(", ") : "none"}`, `${i}.${o}`);
+      }
+      const a = e[o];
+      if (typeof a == "object" && a !== null) {
+        const u = (r = n == null ? void 0 : n.entities[t].links[o]) == null ? void 0 : r.entityName;
+        u && fn(a, u, n, `${i}.${o}`, s + 1);
+      }
+    } else {
+      const a = e[o];
+      if (typeof a != "object" || a === null)
+        throw new E(`Query parameter '$' must be an object in entity '${t}', but received: ${typeof a}`, `${i}.$`);
+      ti(a, t, n, `${i}.$`, s);
+    }
+}, Lt = (e, t) => {
+  if (typeof e != "object" || e === null)
+    throw new E(`Query must be an object, but received: ${typeof e}${e === null ? " (null)" : ""}`);
+  if (Array.isArray(e))
+    throw new E(`Query must be an object, but received: ${typeof e}`);
+  const n = e;
+  for (const i of Object.keys(n)) {
+    if (Array.isArray(e[i]))
+      throw new E(`Query keys must be strings, but found key of type: ${typeof i}`, i);
+    if (typeof i != "string")
+      throw new E(`Query keys must be strings, but found key of type: ${typeof i}`, i);
+    if (i !== "$$ruleParams") {
+      if (t && !t.entities[i]) {
+        const s = Object.keys(t.entities);
+        throw new E(`Entity '${i}' does not exist in schema. Available entities: ${s.length > 0 ? s.join(", ") : "none"}`, i);
+      }
+      fn(n[i], i, t, i, 0);
+    }
+  }
+}, Wt = (e) => typeof e != "string" ? !1 : on(e) ? !0 : Te(e);
+class q extends Error {
+  constructor(t) {
+    super(t), this.name = "TransactionValidationError";
+  }
+}
+const ln = (e) => e.length > 0 ? e.join(", ") : "none", ni = (e, t) => new q(`Entity '${e}' does not exist in schema. Available entities: ${ln(t)}`), at = {
+  string: (e) => typeof e == "string",
+  number: (e) => typeof e == "number" && !isNaN(e),
+  boolean: (e) => typeof e == "boolean",
+  date: (e) => e instanceof Date || typeof e == "string" || typeof e == "number",
+  json: () => !0
+}, ii = (e, t) => {
+  var n;
+  return e == null ? !0 : ((n = at[t.valueType]) == null ? void 0 : n.call(at, e)) ?? !1;
+}, dn = (e, t) => {
+  const n = t.entities[e];
+  if (!n)
+    throw ni(e, Object.keys(t.entities));
+  return n;
+}, ct = (e, t, n) => {
+  const i = dn(e, n);
+  if (typeof t != "object" || t === null)
+    throw new q(`Arguments for data operation on entity '${e}' must be an object, but received: ${typeof t}`);
+  for (const [s, r] of Object.entries(t)) {
+    if (s === "id")
+      continue;
+    const o = i.attrs[s];
+    if (o && !ii(r, o))
+      throw new q(`Invalid value for attribute '${s}' in entity '${e}'. Expected ${o.valueType}, but received: ${typeof r}`);
+  }
+}, Ft = (e, t, n) => {
+  const i = dn(e, n);
+  if (typeof t != "object" || t === null)
+    throw new q(`Arguments for link operation on entity '${e}' must be an object, but received: ${typeof t}`);
+  for (const [s, r] of Object.entries(t)) {
+    if (!i.links[s]) {
+      const a = Object.keys(i.links);
+      throw new q(`Link '${s}' does not exist on entity '${e}'. Available links: ${ln(a)}`);
+    }
+    if (r != null) {
+      if (Array.isArray(r)) {
+        for (const a of r)
+          if (!Wt(a))
+            throw new q(`Invalid entity ID in link '${s}' for entity '${e}'. Expected a UUID or a lookup, but received: ${a}`);
+      } else if (!Wt(r))
+        throw new q(`Invalid UUID in link '${s}' for entity '${e}'. Expected a UUID, but received: ${r}`);
+    }
+  }
+}, si = {
+  create: ct,
+  update: ct,
+  merge: ct,
+  link: Ft,
+  unlink: Ft,
+  delete: () => {
+  }
+}, ri = (e, t) => {
+  if (!t)
+    return;
+  const [n, i, s, r] = e;
+  if (!Array.isArray(s) && !Te(s))
+    throw new q(`Invalid id for entity '${i}'. Expected a UUID, but received: ${s}`);
+  if (typeof i != "string")
+    throw new q(`Entity name must be a string, but received: ${typeof i}`);
+  const o = si[n];
+  o && r !== void 0 && o(i, r, t);
+}, oi = (e, t) => {
+  const n = Array.isArray(e) ? e : [e];
+  for (const i of n) {
+    if (!i || typeof i != "object")
+      throw new q(`Transaction chunk must be an object, but received: ${typeof i}`);
+    if (!Array.isArray(i.__ops))
+      throw new q(`Transaction chunk must have __ops array, but received: ${typeof i.__ops}`);
+    for (const s of i.__ops) {
+      if (!Array.isArray(s))
+        throw new q(`Transaction operation must be an array, but received: ${typeof s}`);
+      ri(s, t);
+    }
+  }
+};
+let ai = 0;
+class ci {
+  constructor(t, n, i) {
+    d(this, "type", "sse");
+    d(this, "initParams", null);
+    d(this, "sendQueue", []);
+    d(this, "sendPromise");
+    d(this, "closeFired", !1);
+    d(this, "sseInitTimeout");
+    d(this, "ES");
+    d(this, "messageUrl");
+    d(this, "conn");
+    d(this, "url");
+    d(this, "id");
+    d(this, "onopen");
+    d(this, "onmessage");
+    d(this, "onclose");
+    d(this, "onerror");
+    this.id = `${this.type}_${ai++}`, this.url = n, this.messageUrl = i || this.url, this.ES = t, this.conn = new t(n), this.sseInitTimeout = setTimeout(() => {
+      this.initParams || this.handleError();
+    }, 1e4), this.conn.onmessage = (s) => {
+      const r = JSON.parse(s.data);
+      if (Array.isArray(r))
+        for (const o of r)
+          this.handleMessage(o);
+      else
+        this.handleMessage(r);
+    }, this.conn.onerror = (s) => {
+      this.handleError();
+    };
+  }
+  handleMessage(t) {
+    if (t.op === "sse-init") {
+      this.initParams = {
+        machineId: t["machine-id"],
+        sessionId: t["session-id"],
+        sseToken: t["sse-token"]
+      }, this.onopen && this.onopen({ target: this }), clearTimeout(this.sseInitTimeout);
+      return;
+    }
+    this.onmessage && this.onmessage({
+      target: this,
+      message: t
+    });
+  }
+  // Runs the onerror and closes the connection
+  handleError() {
+    try {
+      this.onerror && this.onerror({ target: this });
+    } finally {
+      this.handleClose();
+    }
+  }
+  handleClose() {
+    this.conn.close(), this.onclose && !this.closeFired && (this.closeFired = !0, this.onclose({ target: this }));
+  }
+  async postMessages(t) {
+    var n, i, s;
+    try {
+      (await fetch(this.messageUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          machine_id: (n = this.initParams) == null ? void 0 : n.machineId,
+          session_id: (i = this.initParams) == null ? void 0 : i.sessionId,
+          sse_token: (s = this.initParams) == null ? void 0 : s.sseToken,
+          messages: t
+        })
+      })).ok || this.handleError();
+    } catch {
+      this.handleError();
+    }
+  }
+  async flushQueue() {
+    if (this.sendPromise || !this.sendQueue.length)
+      return;
+    const t = this.sendQueue;
+    this.sendQueue = [];
+    const n = this.postMessages(t);
+    this.sendPromise = n, n.then(() => {
+      this.sendPromise = null, this.flushQueue();
+    });
+  }
+  send(t) {
+    if (!this.isOpen() || !this.initParams)
+      throw this.isConnecting() ? new Error("Failed to execute 'send' on 'EventSource': Still in CONNECTING state.") : this.conn.readyState === this.ES.CLOSED ? new Error("EventSource is already in CLOSING or CLOSED state.") : new Error("EventSource is in invalid state.");
+    this.sendQueue.push(t), this.flushQueue();
+  }
+  isOpen() {
+    return this.conn.readyState === this.ES.OPEN && this.initParams !== null;
+  }
+  isConnecting() {
+    return this.conn.readyState === this.ES.CONNECTING || this.conn.readyState === this.ES.OPEN && this.initParams === null;
+  }
+  close() {
+    this.handleClose();
+  }
+}
+var zt;
+(function(e) {
+  e.InitialSyncBatch = "InitialSyncBatch", e.InitialSyncComplete = "InitialSyncComplete", e.LoadFromStorage = "LoadFromStorage", e.SyncTransaction = "SyncTransaction", e.Error = "Error";
+})(zt || (zt = {}));
+function ui({ WStream: e, opts: t, startStream: n, appendStream: i, registerStream: s }) {
+  const r = t.clientId;
+  let o = null, a = null;
+  const u = Ee();
+  let c = !1, l = !1;
+  const f = [], m = [], p = [];
+  let I = !1, g = 0, h = 0;
+  const $ = [], w = new TextEncoder();
+  function O() {
+    l = !0;
+    for (const y of f)
+      y();
+  }
+  function ne(y) {
+    return f.push(y), () => {
+      const v = f.indexOf(y);
+      v !== -1 && f.splice(v, 1);
+    };
+  }
+  function P(y) {
+    return p.push(y), () => {
+      const v = p.indexOf(y);
+      v !== -1 && p.splice(v, 1);
+    };
+  }
+  t.waitUntil && t.waitUntil(new Promise((y) => {
+    p.push(y);
+  }));
+  function j() {
+    for (const y of p)
+      try {
+        y();
+      } catch {
+      }
+  }
+  function K(y) {
+    return m.push(y), () => {
+      const v = m.indexOf(y);
+      v !== -1 && m.splice(v, 1);
+    };
+  }
+  function ie(y) {
+    o = y;
+    for (const v of m)
+      v(o);
+  }
+  function V() {
+    I = !0;
+  }
+  function Ae(y) {
+    let v = g, D = 0, F = 0;
+    for (const { byteLen: X } of $) {
+      const re = v + X;
+      if (re > y)
+        break;
+      v = re, D++, F += X;
+    }
+    D > 0 && (g += F, h -= F, $.splice(0, D));
+  }
+  function pe(y, v) {
+    O(), y.error(v), j();
+  }
+  async function me() {
+    const y = await n({
+      clientId: r,
+      reconnectToken: u,
+      ruleParams: t.ruleParams
+    });
+    switch (y.type) {
+      case "ok": {
+        const { streamId: v, offset: D } = y;
+        o = v, Ae(D), $.length && i({
+          streamId: v,
+          chunks: $.map((F) => F.chunk),
+          offset: g
+        }), I = !1;
+        break;
+      }
+      case "disconnect": {
+        V();
+        break;
+      }
+      case "error": {
+        a && pe(a, y.error);
+        break;
+      }
+    }
+  }
+  function se() {
+    V(), me();
+  }
+  function J({ offset: y, done: v }) {
+    Ae(y), v && (c = !0, j());
+  }
+  function Pe(y) {
+    return c ? (pe(y, new B("Stream has been closed.")), null) : o || (pe(y, new B("Stream has not been initialized.")), null);
+  }
+  async function $n(y) {
+    a = y;
+    let v = !0, D = 0;
+    for (; v; ) {
+      let F = Date.now() + Math.min(15e3, 500 * (D - 1));
+      v = !1;
+      const X = await n({
+        clientId: t.clientId,
+        reconnectToken: u,
+        ruleParams: t.ruleParams
+      });
+      switch (X.type) {
+        case "ok": {
+          const { streamId: re, offset: it } = X;
+          if (it !== 0) {
+            const je = new B("Write stream is corrupted");
+            pe(y, je);
+            return;
+          }
+          ie(re), s(re, {
+            onDisconnect: V,
+            onFlush: J,
+            onConnectionReconnect: me,
+            onAppendFailed: se
+          }), I = !1;
+          return;
+        }
+        case "disconnect": {
+          v = !0, V(), D++, await new Promise((re) => {
+            setTimeout(re, Math.max(0, F - Date.now()));
+          });
+          break;
+        }
+        case "error": {
+          pe(y, X.error);
+          return;
+        }
+      }
+    }
+  }
+  class kn extends e {
+    constructor(v, D) {
+      super(v, D);
+    }
+    async streamId() {
+      return o || new Promise((v, D) => {
+        const F = [], X = () => {
+          for (const je of F)
+            je();
+        }, re = (je) => {
+          v(je), X();
+        }, it = () => {
+          D(new B("Stream is closed.")), X();
+        };
+        F.push(K(re)), F.push(ne(it));
+      });
+    }
+  }
+  return {
+    stream: new kn({
+      // TODO(dww): accept a storage so that write streams can survive across
+      //            browser restarts
+      async start(y) {
+        try {
+          await $n(y);
+        } catch (v) {
+          pe(y, v);
+        }
+      },
+      write(y, v) {
+        const D = Pe(v);
+        if (D) {
+          const F = w.encode(y).length;
+          $.push({ chunk: y, byteLen: F });
+          const X = g + h;
+          h += F, I || i({ streamId: D, chunks: [y], offset: X });
+        }
+      },
+      close() {
+        o ? i({
+          streamId: o,
+          chunks: [],
+          offset: g + h,
+          isDone: !0
+        }) : j(), O();
+      },
+      abort(y) {
+        o ? i({
+          streamId: o,
+          chunks: [],
+          offset: g + h,
+          isDone: !0,
+          abortReason: y
+        }) : j(), O();
+      }
+    }),
+    addCompleteCb: P,
+    closed() {
+      return l;
+    }
+  };
+}
+class fi {
+  constructor() {
+    d(this, "items", []);
+    d(this, "resolvers", []);
+    d(this, "isClosed", !1);
+  }
+  push(t) {
+    if (this.isClosed)
+      return;
+    const n = this.resolvers.shift();
+    n ? n({ value: t, done: !1 }) : this.items.push(t);
+  }
+  close() {
+    for (this.isClosed = !0; this.resolvers.length > 0; )
+      this.resolvers.shift()({ value: void 0, done: !0 });
+  }
+  async *[Symbol.asyncIterator]() {
+    for (; ; )
+      if (this.items.length > 0)
+        yield this.items.shift();
+      else {
+        if (this.isClosed)
+          return;
+        {
+          const { value: t, done: n } = await new Promise((i) => {
+            this.resolvers.push(i);
+          });
+          if (n || !t)
+            return;
+          yield t;
+        }
+      }
+  }
+}
+function li({ RStream: e, opts: t, startStream: n, cancelStream: i }) {
+  let s = t.byteOffset || 0, r = !1;
+  const o = new TextDecoder("utf-8"), a = new TextEncoder();
+  let u, c = !1;
+  const l = [];
+  function f() {
+    c = !0;
+    for (const w of l)
+      w();
+  }
+  function m(w) {
+    return l.push(w), () => {
+      const O = l.indexOf(w);
+      O !== -1 && l.splice(O, 1);
+    };
+  }
+  function p(w, O) {
+    w.error(O), f();
+  }
+  let I = 0;
+  async function g(w, O) {
+    u = Ee();
+    const ne = { ...w || {}, eventId: u };
+    for await (const P of n(ne)) {
+      if (r)
+        return;
+      if (P.type === "reconnect")
+        return { retry: !0 };
+      if (P.type === "error") {
+        p(O, P.error);
+        return;
+      }
+      if (P.offset > s) {
+        p(O, new B("Stream is corrupted.")), r = !0;
+        return;
+      }
+      let j = s - P.offset;
+      if (P.files && P.files.length) {
+        const K = new AbortController();
+        let ie = fetch(P.files[0].url, {
+          signal: K.signal
+        });
+        for (let V = 0; V < P.files.length; V++) {
+          const Ae = P.files[V + 1], me = await ie;
+          if (Ae && (ie = fetch(Ae.url, { signal: K.signal })), !me.ok) {
+            if (I++, I > 10) {
+              p(O, new B("Unable to process stream."));
+              return;
+            }
+            return { retry: !0 };
+          }
+          if (me.body)
+            for await (const se of me.body) {
+              if (r) {
+                K.abort();
+                return;
+              }
+              let J = se;
+              if (j > 0 && (J = se.subarray(j), j -= se.length - J.length), !J.length)
+                continue;
+              s += J.length;
+              const Pe = o.decode(J);
+              O.enqueue(Pe);
+            }
+          else {
+            const se = await me.arrayBuffer();
+            let J = se;
+            if (r) {
+              K.abort();
+              return;
+            }
+            if (j > 0 && (J = new Uint8Array(se).subarray(j), j -= se.byteLength - J.length), !J.byteLength)
+              continue;
+            s += J.byteLength;
+            const Pe = o.decode(J);
+            O.enqueue(Pe);
+          }
+        }
+      }
+      if (I = 0, P.content) {
+        let K = P.content, ie = a.encode(P.content);
+        if (j > 0) {
+          const V = ie.subarray(j);
+          if (j -= ie.length - V.length, !V.length)
+            continue;
+          ie = V, K = o.decode(V);
+        }
+        s += ie.length, O.enqueue(K);
+      }
+    }
+  }
+  async function h(w) {
+    let O = !0, ne = 0;
+    for (; O; ) {
+      O = !1;
+      let P = Date.now() + Math.min(15e3, 500 * (ne - 1));
+      const j = await g({ ...t, offset: s }, w);
+      j != null && j.retry && (O = !0, ne++, P < Date.now() - 3e5 && (ne = 0), await new Promise((K) => {
+        setTimeout(K, Math.max(0, P - Date.now()));
+      }));
+    }
+    !r && !c && (w.close(), f());
+  }
+  return {
+    stream: new e({
+      start(w) {
+        h(w);
+      },
+      cancel(w) {
+        r = !0, u && i({ eventId: u }), f();
+      }
+    }),
+    addCloseCb: m,
+    closed() {
+      return c;
+    }
+  };
+}
+class di {
+  constructor({ WStream: t, RStream: n, trySend: i, log: s }) {
+    d(this, "trySend");
+    d(this, "WStream");
+    d(this, "RStream");
+    d(this, "writeStreams", {});
+    d(this, "startWriteStreamCbs", {});
+    d(this, "readStreamIterators", {});
+    d(this, "log");
+    d(this, "activeStreams", /* @__PURE__ */ new Set());
+    this.WStream = t, this.RStream = n, this.trySend = i, this.log = s;
+  }
+  createWriteStream(t) {
+    const { stream: n, addCompleteCb: i } = ui({
+      WStream: this.WStream,
+      startStream: this.startWriteStream.bind(this),
+      appendStream: this.appendStream.bind(this),
+      registerStream: this.registerWriteStream.bind(this),
+      opts: t
+    });
+    return this.activeStreams.add(n), i(() => {
+      this.activeStreams.delete(n);
+    }), n;
+  }
+  createReadStream(t) {
+    const { stream: n, addCloseCb: i } = li({
+      RStream: this.RStream,
+      opts: t,
+      startStream: this.startReadStream.bind(this),
+      cancelStream: this.cancelReadStream.bind(this)
+    });
+    return this.activeStreams.add(n), i(() => {
+      this.activeStreams.delete(n);
+    }), n;
+  }
+  startWriteStream(t) {
+    const n = Ee();
+    let i = null;
+    const s = new Promise((o) => {
+      i = o;
+    });
+    this.startWriteStreamCbs[n] = i;
+    const r = {
+      op: "start-stream",
+      "client-id": t.clientId,
+      "reconnect-token": t.reconnectToken
+    };
+    return t.ruleParams && (r["rule-params"] = t.ruleParams), this.trySend(n, r), s;
+  }
+  registerWriteStream(t, n) {
+    this.writeStreams[t] = n;
+  }
+  appendStream({ streamId: t, chunks: n, isDone: i, offset: s, abortReason: r }) {
+    const o = {
+      op: "append-stream",
+      "stream-id": t,
+      chunks: n,
+      offset: s,
+      done: !!i
+    };
+    r && (o["abort-reason"] = r), this.trySend(Ee(), o);
+  }
+  onAppendFailed(t) {
+    const n = this.writeStreams[t["stream-id"]];
+    n && n.onAppendFailed();
+  }
+  onStartStreamOk(t) {
+    const n = this.startWriteStreamCbs[t["client-event-id"]];
+    if (!n) {
+      this.log.info("No stream for start-stream-ok", t);
+      return;
+    }
+    n({ type: "ok", streamId: t["stream-id"], offset: t.offset }), delete this.startWriteStreamCbs[t["client-event-id"]];
+  }
+  onStreamFlushed(t) {
+    const n = t["stream-id"], i = this.writeStreams[n];
+    if (!i) {
+      this.log.info("No stream cbs for stream-flushed", t);
+      return;
+    }
+    i.onFlush({ offset: t.offset, done: t.done }), t.done && delete this.writeStreams[n];
+  }
+  startReadStream({ eventId: t, clientId: n, streamId: i, offset: s, ruleParams: r }) {
+    const o = { op: "subscribe-stream" };
+    if (!i && !n)
+      throw new Error("Must provide one of streamId or clientId to subscribe to the stream.");
+    i && (o["stream-id"] = i), n && (o["client-id"] = n), s && (o.offset = s), r && (o["rule-params"] = r);
+    const a = new fi();
+    return this.readStreamIterators[t] = a, this.trySend(t, o), a;
+  }
+  cancelReadStream({ eventId: t }) {
+    const n = {
+      op: "unsubscribe-stream",
+      "subscribe-event-id": t
+    };
+    this.trySend(Ee(), n), delete this.readStreamIterators[t];
+  }
+  onStreamAppend(t) {
+    var s;
+    const n = t["client-event-id"], i = this.readStreamIterators[n];
+    if (!i) {
+      this.log.info("No iterator for read stream", t);
+      return;
+    }
+    if (t.error) {
+      t.retry ? i.push({ type: "reconnect" }) : i.push({
+        type: "error",
+        error: new B(t.error)
+      }), i.close(), delete this.readStreamIterators[n];
+      return;
+    }
+    ((s = t.files) != null && s.length || t.content) && i.push({
+      type: "append",
+      offset: t.offset,
+      files: t.files,
+      content: t.content
+    }), t.done && (i.close(), delete this.readStreamIterators[n]);
+  }
+  onConnectionStatusChange(t) {
+    for (const n of Object.values(this.startWriteStreamCbs))
+      n({ type: "disconnect" });
+    if (this.startWriteStreamCbs = {}, t !== hi.AUTHENTICATED)
+      for (const { onDisconnect: n } of Object.values(this.writeStreams))
+        n();
+    else {
+      for (const { onConnectionReconnect: n } of Object.values(this.writeStreams))
+        n();
+      for (const n of Object.values(this.readStreamIterators))
+        n.push({ type: "reconnect" }), n.close();
+      this.readStreamIterators = {};
+    }
+  }
+  onRecieveError(t) {
+    const n = t["original-event"];
+    switch (n.op) {
+      case "append-stream": {
+        const i = n["stream-id"], s = this.writeStreams[i];
+        s == null || s.onAppendFailed();
+        break;
+      }
+      case "start-stream": {
+        const i = t["client-event-id"], s = this.startWriteStreamCbs[i];
+        s && (s({
+          type: "error",
+          error: new B(t.message || "Unknown error", t.hint)
+        }), delete this.startWriteStreamCbs[i]);
+        break;
+      }
+      case "subscribe-stream": {
+        const i = t["client-event-id"], s = this.readStreamIterators[i];
+        s && (s.push({
+          type: "error",
+          error: new B(t.message || "Unknown error", t.hint)
+        }), s.close(), delete this.readStreamIterators[i]);
+        break;
+      }
+    }
+  }
+  hasActiveStreams() {
+    return this.activeStreams.size > 0;
+  }
+}
+const hi = {
+  AUTHENTICATED: "authenticated"
+};
+function pi() {
+  return globalThis.__instantDbSchemaHashStore = globalThis.__instantDbSchemaHashStore ?? /* @__PURE__ */ new WeakMap(), globalThis.__instantDbSchemaHashStore;
+}
+function mi() {
+  return globalThis.__instantDbStore = globalThis.__instantDbStore ?? {}, globalThis.__instantDbStore;
+}
+mi();
+pi();
+class Vt extends Error {
+  constructor(t, n) {
+    super(t), this.name = "ParseError", this.type = n.type, this.field = n.field, this.value = n.value, this.line = n.line;
+  }
+}
+function ut(e) {
+}
+function yi(e) {
+  if (typeof e == "function")
+    throw new TypeError(
+      "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
+    );
+  const { onEvent: t = ut, onError: n = ut, onRetry: i = ut, onComment: s } = e;
+  let r = "", o = !0, a, u = "", c = "";
+  function l(g) {
+    const h = o ? g.replace(/^\xEF\xBB\xBF/, "") : g, [$, w] = bi(`${r}${h}`);
+    for (const O of $)
+      f(O);
+    r = w, o = !1;
+  }
+  function f(g) {
+    if (g === "") {
+      p();
+      return;
+    }
+    if (g.startsWith(":")) {
+      s && s(g.slice(g.startsWith(": ") ? 2 : 1));
+      return;
+    }
+    const h = g.indexOf(":");
+    if (h !== -1) {
+      const $ = g.slice(0, h), w = g[h + 1] === " " ? 2 : 1, O = g.slice(h + w);
+      m($, O, g);
+      return;
+    }
+    m(g, "", g);
+  }
+  function m(g, h, $) {
+    switch (g) {
+      case "event":
+        c = h;
+        break;
+      case "data":
+        u = `${u}${h}
+`;
+        break;
+      case "id":
+        a = h.includes("\0") ? void 0 : h;
+        break;
+      case "retry":
+        /^\d+$/.test(h) ? i(parseInt(h, 10)) : n(
+          new Vt(`Invalid \`retry\` value: "${h}"`, {
+            type: "invalid-retry",
+            value: h,
+            line: $
+          })
+        );
+        break;
+      default:
+        n(
+          new Vt(
+            `Unknown field "${g.length > 20 ? `${g.slice(0, 20)}…` : g}"`,
+            { type: "unknown-field", field: g, value: h, line: $ }
+          )
+        );
+        break;
+    }
+  }
+  function p() {
+    u.length > 0 && t({
+      id: a,
+      event: c || void 0,
+      // If the data buffer's last character is a U+000A LINE FEED (LF) character,
+      // then remove the last character from the data buffer.
+      data: u.endsWith(`
+`) ? u.slice(0, -1) : u
+    }), a = void 0, u = "", c = "";
+  }
+  function I(g = {}) {
+    r && g.consume && f(r), o = !0, a = void 0, u = "", c = "", r = "";
+  }
+  return { feed: l, reset: I };
+}
+function bi(e) {
+  const t = [];
+  let n = "", i = 0;
+  for (; i < e.length; ) {
+    const s = e.indexOf("\r", i), r = e.indexOf(`
+`, i);
+    let o = -1;
+    if (s !== -1 && r !== -1 ? o = Math.min(s, r) : s !== -1 ? o = s : r !== -1 && (o = r), o === -1) {
+      n = e.slice(i);
+      break;
+    } else {
+      const a = e.slice(i, o);
+      t.push(a), i = o + 1, e[i - 1] === "\r" && e[i] === `
+` && i++;
+    }
+  }
+  return [t, n];
+}
+class Jt extends Event {
+  /**
+   * Constructs a new `ErrorEvent` instance. This is typically not called directly,
+   * but rather emitted by the `EventSource` object when an error occurs.
+   *
+   * @param type - The type of the event (should be "error")
+   * @param errorEventInitDict - Optional properties to include in the error event
+   */
+  constructor(t, n) {
+    var i, s;
+    super(t), this.code = (i = n == null ? void 0 : n.code) != null ? i : void 0, this.message = (s = n == null ? void 0 : n.message) != null ? s : void 0;
+  }
+  /**
+   * Node.js "hides" the `message` and `code` properties of the `ErrorEvent` instance,
+   * when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging,
+   * we explicitly include the properties in the `inspect` method.
+   *
+   * This is automatically called by Node.js when you `console.log` an instance of this class.
+   *
+   * @param _depth - The current depth
+   * @param options - The options passed to `util.inspect`
+   * @param inspect - The inspect function to use (prevents having to import it from `util`)
+   * @returns A string representation of the error
+   */
+  [Symbol.for("nodejs.util.inspect.custom")](t, n, i) {
+    return i(Qt(this), n);
+  }
+  /**
+   * Deno "hides" the `message` and `code` properties of the `ErrorEvent` instance,
+   * when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging,
+   * we explicitly include the properties in the `inspect` method.
+   *
+   * This is automatically called by Deno when you `console.log` an instance of this class.
+   *
+   * @param inspect - The inspect function to use (prevents having to import it from `util`)
+   * @param options - The options passed to `Deno.inspect`
+   * @returns A string representation of the error
+   */
+  [Symbol.for("Deno.customInspect")](t, n) {
+    return t(Qt(this), n);
+  }
+}
+function gi(e) {
+  const t = globalThis.DOMException;
+  return typeof t == "function" ? new t(e, "SyntaxError") : new SyntaxError(e);
+}
+function mt(e) {
+  return e instanceof Error ? "errors" in e && Array.isArray(e.errors) ? e.errors.map(mt).join(", ") : "cause" in e && e.cause instanceof Error ? `${e}: ${mt(e.cause)}` : e.message : `${e}`;
+}
+function Qt(e) {
+  return {
+    type: e.type,
+    message: e.message,
+    code: e.code,
+    defaultPrevented: e.defaultPrevented,
+    cancelable: e.cancelable,
+    timeStamp: e.timeStamp
+  };
+}
+var hn = (e) => {
+  throw TypeError(e);
+}, Rt = (e, t, n) => t.has(e) || hn("Cannot " + n), S = (e, t, n) => (Rt(e, t, "read from private field"), n ? n.call(e) : t.get(e)), x = (e, t, n) => t.has(e) ? hn("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, n), _ = (e, t, n, i) => (Rt(e, t, "write to private field"), t.set(e, n), n), ae = (e, t, n) => (Rt(e, t, "access private method"), n), z, ye, ve, He, Xe, Le, ke, We, de, Oe, Ce, $e, Ue, Y, yt, bt, gt, Gt, wt, St, De, It, vt;
+class ee extends EventTarget {
+  constructor(t, n) {
+    var i, s;
+    super(), x(this, Y), this.CONNECTING = 0, this.OPEN = 1, this.CLOSED = 2, x(this, z), x(this, ye), x(this, ve), x(this, He), x(this, Xe), x(this, Le), x(this, ke), x(this, We, null), x(this, de), x(this, Oe), x(this, Ce, null), x(this, $e, null), x(this, Ue, null), x(this, bt, async (r) => {
+      var o;
+      S(this, Oe).reset();
+      const { body: a, redirected: u, status: c, headers: l } = r;
+      if (c === 204) {
+        ae(this, Y, De).call(this, "Server sent HTTP 204, not reconnecting", 204), this.close();
+        return;
+      }
+      if (u ? _(this, ve, new URL(r.url)) : _(this, ve, void 0), c !== 200) {
+        ae(this, Y, De).call(this, `Non-200 status code (${c})`, c);
+        return;
+      }
+      if (!(l.get("content-type") || "").startsWith("text/event-stream")) {
+        ae(this, Y, De).call(this, 'Invalid content type, expected "text/event-stream"', c);
+        return;
+      }
+      if (S(this, z) === this.CLOSED)
+        return;
+      _(this, z, this.OPEN);
+      const f = new Event("open");
+      if ((o = S(this, Ue)) == null || o.call(this, f), this.dispatchEvent(f), typeof a != "object" || !a || !("getReader" in a)) {
+        ae(this, Y, De).call(this, "Invalid response body, expected a web ReadableStream", c), this.close();
+        return;
+      }
+      const m = new TextDecoder(), p = a.getReader();
+      let I = !0;
+      do {
+        const { done: g, value: h } = await p.read();
+        h && S(this, Oe).feed(m.decode(h, { stream: !g })), g && (I = !1, S(this, Oe).reset(), ae(this, Y, It).call(this));
+      } while (I);
+    }), x(this, gt, (r) => {
+      _(this, de, void 0), !(r.name === "AbortError" || r.type === "aborted") && ae(this, Y, It).call(this, mt(r));
+    }), x(this, wt, (r) => {
+      typeof r.id == "string" && _(this, We, r.id);
+      const o = new MessageEvent(r.event || "message", {
+        data: r.data,
+        origin: S(this, ve) ? S(this, ve).origin : S(this, ye).origin,
+        lastEventId: r.id || ""
+      });
+      S(this, $e) && (!r.event || r.event === "message") && S(this, $e).call(this, o), this.dispatchEvent(o);
+    }), x(this, St, (r) => {
+      _(this, Le, r);
+    }), x(this, vt, () => {
+      _(this, ke, void 0), S(this, z) === this.CONNECTING && ae(this, Y, yt).call(this);
+    });
+    try {
+      if (t instanceof URL)
+        _(this, ye, t);
+      else if (typeof t == "string")
+        _(this, ye, new URL(t, wi()));
+      else
+        throw new Error("Invalid URL");
+    } catch {
+      throw gi("An invalid or illegal string was specified");
+    }
+    _(this, Oe, yi({
+      onEvent: S(this, wt),
+      onRetry: S(this, St)
+    })), _(this, z, this.CONNECTING), _(this, Le, 3e3), _(this, Xe, (i = n == null ? void 0 : n.fetch) != null ? i : globalThis.fetch), _(this, He, (s = n == null ? void 0 : n.withCredentials) != null ? s : !1), ae(this, Y, yt).call(this);
+  }
+  /**
+   * Returns the state of this EventSource object's connection. It can have the values described below.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/readyState)
+   *
+   * Note: typed as `number` instead of `0 | 1 | 2` for compatibility with the `EventSource` interface,
+   * defined in the TypeScript `dom` library.
+   *
+   * @public
+   */
+  get readyState() {
+    return S(this, z);
+  }
+  /**
+   * Returns the URL providing the event stream.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/url)
+   *
+   * @public
+   */
+  get url() {
+    return S(this, ye).href;
+  }
+  /**
+   * Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/withCredentials)
+   */
+  get withCredentials() {
+    return S(this, He);
+  }
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/error_event) */
+  get onerror() {
+    return S(this, Ce);
+  }
+  set onerror(t) {
+    _(this, Ce, t);
+  }
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/message_event) */
+  get onmessage() {
+    return S(this, $e);
+  }
+  set onmessage(t) {
+    _(this, $e, t);
+  }
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/open_event) */
+  get onopen() {
+    return S(this, Ue);
+  }
+  set onopen(t) {
+    _(this, Ue, t);
+  }
+  addEventListener(t, n, i) {
+    const s = n;
+    super.addEventListener(t, s, i);
+  }
+  removeEventListener(t, n, i) {
+    const s = n;
+    super.removeEventListener(t, s, i);
+  }
+  /**
+   * Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/close)
+   *
+   * @public
+   */
+  close() {
+    S(this, ke) && clearTimeout(S(this, ke)), S(this, z) !== this.CLOSED && (S(this, de) && S(this, de).abort(), _(this, z, this.CLOSED), _(this, de, void 0));
+  }
+}
+z = /* @__PURE__ */ new WeakMap(), ye = /* @__PURE__ */ new WeakMap(), ve = /* @__PURE__ */ new WeakMap(), He = /* @__PURE__ */ new WeakMap(), Xe = /* @__PURE__ */ new WeakMap(), Le = /* @__PURE__ */ new WeakMap(), ke = /* @__PURE__ */ new WeakMap(), We = /* @__PURE__ */ new WeakMap(), de = /* @__PURE__ */ new WeakMap(), Oe = /* @__PURE__ */ new WeakMap(), Ce = /* @__PURE__ */ new WeakMap(), $e = /* @__PURE__ */ new WeakMap(), Ue = /* @__PURE__ */ new WeakMap(), Y = /* @__PURE__ */ new WeakSet(), /**
+* Connect to the given URL and start receiving events
+*
+* @internal
+*/
+yt = function() {
+  _(this, z, this.CONNECTING), _(this, de, new AbortController()), S(this, Xe)(S(this, ye), ae(this, Y, Gt).call(this)).then(S(this, bt)).catch(S(this, gt));
+}, bt = /* @__PURE__ */ new WeakMap(), gt = /* @__PURE__ */ new WeakMap(), /**
+* Get request options for the `fetch()` request
+*
+* @returns The request options
+* @internal
+*/
+Gt = function() {
+  var e;
+  const t = {
+    // [spec] Let `corsAttributeState` be `Anonymous`…
+    // [spec] …will have their mode set to "cors"…
+    mode: "cors",
+    redirect: "follow",
+    headers: { Accept: "text/event-stream", ...S(this, We) ? { "Last-Event-ID": S(this, We) } : void 0 },
+    cache: "no-store",
+    signal: (e = S(this, de)) == null ? void 0 : e.signal
+  };
+  return "window" in globalThis && (t.credentials = this.withCredentials ? "include" : "same-origin"), t;
+}, wt = /* @__PURE__ */ new WeakMap(), St = /* @__PURE__ */ new WeakMap(), /**
+* Handles the process referred to in the EventSource specification as "failing a connection".
+*
+* @param error - The error causing the connection to fail
+* @param code - The HTTP status code, if available
+* @internal
+*/
+De = function(e, t) {
+  var n;
+  S(this, z) !== this.CLOSED && _(this, z, this.CLOSED);
+  const i = new Jt("error", { code: t, message: e });
+  (n = S(this, Ce)) == null || n.call(this, i), this.dispatchEvent(i);
+}, /**
+* Schedules a reconnection attempt against the EventSource endpoint.
+*
+* @param message - The error causing the connection to fail
+* @param code - The HTTP status code, if available
+* @internal
+*/
+It = function(e, t) {
+  var n;
+  if (S(this, z) === this.CLOSED)
+    return;
+  _(this, z, this.CONNECTING);
+  const i = new Jt("error", { code: t, message: e });
+  (n = S(this, Ce)) == null || n.call(this, i), this.dispatchEvent(i), _(this, ke, setTimeout(S(this, vt), S(this, Le)));
+}, vt = /* @__PURE__ */ new WeakMap(), /**
+* ReadyState representing an EventSource currently trying to connect
+*
+* @public
+*/
+ee.CONNECTING = 0, /**
+* ReadyState representing an EventSource connection that is open (eg connected)
+*
+* @public
+*/
+ee.OPEN = 1, /**
+* ReadyState representing an EventSource connection that is closed (eg disconnected)
+*
+* @public
+*/
+ee.CLOSED = 2;
+function wi() {
+  const e = "document" in globalThis ? globalThis.document : void 0;
+  return e && typeof e == "object" && "baseURI" in e && typeof e.baseURI == "string" ? e.baseURI : void 0;
+}
+function Si(e, t, n, i) {
+  let s = null, r = !1;
+  const o = [], a = (f) => {
+    o.push(f), o.length > 100 && o.shift(), s && (s(), s = null);
+  };
+  e(a);
+  const u = () => (n(a), Promise.resolve({ done: !0, value: void 0 }));
+  return t(() => {
+    r = !0, s && s(), u();
+  }), {
+    next: async () => {
+      for (; ; ) {
+        if (i() === "closed" || r)
+          return u();
+        const f = o.shift();
+        if (f)
+          return { value: f, done: !1 };
+        await new Promise((p) => {
+          s = p;
+        });
+      }
+    },
+    return: u,
+    throw(f) {
+      return n(a), Promise.reject(f);
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+}
+function fe(e) {
+  switch (e.readyState) {
+    case e.CLOSED:
+      return "closed";
+    case e.CONNECTING:
+      return "connecting";
+    case e.OPEN:
+      return "open";
+    default:
+      return "connecting";
+  }
+}
+function Ii(e) {
+  let t = null;
+  return {
+    ...e,
+    text() {
+      return t || (t = e.text()), t;
+    },
+    json() {
+      return t || (t = e.text()), t.then((n) => JSON.parse(n));
+    }
+  };
+}
+function Ht(e) {
+  if (!e)
+    return;
+  const t = {};
+  for (const [n, i] of Object.entries(e))
+    t[n] = {
+      startCursor: i["start-cursor"],
+      endCursor: i["end-cursor"],
+      hasNextPage: i["has-next-page?"],
+      hasPreviousPage: i["has-previous-page?"]
+    };
+  return t;
+}
+function vi(e, t, n) {
+  let i, s = !1;
+  const r = Ee(), o = new ee(`${n.apiURI}/admin/subscribe-query?local_connection_id=${r}`, {
+    fetch(h, $) {
+      return i = null, fetch(h, {
+        ...$,
+        method: "POST",
+        headers: n.headers,
+        body: JSON.stringify({
+          query: e,
+          "inference?": n.inference,
+          versions: {
+            "@instantdb/admin": Re,
+            "@instantdb/core": Re
+          }
+        })
+      }).then((w) => (w.ok || (i = Ii(w)), w));
+    }
+  }), a = [], u = [], c = (h) => {
+    a.push(h);
+  }, l = (h) => {
+    a.splice(a.indexOf(h), 1);
+  }, f = (h) => {
+    u.push(h);
+  };
+  t && c(t);
+  let m = null;
+  function p(h) {
+    if (!s)
+      for (const $ of a)
+        try {
+          $(h);
+        } catch (w) {
+          console.error("Error in subscribeQuery callback", w);
+        }
+  }
+  function I(h) {
+    var $, w;
+    switch (h.op) {
+      case "sse-init": {
+        const O = h["machine-id"], ne = h["session-id"];
+        m = { machineId: O, sessionId: ne };
+        break;
+      }
+      case "add-query-ok": {
+        p({
+          type: "ok",
+          data: h.result,
+          pageInfo: Ht(($ = h["result-meta"]) == null ? void 0 : $["page-info"]),
+          sessionInfo: m
+        });
+        break;
+      }
+      case "refresh-ok": {
+        h.computations.length && p({
+          type: "ok",
+          data: h.computations[0]["instaql-result"],
+          pageInfo: Ht((w = h.computations[0]["result-meta"]) == null ? void 0 : w["page-info"]),
+          sessionInfo: m
+        });
+        break;
+      }
+      case "error": {
+        p({
+          type: "error",
+          error: new Se({ body: h, status: h.status }),
+          get readyState() {
+            return fe(o);
+          },
+          get isClosed() {
+            return fe(o) === "closed";
+          },
+          sessionInfo: m
+        });
+        break;
+      }
+    }
+  }
+  return o.onerror = (h) => {
+    if (i)
+      i.text().then(($) => {
+        let w = { type: void 0, message: $ };
+        try {
+          w = JSON.parse($);
+        } catch {
+        }
+        p({
+          type: "error",
+          error: new Se({
+            status: i.status,
+            body: w
+          }),
+          get readyState() {
+            return fe(o);
+          },
+          get isClosed() {
+            return fe(o) === "closed";
+          },
+          sessionInfo: m
+        });
+      });
+    else {
+      const $ = () => {
+        p({
+          type: "error",
+          error: new Se({
+            status: h.code || 500,
+            body: {
+              type: void 0,
+              message: h.message || "Unknown error in subscribe query."
+            }
+          }),
+          get readyState() {
+            return fe(o);
+          },
+          get isClosed() {
+            return fe(o) === "closed";
+          },
+          sessionInfo: m
+        });
+      };
+      if (o.readyState === ee.CLOSED) {
+        $();
+        return;
+      }
+      setTimeout(() => {
+        o.readyState !== ee.OPEN && $();
+      }, 5e3);
+    }
+  }, o.onmessage = (h) => {
+    I(JSON.parse(h.data));
+  }, {
+    close: () => {
+      s = !0;
+      for (const h of u)
+        try {
+          h();
+        } catch ($) {
+          console.error("Error in onClose callback", $);
+        }
+      o.close();
+    },
+    [Symbol.iterator]: () => {
+      throw new Error("subscribeQuery does not support synchronous iteration. Use `for await` instead.");
+    },
+    get sessionInfo() {
+      return m;
+    },
+    get readyState() {
+      return fe(o);
+    },
+    get isClosed() {
+      return fe(o) === "closed";
+    },
+    [Symbol.asyncIterator]: Si.bind(this, c, f, l, () => 1)
+  };
+}
+var ue = {};
+Object.defineProperty(ue, "__esModule", { value: !0 });
+var Oi = ue.parseCookie = yn;
+ue.parse = yn;
+ue.stringifyCookie = xi;
+ue.stringifySetCookie = nt;
+ue.serialize = nt;
+ue.parseSetCookie = Ti;
+ue.stringifySetCookie = nt;
+ue.serialize = nt;
+const pn = /^[\u0021-\u003A\u003C\u003E-\u007E]+$/, mn = /^[\u0021-\u003A\u003C-\u007E]*$/, $i = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i, ki = /^[\u0020-\u003A\u003D-\u007E]*$/, Ei = /^-?\d+$/, _i = Object.prototype.toString, Ci = /* @__PURE__ */ (() => {
+  const e = function() {
+  };
+  return e.prototype = /* @__PURE__ */ Object.create(null), e;
+})();
+function yn(e, t) {
+  const n = new Ci(), i = e.length;
+  if (i < 2)
+    return n;
+  const s = (t == null ? void 0 : t.decode) || bn;
+  let r = 0;
+  do {
+    const o = $t(e, r, i);
+    if (o === -1)
+      break;
+    const a = Ot(e, r, i);
+    if (o > a) {
+      r = e.lastIndexOf(";", o - 1) + 1;
+      continue;
+    }
+    const u = le(e, r, o);
+    n[u] === void 0 && (n[u] = s(le(e, o + 1, a))), r = a + 1;
+  } while (r < i);
+  return n;
+}
+function xi(e, t) {
+  const n = (t == null ? void 0 : t.encode) || encodeURIComponent, i = [];
+  for (const s of Object.keys(e)) {
+    const r = e[s];
+    if (r === void 0)
+      continue;
+    if (!pn.test(s))
+      throw new TypeError(`cookie name is invalid: ${s}`);
+    const o = n(r);
+    if (!mn.test(o))
+      throw new TypeError(`cookie val is invalid: ${r}`);
+    i.push(`${s}=${o}`);
+  }
+  return i.join("; ");
+}
+function nt(e, t, n) {
+  const i = typeof e == "object" ? e : { ...n, name: e, value: String(t) }, s = typeof t == "object" ? t : n, r = (s == null ? void 0 : s.encode) || encodeURIComponent;
+  if (!pn.test(i.name))
+    throw new TypeError(`argument name is invalid: ${i.name}`);
+  const o = i.value ? r(i.value) : "";
+  if (!mn.test(o))
+    throw new TypeError(`argument val is invalid: ${i.value}`);
+  let a = i.name + "=" + o;
+  if (i.maxAge !== void 0) {
+    if (!Number.isInteger(i.maxAge))
+      throw new TypeError(`option maxAge is invalid: ${i.maxAge}`);
+    a += "; Max-Age=" + i.maxAge;
+  }
+  if (i.domain) {
+    if (!$i.test(i.domain))
+      throw new TypeError(`option domain is invalid: ${i.domain}`);
+    a += "; Domain=" + i.domain;
+  }
+  if (i.path) {
+    if (!ki.test(i.path))
+      throw new TypeError(`option path is invalid: ${i.path}`);
+    a += "; Path=" + i.path;
+  }
+  if (i.expires) {
+    if (!Ri(i.expires) || !Number.isFinite(i.expires.valueOf()))
+      throw new TypeError(`option expires is invalid: ${i.expires}`);
+    a += "; Expires=" + i.expires.toUTCString();
+  }
+  if (i.httpOnly && (a += "; HttpOnly"), i.secure && (a += "; Secure"), i.partitioned && (a += "; Partitioned"), i.priority)
+    switch (typeof i.priority == "string" ? i.priority.toLowerCase() : void 0) {
+      case "low":
+        a += "; Priority=Low";
+        break;
+      case "medium":
+        a += "; Priority=Medium";
+        break;
+      case "high":
+        a += "; Priority=High";
+        break;
+      default:
+        throw new TypeError(`option priority is invalid: ${i.priority}`);
+    }
+  if (i.sameSite)
+    switch (typeof i.sameSite == "string" ? i.sameSite.toLowerCase() : i.sameSite) {
+      case !0:
+      case "strict":
+        a += "; SameSite=Strict";
+        break;
+      case "lax":
+        a += "; SameSite=Lax";
+        break;
+      case "none":
+        a += "; SameSite=None";
+        break;
+      default:
+        throw new TypeError(`option sameSite is invalid: ${i.sameSite}`);
+    }
+  return a;
+}
+function Ti(e, t) {
+  const n = (t == null ? void 0 : t.decode) || bn, i = e.length, s = Ot(e, 0, i), r = $t(e, 0, s), o = r === -1 ? { name: "", value: n(le(e, 0, s)) } : {
+    name: le(e, 0, r),
+    value: n(le(e, r + 1, s))
+  };
+  let a = s + 1;
+  for (; a < i; ) {
+    const u = Ot(e, a, i), c = $t(e, a, u), l = c === -1 ? le(e, a, u) : le(e, a, c), f = c === -1 ? void 0 : le(e, c + 1, u);
+    switch (l.toLowerCase()) {
+      case "httponly":
+        o.httpOnly = !0;
+        break;
+      case "secure":
+        o.secure = !0;
+        break;
+      case "partitioned":
+        o.partitioned = !0;
+        break;
+      case "domain":
+        o.domain = f;
+        break;
+      case "path":
+        o.path = f;
+        break;
+      case "max-age":
+        f && Ei.test(f) && (o.maxAge = Number(f));
+        break;
+      case "expires":
+        if (!f)
+          break;
+        const m = new Date(f);
+        Number.isFinite(m.valueOf()) && (o.expires = m);
+        break;
+      case "priority":
+        if (!f)
+          break;
+        const p = f.toLowerCase();
+        (p === "low" || p === "medium" || p === "high") && (o.priority = p);
+        break;
+      case "samesite":
+        if (!f)
+          break;
+        const I = f.toLowerCase();
+        (I === "lax" || I === "strict" || I === "none") && (o.sameSite = I);
+        break;
+    }
+    a = u + 1;
+  }
+  return o;
+}
+function Ot(e, t, n) {
+  const i = e.indexOf(";", t);
+  return i === -1 ? n : i;
+}
+function $t(e, t, n) {
+  const i = e.indexOf("=", t);
+  return i < n ? i : -1;
+}
+function le(e, t, n) {
+  let i = t, s = n;
+  do {
+    const r = e.charCodeAt(i);
+    if (r !== 32 && r !== 9)
+      break;
+  } while (++i < s);
+  for (; s > i; ) {
+    const r = e.charCodeAt(s - 1);
+    if (r !== 32 && r !== 9)
+      break;
+    s--;
+  }
+  return e.slice(i, s);
+}
+function bn(e) {
+  if (e.indexOf("%") === -1)
+    return e;
+  try {
+    return decodeURIComponent(e);
+  } catch {
+    return e;
+  }
+}
+function Ri(e) {
+  return _i.call(e) === "[object Date]";
+}
+function Ai(e) {
+  return { ...{
+    apiURI: "https://api.instantdb.com"
+  }, ...e };
+}
+function Pi(e, t) {
+  return "email" in t ? e["as-email"] = t.email : "token" in t ? e["as-token"] = t.token : "guest" in t && (e["as-guest"] = "true"), e;
+}
+function ji(e, t) {
+  if (!(t && ("token" in t || "guest" in t)) && !e.adminToken)
+    throw t && "email" in t ? new Error("Admin token required. To impersonate users with an email you must pass `adminToken` to `init`.") : new Error("Admin token required. To run this operation pass `adminToken` to `init`, or use `db.asUser`.");
+}
+function C(e, t) {
+  ji(e, t);
+  const { adminToken: n, appId: i } = e, s = {
+    "content-type": "application/json",
+    "app-id": i
+  };
+  return n && (s.authorization = `Bearer ${n}`), t ? Pi(s, t) : s;
+}
+function Mi() {
+  return (
+    // NextJS 13 onwards added a `__nextPatched` property to the fetch function
+    fetch.__nextPatched && // NextJS 15 onwards _also_ added a global `next-patch` symbol.
+    !globalThis[Symbol.for("next-patch")]
+  );
+}
+function Ui() {
+  return Mi() ? { cache: "no-store" } : {};
+}
+async function Di(e, t) {
+  const n = await t.text();
+  try {
+    const i = JSON.parse(n);
+    return e(new Se({ status: t.status, body: i }));
+  } catch {
+    return e(new Se({
+      status: t.status,
+      body: { type: void 0, message: n }
+    }));
+  }
+}
+async function R(e, t) {
+  const n = Ui(), i = {
+    ...(t == null ? void 0 : t.headers) || {},
+    "Instant-Admin-Version": Re,
+    "Instant-Core-Version": Re
+  }, s = await fetch(e, { ...n, ...t, headers: i });
+  if (s.status === 200) {
+    const r = await s.json();
+    return Promise.resolve(r);
+  }
+  return Di((r) => Promise.reject(r), s);
+}
+function Ni(e) {
+  var t, n, gn;
+  return t = class {
+    constructor(r) {
+      G(this, n);
+      d(this, "source");
+      d(this, "url");
+      this.url = r, this.source = H(this, n, gn).call(this, r);
+    }
+    get onopen() {
+      return this.source.onopen;
+    }
+    set onopen(r) {
+      this.source.onopen = r;
+    }
+    get onmessage() {
+      return this.source.onmessage;
+    }
+    set onmessage(r) {
+      this.source.onmessage = r;
+    }
+    get onerror() {
+      return this.source.onerror;
+    }
+    set onerror(r) {
+      this.source.onerror = r;
+    }
+    get readyState() {
+      return this.source.readyState;
+    }
+    close() {
+      this.source.close();
+    }
+  }, n = new WeakSet(), gn = function(r) {
+    return new ee(r, {
+      fetch(a, u) {
+        return fetch(a, {
+          ...u,
+          method: "POST",
+          headers: e.headers,
+          body: JSON.stringify({
+            "inference?": e.inference,
+            versions: {
+              "@instantdb/admin": Re,
+              "@instantdb/core": Re
+            }
+          })
+        });
+      }
+    });
+  }, d(t, "OPEN", ee.OPEN), d(t, "CONNECTING", ee.CONNECTING), d(t, "CLOSED", ee.CLOSED), t;
+}
+function Li(e) {
+  var n, i;
+  (!e.appId || !Te(e.appId)) && console.warn("warning: Instant Admin DB must be initialized with a valid appId. Received: " + JSON.stringify(e.appId));
+  const t = {
+    ...e,
+    appId: (n = e.appId) == null ? void 0 : n.trim(),
+    adminToken: (i = e.adminToken) == null ? void 0 : i.trim(),
+    useDateObjects: e.useDateObjects ?? !1
+  };
+  return new kt(t);
+}
+function Bt(e) {
+  return (Array.isArray(e) ? e : [e]).flatMap(Xn);
+}
+class Wi {
+  constructor(t) {
+    d(this, "config");
+    this.config = t;
+  }
+  async getPresence(t, n) {
+    return (await R(`${this.config.apiURI}/admin/rooms/presence?app_id=${this.config.appId}&room-type=${String(t)}&room-id=${n}`, {
+      method: "GET",
+      headers: C(this.config)
+    })).sessions || {};
+  }
+}
+class Fi {
+  constructor(t) {
+    d(this, "config");
+    /**
+     * Generates a magic code for the user with the given email.
+     * This is useful if you want to use your own email provider
+     * to send magic codes.
+     *
+     * @example
+     *   // Generate a magic code
+     *   const { code } = await db.auth.generateMagicCode({ email })
+     *   // Send the magic code to the user with your own email provider
+     *   await customEmailProvider.sendMagicCode(email, code)
+     *
+     * @see https://instantdb.com/docs/backend#custom-magic-codes
+     */
+    d(this, "generateMagicCode", async (t) => R(`${this.config.apiURI}/admin/magic_code?app_id=${this.config.appId}`, {
+      method: "POST",
+      headers: C(this.config),
+      body: JSON.stringify({ email: t })
+    }));
+    /**
+     * Sends a magic code to the user with the given email.
+     * This uses Instant's built-in email provider.
+     *
+     * @example
+     *   // Send an email to user with magic code
+     *   await db.auth.sendMagicCode({ email })
+     *
+     * @see https://instantdb.com/docs/backend#custom-magic-codes
+     */
+    d(this, "sendMagicCode", async (t) => R(`${this.config.apiURI}/admin/send_magic_code?app_id=${this.config.appId}`, {
+      method: "POST",
+      headers: C(this.config),
+      body: JSON.stringify({ email: t })
+    }));
+    /**
+     * Verifies a magic code for the user with the given email.
+     *
+     * @example
+     *   const user = await db.auth.verifyMagicCode({ email, code })
+     *   console.log("Verified user:", user)
+     *
+     * @see https://instantdb.com/docs/backend#custom-magic-codes
+     */
+    d(this, "verifyMagicCode", async (t, n) => {
+      const { user: i } = await R(`${this.config.apiURI}/admin/verify_magic_code?app_id=${this.config.appId}`, {
+        method: "POST",
+        headers: C(this.config),
+        body: JSON.stringify({ email: t, code: n })
+      });
+      return i;
+    });
+    /**
+     * Verifies a given token and returns the associated user.
+     *
+     * This is often useful for writing custom endpoints, where you need
+     * to authenticate users.
+     *
+     * @example
+     *   app.post('/custom_endpoint', async (req, res) => {
+     *     const user = await db.auth.verifyToken(req.headers['token'])
+     *     if (!user) {
+     *       return res.status(401).send('Uh oh, you are not authenticated')
+     *     }
+     *     // ...
+     *   })
+     * @see https://instantdb.com/docs/backend#custom-endpoints
+     */
+    d(this, "verifyToken", async (t) => (await R(`${this.config.apiURI}/runtime/auth/verify_refresh_token?app_id=${this.config.appId}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        "app-id": this.config.appId,
+        "refresh-token": t
+      })
+    })).user);
+    /**
+     * Retrieves an app user by id, email, or refresh token.
+     *
+     * @example
+     *   try {
+     *     const user = await db.auth.getUser({ email })
+     *     console.log("Found user:", user)
+     *   } catch (err) {
+     *     console.error("Failed to retrieve user:", err.message);
+     *   }
+     *
+     * @see https://instantdb.com/docs/backend#retrieve-a-user
+     */
+    d(this, "getUser", async (t) => {
+      const n = Object.entries(t).map(([s, r]) => `${s}=${encodeURIComponent(r)}`).join("&");
+      return (await R(`${this.config.apiURI}/admin/users?app_id=${this.config.appId}&${n}`, {
+        method: "GET",
+        headers: C(this.config)
+      })).user;
+    });
+    /**
+     * Deletes an app user by id, email, or refresh token.
+     *
+     * NB: This _only_ deletes the user; it does not delete all user data.
+     * You will need to handle this manually.
+     *
+     * @example
+     *   try {
+     *     const deletedUser = await db.auth.deleteUser({ email })
+     *     console.log("Deleted user:", deletedUser)
+     *   } catch (err) {
+     *     console.error("Failed to delete user:", err.message);
+     *   }
+     *
+     * @see https://instantdb.com/docs/backend#delete-a-user
+     */
+    d(this, "deleteUser", async (t) => {
+      const n = Object.entries(t).map(([s, r]) => `${s}=${r}`);
+      return (await R(`${this.config.apiURI}/admin/users?app_id=${this.config.appId}&${n}`, {
+        method: "DELETE",
+        headers: C(this.config)
+      })).deleted;
+    });
+    /**
+     * Get instant user from Request
+     *
+     * Reads cookies and gets a validated user
+     * @param req The request containing a cookie synced with createInstantRouteHandler
+     * @param opts Allow disabling validation of refresh token
+     */
+    d(this, "getUserFromRequest", async (t, n) => {
+      const i = t.headers.get("cookie") || "", s = Oi(i), r = "instant_user_" + this.config.appId;
+      if (!s[r])
+        return null;
+      const o = s[r], a = JSON.parse(o);
+      return a != null && a.refresh_token ? n != null && n.disableValidation ? a : await this.verifyToken(a.refresh_token) : null;
+    });
+    this.config = t, this.createToken = this.createToken.bind(this);
+  }
+  async createToken(t) {
+    const n = typeof t == "string" ? { email: t } : t;
+    return (await R(`${this.config.apiURI}/admin/refresh_tokens?app_id=${this.config.appId}`, {
+      method: "POST",
+      headers: C(this.config),
+      body: JSON.stringify(n)
+    })).user.refresh_token;
+  }
+  async signOut(t) {
+    const n = typeof t == "string" ? { email: t } : t, i = this.config;
+    await R(`${i.apiURI}/admin/sign_out?app_id=${this.config.appId}`, {
+      method: "POST",
+      headers: C(i),
+      body: JSON.stringify(n)
+    });
+  }
+}
+const qt = (e) => e && typeof e == "object" && typeof e.pipe == "function" && typeof e.read == "function", zi = (e) => e && typeof e.getReader == "function";
+class Kt {
+  constructor(t, n) {
+    d(this, "config");
+    d(this, "impersonationOpts");
+    /**
+     * Uploads file at the provided path. Accepts a Buffer or a Readable stream.
+     *
+     * @see https://instantdb.com/docs/storage
+     * @example
+     *   const buffer = fs.readFileSync('demo.png');
+     *   const isSuccess = await db.storage.uploadFile('photos/demo.png', buffer);
+     */
+    d(this, "uploadFile", async (t, n, i = {}) => {
+      const s = {
+        ...C(this.config, this.impersonationOpts),
+        path: t
+      };
+      i.contentDisposition && (s["content-disposition"] = i.contentDisposition), delete s["content-type"], i.contentType && (s["content-type"] = i.contentType);
+      let r;
+      if (qt(n) && (r = "half"), qt(n) || zi(n)) {
+        if (!i.fileSize)
+          throw new Error("fileSize is required in metadata when uploading streams");
+        s["content-length"] = i.fileSize.toString();
+      }
+      let o = {
+        method: "PUT",
+        headers: s,
+        body: n,
+        ...r && { duplex: r }
+      };
+      return R(`${this.config.apiURI}/admin/storage/upload?app_id=${this.config.appId}`, o);
+    });
+    /**
+     * Deletes a file by its path name (e.g. "photos/demo.png").
+     *
+     * @deprecated Use `db.transact` to delete files instead:
+     * @example
+     *   // Delete by id
+     *   await db.transact(db.tx.$files[fileId].delete());
+     *
+     *   // Delete by path
+     *   await db.transact(db.tx.$files[lookup('path', 'photos/demo.png')].delete());
+     *
+     * @see https://instantdb.com/docs/storage
+     */
+    d(this, "delete", async (t) => R(`${this.config.apiURI}/admin/storage/files?app_id=${this.config.appId}&filename=${encodeURIComponent(t)}`, {
+      method: "DELETE",
+      headers: C(this.config, this.impersonationOpts)
+    }));
+    /**
+     * Deletes multiple files by their path names.
+     *
+     * @deprecated Use `db.transact` to delete files instead:
+     * @example
+     *   // Delete multiple files by path
+     *   const paths = ['images/1.png', 'images/2.png', 'images/3.png'];
+     *   await db.transact(paths.map(p => db.tx.$files[lookup('path', p)].delete()));
+     *
+     * @see https://instantdb.com/docs/storage
+     */
+    d(this, "deleteMany", async (t) => R(`${this.config.apiURI}/admin/storage/files/delete?app_id=${this.config.appId}`, {
+      method: "POST",
+      headers: C(this.config, this.impersonationOpts),
+      body: JSON.stringify({ filenames: t })
+    }));
+    /**
+     * @deprecated. This method will be removed in the future. Use `uploadFile`
+     * instead
+     */
+    d(this, "upload", async (t, n, i = {}) => {
+      const { data: s } = await R(`${this.config.apiURI}/admin/storage/signed-upload-url?app_id=${this.config.appId}`, {
+        method: "POST",
+        headers: C(this.config),
+        body: JSON.stringify({
+          app_id: this.config.appId,
+          filename: t
+        })
+      }), r = {}, o = i.contentType;
+      o && (r["Content-Type"] = o);
+      const { ok: a } = await fetch(s, {
+        method: "PUT",
+        body: n,
+        headers: r
+      });
+      return a;
+    });
+    /**
+     * @deprecated. This method will be removed in the future. Use `query` instead
+     * @example
+     * const files = await db.query({ $files: {}})
+     */
+    d(this, "list", async () => {
+      const { data: t } = await R(`${this.config.apiURI}/admin/storage/files?app_id=${this.config.appId}`, {
+        method: "GET",
+        headers: C(this.config)
+      });
+      return t;
+    });
+    /**
+     * @deprecated. getDownloadUrl will be removed in the future.
+     * Use `query` instead to query and fetch for valid urls
+     *
+     * db.useQuery({
+     *   $files: {
+     *     $: {
+     *       where: {
+     *         path: "moop.png"
+     *       }
+     *     }
+     *   }
+     * })
+     */
+    d(this, "getDownloadUrl", async (t) => {
+      const { data: n } = await R(`${this.config.apiURI}/admin/storage/signed-download-url?app_id=${this.config.appId}&filename=${encodeURIComponent(t)}`, {
+        method: "GET",
+        headers: C(this.config)
+      });
+      return n;
+    });
+    this.config = t, this.impersonationOpts = n;
+  }
+}
+var xe;
+class Vi {
+  constructor(t) {
+    G(this, xe);
+    /**
+     * Creates a new ReadableStream for the given clientId.
+     *
+     * @example
+     *   const stream = db.streams.createReadStream({clientId: clientId})
+     *   for await (const chunk of stream) {
+     *     console.log(chunk);
+     *   }
+     */
+    d(this, "createReadStream", (t) => b(this, xe).call(this).createReadStream(t));
+    /**
+     * Creates a new WritableStream for the given clientId.
+     *
+     * @example
+     *   const writeStream = db.streams.createWriteStream({clientId: clientId})
+     *   const writer = writeStream.getWriter();
+     *   writer.write('Hello world');
+     *   writer.close();
+     */
+    d(this, "createWriteStream", (t) => b(this, xe).call(this).createWriteStream(t));
+    oe(this, xe, t);
+  }
+}
+xe = new WeakMap();
+function Ji(e) {
+  return {
+    info: e ? (...t) => console.info(...t) : () => {
+    },
+    debug: e ? (...t) => console.debug(...t) : () => {
+    },
+    error: e ? (...t) => console.error(...t) : () => {
+    }
+  };
+}
+var U, ge, N, L, A, wn, Be, Sn, In, vn, Ye, Ze, et, Et, On, tt;
+const At = class At {
+  constructor(t) {
+    G(this, A);
+    d(this, "config");
+    d(this, "auth");
+    d(this, "storage");
+    d(this, "streams");
+    d(this, "rooms");
+    d(this, "impersonationOpts");
+    G(this, U, null);
+    G(this, ge, 0);
+    G(this, N, null);
+    G(this, L);
+    d(this, "tx", an());
+    /**
+     * Sometimes you want to scope queries to a specific user.
+     *
+     * You can provide a user's auth token, email, or impersonate a guest.
+     *
+     * @see https://instantdb.com/docs/backend#impersonating-users
+     * @example
+     *  await db.asUser({email: "stopa@instantdb.com"}).query({ goals: {} })
+     */
+    d(this, "asUser", (t) => {
+      const n = new At({
+        ...this.config
+      });
+      return n.impersonationOpts = t, n.storage = new Kt(this.config, t), n;
+    });
+    /**
+     * Use this to query your data!
+     *
+     * @see https://instantdb.com/docs/instaql
+     *
+     * @example
+     *  // fetch all goals
+     *  await db.query({ goals: {} })
+     *
+     *  // goals where the title is "Get Fit"
+     *  await db.query({ goals: { $: { where: { title: "Get Fit" } } } })
+     *
+     *  // all goals, _alongside_ their todos
+     *  await db.query({ goals: { todos: {} } })
+     */
+    d(this, "query", (t, n = {}) => {
+      t && n && "ruleParams" in n && (t = { $$ruleParams: n.ruleParams, ...t }), this.config.disableValidation || Lt(t, this.config.schema);
+      const i = n.fetchOpts || {}, s = i.headers || {};
+      return R(`${this.config.apiURI}/admin/query?app_id=${this.config.appId}`, {
+        ...i,
+        method: "POST",
+        headers: {
+          ...s,
+          ...C(this.config, this.impersonationOpts)
+        },
+        body: JSON.stringify({
+          query: t,
+          "inference?": !!this.config.schema
+        })
+      });
+    });
+    /**
+     * Use this to write data! You can create, update, delete, and link objects
+     *
+     * @see https://instantdb.com/docs/instaml
+     *
+     * @example
+     *   // Create a new object in the `goals` namespace
+     *   const goalId = id();
+     *   db.transact(db.tx.goals[goalId].update({title: "Get fit"}))
+     *
+     *   // Update the title
+     *   db.transact(db.tx.goals[goalId].update({title: "Get super fit"}))
+     *
+     *   // Delete it
+     *   db.transact(db.tx.goals[goalId].delete())
+     *
+     *   // Or create an association:
+     *   todoId = id();
+     *   db.transact([
+     *    db.tx.todos[todoId].update({ title: 'Go on a run' }),
+     *    db.tx.goals[goalId].link({todos: todoId}),
+     *  ])
+     */
+    d(this, "transact", (t) => (this.config.disableValidation || oi(t, this.config.schema), R(`${this.config.apiURI}/admin/transact?app_id=${this.config.appId}`, {
+      method: "POST",
+      headers: C(this.config, this.impersonationOpts),
+      body: JSON.stringify({
+        steps: Bt(t),
+        "throw-on-missing-attrs?": !!this.config.schema
+      })
+    })));
+    /**
+     * Like `query`, but returns debugging information
+     * for permissions checks along with the result.
+     * Useful for inspecting the values returned by the permissions checks.
+     * Note, this will return debug information for *all* entities
+     * that match the query's `where` clauses.
+     *
+     * Requires a user/guest context to be set with `asUser`,
+     * since permissions checks are user-specific.
+     *
+     * Accepts an optional configuration object with a `rules` key.
+     * The provided rules will override the rules in the database for the query.
+     *
+     * @see https://instantdb.com/docs/instaql
+     *
+     * @example
+     *  await db.asUser({ guest: true }).debugQuery(
+     *    { goals: {} },
+     *    { rules: { goals: { allow: { read: "auth.id != null" } } }
+     *  )
+     */
+    d(this, "debugQuery", async (t, n) => {
+      t && n && "ruleParams" in n && (t = { $$ruleParams: n.ruleParams, ...t });
+      const i = { query: t, "rules-override": n == null ? void 0 : n.rules };
+      n != null && n.ip && (i["ip-override"] = n.ip), n != null && n.origin && (i["origin-override"] = n.origin);
+      const s = await R(`${this.config.apiURI}/admin/query_perms_check?app_id=${this.config.appId}`, {
+        method: "POST",
+        headers: C(this.config, this.impersonationOpts),
+        body: JSON.stringify(i)
+      });
+      return {
+        result: s.result,
+        checkResults: s["check-results"]
+      };
+    });
+    /**
+     * Like `transact`, but does not write to the database.
+     * Returns debugging information for permissions checks.
+     * Useful for inspecting the values returned by the permissions checks.
+     *
+     * Requires a user/guest context to be set with `asUser`,
+     * since permissions checks are user-specific.
+     *
+     * Accepts an optional configuration object with a `rules` key.
+     * The provided rules will override the rules in the database for the duration of the transaction.
+     *
+     * @example
+     *   const goalId = id();
+     *   db.asUser({ guest: true }).debugTransact(
+     *      [db.tx.goals[goalId].update({title: "Get fit"})],
+     *      { rules: { goals: { allow: { update: "auth.id != null" } } }
+     *   )
+     */
+    d(this, "debugTransact", (t, n) => {
+      const i = {
+        steps: Bt(t),
+        "rules-override": n == null ? void 0 : n.rules,
+        // @ts-expect-error because we're using a private API (for now)
+        "dangerously-commit-tx": n == null ? void 0 : n.__dangerouslyCommit
+      };
+      return n != null && n.ip && (i["ip-override"] = n.ip), n != null && n.origin && (i["origin-override"] = n.origin), R(`${this.config.apiURI}/admin/transact_perms_check?app_id=${this.config.appId}`, {
+        method: "POST",
+        headers: C(this.config, this.impersonationOpts),
+        body: JSON.stringify(i)
+      });
+    });
+    G(this, Ye, (t) => {
+      var n;
+      if (t.target !== b(this, U)) {
+        b(this, L).info("[socket][open]", t.target.id, "skip; this is no longer the current transport");
+        return;
+      }
+      b(this, L).info("[socket][open]", t.target.id), oe(this, ge, 0), (n = b(this, N)) == null || n.onConnectionStatusChange("authenticated");
+    });
+    G(this, Ze, (t) => {
+      var n;
+      if (t.target !== b(this, U)) {
+        b(this, L).info("[socket][close]", t.target.id, "skip; this is no longer the current transport");
+        return;
+      }
+      b(this, L).info("[socket][close]", t.target.id), (n = b(this, N)) == null || n.onConnectionStatusChange("closed"), b(this, U) && (oe(this, U, null), H(this, A, Et).call(this) || (setTimeout(() => H(this, A, Be).call(this), b(this, ge)), oe(this, ge, Math.min(15e3, Math.max(b(this, ge), 500) * 2))));
+    });
+    G(this, et, (t) => {
+      var n;
+      if (t.target !== b(this, U)) {
+        b(this, L).info("[socket][error]", t.target.id, "skip; this is no longer the current transport");
+        return;
+      }
+      b(this, L).info("[socket][error]", t.target.id), (n = b(this, N)) == null || n.onConnectionStatusChange("closed");
+    });
+    G(this, tt, (t) => {
+      var i, s, r, o, a, u;
+      if (t.target !== b(this, U)) {
+        b(this, L).info("[socket][message]", t.target.id, "skip; this is no longer the current transport");
+        return;
+      }
+      const n = t.message;
+      switch (b(this, L).info("[receive]", n), n.op) {
+        case "start-stream-ok": {
+          (i = b(this, N)) == null || i.onStartStreamOk(n);
+          break;
+        }
+        case "stream-flushed": {
+          (s = b(this, N)) == null || s.onStreamFlushed(n);
+          break;
+        }
+        case "append-failed": {
+          (r = b(this, N)) == null || r.onAppendFailed(n);
+          break;
+        }
+        case "stream-append": {
+          (o = b(this, N)) == null || o.onStreamAppend(n);
+          break;
+        }
+        case "error": {
+          switch ((a = n["original-event"]) == null ? void 0 : a.op) {
+            case "start-stream":
+            case "append-stream":
+            case "subscribe-stream":
+            case "unsubscribe-stream": {
+              (u = b(this, N)) == null || u.onRecieveError(n);
+              break;
+            }
+          }
+          break;
+        }
+      }
+      H(this, A, On).call(this);
+    });
+    this.config = Ai(t), this.auth = new Fi(this.config), this.storage = new Kt(this.config, this.impersonationOpts), this.streams = new Vi(H(this, A, vn).bind(this)), this.rooms = new Wi(this.config), oe(this, L, Ji(!!this.config.verbose));
+  }
+  /**
+   * Use this to to get a live view of your data!
+   *
+   * @see https://www.instantdb.com/docs/backend
+   *
+   * @example
+   *  // create a subscription to a query
+   *  const query = { goals: { $: { where: { title: "Get Fit" } } } }
+   *  const sub = db.subscribeQuery(query);
+   *
+   *  // iterate through the results with an async iterator
+   *  for await (const payload of sub) {
+   *    if (payload.error) {
+   *      console.log(payload.error);
+   *      // Stop the subscription
+   *      sub.close();
+   *    } else {
+   *      console.log(payload.data);
+   *    }
+   *  }
+   *
+   *  // Stop the subscription
+   *  sub.close();
+   *
+   *  // Create a subscription with a callback
+   *  const sub = db.subscribeQuery(query, (payload) => {
+   *    if (payload.error) {
+   *      console.log(payload.error);
+   *      // Stop the subscription
+   *      sub.close();
+   *    } else {
+   *      console.log(payload.data);
+   *    }
+   *  });
+   */
+  subscribeQuery(t, n, i = {}) {
+    t && i && "ruleParams" in i && (t = { $$ruleParams: i.ruleParams, ...t }), this.config.disableValidation || Lt(t, this.config.schema);
+    const o = {
+      ...(i.fetchOpts || {}).headers || {},
+      ...C(this.config, this.impersonationOpts)
+    }, a = !!this.config.schema;
+    return vi(t, n, {
+      headers: o,
+      inference: a,
+      apiURI: this.config.apiURI
+    });
+  }
+};
+U = new WeakMap(), ge = new WeakMap(), N = new WeakMap(), L = new WeakMap(), A = new WeakSet(), wn = function() {
+  b(this, U) && b(this, U).close();
+  const t = {
+    ...C(this.config, this.impersonationOpts)
+  }, n = !!this.config.schema, i = Ni({ headers: t, inference: n }), s = new ci(i, `${this.config.apiURI}/admin/sse?app_id=${this.config.appId}`, `${this.config.apiURI}/admin/sse/push?app_id=${this.config.appId}`);
+  return s.onopen = b(this, Ye), s.onmessage = b(this, tt), s.onclose = b(this, Ze), s.onerror = b(this, et), oe(this, U, s), s;
+}, Be = function() {
+  return b(this, U) || H(this, A, wn).call(this);
+}, Sn = function(t, n) {
+  const i = H(this, A, Be).call(this);
+  b(this, L).info("[send]", t, n, {
+    isOpen: i.isOpen()
+  }), i.isOpen() && i.send({ "client-event-id": t, ...n });
+}, In = function() {
+  H(this, A, Be).call(this);
+  const t = new di({
+    WStream: this.config.WritableStream || WritableStream,
+    RStream: this.config.ReadableStream || ReadableStream,
+    trySend: (n, i) => {
+      H(this, A, Sn).call(this, n, i);
+    },
+    log: b(this, L)
+  });
+  return oe(this, N, t), t;
+}, vn = function() {
+  return b(this, N) || H(this, A, In).call(this);
+}, Ye = new WeakMap(), Ze = new WeakMap(), et = new WeakMap(), Et = function() {
+  return !b(this, N) || !b(this, N).hasActiveStreams();
+}, On = function() {
+  if (b(this, U) && H(this, A, Et).call(this)) {
+    const t = b(this, U);
+    b(this, L).info("cleaning up unused socket", t.id), oe(this, U, null), t.close();
+  }
+}, tt = new WeakMap();
+let kt = At;
+var ft = {};
+function Ve(e) {
+  let t = e;
+  return new TransformStream({
+    transform(n, i) {
+      if (!t) {
+        i.enqueue(n);
+        return;
+      }
+      if (t > n.length) {
+        t += n.length;
+        return;
+      }
+      const s = n.slice(t);
+      t = 0, i.enqueue(s);
+    }
+  });
+}
+function Bi(e) {
+  const t = e.appId || ft.INSTANT_APP_ID;
+  if (!t)
+    throw new Error(
+      "Missing appId. Pass it as an argument to createResumableStreamContext or set the INSTANT_APP_ID environment variable."
+    );
+  const n = e.adminToken || ft.INSTANT_APP_ADMIN_TOKEN;
+  if (!t)
+    throw new Error(
+      "Missing adminToken. Pass it as an argument to createResumableStreamContext or set the INSTANT_APP_ADMIN_TOKEN environment variable."
+    );
+  const i = e.apiURI || ft.INSTANT_API_URI, s = Li({
+    appId: t,
+    adminToken: n,
+    apiURI: i
+  });
+  async function r(c, l, f) {
+    const m = s.streams.createWriteStream({
+      clientId: c,
+      waitUntil: e.waitUntil ?? void 0
+    });
+    try {
+      const p = await m.streamId();
+      l().pipeTo(m);
+      const g = s.streams.createReadStream({ streamId: p });
+      return f ? g.pipeThrough(
+        Ve(f)
+      ) : g;
+    } catch {
+      const I = s.streams.createReadStream({ clientId: c });
+      return f ? I.pipeThrough(
+        Ve(f)
+      ) : I;
+    }
+  }
+  async function o(c, l) {
+    const f = s.streams.createReadStream({ clientId: c });
+    return l ? f.pipeThrough(Ve(l)) : f;
+  }
+  async function a(c, l, f) {
+    const m = l(), p = s.streams.createWriteStream({
+      clientId: c,
+      waitUntil: e.waitUntil ?? void 0
+    });
+    await p.streamId(), m.pipeTo(p);
+    const I = s.streams.createReadStream({ clientId: c });
+    return f ? I.pipeThrough(Ve(f)) : I;
+  }
+  async function u(c) {
+    var m;
+    const l = await s.query({
+      $streams: { $: { where: { clientId: c } } }
+    }), f = (m = l == null ? void 0 : l.$streams) == null ? void 0 : m[0];
+    return f != null && f.done ? "DONE" : f ? !0 : null;
+  }
+  return {
+    resumableStream: r,
+    resumeExistingStream: o,
+    createNewResumableStream: a,
+    hasExistingStream: u
+  };
+}
+export {
+  Bi as createResumableStreamContext
+};