@shivaedev/react 0.0.0 → 0.19.0

package/src/client/sessionBoundary.ts

@@ -0,0 +1,107 @@
+import { RegistryContext } from "@effect/atom-react";
+import type { Duration } from "effect";
+import * as AtomRegistry from "effect/reactivity/AtomRegistry";
+import { createContext, createElement, Fragment, type ReactNode, useContext, useEffect, useState } from "react";
+import { DraftSessionContext } from "@shivaedev/form/client/react.ts";
+import { registerSessionRecheck } from "#internal/sessionRecheck.ts";
+import { mountLive } from "./mountLive.ts";
+import { useDraftOwner } from "./useDraftOwner.ts";
+export interface SessionBoundaryProps<TSession, TClient> {
+	readonly children: (client: TClient) => ReactNode;
+	readonly connect: (session: TSession, registry: AtomRegistry.AtomRegistry) => TClient;
+	readonly identify: (session: TSession) => string;
+	readonly liveCoalesceWindow?: Duration.Input | undefined;
+	readonly recheck: () => void;
+	readonly session: TSession | undefined;
+	readonly signedOut?: ReactNode;
+}
+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;
+}
+function owning<TClient>(connect: (registry: AtomRegistry.AtomRegistry) => TClient): Owned<TClient> {
+	const registry = AtomRegistry.make({ "defaultIdleTTL": 400 });
+	let client: { readonly value: TClient } | undefined;
+	return {
+		get client() {
+			client ??= { value: connect(registry) };
+			return client.value;
+		},
+		mounted: 0,
+		registry,
+	};
+}
+// No cleanup runs when a hidden <Activity> subtree is unmounted, so nodes a hidden render creates must not outlive it.
+function hidden<TClient>(connect: (registry: AtomRegistry.AtomRegistry) => TClient): Owned<TClient> {
+	const owned = owning(connect);
+	let reaping = false;
+	owned.registry.onNodeAdded = () => {
+		if (reaping || owned.mounted > 0) {
+			return;
+		}
+		reaping = true;
+		setTimeout(() => {
+			reaping = false;
+			if (owned.mounted === 0) {
+				owned.registry.reset();
+			}
+		}, 0);
+	};
+	return owned;
+}
+interface GenerationProps<TSession, TClient> {
+	readonly children: (client: TClient) => ReactNode;
+	readonly connect: (session: TSession, registry: AtomRegistry.AtomRegistry) => TClient;
+	readonly liveCoalesceWindow?: Duration.Input | undefined;
+	readonly recheck: () => void;
+	readonly session: TSession;
+}
+function Generation<TSession, TClient>({ session, connect, recheck, children, liveCoalesceWindow }: GenerationProps<TSession, TClient>): ReactNode {
+	const [open] = useState(() => (registry: AtomRegistry.AtomRegistry) => connect(session, registry));
+	const [owned, own] = useState(() => owning(open));
+	useEffect(() => registerSessionRecheck(owned.registry, recheck), [owned, recheck]);
+	useEffect(() => {
+		owned.mounted += 1;
+		const stopLive = mountLive(owned.registry, owned.client, liveCoalesceWindow);
+		return () => {
+			stopLive();
+			owned.mounted -= 1;
+			queueMicrotask(() => {
+				if (owned.mounted > 0) {
+					return;
+				}
+				owned.registry.dispose();
+				own((current) => (current === owned ? hidden(open) : current));
+			});
+		};
+	}, [owned, liveCoalesceWindow, open]);
+	return createElement(
+		RecheckContext.Provider,
+		{ value: recheck },
+		createElement(RegistryContext.Provider, { value: owned.registry }, children(owned.client)),
+	);
+}
+export function SessionBoundary<TSession, TClient>({
+	session,
+	liveCoalesceWindow,
+	identify,
+	connect,
+	recheck,
+	signedOut,
+	children,
+}: SessionBoundaryProps<TSession, TClient>): ReactNode {
+	const id = session === undefined ? undefined : identify(session);
+	const current = useDraftOwner(id);
+	return session === undefined
+		? createElement(Fragment, null, signedOut)
+		: createElement(
+				DraftSessionContext.Provider,
+				{ value: current },
+				createElement(Generation<TSession, TClient>, { children, connect, key: id, liveCoalesceWindow, recheck, session }),
+			);
+}

package/src/client/testing.ts

@@ -0,0 +1,142 @@
+import { RegistryContext } from "@effect/atom-react";
+import { Clock, Effect, Exit, Scope } from "effect";
+import * as AtomRegistry from "effect/reactivity/AtomRegistry";
+import { act, createElement, type ReactNode } from "react";
+import { createRoot, type RootOptions } from "react-dom/client";
+import { beforeEach, expect, vi } from "vitest";
+import { eventually as retry } from "@shivaedev/test/eventually.ts";
+import { withLive } from "@shivaedev/test/withLive.ts";
+
+type CaughtErrorHandler = NonNullable<RootOptions["onCaughtError"]>;
+
+export interface ReactWarningsReadout {
+	readonly caughtErrors: readonly unknown[];
+	readonly consoleErrors: readonly (readonly unknown[])[];
+}
+
+export interface ReactWarnings {
+	readonly expectCaughtError: (matches: (error: unknown) => boolean) => CaughtErrorHandler;
+	readonly onCaughtError: CaughtErrorHandler;
+	readonly read: () => ReactWarningsReadout;
+}
+
+const acquireReactWarnings = Effect.acquireRelease(
+	Effect.sync(() => {
+		const errors = vi.spyOn(console, "error").mockImplementation(() => undefined);
+		let consoleErrors: readonly (readonly unknown[])[] | undefined;
+		const caughtErrors: unknown[] = [];
+		const expectations: { caught: boolean }[] = [];
+		const capture: ReactWarnings = {
+			expectCaughtError: (matches) => {
+				const expectation = { caught: false };
+				expectations.push(expectation);
+				return (error) => {
+					if (matches(error)) {
+						expectation.caught = true;
+					} else {
+						caughtErrors.push(error);
+					}
+				};
+			},
+			onCaughtError: (error) => {
+				caughtErrors.push(error);
+			},
+			read: () => ({ caughtErrors: [...caughtErrors], consoleErrors: consoleErrors ?? errors.mock.calls.map((args) => [...args]) }),
+		};
+		return {
+			capture,
+			expectations,
+			restore: () => {
+				consoleErrors = capture.read().consoleErrors;
+				errors.mockRestore();
+			},
+		};
+	}),
+	({ restore }) => Effect.sync(restore),
+);
+
+export const captureReactWarnings = Effect.map(acquireReactWarnings, ({ capture }) => capture);
+
+export function expectNoReactWarnings() {
+	let current: Effect.Success<typeof acquireReactWarnings>;
+	beforeEach(({ onTestFinished }) => {
+		const scope = Effect.runSync(Scope.make());
+		current = Effect.runSync(Effect.provideService(acquireReactWarnings, Scope.Scope, scope));
+		const { capture, expectations } = current;
+		onTestFinished(() => {
+			Effect.runSync(Scope.close(scope, Exit.void));
+			const { consoleErrors, caughtErrors } = capture.read();
+			expect(consoleErrors).toEqual([]);
+			expect(caughtErrors, "Unexpected caught React errors").toEqual([]);
+			expect(
+				expectations.every(({ caught }) => caught),
+				"Expected caught React error did not occur",
+			).toBe(true);
+		});
+	});
+	return {
+		expectCaughtError(matches: (error: unknown) => boolean): NonNullable<RootOptions["onCaughtError"]> {
+			return current.capture.expectCaughtError(matches);
+		},
+	};
+}
+export function eventually(assert: () => void) {
+	return withLive(
+		Effect.gen(function* () {
+			const started = yield* Clock.currentTimeMillis;
+			return yield* retry(Effect.try({ catch: (error) => error, try: assert }), {
+				timeout: "3 seconds",
+				// Responses and React updates must settle together inside act.
+				wait: Effect.promise(() =>
+					act(async () => {
+						await new Promise<void>((resolve) => setTimeout(resolve, 10));
+					}),
+				),
+			}).pipe(
+				Effect.catch((error) =>
+					Effect.gen(function* () {
+						const elapsed = (yield* Clock.currentTimeMillis) - started;
+						return yield* Effect.fail(
+							new Error(`Assertion did not pass after ${elapsed}ms: ${error instanceof Error ? error.message : String(error)}`, { cause: 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, options?: RootOptions): Promise<Rendered> {
+	const registry = AtomRegistry.make();
+	const container = document.createElement("div");
+	document.body.append(container);
+	const root = createRoot(container, options);
+	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/client/useDraftOwner.ts

@@ -0,0 +1,42 @@
+import { useInsertionEffect, useRef, useState } from "react";
+import { type DraftSession, draftSession } from "@shivaedev/form/draftSession.ts";
+
+interface DraftOwner {
+	readonly activate: () => void;
+	readonly session: DraftSession;
+}
+
+function owner(id: string, active: boolean): DraftOwner {
+	const session = draftSession(id);
+	let committed = active;
+	return {
+		activate: () => {
+			committed = true;
+		},
+		session: {
+			...session,
+			get active() {
+				return committed && session.active;
+			},
+		},
+	};
+}
+
+export function useDraftOwner(id: string | undefined): DraftSession | undefined {
+	const [held, hold] = useState(() => (id === undefined ? undefined : owner(id, true)));
+	const committedRef = useRef(held);
+	let current = held;
+	if (current?.session.id !== id) {
+		current = id === undefined ? undefined : owner(id, committedRef.current === undefined);
+		hold(current);
+	}
+	// Insertion effects also run for Activity commits while layout and passive effects are disconnected.
+	useInsertionEffect(() => {
+		if (committedRef.current !== current) {
+			committedRef.current?.session.drop();
+			current?.activate();
+			committedRef.current = current;
+		}
+	}, [current]);
+	return current?.session;
+}

package/src/client/useLoaderQuery.ts

@@ -0,0 +1,16 @@
+import { RegistryContext } from "@effect/atom-react";
+import type * as AsyncResult from "effect/reactivity/AsyncResult";
+import type * as Atom from "effect/reactivity/Atom";
+import { useContext } from "react";
+import { loadedQuery } from "#internal/loadedQuery.ts";
+import { useLoaderHandoff } from "#internal/useLoaderHandoff.ts";
+import { type QueryState, useQuery } from "./resultState.ts";
+
+export interface LoadedQueryState<A, E> extends Omit<QueryState<A, E>, "data" | "result"> {
+	readonly data: A;
+}
+
+export function useLoaderQuery<A, E>(atom: Atom.Atom<AsyncResult.AsyncResult<A, E>>, loaded: NoInfer<A>): LoadedQueryState<A, E> {
+	useLoaderHandoff(useContext(RegistryContext), atom);
+	return loadedQuery(useQuery(atom), loaded);
+}

package/src/fieldRejection.ts

@@ -0,0 +1,51 @@
+import { Effect, Predicate, type Schema, type Scope } from "effect";
+import type { AtomRegistry } from "effect/reactivity/AtomRegistry";
+import type { Reactivity } from "effect/reactivity/Reactivity";
+import type { FieldFailure, Fields, Name, Submitter } from "@shivaedev/form/shape.ts";
+
+export interface FieldRejection<TName extends string> {
+	readonly field: TName;
+	readonly message: string;
+}
+
+export type AtomServices<TRequirements> = TRequirements | Scope.Scope | AtomRegistry | Reactivity;
+
+export type RejectField<TFields extends Fields, TError> = (error: TError) => FieldRejection<Name<TFields>> | undefined;
+
+type Unmatched<TFields extends Fields, TError> = TError extends { readonly _tag: string; readonly message: string }
+	? "field" extends keyof TError
+		? Exclude<TError["field"], Name<TFields> | undefined>
+		: never
+	: never;
+
+export type FieldRejectionMapping<TFields extends Fields, TError> = { readonly rejectField?: RejectField<TFields, TError> } & ([
+	Unmatched<TFields, TError>,
+] extends [never]
+	? unknown
+	: { readonly rejectField: RejectField<TFields, TError> });
+
+export function fieldRejectionOf<TFields extends Fields>(schema: Schema.Struct<TFields>) {
+	return (error: unknown): FieldRejection<Name<TFields>> | undefined => {
+		function isName(name: unknown): name is Name<TFields> {
+			return typeof name === "string" && Object.hasOwn(schema.fields, name);
+		}
+		if (!(Predicate.hasProperty(error, "_tag") && Predicate.hasProperty(error, "field") && Predicate.hasProperty(error, "message"))) {
+			return undefined;
+		}
+		const { _tag, field, message } = error;
+		return typeof _tag === "string" && isName(field) && typeof message === "string" ? { field, message } : undefined;
+	};
+}
+
+export function rejecting<TFields extends Fields, TValues, TResult, TError, TRequirements>(
+	schema: Schema.Struct<TFields>,
+	save: (values: TValues) => Effect.Effect<TResult, TError, TRequirements>,
+	reject: RejectField<TFields, TError> | undefined,
+) {
+	const rejection = reject ?? fieldRejectionOf(schema);
+	return (values: TValues, submitter: Submitter<Name<TFields>>): Effect.Effect<TResult, TError | FieldFailure, TRequirements> =>
+		Effect.catch(save(values), (error): Effect.Effect<never, TError | FieldFailure> => {
+			const found = rejection(error);
+			return found === undefined ? Effect.fail(error) : submitter.fail(found.field, found.message);
+		});
+}

package/src/internal/NoticeContext.ts

@@ -0,0 +1,4 @@
+import { createContext } from "react";
+import type { noticeStore } from "./noticeStore.ts";
+
+export const NoticeContext = createContext<ReturnType<typeof noticeStore> | undefined>(undefined);

package/src/internal/loadedQuery.ts

@@ -0,0 +1,18 @@
+import { type Cause, Option } from "effect";
+
+interface QuerySnapshot<A, E> {
+	readonly cause: Option.Option<Cause.Cause<E>>;
+	readonly data: Option.Option<A>;
+	readonly pending: boolean;
+	readonly refresh: () => void;
+}
+
+export function loadedQuery<A, E>(query: QuerySnapshot<A, E>, loaded: A) {
+	return {
+		cause: query.cause,
+		data: Option.getOrElse(query.data, () => loaded),
+		pending: query.pending,
+		refresh: query.refresh,
+		refreshing: query.pending,
+	};
+}

package/src/internal/noticeEntry.ts

@@ -0,0 +1,65 @@
+import { Duration } from "effect";
+import * as AsyncResult from "effect/reactivity/AsyncResult";
+import * as Atom from "effect/reactivity/Atom";
+import type * as AtomRegistry from "effect/reactivity/AtomRegistry";
+import type { NoticeDescriptor } from "#notices.ts";
+
+export interface NoticeAction {
+	readonly atom: Atom.AtomResultFn<void, unknown, unknown>;
+	readonly label: NoticeDescriptor["message"];
+}
+export interface NoticeEntry {
+	readonly action?: { readonly label: NoticeDescriptor["message"]; readonly run: () => void } | undefined;
+	readonly dismiss: () => void;
+	readonly id: number;
+	readonly message: NoticeDescriptor["message"];
+	readonly release: () => void;
+	readonly status: Atom.Atom<AsyncResult.AsyncResult<unknown, unknown>>;
+}
+const idle = Atom.make(AsyncResult.initial<unknown, unknown>());
+export function noticeEntry(
+	registry: AtomRegistry.AtomRegistry,
+	id: number,
+	descriptor: Pick<NoticeDescriptor, "message" | "expiresIn">,
+	remove: (id: number) => void,
+	action: NoticeAction | undefined,
+): NoticeEntry {
+	let active = true;
+	function dismiss() {
+		if (active) {
+			remove(id);
+			release();
+		}
+	}
+	function run() {
+		if (active && action && !registry.get(action.atom).waiting) {
+			registry.set(action.atom, undefined);
+		}
+	}
+	const resource = Atom.make((get) => {
+		if (action) {
+			get.mount(action.atom);
+		}
+		if (descriptor.expiresIn !== undefined) {
+			const timer = setTimeout(dismiss, Duration.toMillis(descriptor.expiresIn));
+			get.addFinalizer(() => clearTimeout(timer));
+		}
+		return true;
+	}).pipe(Atom.setIdleTTL(0));
+	const unmount = registry.mount(resource);
+	function release() {
+		active = false;
+		if (action) {
+			registry.set(action.atom, Atom.Interrupt);
+		}
+		unmount();
+	}
+	return {
+		action: action === undefined ? undefined : { label: action.label, run },
+		dismiss,
+		id,
+		message: descriptor.message,
+		release,
+		status: action?.atom ?? idle,
+	};
+}

package/src/internal/noticeStore.ts

@@ -0,0 +1,46 @@
+import * as Atom from "effect/reactivity/Atom";
+import type * as AtomRegistry from "effect/reactivity/AtomRegistry";
+import type { NoticeDescriptor } from "#notices.ts";
+import { type NoticeAction, type NoticeEntry, noticeEntry } from "./noticeEntry.ts";
+
+export function noticeStore(registry: AtomRegistry.AtomRegistry) {
+	const entries = Atom.make<readonly NoticeEntry[]>([]);
+	let nextId = 0;
+	function remove(id: number) {
+		registry.set(
+			entries,
+			registry.get(entries).filter((entry) => entry.id !== id),
+		);
+	}
+	const store = {
+		active: false,
+		close: () => {
+			store.active = false;
+			for (const entry of registry.get(entries)) {
+				entry.release();
+			}
+			registry.set(entries, []);
+		},
+		entries,
+		publish: (descriptor: Pick<NoticeDescriptor, "message" | "expiresIn">, action?: NoticeAction) => {
+			if (!store.active) {
+				return;
+			}
+			const entry = noticeEntry(registry, nextId, descriptor, remove, action);
+			nextId += 1;
+			registry.set(entries, [...registry.get(entries), entry]);
+		},
+	};
+	return store;
+}
+export function publishNotice<R, E>(
+	store: ReturnType<typeof noticeStore> | undefined,
+	runtime: Atom.AtomRuntime<R, E>,
+	descriptor: NoticeDescriptor<R> | undefined,
+) {
+	if (!(store?.active && descriptor)) {
+		return;
+	}
+	const action = descriptor.action;
+	store.publish(descriptor, action === undefined ? undefined : { atom: runtime.fn(() => action.run).pipe(Atom.setIdleTTL(0)), label: action.label });
+}

package/src/internal/queryHandoff.ts

@@ -0,0 +1,60 @@
+import * as Atom from "effect/reactivity/Atom";
+import type * as AtomRegistry from "effect/reactivity/AtomRegistry";
+
+interface Handoff {
+	pending: boolean;
+	readonly ready: Promise<void>;
+	readonly release: () => void;
+}
+
+const handoffs = new WeakMap<AtomRegistry.AtomRegistry, WeakMap<Atom.Atom<unknown>, Set<Handoff>>>();
+
+export function keepLoaderQuery(registry: AtomRegistry.AtomRegistry, atom: Atom.Atom<unknown>, signal: AbortSignal) {
+	let atoms = handoffs.get(registry);
+	if (!atoms) {
+		atoms = new WeakMap();
+		handoffs.set(registry, atoms);
+	}
+	const readers = atoms.get(atom) ?? new Set<Handoff>();
+	atoms.set(atom, readers);
+	const key = Atom.isSerializable(atom) ? atom[Atom.SerializableTypeId].key : atom;
+	if (atom.initialValueTarget && !registry.getNodes().has(key)) {
+		// A removed reactive wrapper may have missed invalidations while its source stayed idle.
+		registry.refresh(atom);
+	}
+	const unmount = registry.mount(atom);
+	const ready = Promise.withResolvers<void>();
+	const handoff: Handoff = { pending: true, ready: ready.promise, release };
+	function complete() {
+		handoff.pending = false;
+		ready.resolve();
+	}
+	function release() {
+		if (readers.delete(handoff)) {
+			complete();
+			signal.removeEventListener("abort", release);
+			unmount();
+		}
+	}
+	readers.add(handoff);
+	signal.addEventListener("abort", release, { once: true });
+	if (signal.aborted) {
+		release();
+	}
+	return { complete, release };
+}
+
+export function acceptLoaderQuery(registry: AtomRegistry.AtomRegistry, atom: Atom.Atom<unknown>): void {
+	for (const handoff of handoffs.get(registry)?.get(atom) ?? []) {
+		handoff.release();
+	}
+}
+
+export function pendingLoaderQuery(registry: AtomRegistry.AtomRegistry, atom: Atom.Atom<unknown>): Promise<void> | undefined {
+	for (const handoff of handoffs.get(registry)?.get(atom) ?? []) {
+		if (handoff.pending) {
+			return handoff.ready;
+		}
+	}
+	return undefined;
+}

package/src/internal/sessionRecheck.ts

@@ -0,0 +1,17 @@
+import { Predicate } from "effect";
+import type * as AtomRegistry from "effect/reactivity/AtomRegistry";
+
+const rechecks = new WeakMap<AtomRegistry.AtomRegistry, () => void>();
+
+export function registerSessionRecheck(registry: AtomRegistry.AtomRegistry, recheck: () => void): () => void {
+	rechecks.set(registry, recheck);
+	return () => {
+		rechecks.delete(registry);
+	};
+}
+
+export async function recheckUnauthorized(registry: AtomRegistry.AtomRegistry, error: unknown): Promise<void> {
+	if (Predicate.isTagged(error, "Unauthorized")) {
+		await rechecks.get(registry)?.();
+	}
+}

package/src/internal/useLoaderHandoff.ts

@@ -0,0 +1,20 @@
+import type * as Atom from "effect/reactivity/Atom";
+import type * as AtomRegistry from "effect/reactivity/AtomRegistry";
+import { useEffect, useRef } from "react";
+import { pendingLoaderQuery } from "./queryHandoff.ts";
+
+export function useLoaderHandoff(registry: AtomRegistry.AtomRegistry, atom: Atom.Atom<unknown>): void {
+	const committedRef = useRef<{ readonly registry: AtomRegistry.AtomRegistry; readonly atom: Atom.Atom<unknown> } | undefined>(undefined);
+	useEffect(() => {
+		committedRef.current = { atom, registry };
+		return () => {
+			committedRef.current = undefined;
+		};
+	}, [registry, atom]);
+	if (committedRef.current?.registry !== registry || committedRef.current.atom !== atom) {
+		const pending = pendingLoaderQuery(registry, atom);
+		if (pending !== undefined) {
+			throw pending;
+		}
+	}
+}

package/src/internal/useNoticePublisher.ts

@@ -0,0 +1,10 @@
+import type * as Atom from "effect/reactivity/Atom";
+import { useContext, useMemo } from "react";
+import type { NoticeDescriptor } from "#notices.ts";
+import { NoticeContext } from "./NoticeContext.ts";
+import { publishNotice } from "./noticeStore.ts";
+
+export function useNoticePublisher<R, E>(runtime: Atom.AtomRuntime<R, E>): (descriptor: NoticeDescriptor<R> | undefined) => void {
+	const store = useContext(NoticeContext);
+	return useMemo(() => (descriptor: NoticeDescriptor<R> | undefined) => publishNotice(store, runtime, descriptor), [store, runtime]);
+}

package/src/internal/useQueryNotice.ts

@@ -0,0 +1,32 @@
+import { type Cause, Layer } from "effect";
+import * as AsyncResult from "effect/reactivity/AsyncResult";
+import * as Atom from "effect/reactivity/Atom";
+import { useContext, useEffect, useInsertionEffect, useRef } from "react";
+import type { NoticeDescriptor } from "#notices.ts";
+import { NoticeContext } from "./NoticeContext.ts";
+import { publishNotice } from "./noticeStore.ts";
+
+const runtime = Atom.runtime(Layer.empty);
+
+export function useQueryNotice<A, E>(
+	result: AsyncResult.AsyncResult<A, E>,
+	refreshing: boolean,
+	notice: ((failure: { readonly cause: Cause.Cause<E>; readonly refreshing: boolean }) => NoticeDescriptor | undefined) | undefined,
+) {
+	const store = useContext(NoticeContext);
+	const latestRef = useRef(notice);
+	useInsertionEffect(() => {
+		latestRef.current = notice;
+	}, [notice]);
+	const seenRef = useRef<AsyncResult.AsyncResult<A, E> | undefined>(undefined);
+	useEffect(() => {
+		if (result.waiting || seenRef.current === result) {
+			return;
+		}
+		seenRef.current = result;
+		if (store?.active && AsyncResult.isFailure(result)) {
+			const descriptor = latestRef.current?.({ cause: result.cause, refreshing });
+			publishNotice(store, runtime, descriptor);
+		}
+	}, [result, refreshing, store]);
+}