effect-cf 0.34.0 → 0.36.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # effect-cf
 
+## 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
+
+- [#130](https://github.com/danieljvdm/effect-cf/pull/130) [`6139dc2`](https://github.com/danieljvdm/effect-cf/commit/6139dc2507043abfd81b6abeeff87bfd5b8bb31a) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Keep Worker event-layer resources alive through Effect HTTP response streams, give background work and Workflow steps their own resource scopes, and join interrupted native callbacks before returning. Durable Object transactions now await rollback and cleanup on interruption, including accidental asynchronous work in synchronous transactions. Queue handlers also schedule telemetry flushes after success or failure.
+
+  Propagate fetch cancellation to service bindings and Durable Objects. Report scoped RPC failures, malformed embedding responses, and invalid Analytics Engine URLs through tagged errors. Computer workspace acquisition now exposes `WorkspaceAcquireError` in its layer error channel. Typed WebSocket attachments enforce their declared shape, and fresh RPC connections replace reserved metadata without losing application fields.
+
+  Support modern WebTransport datagram writers and buffered-datagram options while retaining legacy compatibility. Release stream locks after cleanup and datagram writer locks when either peer closes. Failed or interrupted fallback candidates release their resources before selection continues.
+
 ## 0.34.0
 
 ### Minor Changes

package/dist/ComputerWorkspace.d.mts

@@ -1,5 +1,5 @@
 import { ComputerArtifactsClient } from "./ComputerArtifacts.mjs";
-import { t as DurableObjectState } from "./DurableObjectState-CrEunfQ-.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";
@@ -56,6 +56,14 @@ declare const WorkspaceAssetsError_base: Schema.Class<WorkspaceAssetsError, Sche
 }>, import("effect/Cause").YieldableError>;
 /** Schema-serializable error for a workspace Assets operation. */
 declare class WorkspaceAssetsError extends WorkspaceAssetsError_base {}
+declare const WorkspaceAcquireError_base: Schema.Class<WorkspaceAcquireError, Schema.TaggedStruct<"WorkspaceAcquireError", {
+  readonly operation: Schema.String;
+  readonly message: Schema.String;
+  readonly code: Schema.optionalKey<Schema.String>;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** Schema-serializable error while acquiring the Computer workspace client. */
+declare class WorkspaceAcquireError extends WorkspaceAcquireError_base {}
 type WorkspaceReadFileOptions = Omit<CloudflareReadFileOptions, "encoding">;
 type ReadTextFileOptions = WorkspaceReadFileOptions;
 type ListDirectoryOptions = CloudflareReaddirOptions;
@@ -264,7 +272,7 @@ declare class ComputerWorkspace extends ComputerWorkspace_base {
    * Acquires the single workspace registered by `withComputerWorkspace` and
    * releases its RPC client when the layer scope closes.
    */
-  static readonly layer: Layer.Layer<ComputerWorkspace, never, DurableObjectState>;
+  static readonly layer: Layer.Layer<ComputerWorkspace, WorkspaceAcquireError, DurableObjectState>;
 }
 //#endregion
-export { ComputerWorkspace, ComputerWorkspaceAssets, ComputerWorkspaceFilesystem, ComputerWorkspaceGit, ComputerWorkspaceRuntime, ComputerWorkspaceService, type ComputerWorkspaceService as ComputerWorkspaceShape, ComputerWorkspaceThink, ListDirectoryOptions, ReadTextFileOptions, RemovePathOptions, WorkspaceAssetsError, WorkspaceDirectoryEntry, WorkspaceEntryStat, WorkspaceExec, WorkspaceExecChunk, WorkspaceExecCollect, WorkspaceExecEncoding, WorkspaceExecError, WorkspaceExecEvent, WorkspaceExecOptions, WorkspaceExecResult, WorkspaceExecRun, WorkspaceExecSignal, WorkspaceExecSkippedEntry, WorkspaceExecSyncResult, WorkspaceFindOptions, WorkspaceFoundEntry, WorkspaceFsError, WorkspaceGetExec, WorkspaceGetExecOptions, WorkspaceGitCheckoutOptions, WorkspaceGitCloneOptions, WorkspaceGitCommit, WorkspaceGitCommitOptions, WorkspaceGitDiffOptions, WorkspaceGitError, WorkspaceGitFetchOptions, WorkspaceGitFetchResult, WorkspaceGitLogOptions, WorkspaceGitPerson, WorkspaceGitUpdateRefOptions, WorkspaceGrepMatch, WorkspaceGrepOptions, WorkspaceMkdirOptions, WorkspaceReadEncoding, WorkspaceReadFile, WorkspaceReadFileOptions, WorkspaceRuntimeValue, WorkspaceWriteFileContent, WorkspaceWriteFileOptions, fromWorkspaceClient };
+export { ComputerWorkspace, ComputerWorkspaceAssets, ComputerWorkspaceFilesystem, ComputerWorkspaceGit, ComputerWorkspaceRuntime, ComputerWorkspaceService, type ComputerWorkspaceService as ComputerWorkspaceShape, ComputerWorkspaceThink, ListDirectoryOptions, ReadTextFileOptions, RemovePathOptions, WorkspaceAcquireError, WorkspaceAssetsError, WorkspaceDirectoryEntry, WorkspaceEntryStat, WorkspaceExec, WorkspaceExecChunk, WorkspaceExecCollect, WorkspaceExecEncoding, WorkspaceExecError, WorkspaceExecEvent, WorkspaceExecOptions, WorkspaceExecResult, WorkspaceExecRun, WorkspaceExecSignal, WorkspaceExecSkippedEntry, WorkspaceExecSyncResult, WorkspaceFindOptions, WorkspaceFoundEntry, WorkspaceFsError, WorkspaceGetExec, WorkspaceGetExecOptions, WorkspaceGitCheckoutOptions, WorkspaceGitCloneOptions, WorkspaceGitCommit, WorkspaceGitCommitOptions, WorkspaceGitDiffOptions, WorkspaceGitError, WorkspaceGitFetchOptions, WorkspaceGitFetchResult, WorkspaceGitLogOptions, WorkspaceGitPerson, WorkspaceGitUpdateRefOptions, WorkspaceGrepMatch, WorkspaceGrepOptions, WorkspaceMkdirOptions, WorkspaceReadEncoding, WorkspaceReadFile, WorkspaceReadFileOptions, WorkspaceRuntimeValue, WorkspaceWriteFileContent, WorkspaceWriteFileOptions, fromWorkspaceClient };

package/dist/ComputerWorkspace.mjs

@@ -1,4 +1,4 @@
-import { t as DurableObjectState } from "./DurableObjectState-De4ZojhY.mjs";
+import { t as DurableObjectState } from "./DurableObjectState-DCh4PZMN.mjs";
 import { fromClient } from "./ComputerArtifacts.mjs";
 import { t as lookup } from "./ComputerWorkspaceHostRegistry-CY5Fv4Ng.mjs";
 import { Context, Effect, Layer, Predicate, Schema, Stream } from "effect";
@@ -37,6 +37,13 @@ var WorkspaceAssetsError = class extends Schema.TaggedError()("WorkspaceAssetsEr
 	code: Schema.optionalKey(Schema.String),
 	cause: Schema.optionalKey(Schema.Defect({ includeStack: true }))
 }) {};
+/** Schema-serializable error while acquiring the Computer workspace client. */
+var WorkspaceAcquireError = class extends Schema.TaggedError()("WorkspaceAcquireError", {
+	operation: Schema.String,
+	message: Schema.String,
+	code: Schema.optionalKey(Schema.String),
+	cause: Schema.optionalKey(Schema.Defect({ includeStack: true }))
+}) {};
 const errorMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
 const errorCode = (cause) => {
 	if (Predicate.hasProperty(cause, "code") && Predicate.isString(cause.code)) return cause.code;
@@ -72,6 +79,16 @@ const execError = (operation, cause) => {
 	if (code !== void 0) properties.code = code;
 	return WorkspaceExecError.make(properties);
 };
+const acquireError = (operation, cause) => {
+	const properties = {
+		operation,
+		message: errorMessage(cause),
+		cause
+	};
+	const code = errorCode(cause);
+	if (code !== void 0) properties.code = code;
+	return WorkspaceAcquireError.make(properties);
+};
 const assetsError = (operation, path, cause) => {
 	const properties = {
 		operation,
@@ -404,7 +421,6 @@ const wrapRun = (handle) => {
 		kill
 	};
 };
-const releaseRun = (handle) => Effect.sync(() => handle[Symbol.dispose]());
 const makeRuntime = (client) => {
 	const execImplementation = Effect.fn("ComputerWorkspace.runtime.exec", { attributes: {
 		family: "runtime",
@@ -415,14 +431,14 @@ const makeRuntime = (client) => {
 			backend: options?.backend,
 			runId: options?.id
 		});
-		const handle = yield* Effect.acquireRelease(Effect.tryPromise({
+		const handle = yield* Effect.acquireDisposable(Effect.tryPromise({
 			try: () => {
 				if (Predicate.isString(source)) return client.runtime.exec(source, runtimeExecOptions(options));
 				const values = optionsOrValue === void 0 ? remainingValues : [optionsOrValue, ...remainingValues];
 				return client.runtime.exec(source, ...values);
 			},
 			catch: (cause) => execError("exec", cause)
-		}), releaseRun);
+		}));
 		return wrapRun(handle);
 	});
 	const exec = execImplementation;
@@ -434,10 +450,10 @@ const makeRuntime = (client) => {
 			backend: options?.backend,
 			runId: id
 		});
-		const handle = yield* Effect.acquireRelease(Effect.tryPromise({
+		const handle = yield* Effect.acquireDisposable(Effect.tryPromise({
 			try: () => client.runtime.getExec(id, runtimeGetOptions(options)),
 			catch: (cause) => execError("getExec", cause)
-		}), releaseRun);
+		}));
 		return wrapRun(handle);
 	});
 	const killExec = Effect.fn("ComputerWorkspace.runtime.killExec", { attributes: {
@@ -567,10 +583,16 @@ var ComputerWorkspace = class ComputerWorkspace extends Context.Service()("effec
 	static layer = Layer.effect(ComputerWorkspace, Effect.gen(function* () {
 		const host = lookup((yield* DurableObjectState).raw);
 		if (host === void 0) return yield* Effect.die("ComputerWorkspace.layer requires a Durable Object class built with withComputerWorkspace");
-		const computer = yield* Effect.promise(() => import("@cloudflare/computer"));
-		const client = yield* Effect.acquireRelease(Effect.promise(() => computer.getWorkspace(host)), (workspace) => Effect.sync(() => workspace[Symbol.dispose]()));
+		const computer = yield* Effect.tryPromise({
+			try: () => import("@cloudflare/computer"),
+			catch: (cause) => acquireError("import", cause)
+		});
+		const client = yield* Effect.acquireDisposable(Effect.tryPromise({
+			try: () => computer.getWorkspace(host),
+			catch: (cause) => acquireError("getWorkspace", cause)
+		}));
 		return ComputerWorkspace.of(fromWorkspaceClient(client));
 	}));
 };
 //#endregion
-export { ComputerWorkspace, WorkspaceAssetsError, WorkspaceExecError, WorkspaceFsError, WorkspaceGitError, fromWorkspaceClient };
+export { ComputerWorkspace, WorkspaceAcquireError, WorkspaceAssetsError, WorkspaceExecError, WorkspaceFsError, WorkspaceGitError, fromWorkspaceClient };

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-De4ZojhY.mjs → DurableObjectState-DCh4PZMN.mjs}

@@ -1,6 +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, Option, Predicate, Result, Schema } from "effect";
+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,
@@ -103,30 +104,35 @@ const fromDurableObjectStorage = (storage) => ({
 	deleteAlarm: (options) => tryStoragePromise("deleteAlarm", () => storage.deleteAlarm(options)),
 	transactionSync: (closure) => Effect.context().pipe(Effect.flatMap((context) => Effect.suspend(() => {
 		let aborted;
+		let escapedFiber;
 		try {
 			return Effect.succeed(storage.transactionSync(() => {
 				const exit = Effect.runSyncExitWith(context)(closure());
 				if (Exit.isSuccess(exit)) return exit.value;
+				const defect = Cause.findDefect(exit.cause);
+				if (Result.isSuccess(defect) && Cause.isAsyncFiberError(defect.success)) {
+					escapedFiber = defect.success.fiber;
+					escapedFiber.interruptUnsafe();
+				}
 				aborted = exit;
 				throw exit;
 			}));
 		} catch (cause) {
-			if (aborted !== void 0 && cause === aborted && Exit.isFailure(aborted)) return Effect.failCause(aborted.cause);
-			return Effect.fail(storageError("transactionSync", cause));
+			const failure = aborted !== void 0 && cause === aborted && Exit.isFailure(aborted) ? Effect.failCause(aborted.cause) : Effect.fail(storageError("transactionSync", cause));
+			const fiber = escapedFiber;
+			if (fiber !== void 0) return Fiber.interrupt(fiber).pipe(Effect.andThen(failure));
+			return failure;
 		}
 	}))),
-	transaction: (closure) => Effect.context().pipe(Effect.flatMap((context) => Effect.callback((resume) => {
+	transaction: (closure) => Effect.suspend(() => {
 		let aborted;
-		storage.transaction(async (txn) => {
-			const exit = await Effect.runPromiseExitWith(context)(closure(fromDurableObjectTransaction(txn)));
+		return runNativeCallback((run) => storage.transaction(async (txn) => {
+			const exit = await run(Effect.suspend(() => closure(fromDurableObjectTransaction(txn))));
 			if (Exit.isSuccess(exit)) return exit.value;
 			aborted = exit;
 			throw exit;
-		}).then((value) => resume(Effect.succeed(value)), (cause) => {
-			if (aborted !== void 0 && cause === aborted && Exit.isFailure(aborted)) resume(Effect.failCause(aborted.cause));
-			else resume(Effect.fail(storageError("transaction", cause)));
-		});
-	}))),
+		})).pipe(Effect.catch((cause) => aborted !== void 0 && cause === aborted && Exit.isFailure(aborted) ? Effect.failCause(aborted.cause) : Effect.fail(storageError("transaction", cause))));
+	}),
 	sync: () => tryStoragePromise("sync", () => storage.sync()),
 	getCurrentBookmark: () => tryStoragePromise("getCurrentBookmark", () => storage.getCurrentBookmark()),
 	onNextSessionRestoreBookmark: (bookmark) => tryStoragePromise("onNextSessionRestoreBookmark", () => storage.onNextSessionRestoreBookmark(bookmark)),
@@ -160,38 +166,31 @@ var DurableWebSocketAttachmentError = class extends Data.TaggedError("DurableWeb
 		return `Durable Object websocket attachment ${this.operation} failed: ${causeMessage(this.cause)}`;
 	}
 };
-const wrappers = /* @__PURE__ */ new WeakMap();
-const fromWebSocket = (raw) => {
-	const existing = wrappers.get(raw);
-	if (existing !== void 0) return existing;
-	const socket = {
-		raw,
-		send: (data) => Effect.try({
-			try: () => raw.send(data),
-			catch: (cause) => new DurableWebSocketSendError({ cause })
-		}),
-		close: (code, reason) => Effect.try({
-			try: () => raw.close(code, reason),
-			catch: (cause) => new DurableWebSocketCloseError({ cause })
-		}),
-		serializeAttachment: (value) => Effect.try({
-			try: () => raw.serializeAttachment(value),
-			catch: (cause) => new DurableWebSocketAttachmentError({
-				operation: "serialize",
-				cause
-			})
-		}),
-		deserializeAttachment: Effect.try({
-			try: () => raw.deserializeAttachment(),
-			catch: (cause) => new DurableWebSocketAttachmentError({
-				operation: "deserialize",
-				cause
-			})
+const fromWebSocket = (raw) => ({
+	raw,
+	send: (data) => Effect.try({
+		try: () => raw.send(data),
+		catch: (cause) => new DurableWebSocketSendError({ cause })
+	}),
+	close: (code, reason) => Effect.try({
+		try: () => raw.close(code, reason),
+		catch: (cause) => new DurableWebSocketCloseError({ cause })
+	}),
+	serializeAttachment: (value) => Effect.try({
+		try: () => raw.serializeAttachment(value),
+		catch: (cause) => new DurableWebSocketAttachmentError({
+			operation: "serialize",
+			cause
 		})
-	};
-	wrappers.set(raw, socket);
-	return socket;
-};
+	}),
+	deserializeAttachment: Effect.try({
+		try: () => raw.deserializeAttachment(),
+		catch: (cause) => new DurableWebSocketAttachmentError({
+			operation: "deserialize",
+			cause
+		})
+	})
+});
 const acceptUpgrade = Effect.fn("DurableObjectWebSocket.acceptUpgrade")(function* (options = {}) {
 	const state = yield* DurableObjectState;
 	const pair = new WebSocketPair();
@@ -252,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) => (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.scoped(Effect.provideContext(failureHandler(label, cause, options), context))).then((exit) => {
-			if (Exit.isFailure(exit)) console.error(`${label} failure handler failed`, Cause.pretty(exit.cause));
-		});
-		register(runPromiseExit(Effect.scoped(Effect.provideContext(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,
@@ -295,8 +265,12 @@ const fromDurableObjectState = (state) => {
 		id: state.id,
 		storage: fromDurableObjectStorage(state.storage),
 		waitUntil,
-		blockConcurrencyWhile: (effect) => Effect.context().pipe(Effect.flatMap((context) => Effect.promise(() => state.blockConcurrencyWhile(() => runPromiseExitPreservingTypedFailures(context, effect)))), Effect.flatten),
-		blockConcurrencyWhileOrReset: (effect) => Effect.context().pipe(Effect.flatMap((context) => Effect.promise(() => state.blockConcurrencyWhile(() => Effect.runPromiseWith(context)(effect))))),
+		blockConcurrencyWhile: (effect) => runNativeCallback((run) => state.blockConcurrencyWhile(() => runExitPreservingTypedFailures(run, effect))).pipe(Effect.orDie, Effect.flatten),
+		blockConcurrencyWhileOrReset: (effect) => runNativeCallback((run) => state.blockConcurrencyWhile(async () => {
+			const exit = await run(effect);
+			if (Exit.isFailure(exit)) throw Cause.squash(exit.cause);
+			return exit.value;
+		})).pipe(Effect.orDie),
 		acceptWebSocket: (ws, tags) => Effect.sync(() => state.acceptWebSocket(ws.raw, tags)),
 		getWebSockets: (tag) => Effect.sync(() => state.getWebSockets(tag).map((socket) => fromWebSocket(socket))),
 		setWebSocketAutoResponse: (pair) => Effect.sync(() => state.setWebSocketAutoResponse(pair)),
@@ -308,10 +282,10 @@ const fromDurableObjectState = (state) => {
 		abort: (reason, options) => Effect.sync(() => state.abort(reason, options))
 	};
 };
-const runPromiseExitPreservingTypedFailures = async (context, effect) => {
-	const exit = await Effect.runPromiseExitWith(context)(effect);
+const runExitPreservingTypedFailures = async (run, effect) => {
+	const exit = await run(effect);
 	if (Exit.isFailure(exit) && (Cause.hasDies(exit.cause) || Cause.hasInterrupts(exit.cause))) throw Cause.squash(exit.cause);
 	return exit;
 };
 //#endregion
-export { DurableObjectWebSocket_exports as a, DurableObjectStorage_exports as c, fromExecutionContext as i, DurableObjectState_exports as n, DurableWebSocketAttachmentError as o, fromDurableObjectState as r, fromWebSocket as s, DurableObjectState as t };
+export { DurableWebSocketAttachmentError as a, DurableObjectWebSocket_exports as i, DurableObjectState_exports as n, fromWebSocket as o, fromDurableObjectState as r, DurableObjectStorage_exports as s, DurableObjectState as t };