convex-cms 0.0.9-alpha.5 → 0.0.9-alpha.6

package/admin-dist/server/_libs/convex.mjs

@@ -347,7 +347,7 @@ function convexToJsonInternal(value, originalValue, context, includeTopLevelUnde
   }
   if (Array.isArray(value)) {
     return value.map(
-      (value2, i) => convexToJsonInternal(value2, originalValue, context + `[${i}]`)
+      (value2, i) => convexToJsonInternal(value2, originalValue, context + `[${i}]`, false)
     );
   }
   if (value instanceof Set) {
@@ -373,7 +373,14 @@ function convexToJsonInternal(value, originalValue, context, includeTopLevelUnde
   for (const [k, v2] of entries) {
     if (v2 !== void 0) {
       validateObjectField(k);
-      out[k] = convexToJsonInternal(v2, originalValue, context + `.${k}`);
+      out[k] = convexToJsonInternal(v2, originalValue, context + `.${k}`, false);
+    } else if (includeTopLevelUndefined) {
+      validateObjectField(k);
+      out[k] = convexOrUndefinedToJsonInternal(
+        v2,
+        originalValue,
+        context + `.${k}`
+      );
     }
   }
   return out;
@@ -391,12 +398,32 @@ function errorMessageForUnsupportedType(context, typeName, value, originalValue)
     )} is not a supported Convex type.`;
   }
 }
+function convexOrUndefinedToJsonInternal(value, originalValue, context) {
+  if (value === void 0) {
+    return { $undefined: null };
+  } else {
+    if (originalValue === void 0) {
+      throw new Error(
+        `Programming error. Current value is ${stringifyValueForError(
+          value
+        )} but original value is undefined`
+      );
+    }
+    return convexToJsonInternal(value, originalValue, context, false);
+  }
+}
 function convexToJson(value) {
-  return convexToJsonInternal(value, value, "");
+  return convexToJsonInternal(value, value, "", false);
 }
-var __defProp$d = Object.defineProperty;
-var __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$d = (obj, key, value) => __defNormalProp$d(obj, typeof key !== "symbol" ? key + "" : key, value);
+function convexOrUndefinedToJson(value) {
+  return convexOrUndefinedToJsonInternal(value, value, "");
+}
+function patchValueToJson(value) {
+  return convexToJsonInternal(value, value, "", true);
+}
+var __defProp$l = Object.defineProperty;
+var __defNormalProp$l = (obj, key, value) => key in obj ? __defProp$l(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$l = (obj, key, value) => __defNormalProp$l(obj, typeof key !== "symbol" ? key + "" : key, value);
 const UNDEFINED_VALIDATOR_ERROR_URL = "https://docs.convex.dev/error#undefined-validator";
 function throwUndefinedValidatorError(context, fieldName) {
   const fieldInfo = fieldName !== void 0 ? ` for field "${fieldName}"` : "";
@@ -406,10 +433,10 @@ function throwUndefinedValidatorError(context, fieldName) {
 }
 class BaseValidator {
   constructor({ isOptional }) {
-    __publicField$d(this, "type");
-    __publicField$d(this, "fieldPaths");
-    __publicField$d(this, "isOptional");
-    __publicField$d(this, "isConvexValidator");
+    __publicField$l(this, "type");
+    __publicField$l(this, "fieldPaths");
+    __publicField$l(this, "isOptional");
+    __publicField$l(this, "isConvexValidator");
     this.isOptional = isOptional;
     this.isConvexValidator = true;
   }
@@ -423,8 +450,8 @@ class VId extends BaseValidator {
     tableName
   }) {
     super({ isOptional });
-    __publicField$d(this, "tableName");
-    __publicField$d(this, "kind", "id");
+    __publicField$l(this, "tableName");
+    __publicField$l(this, "kind", "id");
     if (typeof tableName !== "string") {
       throw new Error("v.id(tableName) requires a string");
     }
@@ -445,7 +472,7 @@ class VId extends BaseValidator {
 class VFloat64 extends BaseValidator {
   constructor() {
     super(...arguments);
-    __publicField$d(this, "kind", "float64");
+    __publicField$l(this, "kind", "float64");
   }
   /** @internal */
   get json() {
@@ -461,7 +488,7 @@ class VFloat64 extends BaseValidator {
 class VInt64 extends BaseValidator {
   constructor() {
     super(...arguments);
-    __publicField$d(this, "kind", "int64");
+    __publicField$l(this, "kind", "int64");
   }
   /** @internal */
   get json() {
@@ -475,7 +502,7 @@ class VInt64 extends BaseValidator {
 class VBoolean extends BaseValidator {
   constructor() {
     super(...arguments);
-    __publicField$d(this, "kind", "boolean");
+    __publicField$l(this, "kind", "boolean");
   }
   /** @internal */
   get json() {
@@ -491,7 +518,7 @@ class VBoolean extends BaseValidator {
 class VBytes extends BaseValidator {
   constructor() {
     super(...arguments);
-    __publicField$d(this, "kind", "bytes");
+    __publicField$l(this, "kind", "bytes");
   }
   /** @internal */
   get json() {
@@ -505,7 +532,7 @@ class VBytes extends BaseValidator {
 class VString extends BaseValidator {
   constructor() {
     super(...arguments);
-    __publicField$d(this, "kind", "string");
+    __publicField$l(this, "kind", "string");
   }
   /** @internal */
   get json() {
@@ -521,7 +548,7 @@ class VString extends BaseValidator {
 class VNull extends BaseValidator {
   constructor() {
     super(...arguments);
-    __publicField$d(this, "kind", "null");
+    __publicField$l(this, "kind", "null");
   }
   /** @internal */
   get json() {
@@ -535,7 +562,7 @@ class VNull extends BaseValidator {
 class VAny extends BaseValidator {
   constructor() {
     super(...arguments);
-    __publicField$d(this, "kind", "any");
+    __publicField$l(this, "kind", "any");
   }
   /** @internal */
   get json() {
@@ -559,8 +586,8 @@ class VObject extends BaseValidator {
     fields
   }) {
     super({ isOptional });
-    __publicField$d(this, "fields");
-    __publicField$d(this, "kind", "object");
+    __publicField$l(this, "fields");
+    __publicField$l(this, "kind", "object");
     globalThis.Object.entries(fields).forEach(([fieldName, validator]) => {
       if (validator === void 0) {
         throwUndefinedValidatorError("v.object()", fieldName);
@@ -651,8 +678,8 @@ class VLiteral extends BaseValidator {
    */
   constructor({ isOptional, value }) {
     super({ isOptional });
-    __publicField$d(this, "value");
-    __publicField$d(this, "kind", "literal");
+    __publicField$l(this, "value");
+    __publicField$l(this, "kind", "literal");
     if (typeof value !== "string" && typeof value !== "boolean" && typeof value !== "number" && typeof value !== "bigint") {
       throw new Error("v.literal(value) must be a string, number, or boolean");
     }
@@ -682,8 +709,8 @@ class VArray extends BaseValidator {
     element
   }) {
     super({ isOptional });
-    __publicField$d(this, "element");
-    __publicField$d(this, "kind", "array");
+    __publicField$l(this, "element");
+    __publicField$l(this, "kind", "array");
     if (element === void 0) {
       throwUndefinedValidatorError("v.array()");
     }
@@ -714,9 +741,9 @@ class VRecord extends BaseValidator {
     value
   }) {
     super({ isOptional });
-    __publicField$d(this, "key");
-    __publicField$d(this, "value");
-    __publicField$d(this, "kind", "record");
+    __publicField$l(this, "key");
+    __publicField$l(this, "value");
+    __publicField$l(this, "kind", "record");
     if (key === void 0) {
       throwUndefinedValidatorError("v.record()", "key");
     }
@@ -762,8 +789,8 @@ class VUnion extends BaseValidator {
    */
   constructor({ isOptional, members }) {
     super({ isOptional });
-    __publicField$d(this, "members");
-    __publicField$d(this, "kind", "union");
+    __publicField$l(this, "members");
+    __publicField$l(this, "kind", "union");
     members.forEach((member, index) => {
       if (member === void 0) {
         throwUndefinedValidatorError("v.union()", `member at index ${index}`);
@@ -789,6 +816,16 @@ class VUnion extends BaseValidator {
     });
   }
 }
+function isValidator(v2) {
+  return !!v2.isConvexValidator;
+}
+function asObjectValidator(obj) {
+  if (isValidator(obj)) {
+    return obj;
+  } else {
+    return v.object(obj);
+  }
+}
 const v = {
   /**
    * Validates that the value corresponds to an ID of a document in given table.
@@ -920,24 +957,24 @@ const v = {
     return v.union(value, v.null());
   }
 };
-var __defProp$c = Object.defineProperty;
-var __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$c = (obj, key, value) => __defNormalProp$c(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$k = Object.defineProperty;
+var __defNormalProp$k = (obj, key, value) => key in obj ? __defProp$k(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$k = (obj, key, value) => __defNormalProp$k(obj, typeof key !== "symbol" ? key + "" : key, value);
 var _a, _b;
 const IDENTIFYING_FIELD = /* @__PURE__ */ Symbol.for("ConvexError");
 class ConvexError extends (_b = Error, _a = IDENTIFYING_FIELD, _b) {
   constructor(data) {
     super(typeof data === "string" ? data : stringifyValueForError(data));
-    __publicField$c(this, "name", "ConvexError");
-    __publicField$c(this, "data");
-    __publicField$c(this, _a, true);
+    __publicField$k(this, "name", "ConvexError");
+    __publicField$k(this, "data");
+    __publicField$k(this, _a, true);
     this.data = data;
   }
 }
 const version = "1.31.6";
-var __defProp$b = Object.defineProperty;
-var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$b = (obj, key, value) => __defNormalProp$b(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$j = Object.defineProperty;
+var __defNormalProp$j = (obj, key, value) => key in obj ? __defProp$j(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$j = (obj, key, value) => __defNormalProp$j(obj, typeof key !== "symbol" ? key + "" : key, value);
 const INFO_COLOR = "color:rgb(0, 145, 255)";
 function prefix_for_source(source) {
   switch (source) {
@@ -953,8 +990,8 @@ function prefix_for_source(source) {
 }
 class DefaultLogger {
   constructor(options) {
-    __publicField$b(this, "_onLogLineFuncs");
-    __publicField$b(this, "_verbose");
+    __publicField$j(this, "_onLogLineFuncs");
+    __publicField$j(this, "_verbose");
     this._onLogLineFuncs = {};
     this._verbose = options.verbose;
   }
@@ -1086,21 +1123,21 @@ function serializePaginatedPathAndArgs(udfPath, args, options) {
   });
   return result;
 }
-var __defProp$a = Object.defineProperty;
-var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$a = (obj, key, value) => __defNormalProp$a(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$i = Object.defineProperty;
+var __defNormalProp$i = (obj, key, value) => key in obj ? __defProp$i(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$i = (obj, key, value) => __defNormalProp$i(obj, typeof key !== "symbol" ? key + "" : key, value);
 class LocalSyncState {
   constructor() {
-    __publicField$a(this, "nextQueryId");
-    __publicField$a(this, "querySetVersion");
-    __publicField$a(this, "querySet");
-    __publicField$a(this, "queryIdToToken");
-    __publicField$a(this, "identityVersion");
-    __publicField$a(this, "auth");
-    __publicField$a(this, "outstandingQueriesOlderThanRestart");
-    __publicField$a(this, "outstandingAuthOlderThanRestart");
-    __publicField$a(this, "paused");
-    __publicField$a(this, "pendingQuerySetModifications");
+    __publicField$i(this, "nextQueryId");
+    __publicField$i(this, "querySetVersion");
+    __publicField$i(this, "querySet");
+    __publicField$i(this, "queryIdToToken");
+    __publicField$i(this, "identityVersion");
+    __publicField$i(this, "auth");
+    __publicField$i(this, "outstandingQueriesOlderThanRestart");
+    __publicField$i(this, "outstandingAuthOlderThanRestart");
+    __publicField$i(this, "paused");
+    __publicField$i(this, "pendingQuerySetModifications");
     this.nextQueryId = 0;
     this.querySetVersion = 0;
     this.identityVersion = 0;
@@ -1374,17 +1411,17 @@ class LocalSyncState {
     }
   }
 }
-var __defProp$9 = Object.defineProperty;
-var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$9 = (obj, key, value) => __defNormalProp$9(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$h = Object.defineProperty;
+var __defNormalProp$h = (obj, key, value) => key in obj ? __defProp$h(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$h = (obj, key, value) => __defNormalProp$h(obj, typeof key !== "symbol" ? key + "" : key, value);
 class RequestManager {
   constructor(logger, markConnectionStateDirty) {
     this.logger = logger;
     this.markConnectionStateDirty = markConnectionStateDirty;
-    __publicField$9(this, "inflightRequests");
-    __publicField$9(this, "requestsOlderThanRestart");
-    __publicField$9(this, "inflightMutationsCount", 0);
-    __publicField$9(this, "inflightActionsCount", 0);
+    __publicField$h(this, "inflightRequests");
+    __publicField$h(this, "requestsOlderThanRestart");
+    __publicField$h(this, "inflightMutationsCount", 0);
+    __publicField$h(this, "inflightActionsCount", 0);
     this.inflightRequests = /* @__PURE__ */ new Map();
     this.requestsOlderThanRestart = /* @__PURE__ */ new Set();
   }
@@ -1662,13 +1699,13 @@ function createApi(pathParts = []) {
   return new Proxy({}, handler);
 }
 const anyApi = createApi();
-var __defProp$8 = Object.defineProperty;
-var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$8 = (obj, key, value) => __defNormalProp$8(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$g = Object.defineProperty;
+var __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$g = (obj, key, value) => __defNormalProp$g(obj, typeof key !== "symbol" ? key + "" : key, value);
 class OptimisticLocalStoreImpl {
   constructor(queryResults) {
-    __publicField$8(this, "queryResults");
-    __publicField$8(this, "modifiedQueries");
+    __publicField$g(this, "queryResults");
+    __publicField$g(this, "modifiedQueries");
     this.queryResults = queryResults;
     this.modifiedQueries = [];
   }
@@ -1731,8 +1768,8 @@ class OptimisticLocalStoreImpl {
 }
 class OptimisticQueryResults {
   constructor() {
-    __publicField$8(this, "queryResults");
-    __publicField$8(this, "optimisticUpdates");
+    __publicField$g(this, "queryResults");
+    __publicField$g(this, "optimisticUpdates");
     this.queryResults = /* @__PURE__ */ new Map();
     this.optimisticUpdates = [];
   }
@@ -1815,14 +1852,14 @@ class OptimisticQueryResults {
     return query?.result?.logLines;
   }
 }
-var __defProp$7 = Object.defineProperty;
-var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$7 = (obj, key, value) => __defNormalProp$7(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$f = Object.defineProperty;
+var __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$f = (obj, key, value) => __defNormalProp$f(obj, typeof key !== "symbol" ? key + "" : key, value);
 class Long {
   constructor(low, high) {
-    __publicField$7(this, "low");
-    __publicField$7(this, "high");
-    __publicField$7(this, "__isUnsignedLong__");
+    __publicField$f(this, "low");
+    __publicField$f(this, "high");
+    __publicField$f(this, "__isUnsignedLong__");
     this.low = low | 0;
     this.high = high | 0;
     this.__isUnsignedLong__ = true;
@@ -1890,15 +1927,15 @@ const TWO_PWR_16_DBL = 1 << 16;
 const TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;
 const TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;
 const MAX_UNSIGNED_VALUE = new Long(4294967295 | 0, 4294967295 | 0);
-var __defProp$6 = Object.defineProperty;
-var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$6 = (obj, key, value) => __defNormalProp$6(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$e = Object.defineProperty;
+var __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$e = (obj, key, value) => __defNormalProp$e(obj, typeof key !== "symbol" ? key + "" : key, value);
 class RemoteQuerySet {
   constructor(queryPath, logger) {
-    __publicField$6(this, "version");
-    __publicField$6(this, "remoteQuerySet");
-    __publicField$6(this, "queryPath");
-    __publicField$6(this, "logger");
+    __publicField$e(this, "version");
+    __publicField$e(this, "remoteQuerySet");
+    __publicField$e(this, "queryPath");
+    __publicField$e(this, "logger");
     this.version = { querySet: 0, ts: Long.fromNumber(0), identity: 0 };
     this.remoteQuerySet = /* @__PURE__ */ new Map();
     this.queryPath = queryPath;
@@ -2024,9 +2061,9 @@ function encodeClientMessage(message) {
   }
   return void 0;
 }
-var __defProp$5 = Object.defineProperty;
-var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$5 = (obj, key, value) => __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$d = Object.defineProperty;
+var __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$d = (obj, key, value) => __defNormalProp$d(obj, typeof key !== "symbol" ? key + "" : key, value);
 const CLOSE_NORMAL = 1e3;
 const CLOSE_GOING_AWAY = 1001;
 const CLOSE_NO_STATUS = 1005;
@@ -2079,26 +2116,26 @@ class WebSocketManager {
   constructor(uri, callbacks, webSocketConstructor, logger, markConnectionStateDirty, debug) {
     this.markConnectionStateDirty = markConnectionStateDirty;
     this.debug = debug;
-    __publicField$5(this, "socket");
-    __publicField$5(this, "connectionCount");
-    __publicField$5(this, "_hasEverConnected", false);
-    __publicField$5(this, "lastCloseReason");
-    __publicField$5(this, "transitionChunkBuffer", null);
-    __publicField$5(this, "defaultInitialBackoff");
-    __publicField$5(this, "maxBackoff");
-    __publicField$5(this, "retries");
-    __publicField$5(this, "serverInactivityThreshold");
-    __publicField$5(this, "reconnectDueToServerInactivityTimeout");
-    __publicField$5(this, "scheduledReconnect", null);
-    __publicField$5(this, "networkOnlineHandler", null);
-    __publicField$5(this, "pendingNetworkRecoveryInfo", null);
-    __publicField$5(this, "uri");
-    __publicField$5(this, "onOpen");
-    __publicField$5(this, "onResume");
-    __publicField$5(this, "onMessage");
-    __publicField$5(this, "webSocketConstructor");
-    __publicField$5(this, "logger");
-    __publicField$5(this, "onServerDisconnectError");
+    __publicField$d(this, "socket");
+    __publicField$d(this, "connectionCount");
+    __publicField$d(this, "_hasEverConnected", false);
+    __publicField$d(this, "lastCloseReason");
+    __publicField$d(this, "transitionChunkBuffer", null);
+    __publicField$d(this, "defaultInitialBackoff");
+    __publicField$d(this, "maxBackoff");
+    __publicField$d(this, "retries");
+    __publicField$d(this, "serverInactivityThreshold");
+    __publicField$d(this, "reconnectDueToServerInactivityTimeout");
+    __publicField$d(this, "scheduledReconnect", null);
+    __publicField$d(this, "networkOnlineHandler", null);
+    __publicField$d(this, "pendingNetworkRecoveryInfo", null);
+    __publicField$d(this, "uri");
+    __publicField$d(this, "onOpen");
+    __publicField$d(this, "onResume");
+    __publicField$d(this, "onMessage");
+    __publicField$d(this, "webSocketConstructor");
+    __publicField$d(this, "logger");
+    __publicField$d(this, "onServerDisconnectError");
     this.webSocketConstructor = webSocketConstructor;
     this.socket = { state: "disconnected" };
     this.connectionCount = 0;
@@ -2732,25 +2769,25 @@ function jwtDecode(token, options) {
     );
   }
 }
-var __defProp$4 = Object.defineProperty;
-var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$4 = (obj, key, value) => __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$c = Object.defineProperty;
+var __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$c = (obj, key, value) => __defNormalProp$c(obj, typeof key !== "symbol" ? key + "" : key, value);
 const MAXIMUM_REFRESH_DELAY = 20 * 24 * 60 * 60 * 1e3;
 const MAX_TOKEN_CONFIRMATION_ATTEMPTS = 2;
 class AuthenticationManager {
   constructor(syncState, callbacks, config) {
-    __publicField$4(this, "authState", { state: "noAuth" });
-    __publicField$4(this, "configVersion", 0);
-    __publicField$4(this, "syncState");
-    __publicField$4(this, "authenticate");
-    __publicField$4(this, "stopSocket");
-    __publicField$4(this, "tryRestartSocket");
-    __publicField$4(this, "pauseSocket");
-    __publicField$4(this, "resumeSocket");
-    __publicField$4(this, "clearAuth");
-    __publicField$4(this, "logger");
-    __publicField$4(this, "refreshTokenLeewaySeconds");
-    __publicField$4(this, "tokenConfirmationAttempts", 0);
+    __publicField$c(this, "authState", { state: "noAuth" });
+    __publicField$c(this, "configVersion", 0);
+    __publicField$c(this, "syncState");
+    __publicField$c(this, "authenticate");
+    __publicField$c(this, "stopSocket");
+    __publicField$c(this, "tryRestartSocket");
+    __publicField$c(this, "pauseSocket");
+    __publicField$c(this, "resumeSocket");
+    __publicField$c(this, "clearAuth");
+    __publicField$c(this, "logger");
+    __publicField$c(this, "refreshTokenLeewaySeconds");
+    __publicField$c(this, "tokenConfirmationAttempts", 0);
     this.syncState = syncState;
     this.authenticate = callbacks.authenticate;
     this.stopSocket = callbacks.stopSocket;
@@ -3066,9 +3103,9 @@ function getMarksReport(sessionId) {
   }
   return allMarks.map(performanceMarkToJson);
 }
-var __defProp$3 = Object.defineProperty;
-var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$b = Object.defineProperty;
+var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$b = (obj, key, value) => __defNormalProp$b(obj, typeof key !== "symbol" ? key + "" : key, value);
 class BaseConvexClient {
   /**
    * @param address - The url of your Convex deployment, often provided
@@ -3079,25 +3116,25 @@ class BaseConvexClient {
    * @param options - See {@link BaseConvexClientOptions} for a full description.
    */
   constructor(address, onTransition, options) {
-    __publicField$3(this, "address");
-    __publicField$3(this, "state");
-    __publicField$3(this, "requestManager");
-    __publicField$3(this, "webSocketManager");
-    __publicField$3(this, "authenticationManager");
-    __publicField$3(this, "remoteQuerySet");
-    __publicField$3(this, "optimisticQueryResults");
-    __publicField$3(this, "_transitionHandlerCounter", 0);
-    __publicField$3(this, "_nextRequestId");
-    __publicField$3(this, "_onTransitionFns", /* @__PURE__ */ new Map());
-    __publicField$3(this, "_sessionId");
-    __publicField$3(this, "firstMessageReceived", false);
-    __publicField$3(this, "debug");
-    __publicField$3(this, "logger");
-    __publicField$3(this, "maxObservedTimestamp");
-    __publicField$3(this, "connectionStateSubscribers", /* @__PURE__ */ new Map());
-    __publicField$3(this, "nextConnectionStateSubscriberId", 0);
-    __publicField$3(this, "_lastPublishedConnectionState");
-    __publicField$3(this, "markConnectionStateDirty", () => {
+    __publicField$b(this, "address");
+    __publicField$b(this, "state");
+    __publicField$b(this, "requestManager");
+    __publicField$b(this, "webSocketManager");
+    __publicField$b(this, "authenticationManager");
+    __publicField$b(this, "remoteQuerySet");
+    __publicField$b(this, "optimisticQueryResults");
+    __publicField$b(this, "_transitionHandlerCounter", 0);
+    __publicField$b(this, "_nextRequestId");
+    __publicField$b(this, "_onTransitionFns", /* @__PURE__ */ new Map());
+    __publicField$b(this, "_sessionId");
+    __publicField$b(this, "firstMessageReceived", false);
+    __publicField$b(this, "debug");
+    __publicField$b(this, "logger");
+    __publicField$b(this, "maxObservedTimestamp");
+    __publicField$b(this, "connectionStateSubscribers", /* @__PURE__ */ new Map());
+    __publicField$b(this, "nextConnectionStateSubscriberId", 0);
+    __publicField$b(this, "_lastPublishedConnectionState");
+    __publicField$b(this, "markConnectionStateDirty", () => {
       void Promise.resolve().then(() => {
         const curConnectionState = this.connectionState();
         if (JSON.stringify(curConnectionState) !== JSON.stringify(this._lastPublishedConnectionState)) {
@@ -3108,7 +3145,7 @@ class BaseConvexClient {
         }
       });
     });
-    __publicField$3(this, "mark", (name) => {
+    __publicField$b(this, "mark", (name) => {
       if (this.debug) {
         mark(name, this.sessionId);
       }
@@ -3776,15 +3813,15 @@ function asPaginationResult(value) {
   }
   return value;
 }
-var __defProp$2 = Object.defineProperty;
-var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$a = Object.defineProperty;
+var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$a = (obj, key, value) => __defNormalProp$a(obj, typeof key !== "symbol" ? key + "" : key, value);
 class PaginatedQueryClient {
   constructor(client, onTransition) {
     this.client = client;
     this.onTransition = onTransition;
-    __publicField$2(this, "paginatedQuerySet", /* @__PURE__ */ new Map());
-    __publicField$2(this, "lastTransitionTs");
+    __publicField$a(this, "paginatedQuerySet", /* @__PURE__ */ new Map());
+    __publicField$a(this, "lastTransitionTs");
     this.lastTransitionTs = Long.fromNumber(0);
     this.client.addOnTransitionHandler(
       (transition) => this.onBaseTransition(transition)
@@ -4177,9 +4214,9 @@ function useSubscription({
   }, [getCurrentValue, subscribe]);
   return valueToReturn;
 }
-var __defProp$1 = Object.defineProperty;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$9 = Object.defineProperty;
+var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$9 = (obj, key, value) => __defNormalProp$9(obj, typeof key !== "symbol" ? key + "" : key, value);
 const DEFAULT_EXTEND_SUBSCRIPTION_FOR = 5e3;
 if (typeof React === "undefined") {
   throw new Error("Required dependency 'react' not found");
@@ -4210,15 +4247,15 @@ class ConvexReactClient {
    * @param options - See {@link ConvexReactClientOptions} for a full description.
    */
   constructor(address, options) {
-    __publicField$1(this, "address");
-    __publicField$1(this, "cachedSync");
-    __publicField$1(this, "cachedPaginatedQueryClient");
-    __publicField$1(this, "listeners");
-    __publicField$1(this, "options");
-    __publicField$1(this, "closed", false);
-    __publicField$1(this, "_logger");
-    __publicField$1(this, "adminAuth");
-    __publicField$1(this, "fakeUserIdentity");
+    __publicField$9(this, "address");
+    __publicField$9(this, "cachedSync");
+    __publicField$9(this, "cachedPaginatedQueryClient");
+    __publicField$9(this, "listeners");
+    __publicField$9(this, "options");
+    __publicField$9(this, "closed", false);
+    __publicField$9(this, "_logger");
+    __publicField$9(this, "adminAuth");
+    __publicField$9(this, "fakeUserIdentity");
     if (address === void 0) {
       throw new Error(
         "No address provided to ConvexReactClient.\nIf trying to deploy to production, make sure to follow all the instructions found at https://docs.convex.dev/production/hosting/\nIf running locally, make sure to run `convex dev` and ensure the .env.local file is populated."
@@ -4640,14 +4677,14 @@ function assertNotAccidentalArgument(value) {
     );
   }
 }
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$8 = Object.defineProperty;
+var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$8 = (obj, key, value) => __defNormalProp$8(obj, typeof key !== "symbol" ? key + "" : key, value);
 class QueriesObserver {
   constructor(createWatch) {
-    __publicField(this, "createWatch");
-    __publicField(this, "queries");
-    __publicField(this, "listeners");
+    __publicField$8(this, "createWatch");
+    __publicField$8(this, "queries");
+    __publicField$8(this, "listeners");
     this.createWatch = createWatch;
     this.queries = {};
     this.listeners = /* @__PURE__ */ new Set();
@@ -4808,6 +4845,961 @@ function useQueriesHelper(queries, createWatch) {
   );
   return useSubscription(subscription);
 }
+function performSyscall(op, arg) {
+  if (typeof Convex === "undefined" || Convex.syscall === void 0) {
+    throw new Error(
+      "The Convex database and auth objects are being used outside of a Convex backend. Did you mean to use `useQuery` or `useMutation` to call a Convex function?"
+    );
+  }
+  const resultStr = Convex.syscall(op, JSON.stringify(arg));
+  return JSON.parse(resultStr);
+}
+async function performAsyncSyscall(op, arg) {
+  if (typeof Convex === "undefined" || Convex.asyncSyscall === void 0) {
+    throw new Error(
+      "The Convex database and auth objects are being used outside of a Convex backend. Did you mean to use `useQuery` or `useMutation` to call a Convex function?"
+    );
+  }
+  let resultStr;
+  try {
+    resultStr = await Convex.asyncSyscall(op, JSON.stringify(arg));
+  } catch (e) {
+    if (e.data !== void 0) {
+      const rethrown = new ConvexError(e.message);
+      rethrown.data = jsonToConvex(e.data);
+      throw rethrown;
+    }
+    throw new Error(e.message);
+  }
+  return JSON.parse(resultStr);
+}
+function validateArg(arg, idx, method, argName) {
+  if (arg === void 0) {
+    throw new TypeError(
+      `Must provide arg ${idx} \`${argName}\` to \`${method}\``
+    );
+  }
+}
+function validateArgIsNonNegativeInteger(arg, idx, method, argName) {
+  if (!Number.isInteger(arg) || arg < 0) {
+    throw new TypeError(
+      `Arg ${idx} \`${argName}\` to \`${method}\` must be a non-negative integer`
+    );
+  }
+}
+function setupAuth(requestId) {
+  return {
+    getUserIdentity: async () => {
+      return await performAsyncSyscall("1.0/getUserIdentity", {
+        requestId
+      });
+    }
+  };
+}
+var __defProp$7 = Object.defineProperty;
+var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$7 = (obj, key, value) => __defNormalProp$7(obj, typeof key !== "symbol" ? key + "" : key, value);
+class Expression {
+  /**
+   * @internal
+   */
+  constructor() {
+    __publicField$7(this, "_isExpression");
+    __publicField$7(this, "_value");
+  }
+}
+var __defProp$6 = Object.defineProperty;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$6 = (obj, key, value) => __defNormalProp$6(obj, key + "", value);
+class ExpressionImpl extends Expression {
+  constructor(inner) {
+    super();
+    __publicField$6(this, "inner");
+    this.inner = inner;
+  }
+  serialize() {
+    return this.inner;
+  }
+}
+function serializeExpression(expr) {
+  if (expr instanceof ExpressionImpl) {
+    return expr.serialize();
+  } else {
+    return { $literal: convexOrUndefinedToJson(expr) };
+  }
+}
+const filterBuilderImpl = {
+  //  Comparisons  /////////////////////////////////////////////////////////////
+  eq(l, r) {
+    return new ExpressionImpl({
+      $eq: [serializeExpression(l), serializeExpression(r)]
+    });
+  },
+  neq(l, r) {
+    return new ExpressionImpl({
+      $neq: [serializeExpression(l), serializeExpression(r)]
+    });
+  },
+  lt(l, r) {
+    return new ExpressionImpl({
+      $lt: [serializeExpression(l), serializeExpression(r)]
+    });
+  },
+  lte(l, r) {
+    return new ExpressionImpl({
+      $lte: [serializeExpression(l), serializeExpression(r)]
+    });
+  },
+  gt(l, r) {
+    return new ExpressionImpl({
+      $gt: [serializeExpression(l), serializeExpression(r)]
+    });
+  },
+  gte(l, r) {
+    return new ExpressionImpl({
+      $gte: [serializeExpression(l), serializeExpression(r)]
+    });
+  },
+  //  Arithmetic  //////////////////////////////////////////////////////////////
+  add(l, r) {
+    return new ExpressionImpl({
+      $add: [serializeExpression(l), serializeExpression(r)]
+    });
+  },
+  sub(l, r) {
+    return new ExpressionImpl({
+      $sub: [serializeExpression(l), serializeExpression(r)]
+    });
+  },
+  mul(l, r) {
+    return new ExpressionImpl({
+      $mul: [serializeExpression(l), serializeExpression(r)]
+    });
+  },
+  div(l, r) {
+    return new ExpressionImpl({
+      $div: [serializeExpression(l), serializeExpression(r)]
+    });
+  },
+  mod(l, r) {
+    return new ExpressionImpl({
+      $mod: [serializeExpression(l), serializeExpression(r)]
+    });
+  },
+  neg(x) {
+    return new ExpressionImpl({ $neg: serializeExpression(x) });
+  },
+  //  Logic  ///////////////////////////////////////////////////////////////////
+  and(...exprs) {
+    return new ExpressionImpl({ $and: exprs.map(serializeExpression) });
+  },
+  or(...exprs) {
+    return new ExpressionImpl({ $or: exprs.map(serializeExpression) });
+  },
+  not(x) {
+    return new ExpressionImpl({ $not: serializeExpression(x) });
+  },
+  //  Other  ///////////////////////////////////////////////////////////////////
+  field(fieldPath) {
+    return new ExpressionImpl({ $field: fieldPath });
+  }
+};
+var __defProp$5 = Object.defineProperty;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$5 = (obj, key, value) => __defNormalProp$5(obj, key + "", value);
+class IndexRange {
+  /**
+   * @internal
+   */
+  constructor() {
+    __publicField$5(this, "_isIndexRange");
+  }
+}
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+class IndexRangeBuilderImpl extends IndexRange {
+  constructor(rangeExpressions) {
+    super();
+    __publicField$4(this, "rangeExpressions");
+    __publicField$4(this, "isConsumed");
+    this.rangeExpressions = rangeExpressions;
+    this.isConsumed = false;
+  }
+  static new() {
+    return new IndexRangeBuilderImpl([]);
+  }
+  consume() {
+    if (this.isConsumed) {
+      throw new Error(
+        "IndexRangeBuilder has already been used! Chain your method calls like `q => q.eq(...).eq(...)`. See https://docs.convex.dev/using/indexes"
+      );
+    }
+    this.isConsumed = true;
+  }
+  eq(fieldName, value) {
+    this.consume();
+    return new IndexRangeBuilderImpl(
+      this.rangeExpressions.concat({
+        type: "Eq",
+        fieldPath: fieldName,
+        value: convexOrUndefinedToJson(value)
+      })
+    );
+  }
+  gt(fieldName, value) {
+    this.consume();
+    return new IndexRangeBuilderImpl(
+      this.rangeExpressions.concat({
+        type: "Gt",
+        fieldPath: fieldName,
+        value: convexOrUndefinedToJson(value)
+      })
+    );
+  }
+  gte(fieldName, value) {
+    this.consume();
+    return new IndexRangeBuilderImpl(
+      this.rangeExpressions.concat({
+        type: "Gte",
+        fieldPath: fieldName,
+        value: convexOrUndefinedToJson(value)
+      })
+    );
+  }
+  lt(fieldName, value) {
+    this.consume();
+    return new IndexRangeBuilderImpl(
+      this.rangeExpressions.concat({
+        type: "Lt",
+        fieldPath: fieldName,
+        value: convexOrUndefinedToJson(value)
+      })
+    );
+  }
+  lte(fieldName, value) {
+    this.consume();
+    return new IndexRangeBuilderImpl(
+      this.rangeExpressions.concat({
+        type: "Lte",
+        fieldPath: fieldName,
+        value: convexOrUndefinedToJson(value)
+      })
+    );
+  }
+  export() {
+    this.consume();
+    return this.rangeExpressions;
+  }
+}
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, key + "", value);
+class SearchFilter {
+  /**
+   * @internal
+   */
+  constructor() {
+    __publicField$3(this, "_isSearchFilter");
+  }
+}
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+class SearchFilterBuilderImpl extends SearchFilter {
+  constructor(filters) {
+    super();
+    __publicField$2(this, "filters");
+    __publicField$2(this, "isConsumed");
+    this.filters = filters;
+    this.isConsumed = false;
+  }
+  static new() {
+    return new SearchFilterBuilderImpl([]);
+  }
+  consume() {
+    if (this.isConsumed) {
+      throw new Error(
+        "SearchFilterBuilder has already been used! Chain your method calls like `q => q.search(...).eq(...)`."
+      );
+    }
+    this.isConsumed = true;
+  }
+  search(fieldName, query) {
+    validateArg(fieldName, 1, "search", "fieldName");
+    validateArg(query, 2, "search", "query");
+    this.consume();
+    return new SearchFilterBuilderImpl(
+      this.filters.concat({
+        type: "Search",
+        fieldPath: fieldName,
+        value: query
+      })
+    );
+  }
+  eq(fieldName, value) {
+    validateArg(fieldName, 1, "eq", "fieldName");
+    if (arguments.length !== 2) {
+      validateArg(value, 2, "search", "value");
+    }
+    this.consume();
+    return new SearchFilterBuilderImpl(
+      this.filters.concat({
+        type: "Eq",
+        fieldPath: fieldName,
+        value: convexOrUndefinedToJson(value)
+      })
+    );
+  }
+  export() {
+    this.consume();
+    return this.filters;
+  }
+}
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+const MAX_QUERY_OPERATORS = 256;
+class QueryInitializerImpl {
+  constructor(tableName) {
+    __publicField$1(this, "tableName");
+    this.tableName = tableName;
+  }
+  withIndex(indexName, indexRange) {
+    validateArg(indexName, 1, "withIndex", "indexName");
+    let rangeBuilder = IndexRangeBuilderImpl.new();
+    if (indexRange !== void 0) {
+      rangeBuilder = indexRange(rangeBuilder);
+    }
+    return new QueryImpl({
+      source: {
+        type: "IndexRange",
+        indexName: this.tableName + "." + indexName,
+        range: rangeBuilder.export(),
+        order: null
+      },
+      operators: []
+    });
+  }
+  withSearchIndex(indexName, searchFilter) {
+    validateArg(indexName, 1, "withSearchIndex", "indexName");
+    validateArg(searchFilter, 2, "withSearchIndex", "searchFilter");
+    const searchFilterBuilder = SearchFilterBuilderImpl.new();
+    return new QueryImpl({
+      source: {
+        type: "Search",
+        indexName: this.tableName + "." + indexName,
+        filters: searchFilter(searchFilterBuilder).export()
+      },
+      operators: []
+    });
+  }
+  fullTableScan() {
+    return new QueryImpl({
+      source: {
+        type: "FullTableScan",
+        tableName: this.tableName,
+        order: null
+      },
+      operators: []
+    });
+  }
+  order(order) {
+    return this.fullTableScan().order(order);
+  }
+  // This is internal API and should not be exposed to developers yet.
+  async count() {
+    const syscallJSON = await performAsyncSyscall("1.0/count", {
+      table: this.tableName
+    });
+    const syscallResult = jsonToConvex(syscallJSON);
+    return syscallResult;
+  }
+  filter(predicate) {
+    return this.fullTableScan().filter(predicate);
+  }
+  limit(n) {
+    return this.fullTableScan().limit(n);
+  }
+  collect() {
+    return this.fullTableScan().collect();
+  }
+  take(n) {
+    return this.fullTableScan().take(n);
+  }
+  paginate(paginationOpts) {
+    return this.fullTableScan().paginate(paginationOpts);
+  }
+  first() {
+    return this.fullTableScan().first();
+  }
+  unique() {
+    return this.fullTableScan().unique();
+  }
+  [Symbol.asyncIterator]() {
+    return this.fullTableScan()[Symbol.asyncIterator]();
+  }
+}
+function throwClosedError(type) {
+  throw new Error(
+    type === "consumed" ? "This query is closed and can't emit any more values." : "This query has been chained with another operator and can't be reused."
+  );
+}
+class QueryImpl {
+  constructor(query) {
+    __publicField$1(this, "state");
+    __publicField$1(this, "tableNameForErrorMessages");
+    this.state = { type: "preparing", query };
+    if (query.source.type === "FullTableScan") {
+      this.tableNameForErrorMessages = query.source.tableName;
+    } else {
+      this.tableNameForErrorMessages = query.source.indexName.split(".")[0];
+    }
+  }
+  takeQuery() {
+    if (this.state.type !== "preparing") {
+      throw new Error(
+        "A query can only be chained once and can't be chained after iteration begins."
+      );
+    }
+    const query = this.state.query;
+    this.state = { type: "closed" };
+    return query;
+  }
+  startQuery() {
+    if (this.state.type === "executing") {
+      throw new Error("Iteration can only begin on a query once.");
+    }
+    if (this.state.type === "closed" || this.state.type === "consumed") {
+      throwClosedError(this.state.type);
+    }
+    const query = this.state.query;
+    const { queryId } = performSyscall("1.0/queryStream", { query, version });
+    this.state = { type: "executing", queryId };
+    return queryId;
+  }
+  closeQuery() {
+    if (this.state.type === "executing") {
+      const queryId = this.state.queryId;
+      performSyscall("1.0/queryCleanup", { queryId });
+    }
+    this.state = { type: "consumed" };
+  }
+  order(order) {
+    validateArg(order, 1, "order", "order");
+    const query = this.takeQuery();
+    if (query.source.type === "Search") {
+      throw new Error(
+        "Search queries must always be in relevance order. Can not set order manually."
+      );
+    }
+    if (query.source.order !== null) {
+      throw new Error("Queries may only specify order at most once");
+    }
+    query.source.order = order;
+    return new QueryImpl(query);
+  }
+  filter(predicate) {
+    validateArg(predicate, 1, "filter", "predicate");
+    const query = this.takeQuery();
+    if (query.operators.length >= MAX_QUERY_OPERATORS) {
+      throw new Error(
+        `Can't construct query with more than ${MAX_QUERY_OPERATORS} operators`
+      );
+    }
+    query.operators.push({
+      filter: serializeExpression(predicate(filterBuilderImpl))
+    });
+    return new QueryImpl(query);
+  }
+  limit(n) {
+    validateArg(n, 1, "limit", "n");
+    const query = this.takeQuery();
+    query.operators.push({ limit: n });
+    return new QueryImpl(query);
+  }
+  [Symbol.asyncIterator]() {
+    this.startQuery();
+    return this;
+  }
+  async next() {
+    if (this.state.type === "closed" || this.state.type === "consumed") {
+      throwClosedError(this.state.type);
+    }
+    const queryId = this.state.type === "preparing" ? this.startQuery() : this.state.queryId;
+    const { value, done } = await performAsyncSyscall("1.0/queryStreamNext", {
+      queryId
+    });
+    if (done) {
+      this.closeQuery();
+    }
+    const convexValue = jsonToConvex(value);
+    return { value: convexValue, done };
+  }
+  return() {
+    this.closeQuery();
+    return Promise.resolve({ done: true, value: void 0 });
+  }
+  async paginate(paginationOpts) {
+    validateArg(paginationOpts, 1, "paginate", "options");
+    if (typeof paginationOpts?.numItems !== "number" || paginationOpts.numItems < 0) {
+      throw new Error(
+        `\`options.numItems\` must be a positive number. Received \`${paginationOpts?.numItems}\`.`
+      );
+    }
+    const query = this.takeQuery();
+    const pageSize = paginationOpts.numItems;
+    const cursor = paginationOpts.cursor;
+    const endCursor = paginationOpts?.endCursor ?? null;
+    const maximumRowsRead = paginationOpts.maximumRowsRead ?? null;
+    const { page, isDone, continueCursor, splitCursor, pageStatus } = await performAsyncSyscall("1.0/queryPage", {
+      query,
+      cursor,
+      endCursor,
+      pageSize,
+      maximumRowsRead,
+      maximumBytesRead: paginationOpts.maximumBytesRead,
+      version
+    });
+    return {
+      page: page.map((json) => jsonToConvex(json)),
+      isDone,
+      continueCursor,
+      splitCursor,
+      pageStatus
+    };
+  }
+  async collect() {
+    const out = [];
+    for await (const item of this) {
+      out.push(item);
+    }
+    return out;
+  }
+  async take(n) {
+    validateArg(n, 1, "take", "n");
+    validateArgIsNonNegativeInteger(n, 1, "take", "n");
+    return this.limit(n).collect();
+  }
+  async first() {
+    const first_array = await this.take(1);
+    return first_array.length === 0 ? null : first_array[0];
+  }
+  async unique() {
+    const first_two_array = await this.take(2);
+    if (first_two_array.length === 0) {
+      return null;
+    }
+    if (first_two_array.length === 2) {
+      throw new Error(`unique() query returned more than one result from table ${this.tableNameForErrorMessages}:
+ [${first_two_array[0]._id}, ${first_two_array[1]._id}, ...]`);
+    }
+    return first_two_array[0];
+  }
+}
+async function get(table, id, isSystem) {
+  validateArg(id, 1, "get", "id");
+  if (typeof id !== "string") {
+    throw new Error(
+      `Invalid argument \`id\` for \`db.get\`, expected string but got '${typeof id}': ${id}`
+    );
+  }
+  const args = {
+    id: convexToJson(id),
+    isSystem,
+    version,
+    table
+  };
+  const syscallJSON = await performAsyncSyscall("1.0/get", args);
+  return jsonToConvex(syscallJSON);
+}
+function setupReader() {
+  const reader = (isSystem = false) => {
+    return {
+      get: async (arg0, arg1) => {
+        return arg1 !== void 0 ? await get(arg0, arg1, isSystem) : await get(void 0, arg0, isSystem);
+      },
+      query: (tableName) => {
+        return new TableReader(tableName, isSystem).query();
+      },
+      normalizeId: (tableName, id) => {
+        validateArg(tableName, 1, "normalizeId", "tableName");
+        validateArg(id, 2, "normalizeId", "id");
+        const accessingSystemTable = tableName.startsWith("_");
+        if (accessingSystemTable !== isSystem) {
+          throw new Error(
+            `${accessingSystemTable ? "System" : "User"} tables can only be accessed from db.${isSystem ? "" : "system."}normalizeId().`
+          );
+        }
+        const syscallJSON = performSyscall("1.0/db/normalizeId", {
+          table: tableName,
+          idString: id
+        });
+        const syscallResult = jsonToConvex(syscallJSON);
+        return syscallResult.id;
+      },
+      // We set the system reader on the next line
+      system: null,
+      table: (tableName) => {
+        return new TableReader(tableName, isSystem);
+      }
+    };
+  };
+  const { system: _, ...rest } = reader(true);
+  const r = reader();
+  r.system = rest;
+  return r;
+}
+async function insert(tableName, value) {
+  if (tableName.startsWith("_")) {
+    throw new Error("System tables (prefixed with `_`) are read-only.");
+  }
+  validateArg(tableName, 1, "insert", "table");
+  validateArg(value, 2, "insert", "value");
+  const syscallJSON = await performAsyncSyscall("1.0/insert", {
+    table: tableName,
+    value: convexToJson(value)
+  });
+  const syscallResult = jsonToConvex(syscallJSON);
+  return syscallResult._id;
+}
+async function patch(table, id, value) {
+  validateArg(id, 1, "patch", "id");
+  validateArg(value, 2, "patch", "value");
+  await performAsyncSyscall("1.0/shallowMerge", {
+    id: convexToJson(id),
+    value: patchValueToJson(value),
+    table
+  });
+}
+async function replace(table, id, value) {
+  validateArg(id, 1, "replace", "id");
+  validateArg(value, 2, "replace", "value");
+  await performAsyncSyscall("1.0/replace", {
+    id: convexToJson(id),
+    value: convexToJson(value),
+    table
+  });
+}
+async function delete_(table, id) {
+  validateArg(id, 1, "delete", "id");
+  await performAsyncSyscall("1.0/remove", {
+    id: convexToJson(id),
+    table
+  });
+}
+function setupWriter() {
+  const reader = setupReader();
+  return {
+    get: reader.get,
+    query: reader.query,
+    normalizeId: reader.normalizeId,
+    system: reader.system,
+    insert: async (table, value) => {
+      return await insert(table, value);
+    },
+    patch: async (arg0, arg1, arg2) => {
+      return arg2 !== void 0 ? await patch(arg0, arg1, arg2) : await patch(void 0, arg0, arg1);
+    },
+    replace: async (arg0, arg1, arg2) => {
+      return arg2 !== void 0 ? await replace(arg0, arg1, arg2) : await replace(void 0, arg0, arg1);
+    },
+    delete: async (arg0, arg1) => {
+      return arg1 !== void 0 ? await delete_(arg0, arg1) : await delete_(void 0, arg0);
+    },
+    table: (tableName) => {
+      return new TableWriter(tableName, false);
+    }
+  };
+}
+class TableReader {
+  constructor(tableName, isSystem) {
+    this.tableName = tableName;
+    this.isSystem = isSystem;
+  }
+  async get(id) {
+    return get(this.tableName, id, this.isSystem);
+  }
+  query() {
+    const accessingSystemTable = this.tableName.startsWith("_");
+    if (accessingSystemTable !== this.isSystem) {
+      throw new Error(
+        `${accessingSystemTable ? "System" : "User"} tables can only be accessed from db.${this.isSystem ? "" : "system."}query().`
+      );
+    }
+    return new QueryInitializerImpl(this.tableName);
+  }
+}
+class TableWriter extends TableReader {
+  async insert(value) {
+    return insert(this.tableName, value);
+  }
+  async patch(id, value) {
+    return patch(this.tableName, id, value);
+  }
+  async replace(id, value) {
+    return replace(this.tableName, id, value);
+  }
+  async delete(id) {
+    return delete_(this.tableName, id);
+  }
+}
+function setupMutationScheduler() {
+  return {
+    runAfter: async (delayMs, functionReference, args) => {
+      const syscallArgs = runAfterSyscallArgs(delayMs, functionReference, args);
+      return await performAsyncSyscall("1.0/schedule", syscallArgs);
+    },
+    runAt: async (ms_since_epoch_or_date, functionReference, args) => {
+      const syscallArgs = runAtSyscallArgs(
+        ms_since_epoch_or_date,
+        functionReference,
+        args
+      );
+      return await performAsyncSyscall("1.0/schedule", syscallArgs);
+    },
+    cancel: async (id) => {
+      validateArg(id, 1, "cancel", "id");
+      const args = { id: convexToJson(id) };
+      await performAsyncSyscall("1.0/cancel_job", args);
+    }
+  };
+}
+function runAfterSyscallArgs(delayMs, functionReference, args) {
+  if (typeof delayMs !== "number") {
+    throw new Error("`delayMs` must be a number");
+  }
+  if (!isFinite(delayMs)) {
+    throw new Error("`delayMs` must be a finite number");
+  }
+  if (delayMs < 0) {
+    throw new Error("`delayMs` must be non-negative");
+  }
+  const functionArgs = parseArgs(args);
+  const address = getFunctionAddress(functionReference);
+  const ts = (Date.now() + delayMs) / 1e3;
+  return {
+    ...address,
+    ts,
+    args: convexToJson(functionArgs),
+    version
+  };
+}
+function runAtSyscallArgs(ms_since_epoch_or_date, functionReference, args) {
+  let ts;
+  if (ms_since_epoch_or_date instanceof Date) {
+    ts = ms_since_epoch_or_date.valueOf() / 1e3;
+  } else if (typeof ms_since_epoch_or_date === "number") {
+    ts = ms_since_epoch_or_date / 1e3;
+  } else {
+    throw new Error("The invoke time must a Date or a timestamp");
+  }
+  const address = getFunctionAddress(functionReference);
+  const functionArgs = parseArgs(args);
+  return {
+    ...address,
+    ts,
+    args: convexToJson(functionArgs),
+    version
+  };
+}
+function setupStorageReader(requestId) {
+  return {
+    getUrl: async (storageId) => {
+      validateArg(storageId, 1, "getUrl", "storageId");
+      return await performAsyncSyscall("1.0/storageGetUrl", {
+        requestId,
+        version,
+        storageId
+      });
+    },
+    getMetadata: async (storageId) => {
+      return await performAsyncSyscall("1.0/storageGetMetadata", {
+        requestId,
+        version,
+        storageId
+      });
+    }
+  };
+}
+function setupStorageWriter(requestId) {
+  const reader = setupStorageReader(requestId);
+  return {
+    generateUploadUrl: async () => {
+      return await performAsyncSyscall("1.0/storageGenerateUploadUrl", {
+        requestId,
+        version
+      });
+    },
+    delete: async (storageId) => {
+      await performAsyncSyscall("1.0/storageDelete", {
+        requestId,
+        version,
+        storageId
+      });
+    },
+    getUrl: reader.getUrl,
+    getMetadata: reader.getMetadata
+  };
+}
+async function invokeMutation(func, argsStr) {
+  const requestId = "";
+  const args = jsonToConvex(JSON.parse(argsStr));
+  const mutationCtx = {
+    db: setupWriter(),
+    auth: setupAuth(requestId),
+    storage: setupStorageWriter(requestId),
+    scheduler: setupMutationScheduler(),
+    runQuery: (reference, args2) => runUdf("query", reference, args2),
+    runMutation: (reference, args2) => runUdf("mutation", reference, args2)
+  };
+  const result = await invokeFunction(func, mutationCtx, args);
+  validateReturnValue(result);
+  return JSON.stringify(convexToJson(result === void 0 ? null : result));
+}
+function validateReturnValue(v2) {
+  if (v2 instanceof QueryInitializerImpl || v2 instanceof QueryImpl) {
+    throw new Error(
+      "Return value is a Query. Results must be retrieved with `.collect()`, `.take(n), `.unique()`, or `.first()`."
+    );
+  }
+}
+async function invokeFunction(func, ctx, args) {
+  let result;
+  try {
+    result = await Promise.resolve(func(ctx, ...args));
+  } catch (thrown) {
+    throw serializeConvexErrorData(thrown);
+  }
+  return result;
+}
+function dontCallDirectly(funcType, handler) {
+  return (ctx, args) => {
+    globalThis.console.warn(
+      `Convex functions should not directly call other Convex functions. Consider calling a helper function instead. e.g. \`export const foo = ${funcType}(...); await foo(ctx);\` is not supported. See https://docs.convex.dev/production/best-practices/#use-helper-functions-to-write-shared-code`
+    );
+    return handler(ctx, args);
+  };
+}
+function serializeConvexErrorData(thrown) {
+  if (typeof thrown === "object" && thrown !== null && /* @__PURE__ */ Symbol.for("ConvexError") in thrown) {
+    const error = thrown;
+    error.data = JSON.stringify(
+      convexToJson(error.data === void 0 ? null : error.data)
+    );
+    error.ConvexErrorSymbol = /* @__PURE__ */ Symbol.for("ConvexError");
+    return error;
+  } else {
+    return thrown;
+  }
+}
+function assertNotBrowser() {
+  if (typeof window === "undefined" || window.__convexAllowFunctionsInBrowser) {
+    return;
+  }
+  const isRealBrowser = Object.getOwnPropertyDescriptor(globalThis, "window")?.get?.toString().includes("[native code]") ?? false;
+  if (isRealBrowser) {
+    console.error(
+      "Convex functions should not be imported in the browser. This will throw an error in future versions of `convex`. If this is a false negative, please report it to Convex support."
+    );
+  }
+}
+function strictReplacer(key, value) {
+  if (value === void 0) {
+    throw new Error(
+      `A validator is undefined for field "${key}". This is often caused by circular imports. See https://docs.convex.dev/error#undefined-validator for details.`
+    );
+  }
+  return value;
+}
+function exportArgs(functionDefinition) {
+  return () => {
+    let args = v.any();
+    if (typeof functionDefinition === "object" && functionDefinition.args !== void 0) {
+      args = asObjectValidator(functionDefinition.args);
+    }
+    return JSON.stringify(args.json, strictReplacer);
+  };
+}
+function exportReturns(functionDefinition) {
+  return () => {
+    let returns;
+    if (typeof functionDefinition === "object" && functionDefinition.returns !== void 0) {
+      returns = asObjectValidator(functionDefinition.returns);
+    }
+    return JSON.stringify(returns ? returns.json : null, strictReplacer);
+  };
+}
+const mutationGeneric = ((functionDefinition) => {
+  const handler = typeof functionDefinition === "function" ? functionDefinition : functionDefinition.handler;
+  const func = dontCallDirectly("mutation", handler);
+  assertNotBrowser();
+  func.isMutation = true;
+  func.isPublic = true;
+  func.invokeMutation = (argsStr) => invokeMutation(handler, argsStr);
+  func.exportArgs = exportArgs(functionDefinition);
+  func.exportReturns = exportReturns(functionDefinition);
+  func._handler = handler;
+  return func;
+});
+const internalMutationGeneric = ((functionDefinition) => {
+  const handler = typeof functionDefinition === "function" ? functionDefinition : functionDefinition.handler;
+  const func = dontCallDirectly(
+    "internalMutation",
+    handler
+  );
+  assertNotBrowser();
+  func.isMutation = true;
+  func.isInternal = true;
+  func.invokeMutation = (argsStr) => invokeMutation(handler, argsStr);
+  func.exportArgs = exportArgs(functionDefinition);
+  func.exportReturns = exportReturns(functionDefinition);
+  func._handler = handler;
+  return func;
+});
+async function invokeQuery(func, argsStr) {
+  const requestId = "";
+  const args = jsonToConvex(JSON.parse(argsStr));
+  const queryCtx = {
+    db: setupReader(),
+    auth: setupAuth(requestId),
+    storage: setupStorageReader(requestId),
+    runQuery: (reference, args2) => runUdf("query", reference, args2)
+  };
+  const result = await invokeFunction(func, queryCtx, args);
+  validateReturnValue(result);
+  return JSON.stringify(convexToJson(result === void 0 ? null : result));
+}
+const queryGeneric = ((functionDefinition) => {
+  const handler = typeof functionDefinition === "function" ? functionDefinition : functionDefinition.handler;
+  const func = dontCallDirectly("query", handler);
+  assertNotBrowser();
+  func.isQuery = true;
+  func.isPublic = true;
+  func.invokeQuery = (argsStr) => invokeQuery(handler, argsStr);
+  func.exportArgs = exportArgs(functionDefinition);
+  func.exportReturns = exportReturns(functionDefinition);
+  func._handler = handler;
+  return func;
+});
+async function runUdf(udfType, f, args) {
+  const queryArgs = parseArgs(args);
+  const syscallArgs = {
+    udfType,
+    args: convexToJson(queryArgs),
+    ...getFunctionAddress(f)
+  };
+  const result = await performAsyncSyscall("1.0/runUdf", syscallArgs);
+  return jsonToConvex(result);
+}
+const paginationOptsValidator = v.object({
+  numItems: v.number(),
+  cursor: v.union(v.string(), v.null()),
+  endCursor: v.optional(v.union(v.string(), v.null())),
+  id: v.optional(v.number()),
+  maximumRowsRead: v.optional(v.number()),
+  maximumBytesRead: v.optional(v.number())
+});
 function createChildComponents(root, pathParts) {
   const handler = {
     get(_, prop) {
@@ -4830,12 +5822,209 @@ function createChildComponents(root, pathParts) {
   return new Proxy({}, handler);
 }
 const componentsGeneric = () => createChildComponents("components", []);
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class TableDefinition {
+  /**
+   * @internal
+   */
+  constructor(documentType) {
+    __publicField(this, "indexes");
+    __publicField(this, "stagedDbIndexes");
+    __publicField(this, "searchIndexes");
+    __publicField(this, "stagedSearchIndexes");
+    __publicField(this, "vectorIndexes");
+    __publicField(this, "stagedVectorIndexes");
+    __publicField(this, "validator");
+    this.indexes = [];
+    this.stagedDbIndexes = [];
+    this.searchIndexes = [];
+    this.stagedSearchIndexes = [];
+    this.vectorIndexes = [];
+    this.stagedVectorIndexes = [];
+    this.validator = documentType;
+  }
+  /**
+   * This API is experimental: it may change or disappear.
+   *
+   * Returns indexes defined on this table.
+   * Intended for the advanced use cases of dynamically deciding which index to use for a query.
+   * If you think you need this, please chime in on ths issue in the Convex JS GitHub repo.
+   * https://github.com/get-convex/convex-js/issues/49
+   */
+  " indexes"() {
+    return this.indexes;
+  }
+  index(name, indexConfig) {
+    if (Array.isArray(indexConfig)) {
+      this.indexes.push({
+        indexDescriptor: name,
+        fields: indexConfig
+      });
+    } else if (indexConfig.staged) {
+      this.stagedDbIndexes.push({
+        indexDescriptor: name,
+        fields: indexConfig.fields
+      });
+    } else {
+      this.indexes.push({
+        indexDescriptor: name,
+        fields: indexConfig.fields
+      });
+    }
+    return this;
+  }
+  searchIndex(name, indexConfig) {
+    if (indexConfig.staged) {
+      this.stagedSearchIndexes.push({
+        indexDescriptor: name,
+        searchField: indexConfig.searchField,
+        filterFields: indexConfig.filterFields || []
+      });
+    } else {
+      this.searchIndexes.push({
+        indexDescriptor: name,
+        searchField: indexConfig.searchField,
+        filterFields: indexConfig.filterFields || []
+      });
+    }
+    return this;
+  }
+  vectorIndex(name, indexConfig) {
+    if (indexConfig.staged) {
+      this.stagedVectorIndexes.push({
+        indexDescriptor: name,
+        vectorField: indexConfig.vectorField,
+        dimensions: indexConfig.dimensions,
+        filterFields: indexConfig.filterFields || []
+      });
+    } else {
+      this.vectorIndexes.push({
+        indexDescriptor: name,
+        vectorField: indexConfig.vectorField,
+        dimensions: indexConfig.dimensions,
+        filterFields: indexConfig.filterFields || []
+      });
+    }
+    return this;
+  }
+  /**
+   * Work around for https://github.com/microsoft/TypeScript/issues/57035
+   */
+  self() {
+    return this;
+  }
+  /**
+   * Export the contents of this definition.
+   *
+   * This is called internally by the Convex framework.
+   * @internal
+   */
+  export() {
+    const documentType = this.validator.json;
+    if (typeof documentType !== "object") {
+      throw new Error(
+        "Invalid validator: please make sure that the parameter of `defineTable` is valid (see https://docs.convex.dev/database/schemas)"
+      );
+    }
+    return {
+      indexes: this.indexes,
+      stagedDbIndexes: this.stagedDbIndexes,
+      searchIndexes: this.searchIndexes,
+      stagedSearchIndexes: this.stagedSearchIndexes,
+      vectorIndexes: this.vectorIndexes,
+      stagedVectorIndexes: this.stagedVectorIndexes,
+      documentType
+    };
+  }
+}
+function defineTable(documentSchema) {
+  if (isValidator(documentSchema)) {
+    return new TableDefinition(documentSchema);
+  } else {
+    return new TableDefinition(v.object(documentSchema));
+  }
+}
+class SchemaDefinition {
+  /**
+   * @internal
+   */
+  constructor(tables, options) {
+    __publicField(this, "tables");
+    __publicField(this, "strictTableNameTypes");
+    __publicField(this, "schemaValidation");
+    this.tables = tables;
+    this.schemaValidation = options?.schemaValidation === void 0 ? true : options.schemaValidation;
+  }
+  /**
+   * Export the contents of this definition.
+   *
+   * This is called internally by the Convex framework.
+   * @internal
+   */
+  export() {
+    return JSON.stringify({
+      tables: Object.entries(this.tables).map(([tableName, definition]) => {
+        const {
+          indexes,
+          stagedDbIndexes,
+          searchIndexes,
+          stagedSearchIndexes,
+          vectorIndexes,
+          stagedVectorIndexes,
+          documentType
+        } = definition.export();
+        return {
+          tableName,
+          indexes,
+          stagedDbIndexes,
+          searchIndexes,
+          stagedSearchIndexes,
+          vectorIndexes,
+          stagedVectorIndexes,
+          documentType
+        };
+      }),
+      schemaValidation: this.schemaValidation
+    });
+  }
+}
+function defineSchema(schema, options) {
+  return new SchemaDefinition(schema, options);
+}
+defineSchema({
+  _scheduled_functions: defineTable({
+    name: v.string(),
+    args: v.array(v.any()),
+    scheduledTime: v.float64(),
+    completedTime: v.optional(v.float64()),
+    state: v.union(
+      v.object({ kind: v.literal("pending") }),
+      v.object({ kind: v.literal("inProgress") }),
+      v.object({ kind: v.literal("success") }),
+      v.object({ kind: v.literal("failed"), error: v.string() }),
+      v.object({ kind: v.literal("canceled") })
+    )
+  }),
+  _storage: defineTable({
+    sha256: v.string(),
+    size: v.float64(),
+    contentType: v.optional(v.string())
+  })
+});
 export {
   ConvexReactClient as C,
-  ConvexProvider as a,
-  anyApi as b,
+  defineTable as a,
+  ConvexProvider as b,
   componentsGeneric as c,
-  useMutation as d,
+  defineSchema as d,
+  anyApi as e,
+  useMutation as f,
+  internalMutationGeneric as i,
+  mutationGeneric as m,
+  paginationOptsValidator as p,
+  queryGeneric as q,
   useQuery as u,
   v
 };