effect-cf 0.13.1 → 0.14.0

package/dist/index.d.mts

@@ -1,7 +1,6 @@
-import { a as BindingService, c as WorkerConfig, i as BindingNotFoundError, l as WorkerEnv, o as BindingValidationError, s as Binding_d_exports, t as Hyperdrive_d_exports, u as WorkerEnvironment } from "./Hyperdrive-L6ldMlRF.mjs";
-import { Cause, Config, Context, Data, DateTime, Duration, Effect, Layer, Option, Schema, Scope } from "effect";
-import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
-import { OtlpMetrics } from "effect/unstable/observability";
+import { a as BindingService, c as WorkerConfig, i as BindingNotFoundError, l as WorkerEnv, o as BindingValidationError, s as Binding_d_exports, t as Hyperdrive_d_exports, u as WorkerEnvironment } from "./Hyperdrive-C0vfrPeG.mjs";
+import { Cause, Context, Data, DateTime, Duration, Effect, Layer, Option, Schema, Scope } from "effect";
+import { Headers as Headers$1, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import { D1Client } from "@effect/sql-d1";
 import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint, WorkflowEvent, WorkflowSleepDuration, WorkflowStep, WorkflowStepConfig, WorkflowStepContext, WorkflowStepEvent, WorkflowTimeoutDuration } from "cloudflare:workers";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
@@ -12,11 +11,244 @@ import * as _$effect_Types0 from "effect/Types";
 import * as _$effect_Cause0 from "effect/Cause";
 import * as _$effect_Layer0 from "effect/Layer";
 import * as _$effect_Scope0 from "effect/Scope";
-import * as Duration$1 from "effect/Duration";
 import * as Tracer from "effect/Tracer";
 import * as _$effect_Config0 from "effect/Config";
 
-//#region src/DurableObjectStorage.d.ts
+//#region src/WorkersAi.d.ts
+declare namespace WorkersAi_d_exports {
+  export { LayerOptions$16 as LayerOptions, Tag$15 as Tag, TagClass$14 as TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, embeddingResponse, isWorkersAiBinding, layer$13 as layer, make$14 as make, makeClient$10 as makeClient };
+}
+declare const WorkersAiOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "WorkersAiOperationError";
+} & Readonly<A>;
+/** Error raised when a Workers AI operation fails. */
+declare class WorkersAiOperationError extends WorkersAiOperationError_base<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {}
+/** Typed Workers AI binding definition. */
+interface WorkersAiDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+type WorkersAiBinding<ModelList extends AiModelListType = AiModels> = CloudflareAi<ModelList>;
+type WorkersAiOptions = AiOptions;
+type WorkersAiModelsSearchParams = AiModelsSearchParams;
+type WorkersAiModelsSearchObject = AiModelsSearchObject;
+type WorkersAiAsyncBatchResponse = AiAsyncBatchResponse;
+type WorkersAiEmbeddingInput = AiTextEmbeddingsInput | Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Input | Record<string, unknown>;
+interface WorkersAiEmbeddingResponse {
+  readonly data: ReadonlyArray<ReadonlyArray<number>>;
+  readonly shape: 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 Record<string, unknown>, Output = Record<string, unknown>>(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 unsafeRaw: Effect.Effect<WorkersAiBinding<ModelList>>;
+  readonly definition: WorkersAiDefinition;
+}
+declare const WorkersAiServiceTypeId: unique symbol;
+/** Nominal service marker for Workers AI services created with {@link make}. */
+interface WorkersAiService<Id extends string> {
+  readonly [WorkersAiServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions$16 = {
+  readonly binding: string;
+};
+interface TagClass$14<Self, Id extends string, ModelList extends AiModelListType = AiModels> extends Context.ServiceClass<Self, Id, WorkersAiClient<ModelList>> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions$16) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+declare const isWorkersAiBinding: (value: unknown) => value is WorkersAiBinding;
+declare const embeddingResponse: (value: {
+  readonly data?: ReadonlyArray<ReadonlyArray<number>>;
+  readonly shape?: ReadonlyArray<number>;
+}) => WorkersAiEmbeddingResponse;
+declare const makeClient$10: <ModelList extends AiModelListType = AiModels>(definition: WorkersAiDefinition) => (ai: WorkersAiBinding<ModelList>) => WorkersAiClient<ModelList>;
+declare const layer$13: <Self, ModelList extends AiModelListType = AiModels>(tag: Context.Service<Self, WorkersAiClient<ModelList>>, definition: WorkersAiDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make$14: <Id extends string>(id: Id) => TagClass$14<WorkersAiService<Id>, Id, AiModels>;
+declare const Tag$15: <Self>() => <Id extends string, ModelList extends AiModelListType = AiModels>(id: Id) => TagClass$14<Self, Id, ModelList>;
+declare namespace AiGateway_d_exports {
+  export { AiGatewayBinding, AiGatewayClient, AiGatewayDefinition, AiGatewayFetchOptions, AiGatewayHeaders, AiGatewayLog, AiGatewayOperationError, AiGatewayPatchLog, AiGatewayProvider, AiGatewayRunOptions, AiGatewayService, AiGatewayUniversalRequest, LayerOptions$15 as LayerOptions, Tag$14 as Tag, TagClass$13 as TagClass, isAiGatewayBinding, layer$12 as layer, make$13 as make, makeClient$9 as makeClient, makeClientFromAi, makeHttpClient };
+}
+declare const AiGatewayOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "AiGatewayOperationError";
+} & Readonly<A>;
+/** Error raised when an AI Gateway operation fails. */
+declare class AiGatewayOperationError extends AiGatewayOperationError_base<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {}
+/** Typed AI Gateway client definition. */
+interface AiGatewayDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+  /** Gateway id/name passed to `env.AI.gateway(id)`. */
+  readonly gatewayId: string;
+  /** Optional account id used by the HTTP-only helper. */
+  readonly accountId?: string;
+}
+type AiGatewayBinding = CloudflareAiGateway;
+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];
+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 unsafeRaw: Effect.Effect<AiGatewayBinding, AiGatewayOperationError>;
+  readonly definition: AiGatewayDefinition;
+}
+declare const AiGatewayServiceTypeId: unique symbol;
+/** Nominal service marker for AI Gateway services created with {@link make}. */
+interface AiGatewayService<Id extends string> {
+  readonly [AiGatewayServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions$15 = {
+  readonly binding: string;
+  readonly gatewayId: string;
+  readonly accountId?: string;
+};
+interface TagClass$13<Self, Id extends string> extends Context.ServiceClass<Self, Id, AiGatewayClient> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions$15) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError | AiGatewayOperationError, WorkerEnvironment>;
+}
+declare const isAiGatewayBinding: (value: unknown) => value is WorkersAiBinding;
+declare const makeClient$9: (definition: AiGatewayDefinition, gateway: AiGatewayBinding) => {
+  definition: AiGatewayDefinition;
+  run: (data: _$_cloudflare_workers_types0.AIGatewayUniversalRequest | readonly _$_cloudflare_workers_types0.AIGatewayUniversalRequest[], options: {
+    gateway?: _$_cloudflare_workers_types0.UniversalGatewayOptions;
+    extraHeaders?: object;
+    signal?: _$_cloudflare_workers_types0.AbortSignal;
+  } | undefined) => Effect.Effect<_$_cloudflare_workers_types0.Response, AiGatewayOperationError, never>;
+  getUrl: (provider: string | undefined) => Effect.Effect<string, AiGatewayOperationError, never>;
+  fetch: (options: AiGatewayFetchOptions) => Effect.Effect<Response, AiGatewayOperationError, never>;
+  patchLog: (logId: string, data: _$_cloudflare_workers_types0.AiGatewayPatchLog) => Effect.Effect<void, AiGatewayOperationError, never>;
+  getLog: (logId: string) => Effect.Effect<_$_cloudflare_workers_types0.AiGatewayLog, AiGatewayOperationError, never>;
+  unsafeRaw: 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$12: <Self>(tag: Context.Service<Self, AiGatewayClient>, definition: AiGatewayDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make$13: <Id extends string>(id: Id) => TagClass$13<AiGatewayService<Id>, Id>;
+declare const Tag$14: <Self>() => <Id extends string>(id: Id) => TagClass$13<Self, Id>;
+declare namespace BrowserRendering_d_exports {
+  export { BrowserRenderingBinding, BrowserRenderingBrowserClient, BrowserRenderingBrowserLike, BrowserRenderingClient, BrowserRenderingConnect, BrowserRenderingDefinition, BrowserRenderingLaunch, BrowserRenderingOperationError, BrowserRenderingPageClient, BrowserRenderingPageLike, BrowserRenderingService, LayerOptions$14 as LayerOptions, Tag$13 as Tag, TagClass$12 as TagClass, isBrowserRenderingBinding, layer$11 as layer, make$12 as make, makeClient$8 as makeClient };
+}
+declare const BrowserRenderingOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "BrowserRenderingOperationError";
+} & Readonly<A>;
+/** Error raised when a Browser Rendering operation fails. */
+declare class BrowserRenderingOperationError extends BrowserRenderingOperationError_base<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {}
+/** Typed Browser Rendering binding definition. */
+interface BrowserRenderingDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+type BrowserRenderingBinding = object;
+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?: unknown) => Promise<unknown>;
+  readonly setContent?: (html: string, options?: unknown) => Promise<void>;
+  readonly content?: () => Promise<string>;
+  readonly screenshot?: (options?: unknown) => Promise<Uint8Array | string>;
+  readonly pdf?: (options?: unknown) => Promise<Uint8Array>;
+  readonly evaluate?: (pageFunction: unknown, ...args: ReadonlyArray<unknown>) => Promise<unknown>;
+  readonly close?: (options?: unknown) => 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: <A = Uint8Array | string>(options?: Parameters<NonNullable<Page["screenshot"]>>[0]) => Effect.Effect<A, BrowserRenderingOperationError>;
+  readonly pdf: <A = Uint8Array>(options?: Parameters<NonNullable<Page["pdf"]>>[0]) => Effect.Effect<A, BrowserRenderingOperationError>;
+  readonly evaluate: <A = unknown>(pageFunction: Parameters<NonNullable<Page["evaluate"]>>[0], ...args: ReadonlyArray<unknown>) => Effect.Effect<A, 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 unsafeRaw: Effect.Effect<RawBinding>;
+  readonly definition: BrowserRenderingDefinition;
+}
+declare const BrowserRenderingServiceTypeId: unique symbol;
+/** Nominal service marker for Browser Rendering services created with {@link make}. */
+interface BrowserRenderingService<Id extends string> {
+  readonly [BrowserRenderingServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions$14 = {
+  readonly binding: string;
+};
+interface TagClass$12<Self, Id extends string> extends Context.ServiceClass<Self, Id, BrowserRenderingClient> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions$14) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+declare const isBrowserRenderingBinding: (value: unknown) => value is BrowserRenderingBinding;
+declare const makeClient$8: <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$12: <Id extends string>(id: Id) => TagClass$12<BrowserRenderingService<Id>, Id>;
+declare const Tag$13: <Self>() => <Id extends string>(id: Id) => TagClass$12<Self, Id>;
 declare namespace DurableObjectStorage_d_exports {
   export { DurableObjectStorage, DurableObjectTransaction, SchemaBackedSyncKvStorage, SqlCursor, SqlStorage, SqlStorageValue, StorageOperationError, SyncKvDefinition, SyncKvStorage, fromDurableObjectStorage };
 }
@@ -319,121 +551,55 @@ declare class DurableObjectState extends DurableObjectState_base {}
  */
 declare const fromDurableObjectState: (state: globalThis.DurableObjectState) => DurableObjectStateService;
 declare namespace CloudflareOtlp_d_exports {
-  export { CloudflareOtlpSettings, DurableObjectResourceOptions, LayerOptions$12 as LayerOptions, ResourceOptions, Serialization, Settings, Signal, WorkerResourceOptions, durableObjectLayer, layer$9 as layer, layerJson, layerProtobuf, settingsConfig, settingsLayer, workerLayer };
+  export { DurableObjectLayerOptions, LayerOptions$13 as LayerOptions, ResourceOptions, Serialization, Signal, WorkerLayerOptions, durableObjectLayer, layer$10 as layer, layerJson, layerProtobuf, workerLayer };
 }
 /** 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";
-/**
- * Resolved OpenTelemetry settings used by the Cloudflare OTLP layers.
- *
- * The default {@link settingsLayer} reads the standard OpenTelemetry
- * environment variable names from `WorkerEnvironment`. Applications that use
- * different binding names can provide {@link CloudflareOtlpSettings} directly
- * with a custom layer.
- */
-interface Settings {
-  /** Generic OTLP base endpoint, read from `OTEL_EXPORTER_OTLP_ENDPOINT`. */
-  readonly endpoint: Option.Option<string>;
-  /** Logs-specific OTLP endpoint, read from `OTEL_EXPORTER_OTLP_LOGS_ENDPOINT`. */
-  readonly logsEndpoint: Option.Option<string>;
-  /** Traces-specific OTLP endpoint, read from `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`. */
-  readonly tracesEndpoint: Option.Option<string>;
-  /** Metrics-specific OTLP endpoint, read from `OTEL_EXPORTER_OTLP_METRICS_ENDPOINT`. */
-  readonly metricsEndpoint: Option.Option<string>;
-  /** Comma-separated OTLP headers, read from `OTEL_EXPORTER_OTLP_HEADERS`. */
-  readonly headers: Option.Option<string>;
-  /** Logs-specific OTLP headers, read from `OTEL_EXPORTER_OTLP_LOGS_HEADERS`. */
-  readonly logsHeaders: Option.Option<string>;
-  /** Traces-specific OTLP headers, read from `OTEL_EXPORTER_OTLP_TRACES_HEADERS`. */
-  readonly tracesHeaders: Option.Option<string>;
-  /** Metrics-specific OTLP headers, read from `OTEL_EXPORTER_OTLP_METRICS_HEADERS`. */
-  readonly metricsHeaders: Option.Option<string>;
-  /** Service name, read from `OTEL_SERVICE_NAME`. */
-  readonly serviceName: Option.Option<string>;
-  /** Service version, read from the effect-cf convenience alias `OTEL_SERVICE_VERSION`. */
-  readonly serviceVersion: Option.Option<string>;
-  /** Resource attributes, read from `OTEL_RESOURCE_ATTRIBUTES`. */
-  readonly resourceAttributes: Option.Option<Record<string, string>>;
-}
-/**
- * Supported OpenTelemetry environment configuration for Cloudflare OTLP export.
- *
- * This config intentionally uses the conventional `OTEL_*` variable names so
- * deployments can share the same settings used by other OpenTelemetry SDKs.
- * It covers the OTLP HTTP settings supported by the Effect OTLP layers:
- *
- * - `OTEL_EXPORTER_OTLP_ENDPOINT`
- * - `OTEL_EXPORTER_OTLP_LOGS_ENDPOINT`
- * - `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`
- * - `OTEL_EXPORTER_OTLP_METRICS_ENDPOINT`
- * - `OTEL_EXPORTER_OTLP_HEADERS`
- * - `OTEL_EXPORTER_OTLP_LOGS_HEADERS`
- * - `OTEL_EXPORTER_OTLP_TRACES_HEADERS`
- * - `OTEL_EXPORTER_OTLP_METRICS_HEADERS`
- * - `OTEL_SERVICE_NAME`
- * - `OTEL_RESOURCE_ATTRIBUTES`
- *
- * `OTEL_SERVICE_VERSION` is also accepted as an effect-cf convenience alias.
- * The standard OpenTelemetry way to configure service version is
- * `OTEL_RESOURCE_ATTRIBUTES=service.version=...`.
- *
- * Consumers with non-standard binding names should map those names into
- * {@link CloudflareOtlpSettings} rather than changing this config globally.
- */
-declare const settingsConfig: Config.Config<{
-  endpoint: Option.Option<string>;
-  logsEndpoint: Option.Option<string>;
-  tracesEndpoint: Option.Option<string>;
-  metricsEndpoint: Option.Option<string>;
-  headers: Option.Option<string>;
-  logsHeaders: Option.Option<string>;
-  tracesHeaders: Option.Option<string>;
-  metricsHeaders: Option.Option<string>;
-  serviceName: Option.Option<string>;
-  serviceVersion: Option.Option<string>;
-  resourceAttributes: Option.Option<{
-    readonly [x: string]: string;
-  }>;
-}>;
-declare const CloudflareOtlpSettings_base: Context.ServiceClass<CloudflareOtlpSettings, "effect-cf/CloudflareOtlpSettings", Settings>;
-/**
- * Service carrying already-resolved Cloudflare OTLP settings.
- *
- * Provide this service directly when an application needs to map custom
- * Cloudflare binding names, compute settings dynamically, or override settings
- * in tests. When this service is present, the OTLP layers use it instead of
- * reading {@link settingsConfig}.
- *
- * @example
- * ```ts
- * const CustomOtlpSettings = Layer.effect(
- *   CloudflareOtlp.CloudflareOtlpSettings,
- *   Config.all({
- *     ...CloudflareOtlp.settingsConfig,
- *     endpoint: Config.string("MY_OTLP_ENDPOINT").pipe(Config.option),
- *   }),
- * ).pipe(Layer.provide(WorkerConfig.layer));
- * ```
- */
-declare class CloudflareOtlpSettings extends CloudflareOtlpSettings_base {}
 /** Resource metadata shared by Worker and Durable Object OTLP layers. */
 interface ResourceOptions {
-  /** Explicit service name. Overrides `OTEL_SERVICE_NAME` when provided. */
+  /** Explicit service name. OTEL resource environment variables take precedence. */
   readonly serviceName?: string;
-  /** Explicit service version. Overrides `OTEL_SERVICE_VERSION` when provided. */
+  /** Explicit service version. OTEL resource environment variables take precedence. */
   readonly serviceVersion?: string;
-  /** Additional resource attributes attached to all exported telemetry. */
+  /** Additional resource attributes attached to exported telemetry. */
   readonly attributes?: Record<string, unknown>;
 }
+/** Options shared by all Cloudflare OTLP telemetry layers. */
+interface LayerOptions$13 {
+  /**
+   * 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;
+  /** Resource metadata forwarded to Effect's OTLP resource resolver. */
+  readonly resource?: ResourceOptions;
+  /**
+   * Explicit headers for every selected signal.
+   *
+   * When omitted, Effect reads `OTEL_EXPORTER_OTLP_HEADERS` and the
+   * signal-specific `OTEL_EXPORTER_OTLP_*_HEADERS` variables.
+   */
+  readonly headers?: Headers$1.Input;
+  /** Exclude log records emitted for spans when exporting logs. */
+  readonly loggerExcludeLogSpans?: boolean;
+  /** Merge the OTLP logger with existing loggers instead of replacing them. */
+  readonly loggerMergeWithExisting?: boolean;
+  /** Custom trace context lookup used by the Effect OTLP tracer. */
+  readonly tracerContext?: <X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X;
+}
 /** Resource metadata specific to Cloudflare Workers. */
-interface WorkerResourceOptions extends ResourceOptions {
+interface WorkerLayerOptions extends LayerOptions$13 {
   /** Cloudflare Worker name to attach as `cloudflare.worker.name`. */
   readonly workerName?: string;
 }
 /** Resource metadata specific to Cloudflare Durable Objects. */
-interface DurableObjectResourceOptions extends ResourceOptions {
+interface DurableObjectLayerOptions extends LayerOptions$13 {
   /** Durable Object class name to attach as `cloudflare.durable_object.class`. */
   readonly className?: string;
   /**
@@ -443,64 +609,26 @@ interface DurableObjectResourceOptions extends ResourceOptions {
    */
   readonly includeObjectId?: boolean;
 }
-/** Options shared by all Cloudflare OTLP telemetry layers. */
-interface LayerOptions$12 extends ResourceOptions {
-  /** Telemetry signals to export. Defaults to logs, traces, and metrics. */
-  readonly signals?: ReadonlyArray<Signal>;
-  /** OTLP payload serialization. Defaults to protobuf. */
-  readonly serialization?: Serialization;
-  /** Maximum batch size for log and trace exporters. */
-  readonly maxBatchSize?: number;
-  /** Maximum time to wait for exporter shutdown/flush when a scope closes. */
-  readonly shutdownTimeout?: Duration$1.Input;
-  /** Export interval for the logs exporter. */
-  readonly loggerExportInterval?: Duration$1.Input;
-  /** Exclude log records emitted for spans when exporting logs. */
-  readonly loggerExcludeLogSpans?: boolean;
-  /** Merge the OTLP logger with existing loggers instead of replacing them. */
-  readonly loggerMergeWithExisting?: boolean;
-  /** Export interval for the traces exporter. */
-  readonly tracerExportInterval?: Duration$1.Input;
-  /** Custom trace context lookup used by the Effect OTLP tracer. */
-  readonly tracerContext?: <X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X;
-  /** Export interval for the metrics exporter. */
-  readonly metricsExportInterval?: Duration$1.Input;
-  /** Aggregation temporality for exported metrics. */
-  readonly metricsTemporality?: OtlpMetrics.AggregationTemporality;
-}
-/**
- * Layer that reads standard OpenTelemetry settings from the current Cloudflare
- * `env` object.
- *
- * The layer depends on {@link WorkerEnvironment} and installs a
- * Cloudflare-backed Effect `ConfigProvider`, so `settingsConfig` reads from
- * Worker vars/secrets instead of Node process environment variables.
- */
-declare const settingsLayer: Layer.Layer<CloudflareOtlpSettings, Config.ConfigError, WorkerEnvironment>;
 /**
  * Base OTLP telemetry layer for Cloudflare-compatible runtimes.
  *
- * The layer reads {@link CloudflareOtlpSettings} when provided. Otherwise it
- * reads standard OpenTelemetry config from `WorkerEnvironment` when available,
- * then falls back to the ambient Effect `ConfigProvider`.
- *
- * When only `OTEL_EXPORTER_OTLP_ENDPOINT` is configured, per-signal paths are
- * derived by appending `/v1/logs`, `/v1/traces`, and `/v1/metrics`. Signal
- * specific endpoints are used as-is, matching the OpenTelemetry OTLP exporter
- * convention.
+ * 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.
  */
-declare const layer$9: (options?: LayerOptions$12) => Layer.Layer<never, never, never>;
+declare const layer$10: (options?: LayerOptions$13) => Layer.Layer<never, never, never>;
 /** Base OTLP telemetry layer forced to JSON serialization. */
-declare const layerJson: (options?: Omit<LayerOptions$12, "serialization">) => Layer.Layer<never, never, never>;
+declare const layerJson: (options?: Omit<LayerOptions$13, "serialization">) => Layer.Layer<never, never, never>;
 /** Base OTLP telemetry layer forced to protobuf serialization. */
-declare const layerProtobuf: (options?: Omit<LayerOptions$12, "serialization">) => Layer.Layer<never, never, never>;
+declare const layerProtobuf: (options?: Omit<LayerOptions$13, "serialization">) => Layer.Layer<never, never, never>;
 /**
  * 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.
  */
-declare const workerLayer: (options?: LayerOptions$12 & WorkerResourceOptions) => Layer.Layer<never, never, never>;
+declare const workerLayer: (options?: WorkerLayerOptions) => Layer.Layer<never, never, never>;
 /**
  * OTLP layer with Cloudflare Durable Object resource attributes.
  *
@@ -508,9 +636,9 @@ declare const workerLayer: (options?: LayerOptions$12 & WorkerResourceOptions) =
  * Durable Object id. Prefer leaving `includeObjectId` disabled unless the
  * backend can tolerate high-cardinality resource attributes.
  */
-declare const durableObjectLayer: (options?: LayerOptions$12 & DurableObjectResourceOptions) => Layer.Layer<never, never, DurableObjectState>;
+declare const durableObjectLayer: (options?: DurableObjectLayerOptions) => Layer.Layer<never, never, DurableObjectState>;
 declare namespace D1_d_exports {
-  export { D1Definition, D1Service, D1SqlLayerOptions, Service$1 as Service, make$10 as make };
+  export { D1Definition, D1Service, D1SqlLayerOptions, Service$1 as Service, make$11 as make };
 }
 /** Typed D1 binding definition. */
 interface D1Definition {
@@ -529,7 +657,7 @@ interface D1Service<Id extends string> {
 /**
  * Creates a typed D1 service tag plus Effect helpers.
  */
-declare const make$10: <Id extends string>(id: Id, definition: D1Definition) => BindingService<D1Service<Id>, Id, D1Database> & {
+declare const make$11: <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 | _$effect_unstable_sql_SqlClient0.SqlClient, BindingNotFoundError | BindingValidationError | _$effect_Config0.ConfigError, WorkerEnvironment>;
@@ -579,7 +707,7 @@ declare const dispose: (value: unknown) => Effect.Effect<void>;
 declare const resolve: <A>(value: A) => Effect.Effect<Awaited<A>, unknown>;
 declare const scoped: <A>(value: A) => Effect.Effect<Awaited<A>, unknown, Scope.Scope>;
 declare namespace RpcDefinition_d_exports {
-  export { Definition$9 as Definition, Method$5 as Method, Methods$4 as Methods, NoReservedMethods$4 as NoReservedMethods, ReservedMethodName$6 as ReservedMethodName, ReservedMethodNameError, RpcArgumentCountError, RpcArgumentDecodeError, RpcArgumentEncodeError, RpcReservedMethodNameError, RpcSuccessDecodeError, RpcSuccessEncodeError, ServiceFreeSchema$4 as ServiceFreeSchema, assertNoReservedMethodNames, assertNoReservedMethods, decodeArgs, decodeSuccess, encodeArgs, encodeSuccess, make$9 as make, method$4 as method, reservedMethodNames };
+  export { Definition$9 as Definition, Method$5 as Method, Methods$4 as Methods, NoReservedMethods$4 as NoReservedMethods, ReservedMethodName$6 as ReservedMethodName, ReservedMethodNameError, RpcArgumentCountError, RpcArgumentDecodeError, RpcArgumentEncodeError, RpcReservedMethodNameError, RpcSuccessDecodeError, RpcSuccessEncodeError, ServiceFreeSchema$4 as ServiceFreeSchema, assertNoReservedMethodNames, assertNoReservedMethods, decodeArgs, decodeSuccess, encodeArgs, encodeSuccess, make$10 as make, method$4 as method, reservedMethodNames };
 }
 declare const RpcReservedMethodNameError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
   readonly _tag: "RpcReservedMethodNameError";
@@ -678,17 +806,17 @@ declare const decodeArgs: <const Self extends Definition$9.Any, MethodName exten
 declare const encodeArgs: <const Self extends Definition$9.Any, MethodName extends Definition$9.MethodNames<Self>>(definition: Self, methodName: MethodName, args: Method$5.Args<Self["methods"][MethodName]>) => Effect.Effect<Method$5.EncodedArgs<Self["methods"][MethodName]>, RpcArgumentCountError | RpcArgumentEncodeError>;
 declare const encodeSuccess: <const Self extends Definition$9.Any, MethodName extends Definition$9.MethodNames<Self>>(definition: Self, methodName: MethodName, value: Method$5.Success<Self["methods"][MethodName]>) => Effect.Effect<Method$5.EncodedSuccess<Self["methods"][MethodName]>, RpcSuccessEncodeError>;
 declare const decodeSuccess: <const Self extends Definition$9.Any, MethodName extends Definition$9.MethodNames<Self>>(definition: Self, methodName: MethodName, value: unknown) => Effect.Effect<Method$5.Success<Self["methods"][MethodName]>, RpcSuccessDecodeError>;
-declare const make$9: <Id extends string, const MethodsShape extends Methods$4>(id: Id, methods: MethodsShape) => Definition$9<Id, MethodsShape>;
+declare const make$10: <Id extends string, const MethodsShape extends Methods$4>(id: Id, methods: MethodsShape) => Definition$9<Id, MethodsShape>;
 declare namespace QueueBinding_d_exports {
-  export { MessageSendRequest, QueueBindingClient, QueueBindingDefinition, QueueMetrics, QueueOperationError, QueueProducer, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer$8 as layer, makeClient$6 as makeClient };
-}
-type QueueSendOptions = globalThis.QueueSendOptions;
-type QueueSendResponse = globalThis.QueueSendResponse;
-type QueueSendBatchOptions = globalThis.QueueSendBatchOptions;
-type QueueSendBatchResponse = globalThis.QueueSendBatchResponse;
-type QueueMetrics = globalThis.QueueMetrics;
-type MessageSendRequest<Body> = globalThis.MessageSendRequest<Body>;
-type QueueProducer<Body> = Pick<globalThis.Queue<Body>, "send"> & Partial<Pick<globalThis.Queue<Body>, "sendBatch" | "metrics">>;
+  export { MessageSendRequest, QueueBindingClient, QueueBindingDefinition, QueueMetrics, QueueOperationError, QueueProducer, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer$9 as layer, makeClient$7 as makeClient };
+}
+type QueueSendOptions = CloudflareQueueSendOptions;
+type QueueSendResponse = CloudflareQueueSendResponse;
+type QueueSendBatchOptions = CloudflareQueueSendBatchOptions;
+type QueueSendBatchResponse = CloudflareQueueSendBatchResponse;
+type QueueMetrics = CloudflareQueueMetrics;
+type MessageSendRequest<Body> = CloudflareMessageSendRequest<Body>;
+type QueueProducer<Body> = Pick<CloudflareQueue<Body>, "send"> & Partial<Pick<CloudflareQueue<Body>, "sendBatch" | "metrics">>;
 interface QueueBindingDefinition<Message extends ServiceFreeSchema$4> {
   /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
@@ -699,7 +827,7 @@ interface QueueBindingClient<Message extends ServiceFreeSchema$4> {
   readonly send: (message: Schema.Schema.Type<Message>, options?: QueueSendOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError>;
   readonly sendBatch: (messages: Iterable<MessageSendRequest<Schema.Schema.Type<Message>>>, options?: QueueSendBatchOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError>;
   readonly metrics: () => Effect.Effect<QueueMetrics, QueueOperationError>;
-  readonly unsafeRaw: Effect.Effect<globalThis.Queue<Schema.Codec.Encoded<Message>>>;
+  readonly unsafeRaw: Effect.Effect<CloudflareQueue<Schema.Codec.Encoded<Message>>>;
 }
 declare const QueueOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
   readonly _tag: "QueueOperationError";
@@ -711,10 +839,10 @@ declare class QueueOperationError extends QueueOperationError_base<{
   readonly message: string;
 }> {}
 declare const isQueue: <Body>(value: unknown) => value is QueueProducer<Body>;
-declare const makeClient$6: <Message extends ServiceFreeSchema$4>(definition: QueueBindingDefinition<Message>) => ((queue: QueueProducer<Schema.Codec.Encoded<Message>>) => QueueBindingClient<Message>);
-declare const layer$8: <Self, Message extends ServiceFreeSchema$4>(tag: Context.Service<Self, QueueBindingClient<Message>>, definition: QueueBindingDefinition<Message>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const makeClient$7: <Message extends ServiceFreeSchema$4>(definition: QueueBindingDefinition<Message>) => ((queue: QueueProducer<Schema.Codec.Encoded<Message>>) => QueueBindingClient<Message>);
+declare const layer$9: <Self, Message extends ServiceFreeSchema$4>(tag: Context.Service<Self, QueueBindingClient<Message>>, definition: QueueBindingDefinition<Message>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare namespace QueueDefinition_d_exports {
-  export { Definition$8 as Definition, Handler$3 as Handler, LayerOptions$11 as LayerOptions, Options$7 as Options, Queue$1 as Queue, Tag$11 as Tag, TagClass$10 as TagClass, implement$7 as implement, make$8 as make };
+  export { Definition$8 as Definition, Handler$3 as Handler, LayerOptions$12 as LayerOptions, Options$7 as Options, Queue$1 as Queue, Tag$12 as Tag, TagClass$11 as TagClass, implement$7 as implement, make$9 as make };
 }
 interface Definition$8<Id extends string = string, Message extends ServiceFreeSchema$4 = ServiceFreeSchema$4> {
   readonly id: Id;
@@ -728,31 +856,31 @@ interface Options$7<ROut, Self extends Definition$8.Any> extends Omit<WorkerOpti
   readonly queue: Handler$3<ROut, Self>;
   readonly rpc?: never;
 }
-type LayerOptions$11 = {
+type LayerOptions$12 = {
   readonly binding: string;
 };
-interface TagClass$10<Self, Id extends string, Message extends ServiceFreeSchema$4> extends Context.ServiceClass<Self, Id, QueueBindingClient<Message>> {
+interface TagClass$11<Self, Id extends string, Message extends ServiceFreeSchema$4> extends Context.ServiceClass<Self, Id, QueueBindingClient<Message>> {
   readonly id: Id;
   readonly message: Message;
   readonly make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$7<ROut, Definition$8<Id, Message>>) => WorkerClass<Record<never, never>, ROut>;
-  readonly layer: (options: LayerOptions$11) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$12) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
   readonly send: (message: Schema.Schema.Type<Message>, options?: QueueSendOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError, Self>;
   readonly sendBatch: (messages: Iterable<MessageSendRequest<Schema.Schema.Type<Message>>>, options?: QueueSendBatchOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError, Self>;
   readonly metrics: () => Effect.Effect<QueueMetrics, QueueOperationError, Self>;
   readonly unsafeRaw: () => Effect.Effect<globalThis.Queue<Schema.Codec.Encoded<Message>>, never, Self>;
 }
-declare const make$8: <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
+declare const make$9: <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
   readonly message: Message;
-}) => TagClass$10<Definition$8<Id, Message>, Id, Message>;
-declare const Tag$11: <Self>() => <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
+}) => TagClass$11<Definition$8<Id, Message>, Id, Message>;
+declare const Tag$12: <Self>() => <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
   readonly message: Message;
-}) => TagClass$10<Self, Id, Message>;
+}) => TagClass$11<Self, Id, Message>;
 declare const Queue$1: <Self>() => <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
   readonly message: Message;
-}) => TagClass$10<Self, Id, Message>;
+}) => TagClass$11<Self, Id, Message>;
 declare const implement$7: <ROut, const Self extends Definition$8.Any>(_definition: Self, handler: Handler$3<ROut, Self>) => Handler$3<ROut, Self>;
 declare namespace Queue_d_exports {
-  export { Definition$7 as Definition, Handler$2 as Handler, LayerOptions$10 as LayerOptions, Options$6 as Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, QueueOptions, Tag$10 as Tag, TagClass$9 as TagClass, decodeBatch, fromMessage, fromMessageBatch, implement$6 as implement };
+  export { Definition$7 as Definition, Handler$2 as Handler, LayerOptions$11 as LayerOptions, Options$6 as Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, QueueOptions, Tag$11 as Tag, TagClass$10 as TagClass, decodeBatch, fromMessage, fromMessageBatch, implement$6 as implement };
 }
 interface QueueMessage<Body> {
   readonly raw: globalThis.Message<unknown>;
@@ -801,16 +929,16 @@ type Definition$7<Id extends string = string, Message extends Definition$8.Any["
 declare namespace Definition$7 {
   type Any = Definition$8.Any;
 }
-type LayerOptions$10 = LayerOptions$11;
-type TagClass$9<Self, Id extends string, Message extends Definition$8.Any["message"]> = TagClass$10<Self, Id, Message>;
-declare const Tag$10: <Self>() => <Id extends string, Message extends Definition$8.Any["message"]>(id: Id, definition: {
+type LayerOptions$11 = LayerOptions$12;
+type TagClass$10<Self, Id extends string, Message extends Definition$8.Any["message"]> = TagClass$11<Self, Id, Message>;
+declare const Tag$11: <Self>() => <Id extends string, Message extends Definition$8.Any["message"]>(id: Id, definition: {
   readonly message: Message;
-}) => TagClass$9<Self, Id, Message>;
+}) => TagClass$10<Self, Id, Message>;
 declare const implement$6: <ROut, const Self extends Definition$8.Any>(_definition: Self, handler: Handler$3<ROut, Self>) => Handler$3<ROut, Self>;
 type Handler$2<ROut, Self extends Definition$8.Any> = Handler$3<ROut, Self>;
 type Options$6<ROut, Self extends Definition$8.Any> = Options$7<ROut, Self>;
 declare namespace WorkerDefinition_d_exports {
-  export { Api$3 as Api, Definition$6 as Definition, HandlerEffect$3 as HandlerEffect, Handlers$3 as Handlers, LayerOptions$9 as LayerOptions, Method$4 as Method, Methods$3 as Methods, NoReservedMethods$3 as NoReservedMethods, Options$5 as Options, ReservedMethodName$5 as ReservedMethodName, ServerApi$4 as ServerApi, ServiceFreeSchema$3 as ServiceFreeSchema, Tag$9 as Tag, TagClass$8 as TagClass, Worker, implement$5 as implement, make$7 as make, method$3 as method };
+  export { Api$3 as Api, Definition$6 as Definition, HandlerEffect$3 as HandlerEffect, Handlers$3 as Handlers, LayerOptions$10 as LayerOptions, Method$4 as Method, Methods$3 as Methods, NoReservedMethods$3 as NoReservedMethods, Options$5 as Options, ReservedMethodName$5 as ReservedMethodName, ServerApi$4 as ServerApi, ServiceFreeSchema$3 as ServiceFreeSchema, Tag$10 as Tag, TagClass$9 as TagClass, Worker, implement$5 as implement, make$8 as make, method$3 as method };
 }
 type ServiceFreeSchema$3 = Schema.Codec<any, any, never, never>;
 interface Method$4<Args extends ReadonlyArray<ServiceFreeSchema$3> = ReadonlyArray<ServiceFreeSchema$3>, Success extends ServiceFreeSchema$3 = ServiceFreeSchema$3> {
@@ -858,14 +986,14 @@ type Handlers$3<ROut, Self extends Definition$6.Any> = { readonly [Key in keyof
 interface Options$5<ROut, Self extends Definition$6.Any, REvent = never, EventLayerError = never> extends Omit<WorkerOptions<ROut, REvent, EventLayerError, Handlers$3<ROut | REvent, Self>>, "rpc"> {
   readonly rpc: Handlers$3<ROut | REvent, Self>;
 }
-type LayerOptions$9 = {
+type LayerOptions$10 = {
   readonly binding: string;
 };
-type TagClass$8<Self, Id extends string, MethodsShape extends Methods$3> = Context.ServiceClass<Self, Id, ServiceBindingEffectClient<Api$3<Definition$6<Id, MethodsShape>>, Definition$6<Id, MethodsShape>>> & ServiceBindingStaticClient<Self, Api$3<Definition$6<Id, MethodsShape>>, Definition$6<Id, MethodsShape>> & {
+type TagClass$9<Self, Id extends string, MethodsShape extends Methods$3> = Context.ServiceClass<Self, Id, ServiceBindingEffectClient<Api$3<Definition$6<Id, MethodsShape>>, Definition$6<Id, MethodsShape>>> & ServiceBindingStaticClient<Self, Api$3<Definition$6<Id, MethodsShape>>, Definition$6<Id, MethodsShape>> & {
   readonly id: Id;
   readonly methods: MethodsShape;
   readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$5<ROut, Definition$6<Id, MethodsShape>, REvent, EventLayerError>) => WorkerClass<Handlers$3<ROut | REvent, Definition$6<Id, MethodsShape>>, ROut | REvent>;
-  readonly layer: (options: LayerOptions$9) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$10) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
 /**
  * Defines a single RPC method schema in a worker definition.
@@ -879,9 +1007,9 @@ declare const method$3: {
     readonly success: Success;
   }): Method$4<Args, Success>;
 };
-declare const make$7: <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$8<Definition$6<Id, MethodsShape>, Id, MethodsShape>;
-declare const Tag$9: <Self>() => <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$8<Self, Id, MethodsShape>;
-declare const Worker: <Self>() => <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$8<Self, Id, MethodsShape>;
+declare const make$8: <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$9<Definition$6<Id, MethodsShape>, Id, MethodsShape>;
+declare const Tag$10: <Self>() => <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$9<Self, Id, MethodsShape>;
+declare const Worker: <Self>() => <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$9<Self, Id, MethodsShape>;
 /**
  * Helper for implementing handlers with the exact method shape of a definition.
  */
@@ -898,7 +1026,7 @@ type AsyncMethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...a
 type AsyncMethodSuccess<Api, Method extends keyof Api> = Api[Method] extends ((...args: AnyArgs) => Promise<infer A>) ? A : never;
 type AsyncMethodCloudflareReturn<Api, Method extends keyof Api> = Result<AsyncMethodSuccess<Api, Method>>;
 declare namespace ServiceBinding_d_exports {
-  export { Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceFetcher, isServiceBindingClient, layer$7 as layer, makeClient$5 as makeClient, makeDirectMethods$1 as makeDirectMethods };
+  export { Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceFetcher, isServiceBindingClient, layer$8 as layer, makeClient$6 as makeClient, makeDirectMethods$1 as makeDirectMethods };
 }
 declare const TypeId$1: "effect-cf/ServiceBinding";
 /**
@@ -1044,8 +1172,8 @@ type ServiceBindingStaticClient<R, Api extends object, Definition extends Defini
   readonly scopedCall: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, unknown, Scope.Scope | R>;
 };
 declare const isServiceBindingClient: <Api extends object>(value: unknown) => value is ServiceBindingClient<Api>;
-declare const makeClient$5: <Api extends object, const Definition extends Definition$6.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition>);
-declare const layer$7: <Self, Api extends object, const Definition extends Definition$6.Any | undefined = undefined>(tag: Context.Service<Self, ServiceBindingEffectClient<Api, Definition>>, definition: ServiceBindingDefinition<Definition>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const makeClient$6: <Api extends object, const Definition extends Definition$6.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition>);
+declare const layer$8: <Self, Api extends object, const Definition extends Definition$6.Any | undefined = undefined>(tag: Context.Service<Self, ServiceBindingEffectClient<Api, Definition>>, definition: ServiceBindingDefinition<Definition>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 /**
  * Creates a typed Effect service for a Worker service binding.
  *
@@ -1085,7 +1213,7 @@ declare const Service: <Self, Api extends object = never>() => <Id extends strin
 };
 declare const makeDirectMethods$1: <R, Api, Definition extends Definition$6.Any | undefined>(rpcDefinition: Definition | undefined, call: ServiceCall<R, Api>) => DirectMethods$1<R, Definition>;
 declare namespace Worker_d_exports {
-  export { Api$2 as Api, Definition$5 as Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect$2 as HandlerEffect, Handlers$2 as Handlers, LayerOptions$8 as LayerOptions, Method$3 as Method, Methods$2 as Methods, NativeRequest, NoReservedMethods$2 as NoReservedMethods, Options$4 as Options, ReservedMethodName$3 as ReservedMethodName, RpcHandlers$1 as RpcHandlers, ServerApi$3 as ServerApi, ServiceFreeSchema$2 as ServiceFreeSchema, Tag$8 as Tag, TagClass$7 as TagClass, TagFactory$1 as TagFactory, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcHandler, WorkerRpcShape, implement$4 as implement, isWebSocketUpgrade, make$6 as make, makeFetchHandler, method$2 as method, renderHttpResponse };
+  export { Api$2 as Api, Definition$5 as Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect$2 as HandlerEffect, Handlers$2 as Handlers, LayerOptions$9 as LayerOptions, Method$3 as Method, Methods$2 as Methods, NativeRequest, NoReservedMethods$2 as NoReservedMethods, Options$4 as Options, ReservedMethodName$3 as ReservedMethodName, RpcHandlers$1 as RpcHandlers, ServerApi$3 as ServerApi, ServiceFreeSchema$2 as ServiceFreeSchema, Tag$9 as Tag, TagClass$8 as TagClass, TagFactory$1 as TagFactory, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcHandler, WorkerRpcShape, implement$4 as implement, isWebSocketUpgrade, make$7 as make, makeFetchHandler, method$2 as method, renderHttpResponse };
 }
 declare const ExecutionContext_base: Context.ServiceClass<ExecutionContext, "effect-cf/ExecutionContext", globalThis.ExecutionContext<unknown>>;
 declare class ExecutionContext extends ExecutionContext_base {}
@@ -1138,8 +1266,8 @@ interface FetchHandler<Env extends WorkerEnv = WorkerEnv> {
   readonly fetch: (request: Request, env: Env, ctx: globalThis.ExecutionContext) => Promise<Response>;
 }
 declare const renderHttpResponse: <A extends HttpServerResponse.HttpServerResponse, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Response, E, R>;
-declare function make$6<ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, fetch: WorkerHandler<ROut>): WorkerClass<Record<never, never>, ROut>;
-declare function make$6<ROut, LayerError, REvent = never, EventLayerError = never, const Rpc extends WorkerRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptions<ROut, REvent, EventLayerError, Rpc>): WorkerClass<Rpc, ROut | REvent>;
+declare function make$7<ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, fetch: WorkerHandler<ROut>): WorkerClass<Record<never, never>, ROut>;
+declare function make$7<ROut, LayerError, REvent = never, EventLayerError = never, const Rpc extends WorkerRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptions<ROut, REvent, EventLayerError, Rpc>): WorkerClass<Rpc, ROut | REvent>;
 declare const makeFetchHandler: <ROut, LayerError, REvent = never, EventLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptions<ROut, REvent, EventLayerError>) => FetchHandler<Env>;
 type ServiceFreeSchema$2 = Schema.Codec<any, any, never, never>;
 interface Method$3<Args extends ReadonlyArray<ServiceFreeSchema$2> = ReadonlyArray<ServiceFreeSchema$2>, Success extends ServiceFreeSchema$2 = ServiceFreeSchema$2> {
@@ -1168,15 +1296,15 @@ type Handlers$2<ROut, Self extends Definition$5.Any> = { readonly [Key in keyof
 interface Options$4<ROut, Self extends Definition$5.Any, REvent = never, EventLayerError = never> extends Omit<WorkerOptions<ROut, REvent, EventLayerError, Handlers$2<ROut | REvent, Self>>, "rpc"> {
   readonly rpc: Handlers$2<ROut | REvent, Self>;
 }
-type LayerOptions$8 = LayerOptions$9;
-type TagClass$7<Self, Id extends string, MethodsShape extends Methods$2> = Context.ServiceClass<Self, Id, ServiceBindingEffectClient<Api$2<Definition$5<Id, MethodsShape>>, Definition$5<Id, MethodsShape>>> & ServiceBindingStaticClient<Self, Api$2<Definition$5<Id, MethodsShape>>, Definition$5<Id, MethodsShape>> & {
+type LayerOptions$9 = LayerOptions$10;
+type TagClass$8<Self, Id extends string, MethodsShape extends Methods$2> = Context.ServiceClass<Self, Id, ServiceBindingEffectClient<Api$2<Definition$5<Id, MethodsShape>>, Definition$5<Id, MethodsShape>>> & ServiceBindingStaticClient<Self, Api$2<Definition$5<Id, MethodsShape>>, Definition$5<Id, MethodsShape>> & {
   readonly id: Id;
   readonly methods: MethodsShape;
   readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$4<ROut, Definition$5<Id, MethodsShape>, REvent, EventLayerError>) => WorkerClass<Handlers$2<ROut | REvent, Definition$5<Id, MethodsShape>>, ROut | REvent>;
-  readonly layer: (options: LayerOptions$8) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$9) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
-type TagFactory$1 = <Self>() => <Id extends string, const MethodsShape extends Methods$2>(id: Id, methods: MethodsShape & NoReservedMethods$2<MethodsShape>) => TagClass$7<Self, Id, MethodsShape>;
-declare const Tag$8: TagFactory$1;
+type TagFactory$1 = <Self>() => <Id extends string, const MethodsShape extends Methods$2>(id: Id, methods: MethodsShape & NoReservedMethods$2<MethodsShape>) => TagClass$8<Self, Id, MethodsShape>;
+declare const Tag$9: TagFactory$1;
 declare const method$2: {
   <Success extends ServiceFreeSchema$2>(definition: {
     readonly success: Success;
@@ -1189,7 +1317,7 @@ declare const method$2: {
 declare const implement$4: <ROut, const Self extends Definition$5.Any>(_definition: Self, handlers: Handlers$2<ROut, Self>) => Handlers$2<ROut, Self>;
 type HandlerEffect$2<ROut, Self extends Definition$5.Any, Key extends keyof Self["methods"]> = WorkerRpcHandler<ROut, Method$3.Success<Self["methods"][Key]>>;
 declare namespace DurableObjectNamespace_d_exports {
-  export { DurableObjectFetchError, DurableObjectNamespaceBindingDefinition, DurableObjectNamespaceClient, DurableObjectNamespaceDefinition, DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient, DurableObjectRpcError, DurableObjectStubClient, isDurableObjectNamespaceClient, layer$6 as layer, makeClient$4 as makeClient, makeDirectMethods };
+  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>;
@@ -1387,8 +1515,8 @@ type DurableObjectNamespaceStaticClient<R, Api extends object, Definition extend
   readonly unsafeRaw: () => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
 };
 declare const isDurableObjectNamespaceClient: <Api extends object>(value: unknown) => value is DurableObjectNamespaceClient<Api>;
-declare const makeClient$4: <Api extends object, const Definition extends Definition$4.Any | undefined = undefined>(definition: DurableObjectNamespaceBindingDefinition<Definition>) => ((namespace: DurableObjectNamespaceClient<Api>) => DurableObjectNamespaceEffectClient<Api, Definition>);
-declare const layer$6: <Self, Api extends object, const Definition extends Definition$4.Any | undefined = undefined>(tag: Context.Service<Self, DurableObjectNamespaceEffectClient<Api, Definition>>, definition: DurableObjectNamespaceBindingDefinition<Definition>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const makeClient$5: <Api extends object, const Definition extends Definition$4.Any | undefined = undefined>(definition: DurableObjectNamespaceBindingDefinition<Definition>) => ((namespace: DurableObjectNamespaceClient<Api>) => DurableObjectNamespaceEffectClient<Api, Definition>);
+declare const layer$7: <Self, Api extends object, const Definition extends Definition$4.Any | undefined = undefined>(tag: Context.Service<Self, DurableObjectNamespaceEffectClient<Api, Definition>>, definition: DurableObjectNamespaceBindingDefinition<Definition>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const makeDirectMethods: <R, Api extends object, Definition extends Definition$4.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>;
@@ -1396,7 +1524,7 @@ declare const makeDirectMethods: <R, Api extends object, Definition extends Defi
   readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
 }) => DirectMethods<R, Api, Definition>;
 declare namespace DurableObjectDefinition_d_exports {
-  export { Api$1 as Api, Definition$4 as Definition, DurableObject$1 as DurableObject, HandlerEffect$1 as HandlerEffect, Handlers$1 as Handlers, LayerOptions$7 as LayerOptions, Method$2 as Method, Methods$1 as Methods, NoReservedMethods$1 as NoReservedMethods, Options$3 as Options, ReservedMethodName$1 as ReservedMethodName, ServerApi$2 as ServerApi, ServiceFreeSchema$1 as ServiceFreeSchema, Tag$7 as Tag, TagClass$6 as TagClass, implement$3 as implement, make$5 as make, method$1 as method };
+  export { Api$1 as Api, Definition$4 as Definition, DurableObject$1 as DurableObject, HandlerEffect$1 as HandlerEffect, Handlers$1 as Handlers, LayerOptions$8 as LayerOptions, Method$2 as Method, Methods$1 as Methods, NoReservedMethods$1 as NoReservedMethods, Options$3 as Options, ReservedMethodName$1 as ReservedMethodName, ServerApi$2 as ServerApi, ServiceFreeSchema$1 as ServiceFreeSchema, Tag$8 as Tag, TagClass$7 as TagClass, implement$3 as implement, make$6 as make, method$1 as method };
 }
 type ServiceFreeSchema$1 = Schema.Codec<any, any, never, never>;
 interface Method$2<Args extends ReadonlyArray<ServiceFreeSchema$1> = ReadonlyArray<ServiceFreeSchema$1>, Success extends ServiceFreeSchema$1 = ServiceFreeSchema$1> {
@@ -1441,14 +1569,14 @@ type Handlers$1<ROut, Self extends Definition$4.Any> = { readonly [Key in keyof
 interface Options$3<ROut, Self extends Definition$4.Any, REvent = never, EventLayerError = never> extends Omit<DurableObjectOptions<ROut, REvent, EventLayerError, Handlers$1<ROut | REvent, Self>>, "rpc"> {
   readonly rpc: Handlers$1<ROut | REvent, Self>;
 }
-type LayerOptions$7 = {
+type LayerOptions$8 = {
   readonly binding: string;
 };
-type TagClass$6<Self, Id extends string, MethodsShape extends Methods$1> = Context.ServiceClass<Self, Id, DurableObjectNamespaceEffectClient<Api$1<Definition$4<Id, MethodsShape>>, Definition$4<Id, MethodsShape>>> & DurableObjectNamespaceStaticClient<Self, Api$1<Definition$4<Id, MethodsShape>>, Definition$4<Id, MethodsShape>> & {
+type TagClass$7<Self, Id extends string, MethodsShape extends Methods$1> = Context.ServiceClass<Self, Id, DurableObjectNamespaceEffectClient<Api$1<Definition$4<Id, MethodsShape>>, Definition$4<Id, MethodsShape>>> & DurableObjectNamespaceStaticClient<Self, Api$1<Definition$4<Id, MethodsShape>>, Definition$4<Id, MethodsShape>> & {
   readonly id: Id;
   readonly methods: MethodsShape;
   readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options: Options$3<ROut, Definition$4<Id, MethodsShape>, REvent, EventLayerError>) => DurableObjectClass<Handlers$1<ROut | REvent, Definition$4<Id, MethodsShape>>, ROut | REvent>;
-  readonly layer: (options: LayerOptions$7) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$8) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
 /**
  * Defines a single RPC method schema in a Durable Object definition.
@@ -1462,9 +1590,9 @@ declare const method$1: {
     readonly success: Success;
   }): Method$2<Args, Success>;
 };
-declare const make$5: <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$6<Definition$4<Id, MethodsShape>, Id, MethodsShape>;
-declare const Tag$7: <Self>() => <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$6<Self, Id, MethodsShape>;
-declare const DurableObject$1: <Self>() => <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$6<Self, Id, MethodsShape>;
+declare const make$6: <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$7<Definition$4<Id, MethodsShape>, Id, MethodsShape>;
+declare const Tag$8: <Self>() => <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$7<Self, Id, MethodsShape>;
+declare const DurableObject$1: <Self>() => <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$7<Self, Id, MethodsShape>;
 /**
  * Helper for implementing handlers with the exact method shape of a definition.
  */
@@ -1474,7 +1602,7 @@ declare const implement$3: <ROut, const Self extends Definition$4.Any>(_definiti
  */
 type HandlerEffect$1<ROut, Self extends Definition$4.Any, Key extends keyof Self["methods"]> = DurableObjectHandler<ROut, Method$2.Success<Self["methods"][Key]>>;
 declare namespace DurableObject_d_exports {
-  export { Api, Definition$3 as Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcShape, HandlerEffect, Handlers, LayerOptions$6 as LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options$2 as Options, ReservedMethodName, RpcHandlers, ServerApi$1 as ServerApi, ServiceFreeSchema, Tag$6 as Tag, TagClass$5 as TagClass, TagFactory, implement$2 as implement, make$4 as make, method };
+  export { Api, Definition$3 as Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcShape, HandlerEffect, Handlers, LayerOptions$7 as LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options$2 as Options, ReservedMethodName, RpcHandlers, ServerApi$1 as ServerApi, ServiceFreeSchema, Tag$7 as Tag, TagClass$6 as TagClass, TagFactory, implement$2 as implement, make$5 as make, method };
 }
 type RuntimeContext$1<ROut> = DurableObjectState | WorkerEnvironment | ROut;
 type HandlerContext<ROut> = RuntimeContext$1<ROut> | Scope.Scope;
@@ -1534,7 +1662,7 @@ type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (state:
 /**
  * Creates a Durable Object class backed by a single managed Effect runtime.
  */
-declare const make$4: <ROut, LayerError, REvent = never, EventLayerError = never, const Rpc extends DurableObjectRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options?: DurableObjectOptions<ROut, REvent, EventLayerError, Rpc>) => DurableObjectClass<Rpc, ROut | REvent>;
+declare const make$5: <ROut, LayerError, REvent = never, EventLayerError = never, const Rpc extends DurableObjectRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options?: DurableObjectOptions<ROut, REvent, EventLayerError, Rpc>) => DurableObjectClass<Rpc, ROut | REvent>;
 type ServiceFreeSchema = Schema.Codec<any, any, never, never>;
 interface Method$1<Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema = ServiceFreeSchema> {
   readonly args: Args;
@@ -1557,21 +1685,21 @@ interface Definition$3<Id extends string = string, MethodsShape extends Methods
 declare namespace Definition$3 {
   type Any = Definition$3<string, Methods>;
 }
-type LayerOptions$6 = LayerOptions$7;
+type LayerOptions$7 = LayerOptions$8;
 type ServerApi$1<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$1<Self>, ReservedMethodName>;
 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]>> };
 interface Options$2<ROut, Self extends Definition$3.Any, REvent = never, EventLayerError = never> extends Omit<DurableObjectOptions<ROut, REvent, EventLayerError, Handlers<ROut | REvent, Self>>, "rpc"> {
   readonly rpc: Handlers<ROut | REvent, Self>;
 }
-type TagClass$5<Self, Id extends string, MethodsShape extends Methods> = Context.ServiceClass<Self, Id, DurableObjectNamespaceEffectClient<Api<Definition$3<Id, MethodsShape>>, Definition$3<Id, MethodsShape>>> & DurableObjectNamespaceStaticClient<Self, Api<Definition$3<Id, MethodsShape>>, Definition$3<Id, MethodsShape>> & {
+type TagClass$6<Self, Id extends string, MethodsShape extends Methods> = Context.ServiceClass<Self, Id, DurableObjectNamespaceEffectClient<Api<Definition$3<Id, MethodsShape>>, Definition$3<Id, MethodsShape>>> & DurableObjectNamespaceStaticClient<Self, Api<Definition$3<Id, MethodsShape>>, Definition$3<Id, MethodsShape>> & {
   readonly id: Id;
   readonly methods: MethodsShape;
   readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options: Options$2<ROut, Definition$3<Id, MethodsShape>, REvent, EventLayerError>) => DurableObjectClass<Handlers<ROut | REvent, Definition$3<Id, MethodsShape>>, ROut | REvent>;
-  readonly layer: (options: LayerOptions$6) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$7) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
-type TagFactory = <Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape>) => TagClass$5<Self, Id, MethodsShape>;
-declare const Tag$6: TagFactory;
+type TagFactory = <Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape>) => TagClass$6<Self, Id, MethodsShape>;
+declare const Tag$7: TagFactory;
 declare const method: {
   <Success extends ServiceFreeSchema>(definition: {
     readonly success: Success;
@@ -1908,12 +2036,12 @@ declare class DurableObjectAlarm extends DurableObjectAlarm_base {
   static readonly layer: Layer.Layer<DurableObjectAlarm, never, DurableObjectState>;
 }
 declare namespace DurableObjectRpcWebSocket_d_exports {
-  export { DurableObjectRpcWebSocket, DurableObjectRpcWebSocketService, LayerOptions$5 as LayerOptions, NativeWebSocketMessage, layer$5 as layer };
+  export { DurableObjectRpcWebSocket, DurableObjectRpcWebSocketService, LayerOptions$6 as LayerOptions, NativeWebSocketMessage, layer$6 as layer };
 }
 /**
  * Configuration for {@link layer}.
  */
-interface LayerOptions$5 {
+interface LayerOptions$6 {
   /** Tag used to select hibernated sockets. */
   readonly tag?: string | undefined;
   /** Socket attachment key used to persist client ids across hibernation. */
@@ -1938,9 +2066,9 @@ declare class DurableObjectRpcWebSocket extends DurableObjectRpcWebSocket_base {
 /**
  * Builds a layer that bridges Durable Object websocket events to `RpcServer.Protocol`.
  */
-declare const layer$5: (options?: LayerOptions$5) => Layer.Layer<DurableObjectRpcWebSocket | RpcServer.Protocol, never, DurableObjectState | RpcSerialization.RpcSerialization>;
+declare const layer$6: (options?: LayerOptions$6) => Layer.Layer<DurableObjectRpcWebSocket | RpcServer.Protocol, never, DurableObjectState | RpcSerialization.RpcSerialization>;
 declare namespace DurableObjectSqlite_d_exports {
-  export { SqliteLayerOptions, layer$4 as layer };
+  export { SqliteLayerOptions, layer$5 as layer };
 }
 /** Options forwarded to `@effect/sql-sqlite-do` when building a SQL client layer. */
 type SqliteLayerOptions = Omit<SqliteClient.SqliteClientConfig, "db">;
@@ -1955,9 +2083,9 @@ type SqliteLayerOptions = Omit<SqliteClient.SqliteClientConfig, "db">;
  * );
  * ```
  */
-declare const layer$4: (options?: SqliteLayerOptions) => Layer.Layer<_$effect_unstable_sql_SqlClient0.SqlClient | SqliteClient.SqliteClient, never, DurableObjectState>;
+declare const layer$5: (options?: SqliteLayerOptions) => Layer.Layer<_$effect_unstable_sql_SqlClient0.SqlClient | SqliteClient.SqliteClient, never, DurableObjectState>;
 declare namespace Images_d_exports {
-  export { DrawStepOptions, HostedImagesClient, ImageDrawOptions, ImageHandleClient, ImageInfoResponse, ImageInputOptions, ImageInputValue, ImageList, ImageListOptions, ImageMetadata, ImageOutputOptions, ImageTransform, ImageTransformationOutputOptions, ImageTransformationResult, ImageUpdateOptions, ImageUploadOptions, ImageUploadValue, ImagesClient, ImagesDefinition, ImagesOperationError, ImagesRuntimeBinding, ImagesService, ImagesTransformationResultClient, LayerOptions$4 as LayerOptions, ProcessOptions, Step, Steps, Tag$5 as Tag, TagClass$4 as TagClass, draw, empty, isImagesBinding, layer$3 as layer, make$3 as make, makeClient$3 as makeClient, transform };
+  export { DrawStepOptions, HostedImagesClient, ImageDrawOptions, ImageHandleClient, ImageInfoResponse, ImageInputOptions, ImageInputValue, ImageList, ImageListOptions, ImageMetadata, ImageOutputOptions, ImageTransform, ImageTransformationOutputOptions, ImageTransformationResult, ImageUpdateOptions, ImageUploadOptions, ImageUploadValue, ImagesClient, ImagesDefinition, ImagesOperationError, ImagesRuntimeBinding, ImagesService, ImagesTransformationResultClient, LayerOptions$5 as LayerOptions, ProcessOptions, Step, Steps, Tag$6 as Tag, TagClass$5 as TagClass, draw, empty, isImagesBinding, layer$4 as layer, make$4 as make, makeClient$4 as makeClient, transform };
 }
 declare const TypeId: "effect-cf/Images/Steps";
 declare const ImagesOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
@@ -1974,22 +2102,22 @@ interface ImagesDefinition {
   /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
 }
-type ImageInfoResponse = globalThis.ImageInfoResponse;
-type ImageTransform = globalThis.ImageTransform;
-type ImageDrawOptions = globalThis.ImageDrawOptions;
-type ImageInputOptions = globalThis.ImageInputOptions;
-type ImageOutputOptions = globalThis.ImageOutputOptions;
-type ImageTransformationOutputOptions = globalThis.ImageTransformationOutputOptions;
-type ImageTransformationResult = globalThis.ImageTransformationResult;
-type ImageUploadOptions = globalThis.ImageUploadOptions;
-type ImageUpdateOptions = globalThis.ImageUpdateOptions;
-type ImageListOptions = globalThis.ImageListOptions;
-type ImageList = globalThis.ImageList;
-type ImageMetadata = globalThis.ImageMetadata;
+type ImageInfoResponse = CloudflareImageInfoResponse;
+type ImageTransform = CloudflareImageTransform;
+type ImageDrawOptions = CloudflareImageDrawOptions;
+type ImageInputOptions = CloudflareImageInputOptions;
+type ImageOutputOptions = CloudflareImageOutputOptions;
+type ImageTransformationOutputOptions = CloudflareImageTransformationOutputOptions;
+type ImageTransformationResult = CloudflareImageTransformationResult;
+type ImageUploadOptions = CloudflareImageUploadOptions;
+type ImageUpdateOptions = CloudflareImageUpdateOptions;
+type ImageListOptions = CloudflareImageListOptions;
+type ImageList = CloudflareImageList;
+type ImageMetadata = CloudflareImageMetadata;
 type ImageInputValue = ReadableStream<Uint8Array> | ArrayBuffer;
 type ImageUploadValue = ReadableStream<Uint8Array> | ArrayBuffer;
 interface DrawStepOptions {
-  readonly image: ReadableStream<Uint8Array> | globalThis.ImageTransformer;
+  readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
   readonly options?: ImageDrawOptions;
 }
 type Step = Data.TaggedEnum<{
@@ -2008,13 +2136,13 @@ interface ProcessOptions {
   readonly outputOptions: ImageOutputOptions;
 }
 interface ImagesTransformationResultClient {
-  readonly raw: globalThis.ImageTransformationResult;
-  readonly response: Effect.Effect<globalThis.Response, ImagesOperationError>;
+  readonly raw: CloudflareImageTransformationResult;
+  readonly response: Effect.Effect<CloudflareResponse, ImagesOperationError>;
   readonly contentType: Effect.Effect<string, ImagesOperationError>;
   readonly image: (options?: ImageTransformationOutputOptions) => Effect.Effect<ReadableStream<Uint8Array>, ImagesOperationError>;
 }
 interface ImageHandleClient {
-  readonly raw: globalThis.ImageHandle;
+  readonly raw: CloudflareImageHandle;
   readonly details: Effect.Effect<Option.Option<ImageMetadata>, ImagesOperationError>;
   readonly bytes: Effect.Effect<Option.Option<ReadableStream<Uint8Array>>, ImagesOperationError>;
   readonly update: (options: ImageUpdateOptions) => Effect.Effect<ImageMetadata, ImagesOperationError>;
@@ -2024,16 +2152,16 @@ 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 unsafeRaw: Effect.Effect<globalThis.HostedImagesBinding>;
+  readonly unsafeRaw: Effect.Effect<CloudflareHostedImagesBinding>;
 }
 interface ImagesRuntimeBinding {
   readonly info: (image: ImageInputValue, options?: ImageInputOptions) => Promise<ImageInfoResponse>;
-  readonly input: (image: ImageInputValue, options?: ImageInputOptions) => globalThis.ImageTransformer;
-  readonly hosted?: globalThis.HostedImagesBinding;
+  readonly input: (image: ImageInputValue, options?: ImageInputOptions) => CloudflareImageTransformer;
+  readonly hosted?: CloudflareHostedImagesBinding;
 }
 interface ImagesClient {
   readonly info: (image: ImageInputValue, options?: ImageInputOptions) => Effect.Effect<ImageInfoResponse, ImagesOperationError>;
-  readonly input: (image: ImageInputValue, options?: ImageInputOptions) => Effect.Effect<globalThis.ImageTransformer, ImagesOperationError>;
+  readonly input: (image: ImageInputValue, options?: ImageInputOptions) => Effect.Effect<CloudflareImageTransformer, ImagesOperationError>;
   readonly process: (steps: Steps, options: ProcessOptions) => Effect.Effect<ImagesTransformationResultClient, ImagesOperationError>;
   readonly hosted: Option.Option<HostedImagesClient>;
   readonly unsafeRaw: Effect.Effect<ImagesRuntimeBinding>;
@@ -2046,12 +2174,12 @@ interface ImagesService<Id extends string> {
     readonly id: Id;
   };
 }
-type LayerOptions$4 = {
+type LayerOptions$5 = {
   readonly binding: string;
 };
-interface TagClass$4<Self, Id extends string> extends Context.ServiceClass<Self, Id, ImagesClient> {
+interface TagClass$5<Self, Id extends string> extends Context.ServiceClass<Self, Id, ImagesClient> {
   readonly id: Id;
-  readonly layer: (options: LayerOptions$4) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$5) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
 /** Empty Images transformation pipeline. */
 declare const empty: Steps;
@@ -2060,12 +2188,12 @@ declare function transform(steps: Steps, transform: ImageTransform): Steps;
 declare function draw(draw: DrawStepOptions): (steps: Steps) => Steps;
 declare function draw(steps: Steps, draw: DrawStepOptions): Steps;
 declare const isImagesBinding: (value: unknown) => value is 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$3: <Id extends string>(id: Id) => TagClass$4<ImagesService<Id>, Id>;
-declare const Tag$5: <Self>() => <Id extends string>(id: Id) => TagClass$4<Self, Id>;
+declare const makeClient$4: (definition: ImagesDefinition) => (images: ImagesRuntimeBinding) => ImagesClient;
+declare const layer$4: <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$6: <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, KvOperationError, KvPutOptions, KvWithMetadata, LayerOptions$3 as LayerOptions, Tag$4 as Tag, TagClass$3 as TagClass, isKvNamespace, layer$2 as layer, makeClient$2 as makeClient };
+  export { Definition$2 as Definition, KvClient, KvDefinition, KvListKey, KvListOptions, KvListResult, KvOperationError, KvPutOptions, KvWithMetadata, LayerOptions$4 as LayerOptions, Tag$5 as Tag, TagClass$4 as TagClass, isKvNamespace, layer$3 as layer, makeClient$3 as makeClient };
 }
 declare const KvOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
   readonly _tag: "KvOperationError";
@@ -2077,9 +2205,9 @@ declare class KvOperationError extends KvOperationError_base<{
   readonly cause: unknown;
 }> {}
 /** `KVNamespace.put` options. */
-type KvPutOptions = globalThis.KVNamespacePutOptions;
+type KvPutOptions = CloudflareKVNamespacePutOptions;
 /** `KVNamespace.list` options with optional metadata decoding schema. */
-type KvListOptions<Metadata = unknown> = globalThis.KVNamespaceListOptions & {
+type KvListOptions<Metadata = unknown> = CloudflareKVNamespaceListOptions & {
   readonly metadataSchema?: Schema.Codec<Metadata, unknown>;
 };
 /** Successful value returned by `getWithMetadata`. */
@@ -2134,24 +2262,24 @@ interface KvClient<Key, Value, EncodedValue> {
   readonly unsafeRaw: Effect.Effect<KVNamespace>;
   readonly definition: KvDefinition<Key, Value, EncodedValue>;
 }
-type LayerOptions$3 = {
+type LayerOptions$4 = {
   readonly binding: string;
 };
-interface TagClass$3<Self, Id extends string, Key, Value, EncodedValue> extends Context.ServiceClass<Self, Id, KvClient<Key, Value, EncodedValue>> {
+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$3) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$4) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
 declare const isKvNamespace: (value: unknown) => value is 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: {
+declare const makeClient$3: <Key, Value, EncodedValue>(definition: KvDefinition<Key, Value, EncodedValue>) => ((kv: KVNamespace) => KvClient<Key, Value, EncodedValue>);
+declare const layer$3: <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$5: <Self>() => <Id extends string, Key, Value, EncodedValue>(id: Id, definition: {
   readonly key: Schema.Codec<Key, string>;
   readonly value: Schema.Codec<Value, EncodedValue>;
-}) => TagClass$3<Self, Id, Key, Value, EncodedValue>;
+}) => TagClass$4<Self, Id, Key, Value, EncodedValue>;
 declare namespace R2_d_exports {
-  export { LayerOptions$2 as LayerOptions, R2Client, R2Definition, R2GetOptions, R2ListOptions, R2MultipartOptions, R2MultipartUploadClient, R2ObjectBodyClient, R2OperationError, R2PutOptions, R2PutValue, R2Service, R2UploadPartOptions, R2UploadPartValue, Tag$3 as Tag, TagClass$2 as TagClass, isR2Bucket, layer$1 as layer, make$2 as make, makeClient$1 as makeClient };
+  export { LayerOptions$3 as LayerOptions, R2Client, R2Definition, R2GetOptions, R2ListOptions, R2MultipartOptions, R2MultipartUploadClient, R2ObjectBodyClient, R2OperationError, R2PutOptions, R2PutValue, R2Service, R2UploadPartOptions, R2UploadPartValue, Tag$4 as Tag, TagClass$3 as TagClass, isR2Bucket, layer$2 as layer, make$3 as make, makeClient$2 as makeClient };
 }
 declare const R2OperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
   readonly _tag: "R2OperationError";
@@ -2167,15 +2295,15 @@ interface R2Definition {
   /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
 }
-type R2GetOptions = globalThis.R2GetOptions;
-type R2PutOptions = globalThis.R2PutOptions;
-type R2ListOptions = globalThis.R2ListOptions;
-type R2MultipartOptions = globalThis.R2MultipartOptions;
-type R2UploadPartOptions = globalThis.R2UploadPartOptions;
+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<globalThis.R2ObjectBody, "arrayBuffer" | "blob" | "bytes" | "json" | "text"> {
-  readonly raw: globalThis.R2ObjectBody;
+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>;
@@ -2183,32 +2311,32 @@ interface R2ObjectBodyClient extends Omit<globalThis.R2ObjectBody, "arrayBuffer"
   readonly blob: Effect.Effect<Blob, R2OperationError>;
 }
 interface R2MultipartUploadClient {
-  readonly raw: globalThis.R2MultipartUpload;
+  readonly raw: CloudflareR2MultipartUpload;
   readonly key: string;
   readonly uploadId: string;
-  readonly uploadPart: (partNumber: number, value: R2UploadPartValue, options?: R2UploadPartOptions) => Effect.Effect<globalThis.R2UploadedPart, R2OperationError>;
+  readonly uploadPart: (partNumber: number, value: R2UploadPartValue, options?: R2UploadPartOptions) => Effect.Effect<CloudflareR2UploadedPart, R2OperationError>;
   readonly abort: Effect.Effect<void, R2OperationError>;
-  readonly complete: (uploadedParts: ReadonlyArray<globalThis.R2UploadedPart>) => Effect.Effect<globalThis.R2Object, R2OperationError>;
+  readonly complete: (uploadedParts: ReadonlyArray<CloudflareR2UploadedPart>) => Effect.Effect<CloudflareR2Object, R2OperationError>;
 }
 interface R2Client {
-  readonly head: (key: string) => Effect.Effect<Option.Option<globalThis.R2Object>, R2OperationError>;
+  readonly head: (key: string) => Effect.Effect<Option.Option<CloudflareR2Object>, R2OperationError>;
   readonly get: {
     (key: string, options: R2GetOptions & {
-      readonly onlyIf: globalThis.R2Conditional | Headers;
-    }): Effect.Effect<Option.Option<R2ObjectBodyClient | globalThis.R2Object>, R2OperationError>;
+      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: globalThis.R2Conditional | Headers;
-    }): Effect.Effect<Option.Option<globalThis.R2Object>, R2OperationError>;
-    (key: string, value: R2PutValue, options?: R2PutOptions): Effect.Effect<globalThis.R2Object, R2OperationError>;
+      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<globalThis.R2Objects, R2OperationError>;
-  readonly unsafeRaw: Effect.Effect<globalThis.R2Bucket>;
+  readonly list: (options?: R2ListOptions) => Effect.Effect<CloudflareR2Objects, R2OperationError>;
+  readonly unsafeRaw: Effect.Effect<CloudflareR2Bucket>;
   readonly definition: R2Definition;
 }
 declare const R2ServiceTypeId: unique symbol;
@@ -2218,22 +2346,22 @@ interface R2Service<Id extends string> {
     readonly id: Id;
   };
 }
-type LayerOptions$2 = {
+type LayerOptions$3 = {
   readonly binding: string;
 };
-interface TagClass$2<Self, Id extends string> extends Context.ServiceClass<Self, Id, R2Client> {
+interface TagClass$3<Self, Id extends string> extends Context.ServiceClass<Self, Id, R2Client> {
   readonly id: Id;
-  readonly layer: (options: LayerOptions$2) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly layer: (options: LayerOptions$3) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
-declare const isR2Bucket: (value: unknown) => value is globalThis.R2Bucket;
-declare const makeClient$1: (definition: R2Definition) => ((bucket: globalThis.R2Bucket) => R2Client);
-declare const layer$1: <Self>(tag: Context.Service<Self, R2Client>, definition: R2Definition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const make$2: <Id extends string>(id: Id) => TagClass$2<R2Service<Id>, Id>;
-declare const Tag$3: <Self>() => <Id extends string>(id: Id) => TagClass$2<Self, Id>;
+declare const isR2Bucket: (value: unknown) => value is CloudflareR2Bucket;
+declare const makeClient$2: (definition: R2Definition) => ((bucket: CloudflareR2Bucket) => R2Client);
+declare const layer$2: <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$4: <Self>() => <Id extends string>(id: Id) => TagClass$3<Self, Id>;
 declare namespace WorkflowBinding_d_exports {
-  export { WorkflowBindingClient, WorkflowBindingDefinition, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowInstanceEvent, WorkflowInstanceRestartOptions, WorkflowInstanceStatus, WorkflowInstanceStatusName, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer, makeClient };
+  export { WorkflowBindingClient, WorkflowBindingDefinition, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowInstanceEvent, WorkflowInstanceRestartOptions, WorkflowInstanceStatus, WorkflowInstanceStatusName, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer$1 as layer, makeClient$1 as makeClient };
 }
-type WorkflowInstanceCreateOptions<Payload> = Omit<globalThis.WorkflowInstanceCreateOptions<Payload>, "params">;
+type WorkflowInstanceCreateOptions<Payload> = Omit<CloudflareWorkflowInstanceCreateOptions<Payload>, "params">;
 type WorkflowInstanceCreateBatchOptions<Payload, EncodedPayload = unknown> = ReadonlyArray<{
   readonly payload: Payload;
 } & WorkflowInstanceCreateOptions<EncodedPayload>>;
@@ -2244,7 +2372,7 @@ interface WorkflowInstanceRestartOptions {
     readonly type?: string;
   };
 }
-type WorkflowInstanceStatusName = globalThis.InstanceStatus["status"];
+type WorkflowInstanceStatusName = CloudflareInstanceStatus["status"];
 interface WorkflowInstanceStatus<Result> {
   readonly status: WorkflowInstanceStatusName;
   readonly output: Option.Option<Result>;
@@ -2254,7 +2382,7 @@ interface WorkflowInstanceStatus<Result> {
   }>;
 }
 interface WorkflowInstance<Result> {
-  readonly raw: globalThis.WorkflowInstance;
+  readonly raw: CloudflareWorkflowInstance;
   readonly id: string;
   readonly pause: Effect.Effect<void, WorkflowOperationError>;
   readonly resume: Effect.Effect<void, WorkflowOperationError>;
@@ -2279,7 +2407,7 @@ interface WorkflowBindingClient<Payload extends ServiceFreeSchema$4, Result exte
   readonly create: (payload: Schema.Schema.Type<Payload>, options?: WorkflowInstanceCreateOptions<Schema.Codec.Encoded<Payload>>) => Effect.Effect<WorkflowInstance<Schema.Schema.Type<Result>>, WorkflowOperationError | Schema.SchemaError>;
   readonly createBatch: (batch: WorkflowInstanceCreateBatchOptions<Schema.Schema.Type<Payload>, Schema.Codec.Encoded<Payload>>) => Effect.Effect<ReadonlyArray<WorkflowInstance<Schema.Schema.Type<Result>>>, WorkflowOperationError | Schema.SchemaError>;
   readonly get: (instanceId: string) => Effect.Effect<WorkflowInstance<Schema.Schema.Type<Result>>, WorkflowOperationError>;
-  readonly unsafeRaw: Effect.Effect<globalThis.Workflow<Schema.Codec.Encoded<Payload>>>;
+  readonly unsafeRaw: Effect.Effect<CloudflareWorkflow<Schema.Codec.Encoded<Payload>>>;
 }
 declare const WorkflowOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
   readonly _tag: "WorkflowOperationError";
@@ -2297,11 +2425,11 @@ declare class WorkflowResultDecodeError extends WorkflowResultDecodeError_base<{
   readonly instanceId: string;
   readonly cause: unknown;
 }> {}
-declare const isWorkflow: <Payload>(value: unknown) => value is globalThis.Workflow<Payload>;
-declare const makeClient: <Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4>(definition: WorkflowBindingDefinition<Payload, Result>) => ((workflow: globalThis.Workflow<Schema.Codec.Encoded<Payload>>) => WorkflowBindingClient<Payload, Result>);
-declare const layer: <Self, Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4>(tag: Context.Service<Self, WorkflowBindingClient<Payload, Result>>, definition: WorkflowBindingDefinition<Payload, Result>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const isWorkflow: <Payload>(value: unknown) => value is CloudflareWorkflow<Payload>;
+declare const makeClient$1: <Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4>(definition: WorkflowBindingDefinition<Payload, Result>) => ((workflow: CloudflareWorkflow<Schema.Codec.Encoded<Payload>>) => WorkflowBindingClient<Payload, Result>);
+declare const layer$1: <Self, Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4>(tag: Context.Service<Self, WorkflowBindingClient<Payload, Result>>, definition: WorkflowBindingDefinition<Payload, Result>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare namespace WorkflowDefinition_d_exports {
-  export { Definition$1 as Definition, Handler$1 as Handler, LayerOptions$1 as LayerOptions, Options$1 as Options, Tag$2 as Tag, TagClass$1 as TagClass, Workflow, implement$1 as implement, make$1 as make };
+  export { Definition$1 as Definition, Handler$1 as Handler, LayerOptions$2 as LayerOptions, Options$1 as Options, Tag$3 as Tag, TagClass$2 as TagClass, Workflow, implement$1 as implement, make$2 as make };
 }
 interface Definition$1<Id extends string = string, Payload extends ServiceFreeSchema$4 = ServiceFreeSchema$4, Result extends ServiceFreeSchema$4 = ServiceFreeSchema$4> {
   readonly id: Id;
@@ -2315,41 +2443,42 @@ type Handler$1<ROut, Self extends Definition$1.Any> = (payload: Schema.Schema.Ty
 interface Options$1<ROut, Self extends Definition$1.Any> {
   readonly run: Handler$1<ROut, Self>;
 }
-type LayerOptions$1 = {
+type LayerOptions$2 = {
   readonly binding: string;
 };
-interface TagClass$1<Self, Id extends string, Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4> extends Context.ServiceClass<Self, Id, WorkflowBindingClient<Payload, Result>> {
+interface TagClass$2<Self, Id extends string, Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4> extends Context.ServiceClass<Self, 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 layer: (options: LayerOptions$2) => 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 unsafeRaw: () => Effect.Effect<globalThis.Workflow<Schema.Codec.Encoded<Payload>>, never, Self>;
 }
-declare const make$1: <Id extends string, Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4>(id: Id, definition: {
+declare const make$2: <Id extends string, Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4>(id: Id, definition: {
   readonly payload: Payload;
   readonly result: Result;
-}) => TagClass$1<Definition$1<Id, Payload, Result>, Id, Payload, Result>;
-declare const Tag$2: <Self>() => <Id extends string, Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4>(id: Id, definition: {
+}) => TagClass$2<Definition$1<Id, Payload, Result>, Id, Payload, Result>;
+declare const Tag$3: <Self>() => <Id extends string, Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4>(id: Id, definition: {
   readonly payload: Payload;
   readonly result: Result;
-}) => TagClass$1<Self, Id, Payload, Result>;
+}) => TagClass$2<Self, Id, Payload, Result>;
 declare const Workflow: <Self>() => <Id extends string, Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4>(id: Id, definition: {
   readonly payload: Payload;
   readonly result: Result;
-}) => TagClass$1<Self, Id, Payload, Result>;
+}) => TagClass$2<Self, Id, Payload, Result>;
 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$1 as Tag, TagClass, WorkflowClass, WorkflowEvent$1 as WorkflowEvent, WorkflowEventService, WorkflowHandler, WorkflowOptions, WorkflowRunContext, WorkflowStep$1 as WorkflowStep, WorkflowStepContext$1 as WorkflowStepContext, WorkflowStepService, implement, make, sleep, sleepUntil, step, waitForEvent };
+  export { Definition, Handler, LayerOptions$1 as LayerOptions, Options, Tag$2 as Tag, TagClass$1 as TagClass, WorkflowClass, WorkflowEvent$1 as WorkflowEvent, WorkflowEventService, WorkflowHandler, WorkflowOptions, WorkflowRunContext, WorkflowStep$1 as WorkflowStep, WorkflowStepContext$1 as WorkflowStepContext, WorkflowStepService, implement, make$1 as 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 {}
@@ -2376,7 +2505,7 @@ interface WorkflowOptions<ROut, Payload = unknown, Result = unknown> {
 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 make$1: <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, unknown, WorkflowStep$1 | Exclude<R, WorkflowStepContext$1>>;
 declare const sleep: (name: string, duration: WorkflowSleepDuration) => Effect.Effect<void, unknown, WorkflowStep$1>;
 declare const sleepUntil: (name: string, timestamp: Date | number) => Effect.Effect<void, unknown, WorkflowStep$1>;
@@ -2388,14 +2517,74 @@ type Definition<Id extends string = string, Payload extends Definition$1.Any["pa
 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$1: <Self>() => <Id extends string, Payload extends Definition$1.Any["payload"], Result extends Definition$1.Any["result"]>(id: Id, definition: {
+type LayerOptions$1 = LayerOptions$2;
+type TagClass$1<Self, Id extends string, Payload extends Definition$1.Any["payload"], Result extends Definition$1.Any["result"]> = TagClass$2<Self, Id, Payload, Result>;
+declare const Tag$2: <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>;
+}) => TagClass$1<Self, Id, Payload, Result>;
 declare const implement: <ROut, const Self extends Definition$1.Any>(_definition: Self, handler: Handler$1<ROut, Self>) => Handler$1<ROut, Self>;
 type Handler<ROut, Self extends Definition$1.Any> = Handler$1<ROut, Self>;
 type Options<ROut, Self extends Definition$1.Any> = Options$1<ROut, Self>;
+declare namespace Vectorize_d_exports {
+  export { LayerOptions, Tag$1 as Tag, TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails, VectorizeIndexInfo, VectorizeMatch, VectorizeMatches, VectorizeMutation, VectorizeOperationError, VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector, VectorizeVectorMetadata, VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue, isVectorizeBinding, layer, make, makeClient };
+}
+declare const VectorizeOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "VectorizeOperationError";
+} & Readonly<A>;
+/** Error raised when a Vectorize operation fails. */
+declare class VectorizeOperationError extends VectorizeOperationError_base<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {}
+/** Typed Vectorize binding definition. */
+interface VectorizeDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  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 unsafeRaw: Effect.Effect<VectorizeBinding>;
+  readonly definition: VectorizeDefinition;
+}
+declare const VectorizeServiceTypeId: unique symbol;
+/** Nominal service marker for Vectorize services created with {@link make}. */
+interface VectorizeService<Id extends string> {
+  readonly [VectorizeServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions = {
+  readonly binding: string;
+};
+interface TagClass<Self, Id extends string> extends Context.ServiceClass<Self, Id, VectorizeClient> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+declare const isVectorizeBinding: (value: unknown) => 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: <Id extends string>(id: Id) => TagClass<VectorizeService<Id>, Id>;
+declare const Tag$1: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 //#endregion
-export { Binding_d_exports as Binding, CloudflareOtlp_d_exports as CloudflareOtlp, 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, Hyperdrive_d_exports as Hyperdrive, Images_d_exports as Images, Kv_d_exports as Kv, Queue_d_exports as Queue, QueueBinding_d_exports as QueueBinding, QueueDefinition_d_exports as QueueDefinition, R2_d_exports as R2, Rpc_d_exports as Rpc, RpcDefinition_d_exports as RpcDefinition, ServiceBinding_d_exports as ServiceBinding, Worker_d_exports as Worker, WorkerConfig, WorkerDefinition_d_exports as WorkerDefinition, type WorkerEnv, WorkerEnvironment, Workflow_d_exports as Workflow, WorkflowBinding_d_exports as WorkflowBinding, WorkflowDefinition_d_exports as WorkflowDefinition };
+export { AiGateway_d_exports as AiGateway, Binding_d_exports as Binding, BrowserRendering_d_exports as BrowserRendering, CloudflareOtlp_d_exports as CloudflareOtlp, 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, Hyperdrive_d_exports as Hyperdrive, Images_d_exports as Images, Kv_d_exports as Kv, Queue_d_exports as Queue, QueueBinding_d_exports as QueueBinding, QueueDefinition_d_exports as QueueDefinition, R2_d_exports as R2, Rpc_d_exports as Rpc, RpcDefinition_d_exports as RpcDefinition, ServiceBinding_d_exports as ServiceBinding, Vectorize_d_exports as Vectorize, 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 };