effect-cf 0.46.0 → 0.47.0

package/src/R2.ts

@@ -1,17 +1,3 @@
-import type {
-  R2Bucket as CloudflareR2Bucket,
-  R2Conditional as CloudflareR2Conditional,
-  R2GetOptions as CloudflareR2GetOptions,
-  R2ListOptions as CloudflareR2ListOptions,
-  R2MultipartOptions as CloudflareR2MultipartOptions,
-  R2MultipartUpload as CloudflareR2MultipartUpload,
-  R2Object as CloudflareR2Object,
-  R2ObjectBody as CloudflareR2ObjectBody,
-  R2Objects as CloudflareR2Objects,
-  R2PutOptions as CloudflareR2PutOptions,
-  R2UploadPartOptions as CloudflareR2UploadPartOptions,
-  R2UploadedPart as CloudflareR2UploadedPart,
-} from "@cloudflare/workers-types";
 import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
@@ -60,19 +46,19 @@ export interface R2Definition {
   readonly binding: string;
 }
 
-export type R2GetOptions = CloudflareR2GetOptions;
-export type R2PutOptions = CloudflareR2PutOptions;
-export type R2ListOptions = CloudflareR2ListOptions;
-export type R2MultipartOptions = CloudflareR2MultipartOptions;
-export type R2UploadPartOptions = CloudflareR2UploadPartOptions;
+export type R2GetOptions = globalThis.R2GetOptions;
+export type R2ListOptions = globalThis.R2ListOptions;
+export type R2MultipartOptions = globalThis.R2MultipartOptions;
+export type R2PutOptions = globalThis.R2PutOptions;
+export type R2UploadPartOptions = globalThis.R2UploadPartOptions;
 export type R2PutValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | null | Blob;
 export type R2UploadPartValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | Blob;
 
 export interface R2ObjectBodyClient extends Omit<
-  CloudflareR2ObjectBody,
+  R2ObjectBody,
   "arrayBuffer" | "blob" | "bytes" | "json" | "text"
 > {
-  readonly raw: CloudflareR2ObjectBody;
+  readonly raw: R2ObjectBody;
   readonly arrayBuffer: Effect.Effect<ArrayBuffer, R2OperationError>;
   readonly bytes: Effect.Effect<Uint8Array, R2OperationError>;
   readonly text: Effect.Effect<string, R2OperationError>;
@@ -81,29 +67,27 @@ export interface R2ObjectBodyClient extends Omit<
 }
 
 export interface R2MultipartUploadClient {
-  readonly raw: CloudflareR2MultipartUpload;
+  readonly raw: R2MultipartUpload;
   readonly key: string;
   readonly uploadId: string;
   readonly uploadPart: (
     partNumber: number,
     value: R2UploadPartValue,
     options?: R2UploadPartOptions,
-  ) => Effect.Effect<CloudflareR2UploadedPart, R2OperationError>;
+  ) => Effect.Effect<R2UploadedPart, R2OperationError>;
   readonly abort: Effect.Effect<void, R2OperationError>;
   readonly complete: (
-    uploadedParts: ReadonlyArray<CloudflareR2UploadedPart>,
-  ) => Effect.Effect<CloudflareR2Object, R2OperationError>;
+    uploadedParts: ReadonlyArray<R2UploadedPart>,
+  ) => Effect.Effect<R2Object, R2OperationError>;
 }
 
 export interface R2Client {
-  readonly head: (
-    key: string,
-  ) => Effect.Effect<Option.Option<CloudflareR2Object>, R2OperationError>;
+  readonly head: (key: string) => Effect.Effect<Option.Option<R2Object>, R2OperationError>;
   readonly get: {
     (
       key: string,
-      options: R2GetOptions & { readonly onlyIf: CloudflareR2Conditional | Headers },
-    ): Effect.Effect<Option.Option<R2ObjectBodyClient | CloudflareR2Object>, R2OperationError>;
+      options: R2GetOptions & { readonly onlyIf: R2Conditional | Headers },
+    ): Effect.Effect<Option.Option<R2ObjectBodyClient | R2Object>, R2OperationError>;
     (
       key: string,
       options?: R2GetOptions,
@@ -113,13 +97,13 @@ export interface R2Client {
     (
       key: string,
       value: R2PutValue,
-      options: R2PutOptions & { readonly onlyIf: CloudflareR2Conditional | Headers },
-    ): Effect.Effect<Option.Option<CloudflareR2Object>, R2OperationError>;
+      options: R2PutOptions & { readonly onlyIf: R2Conditional | Headers },
+    ): Effect.Effect<Option.Option<R2Object>, R2OperationError>;
     (
       key: string,
       value: R2PutValue,
       options?: R2PutOptions,
-    ): Effect.Effect<CloudflareR2Object, R2OperationError>;
+    ): Effect.Effect<R2Object, R2OperationError>;
   };
   readonly createMultipartUpload: (
     key: string,
@@ -130,8 +114,8 @@ export interface R2Client {
     uploadId: string,
   ) => Effect.Effect<R2MultipartUploadClient, R2OperationError>;
   readonly delete: (keys: string | ReadonlyArray<string>) => Effect.Effect<void, R2OperationError>;
-  readonly list: (options?: R2ListOptions) => Effect.Effect<CloudflareR2Objects, R2OperationError>;
-  readonly rawUnsafe: Effect.Effect<CloudflareR2Bucket>;
+  readonly list: (options?: R2ListOptions) => Effect.Effect<R2Objects, R2OperationError>;
+  readonly rawUnsafe: Effect.Effect<R2Bucket>;
   readonly definition: R2Definition;
 }
 
@@ -189,9 +173,7 @@ const spanOptions = (binding: string, operation: R2Operation) => ({
   attributes: { binding, operation },
 });
 
-const isR2ObjectBody = (
-  value: CloudflareR2ObjectBody | CloudflareR2Object,
-): value is CloudflareR2ObjectBody =>
+const isR2ObjectBody = (value: R2ObjectBody | R2Object): value is R2ObjectBody =>
   "body" in value &&
   Predicate.isFunction(value.arrayBuffer) &&
   Predicate.isFunction(value.bytes) &&
@@ -199,7 +181,7 @@ const isR2ObjectBody = (
   Predicate.isFunction(value.json) &&
   Predicate.isFunction(value.blob);
 
-const wrapObjectBody = (binding: string, object: CloudflareR2ObjectBody): R2ObjectBodyClient => ({
+const wrapObjectBody = (binding: string, object: R2ObjectBody): R2ObjectBodyClient => ({
   key: object.key,
   version: object.version,
   size: object.size,
@@ -238,8 +220,8 @@ const wrapObjectBody = (binding: string, object: CloudflareR2ObjectBody): R2Obje
 
 const wrapGetResult = (
   binding: string,
-  object: CloudflareR2ObjectBody | CloudflareR2Object | null,
-): R2ObjectBodyClient | CloudflareR2Object | null => {
+  object: R2ObjectBody | R2Object | null,
+): R2ObjectBodyClient | R2Object | null => {
   if (object === null || !isR2ObjectBody(object)) {
     return object;
   }
@@ -250,7 +232,7 @@ const wrapGetResult = (
 type R2BindingValue = Schema.Schema.Type<typeof Schema.Unknown>;
 
 const R2BucketSchema = Schema.declare(
-  (value: R2BindingValue): value is CloudflareR2Bucket =>
+  (value: R2BindingValue): value is R2Bucket =>
     Predicate.hasProperty(value, "head") &&
     Predicate.isFunction(value.head) &&
     Predicate.hasProperty(value, "get") &&
@@ -268,13 +250,11 @@ const R2BucketSchema = Schema.declare(
 );
 const decodeR2Bucket = Schema.decodeUnknownOption(R2BucketSchema);
 
-export const isR2Bucket = (value: R2BindingValue): value is CloudflareR2Bucket =>
+export const isR2Bucket = (value: R2BindingValue): value is R2Bucket =>
   Option.isSome(decodeR2Bucket(value));
 
-export const makeClient = (
-  definition: R2Definition,
-): ((bucket: CloudflareR2Bucket) => R2Client) => {
-  const wrapUpload = (upload: CloudflareR2MultipartUpload): R2MultipartUploadClient => ({
+export const makeClient = (definition: R2Definition): ((bucket: R2Bucket) => R2Client) => {
+  const wrapUpload = (upload: R2MultipartUpload): R2MultipartUploadClient => ({
     raw: upload,
     key: upload.key,
     uploadId: upload.uploadId,
@@ -295,7 +275,7 @@ export const makeClient = (
     complete: Effect.fn(
       "R2.completeMultipartUpload",
       spanOptions(definition.binding, "completeMultipartUpload"),
-    )((uploadedParts: ReadonlyArray<CloudflareR2UploadedPart>) =>
+    )((uploadedParts: ReadonlyArray<R2UploadedPart>) =>
       tryR2Promise(definition.binding, "completeMultipartUpload", () =>
         upload.complete([...uploadedParts]),
       ),
@@ -332,7 +312,7 @@ export const makeClient = (
         tryR2Promise(definition.binding, "put", () => bucket.put(key, value, options)).pipe(
           Effect.map((object) => {
             if (object === null) {
-              return Option.none<CloudflareR2Object>();
+              return Option.none<R2Object>();
             }
 
             if (options !== undefined && "onlyIf" in options) {

package/src/RpcWebSocketClient.ts

@@ -0,0 +1,45 @@
+import type * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import type * as Rpc from "effect/unstable/rpc/Rpc";
+import * as RpcClient from "effect/unstable/rpc/RpcClient";
+import type { RpcClientError } from "effect/unstable/rpc/RpcClientError";
+import type * as RpcGroup from "effect/unstable/rpc/RpcGroup";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+import * as Socket from "effect/unstable/socket/Socket";
+
+export interface LayerOptions {
+  readonly socket?: Parameters<typeof Socket.layerWebSocket>[1];
+  readonly protocol?: Parameters<typeof RpcClient.layerProtocolSocket>[0];
+  readonly client?: Omit<NonNullable<Parameters<typeof RpcClient.make>[1]>, "flatten">;
+  /** Must match the server's serialization. Defaults to Effect RPC JSON. */
+  readonly serialization?: RpcSerialization.RpcSerialization["Service"] | undefined;
+}
+
+/**
+ * Provides a typed RPC client and its WebSocket transport for the layer's lifetime.
+ * Callers yield the service without supplying a Scope. Provide this layer once
+ * around the application or session to share the connection across calls.
+ *
+ * Provide Socket.layerWebSocketConstructorGlobal in browsers, or a platform's
+ * WebSocketConstructor layer elsewhere. Streaming RPCs returned as queues still
+ * require a consumer scope; ordinary Stream operations manage their own scopes.
+ */
+export const layer = <I, Rpcs extends Rpc.Any>(
+  service: Context.Key<I, RpcClient.RpcClient<Rpcs, RpcClientError>>,
+  group: RpcGroup.RpcGroup<Rpcs>,
+  url: Parameters<typeof Socket.layerWebSocket>[0],
+  options: LayerOptions = {},
+): Layer.Layer<I, never, Socket.WebSocketConstructor | Rpc.MiddlewareClient<Rpcs>> =>
+  Layer.effect(service, RpcClient.make(group, options.client)).pipe(
+    Layer.provide(
+      RpcClient.layerProtocolSocket(options.protocol).pipe(
+        Layer.provide(Socket.layerWebSocket(url, options.socket)),
+        Layer.provide(
+          Layer.succeed(
+            RpcSerialization.RpcSerialization,
+            options.serialization ?? RpcSerialization.json,
+          ),
+        ),
+      ),
+    ),
+  );

package/src/Vectorize.ts

@@ -5,22 +5,6 @@ import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
 import * as Schema from "effect/Schema";
 import type { Layer } from "effect";
-import type {
-  Vectorize as CloudflareVectorize,
-  VectorizeAsyncMutation as CloudflareVectorizeAsyncMutation,
-  VectorizeIndex as CloudflareVectorizeIndex,
-  VectorizeIndexDetails as CloudflareVectorizeIndexDetails,
-  VectorizeIndexInfo as CloudflareVectorizeIndexInfo,
-  VectorizeMatch as CloudflareVectorizeMatch,
-  VectorizeMatches as CloudflareVectorizeMatches,
-  VectorizeQueryOptions as CloudflareVectorizeQueryOptions,
-  VectorizeVector as CloudflareVectorizeVector,
-  VectorizeVectorMetadata as CloudflareVectorizeVectorMetadata,
-  VectorizeVectorMetadataFilter as CloudflareVectorizeVectorMetadataFilter,
-  VectorizeVectorMetadataValue as CloudflareVectorizeVectorMetadataValue,
-  VectorizeVectorMutation as CloudflareVectorizeVectorMutation,
-} from "@cloudflare/workers-types";
-
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import * as ErrorMessage from "./internal/ErrorMessage";
@@ -53,19 +37,17 @@ export interface VectorizeDefinition {
   readonly binding: string;
 }
 
-export type VectorizeBinding = CloudflareVectorize | CloudflareVectorizeIndex;
-export type VectorizeVector = CloudflareVectorizeVector;
-export type VectorizeVectorMetadata = CloudflareVectorizeVectorMetadata;
-export type VectorizeVectorMetadataValue = CloudflareVectorizeVectorMetadataValue;
-export type VectorizeVectorMetadataFilter = CloudflareVectorizeVectorMetadataFilter;
-export type VectorizeQueryOptions = CloudflareVectorizeQueryOptions;
-export type VectorizeMatches = CloudflareVectorizeMatches;
-export type VectorizeMatch = CloudflareVectorizeMatch;
-export type VectorizeIndexInfo = CloudflareVectorizeIndexInfo;
-export type VectorizeIndexDetails = CloudflareVectorizeIndexDetails;
-export type VectorizeMutation =
-  | CloudflareVectorizeAsyncMutation
-  | CloudflareVectorizeVectorMutation;
+export type VectorizeBinding = Vectorize | VectorizeIndex;
+export type VectorizeIndexDetails = globalThis.VectorizeIndexDetails;
+export type VectorizeIndexInfo = globalThis.VectorizeIndexInfo;
+export type VectorizeMatch = globalThis.VectorizeMatch;
+export type VectorizeMatches = globalThis.VectorizeMatches;
+export type VectorizeQueryOptions = globalThis.VectorizeQueryOptions;
+export type VectorizeVector = globalThis.VectorizeVector;
+export type VectorizeVectorMetadata = globalThis.VectorizeVectorMetadata;
+export type VectorizeVectorMetadataFilter = globalThis.VectorizeVectorMetadataFilter;
+export type VectorizeVectorMetadataValue = globalThis.VectorizeVectorMetadataValue;
+export type VectorizeMutation = VectorizeAsyncMutation | VectorizeVectorMutation;
 export type VectorizeValues = Float32Array | Float64Array | ReadonlyArray<number>;
 
 interface VectorizeRuntimeBinding {

package/src/WebTransport.ts

@@ -29,7 +29,6 @@
  * {@link inboundTransport} decodes the HTTP/3-relevant request metadata that
  * the edge does provide.
  */
-import type { Request as CloudflareRequest } from "@cloudflare/workers-types";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
@@ -61,9 +60,8 @@ const decodeInboundTransport = S.decodeUnknownResult(InboundTransport);
  * dev` or when a Worker invokes another Worker directly) or does not match
  * the expected shape.
  */
-export const inboundTransport = (
-  request: Pick<CloudflareRequest, "cf">,
-): Option.Option<InboundTransport> => Result.getSuccess(decodeInboundTransport(request.cf));
+export const inboundTransport = (request: Pick<Request, "cf">): Option.Option<InboundTransport> =>
+  Result.getSuccess(decodeInboundTransport(request.cf));
 
 export const isHttp3 = (transport: InboundTransport): boolean =>
   transport.clientQuicRtt !== undefined || transport.httpProtocol === "HTTP/3";

package/src/WorkersAi.ts

@@ -5,18 +5,6 @@ import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
 import * as S from "effect/Schema";
 import type { Layer } from "effect";
-import type {
-  Ai as CloudflareAi,
-  AiAsyncBatchResponse,
-  AiGateway as CloudflareAiGateway,
-  AiModelListType,
-  AiModels,
-  AiModelsSearchObject,
-  AiModelsSearchParams,
-  AiOptions,
-  AiTextEmbeddingsInput,
-  Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Input,
-} from "@cloudflare/workers-types";
 
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
@@ -40,8 +28,7 @@ export interface WorkersAiDefinition {
   readonly binding: string;
 }
 
-export type WorkersAiBinding<ModelList extends AiModelListType = AiModels> =
-  CloudflareAi<ModelList>;
+export type WorkersAiBinding<ModelList extends AiModelListType = AiModels> = Ai<ModelList>;
 export type WorkersAiOptions = AiOptions;
 export type WorkersAiModelsSearchParams = AiModelsSearchParams;
 export type WorkersAiModelsSearchObject = AiModelsSearchObject;
@@ -113,9 +100,7 @@ export interface WorkersAiClient<ModelList extends AiModelListType = AiModels> {
   readonly models: (
     params?: WorkersAiModelsSearchParams,
   ) => Effect.Effect<ReadonlyArray<WorkersAiModelsSearchObject>, WorkersAiOperationError>;
-  readonly gateway: (
-    gatewayId: string,
-  ) => Effect.Effect<CloudflareAiGateway, WorkersAiOperationError>;
+  readonly gateway: (gatewayId: string) => Effect.Effect<AiGateway, WorkersAiOperationError>;
   readonly rawUnsafe: Effect.Effect<WorkersAiBinding<ModelList>>;
   readonly definition: WorkersAiDefinition;
 }

package/src/WorkflowBinding.ts

@@ -1,12 +1,3 @@
-import type {
-  InstanceStatus as CloudflareInstanceStatus,
-  Workflow as CloudflareWorkflow,
-  WorkflowInstance as CloudflareWorkflowInstance,
-  WorkflowInstanceCreateOptions as CloudflareWorkflowInstanceCreateOptions,
-  WorkflowInstanceLocationHint as CloudflareWorkflowInstanceLocationHint,
-  WorkflowInstanceRestartOptions as CloudflareWorkflowInstanceRestartOptions,
-  WorkflowInstanceTerminateOptions as CloudflareWorkflowInstanceTerminateOptions,
-} from "@cloudflare/workers-types";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
@@ -21,7 +12,7 @@ import * as ErrorMessage from "./internal/ErrorMessage";
 const expectedWorkflow = "Workflow binding with create(), createBatch(), and get()";
 
 export type WorkflowInstanceCreateOptions<Payload> = Omit<
-  CloudflareWorkflowInstanceCreateOptions<Payload>,
+  globalThis.WorkflowInstanceCreateOptions<Payload>,
   "params"
 >;
 
@@ -29,11 +20,11 @@ export type WorkflowInstanceCreateBatchOptions<Payload, EncodedPayload = unknown
   { readonly payload: Payload } & WorkflowInstanceCreateOptions<EncodedPayload>
 >;
 
-export type WorkflowInstanceRestartOptions = CloudflareWorkflowInstanceRestartOptions;
-export type WorkflowInstanceTerminateOptions = CloudflareWorkflowInstanceTerminateOptions;
-export type WorkflowInstanceLocationHint = CloudflareWorkflowInstanceLocationHint;
+export type WorkflowInstanceLocationHint = globalThis.WorkflowInstanceLocationHint;
+export type WorkflowInstanceRestartOptions = globalThis.WorkflowInstanceRestartOptions;
+export type WorkflowInstanceTerminateOptions = globalThis.WorkflowInstanceTerminateOptions;
 
-export type WorkflowInstanceStatusName = CloudflareInstanceStatus["status"];
+export type WorkflowInstanceStatusName = InstanceStatus["status"];
 
 export interface WorkflowInstanceStatus<Result> {
   readonly status: WorkflowInstanceStatusName;
@@ -45,7 +36,7 @@ export interface WorkflowInstanceStatus<Result> {
 }
 
 export interface WorkflowInstance<Result> {
-  readonly raw: CloudflareWorkflowInstance;
+  readonly raw: globalThis.WorkflowInstance;
   readonly id: string;
   readonly pause: Effect.Effect<void, WorkflowOperationError>;
   readonly resume: Effect.Effect<void, WorkflowOperationError>;
@@ -97,7 +88,7 @@ export interface WorkflowBindingClient<
   readonly get: (
     instanceId: string,
   ) => Effect.Effect<WorkflowInstance<S.Schema.Type<Result>>, WorkflowOperationError>;
-  readonly rawUnsafe: Effect.Effect<CloudflareWorkflow<S.Codec.Encoded<Payload>>>;
+  readonly rawUnsafe: Effect.Effect<Workflow<S.Codec.Encoded<Payload>>>;
 }
 
 export class WorkflowOperationError extends Data.TaggedError("WorkflowOperationError")<{
@@ -136,7 +127,7 @@ const tryWorkflowPromise = <A>(
 type WorkflowBindingValue = S.Schema.Type<typeof S.Unknown>;
 
 const WorkflowBindingSchema = S.declare(
-  (value: WorkflowBindingValue): value is CloudflareWorkflow<WorkflowBindingValue> =>
+  (value: WorkflowBindingValue): value is Workflow<WorkflowBindingValue> =>
     Predicate.hasProperty(value, "create") &&
     Predicate.isFunction(value.create) &&
     Predicate.hasProperty(value, "createBatch") &&
@@ -146,18 +137,15 @@ const WorkflowBindingSchema = S.declare(
 );
 const decodeWorkflowBinding = S.decodeUnknownOption(WorkflowBindingSchema);
 
-export const isWorkflow = <Payload>(
-  value: WorkflowBindingValue,
-): value is CloudflareWorkflow<Payload> => Option.isSome(decodeWorkflowBinding(value));
+export const isWorkflow = <Payload>(value: WorkflowBindingValue): value is Workflow<Payload> =>
+  Option.isSome(decodeWorkflowBinding(value));
 
 export const makeClient = <
   Payload extends RpcDefinition.ServiceFreeSchema,
   Result extends RpcDefinition.ServiceFreeSchema,
 >(
   definition: WorkflowBindingDefinition<Payload, Result>,
-): ((
-  workflow: CloudflareWorkflow<S.Codec.Encoded<Payload>>,
-) => WorkflowBindingClient<Payload, Result>) => {
+): ((workflow: Workflow<S.Codec.Encoded<Payload>>) => WorkflowBindingClient<Payload, Result>) => {
   type PayloadValue = S.Schema.Type<Payload>;
   type EncodedPayload = S.Codec.Encoded<Payload>;
   type ResultValue = S.Schema.Type<Result>;
@@ -165,7 +153,7 @@ export const makeClient = <
   const encodePayload = S.encodeEffect(definition.payload);
   const decodeResult = S.decodeUnknownEffect(definition.result);
 
-  const wrapInstance = (raw: CloudflareWorkflowInstance): WorkflowInstance<ResultValue> => {
+  const wrapInstance = (raw: globalThis.WorkflowInstance): WorkflowInstance<ResultValue> => {
     const operation = <A>(name: string, evaluate: () => Promise<A>) =>
       tryWorkflowPromise(definition.binding, name, evaluate);
 
@@ -229,7 +217,7 @@ export const makeClient = <
     createBatch: Effect.fn("WorkflowBinding.createBatch", {
       attributes: { binding: definition.binding, operation: "createBatch" },
     })(function* (batch: WorkflowInstanceCreateBatchOptions<PayloadValue, EncodedPayload>) {
-      const encodedBatch: Array<CloudflareWorkflowInstanceCreateOptions<EncodedPayload>> = [];
+      const encodedBatch: Array<globalThis.WorkflowInstanceCreateOptions<EncodedPayload>> = [];
 
       for (const item of batch) {
         const { payload, ...options } = item;
@@ -265,7 +253,7 @@ export const layer = <
   Binding.layer(
     tag,
     definition.binding,
-    (value): value is CloudflareWorkflow<S.Codec.Encoded<Payload>> =>
+    (value): value is Workflow<S.Codec.Encoded<Payload>> =>
       isWorkflow<S.Codec.Encoded<Payload>>(value),
     makeClient(definition),
     { expected: expectedWorkflow },

package/src/index.ts

@@ -30,6 +30,7 @@ export * as Rpc from "./Rpc";
 export * as RpcDefinition from "./RpcDefinition";
 export * as RpcTracing from "./RpcTracing";
 export * as RpcTargets from "./RpcTargets";
+export * as RpcWebSocketClient from "./RpcWebSocketClient";
 export * as ServiceBinding from "./ServiceBinding";
 export * as Vectorize from "./Vectorize";
 export * as WebTransport from "./WebTransport";