effect-cf 0.26.0 → 0.28.0

package/dist/index.d.mts

@@ -1,23 +1,20 @@
-import { a as Environment_d_exports, c as WorkerEnvironment, i as Binding_d_exports, n as BindingService, o as WorkerConfig, r as BindingValidationError, s as WorkerEnv, t as BindingNotFoundError } from "./Binding-COCtoJXa.mjs";
-import { a as ArtifactsOperationError, c as ArtifactsTokenListResult, i as ArtifactsCreateTokenResult, l as Artifacts_d_exports, n as ArtifactsCreateOptions, o as ArtifactsRepoInfo, r as ArtifactsCreateRepoResult, s as ArtifactsTokenInfo, t as ArtifactsBinding, u as RepoName } from "./Artifacts-DcoXcRP5.mjs";
-import { t as Hyperdrive_d_exports } from "./Hyperdrive-6p59yyVk.mjs";
-import { A as Rpc_d_exports, C as QueueBinding_d_exports, D as RpcDefinition_d_exports, E as ReservedMethodName$2, M as DurableWebSocket, N as DurableObjectStorage_d_exports, O as ServiceFreeSchema$1, P as StorageOperationError, S as QueueDefinition_d_exports, T as Method$2, _ as AsyncMethodArgs, a as WorkflowInstanceCreateOptions, b as AsyncMethodSuccess, c as DurableObjectState, d as ExecutionContext, f as NativeRequest, g as ServiceBinding_d_exports, h as WorkerDefinition_d_exports, i as WorkflowInstanceCreateBatchOptions, j as DurableObjectWebSocket_d_exports, k as Provider, m as Worker_d_exports, n as WorkflowBinding_d_exports, p as WorkerContext, r as WorkflowInstance, s as WorkflowOperationError, t as WorkflowBindingClient, u as DurableObjectState_d_exports, v as AsyncMethodCloudflareReturn, w as Definition$4, x as Queue_d_exports, y as AsyncMethodKey } from "./WorkflowBinding-D5iWzCUa.mjs";
-import { Config, Context, Data, DateTime, Duration, Effect, Layer, Option, Redacted, Schema, Scope, Stream } from "effect";
+import { a as Environment_d_exports, c as WorkerEnvironment, i as Binding_d_exports, n as BindingService, o as WorkerConfig, r as BindingValidationError, s as WorkerEnv, t as BindingNotFoundError } from "./Binding-xJJJPmiD.mjs";
+import { l as Artifacts_d_exports } from "./Artifacts-DnHQA-Ax.mjs";
+import { C as Rpc_d_exports, D as StorageOperationError, E as DurableObjectStorage_d_exports, S as Provider, T as DurableWebSocket, _ as Definition$4, a as NativeRequest, b as RpcDefinition_d_exports, c as WorkerDefinition_d_exports, d as AsyncMethodCloudflareReturn, f as AsyncMethodKey, g as QueueBinding_d_exports, h as QueueDefinition_d_exports, i as ExecutionContext, l as ServiceBinding_d_exports, m as Queue_d_exports, o as WorkerContext, p as AsyncMethodSuccess, r as DurableObjectState_d_exports, s as Worker_d_exports, t as DurableObjectState, u as AsyncMethodArgs, v as Method$2, w as DurableObjectWebSocket_d_exports, x as ServiceFreeSchema$1, y as ReservedMethodName$2 } from "./DurableObjectState-B3uFY1eM.mjs";
+import { t as Hyperdrive_d_exports } from "./Hyperdrive-z-9fFz15.mjs";
+import { a as WorkflowInstanceCreateOptions, i as WorkflowInstanceCreateBatchOptions, n as WorkflowBinding_d_exports, r as WorkflowInstance, s as WorkflowOperationError, t as WorkflowBindingClient } from "./WorkflowBinding-wZ-yGHow.mjs";
+import { Cause, Config, Context, Data, DateTime, Duration, Effect, Layer, Option, Predicate, Redacted, Schema, Scope } from "effect";
 import { Headers as Headers$1, HttpClient, HttpClientResponse } from "effect/unstable/http";
-import { OtlpExporter } from "effect/unstable/observability";
+import { OtlpExporter, OtlpResource } from "effect/unstable/observability";
 import { D1Client } from "@effect/sql-d1";
 import { DurableObject, WorkflowEntrypoint, WorkflowEvent, WorkflowSleepDuration, WorkflowStep, WorkflowStepConfig, WorkflowStepContext, WorkflowStepEvent, WorkflowTimeoutDuration } from "cloudflare:workers";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 import * as RpcServer from "effect/unstable/rpc/RpcServer";
 import { SqliteClient } from "@effect/sql-sqlite-do";
-import { CommitView, GitClient, GitCloneOptions, GitCommitOptions, GitDiffOptions, GitFetchOptions, GitLogOptions, GitUpdateRefOptions } from "@cloudflare/computer/git";
-import { ExecSyncResult, RuntimeExecOptions, RuntimeGetOptions, RuntimeKillOptions, ShellValue, SkippedEntry, ThinkWorkspaceCompatibility, WorkspaceClient, WorkspaceRuntimeResult, WorkspaceRuntimeValue } from "@cloudflare/computer";
 import { SqlClient } from "effect/unstable/sql";
 import * as Tracer from "effect/Tracer";
-import { ArtifactClient, ArtifactImportOptions, ArtifactImportSource, ArtifactRepoSummary, ArtifactScope, ArtifactsCLIInput, ArtifactsCLIResult, RemoteAddFn } from "@cloudflare/computer/artifacts";
-import { ShareOptions } from "@cloudflare/computer/assets";
 declare namespace WorkersAi_d_exports {
-  export { LayerOptions$14 as LayerOptions, Tag$13 as Tag, TagClass$12 as TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, embeddingResponse, isWorkersAiBinding, layer$14 as layer, make$13 as make, makeClient$12 as makeClient };
+  export { LayerOptions$14 as LayerOptions, Tag$13 as Tag, TagClass$12 as TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, embeddingResponse, isWorkersAiBinding, layer$14 as layer, make$13 as make, makeClient$11 as makeClient };
 }
 declare const WorkersAiOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "WorkersAiOperationError";
@@ -40,10 +37,11 @@ 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>;
+type WorkersAiEmbeddingInput = AiTextEmbeddingsInput | Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Input | Parameters<WorkersAiBinding["run"]>[1];
+declare const embeddingDimensionsKey = "shape";
 interface WorkersAiEmbeddingResponse {
   readonly data: ReadonlyArray<ReadonlyArray<number>>;
-  readonly shape: ReadonlyArray<number>;
+  readonly [embeddingDimensionsKey]: ReadonlyArray<number>;
 }
 interface WorkersAiClient<ModelList extends AiModelListType = AiModels> {
   readonly aiGatewayLogId: Effect.Effect<string | null, WorkersAiOperationError>;
@@ -63,7 +61,7 @@ interface WorkersAiClient<ModelList extends AiModelListType = AiModels> {
       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>;
+    <Input extends Parameters<WorkersAiBinding["run"]>[1], Output = Awaited<ReturnType<WorkersAiBinding["run"]>>>(model: string, input: Input, options?: WorkersAiOptions): Effect.Effect<Output, WorkersAiOperationError>;
   };
   readonly runEmbedding: <Input extends WorkersAiEmbeddingInput>(model: string, input: Input, options?: WorkersAiOptions) => Effect.Effect<WorkersAiEmbeddingResponse, WorkersAiOperationError>;
   readonly models: (params?: WorkersAiModelsSearchParams) => Effect.Effect<ReadonlyArray<WorkersAiModelsSearchObject>, WorkersAiOperationError>;
@@ -85,17 +83,18 @@ interface TagClass$12<Self, Id extends string, ModelList extends AiModelListType
   readonly id: Id;
   readonly layer: (options: LayerOptions$14) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
-declare const isWorkersAiBinding: (value: unknown) => value is WorkersAiBinding;
+type WorkersAiBindingValue = Schema.Schema.Type<typeof Schema.Unknown>;
+declare const isWorkersAiBinding: (value: WorkersAiBindingValue) => value is WorkersAiBinding;
 declare const embeddingResponse: (value: {
   readonly data?: ReadonlyArray<ReadonlyArray<number>>;
-  readonly shape?: ReadonlyArray<number>;
+  readonly [embeddingDimensionsKey]?: ReadonlyArray<number>;
 }) => WorkersAiEmbeddingResponse;
-declare const makeClient$12: <ModelList extends AiModelListType = AiModels>(definition: WorkersAiDefinition) => (ai: WorkersAiBinding<ModelList>) => WorkersAiClient<ModelList>;
+declare const makeClient$11: <ModelList extends AiModelListType = AiModels>(definition: WorkersAiDefinition) => (ai: WorkersAiBinding<ModelList>) => WorkersAiClient<ModelList>;
 declare const layer$14: <Self, ModelList extends AiModelListType = AiModels>(tag: Context.Service<Self, WorkersAiClient<ModelList>>, definition: WorkersAiDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make$13: <Id extends string>(id: Id) => TagClass$12<WorkersAiService<Id>, Id, AiModels>;
 declare const Tag$13: <Self>() => <Id extends string, ModelList extends AiModelListType = AiModels>(id: Id) => TagClass$12<Self, Id, ModelList>;
 declare namespace AiGateway_d_exports {
-  export { AiGatewayBinding, AiGatewayClient, AiGatewayDefinition, AiGatewayFetchOptions, AiGatewayHeaders, AiGatewayLog, AiGatewayOperationError, AiGatewayPatchLog, AiGatewayProvider, AiGatewayRunOptions, AiGatewayService, AiGatewayUniversalRequest, LayerOptions$13 as LayerOptions, Tag$12 as Tag, TagClass$11 as TagClass, isAiGatewayBinding, layer$13 as layer, make$12 as make, makeClient$11 as makeClient, makeClientFromAi, makeHttpClient };
+  export { AiGatewayBinding, AiGatewayClient, AiGatewayDefinition, AiGatewayFetchOptions, AiGatewayHeaders, AiGatewayLog, AiGatewayOperationError, AiGatewayPatchLog, AiGatewayProvider, AiGatewayRunOptions, AiGatewayService, AiGatewayUniversalRequest, LayerOptions$13 as LayerOptions, Tag$12 as Tag, TagClass$11 as TagClass, isAiGatewayBinding, layer$13 as layer, make$12 as make, makeClient$10 as makeClient, makeClientFromAi, makeHttpClient };
 }
 declare const AiGatewayOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "AiGatewayOperationError";
@@ -125,6 +124,7 @@ type AiGatewayProvider = NonNullable<Parameters<AiGatewayBinding["getUrl"]>[0]>;
 type AiGatewayUniversalRequest = Exclude<AiGatewayRunData, ReadonlyArray<unknown>>;
 type AiGatewayHeaders = NonNullable<AiGatewayUniversalRequest["headers"]>;
 type AiGatewayRunOptions = Parameters<CloudflareAiGateway["run"]>[1];
+type AiGatewayBindingCandidate = Parameters<typeof isWorkersAiBinding>[0];
 interface AiGatewayFetchOptions {
   readonly provider?: AiGatewayProvider;
   readonly path?: string;
@@ -155,8 +155,8 @@ interface TagClass$11<Self, Id extends string> extends Context.ServiceClass<Self
   readonly id: Id;
   readonly layer: (options: LayerOptions$13) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError | AiGatewayOperationError, WorkerEnvironment>;
 }
-declare const isAiGatewayBinding: (value: unknown) => value is WorkersAiBinding;
-declare const makeClient$11: (definition: AiGatewayDefinition, gateway: AiGatewayBinding) => {
+declare const isAiGatewayBinding: (value: AiGatewayBindingCandidate) => value is WorkersAiBinding;
+declare const makeClient$10: (definition: AiGatewayDefinition, gateway: AiGatewayBinding) => {
   definition: AiGatewayDefinition;
   run: (data: import("@cloudflare/workers-types").AIGatewayUniversalRequest | readonly import("@cloudflare/workers-types").AIGatewayUniversalRequest[], options?: {
     gateway?: import("@cloudflare/workers-types").UniversalGatewayOptions;
@@ -178,7 +178,7 @@ declare const layer$13: <Self>(tag: Context.Service<Self, AiGatewayClient>, defi
 declare const make$12: <Id extends string>(id: Id) => TagClass$11<AiGatewayService<Id>, Id>;
 declare const Tag$12: <Self>() => <Id extends string>(id: Id) => TagClass$11<Self, Id>;
 declare namespace AnalyticsEngine_d_exports {
-  export { AnalyticsEngineBinding, AnalyticsEngineClient, AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, LayerOptions$12 as LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag$11 as Tag, TagClass$10 as TagClass, isAnalyticsEngineDataset, layer$12 as layer, layerFetch, layerFetchConfig, make$11 as make, makeClient$10 as makeClient, makeQuery, makeQueryClient, queryConfig, queryLayer, queryLayerConfig, writeLimits };
+  export { AnalyticsEngineBinding, AnalyticsEngineClient, AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, LayerOptions$12 as LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag$11 as Tag, TagClass$10 as TagClass, isAnalyticsEngineDataset, layer$12 as layer, layerFetch, layerFetchConfig, make$11 as make, makeClient$9 as makeClient, makeQuery, makeQueryClient, queryConfig, queryLayer, queryLayerConfig, writeLimits };
 }
 declare const writeLimits: {
   readonly maxBlobs: 20;
@@ -327,8 +327,8 @@ interface QueryTagClass<Self, Id extends string> extends Context.ServiceClass<Se
   readonly layerFetchConfig: (config?: Config.Config<AnalyticsEngineQueryDefinition>) => Layer.Layer<Self, Config.ConfigError>;
 }
 declare const makeQueryClient: (definition: AnalyticsEngineQueryDefinition) => Effect.Effect<AnalyticsEngineQueryClient, never, HttpClient.HttpClient>;
-declare const isAnalyticsEngineDataset: (value: unknown) => value is AnalyticsEngineBinding;
-declare const makeClient$10: (definition: AnalyticsEngineDefinition, defaults?: AnalyticsEngineWritePolicy) => (dataset: AnalyticsEngineBinding) => AnalyticsEngineClient;
+declare const isAnalyticsEngineDataset: <Candidate>(value: Candidate) => value is Candidate & AnalyticsEngineBinding;
+declare const makeClient$9: (definition: AnalyticsEngineDefinition, defaults?: AnalyticsEngineWritePolicy) => (dataset: AnalyticsEngineBinding) => AnalyticsEngineClient;
 declare const queryConfig: (options?: QueryConfigOptions) => Config.Config<{
   accountId: string;
   apiToken: Redacted.Redacted<string>;
@@ -344,7 +344,7 @@ declare const makeQuery: <Id extends string>(id: Id) => QueryTagClass<AnalyticsE
 declare const Tag$11: <Self>() => <Id extends string>(id: Id) => TagClass$10<Self, Id>;
 declare const QueryTag: <Self>() => <Id extends string>(id: Id) => QueryTagClass<Self, Id>;
 declare namespace BrowserRendering_d_exports {
-  export { BrowserRenderingBinding, BrowserRenderingBrowserClient, BrowserRenderingBrowserLike, BrowserRenderingClient, BrowserRenderingConnect, BrowserRenderingDefinition, BrowserRenderingLaunch, BrowserRenderingOperationError, BrowserRenderingPageClient, BrowserRenderingPageLike, BrowserRenderingService, LayerOptions$11 as LayerOptions, Tag$10 as Tag, TagClass$9 as TagClass, isBrowserRenderingBinding, layer$11 as layer, make$10 as make, makeClient$9 as makeClient };
+  export { BrowserRenderingBinding, BrowserRenderingBrowserClient, BrowserRenderingBrowserLike, BrowserRenderingClient, BrowserRenderingConnect, BrowserRenderingDefinition, BrowserRenderingExternalResult, BrowserRenderingLaunch, BrowserRenderingMethodOptions, BrowserRenderingOperationError, BrowserRenderingPageClient, BrowserRenderingPageFunction, BrowserRenderingPageLike, BrowserRenderingService, LayerOptions$11 as LayerOptions, Tag$10 as Tag, TagClass$9 as TagClass, isBrowserRenderingBinding, layer$11 as layer, make$10 as make, makeClient$8 as makeClient };
 }
 declare const BrowserRenderingOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "BrowserRenderingOperationError";
@@ -363,6 +363,9 @@ interface BrowserRenderingDefinition {
   readonly binding: string;
 }
 type BrowserRenderingBinding = object;
+interface BrowserRenderingMethodOptions {}
+type BrowserRenderingExternalResult = Awaited<ReturnType<Response["json"]>>;
+type BrowserRenderingPageFunction = string | Function;
 type BrowserRenderingLaunch<RawBinding, Browser, LaunchOptions = unknown> = (binding: RawBinding, options?: LaunchOptions) => Promise<Browser>;
 type BrowserRenderingConnect<RawBinding, Browser, ConnectOptions = unknown> = (binding: RawBinding, options?: ConnectOptions) => Promise<Browser>;
 interface BrowserRenderingBrowserLike<Page = BrowserRenderingPageLike> {
@@ -372,22 +375,22 @@ interface BrowserRenderingBrowserLike<Page = BrowserRenderingPageLike> {
   readonly version?: () => Promise<string>;
 }
 interface BrowserRenderingPageLike {
-  readonly goto?: (url: string, options?: unknown) => Promise<unknown>;
-  readonly setContent?: (html: string, options?: unknown) => Promise<void>;
+  readonly goto?: (url: string, options?: BrowserRenderingMethodOptions) => Promise<BrowserRenderingExternalResult>;
+  readonly setContent?: (html: string, options?: BrowserRenderingMethodOptions) => 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>;
+  readonly screenshot?: (options?: BrowserRenderingMethodOptions) => Promise<Uint8Array | string>;
+  readonly pdf?: (options?: BrowserRenderingMethodOptions) => Promise<Uint8Array>;
+  readonly evaluate?: (pageFunction: BrowserRenderingPageFunction, ...args: ReadonlyArray<unknown>) => Promise<BrowserRenderingExternalResult>;
+  readonly close?: (options?: BrowserRenderingMethodOptions) => Promise<void>;
 }
 interface BrowserRenderingPageClient<Page extends BrowserRenderingPageLike> {
   readonly raw: Page;
   readonly goto: (url: string, options?: Parameters<NonNullable<Page["goto"]>>[1]) => Effect.Effect<Awaited<ReturnType<NonNullable<Page["goto"]>>>, BrowserRenderingOperationError>;
   readonly setContent: (html: string, options?: Parameters<NonNullable<Page["setContent"]>>[1]) => Effect.Effect<void, BrowserRenderingOperationError>;
   readonly content: Effect.Effect<string, BrowserRenderingOperationError>;
-  readonly screenshot: <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 screenshot: (options?: Parameters<NonNullable<Page["screenshot"]>>[0]) => Effect.Effect<Awaited<ReturnType<NonNullable<Page["screenshot"]>>>, BrowserRenderingOperationError>;
+  readonly pdf: (options?: Parameters<NonNullable<Page["pdf"]>>[0]) => Effect.Effect<Awaited<ReturnType<NonNullable<Page["pdf"]>>>, BrowserRenderingOperationError>;
+  readonly evaluate: (pageFunction: Parameters<NonNullable<Page["evaluate"]>>[0], ...args: ReadonlyArray<unknown>) => Effect.Effect<Awaited<ReturnType<NonNullable<Page["evaluate"]>>>, BrowserRenderingOperationError>;
   readonly close: (options?: Parameters<NonNullable<Page["close"]>>[0]) => Effect.Effect<void, BrowserRenderingOperationError>;
 }
 interface BrowserRenderingBrowserClient<Browser extends BrowserRenderingBrowserLike<Page>, Page extends BrowserRenderingPageLike> {
@@ -417,13 +420,13 @@ interface TagClass$9<Self, Id extends string> extends Context.ServiceClass<Self,
   readonly id: Id;
   readonly layer: (options: LayerOptions$11) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
-declare const isBrowserRenderingBinding: (value: unknown) => value is BrowserRenderingBinding;
-declare const makeClient$9: <RawBinding extends BrowserRenderingBinding = BrowserRenderingBinding>(definition: BrowserRenderingDefinition) => (binding: RawBinding) => BrowserRenderingClient<RawBinding>;
+declare const isBrowserRenderingBinding: <Candidate>(value: Candidate) => value is Candidate & 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$10: <Id extends string>(id: Id) => TagClass$9<BrowserRenderingService<Id>, Id>;
 declare const Tag$10: <Self>() => <Id extends string>(id: Id) => TagClass$9<Self, Id>;
 declare namespace Cache_d_exports {
-  export { CacheClient, CacheOperation, CacheOperationError, CacheQueryOptions, CacheRequest, CacheStorage, CacheStorageClient, layer$10 as layer, layerFrom, makeCacheClient, makeClient$8 as makeClient };
+  export { CacheClient, CacheOperation, CacheOperationError, CacheQueryOptions, CacheRequest, CacheStorage, CacheStorageClient, layer$10 as layer, layerFrom, makeCacheClient, makeClient$7 as makeClient };
 }
 /** Request key accepted by Cloudflare's Cache API. */
 type CacheRequest = CloudflareRequestInfo | URL;
@@ -470,7 +473,7 @@ declare class CacheStorage extends CacheStorage_base {}
 /** Wraps a native Cloudflare `Cache` instance. */
 declare const makeCacheClient: (cache: CloudflareCache, name?: string) => CacheClient;
 /** Wraps a native Cloudflare `CacheStorage` instance. */
-declare const makeClient$8: (storage: CloudflareCacheStorage) => CacheStorageClient;
+declare const makeClient$7: (storage: CloudflareCacheStorage) => CacheStorageClient;
 /** Provides Cache API services from an explicit native `CacheStorage` instance. */
 declare const layerFrom: (storage: CloudflareCacheStorage) => Layer.Layer<CacheStorage>;
 /** Provides Cache API services from Cloudflare's global `caches` object. */
@@ -478,6 +481,7 @@ declare const layer$10: Layer.Layer<CacheStorage>;
 declare namespace CloudflareOtlp_d_exports {
   export { DurableObjectLayerOptions, LayerOptions$10 as LayerOptions, ResourceOptions, Serialization, Signal, WorkerLayerOptions, layer$9 as layer, layerDurableObject, layerJson, layerProtobuf, layerWorker };
 }
+type ResourceAttributes = NonNullable<Parameters<typeof OtlpResource.make>[0]["attributes"]>;
 /** Telemetry signal groups supported by the Cloudflare OTLP layers. */
 type Signal = "logs" | "traces" | "metrics";
 /** OTLP payload serialization used by the Effect OTLP exporters. */
@@ -497,7 +501,7 @@ interface ResourceOptions {
   /** Explicit service version. Takes precedence over OTEL environment variables. */
   readonly serviceVersion?: string;
   /** Additional resource attributes attached to exported telemetry. */
-  readonly attributes?: Record<string, unknown>;
+  readonly attributes?: ResourceAttributes;
 }
 /** Options shared by all Cloudflare OTLP telemetry layers. */
 interface LayerOptions$10 {
@@ -573,331 +577,6 @@ declare const layerWorker: (options?: WorkerLayerOptions) => Layer.Layer<OtlpExp
  * backend can tolerate high-cardinality resource attributes.
  */
 declare const layerDurableObject: (options?: DurableObjectLayerOptions) => Layer.Layer<OtlpExporter.Flusher, never, DurableObjectState>;
-declare namespace ComputerArtifacts_d_exports {
-  export { ComputerArtifactImportOptions, ComputerArtifactImportSource, ComputerArtifactRepoSummary, ComputerArtifactScope, ComputerArtifactsCliInput, ComputerArtifactsCliResult, ComputerArtifactsClient, ComputerArtifactsClientOptions, ComputerArtifactsRemoteAdd, fromClient, makeClient$7 as makeClient };
-}
-/** External Git source accepted by a session-scoped repository import. */
-type ComputerArtifactImportSource = Readonly<ArtifactImportSource>;
-/** Target options accepted by a session-scoped repository import. */
-type ComputerArtifactImportOptions = Readonly<ArtifactImportOptions>;
-/** Repository metadata returned by a session-scoped list operation. */
-type ComputerArtifactRepoSummary = Readonly<ArtifactRepoSummary>;
-/** Token scope accepted by the upstream session facade. */
-type ComputerArtifactScope = ArtifactScope;
-/** Optional Git remote-registration seam accepted by the argv API. */
-type ComputerArtifactsRemoteAdd = RemoteAddFn;
-/** Input to the session-scoped `artifacts` argv API. */
-type ComputerArtifactsCliInput = ArtifactsCLIInput;
-/** Result from the session-scoped `artifacts` argv API. */
-type ComputerArtifactsCliResult = Readonly<ArtifactsCLIResult>;
-/** Options used when wrapping a session-scoped Artifacts client. */
-interface ComputerArtifactsClientOptions {
-  /** Binding name attached to errors and tracing spans. Defaults to `ARTIFACTS`. */
-  readonly binding?: string;
-}
-/**
- * Effect-native facade over `@cloudflare/computer/artifacts`.
- *
- * Repository names are local to {@link sessionId}. Prefixing and filtering are
- * intentionally delegated to the upstream `createArtifact` implementation so
- * this client and the worker-shell `artifacts` command always use the same
- * namespace convention.
- */
-interface ComputerArtifactsClient {
-  readonly sessionId: string;
-  readonly create: (name: RepoName, options?: ArtifactsCreateOptions) => Effect.Effect<ArtifactsCreateRepoResult, ArtifactsOperationError>;
-  readonly get: (name: RepoName) => Effect.Effect<ArtifactsRepoInfo, ArtifactsOperationError>;
-  readonly list: Effect.Effect<ReadonlyArray<ComputerArtifactRepoSummary>, ArtifactsOperationError>;
-  readonly import: (name: RepoName, source: ComputerArtifactImportSource, options?: ComputerArtifactImportOptions) => Effect.Effect<ArtifactsCreateRepoResult, ArtifactsOperationError>;
-  readonly delete: (name: RepoName) => Effect.Effect<boolean, ArtifactsOperationError>;
-  readonly createToken: (name: RepoName, scope?: ComputerArtifactScope, ttl?: number) => Effect.Effect<ArtifactsCreateTokenResult, ArtifactsOperationError>;
-  readonly listTokens: (name: RepoName) => Effect.Effect<ArtifactsTokenListResult, ArtifactsOperationError>;
-  readonly getToken: (name: RepoName, id: string) => Effect.Effect<ArtifactsTokenInfo, ArtifactsOperationError>;
-  readonly revokeToken: (name: RepoName, tokenOrId: string) => Effect.Effect<boolean, ArtifactsOperationError>;
-  readonly cli: (input: ComputerArtifactsCliInput) => Effect.Effect<ComputerArtifactsCliResult, ArtifactsOperationError>;
-  readonly rawUnsafe: Effect.Effect<ArtifactClient>;
-}
-/** Wraps an already-created upstream session client. */
-declare const fromClient: (client: ArtifactClient, options?: ComputerArtifactsClientOptions) => ComputerArtifactsClient;
-/**
- * Creates an Effect-native session client directly from a Worker Artifacts
- * binding. `@cloudflare/computer` is loaded only when this Effect runs, keeping
- * the optional peer out of applications that do not use this integration.
- */
-declare const makeClient$7: (bindingValue: ArtifactsBinding, sessionId: string, options?: ComputerArtifactsClientOptions | undefined) => Effect.Effect<ComputerArtifactsClient, ArtifactsOperationError, never>;
-declare namespace ComputerWorkspace_d_exports {
-  export { ComputerWorkspace, ComputerWorkspaceAssets, ComputerWorkspaceFilesystem, ComputerWorkspaceGit, ComputerWorkspaceRuntime, ComputerWorkspaceShape, ComputerWorkspaceThink, ListDirectoryOptions, ReadTextFileOptions, RemovePathOptions, WorkspaceAssetsError, WorkspaceDirectoryEntry, WorkspaceEntryStat, WorkspaceExec, WorkspaceExecChunk, WorkspaceExecCollect, WorkspaceExecEncoding, WorkspaceExecError, WorkspaceExecEvent, WorkspaceExecOptions, WorkspaceExecResult, WorkspaceExecRun, WorkspaceExecSignal, WorkspaceExecSkippedEntry, WorkspaceExecSyncResult, WorkspaceFindOptions, WorkspaceFoundEntry, WorkspaceFsError, WorkspaceGetExec, WorkspaceGetExecOptions, WorkspaceGitCheckoutOptions, WorkspaceGitCloneOptions, WorkspaceGitCommit, WorkspaceGitCommitOptions, WorkspaceGitDiffOptions, WorkspaceGitError, WorkspaceGitFetchOptions, WorkspaceGitFetchResult, WorkspaceGitLogOptions, WorkspaceGitPerson, WorkspaceGitUpdateRefOptions, WorkspaceGrepMatch, WorkspaceGrepOptions, WorkspaceMkdirOptions, WorkspaceReadEncoding, WorkspaceReadFile, WorkspaceReadFileOptions, WorkspaceRuntimeValue$1 as WorkspaceRuntimeValue, WorkspaceWriteFileContent, WorkspaceWriteFileOptions, fromWorkspaceClient };
-}
-type CloudflareWorkspaceFilesystem = WorkspaceClient["fs"];
-type CloudflareReadFileOptions = Parameters<CloudflareWorkspaceFilesystem["readFile"]>[1];
-type CloudflareReaddirOptions = Parameters<CloudflareWorkspaceFilesystem["readdir"]>[1];
-type CloudflareFindOptions = Parameters<CloudflareWorkspaceFilesystem["find"]>[2];
-type CloudflareGrepOptions = Parameters<CloudflareWorkspaceFilesystem["grep"]>[2];
-type CloudflareRmOptions = Parameters<CloudflareWorkspaceFilesystem["rm"]>[1];
-type CloudflareMkdirOptions = Parameters<CloudflareWorkspaceFilesystem["mkdir"]>[1];
-type CloudflareWriteFileContent = Parameters<CloudflareWorkspaceFilesystem["writeFile"]>[1];
-type CloudflareWriteFileOptions = Parameters<CloudflareWorkspaceFilesystem["writeFile"]>[2];
-type CloudflareWorkspaceDirentResult = Awaited<ReturnType<CloudflareWorkspaceFilesystem["readdir"]>>[number];
-type CloudflareWorkspaceStatResult = Awaited<ReturnType<CloudflareWorkspaceFilesystem["stat"]>>;
-type CloudflareWorkspaceFoundEntry = Awaited<ReturnType<CloudflareWorkspaceFilesystem["find"]>>[number];
-type CloudflareWorkspaceGrepMatch = Awaited<ReturnType<CloudflareWorkspaceFilesystem["grep"]>>[number];
-declare const WorkspaceFsError_base: Schema.Class<WorkspaceFsError, Schema.TaggedStruct<"WorkspaceFsError", {
-  readonly operation: Schema.String;
-  readonly path: Schema.String;
-  readonly message: Schema.String;
-  readonly code: Schema.optionalKey<Schema.String>;
-  readonly cause: Schema.optionalKey<Schema.Defect>;
-}>, import("effect/Cause").YieldableError>;
-/**
- * Workspace errors use `Schema.TaggedError`, unlike most local binding errors,
- * because workspace operations commonly sit behind Durable Object RPC methods.
- * The schema form preserves the operation-family tags across that boundary.
- */
-declare class WorkspaceFsError extends WorkspaceFsError_base {}
-declare const WorkspaceGitError_base: Schema.Class<WorkspaceGitError, Schema.TaggedStruct<"WorkspaceGitError", {
-  readonly operation: Schema.String;
-  readonly message: Schema.String;
-  readonly code: Schema.optionalKey<Schema.String>;
-  readonly cause: Schema.optionalKey<Schema.Defect>;
-}>, import("effect/Cause").YieldableError>;
-/** Schema-serializable error for a workspace Git operation. */
-declare class WorkspaceGitError extends WorkspaceGitError_base {}
-declare const WorkspaceExecError_base: Schema.Class<WorkspaceExecError, Schema.TaggedStruct<"WorkspaceExecError", {
-  readonly operation: Schema.String;
-  readonly message: Schema.String;
-  readonly code: Schema.optionalKey<Schema.String>;
-  readonly cause: Schema.optionalKey<Schema.Defect>;
-}>, import("effect/Cause").YieldableError>;
-/** Schema-serializable error for a workspace runtime operation. */
-declare class WorkspaceExecError extends WorkspaceExecError_base {}
-declare const WorkspaceAssetsError_base: Schema.Class<WorkspaceAssetsError, Schema.TaggedStruct<"WorkspaceAssetsError", {
-  readonly operation: Schema.String;
-  readonly path: Schema.String;
-  readonly message: Schema.String;
-  readonly code: Schema.optionalKey<Schema.String>;
-  readonly cause: Schema.optionalKey<Schema.Defect>;
-}>, import("effect/Cause").YieldableError>;
-/** Schema-serializable error for a workspace Assets operation. */
-declare class WorkspaceAssetsError extends WorkspaceAssetsError_base {}
-type WorkspaceReadFileOptions = Omit<CloudflareReadFileOptions, "encoding">;
-type ReadTextFileOptions = WorkspaceReadFileOptions;
-type ListDirectoryOptions = CloudflareReaddirOptions;
-type WorkspaceDirectoryEntry = CloudflareWorkspaceDirentResult;
-type WorkspaceEntryStat = CloudflareWorkspaceStatResult;
-type WorkspaceFindOptions = CloudflareFindOptions;
-type WorkspaceFoundEntry = CloudflareWorkspaceFoundEntry;
-type WorkspaceGrepOptions = CloudflareGrepOptions;
-type WorkspaceGrepMatch = CloudflareWorkspaceGrepMatch;
-type RemovePathOptions = CloudflareRmOptions;
-type WorkspaceMkdirOptions = CloudflareMkdirOptions;
-type WorkspaceWriteFileContent = CloudflareWriteFileContent;
-type WorkspaceWriteFileOptions = CloudflareWriteFileOptions;
-/** Explicit read mode. Text remains the default for consumer-port compatibility. */
-type WorkspaceReadEncoding = "utf8" | "stream";
-interface WorkspaceReadFile {
-  (path: string, options?: WorkspaceReadFileOptions & {
-    readonly encoding?: "utf8";
-  }): Effect.Effect<string, WorkspaceFsError>;
-  (path: string, options: WorkspaceReadFileOptions & {
-    readonly encoding: "stream";
-  }): Effect.Effect<ReadableStream<Uint8Array>, WorkspaceFsError>;
-}
-/** Complete Effect wrapper of `WorkspaceClient.fs`. */
-interface ComputerWorkspaceFilesystem {
-  readonly readFile: WorkspaceReadFile;
-  readonly stat: (path: string) => Effect.Effect<WorkspaceEntryStat, WorkspaceFsError>;
-  readonly lstat: (path: string) => Effect.Effect<WorkspaceEntryStat, WorkspaceFsError>;
-  readonly exists: (path: string) => Effect.Effect<boolean, WorkspaceFsError>;
-  readonly readlink: (path: string) => Effect.Effect<string, WorkspaceFsError>;
-  readonly readdir: (path: string, options?: ListDirectoryOptions) => Effect.Effect<ReadonlyArray<WorkspaceDirectoryEntry>, WorkspaceFsError>;
-  readonly find: (directory: string, pattern?: string, options?: WorkspaceFindOptions) => Effect.Effect<ReadonlyArray<WorkspaceFoundEntry>, WorkspaceFsError>;
-  readonly ls: (prefix: string) => Effect.Effect<ReadonlyArray<string>, WorkspaceFsError>;
-  readonly grep: (pattern: string, path: string, options?: WorkspaceGrepOptions) => Effect.Effect<ReadonlyArray<WorkspaceGrepMatch>, WorkspaceFsError>;
-  readonly writeFile: (path: string, content: WorkspaceWriteFileContent, options?: WorkspaceWriteFileOptions) => Effect.Effect<void, WorkspaceFsError>;
-  readonly mkdir: (path: string, options?: WorkspaceMkdirOptions) => Effect.Effect<void, WorkspaceFsError>;
-  readonly rm: (path: string, options?: RemovePathOptions) => Effect.Effect<void, WorkspaceFsError>;
-  readonly chmod: (path: string, mode: number) => Effect.Effect<void, WorkspaceFsError>;
-  readonly symlink: (target: string, path: string) => Effect.Effect<void, WorkspaceFsError>;
-}
-type WorkspaceGitCloneOptions = GitCloneOptions;
-type WorkspaceGitFetchOptions = GitFetchOptions;
-type WorkspaceGitFetchResult = Awaited<ReturnType<GitClient["fetch"]>>;
-type WorkspaceGitCheckoutOptions = Parameters<GitClient["checkout"]>[0];
-type WorkspaceGitUpdateRefOptions = GitUpdateRefOptions;
-type WorkspaceGitDiffOptions = GitDiffOptions;
-type WorkspaceGitCommitOptions = GitCommitOptions;
-interface WorkspaceGitLogOptions extends Omit<GitLogOptions, "depth"> {
-  /** Preferred upstream name for the history bound. */
-  readonly depth?: number;
-  /** Consumer-port compatibility alias for `depth`. */
-  readonly maxCount?: number;
-}
-type WorkspaceGitPerson = CommitView["author"] & {
-  /** Consumer-port compatibility alias for `timestamp`. */
-  readonly timestampSeconds: number;
-};
-interface WorkspaceGitCommit {
-  readonly oid: string;
-  readonly message: string;
-  readonly tree: string;
-  readonly parent: ReadonlyArray<string>;
-  /** Consumer-port compatibility alias for `parent`. */
-  readonly parents: ReadonlyArray<string>;
-  readonly author: WorkspaceGitPerson;
-  readonly committer: WorkspaceGitPerson;
-}
-type EffectGitMethod<Method> = Method extends ((...args: infer Args) => Promise<infer Success>) ? (...args: Args) => Effect.Effect<Success, WorkspaceGitError> : never;
-type EffectGitClient = { readonly [Name in keyof GitClient]: EffectGitMethod<GitClient[Name]>; };
-/** Complete Effect wrapper of the `@cloudflare/computer/git` client. */
-type ComputerWorkspaceGit = Omit<EffectGitClient, "log" | "revParse"> & {
-  readonly log: (options?: WorkspaceGitLogOptions) => Effect.Effect<ReadonlyArray<WorkspaceGitCommit>, WorkspaceGitError>;
-  readonly revParse: {
-    (ref: string): Effect.Effect<string, WorkspaceGitError>;
-    (options: Parameters<GitClient["revParse"]>[0]): Effect.Effect<string, WorkspaceGitError>;
-  };
-};
-type WorkspaceExecSignal = NonNullable<RuntimeKillOptions["signal"]>;
-type WorkspaceRuntimeValue$1 = WorkspaceRuntimeValue;
-type WorkspaceExecEncoding = "utf8" | "binary";
-type WorkspaceExecSyncResult = ExecSyncResult;
-type WorkspaceExecSkippedEntry = SkippedEntry;
-type CloudflareEncoding<Encoding extends WorkspaceExecEncoding> = Encoding extends "utf8" ? "utf8" : undefined;
-type WorkspaceExecChunk<Encoding extends WorkspaceExecEncoding> = Encoding extends "utf8" ? string : Uint8Array;
-type WorkspaceExecOptions<Encoding extends WorkspaceExecEncoding = "utf8"> = Omit<RuntimeExecOptions, "encoding" | "timeoutMs"> & {
-  readonly encoding?: Encoding;
-  /** Upstream runtime option name. */
-  readonly timeoutMs?: number;
-  /** Consumer-port compatibility alias for `timeoutMs`. */
-  readonly timeoutMillis?: number;
-};
-type WorkspaceGetExecOptions<Encoding extends WorkspaceExecEncoding = "utf8"> = Omit<RuntimeGetOptions, "encoding"> & {
-  readonly encoding?: Encoding;
-};
-type WorkspaceExecEvent<Encoding extends WorkspaceExecEncoding = "utf8"> = ({
-  readonly _tag: "Stdout";
-  readonly id: string;
-  readonly sequence: number;
-  readonly chunk: WorkspaceExecChunk<Encoding>;
-} & (Encoding extends "utf8" ? {
-  readonly text: string;
-} : {
-  readonly bytes: Uint8Array;
-})) | ({
-  readonly _tag: "Stderr";
-  readonly id: string;
-  readonly sequence: number;
-  readonly chunk: WorkspaceExecChunk<Encoding>;
-} & (Encoding extends "utf8" ? {
-  readonly text: string;
-} : {
-  readonly bytes: Uint8Array;
-})) | {
-  readonly _tag: "Exit";
-  readonly id: string;
-  readonly sequence: number;
-  readonly exitCode: number;
-  readonly value?: WorkspaceRuntimeValue$1;
-};
-interface WorkspaceExecResult<Encoding extends WorkspaceExecEncoding = "utf8"> {
-  readonly status: WorkspaceRuntimeResult<CloudflareEncoding<Encoding>>["status"];
-  readonly exitCode: number;
-  readonly stdout: WorkspaceExecChunk<Encoding>;
-  readonly stderr: WorkspaceExecChunk<Encoding>;
-  readonly value?: WorkspaceRuntimeValue$1;
-  readonly pushed: number;
-  readonly pulled: number;
-  readonly skipped: ReadonlyArray<WorkspaceExecSkippedEntry>;
-  readonly sync: WorkspaceExecSyncResult;
-}
-interface WorkspaceExecRun<Encoding extends WorkspaceExecEncoding = "utf8"> {
-  readonly id: string;
-  readonly backend: string;
-  /**
-   * Live output. Like the upstream handle, `events` and `result` are mutually
-   * exclusive consumers of a run.
-   */
-  readonly events: Stream.Stream<WorkspaceExecEvent<Encoding>, WorkspaceExecError>;
-  readonly result: Effect.Effect<WorkspaceExecResult<Encoding>, WorkspaceExecError>;
-  readonly kill: (signal?: WorkspaceExecSignal) => Effect.Effect<void, WorkspaceExecError>;
-}
-interface WorkspaceExec {
-  (strings: TemplateStringsArray, ...values: Array<ShellValue>): Effect.Effect<WorkspaceExecRun<"utf8">, WorkspaceExecError, Scope.Scope>;
-  (command: string, options?: WorkspaceExecOptions<"utf8">): Effect.Effect<WorkspaceExecRun<"utf8">, WorkspaceExecError, Scope.Scope>;
-  (command: string, options: WorkspaceExecOptions<"binary">): Effect.Effect<WorkspaceExecRun<"binary">, WorkspaceExecError, Scope.Scope>;
-}
-interface WorkspaceGetExec {
-  (id: string, options?: WorkspaceGetExecOptions<"utf8">): Effect.Effect<WorkspaceExecRun<"utf8">, WorkspaceExecError, Scope.Scope>;
-  (id: string, options: WorkspaceGetExecOptions<"binary">): Effect.Effect<WorkspaceExecRun<"binary">, WorkspaceExecError, Scope.Scope>;
-}
-interface WorkspaceExecCollect {
-  (strings: TemplateStringsArray, ...values: Array<ShellValue>): Effect.Effect<WorkspaceExecResult<"utf8">, WorkspaceExecError>;
-  (command: string, options?: WorkspaceExecOptions<"utf8">): Effect.Effect<WorkspaceExecResult<"utf8">, WorkspaceExecError>;
-  (command: string, options: WorkspaceExecOptions<"binary">): Effect.Effect<WorkspaceExecResult<"binary">, WorkspaceExecError>;
-}
-/** Complete Effect wrapper of `WorkspaceClient.runtime`. */
-interface ComputerWorkspaceRuntime {
-  readonly exec: WorkspaceExec;
-  readonly execCollect: WorkspaceExecCollect;
-  readonly getExec: WorkspaceGetExec;
-  readonly killExec: (id: string, options?: RuntimeKillOptions) => Effect.Effect<void, WorkspaceExecError>;
-  readonly disposeExec: (id: string, options?: {
-    readonly backend?: string;
-  }) => Effect.Effect<void, WorkspaceExecError>;
-}
-/** Effect wrapper over a configured local `Workspace.assets` client. */
-interface ComputerWorkspaceAssets {
-  readonly share: (path: string, options: ShareOptions) => Effect.Effect<string, WorkspaceAssetsError>;
-}
-type EffectThinkMethod<Method> = Method extends ((...args: infer Args) => Promise<infer Success>) ? (...args: Args) => Effect.Effect<Success, WorkspaceFsError> : never;
-/** Effect wrapper of the optional Think compatibility surface. */
-type ComputerWorkspaceThink = { readonly [Name in keyof ThinkWorkspaceCompatibility]: EffectThinkMethod<ThinkWorkspaceCompatibility[Name]>; };
-/** Effect service over every client surface exposed by Cloudflare Computer. */
-interface ComputerWorkspaceShape {
-  readonly fs: ComputerWorkspaceFilesystem;
-  readonly git: ComputerWorkspaceGit;
-  readonly runtime: ComputerWorkspaceRuntime;
-  readonly artifacts: ComputerArtifactsClient;
-  readonly assets: ComputerWorkspaceAssets | undefined;
-  readonly think: ComputerWorkspaceThink | undefined;
-  /** Flat filesystem aliases retained for mechanical consumer migration. */
-  readonly readFile: WorkspaceReadFile;
-  readonly stat: ComputerWorkspaceFilesystem["stat"];
-  readonly lstat: ComputerWorkspaceFilesystem["lstat"];
-  readonly exists: ComputerWorkspaceFilesystem["exists"];
-  readonly readlink: ComputerWorkspaceFilesystem["readlink"];
-  readonly readdir: ComputerWorkspaceFilesystem["readdir"];
-  readonly listDirectory: ComputerWorkspaceFilesystem["readdir"];
-  readonly find: ComputerWorkspaceFilesystem["find"];
-  readonly ls: ComputerWorkspaceFilesystem["ls"];
-  readonly grep: ComputerWorkspaceFilesystem["grep"];
-  readonly writeFile: ComputerWorkspaceFilesystem["writeFile"];
-  readonly mkdir: ComputerWorkspaceFilesystem["mkdir"];
-  readonly rm: ComputerWorkspaceFilesystem["rm"];
-  readonly removePath: ComputerWorkspaceFilesystem["rm"];
-  readonly chmod: ComputerWorkspaceFilesystem["chmod"];
-  readonly symlink: ComputerWorkspaceFilesystem["symlink"];
-  /** Flat runtime aliases retained for mechanical consumer migration. */
-  readonly exec: WorkspaceExec;
-  readonly execCollect: WorkspaceExecCollect;
-  readonly getExec: WorkspaceGetExec;
-  readonly killExec: ComputerWorkspaceRuntime["killExec"];
-  readonly disposeExec: ComputerWorkspaceRuntime["disposeExec"];
-}
-/**
- * Wraps a client whose lifetime is owned by the caller. Prefer
- * {@link ComputerWorkspace.layer} in Durable Objects so the parent client and
- * every runtime handle are disposed by Effect `Scope`.
- */
-declare const fromWorkspaceClient: (client: WorkspaceClient) => ComputerWorkspaceShape;
-declare const ComputerWorkspace_base: Context.ServiceClass<ComputerWorkspace, "effect-cf/ComputerWorkspace", ComputerWorkspaceShape>;
-/** Effect service for the workspace owned by the enclosing Durable Object. */
-declare class ComputerWorkspace extends ComputerWorkspace_base {
-  /**
-   * Acquires the single workspace registered by `withComputerWorkspace` and
-   * releases its RPC client when the layer scope closes.
-   */
-  static readonly layer: Layer.Layer<ComputerWorkspace, never, DurableObjectState>;
-}
 declare namespace ContainerNamespace_d_exports {
   export { ContainerInstanceClient, ContainerNamespace, ContainerNamespaceClient, ContainerNamespaceDefinition, ContainerNamespaceResource, ContainerNamespaceService, ContainerNamespaceStaticClient, ContainerOperationError, ContainerReadinessOptions, ContainerSignal, ContainerStartAndWaitForPortsOptions, ContainerStartOptions, ContainerState, ContainerStopSignal, ContainerStub, ContainerStubOf, ContainerWaitOptions, LayerOptions$9 as LayerOptions, Tag$9 as Tag, TagClass$8 as TagClass, isContainerNamespaceResource, layer$8 as layer, make$9 as make, makeClient$6 as makeClient };
 }
@@ -1035,7 +714,7 @@ interface TagClass$8<Self, Id extends string, Namespace extends ContainerNamespa
   readonly id: Id;
   readonly layer: (options: LayerOptions$9) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
-declare const isContainerNamespaceResource: (value: unknown) => value is ContainerNamespaceResource;
+declare const isContainerNamespaceResource: <Candidate>(value: Candidate) => value is Candidate & ContainerNamespaceResource;
 declare const makeClient$6: (definition: ContainerNamespaceDefinition) => <Namespace extends ContainerNamespaceResource>(namespace: Namespace) => ContainerNamespaceClient<Namespace>;
 declare const layer$8: <Self, Namespace extends ContainerNamespaceResource>(tag: Context.Service<Self, ContainerNamespaceClient<Namespace>>, definition: ContainerNamespaceDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make$9: <Id extends string>(id: Id) => TagClass$8<ContainerNamespaceService<Id>, Id, ContainerNamespaceResource>;
@@ -1102,8 +781,9 @@ declare namespace DurableObjectNamespace_d_exports {
 interface DurableObjectFetcher {
   fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
 }
-type RpcClient<Api> = { readonly [Key in keyof Api as Key extends string ? Api[Key] extends ((...args: Array<any>) => unknown) ? Key : never : never]: Api[Key]; };
+type RpcClient<Api> = { readonly [Key in keyof Api as Key extends string ? Api[Key] extends ((...args: Array<any>) => any) ? Key : never : never]: Api[Key]; };
 type ReservedMethodName$1 = ReservedMethodName | "fetch";
+type NamespaceCandidate = Parameters<typeof Predicate.isUnknown>[0];
 /**
  * Cloudflare Durable Object stub, optionally enriched with RPC methods.
  */
@@ -1304,7 +984,7 @@ type DurableObjectNamespaceStaticClient<R, Api extends object, Definition extend
   readonly scopedCall: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, unknown, Scope.Scope | R>;
   readonly rawUnsafe: () => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
 };
-declare const isDurableObjectNamespaceClient: <Api extends object>(value: unknown) => value is DurableObjectNamespaceClient<Api>;
+declare const isDurableObjectNamespaceClient: <Api extends object>(value: NamespaceCandidate) => value is DurableObjectNamespaceClient<Api>;
 declare const makeClient$5: <Api extends object, const Definition extends Definition$3.Any | undefined = undefined>(definition: DurableObjectNamespaceBindingDefinition<Definition>) => ((namespace: DurableObjectNamespaceClient<Api>) => DurableObjectNamespaceEffectClient<Api, Definition>);
 declare const layer$7: <Self, Api extends object, const Definition extends Definition$3.Any | undefined = undefined>(tag: Context.Service<Self, DurableObjectNamespaceEffectClient<Api, Definition>>, definition: DurableObjectNamespaceBindingDefinition<Definition>) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const makeDirectMethods: <R, Api extends object, Definition extends Definition$3.Any | undefined>(rpcDefinition: Definition | undefined, helpers: {
@@ -1329,22 +1009,22 @@ declare namespace Method$1 {
   export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
   export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
   export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
-  export type EncodedSuccess<Self extends Any> = Schema.Json;
+  export type EncodedSuccess<_Self extends Any> = Schema.Json;
   export {};
 }
 type Methods = Record<string, Method$1.Any>;
 /**
  * RPC contract for a Durable Object class.
  */
-interface Definition$3<Id extends string = string, MethodsShape extends Methods = Methods> {
+interface Definition$3<Id extends string = string, MethodDefinitions extends Methods = Methods> {
   readonly id: Id;
-  readonly methods: MethodsShape;
+  readonly methods: MethodDefinitions;
 }
 declare namespace Definition$3 {
   type Any = Definition$3<string, Methods>;
 }
 type ReservedMethodName = ReservedMethodName$2 | "fetch" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError";
-type NoReservedMethods<MethodsShape extends Methods> = Extract<keyof MethodsShape, ReservedMethodName> extends never ? MethodsShape : never;
+type NoReservedMethods<MethodDefinitions extends Methods> = Extract<keyof MethodDefinitions, ReservedMethodName> extends never ? MethodDefinitions : never;
 /**
  * Promise-based client API derived from a Durable Object definition.
  */
@@ -1363,26 +1043,24 @@ interface Options$2<ROut, Self extends Definition$3.Any, REvent = never, EventLa
 type LayerOptions$8 = {
   readonly binding: string;
 };
-type TagClass$7<Self, Id extends string, MethodsShape extends Methods> = Context.ServiceClass<Self, `effect-cf/DurableObject/${Id}`, DurableObjectNamespaceEffectClient<Api<Definition$3<Id, MethodsShape>>, Definition$3<Id, MethodsShape>>> & DurableObjectNamespaceStaticClient<Self, Api<Definition$3<Id, MethodsShape>>, Definition$3<Id, MethodsShape>> & {
+type TagClass$7<Self, Id extends string, MethodDefinitions extends Methods> = Context.ServiceClass<Self, `effect-cf/DurableObject/${Id}`, DurableObjectNamespaceEffectClient<Api<Definition$3<Id, MethodDefinitions>>, Definition$3<Id, MethodDefinitions>>> & DurableObjectNamespaceStaticClient<Self, Api<Definition$3<Id, MethodDefinitions>>, Definition$3<Id, MethodDefinitions>> & {
   readonly id: Id;
-  readonly methods: 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 methods: MethodDefinitions;
+  readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options: Options$2<ROut, Definition$3<Id, MethodDefinitions>, REvent, EventLayerError>) => DurableObjectClass<Handlers<ROut | REvent, Definition$3<Id, MethodDefinitions>>, ROut | REvent>;
   readonly layer: (options: LayerOptions$8) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 };
 /**
  * Defines a single RPC method schema in a Durable Object definition.
  */
-declare const method: {
-  <Success extends ServiceFreeSchema>(definition: {
-    readonly success: Success;
-  }): Method$1<readonly [], Success>;
-  <const Args extends ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema>(definition: {
-    readonly args: Args;
-    readonly success: Success;
-  }): Method$1<Args, Success>;
-};
-declare const make$7: <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape>) => TagClass$7<Definition$3<Id, MethodsShape>, Id, MethodsShape>;
-declare const Tag$8: <Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape>) => TagClass$7<Self, Id, MethodsShape>;
+declare function method<Success extends ServiceFreeSchema>(definition: {
+  readonly success: Success;
+}): Method$1<readonly [], Success>;
+declare function method<const Args extends ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema>(definition: {
+  readonly args: Args;
+  readonly success: Success;
+}): Method$1<Args, Success>;
+declare const make$7: <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>) => TagClass$7<Definition$3<Id, MethodDefinitions>, Id, MethodDefinitions>;
+declare const Tag$8: <Self>() => <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>) => TagClass$7<Self, Id, MethodDefinitions>;
 declare const DurableObject$1: typeof Tag$8;
 /**
  * Helper for implementing handlers with the exact method shape of a definition.
@@ -1393,7 +1071,7 @@ declare const implement$2: <ROut, const Self extends Definition$3.Any>(_definiti
  */
 type HandlerEffect<ROut, Self extends Definition$3.Any, Key extends keyof Self["methods"]> = DurableObjectHandler<ROut, Method$1.Success<Self["methods"][Key]>>;
 declare namespace DurableObject_d_exports {
-  export { Api, Definition$3 as Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcShape, HandlerEffect, Handlers, LayerOptions$8 as LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options$2 as Options, ReservedMethodName, RpcHandlers, ServerApi, ServiceFreeSchema, Tag$8 as Tag, TagClass$7 as TagClass, implement$2 as implement, make$6 as make, method };
+  export { Api, Definition$3 as Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcApi, DurableObjectRpcApi as DurableObjectRpcShape, HandlerEffect, Handlers, LayerOptions$8 as LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options$2 as Options, ReservedMethodName, RpcHandlers, ServerApi, ServiceFreeSchema, Tag$8 as Tag, TagClass$7 as TagClass, implement$2 as implement, make$6 as make, method };
 }
 type RuntimeContext$1<ROut> = DurableObjectState | WorkerEnvironment | ROut;
 type HandlerContext<ROut> = RuntimeContext$1<ROut> | Scope.Scope;
@@ -1406,8 +1084,8 @@ type DurableObjectHandler<ROut, A = unknown> = Effect.Effect<A, unknown, Handler
  * Shape of Durable Object RPC handlers passed to {@link make}.
  */
 type DurableObjectRpc<ROut> = Record<string, (...args: Array<any>) => DurableObjectHandler<ROut>>;
-type DurableObjectRpcShape<Rpc extends DurableObjectRpc<ROut>, ROut> = { readonly [Key in keyof Rpc]: Rpc[Key] extends ((...args: infer Args) => Effect.Effect<infer A, unknown, HandlerContext<ROut>>) ? (...args: Args) => Promise<A> : never; };
-type RpcHandlers<ROut, Api> = { readonly [Key in keyof Api as Key extends keyof DurableObject<WorkerEnv> ? never : Key extends string ? [Api[Key]] extends [never] ? never : Api[Key] extends ((...args: Array<any>) => Promise<unknown>) ? Key : never : never]: Api[Key] extends ((...args: infer Args) => Promise<infer A>) ? (...args: Args) => DurableObjectHandler<ROut, A> : never; };
+type DurableObjectRpcApi<Rpc extends DurableObjectRpc<ROut>, ROut> = { readonly [Key in keyof Rpc]: Rpc[Key] extends ((...args: infer Args) => Effect.Effect<infer A, unknown, HandlerContext<ROut>>) ? (...args: Args) => Promise<A> : never; };
+type RpcHandlers<ROut, Api> = { readonly [Key in keyof Api as Key extends keyof DurableObject<WorkerEnv> ? never : Key extends string ? [Api[Key]] extends [never] ? never : Api[Key] extends ((...args: Array<any>) => Promise<any>) ? Key : never : never]: Api[Key] extends ((...args: infer Args) => Promise<infer A>) ? (...args: Args) => DurableObjectHandler<ROut, A> : never; };
 /**
  * Options for creating a Durable Object class backed by Effect handlers.
  */
@@ -1455,12 +1133,12 @@ interface DurableObjectOptions<RRuntime, REvent = never, EventLayerError = never
   readonly alarm?: (alarmInfo?: globalThis.AlarmInvocationInfo) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
   readonly webSocketMessage?: (socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
   readonly webSocketClose?: (socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
-  readonly webSocketError?: (socket: DurableWebSocket, error: unknown) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
+  readonly webSocketError?: (socket: DurableWebSocket, cause: unknown) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
 }
 /**
  * Cloudflare `DurableObject` constructor produced by {@link make}.
  */
-type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (state: globalThis.DurableObjectState, env: WorkerEnv) => DurableObject<WorkerEnv> & DurableObjectRpcShape<Rpc, ROut>;
+type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (state: globalThis.DurableObjectState, env: WorkerEnv) => DurableObject<WorkerEnv> & DurableObjectRpcApi<Rpc, ROut>;
 /**
  * Creates a Durable Object class backed by a single managed Effect runtime.
  */
@@ -1819,7 +1497,7 @@ interface DurableObjectRpcWebSocketService {
   readonly accept: (socket: DurableWebSocket) => Effect.Effect<void>;
   readonly message: (socket: DurableWebSocket, message: NativeWebSocketMessage) => Effect.Effect<void>;
   readonly close: (socket: DurableWebSocket) => Effect.Effect<void>;
-  readonly error: (socket: DurableWebSocket, error: unknown) => Effect.Effect<void>;
+  readonly error: (socket: DurableWebSocket, cause: unknown) => Effect.Effect<void>;
 }
 declare const DurableObjectRpcWebSocket_base: Context.ServiceClass<DurableObjectRpcWebSocket, "effect-cf/DurableObjectRpcWebSocket", DurableObjectRpcWebSocketService>;
 /**
@@ -1953,7 +1631,7 @@ interface TagClass$6<Self, Id extends string> extends Context.ServiceClass<Self,
  * because the encoded MIME size is only known once Cloudflare composes it.
  */
 declare const validateMessage: (message: EmailMessageBuilder) => ReadonlyArray<EmailViolation>;
-declare const isEmailBinding: (value: unknown) => value is EmailBinding;
+declare const isEmailBinding: <Candidate>(value: Candidate) => value is Candidate & EmailBinding;
 declare const makeClient$4: (definition: EmailDefinition, options?: EmailSendOptions) => (email: EmailBinding) => EmailClient;
 declare const layer$4: <Self>(tag: Context.Service<Self, EmailClient>, definition: LayerOptions$6) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make$5: <Id extends string>(id: Id) => TagClass$6<EmailService<Id>, Id>;
@@ -2127,7 +1805,7 @@ declare const draw: {
   (draw: DrawStepOptions): (steps: Steps) => Steps;
   (steps: Steps, draw: DrawStepOptions): Steps;
 };
-declare const isImagesBinding: (value: unknown) => value is ImagesRuntimeBinding;
+declare const isImagesBinding: <Candidate>(value: Candidate) => value is Candidate & ImagesRuntimeBinding;
 declare const makeClient$3: (definition: ImagesDefinition) => (images: ImagesRuntimeBinding) => ImagesClient;
 declare const layer$3: <Self>(tag: Context.Service<Self, ImagesClient>, definition: ImagesDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make$4: <Id extends string>(id: Id) => TagClass$5<ImagesService<Id>, Id>;
@@ -2215,7 +1893,7 @@ interface TagClass$4<Self, Id extends string, Key, Value, EncodedValue> extends
   readonly valueSchema: Schema.Codec<Value, EncodedValue>;
   readonly layer: (options: LayerOptions$4) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
-declare const isKvNamespace: (value: unknown) => value is KVNamespace;
+declare const isKvNamespace: <Candidate>(value: Candidate) => value is Candidate & KVNamespace;
 declare const makeClient$2: <Key, Value, EncodedValue>(definition: KvDefinition<Key, Value, EncodedValue>) => ((kv: KVNamespace) => KvClient<Key, Value, EncodedValue>);
 declare const layer$2: <Self, Key, Value, EncodedValue>(tag: Context.Service<Self, KvClient<Key, Value, EncodedValue>>, definition: KvDefinition<Key, Value, EncodedValue>) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const Tag$5: <Self>() => <Id extends string, Key, Value, EncodedValue>(id: Id, definition: {
@@ -2301,7 +1979,8 @@ interface TagClass$3<Self, Id extends string> extends Context.ServiceClass<Self,
   readonly id: Id;
   readonly layer: (options: LayerOptions$3) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
-declare const isR2Bucket: (value: unknown) => value is CloudflareR2Bucket;
+type R2BindingValue = Schema.Schema.Type<typeof Schema.Unknown>;
+declare const isR2Bucket: (value: R2BindingValue) => value is CloudflareR2Bucket;
 declare const makeClient$1: (definition: R2Definition) => ((bucket: CloudflareR2Bucket) => R2Client);
 declare const layer$1: <Self>(tag: Context.Service<Self, R2Client>, definition: R2Definition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make$3: <Id extends string>(id: Id) => TagClass$3<R2Service<Id>, Id>;
@@ -2365,7 +2044,8 @@ interface TagClass$2<Self, Id extends string> extends Context.ServiceClass<Self,
   readonly id: Id;
   readonly layer: (options: LayerOptions$2) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
-declare const isVectorizeBinding: (value: unknown) => value is VectorizeBinding;
+type VectorizeBindingValue = Schema.Schema.Type<typeof Schema.Unknown>;
+declare const isVectorizeBinding: (value: VectorizeBindingValue) => value is VectorizeBinding;
 declare const makeClient: (definition: VectorizeDefinition) => (index: VectorizeBinding) => VectorizeClient;
 declare const layer: <Self>(tag: Context.Service<Self, VectorizeClient>, definition: VectorizeDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make$2: <Id extends string>(id: Id) => TagClass$2<VectorizeService<Id>, Id>;
@@ -2486,7 +2166,7 @@ declare const Tag$2: <Self>() => <Id extends string, Payload extends ServiceFree
 declare const Workflow: typeof Tag$2;
 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, WorkflowStepError, WorkflowStepService, implement, make, sleep, sleepUntil, step, waitForEvent };
+  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, WorkflowStepError, WorkflowStepNonRetryableError, WorkflowStepService, implement, make, sleep, sleepUntil, step, waitForEvent };
 }
 interface WorkflowEventService<Payload = unknown> {
   readonly raw: WorkflowEvent<unknown>;
@@ -2497,7 +2177,7 @@ interface WorkflowEventService<Payload = unknown> {
 }
 declare const WorkflowEvent_base: Context.ServiceClass<WorkflowEvent$1, "effect-cf/WorkflowEvent", WorkflowEventService<unknown>>;
 declare class WorkflowEvent$1 extends WorkflowEvent_base {}
-declare const WorkflowStepError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+declare const WorkflowStepError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
   readonly _tag: "WorkflowStepError";
 } & Readonly<A>;
 /** Failure raised when a Cloudflare Workflow step operation rejects. */
@@ -2508,6 +2188,20 @@ declare class WorkflowStepError extends WorkflowStepError_base<{
 }> {
   get message(): string;
 }
+declare const WorkflowStepNonRetryableError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+  readonly _tag: "WorkflowStepNonRetryableError";
+} & Readonly<A>;
+/**
+ * Typed step failure that Cloudflare must treat as terminal instead of retrying.
+ *
+ * The workflow boundary converts this value into Cloudflare's native
+ * `NonRetryableError` while preserving the original cause and its message.
+ */
+declare class WorkflowStepNonRetryableError extends WorkflowStepNonRetryableError_base<{
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
 interface WorkflowStepService {
   readonly raw: WorkflowStep;
   do<A, E, R>(name: string, effect: Effect.Effect<A, E, R>, config?: WorkflowStepConfig): Effect.Effect<A, WorkflowStepError, Exclude<R, WorkflowStepContext$1>>;
@@ -2553,4 +2247,4 @@ declare const implement: typeof implement$1;
 type Handler<ROut, Self extends Definition$1.Any> = Handler$1<ROut, Self>;
 type Options<ROut, Self extends Definition$1.Any> = Options$1<ROut, Self>;
 //#endregion
-export { AiGateway_d_exports as AiGateway, AnalyticsEngine_d_exports as AnalyticsEngine, Artifacts_d_exports as Artifacts, Binding_d_exports as Binding, BrowserRendering_d_exports as BrowserRendering, Cache_d_exports as Cache, CloudflareOtlp_d_exports as CloudflareOtlp, ComputerArtifacts_d_exports as ComputerArtifacts, ComputerWorkspace_d_exports as ComputerWorkspace, ContainerNamespace_d_exports as ContainerNamespace, D1_d_exports as D1, DurableObject_d_exports as DurableObject, DurableObjectAlarm_d_exports as DurableObjectAlarm, DurableObjectDefinition_d_exports as DurableObjectDefinition, DurableObjectNamespace_d_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_d_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_d_exports as DurableObjectSqlite, DurableObjectState_d_exports as DurableObjectState, DurableObjectStorage_d_exports as DurableObjectStorage, DurableObjectWebSocket_d_exports as DurableObjectWebSocket, Email_d_exports as Email, Environment_d_exports as Environment, Hyperdrive_d_exports as Hyperdrive, Images_d_exports as Images, Kv_d_exports as Kv, Queue_d_exports as Queue, QueueBinding_d_exports as QueueBinding, QueueDefinition_d_exports as QueueDefinition, R2_d_exports as R2, Rpc_d_exports as Rpc, RpcDefinition_d_exports as RpcDefinition, ServiceBinding_d_exports as ServiceBinding, Vectorize_d_exports as Vectorize, WebTransport_d_exports as WebTransport, Worker_d_exports as Worker, WorkerConfig, WorkerDefinition_d_exports as WorkerDefinition, type WorkerEnv, WorkerEnvironment, WorkersAi_d_exports as WorkersAi, Workflow_d_exports as Workflow, WorkflowBinding_d_exports as WorkflowBinding, WorkflowDefinition_d_exports as WorkflowDefinition };
+export { AiGateway_d_exports as AiGateway, AnalyticsEngine_d_exports as AnalyticsEngine, Artifacts_d_exports as Artifacts, Binding_d_exports as Binding, BrowserRendering_d_exports as BrowserRendering, Cache_d_exports as Cache, CloudflareOtlp_d_exports as CloudflareOtlp, ContainerNamespace_d_exports as ContainerNamespace, D1_d_exports as D1, DurableObject_d_exports as DurableObject, DurableObjectAlarm_d_exports as DurableObjectAlarm, DurableObjectDefinition_d_exports as DurableObjectDefinition, DurableObjectNamespace_d_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_d_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_d_exports as DurableObjectSqlite, DurableObjectState_d_exports as DurableObjectState, DurableObjectStorage_d_exports as DurableObjectStorage, DurableObjectWebSocket_d_exports as DurableObjectWebSocket, Email_d_exports as Email, Environment_d_exports as Environment, Hyperdrive_d_exports as Hyperdrive, Images_d_exports as Images, Kv_d_exports as Kv, Queue_d_exports as Queue, QueueBinding_d_exports as QueueBinding, QueueDefinition_d_exports as QueueDefinition, R2_d_exports as R2, Rpc_d_exports as Rpc, RpcDefinition_d_exports as RpcDefinition, ServiceBinding_d_exports as ServiceBinding, Vectorize_d_exports as Vectorize, WebTransport_d_exports as WebTransport, Worker_d_exports as Worker, WorkerConfig, WorkerDefinition_d_exports as WorkerDefinition, type WorkerEnv, WorkerEnvironment, WorkersAi_d_exports as WorkersAi, Workflow_d_exports as Workflow, WorkflowBinding_d_exports as WorkflowBinding, WorkflowDefinition_d_exports as WorkflowDefinition };