@concavejs/runtime-cf 0.0.1-alpha.4

package/dist/internal.js

@@ -0,0 +1,3773 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// ../core/node_modules/convex/dist/esm/values/base64.js
+function getLens(b64) {
+  var len2 = b64.length;
+  if (len2 % 4 > 0) {
+    throw new Error("Invalid string. Length must be a multiple of 4");
+  }
+  var validLen = b64.indexOf("=");
+  if (validLen === -1)
+    validLen = len2;
+  var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
+  return [validLen, placeHoldersLen];
+}
+function _byteLength(_b64, validLen, placeHoldersLen) {
+  return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+}
+function toByteArray(b64) {
+  var tmp;
+  var lens = getLens(b64);
+  var validLen = lens[0];
+  var placeHoldersLen = lens[1];
+  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+  var curByte = 0;
+  var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
+  var i2;
+  for (i2 = 0;i2 < len2; i2 += 4) {
+    tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];
+    arr[curByte++] = tmp >> 16 & 255;
+    arr[curByte++] = tmp >> 8 & 255;
+    arr[curByte++] = tmp & 255;
+  }
+  if (placeHoldersLen === 2) {
+    tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;
+    arr[curByte++] = tmp & 255;
+  }
+  if (placeHoldersLen === 1) {
+    tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;
+    arr[curByte++] = tmp >> 8 & 255;
+    arr[curByte++] = tmp & 255;
+  }
+  return arr;
+}
+function tripletToBase64(num) {
+  return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+}
+function encodeChunk(uint8, start, end) {
+  var tmp;
+  var output = [];
+  for (var i2 = start;i2 < end; i2 += 3) {
+    tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);
+    output.push(tripletToBase64(tmp));
+  }
+  return output.join("");
+}
+function fromByteArray(uint8) {
+  var tmp;
+  var len2 = uint8.length;
+  var extraBytes = len2 % 3;
+  var parts = [];
+  var maxChunkLength = 16383;
+  for (var i2 = 0, len22 = len2 - extraBytes;i2 < len22; i2 += maxChunkLength) {
+    parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
+  }
+  if (extraBytes === 1) {
+    tmp = uint8[len2 - 1];
+    parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
+  } else if (extraBytes === 2) {
+    tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];
+    parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
+  }
+  return parts.join("");
+}
+var lookup, revLookup, Arr, code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", i, len;
+var init_base64 = __esm(() => {
+  lookup = [];
+  revLookup = [];
+  Arr = Uint8Array;
+  for (i = 0, len = code.length;i < len; ++i) {
+    lookup[i] = code[i];
+    revLookup[code.charCodeAt(i)] = i;
+  }
+  revLookup[45] = 62;
+  revLookup[95] = 63;
+});
+
+// ../core/node_modules/convex/dist/esm/common/index.js
+function parseArgs(args) {
+  if (args === undefined) {
+    return {};
+  }
+  if (!isSimpleObject(args)) {
+    throw new Error(`The arguments to a Convex function must be an object. Received: ${args}`);
+  }
+  return args;
+}
+function isSimpleObject(value) {
+  const isObject = typeof value === "object";
+  const prototype = Object.getPrototypeOf(value);
+  const isSimple = prototype === null || prototype === Object.prototype || prototype?.constructor?.name === "Object";
+  return isObject && isSimple;
+}
+
+// ../core/node_modules/convex/dist/esm/values/value.js
+function isSpecial(n) {
+  return Number.isNaN(n) || !Number.isFinite(n) || Object.is(n, -0);
+}
+function slowBigIntToBase64(value) {
+  if (value < ZERO) {
+    value -= MIN_INT64 + MIN_INT64;
+  }
+  let hex = value.toString(16);
+  if (hex.length % 2 === 1)
+    hex = "0" + hex;
+  const bytes = new Uint8Array(new ArrayBuffer(8));
+  let i2 = 0;
+  for (const hexByte of hex.match(/.{2}/g).reverse()) {
+    bytes.set([parseInt(hexByte, 16)], i2++);
+    value >>= EIGHT;
+  }
+  return fromByteArray(bytes);
+}
+function slowBase64ToBigInt(encoded) {
+  const integerBytes = toByteArray(encoded);
+  if (integerBytes.byteLength !== 8) {
+    throw new Error(`Received ${integerBytes.byteLength} bytes, expected 8 for $integer`);
+  }
+  let value = ZERO;
+  let power = ZERO;
+  for (const byte of integerBytes) {
+    value += BigInt(byte) * TWOFIFTYSIX ** power;
+    power++;
+  }
+  if (value > MAX_INT64) {
+    value += MIN_INT64 + MIN_INT64;
+  }
+  return value;
+}
+function modernBigIntToBase64(value) {
+  if (value < MIN_INT64 || MAX_INT64 < value) {
+    throw new Error(`BigInt ${value} does not fit into a 64-bit signed integer.`);
+  }
+  const buffer = new ArrayBuffer(8);
+  new DataView(buffer).setBigInt64(0, value, true);
+  return fromByteArray(new Uint8Array(buffer));
+}
+function modernBase64ToBigInt(encoded) {
+  const integerBytes = toByteArray(encoded);
+  if (integerBytes.byteLength !== 8) {
+    throw new Error(`Received ${integerBytes.byteLength} bytes, expected 8 for $integer`);
+  }
+  const intBytesView = new DataView(integerBytes.buffer);
+  return intBytesView.getBigInt64(0, true);
+}
+function validateObjectField(k) {
+  if (k.length > MAX_IDENTIFIER_LEN) {
+    throw new Error(`Field name ${k} exceeds maximum field name length ${MAX_IDENTIFIER_LEN}.`);
+  }
+  if (k.startsWith("$")) {
+    throw new Error(`Field name ${k} starts with a '$', which is reserved.`);
+  }
+  for (let i2 = 0;i2 < k.length; i2 += 1) {
+    const charCode = k.charCodeAt(i2);
+    if (charCode < 32 || charCode >= 127) {
+      throw new Error(`Field name ${k} has invalid character '${k[i2]}': Field names can only contain non-control ASCII characters`);
+    }
+  }
+}
+function jsonToConvex(value) {
+  if (value === null) {
+    return value;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((value2) => jsonToConvex(value2));
+  }
+  if (typeof value !== "object") {
+    throw new Error(`Unexpected type of ${value}`);
+  }
+  const entries = Object.entries(value);
+  if (entries.length === 1) {
+    const key = entries[0][0];
+    if (key === "$bytes") {
+      if (typeof value.$bytes !== "string") {
+        throw new Error(`Malformed $bytes field on ${value}`);
+      }
+      return toByteArray(value.$bytes).buffer;
+    }
+    if (key === "$integer") {
+      if (typeof value.$integer !== "string") {
+        throw new Error(`Malformed $integer field on ${value}`);
+      }
+      return base64ToBigInt(value.$integer);
+    }
+    if (key === "$float") {
+      if (typeof value.$float !== "string") {
+        throw new Error(`Malformed $float field on ${value}`);
+      }
+      const floatBytes = toByteArray(value.$float);
+      if (floatBytes.byteLength !== 8) {
+        throw new Error(`Received ${floatBytes.byteLength} bytes, expected 8 for $float`);
+      }
+      const floatBytesView = new DataView(floatBytes.buffer);
+      const float = floatBytesView.getFloat64(0, LITTLE_ENDIAN);
+      if (!isSpecial(float)) {
+        throw new Error(`Float ${float} should be encoded as a number`);
+      }
+      return float;
+    }
+    if (key === "$set") {
+      throw new Error(`Received a Set which is no longer supported as a Convex type.`);
+    }
+    if (key === "$map") {
+      throw new Error(`Received a Map which is no longer supported as a Convex type.`);
+    }
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    validateObjectField(k);
+    out[k] = jsonToConvex(v);
+  }
+  return out;
+}
+function stringifyValueForError(value) {
+  const str = JSON.stringify(value, (_key, value2) => {
+    if (value2 === undefined) {
+      return "undefined";
+    }
+    if (typeof value2 === "bigint") {
+      return `${value2.toString()}n`;
+    }
+    return value2;
+  });
+  if (str.length > MAX_VALUE_FOR_ERROR_LEN) {
+    const rest = "[...truncated]";
+    let truncateAt = MAX_VALUE_FOR_ERROR_LEN - rest.length;
+    const codePoint = str.codePointAt(truncateAt - 1);
+    if (codePoint !== undefined && codePoint > 65535) {
+      truncateAt -= 1;
+    }
+    return str.substring(0, truncateAt) + rest;
+  }
+  return str;
+}
+function convexToJsonInternal(value, originalValue, context, includeTopLevelUndefined) {
+  if (value === undefined) {
+    const contextText = context && ` (present at path ${context} in original object ${stringifyValueForError(originalValue)})`;
+    throw new Error(`undefined is not a valid Convex value${contextText}. To learn about Convex's supported types, see https://docs.convex.dev/using/types.`);
+  }
+  if (value === null) {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    if (value < MIN_INT64 || MAX_INT64 < value) {
+      throw new Error(`BigInt ${value} does not fit into a 64-bit signed integer.`);
+    }
+    return { $integer: bigIntToBase64(value) };
+  }
+  if (typeof value === "number") {
+    if (isSpecial(value)) {
+      const buffer = new ArrayBuffer(8);
+      new DataView(buffer).setFloat64(0, value, LITTLE_ENDIAN);
+      return { $float: fromByteArray(new Uint8Array(buffer)) };
+    } else {
+      return value;
+    }
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof ArrayBuffer) {
+    return { $bytes: fromByteArray(new Uint8Array(value)) };
+  }
+  if (Array.isArray(value)) {
+    return value.map((value2, i2) => convexToJsonInternal(value2, originalValue, context + `[${i2}]`, false));
+  }
+  if (value instanceof Set) {
+    throw new Error(errorMessageForUnsupportedType(context, "Set", [...value], originalValue));
+  }
+  if (value instanceof Map) {
+    throw new Error(errorMessageForUnsupportedType(context, "Map", [...value], originalValue));
+  }
+  if (!isSimpleObject(value)) {
+    const theType = value?.constructor?.name;
+    const typeName = theType ? `${theType} ` : "";
+    throw new Error(errorMessageForUnsupportedType(context, typeName, value, originalValue));
+  }
+  const out = {};
+  const entries = Object.entries(value);
+  entries.sort(([k1, _v1], [k2, _v2]) => k1 === k2 ? 0 : k1 < k2 ? -1 : 1);
+  for (const [k, v] of entries) {
+    if (v !== undefined) {
+      validateObjectField(k);
+      out[k] = convexToJsonInternal(v, originalValue, context + `.${k}`, false);
+    } else if (includeTopLevelUndefined) {
+      validateObjectField(k);
+      out[k] = convexOrUndefinedToJsonInternal(v, originalValue, context + `.${k}`);
+    }
+  }
+  return out;
+}
+function errorMessageForUnsupportedType(context, typeName, value, originalValue) {
+  if (context) {
+    return `${typeName}${stringifyValueForError(value)} is not a supported Convex type (present at path ${context} in original object ${stringifyValueForError(originalValue)}). To learn about Convex's supported types, see https://docs.convex.dev/using/types.`;
+  } else {
+    return `${typeName}${stringifyValueForError(value)} is not a supported Convex type.`;
+  }
+}
+function convexOrUndefinedToJsonInternal(value, originalValue, context) {
+  if (value === undefined) {
+    return { $undefined: null };
+  } else {
+    if (originalValue === undefined) {
+      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, "", false);
+}
+function convexOrUndefinedToJson(value) {
+  return convexOrUndefinedToJsonInternal(value, value, "");
+}
+function patchValueToJson(value) {
+  return convexToJsonInternal(value, value, "", true);
+}
+var LITTLE_ENDIAN = true, MIN_INT64, MAX_INT64, ZERO, EIGHT, TWOFIFTYSIX, bigIntToBase64, base64ToBigInt, MAX_IDENTIFIER_LEN = 1024, MAX_VALUE_FOR_ERROR_LEN = 16384;
+var init_value = __esm(() => {
+  init_base64();
+  MIN_INT64 = BigInt("-9223372036854775808");
+  MAX_INT64 = BigInt("9223372036854775807");
+  ZERO = BigInt("0");
+  EIGHT = BigInt("8");
+  TWOFIFTYSIX = BigInt("256");
+  bigIntToBase64 = DataView.prototype.setBigInt64 ? modernBigIntToBase64 : slowBigIntToBase64;
+  base64ToBigInt = DataView.prototype.getBigInt64 ? modernBase64ToBigInt : slowBase64ToBigInt;
+});
+
+// ../core/node_modules/convex/dist/esm/values/validators.js
+function throwUndefinedValidatorError(context, fieldName) {
+  const fieldInfo = fieldName !== undefined ? ` for field "${fieldName}"` : "";
+  throw new Error(`A validator is undefined${fieldInfo} in ${context}. This is often caused by circular imports. See ${UNDEFINED_VALIDATOR_ERROR_URL} for details.`);
+}
+
+class BaseValidator {
+  constructor({ isOptional }) {
+    __publicField(this, "type");
+    __publicField(this, "fieldPaths");
+    __publicField(this, "isOptional");
+    __publicField(this, "isConvexValidator");
+    this.isOptional = isOptional;
+    this.isConvexValidator = true;
+  }
+}
+var __defProp2, __defNormalProp = (obj, key, value) => (key in obj) ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value, __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value), UNDEFINED_VALIDATOR_ERROR_URL = "https://docs.convex.dev/error#undefined-validator", VId, VFloat64, VInt64, VBoolean, VBytes, VString, VNull, VAny, VObject, VLiteral, VArray, VRecord, VUnion;
+var init_validators = __esm(() => {
+  init_value();
+  __defProp2 = Object.defineProperty;
+  VId = class VId extends BaseValidator {
+    constructor({
+      isOptional,
+      tableName
+    }) {
+      super({ isOptional });
+      __publicField(this, "tableName");
+      __publicField(this, "kind", "id");
+      if (typeof tableName !== "string") {
+        throw new Error("v.id(tableName) requires a string");
+      }
+      this.tableName = tableName;
+    }
+    get json() {
+      return { type: "id", tableName: this.tableName };
+    }
+    asOptional() {
+      return new VId({
+        isOptional: "optional",
+        tableName: this.tableName
+      });
+    }
+  };
+  VFloat64 = class VFloat64 extends BaseValidator {
+    constructor() {
+      super(...arguments);
+      __publicField(this, "kind", "float64");
+    }
+    get json() {
+      return { type: "number" };
+    }
+    asOptional() {
+      return new VFloat64({
+        isOptional: "optional"
+      });
+    }
+  };
+  VInt64 = class VInt64 extends BaseValidator {
+    constructor() {
+      super(...arguments);
+      __publicField(this, "kind", "int64");
+    }
+    get json() {
+      return { type: "bigint" };
+    }
+    asOptional() {
+      return new VInt64({ isOptional: "optional" });
+    }
+  };
+  VBoolean = class VBoolean extends BaseValidator {
+    constructor() {
+      super(...arguments);
+      __publicField(this, "kind", "boolean");
+    }
+    get json() {
+      return { type: this.kind };
+    }
+    asOptional() {
+      return new VBoolean({
+        isOptional: "optional"
+      });
+    }
+  };
+  VBytes = class VBytes extends BaseValidator {
+    constructor() {
+      super(...arguments);
+      __publicField(this, "kind", "bytes");
+    }
+    get json() {
+      return { type: this.kind };
+    }
+    asOptional() {
+      return new VBytes({ isOptional: "optional" });
+    }
+  };
+  VString = class VString extends BaseValidator {
+    constructor() {
+      super(...arguments);
+      __publicField(this, "kind", "string");
+    }
+    get json() {
+      return { type: this.kind };
+    }
+    asOptional() {
+      return new VString({
+        isOptional: "optional"
+      });
+    }
+  };
+  VNull = class VNull extends BaseValidator {
+    constructor() {
+      super(...arguments);
+      __publicField(this, "kind", "null");
+    }
+    get json() {
+      return { type: this.kind };
+    }
+    asOptional() {
+      return new VNull({ isOptional: "optional" });
+    }
+  };
+  VAny = class VAny extends BaseValidator {
+    constructor() {
+      super(...arguments);
+      __publicField(this, "kind", "any");
+    }
+    get json() {
+      return {
+        type: this.kind
+      };
+    }
+    asOptional() {
+      return new VAny({
+        isOptional: "optional"
+      });
+    }
+  };
+  VObject = class VObject extends BaseValidator {
+    constructor({
+      isOptional,
+      fields
+    }) {
+      super({ isOptional });
+      __publicField(this, "fields");
+      __publicField(this, "kind", "object");
+      globalThis.Object.entries(fields).forEach(([fieldName, validator]) => {
+        if (validator === undefined) {
+          throwUndefinedValidatorError("v.object()", fieldName);
+        }
+        if (!validator.isConvexValidator) {
+          throw new Error("v.object() entries must be validators");
+        }
+      });
+      this.fields = fields;
+    }
+    get json() {
+      return {
+        type: this.kind,
+        value: globalThis.Object.fromEntries(globalThis.Object.entries(this.fields).map(([k, v]) => [
+          k,
+          {
+            fieldType: v.json,
+            optional: v.isOptional === "optional" ? true : false
+          }
+        ]))
+      };
+    }
+    asOptional() {
+      return new VObject({
+        isOptional: "optional",
+        fields: this.fields
+      });
+    }
+    omit(...fields) {
+      const newFields = { ...this.fields };
+      for (const field of fields) {
+        delete newFields[field];
+      }
+      return new VObject({
+        isOptional: this.isOptional,
+        fields: newFields
+      });
+    }
+    pick(...fields) {
+      const newFields = {};
+      for (const field of fields) {
+        newFields[field] = this.fields[field];
+      }
+      return new VObject({
+        isOptional: this.isOptional,
+        fields: newFields
+      });
+    }
+    partial() {
+      const newFields = {};
+      for (const [key, validator] of globalThis.Object.entries(this.fields)) {
+        newFields[key] = validator.asOptional();
+      }
+      return new VObject({
+        isOptional: this.isOptional,
+        fields: newFields
+      });
+    }
+    extend(fields) {
+      return new VObject({
+        isOptional: this.isOptional,
+        fields: { ...this.fields, ...fields }
+      });
+    }
+  };
+  VLiteral = class VLiteral extends BaseValidator {
+    constructor({ isOptional, value }) {
+      super({ isOptional });
+      __publicField(this, "value");
+      __publicField(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");
+      }
+      this.value = value;
+    }
+    get json() {
+      return {
+        type: this.kind,
+        value: convexToJson(this.value)
+      };
+    }
+    asOptional() {
+      return new VLiteral({
+        isOptional: "optional",
+        value: this.value
+      });
+    }
+  };
+  VArray = class VArray extends BaseValidator {
+    constructor({
+      isOptional,
+      element
+    }) {
+      super({ isOptional });
+      __publicField(this, "element");
+      __publicField(this, "kind", "array");
+      if (element === undefined) {
+        throwUndefinedValidatorError("v.array()");
+      }
+      this.element = element;
+    }
+    get json() {
+      return {
+        type: this.kind,
+        value: this.element.json
+      };
+    }
+    asOptional() {
+      return new VArray({
+        isOptional: "optional",
+        element: this.element
+      });
+    }
+  };
+  VRecord = class VRecord extends BaseValidator {
+    constructor({
+      isOptional,
+      key,
+      value
+    }) {
+      super({ isOptional });
+      __publicField(this, "key");
+      __publicField(this, "value");
+      __publicField(this, "kind", "record");
+      if (key === undefined) {
+        throwUndefinedValidatorError("v.record()", "key");
+      }
+      if (value === undefined) {
+        throwUndefinedValidatorError("v.record()", "value");
+      }
+      if (key.isOptional === "optional") {
+        throw new Error("Record validator cannot have optional keys");
+      }
+      if (value.isOptional === "optional") {
+        throw new Error("Record validator cannot have optional values");
+      }
+      if (!key.isConvexValidator || !value.isConvexValidator) {
+        throw new Error("Key and value of v.record() but be validators");
+      }
+      this.key = key;
+      this.value = value;
+    }
+    get json() {
+      return {
+        type: this.kind,
+        keys: this.key.json,
+        values: {
+          fieldType: this.value.json,
+          optional: false
+        }
+      };
+    }
+    asOptional() {
+      return new VRecord({
+        isOptional: "optional",
+        key: this.key,
+        value: this.value
+      });
+    }
+  };
+  VUnion = class VUnion extends BaseValidator {
+    constructor({ isOptional, members }) {
+      super({ isOptional });
+      __publicField(this, "members");
+      __publicField(this, "kind", "union");
+      members.forEach((member, index) => {
+        if (member === undefined) {
+          throwUndefinedValidatorError("v.union()", `member at index ${index}`);
+        }
+        if (!member.isConvexValidator) {
+          throw new Error("All members of v.union() must be validators");
+        }
+      });
+      this.members = members;
+    }
+    get json() {
+      return {
+        type: this.kind,
+        value: this.members.map((v) => v.json)
+      };
+    }
+    asOptional() {
+      return new VUnion({
+        isOptional: "optional",
+        members: this.members
+      });
+    }
+  };
+});
+
+// ../core/node_modules/convex/dist/esm/values/validator.js
+function isValidator(v2) {
+  return !!v2.isConvexValidator;
+}
+function asObjectValidator(obj) {
+  if (isValidator(obj)) {
+    return obj;
+  } else {
+    return v.object(obj);
+  }
+}
+var v;
+var init_validator = __esm(() => {
+  init_validators();
+  v = {
+    id: (tableName) => {
+      return new VId({
+        isOptional: "required",
+        tableName
+      });
+    },
+    null: () => {
+      return new VNull({ isOptional: "required" });
+    },
+    number: () => {
+      return new VFloat64({ isOptional: "required" });
+    },
+    float64: () => {
+      return new VFloat64({ isOptional: "required" });
+    },
+    bigint: () => {
+      return new VInt64({ isOptional: "required" });
+    },
+    int64: () => {
+      return new VInt64({ isOptional: "required" });
+    },
+    boolean: () => {
+      return new VBoolean({ isOptional: "required" });
+    },
+    string: () => {
+      return new VString({ isOptional: "required" });
+    },
+    bytes: () => {
+      return new VBytes({ isOptional: "required" });
+    },
+    literal: (literal) => {
+      return new VLiteral({ isOptional: "required", value: literal });
+    },
+    array: (element) => {
+      return new VArray({ isOptional: "required", element });
+    },
+    object: (fields) => {
+      return new VObject({ isOptional: "required", fields });
+    },
+    record: (keys, values) => {
+      return new VRecord({
+        isOptional: "required",
+        key: keys,
+        value: values
+      });
+    },
+    union: (...members) => {
+      return new VUnion({
+        isOptional: "required",
+        members
+      });
+    },
+    any: () => {
+      return new VAny({ isOptional: "required" });
+    },
+    optional: (value) => {
+      return value.asOptional();
+    },
+    nullable: (value) => {
+      return v.union(value, v.null());
+    }
+  };
+});
+
+// ../core/node_modules/convex/dist/esm/values/errors.js
+var __defProp3, __defNormalProp2 = (obj, key, value) => (key in obj) ? __defProp3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value, __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value), _a, _b, IDENTIFYING_FIELD, ConvexError;
+var init_errors = __esm(() => {
+  init_value();
+  __defProp3 = Object.defineProperty;
+  IDENTIFYING_FIELD = Symbol.for("ConvexError");
+  ConvexError = class ConvexError extends (_b = Error, _a = IDENTIFYING_FIELD, _b) {
+    constructor(data) {
+      super(typeof data === "string" ? data : stringifyValueForError(data));
+      __publicField2(this, "name", "ConvexError");
+      __publicField2(this, "data");
+      __publicField2(this, _a, true);
+      this.data = data;
+    }
+  };
+});
+
+// ../core/node_modules/convex/dist/esm/values/index.js
+var init_values = __esm(() => {
+  init_value();
+  init_validator();
+  init_errors();
+});
+
+// ../core/node_modules/convex/dist/esm/index.js
+var version = "1.31.7";
+
+// ../core/node_modules/convex/dist/esm/server/impl/syscall.js
+function performSyscall(op, arg) {
+  if (typeof Convex === "undefined" || Convex.syscall === undefined) {
+    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 === undefined) {
+    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 !== undefined) {
+      const rethrown = new ConvexError(e.message);
+      rethrown.data = jsonToConvex(e.data);
+      throw rethrown;
+    }
+    throw new Error(e.message);
+  }
+  return JSON.parse(resultStr);
+}
+var init_syscall = __esm(() => {
+  init_errors();
+  init_value();
+});
+
+// ../core/node_modules/convex/dist/esm/server/functionName.js
+var functionName;
+var init_functionName = __esm(() => {
+  functionName = Symbol.for("functionName");
+});
+
+// ../core/node_modules/convex/dist/esm/server/components/paths.js
+function extractReferencePath(reference) {
+  return reference[toReferencePath] ?? null;
+}
+function isFunctionHandle(s) {
+  return s.startsWith("function://");
+}
+function getFunctionAddress(functionReference) {
+  let functionAddress;
+  if (typeof functionReference === "string") {
+    if (isFunctionHandle(functionReference)) {
+      functionAddress = { functionHandle: functionReference };
+    } else {
+      functionAddress = { name: functionReference };
+    }
+  } else if (functionReference[functionName]) {
+    functionAddress = { name: functionReference[functionName] };
+  } else {
+    const referencePath = extractReferencePath(functionReference);
+    if (!referencePath) {
+      throw new Error(`${functionReference} is not a functionReference`);
+    }
+    functionAddress = { reference: referencePath };
+  }
+  return functionAddress;
+}
+var toReferencePath;
+var init_paths = __esm(() => {
+  init_functionName();
+  toReferencePath = Symbol.for("toReferencePath");
+});
+
+// ../core/node_modules/convex/dist/esm/server/impl/validate.js
+function validateArg(arg, idx, method, argName) {
+  if (arg === undefined) {
+    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`);
+  }
+}
+
+// ../core/node_modules/convex/dist/esm/server/impl/authentication_impl.js
+function setupAuth(requestId) {
+  return {
+    getUserIdentity: async () => {
+      return await performAsyncSyscall("1.0/getUserIdentity", {
+        requestId
+      });
+    }
+  };
+}
+var init_authentication_impl = __esm(() => {
+  init_syscall();
+});
+
+// ../core/node_modules/convex/dist/esm/server/filter_builder.js
+class Expression {
+  constructor() {
+    __publicField3(this, "_isExpression");
+    __publicField3(this, "_value");
+  }
+}
+var __defProp4, __defNormalProp3 = (obj, key, value) => (key in obj) ? __defProp4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value, __publicField3 = (obj, key, value) => __defNormalProp3(obj, typeof key !== "symbol" ? key + "" : key, value);
+var init_filter_builder = __esm(() => {
+  __defProp4 = Object.defineProperty;
+});
+
+// ../core/node_modules/convex/dist/esm/server/impl/filter_builder_impl.js
+function serializeExpression(expr) {
+  if (expr instanceof ExpressionImpl) {
+    return expr.serialize();
+  } else {
+    return { $literal: convexOrUndefinedToJson(expr) };
+  }
+}
+var __defProp5, __defNormalProp4 = (obj, key, value) => (key in obj) ? __defProp5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value, __publicField4 = (obj, key, value) => __defNormalProp4(obj, typeof key !== "symbol" ? key + "" : key, value), ExpressionImpl, filterBuilderImpl;
+var init_filter_builder_impl = __esm(() => {
+  init_value();
+  init_filter_builder();
+  __defProp5 = Object.defineProperty;
+  ExpressionImpl = class ExpressionImpl extends Expression {
+    constructor(inner) {
+      super();
+      __publicField4(this, "inner");
+      this.inner = inner;
+    }
+    serialize() {
+      return this.inner;
+    }
+  };
+  filterBuilderImpl = {
+    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)]
+      });
+    },
+    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) });
+    },
+    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) });
+    },
+    field(fieldPath) {
+      return new ExpressionImpl({ $field: fieldPath });
+    }
+  };
+});
+
+// ../core/node_modules/convex/dist/esm/server/index_range_builder.js
+class IndexRange {
+  constructor() {
+    __publicField5(this, "_isIndexRange");
+  }
+}
+var __defProp6, __defNormalProp5 = (obj, key, value) => (key in obj) ? __defProp6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value, __publicField5 = (obj, key, value) => __defNormalProp5(obj, typeof key !== "symbol" ? key + "" : key, value);
+var init_index_range_builder = __esm(() => {
+  __defProp6 = Object.defineProperty;
+});
+
+// ../core/node_modules/convex/dist/esm/server/impl/index_range_builder_impl.js
+var __defProp7, __defNormalProp6 = (obj, key, value) => (key in obj) ? __defProp7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value, __publicField6 = (obj, key, value) => __defNormalProp6(obj, typeof key !== "symbol" ? key + "" : key, value), IndexRangeBuilderImpl;
+var init_index_range_builder_impl = __esm(() => {
+  init_value();
+  init_index_range_builder();
+  __defProp7 = Object.defineProperty;
+  IndexRangeBuilderImpl = class IndexRangeBuilderImpl extends IndexRange {
+    constructor(rangeExpressions) {
+      super();
+      __publicField6(this, "rangeExpressions");
+      __publicField6(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;
+    }
+  };
+});
+
+// ../core/node_modules/convex/dist/esm/server/search_filter_builder.js
+class SearchFilter {
+  constructor() {
+    __publicField7(this, "_isSearchFilter");
+  }
+}
+var __defProp8, __defNormalProp7 = (obj, key, value) => (key in obj) ? __defProp8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value, __publicField7 = (obj, key, value) => __defNormalProp7(obj, typeof key !== "symbol" ? key + "" : key, value);
+var init_search_filter_builder = __esm(() => {
+  __defProp8 = Object.defineProperty;
+});
+
+// ../core/node_modules/convex/dist/esm/server/impl/search_filter_builder_impl.js
+var __defProp9, __defNormalProp8 = (obj, key, value) => (key in obj) ? __defProp9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value, __publicField8 = (obj, key, value) => __defNormalProp8(obj, typeof key !== "symbol" ? key + "" : key, value), SearchFilterBuilderImpl;
+var init_search_filter_builder_impl = __esm(() => {
+  init_value();
+  init_search_filter_builder();
+  __defProp9 = Object.defineProperty;
+  SearchFilterBuilderImpl = class SearchFilterBuilderImpl extends SearchFilter {
+    constructor(filters) {
+      super();
+      __publicField8(this, "filters");
+      __publicField8(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;
+    }
+  };
+});
+
+// ../core/node_modules/convex/dist/esm/server/impl/query_impl.js
+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.");
+}
+var __defProp10, __defNormalProp9 = (obj, key, value) => (key in obj) ? __defProp10(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value, __publicField9 = (obj, key, value) => __defNormalProp9(obj, typeof key !== "symbol" ? key + "" : key, value), MAX_QUERY_OPERATORS = 256, QueryInitializerImpl, QueryImpl;
+var init_query_impl = __esm(() => {
+  init_values();
+  init_syscall();
+  init_filter_builder_impl();
+  init_index_range_builder_impl();
+  init_search_filter_builder_impl();
+  __defProp10 = Object.defineProperty;
+  QueryInitializerImpl = class QueryInitializerImpl {
+    constructor(tableName) {
+      __publicField9(this, "tableName");
+      this.tableName = tableName;
+    }
+    withIndex(indexName, indexRange) {
+      validateArg(indexName, 1, "withIndex", "indexName");
+      let rangeBuilder = IndexRangeBuilderImpl.new();
+      if (indexRange !== undefined) {
+        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);
+    }
+    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]();
+    }
+  };
+  QueryImpl = class QueryImpl {
+    constructor(query) {
+      __publicField9(this, "state");
+      __publicField9(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: undefined });
+    }
+    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];
+    }
+  };
+});
+
+// ../core/node_modules/convex/dist/esm/server/impl/database_impl.js
+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 !== undefined ? await get(arg0, arg1, isSystem) : await get(undefined, 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;
+      },
+      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 !== undefined ? await patch(arg0, arg1, arg2) : await patch(undefined, arg0, arg1);
+    },
+    replace: async (arg0, arg1, arg2) => {
+      return arg2 !== undefined ? await replace(arg0, arg1, arg2) : await replace(undefined, arg0, arg1);
+    },
+    delete: async (arg0, arg1) => {
+      return arg1 !== undefined ? await delete_(arg0, arg1) : await delete_(undefined, 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);
+  }
+}
+var TableWriter;
+var init_database_impl = __esm(() => {
+  init_values();
+  init_syscall();
+  init_query_impl();
+  init_value();
+  TableWriter = 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);
+    }
+  };
+});
+
+// ../core/node_modules/convex/dist/esm/server/impl/scheduler_impl.js
+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) / 1000;
+  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() / 1000;
+  } else if (typeof ms_since_epoch_or_date === "number") {
+    ts = ms_since_epoch_or_date / 1000;
+  } 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
+  };
+}
+var init_scheduler_impl = __esm(() => {
+  init_values();
+  init_syscall();
+  init_paths();
+});
+
+// ../core/node_modules/convex/dist/esm/server/impl/storage_impl.js
+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
+  };
+}
+var init_storage_impl = __esm(() => {
+  init_syscall();
+});
+
+// ../core/node_modules/convex/dist/esm/server/impl/registration_impl.js
+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 === undefined ? 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 && Symbol.for("ConvexError") in thrown) {
+    const error = thrown;
+    error.data = JSON.stringify(convexToJson(error.data === undefined ? null : error.data));
+    error.ConvexErrorSymbol = 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 === undefined) {
+    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 !== undefined) {
+      args = asObjectValidator(functionDefinition.args);
+    }
+    return JSON.stringify(args.json, strictReplacer);
+  };
+}
+function exportReturns(functionDefinition) {
+  return () => {
+    let returns;
+    if (typeof functionDefinition === "object" && functionDefinition.returns !== undefined) {
+      returns = asObjectValidator(functionDefinition.returns);
+    }
+    return JSON.stringify(returns ? returns.json : null, strictReplacer);
+  };
+}
+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 === undefined ? null : result));
+}
+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);
+}
+var 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;
+}, 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;
+};
+var init_registration_impl = __esm(() => {
+  init_values();
+  init_authentication_impl();
+  init_database_impl();
+  init_query_impl();
+  init_scheduler_impl();
+  init_storage_impl();
+  init_syscall();
+  init_validator();
+  init_paths();
+});
+
+// ../core/node_modules/convex/dist/esm/server/pagination.js
+var paginationOptsValidator;
+var init_pagination = __esm(() => {
+  init_validator();
+  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())
+  });
+});
+
+// ../core/node_modules/convex/dist/esm/server/index.js
+var init_server = __esm(() => {
+  init_registration_impl();
+  init_pagination();
+  init_search_filter_builder();
+});
+
+// ../core/dist/system/system-functions-module.js
+function getSystemFunctionsModule() {
+  return systemFunctions;
+}
+var systemFunctions;
+var init_system_functions_module = __esm(() => {
+  init_server();
+  init_internal();
+  systemFunctions = createSystemFunctions({
+    query: queryGeneric,
+    mutation: mutationGeneric
+  });
+});
+
+// ../core/dist/udf/module-loader/module-loader.js
+var exports_module_loader = {};
+__export(exports_module_loader, {
+  withModuleRegistry: () => withModuleRegistry,
+  setModuleLoaderMetadata: () => setModuleLoaderMetadata,
+  setDefaultModuleRegistry: () => setDefaultModuleRegistry,
+  setConcaveModuleLoader: () => setConcaveModuleLoader,
+  resetModuleState: () => resetModuleState,
+  registerModuleLoader: () => registerModuleLoader,
+  onModuleLoadersChanged: () => onModuleLoadersChanged,
+  loadConvexModule: () => loadConvexModule,
+  listRegisteredModules: () => listRegisteredModules,
+  getModuleRegistry: () => getModuleRegistry,
+  getModuleLoaderMetadata: () => getModuleLoaderMetadata,
+  getConcaveModuleLoader: () => getConcaveModuleLoader,
+  createModuleLoaderFromGlob: () => createModuleLoaderFromGlob,
+  clearModuleLoader: () => clearModuleLoader,
+  ModuleRegistry: () => ModuleRegistry
+});
+import { AsyncLocalStorage } from "async_hooks";
+
+class ModuleRegistry {
+  scopedLoaders = new Map;
+  constructor(defaults = []) {
+    this.reset(defaults, { suppressEmit: true });
+  }
+  reset(defaults, options = {}) {
+    this.scopedLoaders.clear();
+    this.scopedLoaders.set("", defaults.map(createRegisteredLoader));
+    if (!options.suppressEmit) {
+      emitModuleLoadersChanged();
+    }
+  }
+  clone() {
+    const next = new ModuleRegistry;
+    for (const [scope, loaders] of this.scopedLoaders.entries()) {
+      next.scopedLoaders.set(scope, loaders.map(cloneRegisteredLoader));
+    }
+    return next;
+  }
+  setScopeLoaders(scope, loaders) {
+    const normalizedScope = normalizeComponentPath(scope);
+    this.scopedLoaders.set(normalizedScope, loaders.map(createRegisteredLoader));
+    emitModuleLoadersChanged();
+  }
+  setRootLoaders(loaders) {
+    this.setScopeLoaders("", loaders);
+  }
+  register(loader, options = {}) {
+    const scope = normalizeComponentPath(options.componentPath ?? "");
+    const list = this.scopedLoaders.get(scope) ?? [];
+    const entry = createRegisteredLoader(loader);
+    if (options.prepend) {
+      list.unshift(entry);
+    } else {
+      list.push(entry);
+    }
+    this.scopedLoaders.set(scope, list);
+    emitModuleLoadersChanged();
+    return () => {
+      const current = this.scopedLoaders.get(scope);
+      if (!current)
+        return;
+      const index = current.indexOf(entry);
+      if (index >= 0) {
+        current.splice(index, 1);
+      }
+      this.scopedLoaders.set(scope, current);
+      emitModuleLoadersChanged();
+    };
+  }
+  async load(request) {
+    const scopes = expandComponentScopes(request.componentPath);
+    const errors2 = [];
+    let attempted = false;
+    for (const scope of scopes) {
+      const loaders = this.scopedLoaders.get(scope);
+      if (!loaders || loaders.length === 0) {
+        continue;
+      }
+      for (const entry of loaders) {
+        attempted = true;
+        try {
+          const result = await entry.loader(request.path, { ...request, scope: scope || undefined });
+          if (result !== undefined) {
+            return result;
+          }
+        } catch (error2) {
+          errors2.push(error2);
+        }
+      }
+    }
+    const description = request.componentPath ? `module "${request.path}" for component "${request.componentPath}"` : `module "${request.path}"`;
+    if (!attempted) {
+      throw new Error(`Unable to resolve ${description}. No module loaders are registered${request.componentPath ? ` for component "${request.componentPath}"` : ""}. Register a loader with runtime worker options (\`moduleLoader\`, \`moduleLoaders\`, or \`configureModuleLoaders\`).`);
+    }
+    const error = new Error(`Unable to resolve ${description}`);
+    if (errors2.length > 0) {
+      error.causes = errors2;
+    }
+    throw error;
+  }
+  async enumerate(request = {}) {
+    const scopes = request.componentPath ? expandComponentScopes(request.componentPath) : Array.from(this.scopedLoaders.keys());
+    const results = new Map;
+    for (const scope of scopes) {
+      const loaders = this.scopedLoaders.get(scope);
+      if (!loaders || loaders.length === 0) {
+        continue;
+      }
+      for (const entry of loaders) {
+        const enumerate = entry.metadata?.enumerate;
+        if (!enumerate)
+          continue;
+        try {
+          const listings = await collectEnumerationResults(enumerate({ componentPath: request.componentPath, hint: request.hint, scope: scope || undefined }));
+          for (const listing of listings) {
+            const normalized = normalizeModuleListing(listing);
+            if (!normalized)
+              continue;
+            if (!results.has(normalized.path)) {
+              results.set(normalized.path, {
+                ...normalized,
+                scope: scope || undefined,
+                componentPath: normalized.componentPath ?? (scope || undefined)
+              });
+            }
+          }
+        } catch (error) {
+          console.debug("[ModuleLoader] Failed to enumerate modules:", error);
+        }
+      }
+    }
+    return Array.from(results.values());
+  }
+}
+function emitModuleLoadersChanged() {
+  const state = getModuleState();
+  for (const listener of Array.from(state.listeners)) {
+    try {
+      listener();
+    } catch (error) {
+      console.error("Error in module loader change listener:", error);
+    }
+  }
+}
+function getModuleState() {
+  const globalAny = globalThis;
+  let state = globalAny[MODULE_STATE_SYMBOL];
+  if (!state) {
+    const defaults = [];
+    state = {
+      registry: new ModuleRegistry(defaults),
+      defaults,
+      listeners: new Set
+    };
+    globalAny[MODULE_STATE_SYMBOL] = state;
+  }
+  return state;
+}
+function resetModuleState() {
+  const globalAny = globalThis;
+  delete globalAny[MODULE_STATE_SYMBOL];
+}
+function getModuleRegistry() {
+  return MODULE_REGISTRY_CONTEXT.getStore() ?? getModuleState().registry;
+}
+function withModuleRegistry(registry, fn) {
+  return MODULE_REGISTRY_CONTEXT.run(registry, fn);
+}
+function setDefaultModuleRegistry(registry) {
+  getModuleState().registry = registry;
+}
+function setConcaveModuleLoader(loader, options = {}) {
+  const loaders = Array.isArray(loader) ? loader : [loader];
+  const state = getModuleState();
+  const registry = state.registry;
+  if (options.componentPath) {
+    registry.setScopeLoaders(options.componentPath, loaders);
+  } else {
+    registry.setRootLoaders(loaders);
+  }
+}
+function registerModuleLoader(loader, options = {}) {
+  return getModuleRegistry().register(loader, options);
+}
+function clearModuleLoader() {
+  const state = getModuleState();
+  state.registry.reset(state.defaults);
+}
+async function loadConvexModule(specifier, options = {}) {
+  const request = normalizeModuleRequest(specifier, options);
+  if (request.path === "_system") {
+    try {
+      return await getModuleRegistry().load(request);
+    } catch (error) {
+      if (error?.message?.includes("Unable to resolve")) {
+        return getSystemFunctionsModule();
+      }
+      throw error;
+    }
+  }
+  return getModuleRegistry().load(request);
+}
+function getConcaveModuleLoader() {
+  return async (modulePath, context) => {
+    const request = normalizeModuleRequest(modulePath, {
+      componentPath: context?.componentPath,
+      hint: context?.hint
+    });
+    const scope = context?.scope;
+    if (scope) {
+      request.scope = scope;
+    }
+    return getModuleRegistry().load(request);
+  };
+}
+async function listRegisteredModules(options = {}) {
+  const listings = await getModuleRegistry().enumerate(options);
+  return listings.map(({ scope, ...rest }) => ({
+    ...rest,
+    componentPath: rest.componentPath ?? scope ?? undefined
+  }));
+}
+function setModuleLoaderMetadata(loader, metadata) {
+  loader[MODULE_LOADER_METADATA_SYMBOL] = metadata;
+}
+function getModuleLoaderMetadata(loader) {
+  return loader[MODULE_LOADER_METADATA_SYMBOL];
+}
+function onModuleLoadersChanged(listener) {
+  const state = getModuleState();
+  state.listeners.add(listener);
+  return () => {
+    state.listeners.delete(listener);
+  };
+}
+function createModuleLoaderFromGlob(registry, options = {}) {
+  const normalizedEntries = new Map;
+  const canonicalEntries = new Map;
+  for (const [rawKey, entry] of Object.entries(registry)) {
+    const key = normalizeRegistryKey(rawKey, options.trimPrefix);
+    const loader2 = memoizeEntry(entry);
+    normalizedEntries.set(key, loader2);
+    normalizedEntries.set(removeExtension(key), loader2);
+    const canonical = removeExtension(key);
+    if (!canonicalEntries.has(canonical)) {
+      canonicalEntries.set(canonical, {
+        loader: loader2,
+        source: key
+      });
+    }
+  }
+  const loader = async (modulePath) => {
+    const normalized = ensureExtension(normalizeModulePath(modulePath));
+    const load = normalizedEntries.get(normalized) ?? normalizedEntries.get(removeExtension(normalized));
+    if (!load) {
+      return;
+    }
+    return load();
+  };
+  setModuleLoaderMetadata(loader, {
+    enumerate: () => Array.from(canonicalEntries.entries()).map(([path, info]) => ({
+      path,
+      source: normalizeSourcePath(info.source)
+    }))
+  });
+  return loader;
+}
+function memoizeEntry(entry) {
+  if (typeof entry === "function") {
+    let cached;
+    return () => {
+      if (!cached) {
+        cached = Promise.resolve(entry());
+      }
+      return cached;
+    };
+  }
+  const resolved = Promise.resolve(entry);
+  return () => resolved;
+}
+function normalizeModuleRequest(specifier, options) {
+  if (typeof specifier === "string") {
+    return {
+      path: normalizeModulePath(specifier),
+      componentPath: options.componentPath,
+      hint: options.hint
+    };
+  }
+  return {
+    path: normalizeModulePath(specifier.path),
+    componentPath: specifier.componentPath ?? options.componentPath,
+    hint: specifier.hint ?? options.hint,
+    scope: specifier.scope
+  };
+}
+function normalizeModulePath(path) {
+  const trimmed = path.trim();
+  if (!trimmed) {
+    throw new Error("Module path must be a non-empty string");
+  }
+  let sanitized = trimmed.replace(/\\/g, "/");
+  while (sanitized.startsWith("./") || sanitized.startsWith("../")) {
+    sanitized = sanitized.startsWith("./") ? sanitized.slice(2) : sanitized.slice(3);
+  }
+  if (sanitized.startsWith("convex/")) {
+    sanitized = sanitized.slice("convex/".length);
+  }
+  return sanitized.replace(/^\/+/, "");
+}
+function normalizeComponentPath(componentPath) {
+  if (!componentPath) {
+    return "";
+  }
+  return normalizeModulePath(componentPath);
+}
+function expandComponentScopes(componentPath) {
+  const scopes = [];
+  if (componentPath) {
+    const normalized = normalizeComponentPath(componentPath);
+    const segments = normalized.split("/").filter(Boolean);
+    for (let i2 = segments.length;i2 > 0; i2--) {
+      scopes.push(segments.slice(0, i2).join("/"));
+    }
+  }
+  scopes.push("");
+  return scopes;
+}
+function ensureExtension(path) {
+  if (/\.[a-zA-Z0-9]+$/.test(path)) {
+    return path;
+  }
+  return `${path}.ts`;
+}
+function removeExtension(path) {
+  return path.replace(/\.[^.]+$/, "");
+}
+function normalizeRegistryKey(key, trimPrefix) {
+  let normalized = key.replace(/\\/g, "/");
+  while (normalized.startsWith("./") || normalized.startsWith("../")) {
+    normalized = normalized.startsWith("./") ? normalized.slice(2) : normalized.slice(3);
+  }
+  if (trimPrefix) {
+    const prefix = normalizeModulePath(trimPrefix);
+    if (prefix && normalized.startsWith(prefix)) {
+      normalized = normalized.slice(prefix.length);
+    }
+  }
+  if (normalized.startsWith("convex/")) {
+    normalized = normalized.slice("convex/".length);
+  }
+  return normalizeModulePath(normalized);
+}
+function createRegisteredLoader(loader) {
+  return {
+    loader,
+    metadata: getModuleLoaderMetadata(loader)
+  };
+}
+function cloneRegisteredLoader(entry) {
+  return {
+    loader: entry.loader,
+    metadata: entry.metadata
+  };
+}
+async function collectEnumerationResults(result) {
+  const awaited = result instanceof Promise ? await result : result;
+  if (!awaited) {
+    return [];
+  }
+  if (typeof awaited === "string" || isModuleListingLike(awaited)) {
+    return [awaited];
+  }
+  if (isAsyncIterable(awaited)) {
+    const collected = [];
+    for await (const item of awaited) {
+      if (typeof item === "string" || isModuleListingLike(item)) {
+        collected.push(item);
+      }
+    }
+    return collected;
+  }
+  if (isIterable(awaited)) {
+    const collected = [];
+    for (const item of awaited) {
+      if (typeof item === "string" || isModuleListingLike(item)) {
+        collected.push(item);
+      }
+    }
+    return collected;
+  }
+  return [];
+}
+function normalizeModuleListing(listing) {
+  if (typeof listing === "string") {
+    const canonical = removeExtension(normalizeModulePath(listing));
+    return { path: canonical };
+  }
+  if (!listing || typeof listing.path !== "string") {
+    return null;
+  }
+  const normalizedPath = removeExtension(normalizeModulePath(listing.path));
+  const normalizedSource = listing.source ? normalizeSourcePath(listing.source) : undefined;
+  return {
+    path: normalizedPath,
+    source: normalizedSource,
+    componentPath: listing.componentPath ? normalizeComponentPath(listing.componentPath) : undefined,
+    hint: listing.hint
+  };
+}
+function normalizeSourcePath(path) {
+  if (!path)
+    return;
+  const normalized = ensureExtension(normalizeModulePath(path));
+  return normalized.startsWith("convex/") ? normalized : `convex/${normalized}`;
+}
+function isModuleListingLike(value) {
+  return value && typeof value === "object" && typeof value.path === "string";
+}
+function isIterable(value) {
+  return value && typeof value[Symbol.iterator] === "function";
+}
+function isAsyncIterable(value) {
+  return value && typeof value[Symbol.asyncIterator] === "function";
+}
+var MODULE_STATE_SYMBOL, MODULE_LOADER_METADATA_SYMBOL, MODULE_REGISTRY_CONTEXT;
+var init_module_loader = __esm(() => {
+  init_system_functions_module();
+  MODULE_STATE_SYMBOL = Symbol.for("concave.moduleLoader.state");
+  MODULE_LOADER_METADATA_SYMBOL = Symbol.for("concave.moduleLoader.metadata");
+  MODULE_REGISTRY_CONTEXT = new AsyncLocalStorage;
+});
+
+// ../core/dist/utils/utils.js
+function hexToArrayBuffer(hex) {
+  if (hex === "") {
+    return new Uint8Array(0).buffer;
+  }
+  const matches = hex.match(/.{1,2}/g);
+  if (!matches) {
+    throw new Error(`Invalid hex string: ${hex}`);
+  }
+  return new Uint8Array(matches.map((byte) => parseInt(byte, 16))).buffer;
+}
+function hexToString(hex) {
+  const buffer = hexToArrayBuffer(hex);
+  return new TextDecoder().decode(buffer);
+}
+function deserializeDeveloperId(developerId) {
+  if (!developerId) {
+    return null;
+  }
+  for (const separator of [DOC_ID_SEPARATOR, LEGACY_DOC_ID_SEPARATOR]) {
+    const parts = developerId.split(separator);
+    if (parts.length === 2 && parts[0] && parts[1]) {
+      return { table: parts[0], internalId: parts[1] };
+    }
+  }
+  return null;
+}
+var DOC_ID_SEPARATOR = ":", LEGACY_DOC_ID_SEPARATOR = ";";
+
+// ../core/dist/queryengine/indexing/index-key-codec.js
+var TypeTag;
+var init_index_key_codec = __esm(() => {
+  (function(TypeTag2) {
+    TypeTag2[TypeTag2["Null"] = 0] = "Null";
+    TypeTag2[TypeTag2["False"] = 16] = "False";
+    TypeTag2[TypeTag2["True"] = 17] = "True";
+    TypeTag2[TypeTag2["NegativeInfinity"] = 32] = "NegativeInfinity";
+    TypeTag2[TypeTag2["NegativeNumber"] = 33] = "NegativeNumber";
+    TypeTag2[TypeTag2["NegativeZero"] = 34] = "NegativeZero";
+    TypeTag2[TypeTag2["Zero"] = 35] = "Zero";
+    TypeTag2[TypeTag2["PositiveNumber"] = 36] = "PositiveNumber";
+    TypeTag2[TypeTag2["PositiveInfinity"] = 37] = "PositiveInfinity";
+    TypeTag2[TypeTag2["NaN"] = 38] = "NaN";
+    TypeTag2[TypeTag2["NegativeBigInt"] = 48] = "NegativeBigInt";
+    TypeTag2[TypeTag2["ZeroBigInt"] = 49] = "ZeroBigInt";
+    TypeTag2[TypeTag2["PositiveBigInt"] = 50] = "PositiveBigInt";
+    TypeTag2[TypeTag2["String"] = 64] = "String";
+    TypeTag2[TypeTag2["Bytes"] = 80] = "Bytes";
+  })(TypeTag || (TypeTag = {}));
+});
+
+// ../core/dist/queryengine/indexing/index-manager.js
+function getStandardIndexes() {
+  return [
+    {
+      name: "by_creation_time",
+      fields: ["_creationTime", "_id"]
+    },
+    {
+      name: "by_id",
+      fields: ["_id"]
+    }
+  ];
+}
+var init_index_manager = __esm(() => {
+  init_index_key_codec();
+});
+
+// ../core/dist/tables/interface.js
+function getFullTableName(tableName, componentPath) {
+  if (!componentPath || componentPath === "") {
+    return tableName;
+  }
+  return `${componentPath}/${tableName}`;
+}
+function parseFullTableName(fullName) {
+  const lastSlash = fullName.lastIndexOf("/");
+  if (lastSlash === -1) {
+    return { tableName: fullName, componentPath: "" };
+  }
+  return {
+    componentPath: fullName.substring(0, lastSlash),
+    tableName: fullName.substring(lastSlash + 1)
+  };
+}
+var init_interface = () => {};
+
+// ../core/dist/udf/analysis/validator.js
+class SchemaValidator {
+  schemaCache = new Map;
+  componentPath;
+  constructor(componentPath) {
+    this.componentPath = componentPath;
+  }
+  async loadTableSchema(tableName) {
+    if (this.schemaCache.has(tableName)) {
+      return this.schemaCache.get(tableName);
+    }
+    try {
+      const schemaModule = await loadConvexModule("schema", { hint: "schema", componentPath: this.componentPath });
+      const schema = schemaModule.default;
+      if (schema?.schemaValidation === false) {
+        return null;
+      }
+      if (!schema || !schema.tables || !schema.tables[tableName]) {
+        return null;
+      }
+      const tableSchema = schema.tables[tableName];
+      let validator;
+      if (typeof tableSchema.export === "function") {
+        const exportedSchema = tableSchema.export();
+        validator = exportedSchema.documentType;
+      } else if (tableSchema.validator) {
+        validator = tableSchema.validator;
+      } else {
+        return null;
+      }
+      this.schemaCache.set(tableName, validator);
+      return validator;
+    } catch (error) {
+      if (!isMissingSchemaModuleError(error)) {
+        console.debug(`Failed to load schema for table ${tableName}:`, error);
+      }
+      return null;
+    }
+  }
+  async validateDocument(tableName, document) {
+    if (tableName.startsWith("_")) {
+      return;
+    }
+    const tableSchema = await this.loadTableSchema(tableName);
+    if (!tableSchema) {
+      return;
+    }
+    try {
+      validateValidator(tableSchema, omit(document, ["_id", "_creationTime"]), "", {
+        componentPath: this.componentPath ?? ""
+      });
+    } catch (error) {
+      throw new ValidatorError(`Failed to insert or update a document in table "${tableName}" because it does not match the schema: ${error.message}`);
+    }
+  }
+  clearCache() {
+    this.schemaCache.clear();
+  }
+}
+function omit(obj, keys) {
+  return Object.fromEntries(Object.entries(obj).filter(([key]) => !keys.includes(key)));
+}
+function validateValidator(validator, value, path = "", options = {}) {
+  const formatPath = (p) => p || ".";
+  const formatValue = (v2) => {
+    if (v2 === null)
+      return "null";
+    if (v2 === undefined)
+      return "undefined";
+    if (typeof v2 === "string")
+      return `"${v2}"`;
+    return String(v2);
+  };
+  switch (validator.type) {
+    case "null": {
+      if (value !== null) {
+        throw new Error(`Value does not match validator.
+Path: ${formatPath(path)}
+Value: ${formatValue(value)}
+Validator: v.null()`);
+      }
+      return;
+    }
+    case "number": {
+      if (typeof value !== "number") {
+        throw new Error(`Value does not match validator.
+Path: ${formatPath(path)}
+Value: ${formatValue(value)}
+Validator: v.float64()`);
+      }
+      return;
+    }
+    case "bigint": {
+      if (typeof value !== "bigint") {
+        throw new Error(`Value does not match validator.
+Path: ${formatPath(path)}
+Value: ${formatValue(value)}
+Validator: v.int64()`);
+      }
+      return;
+    }
+    case "boolean": {
+      if (typeof value !== "boolean") {
+        throw new Error(`Value does not match validator.
+Path: ${formatPath(path)}
+Value: ${formatValue(value)}
+Validator: v.boolean()`);
+      }
+      return;
+    }
+    case "string": {
+      if (typeof value !== "string") {
+        throw new Error(`Value does not match validator.
+Path: ${formatPath(path)}
+Value: ${formatValue(value)}
+Validator: v.string()`);
+      }
+      return;
+    }
+    case "bytes": {
+      if (!(value instanceof ArrayBuffer)) {
+        throw new Error(`Value does not match validator.
+Path: ${formatPath(path)}
+Value: ${formatValue(value)}
+Validator: v.bytes()`);
+      }
+      return;
+    }
+    case "any": {
+      return;
+    }
+    case "literal": {
+      if (value !== validator.value) {
+        throw new Error(`Value does not match validator.
+Path: ${formatPath(path)}
+Value: ${formatValue(value)}
+Validator: v.literal(${formatValue(validator.value)})`);
+      }
+      return;
+    }
+    case "id": {
+      if (typeof value !== "string") {
+        throw new Error(`Value does not match validator.
+Path: ${formatPath(path)}
+Value: ${formatValue(value)}
+Validator: v.id("${validator.tableName}")`);
+      }
+      const tableName = tableNameFromId(value);
+      if (!tableName || !isMatchingValidatorTable(tableName, validator.tableName, options.componentPath)) {
+        throw new Error(`Value does not match validator.
+Path: ${formatPath(path)}
+Value: ${formatValue(value)}
+Validator: v.id("${validator.tableName}")`);
+      }
+      return;
+    }
+    case "array": {
+      if (!Array.isArray(value)) {
+        throw new Error(`Value does not match validator.
+Path: ${formatPath(path)}
+Value: ${formatValue(value)}
+Validator: v.array(...)`);
+      }
+      for (let i2 = 0;i2 < value.length; i2++) {
+        validateValidator(validator.value, value[i2], `${path}[${i2}]`, options);
+      }
+      return;
+    }
+    case "union": {
+      let isValid = false;
+      for (const v2 of validator.value) {
+        try {
+          validateValidator(v2, value, path, options);
+          isValid = true;
+          break;
+        } catch (_e) {}
+      }
+      if (!isValid) {
+        throw new Error(`Value does not match validator.
+Path: ${formatPath(path)}
+Value: ${formatValue(value)}
+Validator: v.union(...)`);
+      }
+      return;
+    }
+    case "object": {
+      if (typeof value !== "object") {
+        throw new Error(`Value does not match validator.
+Path: ${formatPath(path)}
+Value: ${formatValue(value)}
+Validator: v.object({...})`);
+      }
+      if (!isSimpleObject2(value)) {
+        throw new Error(`Value does not match validator.
+Path: ${formatPath(path)}
+Value: ${formatValue(value)}
+Validator: v.object({...})`);
+      }
+      for (const [k, { fieldType, optional }] of Object.entries(validator.value)) {
+        if (value[k] === undefined) {
+          if (!optional) {
+            throw new Error(`Object is missing the required field \`${k}\`. Consider wrapping the field validator in \`v.optional(...)\` if this is expected.
+
+Object: ${JSON.stringify(value)}
+Validator: v.object({...})`);
+          }
+        } else {
+          const fieldPath = path ? `${path}.${k}` : `.${k}`;
+          validateValidator(fieldType, value[k], fieldPath, options);
+        }
+      }
+      for (const k of Object.keys(value)) {
+        if (validator.value[k] === undefined) {
+          throw new Error(`Object contains extra field \`${k}\` that is not in the validator.
+
+Object: ${JSON.stringify(value)}
+Validator: v.object({...})`);
+        }
+      }
+      return;
+    }
+  }
+}
+function tableNameFromId(id) {
+  const parts = deserializeDeveloperId(id);
+  if (!parts) {
+    return null;
+  }
+  return hexToString(parts.table);
+}
+function isMatchingValidatorTable(idTableName, validatorTableName, componentPath) {
+  if (idTableName === validatorTableName) {
+    return true;
+  }
+  const { tableName: validatorBareName } = parseFullTableName(validatorTableName);
+  const { tableName: idBareName } = parseFullTableName(idTableName);
+  if (componentPath !== undefined) {
+    const expectedFullName = getFullTableName(validatorBareName, componentPath);
+    return idTableName === expectedFullName;
+  }
+  return idBareName === validatorBareName;
+}
+function isSimpleObject2(value) {
+  const isObject = typeof value === "object";
+  const prototype = Object.getPrototypeOf(value);
+  const isSimple = prototype === null || prototype === Object.prototype || prototype?.constructor?.name === "Object";
+  return isObject && isSimple;
+}
+var ValidatorError;
+var init_validator2 = __esm(() => {
+  init_interface();
+  init_module_loader();
+  init_schema_service();
+  ValidatorError = class ValidatorError extends Error {
+    path;
+    constructor(message, path = "") {
+      super(message);
+      this.path = path;
+      this.name = "ValidatorError";
+    }
+  };
+});
+
+// ../core/dist/kernel/schema-service.js
+class SchemaService {
+  cachedSchemaDefinition = undefined;
+  tableCache = new Map;
+  schemaValidator;
+  componentPath;
+  constructor(componentPath) {
+    this.componentPath = componentPath;
+    this.schemaValidator = new SchemaValidator(componentPath);
+  }
+  async validate(tableName, document) {
+    try {
+      await this.schemaValidator.validateDocument(tableName, document);
+    } catch (error) {
+      if (error instanceof ValidatorError) {
+        throw new Error(error.message);
+      }
+      throw error;
+    }
+  }
+  async getTableSchema(tableName) {
+    if (this.tableCache.has(tableName)) {
+      return this.tableCache.get(tableName) ?? null;
+    }
+    const schemaDefinition = await this.getSchemaDefinition();
+    const tableSchema = schemaDefinition?.tables?.[tableName] ?? null;
+    this.tableCache.set(tableName, tableSchema);
+    return tableSchema;
+  }
+  async getIndexFieldsForTable(tableName, indexDescriptor) {
+    if (indexDescriptor === "by_creation_time") {
+      return ["_creationTime", "_id"];
+    }
+    if (indexDescriptor === "by_id") {
+      return ["_id"];
+    }
+    const tableSchema = await this.getTableSchema(tableName);
+    const dbIndexes = tableSchema?.indexes;
+    const matchingIndex = dbIndexes?.find((idx) => idx.indexDescriptor === indexDescriptor);
+    if (!matchingIndex) {
+      return null;
+    }
+    return [...matchingIndex.fields, "_creationTime", "_id"];
+  }
+  async getAllIndexesForTable(tableName) {
+    const indexes = [...getStandardIndexes()];
+    const tableSchema = await this.getTableSchema(tableName);
+    const schemaIndexes = tableSchema?.indexes;
+    if (schemaIndexes) {
+      for (const idx of schemaIndexes) {
+        indexes.push({
+          name: idx.indexDescriptor,
+          fields: [...idx.fields, "_creationTime", "_id"]
+        });
+      }
+    }
+    return indexes;
+  }
+  async getSearchIndexConfig(tableName, indexDescriptor) {
+    const tableSchema = await this.getTableSchema(tableName);
+    const searchIndexes = tableSchema?.searchIndexes;
+    return searchIndexes?.find((idx) => idx.indexDescriptor === indexDescriptor) ?? null;
+  }
+  async getVectorIndexConfig(tableName, indexDescriptor) {
+    const tableSchema = await this.getTableSchema(tableName);
+    const vectorIndexes = tableSchema?.vectorIndexes;
+    return vectorIndexes?.find((idx) => idx.indexDescriptor === indexDescriptor) ?? null;
+  }
+  async getAllVectorIndexes() {
+    const schemaDefinition = await this.getSchemaDefinition();
+    if (!schemaDefinition?.tables) {
+      return [];
+    }
+    const allVectorIndexes = [];
+    for (const [tableName, tableSchema] of Object.entries(schemaDefinition.tables)) {
+      const vectorIndexes = tableSchema?.vectorIndexes;
+      if (vectorIndexes) {
+        for (const vectorIndex of vectorIndexes) {
+          allVectorIndexes.push({
+            tableName,
+            indexDescriptor: vectorIndex.indexDescriptor,
+            vectorField: vectorIndex.vectorField,
+            filterFields: vectorIndex.filterFields ?? []
+          });
+        }
+      }
+    }
+    return allVectorIndexes;
+  }
+  async getAllSearchIndexes() {
+    const schemaDefinition = await this.getSchemaDefinition();
+    if (!schemaDefinition?.tables) {
+      return [];
+    }
+    const allSearchIndexes = [];
+    for (const [tableName, tableSchema] of Object.entries(schemaDefinition.tables)) {
+      const searchIndexes = tableSchema?.searchIndexes;
+      if (searchIndexes) {
+        for (const searchIndex of searchIndexes) {
+          allSearchIndexes.push({
+            tableName,
+            indexDescriptor: searchIndex.indexDescriptor,
+            searchField: searchIndex.searchField,
+            filterFields: searchIndex.filterFields ?? []
+          });
+        }
+      }
+    }
+    return allSearchIndexes;
+  }
+  async getTableNames() {
+    const schemaDefinition = await this.getSchemaDefinition();
+    if (!schemaDefinition?.tables) {
+      return [];
+    }
+    return Object.keys(schemaDefinition.tables);
+  }
+  async getSchemaDefinition() {
+    if (this.cachedSchemaDefinition !== undefined) {
+      return this.cachedSchemaDefinition;
+    }
+    try {
+      const schemaModule = await loadConvexModule("schema", { hint: "schema", componentPath: this.componentPath });
+      this.cachedSchemaDefinition = schemaModule.default ?? null;
+    } catch (error) {
+      if (!isMissingSchemaModuleError(error)) {
+        console.warn("Failed to load Convex schema definition:", error);
+      }
+      this.cachedSchemaDefinition = null;
+    }
+    return this.cachedSchemaDefinition;
+  }
+}
+function isMissingSchemaModuleError(error) {
+  if (!error)
+    return false;
+  const errorString = String(error);
+  const isMissing = errorString.includes('Unable to resolve module "schema"') || errorString.includes("Module not found: schema") || errorString.includes('Unable to resolve module "convex/schema"');
+  if (isMissing)
+    return true;
+  const causes = error.causes;
+  if (Array.isArray(causes)) {
+    return causes.some(isMissingSchemaModuleError);
+  }
+  const cause = error.cause;
+  if (cause) {
+    return isMissingSchemaModuleError(cause);
+  }
+  return false;
+}
+var init_schema_service = __esm(() => {
+  init_index_manager();
+  init_validator2();
+  init_module_loader();
+});
+
+// ../core/dist/udf/analysis/udf-analyze.js
+function invalidUdfError(message) {
+  return new UdfAnalysisError(message);
+}
+function analyzeFunction(exported_function, exportName, modulePath) {
+  if (typeof exported_function !== "object" && typeof exported_function !== "function" || exported_function === null) {
+    return null;
+  }
+  const isQuery = !!exported_function.isQuery;
+  const isMutation = !!exported_function.isMutation;
+  const isAction = !!exported_function.isAction;
+  let udfType;
+  if (isQuery && !isMutation && !isAction) {
+    udfType = "query";
+  } else if (!isQuery && isMutation && !isAction) {
+    udfType = "mutation";
+  } else if (!isQuery && !isMutation && isAction) {
+    udfType = "action";
+  } else {
+    return null;
+  }
+  const isPublic = !!exported_function.isPublic;
+  const isInternal = !!exported_function.isInternal;
+  let visibility = null;
+  if (isPublic && !isInternal) {
+    visibility = "public";
+  } else if (!isPublic && isInternal) {
+    visibility = "internal";
+  } else if (isPublic && isInternal) {
+    console.warn(`Function ${exportName} is marked as both public and internal. Skipping.`);
+    return null;
+  } else if (!isPublic && !isInternal) {
+    visibility = null;
+  }
+  const functionIdentifierForError = `${modulePath}:${exportName}`;
+  let args = "Unvalidated";
+  if (typeof exported_function.exportArgs === "function") {
+    try {
+      const argsJson = exported_function.exportArgs();
+      if (typeof argsJson !== "string") {
+        throw invalidUdfError(`${functionIdentifierForError}.exportArgs() didn't return a string.`);
+      }
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      throw invalidUdfError(`Invalid JSON returned from ${functionIdentifierForError}.exportArgs(): ${e.message}`);
+    }
+  } else if (exported_function.exportArgs !== undefined) {
+    throw invalidUdfError(`${functionIdentifierForError}.exportArgs is not a function or \`undefined\`.`);
+  }
+  let returns = "Unvalidated";
+  if (typeof exported_function.exportReturns === "function") {
+    try {
+      const returnsJson = exported_function.exportReturns();
+      if (typeof returnsJson !== "string") {
+        throw invalidUdfError(`${functionIdentifierForError}.exportReturns() didn't return a string.`);
+      }
+      returns = JSON.parse(returnsJson);
+    } catch (e) {
+      throw invalidUdfError(`Invalid JSON returned from ${functionIdentifierForError}.exportReturns(): ${e.message}`);
+    }
+  } else if (exported_function.exportReturns !== undefined) {
+    throw invalidUdfError(`${functionIdentifierForError}.exportReturns is not a function or \`undefined\`.`);
+  }
+  return {
+    name: exportName,
+    udfType,
+    visibility,
+    args,
+    returns,
+    pos: null
+  };
+}
+function analyzeUdfModule(module, modulePath) {
+  const functions = [];
+  let httpRoutes = null;
+  let cronSpecs = null;
+  if (isHttpModule(modulePath)) {
+    if (!module.default) {
+      throw invalidUdfError(`\`convex/http.js\` must have a default export of a Router.`);
+    }
+    httpRoutes = analyzeHttp(module.default);
+  } else if (isCronsModule(modulePath)) {
+    if (!module.default) {
+      throw invalidUdfError(`\`convex/crons.js\` must have a default export of a Crons object.`);
+    }
+    cronSpecs = analyzeCrons(module.default);
+  } else {
+    for (const exportName in module) {
+      if (!Object.hasOwn(module, exportName)) {
+        continue;
+      }
+      let exportedValue;
+      try {
+        exportedValue = module[exportName];
+      } catch (error) {
+        console.warn(`Skipping export "${exportName}" in module "${modulePath}":`, error);
+        continue;
+      }
+      const analyzedFunc = analyzeFunction(exportedValue, exportName, modulePath);
+      if (analyzedFunc) {
+        functions.push(analyzedFunc);
+      }
+    }
+  }
+  functions.sort((a, b) => a.name.localeCompare(b.name));
+  if (httpRoutes) {
+    httpRoutes.routes.sort((a, b) => a.route.path.localeCompare(b.route.path));
+  }
+  return {
+    functions,
+    httpRoutes,
+    cronSpecs
+  };
+}
+function isHttpModule(modulePath) {
+  return matchesModuleSpecifier(modulePath, "http");
+}
+function isCronsModule(modulePath) {
+  return matchesModuleSpecifier(modulePath, "crons");
+}
+function matchesModuleSpecifier(modulePath, moduleName) {
+  const normalized = normalizeModuleSpecifier(modulePath);
+  return normalized === moduleName || normalized.endsWith(`/${moduleName}`);
+}
+function normalizeModuleSpecifier(modulePath) {
+  return modulePath.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\.(?:cjs|mjs|js|jsx|ts|tsx)$/i, "");
+}
+function analyzeHttp(router) {
+  if (typeof router !== "object" || router === null) {
+    throw invalidUdfError("The default export of `convex/http.js` is not a Router.");
+  }
+  if (!router.isRouter) {
+    throw invalidUdfError("The default export of `convex/http.js` is not a Router.");
+  }
+  if (typeof router.getRoutes !== "function") {
+    throw invalidUdfError(".getRoutes property on Router not found");
+  }
+  const routesArr = router.getRoutes();
+  if (!Array.isArray(routesArr)) {
+    throw invalidUdfError("The `getRoutes()` method of Router did not return an array.");
+  }
+  const http_routes = [];
+  for (const entry of routesArr) {
+    if (!Array.isArray(entry) || entry.length < 3) {
+      throw invalidUdfError("Invalid entry in routes array: must be [path, method, handler]");
+    }
+    const [path, method, handler] = entry;
+    if (typeof path !== "string" || typeof method !== "string") {
+      throw invalidUdfError("Invalid entry in routes array: path and method must be strings.");
+    }
+    const upperMethod = method.toUpperCase();
+    if (!["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"].includes(upperMethod)) {
+      throw invalidUdfError(`'${method}' is not not a routable method.`);
+    }
+    const handlerType = typeof handler;
+    const handlerIsObjectLike = handlerType === "object" && handler !== null || handlerType === "function";
+    if (!handlerIsObjectLike || !handler?.isHttp) {
+      throw invalidUdfError("Invalid entry in routes array: handler is not an HTTP action.");
+    }
+    http_routes.push({
+      route: {
+        path,
+        method: upperMethod
+      },
+      pos: null
+    });
+  }
+  return { routes: http_routes };
+}
+function analyzeCrons(crons) {
+  if (typeof crons !== "object" || crons === null) {
+    throw invalidUdfError("The default export of `convex/crons.js` is not a Crons object.");
+  }
+  if (!crons.isCrons) {
+    throw invalidUdfError("The default export of `convex/crons.js` is not a Crons object.");
+  }
+  if (typeof crons.export !== "function") {
+    throw invalidUdfError(".export property on Crons object not found");
+  }
+  const exportedJson = crons.export();
+  if (typeof exportedJson !== "string") {
+    throw invalidUdfError(".export() of Crons object did not return a string.");
+  }
+  try {
+    return JSON.parse(exportedJson);
+  } catch (e) {
+    throw invalidUdfError(`Invalid JSON returned from .export() of Crons object: ${e.message}`);
+  }
+}
+var UdfAnalysisError;
+var init_udf_analyze = __esm(() => {
+  UdfAnalysisError = class UdfAnalysisError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "UdfAnalysisError";
+    }
+  };
+});
+
+// ../core/dist/udf/analysis/index.js
+var init_analysis = __esm(() => {
+  init_udf_analyze();
+  init_validator2();
+});
+
+// ../core/dist/system/function-introspection.js
+async function listSystemFunctions(options = {}) {
+  const componentPath = options.componentPath;
+  const moduleLoader = await ensureModuleLoaderApi();
+  const listings = await moduleLoader.listRegisteredModules({
+    componentPath,
+    hint: "udf"
+  });
+  const filteredListings = listings.filter((listing) => {
+    if (listing.path.startsWith("_generated/") || listing.path.startsWith("_system")) {
+      return false;
+    }
+    const listingComponentPath = listing.componentPath || undefined;
+    if (componentPath === undefined) {
+      return listingComponentPath === undefined;
+    }
+    return listingComponentPath === componentPath;
+  });
+  const analysisResults = await pooledMap(filteredListings, (listing) => analyzeModule(listing, componentPath), 20);
+  const results = [];
+  for (let i2 = 0;i2 < filteredListings.length; i2++) {
+    const listing = filteredListings[i2];
+    const result = analysisResults[i2];
+    if (result.status === "rejected") {
+      if (!isNpmPackageError(result.reason)) {
+        console.warn(`Failed to analyze module "${listing.path}":`, result.reason);
+      }
+      continue;
+    }
+    const { analyzed } = result.value;
+    const sourcePath = listing.source ?? buildFallbackSourcePath(listing.path);
+    const owningComponent = listing.componentPath || undefined;
+    const functions = analyzed.functions ?? [];
+    const httpRoutes = analyzed.httpRoutes?.routes ?? [];
+    if (functions.length === 0 && httpRoutes.length === 0) {
+      continue;
+    }
+    for (const fn of functions) {
+      results.push({
+        name: fn.name,
+        module: listing.path,
+        path: `${listing.path}:${fn.name}`,
+        type: fn.udfType,
+        visibility: fn.visibility ?? null,
+        args: fn.args,
+        returns: fn.returns,
+        source: sourcePath,
+        componentPath: owningComponent
+      });
+    }
+    for (const route of httpRoutes) {
+      const method = route.route.method;
+      const routePath = route.route.path;
+      results.push({
+        name: `${method} ${routePath}`,
+        module: listing.path,
+        path: `${listing.path}:${method}:${routePath}`,
+        type: "http",
+        visibility: null,
+        source: sourcePath,
+        componentPath: owningComponent,
+        httpMethod: method,
+        httpPath: routePath
+      });
+    }
+  }
+  results.sort((a, b) => {
+    const moduleComparison = a.module.localeCompare(b.module);
+    if (moduleComparison !== 0) {
+      return moduleComparison;
+    }
+    return a.name.localeCompare(b.name);
+  });
+  return results;
+}
+async function ensureModuleLoaderApi() {
+  if (!moduleLoaderApiPromise) {
+    moduleLoaderApiPromise = Promise.resolve().then(() => (init_module_loader(), exports_module_loader));
+  }
+  const api = await moduleLoaderApiPromise;
+  if (!unsubscribeModuleLoader) {
+    unsubscribeModuleLoader = api.onModuleLoadersChanged(() => moduleAnalysisCache.clear());
+  }
+  return api;
+}
+async function analyzeModule(listing, componentPath) {
+  const cacheKey = makeCacheKey(componentPath, listing.path);
+  let cached = moduleAnalysisCache.get(cacheKey);
+  if (!cached) {
+    cached = loadAndAnalyzeModule(listing, componentPath);
+    cached.catch(() => moduleAnalysisCache.delete(cacheKey));
+    moduleAnalysisCache.set(cacheKey, cached);
+  }
+  return cached;
+}
+async function loadAndAnalyzeModule(listing, componentPath) {
+  const moduleLoader = await ensureModuleLoaderApi();
+  const module = await moduleLoader.loadConvexModule(listing.path, {
+    componentPath,
+    hint: listing.hint ?? "udf"
+  });
+  const sourcePath = listing.source ?? buildFallbackSourcePath(listing.path);
+  const analyzed = analyzeUdfModule(module, sourcePath);
+  return {
+    listing: {
+      ...listing,
+      source: sourcePath
+    },
+    analyzed
+  };
+}
+function makeCacheKey(componentPath, modulePath) {
+  return `${componentPath ?? ""}::${modulePath}`;
+}
+function buildFallbackSourcePath(modulePath) {
+  const trimmed = modulePath.replace(/\\/g, "/").replace(/^\//, "");
+  const withConvex = trimmed.startsWith("convex/") ? trimmed : `convex/${trimmed}`;
+  return withConvex.endsWith(".ts") || withConvex.endsWith(".js") ? withConvex : `${withConvex}.ts`;
+}
+async function pooledMap(items, fn, concurrency) {
+  const results = new Array(items.length);
+  let next = 0;
+  async function worker() {
+    while (next < items.length) {
+      const idx = next++;
+      try {
+        results[idx] = { status: "fulfilled", value: await fn(items[idx]) };
+      } catch (reason) {
+        results[idx] = { status: "rejected", reason };
+      }
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
+  return results;
+}
+function isNpmPackageError(error) {
+  if (!(error instanceof Error))
+    return false;
+  const causes = error.causes;
+  if (!Array.isArray(causes))
+    return false;
+  return causes.some((cause) => {
+    if (!(cause instanceof Error))
+      return false;
+    const match = cause.message.match(/Module not found: ([^\s]+)/);
+    if (!match)
+      return false;
+    const modulePath = match[1];
+    return !modulePath.startsWith(".") && !modulePath.startsWith("/");
+  });
+}
+var moduleAnalysisCache, moduleLoaderApiPromise = null, unsubscribeModuleLoader = null;
+var init_function_introspection = __esm(() => {
+  init_analysis();
+  moduleAnalysisCache = new Map;
+});
+
+// ../core/dist/system/execution-log.js
+class InMemoryLogSink {
+  entries = [];
+  nextId = 1;
+  maxEntries;
+  constructor(maxEntries = MAX_ENTRIES) {
+    this.maxEntries = maxEntries;
+  }
+  record(entry) {
+    const logEntry = {
+      ...entry,
+      id: `log_${this.nextId++}`
+    };
+    if (this.entries.length >= this.maxEntries) {
+      this.entries.shift();
+    }
+    this.entries.push(logEntry);
+  }
+  query(filter = {}) {
+    let result = this.entries;
+    if (filter.functionType) {
+      result = result.filter((e) => e.functionType === filter.functionType);
+    }
+    if (filter.status) {
+      result = result.filter((e) => e.status === filter.status);
+    }
+    if (filter.search) {
+      const search = filter.search.toLowerCase();
+      result = result.filter((e) => e.functionName.toLowerCase().includes(search) || e.logLines.some((l) => l.toLowerCase().includes(search)) || e.error && e.error.toLowerCase().includes(search));
+    }
+    const reversed = [...result].reverse();
+    if (filter.limit && filter.limit > 0) {
+      return reversed.slice(0, filter.limit);
+    }
+    return reversed;
+  }
+  clear() {
+    this.entries = [];
+  }
+  get size() {
+    return this.entries.length;
+  }
+}
+function queryExecutionLog(filter = {}) {
+  return defaultSink.query(filter);
+}
+function clearExecutionLog() {
+  defaultSink.clear();
+}
+var MAX_ENTRIES = 1000, defaultSink;
+var init_execution_log = __esm(() => {
+  defaultSink = new InMemoryLogSink;
+});
+
+// ../core/dist/system/internal.js
+function createSystemFunctions(deps) {
+  const { query, mutation } = deps;
+  return {
+    systemListComponents: query({
+      args: {},
+      handler: async (_ctx) => {
+        const modules = await listRegisteredModules();
+        const componentPaths = new Set;
+        componentPaths.add("");
+        for (const module of modules) {
+          if (module.componentPath) {
+            componentPaths.add(module.componentPath);
+          }
+        }
+        const components = [];
+        for (const path of componentPaths) {
+          const componentModules = modules.filter((m) => path === "" ? !m.componentPath || m.componentPath === "" : m.componentPath === path);
+          const functions = await listSystemFunctions({ componentPath: path || undefined });
+          components.push({
+            path: path || "(root)",
+            isRoot: path === "",
+            moduleCount: componentModules.length,
+            functionCount: functions.length
+          });
+        }
+        return components.sort((a, b) => {
+          if (a.isRoot)
+            return -1;
+          if (b.isRoot)
+            return 1;
+          return a.path.localeCompare(b.path);
+        });
+      }
+    }),
+    systemListTables: query({
+      args: { componentPath: v.optional(v.string()) },
+      handler: async (ctx, { componentPath }) => {
+        const targetComponent = componentPath ?? "";
+        const schema = await loadSchemaDefinition(targetComponent);
+        let tableEntries = [];
+        if (schema?.tables) {
+          tableEntries = extractTablesFromSchema(schema);
+        } else {
+          try {
+            const systemTables = await ctx.db.system.query("_tables").collect();
+            tableEntries = systemTables.map((table) => ({
+              name: table.name,
+              exported: {
+                indexes: table.indexes || [],
+                searchIndexes: table.searchIndexes || [],
+                vectorIndexes: table.vectorIndexes || [],
+                documentType: null
+              }
+            }));
+          } catch {
+            tableEntries = [];
+          }
+        }
+        const tableInfo = await Promise.all(tableEntries.map(async (table) => {
+          const fullName = getFullTableName(table.name, targetComponent);
+          const documentCount = await countDocuments(ctx, fullName);
+          const exported = table.exported;
+          const searchIndexes = exported?.searchIndexes ?? [];
+          const vectorIndexes = exported?.vectorIndexes ?? [];
+          return {
+            name: table.name,
+            fullName,
+            componentPath: targetComponent || undefined,
+            documentCount,
+            indexes: buildIndexList(exported?.indexes),
+            searchIndexes: searchIndexes.map((idx) => typeof idx === "string" ? idx : idx.indexDescriptor),
+            vectorIndexes: vectorIndexes.map((idx) => typeof idx === "string" ? idx : idx.indexDescriptor)
+          };
+        }));
+        return tableInfo.sort((a, b) => a.name.localeCompare(b.name));
+      }
+    }),
+    systemGetTableSchema: query({
+      args: { tableName: v.string(), componentPath: v.optional(v.string()) },
+      handler: async (ctx, { tableName, componentPath }) => {
+        const targetComponent = componentPath ?? "";
+        const schema = await loadSchemaDefinition(targetComponent);
+        const tableMeta = schema ? extractTableMetadata(schema, tableName) : null;
+        if (tableMeta?.exported) {
+          const exported = tableMeta.exported;
+          const fields = extractFieldsFromDocumentType(exported.documentType, tableName);
+          return {
+            tableName,
+            componentPath: targetComponent || undefined,
+            fields,
+            indexes: buildIndexList(exported.indexes).map((name) => ({
+              name,
+              fields: findIndexFields(exported.indexes, name)
+            })),
+            searchIndexes: buildSearchIndexMetadata(exported.searchIndexes),
+            vectorIndexes: buildVectorIndexMetadata(exported.vectorIndexes)
+          };
+        }
+        try {
+          const fullName = getFullTableName(tableName, targetComponent);
+          const sampleDoc = await ctx.db.query(fullName).first();
+          const fields = sampleDoc ? Object.keys(sampleDoc).map((key) => ({
+            name: key,
+            type: typeof sampleDoc[key],
+            optional: false
+          })) : [];
+          return {
+            tableName,
+            componentPath: targetComponent || undefined,
+            fields,
+            indexes: [
+              { name: "by_id", fields: ["_id"] },
+              { name: "by_creation_time", fields: ["_creationTime"] }
+            ],
+            searchIndexes: [],
+            vectorIndexes: []
+          };
+        } catch (error) {
+          console.warn(`Failed to resolve schema for table ${tableName}:`, error);
+          return null;
+        }
+      }
+    }),
+    systemGetTableData: query({
+      args: {
+        tableName: v.string(),
+        componentPath: v.optional(v.string()),
+        page: v.number(),
+        pageSize: v.number(),
+        orderBy: v.optional(v.string()),
+        order: v.optional(v.string())
+      },
+      handler: async (ctx, args) => {
+        const fullName = getFullTableName(args.tableName, args.componentPath ?? "");
+        let query2 = ctx.db.query(fullName);
+        if (args.orderBy && args.orderBy !== "_creationTime") {
+          const allDocs2 = await query2.collect();
+          const sorted = allDocs2.sort((a, b) => {
+            const aVal = a[args.orderBy];
+            const bVal = b[args.orderBy];
+            if (aVal < bVal)
+              return args.order === "desc" ? 1 : -1;
+            if (aVal > bVal)
+              return args.order === "desc" ? -1 : 1;
+            return 0;
+          });
+          const start2 = (args.page - 1) * args.pageSize;
+          const end2 = start2 + args.pageSize;
+          const paginatedData2 = sorted.slice(start2, end2);
+          return {
+            data: paginatedData2,
+            total: sorted.length,
+            page: args.page,
+            pageSize: args.pageSize,
+            hasMore: end2 < sorted.length
+          };
+        }
+        if (args.order === "desc") {
+          query2 = query2.order("desc");
+        }
+        const allDocs = await query2.collect();
+        const start = (args.page - 1) * args.pageSize;
+        const end = start + args.pageSize;
+        const paginatedData = allDocs.slice(start, end);
+        return {
+          data: paginatedData,
+          total: allDocs.length,
+          page: args.page,
+          pageSize: args.pageSize,
+          hasMore: end < allDocs.length
+        };
+      }
+    }),
+    systemDeleteDocument: mutation({
+      args: { tableName: v.string(), documentId: v.string() },
+      handler: async (ctx, { documentId }) => {
+        await ctx.db.delete(documentId);
+      }
+    }),
+    systemClearTable: mutation({
+      args: { tableName: v.string(), componentPath: v.optional(v.string()) },
+      handler: async (ctx, args) => {
+        const fullName = getFullTableName(args.tableName, args.componentPath ?? "");
+        const docs = await ctx.db.query(fullName).collect();
+        for (const doc of docs) {
+          await ctx.db.delete(doc._id);
+        }
+        return { deleted: docs.length };
+      }
+    }),
+    systemUpdateDocument: mutation({
+      args: {
+        tableName: v.string(),
+        documentId: v.string(),
+        data: v.any()
+      },
+      handler: async (ctx, { documentId, data }) => {
+        await ctx.db.patch(documentId, data);
+      }
+    }),
+    systemGetLogs: query({
+      args: {
+        limit: v.number(),
+        functionType: v.optional(v.string()),
+        status: v.optional(v.string()),
+        search: v.optional(v.string())
+      },
+      handler: async (_ctx, args) => {
+        return queryExecutionLog({
+          limit: args.limit,
+          functionType: args.functionType,
+          status: args.status,
+          search: args.search
+        });
+      }
+    }),
+    systemClearLogs: mutation({
+      args: {},
+      handler: async () => {
+        clearExecutionLog();
+        return { cleared: true };
+      }
+    }),
+    systemGetAnalytics: query({
+      args: { timeRange: v.string() },
+      handler: async (ctx, { timeRange }) => {
+        const now = Date.now();
+        const ranges = {
+          "24h": 24 * 60 * 60 * 1000,
+          "7d": 7 * 24 * 60 * 60 * 1000,
+          "30d": 30 * 24 * 60 * 60 * 1000
+        };
+        const cutoff = now - (ranges[timeRange] || ranges["24h"]);
+        try {
+          const scheduled = await ctx.db.system.query("_scheduled_functions").filter((q) => q.gte(q.field("_creationTime"), cutoff)).collect();
+          const failed = scheduled.filter((s) => s.state?.kind === "failed").length;
+          const total = scheduled.length;
+          return {
+            totalRequests: total,
+            errorRate: total > 0 ? failed / total * 100 : 0,
+            p50Latency: 50,
+            p95Latency: 100,
+            p99Latency: 200,
+            activeConnections: 0,
+            requestsOverTime: [],
+            functionCallsByType: {
+              query: 0,
+              mutation: scheduled.length,
+              action: 0
+            },
+            tableOperations: {},
+            storageUsed: 0
+          };
+        } catch (e) {
+          console.debug("[systemGetAnalytics] Failed to query system tables:", e);
+          return {
+            totalRequests: 0,
+            errorRate: 0,
+            p50Latency: 0,
+            p95Latency: 0,
+            p99Latency: 0,
+            activeConnections: 0,
+            requestsOverTime: [],
+            functionCallsByType: {},
+            tableOperations: {},
+            storageUsed: 0
+          };
+        }
+      }
+    }),
+    systemListScheduledFunctions: query({
+      args: {},
+      handler: async (ctx) => {
+        try {
+          const jobs = await ctx.db.system.query("_scheduled_functions").collect();
+          return jobs.map((job) => ({
+            _id: job._id,
+            _creationTime: job._creationTime,
+            name: job.name,
+            args: job.args,
+            state: job.state,
+            scheduledTime: job.scheduledTime,
+            completedTime: job.completedTime,
+            error: job.state?.kind === "failed" ? job.state.error : undefined
+          }));
+        } catch (e) {
+          console.debug("[systemListScheduledFunctions] Failed to query scheduled functions:", e);
+          return [];
+        }
+      }
+    }),
+    systemCancelScheduledFunction: mutation({
+      args: { id: v.id("_scheduled_functions") },
+      handler: async (ctx, { id }) => {
+        await ctx.db.system.delete(id);
+      }
+    }),
+    systemListCrons: query({
+      args: {},
+      handler: async (ctx) => {
+        try {
+          const jobs = await ctx.db.system.query("_crons").collect();
+          return jobs.map((job) => ({
+            _id: job._id,
+            _creationTime: job._creationTime,
+            name: job.name,
+            schedule: job.schedule,
+            functionPath: job.functionPath,
+            args: job.args,
+            componentPath: job.componentPath,
+            lastRun: job.lastRun,
+            nextRun: job.nextRun,
+            lastRunState: job.lastRunState
+          }));
+        } catch (e) {
+          console.debug("[systemListCronJobs] Failed to query cron jobs:", e);
+          return [];
+        }
+      }
+    }),
+    systemListStorage: query({
+      args: {
+        page: v.number(),
+        pageSize: v.number(),
+        sortBy: v.optional(v.union(v.literal("uploadedAt"), v.literal("size"), v.literal("contentType"))),
+        sortOrder: v.optional(v.union(v.literal("asc"), v.literal("desc")))
+      },
+      handler: async (ctx, args) => {
+        try {
+          const allFiles = await ctx.db.system.query("_storage").collect();
+          const sortBy = args.sortBy || "uploadedAt";
+          const sortOrder = args.sortOrder || "desc";
+          const sortedFiles = allFiles.sort((a, b) => {
+            const aVal = a[sortBy] ?? 0;
+            const bVal = b[sortBy] ?? 0;
+            if (typeof aVal === "string" && typeof bVal === "string") {
+              return sortOrder === "asc" ? aVal.localeCompare(bVal) : bVal.localeCompare(aVal);
+            }
+            if (sortOrder === "asc") {
+              return aVal - bVal;
+            } else {
+              return bVal - aVal;
+            }
+          });
+          const start = (args.page - 1) * args.pageSize;
+          const end = start + args.pageSize;
+          const paginatedFiles = sortedFiles.slice(start, end);
+          const totalSize = allFiles.reduce((sum, file) => sum + (file.size || 0), 0);
+          return {
+            files: paginatedFiles.map((file) => ({
+              _id: file._id,
+              _creationTime: file._creationTime,
+              sha256: file.sha256,
+              size: file.size,
+              contentType: file.contentType
+            })),
+            total: allFiles.length,
+            page: args.page,
+            pageSize: args.pageSize,
+            hasMore: end < allFiles.length,
+            totalSize
+          };
+        } catch (e) {
+          console.debug("[systemListStorageFiles] Failed to query storage files:", e);
+          return {
+            files: [],
+            total: 0,
+            page: args.page,
+            pageSize: args.pageSize,
+            hasMore: false,
+            totalSize: 0
+          };
+        }
+      }
+    }),
+    systemDeleteStorage: mutation({
+      args: { storageId: v.id("_storage") },
+      handler: async (ctx, { storageId }) => {
+        await ctx.storage.delete(storageId);
+      }
+    }),
+    systemGetStorageMetadata: query({
+      args: { storageId: v.id("_storage") },
+      handler: async (ctx, { storageId }) => {
+        const file = await ctx.db.system.get(storageId);
+        return file;
+      }
+    }),
+    systemListFunctions: query({
+      args: { componentPath: v.optional(v.string()) },
+      handler: async (ctx, args) => {
+        const componentPath = args.componentPath ?? ctx?.componentPath ?? undefined;
+        const functions = await listSystemFunctions({ componentPath });
+        return functions.map((fn) => ({
+          name: fn.name,
+          path: fn.path,
+          type: fn.type,
+          module: fn.module,
+          visibility: fn.visibility,
+          args: fn.args,
+          returns: fn.returns,
+          source: fn.source,
+          componentPath: fn.componentPath,
+          httpMethod: fn.httpMethod,
+          httpPath: fn.httpPath
+        }));
+      }
+    }),
+    systemExecuteFunction: mutation({
+      args: {
+        functionPath: v.string(),
+        args: v.any(),
+        functionType: v.union(v.literal("query"), v.literal("mutation"), v.literal("action"), v.literal("http")),
+        componentPath: v.optional(v.string())
+      },
+      handler: async (ctx, { functionPath, args, functionType, componentPath }) => {
+        if (typeof functionPath !== "string" || !functionPath.includes(":")) {
+          throw new Error(`Invalid function path: ${functionPath}`);
+        }
+        const executorArgs = args ?? {};
+        const target = resolveFunctionReference(functionPath, componentPath);
+        try {
+          switch (functionType) {
+            case "query": {
+              return await ctx.runQuery(target, executorArgs);
+            }
+            case "mutation": {
+              return await ctx.runMutation(target, executorArgs);
+            }
+            case "action": {
+              return await ctx.runAction(target, executorArgs);
+            }
+            case "http": {
+              throw new Error("HTTP actions can be tested via HTTP requests but not executed directly here.");
+            }
+            default: {
+              throw new Error(`Unsupported function type: ${functionType}`);
+            }
+          }
+        } catch (error) {
+          const message = error?.message ?? String(error);
+          throw new Error(`Failed to execute ${functionPath}: ${message}`);
+        }
+      }
+    })
+  };
+}
+function resolveFunctionReference(functionPath, componentPath) {
+  if (componentPath && componentPath.trim().length > 0) {
+    const normalizedComponent = componentPath.replace(/^\/+|\/+$/g, "");
+    return `function://${normalizedComponent};${functionPath}`;
+  }
+  return functionPath;
+}
+async function loadSchemaDefinition(componentPath) {
+  try {
+    const module = await loadConvexModule("schema", {
+      hint: "schema",
+      componentPath: componentPath || undefined
+    });
+    return module?.default ?? null;
+  } catch (error) {
+    if (!isMissingSchemaModuleError(error)) {
+      console.debug("Failed to load schema module:", error);
+    }
+    return null;
+  }
+}
+function extractTablesFromSchema(schema) {
+  const entries = Object.entries(schema.tables ?? {});
+  return entries.map(([name, definition]) => ({
+    name,
+    exported: typeof definition?.export === "function" ? definition.export() : null
+  }));
+}
+function extractTableMetadata(schema, tableName) {
+  const definition = schema.tables?.[tableName];
+  if (!definition) {
+    return null;
+  }
+  return {
+    name: tableName,
+    exported: typeof definition?.export === "function" ? definition.export() : null
+  };
+}
+async function countDocuments(ctx, tableName) {
+  try {
+    const documents = await ctx.db.query(tableName).collect();
+    return documents.length;
+  } catch (error) {
+    console.warn(`Failed to count documents for table ${tableName}:`, error);
+    return 0;
+  }
+}
+function buildIndexList(indexes) {
+  const base = ["by_id", "by_creation_time"];
+  if (!indexes || indexes.length === 0) {
+    return base;
+  }
+  const extras = indexes.map((idx) => {
+    if (typeof idx === "string")
+      return idx;
+    return idx?.indexDescriptor;
+  }).filter((value) => typeof value === "string" && value.length > 0);
+  return Array.from(new Set([...base, ...extras]));
+}
+function findIndexFields(indexes, descriptor) {
+  if (descriptor === "by_id") {
+    return ["_id"];
+  }
+  if (descriptor === "by_creation_time") {
+    return ["_creationTime", "_id"];
+  }
+  const match = indexes?.find((idx) => idx.indexDescriptor === descriptor);
+  return match?.fields ?? [];
+}
+function buildSearchIndexMetadata(searchIndexes) {
+  if (!searchIndexes) {
+    return [];
+  }
+  return searchIndexes.map((idx) => {
+    if (typeof idx === "string") {
+      return { name: idx, searchField: "", filterFields: undefined };
+    }
+    return {
+      name: idx.indexDescriptor,
+      searchField: idx.searchField,
+      filterFields: idx.filterFields
+    };
+  }).filter((entry) => typeof entry.name === "string" && entry.name.length > 0);
+}
+function buildVectorIndexMetadata(vectorIndexes) {
+  if (!vectorIndexes) {
+    return [];
+  }
+  return vectorIndexes.map((idx) => {
+    if (typeof idx === "string") {
+      return { name: idx, vectorField: "", dimension: undefined, filterFields: undefined };
+    }
+    return {
+      name: idx.indexDescriptor,
+      vectorField: idx.vectorField,
+      dimension: idx.dimension,
+      filterFields: idx.filterFields
+    };
+  }).filter((entry) => typeof entry.name === "string" && entry.name.length > 0);
+}
+function extractFieldsFromDocumentType(documentType, tableName) {
+  const fields = [
+    { name: "_id", type: `Id<${tableName}>`, optional: false },
+    { name: "_creationTime", type: "number", optional: false }
+  ];
+  if (!documentType || documentType.type !== "object" || !documentType.value) {
+    return fields;
+  }
+  for (const [name, fieldDef] of Object.entries(documentType.value)) {
+    const definition = fieldDef;
+    fields.push({
+      name,
+      type: describeFieldType(definition.fieldType),
+      optional: Boolean(definition.optional)
+    });
+  }
+  return fields;
+}
+function describeFieldType(node) {
+  if (!node || typeof node !== "object") {
+    return "unknown";
+  }
+  if (node.type === "object") {
+    const childFields = node.value ? Object.keys(node.value) : [];
+    return `object{${childFields.join(", ")}}`;
+  }
+  if (node.type === "array") {
+    return `array<${describeFieldType(node.value)}>`;
+  }
+  if (node.type === "union") {
+    const members = Array.isArray(node.value) ? node.value.map(describeFieldType) : [];
+    return `union<${members.join(" | ")}>`;
+  }
+  if (node.type === "literal") {
+    return `literal(${JSON.stringify(node.value)})`;
+  }
+  if (node.type === "id") {
+    return `Id<${node.tableName ?? "unknown"}>`;
+  }
+  return node.type ?? "unknown";
+}
+var init_internal = __esm(() => {
+  init_values();
+  init_module_loader();
+  init_schema_service();
+  init_function_introspection();
+  init_interface();
+  init_execution_log();
+});
+
+// src/internal.ts
+init_internal();
+export {
+  createSystemFunctions
+};