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

package/dist/http/dx-http.d.ts

@@ -0,0 +1,28 @@
+import type { DocStore, DocumentLogEntry, DatabaseIndexUpdate, InternalDocumentId, Interval, Order, TimestampRange, GlobalKey, DocumentPrevTsQuery, LatestDocument, IndexKeyBytes, type SearchIndexDefinition, type VectorIndexDefinition } from "@concavejs/core/docstore";
+import type { JSONValue as JsonValue } from "convex/values";
+export declare class HttpDocStore implements DocStore {
+    private readonly url;
+    constructor(url: string);
+    private post;
+    setupSchema(options?: {
+        searchIndexes?: SearchIndexDefinition[];
+        vectorIndexes?: VectorIndexDefinition[];
+    }): Promise<void>;
+    write(documents: DocumentLogEntry[], indexes: Set<{
+        ts: bigint;
+        update: DatabaseIndexUpdate;
+    }>, conflictStrategy: "Error" | "Overwrite"): Promise<void>;
+    index_scan(indexId: string, tabletId: string, readTimestamp: bigint, interval: Interval, order: Order): AsyncGenerator<[IndexKeyBytes, LatestDocument]>;
+    load_documents(range: TimestampRange, order: Order): AsyncGenerator<DocumentLogEntry>;
+    getGlobal(key: GlobalKey): Promise<JsonValue | null>;
+    writeGlobal(key: GlobalKey, value: JsonValue): Promise<void>;
+    previous_revisions(queries: Set<{
+        id: InternalDocumentId;
+        ts: bigint;
+    }>): Promise<Map<string, DocumentLogEntry>>;
+    previous_revisions_of_documents(queries: Set<DocumentPrevTsQuery>): Promise<Map<string, DocumentLogEntry>>;
+    get(id: InternalDocumentId, readTimestamp?: bigint): Promise<LatestDocument | null>;
+    count(table: string): Promise<number>;
+    scan(table: string, readTimestamp?: bigint): Promise<LatestDocument[]>;
+}
+export declare function handleRequest(docstore: DocStore, request: Request): Promise<Response>;

package/dist/http/dx-http.js

@@ -0,0 +1,306 @@
+// Serialization helpers
+function ab_to_hex(buffer) {
+    return [...new Uint8Array(buffer)].map((x) => x.toString(16).padStart(2, "0")).join("");
+}
+function hex_to_ab(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+        bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
+    }
+    return bytes.buffer;
+}
+// Custom JSON serialization to handle BigInt, ArrayBuffer, Map, and Set.
+function serialize(obj) {
+    return JSON.stringify(obj, (_key, value) => {
+        if (typeof value === "bigint") {
+            return { __type: "bigint", value: value.toString() };
+        }
+        if (value instanceof ArrayBuffer) {
+            return { __type: "ArrayBuffer", value: ab_to_hex(value) };
+        }
+        if (value instanceof Map) {
+            return { __type: "Map", value: Array.from(value.entries()) };
+        }
+        if (value instanceof Set) {
+            return { __type: "Set", value: Array.from(value) };
+        }
+        return value;
+    });
+}
+function deserialize(json) {
+    const reviver = (_key, value) => {
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+            if (value.__type === "bigint") {
+                return BigInt(value.value);
+            }
+            if (value.__type === "ArrayBuffer") {
+                return hex_to_ab(value.value);
+            }
+            if (value.__type === "Map") {
+                return new Map(value.value.map(([k, v]) => [reviver("", k), reviver("", v)]));
+            }
+            if (value.__type === "Set") {
+                return new Set(value.value.map((v) => reviver("", v)));
+            }
+        }
+        return value;
+    };
+    return JSON.parse(json, reviver);
+}
+// Client-side implementation of DocStore over HTTP
+export class HttpDocStore {
+    url;
+    constructor(url) {
+        this.url = url;
+    }
+    async post(path, body) {
+        const serializedBody = serialize(body);
+        return await fetch(`${this.url}/${path}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: serializedBody,
+        });
+    }
+    async setupSchema(options) {
+        const response = await this.post("setupSchema", options ?? {});
+        if (!response.ok) {
+            throw new Error(`setupSchema failed: ${await response.text()}`);
+        }
+    }
+    async write(documents, indexes, conflictStrategy) {
+        const response = await this.post("write", {
+            documents,
+            indexes,
+            conflictStrategy,
+        });
+        if (!response.ok) {
+            throw new Error(`write failed: ${await response.text()}`);
+        }
+    }
+    async *index_scan(indexId, tabletId, readTimestamp, interval, order) {
+        const response = await this.post("index_scan", {
+            indexId,
+            tabletId,
+            readTimestamp,
+            interval,
+            order,
+        });
+        if (!response.ok) {
+            throw new Error(`index_scan failed: ${await response.text()}`);
+        }
+        if (!response.body) {
+            return;
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop();
+            for (const line of lines) {
+                if (line.trim() === "")
+                    continue;
+                yield deserialize(line);
+            }
+        }
+        if (buffer.trim() !== "") {
+            yield deserialize(buffer);
+        }
+    }
+    async *load_documents(range, order) {
+        const response = await this.post("load_documents", { range, order });
+        if (!response.ok) {
+            throw new Error(`load_documents failed: ${await response.text()}`);
+        }
+        if (!response.body) {
+            return;
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop();
+            for (const line of lines) {
+                if (line.trim() === "")
+                    continue;
+                yield deserialize(line);
+            }
+        }
+        if (buffer.trim() !== "") {
+            yield deserialize(buffer);
+        }
+    }
+    async getGlobal(key) {
+        const response = await this.post("getGlobal", { key });
+        if (!response.ok) {
+            throw new Error(`getGlobal failed: ${await response.text()}`);
+        }
+        return deserialize(await response.text());
+    }
+    async writeGlobal(key, value) {
+        const response = await this.post("writeGlobal", { key, value });
+        if (!response.ok) {
+            throw new Error(`writeGlobal failed: ${await response.text()}`);
+        }
+    }
+    async previous_revisions(queries) {
+        const response = await this.post("previous_revisions", { queries });
+        if (!response.ok) {
+            throw new Error(`previous_revisions failed: ${await response.text()}`);
+        }
+        return deserialize(await response.text());
+    }
+    async previous_revisions_of_documents(queries) {
+        const response = await this.post("previous_revisions_of_documents", {
+            queries,
+        });
+        if (!response.ok) {
+            throw new Error(`previous_revisions_of_documents failed: ${await response.text()}`);
+        }
+        return deserialize(await response.text());
+    }
+    async get(id, readTimestamp) {
+        const response = await this.post("get", { id, readTimestamp });
+        if (!response.ok) {
+            throw new Error(`get failed: ${await response.text()}`);
+        }
+        return deserialize(await response.text());
+    }
+    async count(table) {
+        const response = await this.post("count", { table });
+        if (!response.ok) {
+            throw new Error(`count failed: ${await response.text()}`);
+        }
+        return deserialize(await response.text());
+    }
+    async scan(table, readTimestamp) {
+        const response = await this.post("scan", { table, readTimestamp });
+        if (!response.ok) {
+            throw new Error(`scan failed: ${await response.text()}`);
+        }
+        return deserialize(await response.text());
+    }
+}
+// Server-side request handler
+export async function handleRequest(docstore, request) {
+    const url = new URL(request.url);
+    const path = url.pathname.split("/").pop();
+    if (request.method !== "POST") {
+        return new Response("Method not allowed", { status: 405 });
+    }
+    try {
+        const body = await request.text();
+        const args = body ? deserialize(body) : {};
+        switch (path) {
+            case "setupSchema":
+                await docstore.setupSchema(args);
+                return new Response(null, { status: 200 });
+            case "write":
+                await docstore.write(args.documents, args.indexes, args.conflictStrategy);
+                return new Response(null, { status: 200 });
+            case "index_scan": {
+                const stream = new ReadableStream({
+                    async start(controller) {
+                        try {
+                            for await (const row of docstore.index_scan(args.indexId, args.tabletId, args.readTimestamp, args.interval, args.order)) {
+                                controller.enqueue(serialize(row) + "\n");
+                            }
+                            controller.close();
+                        }
+                        catch (e) {
+                            controller.error(e);
+                        }
+                    },
+                });
+                const encoder = new TextEncoder();
+                const encodedStream = stream.pipeThrough(new TransformStream({
+                    transform(chunk, controller) {
+                        controller.enqueue(encoder.encode(chunk));
+                    },
+                }));
+                return new Response(encodedStream, {
+                    headers: { "Content-Type": "application/x-ndjson" },
+                });
+            }
+            case "load_documents": {
+                const stream = new ReadableStream({
+                    async start(controller) {
+                        try {
+                            for await (const row of docstore.load_documents(args.range, args.order)) {
+                                controller.enqueue(serialize(row) + "\n");
+                            }
+                            controller.close();
+                        }
+                        catch (e) {
+                            controller.error(e);
+                        }
+                    },
+                });
+                const encoder = new TextEncoder();
+                const encodedStream = stream.pipeThrough(new TransformStream({
+                    transform(chunk, controller) {
+                        controller.enqueue(encoder.encode(chunk));
+                    },
+                }));
+                return new Response(encodedStream, {
+                    headers: { "Content-Type": "application/x-ndjson" },
+                });
+            }
+            case "getGlobal": {
+                const result = await docstore.getGlobal(args.key);
+                return new Response(serialize(result), {
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+            case "writeGlobal":
+                await docstore.writeGlobal(args.key, args.value);
+                return new Response(null, { status: 200 });
+            case "previous_revisions": {
+                const result = await docstore.previous_revisions(args.queries);
+                return new Response(serialize(result), {
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+            case "previous_revisions_of_documents": {
+                const result = await docstore.previous_revisions_of_documents(args.queries);
+                return new Response(serialize(result), {
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+            case "get": {
+                const result = await docstore.get(args.id, args.readTimestamp);
+                return new Response(serialize(result), {
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+            case "count": {
+                const result = await docstore.count(args.table);
+                return new Response(serialize(result), {
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+            case "scan": {
+                const result = await docstore.scan(args.table, args.readTimestamp);
+                return new Response(serialize(result), {
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+            default:
+                return new Response("Not Found", { status: 404 });
+        }
+    }
+    catch (e) {
+        return new Response(e.stack || e.toString(), { status: 500 });
+    }
+}

package/dist/http/http-api.d.ts

@@ -0,0 +1 @@
+export declare function handleHttpApiRequest(request: Request, env: Env, ctx: ExecutionContext, instance?: string): Promise<Response>;

package/dist/http/http-api.js

@@ -0,0 +1,262 @@
+import { ConcaveStubExecutor } from "../udf/executor/do-client-executor";
+import { createClientAdapter } from "@concavejs/core/udf/execution-adapter";
+import { loadConvexModule } from "@concavejs/core/udf";
+import { writtenTablesFromRanges } from "@concavejs/core/utils";
+import { applyCors, computeCorsHeaders, handleCoreHttpApiRequest, resolveAuthContext } from "@concavejs/core/http";
+import { AdminAuthError, identityFromToken, isAdminToken, isSystemToken, JWTValidationError, SystemAuthError, } from "@concavejs/core/auth";
+import { InternalFunctionAccessError } from "@concavejs/core/errors";
+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;
+    }
+    if (normalizedPath === "/api/http" || normalizedPath.startsWith("/api/http/")) {
+        return true;
+    }
+    if (normalizedPath === "/api/run" || normalizedPath.startsWith("/api/run/")) {
+        return true;
+    }
+    return false;
+}
+function shouldForwardApiPath(pathname) {
+    if (!pathname.startsWith("/api/")) {
+        return false;
+    }
+    return !isReservedApiPath(pathname);
+}
+/**
+ * Create a storage adapter that routes through the ConcaveDO's storage syscall handler.
+ * This ensures storage operations are properly isolated within the DO.
+ */
+function createStorageAdapter(concaveDO, _instance) {
+    return {
+        store: async (blob) => {
+            const buffer = await blob.arrayBuffer();
+            const base64 = btoa(String.fromCharCode(...new Uint8Array(buffer)));
+            const response = await concaveDO.fetch("http://do/storage", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    method: "store",
+                    args: [{ __arrayBuffer: base64 }, { contentType: blob.type }],
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                throw new Error(error?.error?.message ?? "Storage store failed");
+            }
+            const result = await response.json();
+            return {
+                storageId: result.result.storageId,
+                writtenRanges: [],
+                writtenTables: ["_storage"],
+            };
+        },
+        get: async (storageId) => {
+            const response = await concaveDO.fetch("http://do/storage", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    method: "get",
+                    args: [storageId],
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                throw new Error(error?.error?.message ?? "Storage get failed");
+            }
+            const result = await response.json();
+            if (!result.result || !result.result.__arrayBuffer) {
+                return { blob: null };
+            }
+            const binary = atob(result.result.__arrayBuffer);
+            const bytes = new Uint8Array(binary.length);
+            for (let i = 0; i < binary.length; i++) {
+                bytes[i] = binary.charCodeAt(i);
+            }
+            return { blob: new Blob([bytes.buffer]) };
+        },
+    };
+}
+function createNotifyWrites(env, instance, ctx) {
+    return async (writtenRanges, writtenTables, commitTimestamp) => {
+        if (!writtenRanges?.length && !writtenTables?.length) {
+            return;
+        }
+        const syncDoId = env.SYNC_DO.idFromName(instance);
+        const syncDo = env.SYNC_DO.get(syncDoId);
+        const payload = {
+            writtenRanges,
+            writtenTables: writtenTables ?? writtenTablesFromRanges(writtenRanges),
+            commitTimestamp: commitTimestamp ? commitTimestamp.toString() : undefined,
+        };
+        ctx.waitUntil(syncDo.fetch("http://do/notify", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+        }));
+    };
+}
+export async function handleHttpApiRequest(request, env, ctx, instance = "singleton") {
+    const corsHeaders = computeCorsHeaders(request);
+    const apply = (response) => applyCors(response, corsHeaders);
+    const url = new URL(request.url);
+    const pathParts = url.pathname.slice(1).split("/");
+    if (pathParts[0] !== "api") {
+        return apply(new Response("Not found", { status: 404 }));
+    }
+    console.log(`[handleHttpApiRequest] instance=${instance}`);
+    const concaveId = env.CONCAVE_DO.idFromName(instance);
+    const concave = env.CONCAVE_DO.get(concaveId);
+    const executor = new ConcaveStubExecutor(concave);
+    const adapter = createClientAdapter(executor);
+    const notifyWrites = createNotifyWrites(env, instance, ctx);
+    // Route storage operations through the DO's storage syscall handler
+    const storageAdapter = createStorageAdapter(concave, instance);
+    const authHeader = request.headers.get("Authorization");
+    const headerToken = authHeader?.replace(/^Bearer\s+/i, "").trim() || undefined;
+    let headerIdentity;
+    try {
+        headerIdentity =
+            headerToken && !isAdminToken(headerToken) && !isSystemToken(headerToken)
+                ? await identityFromToken(headerToken)
+                : undefined;
+    }
+    catch (error) {
+        if (error instanceof JWTValidationError || error instanceof AdminAuthError || error instanceof SystemAuthError) {
+            return apply(Response.json({ error: "Unauthorized" }, { status: 401 }));
+        }
+        throw error;
+    }
+    // Note: Internal function access control is now handled by core executor (fail-closed)
+    const coreResult = await handleCoreHttpApiRequest(request, {
+        executeFunction: async ({ type, path, args, auth, componentPath }) => adapter.executeUdf(path, args, type, auth, componentPath),
+        notifyWrites,
+        storage: storageAdapter,
+        corsHeaders,
+    });
+    if (coreResult?.handled) {
+        return coreResult.response;
+    }
+    // Handle /api/http/*
+    if (pathParts.length >= 2 && pathParts[1] === "http") {
+        const forwardUrl = new URL(request.url);
+        const forwardedRequest = new Request(forwardUrl.toString(), request);
+        const response = await concave.fetch(forwardedRequest);
+        return apply(response);
+    }
+    // Handle /api/run/{functionIdentifier}
+    if (pathParts.length > 2 && pathParts[1] === "run") {
+        const functionIdentifier = pathParts.slice(2).join("/");
+        const udfPath = functionIdentifier.replace(/\//g, ":");
+        let bodyArgs = {};
+        if (request.headers.get("Content-Type")?.includes("application/json") && request.body) {
+            try {
+                const body = await request.clone().json();
+                if (body.args && typeof body.args === "object") {
+                    bodyArgs = body.args;
+                }
+            }
+            catch (_error) {
+                // Ignore parse errors
+            }
+        }
+        const queryArgs = {};
+        for (const [key, value] of url.searchParams.entries()) {
+            try {
+                queryArgs[key] = JSON.parse(value);
+            }
+            catch {
+                queryArgs[key] = value;
+            }
+        }
+        const mergedArgs = { ...queryArgs, ...bodyArgs };
+        let authForExecution;
+        try {
+            authForExecution = await resolveAuthContext(undefined, headerToken, headerIdentity);
+        }
+        catch (error) {
+            if (error instanceof JWTValidationError || error instanceof AdminAuthError) {
+                return apply(Response.json({ error: "Unauthorized" }, { status: 401 }));
+            }
+            throw error;
+        }
+        try {
+            const modulePath = udfPath.split(":")[0];
+            const functionName = udfPath.split(":")[1] ?? "default";
+            const module = await loadConvexModule(modulePath, { hint: "udf" });
+            const func = module[functionName];
+            if (!func) {
+                return apply(new Response(`Function ${udfPath} not found`, { status: 404 }));
+            }
+            // Note: Internal function access control is now handled by core executor (fail-closed)
+            let udfType = null;
+            if (func.isQuery)
+                udfType = "query";
+            else if (func.isMutation)
+                udfType = "mutation";
+            else if (func.isAction)
+                udfType = "action";
+            if (!udfType) {
+                console.error(`Function ${udfPath} is not a valid query, mutation, or action.`);
+                return apply(new Response(`Function ${udfPath} is not a valid query, mutation, or action.`, {
+                    status: 400,
+                }));
+            }
+            const result = await adapter.executeUdf(udfPath, mergedArgs, udfType, authForExecution);
+            if ((udfType === "mutation" || udfType === "action") && result.writtenRanges?.length) {
+                await notifyWrites(result.writtenRanges, result.writtenTables);
+            }
+            return apply(Response.json({
+                status: "success",
+                value: result.result,
+                logLines: [],
+            }));
+        }
+        catch (error) {
+            // Handle internal function access errors with 403
+            if (error instanceof InternalFunctionAccessError) {
+                return apply(Response.json({
+                    status: "error",
+                    errorMessage: error.message,
+                }, { status: 403 }));
+            }
+            if (typeof error?.message === "string") {
+                const message = error.message.toLowerCase();
+                if (message.includes("module not found") ||
+                    message.includes("failed to load convex module") ||
+                    message.includes("unable to resolve module")) {
+                    return apply(new Response(`Module for function ${udfPath} not found.`, {
+                        status: 404,
+                    }));
+                }
+            }
+            if (error instanceof Response) {
+                return apply(error);
+            }
+            return apply(new Response(`Error determining function type: ${error?.message ?? String(error)}`, {
+                status: 500,
+            }));
+        }
+    }
+    if (shouldForwardApiPath(url.pathname)) {
+        const forwardUrl = new URL(request.url);
+        forwardUrl.pathname = stripApiVersionPrefix(forwardUrl.pathname);
+        const forwardedRequest = new Request(forwardUrl.toString(), request);
+        const response = await concave.fetch(forwardedRequest);
+        return apply(response);
+    }
+    return apply(new Response("Not found", { status: 404 }));
+}

package/dist/http/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * HTTP Module
+ *
+ * HTTP API handlers and request processing
+ */
+export * from "./http-api";
+export * from "./dx-http";

package/dist/http/index.js

@@ -0,0 +1,7 @@
+/**
+ * HTTP Module
+ *
+ * HTTP API handlers and request processing
+ */
+export * from "./http-api";
+export * from "./dx-http";

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export * from "@concavejs/core";
+export { UdfExecutorRpc } from "./worker/udf-worker";
+export { createConcaveWorker, resolveNamespaceBinding, createScopedNamespace, type ConcaveWorkerOptions, type ConcaveWorkerBindings, type ConcaveWorker, } from "./worker/create-concave-worker";
+export { DEFAULT_INSTANCE_KEY, DEFAULT_INSTANCE_VALUE, DEFAULT_INSTANCE_COOKIE_PATH, resolveInstanceFromRequest, maybeAttachInstanceCookie, readCookieValue, buildInstanceCookie, type InstanceResolution, type InstanceResolutionOptions, type InstanceCookieOptions, } from "./routing/instance";
+export { UdfExecInline } from "./udf/executor/inline-executor";
+export { UdfExecIsolated } from "./udf/executor/isolated-executor";
+export { ConcaveDOBase, type ConcaveDOConfig, type ConcaveDOAdapterContext, type ConcaveDOExecutorContext, } from "./durable-objects/concave-do-base";
+export { createDocStoreProxy, createBlobStoreProxy, createGatewayDocStoreProxy, createGatewayBlobStoreProxy, } from "./rpc";
+export { CFWebSocketAdapter } from "./adapters/cf-websocket-adapter";
+export { CFWebSocketAdapter as SyncWebSocketAdapter } from "./sync/cf-websocket-adapter";
+export { ConcaveDOUdfExecutor } from "./sync/concave-do-udf-executor";
+export { SHIM_SOURCE } from "./udf/executor/shim-content";
+export { DODocStore } from "@concavejs/docstore-cf-do";
+export { D1DocStore } from "@concavejs/docstore-cf-d1";
+export { R2BlobStore } from "@concavejs/blobstore-cf-r2";

package/dist/index.js

@@ -0,0 +1,25 @@
+// Re-export core functionality
+export * from "@concavejs/core";
+// Export Cloudflare Workers utilities
+export { UdfExecutorRpc } from "./worker/udf-worker";
+export { createConcaveWorker, resolveNamespaceBinding, createScopedNamespace, } from "./worker/create-concave-worker";
+// Export instance routing helpers
+export { DEFAULT_INSTANCE_KEY, DEFAULT_INSTANCE_VALUE, DEFAULT_INSTANCE_COOKIE_PATH, resolveInstanceFromRequest, maybeAttachInstanceCookie, readCookieValue, buildInstanceCookie, } from "./routing/instance";
+// Export UDF executors
+export { UdfExecInline } from "./udf/executor/inline-executor";
+export { UdfExecIsolated } from "./udf/executor/isolated-executor";
+// Export Durable Object base classes
+export { ConcaveDOBase, } from "./durable-objects/concave-do-base";
+// Export RPC proxy utilities
+export { createDocStoreProxy, createBlobStoreProxy, createGatewayDocStoreProxy, createGatewayBlobStoreProxy, } from "./rpc";
+// Export CF-specific adapters
+export { CFWebSocketAdapter } from "./adapters/cf-websocket-adapter";
+// Export sync protocol adapters
+export { CFWebSocketAdapter as SyncWebSocketAdapter } from "./sync/cf-websocket-adapter";
+export { ConcaveDOUdfExecutor } from "./sync/concave-do-udf-executor";
+// Export embedded shim source
+export { SHIM_SOURCE } from "./udf/executor/shim-content";
+// Export CF-specific DocStore implementations
+export { DODocStore } from "@concavejs/docstore-cf-do";
+export { D1DocStore } from "@concavejs/docstore-cf-d1";
+export { R2BlobStore } from "@concavejs/blobstore-cf-r2";

package/dist/internal.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Internal exports re-exported from core
+ */
+export * from "@concavejs/core/system/internal";

package/dist/internal.js

@@ -0,0 +1,4 @@
+/**
+ * Internal exports re-exported from core
+ */
+export * from "@concavejs/core/system/internal";