@shivaedev/form 0.0.0 → 0.6.2

package/dist/shape.js

@@ -0,0 +1,18 @@
+import { Data } from "effect";
+export class FieldFailure extends Data.TaggedError("FieldFailure") {
+}
+export class Invalid extends Data.TaggedError("Invalid") {
+}
+export function holder(values) {
+    return values;
+}
+export function fieldOf(ref) {
+    return ref;
+}
+export function choicesOf(choices) {
+    return choices;
+}
+export function checkOf(check) {
+    return check;
+}
+//# sourceMappingURL=shape.js.map

package/dist/shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape.js","sourceRoot":"","sources":["../src/shape.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAuD,MAAM,QAAQ,CAAC;AA0BnF,MAAM,OAAO,YAAa,SAAQ,IAAI,CAAC,WAAW,CAAC,cAAc,CAI/D;CAAG;AAEL,MAAM,OAAO,OAAQ,SAAQ,IAAI,CAAC,WAAW,CAAC,SAAS,CAErD;CAAG;AA0CL,MAAM,UAAU,MAAM,CAAC,MAAc;IACpC,OAAO,MAAM,CAAC;AACf,CAAC;AAGD,MAAM,UAAU,OAAO,CAAC,GAA6B;IACpD,OAAO,GAAG,CAAC;AACZ,CAAC;AAGD,MAAM,UAAU,SAAS,CAAC,OAAuC;IAChE,OAAO,OAAO,CAAC;AAChB,CAAC;AAGD,MAAM,UAAU,OAAO,CAAC,KAAc;IACrC,OAAO,KAAK,CAAC;AACd,CAAC"}

package/dist/statusOf.d.ts

@@ -0,0 +1,14 @@
+import * as Atom from "effect/reactivity/Atom";
+import { type KeySelectors, type PathMessage } from "./paths.ts";
+import type { Path } from "./shape.ts";
+export declare function statusOf(): {
+    attempt: () => void;
+    failures: Atom.Atom<Readonly<Record<string, string>>>;
+    note: (input: string | Path, message: string) => void;
+    paths: Atom.Atom<readonly PathMessage[]>;
+    rebase: (previous: unknown, next: unknown, keys: KeySelectors) => void;
+    submitted: Atom.Atom<boolean>;
+    touch: (name: string) => void;
+    touched: Atom.Atom<Readonly<Record<string, true>>>;
+};
+//# sourceMappingURL=statusOf.d.ts.map

package/dist/statusOf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statusOf.d.ts","sourceRoot":"","sources":["../src/statusOf.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,IAAI,MAAM,wBAAwB,CAAC;AAG/C,OAAO,EAAU,KAAK,YAAY,EAAE,KAAK,WAAW,EAAgB,MAAM,YAAY,CAAC;AAEvF,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAQvC,wBAAgB,QAAQ;mBAQT,IAAI;;kBAgBH,MAAM,GAAG,IAAI,WAAW,MAAM,KAAG,IAAI;;uBAQhC,OAAO,QAAQ,OAAO,QAAQ,YAAY,KAAG,IAAI;;kBAUtD,MAAM,KAAG,IAAI;;EAa5B"}

package/dist/statusOf.js

@@ -0,0 +1,60 @@
+import { Equal } from "effect";
+import * as Atom from "effect/reactivity/Atom";
+import * as AtomRef from "effect/reactivity/AtomRef";
+import { asPath, retainedPath } from "./paths.js";
+import { fromRef } from "./refs.js";
+export function statusOf() {
+    const state = AtomRef.make({
+        failures: [],
+        submitted: false,
+        touched: {},
+    });
+    const paths = fromRef(state.prop("failures"));
+    return {
+        attempt: () => {
+            state.update((current) => ({
+                ...current,
+                failures: [],
+                submitted: true,
+            }));
+        },
+        failures: Atom.map(paths, (entries) => {
+            const messages = Object.create(null);
+            for (const { path, message } of entries) {
+                if (!Object.hasOwn(messages, path[0])) {
+                    messages[path[0]] = message;
+                }
+            }
+            return messages;
+        }),
+        note: (input, message) => {
+            const path = asPath(input);
+            state.update((current) => ({
+                ...current,
+                failures: [...current.failures.filter((entry) => !Equal.equals(entry.path, path)), { message, path }],
+            }));
+        },
+        paths,
+        rebase: (previous, next, keys) => {
+            state.update((current) => ({
+                ...current,
+                failures: current.failures.flatMap((entry) => {
+                    const path = retainedPath(entry.path, previous, next, keys);
+                    return path === undefined ? [] : [{ ...entry, path }];
+                }),
+            }));
+        },
+        submitted: fromRef(state.prop("submitted")),
+        touch: (name) => {
+            state.update((current) => current.touched[name] === true && !current.failures.some((entry) => entry.path.length === 1 && entry.path[0] === name)
+                ? current
+                : {
+                    ...current,
+                    failures: current.failures.filter((entry) => entry.path.length !== 1 || entry.path[0] !== name),
+                    touched: { ...current.touched, [name]: true },
+                });
+        },
+        touched: fromRef(state.prop("touched")),
+    };
+}
+//# sourceMappingURL=statusOf.js.map

package/dist/statusOf.js.map

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

package/dist/trackRejections.d.ts

@@ -0,0 +1,5 @@
+import { Effect } from "effect";
+import { type Holder } from "./shape.ts";
+import type { statusOf } from "./statusOf.ts";
+export declare function trackRejections(values: Holder, selectors: Readonly<Record<string, unknown>> | undefined, status: ReturnType<typeof statusOf>): (submitted: unknown) => (cause: unknown) => Effect.Effect<void>;
+//# sourceMappingURL=trackRejections.d.ts.map

package/dist/trackRejections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackRejections.d.ts","sourceRoot":"","sources":["../src/trackRejections.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,EAAE,MAAM,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,eAOzH,OAAO,aACjB,OAAO,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAStC"}

package/dist/trackRejections.js

@@ -0,0 +1,20 @@
+import { Effect } from "effect";
+import { asPath, keySelector, retainedPath } from "./paths.js";
+import { FieldFailure } from "./shape.js";
+export function trackRejections(values, selectors, status) {
+    const keys = new Map(Object.entries(selectors ?? {}).map(([name, select]) => [name, keySelector(select)]));
+    let previous = values.value;
+    values.subscribe((next) => {
+        status.rebase(previous, next, keys);
+        previous = next;
+    });
+    return (submitted) => (cause) => Effect.sync(() => {
+        if (cause instanceof FieldFailure) {
+            const path = retainedPath(cause.segments ?? asPath(cause.path), submitted, values.value, keys);
+            if (path !== undefined) {
+                status.note(path, cause.message);
+            }
+        }
+    });
+}
+//# sourceMappingURL=trackRejections.js.map

package/dist/trackRejections.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackRejections.js","sourceRoot":"","sources":["../src/trackRejections.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAe,MAAM,YAAY,CAAC;AAGvD,MAAM,UAAU,eAAe,CAAC,MAAc,EAAE,SAAwD,EAAE,MAAmC;IAC5I,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3G,IAAI,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC;IAC5B,MAAM,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE;QACzB,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;QACpC,QAAQ,GAAG,IAAI,CAAC;IACjB,CAAC,CAAC,CAAC;IACH,OAAO,CAAC,SAAkB,EAAE,EAAE,CAC7B,CAAC,KAAc,EAAuB,EAAE,CACvC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE;QAChB,IAAI,KAAK,YAAY,YAAY,EAAE,CAAC;YACnC,MAAM,IAAI,GAAG,YAAY,CAAC,KAAK,CAAC,QAAQ,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;YAC/F,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;gBACxB,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;YAClC,CAAC;QACF,CAAC;IACF,CAAC,CAAC,CAAC;AACN,CAAC"}

package/package.json

@@ -1,10 +1,84 @@
 {
   "name": "@shivaedev/form",
-  "version": "0.0.0",
-  "description": "Placeholder for the ShivaeDev form package.",
-  "license": "MIT",
+  "version": "0.6.2",
+  "description": "Schema-derived Effect atom forms with optional React hooks",
+  "keywords": [
+    "effect"
+  ],
+  "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/form#readme",
+  "bugs": {
+    "url": "https://github.com/ShivaeDev/platform/issues"
+  },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ShivaeDev/platform.git"
+    "url": "git+https://github.com/ShivaeDev/platform.git",
+    "directory": "packages/form"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "imports": {
+    "#test/*": "./src/test-support/*",
+    "#*.ts": {
+      "source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
+  },
+  "exports": {
+    "./*.ts": {
+      "source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.spec.ts",
+    "!src/**/test-support",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@effect/atom-react": "4.0.5",
+    "@effect/vitest": "4.0.5",
+    "@shivaedev/quality": "0.41.1",
+    "@shivaedev/test": "0.9.0",
+    "@shivaedev/test-story": "0.20.1",
+    "@types/node": "24.19.2",
+    "@types/react": "19.3.0",
+    "effect": "4.0.5",
+    "react": "19.3.1",
+    "typescript": "7.0.2",
+    "vitest": "5.0.5"
+  },
+  "peerDependencies": {
+    "@effect/atom-react": "4.0.5",
+    "effect": "4.0.5",
+    "react": "19.3.1"
+  },
+  "peerDependenciesMeta": {
+    "@effect/atom-react": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc --project tsconfig.build.json",
+    "ready": "pnpm typecheck && pnpm test && pnpm build",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
   }
 }

package/src/client/react.ts

@@ -0,0 +1,54 @@
+import { useAtomRef, useAtomSet, useAtomValue } from "@effect/atom-react";
+import type * as AsyncResult from "effect/reactivity/AsyncResult";
+import { createContext, useCallback, useContext, useMemo } from "react";
+import type { DraftSession } from "#draftSession.ts";
+import type { DraftStorage, PersistedDraftConfig } from "#persistence.ts";
+import type { Encoded, FieldFailure, Fields, Form, Invalid, Name } from "#shape.ts";
+export const DraftSessionContext = createContext<DraftSession | undefined>(undefined);
+export interface BrowserDraftConfig extends Omit<PersistedDraftConfig, "storage"> {
+	readonly storage?: () => DraftStorage;
+}
+function browserStorage(): DraftStorage {
+	return globalThis.localStorage;
+}
+export function usePersistedDraft(config: BrowserDraftConfig): PersistedDraftConfig;
+export function usePersistedDraft(config: BrowserDraftConfig | undefined): PersistedDraftConfig | undefined;
+export function usePersistedDraft(config: BrowserDraftConfig | undefined): PersistedDraftConfig | undefined {
+	const session = useContext(DraftSessionContext);
+	return config ? { ...config, session: session ?? config.session, storage: config.storage ?? browserStorage } : undefined;
+}
+export interface Field<TFields extends Fields, TKey extends Name<TFields>> {
+	readonly choices: readonly Encoded<TFields>[TKey][] | undefined;
+	readonly error: string | undefined;
+	readonly name: TKey;
+	readonly onBlur: () => void;
+	readonly onChange: (value: Encoded<TFields>[TKey]) => void;
+	readonly value: Encoded<TFields>[TKey];
+}
+export function useField<TFields extends Fields, A, E, TRuntimeError, TKey extends Name<TFields>>(
+	form: Form<TFields, A, E, TRuntimeError>,
+	name: TKey,
+): Field<TFields, TKey> {
+	const value = useAtomRef(form.field(name));
+	const error = useAtomValue(form.error(name));
+	const onChange = useCallback((next: Encoded<TFields>[TKey]) => form.change(name, next), [form, name]);
+	const onBlur = useCallback(() => form.blur(name), [form, name]);
+	const choices = useMemo(() => form.choices(name), [form, name]);
+	return { choices, error, name, onBlur, onChange, value };
+}
+export interface Submit<A, E> {
+	readonly result: AsyncResult.AsyncResult<A, E>;
+	readonly run: () => void;
+	readonly submitting: boolean;
+}
+export function useSubmit<TFields extends Fields, A, E, TRuntimeError>(
+	form: Form<TFields, A, E, TRuntimeError>,
+): Submit<A, E | TRuntimeError | FieldFailure | Invalid> {
+	const result = useAtomValue(form.submit);
+	const set = useAtomSet(form.submit);
+	const run = useCallback(() => set(), [set]);
+	return { result, run, submitting: result.waiting };
+}
+export function useDirty<TFields extends Fields, A, E, TRuntimeError>(form: Form<TFields, A, E, TRuntimeError>): boolean {
+	return useAtomValue(form.dirty);
+}

package/src/draft.ts

@@ -0,0 +1,98 @@
+import { Equal } from "effect";
+import * as Atom from "effect/reactivity/Atom";
+import * as AtomRef from "effect/reactivity/AtomRef";
+import type { Persistence } from "./persistence.ts";
+
+type Entries = Readonly<Record<string, unknown>>;
+
+interface Draft<TValues> {
+	readonly baseline: TValues;
+	readonly current: TValues;
+	readonly settled: Entries;
+}
+
+const none: Entries = {};
+
+function untouched({ baseline, current, settled }: Draft<Entries>, name: string): boolean {
+	return Equal.equals(current[name], baseline[name]) || (Object.hasOwn(settled, name) && Equal.equals(current[name], settled[name]));
+}
+
+function changed(held: Draft<Entries>): boolean {
+	return Object.keys({ ...held.baseline, ...held.current }).some((name) => !untouched(held, name));
+}
+
+function merged<TValues>(held: Draft<TValues>, incoming: TValues): TValues;
+function merged(held: Draft<Entries>, incoming: Entries): unknown {
+	const result: Record<string, unknown> = {};
+	for (const name of Object.keys({ ...held.current, ...incoming })) {
+		const source = untouched(held, name) ? incoming : held.current;
+		if (Object.hasOwn(source, name)) {
+			result[name] = source[name];
+		}
+	}
+	return result;
+}
+
+function matching(current: Entries, submitted: Entries): Entries {
+	return Object.fromEntries(
+		Object.keys({ ...current, ...submitted })
+			.filter((name) => Equal.equals(current[name], submitted[name]))
+			.map((name) => [name, submitted[name]]),
+	);
+}
+
+export function draft<TValues extends Entries>(initial: TValues, persistence?: Persistence<TValues>) {
+	const restored = persistence?.read();
+	const loaded = {
+		baseline: restored?.baseline ?? initial,
+		current: restored?.values ?? initial,
+		settled: restored ? Object.fromEntries(Object.entries(restored.values).filter(([name]) => !restored.edited.includes(name))) : none,
+	};
+	const state = AtomRef.make<Draft<TValues>>({
+		baseline: initial,
+		current: restored ? merged(loaded, initial) : initial,
+		settled: none,
+	});
+	if (persistence) {
+		state.subscribe((value) => {
+			if (changed(value)) {
+				const edited = Object.keys({ ...value.baseline, ...value.current }).filter((name) => !untouched(value, name));
+				persistence.write({ ...value.baseline, ...value.settled }, value.current, edited);
+			} else {
+				persistence.clear();
+			}
+		});
+	}
+	return {
+		dirty: Atom.readable((get) => {
+			get.addFinalizer(state.subscribe((value) => get.setSelf(changed(value))));
+			return changed(state.value);
+		}),
+		receive: (incoming: TValues): void => {
+			state.update((held) => ({
+				baseline: incoming,
+				current: changed(held) ? merged(held, incoming) : incoming,
+				settled: none,
+			}));
+		},
+		revert: (): void => {
+			state.update((held) => ({
+				...held,
+				current: held.baseline,
+				settled: none,
+			}));
+		},
+		submission: () => {
+			const { baseline, current: submitted } = state.value;
+			return {
+				accept: (): void => {
+					state.update((held) =>
+						held.baseline === baseline ? { ...held, baseline: submitted, settled: none } : { ...held, settled: matching(held.current, submitted) },
+					);
+				},
+				values: submitted,
+			};
+		},
+		values: state.prop("current"),
+	};
+}

package/src/draftSession.ts

@@ -0,0 +1,29 @@
+export interface DraftSession {
+	readonly active: boolean;
+	readonly drop: () => void;
+	readonly id: string;
+	readonly track: (key: string, clear: () => void) => void;
+}
+
+export function draftSession(id: string): DraftSession {
+	const drafts = new Map<string, () => void>();
+	let active = true;
+	return {
+		get active() {
+			return active;
+		},
+		drop: () => {
+			active = false;
+			for (const clear of drafts.values()) {
+				clear();
+			}
+			drafts.clear();
+		},
+		id,
+		track: (key, clear) => {
+			if (active) {
+				drafts.set(key, clear);
+			}
+		},
+	};
+}

package/src/emptyAsNull.ts

@@ -0,0 +1,12 @@
+import { Schema, SchemaGetter } from "effect";
+
+export function emptyAsNull<TSchema extends Schema.Constraint & Schema.Top>(
+	inner: TSchema,
+): Schema.Codec<TSchema["Type"] | null, TSchema["Encoded"] | "", TSchema["DecodingServices"], TSchema["EncodingServices"]> {
+	return Schema.Union([Schema.Literal(""), inner]).pipe(
+		Schema.decodeTo(Schema.NullOr(Schema.toType(inner)), {
+			decode: SchemaGetter.transform((value) => (value === "" ? null : value)),
+			encode: SchemaGetter.transform((value) => (value === null ? "" : value)),
+		}),
+	);
+}

package/src/form.ts

@@ -0,0 +1,142 @@
+import { Effect, Equal, Result, type Schema, type SchemaIssue, SchemaParser } from "effect";
+import * as AsyncResult from "effect/reactivity/AsyncResult";
+import * as Atom from "effect/reactivity/Atom";
+import type * as AtomRef from "effect/reactivity/AtomRef";
+import { draft } from "./draft.ts";
+import { literalChoices, messageAt, messagesByField, schemaFeedback } from "./messages.ts";
+import { pathMessageAt } from "./paths.ts";
+import { persistence } from "./persistence.ts";
+import { fromRef, propertyRef } from "./refs.ts";
+import {
+	type Config,
+	checkOf,
+	choicesOf,
+	type Decoded,
+	type Encoded,
+	FieldFailure,
+	type Fields,
+	type Form,
+	fieldOf,
+	holder,
+	Invalid,
+	type Name,
+	type Submitter,
+} from "./shape.ts";
+import { statusOf } from "./statusOf.ts";
+import { trackRejections } from "./trackRejections.ts";
+
+export function form<TFields extends Fields, TValue, TError, TServices, TRuntimeError>(
+	schema: Schema.Struct<TFields>,
+	config: Config<TFields, TValue, TError, TServices, TRuntimeError>,
+): Form<TFields, TValue, TError, TRuntimeError> {
+	const { initialValues, onSubmit, runtime } = config;
+	const debounce = config.debounce ?? "300 millis";
+	const checks: ReadonlyMap<string, unknown> = new Map(Object.entries(config.checks ?? {}));
+	const decode = SchemaParser.decodeUnknownEffect(schema, { errors: "all" });
+
+	const editing = draft(initialValues, config.persistedDraft ? persistence(schema, config.persistedDraft) : undefined);
+	const { values } = editing;
+	const status = statusOf();
+	const noted = trackRejections(holder(values), config.arrayKeys, status);
+	const held = new Map<string, AtomRef.AtomRef<unknown>>();
+	function refFor(name: string): AtomRef.AtomRef<unknown> {
+		const known = held.get(name);
+		if (known !== undefined) {
+			return known;
+		}
+		const made = propertyRef(holder(values), name);
+		held.set(name, made);
+		return made;
+	}
+
+	const offered = new Map<string, readonly unknown[]>();
+	for (const [name, member] of Object.entries(schema.fields)) {
+		const choices = literalChoices(member.ast);
+		if (choices !== undefined) {
+			offered.set(name, choices);
+		}
+	}
+
+	const valuesAtom = fromRef(values);
+
+	const decoded = runtime.atom((get) =>
+		decode(get(valuesAtom)).pipe(
+			Effect.match({
+				onFailure: (issue): Result.Result<Decoded<TFields>, SchemaIssue.Issue> => Result.fail(issue),
+				onSuccess: (value): Result.Result<Decoded<TFields>, SchemaIssue.Issue> => Result.succeed(value),
+			}),
+		),
+	);
+
+	const schemaErrors = schemaFeedback(decoded);
+
+	const checkError = Atom.family((name: string): Atom.Atom<string | undefined> => {
+		const check = checks.get(name);
+		if (check === undefined) {
+			return Atom.make((): string | undefined => undefined);
+		}
+		const current = fromRef(refFor(name));
+		const settled = Atom.debounce(current, debounce);
+		const answered = runtime.atom((get) => {
+			const input = get(settled);
+			return Effect.map(checkOf<TServices>(check)(input), (message) => ({
+				input,
+				message,
+			}));
+		});
+		return Atom.readable((get): string | undefined => {
+			const result = get(answered);
+			const value = get(current);
+			return AsyncResult.isSuccess(result) && !result.waiting && Equal.equals(result.value.input, value) ? result.value.message : undefined;
+		});
+	});
+
+	const error = Atom.family((name: string) =>
+		Atom.readable((get): string | undefined => {
+			if (get(status.touched)[name] !== true && !get(status.submitted)) {
+				return undefined;
+			}
+			return messageAt(get(status.failures), name) ?? get(schemaErrors.field(name)) ?? get(checkError(name));
+		}),
+	);
+
+	const submitter: Submitter<Name<TFields>> = {
+		fail: (path, message) => Effect.fail(new FieldFailure(typeof path === "string" ? { message, path } : { message, path: path[0], segments: path })),
+	};
+
+	const submit = runtime.fn<void>()(() =>
+		Effect.gen(function* () {
+			status.attempt();
+			const submission = editing.submission();
+			const submitted = submission.values;
+			const value = yield* decode(submitted).pipe(Effect.mapError((issue) => new Invalid({ messages: messagesByField(issue) })));
+			return yield* onSubmit(value, submitter, submitted).pipe(
+				Effect.tapError(noted(submitted)),
+				Effect.tap(() => Effect.sync(submission.accept)),
+			);
+		}),
+	);
+
+	return {
+		blur: status.touch,
+		change: (name, value) => {
+			refFor(name).set(value);
+			status.touch(name);
+		},
+		choices: <TName extends Name<TFields>>(name: TName) => choicesOf<Encoded<TFields>[TName]>(offered.get(name)),
+		dirty: editing.dirty,
+		error,
+		errorAt: Atom.family((path: readonly [Name<TFields>, ...PropertyKey[]]) => {
+			const message = schemaErrors.at(path);
+			return Atom.readable((get) =>
+				get(status.touched)[path[0]] === true || get(status.submitted) ? (pathMessageAt(get(status.paths), path) ?? get(message)) : undefined,
+			);
+		}),
+		field: <TName extends Name<TFields>>(name: TName) => fieldOf<Encoded<TFields>[TName]>(refFor(name)),
+		receive: editing.receive,
+		revert: editing.revert,
+		submit,
+		submitting: Atom.map(submit, AsyncResult.isWaiting),
+		values,
+	};
+}