alchemy 2.0.0-beta.40 → 2.0.0-beta.41

package/src/Cloudflare/Workers/WorkerAsyncBindings.ts

@@ -0,0 +1,149 @@
+import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+import type { InputProps } from "../../Input.ts";
+import * as Output from "../../Output.ts";
+import type { ResourceBinding } from "../../Resource.ts";
+import { isYieldableEffectLike } from "../../Util/effect.ts";
+import { isAnalyticsEngineDataset } from "../AnalyticsEngine/AnalyticsEngineDataset.ts";
+import { isArtifacts } from "../Artifacts/Artifacts.ts";
+import { isSendEmail } from "../Email/SendEmail.ts";
+import { isImages } from "../Images/Images.ts";
+import { isAssets } from "./Assets.ts";
+import { isDurableObjectNamespaceLike } from "./DurableObjectNamespace.ts";
+import type { WorkerBindingProps } from "./Worker.ts";
+import { isWorker, type Worker, type WorkerProps } from "./Worker.ts";
+import type { WorkerBinding, WorkerBindingResource } from "./WorkerBinding.ts";
+
+export const bindWorkerAsyncBindings = Effect.fnUntraced(function* (
+  resource: Worker,
+  props: InputProps<WorkerProps<WorkerBindingProps>>,
+) {
+  if (props.bindings) {
+    for (const bindingName in props.bindings) {
+      // @ts-expect-error
+      const bindingEff = props.bindings?.[bindingName] as
+        | WorkerBindingResource
+        | Effect.Effect<WorkerBindingResource>;
+      // Bindings can be passed as a plain resource value, an Effect that
+      // yields a resource, or an effect-class (e.g. a `Cloudflare.Worker`
+      // class). Resolve the yieldable forms before deriving binding metadata.
+      const binding = isYieldableEffectLike(bindingEff)
+        ? ((yield* bindingEff as Effect.Effect<unknown>) as WorkerBindingResource)
+        : bindingEff;
+
+      const bindingMeta: InputProps<WorkerBinding> | undefined =
+        typeof binding === "string"
+          ? {
+              type: "plain_text",
+              name: bindingName,
+              value: binding,
+            }
+          : Redacted.isRedacted(binding)
+            ? {
+                type: "secret_text",
+                name: bindingName,
+                value: Redacted.value(binding),
+              }
+            : isAssets(binding)
+              ? {
+                  type: "assets",
+                  name: bindingName,
+                }
+              : isArtifacts(binding)
+                ? ({
+                    type: "artifacts",
+                    name: bindingName,
+                    namespace: binding.namespace,
+                  } as any)
+                : isImages(binding)
+                  ? {
+                      type: "images",
+                      name: bindingName,
+                    }
+                  : isAnalyticsEngineDataset(binding)
+                    ? {
+                        type: "analytics_engine",
+                        name: bindingName,
+                        dataset: binding.dataset,
+                      }
+                    : isSendEmail(binding)
+                      ? {
+                          type: "send_email",
+                          name: bindingName,
+                          destinationAddress: binding.destinationAddress,
+                          allowedDestinationAddresses:
+                            binding.allowedDestinationAddresses,
+                          allowedSenderAddresses:
+                            binding.allowedSenderAddresses,
+                        }
+                      : isDurableObjectNamespaceLike(binding)
+                        ? {
+                            type: "durable_object_namespace",
+                            name: bindingName,
+                            className: binding.className ?? binding.name,
+                          }
+                        : binding.Type === "Cloudflare.D1Database"
+                          ? {
+                              type: "d1",
+                              id: binding.databaseId,
+                              name: bindingName,
+                            }
+                          : binding.Type === "Cloudflare.R2Bucket"
+                            ? {
+                                type: "r2_bucket",
+                                name: bindingName,
+                                bucketName: binding.bucketName,
+                                jurisdiction: binding.jurisdiction.pipe(
+                                  Output.map((jurisdiction) =>
+                                    jurisdiction === "default"
+                                      ? undefined
+                                      : jurisdiction,
+                                  ),
+                                ),
+                              }
+                            : binding.Type === "Cloudflare.KVNamespace"
+                              ? {
+                                  type: "kv_namespace",
+                                  name: bindingName,
+                                  namespaceId: binding.namespaceId,
+                                }
+                              : binding.Type === "Cloudflare.Queue"
+                                ? {
+                                    type: "queue",
+                                    name: bindingName,
+                                    queueName: binding.queueName,
+                                  }
+                                : binding.Type === "Cloudflare.AiGateway"
+                                  ? {
+                                      type: "ai",
+                                      name: bindingName,
+                                    }
+                                  : binding.Type === "Cloudflare.Hyperdrive"
+                                    ? {
+                                        type: "hyperdrive",
+                                        name: bindingName,
+                                        id: binding.hyperdriveId,
+                                      }
+                                    : isWorker(binding)
+                                      ? {
+                                          type: "service",
+                                          name: bindingName,
+                                          service: binding.workerName,
+                                        }
+                                      : // TODO(sam): handle others
+                                        undefined;
+
+      if (bindingMeta) {
+        yield* resource.bind`${bindingName}`({
+          bindings: [bindingMeta],
+        });
+      } else {
+        return yield* Effect.die(`Unknown binding type: ${bindingName}`);
+      }
+    }
+  }
+});
+
+export const getCronBindings = (
+  bindings: ReadonlyArray<ResourceBinding<Worker["Binding"]>>,
+) => Array.from(new Set(bindings.flatMap((b) => b.data.crons ?? [])));

package/src/Cloudflare/Workers/WorkerBinding.ts

@@ -0,0 +1,103 @@
+import type * as workers from "@distilled.cloud/cloudflare/workers";
+import * as Effect from "effect/Effect";
+import * as Binding from "../../Binding.ts";
+import type { Rpc } from "../../Rpc.ts";
+import { isYieldableEffectLike } from "../../Util/effect.ts";
+import type { AiGateway } from "../AiGateway/AiGateway.ts";
+import { AnalyticsEngineDataset } from "../AnalyticsEngine/AnalyticsEngineDataset.ts";
+import { Artifacts } from "../Artifacts/Artifacts.ts";
+import type { D1Database } from "../D1/D1Database.ts";
+import { SendEmail } from "../Email/SendEmail.ts";
+import { Hyperdrive } from "../Hyperdrive/Hyperdrive.ts";
+import { Images } from "../Images/Images.ts";
+import type { KVNamespace } from "../KV/KVNamespace.ts";
+import type { Queue } from "../Queue/Queue.ts";
+import type { R2Bucket } from "../R2/R2Bucket.ts";
+import type { Assets } from "./Assets.ts";
+import type { DurableObjectNamespaceLike } from "./DurableObjectNamespace.ts";
+import { makeRpcStub } from "./Rpc.ts";
+import { isWorker, Worker, WorkerEnvironment } from "./Worker.ts";
+
+export type WorkerBinding = Exclude<
+  workers.PutScriptRequest["metadata"]["bindings"],
+  undefined
+>[number];
+
+export type WorkerSettingsBinding = Exclude<
+  workers.GetScriptScriptAndVersionSettingResponse["bindings"],
+  null | undefined
+>[number];
+
+export type WorkerBindingResource =
+  | Assets
+  | R2Bucket
+  | D1Database
+  | KVNamespace
+  | Queue
+  | AiGateway
+  | AnalyticsEngineDataset
+  | SendEmail
+  | Artifacts
+  | Images
+  | Hyperdrive
+  | Worker
+  | DurableObjectNamespaceLike<any>;
+
+export type WorkerBindings = {
+  [bindingName in string]: WorkerBindingResource;
+};
+
+export const bindWorker = Effect.fnUntraced(function* <Shape, Req = never>(
+  workerEff:
+    | (Worker & Rpc<Shape>)
+    | Effect.Effect<Worker & Rpc<Shape>, never, Req>,
+) {
+  // Worker classes and regular Effects are both yieldable here.
+  const worker = isYieldableEffectLike(workerEff)
+    ? yield* workerEff as Effect.Effect<Worker & Rpc<Shape>, never, Req>
+    : workerEff;
+  const self = yield* Worker;
+  yield* self.bind`${worker}`({
+    bindings: [
+      {
+        type: "service",
+        name: worker.LogicalId,
+        service: worker.workerName,
+      },
+    ],
+  });
+
+  // `bindWorker` runs at *init* phase (both at plantime and at runtime
+  // cold-start). `WorkerEnvironment` only exists at exec phase on the
+  // deployed worker, so we hand `makeRpcStub` an `Effect<stub>` that
+  // resolves the binding lazily on each method call.
+  const stubEff = WorkerEnvironment.pipe(
+    Effect.map((env) => (env as Record<string, unknown>)[worker.LogicalId]),
+  );
+  return makeRpcStub<Shape>(stubEff);
+});
+
+export class BindWorkerPolicy extends Binding.Policy<
+  BindWorkerPolicy,
+  (worker: Worker) => Effect.Effect<void>
+>()("Cloudflare.Worker.Bind") {}
+
+export const BindWorkerPolicyLive = BindWorkerPolicy.layer.succeed(
+  Effect.fn(function* (host, worker: Worker) {
+    if (isWorker(host)) {
+      yield* host.bind`${worker}`({
+        bindings: [
+          {
+            type: "service",
+            name: worker.LogicalId,
+            service: worker.workerName,
+          },
+        ],
+      });
+    } else {
+      return yield* Effect.die(
+        new Error(`BindWorkerPolicy does not support runtime '${host.Type}'`),
+      );
+    }
+  }),
+);

package/src/Cloudflare/Workers/WorkerBridge.ts

@@ -0,0 +1,304 @@
+import type * as cf from "@cloudflare/workers-types";
+import { NodeServices } from "@effect/platform-node";
+import type { DurableObject, WorkerEntrypoint } from "cloudflare:workers";
+import { Stream } from "effect";
+import * as Cause from "effect/Cause";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import { pipe } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
+import { MinimumLogLevel } from "effect/References";
+import * as Scope from "effect/Scope";
+import { FetchHttpClient } from "effect/unstable/http";
+import { ExecutionContext } from "../../ExecutionContext.ts";
+import { makeEntrypointLayer } from "../../Runtime.ts";
+import { Self } from "../../Self.ts";
+import { Stack } from "../../Stack.ts";
+import {
+  ErrorTag,
+  type RpcErrorEnvelope,
+  type RpcStreamEnvelope,
+  encodeRpcError,
+  toRpcStream,
+} from "./Rpc.ts";
+import {
+  ExportedHandlerMethods,
+  Worker,
+  WorkerEnvironment,
+  WorkerExecutionContext,
+} from "./Worker.ts";
+import type { WorkerRuntimeContext } from "./WorkerRuntimeContext.ts";
+import cloudflare_workers from "./cloudflare_workers.ts";
+
+/**
+ * Makes the WorkerEntrypoint class and bridges to Effect fetch and RPC calls.
+ */
+export const makeWorkerBridge = (
+  Base: typeof WorkerEntrypoint | typeof DurableObject,
+  {
+    stack,
+    entrypoint,
+  }: {
+    stack: {
+      name: string;
+      stage: string;
+    };
+    entrypoint: any;
+  },
+) => {
+  const { globalContext, exported, shape } = getWorkerExport({
+    entrypoint,
+    stack,
+    exportName: "default",
+  });
+
+  const processEvent = (
+    eff: Effect.Effect<
+      readonly [Effect.Effect<any, any, any>, Context.Context<never>],
+      any,
+      any
+    >,
+    ctx: cf.ExecutionContext,
+  ) => {
+    const scope = Scope.makeUnsafe();
+    return eff
+      .pipe(
+        Effect.flatMap(([eff, context]) =>
+          Effect.provide(
+            eff,
+            pipe(
+              Layer.succeedContext(context),
+              Layer.provideMerge(Layer.succeedContext(context)),
+              Layer.provideMerge(Layer.succeed(WorkerExecutionContext, ctx)),
+              Layer.provideMerge(
+                Layer.succeed(ExecutionContext, {
+                  scope,
+                  cache: {},
+                }),
+              ),
+            ),
+          ),
+        ),
+        Effect.provide(
+          Layer.provideMerge(globalContext, Layer.succeed(Scope.Scope, scope)),
+        ),
+        Effect.runPromiseExit,
+      )
+      .finally(() =>
+        Scope.close(scope, Exit.void).pipe(Effect.runPromise, (promise) =>
+          ctx.waitUntil(promise),
+        ),
+      );
+  };
+  class WorkerBridge extends Base {
+    constructor(
+      public readonly ctx: any,
+      public readonly env: any,
+    ) {
+      super(ctx, env);
+
+      for (const methodName of ExportedHandlerMethods) {
+        (this as any)[methodName] = async (input: any) =>
+          exported
+            .pipe(
+              Effect.map((_default) => _default[methodName]),
+              Effect.map(
+                (f) =>
+                  f(input, this.env, this.ctx) as [
+                    Effect.Effect<any>,
+                    Context.Context<never>,
+                  ],
+              ),
+              (eff) => processEvent(eff, this.ctx),
+            )
+            .then((exit) =>
+              exit._tag === "Success"
+                ? Promise.resolve(exit.value)
+                : Promise.reject(Cause.squash(exit.cause)),
+            );
+      }
+
+      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 (...args: unknown[]) =>
+            shape
+              .pipe(
+                Effect.map((shape: any) => shape[prop]),
+                Effect.flatMap((dispatcher) => {
+                  if (typeof dispatcher !== "function") {
+                    return Effect.die(
+                      new Error(
+                        `Method "${prop}" not found on worker. ` +
+                          `Make sure it's returned from the worker's default export.`,
+                      ),
+                    );
+                  }
+                  console.log("dispatcher", dispatcher.toString());
+                  return Effect.succeed([
+                    dispatcher(...args) as Effect.Effect<any>,
+                    Context.empty(),
+                  ] as const);
+                }),
+                (eff) => processEvent(eff, this.ctx),
+              )
+              .then(handleRpcExit);
+        },
+      });
+    }
+  }
+
+  // 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;
+};
+
+export const getWorkerExport = <Export = any>({
+  entrypoint,
+  stack,
+  exportName,
+}: {
+  entrypoint: any;
+  stack: { name: string; stage: string };
+  exportName: string;
+}) => {
+  const tag = Self as any as Context.Service<
+    never,
+    Worker & {
+      RuntimeContext: WorkerRuntimeContext;
+    }
+  >;
+
+  const runtimeContext = tag.pipe(Effect.map((func) => func.RuntimeContext));
+  const shape = runtimeContext.pipe(Effect.map((context) => context.shape()));
+  const exported = runtimeContext.pipe(
+    Effect.flatMap((context) => context.exports),
+    Effect.flatMap((exports) =>
+      Effect.isEffect(exports[exportName])
+        ? exports[exportName]
+        : Effect.succeed(exports[exportName]),
+    ),
+  ) as Effect.Effect<Export>;
+
+  const layer = makeEntrypointLayer(tag, entrypoint);
+
+  const platform = Layer.mergeAll(
+    NodeServices.layer,
+    FetchHttpClient.layer,
+    // TODO(sam): wire this up to telemetry more directly
+    Logger.layer([Logger.consolePretty()]),
+  );
+
+  const globalContext = Layer.unwrap(
+    cloudflare_workers.pipe(
+      Effect.map(({ env }) =>
+        layer.pipe(
+          Layer.provideMerge(
+            Layer.succeed(Stack, {
+              name: stack.name,
+              stage: stack.stage,
+              bindings: {},
+              resources: {},
+              actions: {},
+            }),
+          ),
+          Layer.provideMerge(platform),
+          Layer.provideMerge(
+            Layer.succeed(
+              ConfigProvider.ConfigProvider,
+              ConfigProvider.orElse(
+                ConfigProvider.fromUnknown({ ALCHEMY_PHASE: "runtime" }),
+                ConfigProvider.fromUnknown(env),
+              ),
+            ),
+          ),
+          Layer.provideMerge(Layer.succeed(WorkerEnvironment, env)),
+          Layer.provideMerge(
+            Layer.succeed(
+              MinimumLogLevel,
+              (env as any).DEBUG ? "Debug" : "Info",
+            ),
+          ),
+        ),
+      ),
+    ),
+  );
+
+  return {
+    globalContext,
+    exported,
+    shape,
+  };
+};
+
+export const makeRpcProxy = (
+  self: any,
+  userShape: Effect.Effect<any>,
+  processEvent: (
+    eff: Effect.Effect<[Effect.Effect<any>, Context.Context<never>]>,
+  ) => Promise<any>,
+) =>
+  new Proxy(self, {
+    get: (target, prop) => {
+      if (typeof prop !== "string") return (target as any)[prop];
+      if (prop in target) return (target as any)[prop];
+      return (...args: unknown[]) =>
+        userShape
+          .pipe(
+            Effect.map((shape) => shape[prop]),
+            Effect.flatMap((dispatcher) => {
+              if (typeof dispatcher !== "function") {
+                return Effect.die(
+                  new Error(
+                    `Method "${prop}" not found on worker. ` +
+                      `Make sure it's returned from the worker's default export.`,
+                  ),
+                );
+              }
+              console.log("dispatcher", dispatcher.toString());
+              return dispatcher(...args) as Effect.Effect<any>;
+            }),
+            processEvent,
+          )
+          .then(handleRpcExit);
+    },
+  });
+
+export const handleRpcExit = async (exit: Exit.Exit<any, any>) => {
+  if (exit._tag === "Success") {
+    if (Stream.isStream(exit.value)) {
+      return await Effect.runPromise(
+        toRpcStream(exit.value) as Effect.Effect<RpcStreamEnvelope>,
+      );
+    }
+    return exit.value;
+  }
+  const failReason = exit.cause.reasons.find(Cause.isFailReason);
+  if (failReason) {
+    return {
+      _tag: ErrorTag,
+      error: encodeRpcError(failReason.error),
+    } satisfies RpcErrorEnvelope;
+  }
+  const dieReason = exit.cause.reasons.find(Cause.isDieReason);
+  throw (
+    dieReason?.defect ?? new Error("RPC method failed with an unexpected cause")
+  );
+};

package/src/Cloudflare/Workers/WorkerBundle.ts

@@ -9,7 +9,6 @@ import type * as rolldown from "rolldown";
 import Sonda from "sonda/rolldown";
 import * as Bundle from "../../Bundle/Bundle.ts";
 import { findCwdForBundle } from "../../Bundle/TempRoot.ts";
-import { Self } from "../../Self.ts";
 import {
   isDurableObjectExport,
   type DurableObjectExport,
@@ -47,6 +46,12 @@ export const WorkerBundle = Effect.gen(function* () {
     const realMain = yield* sanitizeMain(options.main);
     const inputOptions: rolldown.InputOptions = {
       input: realMain,
+      // Forever-devtool native modules that vite/chokidar reference behind
+      // runtime guards. Rolldown resolves before tree-shaking, so the dead
+      // `require('../pkg')` (lightningcss < 1.32) and `require('fsevents')`
+      // (darwin-only) trip [UNRESOLVED_IMPORT] before DCE can prune them.
+      // See rolldown/tsdown#212.
+      external: ["lightningcss", "fsevents"],
       cwd: yield* findCwdForBundle(realMain).pipe(
         Effect.mapError(
           (cause) =>
@@ -148,100 +153,29 @@ export const makeEffectVirtualEntry = (
   const hasDoClasses = doClasses.length > 0;
   const hasWfClasses = wfClasses.length > 0;
   return (importPath: string) => `
-import * as Config from "effect/Config";
-import * as ConfigProvider from "effect/ConfigProvider";
-import * as Console from "effect/Console";
 import * as Effect from "effect/Effect";
-import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
-import * as Layer from "effect/Layer";
-import * as Logger from "effect/Logger";
-import * as Context from "effect/Context";
-import * as Stream from "effect/Stream";
 
 import { env, DurableObject, WorkerEntrypoint${hasWfClasses ? ", WorkflowEntrypoint" : ""} } from "cloudflare:workers";
-import { MinimumLogLevel } from "effect/References";
-import * as NodeServices from "@effect/platform-node/NodeServices";
-import { Stack } from "alchemy/Stack";
-import { WorkerEnvironment, makeDurableObjectBridge, makeWorkerBridge${hasWfClasses ? ", makeWorkflowBridge" : ""}, ExportedHandlerMethods } from "alchemy/Cloudflare";
+import { makeDurableObjectBridge, makeWorkerBridge${hasWfClasses ? ", makeWorkflowBridge" : ""} } from "alchemy/Cloudflare";
 import { makeEntrypointLayer } from "alchemy/Runtime";
 
 import entrypoint from ${JSON.stringify(importPath)};
 
-const tag = Context.Service("${Self.key}")
-const layer = makeEntrypointLayer(tag, entrypoint);
-
-const platform = Layer.mergeAll(
-  NodeServices.layer,
-  FetchHttpClient.layer,
-  // TODO(sam): wire this up to telemetry more directly
-  Logger.layer([Logger.consolePretty()]),
-);
-
-const stack = Layer.succeed(
-  Stack,
-  {
-    name: "${stack.name}",
-    stage: "${stack.stage}",
-    bindings: {},
-    resources: {}
-  }
-);
-
-const exportsEffect = tag.pipe(
-  Effect.flatMap(func => func.RuntimeContext.exports),
-  Effect.provide(
-    layer.pipe(
-      Layer.provideMerge(stack),
-      Layer.provideMerge(platform),
-      Layer.provideMerge(
-        Layer.succeed(
-          ConfigProvider.ConfigProvider,
-          ConfigProvider.orElse(
-            ConfigProvider.fromUnknown({ ALCHEMY_PHASE: "runtime" }),
-            ConfigProvider.fromUnknown(env),
-          ),
-        ),
-      ),
-      Layer.provideMerge(Layer.succeed(WorkerEnvironment, env)),
-      Layer.provideMerge(
-        Layer.succeed(MinimumLogLevel, env.DEBUG ? "Debug" : "Info"),
-      ),
-    ),
-  ),
-  Effect.scoped,
-);
-
-// TODO(sam): we could kick this off during module init, but any I/O will break deploy
-// let exportsPromise = Effect.runPromise(exportsEffect);
-
-// for now, we delay initializing the worker until the first request
-let exportsPromise;
-
-// don't initialize the workerEffect during module init because Cloudflare does not allow I/O during module init
-// we cache it synchronously (??=) to guarnatee only one initialization ever happens
-const getExports = () => (exportsPromise ??= Effect.runPromise(exportsEffect))
-const getExport = (name) => getExports().then(exports => exports[name]?.make)
-const getDefault = () => getExports().then(exports => exports.default)
-const getRpc = () => getExports().then(exports => exports.__rpc__ ?? {})
+const meta = {
+  entrypoint,
+  stack: {
+    name: ${JSON.stringify(stack.name)},
+    stage: ${JSON.stringify(stack.stage)},
+  },
+};
 
-// Bridge the user's default-export shape onto a real \`WorkerEntrypoint\`
-// subclass so Cloudflare service bindings can dispatch both the standard
-// handler methods (fetch, scheduled, …) and any user-defined RPC methods.
-// RPC method results are wire-encoded by \`runtimeContext.exports\`;
-// consumers unwrap them with \`Cloudflare.toPromiseApi(env.X)\` (Promise
-// API) or \`bindWorker(WorkerClass)\` (Effect API).
-export default makeWorkerBridge(
-  WorkerEntrypoint,
-  ExportedHandlerMethods,
-  getDefault,
-  getRpc,
-);
+export default makeWorkerBridge(WorkerEntrypoint, meta);
 
 // export class proxy stubs for Durable Objects and Workflows
 ${[
   ...(hasDoClasses
     ? [
-        "const DurableObjectBridge = makeDurableObjectBridge(DurableObject, getExport);",
+        "const DurableObjectBridge = makeDurableObjectBridge(DurableObject, meta);",
         ...doClasses.map(
           (id) => `export class ${id} extends DurableObjectBridge("${id}") {}`,
         ),
@@ -249,7 +183,7 @@ ${[
     : []),
   ...(hasWfClasses
     ? [
-        "const WorkflowBridgeFn = makeWorkflowBridge(WorkflowEntrypoint, getExport);",
+        "const WorkflowBridgeFn = makeWorkflowBridge(WorkflowEntrypoint, meta);",
         ...wfClasses.map(
           (id) => `export class ${id} extends WorkflowBridgeFn("${id}") {}`,
         ),