alchemy 2.0.0-beta.70 → 2.0.0-beta.71

package/src/Cloudflare/Workers/Assets.ts

@@ -20,10 +20,65 @@ export interface Assets {
 export const isAssets = (value: any): value is Assets =>
   value?.kind === "Cloudflare.Workers.Assets";
 
-export interface AssetsConfig extends Exclude<
-  Exclude<workers.PutScriptRequest["metadata"]["assets"], undefined>["config"],
-  undefined
-> {}
+/**
+ * Routing configuration for a Worker's static assets — sent to Cloudflare
+ * as `metadata.assets.config` on script upload. Declared explicitly (not
+ * derived from the distilled API schema) so alchemy owns and documents its
+ * public surface.
+ */
+export interface AssetsConfig {
+  /**
+   * Determines the redirects and rewrites of requests for HTML content:
+   * whether `/page` serves `page.html`, and whether trailing slashes are
+   * added or dropped.
+   *
+   * @default "auto-trailing-slash"
+   */
+  htmlHandling?:
+    | "auto-trailing-slash"
+    | "force-trailing-slash"
+    | "drop-trailing-slash"
+    | "none";
+  /**
+   * Determines the response when a request does not match a static asset:
+   * `"404-page"` serves the nearest `404.html`, and
+   * `"single-page-application"` serves `index.html` for client-side
+   * routing. When the Worker has a script, an unmatched request falls
+   * through to the Worker instead.
+   *
+   * @default "none"
+   */
+  notFoundHandling?: "none" | "404-page" | "single-page-application";
+  /**
+   * Routes requests through the Worker *before* static-asset matching.
+   *
+   * Assets-first by default: a request matching a file is served directly
+   * and never invokes the Worker. `true` routes every request through the
+   * Worker ahead of the asset layer — serve files yourself via the
+   * `ASSETS` binding. A path-rule array routes only matching paths
+   * worker-first (e.g. `["/api/*"]`): glob (`*`) and negative (`!`) rules
+   * are supported, rules must start with `/` or `!/`, and negative rules
+   * take precedence. The same routing applies under `alchemy dev`.
+   *
+   * @default false
+   */
+  runWorkerFirst?: boolean | string[];
+  /**
+   * Legacy routing flag predating `runWorkerFirst`.
+   */
+  serveDirectly?: boolean;
+  /**
+   * Raw contents of a `_headers` file — header rules applied by the asset
+   * layer. Overrides a `_headers` file read from the assets directory.
+   */
+  headers?: string;
+  /**
+   * Raw contents of a `_redirects` file — redirect rules applied by the
+   * asset layer. Overrides a `_redirects` file read from the assets
+   * directory.
+   */
+  redirects?: string;
+}
 
 export interface AssetReadResult {
   directory: string;
@@ -117,23 +172,56 @@ export class AssetUploadSessionError extends Data.TaggedError(
   workerName: string;
 }> {}
 
+const contentTypesByExtension: Record<string, string> = {
+  html: "text/html",
+  htm: "text/html",
+  txt: "text/plain",
+  md: "text/markdown",
+  sql: "text/sql",
+  json: "application/json",
+  // Source maps are JSON; serving them as such lets devtools consume them.
+  map: "application/json",
+  jsonld: "application/ld+json",
+  xml: "application/xml",
+  csv: "text/csv",
+  // Browsers only accept JavaScript module scripts when the MIME type is a
+  // "JavaScript MIME type" (e.g. text/javascript). application/javascript+module
+  // is not valid and causes strict module loading to fail.
+  js: "text/javascript; charset=utf-8",
+  mjs: "text/javascript; charset=utf-8",
+  css: "text/css",
+  wasm: "application/wasm",
+  pdf: "application/pdf",
+  // images
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  svg: "image/svg+xml",
+  ico: "image/x-icon",
+  bmp: "image/bmp",
+  // fonts
+  woff: "font/woff",
+  woff2: "font/woff2",
+  ttf: "font/ttf",
+  otf: "font/otf",
+  eot: "application/vnd.ms-fontobject",
+  // media
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  // app manifests
+  webmanifest: "application/manifest+json",
+};
+
 const getContentType = (name: string) => {
-  if (name.endsWith(".html")) return "text/html";
-  if (name.endsWith(".txt")) return "text/plain";
-  if (name.endsWith(".sql")) return "text/sql";
-  if (name.endsWith(".json")) return "application/json";
-  if (name.endsWith(".js") || name.endsWith(".mjs")) {
-    // Browsers only accept JavaScript module scripts when the MIME type is a
-    // "JavaScript MIME type" (e.g. text/javascript). application/javascript+module
-    // is not valid and causes strict module loading to fail.
-    return "text/javascript; charset=utf-8";
-  }
-  if (name.endsWith(".css")) return "text/css";
-  if (name.endsWith(".wasm")) return "application/wasm";
-  if (name.endsWith(".png")) return "image/png";
-  if (name.endsWith(".svg")) return "image/svg+xml";
-  if (name.endsWith(".ico")) return "image/x-icon";
-  return "application/octet-stream";
+  const dot = name.lastIndexOf(".");
+  const ext = dot === -1 ? "" : name.slice(dot + 1).toLowerCase();
+  return contentTypesByExtension[ext] ?? "application/octet-stream";
 };
 
 const maybeReadString = Effect.fn(function* (file: string) {
@@ -254,7 +342,21 @@ export const readAssets = Effect.fn(function* ({
           size,
         });
       }
+      // Hash content + extension (matching wrangler): the upload API stores
+      // one blob + content type per hash, so two identical bodies under
+      // different extensions must not collapse into a single entry — the
+      // second file would serve with the first file's content type.
+      const extension = name.slice(name.lastIndexOf(".") + 1).toLowerCase();
       const hash = yield* fs.readFile(file).pipe(
+        Effect.flatMap((content) =>
+          Effect.sync(() => {
+            const extBytes = new TextEncoder().encode(extension);
+            const hashed = new Uint8Array(content.length + extBytes.length);
+            hashed.set(content);
+            hashed.set(extBytes, content.length);
+            return hashed;
+          }),
+        ),
         Effect.flatMap(sha256),
         Effect.map((hash) => hash.slice(0, 32)),
       );

package/src/Cloudflare/Workers/LocalWorkerProvider.ts

@@ -8,9 +8,9 @@ import {
   type DurableObjectNamespace as RuntimeDurableObject,
   type QueueConsumer as RuntimeQueueConsumer,
   type Workflow as RuntimeWorkflow,
-} from "@distilled.cloud/cloudflare-runtime";
-import type { ContainerImage } from "@distilled.cloud/cloudflare-runtime/Docker";
-import * as WorkerProxy from "@distilled.cloud/cloudflare-runtime/proxy/WorkerProxy";
+} from "@alchemy.run/cloudflare-runtime/core";
+import type { ContainerImage } from "@alchemy.run/cloudflare-runtime/core/Docker";
+import * as WorkerProxy from "@alchemy.run/cloudflare-runtime/core/proxy/WorkerProxy";
 import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
 import * as Equal from "effect/Equal";
@@ -36,6 +36,7 @@ import {
   LocalRuntimeState,
   localStorageDirectory,
 } from "../LocalRuntime.ts";
+import type { ConsumerSettings } from "../Queues/Consumer.ts";
 import type { WorkerAssetsConfig, WorkerProps } from "../Workers/Worker.ts";
 import { readAssetsConfigFiles } from "./Assets.ts";
 import { getCompatibility } from "./Compatibility.ts";
@@ -126,6 +127,25 @@ export const LocalWorkerProvider = () =>
         }
       >();
 
+      // ConsumerSettings speaks the Cloudflare API's dialect (batchSize,
+      // maxWaitTimeMs in milliseconds); the runtime's QueueConsumer speaks
+      // wrangler's (maxBatchSize, maxBatchTimeout in seconds). Map
+      // explicitly — a spread silently drops the mismatched fields.
+      const toRuntimeConsumerSettings = (
+        settings: ConsumerSettings | undefined,
+      ): Pick<
+        RuntimeQueueConsumer,
+        "maxBatchSize" | "maxBatchTimeout" | "maxRetries" | "retryDelay"
+      > => ({
+        maxBatchSize: settings?.batchSize,
+        maxBatchTimeout:
+          settings?.maxWaitTimeMs !== undefined
+            ? settings.maxWaitTimeMs / 1000
+            : undefined,
+        maxRetries: settings?.maxRetries,
+        retryDelay: settings?.retryDelay,
+      });
+
       const getQueueConsumers = Effect.fn(function* (scriptName: string) {
         const consumers: RuntimeQueueConsumer[] = [];
         for (const consumer of MutableHashMap.values(
@@ -146,7 +166,7 @@ export const LocalWorkerProvider = () =>
               consumers.push({
                 queueName: consumer.queueName,
                 deadLetterQueue: consumer.deadLetterQueue,
-                ...consumer.settings,
+                ...toRuntimeConsumerSettings(consumer.settings),
                 pull: {
                   queueId: consumer.queueId,
                   accountId: consumer.accountId,
@@ -162,7 +182,7 @@ export const LocalWorkerProvider = () =>
               consumers.push({
                 queueName: queue.queueName,
                 deadLetterQueue: consumer.deadLetterQueue,
-                ...consumer.settings,
+                ...toRuntimeConsumerSettings(consumer.settings),
               });
             } else {
               return yield* Effect.die(`Queue ${consumer.queueId} not found`);
@@ -675,24 +695,41 @@ export const LocalWorkerProvider = () =>
         );
 
       /**
-       * Restart a running worker with its latest bundle so start-time
-       * runtime wiring (queue consumers) is re-read from
-       * {@link LocalRuntimeState}. No-op if the worker hasn't served yet —
-       * the pending first serve will already observe the updated state.
+       * Restart a running worker with its latest bundle (or its latest Vite
+       * dev-server child) so start-time runtime wiring (queue consumers) is
+       * re-read from {@link LocalRuntimeState}. No-op if the worker hasn't
+       * served yet — the pending first serve will already observe the
+       * updated state.
        */
+      const logRestartFailure = (id: string) =>
+        Effect.catchCause((cause: Cause.Cause<unknown>) =>
+          Effect.logWarning(
+            `[${id}] Failed to restart local worker`,
+            Cause.squash(cause),
+          ),
+        );
+
       const restartWorker = (id: string) =>
         Effect.suspend(() => {
           const latest = latestServes.get(id);
-          if (!latest) return Effect.void;
-          return serveWith(latest.worker, latest.bundle, latest.proxy).pipe(
-            Effect.asVoid,
-            Effect.catchCause((cause) =>
-              Effect.logWarning(
-                `[${id}] Failed to restart local worker`,
-                Cause.squash(cause),
-              ),
-            ),
-          );
+          if (latest) {
+            return serveWith(latest.worker, latest.bundle, latest.proxy).pipe(
+              Effect.asVoid,
+              logRestartFailure(id),
+            );
+          }
+          const vite = latestViteServes.get(id);
+          if (vite) {
+            // A Vite boot is expensive, so skip the restart if the running
+            // child already serves the current wiring (the in-flight serve's
+            // re-check loop may have picked it up while this restart waited
+            // on the serve lock).
+            return serveVite(vite, { onlyIfConsumersChanged: true }).pipe(
+              Effect.asVoid,
+              logRestartFailure(id),
+            );
+          }
+          return Effect.void;
         });
 
       // Tear down the running workerd for a worker id, if any. Used when the
@@ -711,13 +748,15 @@ export const LocalWorkerProvider = () =>
       // in-flight restart may still hold the semaphore when the instance
       // is torn down, and a same-id re-create must serialize against it.
       const dropServeState = (id: string) => {
-        const latest = latestServes.get(id);
+        const latest = latestServes.get(id) ?? latestViteServes.get(id);
         if (latest) {
           MutableHashMap.remove(
             localRuntimeState.workerRestarts,
             latest.worker.name,
           );
           latestServes.delete(id);
+          latestViteServes.delete(id);
+          servedViteConsumers.delete(id);
         }
       };
 
@@ -863,6 +902,165 @@ export const LocalWorkerProvider = () =>
         return proxy.url;
       });
 
+      /** Everything needed to serve (or re-serve) a Vite dev-server child. */
+      interface ViteServeArgs {
+        worker: RunnableWorkerConfig;
+        rootDir: string | undefined;
+        invalidate: Effect.Effect<void>;
+        source: NonNullable<ViteChildConfig["source"]> | undefined;
+        proxy: WorkerProxy.WorkerProxyInstance;
+      }
+
+      /** The Vite analogue of `latestServes`: everything needed to restart
+       * the dev-server child when a sibling `Consumer` reconcile changes the
+       * queue-consumer wiring (see `workerRestarts`). */
+      const latestViteServes = new Map<string, ViteServeArgs>();
+
+      /** The queue-consumer wiring (canonical JSON) each running Vite child
+       * was started with, for the restart path's changed-wiring check. */
+      const servedViteConsumers = new Map<string, string>();
+
+      // Serve a Vite dev-server child with the same two guarantees
+      // `serveWith` gives a plain worker: a `workerRestarts` hook so sibling
+      // `Consumer` reconciles can restart the child with fresh queue-consumer
+      // wiring, and a post-start re-check so wiring that lands while the
+      // child is starting is not lost. Unlike `serveWith` this is
+      // break-before-make — two Vite dev servers rooted at the same app
+      // would race file watchers and Durable Object storage — so the proxy
+      // queues requests across the gap. The child's scope is forked from
+      // `rootScope` and tracked in `workerdScopes`, so it survives instance
+      // restarts and is reclaimed by `stop`/handoff/`serveWith` like any
+      // other running instance.
+      const serveVite = (
+        args: ViteServeArgs,
+        options?: { onlyIfConsumersChanged?: boolean },
+      ) =>
+        Semaphore.withPermits(
+          serveLock(args.worker.id),
+          1,
+        )(
+          // The bookkeeping around `startViteChild` must not be torn in half
+          // by an interrupt: once a replacement child is up it must be
+          // recorded in `workerdScopes`, or it would leak until provider
+          // shutdown while holding the worker's registry key.
+          Effect.uninterruptibleMask((restore) =>
+            Effect.gen(function* () {
+              const { worker, rootDir, invalidate, source, proxy } = args;
+              if (options?.onlyIfConsumersChanged) {
+                const current = yield* getQueueConsumers(worker.name);
+                if (
+                  workerdScopes.has(worker.id) &&
+                  JSON.stringify(current) === servedViteConsumers.get(worker.id)
+                ) {
+                  return;
+                }
+              }
+              // Queue requests while the child is (re)starting.
+              yield* proxy.unset().pipe(Effect.forkChild);
+              // The dev server and its workerd run in a child process rooted
+              // at the app.
+              const root = path.resolve(rootDir ?? process.cwd());
+              const { accountId } = yield* cloudflareEnv;
+              // Queue-consumer wiring can change while the child is starting
+              // (a sibling `Consumer` reconcile), before the restart hook
+              // below exists to pick it up. We hold the serve lock, so a
+              // restart would deadlock — instead, loop and serve again until
+              // the wiring is stable across a start.
+              while (true) {
+                const queueConsumers = yield* getQueueConsumers(worker.name);
+                // Break-before-make: tear the previous child down before
+                // starting its replacement (also covers a superseded child
+                // from the previous loop iteration).
+                yield* closeWorkerd(worker.id);
+                const scope = yield* Scope.fork(rootScope);
+                const child = yield* restore(
+                  startViteChild(
+                    {
+                      rootDir: root,
+                      publicUrl: proxy.url.toString().replace(/\/$/, ""),
+                      accountId,
+                      storageDirectory,
+                      stack: { name: stack.name, stage: stack.stage },
+                      // Already resolved to plain values by `start`
+                      // (`Worker.URL` sentinels substituted); Redacted
+                      // unwraps at the process boundary inside
+                      // `startViteChild`.
+                      env: worker.env ?? {},
+                      source,
+                      worker: {
+                        name: worker.name,
+                        compatibility: worker.compatibility,
+                        main: worker.viteMain,
+                        viteEnvironments: worker.viteEnvironments,
+                        hasAssets: worker.hasAssets,
+                        bindingDescriptors: worker.bindingDescriptors,
+                        devRemote: worker.devRemote,
+                        durableObjectNamespaces: worker.durableObjectNamespaces,
+                        workflows: worker.workflows,
+                        hyperdrives: worker.hyperdrives,
+                        queueConsumers,
+                        assets: yield* toRuntimeAssets(worker.assets),
+                      },
+                    },
+                    (channel, line) => {
+                      process[channel].write(`${worker.id} | ${line}\n`);
+                    },
+                  ).pipe(Scope.provide(scope)),
+                ).pipe(
+                  // The scope hangs off `rootScope`, so a failed or
+                  // interrupted start must close it here — nothing else owns
+                  // it yet.
+                  Effect.onExit((exit) =>
+                    exit._tag === "Failure"
+                      ? Scope.close(scope, exit)
+                      : Effect.void,
+                  ),
+                );
+                workerdScopes.set(worker.id, scope);
+                latestViteServes.set(worker.id, args);
+                // Unexpected child death: log, park the proxy, and mark the
+                // instance for update on the next plan. Forked into the
+                // child's scope so a deliberate restart or teardown
+                // interrupts the watcher before the process is killed.
+                yield* child.exitCode.pipe(
+                  Effect.flatMap((exitCode) =>
+                    Effect.logWarning(
+                      `[${worker.id}] Dev server child exited unexpectedly with code ${exitCode}`,
+                    ),
+                  ),
+                  Effect.andThen(proxy.unset().pipe(Effect.ignore)),
+                  Effect.andThen(invalidate),
+                  Effect.forkIn(scope),
+                );
+                // Register the restart hook before the re-check below:
+                // changes landing after the re-check find the hook; changes
+                // before it are caught by the re-check. Nothing falls in
+                // between.
+                MutableHashMap.set(
+                  localRuntimeState.workerRestarts,
+                  worker.name,
+                  restartWorker(worker.id),
+                );
+                const currentConsumers = yield* getQueueConsumers(worker.name);
+                if (
+                  JSON.stringify(currentConsumers) !==
+                  JSON.stringify(queueConsumers)
+                ) {
+                  // Wiring changed while the child was starting — serve
+                  // again with the fresh consumers before exposing it.
+                  continue;
+                }
+                servedViteConsumers.set(
+                  worker.id,
+                  JSON.stringify(queueConsumers),
+                );
+                yield* proxy.set(child.url);
+                return;
+              }
+            }),
+          ),
+        );
+
       const runVite = Effect.fn(function* (
         worker: RunnableWorkerConfig,
         rootDir: string | undefined,
@@ -870,53 +1068,7 @@ export const LocalWorkerProvider = () =>
         source?: NonNullable<ViteChildConfig["source"]>,
       ) {
         const proxy = yield* maybeStartProxy(worker.id, worker.dev);
-        yield* proxy.unset().pipe(Effect.forkChild);
-        // The dev server and its workerd run in a child process rooted at
-        // the app.
-        const root = path.resolve(rootDir ?? process.cwd());
-        const { accountId } = yield* cloudflareEnv;
-        const child = yield* startViteChild(
-          {
-            rootDir: root,
-            publicUrl: proxy.url.toString().replace(/\/$/, ""),
-            accountId,
-            storageDirectory,
-            stack: { name: stack.name, stage: stack.stage },
-            // Already resolved to plain values by `start` (`Worker.URL`
-            // sentinels substituted); Redacted unwraps at the process
-            // boundary inside `startViteChild`.
-            env: worker.env ?? {},
-            source,
-            worker: {
-              name: worker.name,
-              compatibility: worker.compatibility,
-              main: worker.viteMain,
-              viteEnvironments: worker.viteEnvironments,
-              hasAssets: worker.hasAssets,
-              bindingDescriptors: worker.bindingDescriptors,
-              devRemote: worker.devRemote,
-              durableObjectNamespaces: worker.durableObjectNamespaces,
-              workflows: worker.workflows,
-              hyperdrives: worker.hyperdrives,
-              queueConsumers: yield* getQueueConsumers(worker.name),
-              assets: yield* toRuntimeAssets(worker.assets),
-            },
-          },
-          (channel, line) => {
-            process[channel].write(`${worker.id} | ${line}\n`);
-          },
-        );
-        yield* proxy.set(child.url);
-        yield* child.exitCode.pipe(
-          Effect.flatMap((exitCode) =>
-            Effect.logWarning(
-              `[${worker.id}] Dev server child exited unexpectedly with code ${exitCode}`,
-            ),
-          ),
-          Effect.andThen(proxy.unset().pipe(Effect.ignore)),
-          Effect.andThen(invalidate),
-          Effect.forkScoped,
-        );
+        yield* serveVite({ worker, rootDir, invalidate, source, proxy });
         return proxy.url;
       });
 
@@ -1192,20 +1344,15 @@ const toRuntimeAssets = Effect.fn(function* (
     directory: assets.directory,
     headers: assets.headers ?? files._headers,
     redirects: assets.redirects ?? files._redirects,
-    // Distilled widened generated string enums to open unions (`string & {}`);
-    // the API only ever returns the known variants here.
-    htmlHandling: assets.htmlHandling as
-      | "none"
-      | "auto-trailing-slash"
-      | "force-trailing-slash"
-      | "drop-trailing-slash"
-      | undefined,
-    notFoundHandling: assets.notFoundHandling as
-      | "none"
-      | "404-page"
-      | "single-page-application"
-      | undefined,
-    runWorkerFirst: assets.runWorkerFirst,
+    htmlHandling: assets.htmlHandling,
+    notFoundHandling: assets.notFoundHandling,
+    // The deployed default is assets-first (`run_worker_first` omitted =
+    // false on the cloud API), but the runtime's router inverts it — it
+    // treats anything `!== false` (including `undefined`) as worker-first.
+    // Pin the cloud default explicitly so a Worker with an assets directory
+    // and a `main` serves asset paths from the asset layer locally exactly
+    // like it does deployed.
+    runWorkerFirst: assets.runWorkerFirst ?? false,
     serveDirectly: assets.serveDirectly,
   };
 });

package/src/Cloudflare/Workers/RuntimeBindings.ts

@@ -1,7 +1,7 @@
 import type {
   BindingHook,
   BindingServices,
-} from "@distilled.cloud/cloudflare-runtime";
+} from "@alchemy.run/cloudflare-runtime/core";
 import {
   Ai,
   AiSearch,
@@ -35,14 +35,14 @@ import {
   WasmModule,
   WorkerLoader,
   Workflows,
-} from "@distilled.cloud/cloudflare-runtime/bindings";
+} from "@alchemy.run/cloudflare-runtime/core/bindings";
 import * as Effect from "effect/Effect";
 import * as Redacted from "effect/Redacted";
 import * as Schema from "effect/Schema";
 import { isLocalId } from "../LocalRuntime.ts";
 import type { WorkerBinding } from "./WorkerBinding.ts";
 
-export class WorkerValidationError extends Schema.TaggedErrorClass<WorkerValidationError>()(
+export class WorkerValidationError extends Schema.TaggedError<WorkerValidationError>()(
   "WorkerValidationError",
   {
     message: Schema.String,

package/src/Cloudflare/Workers/Source.ts

@@ -6,7 +6,7 @@ import type {
   DurableObjectNamespace as RuntimeDurableObject,
   QueueConsumer as RuntimeQueueConsumer,
   RuntimeServices,
-} from "@distilled.cloud/cloudflare-runtime";
+} from "@alchemy.run/cloudflare-runtime/core";
 import type * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
@@ -360,7 +360,7 @@ export const resolveSource = (
   }
   if (props.vite) {
     // Loaded lazily: `./Sources/Vite.ts` pulls in
-    // `@distilled.cloud/cloudflare-vite-plugin` (~0.5s), which is only
+    // `@alchemy.run/cloudflare-runtime/vite` (~0.5s), which is only
     // needed for vite-based workers — not for every Worker resolution.
     const vite = props.vite;
     return Effect.promise(() => import("./Sources/Vite.ts")).pipe(

package/src/Cloudflare/Workers/Sources/Rolldown.ts

@@ -61,10 +61,9 @@ export interface WorkerBundleOptions {
  * Rebuild any `builtin:esm-external-require` plugin instance with OUR copy of
  * rolldown.
  *
- * cloudflare-tools is its own bun workspace with its own dependency store, so
- * under bun's `bun` export condition `@distilled.cloud/cloudflare-rolldown-plugin`
+ * A separately installed or bundled `@alchemy.run/cloudflare-runtime/rolldown`
  * can resolve a physically different copy of rolldown than the one Alchemy
- * bundles with. Builtin plugins — here `builtin:esm-external-require`, which
+ * invokes. Builtin plugins — here `builtin:esm-external-require`, which
  * rewrites CJS `require`s of Node builtins into ESM imports under
  * `nodejs_compat` — are `BuiltinPlugin` class instances that rolldown
  * recognizes with an `instanceof` check. An instance constructed by the
@@ -105,7 +104,7 @@ export const WorkerBundle = Effect.gen(function* () {
     const [{ default: cloudflareRolldown }, { esmExternalRequirePlugin }] =
       yield* Effect.promise(() =>
         Promise.all([
-          import("@distilled.cloud/cloudflare-rolldown-plugin"),
+          import("@alchemy.run/cloudflare-runtime/rolldown"),
           import("rolldown/plugins"),
         ]),
       );