alchemy 0.44.4 → 0.45.0

package/lib/cloudflare/worker.js

@@ -1,6 +1,8 @@
+import kleur from "kleur";
 import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
-import path from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import path from "pathe";
 import { BUILD_DATE } from "../build-date.js";
 import { InnerResourceScope, Resource, ResourceKind } from "../resource.js";
 import { getBindKey, tryGetBinding } from "../runtime/bind.js";
@@ -9,7 +11,6 @@ import { bootstrapPlugin } from "../runtime/plugin.js";
 import { Scope } from "../scope.js";
 import { Secret, secret } from "../secret.js";
 import { serializeScope } from "../serde.js";
-import { getContentType } from "../util/content-type.js";
 import { DeferredPromise } from "../util/deferred-promise.js";
 import { logger } from "../util/logger.js";
 import { withExponentialBackoff } from "../util/retry.js";
@@ -17,14 +18,15 @@ import { CloudflareApiError, handleApiError } from "./api-error.js";
 import { createCloudflareApi, } from "./api.js";
 import { Json, } from "./bindings.js";
 import { isBucket } from "./bucket.js";
-import { createWorkerDevContext } from "./bundle/bundle-worker-dev.js";
-import { bundleWorkerScript, } from "./bundle/bundle-worker.js";
+import { normalizeWorkerBundle, } from "./bundle/index.js";
+import { wrap } from "./bundle/normalize.js";
 import { ContainerApplication } from "./container.js";
 import { CustomDomain } from "./custom-domain.js";
 import { isD1Database } from "./d1-database.js";
 import { DurableObjectNamespace, isDurableObjectNamespace, } from "./durable-object-namespace.js";
 import { isQueueEventSource, } from "./event-source.js";
 import { isKVNamespace } from "./kv-namespace.js";
+import { miniflareServer } from "./miniflare/miniflare.js";
 import { isPipeline } from "./pipeline.js";
 import { QueueConsumer, deleteQueueConsumer, listQueueConsumersForWorker, } from "./queue-consumer.js";
 import { isQueue } from "./queue.js";
@@ -33,8 +35,8 @@ import { isVectorizeIndex } from "./vectorize-index.js";
 import { uploadAssets } from "./worker-assets.js";
 import { bumpMigrationTagVersion, prepareWorkerMetadata, } from "./worker-metadata.js";
 import { WorkerStub, isWorkerStub } from "./worker-stub.js";
-import { miniflareServer } from "./worker/miniflare.js";
-import { getAccountSubdomain } from "./worker/subdomain.js";
+import { WorkerSubdomain, disableWorkerSubdomain } from "./worker-subdomain.js";
+import { createTail } from "./worker/tail.js";
 import { Workflow, isWorkflow, upsertWorkflow } from "./workflow.js";
 export function isWorker(resource) {
     return resource[ResourceKind] === "cloudflare::Worker";
@@ -224,174 +226,60 @@ export const DEFAULT_COMPATIBILITY_DATE = BUILD_DATE;
 export const _Worker = Resource("cloudflare::Worker", {
     alwaysUpdate: true,
 }, async function (id, props) {
-    if (props.noBundle && !props.entrypoint) {
-        throw new Error("entrypoint must be provided when noBundle is true");
-    }
-    // Use the provided name
-    const workerName = props.name ?? id;
     if (props.projectRoot) {
         logger.warn("projectRoot is deprecated, use cwd instead");
         props.cwd = props.projectRoot;
     }
-    const cwd = props.cwd ? path.resolve(props.cwd) : process.cwd();
+    const cwd = path.resolve(props.cwd ?? process.cwd());
     const relativeCwd = cwd === process.cwd() ? undefined : path.relative(process.cwd(), cwd);
+    const workerName = props.name ?? id;
     const compatibilityDate = props.compatibilityDate ?? DEFAULT_COMPATIBILITY_DATE;
     const compatibilityFlags = props.compatibilityFlags ?? [];
-    if (this.scope.dev && this.phase !== "delete" && props.dev !== false) {
-        // Get current timestamp
-        const now = Date.now();
-        if (typeof props.dev === "object" && "command" in props.dev) {
-            upsertDevCommand({
-                id,
-                command: props.dev.command,
-                cwd: props.dev.cwd ?? cwd,
-                env: props.env ?? {},
-            });
-            return this({
-                type: "service",
-                id,
-                entrypoint: props.entrypoint,
-                name: workerName,
-                cwd: relativeCwd,
-                compatibilityDate,
-                compatibilityFlags,
-                format: props.format || "esm", // Include format in the output
-                bindings: props.bindings ?? {},
-                env: props.env,
-                observability: props.observability,
-                createdAt: now,
-                updatedAt: now,
-                eventSources: props.eventSources,
-                url: props.dev.url,
-                dev: props.dev,
-                // Include assets configuration in the output
-                assets: props.assets,
-                // Include cron triggers in the output
-                crons: props.crons,
-                // phantom property
-                Env: undefined,
-            });
-        }
-        const sharedOptions = {
-            name: workerName,
-            compatibilityDate,
-            compatibilityFlags,
-            bindings: props.bindings ?? {},
-            port: typeof props.dev === "object" ? props.dev.port : undefined,
-        };
+    const dispatchNamespace = typeof props.namespace === "string"
+        ? props.namespace
+        : props.namespace?.namespaceName;
+    const dev = normalizeDev(this, props.dev);
+    const [bundle, error] = wrap(() => normalizeWorkerBundle({
+        entrypoint: props.entrypoint,
+        script: props.script,
+        format: props.format,
+        noBundle: props.noBundle,
+        rules: "rules" in props ? props.rules : undefined,
+        bundle: props.bundle,
+        cwd,
+        compatibilityDate,
+        compatibilityFlags,
+        outdir: props.bundle?.outdir ??
+            path.join(process.cwd(), ".alchemy", ...this.scope.chain, id),
+        sourceMap: "sourceMap" in props ? props.sourceMap : undefined,
+    }));
+    if (dev.local) {
         let url;
-        // If entrypoint is provided, set up hot reloading with esbuild context
-        if (props.entrypoint) {
-            const startPromise = new DeferredPromise();
-            await createWorkerDevContext(workerName, {
-                ...props,
-                entrypoint: props.entrypoint,
-                cwd,
-                compatibilityDate,
-                compatibilityFlags,
-            }, {
-                onBuildStart: () => {
-                    logger.task("miniflare-server", {
-                        message: `${startPromise.status === "pending" ? "Building" : "Rebuilding"}`,
-                        status: "pending",
-                        resource: id,
-                        prefix: "build",
-                        prefixColor: "cyanBright",
-                    });
-                },
-                onBuildEnd: async (newScript) => {
-                    try {
-                        // Hot reload callback - update the miniflare worker
-                        const server = await miniflareServer.push({
-                            ...sharedOptions,
-                            script: newScript,
-                        });
-                        if (startPromise.status === "pending") {
-                            logger.task("miniflare-server", {
-                                message: `Started Miniflare server at ${server.url}`,
-                                status: "success",
-                                resource: id,
-                                prefix: "ready",
-                                prefixColor: "cyanBright",
-                            });
-                            startPromise.resolve(server.url);
-                        }
-                        else {
-                            logger.task("miniflare-server", {
-                                message: `Updated Miniflare server at ${server.url}`,
-                                status: "success",
-                                resource: id,
-                                prefix: "reload",
-                                prefixColor: "cyanBright",
-                            });
-                        }
-                    }
-                    catch (error) {
-                        if (startPromise.status === "pending") {
-                            logger.error(error);
-                            logger.task("miniflare-server", {
-                                message: "Failed to start Miniflare server",
-                                status: "failure",
-                                resource: id,
-                                prefix: "error",
-                                prefixColor: "redBright",
-                            });
-                            startPromise.reject(new Error(`Failed to start Miniflare server for worker "${workerName}"`, { cause: error }));
-                        }
-                        else {
-                            logger.task("miniflare-server", {
-                                message: "Failed to update Miniflare server",
-                                status: "failure",
-                                resource: id,
-                                prefix: "error",
-                                prefixColor: "redBright",
-                            });
-                            logger.error(error);
-                        }
-                    }
-                },
-                onBuildError: (errors) => {
-                    if (startPromise.status === "pending") {
-                        logger.task("miniflare-server", {
-                            message: "Failed to build worker",
-                            status: "failure",
-                            resource: id,
-                            prefix: "error",
-                            prefixColor: "redBright",
-                        });
-                        startPromise.reject(errors);
-                    }
-                    else {
-                        logger.task("miniflare-server", {
-                            message: "Failed to rebuild worker",
-                            status: "failure",
-                            resource: id,
-                            prefix: "error",
-                            prefixColor: "redBright",
-                        });
-                        logger.error(errors);
-                    }
-                },
-            });
-            url = await startPromise.value;
+        if (error) {
+            throw error;
         }
-        else {
-            // Fallback to one-time bundling for inline scripts
-            const scriptContent = props.script ??
-                (await bundleWorkerScript({
-                    name: workerName,
-                    ...props,
-                    cwd,
+        switch (dev.type) {
+            case "command":
+                createDevCommand({
+                    id,
+                    command: dev.command,
+                    cwd: dev.cwd ?? process.cwd(),
+                    env: props.env ?? {},
+                });
+                url = dev.url;
+                break;
+            case "miniflare": {
+                url = await createMiniflare({
+                    id,
+                    workerName,
                     compatibilityDate,
                     compatibilityFlags,
-                }));
-            const server = await miniflareServer.push({
-                ...sharedOptions,
-                script: typeof scriptContent === "string"
-                    ? scriptContent
-                    : scriptContent[props.entrypoint].toString(),
-            });
-            url = server.url;
+                    bindings: props.bindings,
+                    bundle,
+                    port: dev.port,
+                });
+                break;
+            }
         }
         return this({
             type: "service",
@@ -402,11 +290,11 @@ export const _Worker = Resource("cloudflare::Worker", {
             compatibilityDate,
             compatibilityFlags,
             format: props.format || "esm", // Include format in the output
-            bindings: props.bindings ?? {},
+            bindings: normalizeExportBindings(workerName, props.bindings),
             env: props.env,
             observability: props.observability,
-            createdAt: now,
-            updatedAt: now,
+            createdAt: this.output?.createdAt ?? Date.now(),
+            updatedAt: Date.now(),
             eventSources: props.eventSources,
             url,
             dev: props.dev,
@@ -418,59 +306,48 @@ export const _Worker = Resource("cloudflare::Worker", {
             Env: undefined,
         });
     }
-    // Create Cloudflare API client with automatic account discovery
     const api = await createCloudflareApi(props);
-    const uploadWorkerScript = async (props) => {
-        // Get the script content - either from props.script, or by bundling
-        const scriptBundle = props.script ??
-            (await bundleWorkerScript({
-                ...props,
-                name: workerName,
-                cwd,
-                compatibilityDate,
-                compatibilityFlags,
-            }));
-        // Find any assets bindings
-        const assetsBindings = [];
-        const workflowsBindings = [];
-        const containersBindings = [];
-        if (props.bindings) {
-            for (const [bindingName, binding] of Object.entries(props.bindings)) {
-                if (typeof binding === "object") {
-                    if (binding.type === "assets") {
-                        assetsBindings.push({ name: bindingName, assets: binding });
-                    }
-                    else if (binding.type === "workflow") {
-                        workflowsBindings.push(binding);
-                    }
-                    else if (binding.type === "container") {
-                        containersBindings.push(binding);
-                    }
-                }
+    if (this.phase === "delete") {
+        await bundle?.delete?.();
+        if (!props.version) {
+            await deleteQueueConsumers(api, workerName);
+            await deleteWorker(api, {
+                scriptName: workerName,
+                dispatchNamespace,
+            });
+        }
+        return this.destroy();
+    }
+    else if (error) {
+        throw error;
+    }
+    let assetsBinding;
+    const workflowsBindings = [];
+    const containersBindings = [];
+    for (const binding of Object.values(props.bindings ?? {})) {
+        if (typeof binding === "object") {
+            if (binding.type === "assets") {
+                assetsBinding = binding;
+            }
+            else if (binding.type === "workflow") {
+                workflowsBindings.push(binding);
+            }
+            else if (binding.type === "container") {
+                containersBindings.push(binding);
             }
         }
-        // Get dispatch namespace if specified
-        const dispatchNamespace = props.namespace
-            ? typeof props.namespace === "string"
-                ? props.namespace
-                : props.namespace.namespace
-            : undefined;
-        // 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, {
+    }
+    const putWorkerWithAssets = async (props, scriptBundle) => {
+        const assetUploadResult = assetsBinding
+            ? await uploadAssets(api, {
                 workerName,
-                assets: assetBinding.assets,
+                assets: assetsBinding,
                 assetConfig: props.assets,
                 namespace: dispatchNamespace,
-            });
-        }
+            })
+            : undefined;
         // Deploy worker (either as version or live worker)
-        const versionResult = await putWorker(api, {
+        return await putWorker(api, {
             ...props,
             workerName,
             scriptBundle,
@@ -480,115 +357,14 @@ export const _Worker = Resource("cloudflare::Worker", {
             compatibilityFlags,
             assetUploadResult,
         });
-        versionResult.versionId;
-        for (const workflow of workflowsBindings) {
-            if (workflow.scriptName === undefined ||
-                workflow.scriptName === workerName) {
-                await upsertWorkflow(api, {
-                    workflowName: workflow.workflowName,
-                    className: workflow.className,
-                    scriptName: workflow.scriptName ?? workerName,
-                });
-            }
-        }
-        for (const container of containersBindings) {
-            async function findNamespaceId() {
-                const response = await api.get(`/accounts/${api.accountId}/workers/scripts/${workerName}/versions/${versionResult.deploymentId}`);
-                const result = (await response.json());
-                const namespaceId = result.result.resources.bindings.find((binding) => binding.type === "durable_object_namespace" &&
-                    binding.class_name === container.className)?.namespace_id;
-                if (!namespaceId) {
-                    throw new Error(`Namespace ID not found for container ${container.id}`);
-                }
-                return namespaceId;
-            }
-            await ContainerApplication(container.id, {
-                accountId: props.accountId,
-                apiKey: props.apiKey,
-                apiToken: props.apiToken,
-                baseUrl: props.baseUrl,
-                email: props.email,
-                image: container.image,
-                name: container.id,
-                instanceType: container.instanceType,
-                observability: container.observability,
-                durableObjects: {
-                    namespaceId: await findNamespaceId(),
-                },
-                schedulingPolicy: container.schedulingPolicy,
-            });
-        }
-        await Promise.all(props.eventSources?.map((eventSource) => {
-            if (isQueue(eventSource) || isQueueEventSource(eventSource)) {
-                const queue = isQueue(eventSource)
-                    ? eventSource
-                    : eventSource.queue;
-                return QueueConsumer(`${queue.id}-consumer`, {
-                    queue,
-                    scriptName: workerName,
-                    accountId: api.accountId,
-                    adopt: props.adopt,
-                    settings: isQueueEventSource(eventSource)
-                        ? eventSource.settings
-                        : queue.dlq
-                            ? { deadLetterQueue: queue.dlq }
-                            : undefined,
-                });
-            }
-            throw new Error(`Unsupported event source type: ${eventSource}`);
-        }) ?? []);
-        // Handle worker URL if requested
-        let workerUrl;
-        if (props.version) {
-            // For versions, use the preview URL if available
-            workerUrl = versionResult?.previewUrl;
-        }
-        else if (!props.namespace) {
-            // namespaces don't support URLs
-            // For regular workers, use the normal URL configuration
-            workerUrl = await configureURL(this, api, {
-                ...props,
-                workerName,
-                url: props.url ?? true,
-            });
-        }
-        // Get current timestamp
-        const now = Date.now();
-        // Update cron triggers
-        if (props.crons) {
-            const res = await api.put(`/accounts/${api.accountId}/workers/scripts/${workerName}/schedules`, props.crons.map((cron) => ({ cron })));
-            if (!res.ok) {
-                await handleApiError(res, "updating cron triggers", "worker", workerName);
-            }
-        }
-        return { scriptBundle, workerUrl, now, versionResult };
     };
-    if (this.phase === "delete") {
-        // only delete the worker if it's not a version
-        if (!props.version) {
-            // Delete any queue consumers attached to this worker first
-            await deleteQueueConsumers(api, workerName);
-            await withExponentialBackoff(() => deleteWorker(api, {
-                workerName,
-                namespace: typeof props.namespace === "string"
-                    ? props.namespace
-                    : props.namespace?.namespaceId,
-                url: this.output.url,
-            }), (err) => (err.status === 400 &&
-                err.message.includes("is still referenced by service bindings in Workers")) ||
-                err.status === 500 ||
-                err.status === 503, 10, 100);
-        }
-        return this.destroy();
-    }
     if (this.phase === "create") {
         if (props.version) {
             // When version is specified, we adopt existing workers or create them if they don't exist
-            const workerExists = await checkWorkerExists(api, workerName);
-            if (!workerExists) {
+            if (!(await workerExists(api, workerName))) {
                 // Create the base worker first if it doesn't exist
                 const baseWorkerProps = { ...props, version: undefined };
-                await uploadWorkerScript(baseWorkerProps);
+                await putWorkerWithAssets(baseWorkerProps, await bundle.create());
             }
             // We always "adopt" when publishing versions
         }
@@ -596,73 +372,136 @@ export const _Worker = Resource("cloudflare::Worker", {
             await assertWorkerDoesNotExist(api, workerName);
         }
     }
-    const { workerUrl, now } = await uploadWorkerScript(props);
-    function ensureNoDuplicates(name, items) {
-        const duplicates = items.filter((pattern, index) => items.indexOf(pattern) !== index);
-        if (duplicates.length > 0) {
-            throw new Error(`Duplicate ${name} found: ${duplicates.join(", ")}`);
-        }
-    }
-    let createdDomains;
-    if (props.domains?.length) {
-        ensureNoDuplicates("Custom Domain", props.domains.map((domain) => typeof domain === "string" ? domain : domain.domainName));
-        createdDomains = await Promise.all(props.domains.map(async (customDomain) => {
-            const domainName = typeof customDomain === "string"
-                ? customDomain
-                : customDomain.domainName;
-            return await CustomDomain(domainName, {
-                workerName,
-                name: domainName,
-                zoneId: typeof customDomain === "string"
-                    ? undefined
-                    : customDomain.zoneId,
-                adopt: typeof customDomain === "string"
-                    ? (props.adopt ?? false)
-                    : (customDomain.adopt ?? props.adopt),
-            });
+    let putWorkerResult;
+    if (dev.type === "remote") {
+        // todo(john): clean this up and add log tail
+        const controller = new AbortController();
+        cleanups.push(() => controller.abort());
+        const watcher = await bundle.watch(controller.signal);
+        const promise = new DeferredPromise();
+        void watcher.pipeTo(new WritableStream({
+            async write(chunk) {
+                switch (chunk.type) {
+                    case "start":
+                        logger.task("", {
+                            message: "start",
+                            status: "pending",
+                            resource: id,
+                            prefix: "build",
+                            prefixColor: "cyanBright",
+                        });
+                        break;
+                    case "end": {
+                        if (promise.status === "pending") {
+                            await putWorkerWithAssets(props, chunk.result)
+                                .then((result) => promise.resolve(result))
+                                .catch((error) => {
+                                controller.abort();
+                                promise.reject(error);
+                            });
+                            return;
+                        }
+                        logger.task("", {
+                            message: "reload",
+                            status: "success",
+                            resource: id,
+                            prefix: "build",
+                            prefixColor: "cyanBright",
+                        });
+                        await putWorker(api, {
+                            ...props,
+                            workerName,
+                            scriptBundle: chunk.result,
+                            dispatchNamespace,
+                            version: props.version,
+                            compatibilityDate,
+                            compatibilityFlags,
+                            assetUploadResult: assetsBinding
+                                ? {
+                                    keepAssets: true,
+                                    assetConfig: props.assets,
+                                }
+                                : undefined,
+                            unstable_cacheWorkerSettings: true,
+                        });
+                        logger.task("", {
+                            message: "updated",
+                            status: "success",
+                            resource: id,
+                            prefix: "build",
+                            prefixColor: "greenBright",
+                        });
+                        break;
+                    }
+                    case "error":
+                        logger.task("", {
+                            message: "error",
+                            status: "failure",
+                            resource: id,
+                            prefix: "build",
+                            prefixColor: "redBright",
+                        });
+                        logger.error(chunk.errors);
+                        break;
+                }
+            },
         }));
+        putWorkerResult = await promise.value;
+        const tail = await createTail(api, id, workerName);
+        cleanups.push(() => tail.close());
     }
-    // Create routes if provided and capture their outputs
-    let createdRoutes;
-    if (props.routes && props.routes.length > 0) {
-        ensureNoDuplicates("Route", props.routes.map((route) => typeof route === "string" ? route : route.pattern));
-        // Create Route resources for each route and capture their outputs
-        createdRoutes = await Promise.all(props.routes.map(async (routeConfig) => {
-            const pattern = typeof routeConfig === "string" ? routeConfig : routeConfig.pattern;
-            return await Route(pattern, {
-                pattern,
-                script: workerName,
-                zoneId: typeof routeConfig === "string" ? undefined : routeConfig.zoneId, // Route resource will handle inference if not provided
-                adopt: typeof routeConfig === "string"
-                    ? (props.adopt ?? false)
-                    : (routeConfig.adopt ?? props.adopt),
-                accountId: props.accountId,
-                apiKey: props.apiKey,
-                apiToken: props.apiToken,
-                baseUrl: props.baseUrl,
-                email: props.email,
-            });
-        }));
+    else {
+        putWorkerResult = await putWorkerWithAssets(props, await bundle.create());
     }
-    function exportBindings() {
-        return Object.fromEntries(Object.entries(props.bindings ?? {}).map(([bindingName, binding]) => [
-            bindingName,
-            isDurableObjectNamespace(binding) &&
-                binding.scriptName === undefined
-                ? new DurableObjectNamespace(binding.id, {
-                    ...binding,
-                    // re-export this binding mapping to the host worker (this worker)
-                    scriptName: workerName,
-                })
-                : isWorkflow(binding) && binding.scriptName === undefined
-                    ? new Workflow(binding.id, {
-                        ...binding,
-                        // re-export this binding mapping to the host worker (this worker)
-                        scriptName: workerName,
-                    })
-                    : binding,
-        ]));
+    const tasks = [];
+    for (const workflow of workflowsBindings) {
+        if (workflow.scriptName === undefined ||
+            workflow.scriptName === workerName) {
+            tasks.push(upsertWorkflow(api, {
+                workflowName: workflow.workflowName,
+                className: workflow.className,
+                scriptName: workflow.scriptName ?? workerName,
+            }));
+        }
+    }
+    if (containersBindings.length > 0) {
+        tasks.push(getVersionMetadata(api, workerName, putWorkerResult.deployment_id).then((versionMetadata) => provisionContainers(api, {
+            scriptName: workerName,
+            containers: containersBindings,
+            bindings: versionMetadata.resources.bindings,
+        })));
+    }
+    if (!isDeepStrictEqual(props.crons, this.output?.crons)) {
+        tasks.push(api.put(`/accounts/${api.accountId}/workers/scripts/${workerName}/schedules`, props.crons?.map((cron) => ({ cron })) ?? []));
     }
+    tasks.push(provisionEventSources(api, {
+        scriptName: workerName,
+        eventSources: props.eventSources,
+    }));
+    const [domains, routes, subdomain] = await Promise.all([
+        // TODO: can you provision domains and routes in parallel, or is there a dependency?
+        provisionDomains(api, {
+            scriptName: workerName,
+            adopt: props.adopt,
+            domains: props.domains,
+        }),
+        provisionRoutes(api, {
+            scriptName: workerName,
+            adopt: props.adopt,
+            routes: props.routes,
+        }),
+        provisionSubdomain(api, {
+            scriptName: workerName,
+            enable: props.url ?? dispatchNamespace === undefined,
+            previewVersionId: props.version && putWorkerResult.metadata.has_preview
+                ? putWorkerResult.id
+                : undefined,
+            retain: !!props.version,
+            forceDelete: this.phase === "create" && !!props.adopt && props.url === false,
+        }),
+        ...tasks,
+    ]);
+    const now = Date.now();
     // Construct the output
     return this({
         ...props,
@@ -674,22 +513,22 @@ export const _Worker = Resource("cloudflare::Worker", {
         compatibilityDate,
         compatibilityFlags,
         format: props.format || "esm", // Include format in the output
-        bindings: exportBindings(),
+        bindings: normalizeExportBindings(workerName, props.bindings),
         env: props.env,
         observability: props.observability,
-        createdAt: now,
+        createdAt: this.output?.createdAt ?? now,
         updatedAt: now,
         eventSources: props.eventSources,
-        url: workerUrl,
+        url: subdomain?.url,
         dev: props.dev,
         // Include assets configuration in the output
         assets: props.assets,
         // Include cron triggers in the output
         crons: props.crons,
         // Include the created routes in the output
-        routes: createdRoutes,
+        routes,
         // Include the created domains in the output
-        domains: createdDomains,
+        domains,
         // Include the dispatch namespace in the output
         namespace: props.namespace,
         // Include version information in the output
@@ -698,31 +537,324 @@ export const _Worker = Resource("cloudflare::Worker", {
         Env: undefined,
     });
 });
-export async function deleteWorker(api, props) {
-    const workerName = props.workerName;
-    // Delete worker
-    const deleteResponse = await api.delete(props.namespace
-        ? `/accounts/${api.accountId}/workers/dispatch/namespaces/${props.namespace}/scripts/${workerName}?force=true`
-        : `/accounts/${api.accountId}/workers/scripts/${workerName}?force=true`);
-    // Check for success (2xx status code)
-    if (!deleteResponse.ok && deleteResponse.status !== 404) {
-        await handleApiError(deleteResponse, "delete", "worker", workerName);
-    }
-    // Disable the URL if it was enabled
-    if (props.url) {
-        try {
-            await api.post(`/accounts/${api.accountId}/workers/scripts/${workerName}/subdomain`, JSON.stringify({ enabled: false }), {
-                headers: { "Content-Type": "application/json" },
+const cleanups = [];
+let exiting = false;
+process.on("SIGINT", async () => {
+    if (cleanups.length > 0) {
+        if (!exiting) {
+            exiting = true;
+            logger.log(`\n${kleur.gray("Exiting...")}`);
+        }
+        // TODO: for some reason this runs twice...
+        // and this whole thing feels hacky anyway
+        await Promise.allSettled(cleanups.map((cleanup) => cleanup()));
+    }
+    process.exit(0);
+});
+const normalizeDev = (ctx, dev) => {
+    if (!ctx.scope.dev || ctx.phase === "delete" || dev === false) {
+        return {
+            type: "none",
+            local: false,
+        };
+    }
+    const devObj = dev === true ? {} : (dev ?? {});
+    if ("command" in devObj) {
+        // Commands are always local
+        return {
+            type: "command",
+            ...devObj,
+            local: true,
+        };
+    }
+    if (devObj.remote === false || ctx.scope.dev === "prefer-local") {
+        return {
+            type: "miniflare",
+            port: devObj.port,
+            local: true,
+        };
+    }
+    return {
+        type: "remote",
+        local: false,
+    };
+};
+const assertUnique = (inputs, key, message) => {
+    const ids = inputs.map((input) => input[key]);
+    const duplicates = ids.filter((id, index) => ids.indexOf(id) !== index);
+    if (duplicates.length > 0) {
+        throw new Error(`Duplicate ${message} found: ${duplicates.join(", ")}`);
+    }
+};
+const normalizeExportBindings = (scriptName, bindings = {}) => {
+    return Object.fromEntries(Object.entries(bindings).map(([bindingName, binding]) => [
+        bindingName,
+        isDurableObjectNamespace(binding) && binding.scriptName === undefined
+            ? new DurableObjectNamespace(binding.id, {
+                ...binding,
+                // re-export this binding mapping to the host worker (this worker)
+                scriptName,
+            })
+            : isWorkflow(binding) && binding.scriptName === undefined
+                ? new Workflow(binding.id, {
+                    ...binding,
+                    // re-export this binding mapping to the host worker (this worker)
+                    scriptName,
+                })
+                : binding,
+    ]));
+};
+const normalizeApiOptions = (api) => ({
+    accountId: api.accountId,
+    apiKey: api.apiKey,
+    apiToken: api.apiToken,
+    email: api.email,
+    baseUrl: api.baseUrl,
+});
+async function provisionContainers(api, props) {
+    if (!props.containers?.length) {
+        return;
+    }
+    return await Promise.all(props.containers.map((container) => {
+        const namespaceId = props.bindings.find((binding) => binding.type === "durable_object_namespace" &&
+            binding.class_name === container.className)?.namespace_id;
+        if (!namespaceId) {
+            throw new Error(`Namespace ID not found for container ${container.id}`);
+        }
+        return ContainerApplication(container.id, {
+            image: container.image,
+            name: container.id,
+            instanceType: container.instanceType,
+            observability: container.observability,
+            durableObjects: {
+                namespaceId,
+            },
+            schedulingPolicy: container.schedulingPolicy,
+            adopt: container.adopt,
+            ...normalizeApiOptions(api),
+        });
+    }));
+}
+async function provisionEventSources(api, props) {
+    if (!props.eventSources?.length) {
+        return;
+    }
+    return await Promise.all(props.eventSources.map((eventSource) => {
+        if (isQueue(eventSource)) {
+            return QueueConsumer(`${eventSource.id}-consumer`, {
+                queue: eventSource,
+                scriptName: props.scriptName,
+                settings: eventSource.dlq
+                    ? { deadLetterQueue: eventSource.dlq }
+                    : undefined,
+                ...normalizeApiOptions(api),
             });
         }
-        catch (error) {
-            logger.warn("Failed to disable worker URL during deletion:", error);
+        if (isQueueEventSource(eventSource)) {
+            return QueueConsumer(`${eventSource.queue.id}-consumer`, {
+                queue: eventSource.queue,
+                scriptName: props.scriptName,
+                settings: eventSource.settings,
+                ...normalizeApiOptions(api),
+            });
         }
+        throw new Error(`Unsupported event source: ${eventSource}`);
+    }));
+}
+async function provisionDomains(api, props) {
+    if (!props.domains?.length) {
+        return;
+    }
+    const domains = props.domains.map((domain) => {
+        if (typeof domain === "string") {
+            return {
+                name: domain,
+                zoneId: undefined,
+                adopt: props.adopt,
+            };
+        }
+        return {
+            name: domain.domainName,
+            zoneId: domain.zoneId,
+            adopt: domain.adopt ?? props.adopt,
+        };
+    });
+    assertUnique(domains, "name", "Custom Domain");
+    return await Promise.all(domains.map(async (domain) => {
+        return await CustomDomain(domain.name, {
+            workerName: props.scriptName,
+            name: domain.name,
+            zoneId: domain.zoneId,
+            adopt: domain.adopt,
+            ...normalizeApiOptions(api),
+        });
+    }));
+}
+async function provisionRoutes(api, props) {
+    if (!props.routes?.length) {
+        return;
+    }
+    const routes = props.routes.map((route) => {
+        if (typeof route === "string") {
+            return {
+                pattern: route,
+                adopt: props.adopt,
+            };
+        }
+        return {
+            pattern: route.pattern,
+            zoneId: route.zoneId,
+            adopt: route.adopt ?? props.adopt,
+        };
+    });
+    assertUnique(routes, "pattern", "Route");
+    return await Promise.all(routes.map(async (route) => {
+        return await Route(route.pattern, {
+            pattern: route.pattern,
+            script: props.scriptName,
+            zoneId: route.zoneId,
+            adopt: route.adopt,
+            ...normalizeApiOptions(api),
+        });
+    }));
+}
+async function provisionSubdomain(api, props) {
+    if (props.enable) {
+        return await WorkerSubdomain("url", {
+            scriptName: props.scriptName,
+            previewVersionId: props.previewVersionId,
+            retain: props.retain,
+            ...normalizeApiOptions(api),
+        });
+    }
+    if (props.forceDelete) {
+        await disableWorkerSubdomain(api, props.scriptName);
     }
-    // Return minimal output for deleted state
-    return;
 }
-function upsertDevCommand(props) {
+async function createMiniflare(props) {
+    const sharedOptions = {
+        name: props.workerName,
+        compatibilityDate: props.compatibilityDate,
+        compatibilityFlags: props.compatibilityFlags,
+        bindings: props.bindings,
+        port: props.port,
+    };
+    const startPromise = new DeferredPromise();
+    const controller = new AbortController();
+    cleanups.push(() => controller.abort());
+    (await props.bundle.watch(controller.signal))
+        .pipeThrough(new TransformStream({
+        async transform(chunk, controller) {
+            switch (chunk.type) {
+                case "start": {
+                    controller.enqueue({ type: "build-start" });
+                    break;
+                }
+                case "end": {
+                    controller.enqueue({ type: "build-end" });
+                    try {
+                        const server = await miniflareServer.push({
+                            ...sharedOptions,
+                            bundle: chunk.result,
+                        });
+                        controller.enqueue({
+                            type: "miniflare-ready",
+                            url: server.url,
+                        });
+                    }
+                    catch (error) {
+                        controller.enqueue({
+                            type: "miniflare-error",
+                            error: error,
+                        });
+                    }
+                    break;
+                }
+                case "error": {
+                    controller.enqueue({
+                        type: "build-error",
+                        errors: chunk.errors,
+                    });
+                    break;
+                }
+            }
+        },
+    }))
+        .pipeTo(new WritableStream({
+        write: async (chunk) => {
+            switch (chunk.type) {
+                case "build-start": {
+                    logger.task("", {
+                        message: "start",
+                        status: "pending",
+                        resource: props.id,
+                        prefix: "build",
+                        prefixColor: "cyanBright",
+                    });
+                    break;
+                }
+                case "build-end": {
+                    logger.task("", {
+                        message: startPromise.status === "pending" ? "load" : "reload",
+                        status: "success",
+                        resource: props.id,
+                        prefix: "build",
+                        prefixColor: "greenBright",
+                    });
+                    break;
+                }
+                case "build-error": {
+                    logger.task("", {
+                        message: "error",
+                        status: "failure",
+                        resource: props.id,
+                        prefix: "build",
+                        prefixColor: "redBright",
+                    });
+                    if (startPromise.status === "pending") {
+                        controller.abort();
+                        startPromise.reject(chunk.errors);
+                    }
+                    else {
+                        logger.error(chunk.errors);
+                    }
+                    break;
+                }
+                case "miniflare-ready": {
+                    logger.task("", {
+                        message: `ready at ${chunk.url}`,
+                        status: "success",
+                        resource: props.id,
+                        prefix: "miniflare",
+                        prefixColor: "greenBright",
+                    });
+                    if (startPromise.status === "pending") {
+                        startPromise.resolve(chunk.url);
+                    }
+                    break;
+                }
+                case "miniflare-error": {
+                    logger.task("", {
+                        message: "error",
+                        status: "failure",
+                        resource: props.id,
+                        prefix: "miniflare",
+                        prefixColor: "redBright",
+                    });
+                    if (startPromise.status === "pending") {
+                        startPromise.reject(chunk.error);
+                    }
+                    else {
+                        logger.error(chunk.error);
+                    }
+                    break;
+                }
+            }
+        },
+    }));
+    return await startPromise.value;
+}
+function createDevCommand(props) {
     const persistFile = path.join(process.cwd(), ".alchemy", `${props.id}.pid`);
     if (existsSync(persistFile)) {
         const pid = Number.parseInt(readFileSync(persistFile, "utf8"));
@@ -749,104 +881,92 @@ function upsertDevCommand(props) {
         },
         stdio: ["inherit", "inherit", "inherit"],
     });
-    process.on("SIGINT", () => {
+    cleanups.push(() => {
         try {
             unlinkSync(persistFile);
         }
         catch {
             // ignore
         }
-        proc.kill("SIGINT");
-        process.exit(0);
+        proc.kill();
     });
     if (proc.pid) {
         mkdirSync(path.dirname(persistFile), { recursive: true });
         writeFileSync(persistFile, proc.pid.toString());
     }
 }
+async function prepareWorkerUpload(api, props) {
+    const scriptMetadata = await prepareWorkerMetadata(api, props);
+    if (props.format === "cjs") {
+        scriptMetadata.body_part = props.scriptBundle.entrypoint;
+    }
+    else {
+        scriptMetadata.main_module = props.scriptBundle.entrypoint;
+    }
+    const body = new FormData();
+    for await (const file of props.scriptBundle.files) {
+        body.append(file.name, file);
+    }
+    // Prepare metadata - add version annotations if this is a version
+    const finalMetadata = props.version
+        ? {
+            ...scriptMetadata,
+            // Exclude migrations for worker versions - they're not allowed
+            migrations: undefined,
+            annotations: {
+                "workers/tag": props.version,
+                "workers/message": `Version ${props.version}`,
+            },
+        }
+        : {
+            ...scriptMetadata,
+            migrations: scriptMetadata.migrations
+                ? {
+                    ...scriptMetadata.migrations,
+                    old_tag: props.migrationTag,
+                    new_tag: bumpMigrationTagVersion(props.migrationTag),
+                }
+                : undefined,
+        };
+    body.append("metadata", new Blob([JSON.stringify(finalMetadata)], {
+        type: "application/json",
+    }));
+    let endpoint;
+    let method;
+    if (props.version) {
+        if (props.dispatchNamespace) {
+            throw new Error("Worker Preview Versions are not supported in Workers for Platforms");
+        }
+        // Upload worker version using the versions API
+        endpoint = `/accounts/${api.accountId}/workers/scripts/${props.workerName}/versions`;
+        method = "POST";
+    }
+    else {
+        // Upload worker script with bindings
+        endpoint = props.dispatchNamespace
+            ? `/accounts/${api.accountId}/workers/dispatch/namespaces/${props.dispatchNamespace}/scripts/${props.workerName}`
+            : `/accounts/${api.accountId}/workers/scripts/${props.workerName}`;
+        method = "PUT";
+    }
+    return {
+        body,
+        endpoint,
+        method,
+    };
+}
 export async function putWorker(api, props) {
     const { 
     //
-    dispatchNamespace, migrationTag, workerName, scriptBundle, version, } = props;
-    const scriptMetadata = await prepareWorkerMetadata(api, props);
+    workerName, version, } = props;
     return withExponentialBackoff(async () => {
-        const scriptName = scriptMetadata.main_module ?? scriptMetadata.body_part;
-        // Create FormData for the upload
-        const formData = new FormData();
-        function addFile(fileName, content) {
-            const contentType = getContentType(fileName) ?? "application/null";
-            formData.append(fileName, new Blob([content], {
-                type: contentType === "application/javascript" &&
-                    scriptMetadata.main_module
-                    ? "application/javascript+module"
-                    : contentType,
-            }), fileName);
-        }
-        if (typeof scriptBundle === "string") {
-            addFile(scriptName, scriptBundle);
-        }
-        else {
-            for (const [fileName, content] of Object.entries(scriptBundle)) {
-                addFile(fileName, content);
-            }
-        }
-        // Prepare metadata - add version annotations if this is a version
-        const finalMetadata = version
-            ? {
-                ...scriptMetadata,
-                // Exclude migrations for worker versions - they're not allowed
-                migrations: undefined,
-                annotations: {
-                    "workers/tag": version,
-                    "workers/message": `Version ${version}`,
-                },
-            }
-            : {
-                ...scriptMetadata,
-                migrations: scriptMetadata.migrations
-                    ? {
-                        ...scriptMetadata.migrations,
-                        old_tag: migrationTag,
-                        new_tag: bumpMigrationTagVersion(migrationTag),
-                    }
-                    : undefined,
-            };
-        if (process.env.DEBUG) {
-            console.log(`metadata(${scriptName}):`, finalMetadata);
-        }
-        // Add metadata as JSON
-        formData.append("metadata", new Blob([JSON.stringify(finalMetadata)], {
-            type: "application/json",
-        }));
-        // Determine endpoint and HTTP method
-        let endpoint;
-        let method;
-        if (version) {
-            if (dispatchNamespace) {
-                throw new Error("Worker Preview Versions are not supported in Workers for Platforms");
-            }
-            // Upload worker version using the versions API
-            endpoint = `/accounts/${api.accountId}/workers/scripts/${workerName}/versions`;
-            method = "POST";
-        }
-        else {
-            // Upload worker script with bindings
-            endpoint = dispatchNamespace
-                ? `/accounts/${api.accountId}/workers/dispatch/namespaces/${dispatchNamespace}/scripts/${workerName}`
-                : `/accounts/${api.accountId}/workers/scripts/${workerName}`;
-            method = "PUT";
-        }
-        const uploadResponse = method === "PUT"
-            ? await api.put(endpoint, formData, {
-                headers: {
-                    "Content-Type": "multipart/form-data",
-                },
-            })
-            : await api.post(endpoint, formData, {
-                headers: {
-                    "Content-Type": "multipart/form-data",
-                },
-            });
+        const { body, endpoint, method } = await prepareWorkerUpload(api, props);
+        const uploadResponse = await api.fetch(endpoint, {
+            method,
+            headers: {
+                "Content-Type": "multipart/form-data",
+            },
+            body,
+        });
         // Check if the upload was successful
         if (!uploadResponse.ok) {
             try {
@@ -880,33 +1000,7 @@ export async function putWorker(api, props) {
             }
         }
         const responseData = (await uploadResponse.json());
-        const result = responseData.result;
-        // Handle version response
-        if (props.version) {
-            // Get the account's workers.dev subdomain to construct preview URL
-            let previewUrl;
-            if (result.metadata?.has_preview) {
-                // Need to get the subdomain
-                const subdomainResponse = await api.get(`/accounts/${api.accountId}/workers/subdomain`);
-                if (subdomainResponse.ok) {
-                    const subdomainData = await subdomainResponse.json();
-                    const subdomain = subdomainData.result?.subdomain;
-                    if (subdomain) {
-                        // Preview URL format: <FIRST_8_CHARS_OF_VERSION_ID>-<WORKER_NAME>.<SUBDOMAIN>.workers.dev
-                        const versionPrefix = result.id.substring(0, 8);
-                        previewUrl = `https://${versionPrefix}-${workerName}.${subdomain}.workers.dev`;
-                    }
-                }
-            }
-            return {
-                versionId: result.id,
-                previewUrl,
-                deploymentId: result.deployment_id,
-            };
-        }
-        return {
-            deploymentId: result.deployment_id,
-        };
+        return responseData.result;
     }, (err) => err.status === 404 ||
         err.status === 500 ||
         err.status === 503 ||
@@ -915,79 +1009,57 @@ export async function putWorker(api, props) {
             err.status === 400 &&
             err.message.match(/binding.*failed to generate/)), 10, 100);
 }
-export async function checkWorkerExists(api, workerName) {
-    const response = await api.get(`/accounts/${api.accountId}/workers/scripts/${workerName}`);
-    return response.status === 200;
+async function workerExists(api, scriptName) {
+    const res = await api.get(`/accounts/${api.accountId}/workers/scripts/${scriptName}`);
+    return res.status === 200;
 }
-export async function assertWorkerDoesNotExist(api, workerName) {
-    const response = await api.get(`/accounts/${api.accountId}/workers/scripts/${workerName}`);
+async function assertWorkerDoesNotExist(api, scriptName) {
+    const response = await api.get(`/accounts/${api.accountId}/workers/scripts/${scriptName}`);
     if (response.status === 404) {
         return true;
     }
     if (response.status === 200) {
-        const metadata = await getWorkerScriptMetadata(api, workerName);
+        const metadata = await getScriptMetadata(api, scriptName);
         if (!metadata) {
             throw new Error(`Worker exists but failed to fetch metadata: ${response.status} ${response.statusText}`);
         }
-        throw new Error(`Worker with name '${workerName}' already exists. Please use a unique name.`);
+        throw new Error(`Worker with name '${scriptName}' already exists. Please use a unique name.`);
     }
     throw new Error(`Error checking if worker exists: ${response.status} ${response.statusText} ${await response.text()}`);
 }
-export async function configureURL(ctx, api, props) {
-    const { workerName, url } = props;
-    let workerUrl;
-    if (url) {
-        // Enable the workers.dev subdomain for this worker
-        await api.post(`/accounts/${api.accountId}/workers/scripts/${workerName}/subdomain`, { enabled: true, previews_enabled: true }, {
-            headers: { "Content-Type": "application/json" },
-        });
-        // Get the account's workers.dev subdomain
-        const subdomain = await getAccountSubdomain(api);
-        if (subdomain) {
-            workerUrl = `https://${workerName}.${subdomain}.workers.dev`;
-        }
-    }
-    else if (url === false &&
-        (ctx.output?.url || (ctx.phase === "create" && props.adopt))) {
-        // Explicitly disable URL if it was previously enabled
-        const response = await api.post(`/accounts/${api.accountId}/workers/scripts/${workerName}/subdomain`, JSON.stringify({ enabled: false }), {
-            headers: { "Content-Type": "application/json" },
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to disable worker URL: ${response.status} ${response.statusText}`);
-        }
-    }
-    return workerUrl;
-}
-export async function getWorkerSubdomainConfig(api, workerName) {
-    // Query Cloudflare API to verify subdomain is disabled
-    const subdomainResponse = await api.get(`/accounts/${api.accountId}/workers/scripts/${workerName}/subdomain`);
-    if (subdomainResponse.status === 404) {
-        return undefined;
-    }
-    const subdomainData = await subdomainResponse.json();
-    return subdomainData.result;
-}
-export async function getWorkerScriptMetadata(api, workerName) {
-    const response = await api.get(`/accounts/${api.accountId}/workers/services/${workerName}`);
-    if (response.status === 404) {
-        return undefined;
+async function getScriptMetadata(api, scriptName) {
+    const res = await api.get(`/accounts/${api.accountId}/workers/services/${scriptName}`);
+    if (res.status === 404) {
+        return;
     }
-    if (!response.ok) {
-        throw new Error(`Error getting worker script metadata: ${response.status} ${response.statusText}`);
+    if (!res.ok) {
+        throw new Error(`Error getting worker script metadata: ${res.status} ${res.statusText}`);
     }
-    return (await response.json()).result;
+    const json = (await res.json());
+    return json.result;
 }
-/**
- * Lists and deletes all queue consumers for a specific worker
- * @param ctx Worker context containing eventSources
- * @param api CloudflareApi instance
- * @param workerName Name of the worker script
- */
-async function deleteQueueConsumers(api, workerName) {
-    const consumers = await listQueueConsumersForWorker(api, workerName);
+async function deleteQueueConsumers(api, scriptName) {
+    const consumers = await listQueueConsumersForWorker(api, scriptName);
     await Promise.all(consumers.map(async (consumer) => {
         await deleteQueueConsumer(api, consumer.queueId, consumer.consumerId);
     }));
 }
+export async function deleteWorker(api, props) {
+    await withExponentialBackoff(async () => {
+        const deleteResponse = await api.delete(props.dispatchNamespace
+            ? `/accounts/${api.accountId}/workers/dispatch/namespaces/${props.dispatchNamespace}/scripts/${props.scriptName}?force=true`
+            : `/accounts/${api.accountId}/workers/scripts/${props.scriptName}?force=true`);
+        if (!deleteResponse.ok && deleteResponse.status !== 404) {
+            await handleApiError(deleteResponse, "delete", "worker", props.scriptName);
+        }
+    }, (err) => (err.status === 400 &&
+        err.message.includes("is still referenced by service bindings in Workers")) ||
+        err.status === 500 ||
+        err.status === 503, 10, 100);
+}
+async function getVersionMetadata(api, scriptName, deploymentId) {
+    const response = await api.get(`/accounts/${api.accountId}/workers/scripts/${scriptName}/versions/${deploymentId}`);
+    const result = (await response.json());
+    return result.result;
+}
 //# sourceMappingURL=worker.js.map