@thomasfosterau/effect-forms-svelte 0.2.0 → 0.3.2

package/README.md

@@ -1,6 +1,6 @@
 # @thomasfosterau/effect-forms-svelte
 
-Svelte 5 (runes) bindings for [`@thomasfosterau/effect-forms`](../forms): a reactive form store with progressive-enhancement submission, tainted tracking, lifecycle events, and optional client-side validation against the **same Effect Schema the server uses**.
+Svelte 5 (runes) bindings for [`@thomasfosterau/effect-forms`](https://www.npmjs.com/package/@thomasfosterau/effect-forms): a reactive form store with progressive-enhancement submission, tainted tracking, lifecycle events, and optional client-side validation against the **same Effect Schema the server uses**.
 
 The root entry depends only on `svelte` and the framework-neutral core, not SvelteKit, so it works in any Svelte 5 app. The [`/kit` entry](#kit) (`@thomasfosterau/effect-forms-svelte/kit`) is the SvelteKit-only half: derived form actions, JSON:API error routing and `$app/forms` glue.
 
@@ -45,7 +45,7 @@ Server (`+page.server.ts` or any action) produces a `FormState` with the core's
 
 ## The store
 
-`createForm(source, options)` returns a [`FormStore`](src/FormStore.svelte.ts). `source` is a server-produced `FormState`, a `{ schema, defaults }` seed, or a [`FormBuilder`](../forms/src/FormBuilder.ts) — the builder derives its schema, blank defaults, and array-item defaults for you:
+`createForm(source, options)` returns a [`FormStore`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/src/FormStore.svelte.ts). `source` is a server-produced `FormState`, a `{ schema, defaults }` seed, or a [`FormBuilder`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/forms/src/FormBuilder.ts) — the builder derives its schema, blank defaults, and array-item defaults for you:
 
 ```ts
 import { createForm } from "@thomasfosterau/effect-forms-svelte";
@@ -56,13 +56,13 @@ const form = createForm(signup, { mode: { validation: "onChange", debounce: 300
 
 **Reactive state** — `data` (mutable, bind inputs to it), `errors` (merged client + server), `clientErrors` / `serverErrors` (per-source views), `message`, `constraints`, `submitting`, `delayed`, `posted`, `valid`, `canSubmit`, `isValidating`, `isSubmitted`, `isSubmitSuccessful`, `submissionAttempts`, `tainted`, `isTainted`, and (against the last submission) `changedSinceSubmit` / `hasChangedSinceSubmit`.
 
-**Methods** — `enhance(node)` (the form action), `validate()` / `validateField(path)` (client-side, needs `schema`; also runs a builder's `refineEffect` refinements), `errorsAt(path)` / `taintedAt(path)` / `isValidatingAt(path)`, `setValue(path, v)` / `valueAt(path)`, `handleBlur(path)` / `setTouched(path)` / `isTouchedAt(path)`, `isDirtyAt(path)` / `isDefaultValueAt(path)` (persistent per-field dirty tracking — see [Field handles](#field-handles)), `setFieldValidators(path, validators)` (register a field's validators dynamically), `shouldShowError(path)` / `visibleErrorsAt(path)` (mode-aware display gating), `constraintAt(path)`, `revertToLastSubmit()`, `reset()`, `capture()` / `restore()` (SvelteKit snapshots), `setServerState(data, errors)` (apply a result received some other way), `toFormData()`.
+**Methods** — `enhance(node)` (the form action), `validate()` / `validateField(path)` (client-side, needs `schema`; also runs a builder's `refineEffect` refinements, on the decoded values as the server does, once they decode), `errorsAt(path)` / `taintedAt(path)` / `isValidatingAt(path)`, `setValue(path, v)` / `valueAt(path)`, `handleBlur(path)` / `setTouched(path)` / `isTouchedAt(path)`, `isDirtyAt(path)` / `isDefaultValueAt(path)` (persistent per-field dirty tracking — see [Field handles](#field-handles)), `setFieldValidators(path, validators)` (register a field's validators dynamically), `shouldShowError(path)` / `visibleErrorsAt(path)` (mode-aware display gating), `constraintAt(path)`, `revertToLastSubmit()`, `reset()`, `capture()` / `restore()` (SvelteKit snapshots), `setServerState(data, errors)` (apply a result received some other way), `toFormData()`.
 
 **Field arrays** — `append(path, value?)`, `insertItem(path, i, value?)`, `replaceItem(path, i, value)`, `removeItem(path, i)`, `clearItems(path)`, `swap(path, a, b)`, `move(path, from, to)` mutate the array at `path` immutably. `append` / `insertItem` derive a blank item by walking the bound schema's AST at `path` (any nesting depth, e.g. `authors[0].emails`), falling back to the top-level `FormBuilder` field when no schema is bound. Every index-shifting mutation (`insertItem` / `removeItem` / `swap` / `move` / `clearItems`) remaps per-index touched flags and errors so they keep following their row — `replaceItem` drops only the replaced index's own touched flag / errors.
 
 ## Field handles
 
-`form.field(path)` (modelled on TanStack Form's `FieldApi`) returns a typed, reactive [`FieldHandle`](src/FormStore.svelte.ts) bundling everything one input needs, instead of wiring `bind:value` / `name` / `handleBlur` / `visibleErrorsAt` / `constraints` against the store separately:
+`form.field(path)` (modelled on TanStack Form's `FieldApi`) returns a typed, reactive [`FieldHandle`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/src/FormStore.svelte.ts) bundling everything one input needs, instead of wiring `bind:value` / `name` / `handleBlur` / `visibleErrorsAt` / `constraints` against the store separately:
 
 ```svelte
 <script lang="ts">
@@ -82,7 +82,7 @@ const form = createForm(signup, { mode: { validation: "onChange", debounce: 300
 
 `field.meta` exposes TanStack-style field state: `isBlurred` (lost focus at least once), `isTouched` (`isBlurred || isDirty`), `isDirty` (changed away from the default at some point — **persistent**, unlike `taintedAt` it does not clear on reverting to the default; only `reset()` clears it), and `isDefaultValue` (current value equals the default — flips back on revert). `isDirty` only tracks writes made through `field.value = …` / `setValue` / the array mutators (`append` / `removeItem` / `swap` / `move`) — a form that still binds `bind:value={form.data.x}` directly, bypassing `field()`, never marks that field dirty.
 
-**Validation modes** — the `mode` option (see [`Mode`](../forms/src/Mode.ts)) drives when the form validates: `onSubmit` (default), `onBlur` (call `handleBlur` from an input's blur), or `onChange` (debounced). `onBlur` / `onChange` may `autoSubmit`, turning the form into a live-saving surface. `revalidate` (`"onChange"` default / `"onBlur"` / `"never"`) governs what happens _after_ a failed post in `onSubmit` mode: fixing a field re-validates just that field, clearing its error without a resubmit. Errors are computed for the whole form; gate their display per field with `visibleErrorsAt(path)` (shown only once the field is tainted / touched, or after a submit).
+**Validation modes** — the `mode` option (see [`Mode`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/forms/src/Mode.ts)) drives when the form validates: `onSubmit` (default), `onBlur` (call `handleBlur` from an input's blur), or `onChange` (debounced). `onBlur` / `onChange` may `autoSubmit`, turning the form into a live-saving surface. `revalidate` (`"onChange"` default / `"onBlur"` / `"never"`) governs what happens _after_ a failed post in `onSubmit` mode: fixing a field re-validates just that field, clearing its error without a resubmit. Errors are computed for the whole form; gate their display per field with `visibleErrorsAt(path)` (shown only once the field is tainted / touched, or after a submit).
 
 **Per-field validators** — the `validators` option (or `setFieldValidators`) attaches TanStack-Form-style `{ onChange?, onBlur?, onChangeAsync?, onBlurAsync?, asyncDebounceMs? }` per field, keyed by `Path.toString` (e.g. `"author.name"`, `"tags[0]"`). Sync validators return a `Schema.FilterOutput`; async ones are `Effect`s, run as a fiber per field — a new value interrupts the field's in-flight fiber before forking the next run, which is what gives the debounce + "latest wins" cancellation (no timer bookkeeping needed). Pass `layer` when a validator (or a builder's `refineEffect` refinement) needs services on its `R` channel:
 
@@ -103,23 +103,23 @@ const form = createForm(
 
 **Error sources** — a field's server-reported error (from the last submission) survives a client-side revalidation of some _other_ field; it clears once _that_ field's own value changes (or the server clears it on the next submit). `errors` is the merged view; `clientErrors` / `serverErrors` expose the two trees separately for a UI that wants to style them differently.
 
-**Lifecycle options** — `onSubmit` (with `cancel()`), `onResult`, `onUpdate`, `onUpdated`, `onError`, `onRedirect`, plus `resetForm`, `taintedMessage`, `delayMs`, and a `submit` transport override (defaults to `fetch` to the form's action, parsing a JSON [`FormActionResult`](../forms/src/Result.ts) or a bare `FormState`).
+**Lifecycle options** — `onSubmit` (with `cancel()`), `onResult`, `onUpdate`, `onUpdated`, `onError`, `onRedirect`, plus `resetForm`, `taintedMessage`, `delayMs`, and a `submit` transport override (defaults to `fetch` to the form's action, parsing a JSON [`FormActionResult`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/forms/src/Result.ts) or a bare `FormState`).
 
 ## API
 
 Everything below is exported flat from the root entry (`@thomasfosterau/effect-forms-svelte`).
 
-| Module                                    | Exports                                                                                                                                                                                         |
-| ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| [`FormStore`](src/FormStore.svelte.ts)    | `createForm`, `FormStore`, `FieldHandle`, `FieldMeta`, `FormOptions`, `FormSeed` — the reactive store above.                                                                                    |
-| [`EntityForm`](src/EntityForm.ts)         | `defineEntityForm` — an ordered, key-checked field list over a core `Command.plan`, walked by one generic renderer component; its entry types (`ScalarEntry`, `SelectEntry`, `WidgetEntry`, …). |
-| [`SvelteKit`](src/SvelteKit.ts)           | `applyActionResult` — apply a SvelteKit `ActionResult` (`ServerActionResult`) to a store; returns whether it consumed a validation failure.                                                     |
-| [`Listeners`](src/Listeners.ts)           | `changeEvents` / `dispatchChange` and the `FormListeners` / `FieldListener` types — per-field and form-wide change listeners (linked fields).                                                   |
-| [`Tainted`](src/Tainted.ts)               | Deep-diff the data to compute the tainted tree.                                                                                                                                                 |
-| [`ClientValidate`](src/ClientValidate.ts) | `validateData` / `validateField` — validate the form, or one field, against the schema.                                                                                                         |
-| [`EnhanceCore`](src/EnhanceCore.ts)       | Serialise data → form body, parse the response, compute the store update.                                                                                                                       |
+| Module                                                                                                              | Exports                                                                                                                                                                                         |
+| ------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [`FormStore`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/src/FormStore.svelte.ts)    | `createForm`, `FormStore`, `FieldHandle`, `FieldMeta`, `FormOptions`, `FormSeed` — the reactive store above.                                                                                    |
+| [`EntityForm`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/src/EntityForm.ts)         | `defineEntityForm` — an ordered, key-checked field list over a core `Command.plan`, walked by one generic renderer component; its entry types (`ScalarEntry`, `SelectEntry`, `WidgetEntry`, …). |
+| [`SvelteKit`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/src/SvelteKit.ts)           | `applyActionResult` — apply a SvelteKit `ActionResult` (`ServerActionResult`) to a store; returns whether it consumed a validation failure.                                                     |
+| [`Listeners`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/src/Listeners.ts)           | `changeEvents` / `dispatchChange` and the `FormListeners` / `FieldListener` types — per-field and form-wide change listeners (linked fields).                                                   |
+| [`Tainted`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/src/Tainted.ts)               | Deep-diff the data to compute the tainted tree.                                                                                                                                                 |
+| [`ClientValidate`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/src/ClientValidate.ts) | `validateData` / `validateField` — validate the form, or one field, against the schema.                                                                                                         |
+| [`EnhanceCore`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/src/EnhanceCore.ts)       | Serialise data → form body, parse the response, compute the store update.                                                                                                                       |
 
-The reactive store (`FormStore.svelte.ts`, rune-compiled) delegates its logic to the pure, unit-tested modules. The store itself is type-checked as plain TypeScript; its submitter-aware submit path (`enhance` → the posted `FormData`) is unit-tested in [`FormStore.svelte.test.ts`](tests/FormStore.svelte.test.ts).
+The reactive store (`FormStore.svelte.ts`, rune-compiled) delegates its logic to the pure, unit-tested modules. The store itself is type-checked (by `vp check` and by `svelte-check`); its submitter-aware submit path (`enhance` → the posted `FormData`) is unit-tested in [`FormStore.svelte.test.ts`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/tests/FormStore.svelte.test.ts).
 
 ## /kit
 
@@ -138,7 +138,7 @@ The reactive store (`FormStore.svelte.ts`, rune-compiled) delegates its logic to
 
 ### Peers
 
-- `@sveltejs/kit` (`^3.0.0`) is an **optional** peer of the package and **required** by `/kit`. SvelteKit 2 is not supported. The repository's tests run against SvelteKit 3.0.0, pinned in its `pnpm-workspace.yaml`.
+- `@sveltejs/kit` (`^3.0.0`) is an **optional** peer of the package and **required** by `/kit`. SvelteKit 2 is not supported. The repository's tests run against the SvelteKit version pinned in its `pnpm-workspace.yaml`.
 - `$app/forms` is a SvelteKit virtual module, not a dependency. It resolves because SvelteKit compiles this package (its `exports` carry the `svelte` condition), so `/kit` only works inside a SvelteKit build.
 - `@thomasfosterau/effect-jsonapi` (`>=0.16.0`) is an **optional** peer used **for its types only**. `CommandFailure.ErrorObject` is `Document.ErrorObject.Type`. At runtime a failure is recognised by its `_tag`, so an application's own `JsonapiError` with the same shape is recognised too.
 
@@ -203,7 +203,7 @@ export const actions = {
 };
 ```
 
-The runnable copy is [`packages/svelte/tests/kit/examples/login.page.server.ts`](tests/kit/examples/login.page.server.ts). [`login.example.test.ts`](tests/kit/login.example.test.ts) runs it against the real `@sveltejs/kit`, covering the success redirect, the off-site `redirectTo` guard, the 401 with a blanked password, and the rethrow.
+The runnable copy is [`packages/svelte/tests/kit/examples/login.page.server.ts`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/tests/kit/examples/login.page.server.ts). [`login.example.test.ts`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/tests/kit/login.example.test.ts) runs it against the real `@sveltejs/kit`, covering the success redirect, the off-site `redirectTo` guard, the 401 with a blanked password, and the rethrow.
 
 The page renders server state without a client store:
 
@@ -226,4 +226,4 @@ With a client store, spread `enhanceForm(form)` onto the `<form>` instead.
 
 ## License
 
-[MIT](LICENSE)
+[MIT](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/LICENSE)

package/dist/ClientValidate.d.ts

@@ -1,6 +1,5 @@
 import { Errors, Issues } from "@thomasfosterau/effect-forms";
 import * as Schema from "effect/Schema";
-//#region src/ClientValidate.d.ts
 type FormErrors = Errors.FormErrors;
 type FormPath = Issues.FormPath;
 type LeafFormatter = Issues.LeafFormatter;
@@ -13,5 +12,5 @@ export declare function validateData<S extends Schema.Top>(schema: S, data: unkn
  * field only.
  */
 export declare function validateField<S extends Schema.Top>(schema: S, data: unknown, path: FormPath, format?: LeafFormatter): readonly string[];
-//#endregion
+export {};
 //# sourceMappingURL=ClientValidate.d.ts.map

package/dist/ClientValidate.js

@@ -1,5 +1,5 @@
 import { Errors, Validate } from "@thomasfosterau/effect-forms";
-//#region src/ClientValidate.ts
+// src/ClientValidate.ts
 /**
 * Client-side validation helpers — validate the whole form or a single field
 * against the same Effect Schema the server uses, returning the nested
@@ -30,7 +30,6 @@ function validateField(schema, data, path, format) {
 	const errors = validateData(schema, data, format);
 	return getError(errors, path) ?? [];
 }
-//#endregion
 export { validateData, validateField };
 
 //# sourceMappingURL=ClientValidate.js.map

package/dist/EnhanceCore.d.ts

@@ -1,10 +1,40 @@
 import { Errors, Result } from "@thomasfosterau/effect-forms";
-//#region src/EnhanceCore.d.ts
 type FormActionResult<A, Message = unknown> = Result.FormActionResult<A, Message>;
 type FormErrors = Errors.FormErrors;
-/** Flatten a nested data object into `[name, value]` entries using path notation. */
+/**
+ * Flatten a nested data object into `[name, value]` string entries using path
+ * notation.
+ *
+ * Nested objects become dotted names (`author.name`) and array items indexed
+ * names (`tags[0]`). Each leaf kind is handled as follows:
+ *
+ * - A `string`, `number`, `boolean` or `bigint` is stringified.
+ * - `null` becomes `""`.
+ * - A `Date` becomes the `YYYY-MM-DD` of its **UTC** calendar day (what
+ *   `<input type="date">` submits, and what `Schema.DateFromString` decodes
+ *   back to UTC midnight); the time of day is dropped, so a datetime needs its
+ *   own string field. An invalid `Date` is omitted.
+ * - A `Blob` or `File` is omitted here, since a string entry can't carry it;
+ *   {@link objectToFormData} keeps it.
+ * - An `undefined`, `function` or `symbol` is omitted, as `JSON.stringify`
+ *   omits such object properties, so a callback or symbol left in form data
+ *   never reaches the form body as `"Symbol(…)"` or function source.
+ * - Any other object contributes its own enumerable fields, so one with none
+ *   (a `Map`, a `Set`, an empty object) contributes no entries.
+ *
+ * An omitted array item leaves a gap (where `JSON.stringify` would write
+ * `null`), so the remaining items keep their indices (`tags[0]`, `tags[2]`).
+ */
 export declare function objectToEntries(data: unknown, prefix?: string): Array<[string, string]>;
-/** Serialise the store's data into a {@link FormData} body for submission. */
+/**
+ * Serialise the store's data into a {@link FormData} body for submission.
+ *
+ * Names and leaves follow {@link objectToEntries}, except that a `Blob` or
+ * `File` leaf is appended as a file (a `File` keeps its name; a bare `Blob`
+ * arrives as a `File` named `"blob"`, the `FormData` default), as an
+ * `<input type="file">` would submit it, so it reaches the core's
+ * `FormData.formDataToObject` (`@thomasfosterau/effect-forms`) unchanged.
+ */
 export declare function objectToFormData(data: unknown): FormData;
 /**
  * Normalise a parsed JSON response body into a {@link FormActionResult}. The
@@ -56,5 +86,5 @@ export declare function computeDataApplication<A>(params: {
   readonly resetForm: boolean;
   readonly autoSubmit: boolean;
 }): DataApplication<A>;
-//#endregion
+export {};
 //# sourceMappingURL=EnhanceCore.d.ts.map

package/dist/EnhanceCore.js

@@ -1,5 +1,9 @@
 import { Result } from "@thomasfosterau/effect-forms";
-//#region src/EnhanceCore.ts
+import * as Arr from "effect/Array";
+import * as Match from "effect/Match";
+import * as Predicate from "effect/Predicate";
+import * as Record from "effect/Record";
+// src/EnhanceCore.ts
 /**
 * Pure plumbing for the `enhance` action: serialise the store's data back into
 * a form body, interpret a server response into a {@link FormActionResult}, and
@@ -11,38 +15,105 @@ import { Result } from "@thomasfosterau/effect-forms";
 * @module effect-forms-svelte/EnhanceCore
 */
 const { failure, success } = Result;
-/** Flatten a nested data object into `[name, value]` entries using path notation. */
-function objectToEntries(data, prefix = "") {
+/**
+* Whether a value is a `Blob` (a `File` is one). Guards on `globalThis.Blob`
+* so it holds in any runtime, including one without a global `Blob`.
+*/
+const isBlob = (value) => !Predicate.isUndefined(globalThis.Blob) && value instanceof Blob;
+/**
+* Encode a `Date` as the `YYYY-MM-DD` of its UTC calendar day, or `undefined`
+* for an invalid `Date`. The UTC day round-trips: a `YYYY-MM-DD` string
+* decodes to UTC midnight. Taking everything before the `T` keeps
+* `toISOString`'s expanded form for a year outside 0000–9999
+* (`+010000-01-01`), where a fixed 10-character slice would cut it off.
+*/
+const encodeDate = (value) => {
+	if (Number.isNaN(value.getTime())) return void 0;
+	const iso = value.toISOString();
+	return iso.slice(0, iso.indexOf("T"));
+};
+/** Append the entries for one named value to `out`, recursing into containers. */
+function appendEntries(out, key, value) {
+	if (value === null) out.push([key, ""]);
+	else if (isBlob(value)) out.push([key, value]);
+	else if (value instanceof Date) {
+		const encoded = encodeDate(value);
+		if (encoded !== void 0) out.push([key, encoded]);
+	} else if (Array.isArray(value)) value.forEach((item, i) => appendEntries(out, `${key}[${i}]`, item));
+	else if (Predicate.isObject(value)) appendFields(out, value, key);
+	else if (Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value) || Predicate.isBigInt(value)) out.push([key, String(value)]);
+}
+/** Append an object's own enumerable fields to `out`, as `prefix.key` names. */
+function appendFields(out, data, prefix) {
+	Arr.forEach(Record.toEntries(data), ([key, value]) => appendEntries(out, prefix ? `${prefix}.${key}` : key, value));
+}
+/** Flatten `data` into form-body entries, `Blob` / `File` leaves included. */
+function toBodyEntries(data, prefix) {
 	const out = [];
-	const push = (key, value) => {
-		if (value === void 0) return;
-		if (value === null) out.push([key, ""]);
-		else if (Array.isArray(value)) value.forEach((item, i) => out.push(...objectToEntries(item, `${key}[${i}]`)));
-		else if (typeof value === "object") out.push(...objectToEntries(value, key));
-		else out.push([key, String(value)]);
-	};
-	if (data !== null && typeof data === "object" && !Array.isArray(data)) for (const [key, value] of Object.entries(data)) push(prefix ? `${prefix}.${key}` : key, value);
-	else if (prefix) push(prefix, data);
+	if (prefix) appendEntries(out, prefix, data);
+	else if (Predicate.isObject(data)) appendFields(out, data, "");
 	return out;
 }
-/** Serialise the store's data into a {@link FormData} body for submission. */
+/**
+* Flatten a nested data object into `[name, value]` string entries using path
+* notation.
+*
+* Nested objects become dotted names (`author.name`) and array items indexed
+* names (`tags[0]`). Each leaf kind is handled as follows:
+*
+* - A `string`, `number`, `boolean` or `bigint` is stringified.
+* - `null` becomes `""`.
+* - A `Date` becomes the `YYYY-MM-DD` of its **UTC** calendar day (what
+*   `<input type="date">` submits, and what `Schema.DateFromString` decodes
+*   back to UTC midnight); the time of day is dropped, so a datetime needs its
+*   own string field. An invalid `Date` is omitted.
+* - A `Blob` or `File` is omitted here, since a string entry can't carry it;
+*   {@link objectToFormData} keeps it.
+* - An `undefined`, `function` or `symbol` is omitted, as `JSON.stringify`
+*   omits such object properties, so a callback or symbol left in form data
+*   never reaches the form body as `"Symbol(…)"` or function source.
+* - Any other object contributes its own enumerable fields, so one with none
+*   (a `Map`, a `Set`, an empty object) contributes no entries.
+*
+* An omitted array item leaves a gap (where `JSON.stringify` would write
+* `null`), so the remaining items keep their indices (`tags[0]`, `tags[2]`).
+*/
+function objectToEntries(data, prefix = "") {
+	return toBodyEntries(data, prefix).filter((entry) => Predicate.isString(entry[1]));
+}
+/**
+* Serialise the store's data into a {@link FormData} body for submission.
+*
+* Names and leaves follow {@link objectToEntries}, except that a `Blob` or
+* `File` leaf is appended as a file (a `File` keeps its name; a bare `Blob`
+* arrives as a `File` named `"blob"`, the `FormData` default), as an
+* `<input type="file">` would submit it, so it reaches the core's
+* `FormData.formDataToObject` (`@thomasfosterau/effect-forms`) unchanged.
+*/
 function objectToFormData(data) {
 	const formData = new FormData();
-	for (const [key, value] of objectToEntries(data)) formData.append(key, value);
+	Arr.forEach(toBodyEntries(data, ""), ([key, value]) => formData.append(key, value));
 	return formData;
 }
-/** Whether a value looks like a {@link FormActionResult} (carries a known `_tag`). */
+/**
+* Whether a value looks like a {@link FormActionResult} (carries a known
+* `_tag`). Only the tag is checked: `A` / `Message` are the caller's declared
+* expectation of the server's response, not verified here.
+*/
 function isActionResult(value) {
-	return typeof value === "object" && value !== null && typeof value._tag === "string" && [
+	return Predicate.isObjectOrArray(value) && Predicate.hasProperty(value, "_tag") && Predicate.isString(value._tag) && [
 		"Success",
 		"Failure",
 		"Redirect",
 		"Error"
 	].includes(value._tag);
 }
-/** Whether a value looks like a bare {@link FormState}. */
+/**
+* Whether a value looks like a bare {@link FormState}. Only the keys are
+* checked: `A` / `Message` are the caller's declared expectation, not verified.
+*/
 function isFormState(value) {
-	return typeof value === "object" && value !== null && "valid" in value && "data" in value && "errors" in value;
+	return Predicate.isObjectOrArray(value) && "valid" in value && "data" in value && "errors" in value;
 }
 /**
 * Normalise a parsed JSON response body into a {@link FormActionResult}. The
@@ -52,10 +123,7 @@ function isFormState(value) {
 */
 function parseActionResult(body, status = 200) {
 	if (isActionResult(body)) return body;
-	if (isFormState(body)) {
-		const state = body;
-		return state.valid ? success(state, status) : failure(state, status);
-	}
+	if (isFormState(body)) return body.valid ? success(body, status) : failure(body, status);
 	return {
 		_tag: "Error",
 		status,
@@ -68,25 +136,25 @@ function parseActionResult(body, status = 200) {
 * `redirect` / `error`.
 */
 function resultToUpdate(result) {
-	switch (result._tag) {
-		case "Success": return {
-			data: result.state.data,
-			errors: result.state.errors,
-			message: result.state.message,
+	return Match.valueTags(result, {
+		Success: ({ state }) => ({
+			data: state.data,
+			errors: state.errors,
+			message: state.message,
 			valid: true
-		};
-		case "Failure": return {
-			data: result.state.data,
-			errors: result.state.errors,
-			message: result.state.message,
+		}),
+		Failure: ({ state }) => ({
+			data: state.data,
+			errors: state.errors,
+			message: state.message,
 			valid: false
-		};
-		case "Redirect": return { redirect: result.location };
-		case "Error": return {
-			error: result.message,
+		}),
+		Redirect: ({ location }) => ({ redirect: location }),
+		Error: ({ message }) => ({
+			error: message,
 			valid: false
-		};
-	}
+		})
+	});
 }
 /**
 * Decide how a submit result's data applies to the store, given a defined
@@ -116,7 +184,6 @@ function computeDataApplication(params) {
 		rebaseTo: isSuccess ? appliedData : void 0
 	};
 }
-//#endregion
 export { computeDataApplication, objectToEntries, objectToFormData, parseActionResult, resultToUpdate };
 
 //# sourceMappingURL=EnhanceCore.js.map

package/dist/EnhanceCore.js.map

@@ -1 +1 @@
-{"version":3,"file":"EnhanceCore.js","names":[],"sources":["../src/EnhanceCore.ts"],"sourcesContent":["/**\n * Pure plumbing for the `enhance` action: serialise the store's data back into\n * a form body, interpret a server response into a {@link FormActionResult}, and\n * compute the store update a result implies. Kept framework-free and side-\n * effect-free so it is unit-testable in isolation; the rune store\n * (`FormStore.svelte.ts`) wires these to the DOM.\n *\n * @copyright Thomas Foster\n * @module effect-forms-svelte/EnhanceCore\n */\n\nimport { Errors, Result, State } from \"@thomasfosterau/effect-forms\";\n\n// Terse local aliases onto the namespaced core exports.\ntype FormActionResult<A, Message = unknown> = Result.FormActionResult<A, Message>;\ntype FormErrors = Errors.FormErrors;\ntype FormState<A, Message = unknown> = State.FormState<A, Message>;\nconst { failure, success } = Result;\n\n/** Flatten a nested data object into `[name, value]` entries using path notation. */\nexport function objectToEntries(data: unknown, prefix = \"\"): Array<[string, string]> {\n  const out: Array<[string, string]> = [];\n  const push = (key: string, value: unknown): void => {\n    if (value === undefined) return;\n    if (value === null) {\n      out.push([key, \"\"]);\n    } else if (Array.isArray(value)) {\n      value.forEach((item, i) => out.push(...objectToEntries(item, `${key}[${i}]`)));\n    } else if (typeof value === \"object\") {\n      out.push(...objectToEntries(value, key));\n    } else {\n      out.push([key, String(value)]);\n    }\n  };\n\n  if (data !== null && typeof data === \"object\" && !Array.isArray(data)) {\n    for (const [key, value] of Object.entries(data as Record<string, unknown>)) {\n      push(prefix ? `${prefix}.${key}` : key, value);\n    }\n  } else if (prefix) {\n    push(prefix, data);\n  }\n  return out;\n}\n\n/** Serialise the store's data into a {@link FormData} body for submission. */\nexport function objectToFormData(data: unknown): FormData {\n  const formData = new FormData();\n  for (const [key, value] of objectToEntries(data)) formData.append(key, value);\n  return formData;\n}\n\n/** Whether a value looks like a {@link FormActionResult} (carries a known `_tag`). */\nfunction isActionResult(value: unknown): value is FormActionResult<unknown, unknown> {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    typeof (value as { _tag?: unknown })._tag === \"string\" &&\n    [\"Success\", \"Failure\", \"Redirect\", \"Error\"].includes((value as { _tag: string })._tag)\n  );\n}\n\n/** Whether a value looks like a bare {@link FormState}. */\nfunction isFormState(value: unknown): value is FormState<unknown, unknown> {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"valid\" in value &&\n    \"data\" in value &&\n    \"errors\" in value\n  );\n}\n\n/**\n * Normalise a parsed JSON response body into a {@link FormActionResult}. The\n * server may return a full action result (`{ _tag, … }`) or a bare\n * {@link FormState} — a bare state maps to `Success` / `Failure` by its `valid`\n * flag, using `status` for the failure code.\n */\nexport function parseActionResult<A, Message>(\n  body: unknown,\n  status = 200,\n): FormActionResult<A, Message> {\n  if (isActionResult(body)) return body as FormActionResult<A, Message>;\n  if (isFormState(body)) {\n    const state = body as FormState<A, Message>;\n    return state.valid ? success(state, status) : failure(state, status);\n  }\n  return { _tag: \"Error\", status, message: \"Unrecognised form response\" };\n}\n\n/** The mutation a {@link FormActionResult} implies for the store. */\nexport interface FormUpdate<A, Message> {\n  readonly data?: A | undefined;\n  readonly errors?: FormErrors | undefined;\n  readonly message?: Message | undefined;\n  readonly redirect?: string | undefined;\n  readonly error?: string | undefined;\n  readonly valid?: boolean | undefined;\n}\n\n/**\n * Compute the store update implied by a {@link FormActionResult}. Pure: the\n * caller applies the returned fields to its reactive state and acts on\n * `redirect` / `error`.\n */\nexport function resultToUpdate<A, Message>(\n  result: FormActionResult<A, Message>,\n): FormUpdate<A, Message> {\n  switch (result._tag) {\n    case \"Success\":\n      return {\n        data: result.state.data,\n        errors: result.state.errors,\n        message: result.state.message,\n        valid: true,\n      };\n    case \"Failure\":\n      return {\n        data: result.state.data,\n        errors: result.state.errors,\n        message: result.state.message,\n        valid: false,\n      };\n    case \"Redirect\":\n      return { redirect: result.location };\n    case \"Error\":\n      return { error: result.message, valid: false };\n  }\n}\n\n/** How a successful/failed submit's data should land on `data` and the tainted baseline. */\nexport interface DataApplication<A> {\n  /** The next value for `data`, or `undefined` to leave it untouched (an auto-submit keeps local edits). */\n  readonly data: A | undefined;\n  /** The next tainted baseline (`#initial`), or `undefined` when this isn't a successful submit. */\n  readonly rebaseTo: A | undefined;\n}\n\n/**\n * Decide how a submit result's data applies to the store, given a defined\n * `update.data` (redirects/errors never reach this — see {@link resultToUpdate}).\n * Pure so the save-then-navigate baseline rebase is unit-testable without\n * compiling the rune store: on a successful submit the tainted baseline\n * rebases to whatever was actually persisted, so `isTainted` goes back to\n * `false` for values that were just saved, not just the original seed. An\n * auto-submitting (live-save) form keeps its local `data` as the source of\n * truth while a request is in flight — adopting the server's echo would\n * discard keystrokes made during the round-trip — but on success rebases to\n * `submittedData` (the snapshot actually sent), not the live value, since the\n * user may have typed further edits that haven't been submitted yet.\n */\nexport function computeDataApplication<A>(params: {\n  readonly isSuccess: boolean;\n  readonly appliedData: A;\n  readonly initial: A;\n  readonly submittedData: A;\n  readonly resetForm: boolean;\n  readonly autoSubmit: boolean;\n}): DataApplication<A> {\n  const { isSuccess, appliedData, initial, submittedData, resetForm, autoSubmit } = params;\n  if (resetForm && isSuccess) return { data: initial, rebaseTo: initial };\n  if (autoSubmit) return { data: undefined, rebaseTo: isSuccess ? submittedData : undefined };\n  return { data: appliedData, rebaseTo: isSuccess ? appliedData : undefined };\n}\n"],"mappings":";;;;;;;;;;;;AAiBA,MAAM,EAAE,SAAS,YAAY;;AAG7B,SAAgB,gBAAgB,MAAe,SAAS,IAA6B;CACnF,MAAM,MAA+B,CAAC;CACtC,MAAM,QAAQ,KAAa,UAAyB;EAClD,IAAI,UAAU,KAAA,GAAW;EACzB,IAAI,UAAU,MACZ,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;OACb,IAAI,MAAM,QAAQ,KAAK,GAC5B,MAAM,SAAS,MAAM,MAAM,IAAI,KAAK,GAAG,gBAAgB,MAAM,GAAG,IAAI,GAAG,EAAE,EAAE,CAAC,CAAC;OACxE,IAAI,OAAO,UAAU,UAC1B,IAAI,KAAK,GAAG,gBAAgB,OAAO,GAAG,CAAC;OAEvC,IAAI,KAAK,CAAC,KAAK,OAAO,KAAK,CAAC,CAAC;CAEjC;CAEA,IAAI,SAAS,QAAQ,OAAO,SAAS,YAAY,CAAC,MAAM,QAAQ,IAAI,GAClE,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,IAA+B,GACvE,KAAK,SAAS,GAAG,OAAO,GAAG,QAAQ,KAAK,KAAK;MAE1C,IAAI,QACT,KAAK,QAAQ,IAAI;CAEnB,OAAO;AACT;;AAGA,SAAgB,iBAAiB,MAAyB;CACxD,MAAM,WAAW,IAAI,SAAS;CAC9B,KAAK,MAAM,CAAC,KAAK,UAAU,gBAAgB,IAAI,GAAG,SAAS,OAAO,KAAK,KAAK;CAC5E,OAAO;AACT;;AAGA,SAAS,eAAe,OAA6D;CACnF,OACE,OAAO,UAAU,YACjB,UAAU,QACV,OAAQ,MAA6B,SAAS,YAC9C;EAAC;EAAW;EAAW;EAAY;CAAO,CAAC,CAAC,SAAU,MAA2B,IAAI;AAEzF;;AAGA,SAAS,YAAY,OAAsD;CACzE,OACE,OAAO,UAAU,YACjB,UAAU,QACV,WAAW,SACX,UAAU,SACV,YAAY;AAEhB;;;;;;;AAQA,SAAgB,kBACd,MACA,SAAS,KACqB;CAC9B,IAAI,eAAe,IAAI,GAAG,OAAO;CACjC,IAAI,YAAY,IAAI,GAAG;EACrB,MAAM,QAAQ;EACd,OAAO,MAAM,QAAQ,QAAQ,OAAO,MAAM,IAAI,QAAQ,OAAO,MAAM;CACrE;CACA,OAAO;EAAE,MAAM;EAAS;EAAQ,SAAS;CAA6B;AACxE;;;;;;AAiBA,SAAgB,eACd,QACwB;CACxB,QAAQ,OAAO,MAAf;EACE,KAAK,WACH,OAAO;GACL,MAAM,OAAO,MAAM;GACnB,QAAQ,OAAO,MAAM;GACrB,SAAS,OAAO,MAAM;GACtB,OAAO;EACT;EACF,KAAK,WACH,OAAO;GACL,MAAM,OAAO,MAAM;GACnB,QAAQ,OAAO,MAAM;GACrB,SAAS,OAAO,MAAM;GACtB,OAAO;EACT;EACF,KAAK,YACH,OAAO,EAAE,UAAU,OAAO,SAAS;EACrC,KAAK,SACH,OAAO;GAAE,OAAO,OAAO;GAAS,OAAO;EAAM;CACjD;AACF;;;;;;;;;;;;;;AAuBA,SAAgB,uBAA0B,QAOnB;CACrB,MAAM,EAAE,WAAW,aAAa,SAAS,eAAe,WAAW,eAAe;CAClF,IAAI,aAAa,WAAW,OAAO;EAAE,MAAM;EAAS,UAAU;CAAQ;CACtE,IAAI,YAAY,OAAO;EAAE,MAAM,KAAA;EAAW,UAAU,YAAY,gBAAgB,KAAA;CAAU;CAC1F,OAAO;EAAE,MAAM;EAAa,UAAU,YAAY,cAAc,KAAA;CAAU;AAC5E"}
+{"version":3,"file":"EnhanceCore.js","names":[],"sources":["../src/EnhanceCore.ts"],"sourcesContent":["/**\n * Pure plumbing for the `enhance` action: serialise the store's data back into\n * a form body, interpret a server response into a {@link FormActionResult}, and\n * compute the store update a result implies. Kept framework-free and side-\n * effect-free so it is unit-testable in isolation; the rune store\n * (`FormStore.svelte.ts`) wires these to the DOM.\n *\n * @copyright Thomas Foster\n * @module effect-forms-svelte/EnhanceCore\n */\n\nimport { Errors, Result, State } from \"@thomasfosterau/effect-forms\";\nimport * as Arr from \"effect/Array\";\nimport * as Match from \"effect/Match\";\nimport * as Predicate from \"effect/Predicate\";\nimport * as Record from \"effect/Record\";\n\n// Terse local aliases onto the namespaced core exports.\ntype FormActionResult<A, Message = unknown> = Result.FormActionResult<A, Message>;\ntype FormErrors = Errors.FormErrors;\ntype FormState<A, Message = unknown> = State.FormState<A, Message>;\nconst { failure, success } = Result;\n\n/** A form-body entry: a stringified leaf, or a `Blob` / `File` passed through. */\ntype BodyEntry = [string, string | Blob];\n\n/**\n * Whether a value is a `Blob` (a `File` is one). Guards on `globalThis.Blob`\n * so it holds in any runtime, including one without a global `Blob`.\n */\nconst isBlob = (value: unknown): value is Blob =>\n  !Predicate.isUndefined(globalThis.Blob) && value instanceof Blob;\n\n/**\n * Encode a `Date` as the `YYYY-MM-DD` of its UTC calendar day, or `undefined`\n * for an invalid `Date`. The UTC day round-trips: a `YYYY-MM-DD` string\n * decodes to UTC midnight. Taking everything before the `T` keeps\n * `toISOString`'s expanded form for a year outside 0000–9999\n * (`+010000-01-01`), where a fixed 10-character slice would cut it off.\n */\nconst encodeDate = (value: Date): string | undefined => {\n  if (Number.isNaN(value.getTime())) return undefined;\n  const iso = value.toISOString();\n  return iso.slice(0, iso.indexOf(\"T\"));\n};\n\n/** Append the entries for one named value to `out`, recursing into containers. */\nfunction appendEntries(out: Array<BodyEntry>, key: string, value: unknown): void {\n  if (value === null) {\n    out.push([key, \"\"]);\n  } else if (isBlob(value)) {\n    out.push([key, value]);\n  } else if (value instanceof Date) {\n    const encoded = encodeDate(value);\n    if (encoded !== undefined) out.push([key, encoded]);\n  } else if (Array.isArray(value)) {\n    value.forEach((item, i) => appendEntries(out, `${key}[${i}]`, item));\n  } else if (Predicate.isObject(value)) {\n    appendFields(out, value, key);\n  } else if (\n    Predicate.isString(value) ||\n    Predicate.isNumber(value) ||\n    Predicate.isBoolean(value) ||\n    Predicate.isBigInt(value)\n  ) {\n    out.push([key, String(value)]);\n  }\n  // `undefined`, `function` and `symbol` leaves are omitted.\n}\n\n/** Append an object's own enumerable fields to `out`, as `prefix.key` names. */\nfunction appendFields<V>(\n  out: Array<BodyEntry>,\n  data: Record.ReadonlyRecord<string, V>,\n  prefix: string,\n): void {\n  Arr.forEach(Record.toEntries(data), ([key, value]) =>\n    appendEntries(out, prefix ? `${prefix}.${key}` : key, value),\n  );\n}\n\n/** Flatten `data` into form-body entries, `Blob` / `File` leaves included. */\nfunction toBodyEntries(data: unknown, prefix: string): Array<BodyEntry> {\n  const out: Array<BodyEntry> = [];\n  if (prefix) appendEntries(out, prefix, data);\n  else if (Predicate.isObject(data)) {\n    appendFields(out, data, \"\");\n  }\n  return out;\n}\n\n/**\n * Flatten a nested data object into `[name, value]` string entries using path\n * notation.\n *\n * Nested objects become dotted names (`author.name`) and array items indexed\n * names (`tags[0]`). Each leaf kind is handled as follows:\n *\n * - A `string`, `number`, `boolean` or `bigint` is stringified.\n * - `null` becomes `\"\"`.\n * - A `Date` becomes the `YYYY-MM-DD` of its **UTC** calendar day (what\n *   `<input type=\"date\">` submits, and what `Schema.DateFromString` decodes\n *   back to UTC midnight); the time of day is dropped, so a datetime needs its\n *   own string field. An invalid `Date` is omitted.\n * - A `Blob` or `File` is omitted here, since a string entry can't carry it;\n *   {@link objectToFormData} keeps it.\n * - An `undefined`, `function` or `symbol` is omitted, as `JSON.stringify`\n *   omits such object properties, so a callback or symbol left in form data\n *   never reaches the form body as `\"Symbol(…)\"` or function source.\n * - Any other object contributes its own enumerable fields, so one with none\n *   (a `Map`, a `Set`, an empty object) contributes no entries.\n *\n * An omitted array item leaves a gap (where `JSON.stringify` would write\n * `null`), so the remaining items keep their indices (`tags[0]`, `tags[2]`).\n */\nexport function objectToEntries(data: unknown, prefix = \"\"): Array<[string, string]> {\n  return toBodyEntries(data, prefix).filter((entry): entry is [string, string] =>\n    Predicate.isString(entry[1]),\n  );\n}\n\n/**\n * Serialise the store's data into a {@link FormData} body for submission.\n *\n * Names and leaves follow {@link objectToEntries}, except that a `Blob` or\n * `File` leaf is appended as a file (a `File` keeps its name; a bare `Blob`\n * arrives as a `File` named `\"blob\"`, the `FormData` default), as an\n * `<input type=\"file\">` would submit it, so it reaches the core's\n * `FormData.formDataToObject` (`@thomasfosterau/effect-forms`) unchanged.\n */\nexport function objectToFormData(data: unknown): FormData {\n  const formData = new FormData();\n  Arr.forEach(toBodyEntries(data, \"\"), ([key, value]) => formData.append(key, value));\n  return formData;\n}\n\n/**\n * Whether a value looks like a {@link FormActionResult} (carries a known\n * `_tag`). Only the tag is checked: `A` / `Message` are the caller's declared\n * expectation of the server's response, not verified here.\n */\nfunction isActionResult<A, Message>(value: unknown): value is FormActionResult<A, Message> {\n  return (\n    Predicate.isObjectOrArray(value) &&\n    Predicate.hasProperty(value, \"_tag\") &&\n    Predicate.isString(value._tag) &&\n    [\"Success\", \"Failure\", \"Redirect\", \"Error\"].includes(value._tag)\n  );\n}\n\n/**\n * Whether a value looks like a bare {@link FormState}. Only the keys are\n * checked: `A` / `Message` are the caller's declared expectation, not verified.\n */\nfunction isFormState<A, Message>(value: unknown): value is FormState<A, Message> {\n  return (\n    Predicate.isObjectOrArray(value) && \"valid\" in value && \"data\" in value && \"errors\" in value\n  );\n}\n\n/**\n * Normalise a parsed JSON response body into a {@link FormActionResult}. The\n * server may return a full action result (`{ _tag, … }`) or a bare\n * {@link FormState} — a bare state maps to `Success` / `Failure` by its `valid`\n * flag, using `status` for the failure code.\n */\nexport function parseActionResult<A, Message>(\n  body: unknown,\n  status = 200,\n): FormActionResult<A, Message> {\n  if (isActionResult<A, Message>(body)) return body;\n  if (isFormState<A, Message>(body)) {\n    return body.valid ? success(body, status) : failure(body, status);\n  }\n  return { _tag: \"Error\", status, message: \"Unrecognised form response\" };\n}\n\n/** The mutation a {@link FormActionResult} implies for the store. */\nexport interface FormUpdate<A, Message> {\n  readonly data?: A | undefined;\n  readonly errors?: FormErrors | undefined;\n  readonly message?: Message | undefined;\n  readonly redirect?: string | undefined;\n  readonly error?: string | undefined;\n  readonly valid?: boolean | undefined;\n}\n\n/**\n * Compute the store update implied by a {@link FormActionResult}. Pure: the\n * caller applies the returned fields to its reactive state and acts on\n * `redirect` / `error`.\n */\nexport function resultToUpdate<A, Message>(\n  result: FormActionResult<A, Message>,\n): FormUpdate<A, Message> {\n  return Match.valueTags(result, {\n    Success: ({ state }): FormUpdate<A, Message> => ({\n      data: state.data,\n      errors: state.errors,\n      message: state.message,\n      valid: true,\n    }),\n    Failure: ({ state }): FormUpdate<A, Message> => ({\n      data: state.data,\n      errors: state.errors,\n      message: state.message,\n      valid: false,\n    }),\n    Redirect: ({ location }): FormUpdate<A, Message> => ({ redirect: location }),\n    Error: ({ message }): FormUpdate<A, Message> => ({ error: message, valid: false }),\n  });\n}\n\n/** How a successful/failed submit's data should land on `data` and the tainted baseline. */\nexport interface DataApplication<A> {\n  /** The next value for `data`, or `undefined` to leave it untouched (an auto-submit keeps local edits). */\n  readonly data: A | undefined;\n  /** The next tainted baseline (`#initial`), or `undefined` when this isn't a successful submit. */\n  readonly rebaseTo: A | undefined;\n}\n\n/**\n * Decide how a submit result's data applies to the store, given a defined\n * `update.data` (redirects/errors never reach this — see {@link resultToUpdate}).\n * Pure so the save-then-navigate baseline rebase is unit-testable without\n * compiling the rune store: on a successful submit the tainted baseline\n * rebases to whatever was actually persisted, so `isTainted` goes back to\n * `false` for values that were just saved, not just the original seed. An\n * auto-submitting (live-save) form keeps its local `data` as the source of\n * truth while a request is in flight — adopting the server's echo would\n * discard keystrokes made during the round-trip — but on success rebases to\n * `submittedData` (the snapshot actually sent), not the live value, since the\n * user may have typed further edits that haven't been submitted yet.\n */\nexport function computeDataApplication<A>(params: {\n  readonly isSuccess: boolean;\n  readonly appliedData: A;\n  readonly initial: A;\n  readonly submittedData: A;\n  readonly resetForm: boolean;\n  readonly autoSubmit: boolean;\n}): DataApplication<A> {\n  const { isSuccess, appliedData, initial, submittedData, resetForm, autoSubmit } = params;\n  if (resetForm && isSuccess) return { data: initial, rebaseTo: initial };\n  if (autoSubmit) return { data: undefined, rebaseTo: isSuccess ? submittedData : undefined };\n  return { data: appliedData, rebaseTo: isSuccess ? appliedData : undefined };\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAqBA,MAAM,EAAE,SAAS,YAAY;;;;;AAS7B,MAAM,UAAU,UACd,CAAC,UAAU,YAAY,WAAW,IAAI,KAAK,iBAAiB;;;;;;;;AAS9D,MAAM,cAAc,UAAoC;CACtD,IAAI,OAAO,MAAM,MAAM,QAAQ,CAAC,GAAG,OAAO,KAAA;CAC1C,MAAM,MAAM,MAAM,YAAY;CAC9B,OAAO,IAAI,MAAM,GAAG,IAAI,QAAQ,GAAG,CAAC;AACtC;;AAGA,SAAS,cAAc,KAAuB,KAAa,OAAsB;CAC/E,IAAI,UAAU,MACZ,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;MACb,IAAI,OAAO,KAAK,GACrB,IAAI,KAAK,CAAC,KAAK,KAAK,CAAC;MAChB,IAAI,iBAAiB,MAAM;EAChC,MAAM,UAAU,WAAW,KAAK;EAChC,IAAI,YAAY,KAAA,GAAW,IAAI,KAAK,CAAC,KAAK,OAAO,CAAC;CACpD,OAAO,IAAI,MAAM,QAAQ,KAAK,GAC5B,MAAM,SAAS,MAAM,MAAM,cAAc,KAAK,GAAG,IAAI,GAAG,EAAE,IAAI,IAAI,CAAC;MAC9D,IAAI,UAAU,SAAS,KAAK,GACjC,aAAa,KAAK,OAAO,GAAG;MACvB,IACL,UAAU,SAAS,KAAK,KACxB,UAAU,SAAS,KAAK,KACxB,UAAU,UAAU,KAAK,KACzB,UAAU,SAAS,KAAK,GAExB,IAAI,KAAK,CAAC,KAAK,OAAO,KAAK,CAAC,CAAC;AAGjC;;AAGA,SAAS,aACP,KACA,MACA,QACM;CACN,IAAI,QAAQ,OAAO,UAAU,IAAI,IAAI,CAAC,KAAK,WACzC,cAAc,KAAK,SAAS,GAAG,OAAO,GAAG,QAAQ,KAAK,KAAK,CAC7D;AACF;;AAGA,SAAS,cAAc,MAAe,QAAkC;CACtE,MAAM,MAAwB,CAAC;CAC/B,IAAI,QAAQ,cAAc,KAAK,QAAQ,IAAI;MACtC,IAAI,UAAU,SAAS,IAAI,GAC9B,aAAa,KAAK,MAAM,EAAE;CAE5B,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,gBAAgB,MAAe,SAAS,IAA6B;CACnF,OAAO,cAAc,MAAM,MAAM,CAAC,CAAC,QAAQ,UACzC,UAAU,SAAS,MAAM,EAAE,CAC7B;AACF;;;;;;;;;;AAWA,SAAgB,iBAAiB,MAAyB;CACxD,MAAM,WAAW,IAAI,SAAS;CAC9B,IAAI,QAAQ,cAAc,MAAM,EAAE,IAAI,CAAC,KAAK,WAAW,SAAS,OAAO,KAAK,KAAK,CAAC;CAClF,OAAO;AACT;;;;;;AAOA,SAAS,eAA2B,OAAuD;CACzF,OACE,UAAU,gBAAgB,KAAK,KAC/B,UAAU,YAAY,OAAO,MAAM,KACnC,UAAU,SAAS,MAAM,IAAI,KAC7B;EAAC;EAAW;EAAW;EAAY;CAAO,CAAC,CAAC,SAAS,MAAM,IAAI;AAEnE;;;;;AAMA,SAAS,YAAwB,OAAgD;CAC/E,OACE,UAAU,gBAAgB,KAAK,KAAK,WAAW,SAAS,UAAU,SAAS,YAAY;AAE3F;;;;;;;AAQA,SAAgB,kBACd,MACA,SAAS,KACqB;CAC9B,IAAI,eAA2B,IAAI,GAAG,OAAO;CAC7C,IAAI,YAAwB,IAAI,GAC9B,OAAO,KAAK,QAAQ,QAAQ,MAAM,MAAM,IAAI,QAAQ,MAAM,MAAM;CAElE,OAAO;EAAE,MAAM;EAAS;EAAQ,SAAS;CAA6B;AACxE;;;;;;AAiBA,SAAgB,eACd,QACwB;CACxB,OAAO,MAAM,UAAU,QAAQ;EAC7B,UAAU,EAAE,aAAqC;GAC/C,MAAM,MAAM;GACZ,QAAQ,MAAM;GACd,SAAS,MAAM;GACf,OAAO;EACT;EACA,UAAU,EAAE,aAAqC;GAC/C,MAAM,MAAM;GACZ,QAAQ,MAAM;GACd,SAAS,MAAM;GACf,OAAO;EACT;EACA,WAAW,EAAE,gBAAwC,EAAE,UAAU,SAAS;EAC1E,QAAQ,EAAE,eAAuC;GAAE,OAAO;GAAS,OAAO;EAAM;CAClF,CAAC;AACH;;;;;;;;;;;;;;AAuBA,SAAgB,uBAA0B,QAOnB;CACrB,MAAM,EAAE,WAAW,aAAa,SAAS,eAAe,WAAW,eAAe;CAClF,IAAI,aAAa,WAAW,OAAO;EAAE,MAAM;EAAS,UAAU;CAAQ;CACtE,IAAI,YAAY,OAAO;EAAE,MAAM,KAAA;EAAW,UAAU,YAAY,gBAAgB,KAAA;CAAU;CAC1F,OAAO;EAAE,MAAM;EAAa,UAAU,YAAY,cAAc,KAAA;CAAU;AAC5E"}

package/dist/EntityForm.d.ts

@@ -1,7 +1,6 @@
 import { Command } from "@thomasfosterau/effect-forms";
 import * as Schema from "effect/Schema";
 import { Component } from "svelte";
-//#region src/EntityForm.d.ts
 /** A render-time message thunk — pass the message function itself, uncalled. */
 export type MessageThunk = () => string;
 /** Presentation options for a scalar text entry. */
@@ -153,5 +152,4 @@ export interface DefineEntityFormOptions<C extends CommandStructLike, U extends
  * key — a command-struct change must surface here, at definition time.
  */
 export declare const defineEntityForm: <C extends CommandStructLike, U extends CommandStructLike>(options: DefineEntityFormOptions<C, U>, build: (f: EntryBuilders<CommandKeys<C, U>>) => readonly EntityFormEntry[]) => EntityFormDefinition;
-//#endregion
 //# sourceMappingURL=EntityForm.d.ts.map

package/dist/EntityForm.js

@@ -1,6 +1,12 @@
 import { Command } from "@thomasfosterau/effect-forms";
+import * as Arr from "effect/Array";
+import * as Predicate from "effect/Predicate";
+import * as Record from "effect/Record";
+import * as HashMap from "effect/HashMap";
+import * as HashSet from "effect/HashSet";
+import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
-//#region src/EntityForm.ts
+// src/EntityForm.ts
 const builders = {
 	text: (key, options) => ({
 		_tag: "scalar",
@@ -37,15 +43,22 @@ const builders = {
 	})
 };
 /**
+* A definition-time error: the entries don't match the command structs. Thrown
+* synchronously from `defineEntityForm` (and `fieldFor`), never as an Effect
+* failure — a definition module that doesn't match its commands must fail at
+* import.
+*/
+var EntityFormDefinitionError = class extends Schema.TaggedError()("EntityFormDefinitionError", { message: Schema.String }) {};
+/**
 * Validate an `f.select` entry against its plan field at definition time: the
 * field must be `enum`-kind (the only kind `Command.plan` derives option
 * values for), and every derived value must have a matching `optionLabels`
 * thunk.
 */
 const validateSelectEntry = (entry, field) => {
-	if (field.kind !== "enum") throw new Error(`defineEntityForm: entry "${entry.key}" is f.select but its command field is "${field.kind}"-kind, not enum`);
+	if (field.kind !== "enum") throw new EntityFormDefinitionError({ message: `defineEntityForm: entry "${entry.key}" is f.select but its command field is "${field.kind}"-kind, not enum` });
 	const missingLabels = (field.options ?? []).filter((value) => !Object.prototype.hasOwnProperty.call(entry.options.optionLabels, value));
-	if (missingLabels.length > 0) throw new Error(`defineEntityForm: entry "${entry.key}" is missing optionLabels for: ${missingLabels.join(", ")}`);
+	if (Arr.isReadonlyArrayNonEmpty(missingLabels)) throw new EntityFormDefinitionError({ message: `defineEntityForm: entry "${entry.key}" is missing optionLabels for: ${missingLabels.join(", ")}` });
 };
 /**
 * Build an entity-form definition from a command-struct pair and an ordered
@@ -54,30 +67,21 @@ const validateSelectEntry = (entry, field) => {
 * key — a command-struct change must surface here, at definition time.
 */
 const defineEntityForm = (options, build) => {
-	const omitted = new Set(options.omit ?? []);
-	const withoutOmitted = (struct) => {
-		if (omitted.size === 0) return struct;
-		const fields = {};
-		for (const key in struct.fields) if (!omitted.has(key)) fields[key] = struct.fields[key];
-		return { fields };
-	};
+	const omitted = HashSet.fromIterable(options.omit ?? []);
+	const withoutOmitted = (struct) => HashSet.size(omitted) === 0 ? struct : { fields: Record.filter(struct.fields, (_, key) => !HashSet.has(omitted, key)) };
 	const plan = Command.plan(withoutOmitted(options.create), withoutOmitted(options.update));
 	const entries = build(builders);
-	const byKey = new Map(plan.fields.map((field) => [field.key, field]));
-	const declared = /* @__PURE__ */ new Set();
-	for (const entry of entries) {
-		const field = byKey.get(entry.key);
-		if (field === void 0) throw new Error(`defineEntityForm: entry "${entry.key}" is not a field of either command struct`);
-		if (declared.has(entry.key)) throw new Error(`defineEntityForm: entry "${entry.key}" is declared twice`);
-		declared.add(entry.key);
-		if (entry._tag === "select") validateSelectEntry(entry, field);
-	}
-	const missing = plan.fields.filter((field) => !declared.has(field.key)).map((field) => field.key);
-	if (missing.length > 0) throw new Error(`defineEntityForm: command fields not declared by any entry: ${missing.join(", ")} — declare or explicitly widget them`);
-	const entriesFor = (mode) => entries.filter((entry) => {
-		const field = byKey.get(entry.key);
-		return field !== void 0 && (mode === "create" ? field.inCreate : field.inUpdate);
+	const byKey = HashMap.fromIterable(Arr.map(plan.fields, (field) => [field.key, field]));
+	const declared = Arr.reduce(entries, HashSet.empty(), (seen, entry) => {
+		const field = HashMap.get(byKey, entry.key);
+		if (Option.isNone(field)) throw new EntityFormDefinitionError({ message: `defineEntityForm: entry "${entry.key}" is not a field of either command struct` });
+		if (HashSet.has(seen, entry.key)) throw new EntityFormDefinitionError({ message: `defineEntityForm: entry "${entry.key}" is declared twice` });
+		if (Predicate.isTagged(entry, "select")) validateSelectEntry(entry, field.value);
+		return HashSet.add(seen, entry.key);
 	});
+	const missing = Arr.map(Arr.filter(plan.fields, (field) => !HashSet.has(declared, field.key)), (field) => field.key);
+	if (Arr.isReadonlyArrayNonEmpty(missing)) throw new EntityFormDefinitionError({ message: `defineEntityForm: command fields not declared by any entry: ${missing.join(", ")} — declare or explicitly widget them` });
+	const entriesFor = (mode) => Arr.filter(entries, (entry) => Option.exists(HashMap.get(byKey, entry.key), (field) => mode === "create" ? field.inCreate : field.inUpdate));
 	return {
 		plan,
 		entries,
@@ -90,14 +94,9 @@ const defineEntityForm = (options, build) => {
 		submit: options.submit,
 		clientId: plan.clientId,
 		entriesFor,
-		fieldFor: (key) => {
-			const field = byKey.get(key);
-			if (field === void 0) throw new Error(`EntityFormDefinition: unknown field "${key}"`);
-			return field;
-		}
+		fieldFor: (key) => Option.getOrThrowWith(HashMap.get(byKey, key), () => new EntityFormDefinitionError({ message: `EntityFormDefinition: unknown field "${key}"` }))
 	};
 };
-//#endregion
 export { defineEntityForm };
 
 //# sourceMappingURL=EntityForm.js.map