alchemy 0.16.9 → 0.17.0

package/lib/cloudflare/worker.js

@@ -1,124 +1,200 @@
-import * as crypto from "node:crypto";
-import * as fs from "node:fs/promises";
-import { Resource } from "../resource.js";
-import { getContentType } from "../util/content-type.js";
+import path from "node:path";
+import { InnerResourceScope, Resource, ResourceKind } from "../resource.js";
+import { getBindKey, tryGetBinding } from "../runtime/bind.js";
+import { isRuntime } from "../runtime/global.js";
+import { bootstrapPlugin } from "../runtime/plugin.js";
+import { Scope } from "../scope.js";
+import { Secret, secret } from "../secret.js";
+import { serializeScope } from "../serde.js";
 import { withExponentialBackoff } from "../util/retry.js";
 import { slugify } from "../util/slugify.js";
 import { CloudflareApiError, handleApiError } from "./api-error.js";
 import { createCloudflareApi, } from "./api.js";
-import { Self } from "./bindings.js";
+import { Json } from "./bindings.js";
+import { isBucket } from "./bucket.js";
 import { bundleWorkerScript } from "./bundle/bundle-worker.js";
-import { isQueueEventSource } from "./event-source.js";
+import { isD1Database } from "./d1-database.js";
+import { isQueueEventSource, } from "./event-source.js";
+import { isKVNamespace } from "./kv-namespace.js";
+import { isPipeline } from "./pipeline.js";
 import { QueueConsumer, deleteQueueConsumer, listQueueConsumers, } from "./queue-consumer.js";
 import { isQueue } from "./queue.js";
+import { isVectorizeIndex } from "./vectorize-index.js";
+import { uploadAssets } from "./worker-assets.js";
+import { prepareWorkerMetadata, } from "./worker-metadata.js";
+import { WorkerStub, isWorkerStub } from "./worker-stub.js";
 import { upsertWorkflow } from "./workflow.js";
-/**
- * A Cloudflare Worker is a serverless function that can be deployed to the Cloudflare network.
- *
- * @example
- * // Create a basic HTTP handler worker with custom domain routing
- * // and workers.dev URL:
- * const api = await Worker("api", {
- *   name: "api-worker",
- *   entrypoint: "./src/api.ts",
- *   routes: ["api.example.com/*"],
- *   url: true
- * });
- *
- * await Route("route", {
- *   zoneId: zone.zoneId,
- *   worker: api,
- *   pattern: "api.example.com/*",
- * });
- *
- * @example
- * // Create a real-time chat worker using Durable Objects
- * // for state management:
- * const chatRooms = new DurableObjectNamespace("chat-rooms");
- * const userStore = new DurableObjectNamespace("user-store");
- *
- * const chat = await Worker("chat", {
- *   name: "chat-worker",
- *   entrypoint: "./src/chat.ts",
- *   bindings: {
- *     ROOMS: chatRooms,
- *     USERS: userStore
- *   },
- * });
- *
- * @example
- * // Create a worker with KV namespace for caching and data storage:
- * const cache = await KVNamespace("cache-store");
- * const settings = await KVNamespace("user-settings");
- *
- * const cacheWorker = await Worker("cache", {
- *   name: "cache-worker",
- *   entrypoint: "./src/cache.ts",
- *   bindings: {
- *     CACHE: cache,
- *     SETTINGS: settings
- *   }
- * });
- *
- * @example
- * // Create a worker with R2 bucket for object storage:
- * const uploads = await R2Bucket("uploads", {
- *   name: "user-uploads"
- * });
- * const assets = await R2Bucket("assets", {
- *   name: "static-assets",
- *   allowPublicAccess: true
- * });
- *
- * const storageWorker = await Worker("storage", {
- *   name: "storage-worker",
- *   entrypoint: "./src/storage.ts",
- *   bindings: {
- *     UPLOADS: uploads,
- *     ASSETS: assets
- *   }
- * });
- *
- * @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
- *   }
- * });
- *
- * @example
- * // Create a worker with scheduled cron triggers:
- * const cronWorker = await Worker("scheduled-tasks", {
- *   name: "cron-worker",
- *   entrypoint: "./src/scheduled.ts",
- *   crons: ['* 15 * * *', '0 0 * * *', '0 12 * * MON']
- * })
- *
- * @see
- * https://developers.cloudflare.com/workers/
- */
-export const Worker = Resource("cloudflare::Worker", {
+export function isWorker(resource) {
+    return resource[ResourceKind] === "cloudflare::Worker";
+}
+export function Worker(...args) {
+    const [id, meta, props] = args.length === 2 ? [args[0], undefined, args[1]] : args;
+    if (("fetch" in props && props.fetch) || ("queue" in props && props.queue)) {
+        const scope = Scope.current;
+        const workerName = props.name ?? id;
+        // we need to make sure the worker exists
+        const stub = WorkerStub(`${id}/stub`, {
+            name: workerName,
+            accountId: props.accountId,
+            apiKey: props.apiKey,
+            apiToken: props.apiToken,
+            baseUrl: props.baseUrl,
+            email: props.email,
+        });
+        async function collectResources(scope) {
+            if (!scope) {
+                return [];
+            }
+            return (await Promise.all(Array.from(scope.resources.values()).map(async (resource) => [
+                (await resource),
+                ...(await collectResources(await resource[InnerResourceScope])),
+            ]))).flat();
+        }
+        const deferred = scope.defer(async () => {
+            const autoBindings = {};
+            for (const resource of await collectResources(Scope.root)) {
+                if (isQueue(resource) ||
+                    isWorkerStub(resource) ||
+                    isWorker(resource) ||
+                    isD1Database(resource) ||
+                    isBucket(resource) ||
+                    isPipeline(resource) ||
+                    isVectorizeIndex(resource) ||
+                    isKVNamespace(resource)) {
+                    // TODO(sam): make this generic/pluggable
+                    autoBindings[getBindKey(resource)] = resource;
+                }
+            }
+            // TODO(sam): prune to only needed secrets
+            for (const secret of Secret.all()) {
+                autoBindings[secret.name] = secret;
+            }
+            const bindings = {
+                ...props.bindings,
+                __ALCHEMY_WORKER_NAME__: workerName,
+                __ALCHEMY_SERIALIZED_SCOPE__: Json(await serializeScope(scope)),
+                ALCHEMY_STAGE: scope.stage,
+                ALCHEMY_PASSWORD: secret(scope.password),
+                // TODO(sam): prune un-needed bindings
+                ...autoBindings,
+            };
+            return _Worker(id, {
+                ...props,
+                url: true,
+                compatibilityFlags: [
+                    "nodejs_compat",
+                    ...(props.compatibilityFlags ?? []),
+                ],
+                entrypoint: meta.filename,
+                name: workerName,
+                // adopt because the stub guarnatees that the worker exists
+                adopt: true,
+                bindings,
+                bundle: {
+                    ...props.bundle,
+                    plugins: [bootstrapPlugin],
+                    external: [
+                        // for alchemy
+                        "libsodium*",
+                        "@swc/*",
+                        "esbuild",
+                        // TODO(sam): this is for fetch, why is it a package?
+                        "undici",
+                        // TODO(sam): no idea where this came from, feels dangerous to externalize it
+                        "ws",
+                        "miniflare",
+                    ],
+                    banner: {
+                        js: "var __ALCHEMY_RUNTIME__ = true;",
+                    },
+                    inject: [
+                        ...(props.bundle?.inject ?? []),
+                        path.resolve(import.meta.dirname, "..", "runtime", "shims.js"),
+                    ],
+                },
+            });
+        });
+        // defer construction of this worker until the app is about to finaloze
+        // this ensures that the Worker's dependencies are instantiated before we bundle
+        // it is then safe to bundle and import the Worker to detect which resources need to be auto-bound
+        const promise = Promise.all([deferred, stub]).then(([worker]) => worker);
+        if (isRuntime) {
+            if (props.fetch) {
+                promise.fetch = async (request, env, ctx) => {
+                    try {
+                        return await props.fetch(request, env, ctx);
+                    }
+                    catch (err) {
+                        return new Response(err.message + err.stack, {
+                            status: 500,
+                        });
+                    }
+                };
+            }
+            if (props.queue) {
+                promise.queue = async (batch, env, ctx) => {
+                    return await props.queue(batch, env, ctx);
+                };
+            }
+        }
+        else {
+            promise.fetch = async (request, init) => {
+                const worker = await promise;
+                if (!worker.url) {
+                    throw new Error("Worker URL is not available in runtime");
+                }
+                if (request instanceof Request) {
+                    const origin = new URL(worker.url);
+                    const incoming = request.url.startsWith("/")
+                        ? new URL(`${worker.url}${request.url}`)
+                        : new URL(request.url);
+                    console.log(incoming);
+                    const proxyURL = new URL(`${incoming.pathname}${incoming.search}${incoming.hash}`, origin);
+                    const headers = new Headers(request.headers);
+                    headers.set("host", origin.host);
+                    try {
+                        return await fetch(new Request(proxyURL, {
+                            method: request.method,
+                            body: request.body,
+                            headers,
+                            // TODO(sam): do we need this? GPT added it ...
+                            // redirect: "manual",
+                        }));
+                    }
+                    catch (err) {
+                        return new Response(err.message ?? "proxy error", { status: 500 });
+                    }
+                }
+                else {
+                    if (typeof request === "string" && request.startsWith("/")) {
+                        request = new URL(`${worker.url}${request}`);
+                    }
+                    return await fetch(request, init);
+                }
+            };
+        }
+        return promise;
+    }
+    return _Worker(id, props).then(async (worker) => {
+        const binding = await tryGetBinding(worker);
+        if (binding) {
+            worker.fetch = (request) => binding.fetch(request);
+            worker.connect = (address, options) => binding.connect(address, options);
+        }
+        return worker;
+    });
+}
+export const _Worker = Resource("cloudflare::Worker", {
     alwaysUpdate: true,
 }, async function (id, props) {
-    // Validate input - we need either script, entryPoint, or bundle
-    if (!props.script && !props.entrypoint) {
-        throw new Error("One of script or entryPoint must be provided");
-    }
     // Create Cloudflare API client with automatic account discovery
     const api = await createCloudflareApi(props);
     // Use the provided name
     const workerName = props.name ?? id;
-    const oldBindings = await this.get("bindings");
     const compatibilityDate = props.compatibilityDate ?? "2025-04-20";
     const compatibilityFlags = props.compatibilityFlags ?? [];
     const uploadWorkerScript = async (props) => {
+        const oldBindings = await this.get("bindings");
         // Get the script content - either from props.script, or by bundling
         const scriptContent = props.script ??
             (await bundleWorkerScript({
@@ -158,6 +234,8 @@ export const Worker = Resource("cloudflare::Worker", {
             workerName,
         }, assetUploadResult);
         await putWorker(api, workerName, scriptContent, scriptMetadata);
+        // TODO: it is less than ideal that this can fail, resulting in state problem
+        await this.set("bindings", props.bindings);
         for (const workflow of workflowsBindings) {
             await upsertWorkflow(api, {
                 workflowName: workflow.workflowName,
@@ -181,8 +259,6 @@ export const Worker = Resource("cloudflare::Worker", {
             }
             throw new Error(`Unsupported event source type: ${eventSource}`);
         }) ?? []);
-        // TODO: it is less than ideal that this can fail, resulting in state problem
-        await this.set("bindings", props.bindings);
         // Handle worker URL if requested
         const workerUrl = await configureURL(this, api, workerName, props.url ?? false);
         // Get current timestamp
@@ -194,16 +270,19 @@ export const Worker = Resource("cloudflare::Worker", {
                 await handleApiError(res, "updating cron triggers", "worker", workerName);
             }
         }
-        return { scriptMetadata, workerUrl, now };
+        return { scriptContent, scriptMetadata, workerUrl, now };
     };
     if (this.phase === "delete") {
-        if (Object.values(props.bindings ?? {}).some((binding) => binding === Self)) {
-            // remove the Self bindings or else we can't remove (LOL)
-            await uploadWorkerScript({
-                ...props,
-                bindings: Object.fromEntries(Object.entries(props.bindings ?? {}).filter(([_, binding]) => binding !== Self)),
-            });
-        }
+        // Delete any queue consumers attached to this worker first
+        await deleteQueueConsumers(this, api, workerName);
+        await uploadWorkerScript({
+            ...props,
+            entrypoint: undefined,
+            script: props.format === "cjs"
+                ? "addEventListener('fetch', event => { event.respondWith(new Response('hello world')); });"
+                : "export default { fetch(request) { return new Response('hello world'); } }",
+            bindings: {},
+        });
         await withExponentialBackoff(() => deleteWorker(this, api, {
             ...props,
             workerName,
@@ -213,6 +292,10 @@ export const Worker = Resource("cloudflare::Worker", {
             err.status === 503, 10, 100);
         return this.destroy();
     }
+    // Validate input - we need either script, entryPoint, or bundle
+    if (!props.script && !props.entrypoint) {
+        throw new Error("One of script or entrypoint must be provided");
+    }
     if (this.phase === "create") {
         if (!props.adopt) {
             await assertWorkerDoesNotExist(this, api, workerName);
@@ -244,10 +327,8 @@ export const Worker = Resource("cloudflare::Worker", {
         Env: undefined,
     });
 });
-async function deleteWorker(ctx, api, props) {
+export async function deleteWorker(ctx, api, props) {
     const workerName = props.workerName;
-    // Delete any queue consumers attached to this worker first
-    await deleteQueueConsumers(ctx, api, workerName);
     // Delete worker
     const deleteResponse = await api.delete(`/accounts/${api.accountId}/workers/scripts/${workerName}`);
     // Check for success (2xx status code)
@@ -268,7 +349,7 @@ async function deleteWorker(ctx, api, props) {
     // Return minimal output for deleted state
     return;
 }
-async function putWorker(api, workerName, scriptContent, scriptMetadata) {
+export async function putWorker(api, workerName, scriptContent, scriptMetadata) {
     return withExponentialBackoff(async () => {
         const scriptName = scriptMetadata.main_module ?? scriptMetadata.body_part;
         // Create FormData for the upload
@@ -296,254 +377,7 @@ async function putWorker(api, workerName, scriptContent, scriptMetadata) {
         return formData;
     }, (err) => err.status === 404 || err.status === 500 || err.status === 503, 10, 100);
 }
-/**
- * Creates asset configuration object from provided config or defaults
- */
-function createAssetConfig(config) {
-    const assetConfig = {
-        html_handling: "auto-trailing-slash",
-    };
-    if (config) {
-        if (config._headers !== undefined) {
-            assetConfig._headers = config._headers;
-        }
-        if (config._redirects !== undefined) {
-            assetConfig._redirects = config._redirects;
-        }
-        if (config.html_handling !== undefined) {
-            assetConfig.html_handling = config.html_handling;
-        }
-        if (config.not_found_handling !== undefined) {
-            assetConfig.not_found_handling = config.not_found_handling;
-        }
-        if (config.run_worker_first !== undefined) {
-            assetConfig.run_worker_first = config.run_worker_first;
-        }
-        if (config.serve_directly !== undefined) {
-            assetConfig.serve_directly = config.serve_directly;
-        }
-    }
-    return assetConfig;
-}
-async function prepareWorkerMetadata(ctx, oldBindings, props, assetUploadResult) {
-    // Prepare metadata with bindings
-    const meta = {
-        compatibility_date: props.compatibilityDate,
-        compatibility_flags: props.compatibilityFlags,
-        bindings: [],
-        observability: {
-            enabled: props.observability?.enabled !== false,
-        },
-        // TODO(sam): base64 encode instead? 0 collision risk vs readability.
-        tags: [`alchemy:id:${slugify(ctx.fqn)}`],
-        migrations: {
-            new_classes: props.migrations?.new_classes ?? [],
-            deleted_classes: props.migrations?.deleted_classes ?? [],
-            renamed_classes: props.migrations?.renamed_classes ?? [],
-            transferred_classes: props.migrations?.transferred_classes ?? [],
-            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,
-        };
-        // Initialize config from assetUploadResult if it exists
-        if (assetUploadResult.assetConfig) {
-            meta.assets.config = {
-                ...assetUploadResult.assetConfig,
-            };
-        }
-        // If there's no config from assetUploadResult but we have props.assets,
-        // we need to create the config ourselves (this handles the case when no assets were uploaded)
-        if (!meta.assets.config && props.assets) {
-            meta.assets.config = createAssetConfig(props.assets);
-        }
-    }
-    const bindings = (props.bindings ?? {});
-    // Convert bindings to the format expected by the API
-    for (const [bindingName, binding] of Object.entries(bindings)) {
-        // Create a copy of the binding to avoid modifying the original
-        if (typeof binding === "string") {
-            meta.bindings.push({
-                type: "plain_text",
-                name: bindingName,
-                text: binding,
-            });
-        }
-        else if (binding === Self) {
-            meta.bindings.push({
-                type: "service",
-                name: bindingName,
-                service: props.workerName,
-            });
-        }
-        else if (binding.type === "d1") {
-            meta.bindings.push({
-                type: "d1",
-                name: bindingName,
-                id: binding.id,
-            });
-        }
-        else if (binding.type === "kv_namespace") {
-            meta.bindings.push({
-                type: "kv_namespace",
-                name: bindingName,
-                namespace_id: "namespaceId" in binding ? binding.namespaceId : binding.id,
-            });
-        }
-        else if (binding.type === "service") {
-            meta.bindings.push({
-                type: "service",
-                name: bindingName,
-                service: binding.name,
-            });
-        }
-        else if (binding.type === "durable_object_namespace") {
-            meta.bindings.push({
-                type: "durable_object_namespace",
-                name: bindingName,
-                class_name: binding.className,
-                script_name: binding.scriptName,
-                environment: binding.environment,
-                namespace_id: binding.namespaceId,
-            });
-            configureClassMigration(binding, binding.id, binding.className);
-        }
-        else if (binding.type === "r2_bucket") {
-            meta.bindings.push({
-                type: "r2_bucket",
-                name: bindingName,
-                bucket_name: binding.name,
-            });
-        }
-        else if (binding.type === "assets") {
-            meta.bindings.push({
-                type: "assets",
-                name: bindingName,
-            });
-        }
-        else if (binding.type === "secret") {
-            meta.bindings.push({
-                type: "secret_text",
-                name: bindingName,
-                text: binding.unencrypted,
-            });
-        }
-        else if (binding.type === "workflow") {
-            meta.bindings.push({
-                type: "workflow",
-                name: bindingName,
-                workflow_name: binding.workflowName,
-                class_name: binding.className,
-                // this should be set if the Workflow is in another script ...
-                // script_name: ??,
-            });
-            // it's unclear whether this is needed, but it works both ways
-            // configureClassMigration(binding, binding.id, binding.className);
-        }
-        else if (binding.type === "queue") {
-            meta.bindings.push({
-                type: "queue",
-                name: bindingName,
-                queue_name: binding.name,
-            });
-        }
-        else if (binding.type === "pipeline") {
-            meta.bindings.push({
-                type: "pipelines",
-                name: bindingName,
-                pipeline: binding.name,
-            });
-        }
-        else if (binding.type === "vectorize") {
-            meta.bindings.push({
-                type: "vectorize",
-                name: bindingName,
-                index_name: binding.name,
-            });
-        }
-        else if (binding.type === "ai_gateway") {
-            // AI Gateway binding - just needs the name property
-            meta.bindings.push({
-                type: "ai",
-                name: bindingName,
-            });
-        }
-        else if (binding.type === "hyperdrive") {
-            // Hyperdrive binding
-            meta.bindings.push({
-                type: "hyperdrive",
-                name: bindingName,
-                id: binding.hyperdriveId,
-            });
-        }
-        else if (binding.type === "browser") {
-            meta.bindings.push({
-                type: "browser",
-                name: bindingName,
-            });
-        }
-        else if (binding.type === "ai") {
-            meta.bindings.push({
-                type: "ai",
-                name: bindingName,
-            });
-        }
-        else {
-            // @ts-expect-error - we should never reach here
-            throw new Error(`Unsupported binding type: ${binding.type}`);
-        }
-    }
-    function configureClassMigration(binding, stableId, className) {
-        const oldBinding = Object.values(oldBindings ?? {})
-            ?.filter((b) => typeof b === "object" &&
-            (b.type === "durable_object_namespace" || b.type === "workflow"))
-            ?.find((b) => b.id === stableId);
-        if (!oldBinding) {
-            if (binding.type === "durable_object_namespace" && binding.sqlite) {
-                meta.migrations.new_sqlite_classes.push(className);
-            }
-            else {
-                meta.migrations.new_classes.push(className);
-            }
-        }
-        else if (oldBinding.className !== className) {
-            meta.migrations.renamed_classes.push({
-                from: oldBinding.className,
-                to: className,
-            });
-        }
-    }
-    // Convert env variables to plain_text bindings
-    // TODO(sam): remove Worker.env in favor of always bindings
-    if (props.env) {
-        for (const [key, value] of Object.entries(props.env)) {
-            meta.bindings.push({
-                name: key,
-                type: "plain_text",
-                text: value,
-            });
-        }
-    }
-    // Determine if we're using ESM or service worker format
-    const isEsModule = props.format !== "cjs"; // Default to ESM unless CJS is specified
-    const scriptName = isEsModule ? "worker.js" : "script";
-    if (isEsModule) {
-        // For ES modules format
-        meta.main_module = scriptName;
-    }
-    else {
-        // For service worker format (CJS)
-        meta.body_part = scriptName;
-    }
-    if (process.env.DEBUG) {
-        console.log(meta);
-    }
-    return meta;
-}
-async function assertWorkerDoesNotExist(ctx, api, workerName) {
+export async function assertWorkerDoesNotExist(ctx, api, workerName) {
     const response = await api.get(`/accounts/${api.accountId}/workers/scripts/${workerName}`);
     if (response.status === 404) {
         return true;
@@ -560,7 +394,7 @@ async function assertWorkerDoesNotExist(ctx, api, workerName) {
     }
     throw new Error(`Error checking if worker exists: ${response.status} ${response.statusText} ${await response.text()}`);
 }
-async function configureURL(ctx, api, workerName, url) {
+export async function configureURL(ctx, api, workerName, url) {
     let workerUrl;
     if (url) {
         // Enable the workers.dev subdomain for this worker
@@ -595,7 +429,7 @@ async function configureURL(ctx, api, workerName, url) {
     }
     return workerUrl;
 }
-async function getWorkerScriptMetadata(api, workerName) {
+export async function getWorkerScriptMetadata(api, workerName) {
     const response = await api.get(`/accounts/${api.accountId}/workers/services/${workerName}`);
     if (response.status === 404) {
         return undefined;
@@ -605,7 +439,7 @@ async function getWorkerScriptMetadata(api, workerName) {
     }
     return (await response.json()).result;
 }
-async function getWorkerBindings(api, workerName, environment = "production") {
+export async function _getWorkerBindings(api, workerName, environment = "production") {
     const response = await api.get(`/accounts/${api.accountId}/workers/services/${workerName}/environments/${environment}/bindings`, {
         headers: {
             Authorization: `Bearer ${process.env.CLOUDFLARE_API_TOKEN}`,
@@ -621,109 +455,6 @@ 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
- * @param assetConfig Configuration for the assets
- * @returns Completion token for the assets upload
- */
-async function uploadAssets(api, workerName, assets, assetConfig) {
-    // Process the assets configuration once at the beginning
-    const processedConfig = createAssetConfig(assetConfig);
-    // 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,
-            assetConfig: processedConfig,
-        };
-    }
-    // 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();
-        let totalBytes = 0;
-        // 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),
-            });
-            totalBytes += blob.size;
-            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 with asset configuration
-    return {
-        completionToken,
-        assetConfig: processedConfig,
-    };
-}
-/**
- * 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,
-    };
-}
 /**
  * Lists and deletes all queue consumers for a specific worker
  * @param ctx Worker context containing eventSources