effect-cf 0.40.0 → 0.40.2

package/dist/index.d.mts

@@ -1,1840 +1,41 @@
-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 AcceptedUpgrade, c as DurableWebSocketAttachmentError, i as AcceptUpgradeOptions, l as DurableObjectStorage_d_exports, o as DurableObjectWebSocket_d_exports, r as DurableObjectState_d_exports, s as DurableWebSocket, t as DurableObjectState, u as StorageOperationError } from "./DurableObjectState-DJ0K-zyd.mjs";
-import { C as Provider, S as ServiceFreeSchema$1, _ as QueueBinding_d_exports, a as Worker_d_exports, b as ReservedMethodName$2, c as AsyncMethodArgs, d as AsyncMethodSuccess, f as ReceiverOptions, g as QueueDefinition_d_exports, h as Queue_d_exports, l as AsyncMethodCloudflareReturn, m as RpcTracing_d_exports, n as NativeRequest, o as WorkerDefinition_d_exports, p as RpcInvocationInfo, r as WorkerContext, s as ServiceBinding_d_exports, t as ExecutionContext, u as AsyncMethodKey, v as Definition$4, w as Rpc_d_exports, x as RpcDefinition_d_exports, y as Method$2 } from "./Worker-gV4mDqIs.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-DtVykUCz.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";
-import { DurableObject, WorkflowEntrypoint, WorkflowEvent, WorkflowSleepDuration, WorkflowStep, WorkflowStepConfig, WorkflowStepContext, WorkflowStepEvent, WorkflowTimeoutDuration } from "cloudflare:workers";
-import { D1Client } from "@effect/sql-d1";
-import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
-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$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$14 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>;
-declare class WorkersAiOperationError extends WorkersAiOperationError_base<{
-  readonly binding: string;
-  readonly operation: string;
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-interface WorkersAiDefinition {
-  readonly binding: string;
-}
-type WorkersAiBinding<ModelList extends AiModelListType = AiModels> = CloudflareAi<ModelList>;
-type WorkersAiOptions = AiOptions;
-type WorkersAiModelsSearchParams = AiModelsSearchParams;
-type WorkersAiModelsSearchObject = AiModelsSearchObject;
-type WorkersAiAsyncBatchResponse = AiAsyncBatchResponse;
-type WorkersAiEmbeddingInput = AiTextEmbeddingsInput | Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Input | Parameters<WorkersAiBinding["run"]>[1];
-declare const embeddingDimensionsKey = "shape";
-interface WorkersAiEmbeddingResponse {
-  readonly data: ReadonlyArray<ReadonlyArray<number>>;
-  readonly [embeddingDimensionsKey]: ReadonlyArray<number>;
-}
-interface WorkersAiClient<ModelList extends AiModelListType = AiModels> {
-  readonly aiGatewayLogId: Effect.Effect<string | null, WorkersAiOperationError>;
-  readonly run: {
-    <Name extends keyof ModelList>(model: Name, input: {
-      readonly requests: ReadonlyArray<ModelList[Name]["inputs"]>;
-    }, options: WorkersAiOptions & {
-      readonly queueRequest: true;
-    }): Effect.Effect<WorkersAiAsyncBatchResponse, WorkersAiOperationError>;
-    <Name extends keyof ModelList>(model: Name, input: ModelList[Name]["inputs"], options: WorkersAiOptions & {
-      readonly returnRawResponse: true;
-    }): Effect.Effect<Response, WorkersAiOperationError>;
-    <Name extends keyof ModelList>(model: Name, input: ModelList[Name]["inputs"], options: WorkersAiOptions & {
-      readonly websocket: true;
-    }): Effect.Effect<Response, WorkersAiOperationError>;
-    <Name extends keyof ModelList>(model: Name, input: ModelList[Name]["inputs"] & {
-      readonly stream: true;
-    }, options?: WorkersAiOptions): Effect.Effect<ReadableStream, WorkersAiOperationError>;
-    <Name extends keyof ModelList>(model: Name, input: ModelList[Name]["inputs"], options?: WorkersAiOptions): Effect.Effect<ModelList[Name]["postProcessedOutputs"], WorkersAiOperationError>;
-    <Input extends Parameters<WorkersAiBinding["run"]>[1], Output = Awaited<ReturnType<WorkersAiBinding["run"]>>>(model: string, input: Input, options?: WorkersAiOptions): Effect.Effect<Output, WorkersAiOperationError>;
-  };
-  readonly runEmbedding: <Input extends WorkersAiEmbeddingInput>(model: string, input: Input, options?: WorkersAiOptions) => Effect.Effect<WorkersAiEmbeddingResponse, WorkersAiOperationError>;
-  readonly models: (params?: WorkersAiModelsSearchParams) => Effect.Effect<ReadonlyArray<WorkersAiModelsSearchObject>, WorkersAiOperationError>;
-  readonly gateway: (gatewayId: string) => Effect.Effect<CloudflareAiGateway, WorkersAiOperationError>;
-  readonly rawUnsafe: Effect.Effect<WorkersAiBinding<ModelList>>;
-  readonly definition: WorkersAiDefinition;
-}
-declare const WorkersAiServiceTypeId: unique symbol;
-interface WorkersAiService<Id extends string> {
-  readonly [WorkersAiServiceTypeId]: {
-    readonly id: Id;
-  };
-}
-type LayerOptions$13 = {
-  readonly binding: string;
-};
-interface TagClass$11<Self, Id extends string, ModelList extends AiModelListType = AiModels> extends Context.ServiceClass<Self, Id, WorkersAiClient<ModelList>> {
-  readonly id: Id;
-  readonly layer: (options: LayerOptions$13) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-}
-type WorkersAiBindingValue = Schema.Schema.Type<typeof Schema.Unknown>;
-declare const isWorkersAiBinding: (value: WorkersAiBindingValue) => value is WorkersAiBinding;
-declare const embeddingResponse: (value: {
-  readonly data?: ReadonlyArray<ReadonlyArray<number>>;
-  readonly [embeddingDimensionsKey]?: ReadonlyArray<number>;
-}) => WorkersAiEmbeddingResponse;
-declare const makeClient$10: <ModelList extends AiModelListType = AiModels>(definition: WorkersAiDefinition) => (ai: WorkersAiBinding<ModelList>) => WorkersAiClient<ModelList>;
-declare const layer$14: <Self, ModelList extends AiModelListType = AiModels>(tag: Context.Service<Self, WorkersAiClient<ModelList>>, definition: WorkersAiDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const make$12: <Id extends string>(id: Id) => TagClass$11<WorkersAiService<Id>, Id, AiModels>;
-declare const Tag$12: <Self>() => <Id extends string, ModelList extends AiModelListType = AiModels>(id: Id) => TagClass$11<Self, Id, ModelList>;
-declare namespace AiGateway_d_exports {
-  export { AiGatewayBinding, AiGatewayClient, AiGatewayDefinition, AiGatewayFetchOptions, AiGatewayHeaders, AiGatewayLog, AiGatewayOperationError, AiGatewayPatchLog, AiGatewayProvider, AiGatewayRunOptions, AiGatewayService, AiGatewayUniversalRequest, LayerOptions$12 as LayerOptions, Tag$11 as Tag, TagClass$10 as TagClass, isAiGatewayBinding, layer$13 as layer, make$11 as make, makeClient$9 as makeClient, makeClientFromAi, makeHttpClient };
-}
-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>;
-declare class AiGatewayOperationError extends AiGatewayOperationError_base<{
-  readonly binding: string;
-  readonly operation: string;
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-interface AiGatewayDefinition {
-  readonly binding: string;
-  readonly gatewayId: string;
-  readonly accountId?: string;
-}
-type AiGatewayBinding = CloudflareAiGateway;
-type AiGatewayRunData = Parameters<AiGatewayBinding["run"]>[0];
-type AiGatewayPatchLog = Parameters<AiGatewayBinding["patchLog"]>[1];
-type AiGatewayLog = Awaited<ReturnType<AiGatewayBinding["getLog"]>>;
-type AiGatewayProvider = NonNullable<Parameters<AiGatewayBinding["getUrl"]>[0]>;
-type AiGatewayUniversalRequest = Exclude<AiGatewayRunData, ReadonlyArray<unknown>>;
-type AiGatewayHeaders = NonNullable<AiGatewayUniversalRequest["headers"]>;
-type AiGatewayRunOptions = Parameters<CloudflareAiGateway["run"]>[1];
-type AiGatewayBindingCandidate = Parameters<typeof isWorkersAiBinding>[0];
-interface AiGatewayFetchOptions {
-  readonly provider?: AiGatewayProvider;
-  readonly path?: string;
-  readonly init?: RequestInit;
-}
-interface AiGatewayClient {
-  readonly run: (data: AiGatewayUniversalRequest | ReadonlyArray<AiGatewayUniversalRequest>, options?: AiGatewayRunOptions) => Effect.Effect<Response, AiGatewayOperationError>;
-  readonly getUrl: (provider?: AiGatewayProvider) => Effect.Effect<string, AiGatewayOperationError>;
-  readonly fetch: (options: AiGatewayFetchOptions) => Effect.Effect<Response, AiGatewayOperationError>;
-  readonly patchLog: (logId: string, data: AiGatewayPatchLog) => Effect.Effect<void, AiGatewayOperationError>;
-  readonly getLog: (logId: string) => Effect.Effect<AiGatewayLog, AiGatewayOperationError>;
-  readonly rawUnsafe: Effect.Effect<AiGatewayBinding, AiGatewayOperationError>;
-  readonly definition: AiGatewayDefinition;
-}
-declare const AiGatewayServiceTypeId: unique symbol;
-interface AiGatewayService<Id extends string> {
-  readonly [AiGatewayServiceTypeId]: {
-    readonly id: Id;
-  };
-}
-type LayerOptions$12 = {
-  readonly binding: string;
-  readonly gatewayId: string;
-  readonly accountId?: string;
-};
-interface TagClass$10<Self, Id extends string> extends Context.ServiceClass<Self, Id, AiGatewayClient> {
-  readonly id: Id;
-  readonly layer: (options: LayerOptions$12) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError | AiGatewayOperationError, WorkerEnvironment>;
-}
-declare const isAiGatewayBinding: (value: AiGatewayBindingCandidate) => value is WorkersAiBinding;
-declare const makeClient$9: (definition: AiGatewayDefinition, gateway: AiGatewayBinding) => {
-  definition: AiGatewayDefinition;
-  run: (data: import("@cloudflare/workers-types").AIGatewayUniversalRequest | readonly import("@cloudflare/workers-types").AIGatewayUniversalRequest[], options?: {
-    gateway?: import("@cloudflare/workers-types").UniversalGatewayOptions;
-    extraHeaders?: object;
-    signal?: import("@cloudflare/workers-types").AbortSignal;
-  } | undefined) => Effect.Effect<import("@cloudflare/workers-types").Response, AiGatewayOperationError, never>;
-  getUrl: (provider?: string | undefined) => Effect.Effect<string, AiGatewayOperationError, never>;
-  fetch: (options: AiGatewayFetchOptions) => Effect.Effect<Response, AiGatewayOperationError, never>;
-  patchLog: (logId: string, data: import("@cloudflare/workers-types").AiGatewayPatchLog) => Effect.Effect<void, AiGatewayOperationError, never>;
-  getLog: (logId: string) => Effect.Effect<import("@cloudflare/workers-types").AiGatewayLog, AiGatewayOperationError, never>;
-  rawUnsafe: Effect.Effect<CloudflareAiGateway, never, never>;
-};
-declare const makeClientFromAi: (definition: AiGatewayDefinition, ai: WorkersAiBinding) => AiGatewayClient;
-declare const makeHttpClient: (definition: Omit<AiGatewayDefinition, "binding"> & {
-  readonly accountId: string;
-  readonly binding?: string;
-}, request?: typeof fetch) => AiGatewayClient;
-declare const layer$13: <Self>(tag: Context.Service<Self, AiGatewayClient>, definition: AiGatewayDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const make$11: <Id extends string>(id: Id) => TagClass$10<AiGatewayService<Id>, Id>;
-declare const Tag$11: <Self>() => <Id extends string>(id: Id) => TagClass$10<Self, Id>;
-declare namespace AnalyticsEngine_d_exports {
-  export { AnalyticsEngineBinding, AnalyticsEngineClient, AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, LayerOptions$11 as LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag$10 as Tag, TagClass$9 as TagClass, isAnalyticsEngineDataset, layer$12 as layer, layerFetch, layerFetchConfig, make$10 as make, makeClient$8 as makeClient, makeQuery, makeQueryClient, queryConfig, queryLayer, queryLayerConfig, writeLimits };
-}
-declare const writeLimits: {
-  readonly maxBlobs: 20;
-  readonly maxDoubles: 20;
-  readonly maxIndexes: 1;
-  readonly maxBlobBytes: number;
-  readonly maxIndexBytes: 96;
-  readonly maxDataPointsPerInvocation: 250;
-};
-declare const queryColumnSchema: Schema.Struct<{
-  readonly name: Schema.String;
-  readonly type: Schema.String;
-}>;
-declare const queryRowSchema: Schema.$Record<Schema.String, Schema.Unknown>;
-declare const AnalyticsEngineFieldValueSchema: Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.instanceOf<ArrayBuffer, unknown>]>>;
-declare const AnalyticsEngineDataPointSchema: Schema.Struct<{
-  readonly indexes: Schema.optional<Schema.$Array<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.instanceOf<ArrayBuffer, unknown>]>>>>;
-  readonly doubles: Schema.optional<Schema.$Array<Schema.Finite>>;
-  readonly blobs: Schema.optional<Schema.$Array<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.instanceOf<ArrayBuffer, unknown>]>>>>;
-}>;
-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>;
-declare class AnalyticsEngineOperationError extends AnalyticsEngineOperationError_base<{
-  readonly binding: string;
-  readonly operation: string;
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-interface AnalyticsEngineWriteViolation {
-  readonly path: string;
-  readonly message: string;
-  readonly limit?: number;
-  readonly actual?: number;
-}
-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>;
-declare class AnalyticsEngineWriteValidationError extends AnalyticsEngineWriteValidationError_base<{
-  readonly binding: string;
-  readonly operation: string;
-  readonly violations: ReadonlyArray<AnalyticsEngineWriteViolation>;
-  readonly cause?: unknown;
-}> {
-  get message(): string;
-}
-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>;
-declare class AnalyticsEngineQueryError extends AnalyticsEngineQueryError_base<{
-  readonly operation: string;
-  readonly accountId: string;
-  readonly message: string;
-  readonly status?: number;
-  readonly body?: string;
-  readonly cause?: unknown;
-}> {}
-interface AnalyticsEngineDefinition {
-  readonly binding: string;
-}
-type AnalyticsEngineBinding = CloudflareAnalyticsEngineDataset;
-type AnalyticsEngineDataPoint = CloudflareAnalyticsEngineDataPoint;
-type AnalyticsEngineFieldValue = ArrayBuffer | string | null;
-type AnalyticsEngineWriteError = AnalyticsEngineOperationError | AnalyticsEngineWriteValidationError;
-type AnalyticsEngineInvalidWritePolicy = "error" | "drop";
-type AnalyticsEngineQueryColumn = Schema.Schema.Type<typeof queryColumnSchema>;
-type AnalyticsEngineQueryRow = Schema.Schema.Type<typeof queryRowSchema>;
-interface AnalyticsEngineWriteOptions {
-  /**
-   * Controls invalid write behavior. The default is `"error"`, which fails with
-   * `AnalyticsEngineWriteValidationError`. `"drop"` skips invalid points.
-   */
-  readonly onInvalid?: AnalyticsEngineInvalidWritePolicy;
-}
-type AnalyticsEngineWritePolicy = AnalyticsEngineWriteOptions;
-interface AnalyticsEngineQueryResult<Row = AnalyticsEngineQueryRow> {
-  readonly meta: ReadonlyArray<AnalyticsEngineQueryColumn>;
-  readonly data: ReadonlyArray<Row>;
-  readonly rows: number;
-}
-interface AnalyticsEngineQueryDefinition {
-  readonly accountId: string;
-  /** API token with Account Analytics Read permission. */
-  readonly apiToken: Redacted.Redacted<string>;
-  readonly apiBaseUrl?: string | URL;
-}
-interface AnalyticsEngineQueryOptions {
-  /** Additional request headers. Authorization is always derived from `apiToken`. */
-  readonly headers?: Headers$1.Input;
-}
-interface AnalyticsEngineClient {
-  readonly writeDataPoint: (dataPoint?: AnalyticsEngineDataPoint, options?: AnalyticsEngineWriteOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
-  readonly writeDataPoints: (dataPoints: ReadonlyArray<AnalyticsEngineDataPoint>, options?: AnalyticsEngineWriteOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
-  readonly rawUnsafe: Effect.Effect<AnalyticsEngineBinding>;
-  readonly definition: AnalyticsEngineDefinition;
-}
-interface AnalyticsEngineQueryClient {
-  readonly query: (sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<AnalyticsEngineQueryResult, AnalyticsEngineQueryError | Schema.SchemaError>;
-  readonly queryResult: <Row>(row: Schema.Codec<Row, unknown>, sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<AnalyticsEngineQueryResult<Row>, AnalyticsEngineQueryError | Schema.SchemaError>;
-  readonly queryRows: <Row>(row: Schema.Codec<Row, unknown>, sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<ReadonlyArray<Row>, AnalyticsEngineQueryError | Schema.SchemaError>;
-  readonly queryOne: <Row>(row: Schema.Codec<Row, unknown>, sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<Option.Option<Row>, AnalyticsEngineQueryError | Schema.SchemaError>;
-  readonly queryText: (sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<string, AnalyticsEngineQueryError>;
-  readonly raw: (sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<HttpClientResponse.HttpClientResponse, AnalyticsEngineQueryError>;
-  readonly definition: AnalyticsEngineQueryDefinition;
-}
-declare const AnalyticsEngineServiceTypeId: unique symbol;
-declare const AnalyticsEngineQueryServiceTypeId: unique symbol;
-interface AnalyticsEngineService<Id extends string> {
-  readonly [AnalyticsEngineServiceTypeId]: {
-    readonly id: Id;
-  };
-}
-interface AnalyticsEngineQueryService<Id extends string> {
-  readonly [AnalyticsEngineQueryServiceTypeId]: {
-    readonly id: Id;
-  };
-}
-type LayerOptions$11 = {
-  readonly binding: string;
-  readonly write?: AnalyticsEngineWritePolicy;
-};
-type QueryConfigOptions = {
-  readonly accountId?: Config.Config<string>;
-  readonly apiToken?: Config.Config<Redacted.Redacted<string>>;
-  readonly apiBaseUrl?: Config.Config<string>;
-};
-interface TagClass$9<Self, Id extends string> extends Context.ServiceClass<Self, Id, AnalyticsEngineClient> {
-  readonly id: Id;
-  readonly layer: (options: LayerOptions$11) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-}
-interface QueryTagClass<Self, Id extends string> extends Context.ServiceClass<Self, Id, AnalyticsEngineQueryClient> {
-  readonly id: Id;
-  readonly layer: (definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self, never, HttpClient.HttpClient>;
-  readonly layerFetch: (definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self>;
-  readonly layerConfig: (config?: Config.Config<AnalyticsEngineQueryDefinition>) => Layer.Layer<Self, Config.ConfigError, HttpClient.HttpClient>;
-  readonly layerFetchConfig: (config?: Config.Config<AnalyticsEngineQueryDefinition>) => Layer.Layer<Self, Config.ConfigError>;
-}
-declare const makeQueryClient: (definition: AnalyticsEngineQueryDefinition) => Effect.Effect<AnalyticsEngineQueryClient, never, HttpClient.HttpClient>;
-declare const isAnalyticsEngineDataset: <Candidate>(value: Candidate) => value is Candidate & AnalyticsEngineBinding;
-declare const makeClient$8: (definition: AnalyticsEngineDefinition, defaults?: AnalyticsEngineWritePolicy) => (dataset: AnalyticsEngineBinding) => AnalyticsEngineClient;
-declare const queryConfig: (options?: QueryConfigOptions) => Config.Config<{
-  accountId: string;
-  apiToken: Redacted.Redacted<string>;
-  apiBaseUrl: string;
-}>;
-declare const queryLayer: <Self>(tag: Context.Service<Self, AnalyticsEngineQueryClient>, definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self, never, HttpClient.HttpClient>;
-declare const layerFetch: <Self>(tag: Context.Service<Self, AnalyticsEngineQueryClient>, definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self, never, never>;
-declare const queryLayerConfig: <Self>(tag: Context.Service<Self, AnalyticsEngineQueryClient>, config?: Config.Config<AnalyticsEngineQueryDefinition>) => Layer.Layer<Self, Config.ConfigError, HttpClient.HttpClient>;
-declare const layerFetchConfig: <Self>(tag: Context.Service<Self, AnalyticsEngineQueryClient>, config?: Config.Config<AnalyticsEngineQueryDefinition>) => Layer.Layer<Self, Config.ConfigError, never>;
-declare const layer$12: <Self>(tag: Context.Service<Self, AnalyticsEngineClient>, definition: LayerOptions$11) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const make$10: <Id extends string>(id: Id) => TagClass$9<AnalyticsEngineService<Id>, Id>;
-declare const makeQuery: <Id extends string>(id: Id) => QueryTagClass<AnalyticsEngineQueryService<Id>, Id>;
-declare const Tag$10: <Self>() => <Id extends string>(id: Id) => TagClass$9<Self, Id>;
-declare const QueryTag: <Self>() => <Id extends string>(id: Id) => QueryTagClass<Self, Id>;
-declare namespace BrowserRendering_d_exports {
-  export { BrowserRenderingBinding, BrowserRenderingBrowserClient, BrowserRenderingBrowserLike, BrowserRenderingClient, BrowserRenderingConnect, BrowserRenderingDefinition, BrowserRenderingExternalResult, BrowserRenderingLaunch, BrowserRenderingMethodOptions, BrowserRenderingOperationError, BrowserRenderingPageClient, BrowserRenderingPageFunction, BrowserRenderingPageLike, BrowserRenderingService, LayerOptions$10 as LayerOptions, Tag$9 as Tag, TagClass$8 as TagClass, isBrowserRenderingBinding, layer$11 as layer, make$9 as make, makeClient$7 as makeClient };
-}
-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>;
-declare class BrowserRenderingOperationError extends BrowserRenderingOperationError_base<{
-  readonly binding: string;
-  readonly operation: string;
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-interface BrowserRenderingDefinition {
-  readonly binding: string;
-}
-type BrowserRenderingBinding = object;
-interface BrowserRenderingMethodOptions {}
-type BrowserRenderingExternalResult = Awaited<ReturnType<Response["json"]>>;
-type BrowserRenderingPageFunction = string | Function;
-type BrowserRenderingLaunch<RawBinding, Browser, LaunchOptions = unknown> = (binding: RawBinding, options?: LaunchOptions) => Promise<Browser>;
-type BrowserRenderingConnect<RawBinding, Browser, ConnectOptions = unknown> = (binding: RawBinding, options?: ConnectOptions) => Promise<Browser>;
-interface BrowserRenderingBrowserLike<Page = BrowserRenderingPageLike> {
-  readonly newPage: () => Promise<Page>;
-  readonly close?: () => Promise<void>;
-  readonly disconnect?: () => void;
-  readonly version?: () => Promise<string>;
-}
-interface BrowserRenderingPageLike {
-  readonly goto?: (url: string, options?: BrowserRenderingMethodOptions) => Promise<BrowserRenderingExternalResult>;
-  readonly setContent?: (html: string, options?: BrowserRenderingMethodOptions) => Promise<void>;
-  readonly content?: () => Promise<string>;
-  readonly screenshot?: (options?: BrowserRenderingMethodOptions) => Promise<Uint8Array | string>;
-  readonly pdf?: (options?: BrowserRenderingMethodOptions) => Promise<Uint8Array>;
-  readonly evaluate?: (pageFunction: BrowserRenderingPageFunction, ...args: ReadonlyArray<unknown>) => Promise<BrowserRenderingExternalResult>;
-  readonly close?: (options?: BrowserRenderingMethodOptions) => Promise<void>;
-}
-interface BrowserRenderingPageClient<Page extends BrowserRenderingPageLike> {
-  readonly raw: Page;
-  readonly goto: (url: string, options?: Parameters<NonNullable<Page["goto"]>>[1]) => Effect.Effect<Awaited<ReturnType<NonNullable<Page["goto"]>>>, BrowserRenderingOperationError>;
-  readonly setContent: (html: string, options?: Parameters<NonNullable<Page["setContent"]>>[1]) => Effect.Effect<void, BrowserRenderingOperationError>;
-  readonly content: Effect.Effect<string, BrowserRenderingOperationError>;
-  readonly screenshot: (options?: Parameters<NonNullable<Page["screenshot"]>>[0]) => Effect.Effect<Awaited<ReturnType<NonNullable<Page["screenshot"]>>>, BrowserRenderingOperationError>;
-  readonly pdf: (options?: Parameters<NonNullable<Page["pdf"]>>[0]) => Effect.Effect<Awaited<ReturnType<NonNullable<Page["pdf"]>>>, BrowserRenderingOperationError>;
-  readonly evaluate: (pageFunction: Parameters<NonNullable<Page["evaluate"]>>[0], ...args: ReadonlyArray<unknown>) => Effect.Effect<Awaited<ReturnType<NonNullable<Page["evaluate"]>>>, BrowserRenderingOperationError>;
-  readonly close: (options?: Parameters<NonNullable<Page["close"]>>[0]) => Effect.Effect<void, BrowserRenderingOperationError>;
-}
-interface BrowserRenderingBrowserClient<Browser extends BrowserRenderingBrowserLike<Page>, Page extends BrowserRenderingPageLike> {
-  readonly raw: Browser;
-  readonly newPage: Effect.Effect<BrowserRenderingPageClient<Page>, BrowserRenderingOperationError>;
-  readonly version: Effect.Effect<string, BrowserRenderingOperationError>;
-  readonly close: Effect.Effect<void, BrowserRenderingOperationError>;
-  readonly disconnect: Effect.Effect<void, BrowserRenderingOperationError>;
-}
-interface BrowserRenderingClient<RawBinding extends BrowserRenderingBinding = BrowserRenderingBinding> {
-  readonly launchWith: <Browser extends BrowserRenderingBrowserLike<Page>, Page extends BrowserRenderingPageLike = BrowserRenderingPageLike, LaunchOptions = unknown>(launch: BrowserRenderingLaunch<RawBinding, Browser, LaunchOptions>, options?: LaunchOptions) => Effect.Effect<BrowserRenderingBrowserClient<Browser, Page>, BrowserRenderingOperationError>;
-  readonly connectWith: <Browser extends BrowserRenderingBrowserLike<Page>, Page extends BrowserRenderingPageLike = BrowserRenderingPageLike, ConnectOptions = unknown>(connect: BrowserRenderingConnect<RawBinding, Browser, ConnectOptions>, options?: ConnectOptions) => Effect.Effect<BrowserRenderingBrowserClient<Browser, Page>, BrowserRenderingOperationError>;
-  readonly rawUnsafe: Effect.Effect<RawBinding>;
-  readonly definition: BrowserRenderingDefinition;
-}
-declare const BrowserRenderingServiceTypeId: unique symbol;
-interface BrowserRenderingService<Id extends string> {
-  readonly [BrowserRenderingServiceTypeId]: {
-    readonly id: Id;
-  };
-}
-type LayerOptions$10 = {
-  readonly binding: string;
-};
-interface TagClass$8<Self, Id extends string> extends Context.ServiceClass<Self, Id, BrowserRenderingClient> {
-  readonly id: Id;
-  readonly layer: (options: LayerOptions$10) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-}
-declare const isBrowserRenderingBinding: <Candidate>(value: Candidate) => value is Candidate & BrowserRenderingBinding;
-declare const makeClient$7: <RawBinding extends BrowserRenderingBinding = BrowserRenderingBinding>(definition: BrowserRenderingDefinition) => (binding: RawBinding) => BrowserRenderingClient<RawBinding>;
-declare const layer$11: <Self>(tag: Context.Service<Self, BrowserRenderingClient>, definition: BrowserRenderingDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const make$9: <Id extends string>(id: Id) => TagClass$8<BrowserRenderingService<Id>, Id>;
-declare const Tag$9: <Self>() => <Id extends string>(id: Id) => TagClass$8<Self, Id>;
-declare namespace Cache_d_exports {
-  export { CacheClient, CacheOperation, CacheOperationError, CacheQueryOptions, CacheRequest, CacheStorage, CacheStorageClient, layer$10 as layer, layerFrom, makeCacheClient, makeClient$6 as makeClient };
-}
-type CacheRequest = CloudflareRequestInfo | URL;
-type CacheQueryOptions = CloudflareCacheQueryOptions;
-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>;
-declare class CacheOperationError extends CacheOperationError_base<{
-  readonly cache: string;
-  readonly operation: CacheOperation;
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-interface CacheClient {
-  readonly name: string;
-  readonly match: (request: CacheRequest, options?: CacheQueryOptions) => Effect.Effect<Option.Option<Response>, CacheOperationError>;
-  readonly put: (request: CacheRequest, response: Response) => Effect.Effect<void, CacheOperationError>;
-  readonly delete: (request: CacheRequest, options?: CacheQueryOptions) => Effect.Effect<boolean, CacheOperationError>;
-  readonly rawUnsafe: Effect.Effect<CloudflareCache>;
-}
-interface CacheStorageClient {
-  readonly default: CacheClient;
-  readonly open: (name: string) => Effect.Effect<CacheClient, CacheOperationError>;
-  readonly rawUnsafe: Effect.Effect<CloudflareCacheStorage>;
-}
-declare const CacheStorage_base: Context.ServiceClass<CacheStorage, "effect-cf/CacheStorage", CacheStorageClient>;
-declare class CacheStorage extends CacheStorage_base {}
-declare const makeCacheClient: (cache: CloudflareCache, name?: string) => CacheClient;
-declare const makeClient$6: (storage: CloudflareCacheStorage) => CacheStorageClient;
-declare const layerFrom: (storage: CloudflareCacheStorage) => Layer.Layer<CacheStorage>;
-declare const layer$10: Layer.Layer<CacheStorage>;
-declare namespace CloudflareOtlp_d_exports {
-  export { DurableObjectLayerOptions, LayerOptions$9 as LayerOptions, ResourceOptions, Serialization, Signal, WorkerLayerOptions, layer$9 as layer, layerDurableObject, layerJson, layerProtobuf, layerWorker };
-}
-type ResourceAttributes = NonNullable<Parameters<typeof OtlpResource.make>[0]["attributes"]>;
-/** Telemetry signal groups supported by the Cloudflare OTLP layers. */
-type Signal = "logs" | "traces" | "metrics";
-/** OTLP payload serialization used by the Effect OTLP exporters. */
-type Serialization = "json" | "protobuf";
-/**
- * Resource metadata shared by Worker and Durable Object OTLP layers.
- *
- * Precedence follows Effect's `OtlpResource.fromConfig`: explicit
- * `serviceName`/`serviceVersion` win over matching explicit `attributes`, and
- * explicit attributes win over `OTEL_SERVICE_NAME`, `OTEL_SERVICE_VERSION`, and
- * `OTEL_RESOURCE_ATTRIBUTES`. Omit an option to let operators set it from the
- * environment.
- */
-interface ResourceOptions {
-  /** Explicit service name. Takes precedence over OTEL environment variables. */
-  readonly serviceName?: string;
-  /** Explicit service version. Takes precedence over OTEL environment variables. */
-  readonly serviceVersion?: string;
-  /** Additional resource attributes attached to exported telemetry. */
-  readonly attributes?: ResourceAttributes;
-}
-/** Options shared by all Cloudflare OTLP telemetry layers. */
-interface LayerOptions$9 {
-  /**
-   * Telemetry signals to export. Defaults to logs, traces, and metrics.
-   *
-   * Each selected signal is still controlled by standard OTEL exporter config,
-   * such as `OTEL_TRACES_EXPORTER=otlp`.
-   */
-  readonly signals?: ReadonlyArray<Signal>;
-  /** OTLP payload serialization. Defaults to protobuf. */
-  readonly serialization?: Serialization;
-  readonly resource?: ResourceOptions;
-  readonly headers?: Headers$1.Input;
-  readonly loggerExcludeLogSpans?: boolean;
-  readonly loggerMergeWithExisting?: boolean;
-  readonly tracerContext?: <X>(primitive: Tracer$1.EffectPrimitive<X>, span: Tracer$1.AnySpan) => X;
-}
-interface WorkerLayerOptions extends LayerOptions$9 {
-  readonly workerName?: string;
-}
-interface DurableObjectLayerOptions extends LayerOptions$9 {
-  readonly className?: string;
-  /**
-   * Include the Durable Object id as `cloudflare.durable_object.id`.
-   *
-   * This is disabled by default because object ids can be high-cardinality.
-   */
-  readonly includeObjectId?: boolean;
-}
-/**
- * Base OTLP telemetry layer for Cloudflare-compatible runtimes.
- *
- * Standard OpenTelemetry environment variables are resolved by Effect's OTLP
- * layers. In Cloudflare Workers and Durable Objects, the current `env` object is
- * installed as the primary `ConfigProvider`; outside Cloudflare, the ambient
- * Effect `ConfigProvider` remains the fallback.
- *
- * The layer provides {@link OtlpExporter.Flusher} for draining buffered
- * telemetry before the isolate freezes.
- */
-declare const layer$9: (options?: LayerOptions$9) => Layer.Layer<OtlpExporter.Flusher>;
-/** Base OTLP telemetry layer forced to JSON serialization. */
-declare const layerJson: (options?: Omit<LayerOptions$9, "serialization">) => Layer.Layer<OtlpExporter.Flusher>;
-/** Base OTLP telemetry layer forced to protobuf serialization. */
-declare const layerProtobuf: (options?: Omit<LayerOptions$9, "serialization">) => Layer.Layer<OtlpExporter.Flusher>;
-/**
- * OTLP layer with Cloudflare Worker resource attributes.
- *
- * 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>;
-/**
- * OTLP layer with Cloudflare Durable Object resource attributes.
- *
- * The layer reads {@link DurableObjectState} so it can optionally include the
- * Durable Object id. Prefer leaving `includeObjectId` disabled unless the
- * backend can tolerate high-cardinality resource attributes.
- */
-declare const layerDurableObject: (options?: DurableObjectLayerOptions) => Layer.Layer<OtlpExporter.Flusher, never, DurableObjectState>;
-declare namespace CloudflareTracer_d_exports {
-  export { layer$8 as layer };
-}
-/**
- * Sends Effect spans to Cloudflare Workers Observability using the runtime's
- * custom span API. Build this layer inside each invocation, for example with
- * `Worker.make(Services, { eventLayer: CloudflareTracer.layer, fetch })`.
- * It captures the invocation's async context and must not be cached across requests.
- *
- * Enable `observability.traces.enabled` in Wrangler. Cloudflare owns sampling
- * and export; no OTLP exporter or flush is required. Scalar attributes are
- * forwarded; other attributes, events, and links remain Effect-local. Completion
- * is recorded as `effect.exit`, since Cloudflare has no outcome-setting API.
- * Effect trace/span IDs remain independent of Cloudflare's opaque IDs. External
- * parents and `root: true` cannot override the invocation's Cloudflare trace.
- */
-declare const layer$8: Layer.Layer<never>;
-declare namespace D1_d_exports {
-  export { D1Definition, D1Service, D1SqlLayerOptions, Service, TypeId$1 as TypeId, make$8 as make };
-}
-declare const TypeId$1: "~effect-cf/D1";
-type TypeId$1 = typeof TypeId$1;
-interface D1Definition {
-  readonly binding: string;
-}
-type D1SqlLayerOptions = Omit<D1Client.D1ClientConfig, "db">;
-declare const D1ServiceTypeId: unique symbol;
-interface D1Service<Id extends string> {
-  readonly [D1ServiceTypeId]: {
-    readonly id: Id;
-  };
-}
-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>;
-};
-declare const Service: <Self>() => <Id extends string>(id: Id, definition: D1Definition) => BindingService<Self, Id, D1Database> & {
-  "~effect-cf/D1": "~effect-cf/D1";
-  definition: D1Definition;
-  sqlLayer: (options?: D1SqlLayerOptions) => Layer.Layer<D1Client.D1Client | SqlClient.SqlClient, Config.ConfigError | BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-};
-declare namespace DurableObjectAlarm_d_exports {
-  export { AlarmDefinitionConfig, AlarmDefinitionEntry, AlarmDefinitionPayload, AlarmDefinitions, AlarmFailurePolicy, AlarmPayload, AlarmPayloadSchema, AlarmRef, AlarmRegistration, AlarmRetryPolicy, AlarmScheduler, AlarmService, AlarmTagClass, AlarmTransaction, DefinedAlarmEvent, DefinedAlarmHandlers, DefinedAlarmScheduler, DefinedAlarmTransaction, DefinedScheduleAlarmInput, DurableObjectAlarm, DurableObjectAlarmError, DurableObjectAlarmEvent, InvalidAlarmPayloadError, InvalidAlarmRefError, InvalidProcessDueAlarmsOptionsError, InvalidRepeatEveryError, ProcessDueAlarmsFailure, ProcessDueAlarmsFailureAction, ProcessDueAlarmsHandler, ProcessDueAlarmsMode, ProcessDueAlarmsOptions, ProcessDueAlarmsResult, ScheduleAlarmInput, StoredAlarmDecodeError, Tag$8 as Tag, define, processDue };
-}
-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";
-} & Readonly<A>;
-declare class InvalidAlarmRefError extends InvalidAlarmRefError_base<{
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-declare const InvalidAlarmPayloadError_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: "InvalidAlarmPayloadError";
-} & Readonly<A>;
-declare class InvalidAlarmPayloadError extends InvalidAlarmPayloadError_base<{
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-declare const InvalidRepeatEveryError_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: "InvalidRepeatEveryError";
-} & Readonly<A>;
-declare class InvalidRepeatEveryError extends InvalidRepeatEveryError_base<{
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-declare const InvalidProcessDueAlarmsOptionsError_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: "InvalidProcessDueAlarmsOptionsError";
-} & Readonly<A>;
-declare class InvalidProcessDueAlarmsOptionsError extends InvalidProcessDueAlarmsOptionsError_base<{
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-declare const StoredAlarmDecodeError_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: "StoredAlarmDecodeError";
-} & Readonly<A>;
-declare class StoredAlarmDecodeError extends StoredAlarmDecodeError_base<{
-  readonly cause: unknown;
-  readonly storageId: string;
-}> {
-  get message(): string;
-}
-type DurableObjectAlarmError = InvalidAlarmPayloadError | InvalidAlarmRefError | InvalidProcessDueAlarmsOptionsError | InvalidRepeatEveryError | StorageOperationError | StoredAlarmDecodeError;
-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;
-type AlarmRef<Tag extends string = string> = {
-  readonly id: string;
-  readonly tag: Tag;
-};
-/** 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;
-  readonly runAt: DateTime.Utc;
-};
-type ProcessDueAlarmsMode = "isolated" | "ordered";
-interface ProcessDueAlarmsFailure {
-  readonly cause: unknown;
-  readonly event?: DurableObjectAlarmEvent;
-  readonly id: string;
-  readonly storageId: string;
-  readonly tag: string;
-}
-interface ProcessDueAlarmsResult {
-  readonly failed: readonly ProcessDueAlarmsFailure[];
-  readonly handled: readonly DurableObjectAlarmEvent[];
-}
-type ProcessDueAlarmsFailureAction = "ordered" | "retry" | "skip-and-advance-repeat" | {
-  readonly mode: "ordered";
-} | {
-  readonly mode: "retry";
-  readonly retryFailedAfter?: Duration.Input;
-} | {
-  readonly mode: "skip-and-advance-repeat";
-};
-interface ProcessDueAlarmsOptions<OnFailureR = never, OnFailureE = never> {
-  readonly limit?: number;
-  /** `isolated` retries only the failed row; `ordered` stops before later rows. */
-  readonly mode?: ProcessDueAlarmsMode;
-  readonly onFailure?: (failure: ProcessDueAlarmsFailure) => Effect.Effect<ProcessDueAlarmsFailureAction | void, OnFailureE, OnFailureR>;
-  readonly retryFailedAfter?: Duration.Input;
-}
-type ProcessDueAlarmsHandler<R = never, E = never> = (event: DurableObjectAlarmEvent) => Effect.Effect<void, E, R>;
-/**
- * Alarm mutations owned by one transaction callback. Run them in the callback's
- * fiber; forked work and use after the callback ends fail with StorageOperationError.
- */
-type AlarmTransaction = Pick<AlarmScheduler, "scheduleAlarm" | "cancelAlarm">;
-/** Own `storage.setAlarm()` exclusively: a Durable Object has one platform alarm timestamp. */
-type AlarmScheduler = {
-  /**
-   * Commits local application storage and logical alarms in one native SQLite
-   * Durable Object transaction, reconciling the native alarm before commit.
-   * Use the supplied mutations, not standalone alarm methods or nested transactions.
-   * SqlClient queries must use this same Durable Object's storage.
-   *
-   * Failure, defects and interruption before commit roll back. A lost reply or
-   * interruption after commit does not undo committed state. Keep RPC and other
-   * external effects outside; atomically pre-arm a later wake before fallible work.
-   * Cloudflare's native retries are bounded; composition does not remove the
-   * pre-arm requirement or promise infinite retry liveness.
-   */
-  readonly transaction: <A, E, R>(closure: (alarms: AlarmTransaction) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | StorageOperationError, R>;
-  readonly cancelAlarm: (input: AlarmRef) => Effect.Effect<void, InvalidAlarmRefError | StorageOperationError>;
-  /** 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>;
-  /** 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>;
-type AlarmPayloadSchema = Schema.Codec<any, any, never, never>;
-type AlarmFailurePolicy = "ordered" | "retry" | "skip-and-advance-repeat";
-interface AlarmRetryPolicy {
-  readonly initialDelay?: Duration.Input;
-}
-interface AlarmDefinitionConfig<Payload extends AlarmPayloadSchema = AlarmPayloadSchema> {
-  readonly failure?: AlarmFailurePolicy;
-  readonly payload: Payload;
-  readonly retry?: AlarmRetryPolicy;
-}
-type AlarmDefinitionEntry = AlarmDefinitionConfig | AlarmPayloadSchema;
-type AlarmDefinitions = Readonly<Record<string, AlarmDefinitionEntry>>;
-type AlarmDefinitionSchema<Definition> = Definition extends AlarmDefinitionConfig<infer Payload> ? Payload : Definition;
-type AlarmDefinitionPayload<Definition> = AlarmDefinitionSchema<Definition> extends Schema.Codec<infer A, any, never, never> ? A : never;
-type DefinedAlarmEvent<Tag extends string, Payload> = Omit<DurableObjectAlarmEvent, "payload" | "tag"> & {
-  readonly payload: Payload;
-  readonly tag: Tag;
-};
-type DefinedAlarmHandlers<Definitions extends AlarmDefinitions, R = never, E = never> = { readonly [Tag in keyof Definitions & string]: (event: DefinedAlarmEvent<Tag$8, AlarmDefinitionPayload<Definitions[Tag$8]>>) => Effect.Effect<void, E, R>; };
-/** A discriminated union keeps each tag paired with its decoded payload type. */
-type DefinedScheduleAlarmInput<Definitions extends AlarmDefinitions> = { readonly [Tag in keyof Definitions & string]: Omit<ScheduleAlarmInput<Tag$8>, "payload"> & {
-  readonly payload: AlarmDefinitionPayload<Definitions[Tag$8]>;
-}; }[keyof Definitions & string];
-interface DefinedAlarmTransaction<Definitions extends AlarmDefinitions> {
-  readonly scheduleAlarm: (input: DefinedScheduleAlarmInput<Definitions>) => ReturnType<AlarmScheduler["scheduleAlarm"]>;
-  readonly cancelAlarm: (input: AlarmRef<keyof Definitions & string>) => ReturnType<AlarmScheduler["cancelAlarm"]>;
-}
-declare const TypedAlarmSchedulerTypeId: unique symbol;
-/** Identifies service requirements whose scheduler needs a registered dispatcher. */
-interface AlarmService {
-  readonly Service: {
-    readonly [TypedAlarmSchedulerTypeId]: typeof TypedAlarmSchedulerTypeId;
-  };
-}
-interface DefinedAlarmScheduler<Definitions extends AlarmDefinitions> extends DefinedAlarmTransaction<Definitions> {
-  readonly [TypedAlarmSchedulerTypeId]: typeof TypedAlarmSchedulerTypeId;
-  readonly transaction: <A, E, R>(closure: (alarms: DefinedAlarmTransaction<Definitions>) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | StorageOperationError, R>;
-}
-/** Registers a dispatcher and the service authorized to schedule its alarms. */
-interface AlarmRegistration<Self, R = never, E = never> {
-  readonly layer: Layer.Layer<Self, never, DurableObjectAlarm>;
-  readonly run: Effect.Effect<ProcessDueAlarmsResult, E | DurableObjectAlarmError, R | DurableObjectAlarm>;
-}
-interface AlarmTagClass<Self, Id extends string, Definitions extends AlarmDefinitions> extends Context.ServiceClass<Self, Id, DefinedAlarmScheduler<Definitions>> {
-  readonly handlers: <R = never, E = never>(handlers: DefinedAlarmHandlers<Definitions, R, E>, options?: ProcessDueAlarmsOptions<R, E>) => AlarmRegistration<Self, R, E>;
-}
-/** Handler-only definitions for applications using the raw scheduler. Prefer Tag for typed scheduling. */
-declare const define: <const Definitions extends AlarmDefinitions>(definitions: Definitions) => {
-  handlers: <R = never, E = never>(handlers: DefinedAlarmHandlers<Definitions, R, E>, options?: ProcessDueAlarmsOptions<R, E> | undefined) => Effect.Effect<ProcessDueAlarmsResult, E | DurableObjectAlarmError, R | DurableObjectAlarm>;
-};
-/** The typed scheduler becomes available when its handlers are registered on a Durable Object. */
-declare const Tag$8: <Self>() => <const Id extends string, const Definitions extends AlarmDefinitions>(id: Id, definitions: Definitions) => AlarmTagClass<Self, Id, Definitions>;
-declare const DurableObjectAlarm_base: Context.ServiceClass<DurableObjectAlarm, "effect-cf/DurableObjectAlarm", AlarmScheduler>;
-declare class DurableObjectAlarm extends DurableObjectAlarm_base {
-  static readonly layer: Layer.Layer<DurableObjectAlarm, never, DurableObjectState>;
-}
-declare namespace DurableObjectNamespace_d_exports {
-  export { DurableObjectFetchError, DurableObjectNamespaceBindingDefinition, DurableObjectNamespaceClient, DurableObjectNamespaceDefinition, DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient, DurableObjectRpcError, DurableObjectStubClient, isDurableObjectNamespaceClient, layer$7 as layer, makeClient$5 as makeClient, makeDirectMethods };
-}
-interface DurableObjectFetcher {
-  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
-}
-type RpcClient<Api> = { readonly [Key in keyof Api as Key extends string ? Api[Key] extends ((...args: Array<any>) => any) ? Key : never : never]: Api[Key]; };
-type ReservedMethodName$1 = ReservedMethodName | "fetch";
-type NamespaceCandidate = Parameters<typeof Predicate.isUnknown>[0];
-/**
- * Cloudflare Durable Object stub, optionally enriched with RPC methods.
- */
-type DurableObjectStubClient<Api extends object> = DurableObjectFetcher & RpcClient<Provider<Api, ReservedMethodName$1>> & {
-  readonly id: globalThis.DurableObjectId;
-  readonly name?: string;
-};
-interface DurableObjectNamespaceClient<Api extends object> {
-  newUniqueId(options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions): globalThis.DurableObjectId;
-  idFromName(name: string): globalThis.DurableObjectId;
-  idFromString(id: string): globalThis.DurableObjectId;
-  get(id: globalThis.DurableObjectId, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions): DurableObjectStubClient<Api>;
-  getByName(name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions): DurableObjectStubClient<Api>;
-  jurisdiction(jurisdiction: globalThis.DurableObjectJurisdiction): DurableObjectNamespaceClient<Api>;
-}
-/**
- * Minimal namespace binding metadata.
- */
-interface DurableObjectNamespaceDefinition {
-  readonly binding: string;
-}
-/**
- * Namespace binding metadata with optional RPC schema.
- */
-interface DurableObjectNamespaceBindingDefinition<Definition extends Definition$3.Any | undefined = undefined> {
-  readonly binding: string;
-  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";
-} & Readonly<A>;
-/**
- * Failure raised when invoking an RPC method on a Durable Object stub.
- */
-declare class DurableObjectRpcError extends DurableObjectRpcError_base<{
-  readonly binding: string;
-  readonly method: string;
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-declare const DurableObjectFetchError_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: "DurableObjectFetchError";
-} & Readonly<A>;
-/**
- * Failure raised when forwarding a request to a Durable Object stub.
- */
-declare class DurableObjectFetchError extends DurableObjectFetchError_base<{
-  readonly binding: string;
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-type StubMethodKey<Api> = AsyncMethodKey<Api>;
-type StubMethodArgs<Api, Method extends keyof Api> = AsyncMethodArgs<Api, Method>;
-type StubMethodSuccess<Api, Method extends keyof Api> = AsyncMethodSuccess<Api, Method>;
-type StubMethodCloudflareReturn<Api, Method extends keyof Api> = AsyncMethodCloudflareReturn<Api, Method>;
-type StubCall<R, Api extends object> = <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, R>;
-type DefinitionNamespaceDirectMethods<R, Api extends object, Definition extends Definition$3.Any> = { readonly [Method in Definition$4.MethodNames<Definition>]: (stub: DurableObjectStubClient<Api>, ...args: Method$2.Args<Definition["methods"][Method]>) => Effect.Effect<Method$2.Success<Definition["methods"][Method]>, DurableObjectRpcError, R>; };
-type DefinitionDurableObjectDirectClient<R, Definition extends Definition$3.Any> = {
-  readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
-} & { readonly [Method in Definition$4.MethodNames<Definition>]: (...args: Method$2.Args<Definition["methods"][Method]>) => Effect.Effect<Method$2.Success<Definition["methods"][Method]>, DurableObjectRpcError, R>; };
-type DefinitionNamespaceDirectClientMethods<R, Definition extends Definition$3.Any> = {
-  readonly byName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => DefinitionDurableObjectDirectClient<R, Definition>;
-  readonly byId: (id: globalThis.DurableObjectId, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => DefinitionDurableObjectDirectClient<R, Definition>;
-};
-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> & {
-  readonly newUniqueId: (options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions) => Effect.Effect<globalThis.DurableObjectId>;
-  readonly idFromName: (name: string) => Effect.Effect<globalThis.DurableObjectId>;
-  readonly idFromString: (id: string) => Effect.Effect<globalThis.DurableObjectId>;
-  readonly get: (id: globalThis.DurableObjectId, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>>;
-  readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>>;
-  readonly jurisdiction: (jurisdiction: globalThis.DurableObjectJurisdiction) => Effect.Effect<DurableObjectNamespaceClient<Api>>;
-  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.
-   *
-   * This preserves Cloudflare RPC behavior such as promise-like pipelining and
-   * transferable / disposable result objects. It does not resolve the returned
-   * promise-like value and it does not decode definition-backed success schemas.
-   *
-   * Most application code should use {@link call} instead.
-   */
-  readonly rpc: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodCloudflareReturn<Api, Method>, DurableObjectRpcError>;
-  /**
-   * Invokes a Durable Object RPC method, resolves Cloudflare's RPC result, and
-   * 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.
-   */
-  readonly call: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError>;
-  /**
-   * Invokes a Durable Object RPC method in the current `Scope`, resolves
-   * Cloudflare's RPC result, decodes definition-backed success values, and
-   * disposes the resolved result when the scope closes if it implements
-   * `Symbol.dispose`.
-   *
-   * Use this for RPC methods that return Cloudflare RPC resources or other
-   * disposable objects whose lifetime should be tied to an Effect scope.
-   */
-  readonly scopedCall: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, DurableObjectRpcError, Scope.Scope>;
-  /**
-   * Exposes the underlying native Durable Object namespace binding.
-   *
-   * Prefer the typed helpers above unless Cloudflare exposes a platform feature
-   * that is not wrapped by effect-cf yet.
-   */
-  readonly rawUnsafe: Effect.Effect<DurableObjectNamespaceClient<Api>>;
-};
-type DurableObjectNamespaceStaticClient<R, Api extends object, Definition extends Definition$3.Any | undefined = undefined> = DirectMethods<R, Api, Definition> & {
-  readonly newUniqueId: (options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions) => Effect.Effect<globalThis.DurableObjectId, never, R>;
-  readonly idFromName: (name: string) => Effect.Effect<globalThis.DurableObjectId, never, R>;
-  readonly idFromString: (id: string) => Effect.Effect<globalThis.DurableObjectId, never, R>;
-  readonly get: (id: globalThis.DurableObjectId, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
-  readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
-  readonly jurisdiction: (jurisdiction: globalThis.DurableObjectJurisdiction) => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
-  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>>, DurableObjectRpcError, Scope.Scope | R>;
-  readonly rawUnsafe: () => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
-};
-declare const isDurableObjectNamespaceClient: <Api extends object>(value: NamespaceCandidate) => value is DurableObjectNamespaceClient<Api>;
-declare const makeClient$5: <Api extends object, const Definition extends Definition$3.Any | undefined = undefined>(definition: DurableObjectNamespaceBindingDefinition<Definition>) => ((namespace: DurableObjectNamespaceClient<Api>) => DurableObjectNamespaceEffectClient<Api, Definition>);
-declare const layer$7: <Self, Api extends object, const Definition extends Definition$3.Any | undefined = undefined>(tag: Context.Service<Self, DurableObjectNamespaceEffectClient<Api, Definition>>, definition: DurableObjectNamespaceBindingDefinition<Definition>) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const makeDirectMethods: <R, Api extends object, Definition extends Definition$3.Any | undefined>(rpcDefinition: Definition | undefined, helpers: {
-  readonly call: StubCall<R, Api>;
-  readonly fetch: (stub: DurableObjectStubClient<Api>, input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
-  readonly get: (id: globalThis.DurableObjectId, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
-  readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
-}) => DirectMethods<R, Api, Definition>;
-declare namespace DurableObjectDefinition_d_exports {
-  export { Api, Definition$3 as Definition, DurableObject$1 as DurableObject, HandlerEffect, Handlers, LayerOptions$8 as LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options$2 as Options, ReservedMethodName, ServerApi, ServiceFreeSchema, Tag$7 as Tag, TagClass$7 as TagClass, implement$2 as implement, make$7 as make, method };
-}
-type ServiceFreeSchema = Schema.Codec<any, any, never, never>;
-interface Method$1<Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema = ServiceFreeSchema> {
-  readonly args: Args;
-  readonly success: Success;
-}
-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]>>;
-  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"]>;
-  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
-  export type EncodedSuccess<_Self extends Any> = Schema.Json;
-  export {};
-}
-type Methods = Record<string, Method$1.Any>;
-/**
- * RPC contract for a Durable Object class.
- */
-interface Definition$3<Id extends string = string, MethodDefinitions extends Methods = Methods> {
-  readonly id: Id;
-  readonly methods: MethodDefinitions;
-}
-declare namespace Definition$3 {
-  type Any = Definition$3<string, Methods>;
-}
-type ReservedMethodName = ReservedMethodName$2 | "fetch" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError";
-type NoReservedMethods<MethodDefinitions extends Methods> = Extract<keyof MethodDefinitions, ReservedMethodName> extends never ? MethodDefinitions : never;
-/**
- * Promise-based client API derived from a Durable Object definition.
- */
-type ServerApi<Self extends Definition$3.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$1.Args<Self["methods"][Key]>) => Promise<Method$1.Success<Self["methods"][Key]>>; };
-type Api<Self extends Definition$3.Any> = Provider<ServerApi<Self>, ReservedMethodName>;
-/**
- * Effect handlers for each RPC method in a Durable Object definition.
- */
-type Handlers<ROut, Self extends Definition$3.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$1.Args<Self["methods"][Key]>) => DurableObjectHandler<ROut, Method$1.Success<Self["methods"][Key]>>; };
-/**
- * Durable Object constructor options for a specific RPC definition.
- */
-type Options$2<ROut, Self extends Definition$3.Any, REvent = never, EventLayerError = never, RAlarm = never> = DurableObjectOptions<ROut, REvent, EventLayerError, Handlers<NoInfer<ROut> | REvent | NoInfer<RAlarm>, Self>, RAlarm> & {
-  readonly rpc: Handlers<NoInfer<ROut> | REvent | NoInfer<RAlarm>, Self>;
-};
-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;
-  readonly methods: MethodDefinitions;
-  readonly make: <ROut, LayerError, REvent = never, EventLayerError = never, RAlarm = never>(layer: Layer.Layer<ROut, LayerError, RuntimeContext$1<NoInfer<RAlarm>>>, options: Options$2<ROut, Definition$3<Id, MethodDefinitions>, REvent, EventLayerError, RAlarm>) => DurableObjectClass<Handlers<ROut | REvent | RAlarm, Definition$3<Id, MethodDefinitions>>, ROut | REvent | RAlarm>;
-  readonly layer: (options: LayerOptions$8) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-};
-/**
- * Defines a single RPC method schema in a Durable Object definition.
- */
-declare function method<Success extends ServiceFreeSchema>(definition: {
-  readonly success: Success;
-}): Method$1<readonly [], Success>;
-declare function method<const Args extends ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema>(definition: {
-  readonly args: Args;
-  readonly success: Success;
-}): Method$1<Args, Success>;
-declare const make$7: <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>) => TagClass$7<Definition$3<Id, MethodDefinitions>, Id, MethodDefinitions>;
-declare const Tag$7: <Self>() => <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>) => TagClass$7<Self, Id, MethodDefinitions>;
-declare const DurableObject$1: typeof Tag$7;
-/**
- * Helper for implementing handlers with the exact method shape of a definition.
- */
-declare const implement$2: <ROut, const Self extends Definition$3.Any>(_definition: Self, handlers: Handlers<ROut, Self>) => Handlers<ROut, Self>;
-/**
- * Convenience alias for a single Durable Object RPC handler Effect.
- */
-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, RunOptions, RunSymbol, RuntimeContext$1 as RuntimeContext, ServerApi, ServiceFreeSchema, Tag$7 as Tag, TagClass$7 as TagClass, implement$2 as implement, make$6 as make, method };
-}
-type RuntimeContext$1<ROut> = DurableObjectState | DurableObjectAlarm | 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.
- */
-type DurableObjectHandler<ROut, A = unknown> = Effect.Effect<A, unknown, HandlerContext<ROut>>;
-/**
- * Shape of Durable Object RPC handlers passed to {@link make}.
- */
-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; };
-interface DurableObjectOptionsBase<RRuntime, REvent = never, EventLayerError = never, Rpc extends DurableObjectRpc<RRuntime | REvent | RAlarm> = Record<never, never>, RAlarm = never> {
-  /**
-   * Layer provided around each Cloudflare event handled by this Durable Object.
-   *
-   * The layer is built inside the event's Effect scope and finalized when the
-   * event effect completes. It is not applied to `initialize`, which is an
-   * instance-load lifecycle hook rather than a platform event.
-   */
-  readonly eventLayer?: Layer.Layer<REvent, EventLayerError, RuntimeContext$1<NoInfer<RRuntime | RAlarm>>>;
-  /**
-   * Effect run when Cloudflare loads this Durable Object instance into memory.
-   *
-   * Use `DurableObjectState.blockConcurrencyWhile` inside this hook when
-   * incoming events should wait for setup to finish. Cloudflare may construct
-   * the same Durable Object id again after eviction or restart; use Durable
-   * Object storage if work must happen only once per id.
-   */
-  readonly initialize?: Effect.Effect<void, unknown, HandlerContext<NoInfer<RRuntime | RAlarm>>>;
-  /**
-   * Optional RPC methods exposed as Durable Object instance methods.
-   *
-   * After every invocation, the configured OTLP flusher is scheduled through
-   * `DurableObjectState.waitUntil`, including when the handler fails. The
-   * scheduled flush silently settles within two seconds even if the exporter
-   * does not.
-   */
-  readonly rpc?: Rpc;
-  /** Accept live native trace metadata. The client must also enable rpcTracing. */
-  readonly rpcTracing?: ReceiverOptions;
-  readonly fetch?: Effect.Effect<Response, unknown, FetchContext<NoInfer<RRuntime | REvent | RAlarm>>>;
-  /** Register handlers to provide their typed scheduler to application layers and all DO events. */
-  readonly alarms?: Effect.Effect<unknown, unknown, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>> | AlarmRegistration<RAlarm, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>, unknown>;
-  /**
-   * Optional raw alarm handler.
-   *
-   * After every invocation, the configured OTLP flusher is scheduled through
-   * `DurableObjectState.waitUntil`, including when the handler fails. The
-   * scheduled flush silently settles within two seconds even if the exporter
-   * does not.
-   */
-  readonly alarm?: (alarmInfo?: globalThis.AlarmInvocationInfo) => Effect.Effect<void, unknown, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>>;
-  readonly webSocketMessage?: (socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, unknown, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>>;
-  readonly webSocketClose?: (socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, unknown, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>>;
-  readonly webSocketError?: (socket: DurableWebSocket, cause: unknown) => Effect.Effect<void, unknown, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>>;
-}
-type CheckAlarmRegistration<RProvided, RAlarm> = [Exclude<Extract<NoInfer<RProvided>, AlarmService>, NoInfer<RAlarm>>] extends [never] ? unknown : never;
-/** A declared event or alarm service must have its corresponding provider. */
-type DurableObjectOptions<RRuntime, REvent = never, EventLayerError = never, Rpc extends DurableObjectRpc<RRuntime | REvent | RAlarm> = Record<never, never>, RAlarm = never> = DurableObjectOptionsBase<RRuntime, REvent, EventLayerError, Rpc, RAlarm> & CheckAlarmRegistration<RRuntime | REvent, RAlarm> & ([Exclude<REvent, RuntimeContext$1<RRuntime | RAlarm> | Scope.Scope>] extends [never] ? unknown : {
-  readonly eventLayer: Layer.Layer<REvent, EventLayerError, RuntimeContext$1<NoInfer<RRuntime | RAlarm>>>;
-}) & ([RAlarm] extends [never] ? unknown : {
-  readonly alarms: AlarmRegistration<RAlarm, HandlerContext<NoInfer<RRuntime> | REvent | NoInfer<RAlarm>>, unknown>;
-});
-/**
- * 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> & {
-  [RunSymbol]<A, E>(effect: Effect.Effect<A, E, HandlerContext<ROut>>, options?: RunOptions): Promise<A>;
-};
-/**
- * Builds a Durable Object whose base `layer` lives for the in-memory instance.
- * Cloudflare does not expose an eviction or shutdown hook, so finalizers in
- * that layer are not guaranteed to run. Put resources that require timely
- * release in `eventLayer`, whose scope closes after each handled event.
- */
-declare function make$6<ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, RuntimeContext$1<never>> & CheckAlarmRegistration<ROut, never>): DurableObjectClass<Record<never, never>, ROut>;
-declare function make$6<ROut, LayerError, REvent = never, EventLayerError = never, const Rpc extends DurableObjectRpc<NoInfer<ROut> | REvent | NoInfer<RAlarm>> = Record<never, never>, RAlarm = never>(layer: Layer.Layer<ROut, LayerError, RuntimeContext$1<NoInfer<RAlarm>>>, options: DurableObjectOptions<ROut, REvent, EventLayerError, Rpc, RAlarm>): DurableObjectClass<Rpc, ROut | REvent | RAlarm>;
-declare namespace DurableObjectRpcWebSocket_d_exports {
-  export { DurableObjectRpcWebSocket, DurableObjectRpcWebSocketService, HeartbeatPolicy, LayerOptions$7 as LayerOptions, NativeWebSocketMessage, ResumableStreamDeclaration, RpcWebSocketAttachment, layer$6 as layer, resumableStream };
-}
-/** Heartbeat handling for Effect's application-level RPC Ping messages. */
-type HeartbeatPolicy = "auto-response" | "passthrough";
-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;
-  readonly rpcTag: string;
-  /** Validates a resume descriptor restored from a websocket attachment. */
-  readonly resumeDescriptorSchema: Schema.Decoder<ResumeDescriptor>;
-  /** Validates an acknowledged checkpoint restored from a websocket attachment. */
-  readonly checkpointSchema: Schema.Decoder<Checkpoint>;
-  /**
-   * Extracts compact persisted state from an initial encoded request. Do not
-   * recycle a subscription key for an unrelated logical subscription while a
-   * delayed checkpoint for the previous subscription can still arrive.
-   */
-  readonly identify: (request: RpcMessage.RequestEncoded) => Option.Option<{
-    readonly subscriptionKey: string;
-    readonly resumeDescriptor: ResumeDescriptor;
-    readonly acknowledgedCheckpoint: Checkpoint;
-  }>;
-  readonly rebuild: (options: {
-    readonly subscriptionKey: string;
-    readonly resumeDescriptor: ResumeDescriptor;
-    readonly acknowledgedCheckpoint: Checkpoint;
-  }) => {
-    readonly payload: unknown;
-    readonly headers?: ReadonlyArray<readonly [string, string]> | undefined;
-    readonly traceId?: string | undefined;
-    readonly spanId?: string | undefined;
-    readonly sampled?: boolean | undefined;
-  };
-  /** Extracts the durable checkpoint represented by one encoded stream value. */
-  readonly checkpointFromValue: (value: RpcMessage.ResponseChunkEncoded["values"][number]) => Option.Option<Checkpoint>;
-  /**
-   * Produces the checkpoint wire token. A logical event must keep the same
-   * token when replayed, and unrelated events must never reuse it during the
-   * lifetime of a subscription key.
-   */
-  readonly checkpointToken: (checkpoint: Checkpoint) => string;
-}
-type AnyResumableStreamDeclaration = ResumableStreamDeclaration<any, any>;
-/** Declares an explicitly resumable RPC stream. */
-declare const resumableStream: <ResumeDescriptor, Checkpoint>(declaration: ResumableStreamDeclaration<ResumeDescriptor, Checkpoint>) => ResumableStreamDeclaration<ResumeDescriptor, Checkpoint>;
-/**
- * Configuration for {@link layer}.
- */
-interface LayerOptions$7 {
-  readonly tag?: string | undefined;
-  readonly attachmentKey?: string | undefined;
-  /**
-   * Heartbeat behavior. `"auto-response"` (the default) installs Cloudflare's
-   * hibernation-safe text Ping/Pong response while an RPC socket exists and no
-   * non-resumable RPC operation is active, then removes it while one is pending.
-   * `"passthrough"` leaves the Durable Object's existing auto-response
-   * configuration unchanged and makes the application responsible for waking a
-   * lost pending operation.
-   * Cloudflare's pair is global to the Durable Object, so use `"passthrough"`
-   * when RPC and unrelated websocket protocols share one object.
-   */
-  readonly heartbeat?: HeartbeatPolicy | undefined;
-  readonly resumableStreams?: ReadonlyArray<AnyResumableStreamDeclaration> | undefined;
-}
-type NativeWebSocketMessage = string | ArrayBuffer;
-interface DurableObjectRpcWebSocketService {
-  /** Accept a server socket that has not already been accepted. */
-  readonly accept: (socket: DurableWebSocket, tags?: ReadonlyArray<string>) => Effect.Effect<void>;
-  /** 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>;
-  readonly error: (socket: DurableWebSocket, cause: unknown) => Effect.Effect<void>;
-  /**
-   * Persists forward checkpoint progress for a resumable stream. Returns `true`
-   * only when the checkpoint advances the current pending chunk batch. A failed
-   * websocket attachment write resets the connection and fails with
-   * `DurableWebSocketAttachmentError`.
-   */
-  readonly checkpoint: <ResumeDescriptor, Checkpoint>(declaration: ResumableStreamDeclaration<ResumeDescriptor, Checkpoint>, options: {
-    readonly clientId: number;
-    readonly subscriptionKey: string;
-    readonly checkpoint: Checkpoint;
-  }) => Effect.Effect<boolean, DurableWebSocketAttachmentError>;
-}
-declare const DurableObjectRpcWebSocket_base: Context.ServiceClass<DurableObjectRpcWebSocket, "effect-cf/DurableObjectRpcWebSocket", DurableObjectRpcWebSocketService>;
-declare class DurableObjectRpcWebSocket extends DurableObjectRpcWebSocket_base {}
-/**
- * Builds a hibernation-aware transport that bridges Durable Object websocket
- * events to `RpcServer.Protocol`.
- *
- * The layer restores idle tagged sockets and explicitly declared resumable
- * streams after constructor recreation. A socket that lost any other in-flight
- * request is closed with code 1012, which the stock Effect socket protocol
- * reports as an `RpcClientError` containing `SocketCloseError`.
- */
-declare const layer$6: (options?: LayerOptions$7) => Layer.Layer<RpcServer.Protocol | DurableObjectRpcWebSocket, never, DurableObjectState | RpcSerialization.RpcSerialization>;
-declare namespace DurableObjectSqlite_d_exports {
-  export { SqliteLayerOptions, layer$5 as layer };
-}
-type SqliteLayerOptions = Omit<SqliteClient.SqliteClientConfig, "db" | "storage">;
-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$6 as Tag, TagClass$6 as TagClass, emailErrorCodes, isEmailBinding, layer$4 as layer, make$5 as make, makeClient$4 as makeClient, sendLimits, validateMessage };
-}
-declare const sendLimits: {
-  readonly maxRecipients: 50;
-  readonly maxAttachments: 32;
-  readonly maxMessageBytes: number;
-  readonly maxHeaderNameBytes: 100;
-  readonly maxHeaderValueBytes: 2048;
-  readonly maxHeadersBytes: number;
-  readonly maxAllowlistHeaders: 20;
-};
-/**
- * Error codes reported by Cloudflare Email Sending.
- *
- * Surfaced on {@link EmailOperationError} `code` on a best-effort basis: the
- * runtime attaches them as a non-standard `code` property on thrown errors,
- * which may be missing depending on the runtime or dev-time proxying
- * (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"];
-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>;
-declare class EmailOperationError extends EmailOperationError_base<{
-  readonly binding: string;
-  readonly operation: string;
-  readonly cause: unknown;
-  /**
-   * Cloudflare error code taken from the thrown error, when present.
-   *
-   * Best-effort: may be `undefined` depending on the runtime or dev-time
-   * proxying — miniflare remote bindings (`"remote": true`) serialize thrown
-   * errors and can strip the non-standard `code` property.
-   */
-  readonly code?: EmailErrorCode | (string & {});
-}> {
-  get message(): string;
-}
-interface EmailViolation {
-  readonly path: string;
-  readonly message: string;
-  readonly limit?: number;
-  readonly actual?: number;
-}
-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>;
-declare class EmailValidationError extends EmailValidationError_base<{
-  readonly binding: string;
-  readonly operation: string;
-  readonly violations: ReadonlyArray<EmailViolation>;
-}> {
-  get message(): string;
-}
-interface EmailDefinition {
-  readonly binding: string;
-}
-type EmailAddress = CloudflareEmailAddress;
-type EmailAttachment = CloudflareEmailAttachment;
-type EmailMessageBuilder = Parameters<CloudflareSendEmail["send"]>[0];
-type EmailSendResult = CloudflareEmailSendResult;
-type EmailBinding = CloudflareSendEmail;
-type EmailRecipients = string | EmailAddress | ReadonlyArray<string | EmailAddress>;
-type EmailSendError = EmailOperationError | EmailValidationError;
-interface EmailSendOptions {
-  readonly validate?: boolean;
-}
-interface EmailClient {
-  readonly send: (message: EmailMessageBuilder) => Effect.Effect<EmailSendResult, EmailSendError>;
-  readonly rawUnsafe: Effect.Effect<EmailBinding>;
-  readonly definition: EmailDefinition;
-}
-declare const EmailServiceTypeId: unique symbol;
-interface EmailService<Id extends string> {
-  readonly [EmailServiceTypeId]: {
-    readonly id: Id;
-  };
-}
-type LayerOptions$6 = {
-  readonly binding: string;
-  readonly send?: EmailSendOptions;
-};
-interface TagClass$6<Self, Id extends string> extends Context.ServiceClass<Self, Id, EmailClient> {
-  readonly id: Id;
-  readonly layer: (options: LayerOptions$6) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-}
-/**
- * Validates a structured message against documented Cloudflare Email Sending
- * limits and returns every violation found. Total message size is not checked
- * because the encoded MIME size is only known once Cloudflare composes it.
- */
-declare const validateMessage: (message: EmailMessageBuilder) => ReadonlyArray<EmailViolation>;
-declare const isEmailBinding: <Candidate>(value: Candidate) => value is Candidate & EmailBinding;
-declare const makeClient$4: (definition: EmailDefinition, options?: EmailSendOptions) => (email: EmailBinding) => EmailClient;
-declare const layer$4: <Self>(tag: Context.Service<Self, EmailClient>, definition: LayerOptions$6) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const make$5: <Id extends string>(id: Id) => TagClass$6<EmailService<Id>, Id>;
-declare const Tag$6: <Self>() => <Id extends string>(id: Id) => TagClass$6<Self, Id>;
-declare namespace Images_d_exports {
-  export { DrawStepOptions, HostedImagesClient, ImageDirectUploadOptions, ImageDirectUploadResult, ImageDrawOptions, ImageHandleClient, ImageInfoResponse, ImageInputOptions, ImageInputValue, ImageList, ImageListOptions, ImageMetadata, ImageOutputOptions, ImageSignedUrlOptions, ImageTransform, ImageTransformationOutputOptions, ImageTransformationResponseOptions, ImageTransformationResult, ImageUpdateOptions, ImageUploadOptions, ImageUploadValue, ImagesClient, ImagesDefinition, ImagesOperationError, ImagesRuntimeBinding, ImagesService, ImagesTransformationResultClient, LayerOptions$5 as LayerOptions, ProcessOptions, Step, Steps, Tag$5 as Tag, TagClass$5 as TagClass, TextOptions, TypeId, draw, empty, isImagesBinding, layer$3 as layer, make$4 as make, makeClient$3 as makeClient, transform };
-}
-declare const TypeId: "~effect-cf/Images/Steps";
-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>;
-declare class ImagesOperationError extends ImagesOperationError_base<{
-  readonly binding: string;
-  readonly operation: string;
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-interface ImagesDefinition {
-  readonly binding: string;
-}
-type ImageInfoResponse = CloudflareImageInfoResponse;
-type ImageTransform = CloudflareImageTransform;
-type ImageDrawOptions = CloudflareImageDrawOptions;
-type ImageInputOptions = CloudflareImageInputOptions;
-type ImageOutputOptions = CloudflareImageOutputOptions;
-type ImageTransformationOutputOptions = CloudflareImageTransformationOutputOptions;
-type ImageTransformationResponseOptions = CloudflareImageTransformationResponseOptions;
-type ImageTransformationResult = CloudflareImageTransformationResult;
-type ImageUploadOptions = CloudflareImageUploadOptions;
-type ImageUpdateOptions = CloudflareImageUpdateOptions;
-type ImageListOptions = CloudflareImageListOptions;
-type ImageList = CloudflareImageList;
-type ImageMetadata = CloudflareImageMetadata;
-type ImageSignedUrlOptions = CloudflareImageSignedUrlOptions;
-type ImageDirectUploadOptions = CloudflareImageDirectUploadOptions;
-type ImageDirectUploadResult = CloudflareImageDirectUploadResult;
-type TextOptions = CloudflareTextOptions;
-type ImageInputValue = ReadableStream<Uint8Array> | ArrayBuffer;
-type ImageUploadValue = ReadableStream<Uint8Array> | ArrayBuffer;
-interface DrawStepOptions {
-  readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
-  readonly options?: ImageDrawOptions;
-}
-type Step = Data.TaggedEnum<{
-  readonly Transform: {
-    readonly transform: ImageTransform;
-  };
-  readonly Draw: DrawStepOptions;
-}>;
-declare const Step: {
-  readonly $is: <Tag extends "Draw" | "Transform">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Draw";
-    readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
-    readonly options?: ImageDrawOptions;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Transform";
-    readonly transform: ImageTransform;
-  }, {
-    readonly _tag: Tag;
-  }>;
-  readonly $match: {
-    <Cases extends { readonly [Tag in "Draw" | "Transform"]: (args: Extract<{
-      readonly _tag: "Draw";
-      readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
-      readonly options?: ImageDrawOptions;
-    } | {
-      readonly _tag: "Transform";
-      readonly transform: ImageTransform;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Draw";
-      readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
-      readonly options?: ImageDrawOptions;
-    } | {
-      readonly _tag: "Transform";
-      readonly transform: ImageTransform;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Draw" | "Transform"]>>;
-    <Cases extends { readonly [Tag in "Draw" | "Transform"]: (args: Extract<{
-      readonly _tag: "Draw";
-      readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
-      readonly options?: ImageDrawOptions;
-    } | {
-      readonly _tag: "Transform";
-      readonly transform: ImageTransform;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(value: {
-      readonly _tag: "Draw";
-      readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
-      readonly options?: ImageDrawOptions;
-    } | {
-      readonly _tag: "Transform";
-      readonly transform: ImageTransform;
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Draw" | "Transform"]>>;
-  };
-  readonly Draw: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Draw";
-    readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
-    readonly options?: ImageDrawOptions;
-  }, "_tag">;
-  readonly Transform: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Transform";
-    readonly transform: ImageTransform;
-  }, "_tag">;
-};
-interface Steps {
-  readonly [TypeId]: typeof TypeId;
-  readonly steps: ReadonlyArray<Step>;
-}
-type ProcessOptions = {
-  readonly stream: ImageInputValue;
-  readonly inputOptions?: ImageInputOptions;
-  readonly outputOptions: ImageOutputOptions;
-} | {
-  readonly text: string;
-  readonly textOptions: TextOptions;
-  readonly outputOptions: ImageOutputOptions;
-};
-interface ImagesTransformationResultClient {
-  readonly raw: CloudflareImageTransformationResult;
-  readonly response: (options?: ImageTransformationResponseOptions) => Effect.Effect<CloudflareResponse, ImagesOperationError>;
-  readonly contentType: Effect.Effect<string, ImagesOperationError>;
-  readonly image: (options?: ImageTransformationOutputOptions) => Effect.Effect<ReadableStream<Uint8Array>, ImagesOperationError>;
-}
-interface ImageHandleClient {
-  readonly raw: CloudflareImageHandle;
-  readonly details: Effect.Effect<Option.Option<ImageMetadata>, ImagesOperationError>;
-  readonly bytes: Effect.Effect<Option.Option<ReadableStream<Uint8Array>>, ImagesOperationError>;
-  readonly signedUrl: (options: ImageSignedUrlOptions) => Effect.Effect<string, ImagesOperationError>;
-  readonly update: (options: ImageUpdateOptions) => Effect.Effect<ImageMetadata, ImagesOperationError>;
-  readonly delete: Effect.Effect<boolean, ImagesOperationError>;
-}
-interface HostedImagesClient {
-  readonly image: (imageId: string) => ImageHandleClient;
-  readonly upload: (image: ImageUploadValue, options?: ImageUploadOptions) => Effect.Effect<ImageMetadata, ImagesOperationError>;
-  readonly list: (options?: ImageListOptions) => Effect.Effect<ImageList, ImagesOperationError>;
-  readonly createDirectUpload: (options?: ImageDirectUploadOptions) => Effect.Effect<ImageDirectUploadResult, ImagesOperationError>;
-  readonly rawUnsafe: Effect.Effect<CloudflareHostedImagesBinding>;
-}
-interface ImagesRuntimeBinding {
-  readonly info: (image: ImageInputValue, options?: ImageInputOptions) => Promise<ImageInfoResponse>;
-  readonly input: (image: ImageInputValue, options?: ImageInputOptions) => CloudflareImageTransformer;
-  readonly text?: (content: string, options: TextOptions) => CloudflareImageTransformer;
-  readonly hosted?: CloudflareHostedImagesBinding;
-}
-interface ImagesClient {
-  readonly info: (image: ImageInputValue, options?: ImageInputOptions) => Effect.Effect<ImageInfoResponse, ImagesOperationError>;
-  readonly input: (image: ImageInputValue, options?: ImageInputOptions) => Effect.Effect<CloudflareImageTransformer, ImagesOperationError>;
-  readonly text: (content: string, options: TextOptions) => Effect.Effect<CloudflareImageTransformer, ImagesOperationError>;
-  readonly process: (steps: Steps, options: ProcessOptions) => Effect.Effect<ImagesTransformationResultClient, ImagesOperationError>;
-  readonly hosted: Option.Option<HostedImagesClient>;
-  readonly rawUnsafe: Effect.Effect<ImagesRuntimeBinding>;
-  readonly definition: ImagesDefinition;
-}
-declare const ImagesServiceTypeId: unique symbol;
-interface ImagesService<Id extends string> {
-  readonly [ImagesServiceTypeId]: {
-    readonly id: Id;
-  };
-}
-type LayerOptions$5 = {
-  readonly binding: string;
-};
-interface TagClass$5<Self, Id extends string> extends Context.ServiceClass<Self, Id, ImagesClient> {
-  readonly id: Id;
-  readonly layer: (options: LayerOptions$5) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-}
-declare const empty: Steps;
-declare const transform: {
-  (transform: ImageTransform): (steps: Steps) => Steps;
-  (steps: Steps, transform: ImageTransform): Steps;
-};
-declare const draw: {
-  (draw: DrawStepOptions): (steps: Steps) => Steps;
-  (steps: Steps, draw: DrawStepOptions): Steps;
-};
-declare const isImagesBinding: <Candidate>(value: Candidate) => value is Candidate & ImagesRuntimeBinding;
-declare const makeClient$3: (definition: ImagesDefinition) => (images: ImagesRuntimeBinding) => ImagesClient;
-declare const layer$3: <Self>(tag: Context.Service<Self, ImagesClient>, definition: ImagesDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const make$4: <Id extends string>(id: Id) => TagClass$5<ImagesService<Id>, Id>;
-declare const Tag$5: <Self>() => <Id extends string>(id: Id) => TagClass$5<Self, Id>;
-declare namespace Kv_d_exports {
-  export { Definition$2 as Definition, KvClient, KvDefinition, KvListKey, KvListOptions, KvListResult, KvOperation, KvOperationError, KvPutOptions, KvWithMetadata, LayerOptions$4 as LayerOptions, Tag$4 as Tag, TagClass$4 as TagClass, isKvNamespace, layer$2 as layer, makeClient$2 as makeClient };
-}
-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>;
-declare class KvOperationError extends KvOperationError_base<{
-  readonly binding: string;
-  readonly operation: KvOperation;
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-type KvPutOptions = CloudflareKVNamespacePutOptions;
-type KvListOptions<Metadata = unknown> = CloudflareKVNamespaceListOptions & {
-  readonly metadataSchema?: Schema.Codec<Metadata, unknown>;
-};
-interface KvWithMetadata<Value, Metadata> {
-  readonly value: Value;
-  readonly metadata: Option.Option<Metadata>;
-  readonly cacheStatus: Option.Option<string>;
-}
-interface KvListKey<Key, Metadata = unknown> {
-  readonly name: Key;
-  readonly expiration: Option.Option<number>;
-  readonly metadata: Option.Option<Metadata>;
-}
-interface KvListResult<Key, Metadata = unknown> {
-  readonly keys: ReadonlyArray<KvListKey<Key, Metadata>>;
-  readonly listComplete: boolean;
-  readonly cursor: Option.Option<string>;
-  readonly cacheStatus: Option.Option<string>;
-}
-interface KvDefinition<Key, Value, EncodedValue> {
-  readonly binding: string;
-  readonly key: Schema.Codec<Key, string>;
-  readonly value: Schema.Codec<Value, EncodedValue>;
-}
-/**
- * Reusable typed KV resource definition without a concrete Cloudflare binding name.
- */
-interface Definition$2<Id extends string = string, Key = unknown, Value = unknown, EncodedValue = unknown> {
-  readonly id: Id;
-  readonly key: Schema.Codec<Key, string>;
-  readonly value: Schema.Codec<Value, EncodedValue>;
-}
-declare namespace Definition$2 {
-  type Any = Definition$2<string, any, any, any>;
-}
-interface KvClient<Key, Value, EncodedValue> {
-  readonly put: (key: Key, value: Value, options?: KvPutOptions) => Effect.Effect<void, KvOperationError | Schema.SchemaError>;
-  readonly get: (key: Key) => Effect.Effect<Option.Option<Value>, KvOperationError | Schema.SchemaError>;
-  readonly getWithMetadata: <Metadata>(key: Key, metadataSchema: Schema.Codec<Metadata, unknown>) => Effect.Effect<Option.Option<KvWithMetadata<Value, Metadata>>, KvOperationError | Schema.SchemaError>;
-  readonly list: <Metadata = unknown>(options?: KvListOptions<Metadata>) => Effect.Effect<KvListResult<Key, Metadata>, KvOperationError | Schema.SchemaError>;
-  readonly delete: (key: Key) => Effect.Effect<void, KvOperationError | Schema.SchemaError>;
-  readonly rawUnsafe: Effect.Effect<KVNamespace>;
-  readonly definition: KvDefinition<Key, Value, EncodedValue>;
-}
-type LayerOptions$4 = {
-  readonly binding: string;
-};
-interface TagClass$4<Self, Id extends string, Key, Value, EncodedValue> extends Context.ServiceClass<Self, Id, KvClient<Key, Value, EncodedValue>> {
-  readonly id: Id;
-  readonly keySchema: Schema.Codec<Key, string>;
-  readonly valueSchema: Schema.Codec<Value, EncodedValue>;
-  readonly layer: (options: LayerOptions$4) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-}
-declare const isKvNamespace: <Candidate>(value: Candidate) => value is Candidate & KVNamespace;
-declare const makeClient$2: <Key, Value, EncodedValue>(definition: KvDefinition<Key, Value, EncodedValue>) => ((kv: KVNamespace) => KvClient<Key, Value, EncodedValue>);
-declare const layer$2: <Self, Key, Value, EncodedValue>(tag: Context.Service<Self, KvClient<Key, Value, EncodedValue>>, definition: KvDefinition<Key, Value, EncodedValue>) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const Tag$4: <Self>() => <Id extends string, Key, Value, EncodedValue>(id: Id, definition: {
-  readonly key: Schema.Codec<Key, string>;
-  readonly value: Schema.Codec<Value, EncodedValue>;
-}) => TagClass$4<Self, Id, Key, Value, EncodedValue>;
-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$3 as Tag, TagClass$3 as TagClass, isR2Bucket, layer$1 as layer, make$3 as make, makeClient$1 as makeClient };
-}
-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>;
-declare class R2OperationError extends R2OperationError_base<{
-  readonly binding: string;
-  readonly operation: R2Operation;
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-interface R2Definition {
-  readonly binding: string;
-}
-type R2GetOptions = CloudflareR2GetOptions;
-type R2PutOptions = CloudflareR2PutOptions;
-type R2ListOptions = CloudflareR2ListOptions;
-type R2MultipartOptions = CloudflareR2MultipartOptions;
-type R2UploadPartOptions = CloudflareR2UploadPartOptions;
-type R2PutValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | null | Blob;
-type R2UploadPartValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | Blob;
-interface R2ObjectBodyClient extends Omit<CloudflareR2ObjectBody, "arrayBuffer" | "blob" | "bytes" | "json" | "text"> {
-  readonly raw: CloudflareR2ObjectBody;
-  readonly arrayBuffer: Effect.Effect<ArrayBuffer, R2OperationError>;
-  readonly bytes: Effect.Effect<Uint8Array, R2OperationError>;
-  readonly text: Effect.Effect<string, R2OperationError>;
-  readonly json: <T = unknown>() => Effect.Effect<T, R2OperationError>;
-  readonly blob: Effect.Effect<Blob, R2OperationError>;
-}
-interface R2MultipartUploadClient {
-  readonly raw: CloudflareR2MultipartUpload;
-  readonly key: string;
-  readonly uploadId: string;
-  readonly uploadPart: (partNumber: number, value: R2UploadPartValue, options?: R2UploadPartOptions) => Effect.Effect<CloudflareR2UploadedPart, R2OperationError>;
-  readonly abort: Effect.Effect<void, R2OperationError>;
-  readonly complete: (uploadedParts: ReadonlyArray<CloudflareR2UploadedPart>) => Effect.Effect<CloudflareR2Object, R2OperationError>;
-}
-interface R2Client {
-  readonly head: (key: string) => Effect.Effect<Option.Option<CloudflareR2Object>, R2OperationError>;
-  readonly get: {
-    (key: string, options: R2GetOptions & {
-      readonly onlyIf: CloudflareR2Conditional | Headers;
-    }): Effect.Effect<Option.Option<R2ObjectBodyClient | CloudflareR2Object>, R2OperationError>;
-    (key: string, options?: R2GetOptions): Effect.Effect<Option.Option<R2ObjectBodyClient>, R2OperationError>;
-  };
-  readonly put: {
-    (key: string, value: R2PutValue, options: R2PutOptions & {
-      readonly onlyIf: CloudflareR2Conditional | Headers;
-    }): Effect.Effect<Option.Option<CloudflareR2Object>, R2OperationError>;
-    (key: string, value: R2PutValue, options?: R2PutOptions): Effect.Effect<CloudflareR2Object, R2OperationError>;
-  };
-  readonly createMultipartUpload: (key: string, options?: R2MultipartOptions) => Effect.Effect<R2MultipartUploadClient, R2OperationError>;
-  readonly resumeMultipartUpload: (key: string, uploadId: string) => Effect.Effect<R2MultipartUploadClient, R2OperationError>;
-  readonly delete: (keys: string | ReadonlyArray<string>) => Effect.Effect<void, R2OperationError>;
-  readonly list: (options?: R2ListOptions) => Effect.Effect<CloudflareR2Objects, R2OperationError>;
-  readonly rawUnsafe: Effect.Effect<CloudflareR2Bucket>;
-  readonly definition: R2Definition;
-}
-declare const R2ServiceTypeId: unique symbol;
-interface R2Service<Id extends string> {
-  readonly [R2ServiceTypeId]: {
-    readonly id: Id;
-  };
-}
-type LayerOptions$3 = {
-  readonly binding: string;
-};
-interface TagClass$3<Self, Id extends string> extends Context.ServiceClass<Self, Id, R2Client> {
-  readonly id: Id;
-  readonly layer: (options: LayerOptions$3) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-}
-type R2BindingValue = Schema.Schema.Type<typeof Schema.Unknown>;
-declare const isR2Bucket: (value: R2BindingValue) => value is CloudflareR2Bucket;
-declare const makeClient$1: (definition: R2Definition) => ((bucket: CloudflareR2Bucket) => R2Client);
-declare const layer$1: <Self>(tag: Context.Service<Self, R2Client>, definition: R2Definition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const make$3: <Id extends string>(id: Id) => TagClass$3<R2Service<Id>, Id>;
-declare const Tag$3: <Self>() => <Id extends string>(id: Id) => TagClass$3<Self, Id>;
-declare namespace Vectorize_d_exports {
-  export { LayerOptions$2 as LayerOptions, Tag$2 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 };
-}
-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>;
-declare class VectorizeOperationError extends VectorizeOperationError_base<{
-  readonly binding: string;
-  readonly operation: VectorizeOperation;
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-interface VectorizeDefinition {
-  readonly binding: string;
-}
-type VectorizeBinding = CloudflareVectorize | CloudflareVectorizeIndex;
-type VectorizeVector = CloudflareVectorizeVector;
-type VectorizeVectorMetadata = CloudflareVectorizeVectorMetadata;
-type VectorizeVectorMetadataValue = CloudflareVectorizeVectorMetadataValue;
-type VectorizeVectorMetadataFilter = CloudflareVectorizeVectorMetadataFilter;
-type VectorizeQueryOptions = CloudflareVectorizeQueryOptions;
-type VectorizeMatches = CloudflareVectorizeMatches;
-type VectorizeMatch = CloudflareVectorizeMatch;
-type VectorizeIndexInfo = CloudflareVectorizeIndexInfo;
-type VectorizeIndexDetails = CloudflareVectorizeIndexDetails;
-type VectorizeMutation = CloudflareVectorizeAsyncMutation | CloudflareVectorizeVectorMutation;
-type VectorizeValues = Float32Array | Float64Array | ReadonlyArray<number>;
-interface VectorizeClient {
-  readonly describe: Effect.Effect<VectorizeIndexInfo | VectorizeIndexDetails, VectorizeOperationError>;
-  readonly query: (vector: VectorizeValues, options?: VectorizeQueryOptions) => Effect.Effect<VectorizeMatches, VectorizeOperationError>;
-  readonly queryById: (vectorId: string, options?: VectorizeQueryOptions) => Effect.Effect<VectorizeMatches, VectorizeOperationError>;
-  readonly insert: (vectors: ReadonlyArray<VectorizeVector>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
-  readonly upsert: (vectors: ReadonlyArray<VectorizeVector>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
-  readonly deleteByIds: (ids: ReadonlyArray<string>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
-  readonly delete: (ids: ReadonlyArray<string>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
-  readonly getByIds: (ids: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<VectorizeVector>, VectorizeOperationError>;
-  readonly rawUnsafe: Effect.Effect<VectorizeBinding>;
-  readonly definition: VectorizeDefinition;
-}
-declare const VectorizeServiceTypeId: unique symbol;
-interface VectorizeService<Id extends string> {
-  readonly [VectorizeServiceTypeId]: {
-    readonly id: Id;
-  };
-}
-type LayerOptions$2 = {
-  readonly binding: string;
-};
-interface TagClass$2<Self, Id extends string> extends Context.ServiceClass<Self, Id, VectorizeClient> {
-  readonly id: Id;
-  readonly layer: (options: LayerOptions$2) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-}
-type VectorizeBindingValue = Schema.Schema.Type<typeof Schema.Unknown>;
-declare const isVectorizeBinding: (value: VectorizeBindingValue) => value is VectorizeBinding;
-declare const makeClient: (definition: VectorizeDefinition) => (index: VectorizeBinding) => VectorizeClient;
-declare const layer: <Self>(tag: Context.Service<Self, VectorizeClient>, definition: VectorizeDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const make$2: <Id extends string>(id: Id) => TagClass$2<VectorizeService<Id>, Id>;
-declare const Tag$2: <Self>() => <Id extends string>(id: Id) => TagClass$2<Self, Id>;
-declare namespace WebTransport_d_exports {
-  export { Capabilities, InboundTransport, WebTransportCapability, WebTransportUnsupportedError, capabilities, inboundSessionsUnsupported, inboundTransport, isHttp3 };
-}
-declare const InboundTransport_base: Schema.Class<InboundTransport, Schema.Struct<{
-  readonly httpProtocol: Schema.String;
-  readonly clientQuicRtt: Schema.optional<Schema.Number>;
-  readonly clientTcpRtt: Schema.optional<Schema.Number>;
-}>, {}>;
-/**
- * Metadata Cloudflare's edge reports about the inbound client connection.
- *
- * `httpProtocol` and `clientTcpRtt` are declared in
- * `@cloudflare/workers-types`; `clientQuicRtt` is documented by Cloudflare
- * ("only present when the client connected over QUIC (HTTP/3)") but not yet
- * present in the published types, so it is decoded from the open
- * `Record<string, unknown>` side of `request.cf`.
- */
-declare class InboundTransport extends InboundTransport_base {}
-/**
- * Decodes the inbound transport metadata from `request.cf`.
- *
- * Returns `None` when the metadata is absent (for example in local `wrangler
- * dev` or when a Worker invokes another Worker directly) or does not match
- * the expected shape.
- */
-declare const inboundTransport: (request: Pick<CloudflareRequest, "cf">) => Option.Option<InboundTransport>;
-declare const isHttp3: (transport: InboundTransport) => boolean;
-interface Capabilities {
-  /**
-   * Whether Worker code can accept inbound WebTransport sessions. Typed as
-   * literally `false`: no such runtime API exists (cloudflare/workerd#6451),
-   * so this can only change through a breaking, deliberate update when
-   * Cloudflare ships one.
-   */
-  readonly inboundSessions: false;
-  /**
-   * Whether the runtime exposes a client `WebTransport` constructor global.
-   * Feature-detected at runtime; `false` in workerd today, which has no
-   * QUIC stack.
-   */
-  readonly outboundSessions: boolean;
-}
-declare const capabilities: Effect.Effect<Capabilities>;
-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>;
-declare class WebTransportUnsupportedError extends WebTransportUnsupportedError_base<{
-  readonly capability: WebTransportCapability;
-}> {
-  get message(): string;
-}
-/**
- * The explicit typed boundary for inbound WebTransport sessions.
- *
- * Always fails with {@link WebTransportUnsupportedError} today. Route the
- * code path that would accept a session through this effect so the
- * limitation is visible in the type system and greppable when Cloudflare
- * ships a real API.
- */
-declare const inboundSessionsUnsupported: Effect.Effect<never, WebTransportUnsupportedError>;
-declare namespace WorkflowDefinition_d_exports {
-  export { Definition$1 as Definition, Handler$1 as Handler, LayerOptions$1 as LayerOptions, Options$1 as Options, Tag$1 as Tag, TagClass$1 as TagClass, Workflow, implement$1 as implement, make$1 as make };
-}
-interface Definition$1<Id extends string = string, Payload extends ServiceFreeSchema$1 = ServiceFreeSchema$1, Result extends ServiceFreeSchema$1 = ServiceFreeSchema$1> {
-  readonly id: Id;
-  readonly payload: Payload;
-  readonly result: Result;
-}
-declare namespace Definition$1 {
-  type Any = Definition$1<string, ServiceFreeSchema$1, ServiceFreeSchema$1>;
-}
-type Handler$1<ROut, Self extends Definition$1.Any> = (payload: Schema.Schema.Type<Self["payload"]>) => Effect.Effect<Schema.Schema.Type<Self["result"]>, unknown, WorkflowRunContext<ROut>>;
-interface Options$1<ROut, Self extends Definition$1.Any> {
-  readonly run: Handler$1<ROut, Self>;
-}
-type LayerOptions$1 = {
-  readonly binding: string;
-};
-interface TagClass$1<Self, Id extends string, Payload extends ServiceFreeSchema$1, Result extends ServiceFreeSchema$1> extends Context.ServiceClass<Self, `effect-cf/Workflow/${Id}`, WorkflowBindingClient<Payload, Result>> {
-  readonly id: Id;
-  readonly payload: Payload;
-  readonly result: Result;
-  readonly make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$1<ROut, Definition$1<Id, Payload, Result>>) => WorkflowClass<Schema.Codec.Encoded<Payload>, Schema.Codec.Encoded<Result>, ROut>;
-  readonly layer: (options: LayerOptions$1) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-  readonly create: (payload: Schema.Schema.Type<Payload>, options?: WorkflowInstanceCreateOptions<Schema.Codec.Encoded<Payload>>) => Effect.Effect<WorkflowInstance<Schema.Schema.Type<Result>>, WorkflowOperationError | Schema.SchemaError, Self>;
-  readonly createBatch: (batch: WorkflowInstanceCreateBatchOptions<Schema.Schema.Type<Payload>, Schema.Codec.Encoded<Payload>>) => Effect.Effect<ReadonlyArray<WorkflowInstance<Schema.Schema.Type<Result>>>, WorkflowOperationError | Schema.SchemaError, Self>;
-  readonly get: (instanceId: string) => Effect.Effect<WorkflowInstance<Schema.Schema.Type<Result>>, WorkflowOperationError, Self>;
-  readonly rawUnsafe: Effect.Effect<globalThis.Workflow<Schema.Codec.Encoded<Payload>>, never, Self>;
-}
-declare const make$1: <Id extends string, Payload extends ServiceFreeSchema$1, Result extends ServiceFreeSchema$1>(id: Id, definition: {
-  readonly payload: Payload;
-  readonly result: Result;
-}) => TagClass$1<Definition$1<Id, Payload, Result>, Id, Payload, Result>;
-declare const Tag$1: <Self>() => <Id extends string, Payload extends ServiceFreeSchema$1, Result extends ServiceFreeSchema$1>(id: Id, definition: {
-  readonly payload: Payload;
-  readonly result: Result;
-}) => TagClass$1<Self, Id, Payload, Result>;
-declare const Workflow: typeof Tag$1;
-declare const implement$1: <ROut, const Self extends Definition$1.Any>(_definition: Self, handler: Handler$1<ROut, Self>) => Handler$1<ROut, Self>;
-declare namespace Workflow_d_exports {
-  export { Definition, Handler, LayerOptions, Options, Tag, TagClass, WorkflowClass, WorkflowEvent$1 as WorkflowEvent, WorkflowEventService, WorkflowHandler, WorkflowOptions, WorkflowRunContext, WorkflowStep$1 as WorkflowStep, WorkflowStepContext$1 as WorkflowStepContext, WorkflowStepError, WorkflowStepNonRetryableError, WorkflowStepService, implement, make, sleep, sleepUntil, step, waitForEvent };
-}
-interface WorkflowEventService<Payload = unknown> {
-  readonly raw: WorkflowEvent<unknown>;
-  readonly payload: Payload;
-  readonly timestamp: Date;
-  readonly instanceId: string;
-  readonly workflowName: string;
-}
-declare const WorkflowEvent_base: Context.ServiceClass<WorkflowEvent$1, "effect-cf/WorkflowEvent", WorkflowEventService<unknown>>;
-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>;
-declare class WorkflowStepError extends WorkflowStepError_base<{
-  readonly step?: string;
-  readonly operation: string;
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-declare const WorkflowStepNonRetryableError_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: "WorkflowStepNonRetryableError";
-} & Readonly<A>;
-/**
- * Typed step failure that Cloudflare must treat as terminal instead of retrying.
- *
- * The workflow boundary converts this value into Cloudflare's native
- * `NonRetryableError` while preserving the original cause and its message.
- */
-declare class WorkflowStepNonRetryableError extends WorkflowStepNonRetryableError_base<{
-  readonly cause: unknown;
-}> {
-  get message(): string;
-}
-interface WorkflowStepService {
-  readonly raw: WorkflowStep;
-  do<A, E, R>(name: string, effect: Effect.Effect<A, E, R>, config?: WorkflowStepConfig): Effect.Effect<A, WorkflowStepError, Exclude<R, WorkflowStepContext$1>>;
-  readonly sleep: (name: string, duration: WorkflowSleepDuration) => Effect.Effect<void, WorkflowStepError>;
-  readonly sleepUntil: (name: string, timestamp: Date | number) => Effect.Effect<void, WorkflowStepError>;
-  readonly waitForEvent: <Payload>(name: string, options: {
-    readonly type: string;
-    readonly timeout?: WorkflowTimeoutDuration | number;
-  }) => Effect.Effect<WorkflowStepEvent<Payload>, WorkflowStepError>;
-}
-declare const WorkflowStep_base: Context.ServiceClass<WorkflowStep$1, "effect-cf/WorkflowStep", WorkflowStepService>;
-declare class WorkflowStep$1 extends WorkflowStep_base {}
-declare const WorkflowStepContext_base: Context.ServiceClass<WorkflowStepContext$1, "effect-cf/WorkflowStepContext", WorkflowStepContext>;
-declare class WorkflowStepContext$1 extends WorkflowStepContext_base {}
-type RuntimeContext<ROut> = ExecutionContext | WorkerContext | WorkerEnvironment | ROut;
-type WorkflowRunContext<ROut> = RuntimeContext<ROut> | WorkflowEvent$1 | WorkflowStep$1 | Scope.Scope;
-type WorkflowHandler<ROut, Payload = unknown, Result = unknown> = (payload: Payload) => Effect.Effect<Result, unknown, WorkflowRunContext<ROut>>;
-interface WorkflowOptions<ROut, Payload = unknown, Result = unknown> {
-  readonly run: WorkflowHandler<ROut, Payload, Result>;
-}
-type WorkflowClass<Payload, Result, _ROut> = new (ctx: globalThis.ExecutionContext, env: WorkerEnv) => WorkflowEntrypoint<WorkerEnv, Payload> & {
-  run(event: Readonly<WorkflowEvent<Payload>>, step: WorkflowStep): Promise<Result>;
-};
-declare const make: <ROut, LayerError, Payload = unknown, Result = unknown>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkflowOptions<ROut, Payload, Result>) => WorkflowClass<Payload, Result, ROut>;
-declare const step: <A, E, R>(name: string, effect: Effect.Effect<A, E, R>, config?: WorkflowStepConfig) => Effect.Effect<A, WorkflowStepError, WorkflowStep$1 | Exclude<R, WorkflowStepContext$1>>;
-declare const sleep: (name: string, duration: WorkflowSleepDuration) => Effect.Effect<void, WorkflowStepError, WorkflowStep$1>;
-declare const sleepUntil: (name: string, timestamp: Date | number) => Effect.Effect<void, WorkflowStepError, WorkflowStep$1>;
-declare const waitForEvent: <Payload>(name: string, options: {
-  readonly type: string;
-  readonly timeout?: WorkflowTimeoutDuration | number;
-}) => Effect.Effect<WorkflowStepEvent<Payload>, WorkflowStepError, WorkflowStep$1>;
-type Definition<Id extends string = string, Payload extends Definition$1.Any["payload"] = Definition$1.Any["payload"], Result extends Definition$1.Any["result"] = Definition$1.Any["result"]> = Definition$1<Id, Payload, Result>;
-declare namespace Definition {
-  type Any = Definition$1.Any;
-}
-type LayerOptions = LayerOptions$1;
-type TagClass<Self, Id extends string, Payload extends Definition$1.Any["payload"], Result extends Definition$1.Any["result"]> = TagClass$1<Self, Id, Payload, Result>;
-declare const Tag: <Self>() => <Id extends string, Payload extends Definition$1.Any["payload"], Result extends Definition$1.Any["result"]>(id: Id, definition: {
-  readonly payload: Payload;
-  readonly result: Result;
-}) => TagClass<Self, Id, Payload, Result>;
-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
+import { Environment_d_exports, WorkerConfig, WorkerEnv, WorkerEnvironment } from "./Environment.mjs";
+import { Binding_d_exports } from "./Binding.mjs";
+import { Artifacts_d_exports } from "./Artifacts.mjs";
+import { DurableObjectStorage_d_exports } from "./DurableObjectStorage.mjs";
+import { DurableObjectWebSocket_d_exports } from "./DurableObjectWebSocket.mjs";
+import { Rpc_d_exports } from "./Rpc.mjs";
+import { RpcDefinition_d_exports } from "./RpcDefinition.mjs";
+import { QueueBinding_d_exports } from "./QueueBinding.mjs";
+import { QueueDefinition_d_exports } from "./QueueDefinition.mjs";
+import { Queue_d_exports } from "./Queue.mjs";
+import { RpcTracing_d_exports } from "./RpcTracing.mjs";
+import { ServiceBinding_d_exports } from "./ServiceBinding.mjs";
+import { WorkerDefinition_d_exports } from "./WorkerDefinition.mjs";
+import { Worker_d_exports } from "./Worker.mjs";
+import { DurableObjectState_d_exports } from "./DurableObjectState.mjs";
+import { Hyperdrive_d_exports } from "./Hyperdrive.mjs";
+import { ContainerNamespace_d_exports } from "./ContainerNamespace.mjs";
+import { WorkflowBinding_d_exports } from "./WorkflowBinding.mjs";
+import { WorkersAi_d_exports } from "./WorkersAi.mjs";
+import { AiGateway_d_exports } from "./AiGateway.mjs";
+import { AnalyticsEngine_d_exports } from "./AnalyticsEngine.mjs";
+import { BrowserRendering_d_exports } from "./BrowserRendering.mjs";
+import { Cache_d_exports } from "./Cache.mjs";
+import { CloudflareOtlp_d_exports } from "./CloudflareOtlp.mjs";
+import { CloudflareTracer_d_exports } from "./CloudflareTracer.mjs";
+import { D1_d_exports } from "./D1.mjs";
+import { DurableObjectAlarm_d_exports } from "./DurableObjectAlarm.mjs";
+import { DurableObjectNamespace_d_exports } from "./DurableObjectNamespace.mjs";
+import { DurableObjectDefinition_d_exports } from "./DurableObjectDefinition.mjs";
+import { DurableObject_d_exports } from "./DurableObject.mjs";
+import { DurableObjectRpcWebSocket_d_exports } from "./DurableObjectRpcWebSocket.mjs";
+import { DurableObjectSqlite_d_exports } from "./DurableObjectSqlite.mjs";
+import { Email_d_exports } from "./Email.mjs";
+import { Images_d_exports } from "./Images.mjs";
+import { Kv_d_exports } from "./Kv.mjs";
+import { R2_d_exports } from "./R2.mjs";
+import { Vectorize_d_exports } from "./Vectorize.mjs";
+import { WebTransport_d_exports } from "./WebTransport.mjs";
+import { WorkflowDefinition_d_exports } from "./WorkflowDefinition.mjs";
+import { Workflow_d_exports } from "./Workflow.mjs";
 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, CloudflareTracer_d_exports as CloudflareTracer, 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 };