effect-cf 0.25.3 → 0.26.0

package/dist/index.d.mts

@@ -1,7 +1,8 @@
 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 } from "effect";
+import { Config, Context, Data, DateTime, Duration, Effect, Layer, Option, Redacted, Schema, Scope, Stream } from "effect";
 import { Headers as Headers$1, HttpClient, HttpClientResponse } from "effect/unstable/http";
 import { OtlpExporter } from "effect/unstable/observability";
 import { D1Client } from "@effect/sql-d1";
@@ -9,10 +10,14 @@ import { DurableObject, WorkflowEntrypoint, WorkflowEvent, WorkflowSleepDuration
 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$11 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$12 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";
@@ -85,12 +90,12 @@ declare const embeddingResponse: (value: {
   readonly data?: ReadonlyArray<ReadonlyArray<number>>;
   readonly shape?: ReadonlyArray<number>;
 }) => WorkersAiEmbeddingResponse;
-declare const makeClient$11: <ModelList extends AiModelListType = AiModels>(definition: WorkersAiDefinition) => (ai: WorkersAiBinding<ModelList>) => WorkersAiClient<ModelList>;
+declare const makeClient$12: <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$10 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$11 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";
@@ -151,7 +156,7 @@ interface TagClass$11<Self, Id extends string> extends Context.ServiceClass<Self
   readonly layer: (options: LayerOptions$13) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError | AiGatewayOperationError, WorkerEnvironment>;
 }
 declare const isAiGatewayBinding: (value: unknown) => value is WorkersAiBinding;
-declare const makeClient$10: (definition: AiGatewayDefinition, gateway: AiGatewayBinding) => {
+declare const makeClient$11: (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;
@@ -173,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$9 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$10 as makeClient, makeQuery, makeQueryClient, queryConfig, queryLayer, queryLayerConfig, writeLimits };
 }
 declare const writeLimits: {
   readonly maxBlobs: 20;
@@ -323,7 +328,7 @@ interface QueryTagClass<Self, Id extends string> extends Context.ServiceClass<Se
 }
 declare const makeQueryClient: (definition: AnalyticsEngineQueryDefinition) => Effect.Effect<AnalyticsEngineQueryClient, never, HttpClient.HttpClient>;
 declare const isAnalyticsEngineDataset: (value: unknown) => value is AnalyticsEngineBinding;
-declare const makeClient$9: (definition: AnalyticsEngineDefinition, defaults?: AnalyticsEngineWritePolicy) => (dataset: AnalyticsEngineBinding) => AnalyticsEngineClient;
+declare const makeClient$10: (definition: AnalyticsEngineDefinition, defaults?: AnalyticsEngineWritePolicy) => (dataset: AnalyticsEngineBinding) => AnalyticsEngineClient;
 declare const queryConfig: (options?: QueryConfigOptions) => Config.Config<{
   accountId: string;
   apiToken: Redacted.Redacted<string>;
@@ -339,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$8 as makeClient };
+  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 };
 }
 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";
@@ -413,12 +418,12 @@ interface TagClass$9<Self, Id extends string> extends Context.ServiceClass<Self,
   readonly layer: (options: LayerOptions$11) => 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 makeClient$9: <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$7 as makeClient };
+  export { CacheClient, CacheOperation, CacheOperationError, CacheQueryOptions, CacheRequest, CacheStorage, CacheStorageClient, layer$10 as layer, layerFrom, makeCacheClient, makeClient$8 as makeClient };
 }
 /** Request key accepted by Cloudflare's Cache API. */
 type CacheRequest = CloudflareRequestInfo | URL;
@@ -465,7 +470,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$7: (storage: CloudflareCacheStorage) => CacheStorageClient;
+declare const makeClient$8: (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. */
@@ -568,6 +573,331 @@ 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 };
 }
@@ -2040,6 +2370,82 @@ declare const makeClient: (definition: VectorizeDefinition) => (index: Vectorize
 declare const layer: <Self>(tag: Context.Service<Self, VectorizeClient>, definition: VectorizeDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make$2: <Id extends string>(id: Id) => TagClass$2<VectorizeService<Id>, Id>;
 declare const Tag$3: <Self>() => <Id extends string>(id: Id) => TagClass$2<Self, Id>;
+declare namespace WebTransport_d_exports {
+  export { Capabilities, InboundTransport, WebTransportCapability, WebTransportUnsupportedError, capabilities, inboundSessionsUnsupported, inboundTransport, isHttp3 };
+}
+declare const InboundTransport_base: Schema.Class<InboundTransport, Schema.Struct<{
+  /** The HTTP protocol the client used, e.g. `"HTTP/2"` or `"HTTP/3"`. */
+  readonly httpProtocol: Schema.String;
+  /** Client round-trip time; only present for QUIC (HTTP/3) connections. */
+  readonly clientQuicRtt: Schema.optional<Schema.Number>;
+  /** Client round-trip time; only present for TCP (HTTP/1.x, HTTP/2) connections. */
+  readonly clientTcpRtt: Schema.optional<Schema.Number>;
+}>, {}>;
+/**
+ * Metadata Cloudflare's edge reports about the inbound client connection.
+ *
+ * `httpProtocol` and `clientTcpRtt` are declared in
+ * `@cloudflare/workers-types`; `clientQuicRtt` is documented by Cloudflare
+ * ("only present when the client connected over QUIC (HTTP/3)") but not yet
+ * present in the published types, so it is decoded from the open
+ * `Record<string, unknown>` side of `request.cf`.
+ */
+declare class InboundTransport extends InboundTransport_base {}
+/**
+ * Decodes the inbound transport metadata from `request.cf`.
+ *
+ * Returns `None` when the metadata is absent (for example in local `wrangler
+ * dev` or when a Worker invokes another Worker directly) or does not match
+ * the expected shape.
+ */
+declare const inboundTransport: (request: Pick<CloudflareRequest, "cf">) => Option.Option<InboundTransport>;
+/**
+ * Returns `true` when the client reached Cloudflare's edge over QUIC
+ * (HTTP/3). Prefers the documented QUIC signal (`clientQuicRtt` is only
+ * present for QUIC connections) and falls back to the `httpProtocol` string.
+ *
+ * Note this describes the browser→edge hop only: the edge always terminates
+ * QUIC, and the Worker still handles an ordinary `fetch` Request.
+ */
+declare const isHttp3: (transport: InboundTransport) => boolean;
+/** WebTransport-related capabilities of the current Workers runtime. */
+interface Capabilities {
+  /**
+   * Whether Worker code can accept inbound WebTransport sessions. Typed as
+   * literally `false`: no such runtime API exists (cloudflare/workerd#6451),
+   * so this can only change through a breaking, deliberate update when
+   * Cloudflare ships one.
+   */
+  readonly inboundSessions: false;
+  /**
+   * Whether the runtime exposes a client `WebTransport` constructor global.
+   * Feature-detected at runtime; `false` in workerd today, which has no
+   * QUIC stack.
+   */
+  readonly outboundSessions: boolean;
+}
+/** Feature-detects the WebTransport capabilities of the current runtime. */
+declare const capabilities: Effect.Effect<Capabilities>;
+/** WebTransport capability missing from the current Workers runtime. */
+type WebTransportCapability = "inbound-sessions" | "outbound-sessions";
+declare const WebTransportUnsupportedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "WebTransportUnsupportedError";
+} & Readonly<A>;
+/** Raised when a WebTransport capability is unavailable in this runtime. */
+declare class WebTransportUnsupportedError extends WebTransportUnsupportedError_base<{
+  readonly capability: WebTransportCapability;
+}> {
+  get message(): string;
+}
+/**
+ * The explicit typed boundary for inbound WebTransport sessions.
+ *
+ * Always fails with {@link WebTransportUnsupportedError} today. Route the
+ * code path that would accept a session through this effect so the
+ * limitation is visible in the type system and greppable when Cloudflare
+ * ships a real API.
+ */
+declare const inboundSessionsUnsupported: Effect.Effect<never, WebTransportUnsupportedError>;
 declare namespace WorkflowDefinition_d_exports {
   export { Definition$1 as Definition, Handler$1 as Handler, LayerOptions$1 as LayerOptions, Options$1 as Options, Tag$2 as Tag, TagClass$1 as TagClass, Workflow, implement$1 as implement, make$1 as make };
 }
@@ -2147,4 +2553,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, 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, 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, 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 };