effect-cf 0.35.0 → 0.37.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # effect-cf
 
+## 0.37.0
+
+### Minor Changes
+
+- [#135](https://github.com/danieljvdm/effect-cf/pull/135) [`9dea62e`](https://github.com/danieljvdm/effect-cf/commit/9dea62e74818b7fc9da919e8bdbfcc49991aef36) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Add `DurableObjectAlarm.transaction` to commit application storage and logical alarm schedule, replacement, or cancellation together in one native SQLite Durable Object transaction. Application queries can use the existing storage wrapper or a `SqlClient` from `@effect/sql-sqlite-do` backed by the same object. The callback receives transaction-only alarm mutations and preserves the caller's success value, typed errors, and service requirements.
+
+  Failures before commit roll back application rows, logical alarms, and native alarm reconciliation together. Interruption or a lost reply after commit does not undo committed state. Keep external effects outside the transaction and durably pre-arm a later wake before fallible external work; Cloudflare's native alarm retries remain bounded.
+
+## 0.36.0
+
+### Minor Changes
+
+- [#132](https://github.com/danieljvdm/effect-cf/pull/132) [`d2e53a9`](https://github.com/danieljvdm/effect-cf/commit/d2e53a9fab38432a472c9f46a74b87cc89474103) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Add the `effect-cf/mcp` entry point for serving an Effect AI `Toolkit` over MCP from a Worker fetch handler. `Mcp.fromToolkit(toolkit, { name, version, route })` wraps the MCP SDK's stateless Streamable HTTP handler (`createMcpHandler` from `@modelcontextprotocol/server`) together with the Worker edge concerns remote MCP deployments expect (CORS plus `Host` and `Origin` validation with localhost/`workers.dev` defaults): requests on the configured route (default `/mcp`) are answered by a fresh MCP server exposing every toolkit tool, and other requests fall through with `Option.none()` so the rest of the fetch handler (for example an `HttpApi` router) keeps serving them. Tool input/output schemas are derived from each tool's Effect `Schema`, tool calls run through the Worker's Effect runtime with the toolkit handler layer, declared tool failures become `isError` tool results, and invalid arguments are rejected by the tool's parameters schema. The `@modelcontextprotocol/server` package is a new optional peer dependency, needed only when importing `effect-cf/mcp`.
+
 ## 0.35.0
 
 ### Minor Changes

package/README.md

@@ -47,6 +47,8 @@ Declare `SETTINGS` in `wrangler.jsonc` and pass `SettingsLive` to `Worker.make`.
 
 The [counter example](https://github.com/danieljvdm/effect-cf/tree/main/examples/counter) shows `DurableObject.Tag`, storage, a typed RPC call, and the complete Wrangler configuration.
 
+For atomic application writes and alarm changes, see the [alarm transaction example](tests/fixtures/alarm-transaction-consumer.ts) and [API contract](src/DurableObjectAlarm.ts).
+
 ## Native RPC tracing
 
 `call()`, `scopedCall()`, and definition methods create one CLIENT span named `binding/method`, covering argument encoding, the native RPC wait, and success decoding. Raw `rpc()` retains Cloudflare's pipelined result without creating a span. Wrap its complete lifetime with `RpcTracing.withRpcClientSpan` when tracing raw calls.

package/dist/ComputerWorkspace.d.mts

@@ -1,5 +1,5 @@
 import { ComputerArtifactsClient } from "./ComputerArtifacts.mjs";
-import { t as DurableObjectState } from "./DurableObjectState-DpYdNZgT.mjs";
+import { t as DurableObjectState } from "./DurableObjectState-CpgAmFqo.mjs";
 import { Context, Effect, Layer, Schema, Scope, Stream } from "effect";
 import { CommitView, GitClient, GitCloneOptions, GitCommitOptions, GitDiffOptions, GitFetchOptions, GitLogOptions, GitUpdateRefOptions } from "@cloudflare/computer/git";
 import { ExecSyncResult, RuntimeExecOptions, RuntimeGetOptions, RuntimeKillOptions, ShellValue, SkippedEntry, ThinkWorkspaceCompatibility, WorkspaceClient, WorkspaceRuntimeResult, WorkspaceRuntimeValue as WorkspaceRuntimeValue$1 } from "@cloudflare/computer";

package/dist/ComputerWorkspace.mjs

@@ -1,4 +1,4 @@
-import { t as DurableObjectState } from "./DurableObjectState-DcqElJ4e.mjs";
+import { t as DurableObjectState } from "./DurableObjectState-DLL0YgBd.mjs";
 import { fromClient } from "./ComputerArtifacts.mjs";
 import { t as lookup } from "./ComputerWorkspaceHostRegistry-CY5Fv4Ng.mjs";
 import { Context, Effect, Layer, Predicate, Schema, Stream } from "effect";

package/dist/DurableObjectState-CpgAmFqo.d.mts

@@ -0,0 +1,244 @@
+import { i as WorkerContextWaitUntilOptions } from "./Worker-Dl6_Pijl.mjs";
+import { Cause, Context, Duration, Effect, Option, Schema } from "effect";
+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 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 { AcceptedUpgrade as a, DurableWebSocketAttachmentError as c, AcceptUpgradeOptions as i, DurableObjectStorage_d_exports as l, DurableObjectStateService as n, DurableObjectWebSocket_d_exports as o, DurableObjectState_d_exports as r, DurableWebSocket as s, DurableObjectState as t, StorageOperationError as u };

package/dist/{DurableObjectState-DcqElJ4e.mjs → DurableObjectState-DLL0YgBd.mjs}

@@ -1,35 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { t as causeMessage } from "./ErrorMessage-Byx2OgNd.mjs";
-import { Cause, Clock, Context, Data, Duration, Effect, Exit, Fiber, FiberSet, Option, Predicate, Result, Schema } from "effect";
-//#region src/internal/NativeCallback.ts
-/**
-* Runs an Effect callback owned by a native Promise operation.
-*
-* The callback keeps the caller's context, while a private scope owns its
-* fiber. Closing that scope interrupts and joins the callback before awaiting
-* the native operation's settlement.
-*/
-const runNativeCallback = Effect.fnUntraced(function* (operation) {
-	const callerContext = yield* Effect.context();
-	return yield* Effect.scoped(Effect.gen(function* () {
-		let nativePromise;
-		yield* Effect.addFinalizer(() => {
-			const promise = nativePromise;
-			return promise === void 0 ? Effect.void : Effect.promise(() => promise.then(() => void 0, () => void 0));
-		});
-		const runPromise = yield* FiberSet.makeRuntimePromise();
-		return yield* Effect.callback((resume) => {
-			try {
-				nativePromise = operation((effect) => runPromise(Effect.provideContext(Effect.exit(effect), callerContext)));
-			} catch (cause) {
-				resume(Effect.fail(cause));
-				return;
-			}
-			nativePromise.then((value) => resume(Effect.succeed(value)), (cause) => resume(Effect.fail(cause)));
-		});
-	}));
-});
-//#endregion
+import { n as makeWaitUntilScheduler, r as runNativeCallback } from "./WorkerContext-Yobnfw-K.mjs";
+import { Cause, Clock, Context, Data, Duration, Effect, Exit, Fiber, Option, Predicate, Result, Schema } from "effect";
 //#region src/DurableObjectStorage.ts
 var DurableObjectStorage_exports = /* @__PURE__ */ __exportAll({
 	StorageOperationError: () => StorageOperationError,
@@ -279,35 +251,6 @@ const handlers = (options) => ({
 	webSocketError: options.error
 });
 //#endregion
-//#region src/internal/WorkerContext.ts
-const causeError = (cause) => {
-	const squashed = Cause.squash(cause);
-	return squashed instanceof Error ? squashed : new Error(Cause.pretty(cause), { cause: squashed });
-};
-const failureHandler = (label, cause, options) => Effect.suspend(() => options?.onFailure?.(cause) ?? Effect.logError(`${label} failed`, Cause.pretty(cause))).pipe(Effect.catchCause((handlerCause) => Effect.logError(`${label} failure handler failed`, Cause.pretty(cause), Cause.pretty(handlerCause))));
-const makeWaitUntilScheduler = (label, register, runPromiseExit = (effect) => Effect.runPromiseExit(effect)) => {
-	return (effect, options, mode) => Effect.context().pipe(Effect.flatMap((context) => Effect.sync(() => {
-		const runHandler = (cause) => runPromiseExit(Effect.provideContext(Effect.scoped(failureHandler(label, cause, options)), context)).then((exit) => {
-			if (Exit.isFailure(exit)) console.error(`${label} failure handler failed`, Cause.pretty(exit.cause));
-		});
-		register(runPromiseExit(Effect.provideContext(Effect.scoped(effect), context)).then(async (exit) => {
-			if (Exit.isSuccess(exit)) return;
-			await runHandler(exit.cause);
-			if (mode === "propagate") throw causeError(exit.cause);
-		}));
-	})));
-};
-const fromExecutionContext = (ctx, runPromiseExit = (effect) => Effect.runPromiseExit(effect)) => {
-	const schedule = makeWaitUntilScheduler("WorkerContext.waitUntil", (promise) => ctx.waitUntil(promise), runPromiseExit);
-	return {
-		raw: ctx,
-		waitUntil: (effect, options) => schedule(effect, options, options?.mode ?? "observe"),
-		waitUntilPropagating: (effect, options) => schedule(effect, options, "propagate"),
-		passThroughOnException: Effect.sync(() => ctx.passThroughOnException()),
-		abort: (reason) => Effect.sync(() => ctx.abort(reason))
-	};
-};
-//#endregion
 //#region src/DurableObjectState.ts
 var DurableObjectState_exports = /* @__PURE__ */ __exportAll({
 	DurableObjectState: () => DurableObjectState,
@@ -345,4 +288,4 @@ const runExitPreservingTypedFailures = async (run, effect) => {
 	return exit;
 };
 //#endregion
-export { DurableObjectWebSocket_exports as a, DurableObjectStorage_exports as c, fromExecutionContext as i, runNativeCallback as l, DurableObjectState_exports as n, DurableWebSocketAttachmentError as o, fromDurableObjectState as r, fromWebSocket as s, DurableObjectState as t };
+export { DurableWebSocketAttachmentError as a, StorageOperationError as c, DurableObjectWebSocket_exports as i, DurableObjectState_exports as n, fromWebSocket as o, fromDurableObjectState as r, DurableObjectStorage_exports as s, DurableObjectState as t };

package/dist/Mcp.d.mts

@@ -0,0 +1,122 @@
+import { n as NativeRequest } from "./Worker-Dl6_Pijl.mjs";
+import { Effect, Option } from "effect";
+import { CreateMcpHandlerOptions, ServerOptions } from "@modelcontextprotocol/server";
+import { Tool, Toolkit } from "effect/unstable/ai";
+//#region src/Mcp.d.ts
+/**
+ * CORS headers applied to MCP responses.
+ */
+interface CorsOptions {
+  readonly origin?: string;
+  readonly methods?: string;
+  readonly headers?: string;
+  readonly maxAge?: number;
+  readonly exposeHeaders?: string;
+}
+/**
+ * Options for {@link fromToolkit}.
+ *
+ * Extends the MCP SDK `createMcpHandler` options (`legacy`, `responseMode`,
+ * `onerror`, ...) with the server identity advertised to MCP clients and the
+ * Worker edge options (`route`, `corsOptions`, `allowedHostnames`,
+ * `allowedOriginHostnames`).
+ */
+interface FromToolkitOptions extends CreateMcpHandlerOptions {
+  /** Server name advertised in the MCP implementation info. */
+  readonly name: string;
+  /** Server version advertised in the MCP implementation info. */
+  readonly version: string;
+  /** Optional human-readable server title advertised to MCP clients. */
+  readonly title?: string;
+  /**
+   * Options passed to the underlying MCP SDK `McpServer` (capabilities,
+   * instructions, ...).
+   */
+  readonly serverOptions?: ServerOptions;
+  /** Pathname served by the MCP handler. @default "/mcp" */
+  readonly route?: string;
+  /** CORS headers applied to every MCP response. Pass `false` to disable. */
+  readonly corsOptions?: CorsOptions | false;
+  /**
+   * Restrict `Host` headers to these hostnames. Localhost and `workers.dev`
+   * endpoints receive matching defaults; custom domains rely on Cloudflare
+   * routing unless this option is set.
+   */
+  readonly allowedHostnames?: ReadonlyArray<string>;
+  /**
+   * Restrict present browser `Origin` headers to these hostnames. Requests
+   * without an Origin (including non-browser MCP clients) remain valid. The
+   * default includes localhost-class Origins, the endpoint's `workers.dev`
+   * hostname, and a concrete `corsOptions.origin` hostname. Pass `"*"` only
+   * when equivalent Origin validation runs in trusted middleware upstream.
+   */
+  readonly allowedOriginHostnames?: ReadonlyArray<string> | "*";
+}
+/**
+ * Services required to execute the tools of a toolkit: the tool handlers plus
+ * every service those handlers and their parameter/result codecs need.
+ */
+type ToolkitServices<Tools extends Record<string, Tool.Any>> = Tool.HandlersFor<Tools> | Tool.HandlerServices<Tools[keyof Tools]>;
+/**
+ * Context required by the Effect returned from {@link fromToolkit}: the native
+ * request provided by `Worker.make` plus the toolkit services.
+ */
+type FromToolkitContext<Tools extends Record<string, Tool.Any>> = NativeRequest | ToolkitServices<Tools>;
+/**
+ * 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 },
+ * )
+ * ```
+ */
+declare const fromToolkit: <Tools extends Record<string, Tool.Any>>(toolkit: Toolkit.Toolkit<Tools>, options: FromToolkitOptions) => Effect.Effect<Option.Option<Response>, unknown, FromToolkitContext<Tools>>;
+//#endregion
+export { CorsOptions, FromToolkitContext, FromToolkitOptions, ToolkitServices, fromToolkit };