alchemy 2.0.0-beta.45 → 2.0.0-beta.46

package/src/Cloudflare/StateStore/Store.ts

@@ -32,7 +32,7 @@ export default class Store extends DurableObjectNamespace<Store>()(
       const cryptoKey = yield* Effect.tryPromise(() =>
         crypto.subtle.importKey(
           "raw",
-          hexToBytes(keyHex),
+          Buffer.from(keyHex, "hex"),
           { name: "AES-CTR" },
           false,
           ["encrypt", "decrypt"],
@@ -53,22 +53,31 @@ export default class Store extends DurableObjectNamespace<Store>()(
             ),
           );
           // Frame as a single base64 string: nonce || ciphertext.
-          const framed = allocBytes(counter.byteLength + ct.byteLength);
-          framed.set(counter, 0);
-          framed.set(ct, counter.byteLength);
-          return toB64(framed);
+          return Buffer.concat([counter, ct]).toString("base64");
         }).pipe(Effect.orDie);
 
       const decryptEntry = (entry: string) =>
         Effect.tryPromise(async () => {
-          const framed = fromB64(entry);
-          const counter = framed.slice(0, NONCE_BYTES);
-          const ciphertext = framed.slice(NONCE_BYTES);
-          const pt = await crypto.subtle.decrypt(
-            { name: "AES-CTR", counter, length: 64 },
-            cryptoKey,
-            ciphertext,
-          );
+          const framed = Buffer.from(entry, "base64");
+          const counter = framed.subarray(0, NONCE_BYTES);
+          const ciphertext = framed.subarray(NONCE_BYTES);
+          let pt;
+          try {
+            pt = await crypto.subtle.decrypt(
+              { name: "AES-CTR", counter, length: 64 },
+              cryptoKey,
+              ciphertext,
+            );
+          } catch (error) {
+            // We return undefined here because in 2.0.0-beta.45, we rotated encryption keys unnecessarily.
+            // So, we catch a decryption error here and return undefined instead.
+            // The engine should reconcile, hopefully, but users may lose some data
+            console.error(
+              "Error decrypting entry. Returning undefined instead.",
+              error,
+            );
+            return undefined;
+          }
           return JSON.parse(new TextDecoder().decode(pt)) as ResourceState;
         }).pipe(Effect.orDie);
 
@@ -303,25 +312,3 @@ const parseResourceKey = (
  */
 const allocBytes = (size: number): Uint8Array<ArrayBuffer> =>
   new Uint8Array(new ArrayBuffer(size));
-
-const toB64 = (bytes: Uint8Array): string => {
-  let s = "";
-  for (let i = 0; i < bytes.byteLength; i++)
-    s += String.fromCharCode(bytes[i]!);
-  return btoa(s);
-};
-
-const fromB64 = (s: string): Uint8Array<ArrayBuffer> => {
-  const bin = atob(s);
-  const bytes = allocBytes(bin.length);
-  for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
-  return bytes;
-};
-
-const hexToBytes = (hex: string): Uint8Array<ArrayBuffer> => {
-  const bytes = allocBytes(hex.length / 2);
-  for (let i = 0; i < bytes.length; i++) {
-    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return bytes;
-};

package/src/Cloudflare/Vectorize/VectorizeIndex.ts

@@ -0,0 +1,261 @@
+import * as vectorize from "@distilled.cloud/cloudflare/vectorize";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+
+import { isResolved } from "../../Diff.ts";
+import { createPhysicalName } from "../../PhysicalName.ts";
+import * as Provider from "../../Provider.ts";
+import { Resource } from "../../Resource.ts";
+import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
+import type { Providers } from "../Providers.ts";
+import { VectorizeIndexBinding } from "./VectorizeIndexBinding.ts";
+
+const VectorizeIndexTypeId = "Cloudflare.VectorizeIndex" as const;
+type VectorizeIndexTypeId = typeof VectorizeIndexTypeId;
+
+export type DistanceMetric = "cosine" | "euclidean" | "dot-product";
+
+export type VectorizePreset =
+  | "@cf/baai/bge-small-en-v1.5"
+  | "@cf/baai/bge-base-en-v1.5"
+  | "@cf/baai/bge-large-en-v1.5"
+  | "openai/text-embedding-ada-002"
+  | "cohere/embed-multilingual-v2.0"
+  // Keep the union open so new Cloudflare presets aren't blocked by stale types.
+  | (string & {});
+
+const DEFAULT_METRIC: DistanceMetric = "cosine";
+
+export type VectorizeIndexProps = {
+  /**
+   * Name of the index. If omitted, a unique name will be generated.
+   * Must be lowercase alphanumeric with hyphens. Changing it triggers a
+   * replacement.
+   * @default ${app}-${stage}-${id}
+   */
+  name?: string;
+  /**
+   * Number of dimensions for each vector stored in the index. Required
+   * unless `preset` is provided. Cannot be changed after creation —
+   * updating this property triggers a replacement.
+   */
+  dimensions?: number;
+  /**
+   * Distance metric used for similarity search. Cannot be changed after
+   * creation — updating this property triggers a replacement.
+   * @default "cosine"
+   */
+  metric?: DistanceMetric;
+  /**
+   * A managed embedding model preset that fixes `dimensions` and `metric`
+   * to match the named model. Mutually exclusive with `dimensions`/`metric`.
+   * Cannot be changed after creation — updating this triggers a replacement.
+   */
+  preset?: VectorizePreset;
+  /**
+   * Human-readable description of the index. Vectorize has no update API,
+   * so changing the description triggers a replacement.
+   */
+  description?: string;
+};
+
+export type VectorizeIndexAttributes = {
+  indexName: string;
+  dimensions: number | undefined;
+  metric: DistanceMetric | undefined;
+  description: string | undefined;
+  accountId: string;
+  createdOn: string | undefined;
+  modifiedOn: string | undefined;
+};
+
+export type VectorizeIndex = Resource<
+  VectorizeIndexTypeId,
+  VectorizeIndexProps,
+  VectorizeIndexAttributes,
+  never,
+  Providers
+>;
+
+/**
+ * A Cloudflare Vectorize index for storing and querying vector embeddings.
+ *
+ * Vectorize is a globally distributed vector database. Create an index as a
+ * resource, then bind it to a Worker to insert, upsert, and query vectors.
+ *
+ * A Vectorize index is identified by its name and is immutable: its
+ * dimensions, metric, preset, and description are all fixed at creation.
+ * Changing any of them triggers a replacement.
+ *
+ * @section Creating an Index
+ * @example Index with explicit dimensions and metric
+ * ```typescript
+ * const index = yield* Cloudflare.VectorizeIndex("my-index", {
+ *   dimensions: 768,
+ *   metric: "cosine",
+ * });
+ * ```
+ *
+ * @example Index from a managed embedding model preset
+ * A preset fixes the dimensions and metric to match the named model.
+ * ```typescript
+ * const index = yield* Cloudflare.VectorizeIndex("my-index", {
+ *   preset: "@cf/baai/bge-base-en-v1.5",
+ * });
+ * ```
+ *
+ * @example Index with a description
+ * ```typescript
+ * const index = yield* Cloudflare.VectorizeIndex("my-index", {
+ *   dimensions: 1536,
+ *   metric: "euclidean",
+ *   description: "Product catalog embeddings",
+ * });
+ * ```
+ *
+ * @section Binding to a Worker
+ * @example Querying an index inside a Worker
+ * ```typescript
+ * const index = yield* Cloudflare.VectorizeConnection.bind(MyIndex);
+ *
+ * // Insert vectors
+ * yield* index.upsert([
+ *   { id: "1", values: [0.1, 0.2, 0.3], metadata: { title: "doc" } },
+ * ]);
+ *
+ * // Query the nearest neighbors
+ * const matches = yield* index.query([0.1, 0.2, 0.3], { topK: 5 });
+ * ```
+ *
+ * @see https://developers.cloudflare.com/vectorize/
+ */
+export const VectorizeIndex = Resource<VectorizeIndex>(VectorizeIndexTypeId)({
+  bind: VectorizeIndexBinding.bind,
+});
+
+/**
+ * Returns true if the given value is a VectorizeIndex resource.
+ */
+export const isVectorizeIndex = (value: unknown): value is VectorizeIndex =>
+  Predicate.hasProperty(value, "Type") && value.Type === VectorizeIndexTypeId;
+
+export const VectorizeIndexProvider = () =>
+  Provider.effect(
+    VectorizeIndex,
+    Effect.gen(function* () {
+      const { accountId } = yield* CloudflareEnvironment;
+      const createIndex = yield* vectorize.createIndex;
+      const getIndex = yield* vectorize.getIndex;
+      const deleteIndex = yield* vectorize.deleteIndex;
+
+      const createIndexName = (id: string, name: string | undefined) =>
+        Effect.gen(function* () {
+          return name ?? (yield* createPhysicalName({ id, lowercase: true }));
+        });
+
+      const buildConfig = (
+        news: VectorizeIndexProps,
+      ): vectorize.CreateIndexRequest["config"] =>
+        news.preset !== undefined
+          ? // `VectorizePreset` is intentionally open (`| (string & {})`) so
+            // new Cloudflare presets aren't blocked by stale types. The
+            // distilled type is the strict-at-release-time union; cast
+            // through for the API call.
+            ({
+              preset: news.preset as never,
+            } as vectorize.CreateIndexRequest["config"])
+          : {
+              dimensions: news.dimensions!,
+              metric: news.metric ?? DEFAULT_METRIC,
+            };
+
+      return {
+        stables: ["indexName", "accountId"],
+        diff: Effect.fn(function* ({ id, olds = {}, news = {}, output }) {
+          if (!isResolved(news)) return undefined;
+          if ((output?.accountId ?? accountId) !== accountId) {
+            return { action: "replace" } as const;
+          }
+          const name = yield* createIndexName(id, news.name);
+          const oldName = output?.indexName
+            ? output.indexName
+            : yield* createIndexName(id, olds.name);
+          if (
+            oldName !== name ||
+            (news.preset ?? undefined) !== (olds.preset ?? undefined) ||
+            (news.dimensions ?? undefined) !== (olds.dimensions ?? undefined) ||
+            (news.metric ?? DEFAULT_METRIC) !==
+              (olds.metric ?? DEFAULT_METRIC) ||
+            (news.description ?? undefined) !== (olds.description ?? undefined)
+          ) {
+            return { action: "replace" } as const;
+          }
+          return undefined;
+        }),
+        read: Effect.fn(function* ({ id, output, olds }) {
+          const acct = output?.accountId ?? accountId;
+          const name =
+            output?.indexName ?? (yield* createIndexName(id, olds?.name));
+          return yield* getIndex({ accountId: acct, indexName: name }).pipe(
+            Effect.map((index) => toAttributes(index, name, acct)),
+            Effect.catchTag(["NotFound", "Gone"], () =>
+              Effect.succeed(undefined),
+            ),
+          );
+        }),
+        reconcile: Effect.fn(function* ({ id, news = {} }) {
+          const indexName = yield* createIndexName(id, news.name);
+
+          // Observe — read the live index by name. The name is the stable
+          // identifier; fall back through a NotFound to the create path so
+          // we recover from out-of-band deletes or partial state-persistence.
+          let observed = yield* getIndex({
+            accountId,
+            indexName,
+          }).pipe(
+            Effect.catchTag(["NotFound", "Gone"], () =>
+              Effect.succeed(undefined),
+            ),
+          );
+
+          // Ensure — create if missing. Cloudflare returns 409 Conflict when
+          // an index with the same name already exists; tolerate the race by
+          // re-reading it.
+          if (!observed) {
+            observed = yield* createIndex({
+              accountId,
+              name: indexName,
+              config: buildConfig(news),
+              description: news.description,
+            }).pipe(
+              Effect.catchTag("IndexAlreadyExists", () =>
+                getIndex({ accountId, indexName }),
+              ),
+            );
+          }
+
+          return toAttributes(observed, indexName, accountId);
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          yield* deleteIndex({
+            accountId: output.accountId,
+            indexName: output.indexName,
+          }).pipe(Effect.catchTag(["NotFound", "Gone"], () => Effect.void));
+        }),
+      };
+    }),
+  );
+
+const toAttributes = (
+  index: vectorize.GetIndexResponse | vectorize.CreateIndexResponse,
+  name: string,
+  accountId: string,
+): VectorizeIndexAttributes => ({
+  indexName: index.name ?? name,
+  dimensions: index.config?.dimensions,
+  metric: index.config?.metric,
+  description: index.description ?? undefined,
+  accountId,
+  createdOn: index.createdOn ?? undefined,
+  modifiedOn: index.modifiedOn ?? undefined,
+});

package/src/Cloudflare/Vectorize/VectorizeIndexBinding.ts

@@ -0,0 +1,103 @@
+import type * as runtime from "@cloudflare/workers-types";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Binding from "../../Binding.ts";
+import type { ResourceLike } from "../../Resource.ts";
+import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
+import type { VectorizeIndex } from "./VectorizeIndex.ts";
+
+export interface VectorizeIndexClient {
+  /**
+   * An Effect that resolves to the raw underlying Cloudflare Vectorize
+   * binding. Use this for direct access not covered by the helpers below.
+   */
+  raw: Effect.Effect<runtime.Vectorize>;
+  /** Get information about the bound index (dimensions, vector count). */
+  describe: () => Effect.Effect<runtime.VectorizeIndexInfo>;
+  /** Find the nearest neighbors of `vector`. */
+  query: (
+    vector: runtime.VectorFloatArray | number[],
+    options?: runtime.VectorizeQueryOptions,
+  ) => Effect.Effect<runtime.VectorizeMatches>;
+  /** Find the nearest neighbors of an existing vector by its id. */
+  queryById: (
+    vectorId: string,
+    options?: runtime.VectorizeQueryOptions,
+  ) => Effect.Effect<runtime.VectorizeMatches>;
+  /** Insert vectors. Throws if any provided id already exists. */
+  insert: (
+    vectors: runtime.VectorizeVector[],
+  ) => Effect.Effect<runtime.VectorizeAsyncMutation>;
+  /** Upsert vectors, replacing any existing vectors with matching ids. */
+  upsert: (
+    vectors: runtime.VectorizeVector[],
+  ) => Effect.Effect<runtime.VectorizeAsyncMutation>;
+  /** Delete vectors by id. */
+  deleteByIds: (ids: string[]) => Effect.Effect<runtime.VectorizeAsyncMutation>;
+  /** Fetch vectors by id. */
+  getByIds: (ids: string[]) => Effect.Effect<runtime.VectorizeVector[]>;
+}
+
+export class VectorizeIndexBinding extends Binding.Service<
+  VectorizeIndexBinding,
+  (index: VectorizeIndex) => Effect.Effect<VectorizeIndexClient>
+>()("Cloudflare.Vectorize.IndexBinding") {}
+
+export const VectorizeIndexBindingLive = Layer.effect(
+  VectorizeIndexBinding,
+  Effect.gen(function* () {
+    const Policy = yield* VectorizeIndexBindingPolicy;
+
+    return Effect.fn(function* (index: VectorizeIndex) {
+      yield* Policy(index);
+      const rawEff = yield* Effect.serviceOption(WorkerEnvironment).pipe(
+        Effect.map(Option.getOrUndefined),
+        Effect.map((env) => env?.[index.LogicalId]! as runtime.Vectorize),
+        Effect.cached,
+      );
+
+      const withRuntime = <A>(fn: (raw: runtime.Vectorize) => Promise<A>) =>
+        Effect.flatMap(rawEff, (raw) => Effect.promise(() => fn(raw)));
+
+      return {
+        raw: rawEff,
+        describe: () => withRuntime((raw) => raw.describe()),
+        query: (vector, options) =>
+          withRuntime((raw) => raw.query(vector, options)),
+        queryById: (vectorId, options) =>
+          withRuntime((raw) => raw.queryById(vectorId, options)),
+        insert: (vectors) => withRuntime((raw) => raw.insert(vectors)),
+        upsert: (vectors) => withRuntime((raw) => raw.upsert(vectors)),
+        deleteByIds: (ids) => withRuntime((raw) => raw.deleteByIds(ids)),
+        getByIds: (ids) => withRuntime((raw) => raw.getByIds(ids)),
+      } satisfies VectorizeIndexClient;
+    });
+  }),
+);
+
+export class VectorizeIndexBindingPolicy extends Binding.Policy<
+  VectorizeIndexBindingPolicy,
+  (index: VectorizeIndex) => Effect.Effect<void>
+>()("Cloudflare.Vectorize.IndexBinding") {}
+
+export const VectorizeIndexBindingPolicyLive =
+  VectorizeIndexBindingPolicy.layer.succeed(
+    Effect.fn(function* (host: ResourceLike, index: VectorizeIndex) {
+      if (isWorker(host)) {
+        yield* host.bind`${index}`({
+          bindings: [
+            {
+              type: "vectorize",
+              name: index.LogicalId,
+              indexName: index.indexName,
+            },
+          ],
+        });
+      } else {
+        return yield* Effect.die(
+          new Error(`IndexBinding does not support runtime '${host.Type}'`),
+        );
+      }
+    }),
+  );

package/src/Cloudflare/Vectorize/VectorizeMetadataIndex.ts

@@ -0,0 +1,208 @@
+import * as vectorize from "@distilled.cloud/cloudflare/vectorize";
+import * as Effect from "effect/Effect";
+
+import { isResolved } from "../../Diff.ts";
+import * as Provider from "../../Provider.ts";
+import { Resource } from "../../Resource.ts";
+import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
+import type { Providers } from "../Providers.ts";
+
+export type MetadataIndexType = "string" | "number" | "boolean";
+
+export type VectorizeMetadataIndexProps = {
+  /**
+   * Name of the parent Vectorize index. Pass `index.indexName` from a
+   * `VectorizeIndex` to track the dependency. Changing the parent index
+   * triggers a replacement.
+   */
+  indexName: string;
+  /**
+   * The metadata property to index. Filter expressions in `query` use this
+   * name (e.g. `{ category: { $eq: "books" } }`). Cannot be changed after
+   * creation — updating triggers a replacement.
+   */
+  propertyName: string;
+  /**
+   * The type of metadata values stored under `propertyName`. Cannot be
+   * changed after creation — updating triggers a replacement.
+   */
+  indexType: MetadataIndexType;
+};
+
+export type VectorizeMetadataIndexAttributes = {
+  propertyName: string;
+  indexType: MetadataIndexType;
+  indexName: string;
+  accountId: string;
+  mutationId: string | undefined;
+};
+
+export type VectorizeMetadataIndex = Resource<
+  "Cloudflare.VectorizeMetadataIndex",
+  VectorizeMetadataIndexProps,
+  VectorizeMetadataIndexAttributes,
+  never,
+  Providers
+>;
+
+/**
+ * A metadata index on a Cloudflare Vectorize index.
+ *
+ * Metadata indexes enable filtering query results by metadata properties.
+ * Without a metadata index on a property, that property cannot be used in
+ * the `filter` of a `query()` call.
+ *
+ * A metadata index is identified by its parent index and `propertyName` and
+ * is immutable — changing the property name, type, or parent index triggers
+ * a replacement.
+ *
+ * @section Creating a Metadata Index
+ * @example Index a string metadata property
+ * ```typescript
+ * const index = yield* Cloudflare.VectorizeIndex("my-index", {
+ *   dimensions: 768,
+ *   metric: "cosine",
+ * });
+ *
+ * yield* Cloudflare.VectorizeMetadataIndex("CategoryMetaIndex", {
+ *   indexName: index.indexName,
+ *   propertyName: "category",
+ *   indexType: "string",
+ * });
+ * ```
+ *
+ * @example Index a numeric metadata property
+ * ```typescript
+ * yield* Cloudflare.VectorizeMetadataIndex("PriceMetaIndex", {
+ *   indexName: index.indexName,
+ *   propertyName: "price",
+ *   indexType: "number",
+ * });
+ * ```
+ *
+ * @see https://developers.cloudflare.com/vectorize/reference/metadata-filtering/
+ */
+export const VectorizeMetadataIndex = Resource<VectorizeMetadataIndex>(
+  "Cloudflare.VectorizeMetadataIndex",
+);
+
+export const VectorizeMetadataIndexProvider = () =>
+  Provider.effect(
+    VectorizeMetadataIndex,
+    Effect.gen(function* () {
+      const { accountId } = yield* CloudflareEnvironment;
+      const createMetadataIndex = yield* vectorize.createIndexMetadataIndex;
+      const deleteMetadataIndex = yield* vectorize.deleteIndexMetadataIndex;
+      const listMetadataIndexes = yield* vectorize.listIndexMetadataIndexes;
+
+      const findExisting = (
+        acct: string,
+        indexName: string,
+        propertyName: string,
+      ) =>
+        listMetadataIndexes({
+          accountId: acct,
+          indexName,
+        }).pipe(
+          Effect.map((res) => {
+            const index = res.metadataIndexes?.find(
+              (m) => m.propertyName === propertyName,
+            );
+            return index
+              ? {
+                  propertyName: index.propertyName,
+                  indexType:
+                    index.indexType?.toLowerCase() as MetadataIndexType,
+                }
+              : undefined;
+          }),
+          Effect.catchTag(["NotFound", "Gone"], () =>
+            Effect.succeed(undefined),
+          ),
+        );
+
+      return {
+        stables: ["propertyName", "indexName", "accountId"],
+        diff: Effect.fn(function* ({ olds, news, output }) {
+          if (!isResolved(news)) return undefined;
+          if ((output?.accountId ?? accountId) !== accountId) {
+            return { action: "replace" } as const;
+          }
+          const newIndexName = news.indexName;
+          const oldIndexName = output?.indexName ?? olds.indexName;
+          if (
+            (oldIndexName ?? newIndexName) !== newIndexName ||
+            (olds.propertyName ?? news.propertyName) !== news.propertyName ||
+            (olds.indexType ?? news.indexType) !== news.indexType
+          ) {
+            return { action: "replace" } as const;
+          }
+          return undefined;
+        }),
+        read: Effect.fn(function* ({ output, olds }) {
+          const acct = output?.accountId ?? accountId;
+          const indexName = output?.indexName ?? olds?.indexName;
+          const propertyName = output?.propertyName ?? olds?.propertyName;
+          if (!indexName || !propertyName) return undefined;
+          const existing = yield* findExisting(acct, indexName, propertyName);
+          if (!existing?.propertyName || !existing.indexType) return undefined;
+          return {
+            propertyName: existing.propertyName,
+            indexType: existing.indexType,
+            indexName,
+            accountId: acct,
+            mutationId: output?.mutationId,
+          };
+        }),
+        reconcile: Effect.fn(function* ({ news, output }) {
+          const acct = output?.accountId ?? accountId;
+          const indexName = news.indexName;
+
+          // Observe — list metadata indexes on the parent and look for one
+          // matching propertyName.
+          const existing = yield* findExisting(
+            acct,
+            indexName,
+            news.propertyName,
+          );
+
+          // Ensure — create if missing. Cloudflare returns 409 Conflict on
+          // duplicate; tolerate the race by reusing the prior mutationId.
+          let mutationId = output?.mutationId;
+          if (!existing) {
+            const created = yield* createMetadataIndex({
+              accountId: acct,
+              indexName,
+              propertyName: news.propertyName,
+              indexType: news.indexType,
+            }).pipe(
+              Effect.catchTag("MetadataIndexAlreadyExists", () =>
+                Effect.succeed({ mutationId: output?.mutationId }),
+              ),
+            );
+            mutationId = created.mutationId ?? undefined;
+          }
+
+          return {
+            propertyName: news.propertyName,
+            indexType: news.indexType,
+            indexName,
+            accountId: acct,
+            mutationId,
+          };
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          yield* deleteMetadataIndex({
+            accountId: output.accountId,
+            indexName: output.indexName,
+            propertyName: output.propertyName,
+          }).pipe(
+            Effect.catchTag(
+              ["NotFound", "Gone", "MetadataIndexNotFound"],
+              () => Effect.void,
+            ),
+          );
+        }),
+      };
+    }),
+  );

package/src/Cloudflare/Vectorize/index.ts

@@ -0,0 +1,3 @@
+export * from "./VectorizeIndex.ts";
+export * from "./VectorizeIndexBinding.ts";
+export * from "./VectorizeMetadataIndex.ts";

package/src/Cloudflare/Workers/WorkerAsyncBindings.ts

@@ -19,6 +19,7 @@ import { isImages } from "../Images/Images.ts";
 import { isKVNamespace } from "../KV/KVNamespace.ts";
 import { isQueue } from "../Queue/Queue.ts";
 import { isR2Bucket } from "../R2/R2Bucket.ts";
+import { isVectorizeIndex } from "../Vectorize/VectorizeIndex.ts";
 import { isAssets } from "./Assets.ts";
 import { isDurableObjectNamespaceLike } from "./DurableObjectNamespace.ts";
 import type { WorkerBindingProps } from "./Worker.ts";
@@ -190,6 +191,12 @@ const toBinding = (
       name: bindingName,
       service: binding.workerName,
     };
+  } else if (isVectorizeIndex(binding)) {
+    return {
+      type: "vectorize",
+      name: bindingName,
+      indexName: binding.indexName,
+    };
   } else {
     return {
       type: "json",

package/src/Cloudflare/Workers/WorkerBinding.ts

@@ -17,6 +17,7 @@ import { Images } from "../Images/Images.ts";
 import type { KVNamespace } from "../KV/KVNamespace.ts";
 import type { Queue } from "../Queue/Queue.ts";
 import type { R2Bucket } from "../R2/R2Bucket.ts";
+import type { VectorizeIndex } from "../Vectorize/VectorizeIndex.ts";
 import type { Assets } from "./Assets.ts";
 import type { DurableObjectNamespaceLike } from "./DurableObjectNamespace.ts";
 import { makeRpcStub } from "./Rpc.ts";
@@ -50,6 +51,7 @@ export type WorkerBindingResource =
   | BrowserRendering
   | Images
   | Hyperdrive
+  | VectorizeIndex
   | Worker
   | DurableObjectNamespaceLike<any>;