@shivaedev/effect-react 0.2.1 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivaedev/effect-react",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "React query, action, editor and session hooks for native Effect atoms",
   "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/effect-react#readme",
   "bugs": {
@@ -20,19 +20,105 @@
       "source": "./src/*.ts",
       "types": "./dist/*.d.ts",
       "default": "./dist/*.js"
+    },
+    "#create.ts": {
+      "source": "./src/client/create.ts",
+      "types": "./dist/client/create.d.ts",
+      "default": "./dist/client/create.js"
+    },
+    "#editor.ts": {
+      "source": "./src/client/editor.ts",
+      "types": "./dist/client/editor.d.ts",
+      "default": "./dist/client/editor.js"
+    },
+    "#result-state.ts": {
+      "source": "./src/client/resultState.ts",
+      "types": "./dist/client/resultState.d.ts",
+      "default": "./dist/client/resultState.js"
+    },
+    "#save-state.ts": {
+      "source": "./src/client/saveState.ts",
+      "types": "./dist/client/saveState.d.ts",
+      "default": "./dist/client/saveState.js"
+    },
+    "#session-boundary.ts": {
+      "source": "./src/client/sessionBoundary.ts",
+      "types": "./dist/client/sessionBoundary.d.ts",
+      "default": "./dist/client/sessionBoundary.js"
+    },
+    "#testing.ts": {
+      "source": "./src/client/testing.ts",
+      "types": "./dist/client/testing.d.ts",
+      "default": "./dist/client/testing.js"
     }
   },
   "exports": {
-    "./*.ts": {
-      "types": "./dist/*.d.ts",
-      "source": "./src/*.ts",
-      "import": "./dist/*.js",
-      "default": "./dist/*.js"
+    "./package.json": "./package.json",
+    "./router.ts": {
+      "types": "./dist/loadQuery.d.ts",
+      "source": "./src/loadQuery.ts",
+      "import": "./dist/loadQuery.js",
+      "default": "./dist/loadQuery.js"
+    },
+    "./loadQuery.ts": null,
+    "./create.ts": {
+      "types": "./dist/client/create.d.ts",
+      "source": "./src/client/create.ts",
+      "import": "./dist/client/create.js",
+      "default": "./dist/client/create.js"
+    },
+    "./editor.ts": {
+      "types": "./dist/client/editor.d.ts",
+      "source": "./src/client/editor.ts",
+      "import": "./dist/client/editor.js",
+      "default": "./dist/client/editor.js"
+    },
+    "./field-rejection.ts": {
+      "types": "./dist/field-rejection.d.ts",
+      "source": "./src/field-rejection.ts",
+      "import": "./dist/field-rejection.js",
+      "default": "./dist/field-rejection.js"
+    },
+    "./result-state.ts": {
+      "types": "./dist/client/resultState.d.ts",
+      "source": "./src/client/resultState.ts",
+      "import": "./dist/client/resultState.js",
+      "default": "./dist/client/resultState.js"
+    },
+    "./resume-signal.ts": {
+      "types": "./dist/resume-signal.d.ts",
+      "source": "./src/resume-signal.ts",
+      "import": "./dist/resume-signal.js",
+      "default": "./dist/resume-signal.js"
     },
-    "./package.json": "./package.json"
+    "./save-state.ts": {
+      "types": "./dist/client/saveState.d.ts",
+      "source": "./src/client/saveState.ts",
+      "import": "./dist/client/saveState.js",
+      "default": "./dist/client/saveState.js"
+    },
+    "./session-boundary.ts": {
+      "types": "./dist/client/sessionBoundary.d.ts",
+      "source": "./src/client/sessionBoundary.ts",
+      "import": "./dist/client/sessionBoundary.js",
+      "default": "./dist/client/sessionBoundary.js"
+    },
+    "./submission.ts": {
+      "types": "./dist/submission.d.ts",
+      "source": "./src/submission.ts",
+      "import": "./dist/submission.js",
+      "default": "./dist/submission.js"
+    },
+    "./testing.ts": {
+      "types": "./dist/client/testing.d.ts",
+      "source": "./src/client/testing.ts",
+      "import": "./dist/client/testing.js",
+      "default": "./dist/client/testing.js"
+    }
   },
   "files": [
     "dist",
+    "docs",
     "src",
     "!src/**/*.test.ts",
     "!src/**/*.test.tsx",
@@ -43,21 +129,29 @@
     "README.md"
   ],
   "dependencies": {
-    "@shivaedev/effect-contract": "0.4.0"
+    "@shivaedev/effect-contract": "0.4.1"
   },
   "devDependencies": {
     "@effect/atom-react": "4.0.0-rc.112",
+    "@effect/platform-node": "4.0.0-rc.112",
+    "@effect/sql-pg": "4.0.0-rc.112",
     "@effect/sql-sqlite-node": "4.0.0-rc.112",
-    "@shivaedev/effect-form": "0.2.0",
+    "@shivaedev/effect-form": "0.2.1",
+    "@shivaedev/effect-pg-boss": "0.4.0",
     "@shivaedev/effect-service": "0.2.0",
-    "@shivaedev/effect-sql": "0.2.0",
-    "@shivaedev/quality": "0.15.0",
-    "@types/node": "24.10.1",
+    "@shivaedev/effect-sql": "0.2.1",
+    "@shivaedev/effect-test": "0.3.2",
+    "@shivaedev/local-postgres": "0.2.0",
+    "@shivaedev/platform": "0.6.1",
+    "@shivaedev/quality": "0.19.0",
+    "@shivaedev/test-story": "0.1.1",
+    "@tanstack/react-router": "1.170.41",
+    "@types/node": "24.19.1",
     "@types/react": "19.2.18",
     "@types/react-dom": "19.2.4",
     "@typescript/native": "npm:typescript@7.0.2",
     "effect": "4.0.0-rc.112",
-    "happy-dom": "20.11.2",
+    "happy-dom": "20.14.5",
     "react": "19.2.8",
     "react-dom": "19.2.8",
     "typescript": "npm:@typescript/typescript6@6.0.2",
@@ -65,13 +159,25 @@
   },
   "peerDependencies": {
     "@effect/atom-react": "4.0.0-rc.112",
-    "@shivaedev/effect-form": "0.2.0",
+    "@shivaedev/effect-form": "0.2.1",
+    "@tanstack/react-router": "1.170.41",
     "effect": "4.0.0-rc.112",
-    "react": "19.2.8"
+    "react": "19.2.8",
+    "react-dom": "19.2.8",
+    "vitest": "4.1.11"
   },
   "peerDependenciesMeta": {
     "@shivaedev/effect-form": {
       "optional": true
+    },
+    "@tanstack/react-router": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    },
+    "vitest": {
+      "optional": true
     }
   },
   "engines": {
@@ -82,7 +188,7 @@
     "provenance": true
   },
   "scripts": {
-    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc6 --project tsconfig.build.json",
+    "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/create.ts

@@ -0,0 +1,41 @@
+import { type Effect, Equal, Option, type Schema } from "effect";
+import type * as Atom from "effect/unstable/reactivity/Atom";
+import { useCallback, useState } from "react";
+import type { Decoded, Encoded, FieldFailure, Fields, Form, Services } from "@shivaedev/effect-form/shape.ts";
+import type { AtomServices, FieldRejectionMapping } from "#field-rejection.ts";
+import { submission } from "#submission.ts";
+import { type SaveState, useSaveState } from "./saveState.ts";
+export type CreateConfig<TFields extends Fields, TCreated, TSaveError, R, TRuntimeError> = {
+	readonly fields: Schema.Struct<TFields>;
+	readonly initialValues: Encoded<TFields>;
+	readonly create: (values: Decoded<TFields>) => Effect.Effect<TCreated, TSaveError, AtomServices<R>>;
+	readonly runtime: Atom.AtomRuntime<Services<TFields, R>, TRuntimeError>;
+} & FieldRejectionMapping<TFields, TSaveError>;
+export interface Create<TFields extends Fields, TCreated, TSaveError, TRuntimeError> extends SaveState<TSaveError | TRuntimeError> {
+	readonly created: Option.Option<TCreated>;
+	readonly form: Form<TFields, TCreated, TSaveError | FieldFailure, TRuntimeError>;
+}
+function editedSince<TV extends object>(current: TV, submitted: TV | undefined): Readonly<Record<string, unknown>> {
+	const before = new Map(Object.entries(submitted ?? current));
+	return Object.fromEntries(Object.entries(current).filter(([name, value]) => !Equal.equals(value, before.get(name))));
+}
+export function useCreate<TFields extends Fields, TCreated, TSaveError, R, TRuntimeError>(
+	config: CreateConfig<TFields, TCreated, TSaveError, R, TRuntimeError>,
+): Create<TFields, TCreated, TSaveError, TRuntimeError> {
+	const [{ initialValues: baseline, fresh }] = useState(() => {
+		const { fields, initialValues, runtime, create, rejectField } = config;
+		return { fresh: () => submission({ fields, initialValues, rejectField, runtime, save: create }), initialValues };
+	});
+	const [current, replace] = useState(fresh);
+	const [created, record] = useState<Option.Option<TCreated>>(Option.none());
+	const settled = useCallback(
+		(value: TCreated) => {
+			const next = fresh();
+			next.form.values.set({ ...baseline, ...editedSince(current.form.values.value, current.submitted()) });
+			record(Option.some(value));
+			replace(next);
+		},
+		[current, fresh, baseline],
+	);
+	return { ...useSaveState(current.form, settled), created, form: current.form };
+}

package/src/client/editor.ts

@@ -0,0 +1,56 @@
+import { type Effect, Option, type Schema } from "effect";
+import type * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+import type * as Atom from "effect/unstable/reactivity/Atom";
+import { useCallback, useEffect, useState } from "react";
+import type { Decoded, Encoded, FieldFailure, Fields, Form, Services } from "@shivaedev/effect-form/shape.ts";
+import type { AtomServices, FieldRejectionMapping } from "#field-rejection.ts";
+import { submission } from "#submission.ts";
+import { type QueryState, useQuery } from "./resultState.ts";
+import { type SaveState, useSaveState } from "./saveState.ts";
+export type EditorConfig<TFields extends Fields, TRow, TQueryError, TSaveError, R, TRuntimeError> = {
+	readonly query: Atom.Atom<AsyncResult.AsyncResult<TRow, TQueryError>>;
+	readonly fields: Schema.Struct<TFields>;
+	readonly values: (row: TRow) => Encoded<TFields>;
+	readonly save: (values: Decoded<TFields>) => Effect.Effect<TRow, TSaveError, AtomServices<R>>;
+	readonly runtime: Atom.AtomRuntime<Services<TFields, R>, TRuntimeError>;
+} & FieldRejectionMapping<TFields, TSaveError>;
+export interface Editor<TFields extends Fields, TRow, TQueryError, TSaveError, TRuntimeError> extends SaveState<TSaveError | TRuntimeError> {
+	readonly form: Form<TFields, TRow, TSaveError | FieldFailure, TRuntimeError> | undefined;
+	readonly query: QueryState<TRow, TQueryError>;
+}
+interface Held<TFields extends Fields, TRow, TSaveError, TRuntimeError> {
+	readonly form: Form<TFields, TRow, TSaveError | FieldFailure, TRuntimeError>;
+	readonly query: Atom.Atom<unknown>;
+	readonly values: (row: TRow) => Encoded<TFields>;
+}
+export function useEditor<TFields extends Fields, TRow, TQueryError, TSaveError, R, TRuntimeError>(
+	config: EditorConfig<TFields, TRow, TQueryError, TSaveError, R, TRuntimeError>,
+): Editor<TFields, TRow, TQueryError, TSaveError, TRuntimeError> {
+	const query = useQuery(config.query);
+	const row = Option.getOrUndefined(query.data);
+	const [held, hold] = useState<Held<TFields, TRow, TSaveError, TRuntimeError> | undefined>(undefined);
+	let current = held?.query === config.query ? held : undefined;
+	if (current === undefined && row !== undefined) {
+		current = {
+			form: submission({
+				fields: config.fields,
+				initialValues: config.values(row),
+				rejectField: config.rejectField,
+				runtime: config.runtime,
+				save: config.save,
+			}).form,
+			query: config.query,
+			values: config.values,
+		};
+		hold(current);
+	}
+	const form = current?.form;
+	const values = current?.values;
+	useEffect(() => {
+		if (form && values && row !== undefined) {
+			form.receive(values(row));
+		}
+	}, [form, values, row]);
+	const settled = useCallback((saved: TRow) => (form && values ? form.receive(values(saved)) : undefined), [form, values]);
+	return { ...useSaveState(form, settled), form, query };
+}

package/src/client/resultState.ts

@@ -0,0 +1,73 @@
+import { RegistryContext, useAtomRefresh, useAtomSet, useAtomValue } from "@effect/atom-react";
+import { Cause, Option, Predicate } from "effect";
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+import type * as Atom from "effect/unstable/reactivity/Atom";
+import type * as AtomRegistry from "effect/unstable/reactivity/AtomRegistry";
+import { useContext, useEffect, useState } from "react";
+import { useSessionRecheck } from "./sessionBoundary.ts";
+export interface ResultState<A, E> {
+	readonly cause: Option.Option<Cause.Cause<E>>;
+	readonly data: Option.Option<A>;
+	readonly pending: boolean;
+	readonly refreshing: boolean;
+	readonly result: AsyncResult.AsyncResult<A, E>;
+}
+function state<A, E>(result: AsyncResult.AsyncResult<A, E>, data = AsyncResult.value(result)): ResultState<A, E> {
+	return {
+		cause: AsyncResult.cause(result),
+		data,
+		pending: result.waiting,
+		refreshing: result.waiting && Option.isSome(data),
+		result,
+	};
+}
+export function isUnauthorized<E>(cause: Cause.Cause<E>): boolean {
+	return Option.match(Cause.findErrorOption(cause), { onNone: () => false, onSome: (error) => Predicate.isTagged(error, "Unauthorized") });
+}
+function useRecheckOnUnauthorized<A, E>(result: AsyncResult.AsyncResult<A, E>): void {
+	const recheck = useSessionRecheck();
+	useEffect(() => {
+		if (AsyncResult.isFailure(result) && isUnauthorized(result.cause)) {
+			recheck();
+		}
+	}, [recheck, result]);
+}
+export interface QueryState<A, E> extends ResultState<A, E> {
+	readonly refresh: () => void;
+}
+export interface QueryOptions {
+	readonly keepPreviousData?: boolean;
+}
+interface HeldQuery<A, E> {
+	readonly atom: Atom.Atom<AsyncResult.AsyncResult<A, E>>;
+	readonly data: Option.Option<A>;
+	readonly dataAtom: Atom.Atom<AsyncResult.AsyncResult<A, E>>;
+	readonly keepPreviousData: boolean;
+	readonly registry: AtomRegistry.AtomRegistry;
+	readonly result: AsyncResult.AsyncResult<A, E>;
+}
+export function useQuery<A, E>(atom: Atom.Atom<AsyncResult.AsyncResult<A, E>>, options: QueryOptions = {}): QueryState<A, E> {
+	const result = useAtomValue(atom);
+	const registry = useContext(RegistryContext);
+	const keepPreviousData = options.keepPreviousData === true;
+	const nativeData = AsyncResult.value(result);
+	const [held, hold] = useState<HeldQuery<A, E>>(() => ({ atom, data: nativeData, dataAtom: atom, keepPreviousData, registry, result }));
+	const previous = held.registry === registry && (held.dataAtom === atom || keepPreviousData) ? held.data : Option.none<A>();
+	const data = Option.orElse(nativeData, () => previous);
+	const dataAtom = Option.isSome(nativeData) || Option.isNone(previous) ? atom : held.dataAtom;
+	// Render state keeps abandoned React renders from changing the committed screen's retained value.
+	if (held.atom !== atom || held.registry !== registry || held.result !== result || held.keepPreviousData !== keepPreviousData) {
+		hold({ atom, data, dataAtom, keepPreviousData, registry, result });
+	}
+	useRecheckOnUnauthorized(result);
+	return { ...state(result, data), refresh: useAtomRefresh(atom) };
+}
+export interface ActionState<TInput, A, E> extends ResultState<A, E> {
+	readonly dispatch: (input: TInput) => void;
+}
+// The atom's state is shared by every dispatch, so it never claims to be one invocation's completion result.
+export function useAction<TInput, A, E>(atom: Atom.AtomResultFn<TInput, A, E>): ActionState<TInput, A, E> {
+	const result = useAtomValue(atom);
+	useRecheckOnUnauthorized(result);
+	return { ...state(result), dispatch: useAtomSet(atom) };
+}

package/src/{save-state.ts → client/saveState.ts}

@@ -4,12 +4,11 @@ import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
 import * as Atom from "effect/unstable/reactivity/Atom";
 import { useCallback, useContext, useEffect } from "react";
 import { FieldFailure, type Fields, type Form, Invalid } from "@shivaedev/effect-form/shape.ts";
-import { isUnauthorized } from "./result-state.ts";
-import { useSessionRecheck } from "./session-boundary.ts";
+import { isUnauthorized } from "./resultState.ts";
+import { useSessionRecheck } from "./sessionBoundary.ts";
 
 const idle = Atom.make(AsyncResult.initial());
 const clean = Atom.make(false);
-
 export interface SaveState<E> {
 	readonly dirty: boolean;
 	readonly failure: Option.Option<E>;
@@ -17,14 +16,13 @@ export interface SaveState<E> {
 	readonly save: () => void;
 	readonly saving: boolean;
 }
-
-export const useSaveState = <F extends Fields, A, E, ER>(
-	form: Form<F, A, E | FieldFailure, ER> | undefined,
+export function useSaveState<TFields extends Fields, A, E, TRuntimeError>(
+	form: Form<TFields, A, E | FieldFailure, TRuntimeError> | undefined,
 	settled: (result: A) => void,
-): SaveState<E | ER> => {
+): SaveState<E | TRuntimeError> {
 	const registry = useContext(RegistryContext);
 	const recheck = useSessionRecheck();
-	const result: AsyncResult.AsyncResult<A, E | ER | FieldFailure | Invalid> = useAtomValue(form?.submit ?? idle);
+	const result: AsyncResult.AsyncResult<A, E | TRuntimeError | FieldFailure | Invalid> = useAtomValue(form?.submit ?? idle);
 	const dirty = useAtomValue(form?.dirty ?? clean);
 	useEffect(() => {
 		if (AsyncResult.isFailure(result) && isUnauthorized(result.cause)) {
@@ -48,6 +46,9 @@ export const useSaveState = <F extends Fields, A, E, ER>(
 		registry.set(form.submit, undefined);
 	}, [form, registry]);
 	const revert = useCallback(() => form?.revert(), [form]);
-	const failure = Option.filter(AsyncResult.error(result), (error): error is E | ER => !(error instanceof FieldFailure || error instanceof Invalid));
+	const failure = Option.filter(
+		AsyncResult.error(result),
+		(error): error is E | TRuntimeError => !(error instanceof FieldFailure || error instanceof Invalid),
+	);
 	return { dirty, failure, revert, save, saving: result.waiting };
-};
+}

package/src/{session-boundary.ts → client/sessionBoundary.ts}

@@ -1,30 +1,28 @@
 import { RegistryContext } from "@effect/atom-react";
 import * as AtomRegistry from "effect/unstable/reactivity/AtomRegistry";
 import { createContext, createElement, Fragment, type ReactNode, useContext, useEffect, useState } from "react";
-
-export interface SessionBoundaryProps<S, Client> {
-	readonly children: (client: Client) => ReactNode;
-	readonly connect: (session: S) => Client;
-	readonly identify: (session: S) => string;
+export interface SessionBoundaryProps<TSession, TClient> {
+	readonly children: (client: TClient) => ReactNode;
+	readonly connect: (session: TSession) => TClient;
+	readonly identify: (session: TSession) => string;
 	readonly recheck: () => void;
-	readonly session: S | undefined;
+	readonly session: TSession | undefined;
 	readonly signedOut?: ReactNode;
 }
-
-const Recheck = createContext<() => void>(() => {});
-
-export const useSessionRecheck = (): (() => void) => useContext(Recheck);
-
-interface Owned<Client> {
-	readonly client: Client;
+const RecheckContext = createContext<() => void>((): void => undefined);
+export function useSessionRecheck(): () => void {
+	return useContext(RecheckContext);
+}
+interface Owned<TClient> {
+	readonly client: TClient;
 	mounted: number;
 	readonly registry: AtomRegistry.AtomRegistry;
 }
-
-const owning = <Client>(client: Client): Owned<Client> => ({ client, mounted: 0, registry: AtomRegistry.make() });
-
+function owning<TClient>(client: TClient): Owned<TClient> {
+	return { client, mounted: 0, registry: AtomRegistry.make() };
+}
 // No cleanup runs when a hidden <Activity> subtree is unmounted, so nodes a hidden render creates must not outlive it.
-const hidden = <Client>(client: Client): Owned<Client> => {
+function hidden<TClient>(client: TClient): Owned<TClient> {
 	const owned = owning(client);
 	let reaping = false;
 	owned.registry.onNodeAdded = () => {
@@ -40,16 +38,14 @@ const hidden = <Client>(client: Client): Owned<Client> => {
 		}, 0);
 	};
 	return owned;
-};
-
-interface GenerationProps<S, Client> {
-	readonly children: (client: Client) => ReactNode;
-	readonly connect: (session: S) => Client;
+}
+interface GenerationProps<TSession, TClient> {
+	readonly children: (client: TClient) => ReactNode;
+	readonly connect: (session: TSession) => TClient;
 	readonly recheck: () => void;
-	readonly session: S;
+	readonly session: TSession;
 }
-
-const Generation = <S, Client>({ session, connect, recheck, children }: GenerationProps<S, Client>): ReactNode => {
+function Generation<TSession, TClient>({ session, connect, recheck, children }: GenerationProps<TSession, TClient>): ReactNode {
 	const [owned, own] = useState(() => owning(connect(session)));
 	useEffect(() => {
 		owned.mounted += 1;
@@ -65,20 +61,20 @@ const Generation = <S, Client>({ session, connect, recheck, children }: Generati
 		};
 	}, [owned]);
 	return createElement(
-		Recheck.Provider,
+		RecheckContext.Provider,
 		{ value: recheck },
 		createElement(RegistryContext.Provider, { value: owned.registry }, children(owned.client)),
 	);
-};
-
-export const SessionBoundary = <S, Client>({
+}
+export function SessionBoundary<TSession, TClient>({
 	session,
 	identify,
 	connect,
 	recheck,
 	signedOut,
 	children,
-}: SessionBoundaryProps<S, Client>): ReactNode =>
-	session === undefined
+}: SessionBoundaryProps<TSession, TClient>): ReactNode {
+	return session === undefined
 		? createElement(Fragment, null, signedOut)
-		: createElement(Generation<S, Client>, { children, connect, key: identify(session), recheck, session });
+		: createElement(Generation<TSession, TClient>, { children, connect, key: identify(session), recheck, session });
+}

package/src/client/testing.ts

@@ -0,0 +1,68 @@
+import { RegistryContext } from "@effect/atom-react";
+import { Clock, Effect } from "effect";
+import * as AtomRegistry from "effect/unstable/reactivity/AtomRegistry";
+import { act, createElement, type ReactNode } from "react";
+import { createRoot } from "react-dom/client";
+import { beforeEach, expect, vi } from "vitest";
+export function expectNoReactWarnings() {
+	beforeEach(({ onTestFinished }) => {
+		const errors = vi.spyOn(console, "error");
+		onTestFinished(() => {
+			const calls = errors.mock.calls;
+			errors.mockRestore();
+			expect(calls).toEqual([]);
+		});
+	});
+}
+export async function eventually(assert: () => void) {
+	const deadline = Effect.runSync(Clock.currentTimeMillis) + 3000;
+	while (true) {
+		// Network responses must settle inside act, including the time between assertions.
+		await act(async () => {
+			await new Promise<void>((resolve) => setTimeout(resolve, 10));
+		});
+		try {
+			assert();
+			return;
+		} catch (error) {
+			if (Effect.runSync(Clock.currentTimeMillis) >= deadline) {
+				throw error;
+			}
+		}
+	}
+}
+export interface Rendered {
+	readonly container: HTMLDivElement;
+	readonly registry: AtomRegistry.AtomRegistry;
+	readonly render: (node: ReactNode) => Promise<void>;
+	readonly unmount: () => Promise<void>;
+}
+export async function render(node: ReactNode): Promise<Rendered> {
+	const registry = AtomRegistry.make();
+	const container = document.createElement("div");
+	document.body.append(container);
+	const root = createRoot(container);
+	let mounted = true;
+	async function unmount() {
+		if (!mounted) {
+			return;
+		}
+		mounted = false;
+		try {
+			await act(async () => root.unmount());
+		} finally {
+			registry.dispose();
+			container.remove();
+		}
+	}
+	async function update(next: ReactNode) {
+		await act(async () => root.render(createElement(RegistryContext.Provider, { value: registry }, next)));
+	}
+	try {
+		await update(node);
+	} catch (error) {
+		await unmount();
+		throw error;
+	}
+	return { container, registry, render: update, unmount };
+}

package/src/field-rejection.ts

@@ -25,7 +25,9 @@ export type FieldRejectionMapping<F extends Fields, E> = { readonly rejectField?
 export const fieldRejectionOf =
 	<F extends Fields>(schema: Schema.Struct<F>) =>
 	(error: unknown): FieldRejection<Name<F>> | undefined => {
-		const isName = (name: unknown): name is Name<F> => typeof name === "string" && Object.hasOwn(schema.fields, name);
+		function isName(name: unknown): name is Name<F> {
+			return typeof name === "string" && Object.hasOwn(schema.fields, name);
+		}
 		if (!(Predicate.hasProperty(error, "_tag") && Predicate.hasProperty(error, "field") && Predicate.hasProperty(error, "message"))) {
 			return undefined;
 		}

package/src/loadQuery.ts

@@ -0,0 +1,27 @@
+import type { LoaderFnContext } from "@tanstack/react-router";
+import { Effect } from "effect";
+import type * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+import type * as Atom from "effect/unstable/reactivity/Atom";
+import * as AtomRegistry from "effect/unstable/reactivity/AtomRegistry";
+
+export async function loadQuery<A, E>(
+	registry: AtomRegistry.AtomRegistry,
+	atom: Atom.Atom<AsyncResult.AsyncResult<A, E>>,
+	{ abortController }: Pick<LoaderFnContext, "abortController">,
+): Promise<A> {
+	const { signal } = abortController;
+	try {
+		const result = await Effect.runPromise(Effect.result(AtomRegistry.getResult(registry, atom, { suspendOnWaiting: true })), { signal });
+		if (result._tag === "Failure") {
+			throw result.failure;
+		}
+		return result.success;
+	} catch (error) {
+		if (signal.aborted) {
+			const canceled = new Error("Query loading canceled", { cause: error });
+			canceled.name = "AbortError";
+			throw canceled;
+		}
+		throw error;
+	}
+}

package/dist/create.d.ts

@@ -1,17 +0,0 @@
-import { type Effect, Option, type Schema } from "effect";
-import type * as Atom from "effect/unstable/reactivity/Atom";
-import type { Decoded, Encoded, FieldFailure, Fields, Form, Services } from "@shivaedev/effect-form/shape.ts";
-import type { AtomServices, FieldRejectionMapping } from "./field-rejection.ts";
-import { type SaveState } from "./save-state.ts";
-export type CreateConfig<F extends Fields, Created, SE, R, ER> = {
-    readonly fields: Schema.Struct<F>;
-    readonly initialValues: Encoded<F>;
-    readonly create: (values: Decoded<F>) => Effect.Effect<Created, SE, AtomServices<R>>;
-    readonly runtime: Atom.AtomRuntime<Services<F, R>, ER>;
-} & FieldRejectionMapping<F, SE>;
-export interface Create<F extends Fields, Created, SE, ER> extends SaveState<SE | ER> {
-    readonly created: Option.Option<Created>;
-    readonly form: Form<F, Created, SE | FieldFailure, ER>;
-}
-export declare const useCreate: <F extends Fields, Created, SE, R, ER>(config: CreateConfig<F, Created, SE, R, ER>) => Create<F, Created, SE, ER>;
-//# sourceMappingURL=create.d.ts.map

package/dist/create.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../src/create.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAS,MAAM,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AACjE,OAAO,KAAK,KAAK,IAAI,MAAM,iCAAiC,CAAC;AAE7D,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAC9G,OAAO,KAAK,EAAE,YAAY,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAChF,OAAO,EAAE,KAAK,SAAS,EAAgB,MAAM,iBAAiB,CAAC;AAG/D,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,MAAM,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,IAAI;IAChE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;IACrF,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;CACvD,GAAG,qBAAqB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAEjC,MAAM,WAAW,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE,CAAE,SAAQ,SAAS,CAAC,EAAE,GAAG,EAAE,CAAC;IACpF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACzC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,GAAG,YAAY,EAAE,EAAE,CAAC,CAAC;CACvD;AAOD,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,MAAM,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,QAAQ,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE,CAiBtI,CAAC"}

package/dist/create.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"create.js","sourceRoot":"","sources":["../src/create.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,EAAE,MAAM,EAAe,MAAM,QAAQ,CAAC;AAEjE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAG9C,OAAO,EAAkB,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAc7C,MAAM,WAAW,GAAG,CAAmB,OAAU,EAAE,SAAwB,EAAqC,EAAE;IACjH,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,IAAI,OAAO,CAAC,CAAC,CAAC;IAC7D,OAAO,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;AACtH,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,SAAS,GAAG,CAAuC,MAA2C,EAA8B,EAAE;IAC1I,MAAM,CAAC,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE;QAChD,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAAC;QACvE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,aAAa,EAAE,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC;IAClH,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC3C,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,GAAG,QAAQ,CAAyB,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;IAC1E,MAAM,OAAO,GAAG,WAAW,CAC1B,CAAC,KAAc,EAAE,EAAE;QAClB,MAAM,IAAI,GAAG,KAAK,EAAE,CAAC;QACrB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,GAAG,aAAa,EAAE,GAAG,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC;QAC3G,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QAC3B,OAAO,CAAC,IAAI,CAAC,CAAC;IACf,CAAC,EACD,CAAC,OAAO,EAAE,KAAK,EAAE,aAAa,CAAC,CAC/B,CAAC;IACF,OAAO,EAAE,GAAG,YAAY,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC;AAChF,CAAC,CAAC"}