effect-cf 0.46.0 → 0.46.1

package/src/Images.ts

@@ -1,26 +1,3 @@
-import type {
-  HostedImagesBinding as CloudflareHostedImagesBinding,
-  ImageDirectUploadOptions as CloudflareImageDirectUploadOptions,
-  ImageDirectUploadResult as CloudflareImageDirectUploadResult,
-  ImageDrawOptions as CloudflareImageDrawOptions,
-  ImageHandle as CloudflareImageHandle,
-  ImageInfoResponse as CloudflareImageInfoResponse,
-  ImageInputOptions as CloudflareImageInputOptions,
-  ImageList as CloudflareImageList,
-  ImageListOptions as CloudflareImageListOptions,
-  ImageMetadata as CloudflareImageMetadata,
-  ImageOutputOptions as CloudflareImageOutputOptions,
-  ImageSignedUrlOptions as CloudflareImageSignedUrlOptions,
-  ImageTransform as CloudflareImageTransform,
-  ImageTransformationOutputOptions as CloudflareImageTransformationOutputOptions,
-  ImageTransformationResponseOptions as CloudflareImageTransformationResponseOptions,
-  ImageTransformationResult as CloudflareImageTransformationResult,
-  ImageTransformer as CloudflareImageTransformer,
-  ImageUpdateOptions as CloudflareImageUpdateOptions,
-  ImageUploadOptions as CloudflareImageUploadOptions,
-  Response as CloudflareResponse,
-  TextOptions as CloudflareTextOptions,
-} from "@cloudflare/workers-types";
 import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
@@ -55,28 +32,28 @@ export interface ImagesDefinition {
   readonly binding: string;
 }
 
-export type ImageInfoResponse = CloudflareImageInfoResponse;
-export type ImageTransform = CloudflareImageTransform;
-export type ImageDrawOptions = CloudflareImageDrawOptions;
-export type ImageInputOptions = CloudflareImageInputOptions;
-export type ImageOutputOptions = CloudflareImageOutputOptions;
-export type ImageTransformationOutputOptions = CloudflareImageTransformationOutputOptions;
-export type ImageTransformationResponseOptions = CloudflareImageTransformationResponseOptions;
-export type ImageTransformationResult = CloudflareImageTransformationResult;
-export type ImageUploadOptions = CloudflareImageUploadOptions;
-export type ImageUpdateOptions = CloudflareImageUpdateOptions;
-export type ImageListOptions = CloudflareImageListOptions;
-export type ImageList = CloudflareImageList;
-export type ImageMetadata = CloudflareImageMetadata;
-export type ImageSignedUrlOptions = CloudflareImageSignedUrlOptions;
-export type ImageDirectUploadOptions = CloudflareImageDirectUploadOptions;
-export type ImageDirectUploadResult = CloudflareImageDirectUploadResult;
-export type TextOptions = CloudflareTextOptions;
+export type ImageDirectUploadOptions = globalThis.ImageDirectUploadOptions;
+export type ImageDirectUploadResult = globalThis.ImageDirectUploadResult;
+export type ImageDrawOptions = globalThis.ImageDrawOptions;
+export type ImageInfoResponse = globalThis.ImageInfoResponse;
+export type ImageInputOptions = globalThis.ImageInputOptions;
+export type ImageList = globalThis.ImageList;
+export type ImageListOptions = globalThis.ImageListOptions;
+export type ImageMetadata = globalThis.ImageMetadata;
+export type ImageOutputOptions = globalThis.ImageOutputOptions;
+export type ImageSignedUrlOptions = globalThis.ImageSignedUrlOptions;
+export type ImageTransform = globalThis.ImageTransform;
+export type ImageTransformationOutputOptions = globalThis.ImageTransformationOutputOptions;
+export type ImageTransformationResponseOptions = globalThis.ImageTransformationResponseOptions;
+export type ImageTransformationResult = globalThis.ImageTransformationResult;
+export type ImageUpdateOptions = globalThis.ImageUpdateOptions;
+export type ImageUploadOptions = globalThis.ImageUploadOptions;
+export type TextOptions = globalThis.TextOptions;
 export type ImageInputValue = ReadableStream<Uint8Array> | ArrayBuffer;
 export type ImageUploadValue = ReadableStream<Uint8Array> | ArrayBuffer;
 
 export interface DrawStepOptions {
-  readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
+  readonly image: ReadableStream<Uint8Array> | ImageTransformer;
   readonly options?: ImageDrawOptions;
 }
 
@@ -107,10 +84,10 @@ export type ProcessOptions =
     };
 
 export interface ImagesTransformationResultClient {
-  readonly raw: CloudflareImageTransformationResult;
+  readonly raw: ImageTransformationResult;
   readonly response: (
     options?: ImageTransformationResponseOptions,
-  ) => Effect.Effect<CloudflareResponse, ImagesOperationError>;
+  ) => Effect.Effect<Response, ImagesOperationError>;
   readonly contentType: Effect.Effect<string, ImagesOperationError>;
   readonly image: (
     options?: ImageTransformationOutputOptions,
@@ -118,7 +95,7 @@ export interface ImagesTransformationResultClient {
 }
 
 export interface ImageHandleClient {
-  readonly raw: CloudflareImageHandle;
+  readonly raw: ImageHandle;
   readonly details: Effect.Effect<Option.Option<ImageMetadata>, ImagesOperationError>;
   readonly bytes: Effect.Effect<Option.Option<ReadableStream<Uint8Array>>, ImagesOperationError>;
   readonly signedUrl: (
@@ -140,7 +117,7 @@ export interface HostedImagesClient {
   readonly createDirectUpload: (
     options?: ImageDirectUploadOptions,
   ) => Effect.Effect<ImageDirectUploadResult, ImagesOperationError>;
-  readonly rawUnsafe: Effect.Effect<CloudflareHostedImagesBinding>;
+  readonly rawUnsafe: Effect.Effect<HostedImagesBinding>;
 }
 
 export interface ImagesRuntimeBinding {
@@ -148,12 +125,9 @@ export interface ImagesRuntimeBinding {
     image: ImageInputValue,
     options?: ImageInputOptions,
   ) => Promise<ImageInfoResponse>;
-  readonly input: (
-    image: ImageInputValue,
-    options?: ImageInputOptions,
-  ) => CloudflareImageTransformer;
-  readonly text?: (content: string, options: TextOptions) => CloudflareImageTransformer;
-  readonly hosted?: CloudflareHostedImagesBinding;
+  readonly input: (image: ImageInputValue, options?: ImageInputOptions) => ImageTransformer;
+  readonly text?: (content: string, options: TextOptions) => ImageTransformer;
+  readonly hosted?: HostedImagesBinding;
 }
 
 export interface ImagesClient {
@@ -164,11 +138,11 @@ export interface ImagesClient {
   readonly input: (
     image: ImageInputValue,
     options?: ImageInputOptions,
-  ) => Effect.Effect<CloudflareImageTransformer, ImagesOperationError>;
+  ) => Effect.Effect<ImageTransformer, ImagesOperationError>;
   readonly text: (
     content: string,
     options: TextOptions,
-  ) => Effect.Effect<CloudflareImageTransformer, ImagesOperationError>;
+  ) => Effect.Effect<ImageTransformer, ImagesOperationError>;
   readonly process: (
     steps: Steps,
     options: ProcessOptions,
@@ -257,7 +231,7 @@ const hasFunction = <Candidate>(value: Candidate, key: string): boolean =>
 
 const isHostedImagesBinding = <Candidate>(
   value: Candidate,
-): value is Candidate & CloudflareHostedImagesBinding =>
+): value is Candidate & HostedImagesBinding =>
   hasFunction(value, "image") &&
   hasFunction(value, "upload") &&
   hasFunction(value, "list") &&
@@ -270,7 +244,7 @@ export const isImagesBinding = <Candidate>(
 
 const wrapResult = (
   binding: string,
-  result: CloudflareImageTransformationResult,
+  result: ImageTransformationResult,
 ): ImagesTransformationResultClient => ({
   raw: result,
   response: (options) => tryImagesSync(binding, "response", () => result.response(options)),
@@ -278,7 +252,7 @@ const wrapResult = (
   image: (options) => tryImagesSync(binding, "image", () => result.image(options)),
 });
 
-const wrapHandle = (binding: string, handle: CloudflareImageHandle): ImageHandleClient => ({
+const wrapHandle = (binding: string, handle: ImageHandle): ImageHandleClient => ({
   raw: handle,
   details: tryImagesPromise(binding, "details", () => handle.details()).pipe(
     Effect.map(maybe),
@@ -299,10 +273,7 @@ const wrapHandle = (binding: string, handle: CloudflareImageHandle): ImageHandle
   ),
 });
 
-const wrapHosted = (
-  binding: string,
-  hosted: CloudflareHostedImagesBinding,
-): HostedImagesClient => ({
+const wrapHosted = (binding: string, hosted: HostedImagesBinding): HostedImagesClient => ({
   image: (imageId) => wrapHandle(binding, hosted.image(imageId)),
   upload: Effect.fn("Images.upload")((image: ImageUploadValue, options?: ImageUploadOptions) =>
     tryImagesPromise(binding, "upload", () => hosted.upload(image, options)),

package/src/Kv.ts

@@ -1,7 +1,3 @@
-import type {
-  KVNamespaceListOptions as CloudflareKVNamespaceListOptions,
-  KVNamespacePutOptions as CloudflareKVNamespacePutOptions,
-} from "@cloudflare/workers-types";
 import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
@@ -31,8 +27,8 @@ export class KvOperationError extends Data.TaggedError("KvOperationError")<{
   }
 }
 
-export type KvPutOptions = CloudflareKVNamespacePutOptions;
-export type KvListOptions<Metadata = unknown> = CloudflareKVNamespaceListOptions & {
+export type KvPutOptions = KVNamespacePutOptions;
+export type KvListOptions<Metadata = unknown> = KVNamespaceListOptions & {
   readonly metadataSchema?: S.Codec<Metadata, unknown>;
 };
 

package/src/QueueBinding.ts

@@ -1,12 +1,3 @@
-import type {
-  MessageSendRequest as CloudflareMessageSendRequest,
-  Queue as CloudflareQueue,
-  QueueMetrics as CloudflareQueueMetrics,
-  QueueSendBatchOptions as CloudflareQueueSendBatchOptions,
-  QueueSendBatchResponse as CloudflareQueueSendBatchResponse,
-  QueueSendOptions as CloudflareQueueSendOptions,
-  QueueSendResponse as CloudflareQueueSendResponse,
-} from "@cloudflare/workers-types";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Predicate from "effect/Predicate";
@@ -16,15 +7,15 @@ import type { Context } from "effect";
 import * as Binding from "./Binding";
 import type * as RpcDefinition from "./RpcDefinition";
 
-export type QueueSendOptions = CloudflareQueueSendOptions;
-export type QueueSendResponse = CloudflareQueueSendResponse;
-export type QueueSendBatchOptions = CloudflareQueueSendBatchOptions;
-export type QueueSendBatchResponse = CloudflareQueueSendBatchResponse;
-export type QueueMetrics = CloudflareQueueMetrics;
-export type MessageSendRequest<Body> = CloudflareMessageSendRequest<Body>;
+export type MessageSendRequest<Body> = globalThis.MessageSendRequest<Body>;
+export type QueueMetrics = globalThis.QueueMetrics;
+export type QueueSendBatchOptions = globalThis.QueueSendBatchOptions;
+export type QueueSendBatchResponse = globalThis.QueueSendBatchResponse;
+export type QueueSendOptions = globalThis.QueueSendOptions;
+export type QueueSendResponse = globalThis.QueueSendResponse;
 
-export type QueueProducer<Body> = Pick<CloudflareQueue<Body>, "send"> &
-  Partial<Pick<CloudflareQueue<Body>, "sendBatch" | "metrics">>;
+export type QueueProducer<Body> = Pick<Queue<Body>, "send"> &
+  Partial<Pick<Queue<Body>, "sendBatch" | "metrics">>;
 
 const expectedQueueProducer = "Queue producer binding with send(); optional sendBatch()/metrics()";
 

package/src/R2.ts

@@ -1,17 +1,3 @@
-import type {
-  R2Bucket as CloudflareR2Bucket,
-  R2Conditional as CloudflareR2Conditional,
-  R2GetOptions as CloudflareR2GetOptions,
-  R2ListOptions as CloudflareR2ListOptions,
-  R2MultipartOptions as CloudflareR2MultipartOptions,
-  R2MultipartUpload as CloudflareR2MultipartUpload,
-  R2Object as CloudflareR2Object,
-  R2ObjectBody as CloudflareR2ObjectBody,
-  R2Objects as CloudflareR2Objects,
-  R2PutOptions as CloudflareR2PutOptions,
-  R2UploadPartOptions as CloudflareR2UploadPartOptions,
-  R2UploadedPart as CloudflareR2UploadedPart,
-} from "@cloudflare/workers-types";
 import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
@@ -60,19 +46,19 @@ export interface R2Definition {
   readonly binding: string;
 }
 
-export type R2GetOptions = CloudflareR2GetOptions;
-export type R2PutOptions = CloudflareR2PutOptions;
-export type R2ListOptions = CloudflareR2ListOptions;
-export type R2MultipartOptions = CloudflareR2MultipartOptions;
-export type R2UploadPartOptions = CloudflareR2UploadPartOptions;
+export type R2GetOptions = globalThis.R2GetOptions;
+export type R2ListOptions = globalThis.R2ListOptions;
+export type R2MultipartOptions = globalThis.R2MultipartOptions;
+export type R2PutOptions = globalThis.R2PutOptions;
+export type R2UploadPartOptions = globalThis.R2UploadPartOptions;
 export type R2PutValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | null | Blob;
 export type R2UploadPartValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | Blob;
 
 export interface R2ObjectBodyClient extends Omit<
-  CloudflareR2ObjectBody,
+  R2ObjectBody,
   "arrayBuffer" | "blob" | "bytes" | "json" | "text"
 > {
-  readonly raw: CloudflareR2ObjectBody;
+  readonly raw: R2ObjectBody;
   readonly arrayBuffer: Effect.Effect<ArrayBuffer, R2OperationError>;
   readonly bytes: Effect.Effect<Uint8Array, R2OperationError>;
   readonly text: Effect.Effect<string, R2OperationError>;
@@ -81,29 +67,27 @@ export interface R2ObjectBodyClient extends Omit<
 }
 
 export interface R2MultipartUploadClient {
-  readonly raw: CloudflareR2MultipartUpload;
+  readonly raw: R2MultipartUpload;
   readonly key: string;
   readonly uploadId: string;
   readonly uploadPart: (
     partNumber: number,
     value: R2UploadPartValue,
     options?: R2UploadPartOptions,
-  ) => Effect.Effect<CloudflareR2UploadedPart, R2OperationError>;
+  ) => Effect.Effect<R2UploadedPart, R2OperationError>;
   readonly abort: Effect.Effect<void, R2OperationError>;
   readonly complete: (
-    uploadedParts: ReadonlyArray<CloudflareR2UploadedPart>,
-  ) => Effect.Effect<CloudflareR2Object, R2OperationError>;
+    uploadedParts: ReadonlyArray<R2UploadedPart>,
+  ) => Effect.Effect<R2Object, R2OperationError>;
 }
 
 export interface R2Client {
-  readonly head: (
-    key: string,
-  ) => Effect.Effect<Option.Option<CloudflareR2Object>, R2OperationError>;
+  readonly head: (key: string) => Effect.Effect<Option.Option<R2Object>, R2OperationError>;
   readonly get: {
     (
       key: string,
-      options: R2GetOptions & { readonly onlyIf: CloudflareR2Conditional | Headers },
-    ): Effect.Effect<Option.Option<R2ObjectBodyClient | CloudflareR2Object>, R2OperationError>;
+      options: R2GetOptions & { readonly onlyIf: R2Conditional | Headers },
+    ): Effect.Effect<Option.Option<R2ObjectBodyClient | R2Object>, R2OperationError>;
     (
       key: string,
       options?: R2GetOptions,
@@ -113,13 +97,13 @@ export interface R2Client {
     (
       key: string,
       value: R2PutValue,
-      options: R2PutOptions & { readonly onlyIf: CloudflareR2Conditional | Headers },
-    ): Effect.Effect<Option.Option<CloudflareR2Object>, R2OperationError>;
+      options: R2PutOptions & { readonly onlyIf: R2Conditional | Headers },
+    ): Effect.Effect<Option.Option<R2Object>, R2OperationError>;
     (
       key: string,
       value: R2PutValue,
       options?: R2PutOptions,
-    ): Effect.Effect<CloudflareR2Object, R2OperationError>;
+    ): Effect.Effect<R2Object, R2OperationError>;
   };
   readonly createMultipartUpload: (
     key: string,
@@ -130,8 +114,8 @@ export interface R2Client {
     uploadId: string,
   ) => Effect.Effect<R2MultipartUploadClient, R2OperationError>;
   readonly delete: (keys: string | ReadonlyArray<string>) => Effect.Effect<void, R2OperationError>;
-  readonly list: (options?: R2ListOptions) => Effect.Effect<CloudflareR2Objects, R2OperationError>;
-  readonly rawUnsafe: Effect.Effect<CloudflareR2Bucket>;
+  readonly list: (options?: R2ListOptions) => Effect.Effect<R2Objects, R2OperationError>;
+  readonly rawUnsafe: Effect.Effect<R2Bucket>;
   readonly definition: R2Definition;
 }
 
@@ -189,9 +173,7 @@ const spanOptions = (binding: string, operation: R2Operation) => ({
   attributes: { binding, operation },
 });
 
-const isR2ObjectBody = (
-  value: CloudflareR2ObjectBody | CloudflareR2Object,
-): value is CloudflareR2ObjectBody =>
+const isR2ObjectBody = (value: R2ObjectBody | R2Object): value is R2ObjectBody =>
   "body" in value &&
   Predicate.isFunction(value.arrayBuffer) &&
   Predicate.isFunction(value.bytes) &&
@@ -199,7 +181,7 @@ const isR2ObjectBody = (
   Predicate.isFunction(value.json) &&
   Predicate.isFunction(value.blob);
 
-const wrapObjectBody = (binding: string, object: CloudflareR2ObjectBody): R2ObjectBodyClient => ({
+const wrapObjectBody = (binding: string, object: R2ObjectBody): R2ObjectBodyClient => ({
   key: object.key,
   version: object.version,
   size: object.size,
@@ -238,8 +220,8 @@ const wrapObjectBody = (binding: string, object: CloudflareR2ObjectBody): R2Obje
 
 const wrapGetResult = (
   binding: string,
-  object: CloudflareR2ObjectBody | CloudflareR2Object | null,
-): R2ObjectBodyClient | CloudflareR2Object | null => {
+  object: R2ObjectBody | R2Object | null,
+): R2ObjectBodyClient | R2Object | null => {
   if (object === null || !isR2ObjectBody(object)) {
     return object;
   }
@@ -250,7 +232,7 @@ const wrapGetResult = (
 type R2BindingValue = Schema.Schema.Type<typeof Schema.Unknown>;
 
 const R2BucketSchema = Schema.declare(
-  (value: R2BindingValue): value is CloudflareR2Bucket =>
+  (value: R2BindingValue): value is R2Bucket =>
     Predicate.hasProperty(value, "head") &&
     Predicate.isFunction(value.head) &&
     Predicate.hasProperty(value, "get") &&
@@ -268,13 +250,11 @@ const R2BucketSchema = Schema.declare(
 );
 const decodeR2Bucket = Schema.decodeUnknownOption(R2BucketSchema);
 
-export const isR2Bucket = (value: R2BindingValue): value is CloudflareR2Bucket =>
+export const isR2Bucket = (value: R2BindingValue): value is R2Bucket =>
   Option.isSome(decodeR2Bucket(value));
 
-export const makeClient = (
-  definition: R2Definition,
-): ((bucket: CloudflareR2Bucket) => R2Client) => {
-  const wrapUpload = (upload: CloudflareR2MultipartUpload): R2MultipartUploadClient => ({
+export const makeClient = (definition: R2Definition): ((bucket: R2Bucket) => R2Client) => {
+  const wrapUpload = (upload: R2MultipartUpload): R2MultipartUploadClient => ({
     raw: upload,
     key: upload.key,
     uploadId: upload.uploadId,
@@ -295,7 +275,7 @@ export const makeClient = (
     complete: Effect.fn(
       "R2.completeMultipartUpload",
       spanOptions(definition.binding, "completeMultipartUpload"),
-    )((uploadedParts: ReadonlyArray<CloudflareR2UploadedPart>) =>
+    )((uploadedParts: ReadonlyArray<R2UploadedPart>) =>
       tryR2Promise(definition.binding, "completeMultipartUpload", () =>
         upload.complete([...uploadedParts]),
       ),
@@ -332,7 +312,7 @@ export const makeClient = (
         tryR2Promise(definition.binding, "put", () => bucket.put(key, value, options)).pipe(
           Effect.map((object) => {
             if (object === null) {
-              return Option.none<CloudflareR2Object>();
+              return Option.none<R2Object>();
             }
 
             if (options !== undefined && "onlyIf" in options) {

package/src/Vectorize.ts

@@ -5,22 +5,6 @@ import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
 import * as Schema from "effect/Schema";
 import type { Layer } from "effect";
-import type {
-  Vectorize as CloudflareVectorize,
-  VectorizeAsyncMutation as CloudflareVectorizeAsyncMutation,
-  VectorizeIndex as CloudflareVectorizeIndex,
-  VectorizeIndexDetails as CloudflareVectorizeIndexDetails,
-  VectorizeIndexInfo as CloudflareVectorizeIndexInfo,
-  VectorizeMatch as CloudflareVectorizeMatch,
-  VectorizeMatches as CloudflareVectorizeMatches,
-  VectorizeQueryOptions as CloudflareVectorizeQueryOptions,
-  VectorizeVector as CloudflareVectorizeVector,
-  VectorizeVectorMetadata as CloudflareVectorizeVectorMetadata,
-  VectorizeVectorMetadataFilter as CloudflareVectorizeVectorMetadataFilter,
-  VectorizeVectorMetadataValue as CloudflareVectorizeVectorMetadataValue,
-  VectorizeVectorMutation as CloudflareVectorizeVectorMutation,
-} from "@cloudflare/workers-types";
-
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import * as ErrorMessage from "./internal/ErrorMessage";
@@ -53,19 +37,17 @@ export interface VectorizeDefinition {
   readonly binding: string;
 }
 
-export type VectorizeBinding = CloudflareVectorize | CloudflareVectorizeIndex;
-export type VectorizeVector = CloudflareVectorizeVector;
-export type VectorizeVectorMetadata = CloudflareVectorizeVectorMetadata;
-export type VectorizeVectorMetadataValue = CloudflareVectorizeVectorMetadataValue;
-export type VectorizeVectorMetadataFilter = CloudflareVectorizeVectorMetadataFilter;
-export type VectorizeQueryOptions = CloudflareVectorizeQueryOptions;
-export type VectorizeMatches = CloudflareVectorizeMatches;
-export type VectorizeMatch = CloudflareVectorizeMatch;
-export type VectorizeIndexInfo = CloudflareVectorizeIndexInfo;
-export type VectorizeIndexDetails = CloudflareVectorizeIndexDetails;
-export type VectorizeMutation =
-  | CloudflareVectorizeAsyncMutation
-  | CloudflareVectorizeVectorMutation;
+export type VectorizeBinding = Vectorize | VectorizeIndex;
+export type VectorizeIndexDetails = globalThis.VectorizeIndexDetails;
+export type VectorizeIndexInfo = globalThis.VectorizeIndexInfo;
+export type VectorizeMatch = globalThis.VectorizeMatch;
+export type VectorizeMatches = globalThis.VectorizeMatches;
+export type VectorizeQueryOptions = globalThis.VectorizeQueryOptions;
+export type VectorizeVector = globalThis.VectorizeVector;
+export type VectorizeVectorMetadata = globalThis.VectorizeVectorMetadata;
+export type VectorizeVectorMetadataFilter = globalThis.VectorizeVectorMetadataFilter;
+export type VectorizeVectorMetadataValue = globalThis.VectorizeVectorMetadataValue;
+export type VectorizeMutation = VectorizeAsyncMutation | VectorizeVectorMutation;
 export type VectorizeValues = Float32Array | Float64Array | ReadonlyArray<number>;
 
 interface VectorizeRuntimeBinding {

package/src/WebTransport.ts

@@ -29,7 +29,6 @@
  * {@link inboundTransport} decodes the HTTP/3-relevant request metadata that
  * the edge does provide.
  */
-import type { Request as CloudflareRequest } from "@cloudflare/workers-types";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
@@ -61,9 +60,8 @@ const decodeInboundTransport = S.decodeUnknownResult(InboundTransport);
  * dev` or when a Worker invokes another Worker directly) or does not match
  * the expected shape.
  */
-export const inboundTransport = (
-  request: Pick<CloudflareRequest, "cf">,
-): Option.Option<InboundTransport> => Result.getSuccess(decodeInboundTransport(request.cf));
+export const inboundTransport = (request: Pick<Request, "cf">): Option.Option<InboundTransport> =>
+  Result.getSuccess(decodeInboundTransport(request.cf));
 
 export const isHttp3 = (transport: InboundTransport): boolean =>
   transport.clientQuicRtt !== undefined || transport.httpProtocol === "HTTP/3";

package/src/WorkersAi.ts

@@ -5,18 +5,6 @@ import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
 import * as S from "effect/Schema";
 import type { Layer } from "effect";
-import type {
-  Ai as CloudflareAi,
-  AiAsyncBatchResponse,
-  AiGateway as CloudflareAiGateway,
-  AiModelListType,
-  AiModels,
-  AiModelsSearchObject,
-  AiModelsSearchParams,
-  AiOptions,
-  AiTextEmbeddingsInput,
-  Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Input,
-} from "@cloudflare/workers-types";
 
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
@@ -40,8 +28,7 @@ export interface WorkersAiDefinition {
   readonly binding: string;
 }
 
-export type WorkersAiBinding<ModelList extends AiModelListType = AiModels> =
-  CloudflareAi<ModelList>;
+export type WorkersAiBinding<ModelList extends AiModelListType = AiModels> = Ai<ModelList>;
 export type WorkersAiOptions = AiOptions;
 export type WorkersAiModelsSearchParams = AiModelsSearchParams;
 export type WorkersAiModelsSearchObject = AiModelsSearchObject;
@@ -113,9 +100,7 @@ export interface WorkersAiClient<ModelList extends AiModelListType = AiModels> {
   readonly models: (
     params?: WorkersAiModelsSearchParams,
   ) => Effect.Effect<ReadonlyArray<WorkersAiModelsSearchObject>, WorkersAiOperationError>;
-  readonly gateway: (
-    gatewayId: string,
-  ) => Effect.Effect<CloudflareAiGateway, WorkersAiOperationError>;
+  readonly gateway: (gatewayId: string) => Effect.Effect<AiGateway, WorkersAiOperationError>;
   readonly rawUnsafe: Effect.Effect<WorkersAiBinding<ModelList>>;
   readonly definition: WorkersAiDefinition;
 }

package/src/WorkflowBinding.ts

@@ -1,12 +1,3 @@
-import type {
-  InstanceStatus as CloudflareInstanceStatus,
-  Workflow as CloudflareWorkflow,
-  WorkflowInstance as CloudflareWorkflowInstance,
-  WorkflowInstanceCreateOptions as CloudflareWorkflowInstanceCreateOptions,
-  WorkflowInstanceLocationHint as CloudflareWorkflowInstanceLocationHint,
-  WorkflowInstanceRestartOptions as CloudflareWorkflowInstanceRestartOptions,
-  WorkflowInstanceTerminateOptions as CloudflareWorkflowInstanceTerminateOptions,
-} from "@cloudflare/workers-types";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
@@ -21,7 +12,7 @@ import * as ErrorMessage from "./internal/ErrorMessage";
 const expectedWorkflow = "Workflow binding with create(), createBatch(), and get()";
 
 export type WorkflowInstanceCreateOptions<Payload> = Omit<
-  CloudflareWorkflowInstanceCreateOptions<Payload>,
+  globalThis.WorkflowInstanceCreateOptions<Payload>,
   "params"
 >;
 
@@ -29,11 +20,11 @@ export type WorkflowInstanceCreateBatchOptions<Payload, EncodedPayload = unknown
   { readonly payload: Payload } & WorkflowInstanceCreateOptions<EncodedPayload>
 >;
 
-export type WorkflowInstanceRestartOptions = CloudflareWorkflowInstanceRestartOptions;
-export type WorkflowInstanceTerminateOptions = CloudflareWorkflowInstanceTerminateOptions;
-export type WorkflowInstanceLocationHint = CloudflareWorkflowInstanceLocationHint;
+export type WorkflowInstanceLocationHint = globalThis.WorkflowInstanceLocationHint;
+export type WorkflowInstanceRestartOptions = globalThis.WorkflowInstanceRestartOptions;
+export type WorkflowInstanceTerminateOptions = globalThis.WorkflowInstanceTerminateOptions;
 
-export type WorkflowInstanceStatusName = CloudflareInstanceStatus["status"];
+export type WorkflowInstanceStatusName = InstanceStatus["status"];
 
 export interface WorkflowInstanceStatus<Result> {
   readonly status: WorkflowInstanceStatusName;
@@ -45,7 +36,7 @@ export interface WorkflowInstanceStatus<Result> {
 }
 
 export interface WorkflowInstance<Result> {
-  readonly raw: CloudflareWorkflowInstance;
+  readonly raw: globalThis.WorkflowInstance;
   readonly id: string;
   readonly pause: Effect.Effect<void, WorkflowOperationError>;
   readonly resume: Effect.Effect<void, WorkflowOperationError>;
@@ -97,7 +88,7 @@ export interface WorkflowBindingClient<
   readonly get: (
     instanceId: string,
   ) => Effect.Effect<WorkflowInstance<S.Schema.Type<Result>>, WorkflowOperationError>;
-  readonly rawUnsafe: Effect.Effect<CloudflareWorkflow<S.Codec.Encoded<Payload>>>;
+  readonly rawUnsafe: Effect.Effect<Workflow<S.Codec.Encoded<Payload>>>;
 }
 
 export class WorkflowOperationError extends Data.TaggedError("WorkflowOperationError")<{
@@ -136,7 +127,7 @@ const tryWorkflowPromise = <A>(
 type WorkflowBindingValue = S.Schema.Type<typeof S.Unknown>;
 
 const WorkflowBindingSchema = S.declare(
-  (value: WorkflowBindingValue): value is CloudflareWorkflow<WorkflowBindingValue> =>
+  (value: WorkflowBindingValue): value is Workflow<WorkflowBindingValue> =>
     Predicate.hasProperty(value, "create") &&
     Predicate.isFunction(value.create) &&
     Predicate.hasProperty(value, "createBatch") &&
@@ -146,18 +137,15 @@ const WorkflowBindingSchema = S.declare(
 );
 const decodeWorkflowBinding = S.decodeUnknownOption(WorkflowBindingSchema);
 
-export const isWorkflow = <Payload>(
-  value: WorkflowBindingValue,
-): value is CloudflareWorkflow<Payload> => Option.isSome(decodeWorkflowBinding(value));
+export const isWorkflow = <Payload>(value: WorkflowBindingValue): value is Workflow<Payload> =>
+  Option.isSome(decodeWorkflowBinding(value));
 
 export const makeClient = <
   Payload extends RpcDefinition.ServiceFreeSchema,
   Result extends RpcDefinition.ServiceFreeSchema,
 >(
   definition: WorkflowBindingDefinition<Payload, Result>,
-): ((
-  workflow: CloudflareWorkflow<S.Codec.Encoded<Payload>>,
-) => WorkflowBindingClient<Payload, Result>) => {
+): ((workflow: Workflow<S.Codec.Encoded<Payload>>) => WorkflowBindingClient<Payload, Result>) => {
   type PayloadValue = S.Schema.Type<Payload>;
   type EncodedPayload = S.Codec.Encoded<Payload>;
   type ResultValue = S.Schema.Type<Result>;
@@ -165,7 +153,7 @@ export const makeClient = <
   const encodePayload = S.encodeEffect(definition.payload);
   const decodeResult = S.decodeUnknownEffect(definition.result);
 
-  const wrapInstance = (raw: CloudflareWorkflowInstance): WorkflowInstance<ResultValue> => {
+  const wrapInstance = (raw: globalThis.WorkflowInstance): WorkflowInstance<ResultValue> => {
     const operation = <A>(name: string, evaluate: () => Promise<A>) =>
       tryWorkflowPromise(definition.binding, name, evaluate);
 
@@ -229,7 +217,7 @@ export const makeClient = <
     createBatch: Effect.fn("WorkflowBinding.createBatch", {
       attributes: { binding: definition.binding, operation: "createBatch" },
     })(function* (batch: WorkflowInstanceCreateBatchOptions<PayloadValue, EncodedPayload>) {
-      const encodedBatch: Array<CloudflareWorkflowInstanceCreateOptions<EncodedPayload>> = [];
+      const encodedBatch: Array<globalThis.WorkflowInstanceCreateOptions<EncodedPayload>> = [];
 
       for (const item of batch) {
         const { payload, ...options } = item;
@@ -265,7 +253,7 @@ export const layer = <
   Binding.layer(
     tag,
     definition.binding,
-    (value): value is CloudflareWorkflow<S.Codec.Encoded<Payload>> =>
+    (value): value is Workflow<S.Codec.Encoded<Payload>> =>
       isWorkflow<S.Codec.Encoded<Payload>>(value),
     makeClient(definition),
     { expected: expectedWorkflow },