effect-cf 0.27.0 → 0.28.0

package/dist/ComputerWorkspaceHost.d.mts

@@ -1,4 +1,4 @@
-import { t as ArtifactsBinding } from "./Artifacts-DcoXcRP5.mjs";
+import { t as ArtifactsBinding } from "./Artifacts-DnHQA-Ax.mjs";
 import { GitClientFactory } from "@cloudflare/computer/git";
 import { DurableObjectStorageLike, SyncRetryIntent, SyncRetryOptions, SyncRetryScheduler, WithWorkspaceCtor, WorkspaceAttributeValue, WorkspaceAttributes, WorkspaceObserver, WorkspaceOptions, WorkspaceRegisteredBackend, WorkspaceRetryPendingSyncResult, WorkspaceServiceProxy, WorkspaceSpan } from "@cloudflare/computer";
 import { ShellModuleGroup, WorkerShellBackendOptions, WorkerShellLoader, WorkspaceEgressPolicy } from "@cloudflare/computer/backends/worker-shell";

package/dist/ComputerWorkspaceHost.mjs

@@ -18,24 +18,26 @@ const toWorkspaceOptions = (config) => {
 			egress: egress ?? { mode: "none" }
 		}));
 	}
-	return {
+	const options = {
 		storage: config.storage,
-		git: config.git ?? createGitClient(),
-		...config.gitIdentity === void 0 ? {} : { defaultGitIdentity: config.gitIdentity },
-		...backends.length === 0 ? {} : { backends },
-		...config.sessionId === void 0 ? {} : { sessionId: config.sessionId },
-		...config.mounts === void 0 ? {} : { mounts: config.mounts },
-		...config.observer === void 0 ? {} : { observer: config.observer },
-		...config.retryScheduler === void 0 ? {} : { retryScheduler: config.retryScheduler },
-		...config.retry === void 0 ? {} : { retry: config.retry },
-		...config.assets === void 0 ? {} : { assets: config.assets },
-		...config.artifacts === void 0 ? {} : { artifacts: {
-			binding: config.artifacts.binding,
-			...config.artifacts.sessionId === void 0 ? {} : { sessionId: config.artifacts.sessionId }
-		} },
-		...config.now === void 0 ? {} : { now: config.now },
-		...config.useThink === void 0 ? {} : { useThink: config.useThink }
+		git: config.git ?? createGitClient()
 	};
+	if (config.gitIdentity !== void 0) options.defaultGitIdentity = config.gitIdentity;
+	if (backends.length !== 0) options.backends = backends;
+	if (config.sessionId !== void 0) options.sessionId = config.sessionId;
+	if (config.mounts !== void 0) options.mounts = config.mounts;
+	if (config.observer !== void 0) options.observer = config.observer;
+	if (config.retryScheduler !== void 0) options.retryScheduler = config.retryScheduler;
+	if (config.retry !== void 0) options.retry = config.retry;
+	if (config.assets !== void 0) options.assets = config.assets;
+	if (config.artifacts !== void 0) {
+		const artifacts = { binding: config.artifacts.binding };
+		if (config.artifacts.sessionId !== void 0) artifacts.sessionId = config.artifacts.sessionId;
+		options.artifacts = artifacts;
+	}
+	if (config.now !== void 0) options.now = config.now;
+	if (config.useThink !== void 0) options.useThink = config.useThink;
+	return options;
 };
 const HostArguments = Symbol("effect-cf/ComputerWorkspaceHost/arguments");
 /**

package/dist/{DurableObjectState-biHrHwrh.d.mts → DurableObjectState-B3uFY1eM.d.mts}

@@ -1,5 +1,5 @@
-import { c as WorkerEnvironment, n as BindingService, r as BindingValidationError, s as WorkerEnv, t as BindingNotFoundError } from "./Binding-COCtoJXa.mjs";
-import { Cause, Context, Effect, Layer, Option, Schema, Scope } from "effect";
+import { c as WorkerEnvironment, n as BindingService, r as BindingValidationError, s as WorkerEnv, t as BindingNotFoundError } from "./Binding-xJJJPmiD.mjs";
+import { Cause, Context, Effect, Layer, Option, Predicate, Schema, Scope } from "effect";
 import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import { RpcStub, RpcTarget, WorkerEntrypoint } from "cloudflare:workers";
 declare namespace DurableObjectStorage_d_exports {
@@ -236,13 +236,13 @@ declare const attachment: <const AttachmentSchema extends Schema.Codec<any, any,
 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, error: unknown) => Effect.Effect<void, E, R>;
+  readonly error?: (socket: DurableWebSocket, cause: unknown) => Effect.Effect<void, E, R>;
 }
 /** Maps compact websocket lifecycle handler names to `DurableObject.make` options. */
 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, error: unknown) => Effect.Effect<void, E, R>) | undefined;
+  webSocketError: ((socket: DurableWebSocket, cause: unknown) => Effect.Effect<void, E, R>) | undefined;
 };
 declare namespace Rpc_d_exports {
   export { DisposableValue, MethodArgs, MethodKey, MethodReturn, Provider, Result$1 as Result, RpcStub, RpcTarget, Serializable, Stub, Stubable, Stubify, dispose, isDisposable, resolve, scoped };
@@ -252,20 +252,19 @@ type Stub<T extends Stubable> = Rpc.Stub<T>;
 type Provider<T extends object, Reserved extends string = never> = Rpc.Provider<T, Reserved>;
 type BaseType = void | undefined | null | boolean | number | bigint | string | TypedArray | ArrayBuffer | DataView | Date | Error | RegExp | ReadableStream<Uint8Array> | WritableStream<Uint8Array> | Request | Response | Headers;
 type Serializable<T> = BaseType | Map<T extends Map<infer Key, unknown> ? Serializable<Key> : never, T extends Map<unknown, infer Value> ? Serializable<Value> : never> | Set<T extends Set<infer Value> ? Serializable<Value> : never> | ReadonlyArray<T extends ReadonlyArray<infer Value> ? Serializable<Value> : never> | { [Key in keyof T]: Key extends number | string ? Serializable<T[Key]> : never; } | Stub<Stubable> | Stubable;
-type Stubify<T> = T extends Stubable ? Stub<T> : T extends Map<infer Key, infer Value> ? Map<Stubify<Key>, Stubify<Value>> : T extends Set<infer Value> ? Set<Stubify<Value>> : T extends Array<infer Value> ? Array<Stubify<Value>> : T extends ReadonlyArray<infer Value> ? ReadonlyArray<Stubify<Value>> : T extends BaseType ? T : T extends {
-  [key: string | number]: unknown;
-} ? { [Key in keyof T]: Stubify<T[Key]>; } : T;
+type Stubify<T> = T extends Stubable ? Stub<T> : T extends Map<infer Key, infer Value> ? Map<Stubify<Key>, Stubify<Value>> : T extends Set<infer Value> ? Set<Stubify<Value>> : T extends Array<infer Value> ? Array<Stubify<Value>> : T extends ReadonlyArray<infer Value> ? ReadonlyArray<Stubify<Value>> : T extends BaseType ? T : T extends Record<string | number, infer _Value> ? { [Key in keyof T]: Stubify<T[Key]>; } : T;
 type MaybeProvider<T> = T extends object ? Provider<T> : unknown;
 type MaybeDisposable<T> = T extends object ? Disposable : unknown;
 type Result$1<T> = T extends Stubable ? Promise<Stub<T>> & Provider<T> : T extends Serializable<T> ? Promise<Stubify<T> & MaybeDisposable<T>> & MaybeProvider<T> : never;
-type MethodKey<Api> = { [Key in keyof Api]-?: Key extends string ? Api[Key] extends ((...args: Array<any>) => unknown) ? Key : never : never; }[keyof Api];
-type MethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => unknown) ? Args : never;
+type MethodKey<Api> = { [Key in keyof Api]-?: Key extends string ? Api[Key] extends ((...args: Array<any>) => any) ? Key : never : never; }[keyof Api];
+type MethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => any) ? Args : never;
 type MethodReturn<Api, Method extends keyof Api> = Api[Method] extends ((...args: Array<any>) => infer Return) ? Return : never;
 type DisposableValue = {
   [Symbol.dispose](): void;
 };
-declare const isDisposable: (value: unknown) => value is DisposableValue;
-declare const dispose: (value: unknown) => Effect.Effect<void>;
+type RpcBoundaryValue = Schema.Schema.Type<typeof Schema.Unknown>;
+declare const isDisposable: (value: RpcBoundaryValue) => value is DisposableValue;
+declare const dispose: (value: RpcBoundaryValue) => Effect.Effect<void>;
 declare const resolve: <A>(value: A) => Effect.Effect<Awaited<A>, unknown>;
 declare const scoped: <A>(value: A) => Effect.Effect<Awaited<A>, unknown, Scope.Scope>;
 declare namespace RpcDefinition_d_exports {
@@ -327,14 +326,15 @@ declare class RpcSuccessEncodeError extends RpcSuccessEncodeError_base {
 }
 /** Errors raised server-side that must survive the Cloudflare RPC wire. */
 type WireError = RpcArgumentCountError | RpcArgumentDecodeError | RpcSuccessEncodeError;
-declare const isWireError: (error: unknown) => error is WireError;
+type WireValue = Schema.Schema.Type<typeof Schema.Unknown>;
+declare const isWireError: (error: WireValue) => error is WireError;
 /**
  * Encodes package RPC errors into a plain `Error` envelope so their tags
  * survive Cloudflare RPC serialization, which drops custom error properties.
  */
-declare const encodeWireError: (error: unknown) => unknown;
+declare const encodeWireError: (error: WireValue) => WireValue;
 /** Restores package RPC errors from the {@link encodeWireError} envelope. */
-declare const decodeWireError: (cause: unknown) => unknown;
+declare const decodeWireError: (cause: WireValue) => WireValue;
 declare const reservedMethodNames: Set<string>;
 type ReservedMethodName$3 = "constructor" | "fetch" | "connect" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError" | "then" | "dup" | "dispose" | "serialize" | "deserialize";
 type ServiceFreeSchema$1 = Schema.Codec<any, any, never, never>;
@@ -350,14 +350,14 @@ declare namespace Method$2 {
   export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
   export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
   export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
-  export type EncodedSuccess<Self extends Any> = Schema.Json;
+  export type EncodedSuccess<_Self extends Any> = Schema.Json;
   export {};
 }
 type Methods$1 = Record<string, Method$2.Any>;
-type NoReservedMethods$1<MethodsShape extends Methods$1, Reserved extends string = ReservedMethodName$3> = Extract<keyof MethodsShape, Reserved> extends never ? MethodsShape : never;
-interface Definition$3<Id extends string = string, MethodsShape extends Methods$1 = Methods$1> {
+type NoReservedMethods$1<MethodDefinitions extends Methods$1, Reserved extends string = ReservedMethodName$3> = Extract<keyof MethodDefinitions, Reserved> extends never ? MethodDefinitions : never;
+interface Definition$3<Id extends string = string, MethodDefinitions extends Methods$1 = Methods$1> {
   readonly id: Id;
-  readonly methods: MethodsShape;
+  readonly methods: MethodDefinitions;
 }
 declare namespace Definition$3 {
   type Any = Definition$3<string, Methods$1>;
@@ -365,7 +365,8 @@ declare namespace Definition$3 {
   type Api<Self extends Any, Reserved extends string = never> = Provider<ServerApi<Self>, Reserved>;
   type MethodNames<Self extends Any> = Extract<keyof Self["methods"], string>;
 }
-declare const assertNoReservedMethods: (target: string, methods: Record<string, unknown>, reserved: ReadonlySet<string>) => void;
+type ReservedMethodValue = Schema.Schema.Type<typeof Schema.Unknown>;
+declare const assertNoReservedMethods: <MethodDefinitions extends Readonly<Record<string, ReservedMethodValue>>>(target: string, methods: MethodDefinitions, reserved: ReadonlySet<string>) => void;
 declare function method$1<Success extends ServiceFreeSchema$1>(definition: {
   readonly success: Success;
 }): Method$2<readonly [], Success>;
@@ -376,8 +377,8 @@ declare function method$1<const Args extends ReadonlyArray<ServiceFreeSchema$1>,
 declare const decodeArgs: <const Self extends Definition$3.Any, MethodName extends Definition$3.MethodNames<Self>>(definition: Self, methodName: MethodName, args: readonly unknown[]) => Effect.Effect<Self["methods"][MethodName]["args"] extends (infer T) ? T extends Self["methods"][MethodName]["args"] ? T extends readonly [] ? [] : T extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ... /*elided*/ any] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<T[number]>[] : never : never, RpcArgumentCountError | RpcArgumentDecodeError, never>;
 declare const encodeArgs: <const Self extends Definition$3.Any, MethodName extends Definition$3.MethodNames<Self>>(definition: Self, methodName: MethodName, args: Self["methods"][MethodName]["args"] extends (infer T) ? T extends Self["methods"][MethodName]["args"] ? T extends readonly [] ? [] : T extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ...Tail extends readonly [] ? [] : Tail extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends readonly ServiceFreeSchema$1[]] ? [Schema.Schema.Type<Head>, ... /*elided*/ any] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<Tail[number]>[]] : Schema.Schema.Type<T[number]>[] : never : never) => Effect.Effect<Self["methods"][MethodName]["args"] extends (infer T_1 extends readonly ServiceFreeSchema$1[]) ? { [Index in keyof T_1]: Schema.Json; } : never, RpcArgumentCountError | RpcArgumentEncodeError, never>;
 declare const encodeSuccess: <const Self extends Definition$3.Any, MethodName extends Definition$3.MethodNames<Self>>(definition: Self, methodName: MethodName, value: Method$2.Success<Self["methods"][MethodName]>) => Effect.Effect<Method$2.EncodedSuccess<Self["methods"][MethodName]>, RpcSuccessEncodeError>;
-declare const decodeSuccess: <const Self extends Definition$3.Any, MethodName extends Definition$3.MethodNames<Self>>(definition: Self, methodName: MethodName, value: unknown) => Effect.Effect<Method$2.Success<Self["methods"][MethodName]>, RpcSuccessDecodeError>;
-declare const make$3: <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape) => Definition$3<Id, MethodsShape>;
+declare const decodeSuccess: <const Self extends Definition$3.Any, MethodName extends Definition$3.MethodNames<Self>>(definition: Self, methodName: MethodName, value: WireValue) => Effect.Effect<Method$2.Success<Self["methods"][MethodName]>, RpcSuccessDecodeError>;
+declare const make$3: <Id extends string, const MethodDefinitions extends Methods$1>(id: Id, methods: MethodDefinitions) => Definition$3<Id, MethodDefinitions>;
 declare namespace QueueBinding_d_exports {
   export { MessageSendRequest, QueueBindingClient, QueueBindingDefinition, QueueMetrics, QueueOperationError, QueueProducer, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer$1 as layer, makeClient$1 as makeClient };
 }
@@ -388,6 +389,7 @@ type QueueSendBatchResponse = CloudflareQueueSendBatchResponse;
 type QueueMetrics = CloudflareQueueMetrics;
 type MessageSendRequest<Body> = CloudflareMessageSendRequest<Body>;
 type QueueProducer<Body> = Pick<CloudflareQueue<Body>, "send"> & Partial<Pick<CloudflareQueue<Body>, "sendBatch" | "metrics">>;
+type QueueCandidate = Parameters<typeof Predicate.isUnknown>[0];
 interface QueueBindingDefinition<Message extends ServiceFreeSchema$1> {
   /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
@@ -398,7 +400,7 @@ interface QueueBindingClient<Message extends ServiceFreeSchema$1> {
   readonly send: (message: Schema.Schema.Type<Message>, options?: QueueSendOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError>;
   readonly sendBatch: (messages: Iterable<MessageSendRequest<Schema.Schema.Type<Message>>>, options?: QueueSendBatchOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError>;
   readonly metrics: () => Effect.Effect<QueueMetrics, QueueOperationError>;
-  readonly rawUnsafe: Effect.Effect<CloudflareQueue<Schema.Codec.Encoded<Message>>>;
+  readonly rawUnsafe: Effect.Effect<QueueProducer<Schema.Codec.Encoded<Message>>>;
 }
 declare const QueueOperationError_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: "QueueOperationError";
@@ -409,7 +411,7 @@ declare class QueueOperationError extends QueueOperationError_base<{
   readonly cause: unknown;
   readonly message: string;
 }> {}
-declare const isQueue: <Body>(value: unknown) => value is QueueProducer<Body>;
+declare const isQueue: <Body>(value: QueueCandidate) => value is QueueProducer<Body>;
 declare const makeClient$1: <Message extends ServiceFreeSchema$1>(definition: QueueBindingDefinition<Message>) => ((queue: QueueProducer<Schema.Codec.Encoded<Message>>) => QueueBindingClient<Message>);
 declare const layer$1: <Self, Message extends ServiceFreeSchema$1>(tag: Context.Service<Self, QueueBindingClient<Message>>, definition: QueueBindingDefinition<Message>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare namespace QueueDefinition_d_exports {
@@ -423,7 +425,7 @@ declare namespace Definition$2 {
   type Any = Definition$2<string, ServiceFreeSchema$1>;
 }
 type Handler$1<ROut, Self extends Definition$2.Any> = (batch: QueueBatch<Schema.Schema.Type<Self["message"]>>) => Effect.Effect<void, unknown, ExecutionContext | WorkerContext | WorkerEnvironment | Scope.Scope | ROut>;
-interface Options$2<ROut, Self extends Definition$2.Any> extends Omit<WorkerOptions<ROut, Record<never, never>>, "queue" | "rpc"> {
+interface Options$2<ROut, Self extends Definition$2.Any> extends Omit<WorkerOptions<ROut, never, never, Record<never, never>>, "queue" | "rpc"> {
   readonly queue: Handler$1<ROut, Self>;
   readonly rpc?: never;
 }
@@ -438,7 +440,7 @@ interface TagClass$2<Self, Id extends string, Message extends ServiceFreeSchema$
   readonly send: (message: Schema.Schema.Type<Message>, options?: QueueSendOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError, Self>;
   readonly sendBatch: (messages: Iterable<MessageSendRequest<Schema.Schema.Type<Message>>>, options?: QueueSendBatchOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError, Self>;
   readonly metrics: () => Effect.Effect<QueueMetrics, QueueOperationError, Self>;
-  readonly rawUnsafe: Effect.Effect<globalThis.Queue<Schema.Codec.Encoded<Message>>, never, Self>;
+  readonly rawUnsafe: Effect.Effect<QueueProducer<Schema.Codec.Encoded<Message>>, never, Self>;
 }
 declare const make$2: <Id extends string, Message extends ServiceFreeSchema$1>(id: Id, definition: {
   readonly message: Message;
@@ -481,6 +483,7 @@ declare class QueueMessageDecodeError extends QueueMessageDecodeError_base<{
 }
 type RuntimeContext<ROut> = ExecutionContext | WorkerContext | WorkerEnvironment | ROut;
 type QueueHandlerContext<ROut> = RuntimeContext<ROut> | Scope.Scope;
+type EncodedQueueBody = globalThis.Message<unknown>["body"];
 type QueueHandler<ROut, Body = unknown> = (batch: QueueBatch<Body>) => Effect.Effect<void, unknown, QueueHandlerContext<ROut>>;
 interface QueueOptions<ROut, Body = unknown> {
   readonly queue: QueueHandler<ROut, Body>;
@@ -495,7 +498,7 @@ declare const fromMessage: <Body>(message: globalThis.Message<unknown>, body: Bo
   retry: (options?: globalThis.QueueRetryOptions) => Effect.Effect<void, never, never>;
 };
 declare const fromMessageBatch: <Body>(batch: globalThis.MessageBatch<unknown>, messages: ReadonlyArray<QueueMessage<Body>>) => QueueBatch<Body>;
-declare const decodeBatch: <Body>(batch: globalThis.MessageBatch<unknown>, decodeBody: (body: unknown) => Effect.Effect<Body, unknown>) => Effect.Effect<QueueBatch<Body>, QueueMessageDecodeError>;
+declare const decodeBatch: <Body>(batch: globalThis.MessageBatch<unknown>, decodeBody: (body: EncodedQueueBody) => Effect.Effect<Body, unknown>) => Effect.Effect<QueueBatch<Body>, QueueMessageDecodeError>;
 type Definition$1<Id extends string = string, Message extends Definition$2.Any["message"] = Definition$2.Any["message"]> = Definition$2<Id, Message>;
 declare namespace Definition$1 {
   type Any = Definition$2.Any;
@@ -511,8 +514,8 @@ type Options$1<ROut, Self extends Definition$2.Any> = Options$2<ROut, Self>;
 //#endregion
 //#region src/internal/RpcInvocation.d.ts
 type AnyArgs = Array<any>;
-type AsyncMethodKey<Api> = { [Key in keyof Api]-?: Key extends string ? Api[Key] extends ((...args: AnyArgs) => Promise<unknown>) ? Key : never : never; }[keyof Api];
-type AsyncMethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => Promise<unknown>) ? Args : never;
+type AsyncMethodKey<Api> = { [Key in keyof Api]-?: Key extends string ? Api[Key] extends ((...args: AnyArgs) => Promise<any>) ? Key : never : never; }[keyof Api];
+type AsyncMethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => Promise<any>) ? Args : never;
 type AsyncMethodSuccess<Api, Method extends keyof Api> = Api[Method] extends ((...args: AnyArgs) => Promise<infer A>) ? A : never;
 type AsyncMethodCloudflareReturn<Api, Method extends keyof Api> = Result$1<AsyncMethodSuccess<Api, Method>>;
 declare namespace ServiceBinding_d_exports {
@@ -525,22 +528,22 @@ declare const TypeId: "effect-cf/ServiceBinding";
 interface ServiceFetcher {
   fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
 }
-type RpcClient<Api> = { readonly [Key in keyof Api as Key extends string ? Api[Key] extends ((...args: Array<any>) => unknown) ? Key : never : never]: Api[Key]; };
+type RpcClient<Api> = { readonly [Key in keyof Api as Key extends string ? Api[Key] extends ((...args: Array<any>) => any) ? Key : never : never]: Api[Key]; };
 type ReservedMethodName$2 = ReservedMethodName$1 | "fetch";
 /**
  * Native Cloudflare service object including optional RPC methods.
  */
 type ServiceBindingClient<Api extends object> = ServiceFetcher & RpcClient<Provider<Api, ReservedMethodName$2>>;
-type ApiFromDefinition<Definition$4> = Definition$4 extends Definition.Any ? ServerApi$1<Definition$4> : never;
+type ApiFromDefinition<Definition$12> = Definition$12 extends Definition.Any ? ServerApi$1<Definition$12> : never;
 type ApiOrDefinition<Api extends object, Definition> = [Api] extends [never] ? ApiFromDefinition<Definition> : Api;
 /**
  * Binding metadata used to create an Effect service from a Worker binding.
  */
-interface ServiceBindingDefinition<Definition$9 extends Definition.Any | undefined = undefined> {
+interface ServiceBindingDefinition<Definition$8 extends Definition.Any | undefined = undefined> {
   /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
   /** Optional RPC schema used for argument/result encoding. */
-  readonly definition?: Definition$9;
+  readonly definition?: Definition$8;
 }
 declare const ServiceBindingFetchError_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: "ServiceBindingFetchError";
@@ -572,9 +575,9 @@ type ServiceMethodArgs<Api, Method extends keyof Api> = AsyncMethodArgs<Api, Met
 type ServiceMethodSuccess<Api, Method extends keyof Api> = AsyncMethodSuccess<Api, Method>;
 type ServiceMethodCloudflareReturn<Api, Method extends keyof Api> = AsyncMethodCloudflareReturn<Api, Method>;
 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$13 extends Definition.Any> = { readonly [Method in Definition$3.MethodNames<Definition$13>]: (...args: Method$2.Args<Definition$13["methods"][Method]>) => Effect.Effect<Method$2.Success<Definition$13["methods"][Method]>, ServiceBindingRpcError, R>; };
+type DefinitionDirectMethods<R, Definition$11 extends Definition.Any> = { readonly [Method in Definition$3.MethodNames<Definition$11>]: (...args: Method$2.Args<Definition$11["methods"][Method]>) => Effect.Effect<Method$2.Success<Definition$11["methods"][Method]>, ServiceBindingRpcError, R>; };
 type DirectMethods<R, Definition$10> = Definition$10 extends Definition.Any ? DefinitionDirectMethods<R, Definition$10> : {};
-type ServiceBindingEffectClient<Api extends object, Definition$6 extends Definition.Any | undefined = undefined> = DirectMethods<never, Definition$6> & {
+type ServiceBindingEffectClient<Api extends object, Definition$4 extends Definition.Any | undefined = undefined> = DirectMethods<never, Definition$4> & {
   /**
    * Forwards an HTTP request to the bound Worker service.
    *
@@ -659,15 +662,16 @@ type ServiceBindingEffectClient<Api extends object, Definition$6 extends Definit
    */
   readonly scopedCall: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, unknown, Scope.Scope>;
 };
-type ServiceBindingStaticClient<R, Api extends object, Definition$7 extends Definition.Any | undefined = undefined> = DirectMethods<R, Definition$7> & {
+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>;
 };
-declare const isServiceBindingClient: <Api extends object>(value: unknown) => value is ServiceBindingClient<Api>;
-declare const makeClient: <Api extends object, const Definition$8 extends Definition.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition$8>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition$8>);
-declare const layer: <Self, Api extends object, const Definition$12 extends Definition.Any | undefined = undefined>(tag: Context.Service<Self, ServiceBindingEffectClient<Api, Definition$12>>, definition: ServiceBindingDefinition<Definition$12>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+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$13 extends Definition.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition$13>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition$13>);
+declare const layer: <Self, Api extends object, const Definition$6 extends Definition.Any | undefined = undefined>(tag: Context.Service<Self, ServiceBindingEffectClient<Api, Definition$6>>, definition: ServiceBindingDefinition<Definition$6>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 /**
  * Creates a typed Effect service for a Worker service binding.
  *
@@ -697,15 +701,15 @@ declare const layer: <Self, Api extends object, const Definition$12 extends Defi
  * });
  * ```
  */
-declare const Service: <Self, Api extends object = never>() => <Id extends string, const Definition$5 extends Definition.Any | undefined = undefined>(id: Id, definition: ServiceBindingDefinition<Definition$5>) => BindingService<Self, Id, ServiceBindingEffectClient<ApiOrDefinition<Api, Definition$5>, Definition$5>> & DirectMethods<Self, Definition$5> & {
+declare const Service: <Self, Api extends object = never>() => <Id extends string, const Definition$9 extends Definition.Any | undefined = undefined>(id: Id, definition: ServiceBindingDefinition<Definition$9>) => BindingService<Self, Id, ServiceBindingEffectClient<ApiOrDefinition<Api, Definition$9>, Definition$9>> & DirectMethods<Self, Definition$9> & {
   readonly [TypeId]: typeof TypeId;
-  readonly definition: ServiceBindingDefinition<Definition$5>;
+  readonly definition: ServiceBindingDefinition<Definition$9>;
   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$5>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$5>, Method>) => Effect.Effect<Result$1<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$5>, Method>>, ServiceBindingRpcError, Self>;
-  readonly call: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$5>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$5>, Method>) => Effect.Effect<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$5>, Method>, ServiceBindingRpcError, Self>;
-  readonly scopedCall: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$5>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$5>, Method>) => Effect.Effect<Awaited<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$5>, Method>>, unknown, Self | Scope.Scope>;
+  readonly rpc: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$9>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$9>, Method>) => Effect.Effect<Result$1<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$9>, Method>>, ServiceBindingRpcError, Self>;
+  readonly call: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$9>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$9>, Method>) => Effect.Effect<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$9>, Method>, ServiceBindingRpcError, Self>;
+  readonly scopedCall: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition$9>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition$9>, Method>) => Effect.Effect<Awaited<AsyncMethodSuccess<ApiOrDefinition<Api, Definition$9>, Method>>, unknown, Self | Scope.Scope>;
 };
-declare const makeDirectMethods: <R, Api, Definition$11 extends Definition.Any | undefined>(rpcDefinition: Definition$11 | undefined, call: ServiceCall<R, Api>) => DirectMethods<R, Definition$11>;
+declare const makeDirectMethods: <R, Api, Definition$7 extends Definition.Any | undefined>(rpcDefinition: Definition$7 | undefined, call: ServiceCall<R, Api>) => DirectMethods<R, Definition$7>;
 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 };
 }
@@ -722,7 +726,7 @@ declare namespace Method$1 {
   export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
   export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
   export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
-  export type EncodedSuccess<Self extends Any> = Schema.Json;
+  export type EncodedSuccess<_Self extends Any> = Schema.Json;
   export {};
 }
 type Methods = Record<string, Method$1.Any>;
@@ -732,15 +736,15 @@ type Methods = Record<string, Method$1.Any>;
  * Create with {@link make} and reuse to type both worker implementations and
  * service bindings in other workers.
  */
-interface Definition<Id extends string = string, MethodsShape extends Methods = Methods> {
+interface Definition<Id extends string = string, MethodDefinitions extends Methods = Methods> {
   readonly id: Id;
-  readonly methods: MethodsShape;
+  readonly methods: MethodDefinitions;
 }
 declare namespace Definition {
   type Any = Definition<string, Methods>;
 }
 type ReservedMethodName$1 = ReservedMethodName;
-type NoReservedMethods<MethodsShape extends Methods> = Extract<keyof MethodsShape, ReservedMethodName$1> extends never ? MethodsShape : never;
+type NoReservedMethods<MethodDefinitions extends Methods> = Extract<keyof MethodDefinitions, ReservedMethodName$1> extends never ? MethodDefinitions : never;
 /**
  * Promise-based client API derived from a {@link Definition}.
  */
@@ -750,19 +754,28 @@ type Api<Self extends Definition.Any> = Provider<ServerApi$1<Self>, ReservedMeth
  * Effect handlers for each RPC method in a worker definition.
  */
 type Handlers<ROut, Self extends Definition.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$1.Args<Self["methods"][Key]>) => WorkerRpcHandler<ROut, Method$1.Success<Self["methods"][Key]>>; };
+type BaseOptions<ROut, Self extends Definition.Any, REvent, EventLayerError> = Omit<WorkerOptions<ROut, REvent, EventLayerError, Handlers<ROut | REvent, Self>>, "eventLayer" | "rpc"> & {
+  readonly rpc: Handlers<ROut | REvent, Self>;
+};
+type EventLayerOptions<ROut, REvent, EventLayerError> = [REvent] extends [never] ? Pick<WorkerOptions<ROut, never, EventLayerError>, "eventLayer"> : {
+  readonly eventLayer: NonNullable<WorkerOptions<ROut, REvent, EventLayerError>["eventLayer"]>;
+};
 /**
  * Worker constructor options for a specific RPC definition.
  */
-interface Options<ROut, Self extends Definition.Any, REvent = never, EventLayerError = never> extends Omit<WorkerOptions<ROut, REvent, EventLayerError, Handlers<ROut | REvent, Self>>, "rpc"> {
-  readonly rpc: Handlers<ROut | REvent, Self>;
-}
+type Options<ROut, Self extends Definition.Any, REvent = never, EventLayerError = never> = BaseOptions<ROut, Self, REvent, EventLayerError> & EventLayerOptions<ROut, REvent, EventLayerError>;
 type LayerOptions = {
   readonly binding: string;
 };
-type TagClass<Self, Id extends string, MethodsShape extends Methods> = Context.ServiceClass<Self, Id, ServiceBindingEffectClient<Api<Definition<Id, MethodsShape>>, Definition<Id, MethodsShape>>> & ServiceBindingStaticClient<Self, Api<Definition<Id, MethodsShape>>, Definition<Id, MethodsShape>> & {
+type TagClass<Self, Id extends string, MethodDefinitions extends Methods> = Context.ServiceClass<Self, Id, ServiceBindingEffectClient<Api<Definition<Id, MethodDefinitions>>, Definition<Id, MethodDefinitions>>> & ServiceBindingStaticClient<Self, Api<Definition<Id, MethodDefinitions>>, Definition<Id, MethodDefinitions>> & {
   readonly id: Id;
-  readonly methods: MethodsShape;
-  readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options<ROut, Definition<Id, MethodsShape>, REvent, EventLayerError>) => WorkerClass<Handlers<ROut | REvent, Definition<Id, MethodsShape>>, ROut | REvent>;
+  readonly methods: MethodDefinitions;
+  readonly make: {
+    <ROut, LayerError, REvent, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options<ROut, Definition<Id, MethodDefinitions>, REvent, EventLayerError> & {
+      readonly eventLayer: NonNullable<WorkerOptions<ROut, REvent, EventLayerError>["eventLayer"]>;
+    }): WorkerClass<Handlers<ROut | REvent, Definition<Id, MethodDefinitions>>, ROut | REvent>;
+    <ROut, LayerError, REvent extends never = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options<ROut, Definition<Id, MethodDefinitions>, REvent, EventLayerError>): WorkerClass<Handlers<ROut | REvent, Definition<Id, MethodDefinitions>>, ROut | REvent>;
+  };
   readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
 /**
@@ -777,8 +790,8 @@ declare const method: {
     readonly success: Success;
   }): Method$1<Args, Success>;
 };
-declare const make$1: <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape>) => TagClass<Definition<Id, MethodsShape>, Id, MethodsShape>;
-declare const Tag: <Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape>) => TagClass<Self, Id, MethodsShape>;
+declare const make$1: <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>) => TagClass<Definition<Id, MethodDefinitions>, Id, MethodDefinitions>;
+declare const Tag: <Self>() => <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>) => TagClass<Self, Id, MethodDefinitions>;
 declare const Worker: typeof Tag;
 /**
  * Helper for implementing handlers with the exact method shape of a definition.
@@ -789,7 +802,7 @@ declare const implement: <ROut, const Self extends Definition.Any>(_definition:
  */
 type HandlerEffect<ROut, Self extends Definition.Any, Key extends keyof Self["methods"]> = WorkerRpcHandler<ROut, Method$1.Success<Self["methods"][Key]>>;
 declare namespace Worker_d_exports {
-  export { Api, Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect, Handlers, LayerOptions, Method$1 as Method, Methods, NativeRequest, NoReservedMethods, Options, ReservedMethodName, RpcHandlers, ServerApi$1 as ServerApi, ServiceFreeSchema, Tag, TagClass, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcHandler, WorkerRpcShape, implement, isWebSocketUpgrade, make, makeFetchHandler, method };
+  export { Api, Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect, Handlers, LayerOptions, Method$1 as Method, Methods, NativeRequest, NoReservedMethods, Options, ReservedMethodName, RpcHandlers, ServerApi$1 as ServerApi, ServiceFreeSchema, Tag, TagClass, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcContract, WorkerRpcHandler, WorkerRpcContract as WorkerRpcShape, implement, isWebSocketUpgrade, make, makeFetchHandler, method };
 }
 declare const ExecutionContext_base: Context.ServiceClass<ExecutionContext, "effect-cf/ExecutionContext", globalThis.ExecutionContext<unknown>>;
 /**
@@ -845,6 +858,7 @@ type ReservedMethodName = ReservedMethodName$3 | "fetch" | "connect" | "queue" |
 type WorkerBaseContext<ROut> = ExecutionContext | WorkerContext | WorkerEnvironment | ROut;
 type WorkerFetchContext<ROut> = WorkerBaseContext<ROut> | NativeRequest | HttpServerRequest.HttpServerRequest | Scope.Scope;
 type WorkerRpcContext<ROut> = WorkerBaseContext<ROut> | Scope.Scope;
+declare const FetchSymbol: unique symbol;
 /**
  * Successful result of a worker fetch handler: either a native `Response`
  * (returned to Cloudflare untouched) or an Effect `HttpServerResponse`
@@ -863,8 +877,8 @@ type WorkerRpcHandler<ROut, A = unknown> = Effect.Effect<A, unknown, WorkerRpcCo
  * Shape of worker RPC handlers passed to {@link make}.
  */
 type WorkerRpc<ROut> = Record<string, (...args: Array<any>) => WorkerRpcHandler<ROut>>;
-type WorkerRpcShape<Rpc extends WorkerRpc<ROut>, ROut> = { readonly [Key in keyof Rpc]: Rpc[Key] extends ((...args: infer Args) => Effect.Effect<infer A, unknown, WorkerRpcContext<ROut>>) ? (...args: Args) => Promise<A> : never; };
-type RpcHandlers<ROut, Api> = { readonly [Key in keyof Api as Key extends keyof WorkerEntrypoint ? never : Key extends string ? Key extends ReservedMethodName ? never : [Api[Key]] extends [never] ? never : Api[Key] extends ((...args: Array<any>) => Promise<unknown>) ? Key : never : never]: Api[Key] extends ((...args: infer Args) => Promise<infer A>) ? (...args: Args) => WorkerRpcHandler<ROut, A> : never; };
+type WorkerRpcContract<Rpc extends WorkerRpc<ROut>, ROut> = { readonly [Key in keyof Rpc]: Rpc[Key] extends ((...args: infer Args) => Effect.Effect<infer A, unknown, WorkerRpcContext<ROut>>) ? (...args: Args) => Promise<A> : never; };
+type RpcHandlers<ROut, Api> = { readonly [Key in keyof Api as Key extends keyof WorkerEntrypoint ? never : Key extends string ? Key extends ReservedMethodName ? never : [Api[Key]] extends [never] ? never : Api[Key] extends ((...args: Array<any>) => Promise<any>) ? Key : never : never]: Api[Key] extends ((...args: infer Args) => Promise<infer A>) ? (...args: Args) => WorkerRpcHandler<ROut, A> : never; };
 /**
  * Options for creating a worker class with Effect handlers.
  */
@@ -889,16 +903,23 @@ interface WorkerOptions<RRuntime, REvent = never, EventLayerError = never, Rpc e
    */
   readonly rpc?: Rpc;
 }
+type WorkerOptionsWithEventLayer<RRuntime, REvent, EventLayerError, Rpc extends WorkerRpc<RRuntime | REvent> = Record<never, never>> = Omit<WorkerOptions<RRuntime, REvent, EventLayerError, Rpc>, "eventLayer"> & {
+  readonly eventLayer: Layer.Layer<REvent, EventLayerError, WorkerBaseContext<RRuntime>>;
+};
 type FetchWorkerOptions<RRuntime, REvent = never, EventLayerError = never> = Omit<WorkerOptions<RRuntime, REvent, EventLayerError, Record<never, never>>, "rpc"> & {
   readonly rpc?: never;
 };
+type FetchWorkerOptionsWithEventLayer<RRuntime, REvent, EventLayerError> = Omit<FetchWorkerOptions<RRuntime, REvent, EventLayerError>, "eventLayer"> & {
+  readonly eventLayer: Layer.Layer<REvent, EventLayerError, WorkerBaseContext<RRuntime>>;
+};
 /**
  * Cloudflare `WorkerEntrypoint` constructor produced by {@link make}.
  */
 type WorkerClass<Rpc extends WorkerRpc<ROut>, ROut> = new (ctx: globalThis.ExecutionContext, env: WorkerEnv) => WorkerEntrypoint<WorkerEnv> & {
   fetch(request: Request): Promise<Response>;
   queue(batch: globalThis.MessageBatch): Promise<void>;
-} & WorkerRpcShape<Rpc, ROut>;
+  [FetchSymbol](request: Request, requestContext: globalThis.ExecutionContext): Promise<Response>;
+} & WorkerRpcContract<Rpc, ROut>;
 /**
  * `ExportedHandler`-compatible fetch object produced by {@link makeFetchHandler}.
  */
@@ -921,7 +942,8 @@ interface FetchHandler<Env extends WorkerEnv = WorkerEnv> {
  * ```
  */
 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 = never, EventLayerError = never, const Rpc extends WorkerRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptions<ROut, REvent, EventLayerError, Rpc>): WorkerClass<Rpc, ROut | REvent>;
+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>;
+declare function make<ROut, LayerError, REvent extends never = never, EventLayerError = never, const Rpc extends WorkerRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptions<ROut, REvent, EventLayerError, Rpc>): WorkerClass<Rpc, ROut | REvent>;
 /**
  * Creates an `ExportedHandler`-compatible `{ fetch }` object backed by
  * {@link make}.
@@ -933,7 +955,8 @@ declare function make<ROut, LayerError, REvent = never, EventLayerError = never,
  * isolate is evicted; Cloudflare provides no shutdown hook. Use `eventLayer`
  * for resources that must be finalized per event.
  */
-declare const makeFetchHandler: <ROut, LayerError, REvent = never, EventLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptions<ROut, REvent, EventLayerError>) => FetchHandler<Env>;
+declare function makeFetchHandler<ROut, LayerError, REvent, EventLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptionsWithEventLayer<ROut, REvent, EventLayerError>): FetchHandler<Env>;
+declare function makeFetchHandler<ROut, LayerError, REvent extends never = never, EventLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptions<ROut, REvent, EventLayerError>): FetchHandler<Env>;
 declare namespace DurableObjectState_d_exports {
   export { DurableObjectState, DurableObjectStateService, fromDurableObjectState };
 }

package/dist/{DurableObjectState-Dux8KfjG.mjs → DurableObjectState-BjkK2kwH.mjs}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { t as causeMessage } from "./ErrorMessage-_lg53p3W.mjs";
-import { Cause, Context, Data, Effect, Exit, Option, Result, Schema } from "effect";
+import { t as causeMessage } from "./ErrorMessage-BM0K-Nik.mjs";
+import { Cause, Context, Data, Effect, Exit, Option, Predicate, Result, Schema } from "effect";
 //#region src/DurableObjectStorage.ts
 var DurableObjectStorage_exports = /* @__PURE__ */ __exportAll({
 	StorageOperationError: () => StorageOperationError,
@@ -80,7 +80,7 @@ const fromSyncKvStorage = (kv) => ({
 const fromDurableObjectTransaction = (txn) => ({
 	get: (keyOrKeys, options) => Array.isArray(keyOrKeys) ? tryStoragePromise("transaction.get", () => txn.get(keyOrKeys, options)) : tryStoragePromise("transaction.get", () => txn.get(keyOrKeys, options)),
 	list: (options) => tryStoragePromise("transaction.list", () => txn.list(options)),
-	put: (keyOrEntries, valueOrOptions, maybeOptions) => tryStoragePromise("transaction.put", () => typeof keyOrEntries === "string" ? txn.put(keyOrEntries, valueOrOptions, maybeOptions) : txn.put(keyOrEntries, valueOrOptions)),
+	put: (keyOrEntries, valueOrOptions, maybeOptions) => tryStoragePromise("transaction.put", () => Predicate.isString(keyOrEntries) ? txn.put(keyOrEntries, valueOrOptions, maybeOptions) : txn.put(keyOrEntries, valueOrOptions)),
 	delete: (keyOrKeys, options) => Array.isArray(keyOrKeys) ? tryStoragePromise("transaction.delete", () => txn.delete(keyOrKeys, options)) : tryStoragePromise("transaction.delete", () => txn.delete(keyOrKeys, options)),
 	rollback: () => tryStorageSync("transaction.rollback", () => txn.rollback()),
 	getAlarm: (options) => tryStoragePromise("transaction.getAlarm", () => txn.getAlarm(options)),

package/dist/{ErrorMessage-_lg53p3W.mjs → ErrorMessage-BM0K-Nik.mjs}

@@ -33,10 +33,7 @@ let WorkerConfig;
 * for use in tagged error `message` getters.
 */
 const causeMessage = (cause) => {
-	if (typeof cause === "object" && cause !== null) {
-		const message = Reflect.get(cause, "message");
-		if (typeof message === "string" && message.length > 0) return message;
-	}
+	if (Predicate.hasProperty(cause, "message") && Predicate.isString(cause.message) && cause.message.length > 0) return cause.message;
 	try {
 		return String(cause);
 	} catch {

package/dist/{Hyperdrive-6p59yyVk.d.mts → Hyperdrive-z-9fFz15.d.mts}

@@ -1,4 +1,4 @@
-import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-COCtoJXa.mjs";
+import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-xJJJPmiD.mjs";
 import { Context, Effect, Layer } from "effect";
 declare namespace Hyperdrive_d_exports {
   export { HyperdriveClient, HyperdriveDefinition, HyperdriveService, LayerOptions, Tag, TagClass, isHyperdrive, layer, make, makeClient };
@@ -27,7 +27,7 @@ interface TagClass<Self, Id extends string> extends Context.ServiceClass<Self, I
   readonly id: Id;
   readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
-declare const isHyperdrive: (value: unknown) => value is Hyperdrive;
+declare const isHyperdrive: <Candidate>(value: Candidate) => value is Candidate & Hyperdrive;
 declare const makeClient: (definition: HyperdriveDefinition) => (hyperdrive: Hyperdrive) => HyperdriveClient;
 declare const layer: <Self>(tag: Context.Service<Self, HyperdriveClient>, definition: HyperdriveDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make: <Id extends string>(id: Id) => TagClass<HyperdriveService<Id>, Id>;

package/dist/HyperdrivePg.d.mts

@@ -1,5 +1,5 @@
-import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-COCtoJXa.mjs";
-import { n as LayerOptions, r as TagClass } from "./Hyperdrive-6p59yyVk.mjs";
+import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-xJJJPmiD.mjs";
+import { n as LayerOptions, r as TagClass } from "./Hyperdrive-z-9fFz15.mjs";
 import { Layer } from "effect";
 import { PgClient } from "@effect/sql-pg";
 import { SqlClient, SqlError } from "effect/unstable/sql";

package/dist/Vitest.d.mts

@@ -1,7 +1,7 @@
-import { c as WorkerEnvironment, s as WorkerEnv } from "./Binding-COCtoJXa.mjs";
-import { n as DurableObjectStateService, t as DurableObjectState } from "./DurableObjectState-biHrHwrh.mjs";
-import { o as WorkflowInstanceStatusName } from "./WorkflowBinding-zlRPCXVf.mjs";
-import { Effect, Layer } from "effect";
+import { c as WorkerEnvironment, s as WorkerEnv } from "./Binding-xJJJPmiD.mjs";
+import { n as DurableObjectStateService, t as DurableObjectState } from "./DurableObjectState-B3uFY1eM.mjs";
+import { o as WorkflowInstanceStatusName } from "./WorkflowBinding-wZ-yGHow.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";
 //#region src/Vitest.d.ts
@@ -155,12 +155,13 @@ interface WorkflowMockEvent {
 interface WorkflowInstanceModifier {
   readonly disableSleeps: (steps?: ReadonlyArray<WorkflowStepTarget>) => Effect.Effect<void>;
   readonly disableRetryDelays: (steps?: ReadonlyArray<WorkflowStepTarget>) => Effect.Effect<void>;
-  readonly mockStepResult: (step: WorkflowStepTarget, result: unknown) => Effect.Effect<void>;
+  readonly mockStepResult: (step: WorkflowStepTarget, result: WorkflowMockResult) => Effect.Effect<void>;
   readonly mockStepError: (step: WorkflowStepTarget, error: Error, times?: number) => Effect.Effect<void>;
   readonly forceStepTimeout: (step: WorkflowStepTarget, times?: number) => Effect.Effect<void>;
   readonly mockEvent: (event: WorkflowMockEvent) => Effect.Effect<void>;
   readonly forceEventTimeout: (step: WorkflowStepTarget) => Effect.Effect<void>;
 }
+type WorkflowMockResult = Schema.Schema.Type<typeof Schema.Unknown>;
 /** Effect-native introspector for one Workflow instance. */
 interface WorkflowInstanceIntrospector {
   readonly raw: NativeWorkflowInstanceIntrospector;

package/dist/Vitest.mjs

@@ -1,5 +1,5 @@
-import { a as WorkerEnvironment, i as WorkerConfig } from "./ErrorMessage-_lg53p3W.mjs";
-import { r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-Dux8KfjG.mjs";
+import { a as WorkerEnvironment, i as WorkerConfig } from "./ErrorMessage-BM0K-Nik.mjs";
+import { r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-BjkK2kwH.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";