effect-cf 0.33.0 → 0.35.0

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-xJJJPmiD.mjs";
-import { l as Artifacts_d_exports } from "./Artifacts-DnHQA-Ax.mjs";
-import { A as StorageOperationError, C as Rpc_d_exports, D as DurableWebSocket, E as DurableObjectWebSocket_d_exports, O as DurableWebSocketAttachmentError, S as Provider, T as AcceptedUpgrade, _ as Definition$4, a as NativeRequest, b as RpcDefinition_d_exports, c as WorkerDefinition_d_exports, d as AsyncMethodCloudflareReturn, f as AsyncMethodKey, g as QueueBinding_d_exports, h as QueueDefinition_d_exports, i as ExecutionContext, k as DurableObjectStorage_d_exports, l as ServiceBinding_d_exports, m as Queue_d_exports, o as WorkerContext, p as AsyncMethodSuccess, r as DurableObjectState_d_exports, s as Worker_d_exports, t as DurableObjectState, u as AsyncMethodArgs, v as Method$2, w as AcceptUpgradeOptions, x as ServiceFreeSchema$1, y as ReservedMethodName$2 } from "./DurableObjectState-BpRjz6-q.mjs";
-import { t as Hyperdrive_d_exports } from "./Hyperdrive-z-9fFz15.mjs";
-import { t as ContainerNamespace_d_exports } from "./ContainerNamespace-CFjiLw8b.mjs";
-import { a as WorkflowInstanceCreateOptions, i as WorkflowInstanceCreateBatchOptions, n as WorkflowBinding_d_exports, r as WorkflowInstance, s as WorkflowOperationError, t as WorkflowBindingClient } from "./WorkflowBinding-lBR4_-op.mjs";
+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-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-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";
@@ -14,14 +14,13 @@ import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 import * as RpcServer from "effect/unstable/rpc/RpcServer";
 import { SqliteClient } from "@effect/sql-sqlite-do";
 import { SqlClient } from "effect/unstable/sql";
-import * as Tracer from "effect/Tracer";
+import * as Tracer$1 from "effect/Tracer";
 declare namespace WorkersAi_d_exports {
   export { LayerOptions$13 as LayerOptions, Tag$12 as Tag, TagClass$11 as TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, embeddingResponse, isWorkersAiBinding, layer$13 as layer, make$12 as make, makeClient$10 as makeClient };
 }
 declare const WorkersAiOperationError_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: "WorkersAiOperationError";
 } & Readonly<A>;
-/** Error raised when a Workers AI operation fails. */
 declare class WorkersAiOperationError extends WorkersAiOperationError_base<{
   readonly binding: string;
   readonly operation: string;
@@ -29,9 +28,7 @@ declare class WorkersAiOperationError extends WorkersAiOperationError_base<{
 }> {
   get message(): string;
 }
-/** Typed Workers AI binding definition. */
 interface WorkersAiDefinition {
-  /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
 }
 type WorkersAiBinding<ModelList extends AiModelListType = AiModels> = CloudflareAi<ModelList>;
@@ -72,7 +69,6 @@ interface WorkersAiClient<ModelList extends AiModelListType = AiModels> {
   readonly definition: WorkersAiDefinition;
 }
 declare const WorkersAiServiceTypeId: unique symbol;
-/** Nominal service marker for Workers AI services created with {@link make}. */
 interface WorkersAiService<Id extends string> {
   readonly [WorkersAiServiceTypeId]: {
     readonly id: Id;
@@ -101,7 +97,6 @@ declare namespace AiGateway_d_exports {
 declare const AiGatewayOperationError_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: "AiGatewayOperationError";
 } & Readonly<A>;
-/** Error raised when an AI Gateway operation fails. */
 declare class AiGatewayOperationError extends AiGatewayOperationError_base<{
   readonly binding: string;
   readonly operation: string;
@@ -109,13 +104,9 @@ declare class AiGatewayOperationError extends AiGatewayOperationError_base<{
 }> {
   get message(): string;
 }
-/** Typed AI Gateway client definition. */
 interface AiGatewayDefinition {
-  /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
-  /** Gateway id/name passed to `env.AI.gateway(id)`. */
   readonly gatewayId: string;
-  /** Optional account id used by the HTTP-only helper. */
   readonly accountId?: string;
 }
 type AiGatewayBinding = CloudflareAiGateway;
@@ -142,7 +133,6 @@ interface AiGatewayClient {
   readonly definition: AiGatewayDefinition;
 }
 declare const AiGatewayServiceTypeId: unique symbol;
-/** Nominal service marker for AI Gateway services created with {@link make}. */
 interface AiGatewayService<Id extends string> {
   readonly [AiGatewayServiceTypeId]: {
     readonly id: Id;
@@ -204,7 +194,6 @@ declare const AnalyticsEngineDataPointSchema: Schema.Struct<{
 declare const AnalyticsEngineOperationError_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: "AnalyticsEngineOperationError";
 } & Readonly<A>;
-/** Error raised when an Analytics Engine operation fails. */
 declare class AnalyticsEngineOperationError extends AnalyticsEngineOperationError_base<{
   readonly binding: string;
   readonly operation: string;
@@ -221,7 +210,6 @@ interface AnalyticsEngineWriteViolation {
 declare const AnalyticsEngineWriteValidationError_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: "AnalyticsEngineWriteValidationError";
 } & Readonly<A>;
-/** Error raised when an Analytics Engine write input violates Cloudflare limits. */
 declare class AnalyticsEngineWriteValidationError extends AnalyticsEngineWriteValidationError_base<{
   readonly binding: string;
   readonly operation: string;
@@ -233,7 +221,6 @@ declare class AnalyticsEngineWriteValidationError extends AnalyticsEngineWriteVa
 declare const AnalyticsEngineQueryError_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: "AnalyticsEngineQueryError";
 } & Readonly<A>;
-/** Error raised when an Analytics Engine SQL API query fails. */
 declare class AnalyticsEngineQueryError extends AnalyticsEngineQueryError_base<{
   readonly operation: string;
   readonly accountId: string;
@@ -242,9 +229,7 @@ declare class AnalyticsEngineQueryError extends AnalyticsEngineQueryError_base<{
   readonly body?: string;
   readonly cause?: unknown;
 }> {}
-/** Typed Analytics Engine dataset binding definition. */
 interface AnalyticsEngineDefinition {
-  /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
 }
 type AnalyticsEngineBinding = CloudflareAnalyticsEngineDataset;
@@ -268,11 +253,9 @@ interface AnalyticsEngineQueryResult<Row = AnalyticsEngineQueryRow> {
   readonly rows: number;
 }
 interface AnalyticsEngineQueryDefinition {
-  /** Cloudflare account id that owns the Analytics Engine datasets. */
   readonly accountId: string;
   /** API token with Account Analytics Read permission. */
   readonly apiToken: Redacted.Redacted<string>;
-  /** Base Cloudflare API URL. Defaults to `https://api.cloudflare.com/client/v4`. */
   readonly apiBaseUrl?: string | URL;
 }
 interface AnalyticsEngineQueryOptions {
@@ -296,13 +279,11 @@ interface AnalyticsEngineQueryClient {
 }
 declare const AnalyticsEngineServiceTypeId: unique symbol;
 declare const AnalyticsEngineQueryServiceTypeId: unique symbol;
-/** Nominal service marker for Analytics Engine services created with {@link make}. */
 interface AnalyticsEngineService<Id extends string> {
   readonly [AnalyticsEngineServiceTypeId]: {
     readonly id: Id;
   };
 }
-/** Nominal service marker for Analytics Engine query services created with {@link makeQuery}. */
 interface AnalyticsEngineQueryService<Id extends string> {
   readonly [AnalyticsEngineQueryServiceTypeId]: {
     readonly id: Id;
@@ -351,7 +332,6 @@ declare namespace BrowserRendering_d_exports {
 declare const BrowserRenderingOperationError_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: "BrowserRenderingOperationError";
 } & Readonly<A>;
-/** Error raised when a Browser Rendering operation fails. */
 declare class BrowserRenderingOperationError extends BrowserRenderingOperationError_base<{
   readonly binding: string;
   readonly operation: string;
@@ -359,9 +339,7 @@ declare class BrowserRenderingOperationError extends BrowserRenderingOperationEr
 }> {
   get message(): string;
 }
-/** Typed Browser Rendering binding definition. */
 interface BrowserRenderingDefinition {
-  /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
 }
 type BrowserRenderingBinding = object;
@@ -409,7 +387,6 @@ interface BrowserRenderingClient<RawBinding extends BrowserRenderingBinding = Br
   readonly definition: BrowserRenderingDefinition;
 }
 declare const BrowserRenderingServiceTypeId: unique symbol;
-/** Nominal service marker for Browser Rendering services created with {@link make}. */
 interface BrowserRenderingService<Id extends string> {
   readonly [BrowserRenderingServiceTypeId]: {
     readonly id: Id;
@@ -430,16 +407,12 @@ declare const Tag$9: <Self>() => <Id extends string>(id: Id) => TagClass$8<Self,
 declare namespace Cache_d_exports {
   export { CacheClient, CacheOperation, CacheOperationError, CacheQueryOptions, CacheRequest, CacheStorage, CacheStorageClient, layer$9 as layer, layerFrom, makeCacheClient, makeClient$6 as makeClient };
 }
-/** Request key accepted by Cloudflare's Cache API. */
 type CacheRequest = CloudflareRequestInfo | URL;
-/** Query options supported by Cloudflare's Cache API. */
 type CacheQueryOptions = CloudflareCacheQueryOptions;
-/** Cache operation represented by {@link CacheOperationError}. */
 type CacheOperation = "open" | "match" | "put" | "delete";
 declare const CacheOperationError_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: "CacheOperationError";
 } & Readonly<A>;
-/** Error raised when a Cloudflare Cache API operation fails. */
 declare class CacheOperationError extends CacheOperationError_base<{
   readonly cache: string;
   readonly operation: CacheOperation;
@@ -447,38 +420,23 @@ declare class CacheOperationError extends CacheOperationError_base<{
 }> {
   get message(): string;
 }
-/** Effect wrapper around one Cloudflare `Cache` instance. */
 interface CacheClient {
-  /** Cache name (`default` for `caches.default`). */
   readonly name: string;
-  /** Finds a cached response, mapping cache misses to `Option.none()`. */
   readonly match: (request: CacheRequest, options?: CacheQueryOptions) => Effect.Effect<Option.Option<Response>, CacheOperationError>;
-  /** Stores a response under the request key. */
   readonly put: (request: CacheRequest, response: Response) => Effect.Effect<void, CacheOperationError>;
-  /** Deletes a cached response and reports whether it existed. */
   readonly delete: (request: CacheRequest, options?: CacheQueryOptions) => Effect.Effect<boolean, CacheOperationError>;
-  /** Access to the native Cloudflare `Cache` instance. */
   readonly rawUnsafe: Effect.Effect<CloudflareCache>;
 }
-/** Effect wrapper around Cloudflare's global `caches` object. */
 interface CacheStorageClient {
-  /** Cloudflare's shared default cache. */
   readonly default: CacheClient;
-  /** Opens a named cache. */
   readonly open: (name: string) => Effect.Effect<CacheClient, CacheOperationError>;
-  /** Access to the native Cloudflare `CacheStorage` instance. */
   readonly rawUnsafe: Effect.Effect<CloudflareCacheStorage>;
 }
 declare const CacheStorage_base: Context.ServiceClass<CacheStorage, "effect-cf/CacheStorage", CacheStorageClient>;
-/** Service for Cloudflare's global Cache API. */
 declare class CacheStorage extends CacheStorage_base {}
-/** Wraps a native Cloudflare `Cache` instance. */
 declare const makeCacheClient: (cache: CloudflareCache, name?: string) => CacheClient;
-/** Wraps a native Cloudflare `CacheStorage` instance. */
 declare const makeClient$6: (storage: CloudflareCacheStorage) => CacheStorageClient;
-/** Provides Cache API services from an explicit native `CacheStorage` instance. */
 declare const layerFrom: (storage: CloudflareCacheStorage) => Layer.Layer<CacheStorage>;
-/** Provides Cache API services from Cloudflare's global `caches` object. */
 declare const layer$9: Layer.Layer<CacheStorage>;
 declare namespace CloudflareOtlp_d_exports {
   export { DurableObjectLayerOptions, LayerOptions$9 as LayerOptions, ResourceOptions, Serialization, Signal, WorkerLayerOptions, layer$8 as layer, layerDurableObject, layerJson, layerProtobuf, layerWorker };
@@ -516,30 +474,16 @@ interface LayerOptions$9 {
   readonly signals?: ReadonlyArray<Signal>;
   /** OTLP payload serialization. Defaults to protobuf. */
   readonly serialization?: Serialization;
-  /** Resource metadata forwarded to Effect's OTLP resource resolver. */
   readonly resource?: ResourceOptions;
-  /**
-   * Explicit headers for every selected signal.
-   *
-   * When omitted, Effect reads `OTEL_EXPORTER_OTLP_HEADERS` and the
-   * signal-specific `OTEL_EXPORTER_OTLP_*_HEADERS` variables.
-   */
   readonly headers?: Headers$1.Input;
-  /** Exclude log records emitted for spans when exporting logs. */
   readonly loggerExcludeLogSpans?: boolean;
-  /** Merge the OTLP logger with existing loggers instead of replacing them. */
   readonly loggerMergeWithExisting?: boolean;
-  /** Custom trace context lookup used by the Effect OTLP tracer. */
-  readonly tracerContext?: <X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X;
+  readonly tracerContext?: <X>(primitive: Tracer$1.EffectPrimitive<X>, span: Tracer$1.AnySpan) => X;
 }
-/** Resource metadata specific to Cloudflare Workers. */
 interface WorkerLayerOptions extends LayerOptions$9 {
-  /** Cloudflare Worker name to attach as `cloudflare.worker.name`. */
   readonly workerName?: string;
 }
-/** Resource metadata specific to Cloudflare Durable Objects. */
 interface DurableObjectLayerOptions extends LayerOptions$9 {
-  /** Durable Object class name to attach as `cloudflare.durable_object.class`. */
   readonly className?: string;
   /**
    * Include the Durable Object id as `cloudflare.durable_object.id`.
@@ -569,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>;
 /**
@@ -584,43 +530,21 @@ declare namespace D1_d_exports {
 }
 declare const TypeId$1: "~effect-cf/D1";
 type TypeId$1 = typeof TypeId$1;
-/** Typed D1 binding definition. */
 interface D1Definition {
-  /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
 }
-/** Options forwarded to `@effect/sql-d1` when building a SQL client layer. */
 type D1SqlLayerOptions = Omit<D1Client.D1ClientConfig, "db">;
 declare const D1ServiceTypeId: unique symbol;
-/** Nominal service marker for D1 services created with {@link make}. */
 interface D1Service<Id extends string> {
   readonly [D1ServiceTypeId]: {
     readonly id: Id;
   };
 }
-/**
- * Creates a typed D1 service tag plus Effect helpers.
- */
 declare const make$8: <Id extends string>(id: Id, definition: D1Definition) => BindingService<D1Service<Id>, Id, D1Database> & {
   "~effect-cf/D1": "~effect-cf/D1";
   definition: D1Definition;
   sqlLayer: (options?: D1SqlLayerOptions) => Layer.Layer<D1Client.D1Client | SqlClient.SqlClient, Config.ConfigError | BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
-/**
- * Builds a D1 service around a Cloudflare D1 database binding.
- *
- * The returned service exposes the raw `D1Database` binding and `sqlLayer(...)`
- * for providing `effect/unstable/sql` via `@effect/sql-d1`.
- *
- * @example
- * ```ts
- * class TodoDatabase extends D1.Service<TodoDatabase>()("TodoDatabase", {
- *   binding: "TODO_DB",
- * }) {}
- *
- * const SqlLive = TodoDatabase.sqlLayer();
- * ```
- */
 declare const Service: <Self>() => <Id extends string>(id: Id, definition: D1Definition) => BindingService<Self, Id, D1Database> & {
   "~effect-cf/D1": "~effect-cf/D1";
   definition: D1Definition;
@@ -642,21 +566,12 @@ type DurableObjectStubClient<Api extends object> = DurableObjectFetcher & RpcCli
   readonly id: globalThis.DurableObjectId;
   readonly name?: string;
 };
-/**
- * Native Durable Object namespace binding shape.
- */
 interface DurableObjectNamespaceClient<Api extends object> {
-  /** Creates a globally unique Durable Object id. */
   newUniqueId(options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions): globalThis.DurableObjectId;
-  /** Deterministically maps a name to a Durable Object id. */
   idFromName(name: string): globalThis.DurableObjectId;
-  /** Rehydrates a Durable Object id from its string form. */
   idFromString(id: string): globalThis.DurableObjectId;
-  /** Returns a stub for an existing Durable Object id. */
   get(id: globalThis.DurableObjectId, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions): DurableObjectStubClient<Api>;
-  /** Returns a stub by deterministic name. */
   getByName(name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions): DurableObjectStubClient<Api>;
-  /** Selects a namespace pinned to a specific jurisdiction. */
   jurisdiction(jurisdiction: globalThis.DurableObjectJurisdiction): DurableObjectNamespaceClient<Api>;
 }
 /**
@@ -669,10 +584,10 @@ interface DurableObjectNamespaceDefinition {
  * Namespace binding metadata with optional RPC schema.
  */
 interface DurableObjectNamespaceBindingDefinition<Definition extends Definition$3.Any | undefined = undefined> {
-  /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
-  /** Optional RPC schema used for argument/result encoding. */
   readonly definition?: Definition;
+  /** Append live trace context only when the receiver also enables rpcTracing. */
+  readonly rpcTracing?: boolean;
 }
 declare const DurableObjectRpcError_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: "DurableObjectRpcError";
@@ -714,36 +629,12 @@ type DefinitionNamespaceDirectClientMethods<R, Definition extends Definition$3.A
 };
 type DirectMethods<R, Api extends object, Definition> = Definition extends Definition$3.Any ? DefinitionNamespaceDirectMethods<R, Api, Definition> & DefinitionNamespaceDirectClientMethods<R, Definition> : {};
 type DurableObjectNamespaceEffectClient<Api extends object, Definition extends Definition$3.Any | undefined = undefined> = DirectMethods<never, Api, Definition> & {
-  /** Creates a globally unique Durable Object id. */
   readonly newUniqueId: (options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions) => Effect.Effect<globalThis.DurableObjectId>;
-  /** Deterministically maps a name to a Durable Object id. */
   readonly idFromName: (name: string) => Effect.Effect<globalThis.DurableObjectId>;
-  /** Rehydrates a Durable Object id from its string form. */
   readonly idFromString: (id: string) => Effect.Effect<globalThis.DurableObjectId>;
-  /** Returns a stub for an existing Durable Object id. */
   readonly get: (id: globalThis.DurableObjectId, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>>;
-  /** Returns a stub by deterministic name. */
   readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>>;
-  /** Selects a namespace pinned to a specific jurisdiction. */
   readonly jurisdiction: (jurisdiction: globalThis.DurableObjectJurisdiction) => Effect.Effect<DurableObjectNamespaceClient<Api>>;
-  /**
-   * Forwards an HTTP request to a Durable Object stub.
-   *
-   * Use this for fetch-based Durable Object APIs, including WebSocket upgrade
-   * forwarding where the native response must be preserved.
-   *
-   * @example
-   * ```ts
-   * import { Effect } from "effect";
-   *
-   * const program = Effect.gen(function* () {
-   *   const rooms = yield* ChatRooms;
-   *   const room = yield* rooms.getByName("general");
-   *
-   *   return yield* rooms.fetch(room, new Request("https://worker.example/room"));
-   * });
-   * ```
-   */
   readonly fetch: (stub: DurableObjectStubClient<Api>, input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, DurableObjectFetchError>;
   /**
    * Invokes a Durable Object RPC method and returns Cloudflare's raw RPC result.
@@ -753,21 +644,6 @@ type DurableObjectNamespaceEffectClient<Api extends object, Definition extends D
    * promise-like value and it does not decode definition-backed success schemas.
    *
    * Most application code should use {@link call} instead.
-   *
-   * @example
-   * ```ts
-   * import { Effect } from "effect";
-   *
-   * const program = Effect.gen(function* () {
-   *   const counters = yield* Counters;
-   *   const counter = yield* counters.getByName("main");
-   *
-   *   const result = yield* counters.rpc(counter, "get");
-   *   const value = yield* Effect.promise(() => result);
-   *
-   *   return value;
-   * });
-   * ```
    */
   readonly rpc: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodCloudflareReturn<Api, Method>, DurableObjectRpcError>;
   /**
@@ -775,18 +651,6 @@ type DurableObjectNamespaceEffectClient<Api extends object, Definition extends D
    * decodes the success value when the namespace was created from a definition.
    *
    * This is the normal choice when application code wants the final typed value.
-   *
-   * @example
-   * ```ts
-   * import { Effect } from "effect";
-   *
-   * const program = Effect.gen(function* () {
-   *   const counters = yield* Counters;
-   *   const counter = yield* counters.getByName("main");
-   *
-   *   return yield* counters.call(counter, "increment", 1);
-   * });
-   * ```
    */
   readonly call: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError>;
   /**
@@ -797,23 +661,8 @@ 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.
-   *
-   * @example
-   * ```ts
-   * import { Effect } from "effect";
-   *
-   * const program = Effect.scoped(
-   *   Effect.gen(function* () {
-   *     const rooms = yield* ChatRooms;
-   *     const room = yield* rooms.getByName("general");
-   *     const handle = yield* rooms.scopedCall(room, "openStream");
-   *
-   *     return yield* handle.read();
-   *   }),
-   * );
-   * ```
    */
-  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.
    *
@@ -832,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>;
@@ -855,7 +704,6 @@ interface Method$1<Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray
 declare namespace Method$1 {
   export type Any = Method$1<ReadonlyArray<ServiceFreeSchema>, ServiceFreeSchema>;
   type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends ReadonlyArray<ServiceFreeSchema>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
-  /** Method schemas cross the wire through their canonical JSON codec. */
   type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = { [Index in keyof Args]: Schema.Json; };
   export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
   export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
@@ -893,6 +741,7 @@ interface Options$2<ROut, Self extends Definition$3.Any, REvent = never, EventLa
 }
 type LayerOptions$8 = {
   readonly binding: string;
+  readonly rpcTracing?: boolean;
 };
 type TagClass$7<Self, Id extends string, MethodDefinitions extends Methods> = Context.ServiceClass<Self, `effect-cf/DurableObject/${Id}`, DurableObjectNamespaceEffectClient<Api<Definition$3<Id, MethodDefinitions>>, Definition$3<Id, MethodDefinitions>>> & DurableObjectNamespaceStaticClient<Self, Api<Definition$3<Id, MethodDefinitions>>, Definition$3<Id, MethodDefinitions>> & {
   readonly id: Id;
@@ -922,11 +771,19 @@ declare const implement$2: <ROut, const Self extends Definition$3.Any>(_definiti
  */
 type HandlerEffect<ROut, Self extends Definition$3.Any, Key extends keyof Self["methods"]> = DurableObjectHandler<ROut, Method$1.Success<Self["methods"][Key]>>;
 declare namespace DurableObject_d_exports {
-  export { Api, Definition$3 as Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcApi, DurableObjectRpcApi as DurableObjectRpcShape, HandlerEffect, Handlers, LayerOptions$8 as LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options$2 as Options, ReservedMethodName, RpcHandlers, ServerApi, ServiceFreeSchema, Tag$8 as Tag, TagClass$7 as TagClass, implement$2 as implement, make$6 as make, method };
+  export { Api, Definition$3 as Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcApi, DurableObjectRpcApi as DurableObjectRpcShape, HandlerEffect, Handlers, LayerOptions$8 as LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options$2 as Options, ReservedMethodName, RpcHandlers, RunOptions, RunSymbol, ServerApi, ServiceFreeSchema, Tag$8 as Tag, TagClass$7 as TagClass, implement$2 as implement, make$6 as make, method };
 }
 type RuntimeContext$1<ROut> = DurableObjectState | WorkerEnvironment | ROut;
 type HandlerContext<ROut> = RuntimeContext$1<ROut> | Scope.Scope;
 type FetchContext<ROut> = HandlerContext<ROut> | NativeRequest;
+/** Metadata available before an event effect or its event layer starts. */
+interface RunOptions {
+  readonly eventLayer?: boolean;
+  readonly event?: "fetch" | "rpc" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError";
+  readonly rpc?: RpcInvocationInfo;
+}
+/** Override to instrument the whole event, then call super[RunSymbol]. */
+declare const RunSymbol: unique symbol;
 /**
  * Effect type for Durable Object lifecycle and RPC handlers.
  */
@@ -937,9 +794,6 @@ type DurableObjectHandler<ROut, A = unknown> = Effect.Effect<A, unknown, Handler
 type DurableObjectRpc<ROut> = Record<string, (...args: Array<any>) => DurableObjectHandler<ROut>>;
 type DurableObjectRpcApi<Rpc extends DurableObjectRpc<ROut>, ROut> = { readonly [Key in keyof Rpc]: Rpc[Key] extends ((...args: infer Args) => Effect.Effect<infer A, unknown, HandlerContext<ROut>>) ? (...args: Args) => Promise<A> : never; };
 type RpcHandlers<ROut, Api> = { readonly [Key in keyof Api as Key extends keyof DurableObject<WorkerEnv> ? never : Key extends string ? [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) => DurableObjectHandler<ROut, A> : never; };
-/**
- * Options for creating a Durable Object class backed by Effect handlers.
- */
 interface DurableObjectOptions<RRuntime, REvent = never, EventLayerError = never, Rpc extends DurableObjectRpc<RRuntime | REvent> = Record<never, never>> {
   /**
    * Layer provided around each Cloudflare event handled by this Durable Object.
@@ -967,15 +821,9 @@ interface DurableObjectOptions<RRuntime, REvent = never, EventLayerError = never
    * does not.
    */
   readonly rpc?: Rpc;
-  /** Optional fetch handler for HTTP/WebSocket requests. */
+  /** Accept live native trace metadata. The client must also enable rpcTracing. */
+  readonly rpcTracing?: ReceiverOptions;
   readonly fetch?: Effect.Effect<Response, unknown, FetchContext<RRuntime | REvent>>;
-  /**
-   * Optional logical alarm processing effect.
-   *
-   * This runs before `alarm` and should be built with helpers such as
-   * `DurableObjectAlarm.processDue(...)` so the reusable scheduler stays inside
-   * the Durable Object's single managed runtime boundary.
-   */
   readonly alarms?: Effect.Effect<unknown, unknown, HandlerContext<RRuntime | REvent>>;
   /**
    * Optional raw alarm handler.
@@ -993,21 +841,19 @@ interface DurableObjectOptions<RRuntime, REvent = never, EventLayerError = never
 /**
  * Cloudflare `DurableObject` constructor produced by {@link make}.
  */
-type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (state: globalThis.DurableObjectState, env: WorkerEnv) => DurableObject<WorkerEnv> & DurableObjectRpcApi<Rpc, ROut>;
+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>;
+};
 /**
- * Creates a Durable Object class backed by a single managed Effect runtime.
+ * 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 };
 }
-/**
- * JSON-serializable alarm payload stored with each scheduled alarm.
- *
- * Payloads are intentionally opaque to `DurableObjectAlarm`. Consumers should use
- * stable `tag` values to route due alarms and then decode the payload for that
- * tag in their own domain layer.
- */
 type AlarmPayload = Schema.Json;
 declare const InvalidAlarmRefError_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: "InvalidAlarmRefError";
@@ -1051,87 +897,21 @@ declare class StoredAlarmDecodeError extends StoredAlarmDecodeError_base<{
   get message(): string;
 }
 type DurableObjectAlarmError = InvalidAlarmPayloadError | InvalidAlarmRefError | InvalidProcessDueAlarmsOptionsError | InvalidRepeatEveryError | StorageOperationError | StoredAlarmDecodeError;
-/**
- * Events handled by `processDueAlarms`.
- *
- * `AlarmDue` represents one durable alarm whose scheduled time is now due. The
- * `tag` is the consumer-owned routing key, while `id` is the stable alarm id
- * within that tag.
- *
- * `scheduledAt` is the logical due-after timestamp from durable storage. It is
- * not expected to match the current Durable Object alarm invocation time,
- * especially during retries. Retries re-scan durable rows with `run_at <= now`
- * and identify logical events by `{ tag, id }`.
- *
- * @example Handling events by tag
- * ```ts
- * yield* durableObjectAlarm.processDueAlarms((event) =>
- *   event.tag === "heartbeat"
- *     ? heartbeatManager.handleAlarmEvent(event).pipe(Effect.asVoid)
- *     : Effect.void
- * );
- * ```
- */
 declare const DurableObjectAlarmEvent: Schema.TaggedUnion<{
   readonly AlarmDue: Schema.TaggedStruct<"AlarmDue", {
     readonly id: Schema.NonEmptyString;
     readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    /** Persisted due time, which can differ from the invocation time during retries. */
     readonly scheduledAt: Schema.DateTimeUtc;
     readonly tag: Schema.NonEmptyString;
   }>;
 }>;
 type DurableObjectAlarmEvent = typeof DurableObjectAlarmEvent.Type;
-/**
- * Stable reference for a scheduled alarm.
- *
- * The pair of `tag` and `id` is the durable identity. Scheduling another alarm
- * with the same pair replaces the previous alarm, and cancellation uses the
- * same pair.
- *
- * @example Cancel an alarm
- * ```ts
- * yield* durableObjectAlarm.cancelAlarm({
- *   tag: "connection-reconnect-grace",
- *   id: "reconnect-grace-check",
- * });
- * ```
- */
 type AlarmRef<Tag extends string = string> = {
   readonly id: string;
   readonly tag: Tag;
 };
-/**
- * Input for scheduling or replacing an alarm.
- *
- * `runAt` is the absolute first fire time. `repeatEvery` can be any Effect
- * `Duration.Input`, including strings like `"5 seconds"`, numbers interpreted
- * as milliseconds, or `Duration` values.
- *
- * @example One-shot alarm
- * ```ts
- * const now = yield* DateTime.now;
- *
- * yield* durableObjectAlarm.scheduleAlarm({
- *   tag: "connection-reconnect-grace",
- *   id: "reconnect-grace-check",
- *   runAt: DateTime.add(now, { seconds: 15 }),
- *   payload: { reason: "socket-closed" },
- * });
- * ```
- *
- * @example Repeating alarm
- * ```ts
- * const now = yield* DateTime.now;
- *
- * yield* durableObjectAlarm.scheduleAlarm({
- *   tag: "heartbeat",
- *   id: "heartbeat-check",
- *   runAt: DateTime.add(now, { seconds: 5 }),
- *   repeatEvery: "5 seconds",
- *   payload: null,
- * });
- * ```
- */
+/** Reusing `{tag, id}` replaces an alarm. Repeats run after success, never as fixed-cadence catch-up. */
 type ScheduleAlarmInput<Tag extends string = string> = AlarmRef<Tag> & {
   readonly payload: AlarmPayload;
   readonly repeatEvery?: Duration.Input;
@@ -1158,106 +938,19 @@ type ProcessDueAlarmsFailureAction = "ordered" | "retry" | "skip-and-advance-rep
   readonly mode: "skip-and-advance-repeat";
 };
 interface ProcessDueAlarmsOptions<OnFailureR = never, OnFailureE = never> {
-  /** Maximum due rows to load and process in one invocation. Defaults to 100. */
   readonly limit?: number;
-  /**
-   * Failure isolation mode. Defaults to `isolated` so one poison logical alarm
-   * does not block unrelated maintenance work.
-   */
+  /** `isolated` retries only the failed row; `ordered` stops before later rows. */
   readonly mode?: ProcessDueAlarmsMode;
-  /**
-   * Callback for logical handler/decode failures. Return a failure action to
-   * override the global failure behavior for this row.
-   */
   readonly onFailure?: (failure: ProcessDueAlarmsFailure) => Effect.Effect<ProcessDueAlarmsFailureAction | void, OnFailureE, OnFailureR>;
-  /**
-   * Delay before retrying a failed logical row in isolated mode. Defaults to 30
-   * seconds. Ignored by ordered mode unless supplied explicitly.
-   *
-   * Retrying updates only the selected occurrence, so replacements scheduled by
-   * a long-running handler are not clobbered by failure handling.
-   */
   readonly retryFailedAfter?: Duration.Input;
 }
-/**
- * Handler invoked for each due alarm before that alarm is acknowledged.
- *
- * If the handler fails, `DurableObjectAlarm` leaves the row due and fails the alarm
- * processing effect. Cloudflare can then retry the Durable Object alarm handler,
- * and the scheduler will find the same logical row again because `run_at` is
- * still less than or equal to the retry time.
- */
 type ProcessDueAlarmsHandler<R = never, E = never> = (event: DurableObjectAlarmEvent) => Effect.Effect<void, E, R>;
-/**
- * Durable alarm scheduler API.
- *
- * This service only owns scheduling semantics. It does not publish, subscribe,
- * or dispatch events to consumers. Durable Object alarm handlers should pass a
- * domain handler to `processDueAlarms`; rows are acknowledged only after that
- * handler succeeds.
- *
- * This service must be the only code path that owns `storage.setAlarm()` inside
- * a Durable Object instance. Cloudflare exposes one platform alarm timestamp per
- * object, so another scheduler in the same object can clobber this service's
- * reconciled alarm timestamp.
- *
- * @example Durable Object alarm handler
- * ```ts
- * const onAlarm = Effect.gen(function* () {
- *   const durableObjectAlarm = yield* DurableObjectAlarm;
- *
- *   yield* durableObjectAlarm.processDueAlarms((event) =>
- *     Effect.gen(function* () {
- *       if (event.tag === "heartbeat") {
- *         yield* heartbeatManager.handleAlarmEvent(event);
- *         return;
- *       }
- *
- *       if (event.tag === "connection-reconnect-grace") {
- *         yield* connectionManager.expireReconnectGracePeriods();
- *       }
- *     })
- *   );
- * });
- * ```
- */
+/** Own `storage.setAlarm()` exclusively: a Durable Object has one platform alarm timestamp. */
 type AlarmScheduler = {
-  /**
-   * Cancel a scheduled alarm by `{ tag, id }`.
-   *
-   * This is idempotent. Cancelling a missing alarm is a no-op. The underlying
-   * Durable Object alarm is reconciled afterward.
-   */
   readonly cancelAlarm: (input: AlarmRef) => Effect.Effect<void, InvalidAlarmRefError | StorageOperationError>;
-  /**
-   * Process due alarms according to `Clock.currentTimeMillis`.
-   *
-   * Each row is acknowledged only after `handle` succeeds. One-shot alarms are
-   * then deleted. Repeating alarms are rescheduled to `acknowledgedAt +
-   * repeatEvery`, which intentionally behaves as delay-after-success rather
-   * than fixed-cadence catch-up. Acknowledgements are conditional on the stored
-   * row still matching the selected occurrence, so a handler that reschedules
-   * the same `{ tag, id }` will not have its replacement clobbered by the old
-   * acknowledgement.
-   *
-   * Processing is ordered by `runAt` and stable alarm id. By default, logical
-   * handler/decode failures are isolated to the failing row: the row is retried
-   * after `retryFailedAfter`, later due rows still run, and the result reports
-   * both handled and failed rows. Use `mode: "ordered"` when a workflow
-   * intentionally requires strict head-of-line blocking.
-   *
-   * Handlers must still be idempotent: Cloudflare alarms are at-least-once, and
-   * if a handler succeeds but the acknowledgement write fails, the logical event
-   * can be delivered again.
-   */
+  /** Acknowledge after handling. Conditional writes preserve handler replacements; alarms are at-least-once. */
   readonly processDueAlarms: <R = never, E = never, OnFailureR = never, OnFailureE = never>(handle: ProcessDueAlarmsHandler<R, E>, options?: ProcessDueAlarmsOptions<OnFailureR, OnFailureE>) => Effect.Effect<ProcessDueAlarmsResult, E | OnFailureE | DurableObjectAlarmError, R | OnFailureR>;
-  /**
-   * Schedule or replace an alarm by `{ tag, id }`.
-   *
-   * The durable row write and underlying platform alarm reconciliation are run
-   * in one Durable Object storage transaction, so a failed `setAlarm` rolls back
-   * the logical schedule instead of leaving a stored-but-unarmed alarm.
-   */
+  /** A failed platform setAlarm rolls back the logical schedule in the same transaction. */
   readonly scheduleAlarm: (input: ScheduleAlarmInput) => Effect.Effect<void, InvalidAlarmPayloadError | InvalidAlarmRefError | InvalidRepeatEveryError | StorageOperationError>;
 };
 declare const processDue: <R = never, E = never, OnFailureR = never, OnFailureE = never>(handle: ProcessDueAlarmsHandler<R, E>, options?: ProcessDueAlarmsOptions<OnFailureR, OnFailureE>) => Effect.Effect<ProcessDueAlarmsResult, E | OnFailureE | DurableObjectAlarmError, OnFailureR | R | DurableObjectAlarm>;
@@ -1284,50 +977,6 @@ declare const define: <const Definitions extends AlarmDefinitions>(definitions:
   handlers: <R = never, E = never>(handlers: DefinedAlarmHandlers<Definitions, R, E>, options?: ProcessDueAlarmsOptions<R, E>) => Effect.Effect<ProcessDueAlarmsResult, E | DurableObjectAlarmError, R | DurableObjectAlarm>;
 };
 declare const DurableObjectAlarm_base: Context.ServiceClass<DurableObjectAlarm, "effect-cf/DurableObjectAlarm", AlarmScheduler>;
-/**
- * SQLite-backed Durable Object alarm scheduler.
- *
- * `DurableObjectAlarm` stores alarms in the current Durable Object's SQLite storage
- * and keeps the platform alarm set to the earliest pending scheduled alarm. The
- * platform alarm timestamp is only a wake-up hint; logical event identity comes
- * from persisted `{ tag, id }` rows.
- *
- * Retry safety depends on acknowledgement ordering. `processDueAlarms` runs the
- * caller's handler first and only then conditionally deletes or advances the
- * same selected row. By default, handler failures are isolated: the failed row
- * is retried after a delay, later due rows continue, and the platform alarm is
- * reconciled once at the end. Use `mode: "ordered"` for strict workflows where
- * one failed logical alarm should block later due alarms.
- *
- * Provide `DurableObjectAlarm.layer` anywhere `DurableObjectState` is available.
- *
- * @example Providing the service
- * ```ts
- * const program = Effect.gen(function* () {
- *   const durableObjectAlarm = yield* DurableObjectAlarm;
- *   const now = yield* DateTime.now;
- *
- *   yield* durableObjectAlarm.scheduleAlarm({
- *     tag: "heartbeat",
- *     id: "heartbeat-check",
- *     runAt: DateTime.add(now, { seconds: 5 }),
- *     repeatEvery: Duration.seconds(5),
- *     payload: null,
- *   });
- * }).pipe(Effect.provide(DurableObjectAlarm.layer));
- * ```
- *
- * @example Processing due alarms
- * ```ts
- * const handledEvents = yield* durableObjectAlarm.processDueAlarms((event) =>
- *   Effect.gen(function* () {
- *     if (event.tag === "heartbeat") {
- *       yield* heartbeatManager.handleAlarmEvent(event);
- *     }
- *   })
- * );
- * ```
- */
 declare class DurableObjectAlarm extends DurableObjectAlarm_base {
   static readonly layer: Layer.Layer<DurableObjectAlarm, never, DurableObjectState>;
 }
@@ -1336,13 +985,11 @@ declare namespace DurableObjectRpcWebSocket_d_exports {
 }
 /** Heartbeat handling for Effect's application-level RPC Ping messages. */
 type HeartbeatPolicy = "auto-response" | "passthrough";
-/** Object-shaped application attachment fields that can coexist with adapter metadata. */
 type RpcWebSocketAttachment = object;
 /** A resumable RPC stream declaration understood by the websocket transport. */
 interface ResumableStreamDeclaration<ResumeDescriptor = unknown, Checkpoint = unknown> {
   /** Stable declaration identifier. Change it when the persisted representation changes. */
   readonly id: string;
-  /** RPC tag matched against encoded client requests. */
   readonly rpcTag: string;
   /** Validates a resume descriptor restored from a websocket attachment. */
   readonly resumeDescriptorSchema: Schema.Decoder<ResumeDescriptor>;
@@ -1358,7 +1005,6 @@ interface ResumableStreamDeclaration<ResumeDescriptor = unknown, Checkpoint = un
     readonly resumeDescriptor: ResumeDescriptor;
     readonly acknowledgedCheckpoint: Checkpoint;
   }>;
-  /** Rebuilds the encoded request fields used to restart a handler. */
   readonly rebuild: (options: {
     readonly subscriptionKey: string;
     readonly resumeDescriptor: ResumeDescriptor;
@@ -1386,9 +1032,7 @@ declare const resumableStream: <ResumeDescriptor, Checkpoint>(declaration: Resum
  * Configuration for {@link layer}.
  */
 interface LayerOptions$7 {
-  /** Tag used to select hibernated sockets. */
   readonly tag?: string | undefined;
-  /** Socket attachment namespace used to persist adapter metadata across hibernation. */
   readonly attachmentKey?: string | undefined;
   /**
    * Heartbeat behavior. `"auto-response"` (the default) installs Cloudflare's
@@ -1401,22 +1045,13 @@ interface LayerOptions$7 {
    * when RPC and unrelated websocket protocols share one object.
    */
   readonly heartbeat?: HeartbeatPolicy | undefined;
-  /** Explicit stream declarations that may be reconstructed after activation loss. */
   readonly resumableStreams?: ReadonlyArray<AnyResumableStreamDeclaration> | undefined;
 }
-/** Native websocket event payload accepted by Cloudflare Durable Objects. */
 type NativeWebSocketMessage = string | ArrayBuffer;
-/**
- * Service API used to wire websocket lifecycle events to Effect RPC server protocol.
- */
 interface DurableObjectRpcWebSocketService {
-  /** Accepts a new, not-yet-accepted socket with the RPC tag and any application tags. */
+  /** Accept a server socket that has not already been accepted. */
   readonly accept: (socket: DurableWebSocket, tags?: ReadonlyArray<string>) => Effect.Effect<void>;
-  /**
-   * Creates and accepts a websocket upgrade without double-accepting the server
-   * socket. Application attachment fields are shallow-merged with the adapter's
-   * metadata namespace.
-   */
+  /** Shallow-merges application attachment fields with the adapter's metadata namespace. */
   readonly acceptUpgrade: <Attachment extends RpcWebSocketAttachment = RpcWebSocketAttachment>(options?: AcceptUpgradeOptions<Attachment>) => Effect.Effect<AcceptedUpgrade<Attachment>, DurableWebSocketAttachmentError>;
   readonly message: (socket: DurableWebSocket, message: NativeWebSocketMessage) => Effect.Effect<void>;
   readonly close: (socket: DurableWebSocket) => Effect.Effect<void>;
@@ -1434,9 +1069,6 @@ interface DurableObjectRpcWebSocketService {
   }) => Effect.Effect<boolean, DurableWebSocketAttachmentError>;
 }
 declare const DurableObjectRpcWebSocket_base: Context.ServiceClass<DurableObjectRpcWebSocket, "effect-cf/DurableObjectRpcWebSocket", DurableObjectRpcWebSocketService>;
-/**
- * Context tag for the Durable Object RPC websocket service.
- */
 declare class DurableObjectRpcWebSocket extends DurableObjectRpcWebSocket_base {}
 /**
  * Builds a hibernation-aware transport that bridges Durable Object websocket
@@ -1451,34 +1083,18 @@ declare const layer$6: (options?: LayerOptions$7) => Layer.Layer<RpcServer.Proto
 declare namespace DurableObjectSqlite_d_exports {
   export { SqliteLayerOptions, layer$5 as layer };
 }
-/** Options forwarded to `@effect/sql-sqlite-do` when building a SQL client layer. */
 type SqliteLayerOptions = Omit<SqliteClient.SqliteClientConfig, "db" | "storage">;
-/**
- * Provides `effect/unstable/sql` from the current Durable Object SQLite storage.
- *
- * @example
- * ```ts
- * const RoomLayer = Layer.mergeAll(
- *   DurableObjectSqlite.layer(),
- *   OtherRoomServices,
- * );
- * ```
- */
 declare const layer$5: (options?: SqliteLayerOptions) => Layer.Layer<SqliteClient.SqliteClient | SqlClient.SqlClient, never, DurableObjectState>;
 declare namespace Email_d_exports {
   export { EmailAddress, EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailErrorCode, EmailMessageBuilder, EmailOperationError, EmailRecipients, EmailSendError, EmailSendOptions, EmailSendResult, EmailService, EmailValidationError, EmailViolation, LayerOptions$6 as LayerOptions, Tag$7 as Tag, TagClass$6 as TagClass, emailErrorCodes, isEmailBinding, layer$4 as layer, make$5 as make, makeClient$4 as makeClient, sendLimits, validateMessage };
 }
-/** Documented Cloudflare Email Sending limits. */
 declare const sendLimits: {
-  /** Combined `to`, `cc`, and `bcc` addresses per message. */
   readonly maxRecipients: 50;
   readonly maxAttachments: 32;
-  /** Total message size, including attachments. Not enforced client side. */
   readonly maxMessageBytes: number;
   readonly maxHeaderNameBytes: 100;
   readonly maxHeaderValueBytes: 2048;
   readonly maxHeadersBytes: number;
-  /** Allowlisted custom headers, excluding `X-` prefixed headers. */
   readonly maxAllowlistHeaders: 20;
 };
 /**
@@ -1490,12 +1106,10 @@ declare const sendLimits: {
  * (miniflare remote bindings serialize errors and can strip it).
  */
 declare const emailErrorCodes: readonly ["E_VALIDATION_ERROR", "E_FIELD_MISSING", "E_TOO_MANY_RECIPIENTS", "E_TOO_MANY_ATTACHMENTS", "E_SENDER_NOT_VERIFIED", "E_RECIPIENT_NOT_ALLOWED", "E_RECIPIENT_SUPPRESSED", "E_SENDER_DOMAIN_NOT_AVAILABLE", "E_CONTENT_TOO_LARGE", "E_DELIVERY_FAILED", "E_RATE_LIMIT_EXCEEDED", "E_DAILY_LIMIT_EXCEEDED", "E_INTERNAL_SERVER_ERROR", "E_HEADER_NOT_ALLOWED", "E_HEADER_USE_API_FIELD", "E_HEADER_VALUE_INVALID", "E_HEADER_VALUE_TOO_LONG", "E_HEADER_NAME_INVALID", "E_HEADERS_TOO_LARGE", "E_HEADERS_TOO_MANY"];
-/** A documented Cloudflare Email Sending error code. */
 type EmailErrorCode = (typeof emailErrorCodes)[number];
 declare const EmailOperationError_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: "EmailOperationError";
 } & Readonly<A>;
-/** Error raised when a Cloudflare Send Email operation fails. */
 declare class EmailOperationError extends EmailOperationError_base<{
   readonly binding: string;
   readonly operation: string;
@@ -1511,7 +1125,6 @@ declare class EmailOperationError extends EmailOperationError_base<{
 }> {
   get message(): string;
 }
-/** A single message field that violates a documented Email Sending limit. */
 interface EmailViolation {
   readonly path: string;
   readonly message: string;
@@ -1521,7 +1134,6 @@ interface EmailViolation {
 declare const EmailValidationError_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: "EmailValidationError";
 } & Readonly<A>;
-/** Error raised when a message violates documented Cloudflare Email Sending limits. */
 declare class EmailValidationError extends EmailValidationError_base<{
   readonly binding: string;
   readonly operation: string;
@@ -1529,9 +1141,7 @@ declare class EmailValidationError extends EmailValidationError_base<{
 }> {
   get message(): string;
 }
-/** Typed Cloudflare Send Email binding definition. */
 interface EmailDefinition {
-  /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
 }
 type EmailAddress = CloudflareEmailAddress;
@@ -1542,7 +1152,6 @@ type EmailBinding = CloudflareSendEmail;
 type EmailRecipients = string | EmailAddress | ReadonlyArray<string | EmailAddress>;
 type EmailSendError = EmailOperationError | EmailValidationError;
 interface EmailSendOptions {
-  /** Validates builder messages against documented limits. Defaults to `true`. */
   readonly validate?: boolean;
 }
 interface EmailClient {
@@ -1551,7 +1160,6 @@ interface EmailClient {
   readonly definition: EmailDefinition;
 }
 declare const EmailServiceTypeId: unique symbol;
-/** Nominal service marker for Send Email services created with {@link make}. */
 interface EmailService<Id extends string> {
   readonly [EmailServiceTypeId]: {
     readonly id: Id;
@@ -1584,7 +1192,6 @@ type TypeId = typeof TypeId;
 declare const ImagesOperationError_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: "ImagesOperationError";
 } & Readonly<A>;
-/** Error raised when a Cloudflare Images operation fails. */
 declare class ImagesOperationError extends ImagesOperationError_base<{
   readonly binding: string;
   readonly operation: string;
@@ -1592,9 +1199,7 @@ declare class ImagesOperationError extends ImagesOperationError_base<{
 }> {
   get message(): string;
 }
-/** Typed Cloudflare Images binding definition. */
 interface ImagesDefinition {
-  /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
 }
 type ImageInfoResponse = CloudflareImageInfoResponse;
@@ -1735,7 +1340,6 @@ interface ImagesClient {
   readonly definition: ImagesDefinition;
 }
 declare const ImagesServiceTypeId: unique symbol;
-/** Nominal service marker for Images services created with {@link make}. */
 interface ImagesService<Id extends string> {
   readonly [ImagesServiceTypeId]: {
     readonly id: Id;
@@ -1748,7 +1352,6 @@ interface TagClass$5<Self, Id extends string> extends Context.ServiceClass<Self,
   readonly id: Id;
   readonly layer: (options: LayerOptions$5) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
-/** Empty Images transformation pipeline. */
 declare const empty: Steps;
 declare const transform: {
   (transform: ImageTransform): (steps: Steps) => Steps;
@@ -1766,12 +1369,10 @@ declare const Tag$6: <Self>() => <Id extends string>(id: Id) => TagClass$5<Self,
 declare namespace Kv_d_exports {
   export { Definition$2 as Definition, KvClient, KvDefinition, KvListKey, KvListOptions, KvListResult, KvOperation, KvOperationError, KvPutOptions, KvWithMetadata, LayerOptions$4 as LayerOptions, Tag$5 as Tag, TagClass$4 as TagClass, isKvNamespace, layer$2 as layer, makeClient$2 as makeClient };
 }
-/** KV operation represented by {@link KvOperationError}. */
 type KvOperation = "put" | "get" | "getWithMetadata" | "list" | "delete";
 declare const KvOperationError_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: "KvOperationError";
 } & Readonly<A>;
-/** Error raised when a KV operation fails. */
 declare class KvOperationError extends KvOperationError_base<{
   readonly binding: string;
   readonly operation: KvOperation;
@@ -1779,40 +1380,29 @@ declare class KvOperationError extends KvOperationError_base<{
 }> {
   get message(): string;
 }
-/** `KVNamespace.put` options. */
 type KvPutOptions = CloudflareKVNamespacePutOptions;
-/** `KVNamespace.list` options with optional metadata decoding schema. */
 type KvListOptions<Metadata = unknown> = CloudflareKVNamespaceListOptions & {
   readonly metadataSchema?: Schema.Codec<Metadata, unknown>;
 };
-/** Successful value returned by `getWithMetadata`. */
 interface KvWithMetadata<Value, Metadata> {
   readonly value: Value;
   readonly metadata: Option.Option<Metadata>;
   readonly cacheStatus: Option.Option<string>;
 }
-/** Decoded key entry returned by `list`. */
 interface KvListKey<Key, Metadata = unknown> {
   readonly name: Key;
   readonly expiration: Option.Option<number>;
   readonly metadata: Option.Option<Metadata>;
 }
-/** Decoded result returned by `list`. */
 interface KvListResult<Key, Metadata = unknown> {
   readonly keys: ReadonlyArray<KvListKey<Key, Metadata>>;
   readonly listComplete: boolean;
   readonly cursor: Option.Option<string>;
   readonly cacheStatus: Option.Option<string>;
 }
-/**
- * Typed KV binding definition.
- */
 interface KvDefinition<Key, Value, EncodedValue> {
-  /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
-  /** Codec used to encode/decode keys. */
   readonly key: Schema.Codec<Key, string>;
-  /** Codec used to encode/decode values. */
   readonly value: Schema.Codec<Value, EncodedValue>;
 }
 /**
@@ -1820,9 +1410,7 @@ interface KvDefinition<Key, Value, EncodedValue> {
  */
 interface Definition$2<Id extends string = string, Key = unknown, Value = unknown, EncodedValue = unknown> {
   readonly id: Id;
-  /** Codec used to encode/decode keys. */
   readonly key: Schema.Codec<Key, string>;
-  /** Codec used to encode/decode values. */
   readonly value: Schema.Codec<Value, EncodedValue>;
 }
 declare namespace Definition$2 {
@@ -1856,12 +1444,10 @@ declare const Tag$5: <Self>() => <Id extends string, Key, Value, EncodedValue>(i
 declare namespace R2_d_exports {
   export { LayerOptions$3 as LayerOptions, R2Client, R2Definition, R2GetOptions, R2ListOptions, R2MultipartOptions, R2MultipartUploadClient, R2ObjectBodyClient, R2Operation, R2OperationError, R2PutOptions, R2PutValue, R2Service, R2UploadPartOptions, R2UploadPartValue, Tag$4 as Tag, TagClass$3 as TagClass, isR2Bucket, layer$1 as layer, make$3 as make, makeClient$1 as makeClient };
 }
-/** R2 operation represented by {@link R2OperationError}. */
 type R2Operation = "head" | "get" | "put" | "delete" | "list" | "createMultipartUpload" | "resumeMultipartUpload" | "uploadPart" | "abortMultipartUpload" | "completeMultipartUpload" | "arrayBuffer" | "bytes" | "text" | "json" | "blob";
 declare const R2OperationError_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: "R2OperationError";
 } & Readonly<A>;
-/** Error raised when an R2 operation fails. */
 declare class R2OperationError extends R2OperationError_base<{
   readonly binding: string;
   readonly operation: R2Operation;
@@ -1869,9 +1455,7 @@ declare class R2OperationError extends R2OperationError_base<{
 }> {
   get message(): string;
 }
-/** Typed R2 bucket binding definition. */
 interface R2Definition {
-  /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
 }
 type R2GetOptions = CloudflareR2GetOptions;
@@ -1919,7 +1503,6 @@ interface R2Client {
   readonly definition: R2Definition;
 }
 declare const R2ServiceTypeId: unique symbol;
-/** Nominal service marker for R2 services created with {@link make}. */
 interface R2Service<Id extends string> {
   readonly [R2ServiceTypeId]: {
     readonly id: Id;
@@ -1941,12 +1524,10 @@ declare const Tag$4: <Self>() => <Id extends string>(id: Id) => TagClass$3<Self,
 declare namespace Vectorize_d_exports {
   export { LayerOptions$2 as LayerOptions, Tag$3 as Tag, TagClass$2 as TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails, VectorizeIndexInfo, VectorizeMatch, VectorizeMatches, VectorizeMutation, VectorizeOperation, VectorizeOperationError, VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector, VectorizeVectorMetadata, VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue, isVectorizeBinding, layer, make$2 as make, makeClient };
 }
-/** Vectorize operation represented by {@link VectorizeOperationError}. */
 type VectorizeOperation = "describe" | "query" | "queryById" | "insert" | "upsert" | "deleteByIds" | "getByIds";
 declare const VectorizeOperationError_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: "VectorizeOperationError";
 } & Readonly<A>;
-/** Error raised when a Vectorize operation fails. */
 declare class VectorizeOperationError extends VectorizeOperationError_base<{
   readonly binding: string;
   readonly operation: VectorizeOperation;
@@ -1954,9 +1535,7 @@ declare class VectorizeOperationError extends VectorizeOperationError_base<{
 }> {
   get message(): string;
 }
-/** Typed Vectorize binding definition. */
 interface VectorizeDefinition {
-  /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
 }
 type VectorizeBinding = CloudflareVectorize | CloudflareVectorizeIndex;
@@ -1984,7 +1563,6 @@ interface VectorizeClient {
   readonly definition: VectorizeDefinition;
 }
 declare const VectorizeServiceTypeId: unique symbol;
-/** Nominal service marker for Vectorize services created with {@link make}. */
 interface VectorizeService<Id extends string> {
   readonly [VectorizeServiceTypeId]: {
     readonly id: Id;
@@ -2007,11 +1585,8 @@ declare namespace WebTransport_d_exports {
   export { Capabilities, InboundTransport, WebTransportCapability, WebTransportUnsupportedError, capabilities, inboundSessionsUnsupported, inboundTransport, isHttp3 };
 }
 declare const InboundTransport_base: Schema.Class<InboundTransport, Schema.Struct<{
-  /** The HTTP protocol the client used, e.g. `"HTTP/2"` or `"HTTP/3"`. */
   readonly httpProtocol: Schema.String;
-  /** Client round-trip time; only present for QUIC (HTTP/3) connections. */
   readonly clientQuicRtt: Schema.optional<Schema.Number>;
-  /** Client round-trip time; only present for TCP (HTTP/1.x, HTTP/2) connections. */
   readonly clientTcpRtt: Schema.optional<Schema.Number>;
 }>, {}>;
 /**
@@ -2032,16 +1607,7 @@ declare class InboundTransport extends InboundTransport_base {}
  * the expected shape.
  */
 declare const inboundTransport: (request: Pick<CloudflareRequest, "cf">) => Option.Option<InboundTransport>;
-/**
- * Returns `true` when the client reached Cloudflare's edge over QUIC
- * (HTTP/3). Prefers the documented QUIC signal (`clientQuicRtt` is only
- * present for QUIC connections) and falls back to the `httpProtocol` string.
- *
- * Note this describes the browser→edge hop only: the edge always terminates
- * QUIC, and the Worker still handles an ordinary `fetch` Request.
- */
 declare const isHttp3: (transport: InboundTransport) => boolean;
-/** WebTransport-related capabilities of the current Workers runtime. */
 interface Capabilities {
   /**
    * Whether Worker code can accept inbound WebTransport sessions. Typed as
@@ -2057,14 +1623,11 @@ interface Capabilities {
    */
   readonly outboundSessions: boolean;
 }
-/** Feature-detects the WebTransport capabilities of the current runtime. */
 declare const capabilities: Effect.Effect<Capabilities>;
-/** WebTransport capability missing from the current Workers runtime. */
 type WebTransportCapability = "inbound-sessions" | "outbound-sessions";
 declare const WebTransportUnsupportedError_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: "WebTransportUnsupportedError";
 } & Readonly<A>;
-/** Raised when a WebTransport capability is unavailable in this runtime. */
 declare class WebTransportUnsupportedError extends WebTransportUnsupportedError_base<{
   readonly capability: WebTransportCapability;
 }> {
@@ -2133,7 +1696,6 @@ declare class WorkflowEvent$1 extends WorkflowEvent_base {}
 declare const WorkflowStepError_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: "WorkflowStepError";
 } & Readonly<A>;
-/** Failure raised when a Cloudflare Workflow step operation rejects. */
 declare class WorkflowStepError extends WorkflowStepError_base<{
   readonly step?: string;
   readonly operation: string;
@@ -2200,4 +1762,4 @@ declare const implement: typeof implement$1;
 type Handler<ROut, Self extends Definition$1.Any> = Handler$1<ROut, Self>;
 type Options<ROut, Self extends Definition$1.Any> = Options$1<ROut, Self>;
 //#endregion
-export { AiGateway_d_exports as AiGateway, AnalyticsEngine_d_exports as AnalyticsEngine, Artifacts_d_exports as Artifacts, Binding_d_exports as Binding, BrowserRendering_d_exports as BrowserRendering, Cache_d_exports as Cache, CloudflareOtlp_d_exports as CloudflareOtlp, ContainerNamespace_d_exports as ContainerNamespace, D1_d_exports as D1, DurableObject_d_exports as DurableObject, DurableObjectAlarm_d_exports as DurableObjectAlarm, DurableObjectDefinition_d_exports as DurableObjectDefinition, DurableObjectNamespace_d_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_d_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_d_exports as DurableObjectSqlite, DurableObjectState_d_exports as DurableObjectState, DurableObjectStorage_d_exports as DurableObjectStorage, DurableObjectWebSocket_d_exports as DurableObjectWebSocket, Email_d_exports as Email, Environment_d_exports as Environment, Hyperdrive_d_exports as Hyperdrive, Images_d_exports as Images, Kv_d_exports as Kv, Queue_d_exports as Queue, QueueBinding_d_exports as QueueBinding, QueueDefinition_d_exports as QueueDefinition, R2_d_exports as R2, Rpc_d_exports as Rpc, RpcDefinition_d_exports as RpcDefinition, ServiceBinding_d_exports as ServiceBinding, Vectorize_d_exports as Vectorize, WebTransport_d_exports as WebTransport, Worker_d_exports as Worker, WorkerConfig, WorkerDefinition_d_exports as WorkerDefinition, type WorkerEnv, WorkerEnvironment, WorkersAi_d_exports as WorkersAi, Workflow_d_exports as Workflow, WorkflowBinding_d_exports as WorkflowBinding, WorkflowDefinition_d_exports as WorkflowDefinition };
+export { AiGateway_d_exports as AiGateway, AnalyticsEngine_d_exports as AnalyticsEngine, Artifacts_d_exports as Artifacts, Binding_d_exports as Binding, BrowserRendering_d_exports as BrowserRendering, Cache_d_exports as Cache, CloudflareOtlp_d_exports as CloudflareOtlp, ContainerNamespace_d_exports as ContainerNamespace, D1_d_exports as D1, DurableObject_d_exports as DurableObject, DurableObjectAlarm_d_exports as DurableObjectAlarm, DurableObjectDefinition_d_exports as DurableObjectDefinition, DurableObjectNamespace_d_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_d_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_d_exports as DurableObjectSqlite, DurableObjectState_d_exports as DurableObjectState, DurableObjectStorage_d_exports as DurableObjectStorage, DurableObjectWebSocket_d_exports as DurableObjectWebSocket, Email_d_exports as Email, Environment_d_exports as Environment, Hyperdrive_d_exports as Hyperdrive, Images_d_exports as Images, Kv_d_exports as Kv, Queue_d_exports as Queue, QueueBinding_d_exports as QueueBinding, QueueDefinition_d_exports as QueueDefinition, R2_d_exports as R2, Rpc_d_exports as Rpc, RpcDefinition_d_exports as RpcDefinition, RpcTracing_d_exports as RpcTracing, ServiceBinding_d_exports as ServiceBinding, Vectorize_d_exports as Vectorize, WebTransport_d_exports as WebTransport, Worker_d_exports as Worker, WorkerConfig, WorkerDefinition_d_exports as WorkerDefinition, type WorkerEnv, WorkerEnvironment, WorkersAi_d_exports as WorkersAi, Workflow_d_exports as Workflow, WorkflowBinding_d_exports as WorkflowBinding, WorkflowDefinition_d_exports as WorkflowDefinition };