alchemy 2.0.0-beta.41 → 2.0.0-beta.43

package/src/Cloudflare/KV/KVNamespaceBinding.ts

@@ -4,6 +4,7 @@ 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 type { RuntimeContext } from "../../RuntimeContext.ts";
 import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
 import type { KVNamespace } from "./KVNamespace.ts";
 
@@ -17,46 +18,46 @@ export interface KVNamespaceClient<Key extends string = string> {
   get(
     key: Key,
     options?: Partial<KVNamespaceGetOptions<undefined>>,
-  ): Effect.Effect<string | null, KVNamespaceError, WorkerEnvironment>;
+  ): Effect.Effect<string | null, KVNamespaceError, RuntimeContext>;
   get(
     key: Key,
     type: "text",
-  ): Effect.Effect<string | null, KVNamespaceError, WorkerEnvironment>;
+  ): Effect.Effect<string | null, KVNamespaceError, RuntimeContext>;
   get<ExpectedValue = unknown>(
     key: Key,
     type: "json",
-  ): Effect.Effect<ExpectedValue | null, KVNamespaceError, WorkerEnvironment>;
+  ): Effect.Effect<ExpectedValue | null, KVNamespaceError, RuntimeContext>;
   get(
     key: Key,
     type: "arrayBuffer",
-  ): Effect.Effect<ArrayBuffer | null, KVNamespaceError, WorkerEnvironment>;
+  ): Effect.Effect<ArrayBuffer | null, KVNamespaceError, RuntimeContext>;
   get(
     key: Key,
     type: "stream",
-  ): Effect.Effect<ReadableStream | null, KVNamespaceError, WorkerEnvironment>;
+  ): Effect.Effect<ReadableStream | null, KVNamespaceError, RuntimeContext>;
   get(
     key: Key,
     options?: KVNamespaceGetOptions<"text">,
-  ): Effect.Effect<string | null, KVNamespaceError, WorkerEnvironment>;
+  ): Effect.Effect<string | null, KVNamespaceError, RuntimeContext>;
   get<ExpectedValue = unknown>(
     key: Key,
     options?: KVNamespaceGetOptions<"json">,
-  ): Effect.Effect<ExpectedValue | null, KVNamespaceError, WorkerEnvironment>;
+  ): Effect.Effect<ExpectedValue | null, KVNamespaceError, RuntimeContext>;
   get(
     key: Key,
     options?: KVNamespaceGetOptions<"arrayBuffer">,
-  ): Effect.Effect<ArrayBuffer | null, KVNamespaceError, WorkerEnvironment>;
+  ): Effect.Effect<ArrayBuffer | null, KVNamespaceError, RuntimeContext>;
   get(
     key: Key,
     options?: KVNamespaceGetOptions<"stream">,
-  ): Effect.Effect<ReadableStream | null, KVNamespaceError, WorkerEnvironment>;
+  ): Effect.Effect<ReadableStream | null, KVNamespaceError, RuntimeContext>;
   get(
     key: Array<Key>,
     type: "text",
   ): Effect.Effect<
     Map<string, string | null>,
     KVNamespaceError,
-    WorkerEnvironment
+    RuntimeContext
   >;
   get<ExpectedValue = unknown>(
     key: Array<Key>,
@@ -64,7 +65,7 @@ export interface KVNamespaceClient<Key extends string = string> {
   ): Effect.Effect<
     Map<string, ExpectedValue | null>,
     KVNamespaceError,
-    WorkerEnvironment
+    RuntimeContext
   >;
   get(
     key: Array<Key>,
@@ -72,7 +73,7 @@ export interface KVNamespaceClient<Key extends string = string> {
   ): Effect.Effect<
     Map<string, string | null>,
     KVNamespaceError,
-    WorkerEnvironment
+    RuntimeContext
   >;
   get(
     key: Array<Key>,
@@ -80,7 +81,7 @@ export interface KVNamespaceClient<Key extends string = string> {
   ): Effect.Effect<
     Map<string, string | null>,
     KVNamespaceError,
-    WorkerEnvironment
+    RuntimeContext
   >;
   get<ExpectedValue = unknown>(
     key: Array<Key>,
@@ -88,27 +89,27 @@ export interface KVNamespaceClient<Key extends string = string> {
   ): Effect.Effect<
     Map<string, ExpectedValue | null>,
     KVNamespaceError,
-    WorkerEnvironment
+    RuntimeContext
   >;
   list<Metadata = unknown>(
     options?: KVNamespaceListOptions,
   ): Effect.Effect<
     KVNamespaceListResult<Metadata, Key>,
     KVNamespaceError,
-    WorkerEnvironment
+    RuntimeContext
   >;
   put(
     key: Key,
     value: string | ArrayBuffer | ArrayBufferView | ReadableStream,
     options?: KVNamespacePutOptions,
-  ): Effect.Effect<void, KVNamespaceError, WorkerEnvironment>;
+  ): Effect.Effect<void, KVNamespaceError, RuntimeContext>;
   getWithMetadata<Metadata = unknown>(
     key: Key,
     options?: Partial<KVNamespaceGetOptions<undefined>>,
   ): Effect.Effect<
     KVNamespaceGetWithMetadataResult<string, Metadata>,
     KVNamespaceError,
-    WorkerEnvironment
+    RuntimeContext
   >;
   getWithMetadata<Metadata = unknown>(
     key: Key,
@@ -116,7 +117,7 @@ export interface KVNamespaceClient<Key extends string = string> {
   ): Effect.Effect<
     KVNamespaceGetWithMetadataResult<string, Metadata>,
     KVNamespaceError,
-    WorkerEnvironment
+    RuntimeContext
   >;
   getWithMetadata<ExpectedValue = unknown, Metadata = unknown>(
     key: Key,
@@ -124,7 +125,7 @@ export interface KVNamespaceClient<Key extends string = string> {
   ): Effect.Effect<
     KVNamespaceGetWithMetadataResult<ExpectedValue, Metadata>,
     KVNamespaceError,
-    WorkerEnvironment
+    RuntimeContext
   >;
   getWithMetadata<Metadata = unknown>(
     key: Key,
@@ -132,7 +133,7 @@ export interface KVNamespaceClient<Key extends string = string> {
   ): Effect.Effect<
     KVNamespaceGetWithMetadataResult<ArrayBuffer, Metadata>,
     KVNamespaceError,
-    WorkerEnvironment
+    RuntimeContext
   >;
   getWithMetadata<Metadata = unknown>(
     key: Key,
@@ -140,7 +141,7 @@ export interface KVNamespaceClient<Key extends string = string> {
   ): Effect.Effect<
     KVNamespaceGetWithMetadataResult<ReadableStream, Metadata>,
     KVNamespaceError,
-    WorkerEnvironment
+    RuntimeContext
   >;
   getWithMetadata<Metadata = unknown>(
     key: Key,
@@ -148,7 +149,7 @@ export interface KVNamespaceClient<Key extends string = string> {
   ): Effect.Effect<
     KVNamespaceGetWithMetadataResult<string, Metadata>,
     KVNamespaceError,
-    WorkerEnvironment
+    RuntimeContext
   >;
   getWithMetadata<ExpectedValue = unknown, Metadata = unknown>(
     key: Key,
@@ -156,7 +157,7 @@ export interface KVNamespaceClient<Key extends string = string> {
   ): Effect.Effect<
     KVNamespaceGetWithMetadataResult<ExpectedValue, Metadata>,
     KVNamespaceError,
-    WorkerEnvironment
+    RuntimeContext
   >;
   getWithMetadata<Metadata = unknown>(
     key: Key,
@@ -164,7 +165,7 @@ export interface KVNamespaceClient<Key extends string = string> {
   ): Effect.Effect<
     KVNamespaceGetWithMetadataResult<ArrayBuffer, Metadata>,
     KVNamespaceError,
-    WorkerEnvironment
+    RuntimeContext
   >;
   getWithMetadata<Metadata = unknown>(
     key: Key,
@@ -172,7 +173,7 @@ export interface KVNamespaceClient<Key extends string = string> {
   ): Effect.Effect<
     KVNamespaceGetWithMetadataResult<ReadableStream, Metadata>,
     KVNamespaceError,
-    WorkerEnvironment
+    RuntimeContext
   >;
   getWithMetadata<Metadata = unknown>(
     key: Array<Key>,
@@ -180,7 +181,7 @@ export interface KVNamespaceClient<Key extends string = string> {
   ): Effect.Effect<
     Map<string, KVNamespaceGetWithMetadataResult<string, Metadata>>,
     KVNamespaceError,
-    WorkerEnvironment
+    RuntimeContext
   >;
   getWithMetadata<ExpectedValue = unknown, Metadata = unknown>(
     key: Array<Key>,
@@ -188,7 +189,7 @@ export interface KVNamespaceClient<Key extends string = string> {
   ): Effect.Effect<
     Map<string, KVNamespaceGetWithMetadataResult<ExpectedValue, Metadata>>,
     KVNamespaceError,
-    WorkerEnvironment
+    RuntimeContext
   >;
   getWithMetadata<Metadata = unknown>(
     key: Array<Key>,
@@ -196,7 +197,7 @@ export interface KVNamespaceClient<Key extends string = string> {
   ): Effect.Effect<
     Map<string, KVNamespaceGetWithMetadataResult<string, Metadata>>,
     KVNamespaceError,
-    WorkerEnvironment
+    RuntimeContext
   >;
   getWithMetadata<Metadata = unknown>(
     key: Array<Key>,
@@ -204,7 +205,7 @@ export interface KVNamespaceClient<Key extends string = string> {
   ): Effect.Effect<
     Map<string, KVNamespaceGetWithMetadataResult<string, Metadata>>,
     KVNamespaceError,
-    WorkerEnvironment
+    RuntimeContext
   >;
   getWithMetadata<ExpectedValue = unknown, Metadata = unknown>(
     key: Array<Key>,
@@ -212,9 +213,9 @@ export interface KVNamespaceClient<Key extends string = string> {
   ): Effect.Effect<
     Map<string, KVNamespaceGetWithMetadataResult<ExpectedValue, Metadata>>,
     KVNamespaceError,
-    WorkerEnvironment
+    RuntimeContext
   >;
-  delete(key: Key): Effect.Effect<void, KVNamespaceError, WorkerEnvironment>;
+  delete(key: Key): Effect.Effect<void, KVNamespaceError, RuntimeContext>;
 }
 
 export class KVNamespaceBinding extends Binding.Service<
@@ -226,15 +227,13 @@ export const KVNamespaceBindingLive = Layer.effect(
   KVNamespaceBinding,
   Effect.gen(function* () {
     const bind = yield* KVNamespaceBindingPolicy;
+    const env = yield* WorkerEnvironment;
 
     return Effect.fn(function* (bucket: KVNamespace) {
       yield* bind(bucket);
-      const env = WorkerEnvironment;
-      const raw = env.pipe(
-        Effect.map(
-          (env) =>
-            (env as Record<string, runtime.KVNamespace>)[bucket.LogicalId],
-        ),
+      const raw = Effect.sync(
+        // this must be lazy because the WorkerEnvironment is not available yet
+        () => (env as Record<string, runtime.KVNamespace>)[bucket.LogicalId],
       );
       const tryPromise = <T>(
         fn: () => Promise<T>,
@@ -250,9 +249,10 @@ export const KVNamespaceBindingLive = Layer.effect(
 
       const use = <T>(
         fn: (raw: runtime.KVNamespace<string>) => Promise<T>,
-      ): Effect.Effect<T, KVNamespaceError, WorkerEnvironment> =>
+      ): Effect.Effect<T, KVNamespaceError> =>
         raw.pipe(Effect.flatMap((raw) => tryPromise(() => fn(raw))));
 
+      // @ts-expect-error
       return {
         raw: raw,
         // @ts-expect-error

package/src/Cloudflare/Queue/QueueBinding.ts

@@ -2,21 +2,22 @@ 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 type { RuntimeContext } from "../../RuntimeContext.ts";
 import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
 import type { Queue } from "./Queue.ts";
 
 export interface QueueSender {
-  raw: Effect.Effect<any, never, WorkerEnvironment>;
+  raw: Effect.Effect<any, never, RuntimeContext>;
   send(
     body: unknown,
     options?: { contentType?: "json" | "text" },
-  ): Effect.Effect<void, QueueSendError, WorkerEnvironment>;
+  ): Effect.Effect<void, QueueSendError, RuntimeContext>;
   sendBatch(
     messages: ReadonlyArray<{
       body: unknown;
       contentType?: "json" | "text";
     }>,
-  ): Effect.Effect<void, QueueSendError, WorkerEnvironment>;
+  ): Effect.Effect<void, QueueSendError, RuntimeContext>;
 }
 
 import * as Data from "effect/Data";
@@ -68,12 +69,12 @@ export const QueueBindingLive = Layer.effect(
   QueueBinding,
   Effect.gen(function* () {
     const bind = yield* QueueBindingPolicy;
+    const env = yield* WorkerEnvironment;
 
     return Effect.fn(function* (queue: Queue) {
       yield* bind(queue);
-      const env = WorkerEnvironment;
-      const raw = env.pipe(
-        Effect.map((env) => (env as Record<string, any>)[queue.LogicalId]),
+      const raw = Effect.sync(
+        () => (env as Record<string, any>)[queue.LogicalId],
       );
 
       const tryPromise = <T>(

package/src/Cloudflare/R2/R2BucketBinding.ts

@@ -6,6 +6,7 @@ import * as Stream from "effect/Stream";
 import * as Binding from "../../Binding.ts";
 import * as Output from "../../Output.ts";
 import type { ResourceLike } from "../../Resource.ts";
+import type { RuntimeContext } from "../../RuntimeContext.ts";
 import { getRawStream } from "../../Util/Stream.ts";
 import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
 import type { R2Bucket } from "./R2Bucket.ts";
@@ -66,18 +67,18 @@ export type R2UploadedPart = runtime.R2UploadedPart;
 export interface R2UploadPartOptions extends runtime.R2UploadPartOptions {}
 
 export interface R2BucketClient {
-  raw: Effect.Effect<runtime.R2Bucket, never, WorkerEnvironment>;
-  head(key: string): Effect.Effect<R2Object | null, R2Error, WorkerEnvironment>;
+  raw: Effect.Effect<runtime.R2Bucket, never, RuntimeContext>;
+  head(key: string): Effect.Effect<R2Object | null, R2Error, RuntimeContext>;
   get(
     key: string,
     options: R2GetOptions & {
       onlyIf: runtime.R2Conditional | Headers;
     },
-  ): Effect.Effect<R2ObjectBody | R2Object | null, R2Error, WorkerEnvironment>;
+  ): Effect.Effect<R2ObjectBody | R2Object | null, R2Error, RuntimeContext>;
   get(
     key: string,
     options?: R2GetOptions,
-  ): Effect.Effect<R2ObjectBody | null, R2Error, WorkerEnvironment>;
+  ): Effect.Effect<R2ObjectBody | null, R2Error, RuntimeContext>;
   put<Err = never>(
     key: string,
     value:
@@ -92,7 +93,7 @@ export interface R2BucketClient {
       onlyIf: R2Conditional | Headers;
       contentLength?: number;
     },
-  ): Effect.Effect<R2Object | null, R2Error | Err, WorkerEnvironment>;
+  ): Effect.Effect<R2Object | null, R2Error | Err, RuntimeContext>;
   put<Err = never>(
     key: string,
     value:
@@ -103,7 +104,7 @@ export interface R2BucketClient {
       | null
       | Blob,
     options?: R2PutOptions,
-  ): Effect.Effect<R2Object, R2Error | Err, WorkerEnvironment>;
+  ): Effect.Effect<R2Object, R2Error | Err, RuntimeContext>;
   put<Err = never>(
     key: string,
     value:
@@ -117,21 +118,19 @@ export interface R2BucketClient {
     options: R2PutOptions & {
       contentLength: number;
     },
-  ): Effect.Effect<R2Object, R2Error | Err, WorkerEnvironment>;
-  delete(
-    keys: string | string[],
-  ): Effect.Effect<void, R2Error, WorkerEnvironment>;
+  ): Effect.Effect<R2Object, R2Error | Err, RuntimeContext>;
+  delete(keys: string | string[]): Effect.Effect<void, R2Error, RuntimeContext>;
   list(
     options?: R2ListOptions,
-  ): Effect.Effect<R2Objects, R2Error, WorkerEnvironment>;
+  ): Effect.Effect<R2Objects, R2Error, RuntimeContext>;
   createMultipartUpload(
     key: string,
     options?: R2MultipartOptions,
-  ): Effect.Effect<R2MultipartUpload, R2Error, WorkerEnvironment>;
+  ): Effect.Effect<R2MultipartUpload, R2Error, RuntimeContext>;
   resumeMultipartUpload(
     key: string,
     uploadId: string,
-  ): Effect.Effect<R2MultipartUpload, R2Error, WorkerEnvironment>;
+  ): Effect.Effect<R2MultipartUpload, R2Error, RuntimeContext>;
 }
 
 export class R2BucketBinding extends Binding.Service<
@@ -143,14 +142,12 @@ export const R2BucketBindingLive = Layer.effect(
   R2BucketBinding,
   Effect.gen(function* () {
     const bind = yield* R2BucketBindingPolicy;
+    const env = yield* WorkerEnvironment;
 
     return Effect.fn(function* (bucket: R2Bucket) {
       yield* bind(bucket);
-      const env = WorkerEnvironment;
-      const raw = env.pipe(
-        Effect.map(
-          (env) => (env as Record<string, runtime.R2Bucket>)[bucket.LogicalId],
-        ),
+      const raw = Effect.sync(
+        () => (env as Record<string, runtime.R2Bucket>)[bucket.LogicalId]!,
       );
       const tryPromise = <T>(fn: () => Promise<T>): Effect.Effect<T, R2Error> =>
         Effect.tryPromise({
@@ -164,7 +161,7 @@ export const R2BucketBindingLive = Layer.effect(
 
       const use = <T>(
         fn: (raw: runtime.R2Bucket) => Promise<T>,
-      ): Effect.Effect<T, R2Error, WorkerEnvironment> =>
+      ): Effect.Effect<T, R2Error> =>
         raw.pipe(Effect.flatMap((raw) => tryPromise(() => fn(raw))));
 
       const wrapR2Object = (object: runtime.R2Object): R2Object => ({

package/src/Cloudflare/SecretsStore/SecretBinding.ts

@@ -4,6 +4,7 @@ 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 type { RuntimeContext } from "../../RuntimeContext.ts";
 import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
 import type { Secret } from "./Secret.ts";
 
@@ -21,16 +22,16 @@ export class SecretError extends Data.TaggedError("SecretError")<{
 export interface SecretClient extends Effect.Effect<
   string,
   SecretError,
-  WorkerEnvironment
+  RuntimeContext
 > {
   /**
    * Effect that resolves to the raw Cloudflare `SecretsStoreSecret` binding.
    */
-  raw: Effect.Effect<runtime.SecretsStoreSecret, never, WorkerEnvironment>;
+  raw: Effect.Effect<runtime.SecretsStoreSecret, never, RuntimeContext>;
   /**
    * Read the current value of the secret.
    */
-  get(): Effect.Effect<string, SecretError, WorkerEnvironment>;
+  get(): Effect.Effect<string, SecretError, RuntimeContext>;
 }
 
 export class SecretBinding extends Binding.Service<
@@ -42,17 +43,13 @@ export const SecretBindingLive = Layer.effect(
   SecretBinding,
   Effect.gen(function* () {
     const bind = yield* SecretBindingPolicy;
+    const env = yield* WorkerEnvironment;
 
     return Effect.fn(function* (secret: Secret) {
       yield* bind(secret);
-      const env = WorkerEnvironment;
-      const raw = env.pipe(
-        Effect.map(
-          (env) =>
-            (env as Record<string, runtime.SecretsStoreSecret>)[
-              secret.LogicalId
-            ],
-        ),
+      const raw = Effect.sync(
+        () =>
+          (env as Record<string, runtime.SecretsStoreSecret>)[secret.LogicalId],
       );
       const tryPromise = <T>(
         fn: () => Promise<T>,
@@ -66,8 +63,9 @@ export const SecretBindingLive = Layer.effect(
             }),
         });
 
-      const getEffect: Effect.Effect<string, SecretError, WorkerEnvironment> =
-        raw.pipe(Effect.flatMap((raw) => tryPromise(() => raw.get())));
+      const getEffect: Effect.Effect<string, SecretError> = raw.pipe(
+        Effect.flatMap((raw) => tryPromise(() => raw.get())),
+      );
 
       return Object.assign(
         Effect.suspend(() => getEffect),

package/src/Cloudflare/Workers/DurableObjectNamespace.ts

@@ -1,12 +1,12 @@
 import type * as cf from "@cloudflare/workers-types";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
 import type { HttpServerError } from "effect/unstable/http/HttpServerError";
 import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
 import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
 import type { HttpEffect } from "../../Http.ts";
 import * as Output from "../../Output.ts";
+import { ALCHEMY_PHASE } from "../../Phase.ts";
 import type { PlatformServices } from "../../Platform.ts";
 import { effectClass, taggedFunction } from "../../Util/effect.ts";
 import { DurableObjectState } from "./DurableObjectState.ts";
@@ -589,12 +589,12 @@ export const DurableObjectNamespace: DurableObjectNamespaceClass =
                 ],
               });
 
-              const binding = yield* Effect.serviceOption(
+              const binding = yield* Effect.all([
                 WorkerEnvironment,
-              ).pipe(
-                Effect.map(Option.getOrUndefined),
-                Effect.flatMap((env) => {
-                  if (env === undefined) {
+                ALCHEMY_PHASE,
+              ]).pipe(
+                Effect.flatMap(([env, phase]) => {
+                  if (env === undefined || phase === "plan") {
                     // should be fine to return undefined here (it is only undefined at plantime)
                     return Effect.succeed(undefined);
                   }

package/src/Cloudflare/Workers/DynamicWorkerLoader.ts

@@ -1,5 +1,5 @@
 import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
+import { ALCHEMY_PHASE } from "../../Phase.ts";
 import { fromCloudflareFetcher, type Fetcher } from "../Fetcher.ts";
 import { makeRpcStub } from "./Rpc.ts";
 import { Worker, WorkerEnvironment } from "./Worker.ts";
@@ -162,10 +162,9 @@ export const DynamicWorkerLoader = Effect.fnUntraced(function* (name: string) {
     bindings: [{ type: "worker_loader", name } as any],
   });
 
-  const binding = yield* Effect.serviceOption(WorkerEnvironment).pipe(
-    Effect.map(Option.getOrUndefined),
-    Effect.flatMap((env) => {
-      if (env === undefined) {
+  const binding = yield* Effect.all([WorkerEnvironment, ALCHEMY_PHASE]).pipe(
+    Effect.flatMap(([env, phase]) => {
+      if (env === undefined || phase === "plan") {
         return Effect.succeed(undefined as any);
       }
       const loader = env[name];

package/src/Cloudflare/Workers/RpcAsync.ts

@@ -19,6 +19,61 @@ export type RpcAsync<Shape> = {
             : Promise<Shape[K]>;
 };
 
+/**
+ * Wrap a Cloudflare Worker RPC stub in a `Promise<T>`-shaped proxy so callers
+ * outside the Effect runtime (TanStack Start route handlers, plain Workers,
+ * test code) can `await` RPC methods directly.
+ *
+ * The proxy:
+ * - leaves `fetch` / `connect` / `Symbol.dispose` and other non-string keys
+ *   passing through to the underlying binding unchanged,
+ * - turns each `Effect<T>` / `Stream<T>` method into a `Promise<T>` /
+ *   `Promise<ReadableStream<Uint8Array>>`,
+ * - unwraps the wire envelopes produced by the Effect-side RPC bridge:
+ *   `RpcErrorEnvelope` is rethrown via {@link decodeRpcThrowable} so
+ *   `try/catch` sees an `Error` (or a tagged error object), and
+ *   `RpcStreamEnvelope` is flattened to its `ReadableStream` body.
+ *
+ * @example Three ways to reach a value from a plain Worker — direct binding, fetch, RPC
+ * ```ts
+ * import { toRpcAsync } from "alchemy/Cloudflare/Bridge";
+ * import type Backend from "./backend.ts";
+ *
+ * interface Env {
+ *   BUCKET: R2Bucket;
+ *   BACKEND: Service<Backend>;
+ * }
+ *
+ * export default {
+ *   async fetch(request: Request, env: Env): Promise<Response> {
+ *     const url = new URL(request.url);
+ *     const key = url.searchParams.get("key");
+ *     const via = url.searchParams.get("via") ?? "binding";
+ *     if (!key) return new Response("Missing 'key'", { status: 400 });
+ *
+ *     // option 1 — use the async binding directly
+ *     if (via === "binding") {
+ *       const object = await env.BUCKET.get(key);
+ *       if (!object) return new Response("Not found", { status: 404 });
+ *       return new Response(object.body);
+ *     }
+ *
+ *     // option 2 — call the Effect worker's fetch handler
+ *     if (via === "fetch") {
+ *       return env.BACKEND.fetch(
+ *         `https://backend/?key=${encodeURIComponent(key)}`,
+ *       );
+ *     }
+ *
+ *     // option 3 — call an Effect worker RPC method as a Promise
+ *     const backend = toRpcAsync<Backend>(env.BACKEND);
+ *     const value = await backend.hello(key);
+ *     if (value === null) return new Response("Not found", { status: 404 });
+ *     return new Response(value);
+ *   },
+ * };
+ * ```
+ */
 export const toRpcAsync = <W>(stub: any): RpcAsync<Rpc.Shape<W>> & Service =>
   new Proxy(stub, {
     get: (target, prop) => {

package/src/Cloudflare/Workers/Worker.ts

@@ -136,9 +136,13 @@ export const ExportedHandlerMethods = [
   "queue",
 ] as const satisfies (keyof cf.ExportedHandler)[];
 
-export type WorkerServices = Worker | Request | WorkerExecutionContext;
+export type WorkerServices =
+  | Worker
+  | Request
+  | WorkerExecutionContext
+  | WorkerEnvironment;
 
-export type WorkerShape = Main<WorkerServices | WorkerEnvironment>;
+export type WorkerShape = Main<WorkerServices>;
 
 export type WorkerEnv = Record<
   string,
@@ -658,7 +662,7 @@ export const Worker: Platform<
   >(
     id: string,
     props:
-      | WorkerProps<Bindings, Env, Assets>
+      | InputProps<WorkerProps<Bindings, Env, Assets>>
       | Effect.Effect<
           InputProps<WorkerProps<Bindings, Env, Assets>>,
           never,
@@ -681,8 +685,16 @@ export const Worker: Platform<
     Req | Providers
   >;
 } = Platform(WorkerTypeId, {
-  onCreate: bindWorkerAsyncBindings,
-  createRuntimeContext: makeWorkerRuntimeContext,
+  // Both hooks are wrapped in arrows so the imported references are resolved
+  // at call time rather than at module-load time. Worker.ts forms import
+  // cycles with both WorkerAsyncBindings.ts (which imports `isWorker` here)
+  // and WorkerRuntimeContext.ts (which imports `WorkerTypeId`/`WorkerEnvironment`
+  // here). Reading either binding eagerly here hits TDZ when Bun loads the
+  // package from node_modules in a different module-init order than the local
+  // workspace.
+  onCreate: (resource, props) =>
+    bindWorkerAsyncBindings(resource as Worker, props),
+  createRuntimeContext: (id) => makeWorkerRuntimeContext(id),
 });
 
 class MissingDurableObjectNamespaces extends Data.TaggedError(

package/src/Cloudflare/Workers/WorkerRuntimeContext.ts

@@ -1,5 +1,6 @@
 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";
@@ -112,6 +113,7 @@ export const makeWorkerRuntimeContext = (id: string): WorkerRuntimeContext => {
       Effect.sync(() => {
         exports[name] = value;
       }),
+    planServices: Layer.succeed(WorkerEnvironment, {}),
     exports: Effect.gen(function* () {
       const handlers = yield* Effect.all(listeners, {
         concurrency: "unbounded",