alchemy 2.0.0-beta.70 → 2.0.0-beta.72

package/src/Bundle/Bundle.ts

@@ -95,7 +95,7 @@ export interface BundleFile {
   readonly hash: string;
 }
 
-export class BundleError extends Schema.TaggedErrorClass<BundleError>()(
+export class BundleError extends Schema.TaggedError<BundleError>()(
   "BundleError",
   {
     message: Schema.String,
@@ -407,7 +407,7 @@ export function bundleOutputFromRolldownOutputBundle(
  *
  * These run LAST so they see module ids that have already been resolved into
  * `node_modules/<pkg>/...` by upstream resolver plugins such as
- * `@distilled.cloud/cloudflare-rolldown-plugin`.
+ * `@alchemy.run/cloudflare-runtime/rolldown`.
  */
 async function builtInPlugins(
   extra?: BundleExtraOptions,

package/src/Cli/commands/cloudflare.ts

@@ -142,7 +142,7 @@ const teardownCommand = Command.make(
     }),
   ),
 ).pipe(
-  Command.withHidden,
+  Command.unlisted,
   Command.withDescription("Tear down the cloudflare state store"),
 );
 

package/src/Cli/commands/logs.ts

@@ -7,6 +7,7 @@ import * as Option from "effect/Option";
 import { Command, Flag } from "effect/unstable/cli";
 
 import { findProviderByType, type LogLine } from "../../Provider.ts";
+import { stampedMode } from "../../ProviderMode.ts";
 import { Stage } from "../../Stage.ts";
 import * as State from "../../State/index.ts";
 import { loadConfigProvider } from "../../Util/ConfigProvider.ts";
@@ -125,7 +126,7 @@ export const logsCommand = Command.make(
             // row (a local dev worker's logs come from the local provider).
             const provider = yield* findProviderByType(
               resource.Type,
-              (resourceState as any).providerMode,
+              stampedMode(resourceState as any),
             );
             if (!provider.logs) continue;
 

package/src/Cli/commands/nuke.ts

@@ -799,7 +799,7 @@ const nukeCommand = Command.make(
   ),
 ).pipe(
   // hide the command because it's dangerous and we don't want agents to discover and use it
-  Command.withHidden,
+  Command.unlisted,
   Command.withDescription(
     "Enumerate every live resource across the stack's providers and delete " +
       "them. DESTRUCTIVE — use --include/--exclude/--filter to scope it.",

package/src/Cli/commands/tail.ts

@@ -7,6 +7,7 @@ import * as Stream from "effect/Stream";
 import * as Command from "effect/unstable/cli/Command";
 
 import { findProviderByType, type LogLine } from "../../Provider.ts";
+import { stampedMode } from "../../ProviderMode.ts";
 import { Stage } from "../../Stage.ts";
 import * as State from "../../State/index.ts";
 import { loadConfigProvider } from "../../Util/ConfigProvider.ts";
@@ -101,7 +102,7 @@ export const tailCommand = Command.make(
             // row (a local dev worker's logs come from the local provider).
             const provider = yield* findProviderByType(
               resource.Type,
-              (resourceState as any).providerMode,
+              stampedMode(resourceState as any),
             );
             if (!provider.tail) continue;
 

package/src/Cloudflare/AI/LanguageModel.ts

@@ -1023,6 +1023,9 @@ const parseStreamText = (
     Stream.decodeText(),
     Stream.pipeThroughChannel(Sse.decode<AiError.AiError, unknown>()),
     Stream.catchTag("Retry", (retry) => Stream.die(retry)),
+    Stream.catchTag("SseError", (error) =>
+      Stream.fail(toAiError(error, "streamText")),
+    ),
     Stream.mapAccumEffect(
       initialStreamState,
       (state, event) => handleStreamChunk(state, event.data, idGen, hasTools),

package/src/Cloudflare/Access.ts

@@ -8,7 +8,7 @@ import * as ChildProcess from "effect/unstable/process/ChildProcess";
 import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
 import { cachedFunction } from "../Util/cached-function.ts";
 
-export class AccessError extends Schema.TaggedErrorClass<AccessError>()(
+export class AccessError extends Schema.TaggedError<AccessError>()(
   "AccessError",
   {
     message: Schema.String,

package/src/Cloudflare/Containers/ContainerBundle.ts

@@ -454,7 +454,7 @@ await Effect.runPromise(serverEffect).catch((err) => {
  * return the paths + content hash of that context.
  *
  * This is the local-dev image shape (`ContainerImage.Build`) that
- * `@distilled.cloud/cloudflare-runtime` consumes: it `docker build`s the
+ * `@alchemy.run/cloudflare-runtime/core` consumes: it `docker build`s the
  * `dockerfile` against the `context` directory. Shared between the local
  * provider (which serves this context to the runtime as the `dev` image) and
  * the live provider (which persists the same deterministic context path as

package/src/Cloudflare/Containers/ContainerProvider.ts

@@ -460,11 +460,41 @@ export const LiveContainerProvider = () =>
           );
         }
 
-        yield* docker.image.push(imageRef, {
-          username,
-          password: credentials.password,
-          server: registryId,
-        });
+        // Cloudflare's container registry intermittently answers blob HEAD
+        // probes with 500 under concurrent suite push load. Ride that out
+        // with a bounded retry rather than failing the whole deploy.
+        //
+        // Push the SAME platform we pulled/built. With Docker's containerd
+        // image store a tag can hold several platform variants (e.g. a stray
+        // host-arch `docker pull` adds arm64 next to our amd64), and an
+        // un-scoped push then ships the wrong variant — Cloudflare's amd64
+        // hosts never boot it and the app 503s "provisioning" forever.
+        yield* docker.image
+          .push(
+            imageRef,
+            {
+              username,
+              password: credentials.password,
+              server: registryId,
+            },
+            platform,
+          )
+          .pipe(
+            Effect.retry({
+              while: (e) => {
+                const msg = String(e).toLowerCase();
+                return (
+                  msg.includes("500") ||
+                  msg.includes("internal server error") ||
+                  msg.includes("unexpected status")
+                );
+              },
+              schedule: Schedule.max([
+                Schedule.spaced("3 seconds"),
+                Schedule.recurs(5),
+              ]),
+            }),
+          );
       });
 
       const maybeCreateRollout = Effect.fn(function* ({

package/src/Cloudflare/Containers/LocalContainerProvider.ts

@@ -28,7 +28,7 @@ import { ContainerPlatform } from "./ContainerPlatform.ts";
 /**
  * Local (dev) provider for Cloudflare Container applications.
  *
- * The Docker build/run is owned by `@distilled.cloud/cloudflare-runtime`; this
+ * The Docker build/run is owned by `@alchemy.run/cloudflare-runtime/core`; this
  * provider's only job is to resolve the `dev` image the runtime should use —
  * a build context to `docker build` (Effect-native `main` or a user-supplied
  * Dockerfile) or a remote image to `docker pull` — mirroring the three image

package/src/Cloudflare/D1/Database.ts

@@ -1,4 +1,4 @@
-import type { RuntimeServices } from "@distilled.cloud/cloudflare-runtime";
+import type { RuntimeServices } from "@alchemy.run/cloudflare-runtime/core";
 import * as d1 from "@distilled.cloud/cloudflare/d1";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";

package/src/Cloudflare/D1/LocalD1Gateway.ts

@@ -19,10 +19,10 @@
  *
  * NOT exported from `index.ts` — provider-internal scaffolding.
  */
-import { open } from "@distilled.cloud/cloudflare-runtime/platform-proxy";
-import { D1 } from "@distilled.cloud/cloudflare-runtime/bindings";
-import { SERVICE_D1 } from "@distilled.cloud/cloudflare-runtime/bindings/d1/D1Options";
-import type { BindingHook } from "@distilled.cloud/cloudflare-runtime/PluginContext";
+import { open } from "@alchemy.run/cloudflare-runtime/core/platform-proxy";
+import { D1 } from "@alchemy.run/cloudflare-runtime/core/bindings";
+import { SERVICE_D1 } from "@alchemy.run/cloudflare-runtime/core/bindings/d1/D1Options";
+import type { BindingHook } from "@alchemy.run/cloudflare-runtime/core/PluginContext";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import { gatewayName, localGatewayRuntime } from "../LocalGateway.ts";

package/src/Cloudflare/KV/LocalKVGateway.ts

@@ -17,8 +17,8 @@
  *
  * NOT exported from `index.ts` — capability-internal scaffolding.
  */
-import { KvNamespace } from "@distilled.cloud/cloudflare-runtime/bindings";
-import { open } from "@distilled.cloud/cloudflare-runtime/platform-proxy";
+import { KvNamespace } from "@alchemy.run/cloudflare-runtime/core/bindings";
+import { open } from "@alchemy.run/cloudflare-runtime/core/platform-proxy";
 import type * as runtime from "@cloudflare/workers-types";
 import type * as Context from "effect/Context";
 import * as Effect from "effect/Effect";

package/src/Cloudflare/LocalGateway.ts

@@ -10,7 +10,7 @@
  *
  * NOT exported from `index.ts` — provider/capability-internal scaffolding.
  */
-import { layerRuntime } from "@distilled.cloud/cloudflare-runtime";
+import { layerRuntime } from "@alchemy.run/cloudflare-runtime/core";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";

package/src/Cloudflare/LocalRuntime.ts

@@ -1,4 +1,4 @@
-import { layerRuntime } from "@distilled.cloud/cloudflare-runtime";
+import { layerRuntime } from "@alchemy.run/cloudflare-runtime/core";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
@@ -6,6 +6,7 @@ import * as MutableHashMap from "effect/MutableHashMap";
 import * as Path from "effect/Path";
 import { AlchemyContext } from "../AlchemyContext.ts";
 import * as RpcProvider from "../Local/RpcProvider.ts";
+import { LOCAL_ID_PREFIX } from "../ProviderMode.ts";
 import { CloudflareEnvironment } from "./CloudflareEnvironment.ts";
 import type { Queue } from "./Queues/Queue.ts";
 import type { Consumer } from "./Queues/Consumer.ts";
@@ -110,7 +111,8 @@ export const localRuntimeServices = () =>
   (_localRuntimeServices ??= makeLocalRuntimeServices());
 
 export const isLocalId = (id: string | undefined): id is string =>
-  typeof id === "string" && id.startsWith("dev:");
+  typeof id === "string" && id.startsWith(LOCAL_ID_PREFIX);
 export const isLiveId = (id: string | undefined): id is string =>
-  typeof id === "string" && !id.startsWith("dev:");
-export const generateLocalId = (): string => `dev:${crypto.randomUUID()}`;
+  typeof id === "string" && !id.startsWith(LOCAL_ID_PREFIX);
+export const generateLocalId = (): string =>
+  `${LOCAL_ID_PREFIX}${crypto.randomUUID()}`;

package/src/Cloudflare/Queues/Consumer.ts

@@ -1,4 +1,5 @@
 import * as queues from "@distilled.cloud/cloudflare/queues";
+import * as workers from "@distilled.cloud/cloudflare/workers";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as MutableHashMap from "effect/MutableHashMap";
@@ -10,6 +11,7 @@ import * as ProviderLayer from "../../Local/ProviderLayer.ts";
 import * as RpcProvider from "../../Local/RpcProvider.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
+import { Stack } from "../../Stack.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import {
   isLiveId,
@@ -99,8 +101,10 @@ export type Consumer = Resource<
  *
  * Cloudflare allows at most one Worker consumer per queue (HTTP-pull
  * consumers can coexist). The reconciler enforces this: if the queue
- * already has a Worker consumer pointing at a different script, the
- * deploy fails with a clear error rather than silently adopting it.
+ * already has a Worker consumer pointing at a different logical Worker's
+ * script, the deploy fails with a clear error rather than silently
+ * adopting it. A stranded consumer from a prior generation of the *same*
+ * Worker (identified by the scripts' ownership tags) is rebuilt in place.
  * @resource
  * @product Queues
  * @category Storage & Databases
@@ -133,6 +137,69 @@ export const Consumer = Resource<Consumer>("Cloudflare.Queues.Consumer", {
   aliases: ["Cloudflare.QueueConsumer"],
 });
 
+/**
+ * Find and detach every worker queue-consumer pointing at `scriptName`.
+ * Queue consumers have no by-script lookup, so scan the account's queues
+ * (the list response inlines each queue's consumers). Waits until each
+ * detach propagates to the workers subsystem so a follow-up deleteScript
+ * doesn't re-race the conflict.
+ *
+ * Shared by the Worker provider's script delete (QueueConsumerConflict
+ * recovery) and the Queue provider's orphaned-script cleanup.
+ *
+ * @internal
+ */
+export const detachQueueConsumersOfScript = Effect.fn(function* (
+  accountId: string,
+  scriptName: string,
+) {
+  const pages = yield* queues.listQueues.pages({ accountId }).pipe(
+    Stream.runCollect,
+    Effect.catchTag("InvalidRoute", () => Effect.succeed([])),
+  );
+  const targets = Array.from(pages).flatMap((page) =>
+    (page.result ?? []).flatMap((queue) =>
+      (queue.consumers ?? []).flatMap((consumer) =>
+        queue.queueId &&
+        consumer.type === "worker" &&
+        consumer.consumerId &&
+        "scriptName" in consumer &&
+        consumer.scriptName === scriptName
+          ? [{ queueId: queue.queueId, consumerId: consumer.consumerId }]
+          : [],
+      ),
+    ),
+  );
+  yield* Effect.forEach(
+    targets,
+    ({ queueId, consumerId }) =>
+      queues.deleteConsumer({ accountId, queueId, consumerId }).pipe(
+        Effect.catchTag(
+          ["ConsumerNotFound", "QueueNotFound"],
+          () => Effect.void,
+        ),
+        Effect.andThen(
+          queues.getConsumer({ accountId, queueId, consumerId }).pipe(
+            Effect.flatMap(() => Effect.fail("still-attached" as const)),
+            Effect.catchTag(
+              ["ConsumerNotFound", "QueueNotFound"],
+              () => Effect.void,
+            ),
+            Effect.retry({
+              while: (e) => e === "still-attached",
+              schedule: Schedule.max([
+                Schedule.spaced("1 second"),
+                Schedule.recurs(30),
+              ]),
+            }),
+            Effect.ignore,
+          ),
+        ),
+      ),
+    { concurrency: 5, discard: true },
+  );
+});
+
 // Cloudflare allows a single Worker consumer per queue, so the
 // first match in the paginated stream is the only one. Using
 // `.items` defeats single-page lookups that would otherwise
@@ -258,6 +325,29 @@ export const ConsumerProviderLive = () =>
       // Otherwise, the lookup will fail because the request is malformed.
       const queueId = isLiveId(output?.queueId) ? output.queueId : news.queueId;
 
+      // Delete a consumer and wait for Cloudflare's worker subsystem to
+      // drop its claim on the old script so createConsumer below doesn't
+      // race the queue↔script propagation lag.
+      const detachConsumer = Effect.fn(function* (consumerId: string) {
+        yield* queues
+          .deleteConsumer({ accountId: acct, queueId, consumerId })
+          .pipe(Effect.catchTag("ConsumerNotFound", () => Effect.void));
+        yield* queues
+          .getConsumer({ accountId: acct, queueId, consumerId })
+          .pipe(
+            Effect.flatMap(() => Effect.fail("still-attached" as const)),
+            Effect.catchTag("ConsumerNotFound", () => Effect.void),
+            Effect.retry({
+              while: (e) => e === "still-attached",
+              schedule: Schedule.max([
+                Schedule.spaced("1 second"),
+                Schedule.recurs(30),
+              ]),
+            }),
+            Effect.ignore,
+          );
+      });
+
       // Observe — prefer the cached consumerId, then fall back to
       // listConsumers (paginated) to recover from out-of-band
       // deletes or partial state-persistence failures. Track
@@ -301,58 +391,74 @@ export const ConsumerProviderLive = () =>
         observed.scriptName !== undefined &&
         observed.scriptName !== news.scriptName
       ) {
-        yield* queues
-          .deleteConsumer({
-            accountId: acct,
-            queueId,
-            consumerId: observed.consumerId,
-          })
-          .pipe(Effect.catchTag("ConsumerNotFound", () => Effect.void));
-        // Wait for Cloudflare's worker subsystem to drop its
-        // claim on the old script so createConsumer below
-        // doesn't race the queue↔script propagation lag.
-        yield* queues
-          .getConsumer({
-            accountId: acct,
-            queueId,
-            consumerId: observed.consumerId,
-          })
-          .pipe(
-            Effect.flatMap(() => Effect.fail("still-attached" as const)),
-            Effect.catchTag("ConsumerNotFound", () => Effect.void),
-            Effect.retry({
-              while: (e) => e === "still-attached",
-              schedule: Schedule.max([
-                Schedule.spaced("1 second"),
-                Schedule.recurs(30),
-              ]),
-            }),
-            Effect.ignore,
-          );
+        yield* detachConsumer(observed.consumerId);
         observed = undefined;
         owned = false;
       }
 
-      // Refuse to take over a foreign consumer on the state-loss
-      // path. With `owned=false` we found this via the list scan
-      // and the script mismatch means it belongs to another
-      // resource or was created out-of-band — silent adoption
-      // would clobber that.
+      // A consumer found via the list scan (state loss) pointing at a
+      // different script. Probe the script it points at: when it no
+      // longer exists, or is a *prior generation of the same logical
+      // Worker* (same `alchemy:stack/stage/id` ownership tags as the
+      // configured script — replacements mint a new physical name, and
+      // a crashed apply can strand the old generation's consumer with
+      // its state entry lost), the wiring is ours to rebuild. Any other
+      // script — another team's, or a *different* Worker in this stack
+      // (a real misconfiguration: two consumers declared for one queue)
+      // — is refused loudly rather than silently stolen.
       if (
         observed &&
         !owned &&
         observed.scriptName !== undefined &&
         observed.scriptName !== news.scriptName
       ) {
-        return yield* Effect.die(
-          `Cloudflare queue "${queueId}" already has a worker ` +
-            `consumer for script "${observed.scriptName}", but this ` +
-            `resource is configured for "${news.scriptName}" and ` +
-            `local state for the consumer was missing. Each queue ` +
-            `can have only one worker consumer — delete the ` +
-            `existing one, update scriptName to match, or restore ` +
-            `the consumer's state entry before redeploying.`,
-        );
+        const scriptTags = Effect.fn(function* (scriptName: string) {
+          const settings = yield* workers
+            .getScriptScriptAndVersionSetting({
+              accountId: acct,
+              scriptName,
+            })
+            .pipe(
+              Effect.catchTag(["WorkerNotFound", "WorkerHasNoVersions"], () =>
+                Effect.succeed(undefined),
+              ),
+            );
+          return settings === undefined
+            ? undefined
+            : new Set(settings.tags ?? []);
+        });
+        const observedTags = yield* scriptTags(observed.scriptName);
+        let staleGeneration = observedTags === undefined;
+        if (observedTags !== undefined) {
+          const stack = yield* Stack;
+          const desiredTags = news.scriptName
+            ? yield* scriptTags(news.scriptName)
+            : undefined;
+          const observedId = Array.from(observedTags).find((t) =>
+            t.startsWith("alchemy:id:"),
+          );
+          staleGeneration =
+            observedId !== undefined &&
+            observedTags.has(`alchemy:stack:${stack.name}`) &&
+            observedTags.has(`alchemy:stage:${stack.stage}`) &&
+            desiredTags !== undefined &&
+            desiredTags.has(observedId) &&
+            desiredTags.has(`alchemy:stack:${stack.name}`) &&
+            desiredTags.has(`alchemy:stage:${stack.stage}`);
+        }
+        if (!staleGeneration) {
+          return yield* Effect.die(
+            `Cloudflare queue "${queueId}" already has a worker ` +
+              `consumer for script "${observed.scriptName}", but this ` +
+              `resource is configured for "${news.scriptName}" and ` +
+              `local state for the consumer was missing. Each queue ` +
+              `can have only one worker consumer — delete the ` +
+              `existing one, update scriptName to match, or restore ` +
+              `the consumer's state entry before redeploying.`,
+          );
+        }
+        yield* detachConsumer(observed.consumerId);
+        observed = undefined;
       }
 
       // Ensure — create if missing. ConsumerAlreadyExists is the
@@ -614,6 +720,13 @@ export const ConsumerProviderLocal = () =>
         diff: Effect.fn(function* ({ news, output }) {
           const { accountId } = yield* yield* CloudflareEnvironment;
           if (!output) return { action: "update" };
+          // A real (non-`dev:`) consumerId on a local-mode row is legacy
+          // damage from pre-stamping dev runs — replace so the new
+          // generation mints a true local identity (delete best-effort
+          // detaches the stray live consumer).
+          if (isLiveId(output.consumerId)) {
+            return { action: "replace" };
+          }
           if (!isResolved(news)) return undefined;
           if (
             output.queueId !== news.queueId ||
@@ -682,7 +795,13 @@ export const ConsumerProviderLocal = () =>
             }
           }
           const consumer: Consumer["Attributes"] = {
-            consumerId: output?.consumerId ?? `dev:${crypto.randomUUID()}`,
+            // Never carry a real (non-`dev:`) consumer id forward onto a
+            // local row — it belongs to a live consumer this row no longer
+            // manages (legacy pre-stamping damage).
+            consumerId:
+              output?.consumerId && !isLiveId(output.consumerId)
+                ? output.consumerId
+                : `dev:${crypto.randomUUID()}`,
             queueId: news.queueId,
             scriptName: news.scriptName,
             deadLetterQueue: news.deadLetterQueue,
@@ -715,6 +834,25 @@ export const ConsumerProviderLocal = () =>
             output.consumerId,
           );
           yield* restartScripts([output.scriptName]);
+          // Legacy local-mode rows written before providerMode stamping can
+          // carry a real consumer's id — detach the live consumer too so
+          // migrating the row to a true local identity doesn't strand it on
+          // the queue (a stranded worker consumer blocks every future
+          // createConsumer with ConsumerAlreadyExists).
+          if (isLiveId(output.consumerId) && isLiveId(output.queueId)) {
+            yield* queues
+              .deleteConsumer({
+                accountId: output.accountId,
+                queueId: output.queueId,
+                consumerId: output.consumerId,
+              })
+              .pipe(
+                Effect.catchTag(
+                  ["ConsumerNotFound", "QueueNotFound"],
+                  () => Effect.void,
+                ),
+              );
+          }
           // Remove the http_pull consumer this row attached to its live
           // queue. Idempotent: gone-already (or queue deleted first) is
           // success.