@thomasfosterau/effect-forms-svelte 0.1.0 → 0.3.1

package/dist/kit/FormAction.d.ts

@@ -0,0 +1,132 @@
+import { Classify } from "./CommandFailure.js";
+import { Form, Result, State } from "@thomasfosterau/effect-forms";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import { RequestEvent } from "@sveltejs/kit";
+//#region src/kit/FormAction.d.ts
+type FormState<A, Message = unknown> = State.FormState<A, Message>;
+type FormActionResult<A, Message = unknown> = Result.FormActionResult<A, Message>;
+type FormActionData<A = unknown, Message = unknown> = Result.FormActionData<A, Message>;
+/**
+ * A command: a Promise-returning function or one returning an `Effect` with
+ * no requirements (provide them first, e.g. through a `ManagedRuntime`).
+ */
+type Command$1<I, O> = (input: I) => Promise<O> | Effect.Effect<O, unknown>;
+/**
+ * Wrap a client-id create command so a 409 conflict on the caller's OWN
+ * submitted `id` resolves as success instead of a form error — the
+ * double-submit of a create whose id the client generated.
+ *
+ * On any 409 (a `JsonapiError` / `ErrorResponse`-tagged cause), re-fetches
+ * `input.id` via `fetchExisting` and returns that. This is deliberately
+ * unconditional on *why* the 409 fired: the re-fetch is the proof, not the
+ * status. A 409 from an unrelated precondition never left a row at
+ * `input.id`, so the re-fetch fails and the original conflict rethrows
+ * unchanged. An input with no `id`, or any other failure, rethrows as is.
+ *
+ * `input.id` is read structurally rather than through a constraint on
+ * `Input`: a constraint here would be used only contravariantly (as
+ * `create`'s parameter), which makes TypeScript infer `Input` from the
+ * constraint instead of from the command's own input type.
+ */
+export declare function idempotentCreate<Input, Output>(create: (input: Input) => Promise<Output>, fetchExisting: (id: string) => Promise<Output>): (input: Input) => Promise<Output>;
+/**
+ * Idempotent-retry wiring for a client-id create action: `clientId` gates the
+ * wrap to commands whose input actually carries a client-generated `id` (an
+ * entity form definition's own `clientId`, from `defineEntityForm`);
+ * `fetchExisting` re-fetches the submitted id (see {@link idempotentCreate}).
+ */
+export interface IdempotentCreateOptions<O> {
+  readonly clientId: boolean;
+  readonly fetchExisting: (id: string) => Promise<O> | Effect.Effect<O, unknown>;
+}
+/** Options for {@link runFormAction} and {@link formAction}. */
+export interface FormActionOptions<A, O> {
+  /** Retry a client-id create's own 409 as success (see {@link IdempotentCreateOptions}). */
+  readonly idempotent?: IdempotentCreateOptions<O> | undefined;
+  /**
+   * How a command failure is recognised. Defaults to
+   * {@link CommandFailure.jsonapiFailure}; compose with it to add an
+   * application's own failures.
+   */
+  readonly classify?: Classify | undefined;
+  /**
+   * Applied to every form state echoed back to the browser (an invalid
+   * submission, a routed command failure) — e.g. blanking password fields
+   * so a secret never rides a response body.
+   */
+  readonly redact?: ((state: FormState<A>) => FormState<A>) | undefined;
+  /**
+   * What happens to a command failure the classifier does not recognise:
+   * `"error"` (the default) answers an `Error` result at 500 carrying the
+   * cause's message; `"throw"` rethrows the cause, leaving it to SvelteKit's
+   * `handleError`.
+   */
+  readonly unrecognised?: "error" | "throw" | undefined;
+}
+/**
+ * Validate `request` against `form`, then:
+ *
+ * - invalid → a `Failure` carrying the form state (nested errors + posted
+ *   values), status 400, and the command never runs;
+ * - valid → run the command (wrapped in the idempotent retry when
+ *   `options.idempotent.clientId` is true); on success a `Redirect` (303) to
+ *   `locationFor(output, input)`;
+ * - a recognised command failure → a `Failure` at the failure's own status,
+ *   each JSON:API error routed onto its field (or the root);
+ * - an unrecognised one → an `Error` result at 500 (or a rethrow, per
+ *   `options.unrecognised`).
+ *
+ * Posted values survive every failure, so the form re-renders what was typed.
+ *
+ * `locationFor` returns the redirect target as-is: `runFormAction` does not
+ * check it. {@link formAction} hands it to SvelteKit's `redirect`, which
+ * accepts only a same-origin location (see there).
+ */
+export declare function runFormAction<S extends Schema.Top, O, Message = unknown>(form: Form.Form<S, Message>, request: Request, run: Command$1<S["Type"], O>, locationFor: (output: O, input: S["Type"]) => string, options?: FormActionOptions<S["Type"], O>): Promise<FormActionResult<S["Type"]>>;
+/**
+ * A command for {@link formAction}: like {@link Command}, and also handed the
+ * `RequestEvent` (for `locals`, `cookies`, `fetch`).
+ */
+export type ActionCommand<I, O> = (input: I, event: RequestEvent) => Promise<O> | Effect.Effect<O, unknown>;
+/**
+ * Derive a SvelteKit page form **action** from `form` plus its command. The
+ * handler validates the submission, runs the command on success, and maps
+ * the outcome onto SvelteKit's action protocol:
+ *
+ * - success → `redirect(303, locationFor(output, input))`;
+ * - an invalid submission or a recognised command failure →
+ *   `fail(status, { form })`, carrying the (redacted) state;
+ * - an unrecognised failure → `fail(500, { message })` (or a rethrow).
+ *
+ * Wire it into `export const actions`; the client `createForm` store applies
+ * the returned `form` via {@link enhanceForm} (or `applyActionResult`).
+ *
+ * `locationFor` must return a same-origin path, such as
+ * `/organisations/${id}`. SvelteKit 3's `redirect` rejects an external
+ * location unless it is passed `{ external }`, and `formAction` never passes
+ * it, so a `locationFor` that returns an absolute URL on another origin (or a
+ * protocol-relative `//host/...`) makes the action throw an `Error` instead of
+ * redirecting, after the command has already run. To send the user off-site,
+ * redirect to a same-origin route that performs the external redirect itself.
+ *
+ * @example
+ * ```ts
+ * // src/routes/organisations/create/+page.server.ts
+ * import { formAction } from "@thomasfosterau/effect-forms-svelte/kit";
+ * import { organisationForm } from "#lib/forms";
+ * import { api } from "#lib/server/api";
+ *
+ * export const actions = {
+ *   default: formAction(
+ *     organisationForm,
+ *     (input, { locals }) => api(locals).organisations.create(input),
+ *     (id) => `/organisations/${id}`,
+ *   ),
+ * };
+ * ```
+ */
+export declare function formAction<S extends Schema.Top, O, Message = unknown>(form: Form.Form<S, Message>, run: ActionCommand<S["Type"], O>, locationFor: (output: O, input: S["Type"]) => string, options?: FormActionOptions<S["Type"], O>): (event: RequestEvent) => Promise<FormActionData<S["Type"], unknown> | import("@sveltejs/kit").ActionFailure<FormActionData<S["Type"], unknown>>>;
+//#endregion
+export { Command$1 as Command };
+//# sourceMappingURL=FormAction.d.ts.map

package/dist/kit/FormAction.js

@@ -0,0 +1,170 @@
+import { DEFAULT_MESSAGE, detailOf, jsonapiFailure } from "./CommandFailure.js";
+import { fieldFromPointer } from "./Pointer.js";
+import { Result, State } from "@thomasfosterau/effect-forms";
+import * as Match from "effect/Match";
+import * as Predicate from "effect/Predicate";
+import * as Option from "effect/Option";
+import * as Effect from "effect/Effect";
+import { fail, redirect } from "@sveltejs/kit";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+//#region src/kit/FormAction.ts
+/**
+* Derive a SvelteKit page form action from an `@thomasfosterau/effect-forms`
+* form plus the command it submits to.
+*
+* {@link runFormAction} is the framework-neutral seam — validate the request
+* against the form's schema (every field error collected, posted values
+* retained), run the command on a valid submission, and describe the outcome
+* as a `Result.FormActionResult`. {@link formAction} maps that onto
+* SvelteKit's action protocol (`redirect()` / `fail()`), which the client
+* store applies back via `applyActionResult` / {@link enhanceForm}.
+*
+* A command is either a Promise-returning function (an API client call) or
+* an `Effect` with no requirements; a failure on either is classified by
+* {@link CommandFailure.jsonapiFailure} (or a caller's own classifier) and
+* routed onto the form's fields by each JSON:API error's `source.pointer`.
+*
+* @copyright Thomas Foster
+* @module effect-forms-svelte/kit/FormAction
+*/
+const toEffect = (thunk) => Effect.suspend(() => {
+	const out = thunk();
+	return Effect.isEffect(out) ? out : Effect.tryPromise({
+		try: () => out,
+		catch: (cause) => cause
+	});
+});
+const isConflict = (cause) => Predicate.isObjectOrArray(cause) && Predicate.hasProperty(cause, "status") && cause.status === 409 && (Predicate.isTagged(cause, "JsonapiError") || Predicate.isTagged(cause, "ErrorResponse"));
+const submittedId = (input) => Predicate.isObjectOrArray(input) && Predicate.hasProperty(input, "id") && Predicate.isString(input.id) && input.id !== "" ? Option.some(input.id) : Option.none();
+const retryOwnConflict = (create, fetchExisting, input) => toEffect(() => create(input)).pipe(Effect.catch((cause) => Option.match(isConflict(cause) ? submittedId(input) : Option.none(), {
+	onNone: () => Effect.fail(cause),
+	onSome: (id) => toEffect(() => fetchExisting(id)).pipe(Effect.mapError(() => cause))
+})));
+/**
+* Wrap a client-id create command so a 409 conflict on the caller's OWN
+* submitted `id` resolves as success instead of a form error — the
+* double-submit of a create whose id the client generated.
+*
+* On any 409 (a `JsonapiError` / `ErrorResponse`-tagged cause), re-fetches
+* `input.id` via `fetchExisting` and returns that. This is deliberately
+* unconditional on *why* the 409 fired: the re-fetch is the proof, not the
+* status. A 409 from an unrelated precondition never left a row at
+* `input.id`, so the re-fetch fails and the original conflict rethrows
+* unchanged. An input with no `id`, or any other failure, rethrows as is.
+*
+* `input.id` is read structurally rather than through a constraint on
+* `Input`: a constraint here would be used only contravariantly (as
+* `create`'s parameter), which makes TypeScript infer `Input` from the
+* constraint instead of from the command's own input type.
+*/
+function idempotentCreate(create, fetchExisting) {
+	return async (input) => {
+		const exit = await Effect.runPromiseExit(retryOwnConflict(create, fetchExisting, input));
+		if (Exit.isSuccess(exit)) return exit.value;
+		throw Cause.squash(exit.cause);
+	};
+}
+/** The field path an error object's pointer routes to, or `[]` (the root). */
+const fieldPath = (error) => Option.toArray(fieldFromPointer(error.source !== void 0 && "pointer" in error.source ? error.source.pointer : void 0));
+/**
+* Route a recognised command failure onto the form state. A root issue lands
+* at the empty path, which the nested error tree exposes as `_errors` — the
+* form-level message surface (`form.errors._errors`).
+*/
+const routeFailure = (state, failure) => Predicate.isTagged(failure, "Routed") ? failure.errors.reduce((acc, error) => State.withError(acc, fieldPath(error), detailOf(error)), state) : State.withError(state, [], failure.message);
+/**
+* Validate `request` against `form`, then:
+*
+* - invalid → a `Failure` carrying the form state (nested errors + posted
+*   values), status 400, and the command never runs;
+* - valid → run the command (wrapped in the idempotent retry when
+*   `options.idempotent.clientId` is true); on success a `Redirect` (303) to
+*   `locationFor(output, input)`;
+* - a recognised command failure → a `Failure` at the failure's own status,
+*   each JSON:API error routed onto its field (or the root);
+* - an unrecognised one → an `Error` result at 500 (or a rethrow, per
+*   `options.unrecognised`).
+*
+* Posted values survive every failure, so the form re-renders what was typed.
+*
+* `locationFor` returns the redirect target as-is: `runFormAction` does not
+* check it. {@link formAction} hands it to SvelteKit's `redirect`, which
+* accepts only a same-origin location (see there).
+*/
+async function runFormAction(form, request, run, locationFor, options = {}) {
+	const redact = options.redact ?? ((state) => state);
+	const classify = options.classify ?? jsonapiFailure;
+	const validate = form.validate(request);
+	const program = Effect.flatMap(validate, (state) => {
+		if (!state.valid) return Effect.succeed(Result.failure(redact(state), 400));
+		const idempotent = options.idempotent;
+		const command = idempotent?.clientId === true ? retryOwnConflict(run, idempotent.fetchExisting, state.data) : toEffect(() => run(state.data));
+		return Effect.matchCauseEffect(command, {
+			onSuccess: (output) => Effect.sync(() => Result.redirect(locationFor(output, state.data), 303)),
+			onFailure: (commandCause) => Effect.suspend(() => {
+				const cause = Cause.squash(commandCause);
+				return Option.match(classify(cause), {
+					onSome: (failure) => Effect.sync(() => Result.failure(redact(routeFailure(state, failure)), failure.status)),
+					onNone: () => options.unrecognised === "throw" ? Effect.fail(cause) : Effect.succeed(Result.errorResult(Predicate.isError(cause) ? cause.message : DEFAULT_MESSAGE, 500))
+				});
+			})
+		});
+	});
+	const exit = await Effect.runPromiseExit(program);
+	if (Exit.isSuccess(exit)) return exit.value;
+	throw Cause.squash(exit.cause);
+}
+/**
+* Derive a SvelteKit page form **action** from `form` plus its command. The
+* handler validates the submission, runs the command on success, and maps
+* the outcome onto SvelteKit's action protocol:
+*
+* - success → `redirect(303, locationFor(output, input))`;
+* - an invalid submission or a recognised command failure →
+*   `fail(status, { form })`, carrying the (redacted) state;
+* - an unrecognised failure → `fail(500, { message })` (or a rethrow).
+*
+* Wire it into `export const actions`; the client `createForm` store applies
+* the returned `form` via {@link enhanceForm} (or `applyActionResult`).
+*
+* `locationFor` must return a same-origin path, such as
+* `/organisations/${id}`. SvelteKit 3's `redirect` rejects an external
+* location unless it is passed `{ external }`, and `formAction` never passes
+* it, so a `locationFor` that returns an absolute URL on another origin (or a
+* protocol-relative `//host/...`) makes the action throw an `Error` instead of
+* redirecting, after the command has already run. To send the user off-site,
+* redirect to a same-origin route that performs the external redirect itself.
+*
+* @example
+* ```ts
+* // src/routes/organisations/create/+page.server.ts
+* import { formAction } from "@thomasfosterau/effect-forms-svelte/kit";
+* import { organisationForm } from "#lib/forms";
+* import { api } from "#lib/server/api";
+*
+* export const actions = {
+*   default: formAction(
+*     organisationForm,
+*     (input, { locals }) => api(locals).organisations.create(input),
+*     (id) => `/organisations/${id}`,
+*   ),
+* };
+* ```
+*/
+function formAction(form, run, locationFor, options) {
+	return async (event) => {
+		const result = await runFormAction(form, event.request, (input) => run(input, event), locationFor, options);
+		const data = (d) => d;
+		return Match.valueTags(result, {
+			Redirect: (redirectResult) => redirect(redirectResult.status, redirectResult.location),
+			Failure: (failure) => fail(failure.status, data({ form: failure.state })),
+			Error: (error) => fail(error.status, data({ message: error.message })),
+			Success: (success) => data({ form: success.state })
+		});
+	};
+}
+//#endregion
+export { formAction, idempotentCreate, runFormAction };
+
+//# sourceMappingURL=FormAction.js.map

package/dist/kit/FormAction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormAction.js","names":[],"sources":["../../src/kit/FormAction.ts"],"sourcesContent":["/**\n * Derive a SvelteKit page form action from an `@thomasfosterau/effect-forms`\n * form plus the command it submits to.\n *\n * {@link runFormAction} is the framework-neutral seam — validate the request\n * against the form's schema (every field error collected, posted values\n * retained), run the command on a valid submission, and describe the outcome\n * as a `Result.FormActionResult`. {@link formAction} maps that onto\n * SvelteKit's action protocol (`redirect()` / `fail()`), which the client\n * store applies back via `applyActionResult` / {@link enhanceForm}.\n *\n * A command is either a Promise-returning function (an API client call) or\n * an `Effect` with no requirements; a failure on either is classified by\n * {@link CommandFailure.jsonapiFailure} (or a caller's own classifier) and\n * routed onto the form's fields by each JSON:API error's `source.pointer`.\n *\n * @copyright Thomas Foster\n * @module effect-forms-svelte/kit/FormAction\n */\n\nimport { fail, redirect, type RequestEvent } from \"@sveltejs/kit\";\nimport * as Cause from \"effect/Cause\";\nimport * as Effect from \"effect/Effect\";\nimport * as Exit from \"effect/Exit\";\nimport * as Match from \"effect/Match\";\nimport * as Option from \"effect/Option\";\nimport * as Predicate from \"effect/Predicate\";\nimport type * as Schema from \"effect/Schema\";\nimport { type Form, Result, State } from \"@thomasfosterau/effect-forms\";\nimport {\n  type Classify,\n  type CommandFailure,\n  DEFAULT_MESSAGE,\n  detailOf,\n  type ErrorObject,\n  jsonapiFailure,\n} from \"./CommandFailure.ts\";\nimport { fieldFromPointer } from \"./Pointer.ts\";\n\ntype FormState<A, Message = unknown> = State.FormState<A, Message>;\ntype FormActionResult<A, Message = unknown> = Result.FormActionResult<A, Message>;\ntype FormActionData<A = unknown, Message = unknown> = Result.FormActionData<A, Message>;\n\n/**\n * A command: a Promise-returning function or one returning an `Effect` with\n * no requirements (provide them first, e.g. through a `ManagedRuntime`).\n */\nexport type Command<I, O> = (input: I) => Promise<O> | Effect.Effect<O, unknown>;\n\nconst toEffect = <O>(\n  thunk: () => Promise<O> | Effect.Effect<O, unknown>,\n): Effect.Effect<O, unknown> =>\n  Effect.suspend(() => {\n    const out = thunk();\n    return Effect.isEffect(out)\n      ? out\n      : Effect.tryPromise({ try: () => out, catch: (cause) => cause });\n  });\n\n// ── Idempotent client-id create retry ──────────────────────────────────\n\nconst isConflict = (cause: unknown): boolean =>\n  Predicate.isObjectOrArray(cause) &&\n  Predicate.hasProperty(cause, \"status\") &&\n  cause.status === 409 &&\n  (Predicate.isTagged(cause, \"JsonapiError\") || Predicate.isTagged(cause, \"ErrorResponse\"));\n\nconst submittedId = (input: unknown): Option.Option<string> =>\n  Predicate.isObjectOrArray(input) &&\n  Predicate.hasProperty(input, \"id\") &&\n  Predicate.isString(input.id) &&\n  input.id !== \"\"\n    ? Option.some(input.id)\n    : Option.none();\n\nconst retryOwnConflict = <I, O>(\n  create: Command<I, O>,\n  fetchExisting: (id: string) => Promise<O> | Effect.Effect<O, unknown>,\n  input: I,\n): Effect.Effect<O, unknown> =>\n  toEffect(() => create(input)).pipe(\n    Effect.catch((cause) =>\n      Option.match(isConflict(cause) ? submittedId(input) : Option.none(), {\n        onNone: () => Effect.fail(cause),\n        // The re-fetch failing rethrows the ORIGINAL conflict, not its own error.\n        onSome: (id) => toEffect(() => fetchExisting(id)).pipe(Effect.mapError(() => cause)),\n      }),\n    ),\n  );\n\n/**\n * Wrap a client-id create command so a 409 conflict on the caller's OWN\n * submitted `id` resolves as success instead of a form error — the\n * double-submit of a create whose id the client generated.\n *\n * On any 409 (a `JsonapiError` / `ErrorResponse`-tagged cause), re-fetches\n * `input.id` via `fetchExisting` and returns that. This is deliberately\n * unconditional on *why* the 409 fired: the re-fetch is the proof, not the\n * status. A 409 from an unrelated precondition never left a row at\n * `input.id`, so the re-fetch fails and the original conflict rethrows\n * unchanged. An input with no `id`, or any other failure, rethrows as is.\n *\n * `input.id` is read structurally rather than through a constraint on\n * `Input`: a constraint here would be used only contravariantly (as\n * `create`'s parameter), which makes TypeScript infer `Input` from the\n * constraint instead of from the command's own input type.\n */\nexport function idempotentCreate<Input, Output>(\n  create: (input: Input) => Promise<Output>,\n  fetchExisting: (id: string) => Promise<Output>,\n): (input: Input) => Promise<Output> {\n  return async (input) => {\n    const exit = await Effect.runPromiseExit(retryOwnConflict(create, fetchExisting, input));\n    if (Exit.isSuccess(exit)) return exit.value;\n    throw Cause.squash(exit.cause);\n  };\n}\n\n/**\n * Idempotent-retry wiring for a client-id create action: `clientId` gates the\n * wrap to commands whose input actually carries a client-generated `id` (an\n * entity form definition's own `clientId`, from `defineEntityForm`);\n * `fetchExisting` re-fetches the submitted id (see {@link idempotentCreate}).\n */\nexport interface IdempotentCreateOptions<O> {\n  readonly clientId: boolean;\n  readonly fetchExisting: (id: string) => Promise<O> | Effect.Effect<O, unknown>;\n}\n\n/** Options for {@link runFormAction} and {@link formAction}. */\nexport interface FormActionOptions<A, O> {\n  /** Retry a client-id create's own 409 as success (see {@link IdempotentCreateOptions}). */\n  readonly idempotent?: IdempotentCreateOptions<O> | undefined;\n  /**\n   * How a command failure is recognised. Defaults to\n   * {@link CommandFailure.jsonapiFailure}; compose with it to add an\n   * application's own failures.\n   */\n  readonly classify?: Classify | undefined;\n  /**\n   * Applied to every form state echoed back to the browser (an invalid\n   * submission, a routed command failure) — e.g. blanking password fields\n   * so a secret never rides a response body.\n   */\n  readonly redact?: ((state: FormState<A>) => FormState<A>) | undefined;\n  /**\n   * What happens to a command failure the classifier does not recognise:\n   * `\"error\"` (the default) answers an `Error` result at 500 carrying the\n   * cause's message; `\"throw\"` rethrows the cause, leaving it to SvelteKit's\n   * `handleError`.\n   */\n  readonly unrecognised?: \"error\" | \"throw\" | undefined;\n}\n\n/** The field path an error object's pointer routes to, or `[]` (the root). */\nconst fieldPath = (error: ErrorObject): ReadonlyArray<string> =>\n  Option.toArray(\n    fieldFromPointer(\n      error.source !== undefined && \"pointer\" in error.source ? error.source.pointer : undefined,\n    ),\n  );\n\n/**\n * Route a recognised command failure onto the form state. A root issue lands\n * at the empty path, which the nested error tree exposes as `_errors` — the\n * form-level message surface (`form.errors._errors`).\n */\nconst routeFailure = <A>(state: FormState<A>, failure: CommandFailure): FormState<A> =>\n  Predicate.isTagged(failure, \"Routed\")\n    ? failure.errors.reduce(\n        (acc, error) => State.withError(acc, fieldPath(error), detailOf(error)),\n        state,\n      )\n    : State.withError(state, [], failure.message);\n\n/**\n * Validate `request` against `form`, then:\n *\n * - invalid → a `Failure` carrying the form state (nested errors + posted\n *   values), status 400, and the command never runs;\n * - valid → run the command (wrapped in the idempotent retry when\n *   `options.idempotent.clientId` is true); on success a `Redirect` (303) to\n *   `locationFor(output, input)`;\n * - a recognised command failure → a `Failure` at the failure's own status,\n *   each JSON:API error routed onto its field (or the root);\n * - an unrecognised one → an `Error` result at 500 (or a rethrow, per\n *   `options.unrecognised`).\n *\n * Posted values survive every failure, so the form re-renders what was typed.\n *\n * `locationFor` returns the redirect target as-is: `runFormAction` does not\n * check it. {@link formAction} hands it to SvelteKit's `redirect`, which\n * accepts only a same-origin location (see there).\n */\nexport async function runFormAction<S extends Schema.Top, O, Message = unknown>(\n  form: Form.Form<S, Message>,\n  request: Request,\n  run: Command<S[\"Type\"], O>,\n  locationFor: (output: O, input: S[\"Type\"]) => string,\n  options: FormActionOptions<S[\"Type\"], O> = {},\n): Promise<FormActionResult<S[\"Type\"]>> {\n  const redact = options.redact ?? ((state: FormState<S[\"Type\"]>) => state);\n  const classify = options.classify ?? jsonapiFailure;\n  // SAFETY: a posted form needs no decoding services at runtime; schemas\n  // projected from elsewhere can still carry an unreduced `DecodingServices`\n  // type, so only the requirements channel is narrowed here.\n  const validate = form.validate(request) as Effect.Effect<FormState<S[\"Type\"], Message>>;\n  const program = Effect.flatMap(\n    validate,\n    (state): Effect.Effect<FormActionResult<S[\"Type\"]>, unknown> => {\n      if (!state.valid) return Effect.succeed(Result.failure(redact(state), 400));\n      const idempotent = options.idempotent;\n      const command =\n        idempotent?.clientId === true\n          ? retryOwnConflict(run, idempotent.fetchExisting, state.data)\n          : toEffect(() => run(state.data));\n      return Effect.matchCauseEffect(command, {\n        onSuccess: (output) =>\n          Effect.sync(() => Result.redirect(locationFor(output, state.data), 303)),\n        onFailure: (commandCause) =>\n          Effect.suspend(() => {\n            const cause = Cause.squash(commandCause);\n            return Option.match(classify(cause), {\n              onSome: (failure) =>\n                Effect.sync(() =>\n                  Result.failure(redact(routeFailure(state, failure)), failure.status),\n                ),\n              onNone: () =>\n                options.unrecognised === \"throw\"\n                  ? Effect.fail(cause)\n                  : Effect.succeed(\n                      Result.errorResult(\n                        Predicate.isError(cause) ? cause.message : DEFAULT_MESSAGE,\n                        500,\n                      ),\n                    ),\n            });\n          }),\n      });\n    },\n  );\n  // The Promise boundary: an unrecognised failure under `\"throw\"` (or a defect\n  // anywhere above) rejects with the squashed cause, as a thrown value would.\n  const exit = await Effect.runPromiseExit(program);\n  if (Exit.isSuccess(exit)) return exit.value;\n  throw Cause.squash(exit.cause);\n}\n\n/**\n * A command for {@link formAction}: like {@link Command}, and also handed the\n * `RequestEvent` (for `locals`, `cookies`, `fetch`).\n */\nexport type ActionCommand<I, O> = (\n  input: I,\n  event: RequestEvent,\n) => Promise<O> | Effect.Effect<O, unknown>;\n\n/**\n * Derive a SvelteKit page form **action** from `form` plus its command. The\n * handler validates the submission, runs the command on success, and maps\n * the outcome onto SvelteKit's action protocol:\n *\n * - success → `redirect(303, locationFor(output, input))`;\n * - an invalid submission or a recognised command failure →\n *   `fail(status, { form })`, carrying the (redacted) state;\n * - an unrecognised failure → `fail(500, { message })` (or a rethrow).\n *\n * Wire it into `export const actions`; the client `createForm` store applies\n * the returned `form` via {@link enhanceForm} (or `applyActionResult`).\n *\n * `locationFor` must return a same-origin path, such as\n * `/organisations/${id}`. SvelteKit 3's `redirect` rejects an external\n * location unless it is passed `{ external }`, and `formAction` never passes\n * it, so a `locationFor` that returns an absolute URL on another origin (or a\n * protocol-relative `//host/...`) makes the action throw an `Error` instead of\n * redirecting, after the command has already run. To send the user off-site,\n * redirect to a same-origin route that performs the external redirect itself.\n *\n * @example\n * ```ts\n * // src/routes/organisations/create/+page.server.ts\n * import { formAction } from \"@thomasfosterau/effect-forms-svelte/kit\";\n * import { organisationForm } from \"#lib/forms\";\n * import { api } from \"#lib/server/api\";\n *\n * export const actions = {\n *   default: formAction(\n *     organisationForm,\n *     (input, { locals }) => api(locals).organisations.create(input),\n *     (id) => `/organisations/${id}`,\n *   ),\n * };\n * ```\n */\nexport function formAction<S extends Schema.Top, O, Message = unknown>(\n  form: Form.Form<S, Message>,\n  run: ActionCommand<S[\"Type\"], O>,\n  locationFor: (output: O, input: S[\"Type\"]) => string,\n  options?: FormActionOptions<S[\"Type\"], O>,\n) {\n  return async (event: RequestEvent) => {\n    const result = await runFormAction(\n      form,\n      event.request,\n      (input) => run(input, event),\n      locationFor,\n      options,\n    );\n    const data = (d: FormActionData<S[\"Type\"]>): FormActionData<S[\"Type\"]> => d;\n    return Match.valueTags(result, {\n      Redirect: (redirectResult) => redirect(redirectResult.status, redirectResult.location),\n      Failure: (failure) => fail(failure.status, data({ form: failure.state })),\n      Error: (error) => fail(error.status, data({ message: error.message })),\n      // `runFormAction` answers success with a redirect; a success result\n      // carrying state is echoed back as-is.\n      Success: (success) => data({ form: success.state }),\n    });\n  };\n}\n"],"mappings":"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"}

package/dist/kit/FormStateReaders.d.ts

@@ -0,0 +1,58 @@
+//#region src/kit/FormStateReaders.d.ts
+/**
+ * Total readers over the form state a failed form action hands back on
+ * `PageProps["form"]`.
+ *
+ * {@link formAction} answers an invalid submission with
+ * `fail(status, { form: state })`, where `state` carries the posted values
+ * and a nested error tree. A server-rendered page (no client store) needs
+ * three things per field off a value SvelteKit types as `ActionData | null`:
+ * what the user typed, what was wrong with it, and what was wrong with the
+ * form as a whole.
+ *
+ * Every reader is deliberately **total**: it answers sensibly for a first
+ * render (`form` is `null`), for a successful submission, and for a shape
+ * that is not a form state at all. A create page that threw on
+ * `form === null` would fail on the one render it does most.
+ *
+ * `undefined` rather than `Option` for "no submission": these are called from
+ * Svelte templates, where `Option` has no rendering.
+ *
+ * @copyright Thomas Foster
+ * @module effect-forms-svelte/kit/FormStateReaders
+ */
+/**
+ * The subset of `State.FormState` the readers touch: the posted values and
+ * the nested error tree. Structural rather than imported so a page can hand
+ * in its raw `ActionData` without a cast.
+ */
+export interface ActionFormState {
+  readonly data?: Readonly<Record<string, unknown>>;
+  readonly errors?: Readonly<Record<string, unknown>>;
+}
+/**
+ * The carried form state, or `undefined` when there is none — a first
+ * render, a successful submission (which redirects), or an action result
+ * that carried a bare message instead.
+ */
+export declare const formStateOf: (form: unknown) => ActionFormState | undefined;
+/** Messages attached to a named field, or none. */
+export declare const issuesFor: (state: ActionFormState | undefined, field: string) => ReadonlyArray<string>;
+/**
+ * Whole-form messages — the ones with no field to attach to (a 409, a
+ * rejected command). {@link runFormAction} routes them to the error tree's
+ * empty path, which the nested tree exposes as `_errors`.
+ */
+export declare const rootIssuesOf: (state: ActionFormState | undefined) => ReadonlyArray<string>;
+/**
+ * What to render in a field: the value the user posted if this is a failed
+ * submission, else `fallback` (the row's stored value on an edit form, or
+ * the empty string on a create form). A posted blank stays blank.
+ *
+ * Non-string posted values (a checkbox's boolean, a number) render through
+ * `String(...)` rather than being dropped: the point of repopulation is that
+ * the user sees what they sent.
+ */
+export declare const valueOf: (state: ActionFormState | undefined, field: string, fallback?: string) => string;
+//#endregion
+//# sourceMappingURL=FormStateReaders.d.ts.map

package/dist/kit/FormStateReaders.js

@@ -0,0 +1,64 @@
+import * as Predicate from "effect/Predicate";
+//#region src/kit/FormStateReaders.ts
+/**
+* Total readers over the form state a failed form action hands back on
+* `PageProps["form"]`.
+*
+* {@link formAction} answers an invalid submission with
+* `fail(status, { form: state })`, where `state` carries the posted values
+* and a nested error tree. A server-rendered page (no client store) needs
+* three things per field off a value SvelteKit types as `ActionData | null`:
+* what the user typed, what was wrong with it, and what was wrong with the
+* form as a whole.
+*
+* Every reader is deliberately **total**: it answers sensibly for a first
+* render (`form` is `null`), for a successful submission, and for a shape
+* that is not a form state at all. A create page that threw on
+* `form === null` would fail on the one render it does most.
+*
+* `undefined` rather than `Option` for "no submission": these are called from
+* Svelte templates, where `Option` has no rendering.
+*
+* @copyright Thomas Foster
+* @module effect-forms-svelte/kit/FormStateReaders
+*/
+/**
+* The carried form state, or `undefined` when there is none — a first
+* render, a successful submission (which redirects), or an action result
+* that carried a bare message instead.
+*/
+const formStateOf = (form) => {
+	if (!Predicate.isObjectOrArray(form) || !Predicate.hasProperty(form, "form")) return void 0;
+	const state = form.form;
+	if (!Predicate.isObjectOrArray(state)) return void 0;
+	return state;
+};
+/** Messages attached to a named field, or none. */
+const issuesFor = (state, field) => {
+	const issues = state?.errors?.[field];
+	return Array.isArray(issues) ? issues : [];
+};
+/**
+* Whole-form messages — the ones with no field to attach to (a 409, a
+* rejected command). {@link runFormAction} routes them to the error tree's
+* empty path, which the nested tree exposes as `_errors`.
+*/
+const rootIssuesOf = (state) => issuesFor(state, "_errors");
+/**
+* What to render in a field: the value the user posted if this is a failed
+* submission, else `fallback` (the row's stored value on an edit form, or
+* the empty string on a create form). A posted blank stays blank.
+*
+* Non-string posted values (a checkbox's boolean, a number) render through
+* `String(...)` rather than being dropped: the point of repopulation is that
+* the user sees what they sent.
+*/
+const valueOf = (state, field, fallback = "") => {
+	const value = state?.data?.[field];
+	if (value === void 0 || value === null) return fallback;
+	return Predicate.isString(value) ? value : String(value);
+};
+//#endregion
+export { formStateOf, issuesFor, rootIssuesOf, valueOf };
+
+//# sourceMappingURL=FormStateReaders.js.map

package/dist/kit/FormStateReaders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormStateReaders.js","names":[],"sources":["../../src/kit/FormStateReaders.ts"],"sourcesContent":["/**\n * Total readers over the form state a failed form action hands back on\n * `PageProps[\"form\"]`.\n *\n * {@link formAction} answers an invalid submission with\n * `fail(status, { form: state })`, where `state` carries the posted values\n * and a nested error tree. A server-rendered page (no client store) needs\n * three things per field off a value SvelteKit types as `ActionData | null`:\n * what the user typed, what was wrong with it, and what was wrong with the\n * form as a whole.\n *\n * Every reader is deliberately **total**: it answers sensibly for a first\n * render (`form` is `null`), for a successful submission, and for a shape\n * that is not a form state at all. A create page that threw on\n * `form === null` would fail on the one render it does most.\n *\n * `undefined` rather than `Option` for \"no submission\": these are called from\n * Svelte templates, where `Option` has no rendering.\n *\n * @copyright Thomas Foster\n * @module effect-forms-svelte/kit/FormStateReaders\n */\n\nimport * as Predicate from \"effect/Predicate\";\n\n/**\n * The subset of `State.FormState` the readers touch: the posted values and\n * the nested error tree. Structural rather than imported so a page can hand\n * in its raw `ActionData` without a cast.\n */\nexport interface ActionFormState {\n  readonly data?: Readonly<Record<string, unknown>>;\n  readonly errors?: Readonly<Record<string, unknown>>;\n}\n\n/**\n * The carried form state, or `undefined` when there is none — a first\n * render, a successful submission (which redirects), or an action result\n * that carried a bare message instead.\n */\nexport const formStateOf = (form: unknown): ActionFormState | undefined => {\n  if (!Predicate.isObjectOrArray(form) || !Predicate.hasProperty(form, \"form\")) return undefined;\n  const state = form.form;\n  if (!Predicate.isObjectOrArray(state)) return undefined;\n  // SAFETY: `ActionFormState` is all-optional and every reader below reaches\n  // `data` / `errors` only through optional chaining and re-checks the value it\n  // finds (`Array.isArray`, `isString`), so any object answers totally.\n  return state as ActionFormState;\n};\n\n/** Messages attached to a named field, or none. */\nexport const issuesFor = (\n  state: ActionFormState | undefined,\n  field: string,\n): ReadonlyArray<string> => {\n  const issues = state?.errors?.[field];\n  // SAFETY: the error tree `formAction` hands back holds the form's messages\n  // at each field, and these readers serve pages whose messages are strings.\n  return Array.isArray(issues) ? (issues as ReadonlyArray<string>) : [];\n};\n\n/**\n * Whole-form messages — the ones with no field to attach to (a 409, a\n * rejected command). {@link runFormAction} routes them to the error tree's\n * empty path, which the nested tree exposes as `_errors`.\n */\nexport const rootIssuesOf = (state: ActionFormState | undefined): ReadonlyArray<string> =>\n  issuesFor(state, \"_errors\");\n\n/**\n * What to render in a field: the value the user posted if this is a failed\n * submission, else `fallback` (the row's stored value on an edit form, or\n * the empty string on a create form). A posted blank stays blank.\n *\n * Non-string posted values (a checkbox's boolean, a number) render through\n * `String(...)` rather than being dropped: the point of repopulation is that\n * the user sees what they sent.\n */\nexport const valueOf = (\n  state: ActionFormState | undefined,\n  field: string,\n  fallback = \"\",\n): string => {\n  const value = state?.data?.[field];\n  if (value === undefined || value === null) return fallback;\n  // oxlint-disable-next-line typescript/no-base-to-string -- posted values are form scalars (a checkbox's boolean, a number); rendering them is the point\n  return Predicate.isString(value) ? value : String(value);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,MAAa,eAAe,SAA+C;CACzE,IAAI,CAAC,UAAU,gBAAgB,IAAI,KAAK,CAAC,UAAU,YAAY,MAAM,MAAM,GAAG,OAAO,KAAA;CACrF,MAAM,QAAQ,KAAK;CACnB,IAAI,CAAC,UAAU,gBAAgB,KAAK,GAAG,OAAO,KAAA;CAI9C,OAAO;AACT;;AAGA,MAAa,aACX,OACA,UAC0B;CAC1B,MAAM,SAAS,OAAO,SAAS;CAG/B,OAAO,MAAM,QAAQ,MAAM,IAAK,SAAmC,CAAC;AACtE;;;;;;AAOA,MAAa,gBAAgB,UAC3B,UAAU,OAAO,SAAS;;;;;;;;;;AAW5B,MAAa,WACX,OACA,OACA,WAAW,OACA;CACX,MAAM,QAAQ,OAAO,OAAO;CAC5B,IAAI,UAAU,KAAA,KAAa,UAAU,MAAM,OAAO;CAElD,OAAO,UAAU,SAAS,KAAK,IAAI,QAAQ,OAAO,KAAK;AACzD"}

package/dist/kit/Pointer.d.ts

@@ -0,0 +1,23 @@
+import * as Option from "effect/Option";
+//#region src/kit/Pointer.d.ts
+/**
+ * The field a JSON Pointer of the form `/data/attributes/<field>…` names.
+ * Deeper segments are ignored: the form issue layer keys by the top-level
+ * field name.
+ *
+ * `None` covers every non-field pointer, including an absent one, a pointer
+ * outside `/data/attributes`, and an empty field segment
+ * (`/data/attributes/`), so a caller can read the result as a plain `Option`
+ * with no extra `""` test.
+ *
+ * @example
+ * ```ts
+ * import { fieldFromPointer } from "@thomasfosterau/effect-forms-svelte/kit";
+ *
+ * fieldFromPointer("/data/attributes/name"); // Option.some("name")
+ * fieldFromPointer("/data/relationships/author"); // Option.none()
+ * ```
+ */
+export declare const fieldFromPointer: (pointer: string | undefined) => Option.Option<string>;
+//#endregion
+//# sourceMappingURL=Pointer.d.ts.map

package/dist/kit/Pointer.js

@@ -0,0 +1,38 @@
+import * as Option from "effect/Option";
+//#region src/kit/Pointer.ts
+/**
+* JSON Pointer → form field routing for a JSON:API error object's
+* `source.pointer`.
+*
+* @copyright Thomas Foster
+* @module effect-forms-svelte/kit/Pointer
+*/
+const unescapeSegment = (segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~");
+/**
+* The field a JSON Pointer of the form `/data/attributes/<field>…` names.
+* Deeper segments are ignored: the form issue layer keys by the top-level
+* field name.
+*
+* `None` covers every non-field pointer, including an absent one, a pointer
+* outside `/data/attributes`, and an empty field segment
+* (`/data/attributes/`), so a caller can read the result as a plain `Option`
+* with no extra `""` test.
+*
+* @example
+* ```ts
+* import { fieldFromPointer } from "@thomasfosterau/effect-forms-svelte/kit";
+*
+* fieldFromPointer("/data/attributes/name"); // Option.some("name")
+* fieldFromPointer("/data/relationships/author"); // Option.none()
+* ```
+*/
+const fieldFromPointer = (pointer) => {
+	if (pointer === void 0 || pointer === "") return Option.none();
+	const [data, attributes, field] = pointer.split("/").slice(1).map(unescapeSegment);
+	if (data !== "data" || attributes !== "attributes") return Option.none();
+	return field === void 0 || field === "" ? Option.none() : Option.some(field);
+};
+//#endregion
+export { fieldFromPointer };
+
+//# sourceMappingURL=Pointer.js.map

package/dist/kit/Pointer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pointer.js","names":[],"sources":["../../src/kit/Pointer.ts"],"sourcesContent":["/**\n * JSON Pointer → form field routing for a JSON:API error object's\n * `source.pointer`.\n *\n * @copyright Thomas Foster\n * @module effect-forms-svelte/kit/Pointer\n */\n\nimport * as Option from \"effect/Option\";\n\n// RFC 6901 escapes: `~1` → `/`, `~0` → `~` (in that order).\nconst unescapeSegment = (segment: string): string =>\n  segment.replace(/~1/g, \"/\").replace(/~0/g, \"~\");\n\n/**\n * The field a JSON Pointer of the form `/data/attributes/<field>…` names.\n * Deeper segments are ignored: the form issue layer keys by the top-level\n * field name.\n *\n * `None` covers every non-field pointer, including an absent one, a pointer\n * outside `/data/attributes`, and an empty field segment\n * (`/data/attributes/`), so a caller can read the result as a plain `Option`\n * with no extra `\"\"` test.\n *\n * @example\n * ```ts\n * import { fieldFromPointer } from \"@thomasfosterau/effect-forms-svelte/kit\";\n *\n * fieldFromPointer(\"/data/attributes/name\"); // Option.some(\"name\")\n * fieldFromPointer(\"/data/relationships/author\"); // Option.none()\n * ```\n */\nexport const fieldFromPointer = (\n  // A JSON:API error object's `source?.pointer`, verbatim: absent is `undefined`.\n  pointer: string | undefined,\n): Option.Option<string> => {\n  if (pointer === undefined || pointer === \"\") return Option.none();\n  const [data, attributes, field] = pointer.split(\"/\").slice(1).map(unescapeSegment);\n  if (data !== \"data\" || attributes !== \"attributes\") return Option.none();\n  return field === undefined || field === \"\" ? Option.none() : Option.some(field);\n};\n"],"mappings":";;;;;;;;;AAWA,MAAM,mBAAmB,YACvB,QAAQ,QAAQ,OAAO,GAAG,CAAC,CAAC,QAAQ,OAAO,GAAG;;;;;;;;;;;;;;;;;;;AAoBhD,MAAa,oBAEX,YAC0B;CAC1B,IAAI,YAAY,KAAA,KAAa,YAAY,IAAI,OAAO,OAAO,KAAK;CAChE,MAAM,CAAC,MAAM,YAAY,SAAS,QAAQ,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,eAAe;CACjF,IAAI,SAAS,UAAU,eAAe,cAAc,OAAO,OAAO,KAAK;CACvE,OAAO,UAAU,KAAA,KAAa,UAAU,KAAK,OAAO,KAAK,IAAI,OAAO,KAAK,KAAK;AAChF"}

package/dist/kit/index.d.ts

@@ -0,0 +1,7 @@
+import { userFixableMessage, withFailureParams } from "./ActionRedirect.js";
+import { CommandFailure_d_exports, jsonapiFailure } from "./CommandFailure.js";
+import { EnhancedFormProps, enhanceForm } from "./Enhance.js";
+import { ActionCommand, Command, FormActionOptions, IdempotentCreateOptions, formAction, idempotentCreate, runFormAction } from "./FormAction.js";
+import { ActionFormState, formStateOf, issuesFor, rootIssuesOf, valueOf } from "./FormStateReaders.js";
+import { fieldFromPointer } from "./Pointer.js";
+export { ActionCommand, ActionFormState, Command, CommandFailure_d_exports as CommandFailure, EnhancedFormProps, FormActionOptions, IdempotentCreateOptions, enhanceForm, fieldFromPointer, formAction, formStateOf, idempotentCreate, issuesFor, jsonapiFailure, rootIssuesOf, runFormAction, userFixableMessage, valueOf, withFailureParams };

package/dist/kit/index.js

@@ -0,0 +1,7 @@
+import { CommandFailure_exports, jsonapiFailure } from "./CommandFailure.js";
+import { userFixableMessage, withFailureParams } from "./ActionRedirect.js";
+import { enhanceForm } from "./Enhance.js";
+import { fieldFromPointer } from "./Pointer.js";
+import { formAction, idempotentCreate, runFormAction } from "./FormAction.js";
+import { formStateOf, issuesFor, rootIssuesOf, valueOf } from "./FormStateReaders.js";
+export { CommandFailure_exports as CommandFailure, enhanceForm, fieldFromPointer, formAction, formStateOf, idempotentCreate, issuesFor, jsonapiFailure, rootIssuesOf, runFormAction, userFixableMessage, valueOf, withFailureParams };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thomasfosterau/effect-forms-svelte",
-  "version": "0.1.0",
+  "version": "0.3.1",
   "description": "Svelte 5 (runes) bindings for @thomasfosterau/effect-forms — a reactive form store, an enhance action, tainted tracking, and client-side validation.",
   "keywords": [
     "effect",
@@ -12,7 +12,7 @@
     "sveltekit",
     "typescript"
   ],
-  "homepage": "https://github.com/thomasfosterau/effect-forms/tree/main/packages/svelte#readme",
+  "homepage": "https://github.com/thomasfosterau/effect-forms/tree/trunk/packages/svelte#readme",
   "bugs": {
     "url": "https://github.com/thomasfosterau/effect-forms/issues"
   },
@@ -38,18 +38,37 @@
       "types": "./dist/index.d.ts",
       "svelte": "./dist/index.js",
       "import": "./dist/index.js"
+    },
+    "./kit": {
+      "types": "./dist/kit/index.d.ts",
+      "svelte": "./dist/kit/index.js",
+      "import": "./dist/kit/index.js"
     }
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@thomasfosterau/effect-forms": "^0.1.0"
+    "@thomasfosterau/effect-forms": "^0.3.1"
+  },
+  "devDependencies": {
+    "@sveltejs/kit": "3.1.0",
+    "@thomasfosterau/effect-jsonapi": "^0.17.0"
   },
   "peerDependencies": {
-    "effect": "^4.0.0-beta.102",
+    "@sveltejs/kit": "^3.0.0",
+    "@thomasfosterau/effect-jsonapi": ">=0.16.0",
+    "effect": ">=4.0.0",
     "svelte": "^5.40.0"
   },
+  "peerDependenciesMeta": {
+    "@sveltejs/kit": {
+      "optional": true
+    },
+    "@thomasfosterau/effect-jsonapi": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": "^20.19.0 || >=22.12.0"
   },