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

package/src/Cloudflare/Workers/HttpServer.ts

@@ -1,10 +1,9 @@
 import type * as cf from "@cloudflare/workers-types";
 import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import type { Scope } from "effect/Scope";
-import type { HttpBodyError } from "effect/unstable/http/HttpBody";
-import * as HttpServerError from "effect/unstable/http/HttpServerError";
 import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
 import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
 import * as Http from "../../Http.ts";
@@ -13,45 +12,31 @@ import { isWorkerEvent, type WorkerServices } from "./Worker.ts";
 
 export type HttpEffect = Http.HttpEffect<WorkerServices>;
 
-export const workersHttpHandler = <Req = never>(
-  handler: Http.HttpEffect<Req> | Effect.Effect<Http.HttpEffect<Req>>,
-) => {
-  const safeHandler = Http.safeHttpEffect(handler);
-  return (event: any) => {
-    if (isWorkerEvent(event) && event.type === "fetch") {
-      const webRequest = event.input;
-      return serveWebRequest(webRequest, safeHandler, {
-        remoteAddress: webRequest.headers.get("cf-connecting-ip") ?? undefined,
-      });
-    }
-  };
-};
+export const makeRequestHandler =
+  <Req = never>(
+    handler: Http.HttpEffect<Req> | Effect.Effect<Http.HttpEffect<Req>>,
+  ) =>
+  (event: any) =>
+    isWorkerEvent(event) && event.type === "fetch"
+      ? makeRequestEffect(event.input, handler)
+      : undefined;
 
-export const serveWebRequest = <Req = never>(
+export const makeRequestEffect = <Req = never>(
   webRequest: cf.Request,
-  handler: Effect.Effect<
-    HttpServerResponse.HttpServerResponse,
-    HttpServerError.HttpServerError | HttpBodyError,
-    Req
-  >,
-  options: {
-    // Preserve transport metadata when this helper is adapting a request
-    // that originated from another runtime surface.
-    remoteAddress?: string;
-    // Durable Objects need to register the accepted socket on object state
-    // instead of calling `server.accept()` directly.
-    acceptWebSocket?: (socket: cf.WebSocket) => void;
-  } = {},
+  handler: Http.HttpEffect<Req> | Effect.Effect<Http.HttpEffect<Req>>,
 ): Effect.Effect<
   Response,
   never,
   Exclude<Req, HttpServerRequest.HttpServerRequest | Scope>
-> =>
-  Effect.gen(function* () {
+> => {
+  const safeHandler = Http.safeHttpEffect(handler);
+  return Effect.gen(function* () {
     const request = HttpServerRequest.fromWeb(
       webRequest as any as globalThis.Request,
     ).modify({
-      remoteAddress: Option.fromUndefinedOr(options.remoteAddress),
+      remoteAddress: Option.fromUndefinedOr(
+        webRequest.headers.get("cf-connecting-ip") ?? undefined,
+      ),
     });
 
     Object.defineProperty(request, "raw", {
@@ -61,13 +46,15 @@ export const serveWebRequest = <Req = never>(
         }),
     });
 
-    const response = yield* handler.pipe(
-      Effect.provideService(HttpServerRequest.HttpServerRequest, request),
-      Effect.provideService(Request, webRequest as any),
+    const response = yield* safeHandler.pipe(
+      Effect.provide([
+        Layer.succeed(HttpServerRequest.HttpServerRequest, request),
+        Layer.succeed(Request, webRequest as any),
+      ]),
       Effect.catchCause((cause) => {
         const message = Option.match(Cause.findErrorOption(cause), {
           onNone: () => "Internal Server Error",
-          onSome: (error) =>
+          onSome: (error: any) =>
             error instanceof Error && error.message
               ? error.message
               : "Internal Server Error",
@@ -81,7 +68,6 @@ export const serveWebRequest = <Req = never>(
       }),
     );
 
-    return HttpServerResponse.toWeb(response, {
-      context: yield* Effect.context(),
-    });
+    return HttpServerResponse.toWeb(response);
   }) as any;
+};

package/src/Cloudflare/Workers/InferEnv.ts

@@ -2,19 +2,52 @@
 
 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 { Rpc } from "../../Rpc.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
-  | Worker<infer Bindings>
-  | Effect.Effect<Worker<infer Bindings>, any, any>
-  ? {
-      [K in keyof Bindings]: GetBindingType<UnwrapEffect<Bindings[K]>>;
-    }
-  : never;
+export type InferEnv<W> =
+  W extends Effect.Effect<infer A, infer _E, infer _R>
+    ? InferEnv<A>
+    : W extends Worker<any>
+      ? InferEnv<Exclude<W["Props"]["bindings"], undefined>>
+      : {
+          [k in keyof W]: GetBindingType<W[k]>;
+        };
+
+export type GetBindingType<T> =
+  T extends Effect.Effect<infer A, infer _E, infer _R>
+    ? GetBindingType<A>
+    : T extends Cloudflare.Assets
+      ? Service
+      : 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.SendEmail
+                    ? SendEmail
+                    : 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>
+                                >
+                              : T;
 
 /**
  * Cloudflare service-binding wire shape for an Effect-native Worker.
@@ -43,72 +76,3 @@ export type RpcWireShape<Shape> = {
             ? (...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 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.SendEmail
-                ? SendEmail
-                : 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/Rpc.ts

@@ -7,12 +7,8 @@ import * as Option from "effect/Option";
 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";
 export const ErrorTag = "~alchemy/rpc/error";
@@ -231,419 +227,6 @@ export const makeRpcStub = <Shape>(
   }) 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.
- *
- * Accepts the `DurableObject` base class and a `getExport` resolver so the
- * implementation lives in real TypeScript instead of a generated string template.
- */
-export const makeDurableObjectBridge =
-  (
-    DurableObject: abstract new (
-      state: unknown,
-      env: unknown,
-    ) => cf.DurableObject,
-    getExport: (
-      name: string,
-    ) => Promise<
-      (state: unknown, env: unknown) => Effect.Effect<Record<string, unknown>>
-    >,
-  ) =>
-  (className: string) =>
-    class DurableObjectBridge extends DurableObject {
-      readonly object: Promise<DurableObjectShape>;
-
-      async fetch(request: cf.Request): Promise<cf.Response> {
-        const methods = await this.object;
-        if (methods.fetch) {
-          const fetch = methods.fetch as HttpEffect<never>;
-          const response = await serveWebRequest(request, fetch).pipe(
-            Effect.runPromise,
-          );
-          return response as any;
-        } else {
-          return new Response("Method not found", { status: 404 }) as any;
-        }
-      }
-
-      async alarm(alarmInfo?: cf.AlarmInvocationInfo) {
-        const methods = await this.object;
-        if (methods.alarm) {
-          await Effect.runPromise(methods.alarm(alarmInfo));
-        }
-      }
-
-      async webSocketMessage(ws: cf.WebSocket, message: string | ArrayBuffer) {
-        const methods = await this.object;
-        if (methods.webSocketMessage) {
-          const socket = fromWebSocket(ws);
-          const value = methods.webSocketMessage(socket, message);
-          if (Effect.isEffect(value)) {
-            await Effect.runPromise(value as Effect.Effect<void>);
-          }
-        }
-      }
-
-      async webSocketClose(
-        ws: cf.WebSocket,
-        code: number,
-        reason: string,
-        wasClean: boolean,
-      ) {
-        const methods = await this.object;
-        if (methods.webSocketClose) {
-          const socket = fromWebSocket(ws);
-          const value = methods.webSocketClose(socket, code, reason, wasClean);
-          if (Effect.isEffect(value)) {
-            await Effect.runPromise(value as Effect.Effect<void>);
-          }
-        }
-      }
-
-      constructor(
-        state: {
-          blockConcurrencyWhile: (
-            fn: () => Promise<unknown>,
-          ) => Promise<unknown>;
-        },
-        env: unknown,
-      ) {
-        super(state, env);
-
-        this.object = state.blockConcurrencyWhile(async () => {
-          const makeDurableObject = await getExport(className);
-          return await Effect.runPromise(makeDurableObject(state, env));
-        }) as Promise<any>;
-
-        return new Proxy(this, {
-          get: (target: any, prop) =>
-            prop in target
-              ? target[prop]
-              : async (...args: unknown[]) => {
-                  const methods = await this.object;
-                  const method = methods[
-                    prop as keyof DurableObjectShape
-                  ] as any; // TODO(sam): what should the type be? Is it safe to always call it?
-                  const value = method(...args);
-                  if (Effect.isEffect(value)) {
-                    const exit = await Effect.runPromiseExit(
-                      value as Effect.Effect<unknown, never>,
-                    );
-                    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")
-                    );
-                  }
-                  return value;
-                },
-        });
-      }
-    };
-
-/**
- * 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
- * registered via `worker.export(...)`.
- *
- * The bridge provides `WorkflowEvent` and `WorkflowStep` as Effect
- * services so the user writes `yield* WorkflowEvent` and `yield* task(...)`
- * instead of receiving callback parameters.
- */
-export const makeWorkflowBridge =
-  (
-    WorkflowEntrypoint: abstract new (
-      ctx: unknown,
-      env: unknown,
-    ) => { run(event: any, step: any): Promise<unknown> },
-    getExport: (
-      name: string,
-    ) => Promise<
-      (
-        env: unknown,
-      ) => Effect.Effect<(input: unknown) => Effect.Effect<unknown, never, any>>
-    >,
-  ) =>
-  (className: string) =>
-    class WorkflowBridge extends WorkflowEntrypoint {
-      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.fn = getExport(className).then((factory) =>
-          Effect.runPromise(factory(env)),
-        );
-      }
-
-      async run(event: any, step: any): Promise<unknown> {
-        const fn = await this.fn;
-        return Effect.runPromise(
-          fn(event.payload).pipe(
-            Effect.provideService(
-              WorkflowEventService,
-              wrapWorkflowEvent(event),
-            ),
-            Effect.provideService(WorkflowStep, wrapWorkflowStep(step)),
-          ) as Effect.Effect<unknown>,
-        );
-      }
-    };
-
-import type { DurableObjectShape } from "./DurableObjectNamespace.ts";
-import {
-  WorkflowEvent as WorkflowEventService,
-  WorkflowStep,
-} from "./Workflow.ts";
-
-const wrapWorkflowEvent = (
-  event: any,
-): { payload: unknown; timestamp: Date; instanceId: string } => ({
-  payload: event.payload,
-  timestamp:
-    event.timestamp instanceof Date
-      ? event.timestamp
-      : new Date(event.timestamp),
-  instanceId: event.instanceId ?? "",
-});
-
-const wrapWorkflowStep = (step: any): WorkflowStep["Service"] => ({
-  do: <T>(name: string, effect: Effect.Effect<T>): Effect.Effect<T> =>
-    Effect.tryPromise(
-      () => step.do(name, () => Effect.runPromise(effect)) as Promise<T>,
-    ),
-  sleep: (name: string, duration: string | number): Effect.Effect<void> =>
-    Effect.tryPromise(() => step.sleep(name, duration)),
-  sleepUntil: (name: string, timestamp: Date | number): Effect.Effect<void> =>
-    Effect.tryPromise(() =>
-      step.sleepUntil(
-        name,
-        timestamp instanceof Date ? timestamp.toISOString() : timestamp,
-      ),
-    ),
-});
-
-const encodeStreamErrorMarker = (cause: Cause.Cause<unknown>): string => {
-  const failReason = cause.reasons.find(Cause.isFailReason);
-  const error = failReason ? encodeRpcError(failReason.error) : undefined;
-  return (
-    JSON.stringify({
-      _tag: StreamErrorTag,
-      error,
-    } satisfies RpcStreamErrorMarker) + "\n"
-  );
-};
-
-const appendStreamErrors = (s: Stream.Stream<string, unknown>) =>
-  s.pipe(
-    Stream.catchCause((cause) =>
-      Stream.succeed(encodeStreamErrorMarker(cause)),
-    ),
-  );
-
 export const toRpcStream = (stream: Stream.Stream<any, any, any>) =>
   Effect.scoped(
     Effect.gen(function* () {
@@ -690,3 +273,21 @@ export const toRpcStream = (stream: Stream.Stream<any, any, any>) =>
       return Effect.die(Cause.squash(cause));
     }),
   );
+
+const encodeStreamErrorMarker = (cause: Cause.Cause<unknown>): string => {
+  const failReason = cause.reasons.find(Cause.isFailReason);
+  const error = failReason ? encodeRpcError(failReason.error) : undefined;
+  return (
+    JSON.stringify({
+      _tag: StreamErrorTag,
+      error,
+    } satisfies RpcStreamErrorMarker) + "\n"
+  );
+};
+
+const appendStreamErrors = (s: Stream.Stream<string, unknown>) =>
+  s.pipe(
+    Stream.catchCause((cause) =>
+      Stream.succeed(encodeStreamErrorMarker(cause)),
+    ),
+  );