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

package/src/Cloudflare/Workers/WorkerRuntimeContext.ts

@@ -2,9 +2,12 @@ import type * as cf from "@cloudflare/workers-types";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
-import * as Redacted from "effect/Redacted";
 import type { HttpEffect } from "../../Http.ts";
 import * as Output from "../../Output.ts";
+import {
+  packEnvValueKeepRedacted,
+  unpackEnvValue,
+} from "../../RuntimeContext.ts";
 import type * as Serverless from "../../Serverless/index.ts";
 import type { DurableObjectExport } from "./DurableObject.ts";
 import { makeRequestHandler } from "./HttpServer.ts";
@@ -37,53 +40,19 @@ export const makeWorkerRuntimeContext = (id: string): WorkerRuntimeContext => {
     get: (key: string) =>
       Effect.serviceOption(WorkerEnvironment).pipe(
         Effect.map(Option.getOrUndefined),
-        // Key is already canonical (see RuntimeContext.sanitizeKey).
-        Effect.map((env) => env?.[key]),
-        Effect.map((json) => {
-          if (json === undefined) {
-            return undefined;
-          }
-          try {
-            const value = JSON.parse(json);
-            // The `set` path serializes Redacted values as
-            // `{_tag: "Redacted", value: ...}`. After JSON.parse the
-            // result is a plain object — `Redacted.isRedacted` would
-            // always return `false` on it — so detect the marker shape
-            // and rebuild the Redacted wrapper. Plain values pass
-            // through unchanged.
-            if (
-              typeof value === "object" &&
-              value?._tag === "Redacted" &&
-              "value" in value
-            ) {
-              return Redacted.make((value as { value: unknown }).value);
-            }
-            return value;
-          } catch {
-            return json;
-          }
-        }),
+        // Key is already canonical (see RuntimeContext.sanitizeKey). Read
+        // straight from `WorkerEnvironment` — see `unpackEnvValue` for why
+        // this must never resolve through `Config.string`.
+        Effect.map((env) => unpackEnvValue(env?.[key])),
       ) as any,
     set: (key: string, output: Output.Output) =>
       Effect.sync(() => {
-        // Preserve `Redacted`-ness across the Output → env → Cloudflare
-        // binding boundary so the put-worker loop can deploy secrets via
-        // `secret_text` instead of leaking them as `plain_text`. The JSON
-        // payload still carries the `{_tag: "Redacted", …}` marker so the
-        // runtime `get` accessor can rebuild the wrapper after Cloudflare
-        // hands the binding back as a plain string.
-        env[key] = output.pipe(
-          Output.map((value) =>
-            Redacted.isRedacted(value)
-              ? Redacted.make(
-                  JSON.stringify({
-                    _tag: "Redacted",
-                    value: Redacted.value(value),
-                  }),
-                )
-              : JSON.stringify(value),
-          ),
-        );
+        // `packEnvValueKeepRedacted` keeps the Redacted wrapper on the
+        // outside so the put-worker loop can deploy secrets via
+        // `secret_text` instead of leaking them as `plain_text`, while the
+        // inner marker lets the runtime `get` accessor rebuild the wrapper
+        // after Cloudflare hands the binding back as a plain string.
+        env[key] = output.pipe(Output.map(packEnvValueKeepRedacted));
         return key;
       }),
     serve: <Req = never>(

package/src/Cloudflare/Workers/cloudflare_workers.ts

@@ -1,17 +1,25 @@
 import * as Effect from "effect/Effect";
 
-const cloudflare_workers: Effect.Effect<typeof import("cloudflare:workers")> =
-  /** @__PURE__ #__PURE__ */ Effect.promise(() =>
-    import("cloudflare:workers").catch(
-      () =>
-        ({
-          env: {},
-          DurableObject: class {},
-          WorkflowEntrypoint: class {
-            async run() {}
-          },
-        }) as any,
-    ),
+// Start the import at module evaluation (legal since workerd's 2025-03
+// importable-env change) so the isolate-lifetime layer build that awaits it
+// only ever sees an already-settled promise. This keeps the first event's
+// build free of I/O-backed awaits: everything after this is pure layer
+// assembly plus scheduler microtasks. Outside workerd (deploy/plan in Node,
+// vitest) the import rejects and the fallback stub is used; the `.catch` is
+// attached immediately so the rejection is always handled.
+const modulePromise: Promise<typeof import("cloudflare:workers")> =
+  import("cloudflare:workers").catch(
+    () =>
+      ({
+        env: {},
+        DurableObject: class {},
+        WorkflowEntrypoint: class {
+          async run() {}
+        },
+      }) as any,
   );
 
+const cloudflare_workers: Effect.Effect<typeof import("cloudflare:workers")> =
+  Effect.promise(() => modulePromise);
+
 export default cloudflare_workers;

package/src/Cloudflare/Workers/index.ts

@@ -2,6 +2,7 @@ export * from "./AccountSetting.ts";
 export * from "./Assets.ts";
 export * from "./Browser.ts";
 export * from "./BrowserBinding.ts";
+export * from "./BrowserLocal.ts";
 export * from "./Cache.ts";
 export * from "./ConfigProvider.ts";
 export * from "./CronEventSource.ts";

package/src/Cloudflare/Workflows/Workflow.ts

@@ -2,9 +2,9 @@ import * as workflows from "@distilled.cloud/cloudflare/workflows";
 import type { ConfigError } from "effect/Config";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
+import type { Scope } from "effect/Scope";
 import * as Stream from "effect/Stream";
 import { AlchemyContext } from "../../AlchemyContext.ts";
-import { ExecutionContext } from "../../ExecutionContext.ts";
 import type { Input } from "../../Input.ts";
 import { ALCHEMY_PHASE } from "../../Phase.ts";
 import type { PlatformServices } from "../../Platform.ts";
@@ -18,6 +18,7 @@ import {
   WorkerEnvironment,
   type WorkerServices,
 } from "../Workers/Worker.ts";
+import { makeWorkflowName } from "./WorkflowName.ts";
 
 type TypeId = "Cloudflare.Workflow";
 const TypeId = "Cloudflare.Workflow" as const;
@@ -243,17 +244,17 @@ export const waitForEvent = <T = unknown>(
  * reflect that or `yield* WorkerEnvironment` fails to type-check inside a
  * body even though it succeeds at runtime.
  *
- * `ExecutionContext` (scope + cache) is provided per run-invocation by
- * `WorkflowBridge.run` and threaded into every `task` via the surrounding
- * body context, so `@binding` helpers that need it (e.g. `Drizzle.postgres`)
- * resolve their per-run resources inside workflow steps just as they do in a
- * Worker `fetch`/`queue` handler.
+ * A fresh `Scope` is provided per run-invocation by `WorkflowBridge.run` and
+ * threaded into every `task` via the surrounding body context, so `@binding`
+ * helpers that acquire per-run resources against the ambient scope (e.g.
+ * `Drizzle.postgres`) resolve them inside workflow steps just as they do in
+ * a Worker `fetch`/`queue` handler.
  */
 export type WorkflowRunServices =
   | WorkflowEvent
   | WorkflowStep
   | WorkerServices
-  | ExecutionContext;
+  | Scope;
 
 export type WorkflowServices =
   | WorkflowRunServices
@@ -759,7 +760,6 @@ export const Workflow: WorkflowClass = taggedFunction(WorkflowScope, ((
     return {
       kind: TypeId,
       name,
-      workflowName: name,
       className: props?.className ?? name,
       scriptName: props?.scriptName,
     } satisfies WorkflowLike;
@@ -769,25 +769,27 @@ export const Workflow: WorkflowClass = taggedFunction(WorkflowScope, ((
     Effect.gen(function* () {
       const worker = yield* Worker;
 
+      // Workflow names are account-global, so derive the physical name from
+      // the already-unique host Worker name and exported class name.
+      const workflowName = makeWorkflowName(worker.workerName, name);
+      const workflow = yield* WorkflowResource(name, {
+        workflowName,
+        className: name,
+        scriptName: worker.workerName,
+      });
+
       // Add the workflow binding to the Worker metadata
       yield* worker.bind`${name}`({
         bindings: [
           {
             type: "workflow",
             name,
-            workflowName: name,
+            workflowName: workflow.workflowName,
             className: name,
           },
         ],
       });
 
-      // Create the Workflow API resource (putWorkflow / deleteWorkflow)
-      yield* WorkflowResource(name, {
-        workflowName: name,
-        className: name,
-        scriptName: worker.workerName,
-      });
-
       const services = yield* Effect.context<Effect.Services<typeof impl>>();
 
       const binding = yield* Effect.all([
@@ -854,6 +856,9 @@ export const Workflow: WorkflowClass = taggedFunction(WorkflowScope, ((
 // ---------------------------------------------------------------------------
 
 export interface WorkflowResourceProps {
+  /**
+   * Account-global Workflow name.
+   */
   workflowName: string;
   className: string;
   scriptName: string;
@@ -887,7 +892,7 @@ export const WorkflowProvider = () =>
 
       return WorkflowResource.Provider.of({
         // The `workflowId` is no longer marked as stable because if you start in dev mode, the ID will change on first deploy.
-        stables: ["accountId"],
+        stables: ["accountId", "workflowName"],
         // Workflows are account-scoped. Enumerate every workflow in the account
         // via the paginated list API and hydrate each into the same Attributes
         // shape `reconcile` returns (id/name/className/scriptName are all on the
@@ -918,17 +923,46 @@ export const WorkflowProvider = () =>
             return { action: "update" };
           }
         }),
+        read: Effect.fn(function* ({ output, olds }) {
+          // Dev workflows only exist in local state; there is no account-level
+          // Workflow API resource to observe until the first real deploy.
+          if (ctx.dev) return output;
+
+          const { accountId } = yield* yield* CloudflareEnvironment;
+          const workflowName = output?.workflowName ?? olds?.workflowName;
+          if (workflowName === undefined) return undefined;
+
+          const acct = output?.accountId ?? accountId;
+          return yield* workflows
+            .getWorkflow({
+              accountId: acct,
+              workflowName,
+            })
+            .pipe(
+              Effect.map((workflow) => ({
+                workflowId: workflow.id,
+                workflowName: workflow.name,
+                className: workflow.className,
+                scriptName: workflow.scriptName,
+                accountId: acct,
+              })),
+              Effect.catchTag("WorkflowNotFound", () =>
+                Effect.succeed(undefined),
+              ),
+            );
+        }),
         reconcile: Effect.fn(function* ({ news, output }) {
           const { accountId } = yield* yield* CloudflareEnvironment;
           const acct = output?.accountId ?? accountId;
+          const workflowName = news.workflowName;
           yield* Effect.logInfo(
-            `Cloudflare Workflow reconcile: ${news.workflowName}`,
+            `Cloudflare Workflow reconcile: ${workflowName}`,
           );
           if (ctx.dev) {
             return {
               workflowId: output?.workflowId ?? `dev:${crypto.randomUUID()}`,
               accountId,
-              workflowName: news.workflowName,
+              workflowName,
               className: news.className,
               scriptName: news.scriptName,
             };
@@ -939,7 +973,7 @@ export const WorkflowProvider = () =>
           // — the API is naturally reconciler-shaped.
           const result = yield* workflows.putWorkflow({
             accountId: acct,
-            workflowName: news.workflowName,
+            workflowName,
             className: news.className,
             scriptName: news.scriptName,
           });

package/src/Cloudflare/Workflows/WorkflowBridge.ts

@@ -3,7 +3,6 @@ import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as Layer from "effect/Layer";
 import * as Scope from "effect/Scope";
-import { ExecutionContext } from "../../ExecutionContext.ts";
 import { isScopeEjected } from "../Workers/HttpServer.ts";
 import { getWorkerExport } from "../Workers/WorkerBridge.ts";
 import {
@@ -40,35 +39,34 @@ export const makeWorkflowBridge =
       stack: { name: string; stage: string };
     },
   ) =>
-  (className: string) =>
-    class WorkflowBridge extends WorkflowEntrypoint {
+  (className: string) => {
+    // One isolate-lifetime layer build shared by every instantiation of this
+    // workflow class — `build` memoizes the built context.
+    const { build } = getWorkerExport<WorkflowExport>({
+      entrypoint,
+      stack,
+      exportName: className,
+    });
+
+    return class WorkflowBridge extends WorkflowEntrypoint {
       readonly fn: Promise<WorkflowImpl<unknown, unknown>>;
 
       constructor(ctx: unknown, env: unknown) {
         super(ctx, env);
 
-        const { globalContext, exported } = getWorkerExport<WorkflowExport>({
-          entrypoint,
-          stack,
-          exportName: className,
-        });
-
-        this.fn = exported.pipe(
-          Effect.flatMap((wf) => wf.make(env)),
-          Effect.provide(globalContext),
-          Effect.runPromise,
+        this.fn = build(() => {}).then(({ context, export: wf }) =>
+          wf.make(env).pipe(Effect.provideContext(context), Effect.runPromise),
         ) as Promise<WorkflowImpl<unknown, unknown>>;
       }
 
       async run(event: any, step: any): Promise<unknown> {
         const fn = await this.fn;
-        // Each run-invocation gets a fresh ExecutionContext (scope + cache),
-        // following the same per-invocation-scope pattern as
-        // `WorkerBridge.processEvent`. `task` threads this into every step via
-        // the surrounding body context, so `@binding` helpers that need it
-        // (e.g. `Drizzle.postgres`) resolve their per-run resources inside
-        // workflow steps. The same scope is also provided as the ambient
-        // `Scope` service, matching the Worker and Durable Object bridges.
+        // Each run-invocation gets a fresh `Scope`, following the same
+        // per-invocation-scope pattern as `WorkerBridge.processEvent`. `task`
+        // threads it into every step via the surrounding body context, so
+        // `@binding` helpers that acquire per-run resources against the
+        // ambient scope (e.g. `Drizzle.postgres`) resolve them inside
+        // workflow steps, matching the Worker and Durable Object bridges.
         const scope = Scope.makeUnsafe();
         const exit = await Effect.runPromiseExit(
           fn(event.payload).pipe(
@@ -80,9 +78,6 @@ export const makeWorkflowBridge =
                 Layer.provideMerge(
                   Layer.succeed(WorkflowStep, wrapWorkflowStep(step)),
                 ),
-                Layer.provideMerge(
-                  Layer.succeed(ExecutionContext, { scope, cache: {} }),
-                ),
                 Layer.provideMerge(Layer.succeed(Scope.Scope, scope)),
               ),
             ),
@@ -108,6 +103,7 @@ export const makeWorkflowBridge =
         throw Cause.squash(exit.cause);
       }
     };
+  };
 
 const wrapWorkflowEvent = (event: any): WorkflowEventService["Service"] => ({
   payload: event.payload,

package/src/Cloudflare/Workflows/WorkflowName.ts

@@ -0,0 +1,41 @@
+import * as Effect from "effect/Effect";
+import type { Input } from "../../Input.ts";
+import * as Output from "../../Output.ts";
+import { sha256 } from "../../Util/sha256.ts";
+
+/**
+ * Derive an account-global Workflow name from its unique host Worker name and
+ * exported class. The hash preserves uniqueness when the readable prefix must
+ * be truncated to Cloudflare's 64-character limit.
+ *
+ * @internal
+ */
+export const makeWorkflowName = (
+  scriptName: Input<string>,
+  className: string,
+): Output.Output<string> => {
+  const resolvedScriptName = Effect.isEffect(scriptName)
+    ? scriptName.pipe(Effect.orDie)
+    : scriptName;
+  return Output.asOutput(
+    resolvedScriptName as
+      | string
+      | Output.Output<string>
+      | Effect.Effect<string>,
+  ).pipe(
+    Output.mapEffect((scriptName) => {
+      const base = `${scriptName}-${className}`
+        .toLowerCase()
+        .replaceAll(/[^a-z0-9-]/g, "-");
+      return sha256(base).pipe(
+        Effect.map((hash) => {
+          const suffix = `-${hash.slice(0, 8)}`;
+          // Trim trailing dashes left by mid-name truncation so the result
+          // never contains a `--` seam.
+          const head = base.slice(0, 64 - suffix.length).replace(/-+$/, "");
+          return `${head}${suffix}`;
+        }),
+      );
+    }),
+  );
+};

package/src/Cloudflare/Zone/Hold.ts

@@ -109,10 +109,13 @@ export const isHold = (value: unknown): value is Hold =>
 // Cloudflare can transiently fail to authenticate a valid token, surfacing as
 // `Forbidden`. Retry with exponential backoff capped at 5s, bounded to ~8
 // attempts so a persistently-unauthorized call still fails fast.
-const forbiddenRetrySchedule = Schedule.exponential("500 millis").pipe(
-  Schedule.either(Schedule.spaced("5 seconds")),
-  Schedule.both(Schedule.recurs(8)),
-);
+const forbiddenRetrySchedule = Schedule.max([
+  Schedule.min([
+    Schedule.exponential("500 millis"),
+    Schedule.spaced("5 seconds"),
+  ]),
+  Schedule.recurs(8),
+]);
 
 export const HoldProvider = () =>
   Provider.succeed(Hold, {

package/src/Command/Dev.ts

@@ -22,8 +22,10 @@ export interface Dev extends Resource<
   DevProps,
   {
     /**
-     * URL extracted from the first matching stdout/stderr line. Best-effort:
-     * `undefined` if no URL appears within 5 seconds.
+     * URL extracted from stdout/stderr. A `localhost`/IP URL (the dev
+     * server's own address) is preferred over any other URL the command
+     * prints; a non-local URL is only used as a fallback if no local one
+     * appears. Best-effort: `undefined` if no URL appears within 5 seconds.
      */
     url: string | undefined;
   }
@@ -37,10 +39,11 @@ export interface Dev extends Resource<
  * The child process runs inside the dev sidecar (see `Command/Local.ts`) so it
  * survives user-code HMR — Alchemy's user process can restart without killing
  * your `npm run dev` server. Its stdout/stderr are mirrored to the terminal
- * (preserving colored output) and each line is scanned for the first
- * `http(s)://…` URL, which is exposed as the `url` output attribute — useful
- * for surfacing a dev server's local URL back out to whatever resource
- * declared this `Dev`.
+ * (preserving colored output) and scanned for an `http(s)://…` URL, favoring
+ * a `localhost`/IP URL (the dev server's own address) over any unrelated URL
+ * the command prints first. The result is exposed as the `url` output
+ * attribute — useful for surfacing a dev server's local URL back out to
+ * whatever resource declared this `Dev`.
  *
  * @resource
  *
@@ -119,6 +122,11 @@ export const DevProviderLocal = () =>
         const child = yield* spawn(props);
 
         let buffer = "";
+        // A non-local URL seen so far (docs link, error page, update notice,
+        // …). Held as a fallback so that if the dev server never prints a
+        // localhost/IP URL we still surface something, but a localhost URL
+        // always wins if one shows up. See issue #695.
+        let fallbackUrl: string | undefined;
         const deferred = yield* Deferred.make<string>();
 
         const mirror = (sink: "stdout" | "stderr") =>
@@ -132,8 +140,13 @@ export const DevProviderLocal = () =>
                 if (Deferred.isDoneUnsafe(deferred)) return;
                 buffer += text;
                 const url = extractUrl(buffer);
-                if (url) {
+                if (!url) return;
+                if (isLocalUrl(url)) {
+                  // The dev server's own address — resolve immediately.
                   Deferred.doneUnsafe(deferred, Effect.succeed(url));
+                } else {
+                  // Keep scanning: a localhost/IP URL may still appear.
+                  fallbackUrl = url;
                 }
               }),
             ),
@@ -147,7 +160,9 @@ export const DevProviderLocal = () =>
           Deferred.await(deferred).pipe(
             Effect.timeoutOrElse({
               duration: "5 seconds",
-              orElse: () => Effect.undefined,
+              // No localhost/IP URL appeared in time — fall back to any other
+              // URL we saw (or `undefined` if the process stayed silent).
+              orElse: () => Effect.succeed(fallbackUrl),
             }),
           ),
           child.exitCode.pipe(
@@ -206,6 +221,13 @@ export const DevProviderLocal = () =>
     }),
   );
 
+// Matches an http(s) URL whose host is `localhost`, an IPv4 address, or a
+// bracketed IPv6 address — i.e. the shape a dev server prints for its own
+// local address. Preferred over any other URL a command might print first
+// (docs links, error pages, update notices). See issue #695.
+const LOCAL_URL_REGEX =
+  /https?:\/\/(?:localhost|\[[0-9a-fA-F:]+\]|(?:\d{1,3}\.){3}\d{1,3})(?::\d+)?[^\s)\],"'`]*/;
+
 // Matches the first plain http(s) URL. Stops at whitespace and at a small
 // set of punctuation typically used to wrap URLs in log output.
 const URL_REGEX = /https?:\/\/[^\s)\],"'`]+/;
@@ -215,5 +237,15 @@ const URL_REGEX = /https?:\/\/[^\s)\],"'`]+/;
 // eslint-disable-next-line no-control-regex
 const ANSI_REGEX = /\x1b\[[0-9;]*m/g;
 
-const extractUrl = (text: string) =>
-  text.replaceAll(ANSI_REGEX, "").match(URL_REGEX)?.[0];
+/**
+ * Extract a URL from `text`, favoring a localhost/IP URL (the dev server's
+ * own address) over any other URL. Returns the first localhost/IP URL if one
+ * is present, otherwise the first plain http(s) URL, otherwise `undefined`.
+ * @internal
+ */
+export const extractUrl = (text: string) => {
+  const clean = text.replaceAll(ANSI_REGEX, "");
+  return clean.match(LOCAL_URL_REGEX)?.[0] ?? clean.match(URL_REGEX)?.[0];
+};
+
+const isLocalUrl = (url: string) => LOCAL_URL_REGEX.test(url);

package/src/Diff.ts

@@ -1,3 +1,4 @@
+import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as Redacted from "effect/Redacted";
 import type { Input } from "./Input.ts";
@@ -53,6 +54,38 @@ const _hasUnresolved = (value: unknown): boolean => {
   return false;
 };
 
+/**
+ * Deeply replace every unresolved plan-time expression (an `Output`/`Expr`
+ * or an un-evaluated `Effect`) with `undefined`, leaving resolved values
+ * (including opaque `Redacted`/`Duration` instances) intact.
+ *
+ * Persisted resource state must only ever hold plain data. Durable (JSON)
+ * state stores already enforce this implicitly — Output proxies are
+ * function-typed, so `JSON.stringify` silently drops them — but the
+ * in-memory store used by tests retains live proxies, which would later be
+ * fed back into provider lifecycle operations as `olds` after an
+ * interrupted apply (e.g. `read` during a destroy plan) and blow up on
+ * first string coercion. Sanitizing at the commit boundary keeps both
+ * store kinds consistent with the provider contract that `olds` is
+ * resolved `Props`.
+ */
+export const stripUnresolved = <T>(value: T): T => _stripUnresolved(value) as T;
+
+const _stripUnresolved = (value: unknown): unknown => {
+  if (value == null || isPrimitive(value)) return value;
+  if (Output.isExpr(value) || Effect.isEffect(value)) return undefined;
+  // Opaque resolved values — rebuilding them structurally would strip
+  // their prototype (see resolveInput in Plan.ts for the same rule).
+  if (Redacted.isRedacted(value) || Duration.isDuration(value)) return value;
+  if (Array.isArray(value)) return value.map(_stripUnresolved);
+  if (typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [key, _stripUnresolved(item)]),
+    );
+  }
+  return value;
+};
+
 export const somePropsAreDifferent = <Props extends Record<string, any>>(
   olds: Props,
   news: Props,

package/src/Docker/Container.ts

@@ -418,5 +418,8 @@ const normalizeDuration = (
 ): string | undefined => {
   if (!input) return undefined;
   const duration = Duration.fromInputUnsafe(input);
-  return Duration.toNanosUnsafe(duration).toString();
+  // Docker parses `--health-*` durations with Go's `time.ParseDuration`, which
+  // requires a unit suffix — a bare nanosecond count is rejected with "missing
+  // unit in duration". `ns` is the lossless Go-duration rendering of the nanos.
+  return `${Duration.toNanosUnsafe(duration).toString()}ns`;
 };