effect-cf 0.34.0 → 0.36.0

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

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