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

package/dist/kernel/udf-kernel.d.ts

@@ -3,10 +3,20 @@ import type { OccMutationTransaction } from "../transactor/occ-transaction";
 import type { BlobStore } from "../abstractions/blobstore";
 import type { UdfExec } from "../udf/executor/interface";
 import type { KernelAuthContext } from "./types";
+export interface UdfKernelConfig {
+    docstore: DocStore;
+    authContext?: KernelAuthContext;
+    storage?: BlobStore;
+    snapshotOverride?: bigint | null;
+    mutationTransaction?: OccMutationTransaction;
+    udfExecutor?: UdfExec;
+    componentPath?: string;
+    idGenerator?: () => Uint8Array;
+}
 export declare class UdfKernel {
     private readonly context;
     private readonly syscalls;
-    constructor(docstore: DocStore, authContext?: KernelAuthContext, storage?: BlobStore, snapshotOverride?: bigint | null, mutationTransaction?: OccMutationTransaction, udfExecutor?: UdfExec, componentPath?: string, idGenerator?: () => Uint8Array);
+    constructor(config: UdfKernelConfig);
     clearAccessLogs(): void;
     getTrackedReadRanges(): import("..").SerializedKeyRange[];
     getTrackedWriteRanges(): import("..").SerializedKeyRange[];

package/dist/kernel/udf-kernel.js

@@ -8,28 +8,28 @@ import { KernelSyscalls } from "./syscalls/kernel-syscalls";
 export class UdfKernel {
     context;
     syscalls;
-    constructor(docstore, authContext, storage, snapshotOverride, mutationTransaction, udfExecutor, componentPath, idGenerator) {
-        const transaction = mutationTransaction ?? transactionContext.getStore() ?? undefined;
-        const docStore = new DocStoreGateway(docstore, transaction);
+    constructor(config) {
+        const transaction = config.mutationTransaction ?? transactionContext.getStore() ?? undefined;
+        const docStore = new DocStoreGateway(config.docstore, transaction);
         const inheritedSnapshot = snapshotContext.getStore() ?? null;
-        const snapshotTimestamp = docStore.computeSnapshotTimestamp(snapshotOverride, inheritedSnapshot);
+        const snapshotTimestamp = docStore.computeSnapshotTimestamp(config.snapshotOverride, inheritedSnapshot);
         this.context = new KernelContext({
             snapshotTimestamp,
-            authContext,
-            componentPath,
+            authContext: config.authContext,
+            componentPath: config.componentPath,
             mutationTransaction: docStore.getTransaction(),
         });
         docStore.attachContext(this.context);
-        const schemaService = new SchemaService(componentPath);
+        const schemaService = new SchemaService(config.componentPath);
         const queryRuntime = new QueryRuntime(this.context, docStore, schemaService);
         this.syscalls = new KernelSyscalls({
             context: this.context,
             docStore,
             schemaService,
             queryRuntime,
-            storage,
-            udfExecutor,
-            idGenerator: idGenerator ?? generateInternalId,
+            storage: config.storage,
+            udfExecutor: config.udfExecutor,
+            idGenerator: config.idGenerator ?? generateInternalId,
         });
     }
     clearAccessLogs() {

package/dist/query/query-runtime.js

@@ -3,6 +3,7 @@ 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 { isSearchCapable } from "../docstore/search-interfaces";
 import { buildQueryPlan } from "./planner";
 import { paginateByCursor, sortByCreationTimeAndId, sortByIndexFields } from "./execution";
 import { applyQueryOperators } from "./postprocess";
@@ -113,9 +114,11 @@ export class QueryRuntime {
             : operatorLimit && operatorLimit > 0
                 ? operatorLimit
                 : undefined;
-        const searchResults = await this.docStore
-            .getDocStore()
-            .search(plan.indexIdHex, plan.searchTerm, plan.filterMap, { limit: combinedLimit });
+        const rawDocStore = this.docStore.getDocStore();
+        if (!isSearchCapable(rawDocStore)) {
+            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 }) => ({

package/dist/queryengine/cursor.js

@@ -6,6 +6,7 @@
  * - Index cursors: Encode both _id and index key values (for index queries)
  */
 import { convexToJson, jsonToConvex } from "convex/values";
+import { decodeBase64ToUtf8, encodeUtf8ToBase64 } from "../utils/base64";
 /**
  * Encode a cursor for an index query.
  * @param id Document ID
@@ -18,7 +19,7 @@ export function encodeIndexCursor(id, indexKey) {
         id,
         indexKey: indexKey.map((v) => convexToJson(v)),
     };
-    return Buffer.from(JSON.stringify(cursor), "utf-8").toString("base64");
+    return encodeUtf8ToBase64(JSON.stringify(cursor));
 }
 /**
  * Encode a simple cursor for a full table scan.
@@ -36,7 +37,7 @@ export function encodeSimpleCursor(id) {
 export function decodeCursor(cursorString) {
     // Try to decode as base64 first (index cursor)
     try {
-        const decoded = Buffer.from(cursorString, "base64").toString("utf-8");
+        const decoded = decodeBase64ToUtf8(cursorString);
         const parsed = JSON.parse(decoded);
         if (parsed.type === "index" && parsed.id && Array.isArray(parsed.indexKey)) {
             return {

package/dist/queryengine/index.d.ts

@@ -1,8 +1,8 @@
-export { UdfKernel } from "../kernel/udf-kernel";
+export { UdfKernel, type UdfKernelConfig } from "../kernel/udf-kernel";
 export { snapshotContext, transactionContext } from "../kernel/contexts";
 export { QueryRuntime } from "../query/query-runtime";
 export { SchemaService } from "../kernel/schema-service";
-export { DocStoreGateway } from "../kernel/docstore-gateway";
+export { DocStoreGateway, createDocAccess, type DocAccess } from "../kernel/docstore-gateway";
 export * from "./cursor";
 export * from "./filters";
 export * from "./index-query";

package/dist/queryengine/index.js

@@ -2,7 +2,7 @@ export { UdfKernel } from "../kernel/udf-kernel";
 export { snapshotContext, transactionContext } from "../kernel/contexts";
 export { QueryRuntime } from "../query/query-runtime";
 export { SchemaService } from "../kernel/schema-service";
-export { DocStoreGateway } from "../kernel/docstore-gateway";
+export { DocStoreGateway, createDocAccess } from "../kernel/docstore-gateway";
 export * from "./cursor";
 export * from "./filters";
 export * from "./index-query";

package/dist/ryow/uncommitted-writes.js

@@ -6,7 +6,7 @@
  * fragmented RYOW implementation into one clean abstraction.
  */
 import { parseDeveloperId } from "../queryengine/developer-id";
-import { deserializeDeveloperId, readVersionKey } from "../utils/utils";
+import { documentIdKey, parseDocumentIdKey } from "../docstore/interface";
 /**
  * Unified interface for accessing uncommitted writes.
  * Abstracts over both transaction pending documents and local writes.
@@ -63,8 +63,7 @@ export class UncommittedWrites {
             for (const [key, doc] of pending.entries()) {
                 if (doc === null) {
                     // Deleted document - key is in format "table:internalId"
-                    // Use centralized ID parsing to extract table
-                    const parsed = deserializeDeveloperId(key);
+                    const parsed = parseDocumentIdKey(key);
                     if (parsed && parsed.table === tableId) {
                         // Mark as deleted using the key as developer ID
                         writes.set(key, null);
@@ -98,7 +97,7 @@ export class UncommittedWrites {
             if (!parsed) {
                 return undefined;
             }
-            const key = readVersionKey(parsed);
+            const key = documentIdKey(parsed);
             const pending = this.mutationTransaction.getPendingDocuments();
             const doc = pending.get(key);
             if (doc === undefined) {
@@ -146,7 +145,7 @@ export class UncommittedWrites {
                 if (!parsed || parsed.table !== tableId) {
                     continue;
                 }
-                const key = readVersionKey(parsed);
+                const key = documentIdKey(parsed);
                 if (write.value === null) {
                     // Deleted
                     visibleDocs.delete(key);

package/dist/scheduler/cron-executor.js

@@ -8,6 +8,7 @@
  */
 import { Order } from "../docstore";
 import { stringToHex, writtenTablesFromRanges } from "../utils";
+import { randomUuid } from "../utils/crypto";
 import { runAsServerCall } from "../udf/module-loader/call-context";
 const CRONS_TABLE = "_crons";
 export class CronExecutor {
@@ -82,7 +83,7 @@ export class CronExecutor {
             }
             else {
                 // Create new job
-                const internalId = stringToHex(crypto.randomUUID());
+                const internalId = stringToHex(randomUuid());
                 const docId = { table: tableId, internalId };
                 const ts = this.allocateTimestamp?.() ?? BigInt(now);
                 const developerId = `${tableId}:${internalId}`;

package/dist/scheduler/scheduled-function-executor.js

@@ -1,5 +1,6 @@
 import { Order } from "../docstore";
-import { deserializeDeveloperId, stringToHex, writtenTablesFromRanges } from "../utils";
+import { stringToHex, writtenTablesFromRanges } from "../utils";
+import { parseDocumentIdKey } from "../docstore/interface";
 import { runAsServerCall } from "../udf/module-loader/call-context";
 const SCHEDULED_FUNCTIONS_TABLE = "_scheduled_functions";
 export class ScheduledFunctionExecutor {
@@ -183,11 +184,7 @@ export class ScheduledFunctionExecutor {
         }
     }
     getDocumentId(jobId) {
-        const parts = deserializeDeveloperId(jobId);
-        if (!parts) {
-            return null;
-        }
-        return { table: parts.table, internalId: parts.internalId };
+        return parseDocumentIdKey(jobId);
     }
     defaultAllocateTimestamp(previousTs) {
         const now = BigInt(this.now());

package/dist/subscriptions/subscription-manager.d.ts

@@ -49,6 +49,21 @@ export declare class SubscriptionManager {
     private tableToQueries;
     private tableWriteTimestamps;
     private lastCleanupTime;
+    /**
+     * Add a subscription hash to the table→queries inverted index.
+     * Must be called whenever a subscription's table set is established or grows.
+     */
+    private addSubscriptionToTables;
+    /**
+     * Remove a subscription hash from the table→queries inverted index.
+     * Must be called whenever a subscription's table set is cleared or shrinks.
+     */
+    private removeSubscriptionFromTables;
+    /**
+     * Atomically update a subscription's table dependencies and the inverted index.
+     * Removes old mappings, sets new tables, and adds new mappings in one operation.
+     */
+    private updateSubscriptionTables;
     /**
      * Subscribe a client to a query with its dependencies
      *
@@ -110,6 +125,13 @@ export declare class SubscriptionManager {
         totalTables: number;
         totalTrackedWriteTimestamps: number;
     };
+    /**
+     * Validate that all parallel maps are consistent with each other.
+     * Useful for testing and debugging subscription invariants.
+     *
+     * @throws Error if any inconsistency is detected
+     */
+    assertConsistency(): void;
     /**
      * Force cleanup of stale table write timestamps.
      * Useful for testing or manual cleanup.

package/dist/subscriptions/subscription-manager.js

@@ -127,6 +127,44 @@ export class SubscriptionManager {
     tableWriteTimestamps = new Map();
     // Last cleanup time to throttle cleanup frequency
     lastCleanupTime = 0;
+    /**
+     * Add a subscription hash to the table→queries inverted index.
+     * Must be called whenever a subscription's table set is established or grows.
+     */
+    addSubscriptionToTables(hash, tables) {
+        for (const table of tables) {
+            let queries = this.tableToQueries.get(table);
+            if (!queries) {
+                queries = new Set();
+                this.tableToQueries.set(table, queries);
+            }
+            queries.add(hash);
+        }
+    }
+    /**
+     * Remove a subscription hash from the table→queries inverted index.
+     * Must be called whenever a subscription's table set is cleared or shrinks.
+     */
+    removeSubscriptionFromTables(hash, tables) {
+        for (const table of tables) {
+            const queries = this.tableToQueries.get(table);
+            if (queries) {
+                queries.delete(hash);
+                if (queries.size === 0) {
+                    this.tableToQueries.delete(table);
+                }
+            }
+        }
+    }
+    /**
+     * Atomically update a subscription's table dependencies and the inverted index.
+     * Removes old mappings, sets new tables, and adds new mappings in one operation.
+     */
+    updateSubscriptionTables(subscription, newTables) {
+        this.removeSubscriptionFromTables(subscription.queryHash, subscription.tables);
+        subscription.tables = newTables;
+        this.addSubscriptionToTables(subscription.queryHash, newTables);
+    }
     /**
      * Subscribe a client to a query with its dependencies
      *
@@ -170,26 +208,7 @@ export class SubscriptionManager {
         clientQueries.add(queryId);
         // Update table dependencies if they changed
         if (!setsEqual(subscription.tables, tables)) {
-            // Remove old table mappings
-            for (const oldTable of subscription.tables) {
-                const queries = this.tableToQueries.get(oldTable);
-                if (queries) {
-                    queries.delete(hash);
-                    if (queries.size === 0) {
-                        this.tableToQueries.delete(oldTable);
-                    }
-                }
-            }
-            // Add new table mappings
-            subscription.tables = tables;
-            for (const table of tables) {
-                let queries = this.tableToQueries.get(table);
-                if (!queries) {
-                    queries = new Set();
-                    this.tableToQueries.set(table, queries);
-                }
-                queries.add(hash);
-            }
+            this.updateSubscriptionTables(subscription, tables);
         }
         // Check if any writes happened after the query's snapshot timestamp
         // This handles the race condition where:
@@ -238,16 +257,7 @@ export class SubscriptionManager {
         }
         // If no more clients, remove the subscription entirely
         if (subscription.clients.size === 0) {
-            // Remove from table index
-            for (const table of subscription.tables) {
-                const queries = this.tableToQueries.get(table);
-                if (queries) {
-                    queries.delete(hash);
-                    if (queries.size === 0) {
-                        this.tableToQueries.delete(table);
-                    }
-                }
-            }
+            this.removeSubscriptionFromTables(hash, subscription.tables);
             this.subscriptions.delete(hash);
         }
     }
@@ -388,7 +398,7 @@ export class SubscriptionManager {
      * Update client ID across all subscriptions (for session ID changes)
      */
     updateSessionId(oldClientId, newClientId) {
-        // Find all entries for the old client
+        // Collect all updates before mutating any maps
         const updates = [];
         for (const [key, hash] of this.clientQueryToHash) {
             if (key.startsWith(`${oldClientId}:`)) {
@@ -397,25 +407,42 @@ export class SubscriptionManager {
                 updates.push({ oldKey: key, newKey, queryId, hash });
             }
         }
-        for (const { oldKey, newKey, queryId, hash } of updates) {
-            // Update the client->hash mapping
+        // Phase 1: Update all clientQueryToHash mappings
+        for (const { oldKey, newKey, hash } of updates) {
             this.clientQueryToHash.delete(oldKey);
             this.clientQueryToHash.set(newKey, hash);
-            // Update the subscription's clients map
+        }
+        // Phase 2: Update all subscription client maps
+        // Group by hash to avoid redundant lookups
+        const byHash = new Map();
+        for (const { queryId, hash } of updates) {
+            let ids = byHash.get(hash);
+            if (!ids) {
+                ids = [];
+                byHash.set(hash, ids);
+            }
+            ids.push(queryId);
+        }
+        for (const [hash, queryIds] of byHash) {
             const subscription = this.subscriptions.get(hash);
-            if (subscription) {
-                const oldQueries = subscription.clients.get(oldClientId);
-                if (oldQueries) {
+            if (!subscription)
+                continue;
+            // Move all queryIds from old client to new client atomically
+            const oldQueries = subscription.clients.get(oldClientId);
+            if (oldQueries) {
+                for (const queryId of queryIds) {
                     oldQueries.delete(queryId);
-                    if (oldQueries.size === 0) {
-                        subscription.clients.delete(oldClientId);
-                    }
                 }
-                let newQueries = subscription.clients.get(newClientId);
-                if (!newQueries) {
-                    newQueries = new Set();
-                    subscription.clients.set(newClientId, newQueries);
+                if (oldQueries.size === 0) {
+                    subscription.clients.delete(oldClientId);
                 }
+            }
+            let newQueries = subscription.clients.get(newClientId);
+            if (!newQueries) {
+                newQueries = new Set();
+                subscription.clients.set(newClientId, newQueries);
+            }
+            for (const queryId of queryIds) {
                 newQueries.add(queryId);
             }
         }
@@ -438,6 +465,66 @@ export class SubscriptionManager {
             totalTrackedWriteTimestamps: this.tableWriteTimestamps.size,
         };
     }
+    /**
+     * Validate that all parallel maps are consistent with each other.
+     * Useful for testing and debugging subscription invariants.
+     *
+     * @throws Error if any inconsistency is detected
+     */
+    assertConsistency() {
+        // 1. Every clientQueryToHash entry must have a matching subscription with that client
+        for (const [key, hash] of this.clientQueryToHash) {
+            const colonIdx = key.indexOf(":");
+            const clientId = key.substring(0, colonIdx);
+            const queryId = key.substring(colonIdx + 1);
+            const subscription = this.subscriptions.get(hash);
+            if (!subscription) {
+                throw new Error(`clientQueryToHash references hash "${hash}" but no subscription exists`);
+            }
+            const clientQueries = subscription.clients.get(clientId);
+            if (!clientQueries || !clientQueries.has(queryId)) {
+                throw new Error(`clientQueryToHash has ${key} -> ${hash} but subscription doesn't list client "${clientId}" with queryId "${queryId}"`);
+            }
+        }
+        // 2. Every subscription.clients entry must have matching clientQueryToHash entries
+        for (const [hash, subscription] of this.subscriptions) {
+            for (const [clientId, queryIds] of subscription.clients) {
+                for (const queryId of queryIds) {
+                    const key = makeClientQueryKey(clientId, queryId);
+                    const mappedHash = this.clientQueryToHash.get(key);
+                    if (mappedHash !== hash) {
+                        throw new Error(`subscription "${hash}" lists client "${clientId}" queryId "${queryId}" but clientQueryToHash maps to "${mappedHash}"`);
+                    }
+                }
+            }
+        }
+        // 3. tableToQueries must match subscription.tables
+        const expectedTableToQueries = new Map();
+        for (const [hash, subscription] of this.subscriptions) {
+            for (const table of subscription.tables) {
+                let queries = expectedTableToQueries.get(table);
+                if (!queries) {
+                    queries = new Set();
+                    expectedTableToQueries.set(table, queries);
+                }
+                queries.add(hash);
+            }
+        }
+        for (const [table, expectedHashes] of expectedTableToQueries) {
+            const actualHashes = this.tableToQueries.get(table);
+            if (!actualHashes) {
+                throw new Error(`Expected tableToQueries to have table "${table}" but it's missing`);
+            }
+            if (!setsEqual(actualHashes, expectedHashes)) {
+                throw new Error(`tableToQueries for "${table}" is inconsistent with subscription tables`);
+            }
+        }
+        for (const [table] of this.tableToQueries) {
+            if (!expectedTableToQueries.has(table)) {
+                throw new Error(`tableToQueries has orphaned table "${table}" with no matching subscriptions`);
+            }
+        }
+    }
     /**
      * Force cleanup of stale table write timestamps.
      * Useful for testing or manual cleanup.

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

@@ -164,6 +164,11 @@ export declare class SyncProtocolHandler {
     private handleAction;
     private handleAuthenticate;
     private updateOriginatingSession;
+    /**
+     * Re-execute all active subscription queries across all sessions.
+     * Used during hot-reload to push fresh results after module code changes.
+     */
+    rerunAllSubscriptions(): Promise<void>;
     /**
      * Broadcast updates using fine-grained range-based tracking
      * Sends messages directly to affected sessions (excluding the originating session)

package/dist/sync/protocol-handler.js

@@ -7,6 +7,7 @@
 import { encodeServerMessage } from "../types";
 import { assertAdminToken, assertSystemToken, verifyJwtAndGetIdentity, JWTValidationError } from "../auth";
 import { SubscriptionManager } from "../subscriptions";
+import { nativeTimers } from "../kernel/native-timers";
 import { deserializeKeyRange } from "../queryengine";
 import { advanceSessionTimestamp, convertTablesToRanges, formatRangesForLog, longToBigIntTimestamp, makeStateVersion, makeTransitionMessage, toLongTimestamp, } from "./protocol-utils";
 import { executeReactiveQuery } from "./query-execution";
@@ -282,6 +283,13 @@ export class SyncProtocolHandler {
     async handleModifyQuerySet(sessionId, message) {
         const session = this.sessions.get(sessionId);
         return this.withSessionLock(session, async () => {
+            // If the client restarts its local query set (baseVersion=0), align the
+            // server's initial transition timestamp with the zeroed client state.
+            // Without this, a carried maxObservedTimestamp can produce startVersion
+            // mismatches like "X:0:0 transitioning from 0:0:0" after reconnect.
+            if (session.querySetVersion === 0 && session.identityVersion === 0 && message.baseVersion === 0) {
+                session.timestamp = 0n;
+            }
             // For reconnections, accept the client's base version as the starting point
             if (session.querySetVersion === 0 && message.baseVersion > 0) {
                 session.querySetVersion = message.baseVersion;
@@ -576,6 +584,27 @@ export class SyncProtocolHandler {
         const endVersion = makeStateVersion(session.querySetVersion, session.identityVersion, endTimestamp);
         return makeTransitionMessage(startVersion, endVersion, modifications);
     }
+    /**
+     * Re-execute all active subscription queries across all sessions.
+     * Used during hot-reload to push fresh results after module code changes.
+     */
+    async rerunAllSubscriptions() {
+        for (const [sessionId, session] of this.sessions) {
+            if (session.activeQueries.size === 0)
+                continue;
+            await this.withSessionLock(session, async () => {
+                const allQueryIds = new Set(session.activeQueries.keys());
+                const modifications = await this.rerunSpecificQueries(session, sessionId, allQueryIds);
+                if (modifications.length > 0) {
+                    const startTimestamp = session.timestamp;
+                    const endTimestamp = advanceSessionTimestamp(session);
+                    const startVersion = makeStateVersion(session.querySetVersion, session.identityVersion, startTimestamp);
+                    const endVersion = makeStateVersion(session.querySetVersion, session.identityVersion, endTimestamp);
+                    this.send(session, makeTransitionMessage(startVersion, endVersion, modifications));
+                }
+            });
+        }
+    }
     /**
      * Broadcast updates using fine-grained range-based tracking
      * Sends messages directly to affected sessions (excluding the originating session)
@@ -684,13 +713,13 @@ export class SyncProtocolHandler {
         }
         let timeoutHandle;
         const timeoutPromise = new Promise((_, reject) => {
-            timeoutHandle = setTimeout(() => {
+            timeoutHandle = nativeTimers.setTimeout(() => {
                 reject(new Error(`Sync operation timed out after ${this.operationTimeoutMs}ms`));
             }, this.operationTimeoutMs);
         });
         return Promise.race([promise, timeoutPromise]).finally(() => {
             if (timeoutHandle) {
-                clearTimeout(timeoutHandle);
+                nativeTimers.clearTimeout(timeoutHandle);
             }
         });
     }

package/dist/sync/session-backpressure.js

@@ -1,3 +1,4 @@
+import { nativeTimers } from "../kernel/native-timers";
 export class SessionBackpressureController {
     options;
     constructor(options) {
@@ -27,7 +28,7 @@ export class SessionBackpressureController {
     }
     clearDrainTimeout(session) {
         if (session.drainTimeout) {
-            clearTimeout(session.drainTimeout);
+            nativeTimers.clearTimeout(session.drainTimeout);
             session.drainTimeout = undefined;
         }
     }
@@ -35,7 +36,7 @@ export class SessionBackpressureController {
         if (session.isDraining)
             return;
         session.isDraining = true;
-        session.drainTimeout = setTimeout(() => {
+        session.drainTimeout = nativeTimers.setTimeout(() => {
             if (session.messageQueue.length > 0) {
                 this.options.warn(`[SyncProtocolHandler] Slow client timeout - disconnecting. ` +
                     `Queue depth: ${session.messageQueue.length}, dropped: ${session.droppedMessages}`);
@@ -68,7 +69,7 @@ export class SessionBackpressureController {
             this.clearDrainTimeout(session);
         }
         else {
-            setTimeout(() => this.drainQueue(session), 10);
+            nativeTimers.setTimeout(() => this.drainQueue(session), 10);
         }
     }
 }

package/dist/sync/session-heartbeat.js

@@ -1,3 +1,4 @@
+import { nativeTimers } from "../kernel/native-timers";
 export class SessionHeartbeatController {
     options;
     constructor(options) {
@@ -9,7 +10,7 @@ export class SessionHeartbeatController {
     }
     clear(session) {
         if (session.pingTimer) {
-            clearTimeout(session.pingTimer);
+            nativeTimers.clearTimeout(session.pingTimer);
             session.pingTimer = undefined;
         }
     }
@@ -18,7 +19,7 @@ export class SessionHeartbeatController {
         if (!session.websocket || session.websocket.readyState !== this.options.websocketReadyStateOpen) {
             return;
         }
-        session.pingTimer = setTimeout(() => {
+        session.pingTimer = nativeTimers.setTimeout(() => {
             this.options.onPing(session);
         }, this.options.intervalMs);
     }

package/dist/system/internal.js

@@ -21,7 +21,7 @@
  */
 import { v } from "convex/values";
 import { loadConvexModule, listRegisteredModules } from "../udf/module-loader/module-loader";
-import { isMissingSchemaModuleError } from "../kernel/schema-service";
+import { isMissingSchemaModuleError } from "../kernel/missing-schema-error";
 import { listSystemFunctions } from "./function-introspection";
 import { getFullTableName } from "../tables/interface";
 import { queryExecutionLog, clearExecutionLog } from "./execution-log";
@@ -505,8 +505,11 @@ export function createSystemFunctions(deps) {
         systemListFunctions: query({
             args: { componentPath: v.optional(v.string()) },
             handler: async (ctx, args) => {
-                const componentPath = args.componentPath ?? ctx?.componentPath ?? undefined;
-                const functions = await listSystemFunctions({ componentPath });
+                const requestedComponentPath = args.componentPath ?? ctx?.componentPath ?? undefined;
+                const normalizedComponentPath = typeof requestedComponentPath === "string" && requestedComponentPath.trim().length === 0
+                    ? undefined
+                    : requestedComponentPath;
+                const functions = await listSystemFunctions({ componentPath: normalizedComponentPath });
                 return functions.map((fn) => ({
                     name: fn.name,
                     path: fn.path,

package/dist/system/system-functions.js

@@ -4,7 +4,7 @@
  */
 import { hexToString, stringToHex } from "../utils/utils";
 import { loadConvexModule } from "../udf/module-loader/module-loader";
-import { isMissingSchemaModuleError } from "../kernel/schema-service";
+import { isMissingSchemaModuleError } from "../kernel/missing-schema-error";
 import { listSystemFunctions } from "./function-introspection";
 import { Order } from "../docstore/interface";
 /**