alchemy 2.0.0-beta.59 → 2.0.0-beta.60

package/lib/Cloudflare/Workers/WorkerProvider.js

@@ -1,4 +1,5 @@
 import * as workers from "@distilled.cloud/cloudflare/workers";
+import * as wfp from "@distilled.cloud/cloudflare/workers-for-platforms";
 import * as zones from "@distilled.cloud/cloudflare/zones";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
@@ -11,7 +12,6 @@ import * as crypto from "node:crypto";
 import { Unowned } from "../../AdoptPolicy.js";
 import * as Artifacts from "../../Artifacts.js";
 import { hashDirectory } from "../../Command/Memo.js";
-import * as Bundle from "../../Bundle/Bundle.js";
 import { isResolved } from "../../Diff.js";
 import * as ProviderLayer from "../../Local/ProviderLayer.js";
 import * as Provider from "../../Provider.js";
@@ -30,6 +30,95 @@ import { isWorkerLoader } from "./WorkerLoader.js";
 import { createWorkerName } from "./WorkerName.js";
 class MissingDurableObjects extends Data.TaggedError("MissingDurableObjects") {
 }
+/**
+ * Resolve the Workers for Platforms dispatch-namespace *name* from a resolved
+ * `namespace` prop or persisted attribute. The engine resolves a passed
+ * {@link DispatchNamespace} resource to its Attributes object (see
+ * `Input.Resolve` / Plan.ts), so the value is either the namespace name
+ * string, that attributes object, or `undefined` for a regular Worker.
+ *
+ * @internal
+ */
+export const resolveNamespaceName = (namespace) => {
+    if (namespace == null)
+        return undefined;
+    if (typeof namespace === "string")
+        return namespace;
+    return namespace.name;
+};
+// Workers for Platforms "user workers" live inside a dispatch namespace and
+// use a parallel family of script endpoints (`/workers/dispatch/namespaces/
+// :namespace/scripts/...`). The request/response shapes are identical to the
+// account-level Workers API for everything the provider touches, so these
+// helpers route by `dispatchNamespace` and the call sites stay agnostic.
+/**
+ * Read a script's combined settings, routing to the dispatch-namespace
+ * endpoint when `dispatchNamespace` is set. The two response shapes are
+ * structurally identical for the fields the provider consumes (`bindings`,
+ * `tags`, `logpush`), so the WFP response is surfaced as the workers shape.
+ *
+ * @internal
+ */
+const getScriptSettings = (accountId, scriptName, dispatchNamespace) => 
+// `Effect.gen` (rather than a ternary) so the two branches unify into a
+// single `Effect<Settings, WorkersErr | WfpErr>` instead of a *union* of
+// Effects, which `.pipe`/`catchTag` at the call sites can't consume.
+Effect.gen(function* () {
+    if (dispatchNamespace) {
+        const settings = yield* wfp.getDispatchNamespaceScriptSetting({
+            accountId,
+            dispatchNamespace,
+            scriptName,
+        });
+        // The dispatch-namespace settings response is structurally identical to
+        // the account-level one for the fields the provider reads.
+        return settings;
+    }
+    return yield* workers.getScriptScriptAndVersionSetting({
+        accountId,
+        scriptName,
+    });
+});
+/**
+ * Upsert a Worker script, routing to the dispatch-namespace endpoint when
+ * `dispatchNamespace` is set. The metadata/files contract is identical.
+ *
+ * @internal
+ */
+const putWorkerScript = (params) => Effect.gen(function* () {
+    if (params.dispatchNamespace) {
+        return yield* wfp.putDispatchNamespaceScript({
+            accountId: params.accountId,
+            dispatchNamespace: params.dispatchNamespace,
+            scriptName: params.scriptName,
+            metadata: params.metadata,
+            files: params.files,
+        });
+    }
+    return yield* workers.putScript({
+        accountId: params.accountId,
+        scriptName: params.scriptName,
+        metadata: params.metadata,
+        files: params.files,
+    });
+});
+/**
+ * Delete a Worker script, routing to the dispatch-namespace endpoint when
+ * `dispatchNamespace` is set.
+ *
+ * @internal
+ */
+const deleteWorkerScript = (accountId, scriptName, dispatchNamespace) => Effect.gen(function* () {
+    if (dispatchNamespace) {
+        return yield* wfp.deleteDispatchNamespaceScript({
+            accountId,
+            dispatchNamespace,
+            scriptName,
+            force: true,
+        });
+    }
+    return yield* workers.deleteScript({ accountId, scriptName, force: true });
+});
 /**
  * Normalize a Worker's persisted `domains` state to `https://<hostname>`
  * strings. Alchemy <= beta.44 stored each custom domain as a
@@ -276,14 +365,9 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
             binding.scriptName === workerName)
         ? [binding.className]
         : []) ?? []));
-    const getWorkerSettingsWithDurableObjects = Effect.fn(function* (scriptName, expectedClassNames) {
+    const getWorkerSettingsWithDurableObjects = Effect.fn(function* (scriptName, expectedClassNames, dispatchNamespace) {
         const { accountId } = yield* yield* CloudflareEnvironment;
-        return yield* workers
-            .getScriptScriptAndVersionSetting({
-            accountId,
-            scriptName,
-        })
-            .pipe(Effect.map((settings) => {
+        return yield* getScriptSettings(accountId, scriptName, dispatchNamespace).pipe(Effect.map((settings) => {
             const namespaces = getDurableObjects(settings.bindings);
             const missing = expectedClassNames.filter((className) => !namespaces[className]);
             if (missing.length > 0) {
@@ -306,7 +390,9 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
             // propagates. All three are eventual-consistency blips.
             while: (error) => error._tag === "MissingDurableObjects" ||
                 error._tag === "WorkerHasNoVersions" ||
-                error._tag === "WorkerNotFound",
+                error._tag === "WorkerNotFound" ||
+                error._tag === "DispatchNamespaceScriptNotFound" ||
+                error._tag === "DispatchNamespaceNotFound",
             schedule: Schedule.exponential(100).pipe(Schedule.both(Schedule.recurs(20))),
         }));
     });
@@ -348,7 +434,7 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
         // (~0.5s), which is only needed for vite-based workers at build time —
         // not for every Worker definition at module-load time.
         const Vite = yield* Effect.promise(() => import("./Vite.js"));
-        const { assetsDirectory, serverBundle } = yield* Vite.viteBuild(props.vite?.rootDir, Object.fromEntries((yield* Effect.all(Object.entries(props.env ?? {}).map(Effect.fn(function* ([key, value]) {
+        const { clientDirectory, serverBundle } = yield* Vite.viteBuild(props.vite?.rootDir, Object.fromEntries((yield* Effect.all(Object.entries(props.env ?? {}).map(Effect.fn(function* ([key, value]) {
             return [
                 key,
                 typeof value === "string"
@@ -369,23 +455,22 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
         })))).filter(([_, value]) => value !== undefined)), {
             compatibilityDate: compatibility.date,
             compatibilityFlags: compatibility.flags,
+            viteEnvironments: props.vite?.viteEnvironments,
         });
-        if (!assetsDirectory && !serverBundle) {
-            return yield* Effect.die(new Error("Vite build produced neither server nor client output"));
-        }
         const [assets, bundle] = yield* Effect.all([
-            assetsDirectory
+            clientDirectory
                 ? readAssets({
                     ...(props.assets && typeof props.assets !== "string"
                         ? props.assets
                         : undefined),
-                    directory: assetsDirectory,
+                    directory: path.resolve(props.vite?.rootDir ?? process.cwd(), clientDirectory),
                 })
-                : Effect.succeed(undefined),
-            serverBundle
-                ? Bundle.bundleOutputFromRolldownOutputBundle(serverBundle)
-                : Effect.succeed(undefined),
+                : Effect.undefined,
+            serverBundle,
         ], { concurrency: "unbounded" });
+        if (!assets && !bundle) {
+            return yield* Effect.die(new Error("Vite build produced neither assets nor server output"));
+        }
         return { assets, bundle };
     });
     const prepareAssetsAndBundle = (id, props, opts = {}) => Effect.gen(function* () {
@@ -451,6 +536,11 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
     const putWorker = Effect.fn(function* (id, news, bindings, olds, output, session, existingSettings) {
         const { accountId } = yield* yield* CloudflareEnvironment;
         const name = yield* createWorkerName(id, news.name);
+        // When set, this Worker is a Workers for Platforms "user worker"
+        // uploaded into a dispatch namespace rather than a routable
+        // account-level script. The put/settings calls switch endpoints and
+        // the subdomain / custom-domain / cron reconciliation is skipped.
+        const dispatchNamespace = resolveNamespaceName(news?.namespace);
         yield* Effect.logInfo(`Cloudflare Worker ${olds ? "update" : "create"}: preparing bundle for ${name}`);
         // If the caller handed us a precomputed asset hash that matches
         // what we previously stored, we can skip walking the directory
@@ -623,7 +713,24 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
         const newSqliteClasses = [];
         const renamedClasses = [];
         for (const binding of currentDoBindings) {
-            const previousClassName = oldDoClassNameByLogicalId[binding.logicalId];
+            let previousClassName = oldDoClassNameByLogicalId[binding.logicalId];
+            if (!previousClassName) {
+                // No `alchemy:do:` tag maps this logical id to a class — the
+                // worker was created outside Alchemy (raw API / Wrangler) or
+                // before these tags existed. Fall back to matching the observed
+                // cloud binding by binding name so adoption reuses the existing
+                // class instead of asking Cloudflare to create one that already
+                // exists (which fails the migration). This is the "first deploy
+                // must match the existing class name" path; once we write the
+                // `alchemy:do:` tag, subsequent renames are driven by logical id.
+                const observed = oldBindings.find((old) => old.type === "durable_object_namespace" &&
+                    "className" in old &&
+                    old.className &&
+                    old.name === binding.bindingName);
+                if (observed && "className" in observed && observed.className) {
+                    previousClassName = observed.className;
+                }
+            }
             if (!previousClassName) {
                 // Default all new Durable Object classes to SQLite. Cloudflare
                 // recommends SQLite for new namespaces, and container-backed
@@ -695,14 +802,13 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
             tailConsumers: undefined,
             usageModel: undefined,
         };
-        const worker = yield* workers
-            .putScript({
+        const worker = yield* putWorkerScript({
             accountId,
             scriptName: name,
+            dispatchNamespace,
             metadata,
             files: bundle.files,
-        })
-            .pipe(Effect.catch((err) => {
+        }).pipe(Effect.catch((err) => {
             // When adopting a Worker managed by Wrangler (or after a previous
             // deploy with mismatched migrations), the old_tag precondition
             // fails. The only way to discover the actual tag is through the
@@ -713,9 +819,10 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
                 : err);
             const expectedTag = msg.match(/when expected tag is ['"]?([^'"]+)['"]?/)?.[1];
             if (expectedTag) {
-                return workers.putScript({
+                return putWorkerScript({
                     accountId,
                     scriptName: name,
+                    dispatchNamespace,
                     metadata: {
                         ...metadata,
                         migrations: {
@@ -727,9 +834,28 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
                     files: bundle.files,
                 });
             }
+            // @effect-diagnostics-next-line anyUnknownInErrorContext:off
             return Effect.fail(err);
         }));
-        const { settings, durableObjectNamespaces } = yield* getWorkerSettingsWithDurableObjects(name, expectedDurableObjectClassNames);
+        const { settings, durableObjectNamespaces } = yield* getWorkerSettingsWithDurableObjects(name, expectedDurableObjectClassNames, dispatchNamespace);
+        // Workers for Platforms user workers are invoked via dynamic dispatch,
+        // never routed directly — they have no workers.dev subdomain, custom
+        // domains, or cron triggers. Skip all of that reconciliation.
+        if (dispatchNamespace) {
+            return {
+                workerId: worker.id ?? name,
+                workerName: name,
+                namespace: dispatchNamespace,
+                logpush: worker.logpush ?? undefined,
+                url: undefined,
+                tags: settings.tags ?? metadata.tags,
+                durableObjectNamespaces,
+                accountId,
+                domains: [],
+                crons: [],
+                hash,
+            };
+        }
         // Reconcile workers.dev subdomain against observed cloud state.
         // We can't diff `news.url` against `olds.url` here because both
         // default to `undefined` (meaning "enable") — that comparison
@@ -782,6 +908,7 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
         return {
             workerId: worker.id ?? name,
             workerName: name,
+            namespace: undefined,
             logpush: worker.logpush ?? undefined,
             url: domains[0],
             tags: settings.tags ?? metadata.tags,
@@ -879,6 +1006,7 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
                         accountId,
                         workerId: script.id,
                         workerName: script.id,
+                        namespace: undefined,
                         logpush: script.logpush ?? undefined,
                         url: undefined,
                         tags: script.tags ?? undefined,
@@ -896,6 +1024,14 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
             if ((output?.accountId ?? accountId) !== accountId) {
                 return { action: "replace" };
             }
+            // An account-level script and a dispatch-namespace ("user worker")
+            // script are distinct cloud resources; moving a Worker into, out of,
+            // or between namespaces requires a replacement.
+            const newNamespace = resolveNamespaceName(news.namespace);
+            const oldNamespace = output?.namespace ?? resolveNamespaceName(olds?.namespace);
+            if (newNamespace !== oldNamespace) {
+                return { action: "replace" };
+            }
             const workerName = yield* createWorkerName(id, news.name);
             const oldWorkerName = output?.workerName
                 ? output.workerName
@@ -988,6 +1124,30 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
         precreate: Effect.fn(function* ({ id, news, session }) {
             const { accountId } = yield* yield* CloudflareEnvironment;
             const name = yield* createWorkerName(id, news.name);
+            // A Workers for Platforms user worker can't be pre-created: precreate
+            // runs on raw, *unresolved* props (so resources in a dependency cycle
+            // can signal early), meaning a `namespace` that references the
+            // namespace resource is still an unresolved Output here, and the
+            // namespace itself may not be deployed yet. There's also nothing to
+            // pre-create — a user worker is dispatched to by name, never bound to
+            // circularly. Return a stub; `reconcile` performs the real upload
+            // once props resolve and the namespace exists.
+            if (news.namespace != null) {
+                yield* Effect.logInfo(`Cloudflare Worker precreate: skipping stub for dispatch-namespace worker ${name}`);
+                return {
+                    workerId: name,
+                    workerName: name,
+                    namespace: typeof news.namespace === "string" ? news.namespace : undefined,
+                    logpush: undefined,
+                    url: undefined,
+                    tags: undefined,
+                    durableObjectNamespaces: {},
+                    accountId,
+                    domains: [],
+                    crons: [],
+                };
+            }
+            const dispatchNamespace = resolveNamespaceName(news.namespace);
             const exportMap = news.exports ?? {};
             const durableObjects = Object.keys(exportMap)
                 .filter((logicalId) => isDurableObjectExport(exportMap[logicalId]))
@@ -1005,16 +1165,14 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
             ]));
             yield* Effect.logInfo(`Cloudflare Worker precreate: starting ${name}`);
             yield* Effect.logInfo(`Cloudflare Worker precreate: durable objects ${JSON.stringify(durableObjects)}`);
-            const existingSettings = yield* workers
-                .getScriptScriptAndVersionSetting({
-                accountId,
-                scriptName: name,
-            })
-                .pipe(
+            const existingSettings = yield* getScriptSettings(accountId, name, dispatchNamespace).pipe(
             // A freshly pre-created stub can briefly report "has no
             // versions" before its first version registers — treat it the
-            // same as a missing worker (nothing to adopt yet).
-            Effect.catchTag("WorkerNotFound", () => Effect.succeed(undefined)), Effect.catchTag("WorkerHasNoVersions", () => Effect.succeed(undefined)));
+            // same as a missing worker (nothing to adopt yet). For a user
+            // worker the dispatch-namespace endpoints report a missing
+            // script as `DispatchNamespaceScriptNotFound` (and a missing
+            // namespace as `DispatchNamespaceNotFound`).
+            Effect.catchTag("WorkerNotFound", () => Effect.succeed(undefined)), Effect.catchTag("WorkerHasNoVersions", () => Effect.succeed(undefined)), Effect.catchTag("DispatchNamespaceScriptNotFound", () => Effect.succeed(undefined)), Effect.catchTag("DispatchNamespaceNotFound", () => Effect.succeed(undefined)));
             let durableObjectNamespaces = getDurableObjects(existingSettings?.bindings);
             if (existingSettings) {
                 // Engine has already cleared this resource for write via
@@ -1028,10 +1186,10 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
                 const placeholderScript = `${doClasses.length > 0 ? 'import { DurableObject } from "cloudflare:workers";\n\n' : ""}export default { fetch() { return new Response("Alchemy worker is being deployed...") } };\n${doClasses
                     .map((className) => `export class ${className} extends DurableObject {}`)
                     .join("\n")}`;
-                yield* workers
-                    .putScript({
+                yield* putWorkerScript({
                     accountId,
                     scriptName: name,
+                    dispatchNamespace,
                     metadata: {
                         mainModule,
                         bindings: doClasses.length > 0
@@ -1068,8 +1226,7 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
                             type: "application/javascript+module",
                         }),
                     ],
-                })
-                    .pipe(
+                }).pipe(
                 // Cloudflare's PUT /workers/scripts/{name} intermittently
                 // returns code 10002 / "An unknown error has occurred" on the
                 // first put for a fresh worker name. Surfaced as the shared
@@ -1084,16 +1241,17 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
                 }));
                 if (doClasses.length > 0) {
                     ({ durableObjectNamespaces } =
-                        yield* getWorkerSettingsWithDurableObjects(name, doClasses));
+                        yield* getWorkerSettingsWithDurableObjects(name, doClasses, dispatchNamespace));
                 }
             }
             if (existingSettings && doClasses.length > 0) {
                 ({ durableObjectNamespaces } =
-                    yield* getWorkerSettingsWithDurableObjects(name, doClasses));
+                    yield* getWorkerSettingsWithDurableObjects(name, doClasses, dispatchNamespace));
             }
             return {
                 workerId: name,
                 workerName: name,
+                namespace: dispatchNamespace,
                 logpush: existingSettings?.logpush ?? undefined,
                 url: undefined,
                 tags: existingSettings?.tags ?? tags,
@@ -1106,7 +1264,30 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
         read: Effect.fn(function* ({ id, output, olds }) {
             const { accountId } = yield* yield* CloudflareEnvironment;
             const workerName = output?.workerName ?? (yield* createWorkerName(id, olds?.name));
+            const dispatchNamespace = output?.namespace ?? resolveNamespaceName(olds?.namespace);
             yield* Effect.logInfo(`Cloudflare Worker read: checking ${workerName}`);
+            // Workers for Platforms user workers have no subdomain, custom
+            // domains, or cron triggers — read only the script settings from
+            // the dispatch-namespace endpoint.
+            if (dispatchNamespace) {
+                const settings = yield* getScriptSettings(accountId, workerName, dispatchNamespace);
+                yield* Effect.logInfo(`Cloudflare Worker read: found ${workerName} in dispatch namespace ${dispatchNamespace}`);
+                const attrs = {
+                    accountId,
+                    workerId: workerName,
+                    workerName,
+                    namespace: dispatchNamespace,
+                    logpush: settings.logpush ?? undefined,
+                    url: undefined,
+                    tags: settings.tags ?? undefined,
+                    durableObjectNamespaces: getDurableObjects(settings.bindings),
+                    domains: [],
+                    crons: [],
+                };
+                return hasAlchemyWorkerTags(id, settings.tags ?? [])
+                    ? attrs
+                    : Unowned(attrs);
+            }
             // We deliberately don't call `listScripts({ accountId })` here:
             // it pulls every Worker on the account back through a strict
             // schema decode, and a single existing Worker the schema doesn't
@@ -1156,6 +1337,7 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
                 accountId,
                 workerId: workerName,
                 workerName,
+                namespace: undefined,
                 logpush: settings.logpush ?? undefined,
                 url: domains[0],
                 tags: settings.tags ?? undefined,
@@ -1175,7 +1357,9 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
         }, (effect) => effect.pipe(
         // A worker that exists but hasn't registered a version yet reads
         // as "not deployed" — fall through to (re)create like NotFound.
-        Effect.catchTag("WorkerNotFound", () => Effect.succeed(undefined)), Effect.catchTag("WorkerHasNoVersions", () => Effect.succeed(undefined)))),
+        // The dispatch-namespace endpoints report the same conditions as
+        // `DispatchNamespaceScriptNotFound` / `DispatchNamespaceNotFound`.
+        Effect.catchTag("WorkerNotFound", () => Effect.succeed(undefined)), Effect.catchTag("WorkerHasNoVersions", () => Effect.succeed(undefined)), Effect.catchTag("DispatchNamespaceScriptNotFound", () => Effect.succeed(undefined)), Effect.catchTag("DispatchNamespaceNotFound", () => Effect.succeed(undefined)))),
         reconcile: Effect.fn(function* ({ id, news, olds, bindings, output, session, }) {
             const { accountId } = yield* yield* CloudflareEnvironment;
             const name = output?.workerName ?? (yield* createWorkerName(id, news.name));
@@ -1185,28 +1369,35 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
             }));
             yield* Effect.logInfo(`Cloudflare Worker reconcile: starting ${name}`);
             yield* Effect.logInfo(`Cloudflare Worker reconcile: durable objects ${JSON.stringify(durableObjects)}`);
+            const dispatchNamespace = resolveNamespaceName(news.namespace);
             // Observe — fetch the script's current settings if it already exists.
             // `putWorker` is a true upsert against the Cloudflare API; the
             // existing settings inform asset/migration decisions and let the
             // reconciler converge whether the worker is brand-new, adopted, or
             // an in-place update.
-            const existingSettings = yield* workers
-                .getScriptScriptAndVersionSetting({
-                accountId,
-                scriptName: name,
-            })
-                .pipe(
+            const existingSettings = yield* getScriptSettings(accountId, name, dispatchNamespace).pipe(
             // After a pre-create stub (or under a busy account right after
             // the first upload) the settings read can race the script
             // registry and 404 with "has no versions". Treat it as "no
             // existing settings" so reconcile proceeds to upload/converge.
-            Effect.catchTag("WorkerNotFound", () => Effect.succeed(undefined)), Effect.catchTag("WorkerHasNoVersions", () => Effect.succeed(undefined)));
+            // The dispatch-namespace endpoints raise
+            // `DispatchNamespaceScriptNotFound` / `DispatchNamespaceNotFound`.
+            Effect.catchTag("WorkerNotFound", () => Effect.succeed(undefined)), Effect.catchTag("WorkerHasNoVersions", () => Effect.succeed(undefined)), Effect.catchTag("DispatchNamespaceScriptNotFound", () => Effect.succeed(undefined)), Effect.catchTag("DispatchNamespaceNotFound", () => Effect.succeed(undefined)));
             yield* Effect.logInfo(`Cloudflare Worker reconcile: existing durable object tags ${JSON.stringify((existingSettings?.tags ?? []).filter((tag) => tag.startsWith("alchemy:do:")))}`);
             yield* Effect.logInfo(`Cloudflare Worker reconcile: previous durable object tags ${JSON.stringify((output?.tags ?? []).filter((tag) => tag.startsWith("alchemy:do:")))}`);
             return yield* putWorker(id, news, bindings, olds, output, session, existingSettings);
         }),
         delete: Effect.fn(function* ({ output }) {
             yield* Effect.logInfo(`Cloudflare Worker delete: deleting ${output.workerName}`);
+            // Workers for Platforms user workers have no custom domains; delete
+            // the script straight out of its dispatch namespace.
+            if (output.namespace) {
+                yield* deleteWorkerScript(output.accountId, output.workerName, output.namespace).pipe(Effect.catchTag([
+                    "DispatchNamespaceScriptNotFound",
+                    "DispatchNamespaceNotFound",
+                ], () => Effect.void));
+                return;
+            }
             // Look up live domain IDs rather than trusting persisted state.
             // We no longer track `{ id, zoneId }` on the output; fetching
             // straight from Cloudflare handles both the normal case and
@@ -1229,18 +1420,7 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
                     ]
                     : []), { concurrency: "unbounded" });
             }
-            yield* workers
-                .deleteScript({
-                accountId: output.accountId,
-                scriptName: output.workerName,
-                // Force teardown of queue consumers, durable object classes, and
-                // service bindings hanging off this worker. Without `force`, those
-                // conditions raise QueueConsumerConflict / ServiceBindingConflict
-                // and leave the script in CF. Alchemy is the source of truth for
-                // the worker, so we want a hard delete on teardown.
-                force: true,
-            })
-                .pipe(Effect.catchTag("WorkerNotFound", () => Effect.void));
+            yield* deleteWorkerScript(output.accountId, output.workerName, undefined).pipe(Effect.catchTag("WorkerNotFound", () => Effect.void));
         }),
         tail: ({ output }) => telemetry.tailScript({
             accountId: output.accountId,