alchemy 2.0.0-beta.61 → 2.0.0-beta.62

package/src/Cloudflare/Rum/Rule.ts

@@ -274,9 +274,10 @@ export const RuleProvider = () =>
             // visible. Ride out the propagation window with a bounded retry.
             Effect.retry({
               while: (e) => e._tag === "RulesetNotFound",
-              schedule: Schedule.exponential("500 millis").pipe(
-                Schedule.both(Schedule.recurs(8)),
-              ),
+              schedule: Schedule.max([
+                Schedule.exponential("500 millis"),
+                Schedule.recurs(8),
+              ]),
             }),
           );
         const fresh = yield* listRules(accountId, rulesetId);

package/src/Cloudflare/Snippets/Snippet.ts

@@ -256,9 +256,10 @@ export const SnippetProvider = () =>
         .pipe(
           Effect.retry({
             while: (e) => e._tag === "SnippetInUse",
-            schedule: Schedule.exponential("1 second").pipe(
-              Schedule.both(Schedule.recurs(8)),
-            ),
+            schedule: Schedule.max([
+              Schedule.exponential("1 second"),
+              Schedule.recurs(8),
+            ]),
           }),
           Effect.catchTag("SnippetNotFound", () => Effect.void),
         );

package/src/Cloudflare/StateStore/CredentialsFile.ts

@@ -0,0 +1,48 @@
+import type { HttpStateStoreCredentials } from "../../State/HttpStateStore.ts";
+
+/**
+ * Filename (under `~/.alchemy/credentials/{profile}/`) used to cache the
+ * Cloudflare-deployed HTTP state store's endpoint + bearer token.
+ *
+ * Kept in this leaf module (rather than `StateStore/State.ts`) so the
+ * Cloudflare auth provider can invalidate the cache on
+ * `login --configure` / `logout` without importing the heavy state-store
+ * module and creating an import cycle
+ * (`StateStore/State.ts` -> `Providers.ts` -> `Auth/AuthProvider.ts`).
+ */
+export const CREDENTIALS_FILE = "cloudflare-state-store";
+
+/**
+ * On-disk shape of the cached Cloudflare state-store credentials.
+ *
+ * Extends the generic {@link HttpStateStoreCredentials} (`{ url, authToken }`)
+ * with the `accountId` the credentials were minted against. The `url` already
+ * encodes the account (via the `*.workers.dev` subdomain), so a cache written
+ * while logged into account A keeps pointing at account A's state store even
+ * after the user re-authenticates against account B. Persisting `accountId`
+ * lets `state()` detect that mismatch and re-derive.
+ *
+ * `accountId` is optional so legacy files written before this field existed
+ * still parse — they are treated as stale (see
+ * {@link isStateStoreCredentialsStale}) and re-derived on next use.
+ */
+export interface StoredStateStoreCredentials extends HttpStateStoreCredentials {
+  /** Cloudflare account ID the `url`/`authToken` were minted against. */
+  accountId?: string;
+}
+
+/**
+ * `true` when cached state-store credentials must not be trusted for the
+ * current account:
+ *
+ * - the file predates the `accountId` field (legacy cache — exactly the
+ *   artifact that caused deploys to silently target the wrong account), or
+ * - it was minted against a different account than the one now in use.
+ *
+ * A stale cache is discarded and re-derived from the current account.
+ */
+export const isStateStoreCredentialsStale = (
+  credentials: StoredStateStoreCredentials,
+  currentAccountId: string,
+): boolean =>
+  credentials.accountId == null || credentials.accountId !== currentAccountId;

package/src/Cloudflare/StateStore/State.ts

@@ -39,6 +39,11 @@ import * as Access from "../Access.ts";
 import * as CloudflareEnvironment from "../CloudflareEnvironment.ts";
 import { EdgeSessionError, createEdgeSession } from "../EdgeSession.ts";
 import Api, { STATE_STORE_SCRIPT_NAME, STATE_STORE_VERSION } from "./Api.ts";
+import {
+  CREDENTIALS_FILE,
+  type StoredStateStoreCredentials,
+  isStateStoreCredentialsStale,
+} from "./CredentialsFile.ts";
 import {
   AuthToken,
   AuthTokenSecretName,
@@ -48,9 +53,6 @@ import {
 
 const CI = Config.boolean("CI").pipe(Config.withDefault(false));
 
-/** Filename used for stored credentials under the profile directory. */
-const CREDENTIALS_FILE = "cloudflare-state-store";
-
 export const state = () =>
   Layer.effect(
     State,
@@ -173,15 +175,32 @@ export const state = () =>
             return yield* makeCloudflareStateStore(credentials);
           });
 
-        const credentials = yield* credStore.read<HttpStateStoreCredentials>(
+        const { accountId } =
+          yield* yield* CloudflareEnvironment.CloudflareEnvironment;
+
+        const credentials = yield* credStore.read<StoredStateStoreCredentials>(
           profileName,
           CREDENTIALS_FILE,
         );
         if (credentials) {
-          return yield* ensureLatest(credentials);
+          // The cached `url`/`authToken` are minted per-account (the `url`
+          // encodes the account via its workers.dev subdomain). If the
+          // active account changed since they were written — or the file
+          // predates the `accountId` field — trusting the cache would
+          // silently read/write state in the wrong account, so discard it
+          // and fall through to re-derivation from the current account.
+          if (isStateStoreCredentialsStale(credentials, accountId)) {
+            yield* Clank.info(
+              `Cloudflare State Store credentials were minted for a different ` +
+                `Cloudflare account; re-deriving for the current account.`,
+            );
+            yield* credStore
+              .delete(profileName, CREDENTIALS_FILE)
+              .pipe(Effect.ignore);
+          } else {
+            return yield* ensureLatest(credentials);
+          }
         }
-        const { accountId } =
-          yield* yield* CloudflareEnvironment.CloudflareEnvironment;
         if (yield* isStateStoreServing(accountId)) {
           return yield* ensureLatest(
             yield* loginWithCloudflare(profileName, false),
@@ -283,7 +302,7 @@ export const bootstrap = (options: BootstrapOptions = {}) =>
       if (!isCI) {
         // we don't write credentials in CI because the file system is ephemeral
         const store = yield* CredentialsStore;
-        yield* store.write<HttpStateStoreCredentials>(
+        yield* store.write<StoredStateStoreCredentials>(
           profileName,
           CREDENTIALS_FILE,
           credentials,
@@ -667,9 +686,10 @@ const hoistBootstrapStack = Effect.fn(function* ({
               // Secrets Store bindings) can take a while to serve
               // consistently; anything persisting past that is a real
               // failure to surface, not to spin on.
-              schedule: Schedule.fixed(500).pipe(
-                Schedule.both(Schedule.recurs(60)),
-              ),
+              schedule: Schedule.max([
+                Schedule.fixed(500),
+                Schedule.recurs(60),
+              ]),
             }),
           );
       }
@@ -703,11 +723,17 @@ export const loginWithCloudflare = (profileName: string, force: boolean) =>
 
     if (!force) {
       // try and read from the cached credentials first if not forcing (force will always refresh)
-      const credentials = yield* credStore.read<HttpStateStoreCredentials>(
+      const credentials = yield* credStore.read<StoredStateStoreCredentials>(
         profileName,
         CREDENTIALS_FILE,
       );
-      if (credentials) {
+      // Ignore a cache minted for a different account (or a legacy file with
+      // no `accountId`) — reusing it would hand back the wrong account's
+      // state-store URL. Fall through to re-derive against `accountId`.
+      if (
+        credentials &&
+        !isStateStoreCredentialsStale(credentials, accountId)
+      ) {
         return credentials;
       }
     }
@@ -736,10 +762,13 @@ export const loginWithCloudflare = (profileName: string, force: boolean) =>
           isTransientEdgeSessionError(error),
         // Cap the exponential delay at 2s so 15 retries stay within
         // ~30s instead of doubling unboundedly.
-        schedule: Schedule.exponential(200).pipe(
-          Schedule.either(Schedule.spaced("2 seconds")),
-          Schedule.both(Schedule.recurs(15)),
-        ),
+        schedule: Schedule.max([
+          Schedule.min([
+            Schedule.exponential(200),
+            Schedule.spaced("2 seconds"),
+          ]),
+          Schedule.recurs(15),
+        ]),
       }),
     );
 
@@ -751,9 +780,10 @@ export const loginWithCloudflare = (profileName: string, force: boolean) =>
       // 4. Persist credentials. The profile entry is managed by
       //    `loadOrConfigure` when this is invoked through `configure`.
       yield* credStore
-        .write<HttpStateStoreCredentials>(profileName, CREDENTIALS_FILE, {
+        .write<StoredStateStoreCredentials>(profileName, CREDENTIALS_FILE, {
           url,
           authToken: authToken.trim(),
+          accountId,
         })
         .pipe(
           Effect.mapError(
@@ -774,6 +804,7 @@ export const loginWithCloudflare = (profileName: string, force: boolean) =>
     return {
       url,
       authToken: authToken.trim(),
+      accountId,
     };
   }).pipe(
     Effect.catchTag("EdgeSessionError", (e) =>
@@ -871,9 +902,10 @@ const waitForStateStoreVersion = (url: string) =>
       // Edge propagation is usually sub-second but production traces
       // show redeploys occasionally serving the old version for well
       // over 10s. Poll for ~30s before failing loudly.
-      schedule: Schedule.spaced("500 millis").pipe(
-        Schedule.both(Schedule.recurs(60)),
-      ),
+      schedule: Schedule.max([
+        Schedule.spaced("500 millis"),
+        Schedule.recurs(60),
+      ]),
     }),
     Effect.withSpan("state_store.wait_for_version", {
       attributes: {
@@ -911,9 +943,10 @@ const checkStateStoreVersion = (url: string) =>
           : Effect.fail(e),
       ),
       Effect.retry({
-        schedule: Schedule.spaced("250 millis").pipe(
-          Schedule.both(Schedule.recurs(40)),
-        ),
+        schedule: Schedule.max([
+          Schedule.spaced("250 millis"),
+          Schedule.recurs(40),
+        ]),
       }),
       Effect.catch(() => Effect.succeed(undefined)),
     );
@@ -1022,12 +1055,15 @@ const writeCredentials = (url: string, authToken: string) =>
   Effect.gen(function* () {
     const profileName = yield* ALCHEMY_PROFILE;
     const credStore = yield* CredentialsStore;
-    yield* credStore.write<HttpStateStoreCredentials>(
+    const { accountId } =
+      yield* yield* CloudflareEnvironment.CloudflareEnvironment;
+    yield* credStore.write<StoredStateStoreCredentials>(
       profileName,
       CREDENTIALS_FILE,
       {
         url,
         authToken,
+        accountId,
       },
     );
   });

package/src/Cloudflare/Tags/ZoneResourceTags.ts

@@ -21,9 +21,10 @@ type TypeId = typeof TypeId;
 // calls on that typed tag so reconcile waits out the propagation window.
 const targetVisibleRetry = {
   while: (e: { _tag: string }) => e._tag === "ZoneTagResourceNotFound",
-  schedule: Schedule.exponential("500 millis").pipe(
-    Schedule.both(Schedule.recurs(10)),
-  ),
+  schedule: Schedule.max([
+    Schedule.exponential("500 millis"),
+    Schedule.recurs(10),
+  ]),
 } as const;
 
 /**

package/src/Cloudflare/UrlNormalization/UrlNormalization.ts

@@ -155,10 +155,13 @@ export const UrlNormalizationProvider = () =>
             // zone never falls out of the enumeration on a blip.
             Effect.retry({
               while: (e) => e._tag === "Forbidden",
-              schedule: Schedule.exponential("500 millis").pipe(
-                Schedule.either(Schedule.spaced("5 seconds")),
-                Schedule.both(Schedule.recurs(8)),
-              ),
+              schedule: Schedule.max([
+                Schedule.min([
+                  Schedule.exponential("500 millis"),
+                  Schedule.spaced("5 seconds"),
+                ]),
+                Schedule.recurs(8),
+              ]),
             }),
             Effect.map((observed) => toAttributes(zoneId, observed)),
             // Plan-gated or partial zones reject the route; skip them.

package/src/Cloudflare/WaitingRoom/Settings.ts

@@ -116,10 +116,13 @@ export const SettingsProvider = () =>
             // test timeout when a zone is persistently 403.
             Effect.retry({
               while: (e) => e._tag === "Forbidden",
-              schedule: Schedule.exponential("500 millis").pipe(
-                Schedule.either(Schedule.spaced("5 seconds")),
-                Schedule.both(Schedule.recurs(8)),
-              ),
+              schedule: Schedule.max([
+                Schedule.min([
+                  Schedule.exponential("500 millis"),
+                  Schedule.spaced("5 seconds"),
+                ]),
+                Schedule.recurs(8),
+              ]),
             }),
             Effect.map((observed) =>
               toAttributes(

package/src/Cloudflare/Website/Vite.ts

@@ -90,6 +90,25 @@ export interface ViteProps<Bindings extends WorkerBindingProps = {}>
  * });
  * ```
  *
+ * @section Custom Worker Entry
+ * By default the deployed Worker entry is the server bundle the
+ * framework produces. When the Worker must export more than the
+ * framework's fetch handler — Durable Object classes, additional
+ * handlers — point `main` at your own module that wraps the framework
+ * handler and re-exports the extras. `main` takes precedence over any
+ * entry configured in the Vite config.
+ *
+ * @example Custom entry hosting Durable Objects
+ * ```typescript
+ * const app = yield* Cloudflare.Website.Vite("App", {
+ *   main: "worker/index.ts",
+ *   viteEnvironments: {
+ *     entry: "rsc",
+ *     children: ["ssr"],
+ *   },
+ * });
+ * ```
+ *
  * @section Single-Page Applications
  * For SPAs (React, Vue, etc.), configure asset handling so all
  * routes fall back to `index.html`.
@@ -178,6 +197,7 @@ export const Vite: {
             ...props,
             main: undefined!,
             vite: {
+              main: props?.main,
               rootDir: props?.rootDir,
               memo: props?.memo,
               viteEnvironments: props?.viteEnvironments,

package/src/Cloudflare/Workers/Compatibility.ts

@@ -3,10 +3,53 @@ import type { WorkerProps } from "./Worker.ts";
 // TODO: figure out why the later one from workerd breaks
 const DEFAULT_COMPATIBILITY_DATE = "2026-03-17";
 
-export const getCompatibility = (props: WorkerProps) => ({
-  date: props.compatibility?.date ?? DEFAULT_COMPATIBILITY_DATE,
-  flags: [
-    ...(props.compatibility?.flags ?? []),
-    ...(props.isExternal ? [] : ["nodejs_compat"]),
-  ].filter((value, index, self) => self.indexOf(value) === index),
-});
+/**
+ * The Effect worker bridge builds its layer stack once per isolate and shares
+ * the in-flight build promise across concurrent events. Awaiting a promise
+ * created under another event's request context is only sound with workerd's
+ * corrected cross-request promise semantics (default-on since compatibility
+ * date 2024-10-14): continuations are scheduled back into the promise's
+ * origin context instead of running in whichever request happens to resolve
+ * them. A user pinning an older compatibility date must not silently revert
+ * the bridge to the broken semantics, so the flag is forced for
+ * alchemy-bundled workers — and explicitly disabling it is a deploy-time
+ * error.
+ */
+const CROSS_REQUEST_PROMISE_RESOLUTION =
+  "handle_cross_request_promise_resolution";
+
+// The date the flag became default-on. Cloudflare rejects a script that
+// specifies a flag its compatibility date already defaults on ("does not
+// need to be specified anymore"), so it is only appended for older dates.
+const CROSS_REQUEST_PROMISE_RESOLUTION_DEFAULT_ON = "2024-10-14";
+
+export const getCompatibility = (props: WorkerProps) => {
+  const userFlags = props.compatibility?.flags ?? [];
+  if (
+    !props.isExternal &&
+    userFlags.includes(`no_${CROSS_REQUEST_PROMISE_RESOLUTION}`)
+  ) {
+    throw new Error(
+      `The "no_${CROSS_REQUEST_PROMISE_RESOLUTION}" compatibility flag is not supported: ` +
+        "the alchemy Worker runtime shares its layer build across concurrent " +
+        "requests, which requires workerd's corrected cross-request promise " +
+        "semantics. Remove the flag from `compatibility.flags`.",
+    );
+  }
+  const date = props.compatibility?.date ?? DEFAULT_COMPATIBILITY_DATE;
+  return {
+    date,
+    flags: [
+      ...userFlags,
+      ...(props.isExternal
+        ? []
+        : [
+            "nodejs_compat",
+            // ISO dates compare lexically.
+            ...(date < CROSS_REQUEST_PROMISE_RESOLUTION_DEFAULT_ON
+              ? [CROSS_REQUEST_PROMISE_RESOLUTION]
+              : []),
+          ]),
+    ].filter((value, index, self) => self.indexOf(value) === index),
+  };
+};

package/src/Cloudflare/Workers/CronEventSource.ts

@@ -203,14 +203,15 @@ export const cron = <Req = never>(
   process: (
     controller: cf.ScheduledController,
   ) => Effect.Effect<void, unknown, Req>,
-) => CronEventSource.use((source) => source(expression, process));
+): Effect.Effect<void, never, CronEventSource | Exclude<Req, RuntimeContext>> =>
+  CronEventSource.use((source) => source(expression, process));
 
 export type CronEventSourceService = <Req = never>(
   expression: string,
   process: (
     controller: cf.ScheduledController,
   ) => Effect.Effect<void, unknown, Req>,
-) => Effect.Effect<void, never, never>;
+) => Effect.Effect<void, never, Exclude<Req, RuntimeContext>>;
 
 export class CronEventSource extends Context.Service<
   CronEventSource,

package/src/Cloudflare/Workers/DurableObjectBridge.ts

@@ -42,43 +42,44 @@ export const makeDurableObjectBridge =
       };
     },
   ) =>
-  (className: string) =>
-    class DurableObjectBridge extends DurableObject {
+  (className: string) => {
+    // One isolate-lifetime layer build shared by every activation of this DO
+    // class: `build` memoizes the built context, so re-activations (including
+    // hibernatable WebSocket wakes, which re-run the constructor) reuse it
+    // instead of rebuilding the layer stack.
+    const { build } = getWorkerExport<DurableObjectExport>({
+      entrypoint,
+      stack,
+      exportName: className,
+    });
+
+    return class DurableObjectBridge extends DurableObject {
       #state;
-      #globalContext;
-      #exported;
       #instance;
       constructor(state: cf.DurableObjectState, env: any) {
         super(state as any, env);
         this.#state = state;
 
-        const { globalContext, exported } =
-          getWorkerExport<DurableObjectExport>({
-            entrypoint,
-            stack,
-            exportName: className,
-          });
-
-        this.#globalContext = globalContext;
-        this.#exported = exported;
-
         this.#instance = state.blockConcurrencyWhile(() =>
-          this.#exported.pipe(
-            Effect.flatMap(({ constructor, services }) => {
-              const context = Layer.succeed(
+          build((promise) => void (state as any).waitUntil?.(promise)).then(
+            ({ context, export: exported }) => {
+              const { constructor, services } = exported;
+              const doContext = Layer.succeed(
                 DurableObjectState,
                 fromDurableObjectState(this.#state),
-              ).pipe(Layer.provideMerge(Layer.succeedContext(services)));
+              ).pipe(
+                Layer.provideMerge(Layer.succeedContext(services)),
+                Layer.provideMerge(Layer.succeedContext(context)),
+              );
               return constructor.pipe(
-                Effect.provide(context),
+                Effect.provide(doContext),
                 Effect.flatMap((instance) =>
-                  instance.pipe(Effect.provide(context)),
+                  instance.pipe(Effect.provide(doContext)),
                 ),
-                Effect.map((instance) => ({ instance, services })),
+                Effect.map((instance) => ({ instance, services, context })),
+                Effect.runPromise,
               );
-            }),
-            Effect.provide(this.#globalContext),
-            Effect.runPromise,
+            },
           ),
         );
 
@@ -116,11 +117,14 @@ export const makeDurableObjectBridge =
 
       async #execute(
         fn: (instance: DurableObjectShape) => Effect.Effect<any, any, any>,
-        onExit?: (exit: Exit.Exit<any, any>) => Promise<any>,
+        onExit?: (
+          exit: Exit.Exit<any, any>,
+          scope: Scope.Closeable,
+        ) => Promise<any>,
       ) {
         const scope = Scope.makeUnsafe();
 
-        const { instance, services } = await this.#instance;
+        const { instance, services, context } = await this.#instance;
 
         return fn(instance)
           .pipe(
@@ -131,17 +135,17 @@ export const makeDurableObjectBridge =
               ).pipe(
                 Layer.provideMerge(Layer.succeed(Scope.Scope, scope)),
                 Layer.provideMerge(Layer.succeedContext(services)),
-                Layer.provideMerge(this.#globalContext),
+                Layer.provideMerge(Layer.succeedContext(context)),
               ),
             ),
             Effect.runPromiseExit,
           )
-          .then(
-            onExit ??
-              ((exit) =>
-                exit._tag === "Success"
-                  ? Promise.resolve(exit.value)
-                  : Promise.reject(Cause.squash(exit.cause))),
+          .then((exit) =>
+            onExit
+              ? onExit(exit, scope)
+              : exit._tag === "Success"
+                ? Promise.resolve(exit.value)
+                : Promise.reject(Cause.squash(exit.cause)),
           )
           .finally(() =>
             isScopeEjected(scope)
@@ -194,3 +198,4 @@ export const makeDurableObjectBridge =
         );
       }
     } as any;
+  };

package/src/Cloudflare/Workers/HttpServer.ts

@@ -3,7 +3,6 @@ import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
-import * as Scope from "effect/Scope";
 import * as EffectHttp from "effect/unstable/http/HttpEffect";
 import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
 import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
@@ -74,6 +73,4 @@ const toHandledWebResponse = <Req>(
     return yield* Deferred.await(webResponse);
   });
 
-const scopeEjected = Symbol.for("effect/http/HttpEffect/scopeEjected");
-
-export const isScopeEjected = (scope: Scope.Scope) => scopeEjected in scope;
+export { isScopeEjected } from "../../Http.ts";