alchemy 2.0.0-beta.60 → 2.0.0-beta.62

package/src/Cloudflare/Workers/WorkerRuntimeContext.ts

@@ -11,7 +11,9 @@ import { makeRequestHandler } from "./HttpServer.ts";
 import {
   ExportedHandlerMethods,
   WorkerEnvironment,
+  WorkerExecutionContext,
   WorkerTypeId,
+  deferredExecutionContext,
   type WorkerEvent,
 } from "./Worker.ts";
 import type { WorkflowExport } from "../Workflows/Workflow.ts";
@@ -108,7 +110,13 @@ export const makeWorkerRuntimeContext = (id: string): WorkerRuntimeContext => {
       Effect.sync(() => {
         exports[name] = value;
       }),
-    planServices: Layer.succeed(WorkerEnvironment, {}),
+    planServices: Layer.mergeAll(
+      Layer.succeed(WorkerEnvironment, {}),
+      // Lets the init closure `yield*` WorkerExecutionContext during plan;
+      // its RuntimeContext-colored methods can't run until a real handler
+      // provides the live per-event context.
+      Layer.succeed(WorkerExecutionContext, deferredExecutionContext),
+    ),
     exports: Effect.gen(function* () {
       const handlers = yield* Effect.all(listeners, {
         concurrency: "unbounded",
@@ -125,12 +133,25 @@ export const makeWorkerRuntimeContext = (id: string): WorkerRuntimeContext => {
             env,
             context,
           };
+          const effects: Effect.Effect<unknown>[] = [];
           for (const handler of handlers) {
             const eff = handler(event);
             if (Effect.isEffect(eff)) {
-              return [eff, services];
+              effects.push(eff);
             }
           }
+          if (effects.length === 1) {
+            return [effects[0], services];
+          }
+          if (effects.length > 1) {
+            return [
+              Effect.all(effects, {
+                concurrency: "unbounded",
+                discard: true,
+              }),
+              services,
+            ];
+          }
           return [
             Effect.die(
               new Error(`No event handler found for event type '${type}'`),

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 "./Cache.ts";
 export * from "./ConfigProvider.ts";
 export * from "./CronEventSource.ts";
 export * from "./DurableObject.ts";

package/src/Cloudflare/WorkersForPlatforms/DispatchNamespace.ts

@@ -1,12 +1,11 @@
 import * as wfp from "@distilled.cloud/cloudflare/workers-for-platforms";
 import * as Effect from "effect/Effect";
-import * as Predicate from "effect/Predicate";
 import * as Stream from "effect/Stream";
 
 import { isResolved } from "../../Diff.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
 import * as Provider from "../../Provider.ts";
-import { Resource } from "../../Resource.ts";
+import { isResourceOfType, Resource } from "../../Resource.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import type { Providers } from "../Providers.ts";
 
@@ -152,8 +151,7 @@ export const DispatchNamespace = Resource<DispatchNamespace>(TypeId);
  */
 export const isDispatchNamespace = (
   value: unknown,
-): value is DispatchNamespace =>
-  Predicate.hasProperty(value, "Type") && value.Type === TypeId;
+): value is DispatchNamespace => isResourceOfType(value, TypeId);
 
 export const DispatchNamespaceProvider = () =>
   Provider.succeed(DispatchNamespace, {