@concavejs/runtime-cf-base 0.0.1-alpha.10

package/dist/durable-objects/concave-do-base.js

@@ -0,0 +1,466 @@
+/**
+ * Base class for ConcaveDO implementations
+ *
+ * This provides the common functionality shared between runtime-cf and runtime-cloud.
+ * Subclasses provide platform-specific wiring through constructor config.
+ */
+import { DurableObject } from "cloudflare:workers";
+import { DODocStore } from "@concavejs/docstore-cf-do";
+import { writtenTablesFromRanges } from "@concavejs/core/utils";
+import { jsonToConvex } from "convex/values";
+import { getSearchIndexesFromSchema, getVectorIndexesFromSchema } from "@concavejs/core/docstore";
+import { SchemaService } from "@concavejs/core/kernel";
+import { runAsClientCall, runAsServerCall } from "@concavejs/core/udf";
+import { ScheduledFunctionExecutor, CronExecutor } from "@concavejs/core";
+import { resolveAuthContext } from "@concavejs/core/http";
+import { createTenantAuthResolverFromEnv, AuthConfigService } from "@concavejs/core/auth";
+import { DocStoreRpc } from "./docstore-rpc";
+import { BlobStoreRpc } from "./blobstore-rpc";
+import { SyncNotifier } from "./sync-notifier";
+import { SchedulerManager } from "./scheduler-manager";
+const VERSIONED_API_PREFIX = /^\/api\/\d+\.\d+(?:\.\d+)?(?=\/|$)/;
+function stripApiVersionPrefix(pathname) {
+    return pathname.replace(VERSIONED_API_PREFIX, "/api");
+}
+function isReservedApiPath(pathname) {
+    const normalizedPath = stripApiVersionPrefix(pathname);
+    if (normalizedPath === "/api/execute" ||
+        normalizedPath === "/api/sync" ||
+        normalizedPath === "/api/reset-test-state" ||
+        normalizedPath === "/api/query" ||
+        normalizedPath === "/api/query_ts" ||
+        normalizedPath === "/api/query_at_ts" ||
+        normalizedPath === "/api/mutation" ||
+        normalizedPath === "/api/action") {
+        return true;
+    }
+    if (normalizedPath === "/api/storage" || normalizedPath.startsWith("/api/storage/")) {
+        return true;
+    }
+    return false;
+}
+function shouldHandleAsHttpRoute(pathname) {
+    if (pathname.startsWith("/api/http")) {
+        return true;
+    }
+    if (!pathname.startsWith("/api/")) {
+        return false;
+    }
+    return !isReservedApiPath(pathname);
+}
+function parseSnapshotTimestamp(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value === "bigint") {
+        return value;
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
+            throw new Error("Invalid snapshotTimestamp");
+        }
+        return BigInt(value);
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (!/^\d+$/.test(trimmed)) {
+            throw new Error("Invalid snapshotTimestamp");
+        }
+        return BigInt(trimmed);
+    }
+    throw new Error("Invalid snapshotTimestamp");
+}
+/**
+ * Base class for Concave Durable Objects
+ *
+ * Provides:
+ * - Request handling (fetch, syscall, HTTP)
+ * - Scheduled function execution
+ * - Cron job execution
+ * - SyncDO notification
+ *
+ * Subclasses/configurers provide:
+ * - createUdfExecutor(): Platform-specific UDF executor creation
+ */
+export class ConcaveDOBase extends DurableObject {
+    _docstore;
+    _blobstore;
+    udfExecutor;
+    doState;
+    env;
+    scheduler;
+    cronExecutor;
+    docStoreRpc;
+    blobStoreRpc;
+    syncNotifier;
+    schedulerManager;
+    /** Cached search/vector index definitions for reuse (e.g. after reset-test-state) */
+    cachedSearchIndexes = [];
+    cachedVectorIndexes = [];
+    /** Cached JWT providers from auth.config.ts */
+    cachedJwtProviders = [];
+    constructor(state, env, config) {
+        super(state, env);
+        this.doState = state;
+        this.env = env;
+        const instanceId = state.id.name ?? state.id.toString();
+        const adapterContext = {
+            state,
+            env,
+            instance: instanceId,
+        };
+        // Create DocStore (allow override for testing or alternative implementations)
+        this._docstore = config.createDocstore ? config.createDocstore(adapterContext) : new DODocStore(state);
+        // Create BlobStore (allow override for testing or alternative implementations)
+        this._blobstore = config.createBlobstore?.(adapterContext);
+        this.docStoreRpc = new DocStoreRpc(this._docstore);
+        this.blobStoreRpc = this._blobstore ? new BlobStoreRpc(this._blobstore) : null;
+        this.syncNotifier = new SyncNotifier(state, env);
+        // Create UDF executor from resolved runtime services
+        this.udfExecutor = config.createUdfExecutor({
+            ...adapterContext,
+            docstore: this._docstore,
+            blobstore: this._blobstore,
+        });
+        // Set up scheduler and cron executor
+        this.initializeSchedulers();
+        // Initialize schema and cron specs
+        this.doState.blockConcurrencyWhile(async () => {
+            let searchIndexes = [];
+            let vectorIndexes = [];
+            // Try loading schema from registered module loaders (works in self-hosted runtimes)
+            try {
+                const schemaService = new SchemaService();
+                searchIndexes = await getSearchIndexesFromSchema(schemaService);
+                vectorIndexes = await getVectorIndexesFromSchema(schemaService);
+            }
+            catch {
+                // Schema module not available in this context (e.g. cloud runtime with isolated workers)
+            }
+            // Fallback: ask the UDF executor for schema info (e.g. via isolated worker shim)
+            if (searchIndexes.length === 0 && vectorIndexes.length === 0) {
+                try {
+                    if (typeof this.udfExecutor.getSchemaInfo === "function") {
+                        const info = await this.udfExecutor.getSchemaInfo();
+                        if (info) {
+                            searchIndexes = info.searchIndexes ?? [];
+                            vectorIndexes = info.vectorIndexes ?? [];
+                        }
+                    }
+                }
+                catch (error) {
+                    console.warn("[ConcaveDO] Failed to resolve schema from executor:", error?.message ?? error);
+                }
+            }
+            // Cache for reuse (e.g. after reset-test-state clears storage)
+            this.cachedSearchIndexes = searchIndexes;
+            this.cachedVectorIndexes = vectorIndexes;
+            await this._docstore.setupSchema({ searchIndexes, vectorIndexes });
+            // Load auth.config.ts providers (mirrors SchemaService pattern)
+            try {
+                const authConfigService = new AuthConfigService();
+                this.cachedJwtProviders = await authConfigService.getProviders();
+            }
+            catch {
+                // auth.config.ts not available — silent
+            }
+            // Sync cron specs: use pre-computed if provided, otherwise auto-discover
+            await this.initializeCronSpecs(config);
+        });
+    }
+    /**
+     * Initialize scheduler and cron executor
+     */
+    initializeSchedulers() {
+        const notifyWrites = async (ranges, tables, commitTimestamp) => {
+            await this.notifySyncDo(ranges, tables, commitTimestamp);
+        };
+        const allocateTimestamp = () => {
+            const oracle = this._docstore?.timestampOracle;
+            return oracle?.allocateTimestamp ? oracle.allocateTimestamp() : BigInt(Date.now());
+        };
+        this.scheduler = new ScheduledFunctionExecutor({
+            docstore: this._docstore,
+            udfExecutor: this.udfExecutor,
+            logger: console,
+            notifyWrites,
+            allocateTimestamp,
+        });
+        this.cronExecutor = new CronExecutor({
+            docstore: this._docstore,
+            udfExecutor: this.udfExecutor,
+            logger: console,
+            notifyWrites,
+            allocateTimestamp,
+        });
+        this.schedulerManager = new SchedulerManager(this.scheduler, this.cronExecutor, this.doState);
+    }
+    /**
+     * Discover and sync cron specs during DO initialization.
+     * Supports both pre-computed specs (from deploy pipelines) and
+     * runtime auto-discovery from the global module registry.
+     */
+    async initializeCronSpecs(config) {
+        try {
+            let cronSpecs = null;
+            if (config.cronSpecs) {
+                // Pre-computed specs provided (e.g. extracted at build/deploy time)
+                cronSpecs = config.cronSpecs;
+            }
+            else if (config.discoverCrons !== false) {
+                // Auto-discover from registered modules
+                const { discoverCronSpecs } = await import("@concavejs/core/system");
+                cronSpecs = await discoverCronSpecs();
+            }
+            if (cronSpecs && Object.keys(cronSpecs).length > 0) {
+                await this.cronExecutor.syncCronSpecs(cronSpecs);
+                await this.reschedule();
+            }
+        }
+        catch (error) {
+            console.warn("[ConcaveDO] Failed to initialize cron specs:", error?.message ?? error);
+        }
+    }
+    currentSnapshotTimestamp() {
+        const oracle = this._docstore?.timestampOracle;
+        const oracleTimestamp = typeof oracle?.beginSnapshot === "function"
+            ? oracle.beginSnapshot()
+            : typeof oracle?.getCurrentTimestamp === "function"
+                ? oracle.getCurrentTimestamp()
+                : undefined;
+        const wallClock = BigInt(Date.now());
+        if (typeof oracleTimestamp === "bigint" && oracleTimestamp > wallClock) {
+            return oracleTimestamp;
+        }
+        return wallClock;
+    }
+    /**
+     * Main request handler
+     */
+    async fetch(request) {
+        const url = new URL(request.url);
+        if (url.pathname === "/reschedule" && request.method === "POST") {
+            try {
+                await this.reschedule();
+                return new Response("OK", { status: 200 });
+            }
+            catch (error) {
+                console.error("[ConcaveDO] /reschedule failed:", error?.message ?? error);
+                return new Response("Reschedule failed", { status: 500 });
+            }
+        }
+        if (url.pathname === "/query_ts") {
+            if (request.method !== "POST") {
+                return new Response("Method not allowed", { status: 405 });
+            }
+            return Response.json({ ts: this.currentSnapshotTimestamp().toString() }, { headers: this.corsHeaders(request) });
+        }
+        if (shouldHandleAsHttpRoute(url.pathname)) {
+            return this.handleHttp(request);
+        }
+        if (url.pathname === "/health") {
+            return new Response("OK", { status: 200 });
+        }
+        return this.handleUdfRequest(request);
+    }
+    /**
+     * Handle UDF execution request
+     */
+    async handleUdfRequest(request) {
+        try {
+            const { path, args, type, auth, componentPath, caller, snapshotTimestamp } = await request.json();
+            const convexArgs = jsonToConvex(args);
+            const parsedSnapshotTimestamp = parseSnapshotTimestamp(snapshotTimestamp);
+            const requestId = crypto.randomUUID();
+            const exec = () => this.execute(path, convexArgs, type, auth, componentPath, requestId, parsedSnapshotTimestamp);
+            const result = caller === "server" ? await runAsServerCall(exec, path) : await runAsClientCall(exec);
+            if (type === "mutation" || type === "action") {
+                this.doState.waitUntil(this.reschedule().catch((error) => {
+                    console.error("[ConcaveDO] Failed to reschedule alarm", error?.message ?? error);
+                }));
+            }
+            const writtenTables = writtenTablesFromRanges(result.writtenRanges) ?? [];
+            const responseBody = {
+                result: result.result,
+                readRanges: result.readRanges,
+                writtenRanges: result.writtenRanges,
+                writtenTables,
+                logLines: result.logLines,
+                trace: result.trace,
+                snapshotTimestamp: result.snapshotTimestamp ? result.snapshotTimestamp.toString() : undefined,
+                commitTimestamp: result.commitTimestamp ? result.commitTimestamp.toString() : undefined,
+            };
+            return new Response(JSON.stringify(responseBody), {
+                headers: this.corsHeaders(request),
+            });
+        }
+        catch (e) {
+            console.error(e);
+            const errorMessage = e?.message ?? "Internal Server Error";
+            return new Response(JSON.stringify({ error: errorMessage }), {
+                headers: { "Content-Type": "application/json", ...this.corsHeaders(request) },
+                status: 500,
+            });
+        }
+    }
+    /**
+     * Handle HTTP action requests
+     */
+    async handleHttp(request) {
+        try {
+            const url = new URL(request.url);
+            url.pathname = url.pathname.replace(/^\/api\/http/, "");
+            const req = new Request(url.toString(), request);
+            const authHeader = req.headers.get("Authorization");
+            const headerToken = authHeader?.replace(/^Bearer\s+/i, "").trim() || undefined;
+            const projectId = req.headers.get("X-Concave-Project-Id") ?? undefined;
+            const authResolver = createTenantAuthResolverFromEnv(this.env, projectId);
+            if (this.cachedJwtProviders.length > 0 && "updateJwtProviders" in authResolver) {
+                authResolver.updateJwtProviders(this.cachedJwtProviders);
+            }
+            const headerIdentity = undefined;
+            const auth = (await resolveAuthContext(undefined, headerToken, headerIdentity, authResolver));
+            const requestId = crypto.randomUUID();
+            return this.udfExecutor.executeHttp(req, auth, requestId);
+        }
+        catch (e) {
+            console.error(e);
+            return new Response("Internal Server Error", { status: 500, headers: this.corsHeaders(request) });
+        }
+    }
+    /**
+     * Execute a UDF
+     */
+    async execute(path, args, type, auth, componentPath, requestId, snapshotTimestamp) {
+        return this.udfExecutor.execute(path, args, type, auth, componentPath, requestId, snapshotTimestamp);
+    }
+    /**
+     * Handle scheduled function alarms
+     */
+    async alarm() {
+        return this.schedulerManager.handleAlarm();
+    }
+    /**
+     * Reschedule alarms
+     */
+    async reschedule() {
+        return this.schedulerManager.reschedule();
+    }
+    /**
+     * Sync cron specs
+     */
+    async syncCronSpecs(cronSpecs) {
+        return this.schedulerManager.syncCronSpecs(cronSpecs);
+    }
+    // =============================================================================
+    // DocStore RPC Methods - Direct delegation to _docstore
+    // =============================================================================
+    async setupSchema(options) {
+        return this.docStoreRpc.setupSchema(options);
+    }
+    async write(documents, indexes, conflictStrategy) {
+        return this.docStoreRpc.write(documents, indexes, conflictStrategy);
+    }
+    async get(id, readTimestamp) {
+        return this.docStoreRpc.get(id, readTimestamp);
+    }
+    async scan(table, readTimestamp) {
+        return this.docStoreRpc.scan(table, readTimestamp);
+    }
+    async scanPaginated(table, cursor, limit, order, readTimestamp) {
+        return this.docStoreRpc.scanPaginated(table, cursor, limit, order, readTimestamp);
+    }
+    /**
+     * Generators return arrays over RPC (cannot stream async generators)
+     */
+    async index_scan(indexId, tabletId, readTimestamp, interval, order) {
+        return this.docStoreRpc.index_scan(indexId, tabletId, readTimestamp, interval, order);
+    }
+    /**
+     * Generators return arrays over RPC (cannot stream async generators)
+     */
+    async load_documents(range, order) {
+        return this.docStoreRpc.load_documents(range, order);
+    }
+    async count(table) {
+        return this.docStoreRpc.count(table);
+    }
+    async search(indexId, searchQuery, filters, options) {
+        return this.docStoreRpc.search(indexId, searchQuery, filters, options);
+    }
+    async vectorSearch(indexId, vector, limit, filters) {
+        return this.docStoreRpc.vectorSearch(indexId, vector, limit, filters);
+    }
+    async getGlobal(key) {
+        return this.docStoreRpc.getGlobal(key);
+    }
+    async writeGlobal(key, value) {
+        return this.docStoreRpc.writeGlobal(key, value);
+    }
+    async previous_revisions(queries) {
+        return this.docStoreRpc.previous_revisions(queries);
+    }
+    async previous_revisions_of_documents(queries) {
+        return this.docStoreRpc.previous_revisions_of_documents(queries);
+    }
+    // =============================================================================
+    // Blobstore RPC Methods - Prefixed to avoid collision with other methods
+    // =============================================================================
+    async blobstoreStore(buffer, options) {
+        if (!this.blobStoreRpc) {
+            throw new Error("Blobstore not configured");
+        }
+        return this.blobStoreRpc.store(buffer, options);
+    }
+    async blobstoreGet(storageId) {
+        if (!this.blobStoreRpc) {
+            throw new Error("Blobstore not configured");
+        }
+        return this.blobStoreRpc.get(storageId);
+    }
+    async blobstoreDelete(storageId) {
+        if (!this.blobStoreRpc) {
+            throw new Error("Blobstore not configured");
+        }
+        return this.blobStoreRpc.delete(storageId);
+    }
+    async blobstoreGetUrl(storageId) {
+        if (!this.blobStoreRpc) {
+            throw new Error("Blobstore not configured");
+        }
+        return this.blobStoreRpc.getUrl(storageId);
+    }
+    /**
+     * Notify SyncDO of writes for subscription invalidation
+     */
+    async notifySyncDo(writtenRanges, writtenTables, commitTimestamp) {
+        return this.syncNotifier.notify(writtenRanges, writtenTables, commitTimestamp);
+    }
+    /**
+     * Get CORS headers for responses
+     */
+    corsHeaders(request) {
+        const origin = request?.headers.get("Origin") ?? null;
+        const requestedHeaders = request?.headers.get("Access-Control-Request-Headers") ?? null;
+        const headers = {
+            "Content-Type": "application/json",
+            "Access-Control-Allow-Origin": origin ?? "*",
+            "Access-Control-Allow-Headers": requestedHeaders ?? "*",
+            "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+            "Access-Control-Max-Age": "86400",
+        };
+        if (origin) {
+            headers["Access-Control-Allow-Credentials"] = "true";
+        }
+        if (origin && requestedHeaders) {
+            headers.Vary = "Origin, Access-Control-Request-Headers";
+        }
+        else if (origin) {
+            headers.Vary = "Origin";
+        }
+        else if (requestedHeaders) {
+            headers.Vary = "Access-Control-Request-Headers";
+        }
+        return headers;
+    }
+}

package/dist/durable-objects/docstore-rpc.d.ts

@@ -0,0 +1,46 @@
+import type { DocStore, DocumentLogEntry, DatabaseIndexUpdate, Interval, Order, IndexKeyBytes, LatestDocument, TimestampRange, InternalDocumentId, GlobalKey, DocumentPrevTsQuery, SearchIndexDefinition, VectorIndexDefinition } from "@concavejs/core/docstore";
+import type { JSONValue } from "convex/values";
+/**
+ * DocStore RPC surface for service-binding isolation.
+ * Provides async delegation methods that flatten generators into arrays
+ * for RPC transport (async generators cannot be streamed over service bindings).
+ */
+export declare class DocStoreRpc {
+    private readonly docstore;
+    constructor(docstore: DocStore);
+    setupSchema(options?: {
+        searchIndexes?: SearchIndexDefinition[];
+        vectorIndexes?: VectorIndexDefinition[];
+    }): Promise<void>;
+    write(documents: DocumentLogEntry[], indexes: Set<{
+        ts: bigint;
+        update: DatabaseIndexUpdate;
+    }>, conflictStrategy: "Error" | "Overwrite"): Promise<void>;
+    get(id: InternalDocumentId, readTimestamp?: bigint): Promise<LatestDocument | null>;
+    scan(table: string, readTimestamp?: bigint): Promise<LatestDocument[]>;
+    scanPaginated(table: string, cursor: string | null, limit: number, order: Order, readTimestamp?: bigint): Promise<{
+        documents: LatestDocument[];
+        nextCursor: string | null;
+        hasMore: boolean;
+    }>;
+    index_scan(indexId: string, tabletId: string, readTimestamp: bigint, interval: Interval, order: Order): Promise<[IndexKeyBytes, LatestDocument][]>;
+    load_documents(range: TimestampRange, order: Order): Promise<DocumentLogEntry[]>;
+    count(table: string): Promise<number>;
+    search(indexId: string, searchQuery: string, filters: Map<string, unknown>, options?: {
+        limit?: number;
+    }): Promise<{
+        doc: LatestDocument;
+        score: number;
+    }[]>;
+    vectorSearch(indexId: string, vector: number[], limit: number, filters: Map<string, string>): Promise<{
+        doc: LatestDocument;
+        score: number;
+    }[]>;
+    getGlobal(key: GlobalKey): Promise<JSONValue | null>;
+    writeGlobal(key: GlobalKey, value: JSONValue): Promise<void>;
+    previous_revisions(queries: Set<{
+        id: InternalDocumentId;
+        ts: bigint;
+    }>): Promise<[string, DocumentLogEntry][]>;
+    previous_revisions_of_documents(queries: Set<DocumentPrevTsQuery>): Promise<[string, DocumentLogEntry][]>;
+}

package/dist/durable-objects/docstore-rpc.js

@@ -0,0 +1,63 @@
+/**
+ * DocStore RPC surface for service-binding isolation.
+ * Provides async delegation methods that flatten generators into arrays
+ * for RPC transport (async generators cannot be streamed over service bindings).
+ */
+export class DocStoreRpc {
+    docstore;
+    constructor(docstore) {
+        this.docstore = docstore;
+    }
+    async setupSchema(options) {
+        return this.docstore.setupSchema(options);
+    }
+    async write(documents, indexes, conflictStrategy) {
+        return this.docstore.write(documents, indexes, conflictStrategy);
+    }
+    async get(id, readTimestamp) {
+        return this.docstore.get(id, readTimestamp);
+    }
+    async scan(table, readTimestamp) {
+        return this.docstore.scan(table, readTimestamp);
+    }
+    async scanPaginated(table, cursor, limit, order, readTimestamp) {
+        return this.docstore.scanPaginated(table, cursor, limit, order, readTimestamp);
+    }
+    async index_scan(indexId, tabletId, readTimestamp, interval, order) {
+        const results = [];
+        for await (const item of this.docstore.index_scan(indexId, tabletId, readTimestamp, interval, order)) {
+            results.push(item);
+        }
+        return results;
+    }
+    async load_documents(range, order) {
+        const results = [];
+        for await (const item of this.docstore.load_documents(range, order)) {
+            results.push(item);
+        }
+        return results;
+    }
+    async count(table) {
+        return this.docstore.count(table);
+    }
+    async search(indexId, searchQuery, filters, options) {
+        return this.docstore.search(indexId, searchQuery, filters, options);
+    }
+    async vectorSearch(indexId, vector, limit, filters) {
+        return this.docstore.vectorSearch(indexId, vector, limit, filters);
+    }
+    async getGlobal(key) {
+        return this.docstore.getGlobal(key);
+    }
+    async writeGlobal(key, value) {
+        return this.docstore.writeGlobal(key, value);
+    }
+    async previous_revisions(queries) {
+        const result = await this.docstore.previous_revisions(queries);
+        return Array.from(result.entries());
+    }
+    async previous_revisions_of_documents(queries) {
+        const result = await this.docstore.previous_revisions_of_documents(queries);
+        return Array.from(result.entries());
+    }
+}

package/dist/durable-objects/scheduler-manager.d.ts

@@ -0,0 +1,19 @@
+import type { ScheduledFunctionExecutor, CronExecutor } from "@concavejs/core";
+/**
+ * Manages scheduled function and cron job execution.
+ * Extracted from ConcaveDOBase for single-responsibility.
+ */
+export declare class SchedulerManager {
+    private readonly scheduler;
+    private readonly cronExecutor;
+    private readonly doState;
+    constructor(scheduler: ScheduledFunctionExecutor, cronExecutor: CronExecutor, doState: {
+        storage: {
+            setAlarm(time: number): Promise<void>;
+            deleteAlarm(): Promise<void>;
+        };
+    });
+    handleAlarm(): Promise<void>;
+    reschedule(): Promise<void>;
+    syncCronSpecs(cronSpecs: Record<string, any>): Promise<void>;
+}

package/dist/durable-objects/scheduler-manager.js

@@ -0,0 +1,53 @@
+/**
+ * Manages scheduled function and cron job execution.
+ * Extracted from ConcaveDOBase for single-responsibility.
+ */
+export class SchedulerManager {
+    scheduler;
+    cronExecutor;
+    doState;
+    constructor(scheduler, cronExecutor, doState) {
+        this.scheduler = scheduler;
+        this.cronExecutor = cronExecutor;
+        this.doState = doState;
+    }
+    async handleAlarm() {
+        try {
+            const scheduledResult = await this.scheduler.runDueJobs();
+            const cronResult = await this.cronExecutor.runDueJobs();
+            const nextTimes = [scheduledResult.nextScheduledTime, cronResult.nextScheduledTime].filter((t) => t !== null);
+            if (nextTimes.length === 0) {
+                await this.doState.storage.deleteAlarm();
+            }
+            else {
+                const alarmTime = Math.min(...nextTimes);
+                await this.doState.storage.setAlarm(alarmTime);
+            }
+        }
+        catch (error) {
+            console.error("[SchedulerManager] Alarm handler failed:", error?.message ?? error);
+            try {
+                await this.reschedule();
+            }
+            catch (rescheduleError) {
+                console.error("[SchedulerManager] Reschedule after alarm failure also failed:", rescheduleError?.message);
+            }
+        }
+    }
+    async reschedule() {
+        const scheduledTime = await this.scheduler.getNextScheduledTime();
+        const cronTime = await this.cronExecutor.getNextScheduledTime();
+        const nextTimes = [scheduledTime, cronTime].filter((t) => t !== null);
+        if (nextTimes.length === 0) {
+            await this.doState.storage.deleteAlarm();
+        }
+        else {
+            const alarmTime = Math.min(...nextTimes);
+            await this.doState.storage.setAlarm(alarmTime);
+        }
+    }
+    async syncCronSpecs(cronSpecs) {
+        await this.cronExecutor.syncCronSpecs(cronSpecs);
+        await this.reschedule();
+    }
+}

package/dist/durable-objects/sync-notifier.d.ts

@@ -0,0 +1,16 @@
+import type { SerializedKeyRange } from "@concavejs/core/queryengine";
+/**
+ * Notifies the SyncDO of writes for subscription invalidation.
+ * Extracted from ConcaveDOBase for single-responsibility.
+ */
+export declare class SyncNotifier {
+    private readonly doState;
+    private readonly env;
+    constructor(doState: {
+        id: {
+            name?: string | null;
+            toString(): string;
+        };
+    }, env: any);
+    notify(writtenRanges?: SerializedKeyRange[], writtenTables?: string[], commitTimestamp?: bigint): Promise<void>;
+}