@shivaedev/effect-form 0.0.0 → 0.1.1

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;AAiBnF,MAAM,OAAO,YAAa,SAAQ,IAAI,CAAC,WAAW,CAAC,cAAc,CAG/D;CAAG;AAEL,MAAM,OAAO,OAAQ,SAAQ,IAAI,CAAC,WAAW,CAAC,SAAS,CAErD;CAAG;AAuCL,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/status.d.ts

@@ -0,0 +1,9 @@
+export declare const statusOf: () => {
+    attempt: () => void;
+    failures: import("effect/unstable/reactivity/Atom").Atom<Readonly<Record<string, string>>>;
+    note: (path: string, message: string) => void;
+    submitted: import("effect/unstable/reactivity/Atom").Atom<boolean>;
+    touch: (name: string) => void;
+    touched: import("effect/unstable/reactivity/Atom").Atom<Readonly<Record<string, true>>>;
+};
+//# sourceMappingURL=status.d.ts.map

package/dist/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../src/status.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,QAAQ;mBAON,IAAI;;iBAQJ,MAAM,WAAW,MAAM,KAAG,IAAI;;kBAO7B,MAAM,KAAG,IAAI;;CAa5B,CAAC"}

package/dist/status.js

@@ -0,0 +1,38 @@
+import * as AtomRef from "effect/unstable/reactivity/AtomRef";
+import { noMessages, withoutField } from "./messages.js";
+import { fromRef } from "./refs.js";
+export const statusOf = () => {
+    const state = AtomRef.make({
+        failures: noMessages,
+        submitted: false,
+        touched: {},
+    });
+    return {
+        attempt: () => {
+            state.update((current) => ({
+                ...current,
+                failures: noMessages,
+                submitted: true,
+            }));
+        },
+        failures: fromRef(state.prop("failures")),
+        note: (path, message) => {
+            state.update((current) => ({
+                ...current,
+                failures: { ...current.failures, [path]: message },
+            }));
+        },
+        submitted: fromRef(state.prop("submitted")),
+        touch: (name) => {
+            state.update((current) => current.touched[name] === true && !Object.hasOwn(current.failures, name)
+                ? current
+                : {
+                    ...current,
+                    failures: withoutField(current.failures, name),
+                    touched: { ...current.touched, [name]: true },
+                });
+        },
+        touched: fromRef(state.prop("touched")),
+    };
+};
+//# sourceMappingURL=status.js.map

package/dist/status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.js","sourceRoot":"","sources":["../src/status.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,oCAAoC,CAAC;AAC9D,OAAO,EAAsB,UAAU,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQpC,MAAM,CAAC,MAAM,QAAQ,GAAG,GAAG,EAAE;IAC5B,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,CAAQ;QACjC,QAAQ,EAAE,UAAU;QACpB,SAAS,EAAE,KAAK;QAChB,OAAO,EAAE,EAAE;KACX,CAAC,CAAC;IACH,OAAO;QACN,OAAO,EAAE,GAAS,EAAE;YACnB,KAAK,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;gBAC1B,GAAG,OAAO;gBACV,QAAQ,EAAE,UAAU;gBACpB,SAAS,EAAE,IAAI;aACf,CAAC,CAAC,CAAC;QACL,CAAC;QACD,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACzC,IAAI,EAAE,CAAC,IAAY,EAAE,OAAe,EAAQ,EAAE;YAC7C,KAAK,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;gBAC1B,GAAG,OAAO;gBACV,QAAQ,EAAE,EAAE,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE;aAClD,CAAC,CAAC,CAAC;QACL,CAAC;QACD,SAAS,EAAE,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC3C,KAAK,EAAE,CAAC,IAAY,EAAQ,EAAE;YAC7B,KAAK,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CACxB,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,IAAI,CAAC;gBACvE,CAAC,CAAC,OAAO;gBACT,CAAC,CAAC;oBACA,GAAG,OAAO;oBACV,QAAQ,EAAE,YAAY,CAAC,OAAO,CAAC,QAAQ,EAAE,IAAI,CAAC;oBAC9C,OAAO,EAAE,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE;iBAC7C,CACH,CAAC;QACH,CAAC;QACD,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;KACvC,CAAC;AACH,CAAC,CAAC"}

package/package.json

@@ -1,14 +1,78 @@
 {
   "name": "@shivaedev/effect-form",
-  "version": "0.0.0",
-  "description": "Name reservation. The first release is published from https://github.com/ShivaeDev/platform.",
+  "version": "0.1.1",
+  "description": "Schema-derived Effect atom forms with optional React hooks",
+  "type": "module",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShivaeDev/platform.git",
     "directory": "packages/effect-form"
   },
+  "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/effect-form#readme",
+  "bugs": {
+    "url": "https://github.com/ShivaeDev/platform/issues"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "source": "./src/index.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json",
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "source": "./src/react.ts",
+      "import": "./dist/react.js",
+      "default": "./dist/react.js"
+    }
+  },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
+  },
+  "peerDependencies": {
+    "effect": "4.0.0-rc.112",
+    "@effect/atom-react": "4.0.0-rc.112",
+    "react": "19.2.8"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "@effect/atom-react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@effect/vitest": "4.0.0-rc.112",
+    "@types/node": "24.10.1",
+    "@typescript/native": "npm:typescript@7.0.2",
+    "effect": "4.0.0-rc.112",
+    "typescript": "npm:@typescript/typescript6@6.0.2",
+    "vitest": "4.1.9",
+    "@effect/atom-react": "4.0.0-rc.112",
+    "react": "19.2.8",
+    "@types/react": "19.2.18"
+  },
+  "scripts": {
+    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc6 --project tsconfig.build.json",
+    "check": "biome check .",
+    "test": "vitest run",
+    "test:package": "node scripts/test-package.mjs",
+    "typecheck": "tsc --noEmit",
+    "typecheck:compat": "tsc6 --noEmit",
+    "ready": "pnpm check && pnpm typecheck && pnpm typecheck:compat && pnpm test && pnpm build && pnpm test:package"
   }
-}
+}

package/src/draft.ts

@@ -0,0 +1,77 @@
+import { Equal } from "effect";
+import * as Atom from "effect/unstable/reactivity/Atom";
+import * as AtomRef from "effect/unstable/reactivity/AtomRef";
+
+type Entries = Readonly<Record<string, unknown>>;
+
+interface Draft<Values> {
+	readonly baseline: Values;
+	readonly current: Values;
+	readonly settled: Entries;
+}
+
+const none: Entries = {};
+
+const untouched = ({ baseline, current, settled }: Draft<Entries>, name: string): boolean =>
+	Equal.equals(current[name], baseline[name]) || (Object.hasOwn(settled, name) && Equal.equals(current[name], settled[name]));
+
+const changed = (held: Draft<Entries>): boolean => Object.keys({ ...held.baseline, ...held.current }).some((name) => !untouched(held, name));
+
+function merged<Values>(held: Draft<Values>, incoming: Values): Values;
+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;
+}
+
+const matching = (current: Entries, submitted: Entries): Entries =>
+	Object.fromEntries(
+		Object.keys({ ...current, ...submitted })
+			.filter((name) => Equal.equals(current[name], submitted[name]))
+			.map((name) => [name, submitted[name]]),
+	);
+
+export const draft = <Values extends Entries>(initial: Values) => {
+	const state = AtomRef.make<Draft<Values>>({
+		baseline: initial,
+		current: initial,
+		settled: none,
+	});
+	return {
+		dirty: Atom.readable((get) => {
+			get.addFinalizer(state.subscribe((value) => get.setSelf(changed(value))));
+			return changed(state.value);
+		}),
+		receive: (incoming: Values): 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/form.ts

@@ -0,0 +1,145 @@
+import { Effect, Equal, Option, Result, type Schema, SchemaParser } from "effect";
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+import * as Atom from "effect/unstable/reactivity/Atom";
+import type * as AtomRef from "effect/unstable/reactivity/AtomRef";
+import { draft } from "./draft.ts";
+import { type FieldMessages, literalChoices, messageAt, messagesByField, noMessages } from "./messages.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 "./status.ts";
+
+export const make = <F extends Fields, A, E, R, ER>(schema: Schema.Struct<F>, config: Config<F, A, E, R, ER>): Form<F, A, E, ER> => {
+	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);
+	const { values } = editing;
+	const status = statusOf();
+	const held = new Map<string, AtomRef.AtomRef<unknown>>();
+	const 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<F>, FieldMessages> => Result.fail(messagesByField(issue)),
+				onSuccess: (value): Result.Result<Decoded<F>, FieldMessages> => Result.succeed(value),
+			}),
+		),
+	);
+
+	const schemaMessages = Atom.map(decoded, (result) =>
+		Option.match(AsyncResult.value(result), {
+			onNone: () => noMessages,
+			onSome: (either) => (Result.isFailure(either) ? either.failure : noMessages),
+		}),
+	);
+
+	const schemaError = Atom.family((name: string) => Atom.map(schemaMessages, (messages) => messageAt(messages, name)));
+
+	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<R>(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(schemaError(name)) ?? get(checkError(name));
+		}),
+	);
+
+	const noted =
+		(submitted: Encoded<F>) =>
+		(cause: E | FieldFailure): Effect.Effect<void> =>
+			Effect.sync(() => {
+				if (cause instanceof FieldFailure && Equal.equals(refFor(cause.path).value, new Map(Object.entries(submitted)).get(cause.path))) {
+					status.note(cause.path, cause.message);
+				}
+			});
+
+	const submitter: Submitter<Name<F>> = {
+		fail: (path, message) => Effect.fail(new FieldFailure({ message, 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: <K extends Name<F>>(name: K) => choicesOf<Encoded<F>[K]>(offered.get(name)),
+		dirty: editing.dirty,
+		error,
+		field: <K extends Name<F>>(name: K) => fieldOf<Encoded<F>[K]>(refFor(name)),
+		receive: editing.receive,
+		revert: editing.revert,
+		submit,
+		submitting: Atom.map(submit, AsyncResult.isWaiting),
+		values,
+	};
+};

package/src/index.ts

@@ -0,0 +1,15 @@
+export { make } from "./form.ts";
+export type { FieldMessages } from "./messages.ts";
+export { emptyAsNull } from "./optional.ts";
+export type {
+	Checks,
+	Config,
+	Decoded,
+	Encoded,
+	Fields,
+	Form,
+	Name,
+	Services,
+	Submitter,
+} from "./shape.ts";
+export { FieldFailure, Invalid } from "./shape.ts";

package/src/messages.ts

@@ -0,0 +1,73 @@
+import { SchemaAST, SchemaIssue, type StandardSchema } from "effect";
+
+export type FieldMessages = Readonly<Record<string, string>>;
+
+export const noMessages: FieldMessages = {};
+
+const REQUIRED = "Required";
+
+const MINIMUM_LENGTH = "effect/schema/isMinLength";
+
+const refusesEmpty = (check: SchemaAST.Filter<unknown>): boolean => {
+	const representation = check.annotations?.representation;
+	if (representation === undefined || representation.id !== MINIMUM_LENGTH) {
+		return false;
+	}
+	const payload = representation.payload;
+	if (typeof payload !== "object" || payload === null || !("minLength" in payload)) {
+		return false;
+	}
+	return payload.minLength === 1;
+};
+
+const checkHook: SchemaIssue.CheckHook = (issue) => SchemaIssue.defaultCheckHook(issue) ?? (refusesEmpty(issue.filter) ? REQUIRED : undefined);
+
+const formatIssue = SchemaIssue.makeFormatterStandardSchemaV1({ checkHook });
+
+const segmentKey = (segment: PropertyKey | StandardSchema.StandardSchemaV1.PathSegment): string =>
+	typeof segment === "object" ? String(segment.key) : String(segment);
+
+export const messagesByField = (issue: SchemaIssue.Issue): FieldMessages => {
+	const messages: Record<string, string> = Object.create(null);
+	for (const entry of formatIssue(issue).issues) {
+		const head = entry.path?.[0];
+		if (head === undefined) {
+			continue;
+		}
+		const name = segmentKey(head);
+		if (!Object.hasOwn(messages, name)) {
+			messages[name] = entry.message;
+		}
+	}
+	return messages;
+};
+
+export const withoutField = (messages: FieldMessages, name: string): FieldMessages => {
+	if (!Object.hasOwn(messages, name)) {
+		return messages;
+	}
+	const next: Record<string, string> = Object.create(null);
+	for (const [key, message] of Object.entries(messages)) {
+		if (key !== name) {
+			next[key] = message;
+		}
+	}
+	return next;
+};
+
+export const literalChoices = (input: SchemaAST.AST): readonly SchemaAST.LiteralValue[] | undefined => {
+	const ast = SchemaAST.toEncoded(input);
+	if (ast._tag !== "Union") {
+		return undefined;
+	}
+	const choices: SchemaAST.LiteralValue[] = [];
+	for (const member of ast.types) {
+		if (member._tag !== "Literal") {
+			return undefined;
+		}
+		choices.push(member.literal);
+	}
+	return choices;
+};
+
+export const messageAt = (messages: FieldMessages, name: string): string | undefined => (Object.hasOwn(messages, name) ? messages[name] : undefined);

package/src/optional.ts

@@ -0,0 +1,11 @@
+import { Schema, SchemaGetter } from "effect";
+
+export const emptyAsNull = <S extends Schema.Constraint & Schema.Top>(
+	inner: S,
+): Schema.Codec<S["Type"] | null, S["Encoded"] | "", S["DecodingServices"], S["EncodingServices"]> =>
+	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/react.ts

@@ -0,0 +1,37 @@
+import { useAtomRef, useAtomSet, useAtomValue } from "@effect/atom-react";
+import type * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+import { useCallback, useMemo } from "react";
+import type { Encoded, FieldFailure, Fields, Form, Invalid, Name } from "./shape.ts";
+
+export interface Field<F extends Fields, K extends Name<F>> {
+	readonly choices: readonly Encoded<F>[K][] | undefined;
+	readonly error: string | undefined;
+	readonly name: K;
+	readonly onBlur: () => void;
+	readonly onChange: (value: Encoded<F>[K]) => void;
+	readonly value: Encoded<F>[K];
+}
+
+export const useField = <F extends Fields, A, E, ER, K extends Name<F>>(form: Form<F, A, E, ER>, name: K): Field<F, K> => {
+	const value = useAtomRef(form.field(name));
+	const error = useAtomValue(form.error(name));
+	const onChange = useCallback((next: Encoded<F>[K]) => 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 const useSubmit = <F extends Fields, A, E, ER>(form: Form<F, A, E, ER>): Submit<A, E | ER | FieldFailure | Invalid> => {
+	const result = useAtomValue(form.submit);
+	const set = useAtomSet(form.submit);
+	const run = useCallback(() => set(), [set]);
+	return { result, run, submitting: result.waiting };
+};
+
+export const useDirty = <F extends Fields, A, E, ER>(form: Form<F, A, E, ER>): boolean => useAtomValue(form.dirty);

package/src/refs.ts

@@ -0,0 +1,33 @@
+import { Equal, Hash } from "effect";
+import * as Atom from "effect/unstable/reactivity/Atom";
+import * as AtomRef from "effect/unstable/reactivity/AtomRef";
+
+export const fromRef = <A>(ref: AtomRef.ReadonlyRef<A>): Atom.Atom<A> =>
+	Atom.readable((get) => {
+		get.addFinalizer(ref.subscribe((value) => get.setSelf(value)));
+		return ref.value;
+	});
+
+// Native prop refs retain removed keys; form fields must observe their absence.
+export const propertyRef = <A, K extends keyof A>(parent: AtomRef.AtomRef<A>, name: K): AtomRef.AtomRef<A[K]> => {
+	const read = parent.map((value) => value[name]);
+	const write = parent.prop(name);
+	const ref: AtomRef.AtomRef<A[K]> = {
+		[AtomRef.TypeId]: AtomRef.TypeId,
+		[Equal.symbol]: (other) => Equal.equals(read, other),
+		[Hash.symbol]: () => Hash.hash(read),
+		key: read.key,
+		get value() {
+			return read.value;
+		},
+		subscribe: (listener) => read.subscribe(listener),
+		map: (transform) => read.map(transform),
+		prop: (key) => propertyRef(ref, key),
+		set: (value) => {
+			write.set(value);
+			return ref;
+		},
+		update: (transform) => ref.set(transform(read.value)),
+	};
+	return ref;
+};

package/src/shape.ts

@@ -0,0 +1,81 @@
+import { Data, type Duration, type Effect, type Schema, type Scope } from "effect";
+import type * as Atom from "effect/unstable/reactivity/Atom";
+import type * as AtomRef from "effect/unstable/reactivity/AtomRef";
+import type { AtomRegistry } from "effect/unstable/reactivity/AtomRegistry";
+import type { Reactivity } from "effect/unstable/reactivity/Reactivity";
+import type { FieldMessages } from "./messages.ts";
+
+export type Fields = Schema.Struct.Fields;
+
+export type Encoded<F extends Fields> = Schema.Struct.Encoded<F>;
+
+export type Decoded<F extends Fields> = Schema.Struct.Type<F>;
+
+export type Name<F extends Fields> = keyof Encoded<F> & string;
+
+export type Services<F extends Fields, R> = R | Schema.Struct.DecodingServices<F>;
+
+export class FieldFailure extends Data.TaggedError("FieldFailure")<{
+	readonly message: string;
+	readonly path: string;
+}> {}
+
+export class Invalid extends Data.TaggedError("Invalid")<{
+	readonly messages: FieldMessages;
+}> {}
+
+export interface Submitter<N extends string> {
+	readonly fail: (path: N, message: string) => Effect.Effect<never, FieldFailure>;
+}
+
+export type Checks<F extends Fields, R> = {
+	readonly [K in Name<F>]?: (value: Encoded<F>[K]) => Effect.Effect<string | undefined, never, R>;
+};
+
+export interface Config<F extends Fields, A, E, R, ER> {
+	readonly checks?: Checks<F, R>;
+	readonly debounce?: Duration.Input;
+	readonly initialValues: Encoded<F>;
+	readonly onSubmit: (
+		values: Decoded<F>,
+		submitter: Submitter<Name<F>>,
+		submitted: Encoded<F>,
+	) => Effect.Effect<A, E, R | Scope.Scope | AtomRegistry | Reactivity>;
+	readonly runtime: Atom.AtomRuntime<Services<F, R>, ER>;
+}
+
+export interface Form<F extends Fields, A, E, ER> {
+	readonly blur: (name: Name<F>) => void;
+	readonly change: <K extends Name<F>>(name: K, value: Encoded<F>[K]) => void;
+	readonly choices: <K extends Name<F>>(name: K) => readonly Encoded<F>[K][] | undefined;
+	readonly dirty: Atom.Atom<boolean>;
+	readonly error: (name: Name<F>) => Atom.Atom<string | undefined>;
+	readonly field: <K extends Name<F>>(name: K) => AtomRef.AtomRef<Encoded<F>[K]>;
+	readonly receive: (values: Encoded<F>) => void;
+	readonly revert: () => void;
+	readonly submit: Atom.AtomResultFn<void, A, E | ER | FieldFailure | Invalid>;
+	readonly submitting: Atom.Atom<boolean>;
+	readonly values: AtomRef.AtomRef<Encoded<F>>;
+}
+
+export type Holder = AtomRef.AtomRef<Readonly<Record<string, unknown>>>;
+
+export function holder(values: object): Holder;
+export function holder(values: object): unknown {
+	return values;
+}
+
+export function fieldOf<Value>(ref: AtomRef.AtomRef<unknown>): AtomRef.AtomRef<Value>;
+export function fieldOf(ref: AtomRef.AtomRef<unknown>): unknown {
+	return ref;
+}
+
+export function choicesOf<Value>(choices: readonly unknown[] | undefined): readonly Value[] | undefined;
+export function choicesOf(choices: readonly unknown[] | undefined): unknown {
+	return choices;
+}
+
+export function checkOf<R>(check: unknown): (value: unknown) => Effect.Effect<string | undefined, never, R>;
+export function checkOf(check: unknown): unknown {
+	return check;
+}