effect-cf 0.34.0 → 0.35.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # effect-cf
 
+## 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-DpYdNZgT.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-DcqElJ4e.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-De4ZojhY.mjs → DurableObjectState-DcqElJ4e.mjs}

@@ -1,6 +1,35 @@
 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 { 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
 //#region src/DurableObjectStorage.ts
 var DurableObjectStorage_exports = /* @__PURE__ */ __exportAll({
 	StorageOperationError: () => StorageOperationError,
@@ -103,30 +132,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 +194,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();
@@ -257,13 +284,13 @@ 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 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.scoped(Effect.provideContext(failureHandler(label, cause, options), context))).then((exit) => {
+		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.scoped(Effect.provideContext(effect, context))).then(async (exit) => {
+		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);
@@ -295,8 +322,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 +339,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 { 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 };

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

@@ -6,7 +6,7 @@ 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]; }>) => import("effect/Cause").YieldableError & {
+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<{
@@ -142,7 +142,7 @@ interface DurableWebSocket<Attachment = unknown> {
   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 = Attachment>(value: A): Effect.Effect<void, DurableWebSocketAttachmentError>;
+  serializeAttachment<A extends Attachment = Attachment>(value: A): Effect.Effect<void, DurableWebSocketAttachmentError>;
   /** Deserializes hibernation attachment metadata from the socket. */
   readonly deserializeAttachment: Effect.Effect<unknown, DurableWebSocketAttachmentError>;
 }
@@ -274,8 +274,9 @@ declare const isWireError: (error: WireValue) => error is WireError;
  */
 declare const encodeWireError: (error: WireValue) => WireValue;
 declare const decodeWireError: (cause: WireValue) => WireValue;
+declare const reservedMethodNameValues: readonly ["constructor", "fetch", "connect", "alarm", "webSocketMessage", "webSocketClose", "webSocketError", "then", "dup", "dispose", "serialize", "deserialize"];
 declare const reservedMethodNames: Set<string>;
-type ReservedMethodName$3 = "constructor" | "fetch" | "connect" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError" | "then" | "dup" | "dispose" | "serialize" | "deserialize";
+type ReservedMethodName$3 = (typeof reservedMethodNameValues)[number];
 type ServiceFreeSchema$1 = Schema.Codec<any, any, never, never>;
 interface Method$2<Args extends ReadonlyArray<ServiceFreeSchema$1> = ReadonlyArray<ServiceFreeSchema$1>, Success extends ServiceFreeSchema$1 = ServiceFreeSchema$1> {
   readonly args: Args;
@@ -516,9 +517,9 @@ type ApiOrDefinition<Api extends object, Definition> = [Api] extends [never] ? A
 /**
  * Binding metadata used to create an Effect service from a Worker binding.
  */
-interface ServiceBindingDefinition<Definition$6 extends Definition.Any | undefined = undefined> {
+interface ServiceBindingDefinition<Definition$7 extends Definition.Any | undefined = undefined> {
   readonly binding: string;
-  readonly definition?: Definition$6;
+  readonly definition?: Definition$7;
   /** Append live trace context only when the receiver also enables rpcTracing. */
   readonly rpcTracing?: boolean;
 }
@@ -554,7 +555,7 @@ type ServiceMethodCloudflareReturn<Api, Method extends keyof Api> = AsyncMethodC
 type ServiceCall<R, Api> = <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, R>;
 type DefinitionDirectMethods<R, Definition$4 extends Definition.Any> = { readonly [Method in Definition$3.MethodNames<Definition$4>]: (...args: Method$2.Args<Definition$4["methods"][Method]>) => Effect.Effect<Method$2.Success<Definition$4["methods"][Method]>, ServiceBindingRpcError, R>; };
 type DirectMethods<R, Definition$13> = Definition$13 extends Definition.Any ? DefinitionDirectMethods<R, Definition$13> : {};
-type ServiceBindingEffectClient<Api extends object, Definition$7 extends Definition.Any | undefined = undefined> = DirectMethods<never, Definition$7> & {
+type ServiceBindingEffectClient<Api extends object, Definition$8 extends Definition.Any | undefined = undefined> = DirectMethods<never, Definition$8> & {
   readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, ServiceBindingFetchError>;
   /**
    * Invokes a Worker RPC method and returns Cloudflare's raw RPC result.
@@ -581,27 +582,27 @@ type ServiceBindingEffectClient<Api extends object, Definition$7 extends Definit
    * Use this for RPC methods that return Cloudflare RPC resources or other
    * disposable objects whose lifetime should be tied to an Effect scope.
    */
-  readonly scopedCall: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, unknown, Scope.Scope>;
+  readonly scopedCall: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, ServiceBindingRpcError, Scope.Scope>;
 };
-type ServiceBindingStaticClient<R, Api extends object, Definition$8 extends Definition.Any | undefined = undefined> = DirectMethods<R, Definition$8> & {
+type ServiceBindingStaticClient<R, Api extends object, Definition$5 extends Definition.Any | undefined = undefined> = DirectMethods<R, Definition$5> & {
   readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, ServiceBindingFetchError, R>;
   readonly rpc: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodCloudflareReturn<Api, Method>, ServiceBindingRpcError, R>;
   readonly call: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, R>;
-  readonly scopedCall: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, unknown, Scope.Scope | R>;
+  readonly scopedCall: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, ServiceBindingRpcError, Scope.Scope | R>;
 };
 type ServiceBindingValue = Schema.Schema.Type<typeof Schema.Unknown>;
 declare const isServiceBindingClient: <Api extends object>(value: ServiceBindingValue) => value is ServiceBindingClient<Api>;
-declare const makeClient: <Api extends object, const Definition$5 extends Definition.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition$5>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition$5>);
-declare const layer: <Self, Api extends object, const Definition$9 extends Definition.Any | undefined = undefined>(tag: Context.Service<Self, ServiceBindingEffectClient<Api, Definition$9>>, definition: ServiceBindingDefinition<Definition$9>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const Service: <Self, Api extends object = never>() => <Id extends string, const Definition$11 extends Definition.Any | undefined = undefined>(id: Id, definition: ServiceBindingDefinition<Definition$11>) => BindingService<Self, Id, ServiceBindingEffectClient<ApiOrDefinition<Api, Definition$11>, Definition$11>> & DirectMethods<Self, Definition$11> & {
+declare const makeClient: <Api extends object, const Definition$10 extends Definition.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition$10>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition$10>);
+declare const layer: <Self, Api extends object, const Definition$11 extends Definition.Any | undefined = undefined>(tag: Context.Service<Self, ServiceBindingEffectClient<Api, Definition$11>>, definition: ServiceBindingDefinition<Definition$11>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const Service: <Self, Api extends object = never>() => <Id extends string, const Definition$6 extends Definition.Any | undefined = undefined>(id: Id, definition: ServiceBindingDefinition<Definition$6>) => BindingService<Self, Id, ServiceBindingEffectClient<ApiOrDefinition<Api, Definition$6>, Definition$6>> & DirectMethods<Self, Definition$6> & {
   readonly [TypeId]: typeof TypeId;
-  readonly definition: ServiceBindingDefinition<Definition$11>;
+  readonly definition: ServiceBindingDefinition<Definition$6>;
   readonly fetch: (input: URL | RequestInfo<unknown, CfProperties<unknown>>, init?: RequestInit<CfProperties<unknown>> | undefined) => Effect.Effect<Response, ServiceBindingFetchError, Self>;
-  readonly rpc: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$11>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$11>, Method>) => Effect.Effect<Result$1<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$11>, Method>>, ServiceBindingRpcError, Self>;
-  readonly call: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$11>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$11>, Method>) => Effect.Effect<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$11>, Method>, ServiceBindingRpcError, Self>;
-  readonly scopedCall: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$11>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$11>, Method>) => Effect.Effect<Awaited<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$11>, Method>>, unknown, Self | Scope.Scope>;
+  readonly rpc: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$6>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$6>, Method>) => Effect.Effect<Result$1<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$6>, Method>>, ServiceBindingRpcError, Self>;
+  readonly call: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$6>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$6>, Method>) => Effect.Effect<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$6>, Method>, ServiceBindingRpcError, Self>;
+  readonly scopedCall: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$6>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$6>, Method>) => Effect.Effect<Awaited<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$6>, Method>>, ServiceBindingRpcError, Self | Scope.Scope>;
 };
-declare const makeDirectMethods: <R, Api, Definition$10 extends Definition.Any | undefined>(rpcDefinition: Definition$10 | undefined, call: ServiceCall<R, Api>) => DirectMethods<R, Definition$10>;
+declare const makeDirectMethods: <R, Api, Definition$9 extends Definition.Any | undefined>(rpcDefinition: Definition$9 | undefined, call: ServiceCall<R, Api>) => DirectMethods<R, Definition$9>;
 declare namespace WorkerDefinition_d_exports {
   export { Api, Definition, HandlerEffect, Handlers, LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options, ReservedMethodName$1 as ReservedMethodName, ServerApi$1 as ServerApi, ServiceFreeSchema, Tag, TagClass, Worker, implement, make$1 as make, method };
 }
@@ -750,10 +751,12 @@ interface WorkerOptions<RRuntime, REvent = never, EventLayerError = never, Rpc e
   /**
    * Layer provided around each Cloudflare event handled by this Worker.
    *
-   * The layer is built inside the event's Effect scope and finalized when the
-   * event effect completes. Use this for event-scoped resources such as OTLP
-   * trace/log exporters. Worker fetch and RPC handlers schedule a best-effort
-   * flush capped at two seconds; queue handlers do not flush automatically.
+   * The layer is built inside the event's Effect scope. For fetch handlers that
+   * return an Effect `HttpServerResponse` stream, its scope remains open until
+   * the response body finishes or is canceled. Native `Response` values pass
+   * through unchanged, so their body streams do not carry this scoped-lifetime
+   * guarantee. Fetch, queue, and RPC handlers schedule a best-effort telemetry
+   * flush capped at two seconds.
    */
   readonly eventLayer?: Layer.Layer<REvent, EventLayerError, WorkerBaseContext<RRuntime>>;
   readonly fetch?: Effect.Effect<WorkerFetchSuccess, unknown, WorkerFetchContext<RRuntime | REvent>>;
@@ -794,8 +797,10 @@ interface FetchHandler<Env extends WorkerEnv = WorkerEnv> {
   readonly fetch: (request: Request, env: Env, ctx: globalThis.ExecutionContext) => Promise<Response>;
 }
 /**
- * The layer is built once per Worker instance and reused for its events.
- * Eviction skips finalizers, so use `eventLayer` for per-event resources.
+ * Cloudflare creates a new `WorkerEntrypoint` instance for each native
+ * invocation, so this base layer is not shared across invocations. Its managed
+ * runtime has no deterministic disposal point in this adapter; use
+ * `eventLayer` for resources whose finalizers must run with an event.
  */
 declare function make<ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, fetch: WorkerHandler<ROut>): WorkerClass<Record<never, never>, ROut>;
 declare function make<ROut, LayerError, REvent, EventLayerError = never, const Rpc extends WorkerRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptionsWithEventLayer<ROut, REvent, EventLayerError, Rpc>): WorkerClass<Rpc, ROut | REvent>;
@@ -804,12 +809,13 @@ declare function make<ROut, LayerError, REvent extends never = never, EventLayer
  * Creates an `ExportedHandler`-compatible `{ fetch }` object backed by
  * {@link make}.
  *
- * The Effect runtime is cached per `env` identity, so the user layer builds
- * once per isolate instead of once per request. `ExecutionContext`-backed
- * services (`Worker.ExecutionContext`, `Worker.WorkerContext`) are still
- * provided fresh for every request. Layer finalizers do not run when the
- * isolate is evicted; Cloudflare provides no shutdown hook. Use `eventLayer`
- * for resources that must be finalized per event.
+ * The Effect runtime is cached per `env` identity, so the base layer builds
+ * once for that cached handler. Request handlers and `eventLayer` receive fresh
+ * `ExecutionContext` and `WorkerContext` services. A service constructed by the
+ * cached base layer from either context instead captures the first request's
+ * value, so construct invocation-bound services in `eventLayer`. Cloudflare
+ * provides no isolate shutdown hook, so cached base-layer finalizers are not
+ * guaranteed to run.
  */
 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>;

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-CrEunfQ-.mjs";
-import { o as WorkflowInstanceStatusName } from "./WorkflowBinding-BumVQTuW.mjs";
+import { n as DurableObjectStateService, t as DurableObjectState } from "./DurableObjectState-DpYdNZgT.mjs";
+import { o as WorkflowInstanceStatusName } from "./WorkflowBinding-Cn3AuUyP.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,5 @@
 import { a as WorkerEnvironment, i as WorkerConfig } from "./ErrorMessage-Byx2OgNd.mjs";
-import { r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-De4ZojhY.mjs";
+import { l as runNativeCallback, r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-DcqElJ4e.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";
@@ -63,12 +63,10 @@ const queue = Effect.fn("effect-cf/vitest/queue")(function* (Worker, queueName,
 * passed to `use` for direct access.
 */
 const runInDurableObject = Effect.fn("effect-cf/vitest/runInDurableObject")(function* (stub, use) {
-	const context = yield* Effect.context();
-	return yield* yield* Effect.promise(() => runInDurableObject$1(stub, (instance, nativeState) => {
+	return yield* yield* runNativeCallback((run) => runInDurableObject$1(stub, (instance, nativeState) => {
 		const state = fromDurableObjectState(nativeState);
-		const effect = Effect.provideService(use(instance, state), DurableObjectState, state);
-		return Effect.runPromiseExitWith(context)(effect);
-	}));
+		return run(Effect.provideService(Effect.suspend(() => use(instance, state)), DurableObjectState, state));
+	})).pipe(Effect.orDie);
 });
 const runDurableObjectAlarm = Effect.fn("effect-cf/vitest/runDurableObjectAlarm")(function* (stub) {
 	return yield* Effect.promise(() => runDurableObjectAlarm$1(stub));
@@ -119,12 +117,11 @@ const wrapWorkflowModifier = (modifier) => ({
 	forceEventTimeout: (step) => Effect.promise(() => modifier.forceEventTimeout(step))
 });
 const runWorkflowModifier = Effect.fnUntraced(function* (register, use) {
-	const context = yield* Effect.context();
-	return yield* yield* Effect.promise(async () => {
+	return yield* yield* runNativeCallback(async (run) => {
 		let callbackExit;
 		try {
 			await register(async (modifier) => {
-				callbackExit = await Effect.runPromiseExitWith(context)(use(wrapWorkflowModifier(modifier)));
+				callbackExit = await run(Effect.suspend(() => use(wrapWorkflowModifier(modifier))));
 				if (Exit.isFailure(callbackExit)) throw callbackExit;
 			});
 		} catch (cause) {
@@ -133,7 +130,7 @@ const runWorkflowModifier = Effect.fnUntraced(function* (register, use) {
 		}
 		if (callbackExit === void 0) throw new Error("The Workers Vitest plugin did not invoke the Workflow modifier callback");
 		return callbackExit;
-	});
+	}).pipe(Effect.orDie);
 });
 const wrapWorkflowInstanceIntrospector = (introspector) => ({
 	raw: introspector,

package/dist/{WorkflowBinding-BumVQTuW.d.mts → WorkflowBinding-Cn3AuUyP.d.mts}

@@ -1,5 +1,5 @@
 import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-DKcLrQCM.mjs";
-import { w as ServiceFreeSchema } from "./DurableObjectState-CrEunfQ-.mjs";
+import { w as ServiceFreeSchema } from "./DurableObjectState-DpYdNZgT.mjs";
 import { Context, Effect, Option, Schema } from "effect";
 declare namespace WorkflowBinding_d_exports {
   export { WorkflowBindingClient, WorkflowBindingDefinition, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowInstanceEvent, WorkflowInstanceLocationHint, WorkflowInstanceRestartOptions, WorkflowInstanceStatus, WorkflowInstanceStatusName, WorkflowInstanceTerminateOptions, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer, makeClient };

package/dist/index.d.mts

@@ -1,9 +1,9 @@
 import { a as Environment_d_exports, c as WorkerEnvironment, i as Binding_d_exports, n as BindingService, o as WorkerConfig, r as BindingValidationError, s as WorkerEnv, t as BindingNotFoundError } from "./Binding-DKcLrQCM.mjs";
 import { l as Artifacts_d_exports } from "./Artifacts-B3r3RuTB.mjs";
-import { A as DurableWebSocket, C as RpcDefinition_d_exports, D as AcceptUpgradeOptions, E as Rpc_d_exports, M as DurableObjectStorage_d_exports, N as StorageOperationError, O as AcceptedUpgrade, S as ReservedMethodName$2, T as Provider, _ as Queue_d_exports, a as NativeRequest, b as Definition$4, c as WorkerDefinition_d_exports, d as AsyncMethodCloudflareReturn, f as AsyncMethodKey, g as RpcTracing_d_exports, h as RpcInvocationInfo, i as ExecutionContext, j as DurableWebSocketAttachmentError, k as DurableObjectWebSocket_d_exports, l as ServiceBinding_d_exports, m as ReceiverOptions, o as WorkerContext, p as AsyncMethodSuccess, r as DurableObjectState_d_exports, s as Worker_d_exports, t as DurableObjectState, u as AsyncMethodArgs, v as QueueDefinition_d_exports, w as ServiceFreeSchema$1, x as Method$2, y as QueueBinding_d_exports } from "./DurableObjectState-CrEunfQ-.mjs";
+import { A as DurableWebSocket, C as RpcDefinition_d_exports, D as AcceptUpgradeOptions, E as Rpc_d_exports, M as DurableObjectStorage_d_exports, N as StorageOperationError, O as AcceptedUpgrade, S as ReservedMethodName$2, T as Provider, _ as Queue_d_exports, a as NativeRequest, b as Definition$4, c as WorkerDefinition_d_exports, d as AsyncMethodCloudflareReturn, f as AsyncMethodKey, g as RpcTracing_d_exports, h as RpcInvocationInfo, i as ExecutionContext, j as DurableWebSocketAttachmentError, k as DurableObjectWebSocket_d_exports, l as ServiceBinding_d_exports, m as ReceiverOptions, o as WorkerContext, p as AsyncMethodSuccess, r as DurableObjectState_d_exports, s as Worker_d_exports, t as DurableObjectState, u as AsyncMethodArgs, v as QueueDefinition_d_exports, w as ServiceFreeSchema$1, x as Method$2, y as QueueBinding_d_exports } from "./DurableObjectState-DpYdNZgT.mjs";
 import { t as Hyperdrive_d_exports } from "./Hyperdrive-HrwFlZ6x.mjs";
 import { t as ContainerNamespace_d_exports } from "./ContainerNamespace-DbLaeFhN.mjs";
-import { a as WorkflowInstanceCreateOptions, i as WorkflowInstanceCreateBatchOptions, n as WorkflowBinding_d_exports, r as WorkflowInstance, s as WorkflowOperationError, t as WorkflowBindingClient } from "./WorkflowBinding-BumVQTuW.mjs";
+import { a as WorkflowInstanceCreateOptions, i as WorkflowInstanceCreateBatchOptions, n as WorkflowBinding_d_exports, r as WorkflowInstance, s as WorkflowOperationError, t as WorkflowBindingClient } from "./WorkflowBinding-Cn3AuUyP.mjs";
 import { Cause, Config, Context, Data, DateTime, Duration, Effect, Layer, Option, Predicate, Redacted, Schema, Scope } from "effect";
 import { Headers as Headers$1, HttpClient, HttpClientResponse } from "effect/unstable/http";
 import { OtlpExporter, OtlpResource } from "effect/unstable/observability";
@@ -513,6 +513,8 @@ declare const layerProtobuf: (options?: Omit<LayerOptions$9, "serialization">) =
  *
  * Provide this layer at runtime scope for long-lived metrics aggregation, or at
  * handler scope when traces/logs should flush as the Cloudflare event finishes.
+ * A handler-scoped exporter can delay scope closure while its own finalizer
+ * flushes; the two-second background flush limit does not bound layer shutdown.
  */
 declare const layerWorker: (options?: WorkerLayerOptions) => Layer.Layer<OtlpExporter.Flusher>;
 /**
@@ -660,7 +662,7 @@ type DurableObjectNamespaceEffectClient<Api extends object, Definition extends D
    * Use this for RPC methods that return Cloudflare RPC resources or other
    * disposable objects whose lifetime should be tied to an Effect scope.
    */
-  readonly scopedCall: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, unknown, Scope.Scope>;
+  readonly scopedCall: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, DurableObjectRpcError, Scope.Scope>;
   /**
    * Exposes the underlying native Durable Object namespace binding.
    *
@@ -679,7 +681,7 @@ type DurableObjectNamespaceStaticClient<R, Api extends object, Definition extend
   readonly fetch: (stub: DurableObjectStubClient<Api>, input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
   readonly rpc: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodCloudflareReturn<Api, Method>, DurableObjectRpcError, R>;
   readonly call: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, R>;
-  readonly scopedCall: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, unknown, Scope.Scope | R>;
+  readonly scopedCall: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, DurableObjectRpcError, Scope.Scope | R>;
   readonly rawUnsafe: () => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
 };
 declare const isDurableObjectNamespaceClient: <Api extends object>(value: NamespaceCandidate) => value is DurableObjectNamespaceClient<Api>;
@@ -842,6 +844,12 @@ interface DurableObjectOptions<RRuntime, REvent = never, EventLayerError = never
 type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (state: globalThis.DurableObjectState, env: WorkerEnv) => DurableObject<WorkerEnv> & DurableObjectRpcApi<Rpc, ROut> & {
   [RunSymbol]<A, E>(effect: Effect.Effect<A, E, HandlerContext<ROut>>, options?: RunOptions): Promise<A>;
 };
+/**
+ * Builds a Durable Object whose base `layer` lives for the in-memory instance.
+ * Cloudflare does not expose an eviction or shutdown hook, so finalizers in
+ * that layer are not guaranteed to run. Put resources that require timely
+ * release in `eventLayer`, whose scope closes after each handled event.
+ */
 declare const make$6: <ROut, LayerError, REvent = never, EventLayerError = never, const Rpc extends DurableObjectRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options?: DurableObjectOptions<ROut, REvent, EventLayerError, Rpc>) => DurableObjectClass<Rpc, ROut | REvent>;
 declare namespace DurableObjectAlarm_d_exports {
   export { AlarmDefinitionConfig, AlarmDefinitionEntry, AlarmDefinitionPayload, AlarmDefinitions, AlarmFailurePolicy, AlarmPayload, AlarmPayloadSchema, AlarmRef, AlarmRetryPolicy, AlarmScheduler, DefinedAlarmEvent, DefinedAlarmHandlers, DurableObjectAlarm, DurableObjectAlarmError, DurableObjectAlarmEvent, InvalidAlarmPayloadError, InvalidAlarmRefError, InvalidProcessDueAlarmsOptionsError, InvalidRepeatEveryError, ProcessDueAlarmsFailure, ProcessDueAlarmsFailureAction, ProcessDueAlarmsHandler, ProcessDueAlarmsMode, ProcessDueAlarmsOptions, ProcessDueAlarmsResult, ScheduleAlarmInput, StoredAlarmDecodeError, define, processDue };