alchemy 2.0.0-beta.35 → 2.0.0-beta.37

package/src/Cloudflare/StateStore/Api.ts

@@ -29,7 +29,7 @@ export const STATE_STORE_SCRIPT_NAME = "alchemy-state-store" as const;
  * compare against this constant; a mismatch (or 404) triggers a
  * forced redeploy via the bootstrap flow.
  */
-export const STATE_STORE_VERSION = 3 as const;
+export const STATE_STORE_VERSION = 4 as const;
 
 /**
  * Hard-coded OTLP/HTTP endpoints. Point at the public ingest relay
@@ -245,6 +245,39 @@ export default Worker(
               }),
             ),
         )
+        .handle("getStackOutput", ({ params }) =>
+          store
+            .getByName(params.stack)
+            .getOutput({ stage: params.stage })
+            .pipe(
+              Effect.withSpan("state_store.getStackOutput", {
+                attributes: {
+                  "alchemy.state_store.op": "getStackOutput",
+                  "alchemy.state_store.stack": params.stack,
+                  "alchemy.state_store.stage": params.stage,
+                },
+              }),
+            ),
+        )
+        .handle("setStackOutput", ({ params, payload }) =>
+          store
+            .getByName(params.stack)
+            .setOutput({ stage: params.stage, value: payload as any })
+            .pipe(
+              Effect.tap(() =>
+                store
+                  .getByName(Store.ROOT_DO_NAME)
+                  .registerStack({ stack: params.stack }),
+              ),
+              Effect.withSpan("state_store.setStackOutput", {
+                attributes: {
+                  "alchemy.state_store.op": "setStackOutput",
+                  "alchemy.state_store.stack": params.stack,
+                  "alchemy.state_store.stage": params.stage,
+                },
+              }),
+            ),
+        )
         .handle("deleteStack", ({ params, query }) =>
           store
             .getByName(params.stack)

package/src/Cloudflare/StateStore/Store.ts

@@ -36,7 +36,7 @@ export default class Store extends DurableObjectNamespace<Store>()(
         ),
       ).pipe(Effect.orDie);
 
-      const encryptValue = (value: ResourceState) =>
+      const encryptValue = (value: unknown) =>
         Effect.tryPromise(async () => {
           const plaintext = new TextEncoder().encode(
             JSON.stringify(encodeState(value)),
@@ -188,15 +188,39 @@ export default class Store extends DurableObjectNamespace<Store>()(
         deleteStack: ({ stage }: { stage?: string } = {}) =>
           stage === undefined
             ? storage.deleteAll()
-            : storage
-                .list<string>({ prefix: stagePrefix(stage) })
-                .pipe(
-                  Effect.flatMap((entries) =>
-                    entries.size === 0
-                      ? Effect.void
-                      : storage.delete([...entries.keys()]).pipe(Effect.asVoid),
-                  ),
-                ),
+            : storage.list<string>({ prefix: stagePrefix(stage) }).pipe(
+                Effect.flatMap((entries) => {
+                  const keys = [...entries.keys(), stackOutputKey(stage)];
+                  return storage.delete(keys).pipe(Effect.asVoid);
+                }),
+              ),
+
+        /**
+         * (Stack DO only) Read the persisted stack output for `stage`.
+         * Returns `undefined` when the stage has not been deployed.
+         */
+        getOutput: ({ stage }: { stage: string }) =>
+          storage
+            .get<string>(stackOutputKey(stage))
+            .pipe(
+              Effect.flatMap((entry) =>
+                entry == null ? Effect.succeed(undefined) : decryptEntry(entry),
+              ),
+            ),
+
+        /**
+         * (Stack DO only) Persist the resolved stack output for
+         * `stage`. Returns the stored value unchanged.
+         */
+        setOutput: ({ stage, value }: { stage: string; value: any }) =>
+          encryptValue(value).pipe(
+            Effect.flatMap((encrypted) =>
+              storage
+                .put<string>(stackOutputKey(stage), encrypted)
+                .pipe(Effect.asVoid),
+            ),
+            Effect.map(() => value),
+          ),
 
         /**
          * (Stack DO only) Return every resource in a stage whose
@@ -236,6 +260,9 @@ const SEP = "\x00";
 /** Key prefix for resource entries in a stack DO. */
 const RESOURCE_PREFIX = `r${SEP}`;
 
+/** Key prefix for stack-output entries in a stack DO. */
+const STACK_OUTPUT_PREFIX = `o${SEP}`;
+
 /** Key prefix for stack-index entries in the root DO. */
 const STACK_INDEX_PREFIX = "s:";
 
@@ -249,6 +276,9 @@ const resourceKey = (stage: string, fqn: string) =>
 /** Prefix matching every resource key inside a specific stage. */
 const stagePrefix = (stage: string) => `${RESOURCE_PREFIX}${stage}${SEP}`;
 
+/** Build the stack-output key inside a *stack DO*. */
+const stackOutputKey = (stage: string) => `${STACK_OUTPUT_PREFIX}${stage}`;
+
 /**
  * Parse a resource key back into its (stage, fqn) tuple. Returns
  * undefined for keys that do not match the expected shape.

package/src/Cloudflare/Workers/CronEventSource.ts

@@ -0,0 +1,89 @@
+import type * as cf from "@cloudflare/workers-types";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import type { ResourceLike } from "../../Resource.ts";
+import { RuntimeContext } from "../../RuntimeContext.ts";
+import type { FunctionContext } from "../../Serverless/Function.ts";
+import { isWorker, isWorkerEvent } from "./Worker.ts";
+
+/**
+ * Subscribe to Cloudflare Cron Triggers with an Effect handler.
+ *
+ * This wires both pieces of a scheduled Worker:
+ *
+ * - **Runtime**: registers a `scheduled` listener on the Worker.
+ * - **Deploy-time**: attaches the cron expression to the host Worker.
+ *
+ * @example
+ * ```typescript
+ * yield* Cloudflare.cron("0 12 * * *").subscribe((controller) =>
+ *   Effect.log(`scheduled at ${controller.scheduledTime}`),
+ * );
+ * ```
+ */
+export const cron = (expression: string) => ({
+  subscribe: <Req = never>(
+    process: (
+      controller: cf.ScheduledController,
+    ) => Effect.Effect<void, unknown, Req>,
+  ) => 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>;
+
+export class CronEventSource extends Context.Service<
+  CronEventSource,
+  CronEventSourceService
+>()("Cloudflare.Workers.CronEventSource") {}
+
+export class CronEventSourcePolicy extends Binding.Policy<
+  CronEventSourcePolicy,
+  (expression: string) => Effect.Effect<void>
+>()("Cloudflare.Workers.CronEventSource") {}
+
+export const CronEventSourcePolicyLive = CronEventSourcePolicy.layer.succeed(
+  Effect.fnUntraced(function* (host: ResourceLike, expression: string) {
+    if (isWorker(host)) {
+      yield* host.bind(`Cron(${expression})`, {
+        crons: [expression],
+      });
+    } else {
+      return yield* Effect.die(
+        `Cloudflare.cron(...).subscribe(...) is only supported on ` +
+          `Cloudflare.Worker hosts (got '${host.Type}').`,
+      );
+    }
+  }),
+);
+
+export const CronEventSourceLive = Layer.effect(
+  CronEventSource,
+  Effect.gen(function* () {
+    const policy = yield* CronEventSourcePolicy;
+    return Effect.fn(function* <Req>(
+      expression: string,
+      process: (
+        controller: cf.ScheduledController,
+      ) => Effect.Effect<void, unknown, Req>,
+    ) {
+      yield* policy(expression);
+
+      const ctx = (yield* RuntimeContext) as unknown as FunctionContext;
+      yield* ctx.listen<void, Req>((event) => {
+        if (!isWorkerEvent(event) || event.type !== "scheduled") return;
+
+        const controller = event.input as cf.ScheduledController;
+        if (controller.cron !== expression) return;
+
+        return process(controller).pipe(Effect.catchCause(() => Effect.void));
+      });
+    }) as CronEventSourceService;
+  }),
+);

package/src/Cloudflare/Workers/InferEnv.ts

@@ -1,8 +1,11 @@
 /// <reference types="@cloudflare/workers-types" />
 
 import type * as Effect from "effect/Effect";
+import type * as Stream from "effect/Stream";
+import type { Rpc } from "../../Platform.ts";
 import type { UnwrapEffect } from "../../Util/effect.ts";
 import type * as Cloudflare from "../index.ts";
+import type { RpcErrorEnvelope, RpcStreamEnvelope } from "./Rpc.ts";
 import type { Worker } from "./Worker.ts";
 
 export type InferEnv<W> = W extends
@@ -13,20 +16,95 @@ export type InferEnv<W> = W extends
     }
   : never;
 
-type GetBindingType<T> = T extends Cloudflare.Assets
+/**
+ * Cloudflare service-binding wire shape for an Effect-native Worker.
+ *
+ * Effect/Stream return values are encoded as envelopes on the wire (see
+ * `RpcErrorEnvelope`, `RpcStreamEnvelope`), so the mapped types reflect what
+ * the raw binding actually resolves to. `fetch` is dropped from the user
+ * shape and re-introduced via `Service` so callers get the standard
+ * `(input, init?) => Promise<Response>` signature.
+ *
+ * Use {@link toPromiseApi} to wrap a binding into a Promise<T>-flavored view
+ * where envelopes are decoded for you.
+ */
+export type RpcWireShape<Shape> = {
+  [K in keyof Shape as K extends "fetch" ? never : K]: Shape[K] extends (
+    ...args: infer A
+  ) => Effect.Effect<infer T, any, any>
+    ? (...args: A) => Promise<T | RpcErrorEnvelope>
+    : Shape[K] extends (...args: infer A) => Stream.Stream<any, any, any>
+      ? (...args: A) => Promise<RpcStreamEnvelope | RpcErrorEnvelope>
+      : Shape[K] extends Effect.Effect<infer T, any, any>
+        ? Promise<T | RpcErrorEnvelope>
+        : Shape[K] extends Stream.Stream<any, any, any>
+          ? Promise<RpcStreamEnvelope | RpcErrorEnvelope>
+          : Shape[K] extends (...args: infer A) => infer R
+            ? (...args: A) => Promise<Awaited<R>>
+            : Promise<Shape[K]>;
+};
+
+/**
+ * Recover the user's RPC `Shape` from any of the forms a caller might pass
+ * to {@link toPromiseApi}:
+ *
+ *   - the Worker class value's type, e.g. `typeof Backend`, which extends
+ *     `Effect.Effect<Worker & Rpc<Shape>, …>`
+ *   - the unwrapped `Worker & Rpc<Shape>` type
+ *   - a bare `Shape` (when the caller types it explicitly)
+ */
+export type ExtractRpcShape<W> =
+  W extends Effect.Effect<infer R, any, any>
+    ? R extends Rpc<infer Shape>
+      ? Shape
+      : R
+    : W extends Rpc<infer Shape>
+      ? Shape
+      : W;
+
+/**
+ * Promise-flavored consumer view returned by {@link toPromiseApi}: error
+ * envelopes are thrown as exceptions and stream envelopes are unwrapped to
+ * their raw `ReadableStream<Uint8Array>` body.
+ */
+export type RpcPromiseShape<Shape> = {
+  [K in keyof Shape as K extends "fetch" ? never : K]: Shape[K] extends (
+    ...args: infer A
+  ) => Effect.Effect<infer T, any, any>
+    ? (...args: A) => Promise<T>
+    : Shape[K] extends (...args: infer A) => Stream.Stream<any, any, any>
+      ? (...args: A) => Promise<ReadableStream<Uint8Array>>
+      : Shape[K] extends Effect.Effect<infer T, any, any>
+        ? Promise<T>
+        : Shape[K] extends Stream.Stream<any, any, any>
+          ? Promise<ReadableStream<Uint8Array>>
+          : Shape[K] extends (...args: infer A) => infer R
+            ? (...args: A) => Promise<Awaited<R>>
+            : Promise<Shape[K]>;
+};
+
+export type GetBindingType<T> = T extends Cloudflare.Assets
   ? Service
-  : T extends Cloudflare.D1Database
-    ? D1Database
-    : T extends Cloudflare.R2Bucket
-      ? R2Bucket
-      : T extends Cloudflare.KVNamespace
-        ? KVNamespace
-        : T extends Cloudflare.Queue
-          ? Queue<unknown>
-          : T extends Cloudflare.AiGateway
-            ? Ai
-            : T extends Cloudflare.Artifacts
-              ? Artifacts
-              : T extends Cloudflare.DurableObjectNamespaceLike
-                ? DurableObjectNamespace<Exclude<T["Shape"], undefined>>
-                : never;
+  : T extends Rpc<infer Shape extends object>
+    ? RpcWireShape<Shape> & Service
+    : T extends Cloudflare.D1Database
+      ? D1Database
+      : T extends Cloudflare.R2Bucket
+        ? R2Bucket
+        : T extends Cloudflare.KVNamespace
+          ? KVNamespace
+          : T extends Cloudflare.Queue
+            ? Queue<unknown>
+            : T extends Cloudflare.AiGateway
+              ? Ai
+              : T extends Cloudflare.AnalyticsEngineDataset
+                ? AnalyticsEngineDataset
+                : T extends Cloudflare.Artifacts
+                  ? Artifacts
+                  : T extends Cloudflare.Images
+                    ? ImagesBinding
+                    : T extends Cloudflare.Hyperdrive
+                      ? Hyperdrive
+                      : T extends Cloudflare.DurableObjectNamespaceLike
+                        ? DurableObjectNamespace<Exclude<T["Shape"], undefined>>
+                        : never;

package/src/Cloudflare/Workers/LocalWorkerProvider.ts

@@ -7,7 +7,12 @@ import { Stack } from "../../Stack.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import { Sidecar } from "../Local/Sidecar.ts";
 import { getCompatibility } from "./Compatibility.ts";
-import { Worker, type WorkerBinding, type WorkerProps } from "./Worker.ts";
+import {
+  getCronBindings,
+  Worker,
+  type WorkerBinding,
+  type WorkerProps,
+} from "./Worker.ts";
 import { createWorkerName } from "./WorkerName.ts";
 
 export const LocalWorkerProvider = () =>
@@ -105,6 +110,9 @@ export const LocalWorkerProvider = () =>
           tags: [],
           durableObjectNamespaces,
           domains: [],
+          crons: Array.from(
+            new Set([...getCronBindings(bindings), ...(props.crons ?? [])]),
+          ),
           accountId,
         } satisfies Worker["Attributes"];
       });

package/src/Cloudflare/Workers/Rpc.ts

@@ -8,8 +8,10 @@ import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
 import * as Socket from "effect/unstable/socket/Socket";
 import type { HttpEffect } from "../../Http.ts";
+import { isYieldableEffect } from "../../Util/effect.ts";
 import { fromCloudflareFetcher } from "../Fetcher.ts";
 import { serveWebRequest } from "./HttpServer.ts";
+import type { ExtractRpcShape, RpcPromiseShape } from "./InferEnv.ts";
 import { fromWebSocket } from "./WebSocket.ts";
 
 export const StreamTag = "~alchemy/rpc/stream";
@@ -188,22 +190,122 @@ export const decodeRpcResult = (
   return Effect.succeed(decodeRpcValue(value));
 };
 
-export const makeRpcStub = <Shape>(stub: any): Shape => {
-  const fetcher = fromCloudflareFetcher(stub);
-
-  return new Proxy(fetcher, {
-    get: (target: any, prop) =>
-      prop in target
-        ? target[prop]
-        : (...args: any[]) =>
-            Effect.tryPromise({
-              try: () => stub[prop](...args),
-              catch: (cause) =>
-                new RpcCallError({ method: String(prop), cause }),
-            }).pipe(Effect.flatMap(decodeRpcResult)),
+/**
+ * Wrap a Cloudflare service-binding stub (or an `Effect` that resolves
+ * to one — useful when the stub depends on a service like
+ * `WorkerEnvironment` that's only available at *exec* phase) into an
+ * Effect-typed RPC client.
+ *
+ * `Service.fetch`/`Service.connect` are passed through eagerly when the
+ * stub is already resolved; everything else is treated as an RPC method
+ * whose dispatch is deferred until call time, so the user effect runs in
+ * the right runtime layer (which is what `bindWorker` actually wants —
+ * its methods are called at exec, even though it's *defined* at init).
+ */
+export const makeRpcStub = <Shape>(
+  stubSource: unknown | Effect.Effect<unknown, never, never>,
+): Shape => {
+  const isLazy = isYieldableEffect(stubSource);
+  const eagerFetcher = isLazy
+    ? undefined
+    : fromCloudflareFetcher(stubSource as cf.Fetcher);
+  const proxyTarget: object = eagerFetcher ?? {};
+
+  return new Proxy(proxyTarget, {
+    get: (target: any, prop) => {
+      if (!isLazy && prop in target) return target[prop];
+      if (typeof prop !== "string" && typeof prop !== "symbol") {
+        return target[prop];
+      }
+      return (...args: any[]) =>
+        Effect.gen(function* () {
+          const stub = isLazy
+            ? yield* stubSource as Effect.Effect<any>
+            : stubSource;
+          return yield* Effect.tryPromise({
+            try: () => (stub as any)[prop](...args),
+            catch: (cause) => new RpcCallError({ method: String(prop), cause }),
+          }).pipe(Effect.flatMap(decodeRpcResult));
+        });
+    },
   }) as Shape;
 };
 
+/**
+ * Wrap a raw Cloudflare service binding (the wire-typed view emitted by
+ * `InferEnv`) into a Promise-flavored API for non-Effect consumers.
+ *
+ * Effect-native worker methods serialize their results as envelopes:
+ * `Effect.fail` becomes `RpcErrorEnvelope`, `Stream` becomes
+ * `RpcStreamEnvelope`, and `Effect.succeed`/raw values pass through. This
+ * proxy auto-decodes those envelopes — error envelopes are thrown so the
+ * caller's `await` rejects, and stream envelopes are unwrapped to their raw
+ * `ReadableStream<Uint8Array>` body.
+ *
+ * `Service.fetch` and `Service.connect` pass through untouched, so the
+ * returned proxy is still a usable `Service` binding.
+ *
+ * For Effect-to-Effect cross-worker calls, prefer `bindWorker(Worker)` —
+ * it preserves typed errors and decoded streams.
+ *
+ * The generic parameter is the Worker *class* (or its Effect form), the
+ * same value you would pass to `bindWorker`. Shape is recovered from the
+ * embedded `Rpc<Shape>`.
+ *
+ * @example
+ * ```ts
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ * import Backend from "./backend.ts";
+ *
+ * const backend = Cloudflare.toPromiseApi<typeof Backend>(env.BACKEND);
+ * const greeting = await backend.hello(key); // throws on Effect.fail
+ * ```
+ */
+export const toPromiseApi = <W>(
+  stub: any,
+): RpcPromiseShape<ExtractRpcShape<W>> & Service =>
+  new Proxy(stub, {
+    get: (target, prop) => {
+      // `Service` methods (fetch/connect) and any non-string keys (Symbol.dispose, etc.)
+      // pass through to the underlying Cloudflare binding unchanged.
+      if (typeof prop !== "string" || prop === "fetch" || prop === "connect") {
+        const value = (target as any)[prop];
+        return typeof value === "function" ? value.bind(target) : value;
+      }
+
+      return async (...args: unknown[]) => {
+        const result = await (target as any)[prop](...args);
+        if (isRpcErrorEnvelope(result)) {
+          throw decodeRpcThrowable(result.error);
+        }
+        if (isRpcStreamEnvelope(result)) {
+          return result.body;
+        }
+        return result;
+      };
+    },
+  }) as any;
+
+/**
+ * Reconstruct a throwable from {@link encodeRpcError}'s wire form. Plain
+ * `Error` payloads are rebuilt as `Error` instances so `.message`/`.name`/
+ * `.stack` survive. Tagged errors (anything with a `_tag`) and primitives
+ * are thrown as-is so `try { ... } catch (e) { if (e._tag === ...) }` keeps
+ * working.
+ */
+const decodeRpcThrowable = (error: unknown): unknown => {
+  if (error === null || typeof error !== "object") return error;
+  const obj = error as Record<string, unknown>;
+  if ("_tag" in obj) return obj;
+  if (typeof obj.message === "string" || typeof obj.name === "string") {
+    const e = new Error(typeof obj.message === "string" ? obj.message : "");
+    if (typeof obj.name === "string") e.name = obj.name;
+    if (typeof obj.stack === "string") e.stack = obj.stack;
+    return e;
+  }
+  return error;
+};
+
 /**
  * Create a DurableObjectBridge class that proxies RPC method calls through
  * the Effect runtime, encoding success/fail/stream results as RPC envelopes.
@@ -336,6 +438,109 @@ export const makeDurableObjectBridge =
       }
     };
 
+/**
+ * Create a `WorkerBridge` class — a `WorkerEntrypoint` subclass that
+ * Cloudflare instantiates per request and dispatches both standard
+ * handlers (`fetch`/`scheduled`/…) and RPC method calls into.
+ *
+ * The bridge is intentionally layer-ignorant: all runtime-layer plumbing
+ * (services, scope, `WorkerExecutionContext`) lives in the platform's
+ * `runtimeContext.exports` flow, which builds:
+ *
+ *   - `getDefault()` → `{ fetch, scheduled, … }` — handler dispatchers
+ *     that the bridge forwards `(input, env, ctx)` to.
+ *   - `getRpc()`     → `{ method: (args, ctx) => Promise<envelope> }` —
+ *     pre-wrapped RPC dispatchers that already run the user effect with
+ *     the right runtime layer and envelope-encode the result.
+ *
+ * Cloudflare's script-validate step requires standard handler methods
+ * (`fetch`/`scheduled`/etc.) to be visible on the class prototype. We
+ * declare static stubs there and override them per-instance with
+ * closure-bound forwarders that capture `ctx`/`env` from the constructor
+ * (prototype-level `this` doesn't survive the proxy + RPC dispatch
+ * round-trip in some Cloudflare runtime versions).
+ */
+export const makeWorkerBridge = (
+  WorkerEntrypoint: abstract new (
+    ctx: unknown,
+    env: unknown,
+  ) => { fetch?(request: cf.Request): Promise<cf.Response> | cf.Response },
+  ExportedHandlerMethods: ReadonlyArray<string>,
+  getDefault: () => Promise<Record<string, any>>,
+  getRpc: () => Promise<Record<string, any>>,
+) => {
+  class WorkerBridge extends WorkerEntrypoint {
+    constructor(ctx: unknown, env: unknown) {
+      super(ctx, env);
+
+      // Override handler methods per-instance with closure-bound forwarders.
+      // We read `this.ctx`/`this.env` at *call time* rather than capturing
+      // the constructor args because Cloudflare's runtime appears to
+      // populate those instance fields differently depending on whether
+      // the entrypoint is invoked via direct fetch or RPC — `super(ctx, env)`
+      // alone isn't enough to guarantee they survive into the call.
+      const self = this as unknown as { ctx: unknown; env: unknown };
+      // Cloudflare invokes `WorkerEntrypoint.fetch(request)` with only the
+      // primary input on the *parameter list* — `env`/`ctx` live on `this`
+      // (and the runtime sometimes passes `(request, undefined, undefined)`
+      // anyway for legacy compat). Other handlers, including `scheduled`, may
+      // receive the classic `(input, env, ctx)` arguments. The platform's
+      // underlying handler dispatch (`handle("fetch")`, `handle("scheduled")`,
+      // etc.) follows the plain-export signature `(input, env, context)`, so
+      // prefer explicit handler args when Cloudflare provides them and fall
+      // back to the WorkerEntrypoint instance fields.
+      for (const method of ExportedHandlerMethods) {
+        (this as any)[method] = async (
+          input: unknown,
+          envArg?: unknown,
+          ctxArg?: unknown,
+        ) => {
+          const def = await getDefault();
+          return def?.[method]?.(input, envArg ?? self.env, ctxArg ?? self.ctx);
+        };
+      }
+
+      // RPC method dispatch — anything Cloudflare RPC tries to invoke that
+      // isn't an own property goes through the dispatcher table built by
+      // the platform's exports flow.
+      return new Proxy(this, {
+        get: (target, prop) => {
+          if (typeof prop !== "string") return (target as any)[prop];
+          if (prop in target) return (target as any)[prop];
+          return async (...args: unknown[]) => {
+            const rpc = await getRpc();
+            const dispatcher = rpc?.[prop];
+            if (typeof dispatcher !== "function") {
+              throw new Error(
+                `Method "${prop}" not found on worker. ` +
+                  `Make sure it's returned from the worker's default export.`,
+              );
+            }
+            return dispatcher(args, self.ctx);
+          };
+        },
+      });
+    }
+  }
+
+  // Stub prototype methods so Cloudflare's script-validate detects the
+  // standard handler set; per-instance overrides above are what actually
+  // run.
+  for (const method of ExportedHandlerMethods) {
+    Object.defineProperty(WorkerBridge.prototype, method, {
+      value: function () {
+        throw new Error(
+          `Bridge method '${method}' was called before instance setup`,
+        );
+      },
+      writable: true,
+      configurable: true,
+    });
+  }
+
+  return WorkerBridge;
+};
+
 /**
  * Create a WorkflowBridge class that extends `WorkflowEntrypoint` and
  * delegates the `run(event, step)` call to the Effect-native workflow body
@@ -354,26 +559,30 @@ export const makeWorkflowBridge =
     getExport: (
       name: string,
     ) => Promise<
-      (env: unknown) => Effect.Effect<Effect.Effect<unknown, never, any>>
+      (
+        env: unknown,
+      ) => Effect.Effect<(input: unknown) => Effect.Effect<unknown, never, any>>
     >,
   ) =>
   (className: string) =>
     class WorkflowBridge extends WorkflowEntrypoint {
-      readonly body: Promise<Effect.Effect<unknown, never, any>>;
+      readonly fn: Promise<
+        (input: unknown) => Effect.Effect<unknown, never, any>
+      >;
       readonly env: unknown;
 
       constructor(ctx: unknown, env: unknown) {
         super(ctx, env);
         this.env = env;
-        this.body = getExport(className).then((factory) =>
+        this.fn = getExport(className).then((factory) =>
           Effect.runPromise(factory(env)),
         );
       }
 
       async run(event: any, step: any): Promise<unknown> {
-        const body = await this.body;
+        const fn = await this.fn;
         return Effect.runPromise(
-          body.pipe(
+          fn(event.payload).pipe(
             Effect.provideService(
               WorkflowEventService,
               wrapWorkflowEvent(event),