alchemy 2.0.0-beta.61 → 2.0.0-beta.63

package/src/Cloudflare/Workers/LocalWorkerProvider.ts

@@ -54,13 +54,14 @@ import * as Redacted from "effect/Redacted";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
 import * as Scope from "effect/Scope";
+import * as Semaphore from "effect/Semaphore";
 import * as Stream from "effect/Stream";
 import type * as Bundle from "../../Bundle/Bundle.ts";
 import { isResolved } from "../../Diff.ts";
 import * as RpcProvider from "../../Local/RpcProvider.ts";
 import type { ResourceBinding } from "../../Resource.ts";
 import { Stack } from "../../Stack.ts";
-import { sha256 } from "../../Util/index.ts";
+import { sha256, unwrapRedacted } from "../../Util/index.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import { LOCAL_ENTRY_URL, LocalRuntimeState } from "../LocalRuntime.ts";
 import type { WorkerAssetsConfig, WorkerProps } from "../Workers/Worker.ts";
@@ -199,34 +200,133 @@ export const LocalWorkerProvider = () =>
         return modules;
       });
 
+      // Latest successful serve per worker id, so runtime wiring changes
+      // that arrive AFTER workerd started (e.g. a sibling `Consumer`
+      // resource registering this script as a queue consumer) can restart
+      // the instance with the same bundle. `scope` is the parent scope the
+      // workerd child scope is forked from (the instance scope), NOT the
+      // caller's ambient scope — restarts are triggered from other
+      // providers' reconcile fibers whose scopes must not own workerd.
+      const latestServes = new Map<
+        string,
+        {
+          worker: WorkerConfig;
+          bundle: Bundle.BundleOutput;
+          proxy: WorkerProxy.WorkerProxyInstance;
+          scope: Scope.Scope;
+        }
+      >();
+      // Serializes serves per worker id: a restart triggered by a sibling
+      // resource may otherwise interleave with a rebuild-triggered serve
+      // and leak a workerd scope.
+      const serveLocks = new Map<string, Semaphore.Semaphore>();
+      const serveLock = (id: string) => {
+        let lock = serveLocks.get(id);
+        if (!lock) {
+          lock = Semaphore.makeUnsafe(1);
+          serveLocks.set(id, lock);
+        }
+        return lock;
+      };
+
+      const serveWith = (
+        worker: WorkerConfig,
+        bundle: Bundle.BundleOutput,
+        proxy: WorkerProxy.WorkerProxyInstance,
+        parentScope: Scope.Scope,
+      ) =>
+        Semaphore.withPermits(
+          serveLock(worker.id),
+          1,
+        )(
+          Effect.gen(function* () {
+            const previous = workerdScopes.get(worker.id);
+            if (previous) {
+              // Both runtimes use the same registry key. Close the old scope first so
+              // its unregister finalizer cannot delete the replacement registration.
+              yield* Scope.close(previous, Exit.void);
+              workerdScopes.delete(worker.id);
+            }
+            const scope = yield* Scope.fork(parentScope);
+            const url = yield* runtime
+              .start({
+                name: worker.name,
+                compatibilityDate: worker.compatibility.date,
+                compatibilityFlags: worker.compatibility.flags,
+                bindings: worker.workerBindings as never,
+                hyperdrives: worker.hyperdrives,
+                durableObjectNamespaces: worker.durableObjectNamespaces,
+                queueConsumers: yield* getQueueConsumers(worker.name),
+                modules: yield* toRuntimeModules(bundle),
+                assets: toRuntimeAssets(worker.assets),
+              })
+              .pipe(Scope.provide(scope));
+            workerdScopes.set(worker.id, scope);
+            latestServes.set(worker.id, {
+              worker,
+              bundle,
+              proxy,
+              scope: parentScope,
+            });
+            MutableHashMap.set(
+              localRuntimeState.workerRestarts,
+              worker.name,
+              restartWorker(worker.id),
+            );
+            yield* proxy.set(url);
+            return url;
+          }),
+        );
+
       const serveScoped = Effect.fn(function* (
         worker: WorkerConfig,
         bundle: Bundle.BundleOutput,
         proxy: WorkerProxy.WorkerProxyInstance,
       ) {
-        const scope = yield* Effect.scope.pipe(Effect.flatMap(Scope.fork));
-        const url = yield* runtime
-          .start({
-            name: worker.name,
-            compatibilityDate: worker.compatibility.date,
-            compatibilityFlags: worker.compatibility.flags,
-            bindings: worker.workerBindings as never,
-            hyperdrives: worker.hyperdrives,
-            durableObjectNamespaces: worker.durableObjectNamespaces,
-            queueConsumers: yield* getQueueConsumers(worker.name),
-            modules: yield* toRuntimeModules(bundle),
-            assets: toRuntimeAssets(worker.assets),
-          })
-          .pipe(Scope.provide(scope));
-        const previous = workerdScopes.get(worker.id);
-        if (previous) {
-          yield* Effect.forkDetach(Scope.close(previous, Exit.void));
-        }
-        workerdScopes.set(worker.id, scope);
-        yield* proxy.set(url);
-        return url;
+        const parentScope = yield* Effect.scope;
+        return yield* serveWith(worker, bundle, proxy, parentScope);
       });
 
+      /**
+       * 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.
+       */
+      const restartWorker = (id: string) =>
+        Effect.suspend(() => {
+          const latest = latestServes.get(id);
+          if (!latest) return Effect.void;
+          return serveWith(
+            latest.worker,
+            latest.bundle,
+            latest.proxy,
+            latest.scope,
+          ).pipe(
+            Effect.asVoid,
+            Effect.catchCause((cause) =>
+              Effect.logWarning(
+                `[${id}] Failed to restart local worker`,
+                Cause.squash(cause),
+              ),
+            ),
+          );
+        });
+
+      // Note: `serveLocks` entries are intentionally retained — an
+      // 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);
+        if (latest) {
+          MutableHashMap.remove(
+            localRuntimeState.workerRestarts,
+            latest.worker.name,
+          );
+          latestServes.delete(id);
+        }
+      };
+
       const buildConfig = Effect.fn(function* ({
         id,
         props,
@@ -296,9 +396,7 @@ export const LocalWorkerProvider = () =>
                 port: origin.port,
                 user: origin.user,
                 database: origin.database,
-                password: Redacted.isRedacted(origin.password)
-                  ? Redacted.value(origin.password)
-                  : origin.password,
+                password: unwrapRedacted(origin.password),
                 sslmode: origin.sslmode,
               };
             }
@@ -310,7 +408,10 @@ export const LocalWorkerProvider = () =>
                   `Container ${container.className} has no dev image`,
                 );
               }
-              containers[container.className] = container.dev;
+              containers[container.className] = {
+                ...container.dev,
+                env: unwrapRedacted(container.dev.env),
+              };
             }
           }
         }
@@ -328,6 +429,7 @@ export const LocalWorkerProvider = () =>
           compatibility,
           workerBindings,
           durableObjectNamespaces: Object.values(durableObjectNamespaces),
+          viteMain: props.vite?.main,
           viteEnvironments: props.vite?.viteEnvironments,
           hyperdrives,
           env: props.env,
@@ -418,6 +520,7 @@ export const LocalWorkerProvider = () =>
           rootDir,
           worker.env ?? {},
           {
+            main: worker.viteMain,
             compatibilityDate: worker.compatibility.date,
             compatibilityFlags: worker.compatibility.flags,
             viteEnvironments: worker.viteEnvironments,
@@ -566,6 +669,7 @@ export const LocalWorkerProvider = () =>
               yield* Fiber.interrupt(existing.fiber);
               yield* Scope.close(existing.scope, Exit.void);
               instances.delete(id);
+              dropServeState(id);
             }
             const name = yield* createWorkerName(id, news.name);
             return {
@@ -598,6 +702,7 @@ export const LocalWorkerProvider = () =>
             yield* Fiber.interrupt(existing.fiber);
             yield* Scope.close(existing.scope, Exit.void);
             instances.delete(options.id);
+            dropServeState(options.id);
           }
           const scope = yield* Scope.fork(rootScope);
           const fiber = yield* runInstance(options).pipe(
@@ -621,6 +726,7 @@ export const LocalWorkerProvider = () =>
             yield* Fiber.interrupt(existing.fiber);
             yield* Scope.close(existing.scope, Exit.void);
             instances.delete(id);
+            dropServeState(id);
           }
         }),
       };

package/src/Cloudflare/Workers/ObservabilityDestination.ts

@@ -302,9 +302,10 @@ export const ObservabilityDestinationProvider = () =>
             Effect.retry({
               while: (e) =>
                 e._tag === "ObservabilityDestinationPreflightFailed",
-              schedule: Schedule.exponential("1 second").pipe(
-                Schedule.either(Schedule.spaced("5 seconds")),
-              ),
+              schedule: Schedule.min([
+                Schedule.exponential("1 second"),
+                Schedule.spaced("5 seconds"),
+              ]),
               times: 8,
             }),
           );

package/src/Cloudflare/Workers/Vite.ts

@@ -1,6 +1,7 @@
 import cloudflare, {
   type CloudflareVitePluginOptions,
 } from "@distilled.cloud/cloudflare-vite-plugin";
+import * as ConsoleService from "effect/Console";
 import * as Effect from "effect/Effect";
 import * as Redacted from "effect/Redacted";
 import { createRequire } from "node:module";
@@ -9,6 +10,73 @@ import { pathToFileURL } from "node:url";
 import type * as vite from "vite";
 import { viteBuildOutputPlugin } from "../../Bundle/Vite.ts";
 
+/**
+ * Route Vite's logger through the ambient Effect `Console` service instead of
+ * its default stdout logger. Under the CLI this is the global console
+ * (identical output); under environments that override the Console — e.g.
+ * alchemy-test's per-test buffering console — the build output is captured
+ * with the test instead of leaking to the terminal.
+ */
+const makeViteLogger = (console: ConsoleService.Console): vite.Logger => {
+  const loggedErrors = new WeakSet<object>();
+  let hasWarned = false;
+  return {
+    info: (msg) => console.log(msg),
+    warn: (msg) => {
+      hasWarned = true;
+      console.warn(msg);
+    },
+    warnOnce: (msg) => {
+      hasWarned = true;
+      console.warn(msg);
+    },
+    error: (msg, options) => {
+      if (options?.error != null) loggedErrors.add(options.error);
+      console.error(msg);
+    },
+    clearScreen: () => {},
+    hasErrorLogged: (error) => loggedErrors.has(error),
+    get hasWarned() {
+      return hasWarned;
+    },
+  };
+};
+
+/**
+ * Signals to the app's own Vite config that Alchemy is injecting its
+ * resource-aware Cloudflare plugin into this build/dev run.
+ *
+ * Apps that also build standalone (plain `vite build` in CI, no Alchemy)
+ * need the Cloudflare plugin in their `vite.config.ts`. Without a guard,
+ * an Alchemy-orchestrated run instantiates that config-file instance
+ * *alongside* the injected one: two same-named plugin stacks whose
+ * cross-plugin API lookups resolve by name, and — in dev — two workerd
+ * runtimes, only one of which carries the Worker's bindings. Guarding on
+ * this variable lets the config-file instance stand down:
+ *
+ * ```ts
+ * // vite.config.ts
+ * process.env.ALCHEMY_CLOUDFLARE_VITE_INJECTED === "1"
+ *   ? null
+ *   : cloudflare({ ... })
+ * ```
+ *
+ * The variable is set process-locally by `viteDev`/`viteBuild`, so it is
+ * correct regardless of which process hosts Vite (`alchemy dev` runs the
+ * dev server in the spawned local-provider host, not in the process that
+ * evaluates the user's alchemy.run.ts — an env variable set there never
+ * reaches the config).
+ *
+ * Contract: the value is `"1"` while the process is Alchemy-orchestrated;
+ * absence means not injected. It is deliberately never unset — Vite
+ * re-evaluates the app config on dev-server restarts long after
+ * `viteDev` returned, and concurrent `viteBuild`s in one process would
+ * race a save/restore. A process that ran an Alchemy build never also
+ * runs a standalone (non-Alchemy) Vite build, so the flag staying set is
+ * correct for the process lifetime.
+ */
+const ALCHEMY_CLOUDFLARE_VITE_INJECTED = "ALCHEMY_CLOUDFLARE_VITE_INJECTED";
+
 export const viteDev = (
   rootDir: string = process.cwd(),
   env: Record<string, unknown>,
@@ -16,17 +84,21 @@ export const viteDev = (
   serverOptions: vite.ServerOptions,
 ) =>
   Effect.acquireRelease(
-    Effect.promise(async () => {
-      const vite = await loadVite(rootDir);
-      const devServer = await vite.createServer({
-        root: rootDir,
-        define: getDefine(env),
-        plugins: [cloudflare(pluginOptions)],
-        server: serverOptions,
-      });
-      await devServer.listen();
-      return devServer;
-    }),
+    ConsoleService.consoleWith((console) =>
+      Effect.promise(async () => {
+        process.env[ALCHEMY_CLOUDFLARE_VITE_INJECTED] = "1";
+        const vite = await loadVite(rootDir);
+        const devServer = await vite.createServer({
+          root: rootDir,
+          define: getDefine(env),
+          plugins: [cloudflare(pluginOptions)],
+          server: serverOptions,
+          customLogger: makeViteLogger(console),
+        });
+        await devServer.listen();
+        return devServer;
+      }),
+    ),
     (devServer) =>
       Effect.promise(async () => {
         await devServer.close();
@@ -42,13 +114,23 @@ export const viteBuild = (
     const outputPlugin = yield* viteBuildOutputPlugin({
       entryEnvironment: pluginOptions.viteEnvironments?.entry ?? "ssr",
     });
+    const console = yield* ConsoleService.Console;
     yield* Effect.promise(async () => {
+      process.env[ALCHEMY_CLOUDFLARE_VITE_INJECTED] = "1";
       const vite = await loadVite(rootDir);
       const builder = await vite.createBuilder(
         {
           root: rootDir,
           define: getDefine(env),
           plugins: [cloudflare(pluginOptions), outputPlugin.plugin],
+          customLogger: makeViteLogger(console),
+          // Disables the NATIVE rolldown progress reporter ("transforming…",
+          // "rendering chunks…", "computing gzip size…"): it prints from
+          // Rust straight to fd 1 and cannot be intercepted from JS — vite
+          // only enables it when logLevel >= info. Info-level build
+          // summaries are suppressed with it; warnings and errors still
+          // reach the customLogger above.
+          logLevel: "warn",
         },
         // This is the `useLegacyBuilder` option. The Vite CLI implementation uses `null` here.
         // Originally we used `undefined` here, but this caused the static site build to fail.

package/src/Cloudflare/Workers/Worker.ts

@@ -556,6 +556,23 @@ export interface WorkerProps<
 }
 
 export interface ViteOptions {
+  /**
+   * Overrides the module that becomes the deployed Worker entry, forwarded
+   * to the Cloudflare Vite plugin's `main` option. Relative paths resolve
+   * from the Vite root (`rootDir`).
+   *
+   * By default the entry environment's own entry (the server bundle the
+   * framework produces) is deployed. Point `main` at a custom module when
+   * the deployed Worker must export more than the framework's fetch
+   * handler — e.g. Durable Object classes or additional handlers wrapping
+   * the framework handler.
+   *
+   * @example
+   * ```typescript
+   * vite: { main: "worker/index.ts" }
+   * ```
+   */
+  main?: string;
   /**
    * Root directory passed to Vite's `root` option.
    * Defaults to the current working directory (`process.cwd()`).
@@ -568,7 +585,24 @@ export interface ViteOptions {
    *
    * @see {@link MemoOptions}
    */
-  memo?: MemoOptions;
+  memo?: MemoOptions & {
+    /**
+     * Configure additional workspaces to hash.
+     * By default, auto-detects workspaces during Vite build, then hashes all
+     * non-gitignored files in the workspace plus the nearest lockfile.
+     * @default "auto"
+     */
+    workspaces?:
+      | "auto"
+      | Array<
+          MemoOptions & {
+            /**
+             * The working directory to hash, relative to the Vite root.
+             */
+            cwd: string;
+          }
+        >;
+  };
   /**
    * Selects which Vite environments make up the deployed Worker, for
    * frameworks that build more than one (e.g. React Server Components).
@@ -615,6 +649,7 @@ export type Worker<Bindings extends WorkerBindings = any> = Resource<
       assets: string | undefined;
       bundle: string | undefined;
       input: string | undefined;
+      additionalWorkspaces: string[] | undefined;
       // Hash of the deploy-time metadata surface (compatibility, env,
       // bindings, asset config, limits, observability, ...) so metadata-only
       // edits trigger an update (#745). Optional: state written before this
@@ -949,11 +984,16 @@ export type Worker<Bindings extends WorkerBindings = any> = Resource<
  * closure and used from any handler; its methods are `RuntimeContext`-
  * colored, so they can only run inside a handler.
  *
- * The init closure itself is evaluated per event (its Layer is rebuilt for
- * each event's runtime), so treat it as stateless setup: bind resources and
- * build handlers there, but attach cleanup to handler scopes — a finalizer
- * added in the init closure runs at the end of every event, not once per
- * Worker.
+ * The init closure is evaluated once per isolate: the bridge builds the
+ * Worker's layer stack on the first event and every later event reuses the
+ * built services. Resolve services, bind resources, build handlers there —
+ * one-shot I/O that caches a plain value (e.g. fetching a secret for a
+ * client) is fine, but nothing disposable: the build scope is never closed
+ * (workerd has no isolate-teardown hook), so a finalizer added in the init
+ * closure never runs, and I/O-backed objects (sockets, response bodies) are
+ * pinned to the request that created them. Anything that needs cleanup
+ * belongs in a handler, where `Effect.addFinalizer` attaches to the
+ * per-event scope.
  *
  * @example Post-response cleanup with a scope finalizer
  * ```typescript

package/src/Cloudflare/Workers/WorkerAsyncBindings.ts

@@ -1,4 +1,3 @@
-import type { PutScriptRequest } from "@distilled.cloud/cloudflare/workers";
 import * as Effect from "effect/Effect";
 import * as Redacted from "effect/Redacted";
 import type { InputProps } from "../../Input.ts";
@@ -23,9 +22,13 @@ import { isSecret } from "../SecretsStore/Secret.ts";
 import { isIndex } from "../Vectorize/VectorizeIndex.ts";
 import { isDispatchNamespace } from "../WorkersForPlatforms/DispatchNamespace.ts";
 import { isWorkflowLike, WorkflowResource } from "../Workflows/Workflow.ts";
+import { makeWorkflowName } from "../Workflows/WorkflowName.ts";
 import { isAssets } from "./Assets.ts";
 import { isBrowser } from "./Browser.ts";
-import { isDurableObjectLike } from "./DurableObject.ts";
+import {
+  isDurableObjectLike,
+  normalizeTransferredFrom,
+} from "./DurableObject.ts";
 import { isRateLimit } from "./RateLimit.ts";
 import { isVersionMetadata } from "./VersionMetadata.ts";
 import type { WorkerBindingProps } from "./Worker.ts";
@@ -54,32 +57,42 @@ export const bindWorkerAsyncBindings = Effect.fn(function* (
           : bindingEff
       ) as WorkerBindingResource;
 
-      const bindingMeta: InputProps<WorkerBinding> | undefined = toBinding(
+      let bindingMeta: InputProps<WorkerBinding> | undefined = toBinding(
         bindingName,
         binding,
       );
 
       if (bindingMeta) {
+        let resolvedBindingMeta: InputProps<WorkerBinding> = bindingMeta;
+
+        if (isWorkflowLike(binding)) {
+          const className = binding.className ?? binding.name;
+          const scriptName = binding.scriptName ?? resource.workerName;
+          const workflowName = makeWorkflowName(scriptName, className);
+          resolvedBindingMeta = {
+            ...resolvedBindingMeta,
+            workflowName,
+          };
+
+          // A locally-hosted Workflow (no `scriptName`) must be registered
+          // with Cloudflare via `putWorkflow` once the host Worker exists.
+          // Cross-script references are binding-only; both sides derive the
+          // same physical workflow name from the host script and class.
+          if (!binding.scriptName) {
+            yield* WorkflowResource(binding.name, {
+              workflowName,
+              className,
+              scriptName: resource.workerName,
+            });
+          }
+        }
+
         yield* resource.bind`${bindingName}`({
-          bindings: [bindingMeta],
+          bindings: [resolvedBindingMeta],
           hyperdrives: isHyperdriveConnection(binding)
             ? getHyperdriveDevOrigin(binding)
             : undefined,
         });
-
-        // A locally-hosted Workflow (no `scriptName`) must be registered with
-        // Cloudflare via `putWorkflow` once the host Worker exists. Cross-script
-        // references (with `scriptName`) are reference-only — the host owns the
-        // workflow resource. `scriptName: resource.workerName` makes the
-        // WorkflowResource depend on the Worker so it reconciles afterwards.
-        if (isWorkflowLike(binding) && !binding.scriptName) {
-          const workflowName = binding.workflowName ?? binding.name;
-          yield* WorkflowResource(workflowName, {
-            workflowName,
-            className: binding.className ?? binding.name,
-            scriptName: resource.workerName,
-          });
-        }
       } else {
         return yield* Effect.die(`Unknown binding type: ${bindingName}`);
       }
@@ -87,9 +100,7 @@ export const bindWorkerAsyncBindings = Effect.fn(function* (
   }
 });
 
-type BindingSpec = InputProps<
-  Exclude<PutScriptRequest["metadata"]["bindings"], undefined>[number]
->;
+type BindingSpec = InputProps<WorkerBinding>;
 
 const toBinding = (
   bindingName: string,
@@ -170,6 +181,7 @@ const toBinding = (
       name: bindingName,
       className: binding.className ?? binding.name,
       scriptName: binding.scriptName,
+      transferredFrom: normalizeTransferredFrom(binding.transferredFrom),
     };
   } else if (isWorkflowLike(binding)) {
     return {

package/src/Cloudflare/Workers/WorkerBinding.ts

@@ -31,11 +31,30 @@ import type { VersionMetadataBinding } from "./VersionMetadataBinding.ts";
 import { Worker, WorkerEnvironment } from "./Worker.ts";
 import type { WorkerLoader } from "./WorkerLoader.ts";
 
-export type WorkerBinding = Exclude<
+type DistilledWorkerBinding = Exclude<
   workers.PutScriptRequest["metadata"]["bindings"],
   undefined
 >[number];
 
+/**
+ * The `durable_object_namespace` metadata binding extended with alchemy-only
+ * transfer metadata. `transferredFrom` names the Worker(s) — by logical id in
+ * this stack + stage, or by physical script name — that previously hosted the
+ * class, so the provider can drive Cloudflare's data-preserving
+ * `transferred_classes` migration. It is stripped from the binding before the
+ * script upload — Cloudflare never sees it.
+ */
+export type DurableObjectNamespaceWorkerBinding = Extract<
+  DistilledWorkerBinding,
+  { type: "durable_object_namespace" }
+> & {
+  transferredFrom?: string | string[];
+};
+
+export type WorkerBinding =
+  | Exclude<DistilledWorkerBinding, { type: "durable_object_namespace" }>
+  | DurableObjectNamespaceWorkerBinding;
+
 export type WorkerSettingsBinding = Exclude<
   workers.GetScriptScriptAndVersionSettingResponse["bindings"],
   null | undefined