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

package/dist/docstore/interface.js

@@ -18,6 +18,12 @@ export 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 };
 }
 /**

package/dist/http/http-handler.js

@@ -296,6 +296,12 @@ export class HttpHandler {
         if (url.pathname === "/health") {
             return apply(Response.json({ status: "ok", runtime: this.runtimeName }));
         }
+        // Fallback: forward any unmatched, non-reserved path to the HTTP router.
+        // In Convex, HTTP actions are accessible at any path on the deployment URL
+        // (e.g. path: "/" matches requests to the root), not just under /api/http/*.
+        if (!isReservedApiPath(url.pathname)) {
+            return forwardHttpRequest(request, "HTTP action");
+        }
         return apply(Response.json({ error: "Not found" }, { status: 404 }));
     }
 }

package/dist/kernel/blob-store-gateway.js

@@ -93,11 +93,12 @@ export class BlobStoreGateway {
         if (!latest || latest.ts > this.context.snapshotTimestamp) {
             return;
         }
-        await storage.delete(docId.internalId);
+        const canonicalDocId = latest.value.id;
+        await storage.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) {

package/dist/kernel/kernel-context.js

@@ -1,7 +1,6 @@
 import { serializeKeyRange } from "../queryengine/indexing/read-write-set";
 import { AccessLog } from "./access-log";
-import { stringToHex } from "../utils/utils";
-import { decodeIndexId, indexKeyspaceId } from "../utils/keyspace";
+import { decodeIndexId } from "../utils/keyspace";
 import { parseDeveloperId } from "../queryengine/developer-id";
 import { getGlobalTableRegistry } from "../tables/memory-table-registry";
 /**
@@ -46,7 +45,8 @@ export class KernelContext {
     }
     recordTableRead(tableName) {
         if (this.mutationTransaction) {
-            this.mutationTransaction.recordTableScan(stringToHex(tableName), []);
+            // Transactional reads must be recorded with concrete documents by the
+            // transaction-aware read path (for example scanTable/index query handlers).
             return;
         }
         this.readLog.addTableScan(tableName);
@@ -59,8 +59,8 @@ export class KernelContext {
     }
     recordIndexRange(tableName, indexDescriptor, startKey, endKey) {
         if (this.mutationTransaction) {
-            const indexId = indexKeyspaceId(tableName, indexDescriptor);
-            this.mutationTransaction.recordIndexRangeScan(indexId, startKey, endKey, []);
+            // Transactional reads must be recorded with concrete documents by the
+            // transaction-aware query runtime path.
             return;
         }
         this.readLog.addIndexRange(tableName, indexDescriptor, startKey, endKey);

package/dist/kernel/scheduler-gateway.js

@@ -61,15 +61,16 @@ export 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);
     }
 }

package/dist/kernel/syscalls/database-syscalls.js

@@ -131,13 +131,14 @@ export 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) {
@@ -165,6 +166,7 @@ export 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) {
@@ -194,14 +196,14 @@ export 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) {
@@ -225,17 +227,18 @@ export 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 {};
     }
 }

package/dist/query/query-runtime.d.ts

@@ -1,7 +1,7 @@
 import type { KernelContext } from "../kernel/kernel-context";
 import type { DocStoreGateway } from "../kernel/docstore-gateway";
 import type { SchemaService } from "../kernel/schema-service";
-import type { InternalDocumentId } from "../docstore/interface";
+import { type InternalDocumentId } from "../docstore/interface";
 import type { PaginatedResult, SearchActionQuery, VectorSearchActionQuery } from "./types";
 export type { SerializedRangeExpression, SerializedSearchFilter } from "./types";
 export declare class QueryRuntime {

package/dist/query/query-runtime.js

@@ -3,7 +3,9 @@ import { UncommittedWrites } from "../ryow/uncommitted-writes";
 import { stringToHex } from "../utils/utils";
 import { evaluateFilter } from "../queryengine/filters";
 import { executeIndexQuery, rangeExpressionsToIndexBounds, evaluateRangeExpression, } from "../queryengine/index-query";
+import { documentIdKey } from "../docstore/interface";
 import { isSearchCapable } from "../docstore/search-interfaces";
+import { indexKeyspaceId } from "../utils/keyspace";
 import { buildQueryPlan } from "./planner";
 import { paginateByCursor, sortByCreationTimeAndId, sortByIndexFields } from "./execution";
 import { applyQueryOperators } from "./postprocess";
@@ -58,13 +60,27 @@ export 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(indexKeyspaceId(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 = stringToHex(plan.fullTableName);
@@ -99,12 +115,13 @@ export class QueryRuntime {
             const sortedResults = sortByIndexFields(filteredResults, plan.indexFields, plan.order);
             paginationResult = paginateByCursor(sortedResults, cursor, limit);
         }
-        // Index range already recorded above - no need for individual document reads
-        // The index range covers all matching documents
         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
@@ -119,14 +136,16 @@ export 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,
         }));
-        // Table read already recorded above - no need for individual document reads
-        // The full table range covers all search results
         return {
             documents,
             nextCursor: null,

package/dist/queryengine/index-query.d.ts

@@ -4,7 +4,7 @@
  * Provides efficient query execution using database indexes.
  * Handles range queries, equality filters, and ordered scans.
  */
-import { type DocStore } from "../docstore/interface";
+import { type DocStore, type LatestDocument } from "../docstore/interface";
 import type { Value } from "convex/values";
 /**
  * Range expression for index queries (from Convex wire protocol)
@@ -45,7 +45,7 @@ export declare function rangeExpressionsToIndexBounds(expressions: RangeExpressi
  * @param cursor Pagination cursor (serialized index position)
  * @returns Query results with pagination
  */
-export declare function executeIndexQuery(docstore: DocStore, tableName: string, indexName: string, indexFields: string[], expressions: RangeExpression[], order: "asc" | "desc", limit: number | null, cursor: string | null, snapshotTimestamp: bigint): Promise<IndexQueryResult>;
+export declare function executeIndexQuery(docstore: DocStore, tableName: string, indexName: string, indexFields: string[], expressions: RangeExpression[], order: "asc" | "desc", limit: number | null, cursor: string | null, snapshotTimestamp: bigint, onDocumentRead?: (document: LatestDocument) => void): Promise<IndexQueryResult>;
 /**
  * Evaluate range expressions against a document (fallback for non-indexed filters).
  */

package/dist/queryengine/index-query.js

@@ -100,7 +100,7 @@ export function rangeExpressionsToIndexBounds(expressions, indexFields) {
  * @param cursor Pagination cursor (serialized index position)
  * @returns Query results with pagination
  */
-export async function executeIndexQuery(docstore, tableName, indexName, indexFields, expressions, order, limit, cursor, snapshotTimestamp) {
+export async function executeIndexQuery(docstore, tableName, indexName, indexFields, expressions, order, limit, cursor, snapshotTimestamp, onDocumentRead) {
     const tableId = stringToHex(tableName);
     const indexId = stringToHex(`${tableName}:${indexName}`);
     const indexOrder = order === "asc" ? Order.Asc : Order.Desc;
@@ -131,6 +131,7 @@ export async function executeIndexQuery(docstore, tableName, indexName, indexFie
     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;
             // Skip until we're past the cursor position
             if (skipping) {

package/dist/sync/protocol-handler.d.ts

@@ -33,6 +33,8 @@ export interface SyncUdfExecutor {
         logLines?: string[];
         /** The commit timestamp of this mutation (for OCC-aware subscriptions) */
         commitTimestamp?: bigint;
+        /** Snapshot timestamp observed during execution (fallback when commit timestamp is unavailable) */
+        snapshotTimestamp?: bigint;
     }>;
     executeAction(path: string, args: Record<string, any>, auth: AuthContext, componentPath?: string): Promise<{
         result: JSONValue;
@@ -41,6 +43,8 @@ export interface SyncUdfExecutor {
         logLines?: string[];
         /** The commit timestamp of this action's writes (for OCC-aware subscriptions) */
         commitTimestamp?: bigint;
+        /** Snapshot timestamp observed during execution (fallback when commit timestamp is unavailable) */
+        snapshotTimestamp?: bigint;
     }>;
 }
 /**
@@ -129,7 +133,9 @@ export declare class SyncProtocolHandler {
     private readonly rateLimitWindowMs;
     private readonly operationTimeoutMs;
     private readonly maxActiveQueriesPerSession;
+    private lastObservedWriteTimestamp;
     constructor(instanceName: string, udfExecutor: SyncUdfExecutor, options?: SyncProtocolOptions);
+    private resolveWriteTimestamp;
     /**
      * Create a new client session
      */
@@ -156,8 +162,9 @@ export declare class SyncProtocolHandler {
      * @param writtenRanges - The serialized ranges that were written
      * @param writtenTables - The tables that were written (alternative to writtenRanges)
      * @param commitTimestamp - The commit timestamp of the write (for OCC-aware subscriptions)
+     * @param snapshotTimestamp - Snapshot timestamp used as a fallback ordering signal
      */
-    notifyWrites(writtenRanges?: SerializedKeyRange[], writtenTables?: string[], commitTimestamp?: bigint): Promise<void>;
+    notifyWrites(writtenRanges?: SerializedKeyRange[], writtenTables?: string[], commitTimestamp?: bigint, snapshotTimestamp?: bigint): Promise<void>;
     private handleConnect;
     private handleModifyQuerySet;
     private handleMutation;

package/dist/sync/protocol-handler.js

@@ -112,6 +112,7 @@ export class SyncProtocolHandler {
     rateLimitWindowMs;
     operationTimeoutMs;
     maxActiveQueriesPerSession;
+    lastObservedWriteTimestamp = 0n;
     constructor(instanceName, udfExecutor, options) {
         this.udfExecutor = udfExecutor;
         this.instanceName = instanceName;
@@ -137,6 +138,22 @@ export 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;
+    }
     /**
      * Create a new client session
      */
@@ -246,15 +263,16 @@ export class SyncProtocolHandler {
      * @param writtenRanges - The serialized ranges that were written
      * @param writtenTables - The tables that were written (alternative to writtenRanges)
      * @param commitTimestamp - The commit timestamp of the write (for OCC-aware subscriptions)
+     * @param snapshotTimestamp - Snapshot timestamp used as a fallback ordering signal
      */
-    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) {
             // Record the write timestamp for OCC-aware subscription registration
-            const ts = commitTimestamp ?? BigInt(Date.now());
+            const ts = this.resolveWriteTimestamp(commitTimestamp, snapshotTimestamp);
             this.subscriptionManager.recordWrites(ranges, ts);
             await this.broadcastUpdates(ranges);
         }
@@ -366,8 +384,8 @@ export class SyncProtocolHandler {
                 if (message.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(message.udfPath, (message.args[0] ?? {}), session.auth, message.componentPath);
-                const now = commitTimestamp ?? BigInt(Date.now());
+                const { result, writtenRanges, writtenTables, commitTimestamp, snapshotTimestamp, logLines } = await this.udfExecutor.executeMutation(message.udfPath, (message.args[0] ?? {}), session.auth, message.componentPath);
+                const now = this.resolveWriteTimestamp(commitTimestamp, snapshotTimestamp);
                 const successResponse = {
                     type: "MutationResponse",
                     requestId: message.requestId,
@@ -421,8 +439,8 @@ export class SyncProtocolHandler {
                 if (message.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(message.udfPath, (message.args[0] ?? {}), session.auth, message.componentPath);
-                const now = commitTimestamp ?? BigInt(Date.now());
+                const { result, writtenRanges, writtenTables, commitTimestamp, snapshotTimestamp, logLines } = await this.udfExecutor.executeAction(message.udfPath, (message.args[0] ?? {}), session.auth, message.componentPath);
+                const now = this.resolveWriteTimestamp(commitTimestamp, snapshotTimestamp);
                 const successResponse = {
                     type: "ActionResponse",
                     requestId: message.requestId,

package/dist/sync/sync-handler.js

@@ -48,6 +48,7 @@ export function createSyncUdfExecutor(adapter) {
                 writtenTables: writtenTablesFromRanges(result.writtenRanges),
                 logLines: result.logLines,
                 commitTimestamp: result.commitTimestamp,
+                snapshotTimestamp: result.snapshotTimestamp,
             };
         },
         executeAction: async (path, args, auth, componentPath) => {
@@ -67,6 +68,7 @@ export function createSyncUdfExecutor(adapter) {
                 writtenTables: writtenTablesFromRanges(result.writtenRanges),
                 logLines: result.logLines,
                 commitTimestamp: result.commitTimestamp,
+                snapshotTimestamp: result.snapshotTimestamp,
             };
         },
     };

package/dist/transactor/occ-validation.js

@@ -12,7 +12,7 @@ export async function validateReadSetForCommit(docstore, readChecks, writtenDocK
             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) {
@@ -56,12 +56,13 @@ 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 } = decodeIndexId(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, // table as hex-encoded tableId
-    BigInt(Date.now()), interval, Order.Asc)) {
+    validationReadTimestamp, interval, Order.Asc)) {
         currentDocIds.add(documentIdKey(doc.value.id));
     }
     for (const docId of currentDocIds) {
@@ -75,3 +76,12 @@ 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;
+}

package/dist/udf/executor/inline.js

@@ -110,10 +110,17 @@ export 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 {
+                // No convex/http.ts module — no HTTP routes available
+                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) {

package/dist/udf/runtime/udf-setup.js

@@ -377,10 +377,7 @@ export function runUdfMutation(docstore, fn, auth, storage, requestId, udfExecut
         // execute within the same transaction scope
         const existingIdGenerator = idGeneratorContext.getStore();
         const idGenerator = existingIdGenerator ?? createDeterministicIdGenerator(seed);
-        // ContextStorage.run returns R (UdfResult here) but in practice the async
-        // callback produces a Promise<UdfResult>.  We need to attach a .catch for
-        // savepoint rollback, so cast to the runtime-accurate Promise type.
-        const nestedResult = transactionContext.run(parentTransaction, () => idGeneratorContext.run(idGenerator, () => runUdfAndGetLogs(docstore, fn, ops, auth, "mutation", storage, seed, parentTransaction, udfExecutor, componentPath)));
+        const nestedResult = Promise.resolve(transactionContext.run(parentTransaction, () => idGeneratorContext.run(idGenerator, () => runUdfAndGetLogs(docstore, fn, ops, auth, "mutation", storage, seed, parentTransaction, udfExecutor, componentPath))));
         return nestedResult.catch((error) => {
             parentTransaction.restoreSavepoint(savepoint);
             throw error;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@concavejs/core",
-  "version": "0.0.1-alpha.8",
+  "version": "0.0.1-alpha.9",
   "license": "FSL-1.1-Apache-2.0",
   "publishConfig": {
     "access": "public"