@shivaedev/effect-react 0.2.0 → 0.2.2

package/docs/roadmap.md

@@ -0,0 +1,28 @@
+# Roadmap
+
+This roadmap owns the package's hooks, form coordination and session-registry implementation. The [framework roadmap](https://github.com/ShivaeDev/platform/blob/main/docs/framework/roadmap.md) owns composed feature fixtures, adoption and host/deployment validation. A local hook test is evidence for its own runtime and scenario.
+
+## Built
+
+- [x] Opt-in `keepPreviousData` retains the last successful query value across payload changes, pending requests and failures; the default resets it. Registry replacement clears retained data, superseded responses do not replace the latest result, and disabling retention drops an inherited value. [Rendered query evidence](https://github.com/ShivaeDev/platform/blob/main/packages/effect-react/src/queryPayload.dom.spec.ts).
+- [x] Public `testing.ts` render helpers supply an isolated native registry per mount, retain it on rerender, and dispose native resources and remove the container on idempotent unmount. [DOM evidence](https://github.com/ShivaeDev/platform/blob/main/packages/effect-react/src/client/testing.dom.test.tsx) also exercises query refetch after a command through a test RPC Layer; it does not establish browser networking.
+- [x] Native query and action hooks with inferred input/success/failure types, retained data, pending/refresh state and explicit refresh/dispatch methods. DOM tests cover query identity changes, shared query execution and latest-dispatch interruption; compiler fixtures cover types.
+- [x] A session generation owning its client, registry and subtree, with replacement/sign-out cleanup, query Unauthorized rechecking and retained screens until the auth owner changes the session.
+- [x] Session cleanup across StrictMode effect replay and Activity hiding, reveal and hidden unmount, with credential rotation tested against the chosen identity key.
+- [x] `useEditor` composing query, fields and save Effect, with initial loading, per-query forms, per-field refresh/saved-result merges, normalized results and in-flight edits covered by rendered tests.
+- [x] `useCreate` starting a fresh form after success while retaining fields edited during schema decoding or the request; submissions through the form API settle the hooks too.
+- [x] Tagged field-rejection mapping, a typed custom mapper and compile-time requirements for rejection field types that exceed the form's names; other save failures remain separately available.
+- [x] A resume module using effect-contract's shared implementation, with visible browser events, an injected native source, listener disposal and native stale-while-revalidate policy covered by tests.
+- [x] TanStack Router query loaders sharing the native registry, with tagged RPC failures, refresh waiting and abort handling. Render tests cover shared query execution, the route error component and previous data during navigation.
+
+## Next
+
+- [ ] Add direct rendered regressions for Unauthorized action and save failures invoking the session callback. The implementation calls it, but existing boundary assertions exercise query failures.
+- [ ] Add explicit result-state regressions for a successful `undefined` value and causes containing defects or interruption before making stronger README guarantees about those cases.
+- [ ] Verify changing hook configuration during one form lifetime before documenting any supported reconfiguration policy. Creation currently captures its initial configuration, and an editor holds submission functions per query identity.
+
+## Open questions
+
+- Do consumers need an independently scoped action helper, or are distinct native atoms and actual Effects enough for imperative per-invocation outcomes? Keep native shared-action semantics unless a demonstrated use case requires more.
+- What per-request registry and hydration wiring does the TanStack Router host need for SSR? Client render fixtures do not establish SSR isolation.
+- Which hook configuration values should be allowed to change without replacing the form? A rule for changing schemas, runtimes, save functions or initial values needs consumer evidence and explicit lifetime tests.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivaedev/effect-react",
-  "version": "0.2.0",
+  "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": {
@@ -15,56 +15,169 @@
   "sideEffects": false,
   "type": "module",
   "imports": {
-    "#test/*": "./test/*",
+    "#test/*": "./src/test-support/*",
     "#*.ts": {
       "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",
+    "!src/**/*.spec.ts",
+    "!src/**/*.spec.tsx",
+    "!src/**/test-support",
     "CHANGELOG.md",
     "README.md"
   ],
+  "dependencies": {
+    "@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-contract": "0.3.0",
-    "@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.9.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",
-    "vitest": "4.1.9"
+    "vitest": "4.1.11"
   },
   "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": {
@@ -75,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;
+	}
+}