effect-cf 0.13.1 → 0.15.0

package/src/Email.ts

@@ -0,0 +1,134 @@
+import type {
+  EmailAddress as CloudflareEmailAddress,
+  EmailAttachment as CloudflareEmailAttachment,
+  EmailMessage as CloudflareEmailMessage,
+  EmailSendResult as CloudflareEmailSendResult,
+  SendEmail as CloudflareSendEmail,
+} from "@cloudflare/workers-types";
+import { Context, Data, Effect, type Layer } from "effect";
+
+import * as Binding from "./Binding";
+import type { WorkerEnvironment } from "./Environment";
+
+const expectedSendEmailBinding = "Send Email binding with send()";
+
+/** Error raised when a Cloudflare Send Email operation fails. */
+export class EmailOperationError extends Data.TaggedError("EmailOperationError")<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {}
+
+/** Typed Cloudflare Send Email binding definition. */
+export interface EmailDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+
+export type EmailAddress = CloudflareEmailAddress;
+export type EmailAttachment = CloudflareEmailAttachment;
+export type EmailMessage = CloudflareEmailMessage;
+export type EmailMessageBuilder = Parameters<CloudflareSendEmail["send"]>[0];
+export type EmailSendInput = EmailMessage | EmailMessageBuilder;
+export type EmailSendResult = CloudflareEmailSendResult;
+export type EmailBinding = CloudflareSendEmail;
+
+interface EmailRuntimeBinding {
+  readonly send: (message: EmailSendInput) => Promise<EmailSendResult>;
+}
+
+export interface EmailClient {
+  readonly send: {
+    (message: EmailMessage): Effect.Effect<EmailSendResult, EmailOperationError>;
+    (builder: EmailMessageBuilder): Effect.Effect<EmailSendResult, EmailOperationError>;
+  };
+  readonly unsafeRaw: Effect.Effect<EmailBinding>;
+  readonly definition: EmailDefinition;
+}
+
+declare const EmailServiceTypeId: unique symbol;
+
+/** Nominal service marker for Send Email services created with {@link make}. */
+export interface EmailService<Id extends string> {
+  readonly [EmailServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+
+export type LayerOptions = {
+  readonly binding: string;
+};
+
+export interface TagClass<Self, Id extends string> extends Context.ServiceClass<
+  Self,
+  Id,
+  EmailClient
+> {
+  readonly id: Id;
+  readonly layer: (
+    options: LayerOptions,
+  ) => Layer.Layer<
+    Self,
+    Binding.BindingNotFoundError | Binding.BindingValidationError,
+    WorkerEnvironment
+  >;
+}
+
+const emailError = (binding: string, operation: string, cause: unknown) =>
+  new EmailOperationError({ binding, operation, cause });
+
+const tryEmailPromise = <A>(
+  binding: string,
+  operation: string,
+  evaluate: () => Promise<A>,
+): Effect.Effect<A, EmailOperationError> =>
+  Effect.tryPromise({
+    try: evaluate,
+    catch: (cause) => emailError(binding, operation, cause),
+  });
+
+export const isEmailBinding = (value: unknown): value is EmailBinding => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+
+  const resource = value as Record<string, unknown>;
+
+  return typeof resource.send === "function";
+};
+
+export const makeClient =
+  (definition: EmailDefinition) =>
+  (email: EmailBinding): EmailClient => {
+    const runtime = email as EmailRuntimeBinding;
+    const send = ((message: EmailSendInput) =>
+      tryEmailPromise(definition.binding, "send", () =>
+        runtime.send(message),
+      )) as EmailClient["send"];
+
+    return {
+      definition,
+      send,
+      unsafeRaw: Effect.succeed(email),
+    };
+  };
+
+export const layer = <Self>(tag: Context.Service<Self, EmailClient>, definition: EmailDefinition) =>
+  Binding.layer(tag, definition.binding, isEmailBinding, makeClient(definition), {
+    expected: expectedSendEmailBinding,
+  });
+
+export const make = <Id extends string>(id: Id) => Tag<EmailService<Id>>()<Id>(id);
+
+export const Tag =
+  <Self>() =>
+  <Id extends string>(id: Id) => {
+    const tag = Context.Service<Self, EmailClient>()(id);
+
+    const makeLayer = (definition: LayerOptions) => layer(tag, definition);
+
+    return Object.assign(tag, {
+      id,
+      layer: makeLayer,
+    }) as TagClass<Self, Id>;
+  };

package/src/Environment.ts

@@ -25,7 +25,7 @@ type ScalarConfigKey = Extract<
 
 /**
  * Effect `Config` helpers for scalar Cloudflare vars and secrets declared on
- * `Cloudflare.Env` / generated `worker-configuration.d.ts`.
+ * `Cloudflare.Env`.
  *
  * Users still author their app config explicitly with Effect `Config`:
  *

package/src/Images.ts

@@ -1,3 +1,21 @@
+import type {
+  HostedImagesBinding as CloudflareHostedImagesBinding,
+  ImageDrawOptions as CloudflareImageDrawOptions,
+  ImageHandle as CloudflareImageHandle,
+  ImageInfoResponse as CloudflareImageInfoResponse,
+  ImageInputOptions as CloudflareImageInputOptions,
+  ImageList as CloudflareImageList,
+  ImageListOptions as CloudflareImageListOptions,
+  ImageMetadata as CloudflareImageMetadata,
+  ImageOutputOptions as CloudflareImageOutputOptions,
+  ImageTransform as CloudflareImageTransform,
+  ImageTransformationOutputOptions as CloudflareImageTransformationOutputOptions,
+  ImageTransformationResult as CloudflareImageTransformationResult,
+  ImageTransformer as CloudflareImageTransformer,
+  ImageUpdateOptions as CloudflareImageUpdateOptions,
+  ImageUploadOptions as CloudflareImageUploadOptions,
+  Response as CloudflareResponse,
+} from "@cloudflare/workers-types";
 import { Context, Data, Effect, Option, type Layer } from "effect";
 
 import * as Binding from "./Binding";
@@ -19,23 +37,23 @@ export interface ImagesDefinition {
   readonly binding: string;
 }
 
-export type ImageInfoResponse = globalThis.ImageInfoResponse;
-export type ImageTransform = globalThis.ImageTransform;
-export type ImageDrawOptions = globalThis.ImageDrawOptions;
-export type ImageInputOptions = globalThis.ImageInputOptions;
-export type ImageOutputOptions = globalThis.ImageOutputOptions;
-export type ImageTransformationOutputOptions = globalThis.ImageTransformationOutputOptions;
-export type ImageTransformationResult = globalThis.ImageTransformationResult;
-export type ImageUploadOptions = globalThis.ImageUploadOptions;
-export type ImageUpdateOptions = globalThis.ImageUpdateOptions;
-export type ImageListOptions = globalThis.ImageListOptions;
-export type ImageList = globalThis.ImageList;
-export type ImageMetadata = globalThis.ImageMetadata;
+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 ImageTransformationResult = CloudflareImageTransformationResult;
+export type ImageUploadOptions = CloudflareImageUploadOptions;
+export type ImageUpdateOptions = CloudflareImageUpdateOptions;
+export type ImageListOptions = CloudflareImageListOptions;
+export type ImageList = CloudflareImageList;
+export type ImageMetadata = CloudflareImageMetadata;
 export type ImageInputValue = ReadableStream<Uint8Array> | ArrayBuffer;
 export type ImageUploadValue = ReadableStream<Uint8Array> | ArrayBuffer;
 
 export interface DrawStepOptions {
-  readonly image: ReadableStream<Uint8Array> | globalThis.ImageTransformer;
+  readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
   readonly options?: ImageDrawOptions;
 }
 
@@ -58,8 +76,8 @@ export interface ProcessOptions {
 }
 
 export interface ImagesTransformationResultClient {
-  readonly raw: globalThis.ImageTransformationResult;
-  readonly response: Effect.Effect<globalThis.Response, ImagesOperationError>;
+  readonly raw: CloudflareImageTransformationResult;
+  readonly response: Effect.Effect<CloudflareResponse, ImagesOperationError>;
   readonly contentType: Effect.Effect<string, ImagesOperationError>;
   readonly image: (
     options?: ImageTransformationOutputOptions,
@@ -67,7 +85,7 @@ export interface ImagesTransformationResultClient {
 }
 
 export interface ImageHandleClient {
-  readonly raw: globalThis.ImageHandle;
+  readonly raw: CloudflareImageHandle;
   readonly details: Effect.Effect<Option.Option<ImageMetadata>, ImagesOperationError>;
   readonly bytes: Effect.Effect<Option.Option<ReadableStream<Uint8Array>>, ImagesOperationError>;
   readonly update: (
@@ -83,7 +101,7 @@ export interface HostedImagesClient {
     options?: ImageUploadOptions,
   ) => Effect.Effect<ImageMetadata, ImagesOperationError>;
   readonly list: (options?: ImageListOptions) => Effect.Effect<ImageList, ImagesOperationError>;
-  readonly unsafeRaw: Effect.Effect<globalThis.HostedImagesBinding>;
+  readonly unsafeRaw: Effect.Effect<CloudflareHostedImagesBinding>;
 }
 
 export interface ImagesRuntimeBinding {
@@ -94,8 +112,8 @@ export interface ImagesRuntimeBinding {
   readonly input: (
     image: ImageInputValue,
     options?: ImageInputOptions,
-  ) => globalThis.ImageTransformer;
-  readonly hosted?: globalThis.HostedImagesBinding;
+  ) => CloudflareImageTransformer;
+  readonly hosted?: CloudflareHostedImagesBinding;
 }
 
 export interface ImagesClient {
@@ -106,7 +124,7 @@ export interface ImagesClient {
   readonly input: (
     image: ImageInputValue,
     options?: ImageInputOptions,
-  ) => Effect.Effect<globalThis.ImageTransformer, ImagesOperationError>;
+  ) => Effect.Effect<CloudflareImageTransformer, ImagesOperationError>;
   readonly process: (
     steps: Steps,
     options: ProcessOptions,
@@ -223,7 +241,7 @@ const maybe = <A>(value: A | null): Option.Option<A> =>
 const hasFunction = (value: object, key: string): boolean =>
   typeof Reflect.get(value, key) === "function";
 
-const isHostedImagesBinding = (value: unknown): value is globalThis.HostedImagesBinding =>
+const isHostedImagesBinding = (value: unknown): value is CloudflareHostedImagesBinding =>
   typeof value === "object" &&
   value !== null &&
   hasFunction(value, "image") &&
@@ -238,7 +256,7 @@ export const isImagesBinding = (value: unknown): value is ImagesRuntimeBinding =
 
 const wrapResult = (
   binding: string,
-  result: globalThis.ImageTransformationResult,
+  result: CloudflareImageTransformationResult,
 ): ImagesTransformationResultClient => ({
   raw: result,
   response: tryImagesSync(binding, "response", () => result.response()),
@@ -246,7 +264,7 @@ const wrapResult = (
   image: (options) => tryImagesSync(binding, "image", () => result.image(options)),
 });
 
-const wrapHandle = (binding: string, handle: globalThis.ImageHandle): ImageHandleClient => ({
+const wrapHandle = (binding: string, handle: CloudflareImageHandle): ImageHandleClient => ({
   raw: handle,
   details: tryImagesPromise(binding, "details", () => handle.details()).pipe(Effect.map(maybe)),
   bytes: tryImagesPromise(binding, "bytes", () => handle.bytes()).pipe(Effect.map(maybe)),
@@ -256,7 +274,7 @@ const wrapHandle = (binding: string, handle: globalThis.ImageHandle): ImageHandl
 
 const wrapHosted = (
   binding: string,
-  hosted: globalThis.HostedImagesBinding,
+  hosted: CloudflareHostedImagesBinding,
 ): HostedImagesClient => ({
   image: (imageId) => wrapHandle(binding, hosted.image(imageId)),
   upload: (image, options) =>

package/src/Kv.ts

@@ -1,3 +1,7 @@
+import type {
+  KVNamespaceListOptions as CloudflareKVNamespaceListOptions,
+  KVNamespacePutOptions as CloudflareKVNamespacePutOptions,
+} from "@cloudflare/workers-types";
 import { Context, Data, Effect, Option, Schema as S, type Layer } from "effect";
 
 import * as Binding from "./Binding";
@@ -14,9 +18,9 @@ export class KvOperationError extends Data.TaggedError("KvOperationError")<{
 }> {}
 
 /** `KVNamespace.put` options. */
-export type KvPutOptions = globalThis.KVNamespacePutOptions;
+export type KvPutOptions = CloudflareKVNamespacePutOptions;
 /** `KVNamespace.list` options with optional metadata decoding schema. */
-export type KvListOptions<Metadata = unknown> = globalThis.KVNamespaceListOptions & {
+export type KvListOptions<Metadata = unknown> = CloudflareKVNamespaceListOptions & {
   readonly metadataSchema?: S.Codec<Metadata, unknown>;
 };
 

package/src/QueueBinding.ts

@@ -1,17 +1,26 @@
+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 { Context, Data, Effect, Schema as S } from "effect";
 
 import * as Binding from "./Binding";
 import type * as RpcDefinition from "./RpcDefinition";
 
-export type QueueSendOptions = globalThis.QueueSendOptions;
-export type QueueSendResponse = globalThis.QueueSendResponse;
-export type QueueSendBatchOptions = globalThis.QueueSendBatchOptions;
-export type QueueSendBatchResponse = globalThis.QueueSendBatchResponse;
-export type QueueMetrics = globalThis.QueueMetrics;
-export type MessageSendRequest<Body> = globalThis.MessageSendRequest<Body>;
+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 QueueProducer<Body> = Pick<globalThis.Queue<Body>, "send"> &
-  Partial<Pick<globalThis.Queue<Body>, "sendBatch" | "metrics">>;
+export type QueueProducer<Body> = Pick<CloudflareQueue<Body>, "send"> &
+  Partial<Pick<CloudflareQueue<Body>, "sendBatch" | "metrics">>;
 
 const expectedQueueProducer = "Queue producer binding with send(); optional sendBatch()/metrics()";
 
@@ -32,7 +41,7 @@ export interface QueueBindingClient<Message extends RpcDefinition.ServiceFreeSch
     options?: QueueSendBatchOptions,
   ) => Effect.Effect<void, QueueOperationError | S.SchemaError>;
   readonly metrics: () => Effect.Effect<QueueMetrics, QueueOperationError>;
-  readonly unsafeRaw: Effect.Effect<globalThis.Queue<S.Codec.Encoded<Message>>>;
+  readonly unsafeRaw: Effect.Effect<CloudflareQueue<S.Codec.Encoded<Message>>>;
 }
 
 export class QueueOperationError extends Data.TaggedError("QueueOperationError")<{
@@ -129,7 +138,7 @@ export const makeClient = <Message extends RpcDefinition.ServiceFreeSchema>(
 
       return tryQueuePromise(definition.binding, "metrics", () => metrics.call(queue));
     },
-    unsafeRaw: Effect.succeed(queue as globalThis.Queue<EncodedBody>),
+    unsafeRaw: Effect.succeed(queue as CloudflareQueue<EncodedBody>),
   });
 };
 

package/src/R2.ts

@@ -1,3 +1,17 @@
+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 { Context, Data, Effect, Option, type Layer } from "effect";
 
 import * as Binding from "./Binding";
@@ -19,19 +33,19 @@ export interface R2Definition {
   readonly binding: string;
 }
 
-export type R2GetOptions = globalThis.R2GetOptions;
-export type R2PutOptions = globalThis.R2PutOptions;
-export type R2ListOptions = globalThis.R2ListOptions;
-export type R2MultipartOptions = globalThis.R2MultipartOptions;
-export type R2UploadPartOptions = globalThis.R2UploadPartOptions;
+export type R2GetOptions = CloudflareR2GetOptions;
+export type R2PutOptions = CloudflareR2PutOptions;
+export type R2ListOptions = CloudflareR2ListOptions;
+export type R2MultipartOptions = CloudflareR2MultipartOptions;
+export type R2UploadPartOptions = CloudflareR2UploadPartOptions;
 export type R2PutValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | null | Blob;
 export type R2UploadPartValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | Blob;
 
 export interface R2ObjectBodyClient extends Omit<
-  globalThis.R2ObjectBody,
+  CloudflareR2ObjectBody,
   "arrayBuffer" | "blob" | "bytes" | "json" | "text"
 > {
-  readonly raw: globalThis.R2ObjectBody;
+  readonly raw: CloudflareR2ObjectBody;
   readonly arrayBuffer: Effect.Effect<ArrayBuffer, R2OperationError>;
   readonly bytes: Effect.Effect<Uint8Array, R2OperationError>;
   readonly text: Effect.Effect<string, R2OperationError>;
@@ -40,29 +54,29 @@ export interface R2ObjectBodyClient extends Omit<
 }
 
 export interface R2MultipartUploadClient {
-  readonly raw: globalThis.R2MultipartUpload;
+  readonly raw: CloudflareR2MultipartUpload;
   readonly key: string;
   readonly uploadId: string;
   readonly uploadPart: (
     partNumber: number,
     value: R2UploadPartValue,
     options?: R2UploadPartOptions,
-  ) => Effect.Effect<globalThis.R2UploadedPart, R2OperationError>;
+  ) => Effect.Effect<CloudflareR2UploadedPart, R2OperationError>;
   readonly abort: Effect.Effect<void, R2OperationError>;
   readonly complete: (
-    uploadedParts: ReadonlyArray<globalThis.R2UploadedPart>,
-  ) => Effect.Effect<globalThis.R2Object, R2OperationError>;
+    uploadedParts: ReadonlyArray<CloudflareR2UploadedPart>,
+  ) => Effect.Effect<CloudflareR2Object, R2OperationError>;
 }
 
 export interface R2Client {
   readonly head: (
     key: string,
-  ) => Effect.Effect<Option.Option<globalThis.R2Object>, R2OperationError>;
+  ) => Effect.Effect<Option.Option<CloudflareR2Object>, R2OperationError>;
   readonly get: {
     (
       key: string,
-      options: R2GetOptions & { readonly onlyIf: globalThis.R2Conditional | Headers },
-    ): Effect.Effect<Option.Option<R2ObjectBodyClient | globalThis.R2Object>, R2OperationError>;
+      options: R2GetOptions & { readonly onlyIf: CloudflareR2Conditional | Headers },
+    ): Effect.Effect<Option.Option<R2ObjectBodyClient | CloudflareR2Object>, R2OperationError>;
     (
       key: string,
       options?: R2GetOptions,
@@ -72,13 +86,13 @@ export interface R2Client {
     (
       key: string,
       value: R2PutValue,
-      options: R2PutOptions & { readonly onlyIf: globalThis.R2Conditional | Headers },
-    ): Effect.Effect<Option.Option<globalThis.R2Object>, R2OperationError>;
+      options: R2PutOptions & { readonly onlyIf: CloudflareR2Conditional | Headers },
+    ): Effect.Effect<Option.Option<CloudflareR2Object>, R2OperationError>;
     (
       key: string,
       value: R2PutValue,
       options?: R2PutOptions,
-    ): Effect.Effect<globalThis.R2Object, R2OperationError>;
+    ): Effect.Effect<CloudflareR2Object, R2OperationError>;
   };
   readonly createMultipartUpload: (
     key: string,
@@ -89,8 +103,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<globalThis.R2Objects, R2OperationError>;
-  readonly unsafeRaw: Effect.Effect<globalThis.R2Bucket>;
+  readonly list: (options?: R2ListOptions) => Effect.Effect<CloudflareR2Objects, R2OperationError>;
+  readonly unsafeRaw: Effect.Effect<CloudflareR2Bucket>;
   readonly definition: R2Definition;
 }
 
@@ -149,16 +163,16 @@ const maybe = <A>(value: A | null): Option.Option<A> =>
   value === null ? Option.none() : Option.some(value);
 
 const isR2ObjectBody = (
-  value: globalThis.R2ObjectBody | globalThis.R2Object,
-): value is globalThis.R2ObjectBody =>
+  value: CloudflareR2ObjectBody | CloudflareR2Object,
+): value is CloudflareR2ObjectBody =>
   "body" in value &&
-  typeof (value as globalThis.R2ObjectBody).arrayBuffer === "function" &&
-  typeof (value as globalThis.R2ObjectBody).bytes === "function" &&
-  typeof (value as globalThis.R2ObjectBody).text === "function" &&
-  typeof (value as globalThis.R2ObjectBody).json === "function" &&
-  typeof (value as globalThis.R2ObjectBody).blob === "function";
+  typeof (value as CloudflareR2ObjectBody).arrayBuffer === "function" &&
+  typeof (value as CloudflareR2ObjectBody).bytes === "function" &&
+  typeof (value as CloudflareR2ObjectBody).text === "function" &&
+  typeof (value as CloudflareR2ObjectBody).json === "function" &&
+  typeof (value as CloudflareR2ObjectBody).blob === "function";
 
-const wrapObjectBody = (binding: string, object: globalThis.R2ObjectBody): R2ObjectBodyClient => ({
+const wrapObjectBody = (binding: string, object: CloudflareR2ObjectBody): R2ObjectBodyClient => ({
   key: object.key,
   version: object.version,
   size: object.size,
@@ -186,8 +200,8 @@ const wrapObjectBody = (binding: string, object: globalThis.R2ObjectBody): R2Obj
 
 const wrapGetResult = (
   binding: string,
-  object: globalThis.R2ObjectBody | globalThis.R2Object | null,
-): R2ObjectBodyClient | globalThis.R2Object | null => {
+  object: CloudflareR2ObjectBody | CloudflareR2Object | null,
+): R2ObjectBodyClient | CloudflareR2Object | null => {
   if (object === null || !isR2ObjectBody(object)) {
     return object;
   }
@@ -195,7 +209,7 @@ const wrapGetResult = (
   return wrapObjectBody(binding, object);
 };
 
-export const isR2Bucket = (value: unknown): value is globalThis.R2Bucket => {
+export const isR2Bucket = (value: unknown): value is CloudflareR2Bucket => {
   if (typeof value !== "object" || value === null) {
     return false;
   }
@@ -215,8 +229,8 @@ export const isR2Bucket = (value: unknown): value is globalThis.R2Bucket => {
 
 export const makeClient = (
   definition: R2Definition,
-): ((bucket: globalThis.R2Bucket) => R2Client) => {
-  const wrapUpload = (upload: globalThis.R2MultipartUpload): R2MultipartUploadClient => ({
+): ((bucket: CloudflareR2Bucket) => R2Client) => {
+  const wrapUpload = (upload: CloudflareR2MultipartUpload): R2MultipartUploadClient => ({
     raw: upload,
     key: upload.key,
     uploadId: upload.uploadId,
@@ -246,7 +260,7 @@ export const makeClient = (
         tryR2Promise(definition.binding, "put", () => bucket.put(key, value, options)).pipe(
           Effect.map((object) => {
             if (object === null) {
-              return Option.none<globalThis.R2Object>();
+              return Option.none<CloudflareR2Object>();
             }
 
             if (options !== undefined && "onlyIf" in options) {