alchemy 0.4.0 → 0.4.1

package/lib/cloudflare/assets.d.ts

@@ -0,0 +1,74 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+/**
+ * Properties for creating or updating Assets
+ */
+export interface AssetsProps {
+    /**
+     * Path to a directory containing static assets to be uploaded
+     * These files will be served by Cloudflare's Workers runtime
+     */
+    path: string;
+}
+/**
+ * Output returned after Assets creation/update
+ */
+export interface Assets extends Resource<"cloudflare::Asset">, AssetsProps {
+    /**
+     * The type of binding
+     */
+    type: "assets";
+    /**
+     * The ID of the assets bundle
+     */
+    id: string;
+    /**
+     * Asset files that were found
+     */
+    files: AssetFile[];
+    /**
+     * Time at which the assets were created
+     */
+    createdAt: number;
+    /**
+     * Time at which the assets were last updated
+     */
+    updatedAt: number;
+}
+/**
+ * Represents a single asset file
+ */
+export interface AssetFile {
+    /**
+     * Path relative to the assets directory
+     */
+    path: string;
+    /**
+     * Full filesystem path to the file
+     */
+    filePath: string;
+    /**
+     * Content type of the file
+     */
+    contentType: string;
+}
+/**
+ * Cloudflare Assets represent a collection of static files that can be uploaded and served
+ * by Cloudflare Workers.
+ *
+ * @example
+ * // Create a basic assets bundle from a local directory
+ * const staticAssets = await Assets("static", {
+ *   path: "./src/assets"
+ * });
+ *
+ * // Use these assets with a worker
+ * const worker = await Worker("frontend", {
+ *   name: "frontend-worker",
+ *   entrypoint: "./src/worker.ts",
+ *   bindings: {
+ *     ASSETS: staticAssets
+ *   }
+ * });
+ */
+export declare const Assets: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<Assets>, id: string, props: AssetsProps) => Promise<Assets>);

package/lib/cloudflare/assets.js

@@ -0,0 +1,73 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import { Resource } from "../resource";
+import { getContentType } from "../util/content-type";
+/**
+ * Cloudflare Assets represent a collection of static files that can be uploaded and served
+ * by Cloudflare Workers.
+ *
+ * @example
+ * // Create a basic assets bundle from a local directory
+ * const staticAssets = await Assets("static", {
+ *   path: "./src/assets"
+ * });
+ *
+ * // Use these assets with a worker
+ * const worker = await Worker("frontend", {
+ *   name: "frontend-worker",
+ *   entrypoint: "./src/worker.ts",
+ *   bindings: {
+ *     ASSETS: staticAssets
+ *   }
+ * });
+ */
+export const Assets = Resource("cloudflare::Asset", async function (id, props) {
+    if (this.phase === "delete") {
+        return this.destroy();
+    }
+    try {
+        // Check if the assets directory exists
+        const stats = await fs.stat(props.path);
+        if (!stats.isDirectory()) {
+            throw new Error(`Assets path ${props.path} is not a directory`);
+        }
+    }
+    catch (error) {
+        throw new Error(`Assets directory ${props.path} does not exist or is not accessible`);
+    }
+    // Recursively get all files in the assets directory
+    const filesList = await getFilesRecursively(props.path);
+    // Create asset file objects
+    const files = filesList.map((filePath) => {
+        const relativePath = path.relative(props.path, filePath);
+        const normalizedPath = relativePath.split(path.sep).join("/"); // Ensure forward slashes for URLs
+        return {
+            path: normalizedPath,
+            filePath,
+            contentType: getContentType(filePath),
+        };
+    });
+    // Get current timestamp
+    const now = Date.now();
+    // Construct the output
+    return this({
+        id,
+        type: "assets",
+        path: props.path,
+        files,
+        createdAt: this.output?.createdAt || now,
+        updatedAt: now,
+    });
+});
+// Helper functions for file operations
+async function getFilesRecursively(dir) {
+    const files = await fs.readdir(dir, { withFileTypes: true });
+    const allFiles = await Promise.all(files.map(async (file) => {
+        const path = `${dir}/${file.name}`;
+        if (file.isDirectory()) {
+            return getFilesRecursively(path);
+        }
+        return path;
+    }));
+    return allFiles.flat();
+}

package/lib/cloudflare/bindings.d.ts

@@ -4,6 +4,7 @@
  * https://developers.cloudflare.com/api/resources/workers/subresources/scripts/methods/update/
  */
 import type { Secret } from "../secret";
+import type { Assets } from "./assets";
 import type { R2Bucket } from "./bucket";
 import type { DurableObjectNamespace } from "./durable-object-namespace";
 import type { KVNamespace } from "./kv-namespace";
@@ -14,8 +15,12 @@ export type Bindings = {
 /**
  * L2 Binding Resources.
  */
-export type Binding = DurableObjectNamespace | KVNamespace | Worker | R2Bucket | Secret | string;
+export type Binding = DurableObjectNamespace | KVNamespace | Worker | R2Bucket | Secret | string | Assets;
 export declare function isDurableObjectNamespace(binding: Binding): binding is DurableObjectNamespace;
+/**
+ * Check if a binding is an Assets resource
+ */
+export declare function isAssets(binding: Binding): binding is Assets;
 /**
  * Union type for all Worker binding types (API spec)
  */

package/lib/cloudflare/bindings.js

@@ -1,3 +1,9 @@
 export function isDurableObjectNamespace(binding) {
     return (typeof binding === "object" && binding.type === "durable_object_namespace");
 }
+/**
+ * Check if a binding is an Assets resource
+ */
+export function isAssets(binding) {
+    return typeof binding === "object" && binding.type === "assets";
+}

package/lib/cloudflare/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./account-api-token";
 export * from "./api";
+export * from "./assets";
 export * from "./bindings";
 export * from "./bucket";
 export * from "./custom-domain";

package/lib/cloudflare/index.js

@@ -1,5 +1,6 @@
 export * from "./account-api-token";
 export * from "./api";
+export * from "./assets";
 export * from "./bindings";
 export * from "./bucket";
 export * from "./custom-domain";

package/lib/cloudflare/r2-rest-state-store.js

@@ -74,13 +74,22 @@ export class R2RestStateStore {
                 params.append("cursor", cursor);
             }
             const listPath = `/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects?${params.toString()}`;
-            const response = await this.api.get(listPath);
-            if (!response.ok) {
-                const errorData = await response.json().catch(() => ({
-                    errors: [{ message: response.statusText }],
-                }));
-                throw new Error(`Error listing R2 objects: ${errorData.errors?.[0]?.message || response.statusText}`);
-            }
+            const response = await withExponentialBackoff(async () => {
+                const response = await this.api.get(listPath);
+                if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({
+                        errors: [{ message: response.statusText }],
+                    }));
+                    throw new Error(`Error listing R2 objects: ${errorData.errors?.[0]?.message || response.statusText}`);
+                }
+                return response;
+            }, 
+            // Retry on transient errors
+            (error) => error.message?.includes("502") ||
+                error.message?.includes("503") ||
+                error.message?.includes("timeout"), 5, // 5 retry attempts
+            1000 // Start with 1 second delay
+            );
             const data = (await response.json());
             // The result structure may be under "result" key in Cloudflare's API
             const result = data.result || data;
@@ -114,15 +123,27 @@ export class R2RestStateStore {
     async get(key) {
         await this.ensureInitialized();
         try {
-            const response = await this.api.get(`/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`);
-            if (!response.ok) {
-                if (response.status === 404) {
-                    return undefined;
+            const response = await withExponentialBackoff(async () => {
+                const response = await this.api.get(`/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`);
+                if (!response.ok) {
+                    if (response.status === 404) {
+                        return response;
+                    }
+                    const errorData = await response.json().catch(() => ({
+                        errors: [{ message: response.statusText }],
+                    }));
+                    throw new Error(`Error getting R2 object: ${errorData.errors?.[0]?.message || response.statusText}`);
                 }
-                const errorData = await response.json().catch(() => ({
-                    errors: [{ message: response.statusText }],
-                }));
-                throw new Error(`Error getting R2 object: ${errorData.errors?.[0]?.message || response.statusText}`);
+                return response;
+            }, 
+            // Retry on transient errors
+            (error) => error.message?.includes("502") ||
+                error.message?.includes("503") ||
+                error.message?.includes("timeout"), 5, // 5 retry attempts
+            1000 // Start with 1 second delay
+            );
+            if (response.status === 404) {
+                return undefined;
             }
             // Parse and deserialize the state data
             const rawData = await response.json();
@@ -208,13 +229,22 @@ export class R2RestStateStore {
      */
     async delete(key) {
         await this.ensureInitialized();
-        const response = await this.api.delete(`/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`);
-        if (!response.ok && response.status !== 404) {
-            const errorData = await response.json().catch(() => ({
-                errors: [{ message: response.statusText }],
-            }));
-            throw new Error(`Error deleting from R2: ${errorData.errors?.[0]?.message || response.statusText}`);
-        }
+        await withExponentialBackoff(async () => {
+            const response = await this.api.delete(`/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`);
+            if (!response.ok && response.status !== 404) {
+                const errorData = await response.json().catch(() => ({
+                    errors: [{ message: response.statusText }],
+                }));
+                throw new Error(`Error deleting from R2: ${errorData.errors?.[0]?.message || response.statusText}`);
+            }
+            return response;
+        }, 
+        // Retry on transient errors
+        (error) => error.message?.includes("502") ||
+            error.message?.includes("503") ||
+            error.message?.includes("timeout"), 5, // 5 retry attempts
+        1000 // Start with 1 second delay
+        );
     }
     /**
      * Convert key for storage by replacing slashes with colons

package/lib/cloudflare/worker.d.ts

@@ -166,6 +166,20 @@ export interface Worker<B extends Bindings = Bindings> extends Resource<"cloudfl
  *   }
  * });
  *
+ * @example
+ * // Create a worker with static assets:
+ * const staticAssets = await Assets("static", {
+ *   path: "./src/assets"
+ * });
+ *
+ * const frontendWorker = await Worker("frontend", {
+ *   name: "frontend-worker",
+ *   entrypoint: "./src/worker.ts",
+ *   bindings: {
+ *     ASSETS: staticAssets
+ *   }
+ * });
+ *
  * @see https://developers.cloudflare.com/workers/
  */
 export declare const Worker: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | (<const B extends Bindings>(this: Context<Worker<NoInfer<B>>>, id: string, props: WorkerProps<B>) => Promise<Worker<B>>);

package/lib/cloudflare/worker.js

@@ -1,11 +1,13 @@
+import * as crypto from "crypto";
 import * as fs from "fs/promises";
 import { Bundle } from "../esbuild/bundle";
 import { Resource } from "../resource";
 import { isSecret } from "../secret";
+import { getContentType } from "../util/content-type";
 import { withExponentialBackoff } from "../util/retry";
 import { slugify } from "../util/slugify";
 import { createCloudflareApi } from "./api";
-import { isDurableObjectNamespace, } from "./bindings";
+import { isAssets, isDurableObjectNamespace, } from "./bindings";
 import { isKVNamespace } from "./kv-namespace";
 /**
  * A Cloudflare Worker is a serverless function that can be deployed to the Cloudflare network.
@@ -68,6 +70,20 @@ import { isKVNamespace } from "./kv-namespace";
  *   }
  * });
  *
+ * @example
+ * // Create a worker with static assets:
+ * const staticAssets = await Assets("static", {
+ *   path: "./src/assets"
+ * });
+ *
+ * const frontendWorker = await Worker("frontend", {
+ *   name: "frontend-worker",
+ *   entrypoint: "./src/worker.ts",
+ *   bindings: {
+ *     ASSETS: staticAssets
+ *   }
+ * });
+ *
  * @see https://developers.cloudflare.com/workers/
  */
 export const Worker = Resource("cloudflare::Worker", {
@@ -89,9 +105,28 @@ export const Worker = Resource("cloudflare::Worker", {
         await assertWorkerDoesNotExist(this, api, workerName);
     }
     const oldBindings = await this.get("bindings");
-    const scriptMetadata = await prepareWorkerMetadata(this, oldBindings, props);
     // Get the script content - either from props.script, or by bundling
     const scriptContent = props.script ?? (await bundleWorkerScript(props));
+    // Find any assets bindings
+    const assetsBindings = [];
+    if (props.bindings) {
+        for (const [bindingName, binding] of Object.entries(props.bindings)) {
+            if (isAssets(binding)) {
+                assetsBindings.push({ name: bindingName, assets: binding });
+            }
+        }
+    }
+    // Upload any assets and get completion tokens
+    let assetUploadResult;
+    if (assetsBindings.length > 0) {
+        // We'll use the first asset binding for now
+        // In the future, we might want to support multiple asset bindings
+        const assetBinding = assetsBindings[0];
+        // Upload the assets and get the completion token
+        assetUploadResult = await uploadAssets(api, workerName, assetBinding.assets);
+    }
+    // Prepare metadata with bindings
+    const scriptMetadata = await prepareWorkerMetadata(this, oldBindings, props, assetUploadResult);
     // Upload the worker script
     await putWorker(api, workerName, scriptContent, scriptMetadata);
     // TODO: it is less than ideal that this can fail, resulting in state problem
@@ -206,7 +241,7 @@ class NotFoundError extends Error {
         this.name = "NotFoundError";
     }
 }
-async function prepareWorkerMetadata(ctx, oldBindings, props) {
+async function prepareWorkerMetadata(ctx, oldBindings, props, assetUploadResult) {
     // Prepare metadata with bindings
     const meta = {
         bindings: [],
@@ -223,6 +258,15 @@ async function prepareWorkerMetadata(ctx, oldBindings, props) {
             new_sqlite_classes: props.migrations?.new_sqlite_classes ?? [],
         },
     };
+    // If we have asset upload results, add them to the metadata
+    if (assetUploadResult) {
+        meta.assets = {
+            jwt: assetUploadResult.completionToken,
+        };
+        if (assetUploadResult.assetConfig) {
+            meta.assets.config = assetUploadResult.assetConfig;
+        }
+    }
     const bindings = (props.bindings ?? {});
     // Convert bindings to the format expected by the API
     for (const [bindingName, binding] of Object.entries(bindings)) {
@@ -284,6 +328,12 @@ async function prepareWorkerMetadata(ctx, oldBindings, props) {
                 bucket_name: binding.name,
             });
         }
+        else if (isAssets(binding)) {
+            meta.bindings.push({
+                type: "assets",
+                name: bindingName,
+            });
+        }
         else if (isSecret(binding)) {
             meta.bindings.push({
                 type: "secret_text",
@@ -468,3 +518,100 @@ async function getWorkerBindings(api, workerName, environment = "production") {
     const data = await response.json();
     return data.result;
 }
+/**
+ * Uploads assets to Cloudflare and returns a completion token
+ *
+ * @param api CloudflareApi instance
+ * @param workerName Name of the worker
+ * @param assets Assets resource containing files to upload
+ * @returns Completion token for the assets upload
+ */
+async function uploadAssets(api, workerName, assets) {
+    // Generate the file manifest
+    const fileMetadata = {};
+    // Process each file in the assets
+    for (const file of assets.files) {
+        const { hash, size } = await calculateFileMetadata(file.filePath);
+        // Use the relative path as the key, ensuring it starts with a slash
+        const key = file.path.startsWith("/") ? file.path : `/${file.path}`;
+        fileMetadata[key] = { hash, size };
+    }
+    // Start the upload session
+    const uploadSessionUrl = `/accounts/${api.accountId}/workers/scripts/${workerName}/assets-upload-session`;
+    const uploadSessionResponse = await api.post(uploadSessionUrl, JSON.stringify({ manifest: fileMetadata }), {
+        headers: { "Content-Type": "application/json" },
+    });
+    if (!uploadSessionResponse.ok) {
+        throw new Error(`Failed to start assets upload session: ${uploadSessionResponse.status} ${uploadSessionResponse.statusText}`);
+    }
+    const sessionData = (await uploadSessionResponse.json());
+    // If there are no buckets, assets are already uploaded or empty
+    if (!sessionData.result.buckets || sessionData.result.buckets.length === 0) {
+        return { completionToken: sessionData.result.jwt };
+    }
+    // Upload the files in batches as specified by the API
+    let completionToken = sessionData.result.jwt;
+    const buckets = sessionData.result.buckets;
+    // Process each bucket of files
+    for (const bucket of buckets) {
+        const formData = new FormData();
+        // Add each file in the bucket to the form
+        for (const fileHash of bucket) {
+            // Find the file with this hash
+            const file = assets.files.find((f) => {
+                const filePath = f.path.startsWith("/") ? f.path : `/${f.path}`;
+                return fileMetadata[filePath]?.hash === fileHash;
+            });
+            if (!file) {
+                throw new Error(`Could not find file with hash ${fileHash}`);
+            }
+            // Read the file content
+            const fileContent = await fs.readFile(file.filePath);
+            // Convert to base64 as required by the API when using base64=true
+            const base64Content = fileContent.toString("base64");
+            // Add the file to the form with the hash as the key and set the correct content type
+            const blob = new Blob([base64Content], {
+                type: getContentType(file.filePath),
+            });
+            formData.append(fileHash, blob, fileHash);
+        }
+        // Upload this batch of files
+        const uploadResponse = await api.post(`/accounts/${api.accountId}/workers/assets/upload?base64=true`, formData, {
+            headers: {
+                Authorization: `Bearer ${completionToken}`,
+                "Content-Type": "multipart/form-data",
+            },
+        });
+        if (!uploadResponse.ok) {
+            throw new Error(`Failed to upload asset files: ${uploadResponse.status} ${uploadResponse.statusText}`);
+        }
+        const uploadData = (await uploadResponse.json());
+        // Update the completion token for the next batch
+        if (uploadData.result.jwt) {
+            completionToken = uploadData.result.jwt;
+        }
+    }
+    // Return the final completion token
+    return {
+        completionToken,
+        assetConfig: {
+            html_handling: "auto-trailing-slash",
+        },
+    };
+}
+/**
+ * Calculate the SHA-256 hash and size of a file
+ *
+ * @param filePath Path to the file
+ * @returns Hash (first 32 chars of SHA-256) and size of the file
+ */
+async function calculateFileMetadata(filePath) {
+    const hash = crypto.createHash("sha256");
+    const fileContent = await fs.readFile(filePath);
+    hash.update(fileContent);
+    const fileHash = hash.digest("hex").substring(0, 32); // First 32 chars of hash
+    return {
+        hash: fileHash,
+        size: fileContent.length,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "type": "module",
   "module": "./lib/index.js",
   "scripts": {

package/src/cloudflare/assets.ts

@@ -0,0 +1,155 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import { getContentType } from "../util/content-type";
+
+/**
+ * Properties for creating or updating Assets
+ */
+export interface AssetsProps {
+  /**
+   * Path to a directory containing static assets to be uploaded
+   * These files will be served by Cloudflare's Workers runtime
+   */
+  path: string;
+}
+
+/**
+ * Output returned after Assets creation/update
+ */
+export interface Assets extends Resource<"cloudflare::Asset">, AssetsProps {
+  /**
+   * The type of binding
+   */
+  type: "assets";
+
+  /**
+   * The ID of the assets bundle
+   */
+  id: string;
+
+  /**
+   * Asset files that were found
+   */
+  files: AssetFile[];
+
+  /**
+   * Time at which the assets were created
+   */
+  createdAt: number;
+
+  /**
+   * Time at which the assets were last updated
+   */
+  updatedAt: number;
+}
+
+/**
+ * Represents a single asset file
+ */
+export interface AssetFile {
+  /**
+   * Path relative to the assets directory
+   */
+  path: string;
+
+  /**
+   * Full filesystem path to the file
+   */
+  filePath: string;
+
+  /**
+   * Content type of the file
+   */
+  contentType: string;
+}
+
+/**
+ * Cloudflare Assets represent a collection of static files that can be uploaded and served
+ * by Cloudflare Workers.
+ *
+ * @example
+ * // Create a basic assets bundle from a local directory
+ * const staticAssets = await Assets("static", {
+ *   path: "./src/assets"
+ * });
+ *
+ * // Use these assets with a worker
+ * const worker = await Worker("frontend", {
+ *   name: "frontend-worker",
+ *   entrypoint: "./src/worker.ts",
+ *   bindings: {
+ *     ASSETS: staticAssets
+ *   }
+ * });
+ */
+export const Assets = Resource(
+  "cloudflare::Asset",
+  async function (
+    this: Context<Assets>,
+    id: string,
+    props: AssetsProps
+  ): Promise<Assets> {
+    if (this.phase === "delete") {
+      return this.destroy();
+    }
+
+    try {
+      // Check if the assets directory exists
+      const stats = await fs.stat(props.path);
+      if (!stats.isDirectory()) {
+        throw new Error(`Assets path ${props.path} is not a directory`);
+      }
+    } catch (error) {
+      throw new Error(
+        `Assets directory ${props.path} does not exist or is not accessible`
+      );
+    }
+
+    // Recursively get all files in the assets directory
+    const filesList = await getFilesRecursively(props.path);
+
+    // Create asset file objects
+    const files: AssetFile[] = filesList.map((filePath) => {
+      const relativePath = path.relative(props.path, filePath);
+      const normalizedPath = relativePath.split(path.sep).join("/"); // Ensure forward slashes for URLs
+
+      return {
+        path: normalizedPath,
+        filePath,
+        contentType: getContentType(filePath),
+      };
+    });
+
+    // Get current timestamp
+    const now = Date.now();
+
+    // Construct the output
+    return this({
+      id,
+      type: "assets",
+      path: props.path,
+      files,
+      createdAt: this.output?.createdAt || now,
+      updatedAt: now,
+    });
+  }
+);
+
+// Helper functions for file operations
+async function getFilesRecursively(dir: string): Promise<string[]> {
+  const files = await fs.readdir(dir, { withFileTypes: true });
+
+  const allFiles = await Promise.all(
+    files.map(async (file) => {
+      const path = `${dir}/${file.name}`;
+      if (file.isDirectory()) {
+        return getFilesRecursively(path);
+      }
+      return path;
+    })
+  );
+
+  return allFiles.flat();
+}

package/src/cloudflare/bindings.ts

@@ -4,6 +4,7 @@
  * https://developers.cloudflare.com/api/resources/workers/subresources/scripts/methods/update/
  */
 import type { Secret } from "../secret";
+import type { Assets } from "./assets";
 import type { R2Bucket } from "./bucket";
 import type { DurableObjectNamespace } from "./durable-object-namespace";
 import type { KVNamespace } from "./kv-namespace";
@@ -22,16 +23,24 @@ export type Binding =
   | Worker
   | R2Bucket
   | Secret
-  | string;
+  | string
+  | Assets;
 
 export function isDurableObjectNamespace(
-  binding: Binding,
+  binding: Binding
 ): binding is DurableObjectNamespace {
   return (
     typeof binding === "object" && binding.type === "durable_object_namespace"
   );
 }
 
+/**
+ * Check if a binding is an Assets resource
+ */
+export function isAssets(binding: Binding): binding is Assets {
+  return typeof binding === "object" && binding.type === "assets";
+}
+
 /**
  * Union type for all Worker binding types (API spec)
  */

package/src/cloudflare/index.ts

@@ -1,5 +1,6 @@
 export * from "./account-api-token";
 export * from "./api";
+export * from "./assets";
 export * from "./bindings";
 export * from "./bucket";
 export * from "./custom-domain";

package/src/cloudflare/r2-rest-state-store.ts

@@ -123,16 +123,30 @@ export class R2RestStateStore implements StateStore {
       }
 
       const listPath = `/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects?${params.toString()}`;
-      const response = await this.api.get(listPath);
-
-      if (!response.ok) {
-        const errorData: any = await response.json().catch(() => ({
-          errors: [{ message: response.statusText }],
-        }));
-        throw new Error(
-          `Error listing R2 objects: ${errorData.errors?.[0]?.message || response.statusText}`
-        );
-      }
+
+      const response = await withExponentialBackoff(
+        async () => {
+          const response = await this.api.get(listPath);
+
+          if (!response.ok) {
+            const errorData: any = await response.json().catch(() => ({
+              errors: [{ message: response.statusText }],
+            }));
+            throw new Error(
+              `Error listing R2 objects: ${errorData.errors?.[0]?.message || response.statusText}`
+            );
+          }
+
+          return response;
+        },
+        // Retry on transient errors
+        (error) =>
+          error.message?.includes("502") ||
+          error.message?.includes("503") ||
+          error.message?.includes("timeout"),
+        5, // 5 retry attempts
+        1000 // Start with 1 second delay
+      );
 
       const data = (await response.json()) as any;
 
@@ -176,21 +190,38 @@ export class R2RestStateStore implements StateStore {
     await this.ensureInitialized();
 
     try {
-      const response = await this.api.get(
-        `/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`
-      );
+      const response = await withExponentialBackoff(
+        async () => {
+          const response = await this.api.get(
+            `/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`
+          );
 
-      if (!response.ok) {
-        if (response.status === 404) {
-          return undefined;
-        }
+          if (!response.ok) {
+            if (response.status === 404) {
+              return response;
+            }
+
+            const errorData: any = await response.json().catch(() => ({
+              errors: [{ message: response.statusText }],
+            }));
+            throw new Error(
+              `Error getting R2 object: ${errorData.errors?.[0]?.message || response.statusText}`
+            );
+          }
 
-        const errorData: any = await response.json().catch(() => ({
-          errors: [{ message: response.statusText }],
-        }));
-        throw new Error(
-          `Error getting R2 object: ${errorData.errors?.[0]?.message || response.statusText}`
-        );
+          return response;
+        },
+        // Retry on transient errors
+        (error) =>
+          error.message?.includes("502") ||
+          error.message?.includes("503") ||
+          error.message?.includes("timeout"),
+        5, // 5 retry attempts
+        1000 // Start with 1 second delay
+      );
+
+      if (response.status === 404) {
+        return undefined;
       }
 
       // Parse and deserialize the state data
@@ -298,18 +329,31 @@ export class R2RestStateStore implements StateStore {
   async delete(key: string): Promise<void> {
     await this.ensureInitialized();
 
-    const response = await this.api.delete(
-      `/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`
-    );
+    await withExponentialBackoff(
+      async () => {
+        const response = await this.api.delete(
+          `/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`
+        );
 
-    if (!response.ok && response.status !== 404) {
-      const errorData: any = await response.json().catch(() => ({
-        errors: [{ message: response.statusText }],
-      }));
-      throw new Error(
-        `Error deleting from R2: ${errorData.errors?.[0]?.message || response.statusText}`
-      );
-    }
+        if (!response.ok && response.status !== 404) {
+          const errorData: any = await response.json().catch(() => ({
+            errors: [{ message: response.statusText }],
+          }));
+          throw new Error(
+            `Error deleting from R2: ${errorData.errors?.[0]?.message || response.statusText}`
+          );
+        }
+
+        return response;
+      },
+      // Retry on transient errors
+      (error) =>
+        error.message?.includes("502") ||
+        error.message?.includes("503") ||
+        error.message?.includes("timeout"),
+      5, // 5 retry attempts
+      1000 // Start with 1 second delay
+    );
   }
 
   /**

package/src/cloudflare/worker.ts

@@ -1,14 +1,18 @@
+import * as crypto from "crypto";
 import * as fs from "fs/promises";
 import type { Context } from "../context";
 import { Bundle, type BundleProps } from "../esbuild/bundle";
 import { Resource } from "../resource";
 import { isSecret } from "../secret";
+import { getContentType } from "../util/content-type";
 import { withExponentialBackoff } from "../util/retry";
 import { slugify } from "../util/slugify";
 import { type CloudflareApi, createCloudflareApi } from "./api";
+import type { Assets } from "./assets";
 import {
   type Bindings,
   type WorkerBindingSpec,
+  isAssets,
   isDurableObjectNamespace,
 } from "./bindings";
 import type { Bound } from "./bound";
@@ -200,6 +204,20 @@ export interface Worker<B extends Bindings = Bindings>
  *   }
  * });
  *
+ * @example
+ * // Create a worker with static assets:
+ * const staticAssets = await Assets("static", {
+ *   path: "./src/assets"
+ * });
+ *
+ * const frontendWorker = await Worker("frontend", {
+ *   name: "frontend-worker",
+ *   entrypoint: "./src/worker.ts",
+ *   bindings: {
+ *     ASSETS: staticAssets
+ *   }
+ * });
+ *
  * @see https://developers.cloudflare.com/workers/
  */
 export const Worker = Resource(
@@ -232,15 +250,42 @@ export const Worker = Resource(
 
     const oldBindings = await this.get<Bindings>("bindings");
 
+    // Get the script content - either from props.script, or by bundling
+    const scriptContent = props.script ?? (await bundleWorkerScript(props));
+
+    // Find any assets bindings
+    const assetsBindings: { name: string; assets: Assets }[] = [];
+    if (props.bindings) {
+      for (const [bindingName, binding] of Object.entries(props.bindings)) {
+        if (isAssets(binding)) {
+          assetsBindings.push({ name: bindingName, assets: binding });
+        }
+      }
+    }
+
+    // Upload any assets and get completion tokens
+    let assetUploadResult: AssetUploadResult | undefined;
+    if (assetsBindings.length > 0) {
+      // We'll use the first asset binding for now
+      // In the future, we might want to support multiple asset bindings
+      const assetBinding = assetsBindings[0];
+
+      // Upload the assets and get the completion token
+      assetUploadResult = await uploadAssets(
+        api,
+        workerName,
+        assetBinding.assets
+      );
+    }
+
+    // Prepare metadata with bindings
     const scriptMetadata = await prepareWorkerMetadata(
       this,
       oldBindings,
-      props
+      props,
+      assetUploadResult
     );
 
-    // Get the script content - either from props.script, or by bundling
-    const scriptContent = props.script ?? (await bundleWorkerScript(props));
-
     // Upload the worker script
     await putWorker(api, workerName, scriptContent, scriptMetadata);
 
@@ -437,12 +482,29 @@ interface WorkerMetadata {
   main_module?: string;
   body_part?: string;
   tags?: string[];
+  assets?: {
+    jwt?: string;
+    keep_assets?: boolean;
+    config?: {
+      html_handling?: "auto-trailing-slash" | "none";
+      not_found_handling?: "none" | "fall-through";
+    };
+  };
+}
+
+interface AssetUploadResult {
+  completionToken: string;
+  assetConfig?: {
+    html_handling?: "auto-trailing-slash" | "none";
+    not_found_handling?: "none" | "fall-through";
+  };
 }
 
 async function prepareWorkerMetadata<B extends Bindings>(
   ctx: Context<Worker<B>>,
   oldBindings: Bindings | undefined,
-  props: WorkerProps
+  props: WorkerProps,
+  assetUploadResult?: AssetUploadResult
 ): Promise<WorkerMetadata> {
   // Prepare metadata with bindings
   const meta: WorkerMetadata = {
@@ -461,6 +523,17 @@ async function prepareWorkerMetadata<B extends Bindings>(
     },
   };
 
+  // If we have asset upload results, add them to the metadata
+  if (assetUploadResult) {
+    meta.assets = {
+      jwt: assetUploadResult.completionToken,
+    };
+
+    if (assetUploadResult.assetConfig) {
+      meta.assets.config = assetUploadResult.assetConfig;
+    }
+  }
+
   const bindings = (props.bindings ?? {}) as Bindings;
 
   // Convert bindings to the format expected by the API
@@ -522,6 +595,11 @@ async function prepareWorkerMetadata<B extends Bindings>(
         name: bindingName,
         bucket_name: binding.name,
       });
+    } else if (isAssets(binding)) {
+      meta.bindings.push({
+        type: "assets",
+        name: bindingName,
+      });
     } else if (isSecret(binding)) {
       meta.bindings.push({
         type: "secret_text",
@@ -802,3 +880,173 @@ async function getWorkerBindings(
 
   return data.result;
 }
+
+/**
+ * Interface for a file's metadata to be uploaded
+ */
+interface FileMetadata {
+  hash: string;
+  size: number;
+}
+
+/**
+ * Response from the assets upload session API
+ */
+interface UploadSessionResponse {
+  result: {
+    jwt: string;
+    buckets: string[][];
+  };
+  success: boolean;
+  errors: any[];
+  messages: any[];
+}
+
+/**
+ * Response from the file upload API
+ */
+interface UploadResponse {
+  result: {
+    jwt: string;
+    buckets?: string[][];
+  };
+  success: boolean;
+  errors: any[];
+  messages: any[];
+}
+
+/**
+ * Uploads assets to Cloudflare and returns a completion token
+ *
+ * @param api CloudflareApi instance
+ * @param workerName Name of the worker
+ * @param assets Assets resource containing files to upload
+ * @returns Completion token for the assets upload
+ */
+async function uploadAssets(
+  api: CloudflareApi,
+  workerName: string,
+  assets: Assets
+): Promise<AssetUploadResult> {
+  // Generate the file manifest
+  const fileMetadata: Record<string, FileMetadata> = {};
+
+  // Process each file in the assets
+  for (const file of assets.files) {
+    const { hash, size } = await calculateFileMetadata(file.filePath);
+    // Use the relative path as the key, ensuring it starts with a slash
+    const key = file.path.startsWith("/") ? file.path : `/${file.path}`;
+    fileMetadata[key] = { hash, size };
+  }
+
+  // Start the upload session
+  const uploadSessionUrl = `/accounts/${api.accountId}/workers/scripts/${workerName}/assets-upload-session`;
+  const uploadSessionResponse = await api.post(
+    uploadSessionUrl,
+    JSON.stringify({ manifest: fileMetadata }),
+    {
+      headers: { "Content-Type": "application/json" },
+    }
+  );
+
+  if (!uploadSessionResponse.ok) {
+    throw new Error(
+      `Failed to start assets upload session: ${uploadSessionResponse.status} ${uploadSessionResponse.statusText}`
+    );
+  }
+
+  const sessionData =
+    (await uploadSessionResponse.json()) as UploadSessionResponse;
+
+  // If there are no buckets, assets are already uploaded or empty
+  if (!sessionData.result.buckets || sessionData.result.buckets.length === 0) {
+    return { completionToken: sessionData.result.jwt };
+  }
+
+  // Upload the files in batches as specified by the API
+  let completionToken = sessionData.result.jwt;
+  const buckets = sessionData.result.buckets;
+
+  // Process each bucket of files
+  for (const bucket of buckets) {
+    const formData = new FormData();
+
+    // Add each file in the bucket to the form
+    for (const fileHash of bucket) {
+      // Find the file with this hash
+      const file = assets.files.find((f) => {
+        const filePath = f.path.startsWith("/") ? f.path : `/${f.path}`;
+        return fileMetadata[filePath]?.hash === fileHash;
+      });
+
+      if (!file) {
+        throw new Error(`Could not find file with hash ${fileHash}`);
+      }
+
+      // Read the file content
+      const fileContent = await fs.readFile(file.filePath);
+
+      // Convert to base64 as required by the API when using base64=true
+      const base64Content = fileContent.toString("base64");
+
+      // Add the file to the form with the hash as the key and set the correct content type
+      const blob = new Blob([base64Content], {
+        type: getContentType(file.filePath),
+      });
+      formData.append(fileHash, blob, fileHash);
+    }
+
+    // Upload this batch of files
+    const uploadResponse = await api.post(
+      `/accounts/${api.accountId}/workers/assets/upload?base64=true`,
+      formData,
+      {
+        headers: {
+          Authorization: `Bearer ${completionToken}`,
+          "Content-Type": "multipart/form-data",
+        },
+      }
+    );
+
+    if (!uploadResponse.ok) {
+      throw new Error(
+        `Failed to upload asset files: ${uploadResponse.status} ${uploadResponse.statusText}`
+      );
+    }
+
+    const uploadData = (await uploadResponse.json()) as UploadResponse;
+    // Update the completion token for the next batch
+    if (uploadData.result.jwt) {
+      completionToken = uploadData.result.jwt;
+    }
+  }
+
+  // Return the final completion token
+  return {
+    completionToken,
+    assetConfig: {
+      html_handling: "auto-trailing-slash",
+    },
+  };
+}
+
+/**
+ * Calculate the SHA-256 hash and size of a file
+ *
+ * @param filePath Path to the file
+ * @returns Hash (first 32 chars of SHA-256) and size of the file
+ */
+async function calculateFileMetadata(
+  filePath: string
+): Promise<{ hash: string; size: number }> {
+  const hash = crypto.createHash("sha256");
+  const fileContent = await fs.readFile(filePath);
+
+  hash.update(fileContent);
+  const fileHash = hash.digest("hex").substring(0, 32); // First 32 chars of hash
+
+  return {
+    hash: fileHash,
+    size: fileContent.length,
+  };
+}