alchemy 2.0.0-beta.42 → 2.0.0-beta.44

package/src/Cloudflare/Zaraz/ZarazEventTypes.ts

@@ -0,0 +1,257 @@
+import type { Simplify } from "effect/Types";
+
+/**
+ * Type-only helpers for Cloudflare Zaraz events.
+ *
+ * These declarations are not an Alchemy EventSource resource and do not send
+ * events at runtime. They only model the browser-side `window.zaraz` API and
+ * Zaraz HTTP event payloads so application code can share an event contract
+ * with infrastructure code.
+ */
+
+/**
+ * A map of Zaraz event names to the properties accepted by each event.
+ *
+ * Use `undefined` for events that do not accept custom properties.
+ */
+export type ZarazEventMap = Record<string, object | undefined>;
+
+type RequireAtLeastOne<T extends object> = {
+  readonly [K in keyof T]-?: Required<Pick<T, K>> & Partial<Omit<T, K>>;
+}[keyof T];
+
+/**
+ * Product properties supported by Cloudflare Zaraz ecommerce events.
+ */
+export type ZarazEcommerceProduct = {
+  readonly product_id?: string;
+  readonly sku?: string;
+  readonly category?: string;
+  readonly name?: string;
+  readonly brand?: string;
+  readonly variant?: string;
+  readonly price?: number;
+  readonly currency?: string;
+  readonly value?: number;
+  readonly quantity?: number;
+  readonly coupon?: string;
+  readonly position?: number;
+};
+
+/**
+ * Order and checkout properties supported by Cloudflare Zaraz ecommerce events.
+ */
+export type ZarazEcommerceOrder = {
+  readonly checkout_id?: string;
+  readonly order_id?: string;
+  readonly affiliation?: string;
+  readonly total?: number;
+  readonly revenue?: number;
+  readonly shipping?: number;
+  readonly tax?: number;
+  readonly discount?: number;
+  readonly coupon?: string;
+  readonly currency?: string;
+  readonly products?: readonly ZarazEcommerceProduct[];
+};
+
+export type ZarazEcommercePromotion = {
+  readonly creative?: string;
+};
+
+export type ZarazEcommerceSearch = {
+  readonly query?: string;
+};
+
+export type ZarazEcommerceCheckoutStep = {
+  readonly step?: number;
+};
+
+export type ZarazEcommercePayment = {
+  readonly payment_type?: string;
+};
+
+export type ZarazEcommerceRefund = {
+  readonly amount?: number;
+  readonly amount_refunded?: number;
+  readonly currency?: string;
+  readonly refund_reason?: string;
+};
+
+/**
+ * Standard ecommerce events supported by Cloudflare's `zaraz.ecommerce()` API.
+ */
+export type ZarazEcommerceEvents = {
+  readonly "Product List Viewed": RequireAtLeastOne<
+    Pick<ZarazEcommerceOrder, "products">
+  >;
+  readonly "Products Searched": RequireAtLeastOne<ZarazEcommerceSearch>;
+  readonly "Product Clicked": RequireAtLeastOne<ZarazEcommerceProduct>;
+  readonly "Product Added": RequireAtLeastOne<ZarazEcommerceProduct>;
+  readonly "Product Added to Wishlist": RequireAtLeastOne<ZarazEcommerceProduct>;
+  readonly "Product Removed": RequireAtLeastOne<ZarazEcommerceProduct>;
+  readonly "Product Viewed": RequireAtLeastOne<ZarazEcommerceProduct>;
+  readonly "Cart Viewed": RequireAtLeastOne<ZarazEcommerceOrder>;
+  readonly "Checkout Started": RequireAtLeastOne<ZarazEcommerceOrder>;
+  readonly "Checkout Step Viewed": RequireAtLeastOne<ZarazEcommerceCheckoutStep>;
+  readonly "Checkout Step Completed": RequireAtLeastOne<ZarazEcommerceCheckoutStep>;
+  readonly "Payment Info Entered": RequireAtLeastOne<ZarazEcommercePayment>;
+  readonly "Order Completed": RequireAtLeastOne<ZarazEcommerceOrder>;
+  readonly "Order Updated": RequireAtLeastOne<ZarazEcommerceOrder>;
+  readonly "Order Refunded": RequireAtLeastOne<
+    ZarazEcommerceOrder & ZarazEcommerceRefund
+  >;
+  readonly "Order Cancelled": RequireAtLeastOne<ZarazEcommerceOrder>;
+  readonly "Clicked Promotion": RequireAtLeastOne<ZarazEcommercePromotion>;
+  readonly "Viewed Promotion": RequireAtLeastOne<ZarazEcommercePromotion>;
+  readonly "Shipping Info Entered": RequireAtLeastOne<ZarazEcommerceOrder>;
+};
+
+declare const ZarazEventContractTypeId: unique symbol;
+
+/**
+ * Type-only contract for an application's Zaraz events.
+ *
+ * The runtime value is intentionally empty. Application browser code should
+ * import derived types and call Cloudflare's injected `window.zaraz` API rather
+ * than importing Alchemy runtime code into the client bundle.
+ */
+export type ZarazEventContract<
+  Events extends ZarazEventMap,
+  EcommerceEvents extends ZarazEventMap = {},
+> = {
+  readonly [ZarazEventContractTypeId]: {
+    readonly events: Events;
+    readonly ecommerceEvents: EcommerceEvents;
+  };
+};
+
+/**
+ * Define an application's Zaraz event contract.
+ *
+ * @example
+ * ```typescript
+ * const zaraz = Cloudflare.ZarazConfig.events<{
+ *   Login: { method: "google" | "email" | "email-link" };
+ *   "Button Clicked": { button_label: string; context?: string };
+ * }>();
+ *
+ * const zarazWithEcommerce = Cloudflare.ZarazConfig.events<{
+ *   Login: { method: "google" | "email" | "email-link" };
+ * }>({ ecommerce: true });
+ *
+ * export type AppZarazEvents = Cloudflare.InferZarazEvents<typeof zaraz>;
+ * ```
+ */
+export function defineZarazEvents<const Events extends ZarazEventMap>(options: {
+  readonly ecommerce: true;
+}): ZarazEventContract<Events, ZarazEcommerceEvents>;
+export function defineZarazEvents<
+  const Events extends ZarazEventMap,
+>(options?: { readonly ecommerce?: false }): ZarazEventContract<Events, {}>;
+export function defineZarazEvents<
+  const Events extends ZarazEventMap,
+>(_options?: {
+  readonly ecommerce?: boolean;
+}): ZarazEventContract<Events, ZarazEventMap> {
+  return {} as ZarazEventContract<Events, {}>;
+}
+
+export type InferZarazEvents<Contract> =
+  Contract extends ZarazEventContract<infer Events, ZarazEventMap>
+    ? Events
+    : never;
+
+export type InferZarazEcommerceEvents<Contract> =
+  Contract extends ZarazEventContract<ZarazEventMap, infer EcommerceEvents>
+    ? EcommerceEvents
+    : never;
+
+export type ZarazEventName<Events extends ZarazEventMap> = Extract<
+  keyof Events,
+  string
+>;
+
+export type ZarazEventProperties<
+  Events extends ZarazEventMap,
+  Name extends ZarazEventName<Events>,
+> = Events[Name];
+
+type ZarazEventPropertiesArgs<Properties> = [Properties] extends [undefined]
+  ? [properties?: undefined]
+  : undefined extends Properties
+    ? [properties?: Exclude<Properties, undefined>]
+    : [properties: Properties];
+
+/**
+ * Type for Cloudflare's injected `window.zaraz.track` function.
+ */
+export type ZarazTrack<Events extends ZarazEventMap> = <
+  const Name extends ZarazEventName<Events>,
+>(
+  eventName: Name,
+  ...args: ZarazEventPropertiesArgs<Events[Name]>
+) => Promise<void>;
+
+/**
+ * Type for Cloudflare's injected `window.zaraz.ecommerce` function.
+ */
+export type ZarazEcommerce<Events extends ZarazEventMap> = ZarazTrack<Events>;
+
+export type ZarazSetScope = "page" | "session" | "persist";
+
+/**
+ * Type for Cloudflare's injected browser-side Zaraz API.
+ */
+export type ZarazWebApi<
+  Events extends ZarazEventMap,
+  EcommerceEvents extends ZarazEventMap = {},
+> = {
+  set: (
+    name: string,
+    value: unknown,
+    options?: { scope?: ZarazSetScope },
+  ) => void;
+  track: ZarazTrack<Events>;
+  ecommerce: ZarazEcommerce<EcommerceEvents>;
+  preview: (debugKey: string) => Promise<void>;
+  debug: (debugKey: string) => Promise<void>;
+  showConsentModal: () => Promise<void>;
+  pageVariables: Record<string, unknown>;
+};
+
+export type ZarazSystem = {
+  cookies?: Record<string, unknown>;
+  device?: {
+    ip?: string;
+    resolution?: string;
+    viewport?: string;
+    language?: string;
+    "user-agent"?: string;
+  };
+  page?: {
+    title?: string;
+    url?: string;
+    referrer?: string;
+    encoding?: string;
+  };
+};
+
+export type ZarazClientProperties<
+  Events extends ZarazEventMap,
+  Name extends ZarazEventName<Events> = ZarazEventName<Events>,
+> =
+  Name extends ZarazEventName<Events>
+    ? Events[Name] extends undefined
+      ? { readonly __zarazTrack: Name }
+      : Simplify<Events[Name] & { readonly __zarazTrack: Name }>
+    : never;
+
+export type ZarazHttpEvent<Events extends ZarazEventMap> = {
+  readonly client: ZarazClientProperties<Events>;
+  readonly system?: ZarazSystem;
+};
+
+export type ZarazHttpEventsPayload<Events extends ZarazEventMap> = {
+  readonly events: readonly ZarazHttpEvent<Events>[];
+};

package/src/Cloudflare/Zaraz/index.ts

@@ -0,0 +1,25 @@
+export * from "./ZarazConfig.ts";
+export type {
+  InferZarazEcommerceEvents,
+  InferZarazEvents,
+  ZarazClientProperties,
+  ZarazEcommerce,
+  ZarazEcommerceCheckoutStep,
+  ZarazEcommerceEvents,
+  ZarazEcommerceOrder,
+  ZarazEcommercePayment,
+  ZarazEcommerceProduct,
+  ZarazEcommercePromotion,
+  ZarazEcommerceRefund,
+  ZarazEcommerceSearch,
+  ZarazEventContract,
+  ZarazEventMap,
+  ZarazEventName,
+  ZarazEventProperties,
+  ZarazHttpEvent,
+  ZarazHttpEventsPayload,
+  ZarazSetScope,
+  ZarazSystem,
+  ZarazTrack,
+  ZarazWebApi,
+} from "./ZarazEventTypes.ts";

package/src/Cloudflare/index.ts

@@ -21,3 +21,4 @@ export * from "./VpcService/index.ts";
 export * from "./Website/index.ts";
 export * from "./Workers/index.ts";
 export * from "./Workers/RpcAsync.ts";
+export * from "./Zaraz/index.ts";

package/src/Local/RpcProvider.ts

@@ -0,0 +1,102 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { Scope } from "effect/Scope";
+import type { Platform } from "../Platform.ts";
+import * as Provider from "../Provider.ts";
+import type { ResourceClass, ResourceLike } from "../Resource.ts";
+import { RpcProviderProxy } from "./RpcProviderProxy.ts";
+
+/**
+ * Constructs an RpcProvider for a given resource.
+ *
+ * An RpcProvider is a resource provider that can run in a separate process.
+ * This is used for local development so that the resource provider and its state can outlive the user's code when it is hot-reloaded.
+ * If the {@link RpcProviderProxy} is provided, the provider is run in a separate process, which we communicate with here using a websocket.
+ * Otherwise, the given effect is used to construct the provider directly.
+ *
+ * @note If the provider is running in a separate process, you may not need to construct all of its layers in this process.
+ *       You can use {@link providerServices} or {@link providerServicesEffect} to construct such layers only when they are needed.
+ *
+ * @example
+ * ```ts
+ * export const MyProvider = RpcProvider.effect(
+ *   MyResource,
+ *   import.meta.resolve("./my-rpc-provider-server.ts"),
+ *   Effect.gen(function* () {
+ *     return {
+ *       diff: ...,
+ *       reconcile: ...,
+ *       delete: ...,
+ *     }
+ *   })
+ * )
+ * ```
+ *
+ * @param cls - The tag of the resource class to construct a provider for.
+ * @param serverEntryUrl - The main file for the server entry point, if the provider is to be run in a separate process. This is typically obtained using `import.meta.url` or `import.meta.resolve`.
+ * @param eff - The Effect to use to construct the provider.
+ * @returns A layer containing the RpcProvider.
+ */
+export const effect = <
+  R extends ResourceLike,
+  Req = never,
+  ReadReq = never,
+  DiffReq = never,
+  PrecreateReq = never,
+  ReconcileReq = never,
+  DeleteReq = never,
+  TailReq = never,
+  LogsReq = never,
+>(
+  cls: ResourceClass<R> | Platform<R, any, any, any, any>,
+  serverEntryUrl: string,
+  eff: Effect.Effect<
+    Provider.ProviderService<
+      R,
+      ReadReq,
+      DiffReq,
+      PrecreateReq,
+      ReconcileReq,
+      DeleteReq,
+      TailReq,
+      LogsReq
+    >,
+    never,
+    Req
+  >,
+) =>
+  Provider.effect(
+    cls,
+    Effect.gen(function* () {
+      const client = yield* Effect.serviceOption(RpcProviderProxy);
+      if (client._tag === "None") return yield* eff;
+      return yield* client.value.get(serverEntryUrl, cls.Type);
+    }),
+  );
+
+/**
+ * Conditionally constructs a layer for use by an RpcProvider.
+ * If the {@link RpcProviderProxy} is present in context, the layer is empty because it will not be used in this process.
+ * Otherwise, the given layer is returned.
+ * @param self - The layer that is used by the RpcProvider.
+ * @returns A layer that is empty if the {@link RpcProviderProxy} is present in context, otherwise the given layer.
+ */
+export const providerServices = <ROut, E, RIn>(
+  self: Layer.Layer<ROut, E, RIn>,
+): Layer.Layer<ROut, E, RIn> => providerServicesEffect(Effect.succeed(self));
+
+/**
+ * Conditionally constructs a layer for use by an RpcProvider.
+ * If the {@link RpcProviderProxy} is present in context, the layer is empty because it will not be used in this process.
+ * Otherwise, the given layer is returned.
+ * @param self - An effect which returns a layer that is used by the RpcProvider.
+ */
+export const providerServicesEffect = <A, E1, R1, E, R>(
+  self: Effect.Effect<Layer.Layer<A, E1, R1>, E, R>,
+): Layer.Layer<A, E | E1, R1 | Exclude<R, Scope>> =>
+  Effect.serviceOption(RpcProviderProxy).pipe(
+    Effect.flatMap((client) =>
+      client._tag === "None" ? self : (Effect.succeed(Layer.empty) as never),
+    ),
+    Layer.unwrap,
+  );

package/src/Local/RpcProviderProxy.ts

@@ -0,0 +1,86 @@
+import { newWebSocketRpcSession, type RpcStub } from "capnweb";
+import * as Cache from "effect/Cache";
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as HttpBody from "effect/unstable/http/HttpBody";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import { AlchemyContext } from "../AlchemyContext.ts";
+import type { ProviderService } from "../Provider.ts";
+import type { ResourceLike } from "../Resource.ts";
+import { Stack } from "../Stack.ts";
+import { unwrapRpcHandlers } from "./RpcSerialization.ts";
+import type { RpcProxyApi } from "./RpcServer.ts";
+import type { RpcSpawnPayload } from "./RpcSpawner.ts";
+
+export class RpcProviderProxy extends Context.Service<
+  RpcProviderProxy,
+  {
+    readonly get: <R extends ResourceLike>(
+      serverEntryUrl: string,
+      providerName: R["Type"],
+    ) => Effect.Effect<ProviderService<R>, never, AlchemyContext | Stack>;
+  }
+>()("alchemy/Local/RpcProviderProxy") {}
+
+export const SPAWNER_URL_ENV_KEY = "ALCHEMY_RPC_SPAWNER_URL" as const;
+
+const make = Effect.fnUntraced(function* (spawnerUrl: string) {
+  const client = yield* HttpClient.HttpClient;
+
+  const getSession = Effect.fnUntraced(
+    function* (serverEntryUrl: string) {
+      const alchemyContext = yield* AlchemyContext;
+      const stack = yield* Stack;
+      const payload: RpcSpawnPayload = {
+        serverEntryUrl,
+        alchemyContext,
+        stack: { name: stack.name, stage: stack.stage },
+      };
+      const response = yield* client.post(spawnerUrl, {
+        body: yield* HttpBody.json(payload),
+      });
+      const websocketUrl = yield* response.text;
+      return newWebSocketRpcSession(websocketUrl) as RpcStub<RpcProxyApi>;
+    },
+    (effect, serverEntryUrl) =>
+      Effect.catch(effect, (error) =>
+        Effect.die(
+          new Error(
+            `Failed to create provider RPC session for "${serverEntryUrl}"`,
+            {
+              cause: error,
+            },
+          ),
+        ),
+      ),
+  );
+
+  const cache = yield* Cache.make({
+    lookup: getSession,
+    capacity: Infinity,
+    requireServicesAt: "lookup",
+  });
+
+  return RpcProviderProxy.of({
+    get: Effect.fnUntraced(function* (mainUrl, providerName) {
+      const session = yield* cache.lookup(mainUrl);
+      const provider = yield* Effect.promise(
+        () =>
+          session.getProvider(providerName) as ReturnType<
+            RpcProxyApi["getProvider"]
+          >,
+      );
+      return unwrapRpcHandlers(provider, ["tail"]);
+    }),
+  });
+});
+
+export const layer = (url: string) => Layer.effect(RpcProviderProxy, make(url));
+
+export const fromEnv = () =>
+  Layer.effect(
+    RpcProviderProxy,
+    Config.string(SPAWNER_URL_ENV_KEY).pipe(Effect.flatMap(make)),
+  );

package/src/Local/RpcSerialization.ts

@@ -0,0 +1,225 @@
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import { flow } from "effect/Function";
+import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import * as NodeUtil from "node:util";
+import * as Output from "../Output.ts";
+
+type RpcEffectHandler<Args extends Array<any>, Success, Error> = (
+  ...args: Args
+) => Effect.Effect<Success, Error>;
+
+type RpcWrappedEffectHandler<Args extends Array<any>, Success, Error> = (
+  args: Args,
+) => Promise<RpcSerializedExit<Success, Error>>;
+
+type RpcStreamHandler<Args extends Array<any>, Success, Error> = (
+  ...args: Args
+) => Stream.Stream<Success, Error>;
+
+type RpcWrappedStreamHandler<Args extends Array<any>, Success, Error> = (
+  args: Args,
+) => RpcSerializedStream<Success, Error>;
+
+type RpcSerializedStream<Success, _Error> = ReadableStream<Success>;
+
+type RpcSerializedExit<Success, Error> =
+  | { _tag: "Success"; value: Success }
+  | { _tag: "Failure"; cause: Array<RpcSerializedCause<Error>> };
+
+type RpcSerializedCause<Error> =
+  | { _tag: "Fail"; error: Error }
+  | { _tag: "Die"; defect: unknown }
+  | { _tag: "Interrupt"; fiberId: number | undefined };
+
+export type RpcWrapped<T> =
+  T extends RpcEffectHandler<infer Args, infer Success, infer Error>
+    ? RpcWrappedEffectHandler<Args, Success, Error>
+    : T extends RpcStreamHandler<infer Args, infer Success, infer Error>
+      ? RpcWrappedStreamHandler<Args, Success, Error>
+      : T extends Record<string, any>
+        ? { [K in keyof T]: RpcWrapped<T[K]> }
+        : T;
+
+export type RpcUnwrapped<T> =
+  T extends RpcWrappedEffectHandler<infer Args, infer Success, infer Error>
+    ? RpcEffectHandler<Args, Success, Error>
+    : T extends RpcWrappedStreamHandler<infer Args, infer Success, infer Error>
+      ? RpcStreamHandler<Args, Success, Error>
+      : T extends Record<string, any>
+        ? { [K in keyof T]: RpcUnwrapped<T[K]> }
+        : T;
+
+export const wrapRpcHandlers = <T extends Record<string, any>>(
+  handlers: T,
+  streamKeys?: Array<keyof T>,
+): RpcWrapped<T> => {
+  return Object.fromEntries(
+    Object.entries(handlers).map(([key, value]) => [
+      key,
+      typeof value === "function"
+        ? streamKeys?.includes(key)
+          ? wrapRpcStreamHandler(value)
+          : wrapRpcEffectHandler(value)
+        : typeof value === "object" && value !== null
+          ? wrapRpcHandlers(value)
+          : value,
+    ]),
+  ) as RpcWrapped<T>;
+};
+
+export const unwrapRpcHandlers = <T extends Record<string, any>>(
+  handlers: RpcWrapped<T>,
+  streamKeys?: Array<keyof T>,
+): RpcUnwrapped<T> => {
+  return Object.fromEntries(
+    Object.entries(handlers).map(([key, value]) => [
+      key,
+      typeof value === "function"
+        ? streamKeys?.includes(key)
+          ? unwrapRpcStreamHandler(value)
+          : unwrapRpcEffectHandler(value)
+        : typeof value === "object" && value !== null
+          ? unwrapRpcHandlers(value)
+          : value,
+    ]),
+  ) as RpcUnwrapped<T>;
+};
+
+const serializeError = Schema.encodeSync(Schema.Defect);
+
+const wrapRpcEffectHandler = <Args extends Array<any>, Success, Error>(
+  handler: RpcEffectHandler<Args, Success, Error>,
+): RpcWrappedEffectHandler<Args, Success, Error> =>
+  flow(
+    (args) => deserializeRpcArgs(args) as Args,
+    (args) => handler(...args),
+    Effect.exit,
+    Effect.map((exit): RpcSerializedExit<Success, Error> => {
+      if (exit._tag === "Success") {
+        return { _tag: "Success", value: exit.value };
+      }
+      return {
+        _tag: "Failure",
+        cause: exit.cause.reasons.map((reason): RpcSerializedCause<Error> => {
+          switch (reason._tag) {
+            case "Fail":
+              return { _tag: "Fail", error: serializeError(reason.error) };
+            case "Die":
+              return { _tag: "Die", defect: serializeError(reason.defect) };
+            case "Interrupt":
+              return { _tag: "Interrupt", fiberId: reason.fiberId };
+          }
+        }),
+      };
+    }),
+    Effect.runPromise,
+  );
+
+const wrapRpcStreamHandler = <Args extends Array<any>, Success, Error>(
+  handler: RpcStreamHandler<Args, Success, Error>,
+): RpcWrappedStreamHandler<Args, Success, Error> =>
+  flow(
+    (args) => deserializeRpcArgs(args) as Args,
+    (args) => handler(...args),
+    (stream) => Stream.toReadableStream(stream),
+  );
+
+const unwrapRpcEffectHandler = <Args extends Array<any>, Success, Error>(
+  handler: RpcWrappedEffectHandler<Args, Success, Error>,
+): RpcEffectHandler<Args, Success, Error> =>
+  flow(
+    (...args) => serializeRpcArgs(args) as Args,
+    (args) => Effect.promise(() => handler(args)),
+    Effect.flatMap((exit): Exit.Exit<Success, Error> => {
+      if (exit._tag === "Success") {
+        return Exit.succeed(exit.value);
+      }
+      return Exit.failCause(
+        Cause.fromReasons(
+          exit.cause.map((reason): Cause.Reason<Error> => {
+            switch (reason._tag) {
+              case "Fail":
+                return Cause.makeFailReason(reason.error);
+              case "Die":
+                return Cause.makeDieReason(reason.defect);
+              case "Interrupt":
+                return Cause.makeInterruptReason(reason.fiberId);
+            }
+          }),
+        ),
+      );
+    }),
+  );
+
+const unwrapRpcStreamHandler = <Args extends Array<any>, Success, Error>(
+  handler: RpcWrappedStreamHandler<Args, Success, Error>,
+): RpcStreamHandler<Args, Success, Error> =>
+  flow(
+    (...args) => serializeRpcArgs(args) as Args,
+    (args) => handler(args),
+    (stream) =>
+      Stream.fromReadableStream({
+        evaluate: () => stream,
+        onError: (error) => error as Error,
+      }),
+  );
+
+const serializeRpcArgs = (value: unknown): unknown => {
+  if (Redacted.isRedacted(value)) {
+    return { _tag: "Redacted", value: Redacted.value(value) };
+  }
+  if (Output.isOutput(value)) {
+    return {
+      _tag: "Output",
+      description: NodeUtil.inspect(value),
+    };
+  }
+  if (typeof value === "function") {
+    return null;
+  }
+  if (Array.isArray(value)) {
+    return value.map(serializeRpcArgs);
+  }
+  if (value && typeof value === "object" && !("toJSON" in value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, child]) => [
+        key,
+        serializeRpcArgs(child),
+      ]),
+    );
+  }
+  return value;
+};
+
+const deserializeRpcArgs = (value: unknown): unknown => {
+  if (Array.isArray(value)) {
+    return value.map(deserializeRpcArgs);
+  } else if (typeof value === "object" && value !== null) {
+    // These values are serialized as `{_tag: "Redacted", value: ...}` and `{_tag: "Output", description: ...}`,
+    // so we need to detect them manually - Redacted.isRedacted and Output.isOutput do not work.
+    if ("_tag" in value && value._tag === "Redacted" && "value" in value) {
+      return Redacted.make(value.value);
+    } else if (
+      "_tag" in value &&
+      value._tag === "Output" &&
+      "description" in value &&
+      typeof value.description === "string"
+    ) {
+      return new Output.NamedExpr(
+        new Output.EffectExpr(Output.VoidExpr, () => Effect.never),
+        value.description,
+      );
+    }
+    return Object.fromEntries(
+      Object.entries(value).map(([key, child]) => [
+        key,
+        deserializeRpcArgs(child),
+      ]),
+    );
+  }
+  return value;
+};