@gaganref/confect-js 0.0.0-stage → 10.3.1-fork.2

package/LICENSE

@@ -0,0 +1,7 @@
+ISC License
+
+Copyright 2024 RJ Dellecese
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -1,3 +1,17 @@
-# Temporary Holding Version
+# Confect 🧁
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+This is a fork of [Confect](https://github.com/rjdellecese/confect). See [FORK.md](FORK.md) for builds, installation, and maintenance, and [CHANGES.md](CHANGES.md) for the fork additions.
+
+## About Confect
+
+Confect is a framework that deeply integrates Effect with Convex. It's more than just Effect bindings! Confect allows you to:
+
+- Define your Convex database schema using Effect schemas.
+- Write Convex function args and returns validators using Effect's schema library.
+- Use Confect functions to automatically decode and encode your data according to your Effect schema definitions for end-to-end rich types, from client to function to database (and back).
+- Add reusable, type-safe middleware to function groups or individual functions to provide Effect services and run logic around handlers.
+- Declare typed errors on functions and middleware using Effect schemas, then handle the decoded errors at every call site.
+- Use Effect's native HTTP API modules to define your HTTP API.
+- Access Convex platform capabilities via Effect services.
+
+Want to learn more? Read the [docs](https://confect.dev)!

package/dist/HttpClient.d.ts

@@ -0,0 +1,35 @@
+import { ConvexHttpClient } from "convex/browser";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as InternalHttpClient from "./internal/HttpClient";
+export { HttpClientError } from "./internal/HttpClient";
+/**
+ * A Confect client which uses HTTP to communicate with your Convex backend.
+ * Works in any JS runtime that supports `fetch`. Wraps
+ * [ConvexHttpClient](https://docs.convex.dev/api/classes/browser.ConvexHttpClient).
+ */
+export declare const HttpClient: Context.Service<{
+    url: string;
+    setAuth: (token: string) => import("effect/Effect").Effect<void, never, never>;
+    clearAuth: import("effect/Effect").Effect<void, never, never>;
+    query: <Query extends import("@confect/core/Ref").AnyPublicQuery>(ref: Query, ...rest: import("@confect/core/Ref").OptionalArgs<Query>) => import("effect/Effect").Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | InternalHttpClient.HttpClientError | import("effect/Schema").SchemaError>;
+    mutation: <Mutation extends import("@confect/core/Ref").AnyPublicMutation>(ref: Mutation, ...rest: import("@confect/core/Ref").OptionalArgs<Mutation>) => import("effect/Effect").Effect<import("@confect/core/Ref").Returns<Mutation>, import("@confect/core/Ref").Error<Mutation> | InternalHttpClient.HttpClientError | import("effect/Schema").SchemaError>;
+    action: <Action extends import("@confect/core/Ref").AnyPublicAction>(ref: Action, ...rest: import("@confect/core/Ref").OptionalArgs<Action>) => import("effect/Effect").Effect<import("@confect/core/Ref").Returns<Action>, import("@confect/core/Ref").Error<Action> | InternalHttpClient.HttpClientError | import("effect/Schema").SchemaError>;
+}, {
+    url: string;
+    setAuth: (token: string) => import("effect/Effect").Effect<void, never, never>;
+    clearAuth: import("effect/Effect").Effect<void, never, never>;
+    query: <Query extends import("@confect/core/Ref").AnyPublicQuery>(ref: Query, ...rest: import("@confect/core/Ref").OptionalArgs<Query>) => import("effect/Effect").Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | InternalHttpClient.HttpClientError | import("effect/Schema").SchemaError>;
+    mutation: <Mutation extends import("@confect/core/Ref").AnyPublicMutation>(ref: Mutation, ...rest: import("@confect/core/Ref").OptionalArgs<Mutation>) => import("effect/Effect").Effect<import("@confect/core/Ref").Returns<Mutation>, import("@confect/core/Ref").Error<Mutation> | InternalHttpClient.HttpClientError | import("effect/Schema").SchemaError>;
+    action: <Action extends import("@confect/core/Ref").AnyPublicAction>(ref: Action, ...rest: import("@confect/core/Ref").OptionalArgs<Action>) => import("effect/Effect").Effect<import("@confect/core/Ref").Returns<Action>, import("@confect/core/Ref").Error<Action> | InternalHttpClient.HttpClientError | import("effect/Schema").SchemaError>;
+}>;
+export type HttpClient = typeof HttpClient.Identifier;
+export declare const layer: (address: string, options?: ConstructorParameters<typeof ConvexHttpClient>[1]) => Layer.Layer<{
+    url: string;
+    setAuth: (token: string) => import("effect/Effect").Effect<void, never, never>;
+    clearAuth: import("effect/Effect").Effect<void, never, never>;
+    query: <Query extends import("@confect/core/Ref").AnyPublicQuery>(ref: Query, ...rest: import("@confect/core/Ref").OptionalArgs<Query>) => import("effect/Effect").Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | InternalHttpClient.HttpClientError | import("effect/Schema").SchemaError>;
+    mutation: <Mutation extends import("@confect/core/Ref").AnyPublicMutation>(ref: Mutation, ...rest: import("@confect/core/Ref").OptionalArgs<Mutation>) => import("effect/Effect").Effect<import("@confect/core/Ref").Returns<Mutation>, import("@confect/core/Ref").Error<Mutation> | InternalHttpClient.HttpClientError | import("effect/Schema").SchemaError>;
+    action: <Action extends import("@confect/core/Ref").AnyPublicAction>(ref: Action, ...rest: import("@confect/core/Ref").OptionalArgs<Action>) => import("effect/Effect").Effect<import("@confect/core/Ref").Returns<Action>, import("@confect/core/Ref").Error<Action> | InternalHttpClient.HttpClientError | import("effect/Schema").SchemaError>;
+}, never, never>;
+//# sourceMappingURL=HttpClient.d.ts.map

package/dist/HttpClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpClient.d.ts","sourceRoot":"","sources":["../src/HttpClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,kBAAkB,MAAM,uBAAuB,CAAC;AAE5D,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAoBxD;;;;GAIG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;EAEtB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,UAAU,CAAC;AAEtD,eAAO,MAAM,KAAK,YACP,MAAM,YACL,qBAAqB,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC,CAAC;;;;;;;gBACJ,CAAC"}

package/dist/HttpClient.js

@@ -0,0 +1,33 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { HttpClientError, make as make$1 } from "./internal/HttpClient.js";
+import { ConvexHttpClient } from "convex/browser";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+//#region src/HttpClient.ts
+var HttpClient_exports = /* @__PURE__ */ __exportAll({
+	HttpClient: () => HttpClient,
+	HttpClientError: () => HttpClientError,
+	layer: () => layer
+});
+const make = (address, options) => {
+	const client = new ConvexHttpClient(address, options);
+	return make$1({
+		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)
+	});
+};
+/**
+* A Confect client which uses HTTP to communicate with your Convex backend.
+* Works in any JS runtime that supports `fetch`. Wraps
+* [ConvexHttpClient](https://docs.convex.dev/api/classes/browser.ConvexHttpClient).
+*/
+const HttpClient = Context.Service("@confect/js/HttpClient");
+const layer = (address, options) => Layer.sync(HttpClient, () => make(address, options));
+//#endregion
+export { HttpClient, HttpClientError, HttpClient_exports, layer };
+
+//# sourceMappingURL=HttpClient.js.map

package/dist/HttpClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpClient.js","names":["InternalHttpClient.make"],"sources":["../src/HttpClient.ts"],"sourcesContent":["import { ConvexHttpClient } from \"convex/browser\";\nimport * as Context from \"effect/Context\";\nimport * as Layer from \"effect/Layer\";\nimport * as InternalHttpClient from \"./internal/HttpClient\";\n\nexport { HttpClientError } from \"./internal/HttpClient\";\n\nconst make = (\n  address: string,\n  options?: ConstructorParameters<typeof ConvexHttpClient>[1],\n) => {\n  const client = new ConvexHttpClient(address, options);\n  return InternalHttpClient.make({\n    url: client.url,\n    setAuth: (token) => client.setAuth(token),\n    clearAuth: () => client.clearAuth(),\n    query: (functionReference, encodedArgs) =>\n      client.query(functionReference, encodedArgs),\n    mutation: (functionReference, encodedArgs) =>\n      client.mutation(functionReference, encodedArgs),\n    action: (functionReference, encodedArgs) =>\n      client.action(functionReference, encodedArgs),\n  });\n};\n\n/**\n * A Confect client which uses HTTP to communicate with your Convex backend.\n * Works in any JS runtime that supports `fetch`. Wraps\n * [ConvexHttpClient](https://docs.convex.dev/api/classes/browser.ConvexHttpClient).\n */\nexport const HttpClient = Context.Service<ReturnType<typeof make>>(\n  \"@confect/js/HttpClient\",\n);\n\nexport type HttpClient = typeof HttpClient.Identifier;\n\nexport const layer = (\n  address: string,\n  options?: ConstructorParameters<typeof ConvexHttpClient>[1],\n) => Layer.sync(HttpClient, () => make(address, options));\n"],"mappings":";;;;;;;;;;;AAOA,MAAM,QACJ,SACA,YACG;CACH,MAAM,SAAS,IAAI,iBAAiB,SAAS,OAAO;CACpD,OAAOA,OAAwB;EAC7B,KAAK,OAAO;EACZ,UAAU,UAAU,OAAO,QAAQ,KAAK;EACxC,iBAAiB,OAAO,UAAU;EAClC,QAAQ,mBAAmB,gBACzB,OAAO,MAAM,mBAAmB,WAAW;EAC7C,WAAW,mBAAmB,gBAC5B,OAAO,SAAS,mBAAmB,WAAW;EAChD,SAAS,mBAAmB,gBAC1B,OAAO,OAAO,mBAAmB,WAAW;CAChD,CAAC;AACH;;;;;;AAOA,MAAa,aAAa,QAAQ,QAChC,wBACF;AAIA,MAAa,SACX,SACA,YACG,MAAM,KAAK,kBAAkB,KAAK,SAAS,OAAO,CAAC"}

package/dist/WebSocketClient.d.ts

@@ -0,0 +1,47 @@
+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 InternalWebSocketClient from "./internal/WebSocketClient";
+export { WebSocketClientError } from "./internal/WebSocketClient";
+/**
+ * A Confect client which uses a WebSocket to communicate with your Convex
+ * backend and supports reactive query subscriptions. The WebSocket connection
+ * is managed by the layer's scope and closed automatically when the scope ends.
+ * Wraps
+ * [ConvexClient](https://docs.convex.dev/api/classes/browser.ConvexClient).
+ */
+export declare const WebSocketClient: Context.Service<{
+    url: string;
+    setAuth: <R1 = never, R2 = never>(fetchToken: (args: {
+        forceRefreshToken: boolean;
+    }) => Effect.Effect<string | null | undefined, never, R1>, onChange?: (isAuthenticated: boolean) => Effect.Effect<void, never, R2>) => Effect.Effect<void, never, R1 | R2>;
+    query: <Query extends import("@confect/core/Ref").AnyPublicQuery>(ref: Query, ...rest: import("@confect/core/Ref").OptionalArgs<Query>) => Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | InternalWebSocketClient.WebSocketClientError | import("effect/Schema").SchemaError>;
+    mutation: <Mutation extends import("@confect/core/Ref").AnyPublicMutation>(ref: Mutation, ...rest: import("@confect/core/Ref").OptionalArgs<Mutation>) => Effect.Effect<import("@confect/core/Ref").Returns<Mutation>, import("@confect/core/Ref").Error<Mutation> | InternalWebSocketClient.WebSocketClientError | import("effect/Schema").SchemaError>;
+    action: <Action extends import("@confect/core/Ref").AnyPublicAction>(ref: Action, ...rest: import("@confect/core/Ref").OptionalArgs<Action>) => Effect.Effect<import("@confect/core/Ref").Returns<Action>, import("@confect/core/Ref").Error<Action> | InternalWebSocketClient.WebSocketClientError | import("effect/Schema").SchemaError>;
+    reactiveQuery: <Query extends import("@confect/core/Ref").AnyPublicQuery>(ref: Query, ...rest: import("@confect/core/Ref").OptionalArgs<Query>) => import("effect/Stream").Stream<import("@confect/core/Ref").Returns<Query>, import("effect/Schema").SchemaError | InternalWebSocketClient.WebSocketClientError | import("@confect/core/Ref").Error<Query>>;
+    reactiveQueryResult: <Query extends import("@confect/core/Ref").AnyPublicQuery>(ref: Query, ...rest: import("@confect/core/Ref").OptionalArgs<Query>) => import("effect/Stream").Stream<import("effect/Result").Result<import("@confect/core/Ref").Returns<Query>, import("effect/Schema").SchemaError | InternalWebSocketClient.WebSocketClientError | import("@confect/core/Ref").Error<Query>>>;
+}, {
+    url: string;
+    setAuth: <R1 = never, R2 = never>(fetchToken: (args: {
+        forceRefreshToken: boolean;
+    }) => Effect.Effect<string | null | undefined, never, R1>, onChange?: (isAuthenticated: boolean) => Effect.Effect<void, never, R2>) => Effect.Effect<void, never, R1 | R2>;
+    query: <Query extends import("@confect/core/Ref").AnyPublicQuery>(ref: Query, ...rest: import("@confect/core/Ref").OptionalArgs<Query>) => Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | InternalWebSocketClient.WebSocketClientError | import("effect/Schema").SchemaError>;
+    mutation: <Mutation extends import("@confect/core/Ref").AnyPublicMutation>(ref: Mutation, ...rest: import("@confect/core/Ref").OptionalArgs<Mutation>) => Effect.Effect<import("@confect/core/Ref").Returns<Mutation>, import("@confect/core/Ref").Error<Mutation> | InternalWebSocketClient.WebSocketClientError | import("effect/Schema").SchemaError>;
+    action: <Action extends import("@confect/core/Ref").AnyPublicAction>(ref: Action, ...rest: import("@confect/core/Ref").OptionalArgs<Action>) => Effect.Effect<import("@confect/core/Ref").Returns<Action>, import("@confect/core/Ref").Error<Action> | InternalWebSocketClient.WebSocketClientError | import("effect/Schema").SchemaError>;
+    reactiveQuery: <Query extends import("@confect/core/Ref").AnyPublicQuery>(ref: Query, ...rest: import("@confect/core/Ref").OptionalArgs<Query>) => import("effect/Stream").Stream<import("@confect/core/Ref").Returns<Query>, import("effect/Schema").SchemaError | InternalWebSocketClient.WebSocketClientError | import("@confect/core/Ref").Error<Query>>;
+    reactiveQueryResult: <Query extends import("@confect/core/Ref").AnyPublicQuery>(ref: Query, ...rest: import("@confect/core/Ref").OptionalArgs<Query>) => import("effect/Stream").Stream<import("effect/Result").Result<import("@confect/core/Ref").Returns<Query>, import("effect/Schema").SchemaError | InternalWebSocketClient.WebSocketClientError | import("@confect/core/Ref").Error<Query>>>;
+}>;
+export type WebSocketClient = typeof WebSocketClient.Identifier;
+export declare const layer: (address: string, options?: ConstructorParameters<typeof ConvexClient>[1]) => Layer.Layer<{
+    url: string;
+    setAuth: <R1 = never, R2 = never>(fetchToken: (args: {
+        forceRefreshToken: boolean;
+    }) => Effect.Effect<string | null | undefined, never, R1>, onChange?: (isAuthenticated: boolean) => Effect.Effect<void, never, R2>) => Effect.Effect<void, never, R1 | R2>;
+    query: <Query extends import("@confect/core/Ref").AnyPublicQuery>(ref: Query, ...rest: import("@confect/core/Ref").OptionalArgs<Query>) => Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | InternalWebSocketClient.WebSocketClientError | import("effect/Schema").SchemaError>;
+    mutation: <Mutation extends import("@confect/core/Ref").AnyPublicMutation>(ref: Mutation, ...rest: import("@confect/core/Ref").OptionalArgs<Mutation>) => Effect.Effect<import("@confect/core/Ref").Returns<Mutation>, import("@confect/core/Ref").Error<Mutation> | InternalWebSocketClient.WebSocketClientError | import("effect/Schema").SchemaError>;
+    action: <Action extends import("@confect/core/Ref").AnyPublicAction>(ref: Action, ...rest: import("@confect/core/Ref").OptionalArgs<Action>) => Effect.Effect<import("@confect/core/Ref").Returns<Action>, import("@confect/core/Ref").Error<Action> | InternalWebSocketClient.WebSocketClientError | import("effect/Schema").SchemaError>;
+    reactiveQuery: <Query extends import("@confect/core/Ref").AnyPublicQuery>(ref: Query, ...rest: import("@confect/core/Ref").OptionalArgs<Query>) => import("effect/Stream").Stream<import("@confect/core/Ref").Returns<Query>, import("effect/Schema").SchemaError | InternalWebSocketClient.WebSocketClientError | import("@confect/core/Ref").Error<Query>>;
+    reactiveQueryResult: <Query extends import("@confect/core/Ref").AnyPublicQuery>(ref: Query, ...rest: import("@confect/core/Ref").OptionalArgs<Query>) => import("effect/Stream").Stream<import("effect/Result").Result<import("@confect/core/Ref").Returns<Query>, import("effect/Schema").SchemaError | InternalWebSocketClient.WebSocketClientError | import("@confect/core/Ref").Error<Query>>>;
+}, never, never>;
+//# sourceMappingURL=WebSocketClient.d.ts.map

package/dist/WebSocketClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSocketClient.d.ts","sourceRoot":"","sources":["../src/WebSocketClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,uBAAuB,MAAM,4BAA4B,CAAC;AAEtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAiClE;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;EAEI,CAAC;AAEjC,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC,UAAU,CAAC;AAEhE,eAAO,MAAM,KAAK,YACP,MAAM,YACL,qBAAqB,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC;;;;;;;;;;gBACC,CAAC"}

package/dist/WebSocketClient.js

@@ -0,0 +1,36 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { WebSocketClientError, makeScoped } from "./internal/WebSocketClient.js";
+import { ConvexClient } from "convex/browser";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+//#region src/WebSocketClient.ts
+var WebSocketClient_exports = /* @__PURE__ */ __exportAll({
+	WebSocketClient: () => WebSocketClient,
+	WebSocketClientError: () => WebSocketClientError,
+	layer: () => layer
+});
+const make = (address, options) => makeScoped(address, Effect.sync(() => {
+	const convexClient = new ConvexClient(address, options);
+	return {
+		setAuth: (fetchToken, onChange) => onChange === void 0 ? 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)
+	};
+}));
+/**
+* A Confect client which uses a WebSocket to communicate with your Convex
+* backend and supports reactive query subscriptions. The WebSocket connection
+* is managed by the layer's scope and closed automatically when the scope ends.
+* Wraps
+* [ConvexClient](https://docs.convex.dev/api/classes/browser.ConvexClient).
+*/
+const WebSocketClient = Context.Service("@confect/js/WebSocketClient");
+const layer = (address, options) => Layer.effect(WebSocketClient, make(address, options));
+//#endregion
+export { WebSocketClient, WebSocketClientError, WebSocketClient_exports, layer };
+
+//# sourceMappingURL=WebSocketClient.js.map

package/dist/WebSocketClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSocketClient.js","names":["InternalWebSocketClient.makeScoped"],"sources":["../src/WebSocketClient.ts"],"sourcesContent":["import { ConvexClient } from \"convex/browser\";\nimport * as Context from \"effect/Context\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport * as InternalWebSocketClient from \"./internal/WebSocketClient\";\n\nexport { WebSocketClientError } from \"./internal/WebSocketClient\";\n\nconst make = (\n  address: string,\n  options?: ConstructorParameters<typeof ConvexClient>[1],\n) =>\n  InternalWebSocketClient.makeScoped(\n    address,\n    Effect.sync(() => {\n      const convexClient = new ConvexClient(address, options);\n      return {\n        setAuth: (fetchToken, onChange) =>\n          onChange === undefined\n            ? convexClient.setAuth(fetchToken)\n            : convexClient.setAuth(fetchToken, onChange),\n        close: () => convexClient.close(),\n        query: (functionReference, encodedArgs) =>\n          convexClient.query(functionReference, encodedArgs),\n        mutation: (functionReference, encodedArgs) =>\n          convexClient.mutation(functionReference, encodedArgs),\n        action: (functionReference, encodedArgs) =>\n          convexClient.action(functionReference, encodedArgs),\n        onUpdate: (functionReference, encodedArgs, onUpdate, onError) =>\n          convexClient.onUpdate(\n            functionReference,\n            encodedArgs,\n            onUpdate,\n            onError,\n          ),\n      };\n    }),\n  );\n\n/**\n * A Confect client which uses a WebSocket to communicate with your Convex\n * backend and supports reactive query subscriptions. The WebSocket connection\n * is managed by the layer's scope and closed automatically when the scope ends.\n * Wraps\n * [ConvexClient](https://docs.convex.dev/api/classes/browser.ConvexClient).\n */\nexport const WebSocketClient = Context.Service<\n  Effect.Success<ReturnType<typeof make>>\n>(\"@confect/js/WebSocketClient\");\n\nexport type WebSocketClient = typeof WebSocketClient.Identifier;\n\nexport const layer = (\n  address: string,\n  options?: ConstructorParameters<typeof ConvexClient>[1],\n) => Layer.effect(WebSocketClient, make(address, options));\n"],"mappings":";;;;;;;;;;;;AAQA,MAAM,QACJ,SACA,YAEAA,WACE,SACA,OAAO,WAAW;CAChB,MAAM,eAAe,IAAI,aAAa,SAAS,OAAO;CACtD,OAAO;EACL,UAAU,YAAY,aACpB,aAAa,KAAA,IACT,aAAa,QAAQ,UAAU,IAC/B,aAAa,QAAQ,YAAY,QAAQ;EAC/C,aAAa,aAAa,MAAM;EAChC,QAAQ,mBAAmB,gBACzB,aAAa,MAAM,mBAAmB,WAAW;EACnD,WAAW,mBAAmB,gBAC5B,aAAa,SAAS,mBAAmB,WAAW;EACtD,SAAS,mBAAmB,gBAC1B,aAAa,OAAO,mBAAmB,WAAW;EACpD,WAAW,mBAAmB,aAAa,UAAU,YACnD,aAAa,SACX,mBACA,aACA,UACA,OACF;CACJ;AACF,CAAC,CACH;;;;;;;;AASF,MAAa,kBAAkB,QAAQ,QAErC,6BAA6B;AAI/B,MAAa,SACX,SACA,YACG,MAAM,OAAO,iBAAiB,KAAK,SAAS,OAAO,CAAC"}

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * as WebSocketClient from "./WebSocketClient";
+export * as HttpClient from "./HttpClient";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,eAAe,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+import { WebSocketClient_exports } from "./WebSocketClient.js";
+import { HttpClient_exports } from "./HttpClient.js";
+export { HttpClient_exports as HttpClient, WebSocketClient_exports as WebSocketClient };

package/dist/internal/HttpClient.d.ts

@@ -0,0 +1,26 @@
+import * as Ref from "@confect/core/Ref";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+declare const HttpClientError_base: Schema.Class<HttpClientError, Schema.TaggedStruct<"HttpClientError", {
+    readonly cause: Schema.Unknown;
+}>, import("effect/Cause").YieldableError>;
+export declare class HttpClientError extends HttpClientError_base {
+}
+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 declare const make: (client: Transport) => {
+    url: string;
+    setAuth: (token: string) => Effect.Effect<void, never, never>;
+    clearAuth: Effect.Effect<void, never, never>;
+    query: <Query extends Ref.AnyPublicQuery>(ref: Query, ...rest: Ref.OptionalArgs<Query>) => Effect.Effect<Ref.Returns<Query>, Ref.Error<Query> | HttpClientError | Schema.SchemaError>;
+    mutation: <Mutation extends Ref.AnyPublicMutation>(ref: Mutation, ...rest: Ref.OptionalArgs<Mutation>) => Effect.Effect<Ref.Returns<Mutation>, Ref.Error<Mutation> | HttpClientError | Schema.SchemaError>;
+    action: <Action extends Ref.AnyPublicAction>(ref: Action, ...rest: Ref.OptionalArgs<Action>) => Effect.Effect<Ref.Returns<Action>, Ref.Error<Action> | HttpClientError | Schema.SchemaError>;
+};
+export {};
+//# sourceMappingURL=HttpClient.d.ts.map

package/dist/internal/HttpClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpClient.d.ts","sourceRoot":"","sources":["../../src/internal/HttpClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,mBAAmB,CAAC;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;;;;AAExC,qBAAa,eAAgB,SAAQ,oBAKpC;CAAG;AAEJ,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1C,QAAQ,CAAC,SAAS,EAAE,MAAM,IAAI,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,CACd,iBAAiB,EAAE,GAAG,CAAC,iBAAiB,CAAC,GAAG,CAAC,cAAc,CAAC,EAC5D,WAAW,EAAE,OAAO,KACjB,WAAW,CAAC,OAAO,CAAC,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,CACjB,iBAAiB,EAAE,GAAG,CAAC,iBAAiB,CAAC,GAAG,CAAC,iBAAiB,CAAC,EAC/D,WAAW,EAAE,OAAO,KACjB,WAAW,CAAC,OAAO,CAAC,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,CACf,iBAAiB,EAAE,GAAG,CAAC,iBAAiB,CAAC,GAAG,CAAC,eAAe,CAAC,EAC7D,WAAW,EAAE,OAAO,KACjB,WAAW,CAAC,OAAO,CAAC,CAAC;CAC3B;AAcD,eAAO,MAAM,IAAI,WAAY,SAAS;;qBACZ,MAAM;;YAWf,KAAK,SAAS,GAAG,CAAC,cAAc,OACxC,KAAK,WACD,GAAG,CAAC,YAAY,CAAC,KAAK,CAAC,KAC/B,MAAM,CAAC,MAAM,CACd,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,EAClB,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,eAAe,GAAG,MAAM,CAAC,WAAW,CACxD;eAaiB,QAAQ,SAAS,GAAG,CAAC,iBAAiB,OACjD,QAAQ,WACJ,GAAG,CAAC,YAAY,CAAC,QAAQ,CAAC,KAClC,MAAM,CAAC,MAAM,CACd,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,EACrB,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,eAAe,GAAG,MAAM,CAAC,WAAW,CAC3D;aAae,MAAM,SAAS,GAAG,CAAC,eAAe,OAC3C,MAAM,WACF,GAAG,CAAC,YAAY,CAAC,MAAM,CAAC,KAChC,MAAM,CAAC,MAAM,CACd,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,EACnB,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,eAAe,GAAG,MAAM,CAAC,WAAW,CACzD;CAqBF,CAAC"}

package/dist/internal/HttpClient.js

@@ -0,0 +1,41 @@
+import * as Effect from "effect/Effect";
+import * as Ref from "@confect/core/Ref";
+import * as Schema from "effect/Schema";
+//#region src/internal/HttpClient.ts
+var HttpClientError = class extends Schema.TaggedError()("HttpClientError", { cause: Schema.Unknown }) {};
+const runQuery = Effect.fn("HttpClient.query")((effect) => effect);
+const runMutation = Effect.fn("HttpClient.mutation")((effect) => effect);
+const runAction = Effect.fn("HttpClient.action")((effect) => effect);
+const make = (client) => {
+	const setAuth = (token) => Effect.sync(() => {
+		client.setAuth(token);
+	});
+	const clearAuth = Effect.sync(() => {
+		client.clearAuth();
+	});
+	const mapUnknownError = (cause) => new HttpClientError({ cause });
+	const query = (ref, ...rest) => {
+		const args = rest[0] ?? {};
+		return runQuery(Ref.runWithCodec(ref, args, (functionReference, encodedArgs) => client.query(functionReference, encodedArgs), mapUnknownError));
+	};
+	const mutation = (ref, ...rest) => {
+		const args = rest[0] ?? {};
+		return runMutation(Ref.runWithCodec(ref, args, (functionReference, encodedArgs) => client.mutation(functionReference, encodedArgs), mapUnknownError));
+	};
+	const action = (ref, ...rest) => {
+		const args = rest[0] ?? {};
+		return runAction(Ref.runWithCodec(ref, args, (functionReference, encodedArgs) => client.action(functionReference, encodedArgs), mapUnknownError));
+	};
+	return {
+		url: client.url,
+		setAuth,
+		clearAuth,
+		query,
+		mutation,
+		action
+	};
+};
+//#endregion
+export { HttpClientError, make };
+
+//# sourceMappingURL=HttpClient.js.map

package/dist/internal/HttpClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpClient.js","names":[],"sources":["../../src/internal/HttpClient.ts"],"sourcesContent":["import * as Ref from \"@confect/core/Ref\";\nimport * as Effect from \"effect/Effect\";\nimport * as Schema from \"effect/Schema\";\n\nexport class HttpClientError extends Schema.TaggedError<HttpClientError>()(\n  \"HttpClientError\",\n  {\n    cause: Schema.Unknown,\n  },\n) {}\n\nexport interface Transport {\n  readonly url: string;\n  readonly setAuth: (token: string) => void;\n  readonly clearAuth: () => 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}\n\nconst runQuery = Effect.fn(\"HttpClient.query\")(\n  <A, E>(effect: Effect.Effect<A, E>): Effect.Effect<A, E> => effect,\n);\n\nconst runMutation = Effect.fn(\"HttpClient.mutation\")(\n  <A, E>(effect: Effect.Effect<A, E>): Effect.Effect<A, E> => effect,\n);\n\nconst runAction = Effect.fn(\"HttpClient.action\")(\n  <A, E>(effect: Effect.Effect<A, E>): Effect.Effect<A, E> => effect,\n);\n\nexport const make = (client: Transport) => {\n  const setAuth = (token: string) =>\n    Effect.sync(() => {\n      client.setAuth(token);\n    });\n\n  const clearAuth = Effect.sync(() => {\n    client.clearAuth();\n  });\n\n  const mapUnknownError = (cause: unknown) => new HttpClientError({ 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> | HttpClientError | Schema.SchemaError\n  > => {\n    const args = (rest[0] ?? {}) as Ref.Args<Query>;\n    return runQuery(\n      Ref.runWithCodec(\n        ref,\n        args,\n        (functionReference, encodedArgs) =>\n          client.query(functionReference, encodedArgs),\n        mapUnknownError,\n      ),\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> | HttpClientError | Schema.SchemaError\n  > => {\n    const args = (rest[0] ?? {}) as Ref.Args<Mutation>;\n    return runMutation(\n      Ref.runWithCodec(\n        ref,\n        args,\n        (functionReference, encodedArgs) =>\n          client.mutation(functionReference, encodedArgs),\n        mapUnknownError,\n      ),\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> | HttpClientError | Schema.SchemaError\n  > => {\n    const args = (rest[0] ?? {}) as Ref.Args<Action>;\n    return runAction(\n      Ref.runWithCodec(\n        ref,\n        args,\n        (functionReference, encodedArgs) =>\n          client.action(functionReference, encodedArgs),\n        mapUnknownError,\n      ),\n    );\n  };\n\n  return {\n    url: client.url,\n    setAuth,\n    clearAuth,\n    query,\n    mutation,\n    action,\n  };\n};\n"],"mappings":";;;;AAIA,IAAa,kBAAb,cAAqC,OAAO,YAA6B,CAAC,CACxE,mBACA,EACE,OAAO,OAAO,QAChB,CACF,CAAC,CAAC,CAAC;AAoBH,MAAM,WAAW,OAAO,GAAG,kBAAkB,CAAC,EACrC,WAAqD,MAC9D;AAEA,MAAM,cAAc,OAAO,GAAG,qBAAqB,CAAC,EAC3C,WAAqD,MAC9D;AAEA,MAAM,YAAY,OAAO,GAAG,mBAAmB,CAAC,EACvC,WAAqD,MAC9D;AAEA,MAAa,QAAQ,WAAsB;CACzC,MAAM,WAAW,UACf,OAAO,WAAW;EAChB,OAAO,QAAQ,KAAK;CACtB,CAAC;CAEH,MAAM,YAAY,OAAO,WAAW;EAClC,OAAO,UAAU;CACnB,CAAC;CAED,MAAM,mBAAmB,UAAmB,IAAI,gBAAgB,EAAE,MAAM,CAAC;CAEzE,MAAM,SACJ,KACA,GAAG,SAIA;EACH,MAAM,OAAQ,KAAK,MAAM,CAAC;EAC1B,OAAO,SACL,IAAI,aACF,KACA,OACC,mBAAmB,gBAClB,OAAO,MAAM,mBAAmB,WAAW,GAC7C,eACF,CACF;CACF;CAEA,MAAM,YACJ,KACA,GAAG,SAIA;EACH,MAAM,OAAQ,KAAK,MAAM,CAAC;EAC1B,OAAO,YACL,IAAI,aACF,KACA,OACC,mBAAmB,gBAClB,OAAO,SAAS,mBAAmB,WAAW,GAChD,eACF,CACF;CACF;CAEA,MAAM,UACJ,KACA,GAAG,SAIA;EACH,MAAM,OAAQ,KAAK,MAAM,CAAC;EAC1B,OAAO,UACL,IAAI,aACF,KACA,OACC,mBAAmB,gBAClB,OAAO,OAAO,mBAAmB,WAAW,GAC9C,eACF,CACF;CACF;CAEA,OAAO;EACL,KAAK,OAAO;EACZ;EACA;EACA;EACA;EACA;CACF;AACF"}

package/dist/internal/WebSocketClient.d.ts

@@ -0,0 +1,44 @@
+import * as Ref from "@confect/core/Ref";
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+declare const WebSocketClientError_base: Schema.Class<WebSocketClientError, Schema.TaggedStruct<"WebSocketClientError", {
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class WebSocketClientError extends WebSocketClientError_base {
+}
+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 declare const make: (address: string, convexClient: Transport) => {
+    url: string;
+    setAuth: <R1 = never, R2 = never>(fetchToken: (args: {
+        forceRefreshToken: boolean;
+    }) => Effect.Effect<string | null | undefined, never, R1>, onChange?: (isAuthenticated: boolean) => Effect.Effect<void, never, R2>) => Effect.Effect<void, never, R1 | R2>;
+    query: <Query extends Ref.AnyPublicQuery>(ref: Query, ...rest: Ref.OptionalArgs<Query>) => Effect.Effect<Ref.Returns<Query>, Ref.Error<Query> | WebSocketClientError | Schema.SchemaError>;
+    mutation: <Mutation extends Ref.AnyPublicMutation>(ref: Mutation, ...rest: Ref.OptionalArgs<Mutation>) => Effect.Effect<Ref.Returns<Mutation>, Ref.Error<Mutation> | WebSocketClientError | Schema.SchemaError>;
+    action: <Action extends Ref.AnyPublicAction>(ref: Action, ...rest: Ref.OptionalArgs<Action>) => Effect.Effect<Ref.Returns<Action>, Ref.Error<Action> | WebSocketClientError | Schema.SchemaError>;
+    reactiveQuery: <Query extends Ref.AnyPublicQuery>(ref: Query, ...rest: Ref.OptionalArgs<Query>) => Stream.Stream<Ref.Returns<Query>, Schema.SchemaError | WebSocketClientError | Ref.Error<Query>>;
+    reactiveQueryResult: <Query extends Ref.AnyPublicQuery>(ref: Query, ...rest: Ref.OptionalArgs<Query>) => Stream.Stream<Result.Result<Ref.Returns<Query>, Schema.SchemaError | WebSocketClientError | Ref.Error<Query>>>;
+};
+export declare const makeScoped: <E, R>(address: string, acquire: Effect.Effect<Transport, E, R>) => Effect.Effect<{
+    url: string;
+    setAuth: <R1 = never, R2 = never>(fetchToken: (args: {
+        forceRefreshToken: boolean;
+    }) => Effect.Effect<string | null | undefined, never, R1>, onChange?: (isAuthenticated: boolean) => Effect.Effect<void, never, R2>) => Effect.Effect<void, never, R1 | R2>;
+    query: <Query extends Ref.AnyPublicQuery>(ref: Query, ...rest: Ref.OptionalArgs<Query>) => Effect.Effect<Ref.Returns<Query>, Ref.Error<Query> | WebSocketClientError | Schema.SchemaError>;
+    mutation: <Mutation extends Ref.AnyPublicMutation>(ref: Mutation, ...rest: Ref.OptionalArgs<Mutation>) => Effect.Effect<Ref.Returns<Mutation>, Ref.Error<Mutation> | WebSocketClientError | Schema.SchemaError>;
+    action: <Action extends Ref.AnyPublicAction>(ref: Action, ...rest: Ref.OptionalArgs<Action>) => Effect.Effect<Ref.Returns<Action>, Ref.Error<Action> | WebSocketClientError | Schema.SchemaError>;
+    reactiveQuery: <Query extends Ref.AnyPublicQuery>(ref: Query, ...rest: Ref.OptionalArgs<Query>) => Stream.Stream<Ref.Returns<Query>, Schema.SchemaError | WebSocketClientError | Ref.Error<Query>>;
+    reactiveQueryResult: <Query extends Ref.AnyPublicQuery>(ref: Query, ...rest: Ref.OptionalArgs<Query>) => Stream.Stream<Result.Result<Ref.Returns<Query>, Schema.SchemaError | WebSocketClientError | Ref.Error<Query>>>;
+}, E, R | import("effect/Scope").Scope>;
+export {};
+//# sourceMappingURL=WebSocketClient.d.ts.map

package/dist/internal/WebSocketClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSocketClient.d.ts","sourceRoot":"","sources":["../../src/internal/WebSocketClient.ts"],"names":[],"mappings":"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"}

package/dist/internal/WebSocketClient.js

@@ -0,0 +1,74 @@
+import * as Effect from "effect/Effect";
+import * as Ref from "@confect/core/Ref";
+import * as Queue from "effect/Queue";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+//#region src/internal/WebSocketClient.ts
+var WebSocketClientError = class extends Schema.TaggedError()("WebSocketClientError", { cause: Schema.Defect() }) {};
+const runQuery = Effect.fn("WebSocketClient.query")((effect) => effect);
+const runMutation = Effect.fn("WebSocketClient.mutation")((effect) => effect);
+const runAction = Effect.fn("WebSocketClient.action")((effect) => effect);
+const make = (address, convexClient) => {
+	const setAuth = (fetchToken, onChange) => Effect.gen(function* () {
+		const context = yield* Effect.context();
+		const runPromise = Effect.runPromiseWith(context);
+		const runFork = Effect.runForkWith(context);
+		convexClient.setAuth((args) => runPromise(Effect.suspend(() => fetchToken(args))), ...onChange ? [(isAuthenticated) => {
+			runFork(Effect.suspend(() => onChange(isAuthenticated)));
+		}] : []);
+	});
+	const mapUnknownError = (cause) => new WebSocketClientError({ cause });
+	const query = (ref, ...rest) => {
+		const args = rest[0] ?? {};
+		return runQuery(Ref.runWithCodec(ref, args, (functionReference, encodedArgs) => convexClient.query(functionReference, encodedArgs), mapUnknownError));
+	};
+	const mutation = (ref, ...rest) => {
+		const args = rest[0] ?? {};
+		return runMutation(Ref.runWithCodec(ref, args, (functionReference, encodedArgs) => convexClient.mutation(functionReference, encodedArgs), mapUnknownError));
+	};
+	const action = (ref, ...rest) => {
+		const args = rest[0] ?? {};
+		return runAction(Ref.runWithCodec(ref, args, (functionReference, encodedArgs) => convexClient.action(functionReference, encodedArgs), mapUnknownError));
+	};
+	const reactiveQueryResult = (ref, ...rest) => {
+		const args = rest[0] ?? {};
+		const functionReference = Ref.getFunctionReference(ref);
+		const onError = Ref.decodeErrorOrElse(ref, mapUnknownError);
+		return Stream.unwrap(Effect.match(Ref.encodeArgs(ref, args), {
+			onFailure: (error) => Stream.succeed(Result.fail(error)),
+			onSuccess: (encodedArgs) => Stream.callback((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) => 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 = (ref, ...rest) => reactiveQueryResult(ref, ...rest).pipe(Stream.mapEffect(Result.match({
+		onFailure: Effect.fail,
+		onSuccess: Effect.succeed
+	})));
+	return {
+		url: address,
+		setAuth,
+		query,
+		mutation,
+		action,
+		reactiveQuery,
+		reactiveQueryResult
+	};
+};
+const makeScoped = (address, acquire) => Effect.acquireRelease(acquire, (convexClient) => Effect.promise(() => convexClient.close())).pipe(Effect.map((convexClient) => make(address, convexClient)));
+//#endregion
+export { WebSocketClientError, make, makeScoped };
+
+//# sourceMappingURL=WebSocketClient.js.map

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\nconst runQuery = Effect.fn(\"WebSocketClient.query\")(\n  <A, E>(effect: Effect.Effect<A, E>): Effect.Effect<A, E> => effect,\n);\n\nconst runMutation = Effect.fn(\"WebSocketClient.mutation\")(\n  <A, E>(effect: Effect.Effect<A, E>): Effect.Effect<A, E> => effect,\n);\n\nconst runAction = Effect.fn(\"WebSocketClient.action\")(\n  <A, E>(effect: Effect.Effect<A, E>): Effect.Effect<A, E> => effect,\n);\n\nexport const make = (address: string, convexClient: Transport) => {\n  const setAuth = <R1 = never, R2 = never>(\n    fetchToken: (args: {\n      forceRefreshToken: boolean;\n    }) => Effect.Effect<string | null | undefined, never, R1>,\n    onChange?: (isAuthenticated: boolean) => Effect.Effect<void, never, R2>,\n  ): Effect.Effect<void, never, R1 | R2> =>\n    Effect.gen(function* () {\n      const context = yield* Effect.context<R1 | R2>();\n      const runPromise = Effect.runPromiseWith(context);\n      const runFork = Effect.runForkWith(context);\n      convexClient.setAuth(\n        (args) => runPromise(Effect.suspend(() => fetchToken(args))),\n        ...(onChange\n          ? [\n              (isAuthenticated: boolean) => {\n                runFork(Effect.suspend(() => onChange(isAuthenticated)));\n              },\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 runQuery(\n      Ref.runWithCodec(\n        ref,\n        args,\n        (functionReference, encodedArgs) =>\n          convexClient.query(functionReference, encodedArgs),\n        mapUnknownError,\n      ),\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 runMutation(\n      Ref.runWithCodec(\n        ref,\n        args,\n        (functionReference, encodedArgs) =>\n          convexClient.mutation(functionReference, encodedArgs),\n        mapUnknownError,\n      ),\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 runAction(\n      Ref.runWithCodec(\n        ref,\n        args,\n        (functionReference, encodedArgs) =>\n          convexClient.action(functionReference, encodedArgs),\n        mapUnknownError,\n      ),\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,MAAM,WAAW,OAAO,GAAG,uBAAuB,CAAC,EAC1C,WAAqD,MAC9D;AAEA,MAAM,cAAc,OAAO,GAAG,0BAA0B,CAAC,EAChD,WAAqD,MAC9D;AAEA,MAAM,YAAY,OAAO,GAAG,wBAAwB,CAAC,EAC5C,WAAqD,MAC9D;AAEA,MAAa,QAAQ,SAAiB,iBAA4B;CAChE,MAAM,WACJ,YAGA,aAEA,OAAO,IAAI,aAAa;EACtB,MAAM,UAAU,OAAO,OAAO,QAAiB;EAC/C,MAAM,aAAa,OAAO,eAAe,OAAO;EAChD,MAAM,UAAU,OAAO,YAAY,OAAO;EAC1C,aAAa,SACV,SAAS,WAAW,OAAO,cAAc,WAAW,IAAI,CAAC,CAAC,GAC3D,GAAI,WACA,EACG,oBAA6B;GAC5B,QAAQ,OAAO,cAAc,SAAS,eAAe,CAAC,CAAC;EACzD,CACF,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,SACL,IAAI,aACF,KACA,OACC,mBAAmB,gBAClB,aAAa,MAAM,mBAAmB,WAAW,GACnD,eACF,CACF;CACF;CAEA,MAAM,YACJ,KACA,GAAG,SAIA;EACH,MAAM,OAAQ,KAAK,MAAM,CAAC;EAC1B,OAAO,YACL,IAAI,aACF,KACA,OACC,mBAAmB,gBAClB,aAAa,SAAS,mBAAmB,WAAW,GACtD,eACF,CACF;CACF;CAEA,MAAM,UACJ,KACA,GAAG,SAIA;EACH,MAAM,OAAQ,KAAK,MAAM,CAAC;EAC1B,OAAO,UACL,IAAI,aACF,KACA,OACC,mBAAmB,gBAClB,aAAa,OAAO,mBAAmB,WAAW,GACpD,eACF,CACF;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,6 +1,56 @@
 {
   "name": "@gaganref/confect-js",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "10.3.1-fork.2",
+  "peerDependencies": {
+    "@confect/core": "npm:@gaganref/confect-core@10.3.1-fork.2",
+    "convex": "^1.32.0",
+    "effect": "^4.0.0"
+  },
+  "description": "JavaScript client bindings for any JS runtime",
+  "author": "RJ Dellecese",
+  "bugs": {
+    "url": "https://github.com/gaganref/confect"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md",
+    "dist",
+    "!dist/*.tsbuildinfo",
+    "package.json",
+    "src"
+  ],
+  "homepage": "https://confect.dev",
+  "keywords": [
+    "convex",
+    "effect"
+  ],
+  "license": "ISC",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gaganref/confect.git"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  }
 }

package/src/HttpClient.ts

@@ -0,0 +1,40 @@
+import { ConvexHttpClient } from "convex/browser";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as InternalHttpClient from "./internal/HttpClient";
+
+export { HttpClientError } from "./internal/HttpClient";
+
+const make = (
+  address: string,
+  options?: ConstructorParameters<typeof ConvexHttpClient>[1],
+) => {
+  const client = new ConvexHttpClient(address, options);
+  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),
+  });
+};
+
+/**
+ * A Confect client which uses HTTP to communicate with your Convex backend.
+ * Works in any JS runtime that supports `fetch`. Wraps
+ * [ConvexHttpClient](https://docs.convex.dev/api/classes/browser.ConvexHttpClient).
+ */
+export const HttpClient = Context.Service<ReturnType<typeof make>>(
+  "@confect/js/HttpClient",
+);
+
+export type HttpClient = typeof HttpClient.Identifier;
+
+export const layer = (
+  address: string,
+  options?: ConstructorParameters<typeof ConvexHttpClient>[1],
+) => Layer.sync(HttpClient, () => make(address, options));