@concavejs/docstore-bun-sqlite 0.0.1-alpha.11 → 0.0.1-alpha.12

package/dist/index.js

@@ -14,7 +14,6 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
 
 // ../../node_modules/convex/dist/esm/values/base64.js
 function getLens(b64) {
@@ -802,6 +801,237 @@ var init_values = __esm(() => {
   init_errors();
 });
 
+// ../core/dist/id-codec/base32.js
+function base32Encode(data) {
+  if (data.length === 0)
+    return "";
+  let result = "";
+  let buffer = 0;
+  let bitsLeft = 0;
+  for (const byte of data) {
+    buffer = buffer << 8 | byte;
+    bitsLeft += 8;
+    while (bitsLeft >= 5) {
+      bitsLeft -= 5;
+      const index = buffer >> bitsLeft & 31;
+      result += ALPHABET[index];
+    }
+  }
+  if (bitsLeft > 0) {
+    const index = buffer << 5 - bitsLeft & 31;
+    result += ALPHABET[index];
+  }
+  return result;
+}
+function base32Decode(str) {
+  if (str.length === 0)
+    return new Uint8Array(0);
+  const outputLength = Math.floor(str.length * 5 / 8);
+  const result = new Uint8Array(outputLength);
+  let buffer = 0;
+  let bitsLeft = 0;
+  let outputIndex = 0;
+  for (const char of str) {
+    const value = ALPHABET_MAP.get(char);
+    if (value === undefined) {
+      throw new Error(`Invalid base32 character: ${char}`);
+    }
+    buffer = buffer << 5 | value;
+    bitsLeft += 5;
+    if (bitsLeft >= 8) {
+      bitsLeft -= 8;
+      result[outputIndex++] = buffer >> bitsLeft & 255;
+    }
+  }
+  return result;
+}
+function isValidBase32(str) {
+  for (const char of str) {
+    if (!ALPHABET_MAP.has(char)) {
+      return false;
+    }
+  }
+  return true;
+}
+var ALPHABET = "0123456789abcdefghjkmnpqrstvwxyz", ALPHABET_MAP;
+var init_base32 = __esm(() => {
+  ALPHABET_MAP = new Map;
+  for (let i2 = 0;i2 < ALPHABET.length; i2++) {
+    ALPHABET_MAP.set(ALPHABET[i2], i2);
+    ALPHABET_MAP.set(ALPHABET[i2].toUpperCase(), i2);
+  }
+  ALPHABET_MAP.set("i", 1);
+  ALPHABET_MAP.set("I", 1);
+  ALPHABET_MAP.set("l", 1);
+  ALPHABET_MAP.set("L", 1);
+  ALPHABET_MAP.set("o", 0);
+  ALPHABET_MAP.set("O", 0);
+});
+
+// ../core/dist/id-codec/vint.js
+function vintEncode(value) {
+  if (value < 0) {
+    throw new Error("VInt cannot encode negative numbers");
+  }
+  if (value > 4294967295) {
+    throw new Error("VInt cannot encode values larger than 2^32-1");
+  }
+  value = value >>> 0;
+  if (value < 128) {
+    return new Uint8Array([value]);
+  }
+  if (value < 16512) {
+    const adjusted2 = value - 128;
+    return new Uint8Array([128 | adjusted2 >> 8 & 63, adjusted2 & 255]);
+  }
+  if (value < 2113664) {
+    const adjusted2 = value - 16512;
+    return new Uint8Array([192 | adjusted2 >> 16 & 31, adjusted2 >> 8 & 255, adjusted2 & 255]);
+  }
+  if (value < 270549120) {
+    const adjusted2 = value - 2113664;
+    return new Uint8Array([
+      224 | adjusted2 >> 24 & 15,
+      adjusted2 >> 16 & 255,
+      adjusted2 >> 8 & 255,
+      adjusted2 & 255
+    ]);
+  }
+  const adjusted = value - 270549120;
+  return new Uint8Array([
+    240 | adjusted >> 32 & 7,
+    adjusted >> 24 & 255,
+    adjusted >> 16 & 255,
+    adjusted >> 8 & 255,
+    adjusted & 255
+  ]);
+}
+function vintDecode(data, offset = 0) {
+  if (offset >= data.length) {
+    throw new Error("VInt decode: unexpected end of data");
+  }
+  const first = data[offset];
+  if ((first & 128) === 0) {
+    return { value: first, bytesRead: 1 };
+  }
+  if ((first & 192) === 128) {
+    if (offset + 1 >= data.length) {
+      throw new Error("VInt decode: truncated 2-byte encoding");
+    }
+    const value = 128 + ((first & 63) << 8 | data[offset + 1]);
+    return { value, bytesRead: 2 };
+  }
+  if ((first & 224) === 192) {
+    if (offset + 2 >= data.length) {
+      throw new Error("VInt decode: truncated 3-byte encoding");
+    }
+    const value = 16512 + ((first & 31) << 16 | data[offset + 1] << 8 | data[offset + 2]);
+    return { value, bytesRead: 3 };
+  }
+  if ((first & 240) === 224) {
+    if (offset + 3 >= data.length) {
+      throw new Error("VInt decode: truncated 4-byte encoding");
+    }
+    const value = 2113664 + ((first & 15) << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]);
+    return { value: value >>> 0, bytesRead: 4 };
+  }
+  if ((first & 248) === 240) {
+    if (offset + 4 >= data.length) {
+      throw new Error("VInt decode: truncated 5-byte encoding");
+    }
+    const high = first & 7;
+    const low = (data[offset + 1] << 24 | data[offset + 2] << 16 | data[offset + 3] << 8 | data[offset + 4]) >>> 0;
+    const value = 270549120 + high * 4294967296 + low;
+    return { value: value >>> 0, bytesRead: 5 };
+  }
+  throw new Error("VInt decode: invalid prefix");
+}
+
+// ../core/dist/id-codec/fletcher16.js
+function fletcher16(data) {
+  let sum1 = 0;
+  let sum2 = 0;
+  for (const byte of data) {
+    sum1 = (sum1 + byte) % 255;
+    sum2 = (sum2 + sum1) % 255;
+  }
+  return new Uint8Array([sum1, sum2]);
+}
+function verifyFletcher16(data, checksum) {
+  if (checksum.length !== 2)
+    return false;
+  const computed = fletcher16(data);
+  return computed[0] === checksum[0] && computed[1] === checksum[1];
+}
+
+// ../core/dist/utils/crypto.js
+var weakRandomState;
+var init_crypto = __esm(() => {
+  weakRandomState = (Date.now() ^ 2654435769) >>> 0;
+});
+
+// ../core/dist/id-codec/document-id.js
+function encodeDocumentId(tableNumber, internalId) {
+  if (internalId.length !== INTERNAL_ID_LENGTH) {
+    throw new Error(`Internal ID must be exactly ${INTERNAL_ID_LENGTH} bytes, got ${internalId.length}`);
+  }
+  if (tableNumber < 1 || tableNumber > 4294967295) {
+    throw new Error(`Table number must be between 1 and 2^32-1, got ${tableNumber}`);
+  }
+  const tableBytes = vintEncode(tableNumber);
+  const payload = new Uint8Array(tableBytes.length + INTERNAL_ID_LENGTH);
+  payload.set(tableBytes, 0);
+  payload.set(internalId, tableBytes.length);
+  const checksum = fletcher16(payload);
+  const final = new Uint8Array(payload.length + 2);
+  final.set(payload, 0);
+  final.set(checksum, payload.length);
+  return base32Encode(final);
+}
+function decodeDocumentId(encoded) {
+  if (encoded.length < MIN_ENCODED_LENGTH || encoded.length > MAX_ENCODED_LENGTH) {
+    throw new Error(`Invalid document ID length: ${encoded.length} (expected ${MIN_ENCODED_LENGTH}-${MAX_ENCODED_LENGTH})`);
+  }
+  if (!isValidBase32(encoded)) {
+    throw new Error("Invalid document ID: contains invalid base32 characters");
+  }
+  const bytes = base32Decode(encoded);
+  if (bytes.length < 19) {
+    throw new Error(`Invalid document ID: decoded to ${bytes.length} bytes (minimum 19)`);
+  }
+  const checksum = bytes.slice(bytes.length - 2);
+  const payload = bytes.slice(0, bytes.length - 2);
+  if (!verifyFletcher16(payload, checksum)) {
+    throw new Error("Invalid document ID: checksum verification failed");
+  }
+  const { value: tableNumber, bytesRead } = vintDecode(payload, 0);
+  const internalId = payload.slice(bytesRead, bytesRead + INTERNAL_ID_LENGTH);
+  if (internalId.length !== INTERNAL_ID_LENGTH) {
+    throw new Error(`Invalid document ID: internal ID is ${internalId.length} bytes (expected ${INTERNAL_ID_LENGTH})`);
+  }
+  return { tableNumber, internalId };
+}
+function isValidDocumentId(encoded) {
+  try {
+    decodeDocumentId(encoded);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function internalIdToHex(internalId) {
+  let hex = "";
+  for (let i2 = 0;i2 < internalId.length; i2++) {
+    hex += internalId[i2].toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+var INTERNAL_ID_LENGTH = 16, MIN_ENCODED_LENGTH = 31, MAX_ENCODED_LENGTH = 37;
+var init_document_id = __esm(() => {
+  init_base32();
+  init_crypto();
+});
+
 // ../core/dist/utils/utils.js
 function hexToArrayBuffer(hex) {
   if (hex === "") {
@@ -840,9 +1070,15 @@ function deserializeDeveloperId(developerId) {
   return null;
 }
 var DOC_ID_SEPARATOR = ":", LEGACY_DOC_ID_SEPARATOR = ";";
+var init_utils = __esm(() => {
+  init_document_id();
+});
 
 // ../core/dist/tables/interface.js
 function getFullTableName(tableName, componentPath) {
+  if (isSystemTable(tableName)) {
+    return tableName;
+  }
   if (!componentPath || componentPath === "") {
     return tableName;
   }
@@ -859,23 +1095,28 @@ function parseFullTableName(fullName) {
   };
 }
 function isSystemTable(tableName) {
-  return tableName.startsWith("_");
+  return Object.hasOwn(SYSTEM_TABLE_NUMBERS, tableName);
 }
-var SYSTEM_TABLE_NUMBERS, FIRST_USER_TABLE_NUMBER = 100;
+var SYSTEM_TABLE_NUMBERS, FIRST_USER_TABLE_NUMBER = 10001;
 var init_interface = __esm(() => {
   SYSTEM_TABLE_NUMBERS = {
     _tables: 1,
     _scheduled_functions: 2,
     _storage: 3,
-    _crons: 4
+    _crons: 4,
+    _indexes: 5,
+    _schemas: 6,
+    _components: 7,
+    _component_definitions: 8,
+    _schema_validation_progress: 9
   };
 });
 
 // ../core/dist/kernel/context-storage.js
-function resolveFromRequire(req) {
+function resolveFromModuleResolver(resolveModule) {
   for (const specifier of ["node:async_hooks", "async_hooks"]) {
     try {
-      const mod = req(specifier);
+      const mod = resolveModule(specifier);
       if (mod?.AsyncLocalStorage) {
         return mod.AsyncLocalStorage;
       }
@@ -918,16 +1159,16 @@ var resolveAsyncLocalStorage = () => {
   if (globalCtor) {
     return globalCtor;
   }
-  const runtimeRequire = __require;
-  if (runtimeRequire) {
-    const ctor = resolveFromRequire(runtimeRequire);
+  const getBuiltinModule = globalThis?.process?.getBuiltinModule;
+  if (typeof getBuiltinModule === "function") {
+    const ctor = resolveFromModuleResolver((specifier) => getBuiltinModule(specifier));
     if (ctor) {
       return ctor;
     }
   }
   const globalRequire = globalThis?.require;
   if (typeof globalRequire === "function") {
-    return resolveFromRequire(globalRequire);
+    return resolveFromModuleResolver(globalRequire);
   }
   return;
 }, AsyncLocalStorageCtor;
@@ -2212,7 +2453,7 @@ async function listSystemFunctions(options = {}) {
     }
     for (const route of httpRoutes) {
       const method = route.route.method;
-      const routePath = route.route.path;
+      const routePath = mountHttpRoutePath(route.route.path, owningComponent);
       results.push({
         name: `${method} ${routePath}`,
         module: listing.path,
@@ -2274,6 +2515,16 @@ async function loadAndAnalyzeModule(listing, componentPath) {
 function makeCacheKey(componentPath, modulePath) {
   return `${componentPath ?? ""}::${modulePath}`;
 }
+function mountHttpRoutePath(routePath, componentPath) {
+  if (!componentPath) {
+    return routePath;
+  }
+  const prefix = `/${componentPath}`;
+  if (routePath === "/") {
+    return prefix;
+  }
+  return `${prefix}${routePath}`;
+}
 function buildFallbackSourcePath(modulePath) {
   const trimmed = modulePath.replace(/\\/g, "/").replace(/^\//, "");
   const withConvex = trimmed.startsWith("convex/") ? trimmed : `convex/${trimmed}`;
@@ -3960,6 +4211,7 @@ var init_remote = __esm(() => {
 // ../../node_modules/jose/dist/webapi/index.js
 var init_webapi = __esm(() => {
   init_verify4();
+  init_local();
   init_remote();
   init_errors2();
 });
@@ -4164,7 +4416,7 @@ function getRemoteJwks(jwksUrl, config) {
   if (cached) {
     JWKS_CACHE.delete(jwksUrl);
   }
-  const jwks = createRemoteJWKSet(new URL(jwksUrl));
+  const jwks = jwksUrl.startsWith("data:") ? createLocalJWKSet(parseDataUriJson(jwksUrl)) : createRemoteJWKSet(new URL(jwksUrl));
   const configuredTtl = config?.jwksCacheTtlMs;
   const ttlMs = resolveJwksCacheTtlMs(configuredTtl);
   JWKS_CACHE.set(jwksUrl, {
@@ -4173,6 +4425,24 @@ function getRemoteJwks(jwksUrl, config) {
   });
   return jwks;
 }
+function parseDataUriJson(dataUri) {
+  const match = /^data:([^;,]+)?(?:;charset=[^;,]+)?(;base64)?,(.*)$/i.exec(dataUri);
+  if (!match) {
+    throw new JWTValidationError("INVALID_TOKEN", "Invalid JWKS data URI");
+  }
+  const [, , isBase64, payload] = match;
+  const jsonText = isBase64 ? decodeBase642(payload) : decodeURIComponent(payload);
+  return JSON.parse(jsonText);
+}
+function decodeBase642(value) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(value, "base64").toString("utf8");
+  }
+  if (typeof atob === "function") {
+    return new TextDecoder().decode(Uint8Array.from(atob(value), (char) => char.charCodeAt(0)));
+  }
+  throw new JWTValidationError("INVALID_TOKEN", "Base64 decoding is unavailable");
+}
 function resolveJwksCacheTtlMs(configuredTtl) {
   if (configuredTtl === undefined) {
     return DEFAULT_JWKS_CACHE_TTL_MS;
@@ -4207,6 +4477,7 @@ async function verifyJwt(token, config) {
     const options = {
       issuer: effectiveConfig.issuer,
       audience: effectiveConfig.audience,
+      algorithms: effectiveConfig.algorithms,
       clockTolerance: effectiveConfig.clockTolerance ?? DEFAULT_CLOCK_TOLERANCE_SECONDS
     };
     let payload;
@@ -4764,47 +5035,231 @@ var init_auth = __esm(() => {
   init_auth_config_service();
 });
 
-// ../core/dist/system/internal.js
-function requireSystemCapability(capability) {
-  const principal2 = getPrincipal();
-  if (!principal2) {
-    throw new Error("System functions require authentication context");
-  }
-  requireAuthorization(principal2, { kind: "management_operation", capability });
-}
-function createSystemFunctions(deps) {
-  const { query, mutation } = deps;
-  return {
-    systemListComponents: query({
+// ../core/dist/components/manifest.js
+var COMPONENT_MANIFEST_SYMBOL;
+var init_manifest = __esm(() => {
+  COMPONENT_MANIFEST_SYMBOL = Symbol.for("concave.componentManifest");
+});
+
+// ../core/dist/id-codec/index.js
+var init_id_codec = __esm(() => {
+  init_base32();
+  init_document_id();
+});
+
+// ../core/dist/system/system-tables.js
+function getSystemTableDefinition(name) {
+  return SYSTEM_TABLE_DEFINITIONS.find((definition) => definition.name === name) ?? null;
+}
+function isPublicSystemTable(name) {
+  return getSystemTableDefinition(name)?.visibility === "public";
+}
+function createTableInfo(name, tableNumber, componentPath = "", options = {}) {
+  const fullName = getFullTableName(name, componentPath);
+  return {
+    tableNumber,
+    name,
+    componentPath: isSystemTableName(name) ? "" : componentPath,
+    fullName,
+    isSystem: options.isSystem ?? isSystemTableName(name),
+    visibility: options.visibility ?? (isPublicSystemTable(name) ? "public" : "private"),
+    state: "active",
+    createdAt: options.createdAt ?? Date.now()
+  };
+}
+function getReservedSystemTables() {
+  return SYSTEM_TABLE_DEFINITIONS.map((definition) => createTableInfo(definition.name, SYSTEM_TABLE_NUMBERS[definition.name], "", {
+    isSystem: true,
+    visibility: definition.visibility
+  }));
+}
+function tableInfoFromStoredDocument(value) {
+  if (!value) {
+    return null;
+  }
+  const name = typeof value.name === "string" ? value.name : null;
+  const tableNumber = typeof value.tableNumber === "number" ? value.tableNumber : null;
+  if (!name || !tableNumber) {
+    return null;
+  }
+  const componentPath = typeof value.componentPath === "string" ? value.componentPath : "";
+  const fullName = typeof value.fullName === "string" ? value.fullName : getFullTableName(name, componentPath);
+  return {
+    tableNumber,
+    name,
+    componentPath,
+    fullName,
+    isSystem: value.isSystem === true,
+    visibility: value.visibility === "private" ? "private" : "public",
+    state: "active",
+    createdAt: typeof value.createdAt === "number" ? value.createdAt : Date.now()
+  };
+}
+function nextUserTableNumber(tables) {
+  let next = FIRST_USER_TABLE_NUMBER;
+  for (const table of tables) {
+    if (table.tableNumber >= next) {
+      next = table.tableNumber + 1;
+    }
+  }
+  return next;
+}
+function createSystemMetadata(partial) {
+  const now = partial?.updatedAt ?? Date.now();
+  return {
+    version: 1,
+    bootstrapped: true,
+    tableIdStrategy: "registry_u32",
+    developerIdCodec: "convex_base32",
+    nextUserTableNumber: partial?.nextUserTableNumber ?? FIRST_USER_TABLE_NUMBER,
+    registryVersion: partial?.registryVersion ?? now,
+    runtimeMetadataVersion: partial?.runtimeMetadataVersion,
+    bootstrappedAt: partial?.bootstrappedAt ?? now,
+    updatedAt: now
+  };
+}
+async function readSystemMetadata(docstore) {
+  const metadata = await docstore.getGlobal(SYSTEM_METADATA_GLOBAL_KEY);
+  if (!metadata || metadata.bootstrapped !== true || metadata.version !== 1) {
+    return null;
+  }
+  return createSystemMetadata({
+    nextUserTableNumber: metadata.nextUserTableNumber,
+    registryVersion: metadata.registryVersion ?? metadata.updatedAt,
+    runtimeMetadataVersion: metadata.runtimeMetadataVersion,
+    bootstrappedAt: metadata.bootstrappedAt,
+    updatedAt: metadata.updatedAt
+  });
+}
+function createTableNumberReservationKey(tableNumber) {
+  return `${TABLE_NUMBER_RESERVATION_GLOBAL_PREFIX}${tableNumber}`;
+}
+async function ensureSystemTablesBootstrapped(docstore) {
+  const existingMetadata = await readSystemMetadata(docstore);
+  if (existingMetadata?.version === 1 && existingMetadata.bootstrapped) {
+    return;
+  }
+  const now = Date.now();
+  const tableInfos = getReservedSystemTables();
+  const existingEntries = await docstore.scan(stringToHex("_tables"));
+  const existingByName = new Map;
+  for (const entry of existingEntries) {
+    const info = tableInfoFromStoredDocument(entry.value.value);
+    if (info) {
+      existingByName.set(info.fullName, info);
+    }
+  }
+  const docs = [];
+  const oracle = docstore.timestampOracle;
+  const allocateTimestamp = oracle?.allocateTimestamp?.bind(oracle) ?? (() => BigInt(Date.now()));
+  for (const table of tableInfos) {
+    const existing = existingByName.get(table.fullName);
+    const createdAt = existing?.createdAt ?? now;
+    docs.push(createTableMetadataEntry(table, allocateTimestamp(), createdAt));
+  }
+  if (docs.length > 0) {
+    await docstore.write(docs, new Set, "Overwrite");
+  }
+  const metadata = createSystemMetadata({
+    nextUserTableNumber: nextUserTableNumber([...tableInfos, ...existingByName.values()]),
+    registryVersion: now,
+    bootstrappedAt: existingMetadata?.bootstrappedAt ?? now,
+    updatedAt: now
+  });
+  await docstore.writeGlobal(SYSTEM_METADATA_GLOBAL_KEY, metadata);
+}
+function createTableMetadataEntryForUserTable(table, timestamp2) {
+  return createTableMetadataEntry(table, timestamp2, table.createdAt);
+}
+function createTableMetadataEntry(table, timestamp2, createdAt) {
+  const docId = createTableMetadataDocumentId(table.fullName);
+  const developerId = encodeDocumentId(SYSTEM_TABLE_NUMBERS._tables, stableMetadataInternalIdBytes(table.fullName));
+  const storedTable = {
+    _id: developerId,
+    _creationTime: Number(timestamp2),
+    name: table.name,
+    componentPath: table.componentPath,
+    fullName: table.fullName,
+    tableNumber: table.tableNumber,
+    isSystem: table.isSystem,
+    visibility: table.visibility,
+    state: table.state,
+    createdAt
+  };
+  return {
+    ts: timestamp2,
+    id: docId,
+    value: {
+      id: docId,
+      value: storedTable
+    },
+    prev_ts: null
+  };
+}
+function createTableMetadataDocumentId(fullTableName) {
+  const internalIdBytes = stableMetadataInternalIdBytes(fullTableName);
+  return {
+    table: stringToHex("_tables"),
+    internalId: internalIdToHex(internalIdBytes),
+    tableNumber: SYSTEM_TABLE_NUMBERS._tables
+  };
+}
+function stableMetadataInternalIdBytes(fullTableName) {
+  const bytes = new Uint8Array(16);
+  const input = new TextEncoder().encode(`table:${fullTableName}`);
+  for (let i2 = 0;i2 < input.length; i2 += 1) {
+    const target = i2 % 16;
+    bytes[target] = bytes[target] * 33 + input[i2] & 255;
+  }
+  return bytes;
+}
+function isSystemTableName(name) {
+  return Object.hasOwn(SYSTEM_TABLE_NUMBERS, name);
+}
+var SYSTEM_METADATA_GLOBAL_KEY = "concave:system_metadata:v1", TABLE_NUMBER_RESERVATION_GLOBAL_PREFIX = "concave:table_number:", SYSTEM_TABLE_DEFINITIONS;
+var init_system_tables = __esm(() => {
+  init_manifest();
+  init_id_codec();
+  init_interface();
+  init_utils();
+  init_module_loader();
+  SYSTEM_TABLE_DEFINITIONS = [
+    { name: "_tables", visibility: "public" },
+    { name: "_scheduled_functions", visibility: "public" },
+    { name: "_storage", visibility: "public" },
+    { name: "_crons", visibility: "public" },
+    { name: "_indexes", visibility: "private" },
+    { name: "_schemas", visibility: "private" },
+    { name: "_components", visibility: "private" },
+    { name: "_component_definitions", visibility: "private" },
+    { name: "_schema_validation_progress", visibility: "private" }
+  ];
+});
+
+// ../core/dist/system/internal.js
+function requireSystemCapability(capability) {
+  const principal2 = getPrincipal();
+  if (!principal2) {
+    throw new Error("System functions require authentication context");
+  }
+  requireAuthorization(principal2, { kind: "management_operation", capability });
+}
+function createSystemFunctions(deps) {
+  const { query, mutation } = deps;
+  return {
+    systemListComponents: query({
       args: {},
-      handler: async (_ctx) => {
+      handler: async (ctx) => {
         requireSystemCapability("components:read");
-        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,
+        const components = await loadComponentRows(ctx);
+        const withFunctionCounts = await Promise.all(components.map(async (component) => {
+          const functions = await listSystemFunctions({ componentPath: component.componentPath || undefined });
+          return {
+            ...component,
             functionCount: functions.length
-          });
-        }
-        return components.sort((a, b) => {
-          if (a.isRoot)
-            return -1;
-          if (b.isRoot)
-            return 1;
-          return a.path.localeCompare(b.path);
-        });
+          };
+        }));
+        return sortComponentRows(withFunctionCounts);
       }
     }),
     systemListTables: query({
@@ -4813,25 +5268,40 @@ function createSystemFunctions(deps) {
         requireSystemCapability("tables:read");
         const targetComponent = componentPath ?? "";
         const schema2 = await loadSchemaDefinition(targetComponent);
-        let tableEntries = [];
+        const schemaTables = new Map;
         if (schema2?.tables) {
-          tableEntries = extractTablesFromSchema(schema2);
-        } 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 = [];
+          for (const table of extractTablesFromSchema(schema2)) {
+            schemaTables.set(table.name, table);
           }
         }
+        const discoveredTables = new Map;
+        for (const name of schemaTables.keys()) {
+          discoveredTables.set(name, {
+            name,
+            isSystem: isSystemTable(name),
+            visibility: getDefaultSystemTableVisibility(name)
+          });
+        }
+        try {
+          const systemTables = await ctx.db.system.query("_tables").collect();
+          discoveredTables.clear();
+          for (const table of systemTables.filter((entry) => (entry.componentPath ?? "") === targetComponent)) {
+            discoveredTables.set(table.name, {
+              name: table.name,
+              isSystem: table.isSystem === true || isSystemTable(table.name),
+              visibility: table.visibility === "private" ? "private" : "public"
+            });
+          }
+        } catch {}
+        const tableEntries = Array.from(discoveredTables.values()).map((metadata) => ({
+          ...metadata,
+          exported: schemaTables.get(metadata.name)?.exported ?? {
+            indexes: [],
+            searchIndexes: [],
+            vectorIndexes: [],
+            documentType: null
+          }
+        }));
         const tableInfo = await Promise.all(tableEntries.map(async (table) => {
           const fullName = getFullTableName(table.name, targetComponent);
           const documentCount = await countDocuments(ctx, fullName);
@@ -4842,6 +5312,8 @@ function createSystemFunctions(deps) {
             name: table.name,
             fullName,
             componentPath: targetComponent || undefined,
+            isSystem: table.isSystem,
+            visibility: table.visibility,
             documentCount,
             indexes: buildIndexList(exported?.indexes),
             searchIndexes: searchIndexes.map((idx) => typeof idx === "string" ? idx : idx.indexDescriptor),
@@ -4875,7 +5347,7 @@ function createSystemFunctions(deps) {
         }
         try {
           const fullName = getFullTableName(tableName, targetComponent);
-          const sampleDoc = await ctx.db.query(fullName).first();
+          const sampleDoc = await getTableQuery(ctx, fullName).first();
           const fields = sampleDoc ? Object.keys(sampleDoc).map((key) => ({
             name: key,
             type: typeof sampleDoc[key],
@@ -4910,7 +5382,7 @@ function createSystemFunctions(deps) {
       handler: async (ctx, args) => {
         requireSystemCapability("documents:read");
         const fullName = getFullTableName(args.tableName, args.componentPath ?? "");
-        let query2 = ctx.db.query(fullName);
+        let query2 = getTableQuery(ctx, fullName);
         if (args.orderBy && args.orderBy !== "_creationTime") {
           const allDocs2 = await query2.collect();
           const sorted = allDocs2.sort((a, b) => {
@@ -4961,7 +5433,7 @@ function createSystemFunctions(deps) {
       handler: async (ctx, args) => {
         requireSystemCapability("documents:write");
         const fullName = getFullTableName(args.tableName, args.componentPath ?? "");
-        const docs = await ctx.db.query(fullName).collect();
+        const docs = await getTableQuery(ctx, fullName).collect();
         for (const doc of docs) {
           await ctx.db.delete(doc._id);
         }
@@ -5257,6 +5729,83 @@ function resolveFunctionReference(functionPath, componentPath) {
   }
   return functionPath;
 }
+async function loadComponentRows(ctx) {
+  try {
+    const rows = await ctx.db.system.query("_components").collect();
+    if (rows.length > 0) {
+      return rows.map((row) => normalizeStoredComponentRow(row));
+    }
+  } catch {}
+  const modules = await listRegisteredModules();
+  const moduleCountByComponent = new Map;
+  const hasHttpByComponent = new Map;
+  const componentPaths = new Set([""]);
+  for (const module of modules) {
+    const componentPath = module.componentPath ?? "";
+    componentPaths.add(componentPath);
+    moduleCountByComponent.set(componentPath, (moduleCountByComponent.get(componentPath) ?? 0) + 1);
+    if (module.path === "http") {
+      hasHttpByComponent.set(componentPath, true);
+    }
+  }
+  return Array.from(componentPaths).map((componentPath) => ({
+    componentPath,
+    path: componentPath || "(root)",
+    isRoot: componentPath === "",
+    parentPath: componentPath === "" ? null : componentPath.includes("/") ? componentPath.split("/").slice(0, -1).join("/") : "",
+    depth: componentPath === "" ? 0 : componentPath.split("/").length,
+    moduleCount: moduleCountByComponent.get(componentPath) ?? 0,
+    childCount: 0,
+    functionCount: 0,
+    sourceType: "local",
+    hasHttp: hasHttpByComponent.get(componentPath) === true
+  }));
+}
+function normalizeStoredComponentRow(row) {
+  const componentPath = typeof row.componentPath === "string" ? row.componentPath : "";
+  return {
+    componentPath,
+    path: typeof row.displayPath === "string" ? row.displayPath : typeof row.path === "string" && row.path.length > 0 ? row.path : componentPath || "(root)",
+    isRoot: row.isRoot === true || componentPath === "",
+    parentPath: row.parentPath === null ? null : typeof row.parentPath === "string" ? row.parentPath : componentPath === "" ? null : "",
+    depth: typeof row.depth === "number" ? row.depth : componentPath === "" ? 0 : componentPath.split("/").length,
+    moduleCount: typeof row.moduleCount === "number" ? row.moduleCount : 0,
+    childCount: typeof row.childCount === "number" ? row.childCount : 0,
+    functionCount: 0,
+    sourceType: row.sourceType === "npm" ? "npm" : row.sourceType === "local" ? "local" : undefined,
+    sourcePath: typeof row.sourcePath === "string" ? row.sourcePath : undefined,
+    packageName: typeof row.packageName === "string" ? row.packageName : undefined,
+    packageVersion: typeof row.packageVersion === "string" ? row.packageVersion : undefined,
+    hasHttp: row.hasHttp === true
+  };
+}
+function sortComponentRows(rows) {
+  const childrenByParent = new Map;
+  for (const row of rows) {
+    const parentKey = row.parentPath ?? null;
+    const siblings = childrenByParent.get(parentKey) ?? [];
+    siblings.push(row);
+    childrenByParent.set(parentKey, siblings);
+  }
+  for (const siblings of childrenByParent.values()) {
+    siblings.sort((a, b) => {
+      if (a.isRoot)
+        return -1;
+      if (b.isRoot)
+        return 1;
+      return a.componentPath.localeCompare(b.componentPath);
+    });
+  }
+  const ordered = [];
+  const visit = (parentPath) => {
+    for (const row of childrenByParent.get(parentPath) ?? []) {
+      ordered.push(row);
+      visit(row.componentPath);
+    }
+  };
+  visit(null);
+  return ordered;
+}
 async function loadSchemaDefinition(componentPath) {
   try {
     const module = await loadConvexModule("schema", {
@@ -5290,13 +5839,26 @@ function extractTableMetadata(schema2, tableName) {
 }
 async function countDocuments(ctx, tableName) {
   try {
-    const documents = await ctx.db.query(tableName).collect();
+    const documents = await getTableQuery(ctx, tableName).collect();
     return documents.length;
   } catch (error) {
     console.warn(`Failed to count documents for table ${tableName}:`, error);
     return 0;
   }
 }
+function getTableQuery(ctx, fullTableName) {
+  const { tableName } = parseFullTableName(fullTableName);
+  if (isSystemTable(tableName)) {
+    return ctx.db.system.query(tableName);
+  }
+  return ctx.db.query(fullTableName);
+}
+function getDefaultSystemTableVisibility(tableName) {
+  if (!isSystemTable(tableName)) {
+    return "public";
+  }
+  return isPublicSystemTable(tableName) ? "public" : "private";
+}
 function buildIndexList(indexes) {
   const base = ["by_id", "by_creation_time"];
   if (!indexes || indexes.length === 0) {
@@ -5398,6 +5960,7 @@ var init_internal = __esm(() => {
   init_interface();
   init_execution_log();
   init_auth();
+  init_system_tables();
 });
 
 // ../core/dist/system/system-functions-module.js
@@ -5555,8 +6118,9 @@ class ModuleRegistry {
             const normalized = normalizeModuleListing(listing);
             if (!normalized)
               continue;
-            if (!results.has(normalized.path)) {
-              results.set(normalized.path, {
+            const resultKey = `${normalized.componentPath ?? scope ?? ""}:${normalized.path}`;
+            if (!results.has(resultKey)) {
+              results.set(resultKey, {
                 ...normalized,
                 scope: scope || undefined,
                 componentPath: normalized.componentPath ?? (scope || undefined)
@@ -5875,8 +6439,10 @@ var init_module_loader = __esm(() => {
 class SchemaValidator {
   schemaCache = new Map;
   componentPath;
-  constructor(componentPath) {
+  tableRegistry;
+  constructor(componentPath, tableRegistry) {
     this.componentPath = componentPath;
+    this.tableRegistry = tableRegistry;
   }
   async loadTableSchema(tableName) {
     if (this.schemaCache.has(tableName)) {
@@ -5919,8 +6485,11 @@ class SchemaValidator {
       return;
     }
     try {
+      const tableNumberToName = this.tableRegistry ? new Map((await this.tableRegistry.listTables()).map((table) => [table.tableNumber, table.fullName])) : undefined;
       validateValidator(tableSchema, omit(document, ["_id", "_creationTime"]), "", {
-        componentPath: this.componentPath ?? ""
+        componentPath: this.componentPath ?? "",
+        tableRegistry: this.tableRegistry,
+        tableNumberToName
       });
     } catch (error) {
       throw new ValidatorError(`Failed to insert or update a document in table "${tableName}" because it does not match the schema: ${error.message}`);
@@ -6018,6 +6587,16 @@ Path: ${formatPath(path)}
 Value: ${formatValue(value)}
 Validator: v.id("${validator2.tableName}")`);
       }
+      if (isValidDocumentId(value)) {
+        const tableName2 = tableNameFromConvexId(value, options);
+        if (!tableName2 || !isMatchingValidatorTable(tableName2, validator2.tableName, options.componentPath)) {
+          throw new Error(`Value does not match validator.
+Path: ${formatPath(path)}
+Value: ${formatValue(value)}
+Validator: v.id("${validator2.tableName}")`);
+        }
+        return;
+      }
       const tableName = tableNameFromId(value);
       if (!tableName || !isMatchingValidatorTable(tableName, validator2.tableName, options.componentPath)) {
         throw new Error(`Value does not match validator.
@@ -6079,289 +6658,72 @@ Validator: v.object({...})`);
           }
         } else {
           const fieldPath = path ? `${path}.${k}` : `.${k}`;
-          validateValidator(fieldType, value[k], fieldPath, options);
-        }
-      }
-      for (const k of Object.keys(value)) {
-        if (validator2.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 isObject2 = typeof value === "object";
-  const prototype = Object.getPrototypeOf(value);
-  const isSimple = prototype === null || prototype === Object.prototype || prototype?.constructor?.name === "Object";
-  return isObject2 && isSimple;
-}
-var ValidatorError;
-var init_validator2 = __esm(() => {
-  init_interface();
-  init_module_loader();
-  ValidatorError = class ValidatorError extends Error {
-    path;
-    constructor(message2, path = "") {
-      super(message2);
-      this.path = path;
-      this.name = "ValidatorError";
-    }
-  };
-});
-
-// ../core/dist/id-codec/base32.js
-function base32Encode(data) {
-  if (data.length === 0)
-    return "";
-  let result = "";
-  let buffer = 0;
-  let bitsLeft = 0;
-  for (const byte of data) {
-    buffer = buffer << 8 | byte;
-    bitsLeft += 8;
-    while (bitsLeft >= 5) {
-      bitsLeft -= 5;
-      const index = buffer >> bitsLeft & 31;
-      result += ALPHABET[index];
-    }
-  }
-  if (bitsLeft > 0) {
-    const index = buffer << 5 - bitsLeft & 31;
-    result += ALPHABET[index];
-  }
-  return result;
-}
-function base32Decode(str) {
-  if (str.length === 0)
-    return new Uint8Array(0);
-  const outputLength = Math.floor(str.length * 5 / 8);
-  const result = new Uint8Array(outputLength);
-  let buffer = 0;
-  let bitsLeft = 0;
-  let outputIndex = 0;
-  for (const char of str) {
-    const value = ALPHABET_MAP.get(char);
-    if (value === undefined) {
-      throw new Error(`Invalid base32 character: ${char}`);
-    }
-    buffer = buffer << 5 | value;
-    bitsLeft += 5;
-    if (bitsLeft >= 8) {
-      bitsLeft -= 8;
-      result[outputIndex++] = buffer >> bitsLeft & 255;
-    }
-  }
-  return result;
-}
-function isValidBase32(str) {
-  for (const char of str) {
-    if (!ALPHABET_MAP.has(char)) {
-      return false;
-    }
-  }
-  return true;
-}
-var ALPHABET = "0123456789abcdefghjkmnpqrstvwxyz", ALPHABET_MAP;
-var init_base32 = __esm(() => {
-  ALPHABET_MAP = new Map;
-  for (let i2 = 0;i2 < ALPHABET.length; i2++) {
-    ALPHABET_MAP.set(ALPHABET[i2], i2);
-    ALPHABET_MAP.set(ALPHABET[i2].toUpperCase(), i2);
-  }
-  ALPHABET_MAP.set("i", 1);
-  ALPHABET_MAP.set("I", 1);
-  ALPHABET_MAP.set("l", 1);
-  ALPHABET_MAP.set("L", 1);
-  ALPHABET_MAP.set("o", 0);
-  ALPHABET_MAP.set("O", 0);
-});
-
-// ../core/dist/id-codec/vint.js
-function vintEncode(value) {
-  if (value < 0) {
-    throw new Error("VInt cannot encode negative numbers");
-  }
-  if (value > 4294967295) {
-    throw new Error("VInt cannot encode values larger than 2^32-1");
-  }
-  value = value >>> 0;
-  if (value < 128) {
-    return new Uint8Array([value]);
-  }
-  if (value < 16512) {
-    const adjusted2 = value - 128;
-    return new Uint8Array([128 | adjusted2 >> 8 & 63, adjusted2 & 255]);
-  }
-  if (value < 2113664) {
-    const adjusted2 = value - 16512;
-    return new Uint8Array([192 | adjusted2 >> 16 & 31, adjusted2 >> 8 & 255, adjusted2 & 255]);
-  }
-  if (value < 270549120) {
-    const adjusted2 = value - 2113664;
-    return new Uint8Array([
-      224 | adjusted2 >> 24 & 15,
-      adjusted2 >> 16 & 255,
-      adjusted2 >> 8 & 255,
-      adjusted2 & 255
-    ]);
-  }
-  const adjusted = value - 270549120;
-  return new Uint8Array([
-    240 | adjusted >> 32 & 7,
-    adjusted >> 24 & 255,
-    adjusted >> 16 & 255,
-    adjusted >> 8 & 255,
-    adjusted & 255
-  ]);
-}
-function vintDecode(data, offset = 0) {
-  if (offset >= data.length) {
-    throw new Error("VInt decode: unexpected end of data");
-  }
-  const first = data[offset];
-  if ((first & 128) === 0) {
-    return { value: first, bytesRead: 1 };
-  }
-  if ((first & 192) === 128) {
-    if (offset + 1 >= data.length) {
-      throw new Error("VInt decode: truncated 2-byte encoding");
-    }
-    const value = 128 + ((first & 63) << 8 | data[offset + 1]);
-    return { value, bytesRead: 2 };
-  }
-  if ((first & 224) === 192) {
-    if (offset + 2 >= data.length) {
-      throw new Error("VInt decode: truncated 3-byte encoding");
-    }
-    const value = 16512 + ((first & 31) << 16 | data[offset + 1] << 8 | data[offset + 2]);
-    return { value, bytesRead: 3 };
-  }
-  if ((first & 240) === 224) {
-    if (offset + 3 >= data.length) {
-      throw new Error("VInt decode: truncated 4-byte encoding");
-    }
-    const value = 2113664 + ((first & 15) << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]);
-    return { value: value >>> 0, bytesRead: 4 };
-  }
-  if ((first & 248) === 240) {
-    if (offset + 4 >= data.length) {
-      throw new Error("VInt decode: truncated 5-byte encoding");
-    }
-    const high = first & 7;
-    const low = (data[offset + 1] << 24 | data[offset + 2] << 16 | data[offset + 3] << 8 | data[offset + 4]) >>> 0;
-    const value = 270549120 + high * 4294967296 + low;
-    return { value: value >>> 0, bytesRead: 5 };
-  }
-  throw new Error("VInt decode: invalid prefix");
-}
-
-// ../core/dist/id-codec/fletcher16.js
-function fletcher16(data) {
-  let sum1 = 0;
-  let sum2 = 0;
-  for (const byte of data) {
-    sum1 = (sum1 + byte) % 255;
-    sum2 = (sum2 + sum1) % 255;
-  }
-  return new Uint8Array([sum1, sum2]);
-}
-function verifyFletcher16(data, checksum) {
-  if (checksum.length !== 2)
-    return false;
-  const computed = fletcher16(data);
-  return computed[0] === checksum[0] && computed[1] === checksum[1];
-}
-
-// ../core/dist/utils/crypto.js
-var weakRandomState;
-var init_crypto = __esm(() => {
-  weakRandomState = (Date.now() ^ 2654435769) >>> 0;
-});
-
-// ../core/dist/id-codec/document-id.js
-function encodeDocumentId(tableNumber, internalId) {
-  if (internalId.length !== INTERNAL_ID_LENGTH) {
-    throw new Error(`Internal ID must be exactly ${INTERNAL_ID_LENGTH} bytes, got ${internalId.length}`);
-  }
-  if (tableNumber < 1 || tableNumber > 4294967295) {
-    throw new Error(`Table number must be between 1 and 2^32-1, got ${tableNumber}`);
-  }
-  const tableBytes = vintEncode(tableNumber);
-  const payload = new Uint8Array(tableBytes.length + INTERNAL_ID_LENGTH);
-  payload.set(tableBytes, 0);
-  payload.set(internalId, tableBytes.length);
-  const checksum = fletcher16(payload);
-  const final = new Uint8Array(payload.length + 2);
-  final.set(payload, 0);
-  final.set(checksum, payload.length);
-  return base32Encode(final);
-}
-function decodeDocumentId(encoded) {
-  if (encoded.length < MIN_ENCODED_LENGTH || encoded.length > MAX_ENCODED_LENGTH) {
-    throw new Error(`Invalid document ID length: ${encoded.length} (expected ${MIN_ENCODED_LENGTH}-${MAX_ENCODED_LENGTH})`);
-  }
-  if (!isValidBase32(encoded)) {
-    throw new Error("Invalid document ID: contains invalid base32 characters");
-  }
-  const bytes = base32Decode(encoded);
-  if (bytes.length < 19) {
-    throw new Error(`Invalid document ID: decoded to ${bytes.length} bytes (minimum 19)`);
-  }
-  const checksum = bytes.slice(bytes.length - 2);
-  const payload = bytes.slice(0, bytes.length - 2);
-  if (!verifyFletcher16(payload, checksum)) {
-    throw new Error("Invalid document ID: checksum verification failed");
+          validateValidator(fieldType, value[k], fieldPath, options);
+        }
+      }
+      for (const k of Object.keys(value)) {
+        if (validator2.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;
+    }
   }
-  const { value: tableNumber, bytesRead } = vintDecode(payload, 0);
-  const internalId = payload.slice(bytesRead, bytesRead + INTERNAL_ID_LENGTH);
-  if (internalId.length !== INTERNAL_ID_LENGTH) {
-    throw new Error(`Invalid document ID: internal ID is ${internalId.length} bytes (expected ${INTERNAL_ID_LENGTH})`);
+}
+function tableNameFromId(id) {
+  const parts = deserializeDeveloperId(id);
+  if (!parts) {
+    return null;
   }
-  return { tableNumber, internalId };
+  return hexToString(parts.table);
 }
-function isValidDocumentId(encoded) {
+function tableNameFromConvexId(id, options) {
   try {
-    decodeDocumentId(encoded);
-    return true;
+    const decoded = decodeDocumentId(id);
+    const fromMap = options.tableNumberToName?.get(decoded.tableNumber);
+    if (fromMap) {
+      return fromMap;
+    }
+    return null;
   } catch {
-    return false;
+    return null;
   }
 }
-function internalIdToHex(internalId) {
-  let hex = "";
-  for (let i2 = 0;i2 < internalId.length; i2++) {
-    hex += internalId[i2].toString(16).padStart(2, "0");
+function isMatchingValidatorTable(idTableName, validatorTableName, componentPath) {
+  if (idTableName === validatorTableName) {
+    return true;
   }
-  return hex;
+  const { tableName: validatorBareName } = parseFullTableName(validatorTableName);
+  const { tableName: idBareName } = parseFullTableName(idTableName);
+  if (componentPath !== undefined) {
+    const expectedFullName = getFullTableName(validatorBareName, componentPath);
+    return idTableName === expectedFullName;
+  }
+  return idBareName === validatorBareName;
 }
-var INTERNAL_ID_LENGTH = 16, MIN_ENCODED_LENGTH = 31, MAX_ENCODED_LENGTH = 37;
-var init_document_id = __esm(() => {
-  init_base32();
-  init_crypto();
+function isSimpleObject2(value) {
+  const isObject2 = typeof value === "object";
+  const prototype = Object.getPrototypeOf(value);
+  const isSimple = prototype === null || prototype === Object.prototype || prototype?.constructor?.name === "Object";
+  return isObject2 && isSimple;
+}
+var ValidatorError;
+var init_validator2 = __esm(() => {
+  init_utils();
+  init_interface();
+  init_module_loader();
+  init_id_codec();
+  ValidatorError = class ValidatorError extends Error {
+    path;
+    constructor(message2, path = "") {
+      super(message2);
+      this.path = path;
+      this.name = "ValidatorError";
+    }
+  };
 });
 
 // src/sqlite-docstore.ts
@@ -6372,7 +6734,10 @@ init_values();
 
 // ../core/dist/docstore/interface.js
 function documentIdKey(id) {
-  const tableKey = id.table && id.table.length > 0 ? id.table : id.tableNumber !== undefined && Number.isInteger(id.tableNumber) && id.tableNumber > 0 ? `#${id.tableNumber}` : id.table;
+  const tableKey = id.table && id.table.length > 0 ? id.table : id.tableNumber !== undefined && Number.isInteger(id.tableNumber) && id.tableNumber > 0 ? `#${id.tableNumber}` : null;
+  if (!tableKey) {
+    throw new Error("Invalid document ID: missing table and tableNumber");
+  }
   return `${tableKey}:${id.internalId}`;
 }
 var Order;
@@ -6579,6 +6944,7 @@ class TimestampOracle {
   }
 }
 // ../core/dist/utils/keyspace.js
+init_utils();
 var TABLE_PREFIX = "table";
 var INDEX_PREFIX = "index";
 function encodeComponent(component) {
@@ -6619,6 +6985,13 @@ function decodeIndexId(indexId) {
     index: decoded.slice(separatorIndex + 1)
   };
 }
+
+// ../core/dist/utils/index.js
+init_utils();
+
+// ../core/dist/queryengine/indexing/index-manager.js
+init_utils();
+
 // ../core/dist/queryengine/indexing/index-key-codec.js
 var TypeTag;
 (function(TypeTag2) {
@@ -6668,8 +7041,9 @@ function encodeBigInt(n) {
   return bytes;
 }
 function encodeString(s) {
-  const encoder = new TextEncoder;
-  const raw = encoder.encode(s);
+  return encodeEscapedBytes(new TextEncoder().encode(s));
+}
+function encodeEscapedBytes(raw) {
   let nullCount = 0;
   for (const byte of raw) {
     if (byte === 0)
@@ -6733,11 +7107,10 @@ function encodeValue(value) {
   }
   if (value instanceof ArrayBuffer || value instanceof Uint8Array) {
     const bytes = value instanceof Uint8Array ? value : new Uint8Array(value);
-    const result = new Uint8Array(1 + bytes.length + 2);
+    const encoded = encodeEscapedBytes(bytes);
+    const result = new Uint8Array(1 + encoded.length);
     result[0] = TypeTag.Bytes;
-    result.set(bytes, 1);
-    result[result.length - 2] = 0;
-    result[result.length - 1] = 0;
+    result.set(encoded, 1);
     return result;
   }
   throw new Error(`Cannot encode value of type ${typeof value} in index key`);
@@ -6854,9 +7227,11 @@ class SchemaService {
   tableCache = new Map;
   schemaValidator;
   componentPath;
-  constructor(componentPath) {
+  tableRegistry;
+  constructor(componentPath, tableRegistry) {
     this.componentPath = componentPath;
-    this.schemaValidator = new SchemaValidator(componentPath);
+    this.tableRegistry = tableRegistry;
+    this.schemaValidator = new SchemaValidator(componentPath, tableRegistry);
   }
   async validate(tableName, document) {
     try {
@@ -6981,6 +7356,10 @@ class SchemaService {
     return this.cachedSchemaDefinition;
   }
 }
+
+// ../core/dist/queryengine/index-query.js
+init_utils();
+
 // ../core/dist/observability/udf-trace.js
 init_context_storage();
 var TRACE_CONTEXT = new ContextStorage;
@@ -7224,11 +7603,10 @@ function evaluateFieldPath(fieldPath, document) {
   }
   return current;
 }
-// ../core/dist/id-codec/index.js
-init_base32();
-init_document_id();
 
 // ../core/dist/queryengine/developer-id.js
+init_utils();
+init_id_codec();
 function parseDeveloperId(developerId) {
   if (isValidDocumentId(developerId)) {
     try {
@@ -7246,6 +7624,25 @@ function parseDeveloperId(developerId) {
   }
   return { table: parts.table, internalId: parts.internalId };
 }
+async function parseDeveloperIdWithTableRegistry(developerId, tableRegistry) {
+  if (isValidDocumentId(developerId)) {
+    try {
+      const decoded = decodeDocumentId(developerId);
+      const tableInfo = await tableRegistry.getTableInfo(decoded.tableNumber);
+      if (!tableInfo) {
+        return null;
+      }
+      return {
+        table: stringToHex(tableInfo.fullName),
+        internalId: internalIdToHex(decoded.internalId),
+        tableNumber: decoded.tableNumber
+      };
+    } catch {
+      return null;
+    }
+  }
+  return parseDeveloperId(developerId);
+}
 function parseStorageId(storageId) {
   const parsed = parseDeveloperId(storageId);
   if (parsed) {
@@ -7262,12 +7659,21 @@ function parseStorageId(storageId) {
 function isTablePlaceholder(table) {
   return table.startsWith("#");
 }
+
+// ../core/dist/query/query-runtime.js
+init_utils();
+
 // ../core/dist/query/planner.js
 init_interface();
+init_utils();
+
 // ../core/dist/query/actions.js
+init_utils();
 init_interface();
 
 // ../core/dist/queryengine/indexing/read-write-set.js
+init_utils();
+
 class RangeSet {
   ranges = new Map;
   addDocument(docId) {
@@ -7378,6 +7784,8 @@ function deserializeKeyRange(serialized) {
 }
 
 // ../core/dist/kernel/access-log.js
+init_utils();
+
 class AccessLog {
   ranges = new RangeSet;
   addDocument(docId) {
@@ -7402,104 +7810,9 @@ class AccessLog {
   }
 }
 
-// ../core/dist/tables/memory-table-registry.js
+// ../core/dist/kernel/kernel-context.js
 init_interface();
 
-class MemoryTableRegistry {
-  tablesByName = new Map;
-  tablesByNumber = new Map;
-  nextTableNumber = FIRST_USER_TABLE_NUMBER;
-  constructor() {
-    this.registerSystemTables();
-  }
-  registerSystemTables() {
-    for (const [name, number] of Object.entries(SYSTEM_TABLE_NUMBERS)) {
-      const info = {
-        tableNumber: number,
-        name,
-        componentPath: "",
-        fullName: name,
-        isSystem: true,
-        createdAt: Date.now()
-      };
-      this.tablesByName.set(name, info);
-      this.tablesByNumber.set(number, info);
-    }
-  }
-  async getOrAllocateTableNumber(tableName, componentPath = "") {
-    const fullName = getFullTableName(tableName, componentPath);
-    const existing = this.tablesByName.get(fullName);
-    if (existing) {
-      return existing.tableNumber;
-    }
-    if (isSystemTable(tableName) && componentPath === "") {
-      const systemNumber = SYSTEM_TABLE_NUMBERS[tableName];
-      if (systemNumber !== undefined) {
-        return systemNumber;
-      }
-    }
-    const tableNumber = this.nextTableNumber++;
-    const info = {
-      tableNumber,
-      name: tableName,
-      componentPath,
-      fullName,
-      isSystem: false,
-      createdAt: Date.now()
-    };
-    this.tablesByName.set(fullName, info);
-    this.tablesByNumber.set(tableNumber, info);
-    return tableNumber;
-  }
-  async getTableInfo(tableNumber) {
-    return this.tablesByNumber.get(tableNumber) ?? null;
-  }
-  async getTableInfoByName(tableName, componentPath = "") {
-    const fullName = getFullTableName(tableName, componentPath);
-    return this.tablesByName.get(fullName) ?? null;
-  }
-  async listTables(componentPath) {
-    const tables = Array.from(this.tablesByNumber.values());
-    if (componentPath === undefined) {
-      return tables;
-    }
-    return tables.filter((t) => t.componentPath === componentPath);
-  }
-  async hasAccess(tableNumber, componentPath) {
-    const info = await this.getTableInfo(tableNumber);
-    if (!info) {
-      return false;
-    }
-    if (info.isSystem) {
-      return true;
-    }
-    return info.componentPath === componentPath;
-  }
-  getSystemTableNumber(systemTableName) {
-    return SYSTEM_TABLE_NUMBERS[systemTableName];
-  }
-  reset() {
-    this.tablesByName.clear();
-    this.tablesByNumber.clear();
-    this.nextTableNumber = FIRST_USER_TABLE_NUMBER;
-    this.registerSystemTables();
-  }
-  getState() {
-    return {
-      tableCount: this.tablesByNumber.size,
-      nextNumber: this.nextTableNumber
-    };
-  }
-}
-var globalRegistry = null;
-function getGlobalTableRegistry() {
-  if (!globalRegistry) {
-    globalRegistry = new MemoryTableRegistry;
-  }
-  return globalRegistry;
-}
-
-// ../core/dist/kernel/kernel-context.js
 class KernelContext {
   authContext;
   componentPath;
@@ -7516,11 +7829,14 @@ class KernelContext {
     this.authContext = options.authContext;
     this.componentPath = options.componentPath ?? "";
     this.mutationTransaction = options.mutationTransaction;
-    this.tableRegistry = options.tableRegistry ?? getGlobalTableRegistry();
-    this.useConvexIdFormat = options.useConvexIdFormat ?? false;
+    if (!options.tableRegistry) {
+      throw new Error("KernelContext requires an explicit tableRegistry");
+    }
+    this.tableRegistry = options.tableRegistry;
+    this.useConvexIdFormat = options.useConvexIdFormat ?? true;
   }
   async getTableNumber(tableName) {
-    return this.tableRegistry.getOrAllocateTableNumber(tableName, this.componentPath);
+    return this.tableRegistry.getOrAllocateTableNumber(tableName, isSystemTable(tableName) ? "" : this.componentPath);
   }
   nextSubrequestId(prefix, udfPath) {
     return `${prefix}:${udfPath}:${Date.now()}:${Math.random()}:${this.subrequestCounter++}`;
@@ -7565,7 +7881,7 @@ class KernelContext {
     this.writeLog.addDocument(docId);
   }
   recordLocalWrite(developerId, tableName, value, docId) {
-    this.localWrites.set(developerId, { table: tableName, value });
+    this.localWrites.set(developerId, { table: tableName, value, docId });
     if (docId) {
       this.recordDocumentWrite(docId);
       return;
@@ -7607,7 +7923,13 @@ class KernelContext {
   }
 }
 
+// ../core/dist/kernel/udf-kernel.js
+init_id_codec();
+
 // ../core/dist/kernel/blob-store-gateway.js
+init_id_codec();
+init_utils();
+
 class BlobStoreGateway {
   context;
   docStore;
@@ -7656,7 +7978,7 @@ class BlobStoreGateway {
     if (!this.storage) {
       return null;
     }
-    const docId = parseStorageId(storageId);
+    const docId = await parseDeveloperIdWithTableRegistry(storageId, this.context.tableRegistry) ?? parseStorageId(storageId);
     if (!docId) {
       console.debug(`[BlobStoreGateway] Failed to parse storage ID: ${storageId}`);
       return null;
@@ -7677,7 +7999,7 @@ class BlobStoreGateway {
     if (!this.storage) {
       return null;
     }
-    const docId = parseStorageId(storageId);
+    const docId = await parseDeveloperIdWithTableRegistry(storageId, this.context.tableRegistry) ?? parseStorageId(storageId);
     if (!docId) {
       return null;
     }
@@ -7690,7 +8012,7 @@ class BlobStoreGateway {
   }
   async delete(storageId) {
     const storage2 = this.requireStorage();
-    const docId = parseStorageId(storageId);
+    const docId = await parseDeveloperIdWithTableRegistry(storageId, this.context.tableRegistry) ?? parseStorageId(storageId);
     if (!docId) {
       return;
     }
@@ -7715,13 +8037,17 @@ class BlobStoreGateway {
 
 // ../core/dist/kernel/scheduler-gateway.js
 init_values();
+init_id_codec();
+init_utils();
+
 // ../core/dist/kernel/syscalls/utils.js
 init_values();
+init_utils();
 async function resolveTableName(docId, tableRegistry) {
   if (docId.tableNumber !== undefined) {
     const info = await tableRegistry.getTableInfo(docId.tableNumber);
     if (info) {
-      return info.name;
+      return info.fullName;
     }
     if (!isTablePlaceholder(docId.table)) {
       return hexToString(docId.table);
@@ -7902,7 +8228,7 @@ class SchedulerGateway {
     return developerId;
   }
   async cancel(id, state) {
-    const docId = parseDeveloperId(id);
+    const docId = await parseDeveloperIdWithTableRegistry(id, this.context.tableRegistry);
     if (!docId) {
       throw new Error(`Scheduled job with id ${id} not found.`);
     }
@@ -8027,6 +8353,8 @@ class ActionSyscalls {
 
 // ../core/dist/kernel/syscalls/database-syscalls.js
 init_values();
+init_id_codec();
+init_utils();
 init_interface();
 
 class DatabaseSyscalls {
@@ -8063,7 +8391,8 @@ class DatabaseSyscalls {
     if (docId.tableNumber !== undefined) {
       return { id: idString };
     }
-    if (docId.table === stringToHex(tableName)) {
+    const expectedFullTableName = getFullTableName(tableName, isSystemTable(tableName) ? "" : this.context.componentPath);
+    if (docId.table === stringToHex(expectedFullTableName)) {
       return { id: idString };
     }
     return { id: null };
@@ -8122,29 +8451,28 @@ class DatabaseSyscalls {
     return { _id: developerId };
   }
   async handleGet(args) {
-    const { id } = args;
+    const { id, table } = args;
     if (typeof id !== "string") {
       throw new Error("`id` argument for `get` must be a string.");
     }
-    const internalId = parseDeveloperId(id);
-    if (!internalId) {
+    const resolved = await this.resolveDocumentTarget(id, table, "get");
+    if (!resolved) {
       return null;
     }
-    this.context.recordDocumentRead(internalId);
-    const doc = await this.queryRuntime.getVisibleDocumentById(id, internalId);
+    this.context.recordDocumentRead(resolved.docId);
+    const doc = await this.queryRuntime.getVisibleDocumentById(id, resolved.docId);
     return doc ?? null;
   }
   async handleRemove(args) {
-    const { id } = args;
+    const { id, table } = args;
     if (typeof id !== "string") {
       throw new Error("`id` argument for `remove` must be a string.");
     }
-    const docId = parseDeveloperId(id);
-    if (!docId) {
+    const resolved = await this.resolveDocumentTarget(id, table, "remove", true);
+    if (!resolved) {
       throw new Error(`Document with id ${id} not found.`);
     }
-    const fullTableName = await resolveTableName(docId, this.context.tableRegistry);
-    const { tableName: bareTableName } = parseFullTableName(fullTableName);
+    const { docId, fullTableName, bareTableName } = resolved;
     const latest = await this.docStore.fetchLatestDocument(docId, this.context.snapshotTimestamp);
     if (!latest) {
       throw new Error(`Document with id ${id} not found.`);
@@ -8160,16 +8488,15 @@ class DatabaseSyscalls {
     return {};
   }
   async handleShallowMerge(args) {
-    const { id, value } = args;
+    const { id, table, value } = args;
     if (typeof id !== "string") {
       throw new Error("`id` argument for `shallowMerge` must be a string.");
     }
-    const docId = parseDeveloperId(id);
-    if (!docId) {
+    const resolved = await this.resolveDocumentTarget(id, table, "patch", true);
+    if (!resolved) {
       throw new Error(`Document with id ${id} not found.`);
     }
-    const fullTableName = await resolveTableName(docId, this.context.tableRegistry);
-    const { tableName: bareTableName } = parseFullTableName(fullTableName);
+    const { docId, fullTableName, bareTableName } = resolved;
     if (value && typeof value === "object") {
       if ("_id" in value) {
         throw new Error("System field `_id` cannot be modified in a patch operation.");
@@ -8220,16 +8547,15 @@ class DatabaseSyscalls {
     return {};
   }
   async handleReplace(args) {
-    const { id, value } = args;
+    const { id, table, value } = args;
     if (typeof id !== "string") {
       throw new Error("`id` argument for `replace` must be a string.");
     }
-    const docId = parseDeveloperId(id);
-    if (!docId) {
+    const resolved = await this.resolveDocumentTarget(id, table, "replace", true);
+    if (!resolved) {
       throw new Error(`Document with id ${id} not found.`);
     }
-    const fullTableName = await resolveTableName(docId, this.context.tableRegistry);
-    const { tableName: bareTableName } = parseFullTableName(fullTableName);
+    const { docId, fullTableName, bareTableName } = resolved;
     const replaceValue = jsonToConvex(value);
     if (typeof replaceValue !== "object" || replaceValue === null || Array.isArray(replaceValue)) {
       throw new Error("The replacement value for `replace` must be an object.");
@@ -8252,6 +8578,27 @@ class DatabaseSyscalls {
     this.context.recordLocalWrite(id, fullTableName, newValue, canonicalDocId);
     return {};
   }
+  async resolveDocumentTarget(id, table, operation, throwOnMismatch = false) {
+    if (table !== undefined && typeof table !== "string") {
+      throw new Error(`\`table\` argument for \`${operation}\` must be a string.`);
+    }
+    const docId = await parseDeveloperIdWithTableRegistry(id, this.context.tableRegistry);
+    if (!docId) {
+      return null;
+    }
+    const fullTableName = await resolveTableName(docId, this.context.tableRegistry);
+    if (typeof table === "string") {
+      const expectedFullTableName = getFullTableName(table, isSystemTable(table) ? "" : this.context.componentPath);
+      if (fullTableName !== expectedFullTableName) {
+        if (throwOnMismatch) {
+          throw new Error(`Document with id ${id} does not belong to table ${table}.`);
+        }
+        return null;
+      }
+    }
+    const { tableName: bareTableName } = parseFullTableName(fullTableName);
+    return { docId, fullTableName, bareTableName };
+  }
 }
 
 // ../core/dist/kernel/syscalls/identity-syscalls.js
@@ -8567,11 +8914,203 @@ class KernelSyscalls {
     return this.jsRouter.dispatch(op, args);
   }
 }
+
+// ../core/dist/tables/docstore-table-registry.js
+init_system_tables();
+init_utils();
+init_interface();
+
+class DocStoreTableRegistry {
+  docstore;
+  tablesByNumber = new Map;
+  tablesByName = new Map;
+  loadPromise = null;
+  cachedRegistryVersion = 0;
+  constructor(docstore) {
+    this.docstore = docstore;
+  }
+  async getOrAllocateTableNumber(tableName, componentPath = "") {
+    await this.ensureLoaded();
+    await this.ensureFresh();
+    const normalizedComponent = isSystemTable(tableName) ? "" : componentPath;
+    const fullName = getFullTableName(tableName, normalizedComponent);
+    let existing = this.tablesByName.get(fullName);
+    if (existing) {
+      return existing.tableNumber;
+    }
+    await this.reloadTables();
+    existing = this.tablesByName.get(fullName);
+    if (existing) {
+      return existing.tableNumber;
+    }
+    const oracle = this.docstore.timestampOracle;
+    for (;; ) {
+      const metadata = await readSystemMetadata(this.docstore) ?? createSystemMetadata({
+        nextUserTableNumber: Math.max(FIRST_USER_TABLE_NUMBER, nextUserTableNumber(this.tablesByNumber.values()))
+      });
+      const candidate = Math.max(metadata.nextUserTableNumber, nextUserTableNumber(this.tablesByNumber.values()));
+      const reserved = await this.docstore.writeGlobalIfAbsent(createTableNumberReservationKey(candidate), {
+        fullName,
+        reservedAt: Date.now()
+      });
+      if (!reserved) {
+        await this.reloadTables();
+        const raced = this.tablesByName.get(fullName);
+        if (raced) {
+          return raced.tableNumber;
+        }
+        continue;
+      }
+      const createdAt = Date.now();
+      const info = createTableInfo(tableName, candidate, normalizedComponent, { createdAt, visibility: "public" });
+      const timestamp2 = oracle?.allocateTimestamp?.() ?? BigInt(createdAt);
+      const entry = createTableMetadataEntryForUserTable(info, timestamp2);
+      try {
+        await this.docstore.write([entry], new Set, "Error");
+      } catch {
+        await this.reloadTables();
+        const raced = this.tablesByName.get(fullName);
+        if (raced) {
+          return raced.tableNumber;
+        }
+        throw new Error(`Failed to allocate table number for ${fullName}`);
+      }
+      const registryVersion = Number(timestamp2 > BigInt(Number.MAX_SAFE_INTEGER) ? BigInt(Date.now()) : timestamp2);
+      await this.docstore.writeGlobal(SYSTEM_METADATA_GLOBAL_KEY, createSystemMetadata({
+        nextUserTableNumber: candidate + 1,
+        registryVersion,
+        bootstrappedAt: metadata.bootstrappedAt,
+        updatedAt: registryVersion
+      }));
+      this.cachedRegistryVersion = registryVersion;
+      this.tablesByName.set(fullName, info);
+      this.tablesByNumber.set(candidate, info);
+      return candidate;
+    }
+  }
+  async getTableInfo(tableNumber) {
+    await this.ensureLoaded();
+    await this.ensureFresh();
+    const existing = this.tablesByNumber.get(tableNumber);
+    if (existing) {
+      return existing;
+    }
+    await this.reloadTables();
+    return this.tablesByNumber.get(tableNumber) ?? null;
+  }
+  async getTableInfoByName(tableName, componentPath = "") {
+    await this.ensureLoaded();
+    await this.ensureFresh();
+    const fullName = getFullTableName(tableName, isSystemTable(tableName) ? "" : componentPath);
+    const existing = this.tablesByName.get(fullName);
+    if (existing) {
+      return existing;
+    }
+    await this.reloadTables();
+    return this.tablesByName.get(fullName) ?? null;
+  }
+  async listTables(componentPath) {
+    await this.ensureLoaded();
+    await this.ensureFresh();
+    const values = Array.from(this.tablesByNumber.values());
+    if (componentPath === undefined) {
+      return values.sort((a, b) => a.tableNumber - b.tableNumber);
+    }
+    return values.filter((table) => table.componentPath === componentPath).sort((a, b) => a.tableNumber - b.tableNumber);
+  }
+  async hasAccess(tableNumber, componentPath) {
+    const info = await this.getTableInfo(tableNumber);
+    if (!info) {
+      return false;
+    }
+    if (info.isSystem) {
+      return true;
+    }
+    return info.componentPath === componentPath;
+  }
+  getSystemTableNumber(systemTableName) {
+    return SYSTEM_TABLE_NUMBERS[systemTableName];
+  }
+  async ensureLoaded() {
+    if (!this.loadPromise) {
+      this.loadPromise = this.loadTables();
+    }
+    await this.loadPromise;
+  }
+  async ensureFresh() {
+    const metadata = await readSystemMetadata(this.docstore);
+    if (!metadata) {
+      if (this.cachedRegistryVersion !== 0 || this.tablesByName.size > 0 || this.tablesByNumber.size > 0) {
+        await this.reloadTables();
+      }
+      return;
+    }
+    if (metadata.registryVersion > this.cachedRegistryVersion) {
+      await this.reloadTables();
+    }
+  }
+  async reloadTables() {
+    this.loadPromise = this.loadTables();
+    await this.loadPromise;
+  }
+  async loadTables() {
+    await ensureSystemTablesBootstrapped(this.docstore);
+    const docs = await this.docstore.scan(stringToHex("_tables"));
+    this.tablesByName.clear();
+    this.tablesByNumber.clear();
+    for (const doc of docs) {
+      const info = tableInfoFromStoredDocument(doc.value.value);
+      if (!info) {
+        continue;
+      }
+      this.tablesByName.set(info.fullName, info);
+      this.tablesByNumber.set(info.tableNumber, info);
+    }
+    if (this.tablesByNumber.size === 0) {
+      for (const [name, tableNumber] of Object.entries(SYSTEM_TABLE_NUMBERS)) {
+        const info = createTableInfo(name, tableNumber, "", { isSystem: true });
+        this.tablesByName.set(info.fullName, info);
+        this.tablesByNumber.set(info.tableNumber, info);
+      }
+    }
+    const metadata = await readSystemMetadata(this.docstore);
+    if (!metadata) {
+      const now = Date.now();
+      this.cachedRegistryVersion = now;
+      await this.docstore.writeGlobal(SYSTEM_METADATA_GLOBAL_KEY, createSystemMetadata({
+        nextUserTableNumber: Math.max(FIRST_USER_TABLE_NUMBER, nextUserTableNumber(this.tablesByNumber.values())),
+        registryVersion: now,
+        bootstrappedAt: now,
+        updatedAt: now
+      }));
+    } else {
+      this.cachedRegistryVersion = metadata.registryVersion;
+    }
+  }
+}
+
+// ../core/dist/tables/transactional-table-registry.js
+init_system_tables();
+init_utils();
+init_interface();
 // ../core/dist/kernel/contexts.js
 init_context_storage();
-var snapshotContext = new ContextStorage;
-var transactionContext = new ContextStorage;
-var idGeneratorContext = new ContextStorage;
+var SNAPSHOT_CONTEXT_SYMBOL = Symbol.for("@concavejs/core/snapshot-context");
+var TRANSACTION_CONTEXT_SYMBOL = Symbol.for("@concavejs/core/transaction-context");
+var ID_GENERATOR_CONTEXT_SYMBOL = Symbol.for("@concavejs/core/id-generator-context");
+var globalContexts = globalThis;
+var snapshotContext = globalContexts[SNAPSHOT_CONTEXT_SYMBOL] ?? new ContextStorage;
+var transactionContext = globalContexts[TRANSACTION_CONTEXT_SYMBOL] ?? new ContextStorage;
+var idGeneratorContext = globalContexts[ID_GENERATOR_CONTEXT_SYMBOL] ?? new ContextStorage;
+if (!globalContexts[SNAPSHOT_CONTEXT_SYMBOL]) {
+  globalContexts[SNAPSHOT_CONTEXT_SYMBOL] = snapshotContext;
+}
+if (!globalContexts[TRANSACTION_CONTEXT_SYMBOL]) {
+  globalContexts[TRANSACTION_CONTEXT_SYMBOL] = transactionContext;
+}
+if (!globalContexts[ID_GENERATOR_CONTEXT_SYMBOL]) {
+  globalContexts[ID_GENERATOR_CONTEXT_SYMBOL] = idGeneratorContext;
+}
 // ../core/dist/queryengine/convex-ops.js
 var debug = () => {};
 class CfConvex {
@@ -8624,6 +9163,8 @@ class BaseSqliteDocStore {
   vectorIndexesByTable = new Map;
   fts5Available = true;
   statementCache = new Map;
+  configuredSearchIndexes = [];
+  configuredVectorIndexes = [];
   constructor(adapter) {
     this.adapter = adapter;
     this.timestampOracle = new TimestampOracle;
@@ -8638,6 +9179,8 @@ class BaseSqliteDocStore {
     return statement;
   }
   async setupSchema(options) {
+    this.configuredSearchIndexes = [...options?.searchIndexes ?? []];
+    this.configuredVectorIndexes = [...options?.vectorIndexes ?? []];
     await this.adapter.exec(DOCUMENTS_TABLE_SCHEMA);
     await this.adapter.exec(DOCUMENTS_BY_TABLE_INDEX);
     await this.adapter.exec(INDEXES_TABLE_SCHEMA);
@@ -8645,6 +9188,24 @@ class BaseSqliteDocStore {
     await this.setupSearchIndexes(options?.searchIndexes ?? []);
     await this.setupVectorIndexes(options?.vectorIndexes ?? []);
   }
+  async resetForTesting() {
+    const rows = await this.adapter.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND sql IS NOT NULL").all();
+    for (const row of rows) {
+      const tableName = row?.name;
+      if (typeof tableName !== "string" || tableName.length === 0) {
+        continue;
+      }
+      await this.adapter.exec(`DROP TABLE IF EXISTS ${quoteSqlIdentifier(tableName)}`);
+    }
+    this.statementCache.clear();
+    this.searchIndexesByTable.clear();
+    this.vectorIndexesByTable.clear();
+    this.fts5Available = true;
+    await this.setupSchema({
+      searchIndexes: this.configuredSearchIndexes,
+      vectorIndexes: this.configuredVectorIndexes
+    });
+  }
   async setupSearchIndexes(searchIndexes) {
     try {
       await this.adapter.exec(SEARCH_INDEXES_FTS_SCHEMA);
@@ -8860,6 +9421,15 @@ class BaseSqliteDocStore {
     const stmt = this.getPreparedStatement("INSERT OR REPLACE INTO persistence_globals (key, json_value) VALUES (?, ?)");
     await stmt.run(key, JSON.stringify(value));
   }
+  async writeGlobalIfAbsent(key, value) {
+    const insertStmt = this.getPreparedStatement("INSERT OR IGNORE INTO persistence_globals (key, json_value) VALUES (?, ?)");
+    const changesStmt = this.getPreparedStatement("SELECT changes() as changes");
+    return this.adapter.transaction(async () => {
+      await insertStmt.run(key, JSON.stringify(value));
+      const row = await changesStmt.get();
+      return Number(row?.changes ?? 0) > 0;
+    });
+  }
   async previous_revisions(queries) {
     const results = new Map;
     const stmt = this.getPreparedStatement(`
@@ -9155,6 +9725,9 @@ class BaseSqliteDocStore {
     return scored.slice(0, limit);
   }
 }
+function quoteSqlIdentifier(value) {
+  return `"${value.replace(/"/g, '""')}"`;
+}
 // ../docstore-sqlite-base/dist/transaction-runner.js
 function createSerializedTransactionRunner(hooks) {
   let queue = Promise.resolve();