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

package/dist/adapters/cf-websocket-adapter.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Cloudflare WebSocket Adapter
+ *
+ * Adapts Cloudflare Workers WebSocket to the platform-agnostic WebSocketConnection interface
+ */
+import { type WebSocketConnection, WebSocketReadyState, type WebSocketMessageHandler, type WebSocketCloseHandler, type WebSocketErrorHandler } from "@concavejs/core/abstractions";
+export declare class CFWebSocketAdapter implements WebSocketConnection {
+    private ws;
+    private messageHandlers;
+    private closeHandlers;
+    private errorHandlers;
+    constructor(ws: WebSocket);
+    get readyState(): WebSocketReadyState;
+    send(data: string | ArrayBuffer): void;
+    close(code?: number, reason?: string): void;
+    onMessage(handler: WebSocketMessageHandler): void;
+    onClose(handler: WebSocketCloseHandler): void;
+    onError(handler: WebSocketErrorHandler): void;
+    /**
+     * Internal method to trigger message handlers
+     * Call this from your Durable Object's webSocketMessage handler
+     */
+    triggerMessage(data: string | ArrayBuffer): void;
+    /**
+     * Internal method to trigger close handlers
+     * Call this from your Durable Object's webSocketClose handler
+     */
+    triggerClose(code?: number, reason?: string): void;
+    /**
+     * Internal method to trigger error handlers
+     * Call this from your Durable Object's webSocketError handler
+     */
+    triggerError(error: Error): void;
+    /**
+     * Get the underlying Cloudflare WebSocket
+     */
+    get underlying(): WebSocket;
+}

package/dist/adapters/cf-websocket-adapter.js

@@ -0,0 +1,83 @@
+/**
+ * Cloudflare WebSocket Adapter
+ *
+ * Adapts Cloudflare Workers WebSocket to the platform-agnostic WebSocketConnection interface
+ */
+import { WebSocketReadyState, } from "@concavejs/core/abstractions";
+export class CFWebSocketAdapter {
+    ws;
+    messageHandlers = [];
+    closeHandlers = [];
+    errorHandlers = [];
+    constructor(ws) {
+        this.ws = ws;
+    }
+    get readyState() {
+        // Map CF WebSocket ready states to our enum
+        switch (this.ws.readyState) {
+            case WebSocket.READY_STATE_CONNECTING:
+                return WebSocketReadyState.CONNECTING;
+            case WebSocket.READY_STATE_OPEN:
+                return WebSocketReadyState.OPEN;
+            case WebSocket.READY_STATE_CLOSING:
+                return WebSocketReadyState.CLOSING;
+            case WebSocket.READY_STATE_CLOSED:
+                return WebSocketReadyState.CLOSED;
+            default:
+                return WebSocketReadyState.CLOSED;
+        }
+    }
+    send(data) {
+        this.ws.send(data);
+    }
+    close(code, reason) {
+        if (code !== undefined) {
+            this.ws.close(code, reason);
+        }
+        else {
+            this.ws.close();
+        }
+    }
+    onMessage(handler) {
+        this.messageHandlers.push(handler);
+    }
+    onClose(handler) {
+        this.closeHandlers.push(handler);
+    }
+    onError(handler) {
+        this.errorHandlers.push(handler);
+    }
+    /**
+     * Internal method to trigger message handlers
+     * Call this from your Durable Object's webSocketMessage handler
+     */
+    triggerMessage(data) {
+        for (const handler of this.messageHandlers) {
+            handler(data);
+        }
+    }
+    /**
+     * Internal method to trigger close handlers
+     * Call this from your Durable Object's webSocketClose handler
+     */
+    triggerClose(code, reason) {
+        for (const handler of this.closeHandlers) {
+            handler(code, reason);
+        }
+    }
+    /**
+     * Internal method to trigger error handlers
+     * Call this from your Durable Object's webSocketError handler
+     */
+    triggerError(error) {
+        for (const handler of this.errorHandlers) {
+            handler(error);
+        }
+    }
+    /**
+     * Get the underlying Cloudflare WebSocket
+     */
+    get underlying() {
+        return this.ws;
+    }
+}

package/dist/durable-objects/concave-do-base.d.ts

@@ -0,0 +1,158 @@
+/**
+ * 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 type { UdfExec, UdfResult } from "@concavejs/core/udf";
+import type { DocStore, DocumentLogEntry, DatabaseIndexUpdate, Interval, Order, IndexKeyBytes, LatestDocument, TimestampRange, InternalDocumentId, GlobalKey, DocumentPrevTsQuery, SearchIndexDefinition, VectorIndexDefinition } from "@concavejs/core/docstore";
+import type { BlobStore, StorageOptions, StorageMetadata } from "@concavejs/core/abstractions";
+import { ScheduledFunctionExecutor, CronExecutor } from "@concavejs/core";
+import type { SerializedKeyRange } from "@concavejs/core/queryengine";
+import type { JSONValue } from "convex/values";
+/**
+ * Configuration for ConcaveDOBase
+ */
+export interface ConcaveDOAdapterContext<Env = any> {
+    state: DurableObjectState;
+    env: Env;
+    instance: string;
+}
+export interface ConcaveDOExecutorContext<Env = any> extends ConcaveDOAdapterContext<Env> {
+    docstore: DocStore;
+    blobstore?: BlobStore;
+}
+export interface ConcaveDOConfig {
+    /** Override the DocStore implementation (default: DODocStore) */
+    createDocstore?: (context: ConcaveDOAdapterContext) => DocStore;
+    /** Override the BlobStore implementation */
+    createBlobstore?: (context: ConcaveDOAdapterContext) => BlobStore | undefined;
+    /** Create the UDF executor from resolved runtime services */
+    createUdfExecutor: (context: ConcaveDOExecutorContext) => UdfExec;
+    /**
+     * Pre-computed cron specs to sync on initialization.
+     * When provided, these are used directly instead of auto-discovering from modules.
+     * Useful for deploy pipelines that extract specs at build time.
+     */
+    cronSpecs?: Record<string, any>;
+    /**
+     * Whether to auto-discover cron specs from registered modules (default: true).
+     * Set to false to disable auto-discovery (e.g. if no modules are registered globally).
+     * Ignored when `cronSpecs` is explicitly provided.
+     */
+    discoverCrons?: boolean;
+}
+/**
+ * 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 declare class ConcaveDOBase extends DurableObject {
+    protected _docstore: DocStore;
+    protected _blobstore?: BlobStore;
+    protected udfExecutor: UdfExec;
+    protected doState: DurableObjectState;
+    env: any;
+    protected scheduler: ScheduledFunctionExecutor;
+    protected cronExecutor: CronExecutor;
+    constructor(state: DurableObjectState, env: any, config: ConcaveDOConfig);
+    /**
+     * Initialize scheduler and cron executor
+     */
+    private initializeSchedulers;
+    /**
+     * 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.
+     */
+    private initializeCronSpecs;
+    /**
+     * Main request handler
+     */
+    fetch(request: Request): Promise<Response>;
+    /**
+     * Handle UDF execution request
+     */
+    protected handleUdfRequest(request: Request): Promise<Response>;
+    /**
+     * Handle HTTP action requests
+     */
+    protected handleHttp(request: Request): Promise<Response>;
+    /**
+     * Execute a UDF
+     */
+    protected execute(path: string, args: Record<string, any>, type: "query" | "mutation" | "action", auth?: any, componentPath?: string, requestId?: string): Promise<UdfResult>;
+    /**
+     * Handle scheduled function alarms
+     */
+    alarm(): Promise<void>;
+    /**
+     * Reschedule alarms
+     */
+    protected reschedule(): Promise<void>;
+    /**
+     * Sync cron specs
+     */
+    syncCronSpecs(cronSpecs: Record<string, any>): Promise<void>;
+    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;
+    }>;
+    /**
+     * Generators return arrays over RPC (cannot stream async generators)
+     */
+    index_scan(indexId: string, tabletId: string, readTimestamp: bigint, interval: Interval, order: Order): Promise<[IndexKeyBytes, LatestDocument][]>;
+    /**
+     * Generators return arrays over RPC (cannot stream async generators)
+     */
+    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][]>;
+    blobstoreStore(buffer: ArrayBuffer, options?: StorageOptions): Promise<StorageMetadata>;
+    blobstoreGet(storageId: string): Promise<ArrayBuffer | null>;
+    blobstoreDelete(storageId: string): Promise<void>;
+    blobstoreGetUrl(storageId: string): Promise<string | null>;
+    /**
+     * Notify SyncDO of writes for subscription invalidation
+     */
+    protected notifySyncDo(writtenRanges?: SerializedKeyRange[], writtenTables?: string[] | undefined, commitTimestamp?: bigint): Promise<void>;
+    /**
+     * Get CORS headers for responses
+     */
+    protected corsHeaders(request?: Request): Record<string, string>;
+}

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

@@ -0,0 +1,412 @@
+/**
+ * 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 { resolveAdminAuthConfigFromEnv, resolveJwtValidationConfigFromEnv, resolveSystemAuthConfigFromEnv, setAdminAuthConfig, setJwtValidationConfig, setSystemAuthConfig, } from "@concavejs/core/auth";
+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/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);
+}
+/**
+ * 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;
+    constructor(state, env, config) {
+        super(state, env);
+        this.doState = state;
+        this.env = env;
+        const jwtConfig = resolveJwtValidationConfigFromEnv(env);
+        if (jwtConfig) {
+            setJwtValidationConfig(jwtConfig);
+        }
+        const adminConfig = resolveAdminAuthConfigFromEnv(env);
+        const systemConfig = resolveSystemAuthConfigFromEnv(env);
+        setAdminAuthConfig(adminConfig);
+        setSystemAuthConfig(systemConfig);
+        const instanceId = state.id.name ?? state.id.toString();
+        console.log(`[ConcaveDO.constructor] instanceId=${instanceId}`);
+        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);
+        // 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 () => {
+            const schemaService = new SchemaService();
+            const searchIndexes = await getSearchIndexesFromSchema(schemaService);
+            const vectorIndexes = await getVectorIndexesFromSchema(schemaService);
+            await this._docstore.setupSchema({ searchIndexes, vectorIndexes });
+            // 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,
+            runMutationInTransaction: async (operation) => this.doState.storage.transaction(async () => operation()),
+        });
+        this.cronExecutor = new CronExecutor({
+            docstore: this._docstore,
+            udfExecutor: this.udfExecutor,
+            logger: console,
+            notifyWrites,
+            allocateTimestamp,
+        });
+    }
+    /**
+     * 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);
+        }
+    }
+    /**
+     * Main request handler
+     */
+    async fetch(request) {
+        const url = new URL(request.url);
+        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 } = await request.json();
+            const convexArgs = jsonToConvex(args);
+            const requestId = crypto.randomUUID();
+            const exec = () => this.execute(path, convexArgs, type, auth, componentPath, requestId);
+            const result = caller === "server" ? await runAsServerCall(exec, path) : await runAsClientCall(exec);
+            if (type === "mutation" || type === "action") {
+                this.doState.waitUntil(this.reschedule());
+            }
+            const writtenTables = writtenTablesFromRanges(result.writtenRanges) ?? [];
+            const responseBody = {
+                result: result.result,
+                readRanges: result.readRanges,
+                writtenRanges: result.writtenRanges,
+                writtenTables,
+                logLines: result.logLines,
+                commitTimestamp: result.commitTimestamp ? result.commitTimestamp.toString() : undefined,
+            };
+            return new Response(JSON.stringify(responseBody), {
+                headers: this.corsHeaders(request),
+            });
+        }
+        catch (e) {
+            console.error(e);
+            return new Response(`Error in Durable Object: ${e.message}`, {
+                headers: 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 auth = undefined;
+            const requestId = crypto.randomUUID();
+            return this.udfExecutor.executeHttp(req, auth, requestId);
+        }
+        catch (e) {
+            console.error(e);
+            return new Response(`Error in Durable Object: ${e.message}`, { status: 500 });
+        }
+    }
+    /**
+     * Execute a UDF
+     */
+    async execute(path, args, type, auth, componentPath, requestId) {
+        return this.udfExecutor.execute(path, args, type, auth, componentPath, requestId);
+    }
+    /**
+     * Handle scheduled function alarms
+     */
+    async alarm() {
+        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 {
+            await this.doState.storage.setAlarm(Math.min(...nextTimes));
+        }
+    }
+    /**
+     * Reschedule alarms
+     */
+    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 {
+            await this.doState.storage.setAlarm(Math.min(...nextTimes));
+        }
+    }
+    /**
+     * Sync cron specs
+     */
+    async syncCronSpecs(cronSpecs) {
+        await this.cronExecutor.syncCronSpecs(cronSpecs);
+        await this.reschedule();
+    }
+    // =============================================================================
+    // DocStore RPC Methods - Direct delegation to _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);
+    }
+    /**
+     * Generators return arrays over RPC (cannot stream async generators)
+     */
+    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;
+    }
+    /**
+     * Generators return arrays over RPC (cannot stream async generators)
+     */
+    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());
+    }
+    // =============================================================================
+    // Blobstore RPC Methods - Prefixed to avoid collision with other methods
+    // =============================================================================
+    async blobstoreStore(buffer, options) {
+        if (!this._blobstore) {
+            throw new Error("Blobstore not configured");
+        }
+        return this._blobstore.store(buffer, options);
+    }
+    async blobstoreGet(storageId) {
+        if (!this._blobstore) {
+            throw new Error("Blobstore not configured");
+        }
+        const result = await this._blobstore.get(storageId);
+        if (result === null)
+            return null;
+        if (result instanceof Blob)
+            return result.arrayBuffer();
+        return result;
+    }
+    async blobstoreDelete(storageId) {
+        if (!this._blobstore) {
+            throw new Error("Blobstore not configured");
+        }
+        return this._blobstore.delete(storageId);
+    }
+    async blobstoreGetUrl(storageId) {
+        if (!this._blobstore) {
+            throw new Error("Blobstore not configured");
+        }
+        return this._blobstore.getUrl(storageId);
+    }
+    /**
+     * Notify SyncDO of writes for subscription invalidation
+     */
+    async notifySyncDo(writtenRanges, writtenTables, commitTimestamp) {
+        if (!writtenRanges?.length && !writtenTables?.length) {
+            return;
+        }
+        try {
+            const instanceName = this.doState.id.name ?? "singleton";
+            const syncNamespace = this.env?.SYNC_DO;
+            if (!syncNamespace) {
+                return;
+            }
+            const syncId = syncNamespace.idFromName(instanceName);
+            const syncStub = syncNamespace.get(syncId);
+            await syncStub.fetch("http://do/notify", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    writtenRanges,
+                    writtenTables,
+                    commitTimestamp: commitTimestamp ? commitTimestamp.toString() : undefined,
+                }),
+            });
+        }
+        catch (error) {
+            console.warn("Failed to notify SyncDO", error?.message ?? error);
+        }
+    }
+    /**
+     * 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;
+    }
+}