@concavejs/cli 0.0.1-alpha.8 → 0.0.1-alpha.9

package/dist/assets/runtime-node/server/index.js

@@ -2872,6 +2872,12 @@ function parseDocumentIdKey(key) {
   const internalId = key.substring(colonIndex + 1);
   if (!table || !internalId)
     return null;
+  if (table.startsWith("#")) {
+    const tableNumber = Number.parseInt(table.slice(1), 10);
+    if (Number.isInteger(tableNumber) && tableNumber > 0) {
+      return { table, internalId, tableNumber };
+    }
+  }
   return { table, internalId };
 }
 var Order;
@@ -10655,7 +10661,6 @@ class KernelContext5 {
   }
   recordTableRead(tableName) {
     if (this.mutationTransaction) {
-      this.mutationTransaction.recordTableScan(stringToHex5(tableName), []);
       return;
     }
     this.readLog.addTableScan(tableName);
@@ -10668,8 +10673,6 @@ class KernelContext5 {
   }
   recordIndexRange(tableName, indexDescriptor, startKey, endKey) {
     if (this.mutationTransaction) {
-      const indexId = indexKeyspaceId5(tableName, indexDescriptor);
-      this.mutationTransaction.recordIndexRangeScan(indexId, startKey, endKey, []);
       return;
     }
     this.readLog.addIndexRange(tableName, indexDescriptor, startKey, endKey);
@@ -10821,11 +10824,12 @@ class BlobStoreGateway5 {
     if (!latest || latest.ts > this.context.snapshotTimestamp) {
       return;
     }
-    await storage2.delete(docId.internalId);
+    const canonicalDocId = latest.value.id;
+    await storage2.delete(canonicalDocId.internalId);
     const timestamp22 = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp22, id: docId, value: null, prev_ts: latest.ts };
+    const entry = { ts: timestamp22, id: canonicalDocId, value: null, prev_ts: latest.ts };
     await this.docStore.applyWrites([entry], new Set, "Error");
-    this.context.recordLocalWrite(storageId, "_storage", null, docId);
+    this.context.recordLocalWrite(storageId, "_storage", null, canonicalDocId);
   }
   requireStorage() {
     if (!this.storage) {
@@ -11026,16 +11030,17 @@ class SchedulerGateway5 {
     if (!latest) {
       throw new Error(`Scheduled job with id ${id} not found.`);
     }
+    const canonicalDocId = latest.value.id;
     const newValue = {
       ...latest.value.value,
       state: state ?? { kind: "canceled" }
     };
-    const resolvedDocument = { id: docId, value: newValue };
+    const resolvedDocument = { id: canonicalDocId, value: newValue };
     const timestamp22 = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp22, id: docId, value: resolvedDocument, prev_ts: latest.ts };
+    const entry = { ts: timestamp22, id: canonicalDocId, value: resolvedDocument, prev_ts: latest.ts };
     await this.docStore.applyWrites([entry], new Set, "Error");
-    const tableName = await resolveTableName5(docId, this.context.tableRegistry);
-    this.context.recordLocalWrite(id, tableName, resolvedDocument.value, docId);
+    const tableName = await resolveTableName5(canonicalDocId, this.context.tableRegistry);
+    this.context.recordLocalWrite(id, tableName, resolvedDocument.value, canonicalDocId);
   }
 }
 async function runAsServerCall5(fn, functionPath) {
@@ -11238,13 +11243,14 @@ class DatabaseSyscalls5 {
     if (!latest) {
       throw new Error(`Document with id ${id} not found.`);
     }
+    const canonicalDocId = latest.value.id;
     const timestamp22 = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp22, id: docId, value: null, prev_ts: latest.ts };
+    const entry = { ts: timestamp22, id: canonicalDocId, value: null, prev_ts: latest.ts };
     const indexes = await this.schemaService.getAllIndexesForTable(bareTableName);
-    const indexUpdates = generateIndexUpdates5(fullTableName, docId, null, latest.value.value, indexes);
+    const indexUpdates = generateIndexUpdates5(fullTableName, canonicalDocId, null, latest.value.value, indexes);
     const indexEntries = new Set(indexUpdates.map((update) => ({ ts: timestamp22, update })));
     await this.docStore.applyWrites([entry], indexEntries, "Error");
-    this.context.recordLocalWrite(id, fullTableName, null, docId);
+    this.context.recordLocalWrite(id, fullTableName, null, canonicalDocId);
     return {};
   }
   async handleShallowMerge(args) {
@@ -11270,6 +11276,7 @@ class DatabaseSyscalls5 {
     if (!latest) {
       throw new Error(`Document with id ${id} not found.`);
     }
+    const canonicalDocId = latest.value.id;
     const existingValue = latest.value.value;
     const newValue = { ...existingValue };
     if (typeof value === "object" && value !== null && "$undefined" in value) {
@@ -11296,14 +11303,14 @@ class DatabaseSyscalls5 {
       }
     }
     await this.schemaService.validate(bareTableName, newValue);
-    const resolvedDocument = { id: docId, value: newValue };
+    const resolvedDocument = { id: canonicalDocId, value: newValue };
     const timestamp22 = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp22, id: docId, value: resolvedDocument, prev_ts: latest.ts };
+    const entry = { ts: timestamp22, id: canonicalDocId, value: resolvedDocument, prev_ts: latest.ts };
     const indexes = await this.schemaService.getAllIndexesForTable(bareTableName);
-    const indexUpdates = generateIndexUpdates5(fullTableName, docId, resolvedDocument.value, existingValue, indexes);
+    const indexUpdates = generateIndexUpdates5(fullTableName, canonicalDocId, resolvedDocument.value, existingValue, indexes);
     const indexEntries = new Set(indexUpdates.map((update) => ({ ts: timestamp22, update })));
     await this.docStore.applyWrites([entry], indexEntries, "Error");
-    this.context.recordLocalWrite(id, fullTableName, resolvedDocument.value, docId);
+    this.context.recordLocalWrite(id, fullTableName, resolvedDocument.value, canonicalDocId);
     return {};
   }
   async handleReplace(args) {
@@ -11325,17 +11332,18 @@ class DatabaseSyscalls5 {
     if (!latest) {
       throw new Error(`Document with id ${id} not found.`);
     }
+    const canonicalDocId = latest.value.id;
     const { _id, _creationTime } = latest.value.value;
     const newValue = { ...replaceValue, _id, _creationTime };
     await this.schemaService.validate(bareTableName, newValue);
-    const resolvedDocument = { id: docId, value: newValue };
+    const resolvedDocument = { id: canonicalDocId, value: newValue };
     const timestamp22 = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp22, id: docId, value: resolvedDocument, prev_ts: latest.ts };
+    const entry = { ts: timestamp22, id: canonicalDocId, value: resolvedDocument, prev_ts: latest.ts };
     const indexes = await this.schemaService.getAllIndexesForTable(bareTableName);
-    const indexUpdates = generateIndexUpdates5(fullTableName, docId, resolvedDocument.value, latest.value.value, indexes);
+    const indexUpdates = generateIndexUpdates5(fullTableName, canonicalDocId, resolvedDocument.value, latest.value.value, indexes);
     const indexEntries = new Set(indexUpdates.map((update) => ({ ts: timestamp22, update })));
     await this.docStore.applyWrites([entry], indexEntries, "Error");
-    this.context.recordLocalWrite(id, fullTableName, newValue, docId);
+    this.context.recordLocalWrite(id, fullTableName, newValue, canonicalDocId);
     return {};
   }
 }
@@ -20920,7 +20928,6 @@ class KernelContext {
   }
   recordTableRead(tableName) {
     if (this.mutationTransaction) {
-      this.mutationTransaction.recordTableScan(stringToHex(tableName), []);
       return;
     }
     this.readLog.addTableScan(tableName);
@@ -20933,8 +20940,6 @@ class KernelContext {
   }
   recordIndexRange(tableName, indexDescriptor, startKey, endKey) {
     if (this.mutationTransaction) {
-      const indexId = indexKeyspaceId(tableName, indexDescriptor);
-      this.mutationTransaction.recordIndexRangeScan(indexId, startKey, endKey, []);
       return;
     }
     this.readLog.addIndexRange(tableName, indexDescriptor, startKey, endKey);
@@ -21090,11 +21095,12 @@ class BlobStoreGateway {
     if (!latest || latest.ts > this.context.snapshotTimestamp) {
       return;
     }
-    await storage2.delete(docId.internalId);
+    const canonicalDocId = latest.value.id;
+    await storage2.delete(canonicalDocId.internalId);
     const timestamp = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp, id: docId, value: null, prev_ts: latest.ts };
+    const entry = { ts: timestamp, id: canonicalDocId, value: null, prev_ts: latest.ts };
     await this.docStore.applyWrites([entry], new Set, "Error");
-    this.context.recordLocalWrite(storageId, "_storage", null, docId);
+    this.context.recordLocalWrite(storageId, "_storage", null, canonicalDocId);
   }
   requireStorage() {
     if (!this.storage) {
@@ -21297,16 +21303,17 @@ class SchedulerGateway {
     if (!latest) {
       throw new Error(`Scheduled job with id ${id} not found.`);
     }
+    const canonicalDocId = latest.value.id;
     const newValue = {
       ...latest.value.value,
       state: state ?? { kind: "canceled" }
     };
-    const resolvedDocument = { id: docId, value: newValue };
+    const resolvedDocument = { id: canonicalDocId, value: newValue };
     const timestamp = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp, id: docId, value: resolvedDocument, prev_ts: latest.ts };
+    const entry = { ts: timestamp, id: canonicalDocId, value: resolvedDocument, prev_ts: latest.ts };
     await this.docStore.applyWrites([entry], new Set, "Error");
-    const tableName = await resolveTableName(docId, this.context.tableRegistry);
-    this.context.recordLocalWrite(id, tableName, resolvedDocument.value, docId);
+    const tableName = await resolveTableName(canonicalDocId, this.context.tableRegistry);
+    this.context.recordLocalWrite(id, tableName, resolvedDocument.value, canonicalDocId);
   }
 }
 
@@ -21508,13 +21515,14 @@ class DatabaseSyscalls {
     if (!latest) {
       throw new Error(`Document with id ${id} not found.`);
     }
+    const canonicalDocId = latest.value.id;
     const timestamp = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp, id: docId, value: null, prev_ts: latest.ts };
+    const entry = { ts: timestamp, id: canonicalDocId, value: null, prev_ts: latest.ts };
     const indexes = await this.schemaService.getAllIndexesForTable(bareTableName);
-    const indexUpdates = generateIndexUpdates(fullTableName, docId, null, latest.value.value, indexes);
+    const indexUpdates = generateIndexUpdates(fullTableName, canonicalDocId, null, latest.value.value, indexes);
     const indexEntries = new Set(indexUpdates.map((update) => ({ ts: timestamp, update })));
     await this.docStore.applyWrites([entry], indexEntries, "Error");
-    this.context.recordLocalWrite(id, fullTableName, null, docId);
+    this.context.recordLocalWrite(id, fullTableName, null, canonicalDocId);
     return {};
   }
   async handleShallowMerge(args) {
@@ -21540,6 +21548,7 @@ class DatabaseSyscalls {
     if (!latest) {
       throw new Error(`Document with id ${id} not found.`);
     }
+    const canonicalDocId = latest.value.id;
     const existingValue = latest.value.value;
     const newValue = { ...existingValue };
     if (typeof value === "object" && value !== null && "$undefined" in value) {
@@ -21566,14 +21575,14 @@ class DatabaseSyscalls {
       }
     }
     await this.schemaService.validate(bareTableName, newValue);
-    const resolvedDocument = { id: docId, value: newValue };
+    const resolvedDocument = { id: canonicalDocId, value: newValue };
     const timestamp = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp, id: docId, value: resolvedDocument, prev_ts: latest.ts };
+    const entry = { ts: timestamp, id: canonicalDocId, value: resolvedDocument, prev_ts: latest.ts };
     const indexes = await this.schemaService.getAllIndexesForTable(bareTableName);
-    const indexUpdates = generateIndexUpdates(fullTableName, docId, resolvedDocument.value, existingValue, indexes);
+    const indexUpdates = generateIndexUpdates(fullTableName, canonicalDocId, resolvedDocument.value, existingValue, indexes);
     const indexEntries = new Set(indexUpdates.map((update) => ({ ts: timestamp, update })));
     await this.docStore.applyWrites([entry], indexEntries, "Error");
-    this.context.recordLocalWrite(id, fullTableName, resolvedDocument.value, docId);
+    this.context.recordLocalWrite(id, fullTableName, resolvedDocument.value, canonicalDocId);
     return {};
   }
   async handleReplace(args) {
@@ -21595,17 +21604,18 @@ class DatabaseSyscalls {
     if (!latest) {
       throw new Error(`Document with id ${id} not found.`);
     }
+    const canonicalDocId = latest.value.id;
     const { _id, _creationTime } = latest.value.value;
     const newValue = { ...replaceValue, _id, _creationTime };
     await this.schemaService.validate(bareTableName, newValue);
-    const resolvedDocument = { id: docId, value: newValue };
+    const resolvedDocument = { id: canonicalDocId, value: newValue };
     const timestamp = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp, id: docId, value: resolvedDocument, prev_ts: latest.ts };
+    const entry = { ts: timestamp, id: canonicalDocId, value: resolvedDocument, prev_ts: latest.ts };
     const indexes = await this.schemaService.getAllIndexesForTable(bareTableName);
-    const indexUpdates = generateIndexUpdates(fullTableName, docId, resolvedDocument.value, latest.value.value, indexes);
+    const indexUpdates = generateIndexUpdates(fullTableName, canonicalDocId, resolvedDocument.value, latest.value.value, indexes);
     const indexEntries = new Set(indexUpdates.map((update) => ({ ts: timestamp, update })));
     await this.docStore.applyWrites([entry], indexEntries, "Error");
-    this.context.recordLocalWrite(id, fullTableName, newValue, docId);
+    this.context.recordLocalWrite(id, fullTableName, newValue, canonicalDocId);
     return {};
   }
 }
@@ -22290,6 +22300,7 @@ class SyncProtocolHandler {
   rateLimitWindowMs;
   operationTimeoutMs;
   maxActiveQueriesPerSession;
+  lastObservedWriteTimestamp = 0n;
   constructor(instanceName, udfExecutor, options) {
     this.udfExecutor = udfExecutor;
     this.instanceName = instanceName;
@@ -22313,6 +22324,22 @@ class SyncProtocolHandler {
       onPing: (session) => this.sendPing(session)
     });
   }
+  resolveWriteTimestamp(commitTimestamp, snapshotTimestamp) {
+    const wallClock = BigInt(Date.now());
+    const monotonicFloor = this.lastObservedWriteTimestamp + 1n;
+    let resolved = wallClock;
+    if (commitTimestamp !== undefined && commitTimestamp > resolved) {
+      resolved = commitTimestamp;
+    }
+    if (snapshotTimestamp !== undefined && snapshotTimestamp > resolved) {
+      resolved = snapshotTimestamp;
+    }
+    if (monotonicFloor > resolved) {
+      resolved = monotonicFloor;
+    }
+    this.lastObservedWriteTimestamp = resolved;
+    return resolved;
+  }
   createSession(sessionId, websocket) {
     const session = new SyncSession(websocket);
     this.sessions.set(sessionId, session);
@@ -22395,11 +22422,11 @@ class SyncProtocolHandler {
         return assertNever(message2);
     }
   }
-  async notifyWrites(writtenRanges, writtenTables, commitTimestamp) {
+  async notifyWrites(writtenRanges, writtenTables, commitTimestamp, snapshotTimestamp) {
     const ranges = writtenRanges ? writtenRanges.map(deserializeKeyRange) : convertTablesToRanges(writtenTables);
     this.logRanges("/notify", ranges, { writtenTables });
     if (ranges.length > 0) {
-      const ts = commitTimestamp ?? BigInt(Date.now());
+      const ts = this.resolveWriteTimestamp(commitTimestamp, snapshotTimestamp);
       this.subscriptionManager.recordWrites(ranges, ts);
       await this.broadcastUpdates(ranges);
     }
@@ -22497,8 +22524,8 @@ class SyncProtocolHandler {
         if (message2.componentPath && session.auth.tokenType !== "Admin" && session.auth.tokenType !== "System") {
           throw new Error("Only admin or system auth can execute component functions");
         }
-        const { result, writtenRanges, writtenTables, commitTimestamp, logLines } = await this.udfExecutor.executeMutation(message2.udfPath, message2.args[0] ?? {}, session.auth, message2.componentPath);
-        const now = commitTimestamp ?? BigInt(Date.now());
+        const { result, writtenRanges, writtenTables, commitTimestamp, snapshotTimestamp, logLines } = await this.udfExecutor.executeMutation(message2.udfPath, message2.args[0] ?? {}, session.auth, message2.componentPath);
+        const now = this.resolveWriteTimestamp(commitTimestamp, snapshotTimestamp);
         const successResponse = {
           type: "MutationResponse",
           requestId: message2.requestId,
@@ -22543,8 +22570,8 @@ class SyncProtocolHandler {
         if (message2.componentPath && session.auth.tokenType !== "Admin" && session.auth.tokenType !== "System") {
           throw new Error("Only admin or system auth can mutate component functions");
         }
-        const { result, writtenRanges, writtenTables, commitTimestamp, logLines } = await this.udfExecutor.executeAction(message2.udfPath, message2.args[0] ?? {}, session.auth, message2.componentPath);
-        const now = commitTimestamp ?? BigInt(Date.now());
+        const { result, writtenRanges, writtenTables, commitTimestamp, snapshotTimestamp, logLines } = await this.udfExecutor.executeAction(message2.udfPath, message2.args[0] ?? {}, session.auth, message2.componentPath);
+        const now = this.resolveWriteTimestamp(commitTimestamp, snapshotTimestamp);
         const successResponse = {
           type: "ActionResponse",
           requestId: message2.requestId,
@@ -22900,7 +22927,8 @@ function createSyncUdfExecutor(adapter) {
         writtenRanges: result.writtenRanges,
         writtenTables: writtenTablesFromRanges(result.writtenRanges),
         logLines: result.logLines,
-        commitTimestamp: result.commitTimestamp
+        commitTimestamp: result.commitTimestamp,
+        snapshotTimestamp: result.snapshotTimestamp
       };
     },
     executeAction: async (path, args, auth, componentPath) => {
@@ -22918,7 +22946,8 @@ function createSyncUdfExecutor(adapter) {
         writtenRanges: result.writtenRanges,
         writtenTables: writtenTablesFromRanges(result.writtenRanges),
         logLines: result.logLines,
-        commitTimestamp: result.commitTimestamp
+        commitTimestamp: result.commitTimestamp,
+        snapshotTimestamp: result.snapshotTimestamp
       };
     }
   };
@@ -26426,7 +26455,7 @@ function rangeExpressionsToIndexBounds(expressions, indexFields) {
   }
   return { start, end };
 }
-async function executeIndexQuery(docstore, tableName, indexName, indexFields, expressions, order, limit, cursor, snapshotTimestamp) {
+async function executeIndexQuery(docstore, tableName, indexName, indexFields, expressions, order, limit, cursor, snapshotTimestamp, onDocumentRead) {
   const tableId = stringToHex2(tableName);
   const indexId = stringToHex2(`${tableName}:${indexName}`);
   const indexOrder = order === "asc" ? Order.Asc : Order.Desc;
@@ -26452,6 +26481,7 @@ async function executeIndexQuery(docstore, tableName, indexName, indexFields, ex
   try {
     const generator = docstore.index_scan(indexId, tableId, readTimestamp, interval, indexOrder);
     for await (const [indexKey, document] of generator) {
+      onDocumentRead?.(document);
       const doc = document.value.value;
       if (skipping) {
         if (resumeIndexKey) {
@@ -26881,6 +26911,9 @@ class UncommittedWrites {
     }
   }
 }
+// ../core/dist/query/query-runtime.js
+init_interface();
+
 // ../core/dist/query/planner.js
 init_values2();
 init_interface3();
@@ -27250,13 +27283,27 @@ class QueryRuntime {
     return paginateByCursor(sortedResults, cursor, limit);
   }
   async handleIndexRange(plan, cursor, limit) {
-    if (!this.docStore.hasTransaction()) {
-      const { start, end } = rangeExpressionsToIndexBounds(plan.expressions, plan.indexFields);
+    const { start, end } = rangeExpressionsToIndexBounds(plan.expressions, plan.indexFields);
+    const mutationTransaction = this.docStore.getTransaction();
+    if (!mutationTransaction) {
       this.context.recordIndexRange(plan.fullTableName, plan.indexDescriptor, start, end);
     }
+    const observedDocuments = mutationTransaction ? new Map : null;
     let paginationResult;
     try {
-      const indexResult = await executeIndexQuery(this.docStore.getDocStore(), plan.fullTableName, plan.indexDescriptor, plan.indexFields, plan.expressions, plan.order, limit, cursor, this.context.snapshotTimestamp);
+      const indexResult = await executeIndexQuery(this.docStore.getDocStore(), plan.fullTableName, plan.indexDescriptor, plan.indexFields, plan.expressions, plan.order, limit, cursor, this.context.snapshotTimestamp, (latestDoc) => {
+        if (!observedDocuments) {
+          return;
+        }
+        observedDocuments.set(documentIdKey(latestDoc.value.id), latestDoc);
+      });
+      if (mutationTransaction && observedDocuments) {
+        const observed = Array.from(observedDocuments.values());
+        mutationTransaction.recordIndexRangeScan(indexKeyspaceId2(plan.fullTableName, plan.indexDescriptor), start, end, observed);
+        for (const doc of observed) {
+          mutationTransaction.recordDocumentRead(doc.value.id, doc);
+        }
+      }
       const uncommittedWrites = UncommittedWrites.fromContext(this.docStore.getTransaction(), this.context.getLocalWrites());
       if (uncommittedWrites) {
         const tableId = stringToHex2(plan.fullTableName);
@@ -27289,7 +27336,10 @@ class QueryRuntime {
     return paginationResult;
   }
   async handleSearch(plan, _cursor, limit) {
-    this.context.recordTableRead(plan.fullTableName);
+    const mutationTransaction = this.docStore.getTransaction();
+    if (!mutationTransaction) {
+      this.context.recordTableRead(plan.fullTableName);
+    }
     const limitOperator = plan.query.operators?.find((operator) => ("limit" in operator));
     const operatorLimit = limitOperator?.limit;
     const combinedLimit = typeof limit === "number" && limit > 0 ? operatorLimit && operatorLimit > 0 ? Math.min(limit, operatorLimit) : limit : operatorLimit && operatorLimit > 0 ? operatorLimit : undefined;
@@ -27298,7 +27348,13 @@ class QueryRuntime {
       throw new Error("DocStore does not support full-text search");
     }
     const searchResults = await rawDocStore.search(plan.indexIdHex, plan.searchTerm, plan.filterMap, { limit: combinedLimit });
-    const documents = searchResults.filter(({ doc }) => doc.ts <= this.context.snapshotTimestamp).map(({ doc, score }) => ({
+    const visibleResults = searchResults.filter(({ doc }) => doc.ts <= this.context.snapshotTimestamp);
+    if (mutationTransaction) {
+      for (const { doc } of visibleResults) {
+        mutationTransaction.recordDocumentRead(doc.value.id, doc);
+      }
+    }
+    const documents = visibleResults.map(({ doc, score }) => ({
       ...doc.value.value,
       _score: score
     }));
@@ -27485,6 +27541,7 @@ class AccessLog2 {
     return this.ranges.getRanges().map(serializeKeyRange2);
   }
 }
+
 // ../core/dist/tables/memory-table-registry.js
 init_interface3();
 
@@ -27622,7 +27679,6 @@ class KernelContext2 {
   }
   recordTableRead(tableName) {
     if (this.mutationTransaction) {
-      this.mutationTransaction.recordTableScan(stringToHex2(tableName), []);
       return;
     }
     this.readLog.addTableScan(tableName);
@@ -27635,8 +27691,6 @@ class KernelContext2 {
   }
   recordIndexRange(tableName, indexDescriptor, startKey, endKey) {
     if (this.mutationTransaction) {
-      const indexId = indexKeyspaceId2(tableName, indexDescriptor);
-      this.mutationTransaction.recordIndexRangeScan(indexId, startKey, endKey, []);
       return;
     }
     this.readLog.addIndexRange(tableName, indexDescriptor, startKey, endKey);
@@ -27795,11 +27849,12 @@ class BlobStoreGateway2 {
     if (!latest || latest.ts > this.context.snapshotTimestamp) {
       return;
     }
-    await storage2.delete(docId.internalId);
+    const canonicalDocId = latest.value.id;
+    await storage2.delete(canonicalDocId.internalId);
     const timestamp2 = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp2, id: docId, value: null, prev_ts: latest.ts };
+    const entry = { ts: timestamp2, id: canonicalDocId, value: null, prev_ts: latest.ts };
     await this.docStore.applyWrites([entry], new Set, "Error");
-    this.context.recordLocalWrite(storageId, "_storage", null, docId);
+    this.context.recordLocalWrite(storageId, "_storage", null, canonicalDocId);
   }
   requireStorage() {
     if (!this.storage) {
@@ -28006,16 +28061,17 @@ class SchedulerGateway2 {
     if (!latest) {
       throw new Error(`Scheduled job with id ${id} not found.`);
     }
+    const canonicalDocId = latest.value.id;
     const newValue = {
       ...latest.value.value,
       state: state ?? { kind: "canceled" }
     };
-    const resolvedDocument = { id: docId, value: newValue };
+    const resolvedDocument = { id: canonicalDocId, value: newValue };
     const timestamp2 = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp2, id: docId, value: resolvedDocument, prev_ts: latest.ts };
+    const entry = { ts: timestamp2, id: canonicalDocId, value: resolvedDocument, prev_ts: latest.ts };
     await this.docStore.applyWrites([entry], new Set, "Error");
-    const tableName = await resolveTableName2(docId, this.context.tableRegistry);
-    this.context.recordLocalWrite(id, tableName, resolvedDocument.value, docId);
+    const tableName = await resolveTableName2(canonicalDocId, this.context.tableRegistry);
+    this.context.recordLocalWrite(id, tableName, resolvedDocument.value, canonicalDocId);
   }
 }
 
@@ -28239,13 +28295,14 @@ class DatabaseSyscalls2 {
     if (!latest) {
       throw new Error(`Document with id ${id} not found.`);
     }
+    const canonicalDocId = latest.value.id;
     const timestamp2 = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp2, id: docId, value: null, prev_ts: latest.ts };
+    const entry = { ts: timestamp2, id: canonicalDocId, value: null, prev_ts: latest.ts };
     const indexes = await this.schemaService.getAllIndexesForTable(bareTableName);
-    const indexUpdates = generateIndexUpdates2(fullTableName, docId, null, latest.value.value, indexes);
+    const indexUpdates = generateIndexUpdates2(fullTableName, canonicalDocId, null, latest.value.value, indexes);
     const indexEntries = new Set(indexUpdates.map((update) => ({ ts: timestamp2, update })));
     await this.docStore.applyWrites([entry], indexEntries, "Error");
-    this.context.recordLocalWrite(id, fullTableName, null, docId);
+    this.context.recordLocalWrite(id, fullTableName, null, canonicalDocId);
     return {};
   }
   async handleShallowMerge(args) {
@@ -28271,6 +28328,7 @@ class DatabaseSyscalls2 {
     if (!latest) {
       throw new Error(`Document with id ${id} not found.`);
     }
+    const canonicalDocId = latest.value.id;
     const existingValue = latest.value.value;
     const newValue = { ...existingValue };
     if (typeof value === "object" && value !== null && "$undefined" in value) {
@@ -28297,14 +28355,14 @@ class DatabaseSyscalls2 {
       }
     }
     await this.schemaService.validate(bareTableName, newValue);
-    const resolvedDocument = { id: docId, value: newValue };
+    const resolvedDocument = { id: canonicalDocId, value: newValue };
     const timestamp2 = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp2, id: docId, value: resolvedDocument, prev_ts: latest.ts };
+    const entry = { ts: timestamp2, id: canonicalDocId, value: resolvedDocument, prev_ts: latest.ts };
     const indexes = await this.schemaService.getAllIndexesForTable(bareTableName);
-    const indexUpdates = generateIndexUpdates2(fullTableName, docId, resolvedDocument.value, existingValue, indexes);
+    const indexUpdates = generateIndexUpdates2(fullTableName, canonicalDocId, resolvedDocument.value, existingValue, indexes);
     const indexEntries = new Set(indexUpdates.map((update) => ({ ts: timestamp2, update })));
     await this.docStore.applyWrites([entry], indexEntries, "Error");
-    this.context.recordLocalWrite(id, fullTableName, resolvedDocument.value, docId);
+    this.context.recordLocalWrite(id, fullTableName, resolvedDocument.value, canonicalDocId);
     return {};
   }
   async handleReplace(args) {
@@ -28326,17 +28384,18 @@ class DatabaseSyscalls2 {
     if (!latest) {
       throw new Error(`Document with id ${id} not found.`);
     }
+    const canonicalDocId = latest.value.id;
     const { _id, _creationTime } = latest.value.value;
     const newValue = { ...replaceValue, _id, _creationTime };
     await this.schemaService.validate(bareTableName, newValue);
-    const resolvedDocument = { id: docId, value: newValue };
+    const resolvedDocument = { id: canonicalDocId, value: newValue };
     const timestamp2 = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp2, id: docId, value: resolvedDocument, prev_ts: latest.ts };
+    const entry = { ts: timestamp2, id: canonicalDocId, value: resolvedDocument, prev_ts: latest.ts };
     const indexes = await this.schemaService.getAllIndexesForTable(bareTableName);
-    const indexUpdates = generateIndexUpdates2(fullTableName, docId, resolvedDocument.value, latest.value.value, indexes);
+    const indexUpdates = generateIndexUpdates2(fullTableName, canonicalDocId, resolvedDocument.value, latest.value.value, indexes);
     const indexEntries = new Set(indexUpdates.map((update) => ({ ts: timestamp2, update })));
     await this.docStore.applyWrites([entry], indexEntries, "Error");
-    this.context.recordLocalWrite(id, fullTableName, newValue, docId);
+    this.context.recordLocalWrite(id, fullTableName, newValue, canonicalDocId);
     return {};
   }
 }
@@ -28731,7 +28790,7 @@ async function validateReadSetForCommit(docstore, readChecks, writtenDocKeys) {
       await validateTableScanRead(docstore, readEntry.tableId, readEntry.documentIds, writtenDocKeys);
       continue;
     }
-    await validateIndexRangeRead(docstore, readEntry.indexId, readEntry.startKey, readEntry.endKey, readEntry.documentIds, writtenDocKeys);
+    await validateIndexRangeRead(docstore, readEntry.indexId, readEntry.startKey, readEntry.endKey, readEntry.readTimestamp, readEntry.documentIds, writtenDocKeys);
   }
 }
 async function validateDocumentRead(docstore, key, readVersion, writtenDocKeys) {
@@ -28775,11 +28834,12 @@ async function validateTableScanRead(docstore, tableId, readDocumentIds, written
     }
   }
 }
-async function validateIndexRangeRead(docstore, indexId, startKey, endKey, readDocumentIds, writtenDocKeys) {
+async function validateIndexRangeRead(docstore, indexId, startKey, endKey, readTimestamp, readDocumentIds, writtenDocKeys) {
   const { table } = decodeIndexId2(indexId);
   const interval = { start: startKey, end: endKey };
+  const validationReadTimestamp = resolveValidationReadTimestamp(docstore, readTimestamp);
   const currentDocIds = new Set;
-  for await (const [, doc] of docstore.index_scan(indexId, table, BigInt(Date.now()), interval, Order.Asc)) {
+  for await (const [, doc] of docstore.index_scan(indexId, table, validationReadTimestamp, interval, Order.Asc)) {
     currentDocIds.add(documentIdKey(doc.value.id));
   }
   for (const docId of currentDocIds) {
@@ -28793,6 +28853,13 @@ async function validateIndexRangeRead(docstore, indexId, startKey, endKey, readD
     }
   }
 }
+function resolveValidationReadTimestamp(docstore, minimumTimestamp) {
+  const maybeDocStore = docstore;
+  const oracleTimestamp = maybeDocStore.timestampOracle?.getCurrentTimestamp?.();
+  const wallClockTimestamp = BigInt(Date.now());
+  const latestKnownTimestamp = oracleTimestamp !== undefined && oracleTimestamp > wallClockTimestamp ? oracleTimestamp : wallClockTimestamp;
+  return latestKnownTimestamp > minimumTimestamp ? latestKnownTimestamp : minimumTimestamp;
+}
 
 // ../core/dist/transactor/occ-transaction.js
 class OccMutationTransaction {
@@ -29363,7 +29430,7 @@ function runUdfMutation(docstore, fn, auth, storage2, requestId, udfExecutor, co
     const savepoint = parentTransaction.createSavepoint();
     const existingIdGenerator = idGeneratorContext2.getStore();
     const idGenerator = existingIdGenerator ?? createDeterministicIdGenerator(seed);
-    const nestedResult = transactionContext2.run(parentTransaction, () => idGeneratorContext2.run(idGenerator, () => runUdfAndGetLogs(docstore, fn, ops, auth, "mutation", storage2, seed, parentTransaction, udfExecutor, componentPath)));
+    const nestedResult = Promise.resolve(transactionContext2.run(parentTransaction, () => idGeneratorContext2.run(idGenerator, () => runUdfAndGetLogs(docstore, fn, ops, auth, "mutation", storage2, seed, parentTransaction, udfExecutor, componentPath))));
     return nestedResult.catch((error) => {
       parentTransaction.restoreSavepoint(savepoint);
       throw error;
@@ -29509,10 +29576,15 @@ class InlineUdfExecutor {
   async executeHttp(request, auth, requestId) {
     const url = new URL(request.url);
     const runHttpUdf = async () => {
-      const httpModule = await this.loadModule("http");
+      let httpModule;
+      try {
+        httpModule = await this.loadModule("http");
+      } catch {
+        return new Response("Not found", { status: 404 });
+      }
       const router = httpModule?.default;
       if (!router?.isRouter || typeof router.lookup !== "function") {
-        throw new Error("convex/http.ts must export a default httpRouter()");
+        return new Response("Not found", { status: 404 });
       }
       const match = router.lookup(url.pathname, request.method);
       if (!match) {
@@ -29947,6 +30019,9 @@ class HttpHandler {
     if (url.pathname === "/health") {
       return apply(Response.json({ status: "ok", runtime: this.runtimeName }));
     }
+    if (!isReservedApiPath(url.pathname)) {
+      return forwardHttpRequest(request, "HTTP action");
+    }
     return apply(Response.json({ error: "Not found" }, { status: 404 }));
   }
 }
@@ -34103,6 +34178,12 @@ function parseDocumentIdKey2(key) {
   const internalId = key.substring(colonIndex + 1);
   if (!table || !internalId)
     return null;
+  if (table.startsWith("#")) {
+    const tableNumber = Number.parseInt(table.slice(1), 10);
+    if (Number.isInteger(tableNumber) && tableNumber > 0) {
+      return { table, internalId, tableNumber };
+    }
+  }
   return { table, internalId };
 }
 var Order3;
@@ -34615,7 +34696,7 @@ async function validateReadSetForCommit2(docstore, readChecks, writtenDocKeys) {
       await validateTableScanRead2(docstore, readEntry.tableId, readEntry.documentIds, writtenDocKeys);
       continue;
     }
-    await validateIndexRangeRead2(docstore, readEntry.indexId, readEntry.startKey, readEntry.endKey, readEntry.documentIds, writtenDocKeys);
+    await validateIndexRangeRead2(docstore, readEntry.indexId, readEntry.startKey, readEntry.endKey, readEntry.readTimestamp, readEntry.documentIds, writtenDocKeys);
   }
 }
 async function validateDocumentRead2(docstore, key, readVersion, writtenDocKeys) {
@@ -34659,11 +34740,12 @@ async function validateTableScanRead2(docstore, tableId, readDocumentIds, writte
     }
   }
 }
-async function validateIndexRangeRead2(docstore, indexId, startKey, endKey, readDocumentIds, writtenDocKeys) {
+async function validateIndexRangeRead2(docstore, indexId, startKey, endKey, readTimestamp, readDocumentIds, writtenDocKeys) {
   const { table } = decodeIndexId3(indexId);
   const interval = { start: startKey, end: endKey };
+  const validationReadTimestamp = resolveValidationReadTimestamp2(docstore, readTimestamp);
   const currentDocIds = new Set;
-  for await (const [, doc] of docstore.index_scan(indexId, table, BigInt(Date.now()), interval, Order3.Asc)) {
+  for await (const [, doc] of docstore.index_scan(indexId, table, validationReadTimestamp, interval, Order3.Asc)) {
     currentDocIds.add(documentIdKey2(doc.value.id));
   }
   for (const docId of currentDocIds) {
@@ -34677,6 +34759,13 @@ async function validateIndexRangeRead2(docstore, indexId, startKey, endKey, read
     }
   }
 }
+function resolveValidationReadTimestamp2(docstore, minimumTimestamp) {
+  const maybeDocStore = docstore;
+  const oracleTimestamp = maybeDocStore.timestampOracle?.getCurrentTimestamp?.();
+  const wallClockTimestamp = BigInt(Date.now());
+  const latestKnownTimestamp = oracleTimestamp !== undefined && oracleTimestamp > wallClockTimestamp ? oracleTimestamp : wallClockTimestamp;
+  return latestKnownTimestamp > minimumTimestamp ? latestKnownTimestamp : minimumTimestamp;
+}
 
 class OccMutationTransaction2 {
   docstore;
@@ -35281,7 +35370,6 @@ class KernelContext3 {
   }
   recordTableRead(tableName) {
     if (this.mutationTransaction) {
-      this.mutationTransaction.recordTableScan(stringToHex3(tableName), []);
       return;
     }
     this.readLog.addTableScan(tableName);
@@ -35294,8 +35382,6 @@ class KernelContext3 {
   }
   recordIndexRange(tableName, indexDescriptor, startKey, endKey) {
     if (this.mutationTransaction) {
-      const indexId = indexKeyspaceId3(tableName, indexDescriptor);
-      this.mutationTransaction.recordIndexRangeScan(indexId, startKey, endKey, []);
       return;
     }
     this.readLog.addIndexRange(tableName, indexDescriptor, startKey, endKey);
@@ -35451,11 +35537,12 @@ class BlobStoreGateway3 {
     if (!latest || latest.ts > this.context.snapshotTimestamp) {
       return;
     }
-    await storage2.delete(docId.internalId);
+    const canonicalDocId = latest.value.id;
+    await storage2.delete(canonicalDocId.internalId);
     const timestamp2 = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp2, id: docId, value: null, prev_ts: latest.ts };
+    const entry = { ts: timestamp2, id: canonicalDocId, value: null, prev_ts: latest.ts };
     await this.docStore.applyWrites([entry], new Set, "Error");
-    this.context.recordLocalWrite(storageId, "_storage", null, docId);
+    this.context.recordLocalWrite(storageId, "_storage", null, canonicalDocId);
   }
   requireStorage() {
     if (!this.storage) {
@@ -35658,16 +35745,17 @@ class SchedulerGateway3 {
     if (!latest) {
       throw new Error(`Scheduled job with id ${id} not found.`);
     }
+    const canonicalDocId = latest.value.id;
     const newValue = {
       ...latest.value.value,
       state: state ?? { kind: "canceled" }
     };
-    const resolvedDocument = { id: docId, value: newValue };
+    const resolvedDocument = { id: canonicalDocId, value: newValue };
     const timestamp2 = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp2, id: docId, value: resolvedDocument, prev_ts: latest.ts };
+    const entry = { ts: timestamp2, id: canonicalDocId, value: resolvedDocument, prev_ts: latest.ts };
     await this.docStore.applyWrites([entry], new Set, "Error");
-    const tableName = await resolveTableName3(docId, this.context.tableRegistry);
-    this.context.recordLocalWrite(id, tableName, resolvedDocument.value, docId);
+    const tableName = await resolveTableName3(canonicalDocId, this.context.tableRegistry);
+    this.context.recordLocalWrite(id, tableName, resolvedDocument.value, canonicalDocId);
   }
 }
 init_context_storage3();
@@ -35879,13 +35967,14 @@ class DatabaseSyscalls3 {
     if (!latest) {
       throw new Error(`Document with id ${id} not found.`);
     }
+    const canonicalDocId = latest.value.id;
     const timestamp2 = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp2, id: docId, value: null, prev_ts: latest.ts };
+    const entry = { ts: timestamp2, id: canonicalDocId, value: null, prev_ts: latest.ts };
     const indexes = await this.schemaService.getAllIndexesForTable(bareTableName);
-    const indexUpdates = generateIndexUpdates3(fullTableName, docId, null, latest.value.value, indexes);
+    const indexUpdates = generateIndexUpdates3(fullTableName, canonicalDocId, null, latest.value.value, indexes);
     const indexEntries = new Set(indexUpdates.map((update) => ({ ts: timestamp2, update })));
     await this.docStore.applyWrites([entry], indexEntries, "Error");
-    this.context.recordLocalWrite(id, fullTableName, null, docId);
+    this.context.recordLocalWrite(id, fullTableName, null, canonicalDocId);
     return {};
   }
   async handleShallowMerge(args) {
@@ -35911,6 +36000,7 @@ class DatabaseSyscalls3 {
     if (!latest) {
       throw new Error(`Document with id ${id} not found.`);
     }
+    const canonicalDocId = latest.value.id;
     const existingValue = latest.value.value;
     const newValue = { ...existingValue };
     if (typeof value === "object" && value !== null && "$undefined" in value) {
@@ -35937,14 +36027,14 @@ class DatabaseSyscalls3 {
       }
     }
     await this.schemaService.validate(bareTableName, newValue);
-    const resolvedDocument = { id: docId, value: newValue };
+    const resolvedDocument = { id: canonicalDocId, value: newValue };
     const timestamp2 = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp2, id: docId, value: resolvedDocument, prev_ts: latest.ts };
+    const entry = { ts: timestamp2, id: canonicalDocId, value: resolvedDocument, prev_ts: latest.ts };
     const indexes = await this.schemaService.getAllIndexesForTable(bareTableName);
-    const indexUpdates = generateIndexUpdates3(fullTableName, docId, resolvedDocument.value, existingValue, indexes);
+    const indexUpdates = generateIndexUpdates3(fullTableName, canonicalDocId, resolvedDocument.value, existingValue, indexes);
     const indexEntries = new Set(indexUpdates.map((update) => ({ ts: timestamp2, update })));
     await this.docStore.applyWrites([entry], indexEntries, "Error");
-    this.context.recordLocalWrite(id, fullTableName, resolvedDocument.value, docId);
+    this.context.recordLocalWrite(id, fullTableName, resolvedDocument.value, canonicalDocId);
     return {};
   }
   async handleReplace(args) {
@@ -35966,17 +36056,18 @@ class DatabaseSyscalls3 {
     if (!latest) {
       throw new Error(`Document with id ${id} not found.`);
     }
+    const canonicalDocId = latest.value.id;
     const { _id, _creationTime } = latest.value.value;
     const newValue = { ...replaceValue, _id, _creationTime };
     await this.schemaService.validate(bareTableName, newValue);
-    const resolvedDocument = { id: docId, value: newValue };
+    const resolvedDocument = { id: canonicalDocId, value: newValue };
     const timestamp2 = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp2, id: docId, value: resolvedDocument, prev_ts: latest.ts };
+    const entry = { ts: timestamp2, id: canonicalDocId, value: resolvedDocument, prev_ts: latest.ts };
     const indexes = await this.schemaService.getAllIndexesForTable(bareTableName);
-    const indexUpdates = generateIndexUpdates3(fullTableName, docId, resolvedDocument.value, latest.value.value, indexes);
+    const indexUpdates = generateIndexUpdates3(fullTableName, canonicalDocId, resolvedDocument.value, latest.value.value, indexes);
     const indexEntries = new Set(indexUpdates.map((update) => ({ ts: timestamp2, update })));
     await this.docStore.applyWrites([entry], indexEntries, "Error");
-    this.context.recordLocalWrite(id, fullTableName, newValue, docId);
+    this.context.recordLocalWrite(id, fullTableName, newValue, canonicalDocId);
     return {};
   }
 }
@@ -41483,6 +41574,12 @@ function parseDocumentIdKey3(key) {
   const internalId = key.substring(colonIndex + 1);
   if (!table || !internalId)
     return null;
+  if (table.startsWith("#")) {
+    const tableNumber = Number.parseInt(table.slice(1), 10);
+    if (Number.isInteger(tableNumber) && tableNumber > 0) {
+      return { table, internalId, tableNumber };
+    }
+  }
   return { table, internalId };
 }
 var Order4;
@@ -41992,7 +42089,7 @@ async function validateReadSetForCommit3(docstore, readChecks, writtenDocKeys) {
       await validateTableScanRead3(docstore, readEntry.tableId, readEntry.documentIds, writtenDocKeys);
       continue;
     }
-    await validateIndexRangeRead3(docstore, readEntry.indexId, readEntry.startKey, readEntry.endKey, readEntry.documentIds, writtenDocKeys);
+    await validateIndexRangeRead3(docstore, readEntry.indexId, readEntry.startKey, readEntry.endKey, readEntry.readTimestamp, readEntry.documentIds, writtenDocKeys);
   }
 }
 async function validateDocumentRead3(docstore, key, readVersion, writtenDocKeys) {
@@ -42036,11 +42133,12 @@ async function validateTableScanRead3(docstore, tableId, readDocumentIds, writte
     }
   }
 }
-async function validateIndexRangeRead3(docstore, indexId, startKey, endKey, readDocumentIds, writtenDocKeys) {
+async function validateIndexRangeRead3(docstore, indexId, startKey, endKey, readTimestamp, readDocumentIds, writtenDocKeys) {
   const { table } = decodeIndexId4(indexId);
   const interval = { start: startKey, end: endKey };
+  const validationReadTimestamp = resolveValidationReadTimestamp3(docstore, readTimestamp);
   const currentDocIds = new Set;
-  for await (const [, doc] of docstore.index_scan(indexId, table, BigInt(Date.now()), interval, Order4.Asc)) {
+  for await (const [, doc] of docstore.index_scan(indexId, table, validationReadTimestamp, interval, Order4.Asc)) {
     currentDocIds.add(documentIdKey3(doc.value.id));
   }
   for (const docId of currentDocIds) {
@@ -42054,6 +42152,13 @@ async function validateIndexRangeRead3(docstore, indexId, startKey, endKey, read
     }
   }
 }
+function resolveValidationReadTimestamp3(docstore, minimumTimestamp) {
+  const maybeDocStore = docstore;
+  const oracleTimestamp = maybeDocStore.timestampOracle?.getCurrentTimestamp?.();
+  const wallClockTimestamp = BigInt(Date.now());
+  const latestKnownTimestamp = oracleTimestamp !== undefined && oracleTimestamp > wallClockTimestamp ? oracleTimestamp : wallClockTimestamp;
+  return latestKnownTimestamp > minimumTimestamp ? latestKnownTimestamp : minimumTimestamp;
+}
 
 class OccMutationTransaction3 {
   docstore;
@@ -42658,7 +42763,6 @@ class KernelContext4 {
   }
   recordTableRead(tableName) {
     if (this.mutationTransaction) {
-      this.mutationTransaction.recordTableScan(stringToHex4(tableName), []);
       return;
     }
     this.readLog.addTableScan(tableName);
@@ -42671,8 +42775,6 @@ class KernelContext4 {
   }
   recordIndexRange(tableName, indexDescriptor, startKey, endKey) {
     if (this.mutationTransaction) {
-      const indexId = indexKeyspaceId4(tableName, indexDescriptor);
-      this.mutationTransaction.recordIndexRangeScan(indexId, startKey, endKey, []);
       return;
     }
     this.readLog.addIndexRange(tableName, indexDescriptor, startKey, endKey);
@@ -42828,11 +42930,12 @@ class BlobStoreGateway4 {
     if (!latest || latest.ts > this.context.snapshotTimestamp) {
       return;
     }
-    await storage2.delete(docId.internalId);
+    const canonicalDocId = latest.value.id;
+    await storage2.delete(canonicalDocId.internalId);
     const timestamp2 = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp2, id: docId, value: null, prev_ts: latest.ts };
+    const entry = { ts: timestamp2, id: canonicalDocId, value: null, prev_ts: latest.ts };
     await this.docStore.applyWrites([entry], new Set, "Error");
-    this.context.recordLocalWrite(storageId, "_storage", null, docId);
+    this.context.recordLocalWrite(storageId, "_storage", null, canonicalDocId);
   }
   requireStorage() {
     if (!this.storage) {
@@ -43035,16 +43138,17 @@ class SchedulerGateway4 {
     if (!latest) {
       throw new Error(`Scheduled job with id ${id} not found.`);
     }
+    const canonicalDocId = latest.value.id;
     const newValue = {
       ...latest.value.value,
       state: state ?? { kind: "canceled" }
     };
-    const resolvedDocument = { id: docId, value: newValue };
+    const resolvedDocument = { id: canonicalDocId, value: newValue };
     const timestamp2 = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp2, id: docId, value: resolvedDocument, prev_ts: latest.ts };
+    const entry = { ts: timestamp2, id: canonicalDocId, value: resolvedDocument, prev_ts: latest.ts };
     await this.docStore.applyWrites([entry], new Set, "Error");
-    const tableName = await resolveTableName4(docId, this.context.tableRegistry);
-    this.context.recordLocalWrite(id, tableName, resolvedDocument.value, docId);
+    const tableName = await resolveTableName4(canonicalDocId, this.context.tableRegistry);
+    this.context.recordLocalWrite(id, tableName, resolvedDocument.value, canonicalDocId);
   }
 }
 init_context_storage4();
@@ -43255,13 +43359,14 @@ class DatabaseSyscalls4 {
     if (!latest) {
       throw new Error(`Document with id ${id} not found.`);
     }
+    const canonicalDocId = latest.value.id;
     const timestamp2 = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp2, id: docId, value: null, prev_ts: latest.ts };
+    const entry = { ts: timestamp2, id: canonicalDocId, value: null, prev_ts: latest.ts };
     const indexes = await this.schemaService.getAllIndexesForTable(bareTableName);
-    const indexUpdates = generateIndexUpdates4(fullTableName, docId, null, latest.value.value, indexes);
+    const indexUpdates = generateIndexUpdates4(fullTableName, canonicalDocId, null, latest.value.value, indexes);
     const indexEntries = new Set(indexUpdates.map((update) => ({ ts: timestamp2, update })));
     await this.docStore.applyWrites([entry], indexEntries, "Error");
-    this.context.recordLocalWrite(id, fullTableName, null, docId);
+    this.context.recordLocalWrite(id, fullTableName, null, canonicalDocId);
     return {};
   }
   async handleShallowMerge(args) {
@@ -43287,6 +43392,7 @@ class DatabaseSyscalls4 {
     if (!latest) {
       throw new Error(`Document with id ${id} not found.`);
     }
+    const canonicalDocId = latest.value.id;
     const existingValue = latest.value.value;
     const newValue = { ...existingValue };
     if (typeof value === "object" && value !== null && "$undefined" in value) {
@@ -43313,14 +43419,14 @@ class DatabaseSyscalls4 {
       }
     }
     await this.schemaService.validate(bareTableName, newValue);
-    const resolvedDocument = { id: docId, value: newValue };
+    const resolvedDocument = { id: canonicalDocId, value: newValue };
     const timestamp2 = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp2, id: docId, value: resolvedDocument, prev_ts: latest.ts };
+    const entry = { ts: timestamp2, id: canonicalDocId, value: resolvedDocument, prev_ts: latest.ts };
     const indexes = await this.schemaService.getAllIndexesForTable(bareTableName);
-    const indexUpdates = generateIndexUpdates4(fullTableName, docId, resolvedDocument.value, existingValue, indexes);
+    const indexUpdates = generateIndexUpdates4(fullTableName, canonicalDocId, resolvedDocument.value, existingValue, indexes);
     const indexEntries = new Set(indexUpdates.map((update) => ({ ts: timestamp2, update })));
     await this.docStore.applyWrites([entry], indexEntries, "Error");
-    this.context.recordLocalWrite(id, fullTableName, resolvedDocument.value, docId);
+    this.context.recordLocalWrite(id, fullTableName, resolvedDocument.value, canonicalDocId);
     return {};
   }
   async handleReplace(args) {
@@ -43342,17 +43448,18 @@ class DatabaseSyscalls4 {
     if (!latest) {
       throw new Error(`Document with id ${id} not found.`);
     }
+    const canonicalDocId = latest.value.id;
     const { _id, _creationTime } = latest.value.value;
     const newValue = { ...replaceValue, _id, _creationTime };
     await this.schemaService.validate(bareTableName, newValue);
-    const resolvedDocument = { id: docId, value: newValue };
+    const resolvedDocument = { id: canonicalDocId, value: newValue };
     const timestamp2 = this.docStore.allocateTimestamp();
-    const entry = { ts: timestamp2, id: docId, value: resolvedDocument, prev_ts: latest.ts };
+    const entry = { ts: timestamp2, id: canonicalDocId, value: resolvedDocument, prev_ts: latest.ts };
     const indexes = await this.schemaService.getAllIndexesForTable(bareTableName);
-    const indexUpdates = generateIndexUpdates4(fullTableName, docId, resolvedDocument.value, latest.value.value, indexes);
+    const indexUpdates = generateIndexUpdates4(fullTableName, canonicalDocId, resolvedDocument.value, latest.value.value, indexes);
     const indexEntries = new Set(indexUpdates.map((update) => ({ ts: timestamp2, update })));
     await this.docStore.applyWrites([entry], indexEntries, "Error");
-    this.context.recordLocalWrite(id, fullTableName, newValue, docId);
+    this.context.recordLocalWrite(id, fullTableName, newValue, canonicalDocId);
     return {};
   }
 }
@@ -46454,6 +46561,7 @@ class SyncProtocolHandler2 {
   rateLimitWindowMs;
   operationTimeoutMs;
   maxActiveQueriesPerSession;
+  lastObservedWriteTimestamp = 0n;
   constructor(instanceName, udfExecutor, options) {
     this.udfExecutor = udfExecutor;
     this.instanceName = instanceName;
@@ -46477,6 +46585,22 @@ class SyncProtocolHandler2 {
       onPing: (session) => this.sendPing(session)
     });
   }
+  resolveWriteTimestamp(commitTimestamp, snapshotTimestamp) {
+    const wallClock = BigInt(Date.now());
+    const monotonicFloor = this.lastObservedWriteTimestamp + 1n;
+    let resolved = wallClock;
+    if (commitTimestamp !== undefined && commitTimestamp > resolved) {
+      resolved = commitTimestamp;
+    }
+    if (snapshotTimestamp !== undefined && snapshotTimestamp > resolved) {
+      resolved = snapshotTimestamp;
+    }
+    if (monotonicFloor > resolved) {
+      resolved = monotonicFloor;
+    }
+    this.lastObservedWriteTimestamp = resolved;
+    return resolved;
+  }
   createSession(sessionId, websocket) {
     const session = new SyncSession2(websocket);
     this.sessions.set(sessionId, session);
@@ -46559,11 +46683,11 @@ class SyncProtocolHandler2 {
         return assertNever2(message22);
     }
   }
-  async notifyWrites(writtenRanges, writtenTables, commitTimestamp) {
+  async notifyWrites(writtenRanges, writtenTables, commitTimestamp, snapshotTimestamp) {
     const ranges = writtenRanges ? writtenRanges.map(deserializeKeyRange4) : convertTablesToRanges2(writtenTables);
     this.logRanges("/notify", ranges, { writtenTables });
     if (ranges.length > 0) {
-      const ts = commitTimestamp ?? BigInt(Date.now());
+      const ts = this.resolveWriteTimestamp(commitTimestamp, snapshotTimestamp);
       this.subscriptionManager.recordWrites(ranges, ts);
       await this.broadcastUpdates(ranges);
     }
@@ -46661,8 +46785,8 @@ class SyncProtocolHandler2 {
         if (message22.componentPath && session.auth.tokenType !== "Admin" && session.auth.tokenType !== "System") {
           throw new Error("Only admin or system auth can execute component functions");
         }
-        const { result, writtenRanges, writtenTables, commitTimestamp, logLines } = await this.udfExecutor.executeMutation(message22.udfPath, message22.args[0] ?? {}, session.auth, message22.componentPath);
-        const now = commitTimestamp ?? BigInt(Date.now());
+        const { result, writtenRanges, writtenTables, commitTimestamp, snapshotTimestamp, logLines } = await this.udfExecutor.executeMutation(message22.udfPath, message22.args[0] ?? {}, session.auth, message22.componentPath);
+        const now = this.resolveWriteTimestamp(commitTimestamp, snapshotTimestamp);
         const successResponse = {
           type: "MutationResponse",
           requestId: message22.requestId,
@@ -46707,8 +46831,8 @@ class SyncProtocolHandler2 {
         if (message22.componentPath && session.auth.tokenType !== "Admin" && session.auth.tokenType !== "System") {
           throw new Error("Only admin or system auth can mutate component functions");
         }
-        const { result, writtenRanges, writtenTables, commitTimestamp, logLines } = await this.udfExecutor.executeAction(message22.udfPath, message22.args[0] ?? {}, session.auth, message22.componentPath);
-        const now = commitTimestamp ?? BigInt(Date.now());
+        const { result, writtenRanges, writtenTables, commitTimestamp, snapshotTimestamp, logLines } = await this.udfExecutor.executeAction(message22.udfPath, message22.args[0] ?? {}, session.auth, message22.componentPath);
+        const now = this.resolveWriteTimestamp(commitTimestamp, snapshotTimestamp);
         const successResponse = {
           type: "ActionResponse",
           requestId: message22.requestId,