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

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

@@ -24,6 +24,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;
@@ -9103,7 +9109,6 @@ class KernelContext {
   }
   recordTableRead(tableName) {
     if (this.mutationTransaction) {
-      this.mutationTransaction.recordTableScan(stringToHex(tableName), []);
       return;
     }
     this.readLog.addTableScan(tableName);
@@ -9116,8 +9121,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);
@@ -9273,11 +9276,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 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) {
@@ -9480,16 +9484,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 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 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);
   }
 }
 init_context_storage();
@@ -9701,13 +9706,14 @@ class DatabaseSyscalls {
     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 = 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: 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) {
@@ -9733,6 +9739,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) {
@@ -9759,14 +9766,14 @@ class DatabaseSyscalls {
       }
     }
     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 = generateIndexUpdates(fullTableName, docId, resolvedDocument.value, existingValue, indexes);
+    const indexUpdates = generateIndexUpdates(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) {
@@ -9788,17 +9795,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 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 = 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: timestamp2, update })));
     await this.docStore.applyWrites([entry], indexEntries, "Error");
-    this.context.recordLocalWrite(id, fullTableName, newValue, docId);
+    this.context.recordLocalWrite(id, fullTableName, newValue, canonicalDocId);
     return {};
   }
 }
@@ -18124,7 +18132,6 @@ class KernelContext2 {
   }
   recordTableRead(tableName) {
     if (this.mutationTransaction) {
-      this.mutationTransaction.recordTableScan(stringToHex2(tableName), []);
       return;
     }
     this.readLog.addTableScan(tableName);
@@ -18137,8 +18144,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);
@@ -18294,11 +18299,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 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) {
@@ -18501,16 +18507,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 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 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);
   }
 }
 
@@ -18712,13 +18719,14 @@ class DatabaseSyscalls2 {
     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 = 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: 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) {
@@ -18744,6 +18752,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) {
@@ -18770,14 +18779,14 @@ class DatabaseSyscalls2 {
       }
     }
     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 = generateIndexUpdates2(fullTableName, docId, resolvedDocument.value, existingValue, indexes);
+    const indexUpdates = generateIndexUpdates2(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) {
@@ -18799,17 +18808,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 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 = 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: timestamp, update })));
     await this.docStore.applyWrites([entry], indexEntries, "Error");
-    this.context.recordLocalWrite(id, fullTableName, newValue, docId);
+    this.context.recordLocalWrite(id, fullTableName, newValue, canonicalDocId);
     return {};
   }
 }
@@ -19494,6 +19504,7 @@ class SyncProtocolHandler {
   rateLimitWindowMs;
   operationTimeoutMs;
   maxActiveQueriesPerSession;
+  lastObservedWriteTimestamp = 0n;
   constructor(instanceName, udfExecutor, options) {
     this.udfExecutor = udfExecutor;
     this.instanceName = instanceName;
@@ -19517,6 +19528,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);
@@ -19599,11 +19626,11 @@ class SyncProtocolHandler {
         return assertNever(message2);
     }
   }
-  async notifyWrites(writtenRanges, writtenTables, commitTimestamp) {
+  async notifyWrites(writtenRanges, writtenTables, commitTimestamp, snapshotTimestamp) {
     const ranges = writtenRanges ? writtenRanges.map(deserializeKeyRange2) : 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);
     }
@@ -19701,8 +19728,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,
@@ -19747,8 +19774,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,
@@ -20104,7 +20131,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) => {
@@ -20122,7 +20150,8 @@ function createSyncUdfExecutor(adapter) {
         writtenRanges: result.writtenRanges,
         writtenTables: writtenTablesFromRanges(result.writtenRanges),
         logLines: result.logLines,
-        commitTimestamp: result.commitTimestamp
+        commitTimestamp: result.commitTimestamp,
+        snapshotTimestamp: result.snapshotTimestamp
       };
     }
   };
@@ -23636,7 +23665,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 = stringToHex3(tableName);
   const indexId = stringToHex3(`${tableName}:${indexName}`);
   const indexOrder = order === "asc" ? Order.Asc : Order.Desc;
@@ -23662,6 +23691,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) {
@@ -24091,6 +24121,9 @@ class UncommittedWrites {
     }
   }
 }
+// ../core/dist/query/query-runtime.js
+init_interface();
+
 // ../core/dist/query/planner.js
 init_values3();
 init_interface4();
@@ -24460,13 +24493,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(indexKeyspaceId3(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 = stringToHex3(plan.fullTableName);
@@ -24499,7 +24546,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;
@@ -24508,7 +24558,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
     }));
@@ -24695,6 +24751,7 @@ class AccessLog3 {
     return this.ranges.getRanges().map(serializeKeyRange3);
   }
 }
+
 // ../core/dist/tables/memory-table-registry.js
 init_interface4();
 
@@ -24832,7 +24889,6 @@ class KernelContext3 {
   }
   recordTableRead(tableName) {
     if (this.mutationTransaction) {
-      this.mutationTransaction.recordTableScan(stringToHex3(tableName), []);
       return;
     }
     this.readLog.addTableScan(tableName);
@@ -24845,8 +24901,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);
@@ -25005,11 +25059,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) {
@@ -25216,16 +25271,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);
   }
 }
 
@@ -25449,13 +25505,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) {
@@ -25481,6 +25538,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) {
@@ -25507,14 +25565,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) {
@@ -25536,17 +25594,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 {};
   }
 }
@@ -25941,7 +26000,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) {
@@ -25985,11 +26044,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 } = decodeIndexId3(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) {
@@ -26003,6 +26063,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 {
@@ -26573,7 +26640,7 @@ function runUdfMutation(docstore, fn, auth, storage2, requestId, udfExecutor, co
     const savepoint = parentTransaction.createSavepoint();
     const existingIdGenerator = idGeneratorContext3.getStore();
     const idGenerator = existingIdGenerator ?? createDeterministicIdGenerator(seed);
-    const nestedResult = transactionContext3.run(parentTransaction, () => idGeneratorContext3.run(idGenerator, () => runUdfAndGetLogs(docstore, fn, ops, auth, "mutation", storage2, seed, parentTransaction, udfExecutor, componentPath)));
+    const nestedResult = Promise.resolve(transactionContext3.run(parentTransaction, () => idGeneratorContext3.run(idGenerator, () => runUdfAndGetLogs(docstore, fn, ops, auth, "mutation", storage2, seed, parentTransaction, udfExecutor, componentPath))));
     return nestedResult.catch((error) => {
       parentTransaction.restoreSavepoint(savepoint);
       throw error;
@@ -26719,10 +26786,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) {
@@ -27157,6 +27229,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 }));
   }
 }
@@ -31330,6 +31405,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 Order4;
@@ -31842,7 +31923,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) {
@@ -31886,11 +31967,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 } = decodeIndexId4(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, 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) {
@@ -31904,6 +31986,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;
@@ -32508,7 +32597,6 @@ class KernelContext4 {
   }
   recordTableRead(tableName) {
     if (this.mutationTransaction) {
-      this.mutationTransaction.recordTableScan(stringToHex4(tableName), []);
       return;
     }
     this.readLog.addTableScan(tableName);
@@ -32521,8 +32609,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);
@@ -32678,11 +32764,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) {
@@ -32885,16 +32972,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();
@@ -33106,13 +33194,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) {
@@ -33138,6 +33227,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) {
@@ -33164,14 +33254,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) {
@@ -33193,17 +33283,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 {};
   }
 }
@@ -38710,6 +38801,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 Order5;
@@ -39219,7 +39316,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) {
@@ -39263,11 +39360,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 } = decodeIndexId5(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, Order5.Asc)) {
+  for await (const [, doc] of docstore.index_scan(indexId, table, validationReadTimestamp, interval, Order5.Asc)) {
     currentDocIds.add(documentIdKey4(doc.value.id));
   }
   for (const docId of currentDocIds) {
@@ -39281,6 +39379,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;
@@ -39885,7 +39990,6 @@ class KernelContext5 {
   }
   recordTableRead(tableName) {
     if (this.mutationTransaction) {
-      this.mutationTransaction.recordTableScan(stringToHex5(tableName), []);
       return;
     }
     this.readLog.addTableScan(tableName);
@@ -39898,8 +40002,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);
@@ -40055,11 +40157,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 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) {
@@ -40262,16 +40365,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 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 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);
   }
 }
 init_context_storage5();
@@ -40482,13 +40586,14 @@ class DatabaseSyscalls5 {
     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 = 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: 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) {
@@ -40514,6 +40619,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) {
@@ -40540,14 +40646,14 @@ class DatabaseSyscalls5 {
       }
     }
     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 = generateIndexUpdates5(fullTableName, docId, resolvedDocument.value, existingValue, indexes);
+    const indexUpdates = generateIndexUpdates5(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) {
@@ -40569,17 +40675,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 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 = 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: timestamp2, update })));
     await this.docStore.applyWrites([entry], indexEntries, "Error");
-    this.context.recordLocalWrite(id, fullTableName, newValue, docId);
+    this.context.recordLocalWrite(id, fullTableName, newValue, canonicalDocId);
     return {};
   }
 }
@@ -43681,6 +43788,7 @@ class SyncProtocolHandler2 {
   rateLimitWindowMs;
   operationTimeoutMs;
   maxActiveQueriesPerSession;
+  lastObservedWriteTimestamp = 0n;
   constructor(instanceName, udfExecutor, options) {
     this.udfExecutor = udfExecutor;
     this.instanceName = instanceName;
@@ -43704,6 +43812,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);
@@ -43786,11 +43910,11 @@ class SyncProtocolHandler2 {
         return assertNever2(message22);
     }
   }
-  async notifyWrites(writtenRanges, writtenTables, commitTimestamp) {
+  async notifyWrites(writtenRanges, writtenTables, commitTimestamp, snapshotTimestamp) {
     const ranges = writtenRanges ? writtenRanges.map(deserializeKeyRange5) : 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);
     }
@@ -43888,8 +44012,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,
@@ -43934,8 +44058,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,