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

package/dist/Subscription.js

@@ -0,0 +1,123 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { Client, WebSocketClientError } from "./Client.js";
+import { FunctionError, allocateRequest, getSubscriptionRequest } from "./PaginatedQuery.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Match from "effect/Match";
+import * as PaginationError from "@confect/core/PaginationError";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+//#region src/Subscription.ts
+var Subscription_exports = /* @__PURE__ */ __exportAll({
+	paginatedQuery: () => paginatedQuery,
+	reactiveQuery: () => reactiveQuery,
+	reactiveQueryStream: () => reactiveQueryStream
+});
+const paginatedError = (error) => Match.value(error).pipe(Match.when(Schema.isSchemaError, (schemaError) => schemaError), Match.when(Match.instanceOf(WebSocketClientError), (clientError) => PaginationError.fromConvexQueryError(clientError.cause).pipe(Option.getOrElse(() => clientError))), Match.when(Match.any, (functionError) => PaginationError.fromConvexErrorData(functionError).pipe(Option.getOrElse(() => FunctionError({ error: functionError })))), Match.exhaustive);
+/**
+* A `dependenciesToStream` body for a hand-written subscription entry: runs the
+* ref as a reactive query against the `Client` resource and maps every emission
+* and every failure into a Message. Query failures are values, so the
+* subscription remains live and can later emit a successful result.
+*
+* Prefer `reactiveQuery`, which builds the whole entry; reach for this when you
+* need control over the entry's dependencies (custom gating, extra
+* dependencies).
+*/
+const reactiveQueryStream = (ref, handlers) => (...args) => Client.pipe(Effect.map((client) => client.reactiveQueryResult(ref, ...args)), Stream.unwrap, Stream.map(Result.match({
+	onSuccess: handlers.onSuccess,
+	onFailure: handlers.onError
+})));
+/**
+* A complete Foldkit subscription entry for a Confect reactive query. The
+* leading thunk fixes the `Model` type (TypeScript cannot partially infer type
+* arguments), so the `args` extractor's parameter is already typed. Pass the
+* result as an entry value to `Subscription.make`:
+*
+* ```ts
+* import * as Confect from "@confect/foldkit";
+* import * as Subscription from "foldkit/subscription";
+*
+* const subscriptions = Subscription.make<
+*   Model,
+*   Message,
+*   Confect.Client.Client
+* >()(() => ({
+*   note: Confect.Subscription.reactiveQuery<Model>()(
+*     refs.public.notes.get,
+*     {
+*       args: (model) =>
+*         Option.map(model.noteId, (noteId) => ({ noteId })),
+*       onSuccess: (note) => SucceededGetNote({ note }),
+*       onError: (error) => FailedGetNote({ message: String(error) }),
+*     },
+*   ),
+* }));
+* ```
+*
+* The entry's dependencies are the query args wrapped in `Option`: `None`
+* closes the subscription, a change from one `Some` to another unsubscribes and
+* resubscribes with the new args, and structurally equal args leave the
+* subscription running (equivalence is derived from the ref's args schema).
+* Queries without args may omit `args`, leaving the subscription always open.
+*/
+const reactiveQuery = () => (ref, config) => {
+	const modelToArgs = config.args;
+	return {
+		dependenciesSchema: Schema.Struct({ args: Schema.Option(ref.args) }),
+		modelToDependencies: (model) => ({ args: modelToArgs === void 0 ? Option.some({}) : modelToArgs(model) }),
+		dependenciesToStream: ({ args }) => Option.match(args, {
+			onNone: () => Stream.empty,
+			onSome: (someArgs) => reactiveQueryStream(ref, config)(someArgs)
+		})
+	};
+};
+const paginatedQuery = () => (machine, config) => {
+	const ref = machine.ref;
+	const composedArgsSchema = ref.args;
+	const requestEquivalence = Schema.toEquivalence(machine.subscriptionRequestSchema);
+	const optionalRequestEquivalence = Option.makeEquivalence((left, right) => requestEquivalence({
+		...left,
+		paginationId: Option.none()
+	}, {
+		...right,
+		paginationId: Option.none()
+	}));
+	return {
+		dependenciesSchema: Schema.Struct({ request: Schema.Option(machine.subscriptionRequestSchema) }),
+		modelToDependencies: (model) => ({ request: Match.value(config.state(model)).pipe(Match.tag("Idle", () => Option.none()), Match.tag("Active", (state) => Option.some(getSubscriptionRequest(state))), Match.exhaustive) }),
+		keepAliveEquivalence: (left, right) => optionalRequestEquivalence(left.request, right.request),
+		dependenciesToStream: ({ request }) => Option.match(request, {
+			onNone: () => Stream.empty,
+			onSome: (subscriptionRequest) => Stream.unwrap(Effect.gen(function* () {
+				const client = yield* Client;
+				const paginationId = yield* client.resolvePaginationId(subscriptionRequest.paginationId);
+				const allocatedRequest = allocateRequest(subscriptionRequest, paginationId);
+				const { descriptor, options } = allocatedRequest;
+				const composedArgs = composedArgsSchema.make({
+					...allocatedRequest.args,
+					paginationOpts: {
+						numItems: options.initialNumItems,
+						cursor: descriptor.cursor,
+						id: paginationId,
+						...Match.value(options.maximumRowsRead).pipe(Match.when(void 0, () => ({})), Match.when(Match.defined, (maximumRowsRead) => ({ maximumRowsRead })), Match.exhaustive),
+						...Match.value(options.maximumBytesRead).pipe(Match.when(void 0, () => ({})), Match.when(Match.defined, (maximumBytesRead) => ({ maximumBytesRead })), Match.exhaustive),
+						...Option.match(descriptor.endCursor, {
+							onNone: () => ({}),
+							onSome: (endCursor) => ({ endCursor })
+						})
+					}
+				});
+				return client.reactiveQueryResult(ref, composedArgs).pipe(Stream.map((result) => config.onSettled({
+					request: allocatedRequest,
+					result: Result.mapError(result, paginatedError)
+				})));
+			}))
+		})
+	};
+};
+//#endregion
+export { Subscription_exports, paginatedQuery, reactiveQuery, reactiveQueryStream };
+
+//# sourceMappingURL=Subscription.js.map

package/dist/Subscription.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Subscription.js","names":["Client.WebSocketClientError","PaginatedQuery.FunctionError","PaginatedQuery.getSubscriptionRequest","Client.Client","PaginatedQuery.allocateRequest"],"sources":["../src/Subscription.ts"],"sourcesContent":["import * as PaginationError from \"@confect/core/PaginationError\";\nimport type * as Ref from \"@confect/core/Ref\";\nimport * as Effect from \"effect/Effect\";\nimport type * as Equivalence from \"effect/Equivalence\";\nimport * as Match from \"effect/Match\";\nimport * as Option from \"effect/Option\";\nimport * as Result from \"effect/Result\";\nimport * as Schema from \"effect/Schema\";\nimport * as Stream from \"effect/Stream\";\nimport type * as FoldkitSubscription from \"foldkit/subscription\";\nimport * as PaginatedQuery from \"./PaginatedQuery\";\nimport * as Client from \"./Client\";\n\n/**\n * Everything a reactive query subscription against `Query` can fail with: the\n * ref's typed error (if it declares an `error` schema), a transport-level\n * `WebSocketClientError`, or a `SchemaError` from encoding args or decoding\n * returns.\n */\nexport type Error<Query extends Ref.AnyConfectPublicQuery> =\n  | Ref.Error<Query>\n  | Client.WebSocketClientError\n  | Schema.SchemaError;\n\nconst paginatedError = <Query extends Ref.AnyConfectPublicPaginatedQuery>(\n  error: Error<Query>,\n): PaginatedQuery.Error<Query> =>\n  Match.value(error).pipe(\n    Match.when(Schema.isSchemaError, (schemaError) => schemaError),\n    Match.when(Match.instanceOf(Client.WebSocketClientError), (clientError) =>\n      PaginationError.fromConvexQueryError(clientError.cause).pipe(\n        Option.getOrElse(() => clientError),\n      ),\n    ),\n    Match.when(Match.any, (functionError) =>\n      PaginationError.fromConvexErrorData(functionError).pipe(\n        Option.getOrElse(() =>\n          PaginatedQuery.FunctionError({ error: functionError }),\n        ),\n      ),\n    ),\n    Match.exhaustive,\n  ) as PaginatedQuery.Error<Query>;\n\n/**\n * The dependency record of a `reactiveQuery` entry. `None` means the\n * subscription is closed; a change from one `Some` to another tears the server\n * subscription down and reopens it with the new args.\n */\nexport interface Dependencies<Query extends Ref.AnyConfectPublicQuery> {\n  readonly args: Option.Option<Ref.Args<Query>>;\n}\n\n/**\n * Maps a reactive query's emissions into the app's Messages. Every failure—the\n * ref's typed error, a transport error, or a codec error—arrives via `onError`,\n * so the resulting stream's error channel is `never`, as Foldkit requires.\n */\nexport interface Handlers<\n  Query extends Ref.AnyConfectPublicQuery,\n  SuccessMessage,\n  ErrorMessage,\n> {\n  readonly onSuccess: (returns: Ref.Returns<Query>) => SuccessMessage;\n  readonly onError: (error: Error<Query>) => ErrorMessage;\n}\n\n/**\n * The `args` extractor is required whenever the query declares args; queries\n * without args may omit it, in which case the subscription is always open.\n */\ntype ArgsConfig<Query extends Ref.AnyConfectPublicQuery, Model> = {\n  readonly args?: (model: Model) => Option.Option<Ref.Args<Query>>;\n} & (keyof Ref.Args<Query> extends never\n  ? unknown\n  : {\n      readonly args: (model: Model) => Option.Option<Ref.Args<Query>>;\n    });\n\n/**\n * A `dependenciesToStream` body for a hand-written subscription entry: runs the\n * ref as a reactive query against the `Client` resource and maps every emission\n * and every failure into a Message. Query failures are values, so the\n * subscription remains live and can later emit a successful result.\n *\n * Prefer `reactiveQuery`, which builds the whole entry; reach for this when you\n * need control over the entry's dependencies (custom gating, extra\n * dependencies).\n */\nexport const reactiveQueryStream =\n  <Query extends Ref.AnyConfectPublicQuery, SuccessMessage, ErrorMessage>(\n    ref: Query,\n    handlers: Handlers<Query, SuccessMessage, ErrorMessage>,\n  ) =>\n  (\n    ...args: Ref.OptionalArgs<Query>\n  ): Stream.Stream<SuccessMessage | ErrorMessage, never, Client.Client> =>\n    Client.Client.pipe(\n      Effect.map((client) => client.reactiveQueryResult(ref, ...args)),\n      Stream.unwrap,\n      Stream.map(\n        Result.match({\n          onSuccess: handlers.onSuccess,\n          onFailure: handlers.onError,\n        }),\n      ),\n    );\n\n/**\n * A complete Foldkit subscription entry for a Confect reactive query. The\n * leading thunk fixes the `Model` type (TypeScript cannot partially infer type\n * arguments), so the `args` extractor's parameter is already typed. Pass the\n * result as an entry value to `Subscription.make`:\n *\n * ```ts\n * import * as Confect from \"@confect/foldkit\";\n * import * as Subscription from \"foldkit/subscription\";\n *\n * const subscriptions = Subscription.make<\n *   Model,\n *   Message,\n *   Confect.Client.Client\n * >()(() => ({\n *   note: Confect.Subscription.reactiveQuery<Model>()(\n *     refs.public.notes.get,\n *     {\n *       args: (model) =>\n *         Option.map(model.noteId, (noteId) => ({ noteId })),\n *       onSuccess: (note) => SucceededGetNote({ note }),\n *       onError: (error) => FailedGetNote({ message: String(error) }),\n *     },\n *   ),\n * }));\n * ```\n *\n * The entry's dependencies are the query args wrapped in `Option`: `None`\n * closes the subscription, a change from one `Some` to another unsubscribes and\n * resubscribes with the new args, and structurally equal args leave the\n * subscription running (equivalence is derived from the ref's args schema).\n * Queries without args may omit `args`, leaving the subscription always open.\n */\nexport const reactiveQuery =\n  <Model>() =>\n  <Query extends Ref.AnyConfectPublicQuery, SuccessMessage, ErrorMessage>(\n    ref: Query,\n    config: Handlers<Query, SuccessMessage, ErrorMessage> &\n      ArgsConfig<Query, Model>,\n  ): FoldkitSubscription.EntryWithoutKeepAlive<\n    Model,\n    SuccessMessage | ErrorMessage,\n    Dependencies<Query>,\n    Client.Client\n  > => {\n    const modelToArgs = config.args;\n\n    return {\n      dependenciesSchema: Schema.Struct({\n        args: Schema.Option(ref.args),\n      }),\n      modelToDependencies: (model) => ({\n        args:\n          modelToArgs === undefined\n            ? Option.some({} as Ref.Args<Query>)\n            : modelToArgs(model),\n      }),\n      dependenciesToStream: ({ args }) =>\n        Option.match(args, {\n          onNone: () => Stream.empty,\n          onSome: (someArgs) => reactiveQueryStream(ref, config)(someArgs),\n        }),\n    };\n  };\n\n/**\n * A complete Foldkit subscription entry that keeps exactly one live reactive\n * page subscription in sync with a `PaginatedQuery` machine in the Model. The\n * machine state is the single source of truth: navigation and split-pinning\n * change the derived args, while `Idle` closes the subscription. Pagination ids\n * are allocated here and installed by the first settlement.\n *\n * The leading thunk fixes the `Model` type (TypeScript cannot partially infer\n * type arguments), so the `state` extractor's parameter is already typed:\n *\n * ```ts\n * import * as Confect from \"@confect/foldkit\";\n * import * as Subscription from \"foldkit/subscription\";\n *\n * const subscriptions = Subscription.make<\n *   Model,\n *   Message,\n *   Confect.Client.Client\n * >()(() => ({\n *   notesPage: Confect.Subscription.paginatedQuery<Model>()(Notes, {\n *     state: (model) => model.notes,\n *     onSettled: (settlement) => SettledGetNotesPage({ settlement }),\n *   }),\n * }));\n * ```\n *\n * Pass the settlement to `PaginatedQuery.settle` in `update`. The request\n * identity is included in both success and failure Messages, so superseded\n * outcomes cannot settle a newer page or pagination session. Query failures do\n * not close the Convex subscription; a later result can recover naturally.\n */\ntype DependenciesSchema<Dependencies_> = Schema.Schema<Dependencies_> & {\n  readonly fields: Schema.Struct.Fields;\n};\n\ntype EntryWithKeepAlive<Model, Message, Dependencies_, Services> = {\n  readonly dependenciesSchema: DependenciesSchema<Dependencies_>;\n  readonly modelToDependencies: (model: Model) => Dependencies_;\n  readonly keepAliveEquivalence: Equivalence.Equivalence<Dependencies_>;\n  readonly dependenciesToStream: (\n    dependencies: Dependencies_,\n    readDependencies: () => Dependencies_,\n  ) => Stream.Stream<Message, never, Services>;\n};\n\nexport const paginatedQuery =\n  <Model>() =>\n  <\n    PaginatedQueryRef extends Ref.AnyConfectPublicPaginatedQuery,\n    SettledMessage,\n  >(\n    machine: PaginatedQuery.PaginatedQuery<PaginatedQueryRef>,\n    config: {\n      readonly state: (\n        model: Model,\n      ) => PaginatedQuery.State<\n        PaginatedQuery.Item<PaginatedQueryRef>,\n        PaginatedQuery.UserArgs<PaginatedQueryRef>,\n        PaginatedQuery.Error<PaginatedQueryRef>\n      >;\n      readonly onSettled: (\n        settlement: PaginatedQuery.Settlement<\n          PaginatedQuery.Item<PaginatedQueryRef>,\n          PaginatedQuery.UserArgs<PaginatedQueryRef>,\n          PaginatedQuery.Error<PaginatedQueryRef>\n        >,\n      ) => SettledMessage;\n    },\n  ): EntryWithKeepAlive<\n    Model,\n    SettledMessage,\n    {\n      readonly request: Option.Option<\n        PaginatedQuery.SubscriptionRequest<\n          PaginatedQuery.UserArgs<PaginatedQueryRef>\n        >\n      >;\n    },\n    Client.Client\n  > => {\n    const ref = machine.ref;\n    const composedArgsSchema = ref.args;\n    const requestEquivalence = Schema.toEquivalence(\n      machine.subscriptionRequestSchema,\n    );\n    const optionalRequestEquivalence = Option.makeEquivalence<\n      PaginatedQuery.SubscriptionRequest<\n        PaginatedQuery.UserArgs<PaginatedQueryRef>\n      >\n    >((left, right) =>\n      requestEquivalence(\n        { ...left, paginationId: Option.none() },\n        { ...right, paginationId: Option.none() },\n      ),\n    );\n\n    return {\n      dependenciesSchema: Schema.Struct({\n        request: Schema.Option(machine.subscriptionRequestSchema),\n      }),\n      modelToDependencies: (model) => ({\n        request: Match.value(config.state(model)).pipe(\n          Match.tag(\"Idle\", () => Option.none()),\n          Match.tag(\"Active\", (state) =>\n            Option.some(PaginatedQuery.getSubscriptionRequest(state)),\n          ),\n          Match.exhaustive,\n        ),\n      }),\n      keepAliveEquivalence: (left, right) =>\n        optionalRequestEquivalence(left.request, right.request),\n      dependenciesToStream: ({\n        request,\n      }): Stream.Stream<SettledMessage, never, Client.Client> =>\n        Option.match(request, {\n          onNone: () => Stream.empty,\n          onSome: (subscriptionRequest) =>\n            Stream.unwrap(\n              Effect.gen(function* () {\n                const client = yield* Client.Client;\n                const paginationId = yield* client.resolvePaginationId(\n                  subscriptionRequest.paginationId,\n                );\n                const allocatedRequest = PaginatedQuery.allocateRequest(\n                  subscriptionRequest,\n                  paginationId,\n                );\n                const { descriptor, options } = allocatedRequest;\n                const composedArgs = composedArgsSchema.make({\n                  ...allocatedRequest.args,\n                  paginationOpts: {\n                    numItems: options.initialNumItems,\n                    cursor: descriptor.cursor,\n                    id: paginationId,\n                    ...Match.value(options.maximumRowsRead).pipe(\n                      Match.when(undefined, () => ({})),\n                      Match.when(Match.defined, (maximumRowsRead) => ({\n                        maximumRowsRead,\n                      })),\n                      Match.exhaustive,\n                    ),\n                    ...Match.value(options.maximumBytesRead).pipe(\n                      Match.when(undefined, () => ({})),\n                      Match.when(Match.defined, (maximumBytesRead) => ({\n                        maximumBytesRead,\n                      })),\n                      Match.exhaustive,\n                    ),\n                    ...Option.match(descriptor.endCursor, {\n                      onNone: () => ({}),\n                      onSome: (endCursor) => ({ endCursor }),\n                    }),\n                  },\n                });\n                return client.reactiveQueryResult(ref, composedArgs).pipe(\n                  Stream.map((result) =>\n                    config.onSettled({\n                      request: allocatedRequest,\n                      result: Result.mapError(result, paginatedError),\n                    }),\n                  ),\n                );\n              }),\n            ),\n        }),\n    };\n  };\n"],"mappings":"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"}

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,5 @@
+export * as Client from "./Client";
+export * as Command from "./Command";
+export * as PaginatedQuery from "./PaginatedQuery";
+export * as Subscription from "./Subscription";
+//# 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,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,cAAc,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+import { Client_exports } from "./Client.js";
+import { Command_exports } from "./Command.js";
+import { PaginatedQuery_exports } from "./PaginatedQuery.js";
+import { Subscription_exports } from "./Subscription.js";
+export { Client_exports as Client, Command_exports as Command, PaginatedQuery_exports as PaginatedQuery, Subscription_exports as Subscription };

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "@gaganref/confect-foldkit",
-  "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",
+    "@confect/js": "npm:@gaganref/confect-js@10.3.1-fork.2",
+    "effect": "^4.0.0",
+    "foldkit": "^0.165.0"
+  },
+  "description": "Client-side bindings for Foldkit apps",
+  "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",
+    "foldkit"
+  ],
+  "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/Client.ts

@@ -0,0 +1,53 @@
+import * as WebSocketClient from "@confect/js/WebSocketClient";
+import type { ConvexClient } from "convex/browser";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Ref from "effect/Ref";
+
+/**
+ * Builds the Foldkit-facing Confect client around one WebSocket client. The
+ * pagination id allocator shares the WebSocket client's lifetime because its
+ * ids are cache-busters for that client's query cache.
+ */
+export const make = (webSocketClient: WebSocketClient.WebSocketClient) =>
+  Effect.gen(function* () {
+    const paginationId = yield* Ref.make(0);
+
+    return {
+      ...webSocketClient,
+      resolvePaginationId: (restored: Option.Option<number>) =>
+        Ref.modify(paginationId, (current) =>
+          Option.match(restored, {
+            onNone: () => [current + 1, current + 1],
+            onSome: (id) => [id, Math.max(current, id)],
+          }),
+        ),
+    };
+  });
+
+/**
+ * The application-scoped Confect client used by Foldkit Commands and
+ * Subscriptions. It combines the WebSocket API with the pagination-session id
+ * allocator required by Convex's query cache.
+ */
+export const Client = Context.Service<Effect.Success<ReturnType<typeof make>>>(
+  "@confect/foldkit/Client",
+);
+
+export type Client = typeof Client.Identifier;
+
+/**
+ * Constructs one scoped client for a Foldkit application's `resources`.
+ */
+export const layer = (
+  address: string,
+  options?: ConstructorParameters<typeof ConvexClient>[1],
+) =>
+  Layer.effect(
+    Client,
+    Effect.flatMap(WebSocketClient.WebSocketClient, make),
+  ).pipe(Layer.provide(WebSocketClient.layer(address, options)));
+
+export { WebSocketClientError } from "@confect/js/WebSocketClient";