@confect/js 10.0.0-next.20 → 10.0.0-next.21

package/dist/internal/WebSocketClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSocketClient.js","names":[],"sources":["../../src/internal/WebSocketClient.ts"],"sourcesContent":["import * as Ref from \"@confect/core/Ref\";\nimport * as Effect from \"effect/Effect\";\nimport * as Queue from \"effect/Queue\";\nimport * as Result from \"effect/Result\";\nimport * as Schema from \"effect/Schema\";\nimport * as Stream from \"effect/Stream\";\n\nexport class WebSocketClientError extends Schema.TaggedError<WebSocketClientError>()(\n  \"WebSocketClientError\",\n  {\n    cause: Schema.Defect(),\n  },\n) {}\n\nexport interface Transport {\n  readonly setAuth: (\n    fetchToken: (args: {\n      readonly forceRefreshToken: boolean;\n    }) => Promise<string | null | undefined>,\n    onChange?: (isAuthenticated: boolean) => void,\n  ) => void;\n  readonly close: () => Promise<void>;\n  readonly query: (\n    functionReference: Ref.FunctionReference<Ref.AnyPublicQuery>,\n    encodedArgs: unknown,\n  ) => PromiseLike<unknown>;\n  readonly mutation: (\n    functionReference: Ref.FunctionReference<Ref.AnyPublicMutation>,\n    encodedArgs: unknown,\n  ) => PromiseLike<unknown>;\n  readonly action: (\n    functionReference: Ref.FunctionReference<Ref.AnyPublicAction>,\n    encodedArgs: unknown,\n  ) => PromiseLike<unknown>;\n  readonly onUpdate: (\n    functionReference: Ref.FunctionReference<Ref.AnyPublicQuery>,\n    encodedArgs: unknown,\n    onUpdate: (result: unknown) => void,\n    onError: (error: Error) => void,\n  ) => () => void;\n}\n\nexport const make = (address: string, convexClient: Transport) => {\n  const setAuth = (\n    fetchToken: (args: {\n      forceRefreshToken: boolean;\n    }) => Effect.Effect<string | null | undefined>,\n    onChange?: (isAuthenticated: boolean) => Effect.Effect<void>,\n  ) =>\n    Effect.sync(() => {\n      convexClient.setAuth(\n        (args) => Effect.runPromise(fetchToken(args)),\n        ...(onChange\n          ? [\n              (isAuthenticated: boolean) =>\n                Effect.runFork(onChange(isAuthenticated)),\n            ]\n          : []),\n      );\n    });\n\n  const mapUnknownError = (cause: unknown) =>\n    new WebSocketClientError({ cause });\n\n  const query = <Query extends Ref.AnyPublicQuery>(\n    ref: Query,\n    ...rest: Ref.OptionalArgs<Query>\n  ): Effect.Effect<\n    Ref.Returns<Query>,\n    Ref.Error<Query> | WebSocketClientError | Schema.SchemaError\n  > => {\n    const args = (rest[0] ?? {}) as Ref.Args<Query>;\n    return Ref.runWithCodec(\n      ref,\n      args,\n      (functionReference, encodedArgs) =>\n        convexClient.query(functionReference, encodedArgs),\n      mapUnknownError,\n    );\n  };\n\n  const mutation = <Mutation extends Ref.AnyPublicMutation>(\n    ref: Mutation,\n    ...rest: Ref.OptionalArgs<Mutation>\n  ): Effect.Effect<\n    Ref.Returns<Mutation>,\n    Ref.Error<Mutation> | WebSocketClientError | Schema.SchemaError\n  > => {\n    const args = (rest[0] ?? {}) as Ref.Args<Mutation>;\n    return Ref.runWithCodec(\n      ref,\n      args,\n      (functionReference, encodedArgs) =>\n        convexClient.mutation(functionReference, encodedArgs),\n      mapUnknownError,\n    );\n  };\n\n  const action = <Action extends Ref.AnyPublicAction>(\n    ref: Action,\n    ...rest: Ref.OptionalArgs<Action>\n  ): Effect.Effect<\n    Ref.Returns<Action>,\n    Ref.Error<Action> | WebSocketClientError | Schema.SchemaError\n  > => {\n    const args = (rest[0] ?? {}) as Ref.Args<Action>;\n    return Ref.runWithCodec(\n      ref,\n      args,\n      (functionReference, encodedArgs) =>\n        convexClient.action(functionReference, encodedArgs),\n      mapUnknownError,\n    );\n  };\n\n  type ReactiveQueryError<Query extends Ref.AnyPublicQuery> =\n    | Ref.Error<Query>\n    | WebSocketClientError\n    | Schema.SchemaError;\n\n  const reactiveQueryResult = <Query extends Ref.AnyPublicQuery>(\n    ref: Query,\n    ...rest: Ref.OptionalArgs<Query>\n  ): Stream.Stream<\n    Result.Result<Ref.Returns<Query>, ReactiveQueryError<Query>>\n  > => {\n    type QueryResult = Result.Result<\n      Ref.Returns<Query>,\n      ReactiveQueryError<Query>\n    >;\n    const args = (rest[0] ?? {}) as Ref.Args<Query>;\n    const functionReference = Ref.getFunctionReference(ref);\n    const onError = Ref.decodeErrorOrElse(ref, mapUnknownError);\n\n    return Stream.unwrap(\n      Effect.match(Ref.encodeArgs(ref, args), {\n        onFailure: (error) => Stream.succeed<QueryResult>(Result.fail(error)),\n        onSuccess: (encodedArgs) =>\n          Stream.callback<Result.Result<unknown, ReactiveQueryError<Query>>>(\n            (queue) =>\n              Effect.gen(function* () {\n                const unsubscribe = convexClient.onUpdate(\n                  functionReference,\n                  encodedArgs,\n                  (result) => {\n                    Queue.offerUnsafe(queue, Result.succeed(result));\n                  },\n                  (error) => {\n                    Queue.offerUnsafe(queue, Result.fail(onError(error)));\n                  },\n                );\n                yield* Effect.addFinalizer(() =>\n                  Effect.sync(() => unsubscribe()),\n                );\n              }),\n          ),\n      }),\n    ).pipe(\n      Stream.mapEffect((result): Effect.Effect<QueryResult> =>\n        Result.match(result, {\n          onFailure: (error) => Effect.succeed(Result.fail(error)),\n          onSuccess: (encodedReturns) =>\n            Effect.match(Ref.decodeReturns(ref, encodedReturns), {\n              onFailure: Result.fail,\n              onSuccess: Result.succeed,\n            }),\n        }),\n      ),\n    );\n  };\n\n  const reactiveQuery = <Query extends Ref.AnyPublicQuery>(\n    ref: Query,\n    ...rest: Ref.OptionalArgs<Query>\n  ): Stream.Stream<Ref.Returns<Query>, ReactiveQueryError<Query>> =>\n    reactiveQueryResult(ref, ...rest).pipe(\n      Stream.mapEffect(\n        Result.match({\n          onFailure: Effect.fail,\n          onSuccess: Effect.succeed,\n        }),\n      ),\n    );\n\n  return {\n    url: address,\n    setAuth,\n    query,\n    mutation,\n    action,\n    reactiveQuery,\n    reactiveQueryResult,\n  };\n};\n\nexport const makeScoped = <E, R>(\n  address: string,\n  acquire: Effect.Effect<Transport, E, R>,\n) =>\n  Effect.acquireRelease(acquire, (convexClient) =>\n    Effect.promise(() => convexClient.close()),\n  ).pipe(Effect.map((convexClient) => make(address, convexClient)));\n"],"mappings":";;;;;;;AAOA,IAAa,uBAAb,cAA0C,OAAO,YAAkC,CAAC,CAClF,wBACA,EACE,OAAO,OAAO,OAAO,EACvB,CACF,CAAC,CAAC,CAAC;AA8BH,MAAa,QAAQ,SAAiB,iBAA4B;CAChE,MAAM,WACJ,YAGA,aAEA,OAAO,WAAW;EAChB,aAAa,SACV,SAAS,OAAO,WAAW,WAAW,IAAI,CAAC,GAC5C,GAAI,WACA,EACG,oBACC,OAAO,QAAQ,SAAS,eAAe,CAAC,CAC5C,IACA,CAAC,CACP;CACF,CAAC;CAEH,MAAM,mBAAmB,UACvB,IAAI,qBAAqB,EAAE,MAAM,CAAC;CAEpC,MAAM,SACJ,KACA,GAAG,SAIA;EACH,MAAM,OAAQ,KAAK,MAAM,CAAC;EAC1B,OAAO,IAAI,aACT,KACA,OACC,mBAAmB,gBAClB,aAAa,MAAM,mBAAmB,WAAW,GACnD,eACF;CACF;CAEA,MAAM,YACJ,KACA,GAAG,SAIA;EACH,MAAM,OAAQ,KAAK,MAAM,CAAC;EAC1B,OAAO,IAAI,aACT,KACA,OACC,mBAAmB,gBAClB,aAAa,SAAS,mBAAmB,WAAW,GACtD,eACF;CACF;CAEA,MAAM,UACJ,KACA,GAAG,SAIA;EACH,MAAM,OAAQ,KAAK,MAAM,CAAC;EAC1B,OAAO,IAAI,aACT,KACA,OACC,mBAAmB,gBAClB,aAAa,OAAO,mBAAmB,WAAW,GACpD,eACF;CACF;CAOA,MAAM,uBACJ,KACA,GAAG,SAGA;EAKH,MAAM,OAAQ,KAAK,MAAM,CAAC;EAC1B,MAAM,oBAAoB,IAAI,qBAAqB,GAAG;EACtD,MAAM,UAAU,IAAI,kBAAkB,KAAK,eAAe;EAE1D,OAAO,OAAO,OACZ,OAAO,MAAM,IAAI,WAAW,KAAK,IAAI,GAAG;GACtC,YAAY,UAAU,OAAO,QAAqB,OAAO,KAAK,KAAK,CAAC;GACpE,YAAY,gBACV,OAAO,UACJ,UACC,OAAO,IAAI,aAAa;IACtB,MAAM,cAAc,aAAa,SAC/B,mBACA,cACC,WAAW;KACV,MAAM,YAAY,OAAO,OAAO,QAAQ,MAAM,CAAC;IACjD,IACC,UAAU;KACT,MAAM,YAAY,OAAO,OAAO,KAAK,QAAQ,KAAK,CAAC,CAAC;IACtD,CACF;IACA,OAAO,OAAO,mBACZ,OAAO,WAAW,YAAY,CAAC,CACjC;GACF,CAAC,CACL;EACJ,CAAC,CACH,CAAC,CAAC,KACA,OAAO,WAAW,WAChB,OAAO,MAAM,QAAQ;GACnB,YAAY,UAAU,OAAO,QAAQ,OAAO,KAAK,KAAK,CAAC;GACvD,YAAY,mBACV,OAAO,MAAM,IAAI,cAAc,KAAK,cAAc,GAAG;IACnD,WAAW,OAAO;IAClB,WAAW,OAAO;GACpB,CAAC;EACL,CAAC,CACH,CACF;CACF;CAEA,MAAM,iBACJ,KACA,GAAG,SAEH,oBAAoB,KAAK,GAAG,IAAI,CAAC,CAAC,KAChC,OAAO,UACL,OAAO,MAAM;EACX,WAAW,OAAO;EAClB,WAAW,OAAO;CACpB,CAAC,CACH,CACF;CAEF,OAAO;EACL,KAAK;EACL;EACA;EACA;EACA;EACA;EACA;CACF;AACF;AAEA,MAAa,cACX,SACA,YAEA,OAAO,eAAe,UAAU,iBAC9B,OAAO,cAAc,aAAa,MAAM,CAAC,CAC3C,CAAC,CAAC,KAAK,OAAO,KAAK,iBAAiB,KAAK,SAAS,YAAY,CAAC,CAAC"}

package/package.json

@@ -1,22 +1,22 @@
 {
   "name": "@confect/js",
   "description": "JavaScript client bindings for any JS runtime",
-  "version": "10.0.0-next.20",
+  "version": "10.0.0-next.21",
   "author": "RJ Dellecese",
   "bugs": {
     "url": "https://github.com/rjdellecese/confect/issues"
   },
   "devDependencies": {
     "@effect/vitest": "4.0.0-rc.112",
-    "@types/node": "22.20.1",
+    "@types/node": "24.13.3",
     "effect": "4.0.0-rc.112",
     "tsdown": "0.22.14",
     "typescript": "7.0.2",
     "unrun": "0.3.1",
-    "vitest": "4.1.10"
+    "vitest": "4.1.11"
   },
   "engines": {
-    "node": ">=22"
+    "node": ">=24"
   },
   "exports": {
     ".": {
@@ -47,9 +47,9 @@
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "peerDependencies": {
+    "@confect/core": "^10.0.0-next.21",
     "convex": "^1.32.0",
-    "effect": "^4.0.0-rc.112",
-    "@confect/core": "^10.0.0-next.20"
+    "effect": "^4.0.0-rc.112"
   },
   "repository": {
     "type": "git",

package/src/HttpClient.ts

@@ -1,95 +1,26 @@
-import * as Ref from "@confect/core/Ref";
 import { ConvexHttpClient } from "convex/browser";
 import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import * as Schema from "effect/Schema";
+import * as InternalHttpClient from "./internal/HttpClient";
 
-export class HttpClientError extends Schema.TaggedError<HttpClientError>()(
-  "HttpClientError",
-  {
-    cause: Schema.Unknown,
-  },
-) {}
+export { HttpClientError } from "./internal/HttpClient";
 
 const make = (
   address: string,
   options?: ConstructorParameters<typeof ConvexHttpClient>[1],
 ) => {
   const client = new ConvexHttpClient(address, options);
-
-  const url = client.url;
-
-  const setAuth = (token: string) =>
-    Effect.sync(() => {
-      client.setAuth(token);
-    });
-
-  const clearAuth = Effect.sync(() => {
-    client.clearAuth();
+  return InternalHttpClient.make({
+    url: client.url,
+    setAuth: (token) => client.setAuth(token),
+    clearAuth: () => client.clearAuth(),
+    query: (functionReference, encodedArgs) =>
+      client.query(functionReference, encodedArgs),
+    mutation: (functionReference, encodedArgs) =>
+      client.mutation(functionReference, encodedArgs),
+    action: (functionReference, encodedArgs) =>
+      client.action(functionReference, encodedArgs),
   });
-
-  const mapUnknownError = (cause: unknown) => new HttpClientError({ cause });
-
-  const query = <Query extends Ref.AnyPublicQuery>(
-    ref: Query,
-    ...rest: Ref.OptionalArgs<Query>
-  ): Effect.Effect<
-    Ref.Returns<Query>,
-    Ref.Error<Query> | HttpClientError | Schema.SchemaError
-  > => {
-    const args = (rest[0] ?? {}) as Ref.Args<Query>;
-    return Ref.runWithCodec(
-      ref,
-      args,
-      (functionReference, encodedArgs) =>
-        client.query(functionReference, encodedArgs),
-      mapUnknownError,
-    );
-  };
-
-  const mutation = <Mutation extends Ref.AnyPublicMutation>(
-    ref: Mutation,
-    ...rest: Ref.OptionalArgs<Mutation>
-  ): Effect.Effect<
-    Ref.Returns<Mutation>,
-    Ref.Error<Mutation> | HttpClientError | Schema.SchemaError
-  > => {
-    const args = (rest[0] ?? {}) as Ref.Args<Mutation>;
-    return Ref.runWithCodec(
-      ref,
-      args,
-      (functionReference, encodedArgs) =>
-        client.mutation(functionReference, encodedArgs),
-      mapUnknownError,
-    );
-  };
-
-  const action = <Action extends Ref.AnyPublicAction>(
-    ref: Action,
-    ...rest: Ref.OptionalArgs<Action>
-  ): Effect.Effect<
-    Ref.Returns<Action>,
-    Ref.Error<Action> | HttpClientError | Schema.SchemaError
-  > => {
-    const args = (rest[0] ?? {}) as Ref.Args<Action>;
-    return Ref.runWithCodec(
-      ref,
-      args,
-      (functionReference, encodedArgs) =>
-        client.action(functionReference, encodedArgs),
-      mapUnknownError,
-    );
-  };
-
-  return {
-    url,
-    setAuth,
-    clearAuth,
-    query,
-    mutation,
-    action,
-  };
 };
 
 /**

package/src/WebSocketClient.ts

@@ -1,182 +1,38 @@
-import * as Ref from "@confect/core/Ref";
 import { ConvexClient } from "convex/browser";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import * as Queue from "effect/Queue";
-import * as Result from "effect/Result";
-import * as Schema from "effect/Schema";
-import * as Stream from "effect/Stream";
+import * as InternalWebSocketClient from "./internal/WebSocketClient";
 
-export class WebSocketClientError extends Schema.TaggedError<WebSocketClientError>()(
-  "WebSocketClientError",
-  {
-    cause: Schema.Defect(),
-  },
-) {}
+export { WebSocketClientError } from "./internal/WebSocketClient";
 
 const make = (
   address: string,
   options?: ConstructorParameters<typeof ConvexClient>[1],
 ) =>
-  Effect.acquireRelease(
-    Effect.sync(() => new ConvexClient(address, options)),
-    (convexClient) => Effect.promise(() => convexClient.close()),
-  ).pipe(
-    Effect.map((convexClient) => {
-      const url = address;
-
-      const setAuth = (
-        fetchToken: (args: {
-          forceRefreshToken: boolean;
-        }) => Effect.Effect<string | null | undefined>,
-        onChange?: (isAuthenticated: boolean) => Effect.Effect<void>,
-      ) =>
-        Effect.sync(() => {
-          convexClient.setAuth(
-            (args) => Effect.runPromise(fetchToken(args)),
-            ...(onChange
-              ? [
-                  (isAuthenticated: boolean) =>
-                    Effect.runFork(onChange(isAuthenticated)),
-                ]
-              : []),
-          );
-        });
-
-      const mapUnknownError = (cause: unknown) =>
-        new WebSocketClientError({ cause });
-
-      const query = <Query extends Ref.AnyPublicQuery>(
-        ref: Query,
-        ...rest: Ref.OptionalArgs<Query>
-      ): Effect.Effect<
-        Ref.Returns<Query>,
-        Ref.Error<Query> | WebSocketClientError | Schema.SchemaError
-      > => {
-        const args = (rest[0] ?? {}) as Ref.Args<Query>;
-        return Ref.runWithCodec(
-          ref,
-          args,
-          (functionReference, encodedArgs) =>
-            convexClient.query(functionReference, encodedArgs),
-          mapUnknownError,
-        );
-      };
-
-      const mutation = <Mutation extends Ref.AnyPublicMutation>(
-        ref: Mutation,
-        ...rest: Ref.OptionalArgs<Mutation>
-      ): Effect.Effect<
-        Ref.Returns<Mutation>,
-        Ref.Error<Mutation> | WebSocketClientError | Schema.SchemaError
-      > => {
-        const args = (rest[0] ?? {}) as Ref.Args<Mutation>;
-        return Ref.runWithCodec(
-          ref,
-          args,
-          (functionReference, encodedArgs) =>
-            convexClient.mutation(functionReference, encodedArgs),
-          mapUnknownError,
-        );
-      };
-
-      const action = <Action extends Ref.AnyPublicAction>(
-        ref: Action,
-        ...rest: Ref.OptionalArgs<Action>
-      ): Effect.Effect<
-        Ref.Returns<Action>,
-        Ref.Error<Action> | WebSocketClientError | Schema.SchemaError
-      > => {
-        const args = (rest[0] ?? {}) as Ref.Args<Action>;
-        return Ref.runWithCodec(
-          ref,
-          args,
-          (functionReference, encodedArgs) =>
-            convexClient.action(functionReference, encodedArgs),
-          mapUnknownError,
-        );
-      };
-
-      type ReactiveQueryError<Query extends Ref.AnyPublicQuery> =
-        | Ref.Error<Query>
-        | WebSocketClientError
-        | Schema.SchemaError;
-
-      const reactiveQueryResult = <Query extends Ref.AnyPublicQuery>(
-        ref: Query,
-        ...rest: Ref.OptionalArgs<Query>
-      ): Stream.Stream<
-        Result.Result<Ref.Returns<Query>, ReactiveQueryError<Query>>
-      > => {
-        type QueryResult = Result.Result<
-          Ref.Returns<Query>,
-          ReactiveQueryError<Query>
-        >;
-        const args = (rest[0] ?? {}) as Ref.Args<Query>;
-        const functionReference = Ref.getFunctionReference(ref);
-        const onError = Ref.decodeErrorOrElse(ref, mapUnknownError);
-
-        return Stream.unwrap(
-          Effect.match(Ref.encodeArgs(ref, args), {
-            onFailure: (error) =>
-              Stream.succeed<QueryResult>(Result.fail(error)),
-            onSuccess: (encodedArgs) =>
-              Stream.callback<
-                Result.Result<unknown, ReactiveQueryError<Query>>
-              >((queue) =>
-                Effect.gen(function* () {
-                  const unsubscribe = convexClient.onUpdate(
-                    functionReference,
-                    encodedArgs,
-                    (result) => {
-                      Queue.offerUnsafe(queue, Result.succeed(result));
-                    },
-                    (error) => {
-                      Queue.offerUnsafe(queue, Result.fail(onError(error)));
-                    },
-                  );
-                  yield* Effect.addFinalizer(() =>
-                    Effect.sync(() => unsubscribe()),
-                  );
-                }),
-              ),
-          }),
-        ).pipe(
-          Stream.mapEffect((result): Effect.Effect<QueryResult> =>
-            Result.match(result, {
-              onFailure: (error) => Effect.succeed(Result.fail(error)),
-              onSuccess: (encodedReturns) =>
-                Effect.match(Ref.decodeReturns(ref, encodedReturns), {
-                  onFailure: Result.fail,
-                  onSuccess: Result.succeed,
-                }),
-            }),
-          ),
-        );
-      };
-
-      const reactiveQuery = <Query extends Ref.AnyPublicQuery>(
-        ref: Query,
-        ...rest: Ref.OptionalArgs<Query>
-      ): Stream.Stream<Ref.Returns<Query>, ReactiveQueryError<Query>> =>
-        reactiveQueryResult(ref, ...rest).pipe(
-          Stream.mapEffect(
-            Result.match({
-              onFailure: Effect.fail,
-              onSuccess: Effect.succeed,
-            }),
-          ),
-        );
-
+  InternalWebSocketClient.makeScoped(
+    address,
+    Effect.sync(() => {
+      const convexClient = new ConvexClient(address, options);
       return {
-        url,
-        setAuth,
-        query,
-        mutation,
-        action,
-        reactiveQuery,
-        reactiveQueryResult,
+        setAuth: (fetchToken, onChange) =>
+          onChange === undefined
+            ? convexClient.setAuth(fetchToken)
+            : convexClient.setAuth(fetchToken, onChange),
+        close: () => convexClient.close(),
+        query: (functionReference, encodedArgs) =>
+          convexClient.query(functionReference, encodedArgs),
+        mutation: (functionReference, encodedArgs) =>
+          convexClient.mutation(functionReference, encodedArgs),
+        action: (functionReference, encodedArgs) =>
+          convexClient.action(functionReference, encodedArgs),
+        onUpdate: (functionReference, encodedArgs, onUpdate, onError) =>
+          convexClient.onUpdate(
+            functionReference,
+            encodedArgs,
+            onUpdate,
+            onError,
+          ),
       };
     }),
   );

package/src/internal/HttpClient.ts

@@ -0,0 +1,101 @@
+import * as Ref from "@confect/core/Ref";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+
+export class HttpClientError extends Schema.TaggedError<HttpClientError>()(
+  "HttpClientError",
+  {
+    cause: Schema.Unknown,
+  },
+) {}
+
+export interface Transport {
+  readonly url: string;
+  readonly setAuth: (token: string) => void;
+  readonly clearAuth: () => void;
+  readonly query: (
+    functionReference: Ref.FunctionReference<Ref.AnyPublicQuery>,
+    encodedArgs: unknown,
+  ) => PromiseLike<unknown>;
+  readonly mutation: (
+    functionReference: Ref.FunctionReference<Ref.AnyPublicMutation>,
+    encodedArgs: unknown,
+  ) => PromiseLike<unknown>;
+  readonly action: (
+    functionReference: Ref.FunctionReference<Ref.AnyPublicAction>,
+    encodedArgs: unknown,
+  ) => PromiseLike<unknown>;
+}
+
+export const make = (client: Transport) => {
+  const setAuth = (token: string) =>
+    Effect.sync(() => {
+      client.setAuth(token);
+    });
+
+  const clearAuth = Effect.sync(() => {
+    client.clearAuth();
+  });
+
+  const mapUnknownError = (cause: unknown) => new HttpClientError({ cause });
+
+  const query = <Query extends Ref.AnyPublicQuery>(
+    ref: Query,
+    ...rest: Ref.OptionalArgs<Query>
+  ): Effect.Effect<
+    Ref.Returns<Query>,
+    Ref.Error<Query> | HttpClientError | Schema.SchemaError
+  > => {
+    const args = (rest[0] ?? {}) as Ref.Args<Query>;
+    return Ref.runWithCodec(
+      ref,
+      args,
+      (functionReference, encodedArgs) =>
+        client.query(functionReference, encodedArgs),
+      mapUnknownError,
+    );
+  };
+
+  const mutation = <Mutation extends Ref.AnyPublicMutation>(
+    ref: Mutation,
+    ...rest: Ref.OptionalArgs<Mutation>
+  ): Effect.Effect<
+    Ref.Returns<Mutation>,
+    Ref.Error<Mutation> | HttpClientError | Schema.SchemaError
+  > => {
+    const args = (rest[0] ?? {}) as Ref.Args<Mutation>;
+    return Ref.runWithCodec(
+      ref,
+      args,
+      (functionReference, encodedArgs) =>
+        client.mutation(functionReference, encodedArgs),
+      mapUnknownError,
+    );
+  };
+
+  const action = <Action extends Ref.AnyPublicAction>(
+    ref: Action,
+    ...rest: Ref.OptionalArgs<Action>
+  ): Effect.Effect<
+    Ref.Returns<Action>,
+    Ref.Error<Action> | HttpClientError | Schema.SchemaError
+  > => {
+    const args = (rest[0] ?? {}) as Ref.Args<Action>;
+    return Ref.runWithCodec(
+      ref,
+      args,
+      (functionReference, encodedArgs) =>
+        client.action(functionReference, encodedArgs),
+      mapUnknownError,
+    );
+  };
+
+  return {
+    url: client.url,
+    setAuth,
+    clearAuth,
+    query,
+    mutation,
+    action,
+  };
+};

package/src/internal/WebSocketClient.ts

@@ -0,0 +1,202 @@
+import * as Ref from "@confect/core/Ref";
+import * as Effect from "effect/Effect";
+import * as Queue from "effect/Queue";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+
+export class WebSocketClientError extends Schema.TaggedError<WebSocketClientError>()(
+  "WebSocketClientError",
+  {
+    cause: Schema.Defect(),
+  },
+) {}
+
+export interface Transport {
+  readonly setAuth: (
+    fetchToken: (args: {
+      readonly forceRefreshToken: boolean;
+    }) => Promise<string | null | undefined>,
+    onChange?: (isAuthenticated: boolean) => void,
+  ) => void;
+  readonly close: () => Promise<void>;
+  readonly query: (
+    functionReference: Ref.FunctionReference<Ref.AnyPublicQuery>,
+    encodedArgs: unknown,
+  ) => PromiseLike<unknown>;
+  readonly mutation: (
+    functionReference: Ref.FunctionReference<Ref.AnyPublicMutation>,
+    encodedArgs: unknown,
+  ) => PromiseLike<unknown>;
+  readonly action: (
+    functionReference: Ref.FunctionReference<Ref.AnyPublicAction>,
+    encodedArgs: unknown,
+  ) => PromiseLike<unknown>;
+  readonly onUpdate: (
+    functionReference: Ref.FunctionReference<Ref.AnyPublicQuery>,
+    encodedArgs: unknown,
+    onUpdate: (result: unknown) => void,
+    onError: (error: Error) => void,
+  ) => () => void;
+}
+
+export const make = (address: string, convexClient: Transport) => {
+  const setAuth = (
+    fetchToken: (args: {
+      forceRefreshToken: boolean;
+    }) => Effect.Effect<string | null | undefined>,
+    onChange?: (isAuthenticated: boolean) => Effect.Effect<void>,
+  ) =>
+    Effect.sync(() => {
+      convexClient.setAuth(
+        (args) => Effect.runPromise(fetchToken(args)),
+        ...(onChange
+          ? [
+              (isAuthenticated: boolean) =>
+                Effect.runFork(onChange(isAuthenticated)),
+            ]
+          : []),
+      );
+    });
+
+  const mapUnknownError = (cause: unknown) =>
+    new WebSocketClientError({ cause });
+
+  const query = <Query extends Ref.AnyPublicQuery>(
+    ref: Query,
+    ...rest: Ref.OptionalArgs<Query>
+  ): Effect.Effect<
+    Ref.Returns<Query>,
+    Ref.Error<Query> | WebSocketClientError | Schema.SchemaError
+  > => {
+    const args = (rest[0] ?? {}) as Ref.Args<Query>;
+    return Ref.runWithCodec(
+      ref,
+      args,
+      (functionReference, encodedArgs) =>
+        convexClient.query(functionReference, encodedArgs),
+      mapUnknownError,
+    );
+  };
+
+  const mutation = <Mutation extends Ref.AnyPublicMutation>(
+    ref: Mutation,
+    ...rest: Ref.OptionalArgs<Mutation>
+  ): Effect.Effect<
+    Ref.Returns<Mutation>,
+    Ref.Error<Mutation> | WebSocketClientError | Schema.SchemaError
+  > => {
+    const args = (rest[0] ?? {}) as Ref.Args<Mutation>;
+    return Ref.runWithCodec(
+      ref,
+      args,
+      (functionReference, encodedArgs) =>
+        convexClient.mutation(functionReference, encodedArgs),
+      mapUnknownError,
+    );
+  };
+
+  const action = <Action extends Ref.AnyPublicAction>(
+    ref: Action,
+    ...rest: Ref.OptionalArgs<Action>
+  ): Effect.Effect<
+    Ref.Returns<Action>,
+    Ref.Error<Action> | WebSocketClientError | Schema.SchemaError
+  > => {
+    const args = (rest[0] ?? {}) as Ref.Args<Action>;
+    return Ref.runWithCodec(
+      ref,
+      args,
+      (functionReference, encodedArgs) =>
+        convexClient.action(functionReference, encodedArgs),
+      mapUnknownError,
+    );
+  };
+
+  type ReactiveQueryError<Query extends Ref.AnyPublicQuery> =
+    | Ref.Error<Query>
+    | WebSocketClientError
+    | Schema.SchemaError;
+
+  const reactiveQueryResult = <Query extends Ref.AnyPublicQuery>(
+    ref: Query,
+    ...rest: Ref.OptionalArgs<Query>
+  ): Stream.Stream<
+    Result.Result<Ref.Returns<Query>, ReactiveQueryError<Query>>
+  > => {
+    type QueryResult = Result.Result<
+      Ref.Returns<Query>,
+      ReactiveQueryError<Query>
+    >;
+    const args = (rest[0] ?? {}) as Ref.Args<Query>;
+    const functionReference = Ref.getFunctionReference(ref);
+    const onError = Ref.decodeErrorOrElse(ref, mapUnknownError);
+
+    return Stream.unwrap(
+      Effect.match(Ref.encodeArgs(ref, args), {
+        onFailure: (error) => Stream.succeed<QueryResult>(Result.fail(error)),
+        onSuccess: (encodedArgs) =>
+          Stream.callback<Result.Result<unknown, ReactiveQueryError<Query>>>(
+            (queue) =>
+              Effect.gen(function* () {
+                const unsubscribe = convexClient.onUpdate(
+                  functionReference,
+                  encodedArgs,
+                  (result) => {
+                    Queue.offerUnsafe(queue, Result.succeed(result));
+                  },
+                  (error) => {
+                    Queue.offerUnsafe(queue, Result.fail(onError(error)));
+                  },
+                );
+                yield* Effect.addFinalizer(() =>
+                  Effect.sync(() => unsubscribe()),
+                );
+              }),
+          ),
+      }),
+    ).pipe(
+      Stream.mapEffect((result): Effect.Effect<QueryResult> =>
+        Result.match(result, {
+          onFailure: (error) => Effect.succeed(Result.fail(error)),
+          onSuccess: (encodedReturns) =>
+            Effect.match(Ref.decodeReturns(ref, encodedReturns), {
+              onFailure: Result.fail,
+              onSuccess: Result.succeed,
+            }),
+        }),
+      ),
+    );
+  };
+
+  const reactiveQuery = <Query extends Ref.AnyPublicQuery>(
+    ref: Query,
+    ...rest: Ref.OptionalArgs<Query>
+  ): Stream.Stream<Ref.Returns<Query>, ReactiveQueryError<Query>> =>
+    reactiveQueryResult(ref, ...rest).pipe(
+      Stream.mapEffect(
+        Result.match({
+          onFailure: Effect.fail,
+          onSuccess: Effect.succeed,
+        }),
+      ),
+    );
+
+  return {
+    url: address,
+    setAuth,
+    query,
+    mutation,
+    action,
+    reactiveQuery,
+    reactiveQueryResult,
+  };
+};
+
+export const makeScoped = <E, R>(
+  address: string,
+  acquire: Effect.Effect<Transport, E, R>,
+) =>
+  Effect.acquireRelease(acquire, (convexClient) =>
+    Effect.promise(() => convexClient.close()),
+  ).pipe(Effect.map((convexClient) => make(address, convexClient)));