effect-cf 0.35.0 → 0.37.0

package/dist/Mcp.mjs

@@ -0,0 +1,270 @@
+import { r as runNativeCallback } from "./WorkerContext-Yobnfw-K.mjs";
+import { n as NativeRequest } from "./Worker-XsGJsCJX.mjs";
+import { Cause, Context, Effect, Exit, Option, Predicate, Schema, Sink, Stream } from "effect";
+import { McpServer, createMcpHandler, hostHeaderValidationResponse, localhostAllowedHostnames, localhostAllowedOrigins, originValidationResponse } from "@modelcontextprotocol/server";
+import { AiError, Tool } from "effect/unstable/ai";
+//#region src/Mcp.ts
+const DEFAULT_CORS_OPTIONS = {
+	origin: "*",
+	headers: "Content-Type, Accept, Authorization, mcp-session-id, MCP-Protocol-Version, Mcp-Method, Mcp-Name",
+	methods: "GET, POST, DELETE, OPTIONS",
+	exposeHeaders: "mcp-session-id",
+	maxAge: 86400
+};
+const corsHeaders = (options) => {
+	const merged = {
+		...DEFAULT_CORS_OPTIONS,
+		...options
+	};
+	return new Headers({
+		"Access-Control-Allow-Headers": merged.headers,
+		"Access-Control-Allow-Methods": merged.methods,
+		"Access-Control-Allow-Origin": merged.origin,
+		"Access-Control-Expose-Headers": merged.exposeHeaders,
+		"Access-Control-Max-Age": String(merged.maxAge)
+	});
+};
+const withCors = (response, options) => {
+	if (options === false) return response;
+	const headers = new Headers(response.headers);
+	for (const [headerName, value] of corsHeaders(options ?? {})) headers.set(headerName, value);
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+};
+const corsOriginHostname = (corsOptions) => {
+	const origin = corsOptions === false ? void 0 : corsOptions?.origin;
+	if (origin === void 0 || !URL.canParse(origin)) return;
+	const url = new URL(origin);
+	return (url.protocol === "http:" || url.protocol === "https:") && url.hostname !== "" ? url.hostname : void 0;
+};
+/**
+* `Host` and `Origin` validation for the MCP route, using the MCP SDK's
+* validation primitives with the same defaults Cloudflare applies: localhost
+* and `workers.dev` endpoints validate the `Host` header against themselves,
+* and present browser `Origin` headers must match localhost-class Origins, the
+* endpoint's `workers.dev` hostname, or a concrete configured CORS origin.
+*/
+const edgeGuardResponse = (request, requestUrl, options) => {
+	const localEndpoint = localhostAllowedHostnames().includes(requestUrl.hostname);
+	const workersDevEndpoint = requestUrl.hostname.endsWith(".workers.dev");
+	const acceptedHostnames = options.allowedHostnames ?? (localEndpoint ? localhostAllowedHostnames() : workersDevEndpoint ? [requestUrl.hostname] : void 0);
+	if (acceptedHostnames !== void 0) {
+		const hostRejection = hostHeaderValidationResponse(request, [...acceptedHostnames]);
+		if (hostRejection !== void 0) return hostRejection;
+	}
+	if (options.allowedOriginHostnames === "*") return;
+	let acceptedOriginHostnames = options.allowedOriginHostnames;
+	if (acceptedOriginHostnames === void 0) {
+		const defaults = new Set(localhostAllowedOrigins());
+		if (workersDevEndpoint) defaults.add(requestUrl.hostname);
+		const configuredOriginHostname = corsOriginHostname(options.corsOptions);
+		if (configuredOriginHostname !== void 0) defaults.add(configuredOriginHostname);
+		acceptedOriginHostnames = [...defaults];
+	}
+	return originValidationResponse(request, [...acceptedOriginHostnames]);
+};
+const INTERNAL_TOOL_ERROR_MESSAGE = "Tool execution failed due to an internal server error.";
+const toolErrorResult = (message) => ({
+	isError: true,
+	content: [{
+		type: "text",
+		text: message
+	}]
+});
+/**
+* Wraps a JSON Schema produced by Effect `Schema` as the Standard Schema shape
+* accepted by MCP SDK v2 `registerTool`, with a passthrough `validate`.
+*
+* Used for output schemas and for dynamic tools whose parameters are already a
+* JSON Schema: the toolkit performs its own decoding, so there is nothing
+* additional to validate here.
+*/
+const standardSchemaFromJsonSchema = (jsonSchema) => ({ "~standard": {
+	version: 1,
+	vendor: "effect-cf",
+	validate: (value) => ({ value }),
+	jsonSchema: {
+		input: () => jsonSchema,
+		output: () => jsonSchema
+	}
+} });
+/**
+* Builds the tool input schema registered with the MCP SDK.
+*
+* The SDK validates incoming `tools/call` arguments with `~standard.validate`
+* and answers validation failures with an MCP invalid-params error, so the
+* tool's Effect parameters `Schema` backs `validate`. On success the original
+* encoded arguments are kept: the toolkit decodes them itself when the tool
+* handler executes.
+*/
+const standardInputSchema = (tool) => {
+	const jsonSchema = Tool.getJsonSchema(tool);
+	if (!Schema.isSchema(tool.parametersSchema)) return standardSchemaFromJsonSchema(jsonSchema);
+	const parametersSchema = tool.parametersSchema;
+	const validate = Schema.toStandardSchemaV1(parametersSchema)["~standard"].validate;
+	return { "~standard": {
+		version: 1,
+		vendor: "effect-cf",
+		validate: (value) => {
+			const result = validate(value);
+			if (result instanceof Promise) return result.then((awaited) => awaited.issues === void 0 ? { value } : awaited);
+			return result.issues === void 0 ? { value } : result;
+		},
+		jsonSchema: {
+			input: () => jsonSchema,
+			output: () => jsonSchema
+		}
+	} };
+};
+const handleToolCall = (built, tool, params) => {
+	const isDeclaredFailure = Schema.is(tool.failureSchema);
+	return built.handle(tool.name, params).pipe(Stream.unwrap, Stream.run(Sink.last()), Effect.flatMap(Effect.fromOption), Effect.map((result) => {
+		if (result.isFailure) return toolErrorResult(JSON.stringify(result.encodedResult));
+		const structuredContent = Predicate.isObject(result.encodedResult) ? result.encodedResult : void 0;
+		const content = result.encodedResult === void 0 ? [] : [{
+			type: "text",
+			text: JSON.stringify(result.encodedResult)
+		}];
+		if (structuredContent === void 0) return {
+			isError: false,
+			content
+		};
+		return {
+			isError: false,
+			structuredContent,
+			content
+		};
+	}), Effect.tapCause(Effect.logError), Effect.catch((error) => {
+		if (AiError.isAiError(error)) {
+			const reason = error.reason;
+			return Effect.succeed(toolErrorResult(reason._tag === "ToolParameterValidationError" ? reason.message : INTERNAL_TOOL_ERROR_MESSAGE));
+		}
+		if (isDeclaredFailure(error)) {
+			const message = error instanceof Error ? error.message : INTERNAL_TOOL_ERROR_MESSAGE;
+			return Effect.succeed(toolErrorResult(message));
+		}
+		return Effect.succeed(toolErrorResult(INTERNAL_TOOL_ERROR_MESSAGE));
+	}), Effect.catchDefect(() => Effect.succeed(toolErrorResult(INTERNAL_TOOL_ERROR_MESSAGE))));
+};
+const registerToolkitTool = (server, built, tool, run) => {
+	const outputJsonSchema = Tool.getJsonSchemaFromSchema(tool.successSchema);
+	const outputSchema = outputJsonSchema.type === "object" ? standardSchemaFromJsonSchema(outputJsonSchema) : void 0;
+	const title = Context.getOrUndefined(tool.annotations, Tool.Title);
+	const toolMeta = Context.getOrUndefined(tool.annotations, Tool.Meta);
+	server.registerTool(tool.name, {
+		title,
+		description: Tool.getDescription(tool),
+		inputSchema: standardInputSchema(tool),
+		outputSchema,
+		annotations: {
+			title,
+			readOnlyHint: Context.get(tool.annotations, Tool.Readonly),
+			destructiveHint: Context.get(tool.annotations, Tool.Destructive),
+			idempotentHint: Context.get(tool.annotations, Tool.Idempotent),
+			openWorldHint: Context.get(tool.annotations, Tool.OpenWorld)
+		},
+		_meta: toolMeta
+	}, async (args) => {
+		const exit = await run(handleToolCall(built, tool, args ?? {}));
+		if (Exit.isSuccess(exit)) return exit.value;
+		throw Cause.squash(exit.cause);
+	});
+};
+/**
+* Creates an Effect that serves a toolkit over MCP with the MCP SDK's
+* stateless Streamable HTTP handler (`createMcpHandler` from
+* `@modelcontextprotocol/server`), plus the Worker edge concerns Cloudflare's
+* remote MCP deployments expect: CORS, `Host` header validation, and browser
+* `Origin` validation.
+*
+* **Details**
+*
+* Yield the returned Effect inside a `Worker.make` fetch handler before other
+* routing. When the request pathname matches `route` (default `"/mcp"`), the
+* request is served by a fresh MCP server exposing every tool in the toolkit
+* and the Effect succeeds with `Option.some(response)`. Any other pathname
+* succeeds with `Option.none()` so the request can fall through to the rest of
+* the fetch handler.
+*
+* Tool calls run through the caller's Effect context: provide the toolkit
+* handlers (`toolkit.toLayer(...)`) and their services in the Worker layer or
+* event layer. Tool parameters are decoded and results encoded with each
+* tool's Effect `Schema`; parameter validation failures become MCP
+* invalid-params errors, declared tool failures become tool results with
+* `isError: true`, and unexpected errors are logged and reported to the client
+* as an internal tool error.
+*
+* In-flight tool calls are awaited before the HTTP response is returned, so
+* tool handlers always run to completion inside the fetch event, including on
+* transport lanes that stream results into the response body.
+*
+* **Example**
+*
+* ```ts
+* import { Effect, Layer, Option } from "effect"
+* import { HttpRouter } from "effect/unstable/http"
+* import { Worker } from "effect-cf"
+* import * as Mcp from "effect-cf/mcp"
+*
+* const mcp = Mcp.fromToolkit(ActivityToolkit, {
+*   name: "strava-ingestor",
+*   version: "1.0.0",
+*   route: "/mcp",
+* })
+*
+* const fetch = Effect.gen(function* () {
+*   const response = yield* mcp
+*   if (Option.isSome(response)) return response.value
+*   const router = yield* HttpRouter.HttpRouter
+*   return yield* router.asHttpEffect()
+* })
+*
+* export default Worker.make(
+*   Layer.mergeAll(ApplicationLive, ActivityToolkitLive),
+*   { fetch },
+* )
+* ```
+*/
+const fromToolkit = (toolkit, options) => {
+	const { name, version, title, serverOptions, route = "/mcp", corsOptions, allowedHostnames, allowedOriginHostnames, ...handlerOptions } = options;
+	const serverInfo = {
+		name,
+		version,
+		title
+	};
+	return Effect.gen(function* () {
+		const request = yield* NativeRequest;
+		const requestUrl = new URL(request.url);
+		if (requestUrl.pathname !== route) return Option.none();
+		const rejection = edgeGuardResponse(request, requestUrl, {
+			corsOptions,
+			allowedHostnames,
+			allowedOriginHostnames
+		});
+		if (rejection !== void 0) return Option.some(withCors(rejection, corsOptions));
+		if (request.method === "OPTIONS" && corsOptions !== false) return Option.some(new Response(null, { headers: corsHeaders(corsOptions ?? {}) }));
+		const built = yield* toolkit;
+		const response = yield* runNativeCallback(async (run) => {
+			const pending = /* @__PURE__ */ new Set();
+			const trackedRun = (effect) => {
+				const promise = run(effect);
+				pending.add(promise);
+				promise.finally(() => pending.delete(promise));
+				return promise;
+			};
+			const response = await createMcpHandler(() => {
+				const server = new McpServer(serverInfo, serverOptions);
+				for (const tool of Object.values(built.tools)) registerToolkitTool(server, built, tool, trackedRun);
+				return server;
+			}, handlerOptions).fetch(request);
+			while (pending.size > 0) await Promise.allSettled([...pending]);
+			return response;
+		});
+		return Option.some(withCors(response, corsOptions));
+	});
+};
+//#endregion
+export { fromToolkit };

package/dist/Vitest.d.mts

@@ -1,6 +1,6 @@
 import { c as WorkerEnvironment, s as WorkerEnv } from "./Binding-DKcLrQCM.mjs";
-import { n as DurableObjectStateService, t as DurableObjectState } from "./DurableObjectState-DpYdNZgT.mjs";
-import { o as WorkflowInstanceStatusName } from "./WorkflowBinding-Cn3AuUyP.mjs";
+import { n as DurableObjectStateService, t as DurableObjectState } from "./DurableObjectState-CpgAmFqo.mjs";
+import { o as WorkflowInstanceStatusName } from "./WorkflowBinding-CvJT9hB5.mjs";
 import { Effect, Layer, Schema } from "effect";
 import { DurableObject } from "cloudflare:workers";
 import { adminSecretsStore as adminSecretsStore$1, getQueueResult, introspectWorkflow as introspectWorkflow$1, introspectWorkflowInstance as introspectWorkflowInstance$1 } from "cloudflare:test";

package/dist/Vitest.mjs

@@ -1,5 +1,6 @@
 import { a as WorkerEnvironment, i as WorkerConfig } from "./ErrorMessage-Byx2OgNd.mjs";
-import { l as runNativeCallback, r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-DcqElJ4e.mjs";
+import { r as runNativeCallback } from "./WorkerContext-Yobnfw-K.mjs";
+import { r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-DLL0YgBd.mjs";
 import { ConfigProvider, Effect, Exit, Layer } from "effect";
 import { env } from "cloudflare:workers";
 import { abortAllDurableObjects as abortAllDurableObjects$1, adminSecretsStore as adminSecretsStore$1, applyD1Migrations as applyD1Migrations$1, createExecutionContext, createMessageBatch, createPagesEventContext, createScheduledController, evictAllDurableObjects as evictAllDurableObjects$1, evictDurableObject as evictDurableObject$1, getQueueResult, introspectWorkflow as introspectWorkflow$1, introspectWorkflowInstance as introspectWorkflowInstance$1, listDurableObjectIds as listDurableObjectIds$1, reset as reset$1, runDurableObjectAlarm as runDurableObjectAlarm$1, runInDurableObject as runInDurableObject$1, waitOnExecutionContext } from "cloudflare:test";

package/dist/{DurableObjectState-DpYdNZgT.d.mts → Worker-Dl6_Pijl.d.mts}

@@ -1,189 +1,7 @@
 import { c as WorkerEnvironment, n as BindingService, r as BindingValidationError, s as WorkerEnv, t as BindingNotFoundError } from "./Binding-DKcLrQCM.mjs";
-import { Cause, Context, Duration, Effect, Layer, Option, Predicate, Schema, Scope, Tracer } from "effect";
+import { Cause, Context, Effect, Layer, Predicate, Schema, Scope, Tracer } from "effect";
 import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import { RpcStub, RpcTarget, WorkerEntrypoint } from "cloudflare:workers";
-declare namespace DurableObjectStorage_d_exports {
-  export { DurableObjectStorage, DurableObjectTransaction, SchemaBackedSyncKvStorage, SqlCursor, SqlStorage, SqlStorageValue, StorageOperationError, SyncKvDefinition, SyncKvStorage, fromDurableObjectStorage };
-}
-type SqlStorageValue = globalThis.SqlStorageValue;
-declare const StorageOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
-  readonly _tag: "StorageOperationError";
-} & Readonly<A>;
-declare class StorageOperationError extends StorageOperationError_base<{
-  readonly operation: string;
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-type StorageEffect<A> = Effect.Effect<A, StorageOperationError>;
-interface SqlCursor<T extends Record<string, SqlStorageValue>> {
-  next(): StorageEffect<{
-    done?: false;
-    value: T;
-  } | {
-    done: true;
-    value?: never;
-  }>;
-  toArray(): StorageEffect<Array<T>>;
-  one(): StorageEffect<T>;
-  raw<U extends Array<SqlStorageValue>>(): StorageEffect<IterableIterator<U>>;
-  readonly columnNames: Array<string>;
-  readonly rowsRead: StorageEffect<number>;
-  readonly rowsWritten: StorageEffect<number>;
-}
-interface SqlStorage {
-  exec<T extends Record<string, SqlStorageValue>>(query: string, ...bindings: Array<SqlStorageValue>): StorageEffect<SqlCursor<T>>;
-  readonly databaseSize: number;
-}
-interface SyncKvDefinition<Key, Value, EncodedValue> {
-  readonly key: Schema.Codec<Key, string>;
-  readonly value: Schema.Codec<Value, EncodedValue>;
-}
-/**
- * Sync KV wrapper that transparently encodes keys/values through Effect Schema.
- */
-interface SchemaBackedSyncKvStorage<Key, Value> {
-  get(key: Key): Effect.Effect<Option.Option<Value>, unknown>;
-  put(key: Key, value: Value): Effect.Effect<void, unknown>;
-  delete(key: Key): Effect.Effect<boolean, unknown>;
-  list(options?: globalThis.SyncKvListOptions): Effect.Effect<Array<[Key, Value]>, unknown>;
-}
-interface SyncKvStorage {
-  get<T = unknown>(key: string): StorageEffect<T | undefined>;
-  put<T>(key: string, value: T): StorageEffect<void>;
-  delete(key: string): StorageEffect<boolean>;
-  list<T = unknown>(options?: globalThis.SyncKvListOptions): StorageEffect<Array<[string, T]>>;
-  schema<Key, Value, EncodedValue>(definition: SyncKvDefinition<Key, Value, EncodedValue>): SchemaBackedSyncKvStorage<Key, Value>;
-}
-/**
- * Effect wrapper around Cloudflare transaction callbacks.
- */
-interface DurableObjectTransaction {
-  get<T = unknown>(key: string, options?: globalThis.DurableObjectGetOptions): StorageEffect<T | undefined>;
-  get<T = unknown>(keys: Array<string>, options?: globalThis.DurableObjectGetOptions): StorageEffect<Map<string, T>>;
-  list<T = unknown>(options?: globalThis.DurableObjectListOptions): StorageEffect<Map<string, T>>;
-  put<T>(key: string, value: T, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
-  put<T>(entries: Record<string, T>, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
-  delete(key: string, options?: globalThis.DurableObjectPutOptions): StorageEffect<boolean>;
-  delete(keys: Array<string>, options?: globalThis.DurableObjectPutOptions): StorageEffect<number>;
-  rollback(): StorageEffect<void>;
-  getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
-  setAlarm(scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-  setAlarmAfter(delay: Duration.Input, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-  deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-}
-interface DurableObjectStorage {
-  get<T = unknown>(key: string, options?: globalThis.DurableObjectGetOptions): StorageEffect<T | undefined>;
-  put<T>(key: string, value: T, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
-  delete(key: string, options?: globalThis.DurableObjectPutOptions): StorageEffect<boolean>;
-  /**
-   * Deletes all stored data. On compatibility dates before 2026-02-24, Cloudflare
-   * documents that active alarms must be deleted separately with `deleteAlarm()`.
-   */
-  deleteAll(options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
-  getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
-  setAlarm(scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-  setAlarmAfter(delay: Duration.Input, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-  deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
-  /**
-   * SQLite-backed Durable Object storage only.
-   *
-   * The callback Effect must complete synchronously. If it requires asynchronous
-   * work, use `transaction` instead so Cloudflare can run the async transaction
-   * callback under the platform's transaction contract.
-   */
-  transactionSync<A, E, R>(closure: () => Effect.Effect<A, E, R>): Effect.Effect<A, E | StorageOperationError, R>;
-  /**
-   * Runs an async transaction and exposes a typed transaction wrapper.
-   */
-  transaction<A, E, R>(closure: (txn: DurableObjectTransaction) => Effect.Effect<A, E, R>): Effect.Effect<A, E | StorageOperationError, R>;
-  /** Flushes pending writes to disk. */
-  sync(): StorageEffect<void>;
-  /** Requires SQLite-backed Durable Object storage. */
-  getCurrentBookmark(): StorageEffect<string>;
-  /** Requires SQLite-backed Durable Object storage. */
-  onNextSessionRestoreBookmark(bookmark: string): StorageEffect<string>;
-  readonly sql: SqlStorage;
-  readonly kv: SyncKvStorage;
-}
-declare const fromDurableObjectStorage: (storage: globalThis.DurableObjectStorage) => DurableObjectStorage;
-declare namespace DurableObjectWebSocket_d_exports {
-  export { AcceptUpgradeOptions, AcceptedUpgrade, AttachmentInvalidPolicy, AttachmentRehydrateOptions, DurableWebSocket, DurableWebSocketAttachment, DurableWebSocketAttachmentError, DurableWebSocketCloseError, DurableWebSocketHandlers, DurableWebSocketSendData, DurableWebSocketSendError, RehydratedDurableWebSocket, acceptUpgrade, attachment, fromWebSocket, handlers };
-}
-type DurableWebSocketSendData = string | ArrayBuffer | ArrayBufferView;
-declare const DurableWebSocketSendError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "DurableWebSocketSendError";
-} & Readonly<A>;
-declare class DurableWebSocketSendError extends DurableWebSocketSendError_base<{
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-declare const DurableWebSocketCloseError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "DurableWebSocketCloseError";
-} & Readonly<A>;
-declare class DurableWebSocketCloseError extends DurableWebSocketCloseError_base<{
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-declare const DurableWebSocketAttachmentError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-  readonly _tag: "DurableWebSocketAttachmentError";
-} & Readonly<A>;
-/** Error raised when serializing or deserializing a websocket attachment fails. */
-declare class DurableWebSocketAttachmentError extends DurableWebSocketAttachmentError_base<{
-  readonly operation: "serialize" | "deserialize";
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-interface DurableWebSocket<Attachment = unknown> {
-  readonly raw: WebSocket;
-  send(data: DurableWebSocketSendData): Effect.Effect<void, DurableWebSocketSendError>;
-  close(code?: number, reason?: string): Effect.Effect<void, DurableWebSocketCloseError>;
-  /** Serializes hibernation attachment metadata onto the socket. */
-  serializeAttachment<A extends Attachment = Attachment>(value: A): Effect.Effect<void, DurableWebSocketAttachmentError>;
-  /** Deserializes hibernation attachment metadata from the socket. */
-  readonly deserializeAttachment: Effect.Effect<unknown, DurableWebSocketAttachmentError>;
-}
-declare const fromWebSocket: <Attachment = unknown>(raw: WebSocket) => DurableWebSocket<Attachment>;
-interface AcceptUpgradeOptions<Attachment = unknown> {
-  readonly tags?: ReadonlyArray<string> | undefined;
-  /** Optional attachment serialized onto the server socket. */
-  readonly attachment?: Attachment | undefined;
-}
-interface AcceptedUpgrade<Attachment = unknown> {
-  readonly client: WebSocket;
-  readonly server: DurableWebSocket<Attachment>;
-  readonly response: Response;
-}
-declare const acceptUpgrade: <Attachment = unknown>(options?: AcceptUpgradeOptions<Attachment> | undefined) => Effect.Effect<AcceptedUpgrade<Attachment>, DurableWebSocketAttachmentError, DurableObjectState>;
-type AttachmentInvalidPolicy = "ignore" | "ignore-and-close" | "fail";
-interface AttachmentRehydrateOptions {
-  readonly tag?: string | undefined;
-  readonly onInvalid?: AttachmentInvalidPolicy | undefined;
-}
-interface RehydratedDurableWebSocket<Attachment> {
-  readonly socket: DurableWebSocket<Attachment>;
-  readonly attachment: Attachment;
-}
-interface DurableWebSocketAttachment<Attachment, Encoded> {
-  serialize(socket: DurableWebSocket<unknown>, value: Attachment): Effect.Effect<void, DurableWebSocketAttachmentError>;
-  deserialize(socket: DurableWebSocket<unknown>): Effect.Effect<Option.Option<Attachment>, DurableWebSocketAttachmentError>;
-  rehydrate(options?: AttachmentRehydrateOptions): Effect.Effect<Array<RehydratedDurableWebSocket<Attachment>>, DurableWebSocketAttachmentError, DurableObjectState>;
-  readonly schema: Schema.Codec<Attachment, Encoded, never, never>;
-}
-declare const attachment: <const AttachmentSchema extends Schema.Codec<any, any, never, never>>(schema: AttachmentSchema) => DurableWebSocketAttachment<Schema.Schema.Type<AttachmentSchema>, Schema.Codec.Encoded<AttachmentSchema>>;
-interface DurableWebSocketHandlers<R = never, E = unknown> {
-  readonly message?: (socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, E, R>;
-  readonly close?: (socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, E, R>;
-  readonly error?: (socket: DurableWebSocket, cause: unknown) => Effect.Effect<void, E, R>;
-}
-declare const handlers: <R = never, E = unknown>(options: DurableWebSocketHandlers<R, E>) => {
-  webSocketMessage: ((socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, E, R>) | undefined;
-  webSocketClose: ((socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, E, R>) | undefined;
-  webSocketError: ((socket: DurableWebSocket, cause: unknown) => Effect.Effect<void, E, R>) | undefined;
-};
 declare namespace Rpc_d_exports {
   export { DisposableValue, MethodArgs, MethodKey, MethodReturn, Provider, Result$1 as Result, RpcStub, RpcTarget, Serializable, Stub, Stubable, Stubify, dispose, isDisposable, resolve, scoped };
 }
@@ -819,63 +637,5 @@ declare function make<ROut, LayerError, REvent extends never = never, EventLayer
  */
 declare function makeFetchHandler<ROut, LayerError, REvent, EventLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptionsWithEventLayer<ROut, REvent, EventLayerError>): FetchHandler<Env>;
 declare function makeFetchHandler<ROut, LayerError, REvent extends never = never, EventLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptions<ROut, REvent, EventLayerError>): FetchHandler<Env>;
-declare namespace DurableObjectState_d_exports {
-  export { DurableObjectState, DurableObjectStateService, fromDurableObjectState };
-}
-/**
- * Effect-friendly wrapper around Cloudflare `DurableObjectState`.
- */
-interface DurableObjectStateService {
-  readonly raw: globalThis.DurableObjectState;
-  readonly id: globalThis.DurableObjectId;
-  readonly storage: DurableObjectStorage;
-  waitUntil(promise: Promise<unknown>): Effect.Effect<void>;
-  /**
-   * Runs a background Effect via Cloudflare's `waitUntil` with the caller's
-   * Effect context, mirroring `WorkerContext.waitUntil` failure modes:
-   * `"observe"` (default) logs or routes failures to `onFailure`, while
-   * `"propagate"` also rejects the native `waitUntil` promise.
-   */
-  waitUntil<A, E, R, R2 = never>(effect: Effect.Effect<A, E, R>, options?: WorkerContextWaitUntilOptions<E, R2>): Effect.Effect<void, never, R | R2>;
-  /**
-   * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate.
-   *
-   * Cloudflare resets a Durable Object if the callback throws/rejects, or if the
-   * callback exceeds the platform timeout (currently documented as 30 seconds).
-   * This safe default resolves the callback with the Effect `Exit` for typed
-   * Effect failures and resumes that `Exit` afterward, so typed failures remain
-   * ordinary Effect failures instead of resetting the Durable Object. Defects
-   * and interruptions still reject the callback.
-   */
-  blockConcurrencyWhile<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
-  /**
-   * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate and lets
-   * Effect failures reject the callback.
-   *
-   * Use this only when Cloudflare's reset-on-throw behavior is intentional. The
-   * platform also resets the Durable Object if the callback exceeds the
-   * documented timeout (currently 30 seconds).
-   */
-  blockConcurrencyWhileOrReset<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
-  acceptWebSocket(ws: DurableWebSocket, tags?: Array<string>): Effect.Effect<void>;
-  getWebSockets(tag?: string): Effect.Effect<Array<DurableWebSocket>>;
-  setWebSocketAutoResponse(pair?: WebSocketRequestResponsePair): Effect.Effect<void>;
-  getWebSocketAutoResponse: Effect.Effect<WebSocketRequestResponsePair | null>;
-  getWebSocketAutoResponseTimestamp(ws: DurableWebSocket): Effect.Effect<Date | null>;
-  setHibernatableWebSocketEventTimeout(timeoutMs?: number): Effect.Effect<void>;
-  getHibernatableWebSocketEventTimeout: Effect.Effect<number | null>;
-  getTags(ws: DurableWebSocket): Effect.Effect<Array<string>>;
-  /**
-   * Forcibly resets the Durable Object. Cloudflare logs an uncaught Error using
-   * the optional reason, and the method is not available in `wrangler dev` local
-   * development according to the Durable Object State docs. Set
-   * `retryAlarm: false` to prevent the current alarm invocation from retrying;
-   * this option has no effect outside an alarm handler.
-   */
-  abort(reason?: string, options?: globalThis.DurableObjectAbortOptions): Effect.Effect<void>;
-}
-declare const DurableObjectState_base: Context.ServiceClass<DurableObjectState, "effect-cf/DurableObjectState", DurableObjectStateService>;
-declare class DurableObjectState extends DurableObjectState_base {}
-declare const fromDurableObjectState: (state: globalThis.DurableObjectState) => DurableObjectStateService;
 //#endregion
-export { DurableWebSocket as A, RpcDefinition_d_exports as C, AcceptUpgradeOptions as D, Rpc_d_exports as E, DurableObjectStorage_d_exports as M, StorageOperationError as N, AcceptedUpgrade as O, ReservedMethodName$3 as S, Provider as T, Queue_d_exports as _, NativeRequest as a, Definition$3 as b, WorkerDefinition_d_exports as c, AsyncMethodCloudflareReturn as d, AsyncMethodKey as f, RpcTracing_d_exports as g, RpcInvocationInfo as h, ExecutionContext as i, DurableWebSocketAttachmentError as j, DurableObjectWebSocket_d_exports as k, ServiceBinding_d_exports as l, ReceiverOptions as m, DurableObjectStateService as n, WorkerContext as o, AsyncMethodSuccess as p, DurableObjectState_d_exports as r, Worker_d_exports as s, DurableObjectState as t, AsyncMethodArgs as u, QueueDefinition_d_exports as v, ServiceFreeSchema$1 as w, Method$2 as x, QueueBinding_d_exports as y };
+export { Provider as C, ServiceFreeSchema$1 as S, QueueBinding_d_exports as _, Worker_d_exports as a, ReservedMethodName$3 as b, AsyncMethodArgs as c, AsyncMethodSuccess as d, ReceiverOptions as f, QueueDefinition_d_exports as g, Queue_d_exports as h, WorkerContextWaitUntilOptions as i, AsyncMethodCloudflareReturn as l, RpcTracing_d_exports as m, NativeRequest as n, WorkerDefinition_d_exports as o, RpcInvocationInfo as p, WorkerContext as r, ServiceBinding_d_exports as s, ExecutionContext as t, AsyncMethodKey as u, Definition$3 as v, Rpc_d_exports as w, RpcDefinition_d_exports as x, Method$2 as y };