effect-cf 0.13.0 → 0.14.0

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) {

package/src/Vectorize.ts

@@ -0,0 +1,213 @@
+import { Context, Data, Effect, 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";
+
+const expectedVectorizeBinding =
+  "Vectorize index binding with describe(), query(), insert(), upsert(), deleteByIds(), and getByIds()";
+
+/** Error raised when a Vectorize operation fails. */
+export class VectorizeOperationError extends Data.TaggedError("VectorizeOperationError")<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {}
+
+/** Typed Vectorize binding definition. */
+export interface VectorizeDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  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 VectorizeValues = Float32Array | Float64Array | ReadonlyArray<number>;
+
+interface VectorizeRuntimeBinding {
+  readonly describe: () => Promise<VectorizeIndexInfo | VectorizeIndexDetails>;
+  readonly query: (
+    vector: Float32Array | Float64Array | number[],
+    options?: VectorizeQueryOptions,
+  ) => Promise<VectorizeMatches>;
+  readonly queryById?: (
+    vectorId: string,
+    options?: VectorizeQueryOptions,
+  ) => Promise<VectorizeMatches>;
+  readonly insert: (vectors: Array<VectorizeVector>) => Promise<VectorizeMutation>;
+  readonly upsert: (vectors: Array<VectorizeVector>) => Promise<VectorizeMutation>;
+  readonly deleteByIds: (ids: Array<string>) => Promise<VectorizeMutation>;
+  readonly getByIds: (ids: Array<string>) => Promise<Array<VectorizeVector>>;
+}
+
+export interface VectorizeClient {
+  readonly describe: Effect.Effect<
+    VectorizeIndexInfo | VectorizeIndexDetails,
+    VectorizeOperationError
+  >;
+  readonly query: (
+    vector: VectorizeValues,
+    options?: VectorizeQueryOptions,
+  ) => Effect.Effect<VectorizeMatches, VectorizeOperationError>;
+  readonly queryById: (
+    vectorId: string,
+    options?: VectorizeQueryOptions,
+  ) => Effect.Effect<VectorizeMatches, VectorizeOperationError>;
+  readonly insert: (
+    vectors: ReadonlyArray<VectorizeVector>,
+  ) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
+  readonly upsert: (
+    vectors: ReadonlyArray<VectorizeVector>,
+  ) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
+  readonly deleteByIds: (
+    ids: ReadonlyArray<string>,
+  ) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
+  readonly delete: (
+    ids: ReadonlyArray<string>,
+  ) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
+  readonly getByIds: (
+    ids: ReadonlyArray<string>,
+  ) => Effect.Effect<ReadonlyArray<VectorizeVector>, VectorizeOperationError>;
+  readonly unsafeRaw: Effect.Effect<VectorizeBinding>;
+  readonly definition: VectorizeDefinition;
+}
+
+declare const VectorizeServiceTypeId: unique symbol;
+
+/** Nominal service marker for Vectorize services created with {@link make}. */
+export interface VectorizeService<Id extends string> {
+  readonly [VectorizeServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+
+export type LayerOptions = {
+  readonly binding: string;
+};
+
+export interface TagClass<Self, Id extends string> extends Context.ServiceClass<
+  Self,
+  Id,
+  VectorizeClient
+> {
+  readonly id: Id;
+  readonly layer: (
+    options: LayerOptions,
+  ) => Layer.Layer<
+    Self,
+    Binding.BindingNotFoundError | Binding.BindingValidationError,
+    WorkerEnvironment
+  >;
+}
+
+const vectorizeError = (binding: string, operation: string, cause: unknown) =>
+  new VectorizeOperationError({ binding, operation, cause });
+
+const tryVectorizePromise = <A>(
+  binding: string,
+  operation: string,
+  evaluate: () => Promise<A>,
+): Effect.Effect<A, VectorizeOperationError> =>
+  Effect.tryPromise({
+    try: evaluate,
+    catch: (cause) => vectorizeError(binding, operation, cause),
+  });
+
+const hasFunction = (value: object, key: string): boolean =>
+  typeof Reflect.get(value, key) === "function";
+
+export const isVectorizeBinding = (value: unknown): value is VectorizeBinding =>
+  typeof value === "object" &&
+  value !== null &&
+  hasFunction(value, "describe") &&
+  hasFunction(value, "query") &&
+  hasFunction(value, "insert") &&
+  hasFunction(value, "upsert") &&
+  hasFunction(value, "deleteByIds") &&
+  hasFunction(value, "getByIds");
+
+export const makeClient =
+  (definition: VectorizeDefinition) =>
+  (index: VectorizeBinding): VectorizeClient => {
+    const runtime = index as VectorizeRuntimeBinding;
+    const deleteByIds = (ids: ReadonlyArray<string>) =>
+      tryVectorizePromise(definition.binding, "deleteByIds", () => runtime.deleteByIds([...ids]));
+
+    return {
+      definition,
+      describe: tryVectorizePromise(definition.binding, "describe", () => runtime.describe()),
+      query: (vector, options) =>
+        tryVectorizePromise(definition.binding, "query", () =>
+          runtime.query(vector as Float32Array | Float64Array | number[], options),
+        ),
+      queryById: (vectorId, options) =>
+        runtime.queryById !== undefined
+          ? tryVectorizePromise(definition.binding, "queryById", () =>
+              runtime.queryById!(vectorId, options),
+            )
+          : Effect.fail(
+              vectorizeError(
+                definition.binding,
+                "queryById",
+                new TypeError("Vectorize binding does not expose queryById()"),
+              ),
+            ),
+      insert: (vectors) =>
+        tryVectorizePromise(definition.binding, "insert", () => runtime.insert([...vectors])),
+      upsert: (vectors) =>
+        tryVectorizePromise(definition.binding, "upsert", () => runtime.upsert([...vectors])),
+      deleteByIds,
+      delete: deleteByIds,
+      getByIds: (ids) =>
+        tryVectorizePromise(definition.binding, "getByIds", () => runtime.getByIds([...ids])),
+      unsafeRaw: Effect.succeed(index),
+    };
+  };
+
+export const layer = <Self>(
+  tag: Context.Service<Self, VectorizeClient>,
+  definition: VectorizeDefinition,
+) =>
+  Binding.layer(tag, definition.binding, isVectorizeBinding, makeClient(definition), {
+    expected: expectedVectorizeBinding,
+  });
+
+export const make = <Id extends string>(id: Id) => Tag<VectorizeService<Id>>()<Id>(id);
+
+export const Tag =
+  <Self>() =>
+  <Id extends string>(id: Id) => {
+    const tag = Context.Service<Self, VectorizeClient>()(id);
+
+    const makeLayer = (definition: LayerOptions) => layer(tag, definition);
+
+    return Object.assign(tag, {
+      id,
+      layer: makeLayer,
+    }) as TagClass<Self, Id>;
+  };

package/src/Worker.ts

@@ -10,6 +10,7 @@ import type * as Rpc from "./Rpc";
 import type * as RpcDefinition from "./RpcDefinition";
 import type * as ServiceBinding from "./ServiceBinding";
 import * as WorkerDefinition from "./WorkerDefinition";
+import * as CloudflareClock from "./internal/Clock";
 import * as Entrypoint from "./internal/Entrypoint";
 import { fromExecutionContext, type RunWaitUntilEffect } from "./internal/WorkerContext";
 
@@ -241,6 +242,7 @@ export function make<
         Promise.reject(new Error("WorkerContext runtime is not initialized"));
 
       const services = Layer.mergeAll(
+        CloudflareClock.layer,
         Layer.succeed(ExecutionContext, ctx),
         ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))),
         Layer.succeed(