@thomasfosterau/effect-forms 0.0.0 → 0.2.0

package/README.md

@@ -2,11 +2,15 @@
 
 Framework-neutral, **Effect-native** form validation and state — schema-driven validation, nested errors, posted-value retention, status messages, and native input constraints, built on **Effect Schema** with no framework dependency. The Svelte 5 bindings live in [`@thomasfosterau/effect-forms-svelte`](../svelte).
 
-## Why
+## Install
 
-The app validates everything with Effect Schema (Zod is gone). The progressive form libraries in the ecosystem are excellent, but they speak Standard Schema / Zod and bake in a framework. This package keeps the ergonomics — one schema drives validation, errors nest by field, posted values survive a failed submit, native input constraints come for free — while staying on Effect Schema and free of any framework, so the core is testable in isolation and reusable from a Worker, the CLI, or a Svelte route.
+```sh
+pnpm add @thomasfosterau/effect-forms effect
+```
+
+`effect` is a peer dependency; the package never bundles its own copy.
 
-## The shape
+## Usage
 
 ```ts
 import * as Schema from "effect/Schema";
@@ -24,15 +28,17 @@ const signupForm = Form.make(Signup, {
 });
 
 // In a server action / load:
+declare const request: Request;
 const state = await Effect.runPromise(signupForm.validate(request));
 // state: { id, valid, posted, data, errors, constraints, message? }
 ```
 
-## Building a form incrementally
+### Building a form incrementally
 
 `Form.make` binds a hand-written `Schema.Struct`. When you'd rather compose a form field by field — reusing field groups, merging them, and attaching whole-form (cross-field) rules — reach for `FormBuilder`:
 
 ```ts
+import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 import { Field, Form, FormBuilder } from "@thomasfosterau/effect-forms";
 
@@ -47,6 +53,7 @@ const signup = FormBuilder.empty
 
 // Bind it exactly like a schema (defaults are derived when omitted):
 const form = Form.fromBuilder(signup, { id: "signup" });
+declare const request: Request; // the incoming submission
 const state = await Effect.runPromise(form.validate(request));
 ```
 
@@ -57,19 +64,20 @@ Modules are exposed as Effect-style namespaces (`Form`, `State`, `Result`, `Erro
 - **`validate(input)`** accepts a `FormData`, `URLSearchParams`, `Request`, or a plain object. It parses the body (nested `author.name` / `tags[0]` / `tags[]` notation), decodes it through the schema collecting **every** field error (`errors: "all"`), and returns a serialisable [`FormState`](src/State.ts) — valid with the decoded data, or invalid with the nested [`FormErrors`](src/Errors.ts) tree and the **posted values preserved** so the form re-renders what the user typed. It is an `Effect`, so a schema that requires decoding services composes naturally; it never fails on the error channel (validation failures live in the returned state).
 - **`empty()`** seeds a blank, unposted form from the defaults — what a `load` returns to render a create form.
 
-## What's in the box
+## API
 
 | Module                              | Purpose                                                                                                                                                                                                                                                                                                                                                                                                              |
 | ----------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | [`Form`](src/Form.ts)               | `make` — bind a schema to a form (validate + empty); `fromBuilder` — bind a `FormBuilder`.                                                                                                                                                                                                                                                                                                                           |
 | [`FormBuilder`](src/FormBuilder.ts) | Compose a form field by field: `addField` / `merge` / `refine` / `refineEffect` / `buildSchema`.                                                                                                                                                                                                                                                                                                                     |
 | [`Field`](src/Field.ts)             | `makeField` / `makeArrayField` field defs + guards, and blank-default derivation from a schema — `defaultValue` / `defaultEncodedValues` for a builder field, `schemaAt` / `defaultItemAt` for any nested path.                                                                                                                                                                                                      |
-| [`State`](src/State.ts)             | `FormState`, `makeFormState`, `setMessage`, `withError`, `FormStateSchema` (transport).                                                                                                                                                                                                                                                                                                                              |
-| [`Errors`](src/Errors.ts)           | The nested `FormErrors` tree + `issuesToErrors` / `flattenErrors` / `getError` / `setError` / `mergeErrors` / `remapIndices`; `FieldValidators` per-source error tracking via `replaceAt` / `setSourceAt` / `clearSourceAt` / `mergeSourced`.                                                                                                                                                                        |
+| [`State`](src/State.ts)             | `FormState`, `make`, `withMessage`, `withError`, `isValid`, `FormStateSchema` (transport).                                                                                                                                                                                                                                                                                                                           |
+| [`Errors`](src/Errors.ts)           | The nested `FormErrors` tree + `issuesToErrors` / `flattenErrors` / `getError` / `setError` / `mergeErrors` / `remapIndices`; `SourcedErrors` per-source tracking via `replaceAt` / `setSourceAt` / `clearSourceAt` / `mergeSourced`.                                                                                                                                                                                |
 | [`Issues`](src/Issues.ts)           | `FormIssue` + the Effect Schema issue-tree walker.                                                                                                                                                                                                                                                                                                                                                                   |
 | [`FormData`](src/FormData.ts)       | `formDataToObject` / `parseFieldPath` — structured parsing of an HTML body.                                                                                                                                                                                                                                                                                                                                          |
 | [`Path`](src/Path.ts)               | `getAt` / `setAt` (immutable) along a `FormPath`, `toString` / `fromString` notation conversion, the type-level `FieldPath<T>` / `PathValue<T, P>` deep-key projections a typed field handle is built on, and the `IndexMap` constructors (`removeAt` / `insertAt` / `swapAt` / `moveAt` / `replaceAt` / `clearAll`) + `remapIndex` / `remapKeyedRecord` for keeping per-index state in sync with an array mutation. |
 | [`Coerce`](src/Coerce.ts)           | Tri-state (value / `null` / `undefined`) coercers for the form boundary.                                                                                                                                                                                                                                                                                                                                             |
+| [`Command`](src/Command.ts)         | Derive form-input schemas, blank defaults and tri-state create / update adapters from a command-struct pair: `plan`, `formInputFields`, `blankDefaults`, `createAdapter`, `updateAdapter`, `jsonRowsFromField`.                                                                                                                                                                                                      |
 | [`Constraints`](src/Constraints.ts) | `constraintsFromSchema` — native input attributes (`required`, `minlength`/`maxlength`, `min`/`max`, `pattern`, `step`) derived from the schema AST, including into array items; `constraintAt` reads one field's leaf out of the derived tree.                                                                                                                                                                      |
 | [`Mode`](src/Mode.ts)               | `FormMode` + `parse` — when a form validates (`onSubmit` / `onBlur` / `onChange`), whether it auto-submits, and when a posted form revalidates (`revalidate`).                                                                                                                                                                                                                                                       |
 | [`Result`](src/Result.ts)           | `FormActionResult` — the framework-neutral submission outcome (success / failure / redirect / error).                                                                                                                                                                                                                                                                                                                |
@@ -79,22 +87,10 @@ Modules are exposed as Effect-style namespaces (`Form`, `State`, `Result`, `Erro
 
 - **Coercion is the schema's job.** An HTML body is all strings; build the schema from coercing leaves (`Schema.FiniteFromString`, `Schema.BooleanFromString`, the `Coerce` helpers) so the parsed object decodes cleanly. The parser never guesses types.
 - **Errors nest by field.** Leaf fields are `string[]`; nested objects / array indices nest; a branch's own (cross-field) message lives under `_errors`. The tree is plain JSON — it crosses the SSR boundary unchanged.
-- **Update semantics.** The `Coerce` helpers honour the value / `null` / `undefined` contract (set / clear / carry-forward) the app uses for partial updates.
-- **Constraint derivation reads schema checks, not just optionality.** `constraintsFromSchema` walks each property's `.check()`s for the `meta` annotation Effect Schema's built-in checks carry (`isMinLength`, `isLengthBetween`, `isPattern`, `isGreaterThanOrEqualTo`, `isBetween`, `isMultipleOf`, `isInt`, …), unwraps `optional` / `NullOr` unions, and descends into struct and array-item shapes. A check with no recognised `meta` tag (a bare `Schema.filter` predicate) derives nothing — there's no attribute to guess at. Anything the walk can't (or shouldn't) infer goes through the `overrides` argument, which always wins on conflict.
+- **Update semantics.** The `Coerce` helpers honour the value / `null` / `undefined` contract (set / clear / carry-forward) for partial updates.
+- **Constraint derivation reads schema checks, not just optionality.** `constraintsFromSchema` walks each property's `.check()`s for the `meta` annotation Effect Schema's built-in checks carry (`isMinLength`, `isBetweenLength`, `isPattern`, `isGreaterThanOrEqualTo`, `isBetween`, `isMultipleOf`, `isInt`, …), unwraps `optional` / `NullOr` unions, and descends into struct and array-item shapes. A check with no recognised `meta` tag (a bare `Schema.filter` predicate) derives nothing — there's no attribute to guess at. Anything the walk can't (or shouldn't) infer goes through the `overrides` argument, which always wins on conflict.
 - **Errors have a source.** `Errors.SourcedErrors` keeps a `client` tree (browser-side validation) parallel to a `server` tree (the last submission), merged for display by `mergeSourced`. `Errors.replaceAt` / `setSourceAt` / `clearSourceAt` update one path in one source without disturbing the rest — what a reactive store needs so a server-reported failure survives a client revalidation of some _other_ field, but clears once its own field changes.
 
-## File naming
-
-Source modules use PascalCase file names, matching Effect's own convention (`effect/Schema`, `effect/SchemaParser`). The package has a single entry point: every module is re-exported from the `.` barrel, so there are no subpaths to import from.
-
-## Development
-
-From the repository root:
-
-```sh
-vp run -r build   # build every package with tsdown
-vp check          # format (Oxfmt), lint (Oxlint), type-check (tsgolint)
-vp run -r test    # unit tests
-```
+## License
 
-Or from this directory: `vp test run` / `vp test run --coverage`.
+[MIT](LICENSE)

package/dist/index.d.ts

@@ -7,8 +7,6 @@ declare namespace Coerce_d_exports {
   export { booleanFromCheckbox, emptyToNull, emptyToUndefined, numberFromField, trimToNull, trimToUndefined };
 }
 /**
- * @copyright Thomas Foster
- *
  * Tri-state coercers for the HTML-form boundary.
  *
  * An HTML form submits every value as a string, and an absent optional field
@@ -22,6 +20,7 @@ declare namespace Coerce_d_exports {
  * framework's `error()` helper (validation failures belong on the schema, not
  * in a coercer).
  *
+ * @copyright Thomas Foster
  * @module effect-forms/Coerce
  */
 /** Empty string / `undefined` → `undefined`; otherwise the value (skip semantics). */
@@ -143,7 +142,7 @@ declare const createAdapter: (commandPlan: CommandPlan, overrides?: AdaptOverrid
  */
 declare const updateAdapter: (commandPlan: CommandPlan, overrides?: AdaptOverrides) => (input: FormInputRecord) => Record<string, unknown>;
 declare namespace Issues_d_exports {
-  export { FormIssue, FormPath, LeafFormatter, defaultLeafFormatter, filterOutputToFormIssues, schemaIssuesToFormIssues };
+  export { FormIssue, FormPath, LeafFormatter, defaultLeafFormatter, filterOutputToFormIssues$1 as filterOutputToFormIssues, schemaIssuesToFormIssues };
 }
 /**
  * A path into the form's data. String segments address object keys; number
@@ -157,13 +156,19 @@ interface FormIssue {
   readonly message: string;
 }
 /**
- * Render one terminal issue leaf into a human-readable message. The default
- * defers to the issue's own `toString`, which Effect Schema renders into a
- * readable sentence (e.g. `Expected string, got 1`). Override it to localise
- * or to map specific leaf `_tag`s to custom copy.
+ * Render one terminal issue into a human-readable message. The default is
+ * Effect Schema's own formatter (`SchemaIssue.makeFormatterDefault`), which
+ * renders a sentence such as `Expected string`. (An issue's `toString` is no
+ * longer a readable rendering as of Effect rc.118: it prints
+ * `[object Object]`.) Override it to localise or to map specific `_tag`s to
+ * custom copy.
+ *
+ * A failed schema check reaches the formatter as the `Filter` node that
+ * wraps its leaf, because the check's own message (e.g. `Expected a value
+ * with a length of at least 2`) lives on the `Filter`, not on the leaf.
  */
 type LeafFormatter = (issue: SchemaIssue.Issue) => string;
-/** The default leaf formatter — Effect Schema's own rendering of the leaf. */
+/** The default leaf formatter — Effect Schema's own rendering of the issue. */
 declare const defaultLeafFormatter: LeafFormatter;
 /**
  * Walk an Effect Schema issue tree, emitting one {@link FormIssue} per leaf
@@ -180,7 +185,7 @@ declare function schemaIssuesToFormIssues(issue: SchemaIssue.Issue, format?: Lea
  * ({@link module:effect-forms/Validate}) so both fold into the same nested
  * error tree as schema-decode failures.
  */
-declare function filterOutputToFormIssues(output: Schema.FilterOutput): FormIssue[];
+declare function filterOutputToFormIssues$1(output: Schema.FilterOutput): FormIssue[];
 declare namespace Constraints_d_exports {
   export { InputConstraint, InputConstraints, constraintAt, constraintsFromSchema, isLeafConstraint };
 }
@@ -521,6 +526,14 @@ declare const empty: FormBuilder<Record<never, never>, never>;
 declare function buildSchema<TFields extends FieldsRecord, R>(self: FormBuilder<TFields, R>): Schema.Codec<DecodedFromFields<TFields>, EncodedFromFields<TFields>, R>;
 /** The asynchronous refinements carried on a builder, as bare predicates. */
 declare function asyncRefinements<TFields extends FieldsRecord, R>(self: FormBuilder<TFields, R>): ReadonlyArray<(values: DecodedFromFields<TFields>) => Effect.Effect<Schema.FilterOutput, never, R>>;
+/**
+ * Normalise a filter predicate's `Schema.FilterOutput` into a flat list of
+ * {@link FormIssue}s (empty on success).
+ *
+ * @deprecated Use `Issues.filterOutputToFormIssues`; this re-export remains
+ * only for callers that imported it from `FormBuilder`.
+ */
+declare const filterOutputToFormIssues: typeof filterOutputToFormIssues$1;
 /**
  * Run every asynchronous refinement on `self` against `values` and collect
  * their failures as {@link FormIssue}s (empty when all pass). Runs them
@@ -555,11 +568,17 @@ interface FormState<A, Message = unknown> {
 }
 /** Options for {@link make}. */
 interface MakeFormStateOptions<Message> {
+  /** The form's id, distinguishing several forms on one page. Defaults to `"default"`. */
   readonly id?: string;
+  /** Whether the state is valid. Defaults to `true` exactly when `errors` is empty. */
   readonly valid?: boolean;
+  /** Whether the state comes from a submission. Defaults to `false`. */
   readonly posted?: boolean;
+  /** The nested error tree. Defaults to no errors. */
   readonly errors?: FormErrors;
+  /** A status message to render with the form. Omitted by default. */
   readonly message?: Message;
+  /** Native input constraints. Omitted by default. */
   readonly constraints?: InputConstraints;
 }
 /** Build a {@link FormState} from data plus overrides. `valid` defaults to "no errors". */
@@ -618,8 +637,11 @@ interface Form<S extends Schema.Top, Message = unknown> {
   validate(input: FormInput): Effect.Effect<FormState<S["Type"], Message>, never, S["DecodingServices"]>;
 }
 /**
- * Bind `schema` to a form. See the module docs for the contract. The returned
- * {@link Form} is stateless and reusable across requests.
+ * Bind `schema` to a form: `validate(input)` decodes a submission into a
+ * {@link FormState} (it never fails — validation failures live in the state;
+ * its requirements are the schema's decoding services) and `empty()` seeds a
+ * blank form from `defaults`. The returned {@link Form} is stateless and
+ * reusable across requests.
  */
 declare function make<S extends Schema.Top, Message = unknown>(schema: S, options: MakeFormOptions<S>): Form<S, Message>;
 /** Options for {@link fromBuilder}. Like {@link MakeFormOptions} but `defaults` is optional. */
@@ -647,8 +669,6 @@ declare namespace FormData_d_exports {
   export { FormBodySource, formDataToObject, parseFieldPath, requestToObject };
 }
 /**
- * @copyright Thomas Foster
- *
  * Structured parsing of an HTML form body into a plain object the schema can
  * decode.
  *
@@ -664,6 +684,7 @@ declare namespace FormData_d_exports {
  * `File` values pass through untouched; repeated bare keys collapse into an
  * array. The parser is total and never throws.
  *
+ * @copyright Thomas Foster
  * @module effect-forms/FormData
  */
 /** Anything that can be parsed into a structured form object. */

package/dist/index.js

@@ -3,7 +3,7 @@ import * as Schema from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
 import * as Effect from "effect/Effect";
 import * as SchemaParser from "effect/SchemaParser";
-import "effect/SchemaIssue";
+import * as SchemaIssue from "effect/SchemaIssue";
 import * as Duration from "effect/Duration";
 //#region src/Coerce.ts
 var Coerce_exports = /* @__PURE__ */ __exportAll({
@@ -15,8 +15,6 @@ var Coerce_exports = /* @__PURE__ */ __exportAll({
 	trimToUndefined: () => trimToUndefined
 });
 /**
-* @copyright Thomas Foster
-*
 * Tri-state coercers for the HTML-form boundary.
 *
 * An HTML form submits every value as a string, and an absent optional field
@@ -30,6 +28,7 @@ var Coerce_exports = /* @__PURE__ */ __exportAll({
 * framework's `error()` helper (validation failures belong on the schema, not
 * in a coercer).
 *
+* @copyright Thomas Foster
 * @module effect-forms/Coerce
 */
 /** Empty string / `undefined` → `undefined`; otherwise the value (skip semantics). */
@@ -73,8 +72,6 @@ function booleanFromCheckbox(raw) {
 //#endregion
 //#region src/Command.ts
 /**
-* @copyright Thomas Foster
-*
 * Command-struct introspection and form derivation.
 *
 * A host app's write surface is a pair of flat command `Schema.Struct`s per
@@ -102,6 +99,7 @@ function booleanFromCheckbox(raw) {
 * (a create-time default, an asymmetric coercion) stay expressible via the
 * per-field {@link AdaptOverrides} escape hatch instead of forcing ejection.
 *
+* @copyright Thomas Foster
 * @module effect-forms/Command
 */
 var Command_exports = /* @__PURE__ */ __exportAll({
@@ -441,7 +439,7 @@ function flattenChecks(checks, out) {
 const payloadPatches = {
 	"effect/schema/isMinLength": (p) => ({ minlength: p.minLength }),
 	"effect/schema/isMaxLength": (p) => ({ maxlength: p.maxLength }),
-	"effect/schema/isLengthBetween": (p) => ({
+	"effect/schema/isBetweenLength": (p) => ({
 		minlength: p.minimum,
 		maxlength: p.maximum
 	}),
@@ -621,9 +619,10 @@ const isIndexToken = (token) => token === "" || /^\d+$/.test(token);
 /** Create the container a token should live in: array for index/append tokens. */
 const makeContainer = (nextToken) => isIndexToken(nextToken) ? [] : {};
 const setOnContainer = (container, token, value) => {
-	if (Array.isArray(container)) if (token === "") container.push(value);
-	else container[Number(token)] = value;
-	else container[token] = value;
+	if (Array.isArray(container)) {
+		if (token === "") container.push(value);
+		else container[Number(token)] = value;
+	} else container[token] = value;
 };
 const getFromContainer = (container, token) => Array.isArray(container) ? container[Number(token)] : container[token];
 /** Assign `value` deep into `root` along `tokens`, creating containers as needed. */
@@ -681,8 +680,6 @@ async function requestToObject(request) {
 //#endregion
 //#region src/Path.ts
 /**
-* @copyright Thomas Foster
-*
 * Nested get / set along a {@link FormPath}.
 *
 * A form's data is a tree, and the reactive bindings address it by path:
@@ -700,6 +697,7 @@ async function requestToObject(request) {
 * convert to and from the flat `author.name` / `tags[0]` notation the HTML
 * body parser ({@link module:effect-forms/FormData}) uses.
 *
+* @copyright Thomas Foster
 * @module effect-forms/Path
 */
 var Path_exports = /* @__PURE__ */ __exportAll({
@@ -1170,11 +1168,11 @@ function defaultEncodedValues(fields) {
 //#region src/Issues.ts
 var Issues_exports = /* @__PURE__ */ __exportAll({
 	defaultLeafFormatter: () => defaultLeafFormatter,
-	filterOutputToFormIssues: () => filterOutputToFormIssues,
+	filterOutputToFormIssues: () => filterOutputToFormIssues$1,
 	schemaIssuesToFormIssues: () => schemaIssuesToFormIssues
 });
-/** The default leaf formatter — Effect Schema's own rendering of the leaf. */
-const defaultLeafFormatter = (issue) => String(issue);
+/** The default leaf formatter — Effect Schema's own rendering of the issue. */
+const defaultLeafFormatter = SchemaIssue.makeFormatterDefault();
 /**
 * Normalise a `Pointer.path` segment into a {@link FormPath} segment: integer
 * keys become numbers (array indices), everything else becomes a string.
@@ -1184,6 +1182,17 @@ const normaliseSegment = (segment) => {
 	if (typeof segment === "symbol") return segment.toString();
 	return /^\d+$/.test(segment) ? Number(segment) : segment;
 };
+/** Whether `issue` is a terminal leaf: it wraps no further issues. */
+const isTerminal = (issue) => {
+	switch (issue._tag) {
+		case "Pointer":
+		case "Composite":
+		case "Filter":
+		case "Encoding": return false;
+		case "AnyOf": return issue.issues.length === 0;
+		default: return true;
+	}
+};
 /**
 * Walk an Effect Schema issue tree, emitting one {@link FormIssue} per leaf
 * failure. Path segments accumulate through `Pointer` nodes; `Composite` and
@@ -1212,6 +1221,15 @@ function schemaIssuesToFormIssues(issue, format = defaultLeafFormatter) {
 				for (const child of current.issues) walk(child, path);
 				return;
 			case "Filter":
+				if (isTerminal(current.issue)) {
+					out.push({
+						path,
+						message: format(current)
+					});
+					return;
+				}
+				walk(current.issue, path);
+				return;
 			case "Encoding":
 				walk(current.issue, path);
 				return;
@@ -1233,7 +1251,7 @@ function schemaIssuesToFormIssues(issue, format = defaultLeafFormatter) {
 * ({@link module:effect-forms/Validate}) so both fold into the same nested
 * error tree as schema-decode failures.
 */
-function filterOutputToFormIssues(output) {
+function filterOutputToFormIssues$1(output) {
 	if (output === void 0 || output === true) return [];
 	if (output === false) return [{
 		path: [],
@@ -1262,8 +1280,6 @@ function filterIssueToFormIssues(issue) {
 //#endregion
 //#region src/FormBuilder.ts
 /**
-* @copyright Thomas Foster
-*
 * Compose a form schema one field at a time, with cross-field refinements.
 *
 * {@link make} (aliased {@link empty}) starts an empty builder;
@@ -1284,6 +1300,7 @@ function filterIssueToFormIssues(issue) {
 * path — {@link asyncRefinements} exposes them and {@link runAsyncRefinements}
 * runs them into a {@link FormIssue} list.
 *
+* @copyright Thomas Foster
 * @module effect-forms/FormBuilder
 */
 var FormBuilder_exports = /* @__PURE__ */ __exportAll({
@@ -1356,6 +1373,14 @@ function asyncRefinements(self) {
 	return self.refinements.filter((r) => r._tag === "async").map((r) => r.fn);
 }
 /**
+* Normalise a filter predicate's `Schema.FilterOutput` into a flat list of
+* {@link FormIssue}s (empty on success).
+*
+* @deprecated Use `Issues.filterOutputToFormIssues`; this re-export remains
+* only for callers that imported it from `FormBuilder`.
+*/
+const filterOutputToFormIssues = filterOutputToFormIssues$1;
+/**
 * Run every asynchronous refinement on `self` against `values` and collect
 * their failures as {@link FormIssue}s (empty when all pass). Runs them
 * concurrently; requirements propagate on the `R` channel.
@@ -1363,13 +1388,11 @@ function asyncRefinements(self) {
 function runAsyncRefinements(self, values) {
 	const refinements = asyncRefinements(self);
 	if (refinements.length === 0) return Effect.succeed([]);
-	return Effect.forEach(refinements, (fn) => fn(values), { concurrency: "unbounded" }).pipe(Effect.map((outputs) => outputs.flatMap(filterOutputToFormIssues)));
+	return Effect.forEach(refinements, (fn) => fn(values), { concurrency: "unbounded" }).pipe(Effect.map((outputs) => outputs.flatMap(filterOutputToFormIssues$1)));
 }
 //#endregion
 //#region src/State.ts
 /**
-* @copyright Thomas Foster
-*
 * {@link FormState} — the serialisable snapshot of a form.
 *
 * This is the single object a
@@ -1378,6 +1401,7 @@ function runAsyncRefinements(self, values) {
 * boundary, and {@link FormStateSchema} gives it an Effect Schema so it can be
 * decoded back on arrival.
 *
+* @copyright Thomas Foster
 * @module effect-forms/State
 */
 var State_exports = /* @__PURE__ */ __exportAll({
@@ -1436,8 +1460,6 @@ function FormStateSchema(data) {
 //#endregion
 //#region src/Form.ts
 /**
-* @copyright Thomas Foster
-*
 * {@link make} — the core entry point: bind an Effect Schema to a form and
 * get back a validator and an empty-state factory.
 *
@@ -1448,9 +1470,8 @@ function FormStateSchema(data) {
 *   it through the schema, returning a {@link FormState} — valid with the
 *   decoded data, or invalid with the nested {@link FormErrors} and the posted
 *   values preserved so the form re-renders what the user typed. It is an
-*   `Effect`, so a schema requiring decoding services composes naturally and
-*   the caller stays on the typed error channel — there is none; validation
-*   failures live in the returned state, not the error channel.
+*   `Effect`, so a schema requiring decoding services composes naturally; it
+*   has no error channel — validation failures live in the returned state.
 * - `empty()` seeds an unposted, invalid-by-default form from the supplied
 *   defaults — what a `load` returns to render a blank create form.
 *
@@ -1459,6 +1480,7 @@ function FormStateSchema(data) {
 * {@link module:effect-forms/Coerce} helpers, …) so a multipart body decodes
 * cleanly.
 *
+* @copyright Thomas Foster
 * @module effect-forms/Form
 */
 var Form_exports = /* @__PURE__ */ __exportAll({
@@ -1472,8 +1494,11 @@ const toStructured = (input) => {
 	return Effect.succeed(input);
 };
 /**
-* Bind `schema` to a form. See the module docs for the contract. The returned
-* {@link Form} is stateless and reusable across requests.
+* Bind `schema` to a form: `validate(input)` decodes a submission into a
+* {@link FormState} (it never fails — validation failures live in the state;
+* its requirements are the schema's decoding services) and `empty()` seeds a
+* blank form from `defaults`. The returned {@link Form} is stateless and
+* reusable across requests.
 */
 function make(schema, options) {
 	const id = options.id ?? "default";
@@ -1569,8 +1594,6 @@ function fromBuilder(builder, options = {}) {
 //#endregion
 //#region src/Mode.ts
 /**
-* @copyright Thomas Foster
-*
 * When a form validates (and, optionally, auto-submits).
 *
 * A reactive form has to decide *when* to run validation as the user types.
@@ -1595,6 +1618,7 @@ function fromBuilder(builder, options = {}) {
 * once the form has been posted at least once; `"never"` keeps the classic
 * frozen-until-resubmit behaviour.
 *
+* @copyright Thomas Foster
 * @module effect-forms/Mode
 */
 var Mode_exports = /* @__PURE__ */ __exportAll({ parse: () => parse });
@@ -1662,8 +1686,6 @@ const errorResult = (message, status = 500) => ({
 //#endregion
 //#region src/Validate.ts
 /**
-* @copyright Thomas Foster
-*
 * Low-level validation helpers — decode a value through a schema and get back
 * the {@link FormErrors} tree (or the list of {@link FormIssue}s) instead of a
 * raised failure. `Form.make` is the high-level entry; these are for ad
@@ -1680,6 +1702,7 @@ const errorResult = (message, status = 500) => ({
 * and interrupting the previous fiber on every new run (see that function's
 * docs for why that alone gives debounce + "latest wins" cancellation).
 *
+* @copyright Thomas Foster
 * @module effect-forms/Validate
 */
 var Validate_exports = /* @__PURE__ */ __exportAll({
@@ -1725,7 +1748,7 @@ function validateValueSync(schema, input, format) {
 * cannot fail the Effect error channel.
 */
 function runSyncFieldValidator(validator, value) {
-	return filterOutputToFormIssues(validator(value));
+	return filterOutputToFormIssues$1(validator(value));
 }
 /**
 * Build the Effect an {@link AsyncFieldValidator} run is: sleep `debounceMs`
@@ -1745,7 +1768,7 @@ function runSyncFieldValidator(validator, value) {
 function runAsyncFieldValidator(validator, value, debounceMs = 0) {
 	return Effect.gen(function* () {
 		if (debounceMs > 0) yield* Effect.sleep(Duration.millis(debounceMs));
-		return filterOutputToFormIssues(yield* validator(value));
+		return filterOutputToFormIssues$1(yield* validator(value));
 	});
 }
 /**