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

package/dist/Client.js

@@ -0,0 +1,44 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as WebSocketClient from "@confect/js/WebSocketClient";
+import { WebSocketClientError } from "@confect/js/WebSocketClient";
+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";
+//#region src/Client.ts
+var Client_exports = /* @__PURE__ */ __exportAll({
+	Client: () => Client,
+	WebSocketClientError: () => WebSocketClientError,
+	layer: () => layer,
+	make: () => make
+});
+/**
+* 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.
+*/
+const make = (webSocketClient) => Effect.gen(function* () {
+	const paginationId = yield* Ref.make(0);
+	return {
+		...webSocketClient,
+		resolvePaginationId: (restored) => 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.
+*/
+const Client = Context.Service("@confect/foldkit/Client");
+/**
+* Constructs one scoped client for a Foldkit application's `resources`.
+*/
+const layer = (address, options) => Layer.effect(Client, Effect.flatMap(WebSocketClient.WebSocketClient, make)).pipe(Layer.provide(WebSocketClient.layer(address, options)));
+//#endregion
+export { Client, Client_exports, WebSocketClientError, layer, make };
+
+//# sourceMappingURL=Client.js.map

package/dist/Client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Client.js","names":[],"sources":["../src/Client.ts"],"sourcesContent":["import * as WebSocketClient from \"@confect/js/WebSocketClient\";\nimport type { ConvexClient } from \"convex/browser\";\nimport * as Context from \"effect/Context\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport * as Option from \"effect/Option\";\nimport * as Ref from \"effect/Ref\";\n\n/**\n * Builds the Foldkit-facing Confect client around one WebSocket client. The\n * pagination id allocator shares the WebSocket client's lifetime because its\n * ids are cache-busters for that client's query cache.\n */\nexport const make = (webSocketClient: WebSocketClient.WebSocketClient) =>\n  Effect.gen(function* () {\n    const paginationId = yield* Ref.make(0);\n\n    return {\n      ...webSocketClient,\n      resolvePaginationId: (restored: Option.Option<number>) =>\n        Ref.modify(paginationId, (current) =>\n          Option.match(restored, {\n            onNone: () => [current + 1, current + 1],\n            onSome: (id) => [id, Math.max(current, id)],\n          }),\n        ),\n    };\n  });\n\n/**\n * The application-scoped Confect client used by Foldkit Commands and\n * Subscriptions. It combines the WebSocket API with the pagination-session id\n * allocator required by Convex's query cache.\n */\nexport const Client = Context.Service<Effect.Success<ReturnType<typeof make>>>(\n  \"@confect/foldkit/Client\",\n);\n\nexport type Client = typeof Client.Identifier;\n\n/**\n * Constructs one scoped client for a Foldkit application's `resources`.\n */\nexport const layer = (\n  address: string,\n  options?: ConstructorParameters<typeof ConvexClient>[1],\n) =>\n  Layer.effect(\n    Client,\n    Effect.flatMap(WebSocketClient.WebSocketClient, make),\n  ).pipe(Layer.provide(WebSocketClient.layer(address, options)));\n\nexport { WebSocketClientError } from \"@confect/js/WebSocketClient\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAaA,MAAa,QAAQ,oBACnB,OAAO,IAAI,aAAa;CACtB,MAAM,eAAe,OAAO,IAAI,KAAK,CAAC;CAEtC,OAAO;EACL,GAAG;EACH,sBAAsB,aACpB,IAAI,OAAO,eAAe,YACxB,OAAO,MAAM,UAAU;GACrB,cAAc,CAAC,UAAU,GAAG,UAAU,CAAC;GACvC,SAAS,OAAO,CAAC,IAAI,KAAK,IAAI,SAAS,EAAE,CAAC;EAC5C,CAAC,CACH;CACJ;AACF,CAAC;;;;;;AAOH,MAAa,SAAS,QAAQ,QAC5B,yBACF;;;;AAOA,MAAa,SACX,SACA,YAEA,MAAM,OACJ,QACA,OAAO,QAAQ,gBAAgB,iBAAiB,IAAI,CACtD,CAAC,CAAC,KAAK,MAAM,QAAQ,gBAAgB,MAAM,SAAS,OAAO,CAAC,CAAC"}

package/dist/Command.d.ts

@@ -0,0 +1,162 @@
+import type * as Ref from "@confect/core/Ref";
+import * as Effect from "effect/Effect";
+import type * as Schema from "effect/Schema";
+import * as FoldkitCommand from "foldkit/command";
+import * as Client from "./Client";
+/**
+ * Everything a Command against `Ref_` can fail with before it is folded into an
+ * `onError` Message: the ref's typed error (if it declares an `error` schema),
+ * a transport-level `WebSocketClientError`, or a `SchemaError` from encoding
+ * args or decoding returns.
+ */
+export type Error<Ref_ extends Ref.AnyConfect> = Ref.Error<Ref_> | Client.WebSocketClientError | Schema.SchemaError;
+/**
+ * Maps a Confect function's outcome into the app's Messages. Every failure—the
+ * ref's typed error, a transport error, or a codec error—arrives via `onError`,
+ * so the resulting Command's error channel is `never`, as Foldkit requires.
+ * Follow Foldkit's naming convention: past-tense facts like
+ * `SucceededSaveNote`/`FailedSaveNote`.
+ */
+export interface Handlers<Ref_ extends Ref.AnyConfect, SuccessMessage, ErrorMessage> {
+    readonly onSuccess: (returns: Ref.Returns<Ref_>) => SuccessMessage;
+    readonly onError: (error: Error<Ref_>) => ErrorMessage;
+}
+/**
+ * The Command instance a definition call constructs.
+ */
+type Instance<Name extends string, Ref_ extends Ref.AnyConfect, Message> = Readonly<{
+    name: Name;
+    args: Ref.Args<Ref_>;
+    effect: Effect.Effect<Message, never, Client.Client>;
+}>;
+type SchemaArgs<Ref_ extends Ref.AnyConfect> = Schema.Schema.Type<Schema.Struct<Ref.ArgsSchema<Ref_>["fields"]>>;
+/**
+ * A Foldkit Command definition whose args are the ref's args: our ref-derived
+ * call signature (args optional when the ref declares none) intersected with
+ * Foldkit's own `CommandDefinitionWithArgs`, which supplies the
+ * `CommandDefinitionTypeId` brand and makes the definition assignable wherever
+ * Foldkit accepts one—including Story/Scene `Command.resolve` and `expectExact`
+ * matchers. Call it from `update` to construct a Command instance; nothing runs
+ * until the Foldkit runtime executes it.
+ */
+export type Definition<Name extends string, Ref_ extends Ref.AnyConfect, Message> = ((...args: Ref.OptionalArgs<Ref_>) => Instance<Name, Ref_, Message>) & FoldkitCommand.CommandDefinitionWithArgs<Name, Ref.ArgsSchema<Ref_>["fields"], Effect.Effect<Message, never, Client.Client>>;
+/**
+ * Makes a factory-built Command interruptible—Foldkit's `InterruptOption`
+ * applied to the ref's args. `true` keys every invocation by the Command
+ * name—right when at most one invocation is meaningfully in flight; a
+ * `KeyedInterrupt` derives the key part from the ref's args, so concurrent
+ * invocations can be targeted independently.
+ *
+ * Interrupting stops the client-side Effect and guarantees the invocation's
+ * result Messages never dispatch—it does not cancel the Convex function on the
+ * server, which runs to completion once the call is on the wire.
+ */
+export type InterruptOption<Ref_ extends Ref.AnyConfect, KeyField extends keyof SchemaArgs<Ref_> & string = keyof SchemaArgs<Ref_> & string> = FoldkitCommand.InterruptOption<SchemaArgs<Ref_>, KeyField>;
+/**
+ * The keyed arm of `InterruptOption`: `keyFields` declares the args the
+ * `Interrupt` constructor requires; `toKey` derives the key part from them.
+ */
+export type KeyedInterrupt<Ref_ extends Ref.AnyConfect, KeyField extends keyof SchemaArgs<Ref_> & string> = Exclude<InterruptOption<Ref_, KeyField>, true>;
+/**
+ * An interruptible Command definition whose key is the Command name—the
+ * ref-derived call signature intersected with Foldkit's
+ * `Interruptible.DefinitionWithArgsNameKeyed`, which supplies the brand and the
+ * `Interrupt` constructor.
+ */
+export type InterruptibleDefinition<Name extends string, Ref_ extends Ref.AnyConfect, Message> = ((...args: Ref.OptionalArgs<Ref_>) => Instance<Name, Ref_, Message> & Readonly<{
+    key: string;
+}>) & FoldkitCommand.Interruptible.DefinitionWithArgsNameKeyed<Name, Ref.ArgsSchema<Ref_>["fields"], Effect.Effect<Message, never, Client.Client>>;
+/**
+ * An interruptible Command definition whose key is derived from the ref's
+ * args—the ref-derived call signature intersected with Foldkit's
+ * `Interruptible.DefinitionWithArgs`, which supplies the brand and the
+ * key-args-taking `Interrupt` constructor.
+ */
+export type KeyedInterruptibleDefinition<Name extends string, Ref_ extends Ref.AnyConfect, KeyField extends keyof SchemaArgs<Ref_> & string, Message> = ((...args: Ref.OptionalArgs<Ref_>) => Instance<Name, Ref_, Message> & Readonly<{
+    key: string;
+}>) & FoldkitCommand.Interruptible.DefinitionWithArgs<Name, Ref.ArgsSchema<Ref_>["fields"], Pick<SchemaArgs<Ref_>, KeyField>, Effect.Effect<Message, never, Client.Client>>;
+/**
+ * An execute body for a hand-written `Command.define`—every failure already
+ * folded into a Message. Reach for these when the factory below doesn't fit: a
+ * custom args schema, `interrupt`, or a Command that makes several calls.
+ */
+export declare const queryEffect: <Query extends Ref.AnyConfectPublicQuery, SuccessMessage, ErrorMessage>(ref: Query, handlers: Handlers<Query, SuccessMessage, ErrorMessage>) => (...args: Ref.OptionalArgs<Query>) => Effect.Effect<SuccessMessage | ErrorMessage, never, Client.Client>;
+/**
+ * An execute body for a hand-written `Command.define`—every failure already
+ * folded into a Message. See `queryEffect`.
+ */
+export declare const mutationEffect: <Mutation extends Ref.AnyConfectPublicMutation, SuccessMessage, ErrorMessage>(ref: Mutation, handlers: Handlers<Mutation, SuccessMessage, ErrorMessage>) => (...args: Ref.OptionalArgs<Mutation>) => Effect.Effect<SuccessMessage | ErrorMessage, never, Client.Client>;
+/**
+ * An execute body for a hand-written `Command.define`—every failure already
+ * folded into a Message. See `queryEffect`.
+ */
+export declare const actionEffect: <Action extends Ref.AnyConfectPublicAction, SuccessMessage, ErrorMessage>(ref: Action, handlers: Handlers<Action, SuccessMessage, ErrorMessage>) => (...args: Ref.OptionalArgs<Action>) => Effect.Effect<SuccessMessage | ErrorMessage, never, Client.Client>;
+type RunWithArgs<Ref_ extends Ref.AnyConfect, Message> = (...args: Ref.OptionalArgs<Ref_>) => Effect.Effect<Message, never, Client.Client>;
+type FactoryConfig<Ref_ extends Ref.AnyConfect, Messages extends ReadonlyArray<Schema.Top>, SuccessMessage, ErrorMessage> = Handlers<Ref_, SuccessMessage, ErrorMessage> & {
+    readonly messages: Messages;
+};
+type KeyedFactoryConfig<Ref_ extends Ref.AnyConfect, Messages extends ReadonlyArray<Schema.Top>, SuccessMessage, ErrorMessage, KeyField extends keyof SchemaArgs<Ref_> & string> = FactoryConfig<Ref_, Messages, SuccessMessage, ErrorMessage> & {
+    readonly interrupt: KeyedInterrupt<Ref_, KeyField>;
+};
+type NameKeyedFactoryConfig<Ref_ extends Ref.AnyConfect, Messages extends ReadonlyArray<Schema.Top>, SuccessMessage, ErrorMessage> = FactoryConfig<Ref_, Messages, SuccessMessage, ErrorMessage> & {
+    readonly interrupt: true;
+};
+type StandardFactoryConfig<Ref_ extends Ref.AnyConfect, Messages extends ReadonlyArray<Schema.Top>, SuccessMessage, ErrorMessage> = FactoryConfig<Ref_, Messages, SuccessMessage, ErrorMessage> & {
+    readonly interrupt?: never;
+};
+/**
+ * Builds the overload set for one ref kind. Each arm preserves whether
+ * `interrupt` is absent, `true`, or args-keyed all the way to
+ * `makeDefinition`.
+ */
+declare const makeFactory: <BoundRef extends Ref.AnyConfect>(effectHelper: <Ref_ extends BoundRef, SuccessMessage, ErrorMessage>(ref: Ref_, handlers: Handlers<Ref_, SuccessMessage, ErrorMessage>) => RunWithArgs<Ref_, SuccessMessage | ErrorMessage>) => {
+    <const Name extends string, Ref_ extends BoundRef, const Messages extends ReadonlyArray<Schema.Top>, SuccessMessage extends Schema.Schema.Type<Messages[number]>, ErrorMessage extends Schema.Schema.Type<Messages[number]>, KeyField extends keyof SchemaArgs<Ref_> & string>(name: Name, ref: Ref_, config: KeyedFactoryConfig<Ref_, Messages, SuccessMessage, ErrorMessage, KeyField>): KeyedInterruptibleDefinition<Name, Ref_, KeyField, SuccessMessage | ErrorMessage>;
+    <const Name extends string, Ref_ extends BoundRef, const Messages extends ReadonlyArray<Schema.Top>, SuccessMessage extends Schema.Schema.Type<Messages[number]>, ErrorMessage extends Schema.Schema.Type<Messages[number]>>(name: Name, ref: Ref_, config: NameKeyedFactoryConfig<Ref_, Messages, SuccessMessage, ErrorMessage>): InterruptibleDefinition<Name, Ref_, SuccessMessage | ErrorMessage>;
+    <const Name extends string, Ref_ extends BoundRef, const Messages extends ReadonlyArray<Schema.Top>, SuccessMessage extends Schema.Schema.Type<Messages[number]>, ErrorMessage extends Schema.Schema.Type<Messages[number]>>(name: Name, ref: Ref_, config: StandardFactoryConfig<Ref_, Messages, SuccessMessage, ErrorMessage>): Definition<Name, Ref_, SuccessMessage | ErrorMessage>;
+};
+/**
+ * A Foldkit Command definition for a Confect query whose Command args are the
+ * ref's args:
+ *
+ * ```ts
+ * const FetchNote = Command.query("FetchNote", refs.public.notes.get, {
+ *   messages: [SucceededGetNote, FailedGetNote],
+ *   onSuccess: (note) => SucceededGetNote({ note }),
+ *   onError: (error) => FailedGetNote({ message: String(error) }),
+ * });
+ * // In update:
+ * // [model, [FetchNote({ noteId })]]
+ * ```
+ *
+ * Pass `interrupt` to make invocations interruptible via the returned
+ * definition's `Interrupt` constructor—`true` keys them by the Command name, `{
+ * keyFields, toKey }` by a part derived from the ref's args:
+ *
+ * ```ts
+ * const SaveDraft = Command.mutation(
+ *   "SaveDraft",
+ *   refs.public.notes.insert,
+ *   {
+ *     messages: [SucceededSaveDraft, FailedSaveDraft],
+ *     onSuccess: (noteId) => SucceededSaveDraft({ noteId }),
+ *     onError: (error) => FailedSaveDraft({ message: String(error) }),
+ *     interrupt: true,
+ *   },
+ * );
+ * // In update:
+ * // [model, [SaveDraft.Interrupt((outcome) => CompletedCancelSaveDraft({ outcome }))]]
+ * ```
+ */
+export declare const query: ReturnType<typeof makeFactory<Ref.AnyConfectPublicQuery>>;
+/**
+ * A Foldkit Command definition for a Confect mutation whose Command args are
+ * the ref's args. See `query`.
+ */
+export declare const mutation: ReturnType<typeof makeFactory<Ref.AnyConfectPublicMutation>>;
+/**
+ * A Foldkit Command definition for a Confect action whose Command args are the
+ * ref's args. See `query`.
+ */
+export declare const action: ReturnType<typeof makeFactory<Ref.AnyConfectPublicAction>>;
+export {};
+//# sourceMappingURL=Command.d.ts.map

package/dist/Command.d.ts.map

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

package/dist/Command.js

@@ -0,0 +1,115 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { Client } from "./Client.js";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as FoldkitCommand from "foldkit/command";
+//#region src/Command.ts
+var Command_exports = /* @__PURE__ */ __exportAll({
+	action: () => action,
+	actionEffect: () => actionEffect,
+	mutation: () => mutation,
+	mutationEffect: () => mutationEffect,
+	query: () => query,
+	queryEffect: () => queryEffect
+});
+const run = (handlers, invoke) => Effect.flatMap(Client, invoke).pipe(Effect.match({
+	onSuccess: handlers.onSuccess,
+	onFailure: handlers.onError
+}));
+/**
+* An execute body for a hand-written `Command.define`—every failure already
+* folded into a Message. Reach for these when the factory below doesn't fit: a
+* custom args schema, `interrupt`, or a Command that makes several calls.
+*/
+const queryEffect = (ref, handlers) => (...args) => run(handlers, (client) => client.query(ref, ...args));
+/**
+* An execute body for a hand-written `Command.define`—every failure already
+* folded into a Message. See `queryEffect`.
+*/
+const mutationEffect = (ref, handlers) => (...args) => run(handlers, (client) => client.mutation(ref, ...args));
+/**
+* An execute body for a hand-written `Command.define`—every failure already
+* folded into a Message. See `queryEffect`.
+*/
+const actionEffect = (ref, handlers) => (...args) => run(handlers, (client) => client.action(ref, ...args));
+function makeDefinition(name, ref, messages, runWithArgs, interrupt) {
+	const fields = ref.args.fields;
+	const execute = (args) => runWithArgs(...args === void 0 ? [] : [args]);
+	return Match.value(interrupt).pipe(Match.withReturnType(), Match.when(void 0, () => FoldkitCommand.define(name, {
+		args: fields,
+		messages,
+		execute
+	})), Match.when(true, (nameKeyedInterrupt) => FoldkitCommand.define(name, {
+		args: fields,
+		messages,
+		interrupt: nameKeyedInterrupt,
+		execute
+	})), Match.when(Match.defined, (keyedInterrupt) => {
+		return FoldkitCommand.define(name, {
+			args: fields,
+			messages,
+			interrupt: keyedInterrupt,
+			execute
+		});
+	}), Match.exhaustive);
+}
+/**
+* Builds the overload set for one ref kind. Each arm preserves whether
+* `interrupt` is absent, `true`, or args-keyed all the way to
+* `makeDefinition`.
+*/
+const makeFactory = (effectHelper) => {
+	function factory(name, ref, config) {
+		const runWithArgs = effectHelper(ref, config);
+		return Match.value(config.interrupt).pipe(Match.withReturnType(), Match.when(void 0, () => makeDefinition(name, ref, config.messages, runWithArgs)), Match.when(true, (interrupt) => makeDefinition(name, ref, config.messages, runWithArgs, interrupt)), Match.when(Match.defined, (interrupt) => makeDefinition(name, ref, config.messages, runWithArgs, interrupt)), Match.exhaustive);
+	}
+	return factory;
+};
+/**
+* A Foldkit Command definition for a Confect query whose Command args are the
+* ref's args:
+*
+* ```ts
+* const FetchNote = Command.query("FetchNote", refs.public.notes.get, {
+*   messages: [SucceededGetNote, FailedGetNote],
+*   onSuccess: (note) => SucceededGetNote({ note }),
+*   onError: (error) => FailedGetNote({ message: String(error) }),
+* });
+* // In update:
+* // [model, [FetchNote({ noteId })]]
+* ```
+*
+* Pass `interrupt` to make invocations interruptible via the returned
+* definition's `Interrupt` constructor—`true` keys them by the Command name, `{
+* keyFields, toKey }` by a part derived from the ref's args:
+*
+* ```ts
+* const SaveDraft = Command.mutation(
+*   "SaveDraft",
+*   refs.public.notes.insert,
+*   {
+*     messages: [SucceededSaveDraft, FailedSaveDraft],
+*     onSuccess: (noteId) => SucceededSaveDraft({ noteId }),
+*     onError: (error) => FailedSaveDraft({ message: String(error) }),
+*     interrupt: true,
+*   },
+* );
+* // In update:
+* // [model, [SaveDraft.Interrupt((outcome) => CompletedCancelSaveDraft({ outcome }))]]
+* ```
+*/
+const query = makeFactory(queryEffect);
+/**
+* A Foldkit Command definition for a Confect mutation whose Command args are
+* the ref's args. See `query`.
+*/
+const mutation = makeFactory(mutationEffect);
+/**
+* A Foldkit Command definition for a Confect action whose Command args are the
+* ref's args. See `query`.
+*/
+const action = makeFactory(actionEffect);
+//#endregion
+export { Command_exports, action, actionEffect, mutation, mutationEffect, query, queryEffect };
+
+//# sourceMappingURL=Command.js.map

package/dist/Command.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Command.js","names":["Client.Client"],"sources":["../src/Command.ts"],"sourcesContent":["import type * as Ref from \"@confect/core/Ref\";\nimport * as Effect from \"effect/Effect\";\nimport * as Match from \"effect/Match\";\nimport type * as Schema from \"effect/Schema\";\nimport * as FoldkitCommand from \"foldkit/command\";\nimport * as Client from \"./Client\";\n\n/**\n * Everything a Command against `Ref_` can fail with before it is folded into an\n * `onError` Message: the ref's typed error (if it declares an `error` schema),\n * a transport-level `WebSocketClientError`, or a `SchemaError` from encoding\n * args or decoding returns.\n */\nexport type Error<Ref_ extends Ref.AnyConfect> =\n  | Ref.Error<Ref_>\n  | Client.WebSocketClientError\n  | Schema.SchemaError;\n\n/**\n * Maps a Confect function's outcome 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 Command's error channel is `never`, as Foldkit requires.\n * Follow Foldkit's naming convention: past-tense facts like\n * `SucceededSaveNote`/`FailedSaveNote`.\n */\nexport interface Handlers<\n  Ref_ extends Ref.AnyConfect,\n  SuccessMessage,\n  ErrorMessage,\n> {\n  readonly onSuccess: (returns: Ref.Returns<Ref_>) => SuccessMessage;\n  readonly onError: (error: Error<Ref_>) => ErrorMessage;\n}\n\n/**\n * The Command instance a definition call constructs.\n */\ntype Instance<\n  Name extends string,\n  Ref_ extends Ref.AnyConfect,\n  Message,\n> = Readonly<{\n  name: Name;\n  args: Ref.Args<Ref_>;\n  effect: Effect.Effect<Message, never, Client.Client>;\n}>;\n\ntype SchemaArgs<Ref_ extends Ref.AnyConfect> = Schema.Schema.Type<\n  Schema.Struct<Ref.ArgsSchema<Ref_>[\"fields\"]>\n>;\n\n/**\n * A Foldkit Command definition whose args are the ref's args: our ref-derived\n * call signature (args optional when the ref declares none) intersected with\n * Foldkit's own `CommandDefinitionWithArgs`, which supplies the\n * `CommandDefinitionTypeId` brand and makes the definition assignable wherever\n * Foldkit accepts one—including Story/Scene `Command.resolve` and `expectExact`\n * matchers. Call it from `update` to construct a Command instance; nothing runs\n * until the Foldkit runtime executes it.\n */\nexport type Definition<\n  Name extends string,\n  Ref_ extends Ref.AnyConfect,\n  Message,\n> = ((...args: Ref.OptionalArgs<Ref_>) => Instance<Name, Ref_, Message>) &\n  FoldkitCommand.CommandDefinitionWithArgs<\n    Name,\n    Ref.ArgsSchema<Ref_>[\"fields\"],\n    Effect.Effect<Message, never, Client.Client>\n  >;\n\n/**\n * Makes a factory-built Command interruptible—Foldkit's `InterruptOption`\n * applied to the ref's args. `true` keys every invocation by the Command\n * name—right when at most one invocation is meaningfully in flight; a\n * `KeyedInterrupt` derives the key part from the ref's args, so concurrent\n * invocations can be targeted independently.\n *\n * Interrupting stops the client-side Effect and guarantees the invocation's\n * result Messages never dispatch—it does not cancel the Convex function on the\n * server, which runs to completion once the call is on the wire.\n */\nexport type InterruptOption<\n  Ref_ extends Ref.AnyConfect,\n  KeyField extends keyof SchemaArgs<Ref_> & string = keyof SchemaArgs<Ref_> &\n    string,\n> = FoldkitCommand.InterruptOption<SchemaArgs<Ref_>, KeyField>;\n\n/**\n * The keyed arm of `InterruptOption`: `keyFields` declares the args the\n * `Interrupt` constructor requires; `toKey` derives the key part from them.\n */\nexport type KeyedInterrupt<\n  Ref_ extends Ref.AnyConfect,\n  KeyField extends keyof SchemaArgs<Ref_> & string,\n> = Exclude<InterruptOption<Ref_, KeyField>, true>;\n\n/**\n * An interruptible Command definition whose key is the Command name—the\n * ref-derived call signature intersected with Foldkit's\n * `Interruptible.DefinitionWithArgsNameKeyed`, which supplies the brand and the\n * `Interrupt` constructor.\n */\nexport type InterruptibleDefinition<\n  Name extends string,\n  Ref_ extends Ref.AnyConfect,\n  Message,\n> = ((\n  ...args: Ref.OptionalArgs<Ref_>\n) => Instance<Name, Ref_, Message> & Readonly<{ key: string }>) &\n  FoldkitCommand.Interruptible.DefinitionWithArgsNameKeyed<\n    Name,\n    Ref.ArgsSchema<Ref_>[\"fields\"],\n    Effect.Effect<Message, never, Client.Client>\n  >;\n\n/**\n * An interruptible Command definition whose key is derived from the ref's\n * args—the ref-derived call signature intersected with Foldkit's\n * `Interruptible.DefinitionWithArgs`, which supplies the brand and the\n * key-args-taking `Interrupt` constructor.\n */\nexport type KeyedInterruptibleDefinition<\n  Name extends string,\n  Ref_ extends Ref.AnyConfect,\n  KeyField extends keyof SchemaArgs<Ref_> & string,\n  Message,\n> = ((\n  ...args: Ref.OptionalArgs<Ref_>\n) => Instance<Name, Ref_, Message> & Readonly<{ key: string }>) &\n  FoldkitCommand.Interruptible.DefinitionWithArgs<\n    Name,\n    Ref.ArgsSchema<Ref_>[\"fields\"],\n    Pick<SchemaArgs<Ref_>, KeyField>,\n    Effect.Effect<Message, never, Client.Client>\n  >;\n\nconst run = <Ref_ extends Ref.AnyConfect, SuccessMessage, ErrorMessage>(\n  handlers: Handlers<Ref_, SuccessMessage, ErrorMessage>,\n  invoke: (\n    client: Client.Client,\n  ) => Effect.Effect<Ref.Returns<Ref_>, Error<Ref_>>,\n): Effect.Effect<SuccessMessage | ErrorMessage, never, Client.Client> =>\n  Effect.flatMap(Client.Client, invoke).pipe(\n    Effect.match({\n      onSuccess: handlers.onSuccess,\n      onFailure: handlers.onError,\n    }),\n  );\n\n/**\n * An execute body for a hand-written `Command.define`—every failure already\n * folded into a Message. Reach for these when the factory below doesn't fit: a\n * custom args schema, `interrupt`, or a Command that makes several calls.\n */\nexport const queryEffect =\n  <Query extends Ref.AnyConfectPublicQuery, SuccessMessage, ErrorMessage>(\n    ref: Query,\n    handlers: Handlers<Query, SuccessMessage, ErrorMessage>,\n  ) =>\n  (\n    ...args: Ref.OptionalArgs<Query>\n  ): Effect.Effect<SuccessMessage | ErrorMessage, never, Client.Client> =>\n    run(handlers, (client) => client.query(ref, ...args));\n\n/**\n * An execute body for a hand-written `Command.define`—every failure already\n * folded into a Message. See `queryEffect`.\n */\nexport const mutationEffect =\n  <Mutation extends Ref.AnyConfectPublicMutation, SuccessMessage, ErrorMessage>(\n    ref: Mutation,\n    handlers: Handlers<Mutation, SuccessMessage, ErrorMessage>,\n  ) =>\n  (\n    ...args: Ref.OptionalArgs<Mutation>\n  ): Effect.Effect<SuccessMessage | ErrorMessage, never, Client.Client> =>\n    run(handlers, (client) => client.mutation(ref, ...args));\n\n/**\n * An execute body for a hand-written `Command.define`—every failure already\n * folded into a Message. See `queryEffect`.\n */\nexport const actionEffect =\n  <Action extends Ref.AnyConfectPublicAction, SuccessMessage, ErrorMessage>(\n    ref: Action,\n    handlers: Handlers<Action, SuccessMessage, ErrorMessage>,\n  ) =>\n  (\n    ...args: Ref.OptionalArgs<Action>\n  ): Effect.Effect<SuccessMessage | ErrorMessage, never, Client.Client> =>\n    run(handlers, (client) => client.action(ref, ...args));\n\ntype RunWithArgs<Ref_ extends Ref.AnyConfect, Message> = (\n  ...args: Ref.OptionalArgs<Ref_>\n) => Effect.Effect<Message, never, Client.Client>;\n\nfunction makeDefinition<\n  Name extends string,\n  Ref_ extends Ref.AnyConfect,\n  SuccessMessage,\n  ErrorMessage,\n  KeyField extends keyof SchemaArgs<Ref_> & string = keyof SchemaArgs<Ref_> &\n    string,\n>(\n  name: Name,\n  ref: Ref_,\n  messages: ReadonlyArray<Schema.Top>,\n  runWithArgs: RunWithArgs<Ref_, SuccessMessage | ErrorMessage>,\n  interrupt?: InterruptOption<Ref_, KeyField>,\n): Definition<Name, Ref_, SuccessMessage | ErrorMessage> {\n  type Fields = Ref.ArgsSchema<Ref_>[\"fields\"];\n  type FoldkitArgs = SchemaArgs<Ref_>;\n\n  const fields: Fields = ref.args.fields;\n  const execute = (args: FoldkitArgs | undefined) =>\n    runWithArgs(\n      ...((args === undefined ? [] : [args]) as Ref.OptionalArgs<Ref_>),\n    );\n\n  return Match.value(interrupt).pipe(\n    Match.withReturnType<\n      Definition<Name, Ref_, SuccessMessage | ErrorMessage>\n    >(),\n    Match.when(\n      undefined,\n      () =>\n        FoldkitCommand.define(name, {\n          args: fields,\n          messages,\n          execute,\n        }) as Definition<Name, Ref_, SuccessMessage | ErrorMessage>,\n    ),\n    Match.when(\n      true,\n      (nameKeyedInterrupt) =>\n        FoldkitCommand.define(name, {\n          args: fields,\n          messages,\n          interrupt: nameKeyedInterrupt,\n          execute,\n        }) as InterruptibleDefinition<\n          Name,\n          Ref_,\n          SuccessMessage | ErrorMessage\n        >,\n    ),\n    Match.when(Match.defined, (keyedInterrupt) => {\n      const definition: FoldkitCommand.CommandDefinitionWithArgs<\n        Name,\n        Fields,\n        ReturnType<typeof execute>\n      > = FoldkitCommand.define(name, {\n        args: fields,\n        messages,\n        interrupt: keyedInterrupt,\n        execute,\n      });\n      return definition as Definition<\n        Name,\n        Ref_,\n        SuccessMessage | ErrorMessage\n      >;\n    }),\n    Match.exhaustive,\n  );\n}\n\ntype FactoryConfig<\n  Ref_ extends Ref.AnyConfect,\n  Messages extends ReadonlyArray<Schema.Top>,\n  SuccessMessage,\n  ErrorMessage,\n> = Handlers<Ref_, SuccessMessage, ErrorMessage> & {\n  readonly messages: Messages;\n};\n\ntype KeyedFactoryConfig<\n  Ref_ extends Ref.AnyConfect,\n  Messages extends ReadonlyArray<Schema.Top>,\n  SuccessMessage,\n  ErrorMessage,\n  KeyField extends keyof SchemaArgs<Ref_> & string,\n> = FactoryConfig<Ref_, Messages, SuccessMessage, ErrorMessage> & {\n  readonly interrupt: KeyedInterrupt<Ref_, KeyField>;\n};\n\ntype NameKeyedFactoryConfig<\n  Ref_ extends Ref.AnyConfect,\n  Messages extends ReadonlyArray<Schema.Top>,\n  SuccessMessage,\n  ErrorMessage,\n> = FactoryConfig<Ref_, Messages, SuccessMessage, ErrorMessage> & {\n  readonly interrupt: true;\n};\n\ntype StandardFactoryConfig<\n  Ref_ extends Ref.AnyConfect,\n  Messages extends ReadonlyArray<Schema.Top>,\n  SuccessMessage,\n  ErrorMessage,\n> = FactoryConfig<Ref_, Messages, SuccessMessage, ErrorMessage> & {\n  readonly interrupt?: never;\n};\n\n/**\n * Builds the overload set for one ref kind. Each arm preserves whether\n * `interrupt` is absent, `true`, or args-keyed all the way to\n * `makeDefinition`.\n */\nconst makeFactory = <BoundRef extends Ref.AnyConfect>(\n  effectHelper: <Ref_ extends BoundRef, SuccessMessage, ErrorMessage>(\n    ref: Ref_,\n    handlers: Handlers<Ref_, SuccessMessage, ErrorMessage>,\n  ) => RunWithArgs<Ref_, SuccessMessage | ErrorMessage>,\n) => {\n  function factory<\n    const Name extends string,\n    Ref_ extends BoundRef,\n    const Messages extends ReadonlyArray<Schema.Top>,\n    SuccessMessage extends Schema.Schema.Type<Messages[number]>,\n    ErrorMessage extends Schema.Schema.Type<Messages[number]>,\n    KeyField extends keyof SchemaArgs<Ref_> & string,\n  >(\n    name: Name,\n    ref: Ref_,\n    config: KeyedFactoryConfig<\n      Ref_,\n      Messages,\n      SuccessMessage,\n      ErrorMessage,\n      KeyField\n    >,\n  ): KeyedInterruptibleDefinition<\n    Name,\n    Ref_,\n    KeyField,\n    SuccessMessage | ErrorMessage\n  >;\n  function factory<\n    const Name extends string,\n    Ref_ extends BoundRef,\n    const Messages extends ReadonlyArray<Schema.Top>,\n    SuccessMessage extends Schema.Schema.Type<Messages[number]>,\n    ErrorMessage extends Schema.Schema.Type<Messages[number]>,\n  >(\n    name: Name,\n    ref: Ref_,\n    config: NameKeyedFactoryConfig<\n      Ref_,\n      Messages,\n      SuccessMessage,\n      ErrorMessage\n    >,\n  ): InterruptibleDefinition<Name, Ref_, SuccessMessage | ErrorMessage>;\n  function factory<\n    const Name extends string,\n    Ref_ extends BoundRef,\n    const Messages extends ReadonlyArray<Schema.Top>,\n    SuccessMessage extends Schema.Schema.Type<Messages[number]>,\n    ErrorMessage extends Schema.Schema.Type<Messages[number]>,\n  >(\n    name: Name,\n    ref: Ref_,\n    config: StandardFactoryConfig<Ref_, Messages, SuccessMessage, ErrorMessage>,\n  ): Definition<Name, Ref_, SuccessMessage | ErrorMessage>;\n  function factory<\n    const Name extends string,\n    Ref_ extends BoundRef,\n    SuccessMessage,\n    ErrorMessage,\n    KeyField extends keyof SchemaArgs<Ref_> & string,\n  >(\n    name: Name,\n    ref: Ref_,\n    config: FactoryConfig<\n      Ref_,\n      ReadonlyArray<Schema.Top>,\n      SuccessMessage,\n      ErrorMessage\n    > & {\n      readonly interrupt?: InterruptOption<Ref_, KeyField>;\n    },\n  ): Definition<Name, Ref_, SuccessMessage | ErrorMessage> {\n    const runWithArgs = effectHelper(ref, config);\n    return Match.value(config.interrupt).pipe(\n      Match.withReturnType<\n        Definition<Name, Ref_, SuccessMessage | ErrorMessage>\n      >(),\n      Match.when(undefined, () =>\n        makeDefinition(name, ref, config.messages, runWithArgs),\n      ),\n      Match.when(true, (interrupt) =>\n        makeDefinition(name, ref, config.messages, runWithArgs, interrupt),\n      ),\n      Match.when(Match.defined, (interrupt) =>\n        makeDefinition(name, ref, config.messages, runWithArgs, interrupt),\n      ),\n      Match.exhaustive,\n    );\n  }\n\n  return factory;\n};\n\n/**\n * A Foldkit Command definition for a Confect query whose Command args are the\n * ref's args:\n *\n * ```ts\n * const FetchNote = Command.query(\"FetchNote\", refs.public.notes.get, {\n *   messages: [SucceededGetNote, FailedGetNote],\n *   onSuccess: (note) => SucceededGetNote({ note }),\n *   onError: (error) => FailedGetNote({ message: String(error) }),\n * });\n * // In update:\n * // [model, [FetchNote({ noteId })]]\n * ```\n *\n * Pass `interrupt` to make invocations interruptible via the returned\n * definition's `Interrupt` constructor—`true` keys them by the Command name, `{\n * keyFields, toKey }` by a part derived from the ref's args:\n *\n * ```ts\n * const SaveDraft = Command.mutation(\n *   \"SaveDraft\",\n *   refs.public.notes.insert,\n *   {\n *     messages: [SucceededSaveDraft, FailedSaveDraft],\n *     onSuccess: (noteId) => SucceededSaveDraft({ noteId }),\n *     onError: (error) => FailedSaveDraft({ message: String(error) }),\n *     interrupt: true,\n *   },\n * );\n * // In update:\n * // [model, [SaveDraft.Interrupt((outcome) => CompletedCancelSaveDraft({ outcome }))]]\n * ```\n */\nexport const query: ReturnType<typeof makeFactory<Ref.AnyConfectPublicQuery>> =\n  makeFactory(queryEffect);\n\n/**\n * A Foldkit Command definition for a Confect mutation whose Command args are\n * the ref's args. See `query`.\n */\nexport const mutation: ReturnType<\n  typeof makeFactory<Ref.AnyConfectPublicMutation>\n> = makeFactory(mutationEffect);\n\n/**\n * A Foldkit Command definition for a Confect action whose Command args are the\n * ref's args. See `query`.\n */\nexport const action: ReturnType<\n  typeof makeFactory<Ref.AnyConfectPublicAction>\n> = makeFactory(actionEffect);\n"],"mappings":";;;;;;;;;;;;;;AAyIA,MAAM,OACJ,UACA,WAIA,OAAO,QAAQA,QAAe,MAAM,CAAC,CAAC,KACpC,OAAO,MAAM;CACX,WAAW,SAAS;CACpB,WAAW,SAAS;AACtB,CAAC,CACH;;;;;;AAOF,MAAa,eAET,KACA,cAGA,GAAG,SAEH,IAAI,WAAW,WAAW,OAAO,MAAM,KAAK,GAAG,IAAI,CAAC;;;;;AAMxD,MAAa,kBAET,KACA,cAGA,GAAG,SAEH,IAAI,WAAW,WAAW,OAAO,SAAS,KAAK,GAAG,IAAI,CAAC;;;;;AAM3D,MAAa,gBAET,KACA,cAGA,GAAG,SAEH,IAAI,WAAW,WAAW,OAAO,OAAO,KAAK,GAAG,IAAI,CAAC;AAMzD,SAAS,eAQP,MACA,KACA,UACA,aACA,WACuD;CAIvD,MAAM,SAAiB,IAAI,KAAK;CAChC,MAAM,WAAW,SACf,YACE,GAAK,SAAS,KAAA,IAAY,CAAC,IAAI,CAAC,IAAI,CACtC;CAEF,OAAO,MAAM,MAAM,SAAS,CAAC,CAAC,KAC5B,MAAM,eAEJ,GACF,MAAM,KACJ,KAAA,SAEE,eAAe,OAAO,MAAM;EAC1B,MAAM;EACN;EACA;CACF,CAAC,CACL,GACA,MAAM,KACJ,OACC,uBACC,eAAe,OAAO,MAAM;EAC1B,MAAM;EACN;EACA,WAAW;EACX;CACF,CAAC,CAKL,GACA,MAAM,KAAK,MAAM,UAAU,mBAAmB;EAW5C,OANI,eAAe,OAAO,MAAM;GAC9B,MAAM;GACN;GACA,WAAW;GACX;EACF,CACgB;CAKlB,CAAC,GACD,MAAM,UACR;AACF;;;;;;AA4CA,MAAM,eACJ,iBAIG;CAmDH,SAAS,QAOP,MACA,KACA,QAQuD;EACvD,MAAM,cAAc,aAAa,KAAK,MAAM;EAC5C,OAAO,MAAM,MAAM,OAAO,SAAS,CAAC,CAAC,KACnC,MAAM,eAEJ,GACF,MAAM,KAAK,KAAA,SACT,eAAe,MAAM,KAAK,OAAO,UAAU,WAAW,CACxD,GACA,MAAM,KAAK,OAAO,cAChB,eAAe,MAAM,KAAK,OAAO,UAAU,aAAa,SAAS,CACnE,GACA,MAAM,KAAK,MAAM,UAAU,cACzB,eAAe,MAAM,KAAK,OAAO,UAAU,aAAa,SAAS,CACnE,GACA,MAAM,UACR;CACF;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,MAAa,QACX,YAAY,WAAW;;;;;AAMzB,MAAa,WAET,YAAY,cAAc;;;;;AAM9B,MAAa,SAET,YAAY,YAAY"}