@thomasfosterau/effect-forms 0.0.0

package/dist/index.js

@@ -0,0 +1,1768 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+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 Duration from "effect/Duration";
+//#region src/Coerce.ts
+var Coerce_exports = /* @__PURE__ */ __exportAll({
+	booleanFromCheckbox: () => booleanFromCheckbox,
+	emptyToNull: () => emptyToNull,
+	emptyToUndefined: () => emptyToUndefined,
+	numberFromField: () => numberFromField,
+	trimToNull: () => trimToNull,
+	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
+* arrives as `undefined` (or an empty string). Mapping that onto a
+* value / `null` / `undefined` update contract — where a value **sets**, `null`
+* **clears** a nullable field, and `undefined` **skips** (carry-forward) — is
+* the same boundary discipline the host app applies, lifted here so any
+* consumer of the core gets it without a framework dependency.
+*
+* These are plain, total functions: they never throw and never reach for a
+* framework's `error()` helper (validation failures belong on the schema, not
+* in a coercer).
+*
+* @module effect-forms/Coerce
+*/
+/** Empty string / `undefined` → `undefined`; otherwise the value (skip semantics). */
+function emptyToUndefined(value) {
+	return value === "" || value === void 0 ? void 0 : value;
+}
+/**
+* `undefined` stays `undefined` (skip); empty string / `null` → `null`
+* (clear a nullable field); otherwise the value (set). The three-state coercer
+* for nullable update fields.
+*/
+function emptyToNull(value) {
+	if (value === void 0) return void 0;
+	if (value === "" || value === null) return null;
+	return value;
+}
+/** Trim, then {@link emptyToUndefined}: whitespace-only collapses to `undefined` (skip). */
+function trimToUndefined(value) {
+	return emptyToUndefined(value?.trim());
+}
+/** Trim, then {@link emptyToNull}: whitespace-only / blank clears (`null`). */
+function trimToNull(value) {
+	return emptyToNull(value?.trim());
+}
+function numberFromField(raw, { nullable }) {
+	const coerced = nullable ? emptyToNull(raw) : emptyToUndefined(raw);
+	return typeof coerced === "string" ? Number(coerced) : coerced;
+}
+/**
+* Interpret a checkbox field. An HTML checkbox submits its `value` (default
+* `"on"`) only when checked and omits the field entirely when unchecked, so a
+* present field is `true` and an absent one is `false`. The truthy strings
+* `"on"` / `"true"` / `"1"` / `"yes"` all read as `true`; an explicit
+* `"false"` / `"0"` / `"off"` / `"no"` reads as `false`.
+*/
+function booleanFromCheckbox(raw) {
+	if (raw === void 0) return false;
+	const normalised = raw.trim().toLowerCase();
+	return !(normalised === "" || normalised === "false" || normalised === "0" || normalised === "off" || normalised === "no");
+}
+//#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
+* entity — a create struct (required fields bare, the rest `optional`) and an
+* update struct (keyed by a required `id`, every field `optional`, clearable
+* fields `optional(NullOr(...))` carrying the value / `null` / `undefined`
+* tri-state). This module reads that pair into a plain-data {@link CommandPlan}
+* and derives the three per-entity form artefacts that were previously
+* hand-written per entity: the all-string Form-Input schema fields, the blank
+* defaults, and the tri-state adapters that map a validated multipart input
+* onto the encoded command payload.
+*
+* Classification leads with behavioural decode probes — date codecs are
+* transformations and branded ids erase to `String`, so "what does this
+* schema accept" is the only robust signal for those (the same approach the
+* host app's model walkers use). Two kinds fall back to AST matching instead,
+* because no decode probe can name what they are: `enum`'s literal option set
+* (needed anyway for the renderer, not just the classification) and
+* `structured`'s "this is a nested object, not a scalar" shape. Neither
+* shadows a probe-classified kind — see {@link classify}.
+*
+* The derived adapters emit the **encoded** command payload (dates stay
+* `YYYY-MM-DD` strings, ids stay plain strings) — the command's canonical
+* decode downstream owns branding and validation. Genuinely irregular fields
+* (a create-time default, an asymmetric coercion) stay expressible via the
+* per-field {@link AdaptOverrides} escape hatch instead of forcing ejection.
+*
+* @module effect-forms/Command
+*/
+var Command_exports = /* @__PURE__ */ __exportAll({
+	blankDefaults: () => blankDefaults,
+	createAdapter: () => createAdapter,
+	formInputFields: () => formInputFields,
+	jsonRowsFromField: () => jsonRowsFromField,
+	plan: () => plan,
+	updateAdapter: () => updateAdapter
+});
+/**
+* Run one decode probe: whether the schema accepts the input, plus the decoded
+* value for instance checks (the date probe needs to see a `Date` come out,
+* not just a successful decode).
+*/
+const probe = (schema, input) => {
+	try {
+		return {
+			ok: true,
+			value: Schema.decodeUnknownSync(schema)(input)
+		};
+	} catch {
+		return { ok: false };
+	}
+};
+/** True when a schema decodes the given input without throwing. */
+const decodes = (schema, input) => probe(schema, input).ok;
+/** A syntactically valid UUID no other field kind accepts as non-text. */
+const PROBE_UUID = "9f8c1c2e-4b3a-4c5d-8e6f-0a1b2c3d4e5f";
+/**
+* Peel exactly the `optional` / `NullOr` wrapper layers off a property's type
+* AST, stopping at the first union that isn't itself a pure wrapper. A wrapper
+* union carries exactly one non-`null`/`undefined` member (the wrapped type);
+* a union with zero or several such members is a real value-level union (an
+* `enum` field's own literal set, say) rather than another layer to peel, so
+* the loop stops there. Unlike {@link module:effect-forms/Constraints}'s
+* `unwrapOptional` (which only ever needs the *first* real member), this
+* walks every wrapper layer and preserves a multi-member union intact —
+* `enumOptions` below needs the full literal set, not just one branch of it.
+*/
+function unwrapWrapperUnion(ast) {
+	let current = ast;
+	while (SchemaAST.isUnion(current)) {
+		const real = current.types.filter((t) => !SchemaAST.isUndefined(t) && !SchemaAST.isNull(t));
+		if (real.length !== 1 || real.length === current.types.length) break;
+		current = real[0];
+	}
+	return current;
+}
+/**
+* The literal option values of a field shaped like `Schema.Literal(...)` or
+* `Schema.Literals([...])` (optionally `optional` / `NullOr`-wrapped) —
+* `undefined` when the field isn't literal-shaped. Stringified: a `<select>`'s
+* option values are strings at the form boundary regardless of the literal's
+* own type.
+*/
+function enumOptions(ast) {
+	const inner = unwrapWrapperUnion(ast);
+	if (SchemaAST.isLiteral(inner)) return [String(inner.literal)];
+	if (SchemaAST.isUnion(inner)) {
+		const literals = inner.types.filter(SchemaAST.isLiteral);
+		if (literals.length === inner.types.length && literals.length > 0) return literals.map((literal) => String(literal.literal));
+	}
+}
+/**
+* Whether a field is itself an object/struct schema (optionally `optional` /
+* `NullOr`-wrapped) — the `structured` kind's shape (inline / block ProseKit
+* JSON: `{ type, content }`). Mirrors {@link module:effect-forms/Field}'s and
+* {@link module:effect-forms/Constraints}'s own `SchemaAST.isObjects` struct
+* check. A `Schema.declare`d type (`UploadedDocument`, `Image`) has no
+* `Objects` AST node, so it is never caught here — the default-throw the
+* derivation relies on stays intact.
+*/
+function isStructured(ast) {
+	return SchemaAST.isObjects(unwrapWrapperUnion(ast));
+}
+/**
+* The scalar kinds classified purely by what a schema decodes, with no AST
+* inspection: array → boolean → number → date → id → text. `undefined` when
+* the schema accepts none of them, so {@link classify} can fall through to
+* its AST-based checks (`enum`, `structured`).
+*/
+const probeKind = (schema) => {
+	if (decodes(schema, [])) return "jsonArray";
+	if (decodes(schema, true)) return "boolean";
+	if (decodes(schema, 42)) return "number";
+	const date = probe(schema, "2024-01-02T03:04:05.000Z");
+	if (date.ok && date.value instanceof Date) return "date";
+	if (decodes(schema, PROBE_UUID) && !decodes(schema, "not-a-uuid")) return "id";
+	if (decodes(schema, "plain text")) return "text";
+};
+/**
+* Classify one field schema: by its AST shape first, then by what it accepts.
+* `enum` is checked before {@link probeKind} rather than after, since a
+* decode probe can't tell "the literal set an enum accepts" from any other
+* shape (worse, a numeric-literal enum whose set happens to include the `42`
+* probe value would otherwise misclassify as `number`) — reading the literal
+* set off the AST is unambiguous, and it's needed anyway for the renderer.
+* `structured` is checked last, after every probe has failed: an object
+* schema never decodes any of `probeKind`'s scalar probes, so there is no
+* real ordering hazard, but putting the broadest, AST-only check last keeps
+* every more specific kind first in line. A field that matches nothing
+* (`Schema.declare`d — `UploadedDocument`, `Image`) throws at module load so
+* the gap surfaces when the plan is declared, not on a live submission.
+*/
+const classify = (key, schema) => {
+	const options = enumOptions(schema.ast);
+	if (options !== void 0) return {
+		kind: "enum",
+		options
+	};
+	const probed = probeKind(schema);
+	if (probed !== void 0) return { kind: probed };
+	if (isStructured(schema.ast)) return { kind: "structured" };
+	throw new Error(`Command.plan: field "${key}" matches no known kind (text/id/number/date/jsonArray/boolean/enum/structured) — a Schema.declare'd type needs an explicit form-level treatment before it can derive`);
+};
+/**
+* Read a create/update command struct pair into a {@link CommandPlan}.
+* Runs once at module load — probe cost is a handful of tiny decodes per
+* field, never per render or per request.
+*/
+const plan = (create, update) => {
+	const createFields = create.fields;
+	const updateFields = update.fields;
+	const keys = [];
+	for (const key in updateFields) if (key !== "id") keys.push(key);
+	for (const key in createFields) if (key !== "id" && !(key in updateFields)) keys.push(key);
+	return {
+		fields: keys.map((key) => {
+			const createField = createFields[key];
+			const updateField = updateFields[key];
+			const { kind, options } = classify(key, createField ?? updateField);
+			return {
+				key,
+				kind,
+				inCreate: createField !== void 0,
+				createRequired: createField !== void 0 && !decodes(createField, void 0),
+				inUpdate: updateField !== void 0,
+				updateClearable: updateField !== void 0 && decodes(updateField, null),
+				...options !== void 0 ? { options } : {}
+			};
+		}),
+		clientId: "id" in createFields
+	};
+};
+/**
+* Derive the all-string Form-Input schema fields for one mode — every value is
+* a string at the multipart boundary. Create-required fields get a min-length
+* check so blankness surfaces as an inline field error; the update `id` gets
+* the UUID check. Spread into `Schema.Struct({ ...Command.formInputFields(plan,
+* "create") })`, with `overrides` spread last for irregular fields.
+*/
+const formInputFields = (commandPlan, mode, overrides = {}) => {
+	const fields = {};
+	if (mode === "create" && commandPlan.clientId) fields.id = Schema.optional(Schema.String);
+	if (mode === "update") fields.id = Schema.String.check(Schema.isUUID());
+	for (const field of commandPlan.fields) {
+		if (mode === "create" ? !field.inCreate : !field.inUpdate) continue;
+		fields[field.key] = mode === "create" && field.createRequired ? Schema.String.check(Schema.isMinLength(1)) : Schema.optional(Schema.String);
+	}
+	return {
+		...fields,
+		...overrides
+	};
+};
+/**
+* Blank string defaults for one mode's Form-Input shape. Client-id entities
+* override `id` at the call site (`{ ...blankDefaults(plan, "create"), id:
+* crypto.randomUUID() }`) so retries stay idempotent.
+*/
+const blankDefaults = (commandPlan, mode) => {
+	const defaults = {};
+	if (mode === "update" || commandPlan.clientId) defaults.id = "";
+	for (const field of commandPlan.fields) {
+		if (mode === "create" ? !field.inCreate : !field.inUpdate) continue;
+		defaults[field.key] = "";
+	}
+	return defaults;
+};
+/**
+* Parse a JSON-encoded row list (a contributor list) from a multipart form
+* field. A blank or absent field yields `undefined` (skip — leave the existing
+* list untouched); an empty JSON array (`"[]"`) clears the list. Rows keep
+* `id` / `creditedName` when present; `orderingPosition` falls back to the
+* row's array index. Throws a plain `Error` on a malformed payload — mapping
+* that onto a framework response is the caller's concern.
+*/
+const jsonRowsFromField = (raw, label) => {
+	if (raw === void 0 || raw.trim() === "") return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		throw new Error(`Invalid ${label} payload — expected JSON array`);
+	}
+	if (!Array.isArray(parsed)) throw new Error(`Invalid ${label} payload — expected array`);
+	return parsed.map((row, index) => {
+		if (typeof row !== "object" || row === null) throw new Error(`Invalid ${label} entry at index ${index}`);
+		const r = row;
+		if (typeof r.agentId !== "string") throw new Error(`${label} entry at index ${index} missing agentId`);
+		return {
+			id: typeof r.id === "string" ? r.id : void 0,
+			agentId: r.agentId,
+			creditedName: typeof r.creditedName === "string" ? r.creditedName : void 0,
+			orderingPosition: typeof r.orderingPosition === "number" ? r.orderingPosition : index
+		};
+	});
+};
+/** Text fields: trim always; required create fields never skip. */
+const coerceText = (ctx, raw) => ctx.required ? (raw ?? "").trim() : ctx.clearable ? trimToNull(raw) : trimToUndefined(raw);
+/** Id fields: no trimming (pickers emit `""` or a UUID); required create FKs pass through raw. */
+const coerceId = (ctx, raw) => ctx.required ? raw : ctx.clearable ? emptyToNull(raw) : emptyToUndefined(raw);
+/** Numeric text fields: blank clears on the clearable path, skips otherwise. */
+const coerceNumber = (ctx, raw) => ctx.clearable ? numberFromField(raw, { nullable: true }) : numberFromField(raw, { nullable: false });
+/** Date fields stay encoded (`YYYY-MM-DD` strings); create trims, update passes through. */
+const coerceDate = (ctx, raw) => {
+	const value = ctx.trimCreate ? raw?.trim() : raw;
+	return ctx.clearable ? emptyToNull(value) : emptyToUndefined(value);
+};
+/**
+* Boolean fields: a `<select>`'s value set, not a checkbox — the only truthy
+* raw value is the literal string `"true"`, everything else (`"false"`,
+* blank, absent) reads as `false`. Create defaults an absent/blank field to
+* `false` (never skips); update skips absent/blank unless clearable, in which
+* case it clears (`null`) instead — the create-defaults / update-skips
+* asymmetry the Content family already hand-writes.
+*/
+const coerceBoolean = (ctx, raw) => {
+	const trimmed = raw?.trim();
+	if (trimmed === void 0 || trimmed === "") return ctx.required ? false : ctx.clearable ? null : void 0;
+	return trimmed === "true";
+};
+/**
+* Parse a JSON-encoded structured document (inline / block ProseKit JSON)
+* from a multipart field. Blank or absent skips (`undefined`) or, on the
+* clearable path, clears (`null`); a present value is `JSON.parse`d and
+* passed through as-is — shape validation is the command's own decode's job,
+* exactly as {@link jsonRowsFromField} leaves row-shape validation to itself
+* rather than duplicating it here. `JSON.parse` throws a `SyntaxError` on
+* malformed JSON, same as {@link jsonRowsFromField} does on a malformed row
+* list — mapping that onto a framework response is the caller's concern.
+*/
+const structuredFromField = (raw, clearable) => {
+	const trimmed = raw?.trim();
+	if (trimmed === void 0 || trimmed === "") return clearable ? null : void 0;
+	return JSON.parse(trimmed);
+};
+/** Build one field's {@link CoerceContext} for one mode. */
+const coerceContextFor = (field, mode) => ({
+	required: mode === "create" && field.createRequired,
+	clearable: mode === "update" && field.updateClearable,
+	trimCreate: mode === "create"
+});
+/** The default coercion for one field in one mode. */
+const coerce = (field, mode, raw) => {
+	const ctx = coerceContextFor(field, mode);
+	switch (field.kind) {
+		case "text":
+		case "enum": return coerceText(ctx, raw);
+		case "id": return coerceId(ctx, raw);
+		case "number": return coerceNumber(ctx, raw);
+		case "date": return coerceDate(ctx, raw);
+		case "jsonArray": return jsonRowsFromField(raw, field.key);
+		case "boolean": return coerceBoolean(ctx, raw);
+		case "structured": return structuredFromField(raw, ctx.clearable);
+	}
+};
+/**
+* Derive the create adapter: validated all-string input → encoded create
+* command payload. `overrides` replace the default per-field coercion for
+* genuinely irregular fields (e.g. a create-time fallback default).
+*/
+const createAdapter = (commandPlan, overrides = {}) => (input) => {
+	const out = {};
+	if (commandPlan.clientId) out.id = trimToUndefined(input.id);
+	for (const field of commandPlan.fields) {
+		if (!field.inCreate) continue;
+		const override = overrides[field.key];
+		out[field.key] = override ? override(input[field.key]) : coerce(field, "create", input[field.key]);
+	}
+	return out;
+};
+/**
+* Derive the update adapter: validated all-string input → encoded update
+* command payload (value sets, `null` clears a clearable field, `undefined`
+* skips). The required `id` passes through as-is — the command's canonical
+* decode brands it.
+*/
+const updateAdapter = (commandPlan, overrides = {}) => (input) => {
+	const out = { id: input.id };
+	for (const field of commandPlan.fields) {
+		if (!field.inUpdate) continue;
+		const override = overrides[field.key];
+		out[field.key] = override ? override(input[field.key]) : coerce(field, "update", input[field.key]);
+	}
+	return out;
+};
+//#endregion
+//#region src/Constraints.ts
+var Constraints_exports = /* @__PURE__ */ __exportAll({
+	constraintAt: () => constraintAt,
+	constraintsFromSchema: () => constraintsFromSchema,
+	isLeafConstraint: () => isLeafConstraint
+});
+/** Whether a node in an {@link InputConstraints} tree is a leaf ({@link InputConstraint}) rather than a branch. */
+const isLeafConstraint = (value) => "required" in value || "min" in value || "max" in value || "minlength" in value || "maxlength" in value || "pattern" in value || "step" in value;
+/** Whether a property's type AST is optional (so the field is not required). */
+const isOptional = (type) => type.context?.isOptional === true;
+/**
+* Unwrap an `optional` / `NullOr` union the way {@link module:effect-forms/Field}'s
+* `fromAst` does: recurse into the first member that isn't a bare `undefined`
+* / `null` literal, so a wrapped struct / array / refined leaf still yields
+* its own shape instead of falling through to an empty constraint.
+*/
+function unwrapOptional(type) {
+	if (!SchemaAST.isUnion(type)) return type;
+	for (const member of type.types) {
+		if (SchemaAST.isUndefined(member) || SchemaAST.isNull(member)) continue;
+		return unwrapOptional(member);
+	}
+	return type;
+}
+/** Flatten a `Checks` array (recursing into `FilterGroup`s) into individual filters. */
+function flattenChecks(checks, out) {
+	if (!checks) return;
+	for (const check of checks) if (check._tag === "FilterGroup") flattenChecks(check.checks, out);
+	else out.push(check);
+}
+/**
+* One constraint patch per recognised representation id — the built-in
+* checks that map onto a native HTML attribute. An id with no entry here
+* (an unannotated custom filter, or a built-in check with no HTML
+* equivalent) derives nothing. `isInt` isn't a plain patch: it only sets
+* `step` as a fallback when nothing more specific already did, so it's
+* handled separately in {@link constraintFromChecks}.
+*/
+const payloadPatches = {
+	"effect/schema/isMinLength": (p) => ({ minlength: p.minLength }),
+	"effect/schema/isMaxLength": (p) => ({ maxlength: p.maxLength }),
+	"effect/schema/isLengthBetween": (p) => ({
+		minlength: p.minimum,
+		maxlength: p.maximum
+	}),
+	"effect/schema/isPattern": (p) => ({ pattern: p.source }),
+	"effect/schema/isGreaterThan": (p) => ({ min: p.exclusiveMinimum }),
+	"effect/schema/isGreaterThanOrEqualTo": (p) => ({ min: p.minimum }),
+	"effect/schema/isLessThan": (p) => ({ max: p.exclusiveMaximum }),
+	"effect/schema/isLessThanOrEqualTo": (p) => ({ max: p.maximum }),
+	"effect/schema/isBetween": (p) => ({
+		min: p.minimum,
+		max: p.maximum
+	}),
+	"effect/schema/isMultipleOf": (p) => ({ step: p.divisor })
+};
+/**
+* Look up and apply `payloadPatches[representation.id]`. The cast is sound:
+* each payload is authored by the same built-in check constructor its id
+* names, so an entry is never called with a mismatched payload shape.
+*/
+function applyPayloadPatch(representation) {
+	const patch = payloadPatches[representation.id];
+	return patch?.(representation.payload);
+}
+/**
+* Derive an {@link InputConstraint}'s refinement attributes from the checks
+* attached to `outer` (the property's own type, e.g. the union wrapping an
+* optional field) and `inner` (the unwrapped leaf) — `inner`'s checks win on
+* conflict since they're the more specific, unwrapped node. A check whose
+* `representation` annotation has no recognised id (an unannotated custom
+* filter) is skipped: there is no attribute to derive from it.
+*/
+function constraintFromChecks(outer, inner) {
+	const filters = [];
+	flattenChecks(outer.checks, filters);
+	if (inner !== outer) flattenChecks(inner.checks, filters);
+	let out = {};
+	let hasIntCheck = false;
+	for (const filter of filters) {
+		const representation = filter.annotations?.representation;
+		if (!representation) continue;
+		if (representation.id === "effect/schema/isInt") {
+			hasIntCheck = true;
+			continue;
+		}
+		out = {
+			...out,
+			...applyPayloadPatch(representation)
+		};
+	}
+	if (hasIntCheck && out.step === void 0) out.step = 1;
+	return out;
+}
+/**
+* Whether `ast` is a homogeneous array/list — `Schema.Array(item)` or
+* `Schema.NonEmptyArray(item)` — as opposed to a fixed-shape tuple with
+* differently-typed positional elements. Only a homogeneous array has a
+* single item schema to descend into; a tuple's elements each need their own
+* constraint, which this leaf-per-key tree can't represent, so it's left to
+* `overrides`.
+*/
+function homogeneousItem(ast) {
+	if (ast.rest.length !== 1) return void 0;
+	const [item] = ast.rest;
+	if (ast.elements.length === 0) return item;
+	if (ast.elements.length === 1 && ast.elements[0] === item) return item;
+}
+/**
+* Derive the constraint (or nested tree) for one property/item type: a
+* struct descends into its properties, a homogeneous array descends into its
+* item type (the array's own length checks have no native equivalent for a
+* repeated field, so they're not derived) while folding the array's own
+* optionality into the item's `required`, and anything else is a leaf whose
+* `required` comes from optionality and whose refinement attributes come
+* from {@link constraintFromChecks}.
+*/
+function constraintsForType(type) {
+	const required = !isOptional(type);
+	const inner = unwrapOptional(type);
+	if (SchemaAST.isObjects(inner)) return constraintsForObjects(inner);
+	if (SchemaAST.isArrays(inner)) {
+		const item = homogeneousItem(inner);
+		if (!item) return { required };
+		const itemConstraints = constraintsForType(item);
+		return isLeafConstraint(itemConstraints) ? {
+			...itemConstraints,
+			required: required && itemConstraints.required !== false
+		} : itemConstraints;
+	}
+	return {
+		required,
+		...constraintFromChecks(type, inner)
+	};
+}
+/** Build the constraint tree for one object AST node. */
+function constraintsForObjects(ast) {
+	const out = {};
+	for (const ps of ast.propertySignatures) out[String(ps.name)] = constraintsForType(ps.type);
+	return out;
+}
+/** Deep-merge constraint overrides over a derived tree. */
+function mergeConstraints(base, overrides) {
+	const out = { ...base };
+	for (const key of Object.keys(overrides)) {
+		const override = overrides[key];
+		if (override === void 0) continue;
+		const existing = out[key];
+		if (existing !== void 0 && !isLeafConstraint(existing) && !isLeafConstraint(override)) out[key] = mergeConstraints(existing, override);
+		else if (existing !== void 0 && isLeafConstraint(existing) && isLeafConstraint(override)) out[key] = {
+			...existing,
+			...override
+		};
+		else out[key] = override;
+	}
+	return out;
+}
+/**
+* Derive the {@link InputConstraints} for a struct schema. Non-struct schemas
+* yield an empty tree. `overrides` (deep-merged over the derived tree, and
+* winning on conflict) is the seam for anything the AST walk does not infer.
+*/
+function constraintsFromSchema(schema, overrides = {}) {
+	const ast = schema.ast;
+	return mergeConstraints(SchemaAST.isObjects(ast) ? constraintsForObjects(ast) : {}, overrides);
+}
+/**
+* Read the {@link InputConstraint} leaf at `path` in an {@link InputConstraints}
+* tree, defaulting to `{}` when `path` has no derived constraints. Array
+* indices in `path` are skipped rather than descended into — the tree has no
+* per-item nodes to index into, since {@link constraintsForType} derives one
+* constraint (or branch) per *field*, shared by every item at that field. A
+* bare item path (`tags[0]`) resolves to that shared leaf; a path that
+* continues past the index into a struct item's own field (`items[0].label`)
+* skips the index and resolves straight to `label`'s derived constraint.
+*/
+function constraintAt(constraints, path) {
+	let node = constraints;
+	for (const segment of path) {
+		if (typeof segment === "number") continue;
+		if (node === void 0 || isLeafConstraint(node)) return {};
+		node = node[segment];
+	}
+	return node !== void 0 && isLeafConstraint(node) ? node : {};
+}
+//#endregion
+//#region src/FormData.ts
+var FormData_exports = /* @__PURE__ */ __exportAll({
+	formDataToObject: () => formDataToObject,
+	parseFieldPath: () => parseFieldPath,
+	requestToObject: () => requestToObject
+});
+/**
+* Split a flat field name into its path tokens. Supports dot notation
+* (`a.b`), bracket notation (`a[b]`, `a[0]`), and the trailing append form
+* (`a[]`, represented by an empty-string token). `"a[b][0]"` → `["a","b","0"]`;
+* `"a.b[]"` → `["a","b",""]`.
+*/
+function parseFieldPath(name) {
+	const tokens = [];
+	let buffer = "";
+	let inBracket = false;
+	for (const char of name) if (char === "[") {
+		if (buffer !== "") tokens.push(buffer);
+		buffer = "";
+		inBracket = true;
+	} else if (char === "]") {
+		tokens.push(buffer);
+		buffer = "";
+		inBracket = false;
+	} else if (char === "." && !inBracket) {
+		if (buffer !== "") tokens.push(buffer);
+		buffer = "";
+	} else buffer += char;
+	if (buffer !== "") tokens.push(buffer);
+	return tokens.length > 1 && tokens[0] === "" ? tokens.slice(1) : tokens;
+}
+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;
+};
+const getFromContainer = (container, token) => Array.isArray(container) ? container[Number(token)] : container[token];
+/** Assign `value` deep into `root` along `tokens`, creating containers as needed. */
+function assign(root, tokens, value) {
+	let node = root;
+	for (let i = 0; i < tokens.length - 1; i++) {
+		const token = tokens[i];
+		const nextToken = tokens[i + 1];
+		let child = token === "" ? void 0 : getFromContainer(node, token);
+		if (child === void 0 || typeof child !== "object" || child === null) {
+			child = makeContainer(nextToken);
+			setOnContainer(node, token, child);
+		}
+		node = child;
+	}
+	const last = tokens[tokens.length - 1];
+	if (last !== "" && !Array.isArray(node)) {
+		const existing = getFromContainer(node, last);
+		if (existing !== void 0) {
+			const arr = Array.isArray(existing) ? existing : [existing];
+			arr.push(value);
+			setOnContainer(node, last, arr);
+			return;
+		}
+	}
+	setOnContainer(node, last, value);
+}
+/** Normalise a source into `[name, value]` entries. */
+function* entriesOf(source) {
+	if (typeof source[Symbol.iterator] === "function" && !(source instanceof FormData) && !(source instanceof URLSearchParams)) {
+		yield* source;
+		return;
+	}
+	for (const entry of source.entries()) yield entry;
+}
+/**
+* Parse a form body into a nested object / array tree. Field names use dot or
+* bracket path notation (see {@link parseFieldPath}); repeated bare keys
+* become arrays; `File` values pass through. The result is ready to hand to
+* `Schema.decodeUnknown` with a schema whose leaves coerce the string inputs.
+*/
+function formDataToObject(source) {
+	const root = {};
+	for (const [name, value] of entriesOf(source)) {
+		const tokens = parseFieldPath(name);
+		if (tokens.length === 0) continue;
+		assign(root, tokens, value);
+	}
+	return root;
+}
+/** Read and parse a `Request`'s form body. Errors (e.g. wrong content-type) reject. */
+async function requestToObject(request) {
+	return formDataToObject(await request.formData());
+}
+//#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:
+* `["author", "name"]`, `["tags", 0]`. This module reads and writes a value
+* at such a path — {@link getAt} descends, {@link setAt} returns a new tree
+* with the value replaced (structural sharing, never a mutation) so a rune /
+* atom store can diff cheaply. It is the framework-neutral half of the
+* reactive field bindings (the Svelte store leans on it for
+* `setValue` and the array operations).
+*
+* Paths are {@link FormPath}s — the same array-of-segments the {@link
+* module:effect-forms/Errors} tree and {@link module:effect-forms/Issues}
+* walker already speak — so string keys address object properties and number
+* segments address array indices. {@link toString} / {@link fromString}
+* convert to and from the flat `author.name` / `tags[0]` notation the HTML
+* body parser ({@link module:effect-forms/FormData}) uses.
+*
+* @module effect-forms/Path
+*/
+var Path_exports = /* @__PURE__ */ __exportAll({
+	clearAll: () => clearAll,
+	fromString: () => fromString,
+	getAt: () => getAt,
+	insertAt: () => insertAt,
+	isUnder: () => isUnder,
+	moveAt: () => moveAt,
+	remapIndex: () => remapIndex,
+	remapKeyedRecord: () => remapKeyedRecord,
+	removeAt: () => removeAt,
+	replaceAt: () => replaceAt$1,
+	setAt: () => setAt,
+	swapAt: () => swapAt,
+	toString: () => toString
+});
+/**
+* Read the value at `path`. Returns `undefined` if any segment is missing or
+* traverses a non-object. The empty path returns the object itself.
+*/
+function getAt(obj, path) {
+	let current = obj;
+	for (const segment of path) {
+		if (current === null || typeof current !== "object") return void 0;
+		current = current[segment];
+	}
+	return current;
+}
+/**
+* Return a new tree with the value at `path` replaced by `value`. Objects and
+* arrays along the path are cloned (structural sharing elsewhere); missing
+* containers are created as arrays for numeric segments and objects otherwise.
+* The empty path returns `value`. Pure — `obj` is never mutated.
+*/
+function setAt(obj, path, value) {
+	if (path.length === 0) return value;
+	const [head, ...rest] = path;
+	const clone = Array.isArray(obj) ? [...obj] : { ...obj };
+	const child = clone[head];
+	clone[head] = rest.length === 0 ? value : setAt(child === null || typeof child !== "object" ? typeof rest[0] === "number" ? [] : {} : child, rest, value);
+	return clone;
+}
+/** Whether `path` is `root` or nested beneath it. */
+function isUnder(path, root) {
+	if (path.length < root.length) return false;
+	for (let i = 0; i < root.length; i++) if (path[i] !== root[i]) return false;
+	return true;
+}
+/**
+* Render a {@link FormPath} as flat field-name notation: string segments join
+* with `.` and number segments become `[n]` (`["tags", 0]` → `"tags[0]"`).
+* The inverse of {@link fromString}.
+*/
+function toString(path) {
+	let out = "";
+	for (const segment of path) if (typeof segment === "number") out += `[${segment}]`;
+	else out += out === "" ? segment : `.${segment}`;
+	return out;
+}
+/**
+* Parse flat field-name notation into a {@link FormPath}: integer tokens become
+* number segments (array indices), everything else stays a string. The inverse
+* of {@link toString}.
+*/
+function fromString(name) {
+	return parseFieldPath(name).map((token) => /^\d+$/.test(token) ? Number(token) : token);
+}
+/** The {@link IndexMap} for removing the item at `index`: shifts later indices down by one. */
+function removeAt(index) {
+	return (i) => i === index ? null : i > index ? i - 1 : i;
+}
+/** The {@link IndexMap} for inserting an item at `index`: shifts `index` and later up by one. */
+function insertAt(index) {
+	return (i) => i >= index ? i + 1 : i;
+}
+/** The {@link IndexMap} for swapping the items at `a` and `b`. */
+function swapAt(a, b) {
+	return (i) => i === a ? b : i === b ? a : i;
+}
+/** The {@link IndexMap} for moving the item at `from` to `to`, shifting the items between. */
+function moveAt(from, to) {
+	return (i) => {
+		if (i === from) return to;
+		if (from < to) return i > from && i <= to ? i - 1 : i;
+		return i >= to && i < from ? i + 1 : i;
+	};
+}
+/** The {@link IndexMap} for replacing the item at `index` in place: drops only that index's state. */
+function replaceAt$1(index) {
+	return (i) => i === index ? null : i;
+}
+/** The {@link IndexMap} for clearing every item in the array: drops all per-index state. */
+const clearAll = () => null;
+/**
+* Remap `path`'s index segment immediately under `arrayPath` through `map`.
+* Paths outside `arrayPath`, and `arrayPath` itself (a whole-array message),
+* pass through unchanged; a path whose index segment maps to `null` is
+* dropped (returns `null`) — its item no longer exists. Pure.
+*/
+function remapIndex(path, arrayPath, map) {
+	if (!isUnder(path, arrayPath) || path.length === arrayPath.length) return path;
+	const segment = path[arrayPath.length];
+	if (typeof segment !== "number") return path;
+	const mapped = map(segment);
+	if (mapped === null) return null;
+	if (mapped === segment) return path;
+	return [
+		...path.slice(0, arrayPath.length),
+		mapped,
+		...path.slice(arrayPath.length + 1)
+	];
+}
+/**
+* Remap every entry of a flat, path-keyed record (a {@link toString} key per
+* entry — e.g. touched flags) through {@link remapIndex}. Entries whose path
+* maps to `null` are dropped. Pure.
+*/
+function remapKeyedRecord(record, arrayPath, map) {
+	const out = {};
+	for (const key of Object.keys(record)) {
+		const remapped = remapIndex(fromString(key), arrayPath, map);
+		if (remapped !== null) out[toString(remapped)] = record[key];
+	}
+	return out;
+}
+//#endregion
+//#region src/Errors.ts
+var Errors_exports = /* @__PURE__ */ __exportAll({
+	ROOT_ERROR_KEY: () => ROOT_ERROR_KEY,
+	clearSourceAt: () => clearSourceAt,
+	emptySourced: () => emptySourced,
+	flattenErrors: () => flattenErrors,
+	getError: () => getError,
+	hasErrors: () => hasErrors,
+	issuesToErrors: () => issuesToErrors,
+	mergeErrors: () => mergeErrors,
+	mergeSourced: () => mergeSourced,
+	noErrors: () => noErrors,
+	remapIndices: () => remapIndices,
+	replaceAt: () => replaceAt,
+	setError: () => setError,
+	setSourceAt: () => setSourceAt
+});
+/** The root key under which a branch's own (non-field) messages are stored. */
+const ROOT_ERROR_KEY = "_errors";
+const isMessageList = (value) => Array.isArray(value) && value.every((v) => typeof v === "string");
+const ownErrors = (node) => {
+	const existing = node[ROOT_ERROR_KEY];
+	if (isMessageList(existing)) return existing;
+	const created = [];
+	node[ROOT_ERROR_KEY] = created;
+	return created;
+};
+/**
+* If `node[key]` is a leaf's message list, convert it in place into a branch
+* carrying those same messages as its own {@link ROOT_ERROR_KEY} (a path used
+* as a leaf is now needed as a branch too) — a no-op when `node[key]` is
+* already a branch or absent. Shared by {@link insert} and {@link setLeaf}'s
+* path-descent, the one piece of their branch-walking that's identical.
+*/
+const promoteLeafToBranch = (node, key) => {
+	const existing = node[key];
+	if (isMessageList(existing)) node[key] = { [ROOT_ERROR_KEY]: existing };
+};
+/**
+* Insert one message at `path` into a mutable error tree. A leaf becomes a
+* `string[]`; if the same path is later used as a branch the existing list is
+* preserved under {@link ROOT_ERROR_KEY}; if a branch later receives its own
+* message it lands under {@link ROOT_ERROR_KEY}. The empty path targets the
+* tree root's {@link ROOT_ERROR_KEY}.
+*/
+const insert = (root, path, message) => {
+	if (path.length === 0) {
+		ownErrors(root).push(message);
+		return;
+	}
+	let node = root;
+	for (let i = 0; i < path.length - 1; i++) {
+		const key = String(path[i]);
+		if (node[key] === void 0) node[key] = {};
+		else promoteLeafToBranch(node, key);
+		node = node[key];
+	}
+	const last = String(path[path.length - 1]);
+	const existing = node[last];
+	if (existing === void 0) node[last] = [message];
+	else if (isMessageList(existing)) existing.push(message);
+	else ownErrors(existing).push(message);
+};
+/** Build a nested {@link FormErrors} tree from a flat list of {@link FormIssue}s. */
+function issuesToErrors(issues) {
+	const root = {};
+	for (const issue of issues) insert(root, issue.path, issue.message);
+	return root;
+}
+/**
+* Flatten a {@link FormErrors} tree back into a list of {@link FormIssue}s, in
+* depth-first order. The inverse of {@link issuesToErrors} (modulo message
+* ordering within a single field).
+*/
+function flattenErrors(errors) {
+	const out = [];
+	const walk = (node, path) => {
+		for (const key of Object.keys(node)) {
+			const value = node[key];
+			if (value === void 0) continue;
+			if (key === "_errors") {
+				for (const message of value) out.push({
+					path,
+					message
+				});
+				continue;
+			}
+			const segment = /^\d+$/.test(key) ? Number(key) : key;
+			if (isMessageList(value)) for (const message of value) out.push({
+				path: [...path, segment],
+				message
+			});
+			else walk(value, [...path, segment]);
+		}
+	};
+	walk(errors, []);
+	return out;
+}
+/** Whether the tree carries any message anywhere. */
+function hasErrors(errors) {
+	return flattenErrors(errors).length > 0;
+}
+/**
+* Read the messages attached directly to `path` (a leaf's list, or a branch's
+* own {@link ROOT_ERROR_KEY}). Returns `undefined` when the path has no direct
+* messages.
+*/
+function getError(errors, path) {
+	let node = errors;
+	for (const segment of path) {
+		if (node === void 0 || isMessageList(node)) return void 0;
+		node = node[String(segment)];
+	}
+	if (node === void 0) return void 0;
+	if (isMessageList(node)) return node;
+	return node[ROOT_ERROR_KEY];
+}
+/** Return a new tree with `message` added at `path`. Pure. */
+function setError(errors, path, message) {
+	const next = structuredClone(errors);
+	insert(next, path, message);
+	return next;
+}
+/** Combine two error trees into one (left then right). Pure. */
+function mergeErrors(a, b) {
+	return issuesToErrors([...flattenErrors(a), ...flattenErrors(b)]);
+}
+/** The empty error tree. */
+const noErrors = {};
+/**
+* Remap the array-index segments of every message under `arrayPath` through
+* `map` (see {@link module:effect-forms/Path.IndexMap}), so an error recorded
+* against a row follows that row through a remove / insert / swap / move.
+* Messages whose index maps to `null` are dropped. Pure.
+*/
+function remapIndices(errors, arrayPath, map) {
+	const remapped = [];
+	for (const issue of flattenErrors(errors)) {
+		const path = remapIndex(issue.path, arrayPath, map);
+		if (path !== null) remapped.push({
+			path,
+			message: issue.message
+		});
+	}
+	return issuesToErrors(remapped);
+}
+/**
+* Return a new tree with the messages *directly at* `path` replaced by
+* `messages` (removing the key when `messages` is empty), leaving every other
+* path — including children of a branch `path` — untouched. Unlike
+* {@link setError} (which appends one message), this is the "this field's
+* validator just ran, here is its complete result" operation a per-field
+* validator needs: it can clear a field back to valid without disturbing
+* sibling or nested messages. Pure.
+*/
+function replaceAt(errors, path, messages) {
+	const next = structuredClone(errors);
+	setLeaf(next, path, messages);
+	return next;
+}
+const setLeaf = (root, path, messages) => {
+	if (path.length === 0) {
+		setOwnMessages(root, messages);
+		return;
+	}
+	const parent = descendClearing(root, path, messages);
+	if (parent === void 0) return;
+	setLeafMessages(parent, String(path[path.length - 1]), messages);
+};
+/** Set or clear a node's own {@link ROOT_ERROR_KEY} messages. */
+const setOwnMessages = (node, messages) => {
+	if (messages.length === 0) delete node[ROOT_ERROR_KEY];
+	else node[ROOT_ERROR_KEY] = [...messages];
+};
+/**
+* Walk to `path`'s parent branch, creating branches as needed. When
+* `messages` is empty (a clear, not a set) a missing branch means there is
+* nothing to clear — descent stops early and returns `undefined` rather than
+* creating empty branches just to immediately no-op inside them.
+*/
+const descendClearing = (root, path, messages) => {
+	let node = root;
+	for (let i = 0; i < path.length - 1; i++) {
+		const key = String(path[i]);
+		if (node[key] === void 0) {
+			if (messages.length === 0) return void 0;
+			node[key] = {};
+		} else promoteLeafToBranch(node, key);
+		node = node[key];
+	}
+	return node;
+};
+/** Set or clear `node[key]`'s messages — a leaf's list, or (if it's already a branch) its own {@link ROOT_ERROR_KEY}. */
+const setLeafMessages = (node, key, messages) => {
+	const existing = node[key];
+	if (existing === void 0) {
+		if (messages.length > 0) node[key] = [...messages];
+		return;
+	}
+	if (isMessageList(existing)) {
+		if (messages.length === 0) delete node[key];
+		else node[key] = [...messages];
+		return;
+	}
+	if (messages.length === 0) delete existing[ROOT_ERROR_KEY];
+	else existing[ROOT_ERROR_KEY] = [...messages];
+};
+/** Both source trees empty. */
+const emptySourced = {
+	client: noErrors,
+	server: noErrors
+};
+/** Combine both source trees into the single tree a UI reads (server first, then client). */
+function mergeSourced(sourced) {
+	return mergeErrors(sourced.server, sourced.client);
+}
+/**
+* Return new {@link SourcedErrors} with `source`'s tree updated at `path` via
+* {@link replaceAt} (the other source's tree is untouched). Pure.
+*/
+function setSourceAt(sourced, source, path, messages) {
+	return {
+		...sourced,
+		[source]: replaceAt(sourced[source], path, messages)
+	};
+}
+/** Clear `source`'s messages at `path` (and nowhere else). Shorthand for {@link setSourceAt} with `[]`. */
+function clearSourceAt(sourced, source, path) {
+	return setSourceAt(sourced, source, path, []);
+}
+//#endregion
+//#region src/Field.ts
+var Field_exports = /* @__PURE__ */ __exportAll({
+	defaultEncodedValues: () => defaultEncodedValues,
+	defaultItemAt: () => defaultItemAt,
+	defaultValue: () => defaultValue,
+	isArrayFieldDef: () => isArrayFieldDef,
+	isFieldDef: () => isFieldDef,
+	makeArrayField: () => makeArrayField,
+	makeField: () => makeField,
+	schemaAt: () => schemaAt
+});
+/** Whether `def` is an {@link ArrayFieldDef}. */
+const isArrayFieldDef = (def) => def._tag === "array";
+/** Whether `def` is a scalar {@link FieldDef}. */
+const isFieldDef = (def) => def._tag === "field";
+/** Construct a scalar {@link FieldDef}. */
+const makeField = (key, schema) => ({
+	_tag: "field",
+	key,
+	schema
+});
+/** Construct an {@link ArrayFieldDef}. */
+const makeArrayField = (key, itemSchema) => ({
+	_tag: "array",
+	key,
+	itemSchema
+});
+/**
+* Derive a blank *encoded* default from a schema AST: a struct recurses into
+* its properties, an array seeds to `[]`, and any scalar seeds to `""` (an
+* HTML input's empty value). Conservative by design — a value that will not
+* decode cleanly is still a valid *starting* value the user edits.
+*/
+function defaultValue(schema) {
+	return fromAst(schema.ast);
+}
+/**
+* Unwrap a union to its first structured (struct / array) member — an
+* `optional` / `NullOr` wrapper (`Struct | undefined` / `Struct | null`)
+* still resolves to the wrapped struct or array's AST rather than a scalar
+* fallback. Non-unions, and unions with no structured member, pass through.
+*/
+function unwrapToStructured(ast) {
+	if (!SchemaAST.isUnion(ast)) return ast;
+	for (const member of ast.types) {
+		const inner = unwrapToStructured(member);
+		if (SchemaAST.isObjects(inner) || SchemaAST.isArrays(inner)) return inner;
+	}
+	return ast;
+}
+function fromAst(ast) {
+	const unwrapped = unwrapToStructured(ast);
+	if (SchemaAST.isObjects(unwrapped)) {
+		const out = {};
+		for (const ps of unwrapped.propertySignatures) out[String(ps.name)] = fromAst(ps.type);
+		return out;
+	}
+	if (SchemaAST.isArrays(unwrapped)) return [];
+	return "";
+}
+/** The item AST of an {@link SchemaAST.Arrays} node: the rest (spread) type, or the first tuple element. */
+function arrayElementAst(ast) {
+	return ast.rest[0] ?? ast.elements[0];
+}
+/** Descend one array-index path segment from an (already-unwrapped) array AST. */
+function stepIntoArray(ast) {
+	if (!SchemaAST.isArrays(ast)) return void 0;
+	const item = arrayElementAst(ast);
+	return item === void 0 ? void 0 : unwrapToStructured(item);
+}
+/** Descend one struct-property path segment from an (already-unwrapped) struct AST. */
+function stepIntoStruct(ast, key) {
+	if (!SchemaAST.isObjects(ast)) return void 0;
+	const ps = ast.propertySignatures.find((p) => String(p.name) === key);
+	return ps === void 0 ? void 0 : unwrapToStructured(ps.type);
+}
+/**
+* Walk `schema`'s AST along `path` — through struct properties and array
+* elements alike — and return the AST found there, or `undefined` if `path`
+* doesn't resolve (a missing property, or a non-array indexed). Unlike a
+* {@link FieldsRecord} lookup, this works for any nesting depth and for
+* schemas built directly with `Form.make` (no builder involved).
+*/
+function schemaAt(schema, path) {
+	let ast = unwrapToStructured(schema.ast);
+	for (const segment of path) {
+		if (ast === void 0) return void 0;
+		ast = typeof segment === "number" ? stepIntoArray(ast) : stepIntoStruct(ast, segment);
+	}
+	return ast;
+}
+/**
+* Derive a blank encoded item for the array field at `path` (any nesting
+* depth) by walking `schema`'s AST there — the nested-array counterpart to
+* {@link defaultValue}. Returns `""` when `path` doesn't resolve to an array.
+*/
+function defaultItemAt(schema, path) {
+	const ast = schemaAt(schema, path);
+	if (ast === void 0 || !SchemaAST.isArrays(ast)) return "";
+	const item = arrayElementAst(ast);
+	return item === void 0 ? "" : fromAst(item);
+}
+/** Seed a blank encoded value for every field: `[]` for arrays, `""` otherwise. */
+function defaultEncodedValues(fields) {
+	const out = {};
+	for (const [key, def] of Object.entries(fields)) out[key] = isArrayFieldDef(def) ? [] : defaultValue(def.schema);
+	return out;
+}
+//#endregion
+//#region src/Issues.ts
+var Issues_exports = /* @__PURE__ */ __exportAll({
+	defaultLeafFormatter: () => defaultLeafFormatter,
+	filterOutputToFormIssues: () => filterOutputToFormIssues,
+	schemaIssuesToFormIssues: () => schemaIssuesToFormIssues
+});
+/** The default leaf formatter — Effect Schema's own rendering of the leaf. */
+const defaultLeafFormatter = (issue) => String(issue);
+/**
+* Normalise a `Pointer.path` segment into a {@link FormPath} segment: integer
+* keys become numbers (array indices), everything else becomes a string.
+*/
+const normaliseSegment = (segment) => {
+	if (typeof segment === "number") return segment;
+	if (typeof segment === "symbol") return segment.toString();
+	return /^\d+$/.test(segment) ? Number(segment) : segment;
+};
+/**
+* Walk an Effect Schema issue tree, emitting one {@link FormIssue} per leaf
+* failure. Path segments accumulate through `Pointer` nodes; `Composite` and
+* `AnyOf` fan out to siblings; `Filter` / `Encoding` are transparent
+* wrappers. An `AnyOf` with no recorded member failures (a bare union
+* mismatch) is itself a leaf.
+*/
+function schemaIssuesToFormIssues(issue, format = defaultLeafFormatter) {
+	const out = [];
+	const walk = (current, path) => {
+		switch (current._tag) {
+			case "Pointer":
+				walk(current.issue, [...path, ...current.path.map(normaliseSegment)]);
+				return;
+			case "Composite":
+				for (const child of current.issues) walk(child, path);
+				return;
+			case "AnyOf":
+				if (current.issues.length === 0) {
+					out.push({
+						path,
+						message: format(current)
+					});
+					return;
+				}
+				for (const child of current.issues) walk(child, path);
+				return;
+			case "Filter":
+			case "Encoding":
+				walk(current.issue, path);
+				return;
+			default:
+				out.push({
+					path,
+					message: format(current)
+				});
+				return;
+		}
+	};
+	walk(issue, []);
+	return out;
+}
+/**
+* Normalise a filter predicate's {@link Schema.FilterOutput} into a flat list of
+* {@link FormIssue}s (empty on success). Shared by whole-form refinements
+* ({@link module:effect-forms/FormBuilder}) and per-field validators
+* ({@link module:effect-forms/Validate}) so both fold into the same nested
+* error tree as schema-decode failures.
+*/
+function filterOutputToFormIssues(output) {
+	if (output === void 0 || output === true) return [];
+	if (output === false) return [{
+		path: [],
+		message: "Invalid value"
+	}];
+	if (Array.isArray(output)) return output.flatMap(filterIssueToFormIssues);
+	return filterIssueToFormIssues(output);
+}
+function filterIssueToFormIssues(issue) {
+	if (typeof issue === "string") return [{
+		path: [],
+		message: issue
+	}];
+	if ("path" in issue && "issue" in issue) {
+		const prefix = issue.path.map((s) => typeof s === "symbol" ? s.toString() : s);
+		return (typeof issue.issue === "string" ? [{
+			path: [],
+			message: issue.issue
+		}] : schemaIssuesToFormIssues(issue.issue)).map((i) => ({
+			path: [...prefix, ...i.path],
+			message: i.message
+		}));
+	}
+	return schemaIssuesToFormIssues(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;
+* {@link FormBuilder.addField} adds a scalar or array field, {@link
+* FormBuilder.merge} folds another builder in, and {@link FormBuilder.refine} /
+* {@link FormBuilder.refineEffect} attach cross-field validations. The point is
+* incremental composition — assemble a large form from small, reusable
+* field-group builders — plus a home for whole-form rules (`password ===
+* confirmPassword`) that a single field schema can't express.
+*
+* {@link buildSchema} collapses the accumulated fields into an ordinary
+* `Schema.Struct` (array fields become `Schema.Array(item)`) and applies every
+* *synchronous* refinement as a struct-level `check`, so the result decodes,
+* derives constraints, and validates exactly like a hand-written schema — hand
+* it straight to {@link module:effect-forms/Form}'s `make`. *Asynchronous*
+* refinements can't be schema checks (Effect Schema has no effectful filter),
+* so they're carried on the builder and run by the Effect-returning validate
+* path — {@link asyncRefinements} exposes them and {@link runAsyncRefinements}
+* runs them into a {@link FormIssue} list.
+*
+* @module effect-forms/FormBuilder
+*/
+var FormBuilder_exports = /* @__PURE__ */ __exportAll({
+	TypeId: () => TypeId,
+	asyncRefinements: () => asyncRefinements,
+	buildSchema: () => buildSchema,
+	empty: () => empty,
+	filterOutputToFormIssues: () => filterOutputToFormIssues,
+	isFormBuilder: () => isFormBuilder,
+	make: () => make$2,
+	runAsyncRefinements: () => runAsyncRefinements
+});
+/** Brand for a {@link FormBuilder}. */
+const TypeId = Symbol.for("@thomasfosterau/effect-forms/FormBuilder");
+const proto = {
+	[TypeId]: TypeId,
+	addField(keyOrField, schema) {
+		const field = typeof keyOrField === "string" ? makeField(keyOrField, schema) : keyOrField;
+		return build({
+			...this.fields,
+			[field.key]: field
+		}, this.refinements);
+	},
+	merge(other) {
+		return build({
+			...this.fields,
+			...other.fields
+		}, [...this.refinements, ...other.refinements]);
+	},
+	refine(predicate) {
+		return build(this.fields, [...this.refinements, {
+			_tag: "sync",
+			fn: predicate
+		}]);
+	},
+	refineEffect(predicate) {
+		return build(this.fields, [...this.refinements, {
+			_tag: "async",
+			fn: predicate
+		}]);
+	}
+};
+function build(fields, refinements) {
+	const self = Object.create(proto);
+	self.fields = fields;
+	self.refinements = refinements;
+	return self;
+}
+/** Whether `u` is a {@link FormBuilder}. */
+const isFormBuilder = (u) => typeof u === "object" && u !== null && TypeId in u;
+/** The empty builder — the starting point for {@link FormBuilder.addField}. */
+const make$2 = build({}, []);
+/** Alias of {@link make} — the empty builder. */
+const empty = make$2;
+/**
+* Collapse a builder into an Effect Schema: a `Schema.Struct` of the fields
+* (array fields as `Schema.Array(item)`) with every synchronous refinement
+* applied as a struct-level check. Ready for {@link module:effect-forms/Form}.
+*/
+function buildSchema(self) {
+	const structFields = {};
+	for (const [key, def] of Object.entries(self.fields)) if (isArrayFieldDef(def)) structFields[key] = Schema.Array(def.itemSchema);
+	else if (isFieldDef(def)) structFields[key] = def.schema;
+	let schema = Schema.Struct(structFields);
+	for (const refinement of self.refinements) if (refinement._tag === "sync") schema = schema.check(Schema.makeFilter(refinement.fn));
+	return schema;
+}
+/** The asynchronous refinements carried on a builder, as bare predicates. */
+function asyncRefinements(self) {
+	return self.refinements.filter((r) => r._tag === "async").map((r) => r.fn);
+}
+/**
+* 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.
+*/
+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)));
+}
+//#endregion
+//#region src/State.ts
+/**
+* @copyright Thomas Foster
+*
+* {@link FormState} — the serialisable snapshot of a form.
+*
+* This is the single object a
+* server produces (validate a submission, or seed an empty form) and hands to
+* the client to hydrate from. It is plain JSON so it survives the SSR → client
+* boundary, and {@link FormStateSchema} gives it an Effect Schema so it can be
+* decoded back on arrival.
+*
+* @module effect-forms/State
+*/
+var State_exports = /* @__PURE__ */ __exportAll({
+	FormStateSchema: () => FormStateSchema,
+	isValid: () => isValid,
+	make: () => make$1,
+	withError: () => withError,
+	withMessage: () => withMessage
+});
+/** Build a {@link FormState} from data plus overrides. `valid` defaults to "no errors". */
+function make$1(data, options = {}) {
+	const errors = options.errors ?? noErrors;
+	return {
+		id: options.id ?? "default",
+		valid: options.valid ?? !hasErrors(errors),
+		posted: options.posted ?? false,
+		data,
+		errors,
+		...options.message !== void 0 ? { message: options.message } : {},
+		...options.constraints !== void 0 ? { constraints: options.constraints } : {}
+	};
+}
+/** Return a new state carrying `message` (and not otherwise changed). */
+function withMessage(state, message) {
+	return {
+		...state,
+		message
+	};
+}
+/**
+* Return a new state with `message` added at `path` and `valid` forced to
+* `false` — for attaching a
+* server-side validation failure to a specific field after the schema passed.
+*/
+function withError(state, path, message) {
+	return {
+		...state,
+		valid: false,
+		errors: setError(state.errors, path, message)
+	};
+}
+/** Whether the state is valid. */
+const isValid = (state) => state.valid;
+/** Effect Schema describing the JSON shape of {@link FormState} for transport. */
+function FormStateSchema(data) {
+	return Schema.Struct({
+		id: Schema.String,
+		valid: Schema.Boolean,
+		posted: Schema.Boolean,
+		data,
+		errors: Schema.Record(Schema.String, Schema.Unknown),
+		message: Schema.optional(Schema.Unknown),
+		constraints: Schema.optional(Schema.Record(Schema.String, Schema.Unknown))
+	});
+}
+//#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.
+*
+* This is the framework-neutral validate-and-seed entry point,
+* expressed as a small object bound to one schema:
+*
+* - `validate(input)` parses an HTML form body (or a plain object) and decodes
+*   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.
+* - `empty()` seeds an unposted, invalid-by-default form from the supplied
+*   defaults — what a `load` returns to render a blank create form.
+*
+* Coercion (strings → numbers / booleans / dates) is the schema's job: build
+* the schema from coercing leaves (`Schema.FiniteFromString`, the
+* {@link module:effect-forms/Coerce} helpers, …) so a multipart body decodes
+* cleanly.
+*
+* @module effect-forms/Form
+*/
+var Form_exports = /* @__PURE__ */ __exportAll({
+	fromBuilder: () => fromBuilder,
+	make: () => make
+});
+const toStructured = (input) => {
+	if (input === null || input === void 0) return Effect.succeed(null);
+	if (input instanceof Request) return Effect.promise(() => requestToObject(input));
+	if (input instanceof FormData || input instanceof URLSearchParams) return Effect.succeed(formDataToObject(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.
+*/
+function make(schema, options) {
+	const id = options.id ?? "default";
+	const { defaults, leafFormatter } = options;
+	const constraints = options.deriveConstraints === false ? options.constraints ?? {} : constraintsFromSchema(schema, options.constraints ?? {});
+	const decode = SchemaParser.decodeUnknownEffect(schema, { errors: "all" });
+	const empty = (overrides = {}) => make$1(defaults, {
+		id,
+		valid: false,
+		posted: false,
+		constraints,
+		...overrides
+	});
+	const parse = (input) => input instanceof FormData || input instanceof URLSearchParams ? formDataToObject(input) : input;
+	const validate = (input) => toStructured(input).pipe(Effect.flatMap((object) => {
+		if (object === null) return Effect.succeed(empty());
+		return decode(object).pipe(Effect.matchEffect({
+			onSuccess: (data) => Effect.succeed(make$1(data, {
+				id,
+				valid: true,
+				posted: true,
+				constraints
+			})),
+			onFailure: (issue) => Effect.succeed(make$1({
+				...defaults,
+				...object
+			}, {
+				id,
+				valid: false,
+				posted: true,
+				constraints,
+				errors: issuesToErrors(schemaIssuesToFormIssues(issue, leafFormatter))
+			}))
+		}));
+	}));
+	return {
+		schema,
+		id,
+		constraints,
+		empty,
+		parse,
+		validate
+	};
+}
+/**
+* Bind a {@link FormBuilder} to a {@link Form}. Collapses the builder to a
+* schema (see {@link buildSchema}), then behaves like {@link make} — except its
+* `validate` also runs the builder's *asynchronous* refinements after a
+* successful decode, folding any failures into the same nested error tree. When
+* `defaults` is omitted it is derived from the fields (blank encoded values).
+*/
+function fromBuilder(builder, options = {}) {
+	const schema = buildSchema(builder);
+	const defaults = options.defaults ?? defaultEncodedValues(builder.fields);
+	const base = make(schema, {
+		...options,
+		defaults
+	});
+	const decode = SchemaParser.decodeUnknownEffect(schema, { errors: "all" });
+	const validate = (input) => toStructured(input).pipe(Effect.flatMap((object) => {
+		if (object === null) return Effect.succeed(base.empty());
+		const posted = {
+			...defaults,
+			...object
+		};
+		return decode(object).pipe(Effect.matchEffect({
+			onSuccess: (data) => runAsyncRefinements(builder, data).pipe(Effect.map((issues) => issues.length === 0 ? make$1(data, {
+				id: base.id,
+				valid: true,
+				posted: true,
+				constraints: base.constraints
+			}) : make$1(posted, {
+				id: base.id,
+				valid: false,
+				posted: true,
+				constraints: base.constraints,
+				errors: issuesToErrors(issues)
+			}))),
+			onFailure: (issue) => Effect.succeed(make$1(posted, {
+				id: base.id,
+				valid: false,
+				posted: true,
+				constraints: base.constraints,
+				errors: issuesToErrors(schemaIssuesToFormIssues(issue, options.leafFormatter))
+			}))
+		}));
+	}));
+	return {
+		...base,
+		validate
+	};
+}
+//#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.
+* The three modes mirror the common form-library vocabulary:
+*
+* - **`onSubmit`** (the default) — validate only when the form is submitted (or
+*   validation is triggered explicitly). The quietest mode.
+* - **`onBlur`** — validate a field when it loses focus.
+* - **`onChange`** — validate on every change, optionally `debounce`d.
+*
+* `onBlur` / `onChange` may also `autoSubmit`, turning the form into a
+* live-saving surface (a settings panel, a filter bar). This module is the
+* framework-neutral half: {@link parse} normalises the loose {@link FormMode}
+* a caller supplies into a fully-resolved {@link ParsedMode} the reactive
+* store drives from. The store owns the actual scheduling.
+*
+* A separate `revalidate` dimension governs what happens *after a submit*: an
+* `onSubmit`-mode form is otherwise silent until the next submit, which
+* leaves a failed post's errors frozen even after the user fixes the
+* offending field. `revalidate` says which trigger (`"onChange"` /
+* `"onBlur"` — independent of the primary `validation` trigger) re-validates
+* once the form has been posted at least once; `"never"` keeps the classic
+* frozen-until-resubmit behaviour.
+*
+* @module effect-forms/Mode
+*/
+var Mode_exports = /* @__PURE__ */ __exportAll({ parse: () => parse });
+/**
+* Normalise a {@link FormMode} into a {@link ParsedMode}. An absent mode is
+* `onSubmit`. `debounce` is resolved to milliseconds and only applies in
+* `onChange`; `autoSubmit` is only honoured for `onBlur` / `onChange`;
+* `revalidate` defaults to `"onChange"` (TanStack's / RHF's default
+* post-submit behaviour) regardless of the primary `validation` mode.
+*/
+function parse(mode) {
+	const validation = mode?.validation ?? "onSubmit";
+	const revalidate = mode?.revalidate ?? "onChange";
+	if (validation === "onBlur") return {
+		validation: "onBlur",
+		debounce: null,
+		autoSubmit: mode?.autoSubmit === true,
+		revalidate
+	};
+	if (validation === "onChange") return {
+		validation: "onChange",
+		debounce: mode?.debounce === void 0 ? null : Duration.toMillis(mode.debounce),
+		autoSubmit: mode?.autoSubmit === true,
+		revalidate
+	};
+	return {
+		validation: "onSubmit",
+		debounce: null,
+		autoSubmit: false,
+		revalidate
+	};
+}
+//#endregion
+//#region src/Result.ts
+var Result_exports = /* @__PURE__ */ __exportAll({
+	errorResult: () => errorResult,
+	failure: () => failure,
+	redirect: () => redirect,
+	success: () => success
+});
+/** Construct a {@link FormSuccess} (default status 200). */
+const success = (state, status = 200) => ({
+	_tag: "Success",
+	status,
+	state
+});
+/** Construct a {@link FormFailure} (default status 400). */
+const failure = (state, status = 400) => ({
+	_tag: "Failure",
+	status,
+	state
+});
+/** Construct a {@link FormRedirect} (default status 303). */
+const redirect = (location, status = 303) => ({
+	_tag: "Redirect",
+	status,
+	location
+});
+/** Construct a {@link FormErrorResult} (default status 500). */
+const errorResult = (message, status = 500) => ({
+	_tag: "Error",
+	status,
+	message
+});
+//#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
+* hoc field- or value-level validation (e.g. a Svelte client validating a
+* single field on blur).
+*
+* The second half of the module is per-field validators: {@link
+* SyncFieldValidator} / {@link AsyncFieldValidator} (bundled as {@link
+* FieldValidators}) are the framework-neutral shape a reactive store attaches
+* to one field, mirroring TanStack Form's `validators.onChange(Async)` /
+* `onBlur(Async)`. {@link runSyncFieldValidator} runs one synchronously;
+* {@link runAsyncFieldValidator} builds the debounced Effect an async one
+* runs as — the store is responsible for forking it into a fiber per field
+* and interrupting the previous fiber on every new run (see that function's
+* docs for why that alone gives debounce + "latest wins" cancellation).
+*
+* @module effect-forms/Validate
+*/
+var Validate_exports = /* @__PURE__ */ __exportAll({
+	resolveFieldTrigger: () => resolveFieldTrigger,
+	runAsyncFieldValidator: () => runAsyncFieldValidator,
+	runSyncFieldValidator: () => runSyncFieldValidator,
+	validateValue: () => validateValue,
+	validateValueSync: () => validateValueSync
+});
+/**
+* Decode `input` through `schema`, returning a {@link ValidationResult} on the
+* success channel (decode failures become `valid: false`, not an Effect
+* failure). Decoding-service requirements propagate on the `R` channel.
+*/
+function validateValue(schema, input, format) {
+	return SchemaParser.decodeUnknownEffect(schema, { errors: "all" })(input).pipe(Effect.matchEffect({
+		onSuccess: (data) => Effect.succeed({
+			valid: true,
+			data
+		}),
+		onFailure: (issue) => {
+			const issues = schemaIssuesToFormIssues(issue, format);
+			return Effect.succeed({
+				valid: false,
+				errors: issuesToErrors(issues),
+				issues
+			});
+		}
+	}));
+}
+/**
+* Synchronous {@link validateValue} for schemas with no decoding-service
+* requirements (`R = never`) and no async decoding — the common case for plain
+* form schemas. {@link validateValue} never fails on the error channel, so
+* running it with {@link Effect.runSync} is total.
+*/
+function validateValueSync(schema, input, format) {
+	return Effect.runSync(validateValue(schema, input, format));
+}
+/**
+* Run a {@link SyncFieldValidator}, folding its {@link Schema.FilterOutput}
+* into {@link FormIssue}s (empty on success). Total — a sync field validator
+* cannot fail the Effect error channel.
+*/
+function runSyncFieldValidator(validator, value) {
+	return filterOutputToFormIssues(validator(value));
+}
+/**
+* Build the Effect an {@link AsyncFieldValidator} run is: sleep `debounceMs`
+* (a no-op at `0`, the default), then run `validator` and fold its output
+* into {@link FormIssue}s.
+*
+* The debounce is a plain {@link Effect.sleep}, so it rides Effect's `Clock`
+* — deterministic and instantly-advanceable under `TestClock` in tests, real
+* time otherwise (no `setTimeout` bookkeeping for a caller to manage).
+* "Latest wins" falls out of ordinary fiber interruption: a caller re-running
+* this on every keystroke forks a fresh fiber per call and interrupts the
+* previous one before forking the next — interrupting mid-sleep skips the
+* validator entirely (a true debounce, not just a discarded stale result),
+* and interrupting mid-validator aborts whatever the validator was doing
+* (e.g. an in-flight `fetch` wrapped as an Effect).
+*/
+function runAsyncFieldValidator(validator, value, debounceMs = 0) {
+	return Effect.gen(function* () {
+		if (debounceMs > 0) yield* Effect.sleep(Duration.millis(debounceMs));
+		return filterOutputToFormIssues(yield* validator(value));
+	});
+}
+/**
+* Pick `validators`' sync/async pair for `trigger` (TanStack's `onChange` /
+* `onBlur` vs `onChangeAsync` / `onBlurAsync`). A reactive store calls this
+* once per trigger instead of repeating the trigger ternary at each call
+* site — the pure decision half of what {@link module:effect-forms-svelte/FormStore}'s
+* field-trigger dispatch runs.
+*/
+function resolveFieldTrigger(validators, trigger) {
+	return {
+		sync: trigger === "change" ? validators?.onChange : validators?.onBlur,
+		async: trigger === "change" ? validators?.onChangeAsync : validators?.onBlurAsync,
+		asyncDebounceMs: validators?.asyncDebounceMs ?? 0
+	};
+}
+//#endregion
+export { Coerce_exports as Coerce, Command_exports as Command, Constraints_exports as Constraints, Errors_exports as Errors, Field_exports as Field, Form_exports as Form, FormBuilder_exports as FormBuilder, FormData_exports as FormData, Issues_exports as Issues, Mode_exports as Mode, Path_exports as Path, Result_exports as Result, State_exports as State, Validate_exports as Validate };
+
+//# sourceMappingURL=index.js.map