alchemy 0.57.2 → 0.59.0

package/lib/cloudflare/worker.js

@@ -1,4 +1,3 @@
-import { isDeepStrictEqual } from "node:util";
 import path from "pathe";
 import { Resource, ResourceKind } from "../resource.js";
 import { DeferredPromise } from "../util/deferred-promise.js";
@@ -12,11 +11,12 @@ import { ContainerApplication } from "./container.js";
 import { CustomDomain } from "./custom-domain.js";
 import { DurableObjectNamespace, isDurableObjectNamespace, } from "./durable-object-namespace.js";
 import { isQueueEventSource } from "./event-source.js";
+import { deleteMiniflareWorkerData } from "./miniflare/delete.js";
 import { QueueConsumer, deleteQueueConsumer, listQueueConsumersForWorker, } from "./queue-consumer.js";
 import { isQueue } from "./queue.js";
 import { Route } from "./route.js";
 import { uploadAssets } from "./worker-assets.js";
-import { WorkerBundle, normalizeWorkerBundle } from "./worker-bundle.js";
+import { WorkerBundle, normalizeWorkerBundle, } from "./worker-bundle.js";
 import { bumpMigrationTagVersion, prepareWorkerMetadata, } from "./worker-metadata.js";
 import { WorkerSubdomain, disableWorkerSubdomain } from "./worker-subdomain.js";
 import { createTail } from "./worker-tail.js";
@@ -33,111 +33,179 @@ export function Worker(id, props) {
 const _Worker = Resource("cloudflare::Worker", {
     alwaysUpdate: true,
 }, async function (id, props) {
-    if (props.projectRoot) {
-        logger.warn("projectRoot is deprecated, use cwd instead");
-        props.cwd = props.projectRoot;
+    const options = (() => {
+        if (props.projectRoot) {
+            logger.warn("projectRoot is deprecated, use cwd instead");
+            props.cwd = props.projectRoot;
+        }
+        const name = props.name ?? id;
+        const cwd = path.resolve(props.cwd ?? process.cwd());
+        const compatibilityDate = props.compatibilityDate ?? DEFAULT_COMPATIBILITY_DATE;
+        const compatibilityFlags = unionCompatibilityFlags(props.compatibility, props.compatibilityFlags);
+        const dispatchNamespace = typeof props.namespace === "string"
+            ? props.namespace
+            : props.namespace?.namespaceName;
+        const bundle = normalizeWorkerBundle({
+            id,
+            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(cwd, ".alchemy", "out", name),
+            sourceMap: "sourceMap" in props ? props.sourceMap : undefined,
+        });
+        let assets;
+        const containers = [];
+        const workflows = [];
+        const durableObjects = [];
+        for (const binding of Object.values(props.bindings ?? {})) {
+            if (typeof binding !== "object")
+                continue;
+            if (binding.type === "assets") {
+                assets = binding;
+            }
+            else if (binding.type === "container") {
+                containers.push(binding);
+            }
+            else if (binding.type === "workflow" &&
+                (!binding.scriptName || binding.scriptName === name)) {
+                workflows.push(binding);
+            }
+            else if (binding.type === "durable_object_namespace" &&
+                (!binding.scriptName || binding.scriptName === name)) {
+                durableObjects.push(binding);
+            }
+        }
+        return {
+            name,
+            cwd,
+            compatibilityDate,
+            compatibilityFlags,
+            dispatchNamespace,
+            bundle,
+            assets,
+            containers,
+            workflows,
+            durableObjects,
+        };
+    })();
+    if (this.phase === "delete") {
+        if (options.bundle.isOk()) {
+            await options.bundle.value.delete?.();
+        }
+        await deleteMiniflareWorkerData(options.name, {
+            durableObjects: options.durableObjects,
+            workflows: options.workflows,
+        });
+        if (!props.version && this.output?.dev?.hasRemote !== false) {
+            const api = await createCloudflareApi(props);
+            await deleteQueueConsumers(api, options.name);
+            await deleteWorker(api, {
+                scriptName: options.name,
+                dispatchNamespace: options.dispatchNamespace,
+            });
+        }
+        return this.destroy();
     }
-    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 = unionCompatibilityFlags(props.compatibility, props.compatibilityFlags);
-    const dispatchNamespace = typeof props.namespace === "string"
-        ? props.namespace
-        : props.namespace?.namespaceName;
-    const bundleSourceResult = normalizeWorkerBundle({
-        id,
-        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(cwd, ".alchemy", "out", workerName),
-        sourceMap: "sourceMap" in props ? props.sourceMap : undefined,
-    });
-    // run locally if
-    const local = this.scope.local && !props.dev?.remote;
-    const watch = this.scope.watch;
-    if (local) {
+    if (options.bundle.isErr()) {
+        throw new Error(options.bundle.error);
+    }
+    const bundle = options.bundle.value;
+    const api = await createCloudflareApi(props);
+    if (this.scope.local && !props.dev?.remote) {
         let url;
-        if (bundleSourceResult.isErr()) {
-            throw bundleSourceResult.error;
-        }
-        if (props.dev && "url" in props.dev) {
+        if (props.dev?.url) {
             url = props.dev.url;
         }
         else {
             const { MiniflareController } = await import("./miniflare/miniflare-controller.js");
             const controller = MiniflareController.singleton;
             url = await controller.add({
+                api,
                 id,
-                name: workerName,
-                compatibilityDate,
-                compatibilityFlags,
+                name: options.name,
+                compatibilityDate: options.compatibilityDate,
+                compatibilityFlags: options.compatibilityFlags,
                 bindings: props.bindings,
                 eventSources: props.eventSources,
                 assets: props.assets,
-                bundle: bundleSourceResult.value,
-                port: props.dev?.port ?? undefined,
+                bundle,
+                port: props.dev?.port,
             });
             this.onCleanup(() => controller.dispose());
         }
+        await provisionResources(props, {
+            name: options.name,
+            local: true,
+            dispatchNamespace: options.dispatchNamespace,
+            containers: options.containers,
+        });
         return this({
+            ...props,
             type: "service",
             id,
-            entrypoint: props.entrypoint,
-            name: workerName,
-            cwd: relativeCwd,
-            compatibilityDate,
-            compatibilityFlags,
-            format: props.format || "esm", // Include format in the output
-            bindings: normalizeExportBindings(workerName, props.bindings),
-            env: props.env,
-            observability: props.observability,
+            name: options.name,
+            cwd: path.relative(process.cwd(), options.cwd),
+            compatibilityDate: options.compatibilityDate,
+            compatibilityFlags: options.compatibilityFlags,
+            format: props.format || "esm",
+            bindings: normalizeExportBindings(options.name, props.bindings),
             createdAt: this.output?.createdAt ?? Date.now(),
             updatedAt: Date.now(),
-            eventSources: props.eventSources,
             url,
-            dev: props.dev,
-            // Include assets configuration in the output
-            assets: props.assets,
-            // Include cron triggers in the output
-            crons: props.crons,
-            // Include placement configuration in the output
-            placement: props.placement,
-            // Include limits configuration in the output
-            limits: props.limits,
-            // phantom property
+            routes: [],
+            domains: [],
+            dev: {
+                hasRemote: this.output?.dev?.hasRemote ?? false,
+            },
             Env: undefined,
         });
     }
-    const api = await createCloudflareApi(props);
-    if (this.phase === "delete") {
-        if (bundleSourceResult.isOk()) {
-            await bundleSourceResult.value.delete?.();
+    if (this.phase === "create" || this.output.dev?.hasRemote === false) {
+        if (props.version) {
+            // When version is specified, we adopt existing workers or create them if they don't exist
+            if (!(await workerExists(api, options))) {
+                // Create the base worker first if it doesn't exist
+                await putWorker(api, {
+                    ...props,
+                    version: undefined,
+                    workerName: options.name,
+                    scriptBundle: await bundle.create(),
+                    dispatchNamespace: options.dispatchNamespace,
+                    compatibilityDate: options.compatibilityDate,
+                    compatibilityFlags: options.compatibilityFlags,
+                    assetUploadResult: options.assets
+                        ? await uploadAssets(api, {
+                            workerName: options.name,
+                            assets: options.assets,
+                            assetConfig: props.assets,
+                            namespace: options.dispatchNamespace,
+                        })
+                        : undefined,
+                });
+            }
+            // We always "adopt" when publishing versions
         }
-        if (!props.version) {
-            await deleteQueueConsumers(api, workerName);
-            await deleteWorker(api, {
-                scriptName: workerName,
-                dispatchNamespace,
-            });
+        else if (!props.adopt) {
+            await assertWorkerDoesNotExist(api, options.name);
+        }
+        else if (props.adopt &&
+            !options.dispatchNamespace &&
+            props.url === false) {
+            // explicitly disable the workers.dev subdomain
+            await disableWorkerSubdomain(api, options.name);
         }
-        return this.destroy();
-    }
-    else if (bundleSourceResult.isErr()) {
-        throw new Error(bundleSourceResult.error);
     }
-    const bundleSource = bundleSourceResult.value;
-    if (this.phase === "update") {
+    else if (this.phase === "update") {
         const oldName = this.output.name ?? this.output.id;
-        const newName = workerName;
+        const newName = options.name;
         if (oldName && oldName !== newName) {
-            if (dispatchNamespace) {
+            if (options.dispatchNamespace) {
                 this.replace(true);
             }
             else {
@@ -148,212 +216,93 @@ const _Worker = Resource("cloudflare::Worker", {
             }
         }
     }
-    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);
-            }
-        }
-    }
-    const putWorkerWithAssets = async (props, scriptBundle) => {
-        const assetUploadResult = assetsBinding
-            ? await uploadAssets(api, {
-                workerName,
-                assets: assetsBinding,
-                assetConfig: props.assets,
-                namespace: dispatchNamespace,
-            })
-            : undefined;
-        // Deploy worker (either as version or live worker)
-        return await putWorker(api, {
-            ...props,
-            workerName,
-            scriptBundle,
-            dispatchNamespace,
+    const assets = options.assets
+        ? await uploadAssets(api, {
+            workerName: options.name,
+            assets: options.assets,
+            assetConfig: props.assets,
+            namespace: options.dispatchNamespace,
+        })
+        : undefined;
+    let result;
+    if (this.scope.watch) {
+        const controller = new AbortController();
+        result = await watchWorker(api, props, {
+            id,
+            name: options.name,
+            dispatchNamespace: options.dispatchNamespace,
+            bundle,
+            compatibilityDate: options.compatibilityDate,
+            compatibilityFlags: options.compatibilityFlags,
             version: props.version,
-            compatibilityDate,
-            compatibilityFlags,
-            assetUploadResult,
+            assets,
+            controller,
         });
-    };
-    if (this.phase === "create") {
-        if (props.version) {
-            // When version is specified, we adopt existing workers or create them if they don't exist
-            if (!(await workerExists(api, workerName))) {
-                // Create the base worker first if it doesn't exist
-                const baseWorkerProps = { ...props, version: undefined };
-                await putWorkerWithAssets(baseWorkerProps, await bundleSource.create());
-            }
-            // We always "adopt" when publishing versions
-        }
-        else if (!props.adopt) {
-            await assertWorkerDoesNotExist(api, workerName);
-        }
-    }
-    let putWorkerResult;
-    if (watch) {
-        const controller = new AbortController();
-        const promise = new DeferredPromise();
-        const runWatch = async () => {
-            for await (const bundle of bundleSource.watch(controller.signal)) {
-                if (promise.status === "pending") {
-                    await putWorkerWithAssets(props, bundle)
-                        .then((result) => promise.resolve(result))
-                        .catch((error) => {
-                        controller.abort();
-                        promise.reject(error);
-                    });
-                    continue;
-                }
-                logger.task("", {
-                    message: "reload",
-                    status: "success",
-                    resource: id,
-                    prefix: "build",
-                    prefixColor: "cyanBright",
-                });
-                await putWorker(api, {
-                    ...props,
-                    workerName,
-                    scriptBundle: bundle,
-                    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",
-                });
-            }
-        };
-        void runWatch(); // this is not awaited because it's an ongoing process
         this.onCleanup(() => controller.abort());
-        putWorkerResult = await promise.value;
-        const tail = await createTail(api, id, workerName).catch((error) => {
-            logger.error(`Failed to create tail for ${workerName}`, error);
+        const tail = await createTail(api, id, options.name).catch((error) => {
+            logger.error(`Failed to create tail for ${options.name}`, error);
         });
         this.onCleanup(() => tail?.close());
     }
     else {
-        const scriptBundle = await bundleSource.create();
-        putWorkerResult = await putWorkerWithAssets(props, scriptBundle);
-    }
-    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,
-        })));
+        result = await putWorker(api, {
+            ...props,
+            workerName: options.name,
+            scriptBundle: await bundle.create(),
+            dispatchNamespace: options.dispatchNamespace,
+            compatibilityDate: options.compatibilityDate,
+            compatibilityFlags: options.compatibilityFlags,
+            assetUploadResult: assets,
+        });
     }
-    if (!isDeepStrictEqual(props.crons, this.output?.crons)) {
-        tasks.push(api.put(`/accounts/${api.accountId}/workers/scripts/${workerName}/schedules`, props.crons?.map((cron) => ({ cron })) ?? []));
+    if (props.crons) {
+        await api.put(`/accounts/${api.accountId}/workers/scripts/${options.name}/schedules`, props.crons?.map((cron) => ({ cron })) ?? []);
     }
-    tasks.push(provisionEventSources(api, {
-        scriptName: workerName,
-        eventSources: props.eventSources,
-        adopt: props.adopt,
-    }));
-    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
+    await Promise.all(options.workflows.map((workflow) => upsertWorkflow(api, {
+        workflowName: workflow.workflowName,
+        className: workflow.className,
+        scriptName: workflow.scriptName ?? options.name,
+    })));
+    const { domains, routes, subdomain } = await provisionResources(props, {
+        name: options.name,
+        local: false,
+        dispatchNamespace: options.dispatchNamespace,
+        containers: options.containers,
+        result,
+        api,
+    });
+    const now = new Date();
     return this({
         ...props,
         type: "service",
         id,
         entrypoint: props.entrypoint,
-        name: workerName,
-        cwd: relativeCwd,
-        compatibilityDate,
-        compatibilityFlags,
-        format: props.format || "esm", // Include format in the output
-        bindings: normalizeExportBindings(workerName, props.bindings),
+        name: options.name,
+        cwd: path.relative(process.cwd(), options.cwd),
+        compatibilityDate: options.compatibilityDate,
+        compatibilityFlags: options.compatibilityFlags,
+        format: props.format || "esm",
+        bindings: normalizeExportBindings(options.name, props.bindings),
         env: props.env,
         observability: props.observability,
         createdAt: this.output?.createdAt ?? now,
         updatedAt: now,
         eventSources: props.eventSources,
         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,
-        // Include the created domains in the output
         domains,
-        // Include the dispatch namespace in the output
         namespace: props.namespace,
-        // Include version information in the output
         version: props.version,
-        // Include placement configuration in the output
         placement: props.placement,
-        // Include limits configuration in the output
         limits: props.limits,
-        // phantom property
         Env: undefined,
+        dev: {
+            hasRemote: true,
+        },
     });
 });
-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,
@@ -372,133 +321,212 @@ const normalizeExportBindings = (scriptName, bindings = {}) => {
                 : binding,
     ]));
 };
-const normalizeApiOptions = (api) => ({
-    accountId: api.accountId,
-    baseUrl: api.baseUrl,
-    ...api.authOptions,
-});
-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.name,
-            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,
-                adopt: props.adopt,
-                ...normalizeApiOptions(api),
-            });
-        }
-        if (isQueueEventSource(eventSource)) {
-            return QueueConsumer(`${eventSource.queue.id}-consumer`, {
-                queue: eventSource.queue,
-                scriptName: props.scriptName,
-                settings: eventSource.settings,
-                adopt: props.adopt,
-                ...normalizeApiOptions(api),
-            });
-        }
-        throw new Error(`Unsupported event source: ${eventSource}`);
-    }));
-}
-async function provisionDomains(api, props) {
-    if (!props.domains?.length) {
-        return;
+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 domains = props.domains.map((domain) => {
-        if (typeof domain === "string") {
+};
+async function provisionResources(props, options) {
+    let metadataPromise;
+    const input = {
+        containers: options.containers,
+        domains: props.domains?.map((domain) => {
+            if (typeof domain === "string") {
+                return {
+                    name: domain,
+                    zoneId: undefined,
+                    adopt: props.adopt,
+                };
+            }
             return {
-                name: domain,
-                zoneId: undefined,
-                adopt: props.adopt,
+                name: domain.domainName,
+                zoneId: domain.zoneId,
+                adopt: domain.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") {
+        }),
+        eventSources: props.eventSources?.map((eventSource) => {
+            if (isQueue(eventSource)) {
+                return {
+                    queue: eventSource,
+                    settings: eventSource.dlq
+                        ? { deadLetterQueue: eventSource.dlq }
+                        : undefined,
+                };
+            }
+            if (isQueueEventSource(eventSource)) {
+                return {
+                    queue: eventSource.queue,
+                    settings: eventSource.settings,
+                };
+            }
+            throw new Error(`Unsupported event source: ${eventSource}`);
+        }),
+        routes: props.routes?.map((route) => {
+            if (typeof route === "string") {
+                return {
+                    pattern: route,
+                    adopt: props.adopt,
+                };
+            }
             return {
-                pattern: route,
-                adopt: props.adopt,
+                pattern: route.pattern,
+                zoneId: route.zoneId,
+                adopt: 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),
-        });
+        }),
+        api: {
+            accountId: props.accountId,
+            apiKey: props.apiKey,
+            apiToken: props.apiToken,
+            email: props.email,
+            baseUrl: props.baseUrl,
+        },
+    };
+    if (input.routes) {
+        assertUnique(input.routes, "pattern", "Route");
     }
-    if (props.forceDelete) {
-        await disableWorkerSubdomain(api, props.scriptName);
+    if (input.domains) {
+        assertUnique(input.domains, "name", "Custom Domain");
+    }
+    const [containers, domains, eventSources, routes, subdomain] = await Promise.all([
+        input.containers
+            ? Promise.all(input.containers.map(async (container) => {
+                return await ContainerApplication(container.id, {
+                    image: container.image,
+                    name: container.name,
+                    instanceType: container.instanceType,
+                    observability: container.observability,
+                    durableObjects: {
+                        namespaceId: await getContainerNamespaceId(container),
+                    },
+                    schedulingPolicy: container.schedulingPolicy,
+                    adopt: container.adopt,
+                    dev: options.local,
+                    ...input.api,
+                });
+            }))
+            : undefined,
+        input.domains
+            ? Promise.all(input.domains.map(async (domain) => {
+                return await CustomDomain(domain.name, {
+                    name: domain.name,
+                    zoneId: domain.zoneId,
+                    adopt: domain.adopt,
+                    workerName: options.name,
+                    dev: options.local,
+                    ...input.api,
+                });
+            }))
+            : undefined,
+        input.eventSources
+            ? Promise.all(input.eventSources.map(async (eventSource) => {
+                return await QueueConsumer(`${eventSource.queue.id}-consumer`, {
+                    queue: eventSource.queue,
+                    scriptName: options.name,
+                    settings: eventSource.settings,
+                    adopt: props.adopt,
+                    dev: options.local,
+                    ...input.api,
+                });
+            }))
+            : undefined,
+        input.routes
+            ? Promise.all(input.routes.map(async (route) => {
+                return await Route(route.pattern, {
+                    pattern: route.pattern,
+                    script: options.name,
+                    zoneId: route.zoneId,
+                    adopt: route.adopt,
+                    dev: options.local,
+                    ...input.api,
+                });
+            }))
+            : undefined,
+        (props.url ?? !options.dispatchNamespace)
+            ? WorkerSubdomain("url", {
+                scriptName: options.name,
+                previewVersionId: props.version ? options.result?.id : undefined,
+                retain: !!props.version,
+                dev: options.local,
+                ...input.api,
+            })
+            : undefined,
+    ]);
+    return { containers, domains, routes, eventSources, subdomain };
+    async function getContainerNamespaceId(container) {
+        if (options.local) {
+            return container.id;
+        }
+        metadataPromise ??= getVersionMetadata(options.api, options.name, options.result.deployment_id);
+        const metadata = await metadataPromise;
+        const binding = metadata.resources.bindings.find((binding) => binding.type === "durable_object_namespace" &&
+            binding.class_name === container.className);
+        if (!binding?.namespace_id) {
+            throw new Error(`Container ${container.name} not found in version ${options.result.deployment_id}`);
+        }
+        return binding.namespace_id;
     }
 }
+const watchWorker = async (api, props, input) => {
+    const promise = new DeferredPromise();
+    const run = async () => {
+        for await (const bundle of input.bundle.watch(input.controller.signal)) {
+            if (promise.status === "pending") {
+                try {
+                    const result = await putWorker(api, {
+                        ...props,
+                        workerName: input.name,
+                        scriptBundle: bundle,
+                        dispatchNamespace: input.dispatchNamespace,
+                        compatibilityDate: input.compatibilityDate,
+                        compatibilityFlags: input.compatibilityFlags,
+                        assetUploadResult: input.assets,
+                    });
+                    promise.resolve(result);
+                }
+                catch (error) {
+                    input.controller.abort();
+                    promise.reject(error);
+                }
+                continue;
+            }
+            logger.task("", {
+                message: "reload",
+                status: "success",
+                resource: input.id,
+                prefix: "build",
+                prefixColor: "cyanBright",
+            });
+            await putWorker(api, {
+                ...props,
+                workerName: input.name,
+                scriptBundle: bundle,
+                dispatchNamespace: input.dispatchNamespace,
+                version: input.version,
+                compatibilityDate: input.compatibilityDate,
+                compatibilityFlags: input.compatibilityFlags,
+                assetUploadResult: input.assets
+                    ? {
+                        keepAssets: true,
+                        assetConfig: props.assets,
+                    }
+                    : undefined,
+                unstable_cacheWorkerSettings: true,
+            });
+            logger.task("", {
+                message: "updated",
+                status: "success",
+                resource: input.id,
+                prefix: "build",
+                prefixColor: "greenBright",
+            });
+        }
+    };
+    void run();
+    return await promise.value;
+};
 async function prepareWorkerUpload(api, props) {
     const scriptMetadata = await prepareWorkerMetadata(api, props);
     if (props.format === "cjs") {
@@ -610,10 +638,12 @@ export async function putWorker(api, props) {
             err.status === 400 &&
             err.message.match(/binding.*failed to generate/)), 10, 100);
 }
-async function workerExists(api, scriptName) {
-    const res = await api.get(`/accounts/${api.accountId}/workers/scripts/${scriptName}`);
+const workerExists = async (api, options) => {
+    const res = await api.get(options.dispatchNamespace
+        ? `/accounts/${api.accountId}/workers/dispatch/namespaces/${options.dispatchNamespace}/scripts/${options.name}`
+        : `/accounts/${api.accountId}/workers/scripts/${options.name}`);
     return res.status === 200;
-}
+};
 async function assertWorkerDoesNotExist(api, scriptName) {
     const response = await api.get(`/accounts/${api.accountId}/workers/scripts/${scriptName}`);
     if (response.status === 404) {