@ensforge/react 0.1.0 → 0.1.1

package/dist/hooks/use-mutation.js

@@ -9,58 +9,44 @@ import { useContext, useRef, useState } from "react";
 
 //#region src/hooks/use-mutation.ts
 const makeMutationHook = (factory) => (options = {}) => {
-	const { sdk } = useEnsforgeContext();
+	const { defaults, sdk } = useEnsforgeContext();
 	const registry = useContext(RegistryContext);
 	const atomRef = useRef(void 0);
 	const [parameters, setParameters] = useState(void 0);
 	if (atomRef.current === void 0) atomRef.current = factory(sdk);
 	const atom = atomRef.current;
 	const result = useAtomValue(atom);
+	const retry = options.retry ?? defaults.mutations?.retry ?? false;
 	const mutateEffect = (nextParameters) => {
 		const effect = Effect.sync(() => {
 			setParameters(nextParameters);
 			registry.set(atom, nextParameters);
 		}).pipe(Effect.andThen(AtomRegistry.getResult(registry, atom, { suspendOnWaiting: true })));
-		return options.retry === void 0 || options.retry === false ? effect : effect.pipe(Effect.retry({ times: options.retry }));
+		return retry === false ? effect : effect.pipe(Effect.retry(retry));
 	};
-	const runCallbacks = (exit, nextParameters, local) => {
-		if (Exit.isSuccess(exit)) {
-			options.onSuccess?.(exit.value, nextParameters);
-			local?.onSuccess?.(exit.value, nextParameters);
-			options.onSettled?.(exit.value, null, nextParameters);
-			local?.onSettled?.(exit.value, null, nextParameters);
-			return;
-		}
-		const error = errorFromCause(exit.cause);
-		options.onError?.(error, nextParameters);
-		local?.onError?.(error, nextParameters);
-		options.onSettled?.(void 0, error, nextParameters);
-		local?.onSettled?.(void 0, error, nextParameters);
-	};
-	const mutate = (nextParameters, callbacks) => {
-		Effect.runPromiseExit(mutateEffect(nextParameters)).then((exit) => runCallbacks(exit, nextParameters, callbacks));
+	const notifyExit = (exit, nextParameters, local) => {
+		options.onExit?.(exit, nextParameters);
+		local?.onExit?.(exit, nextParameters);
 	};
 	const mutateAsync = async (nextParameters) => {
 		const exit = await Effect.runPromiseExit(mutateEffect(nextParameters));
-		runCallbacks(exit, nextParameters, void 0);
+		notifyExit(exit, nextParameters, void 0);
 		if (Exit.isSuccess(exit)) return exit.value;
 		throw Cause.squash(exit.cause);
 	};
+	const mutate = (nextParameters, local) => {
+		Effect.runPromiseExit(mutateEffect(nextParameters)).then((exit) => notifyExit(exit, nextParameters, local));
+	};
 	const cause = Option.getOrNull(AsyncResult.cause(result));
-	const data = Option.getOrUndefined(AsyncResult.value(result));
-	const isIdle = AsyncResult.isInitial(result) && !result.waiting;
-	const isPending = result.waiting;
-	const isError = AsyncResult.isFailure(result);
-	const isSuccess = AsyncResult.isSuccess(result) && !result.waiting;
 	return {
 		cause,
-		data,
+		data: Option.getOrUndefined(AsyncResult.value(result)),
 		error: cause === null ? null : errorFromCause(cause),
 		interrupt: () => registry.set(atom, Atom.Interrupt),
-		isError,
-		isIdle,
-		isPending,
-		isSuccess,
+		isFailure: AsyncResult.isFailure(result),
+		isInitial: AsyncResult.isInitial(result) && !result.waiting,
+		isSuccess: AsyncResult.isSuccess(result) && !result.waiting,
+		isWaiting: result.waiting,
 		mutate,
 		mutateAsync,
 		mutateEffect,
@@ -69,8 +55,7 @@ const makeMutationHook = (factory) => (options = {}) => {
 			setParameters(void 0);
 			registry.set(atom, Atom.Reset);
 		},
-		result,
-		status: isPending ? "pending" : isError ? "error" : isSuccess ? "success" : "idle"
+		result
 	};
 };
 

package/dist/hooks/use-mutation.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-mutation.js","names":[],"sources":["../../src/hooks/use-mutation.ts"],"sourcesContent":["\"use client\";\n\nimport { useContext, useRef, useState } from \"react\";\n\nimport { RegistryContext, useAtomValue } from \"@effect/atom-react\";\nimport { Cause, Effect, Exit, Option } from \"effect\";\nimport { AsyncResult, Atom, AtomRegistry } from \"effect/unstable/reactivity\";\n\nimport type { EnsMutationAtomFactory } from \"../atoms/mutation.js\";\nimport type { EnsMutationCallbacks, EnsMutationOptions } from \"../mutation/options.js\";\nimport type { EnsMutationResult } from \"../mutation/result.js\";\nimport { useEnsforgeContext } from \"../provider/context.js\";\nimport { errorFromCause } from \"../query/result.js\";\n\nexport const makeMutationHook =\n  <Parameters, Success, Failure>(factory: EnsMutationAtomFactory<Parameters, Success, Failure>) =>\n  (\n    options: EnsMutationOptions<Parameters, Success, Failure> = {},\n  ): EnsMutationResult<Parameters, Success, Failure> => {\n    const { sdk } = useEnsforgeContext();\n    const registry = useContext(RegistryContext);\n    const atomRef = useRef<ReturnType<typeof factory> | undefined>(undefined);\n    const [parameters, setParameters] = useState<Parameters | undefined>(undefined);\n    if (atomRef.current === undefined) atomRef.current = factory(sdk);\n    const atom = atomRef.current;\n    const result = useAtomValue(atom);\n\n    const mutateEffect = (nextParameters: Parameters): Effect.Effect<Success, Failure> => {\n      const effect = Effect.sync(() => {\n        setParameters(nextParameters);\n        registry.set(atom, nextParameters);\n      }).pipe(\n        Effect.andThen(\n          AtomRegistry.getResult(registry, atom, {\n            suspendOnWaiting: true,\n          }),\n        ),\n      );\n      return options.retry === undefined || options.retry === false\n        ? effect\n        : effect.pipe(Effect.retry({ times: options.retry }));\n    };\n\n    const runCallbacks = (\n      exit: Exit.Exit<Success, Failure>,\n      nextParameters: Parameters,\n      local: EnsMutationCallbacks<Parameters, Success, Failure> | undefined,\n    ) => {\n      if (Exit.isSuccess(exit)) {\n        options.onSuccess?.(exit.value, nextParameters);\n        local?.onSuccess?.(exit.value, nextParameters);\n        options.onSettled?.(exit.value, null, nextParameters);\n        local?.onSettled?.(exit.value, null, nextParameters);\n        return;\n      }\n\n      const error = errorFromCause(exit.cause);\n      options.onError?.(error, nextParameters);\n      local?.onError?.(error, nextParameters);\n      options.onSettled?.(undefined, error, nextParameters);\n      local?.onSettled?.(undefined, error, nextParameters);\n    };\n\n    const mutate = (\n      nextParameters: Parameters,\n      callbacks?: EnsMutationCallbacks<Parameters, Success, Failure>,\n    ) => {\n      void Effect.runPromiseExit(mutateEffect(nextParameters)).then((exit) =>\n        runCallbacks(exit, nextParameters, callbacks),\n      );\n    };\n\n    const mutateAsync = async (nextParameters: Parameters): Promise<Success> => {\n      const exit = await Effect.runPromiseExit(mutateEffect(nextParameters));\n      runCallbacks(exit, nextParameters, undefined);\n      if (Exit.isSuccess(exit)) return exit.value;\n      throw Cause.squash(exit.cause);\n    };\n\n    const cause = Option.getOrNull(AsyncResult.cause(result));\n    const data = Option.getOrUndefined(AsyncResult.value(result));\n    const isIdle = AsyncResult.isInitial(result) && !result.waiting;\n    const isPending = result.waiting;\n    const isError = AsyncResult.isFailure(result);\n    const isSuccess = AsyncResult.isSuccess(result) && !result.waiting;\n\n    return {\n      cause,\n      data,\n      error: cause === null ? null : errorFromCause(cause),\n      interrupt: () => registry.set(atom, Atom.Interrupt),\n      isError,\n      isIdle,\n      isPending,\n      isSuccess,\n      mutate,\n      mutateAsync,\n      mutateEffect,\n      parameters,\n      reset: () => {\n        setParameters(undefined);\n        registry.set(atom, Atom.Reset);\n      },\n      result,\n      status: isPending ? \"pending\" : isError ? \"error\" : isSuccess ? \"success\" : \"idle\",\n    };\n  };\n"],"mappings":";;;;;;;;;;AAcA,MAAa,oBACoB,aAE7B,UAA4D,CAAC,MACT;CACpD,MAAM,EAAE,QAAQ,mBAAmB;CACnC,MAAM,WAAW,WAAW,eAAe;CAC3C,MAAM,UAAU,OAA+C,MAAS;CACxE,MAAM,CAAC,YAAY,iBAAiB,SAAiC,MAAS;CAC9E,IAAI,QAAQ,YAAY,QAAW,QAAQ,UAAU,QAAQ,GAAG;CAChE,MAAM,OAAO,QAAQ;CACrB,MAAM,SAAS,aAAa,IAAI;CAEhC,MAAM,gBAAgB,mBAAgE;EACpF,MAAM,SAAS,OAAO,WAAW;GAC/B,cAAc,cAAc;GAC5B,SAAS,IAAI,MAAM,cAAc;EACnC,CAAC,CAAC,CAAC,KACD,OAAO,QACL,aAAa,UAAU,UAAU,MAAM,EACrC,kBAAkB,KACpB,CAAC,CACH,CACF;EACA,OAAO,QAAQ,UAAU,UAAa,QAAQ,UAAU,QACpD,SACA,OAAO,KAAK,OAAO,MAAM,EAAE,OAAO,QAAQ,MAAM,CAAC,CAAC;CACxD;CAEA,MAAM,gBACJ,MACA,gBACA,UACG;EACH,IAAI,KAAK,UAAU,IAAI,GAAG;GACxB,QAAQ,YAAY,KAAK,OAAO,cAAc;GAC9C,OAAO,YAAY,KAAK,OAAO,cAAc;GAC7C,QAAQ,YAAY,KAAK,OAAO,MAAM,cAAc;GACpD,OAAO,YAAY,KAAK,OAAO,MAAM,cAAc;GACnD;EACF;EAEA,MAAM,QAAQ,eAAe,KAAK,KAAK;EACvC,QAAQ,UAAU,OAAO,cAAc;EACvC,OAAO,UAAU,OAAO,cAAc;EACtC,QAAQ,YAAY,QAAW,OAAO,cAAc;EACpD,OAAO,YAAY,QAAW,OAAO,cAAc;CACrD;CAEA,MAAM,UACJ,gBACA,cACG;EACH,AAAK,OAAO,eAAe,aAAa,cAAc,CAAC,CAAC,CAAC,MAAM,SAC7D,aAAa,MAAM,gBAAgB,SAAS,CAC9C;CACF;CAEA,MAAM,cAAc,OAAO,mBAAiD;EAC1E,MAAM,OAAO,MAAM,OAAO,eAAe,aAAa,cAAc,CAAC;EACrE,aAAa,MAAM,gBAAgB,MAAS;EAC5C,IAAI,KAAK,UAAU,IAAI,GAAG,OAAO,KAAK;EACtC,MAAM,MAAM,OAAO,KAAK,KAAK;CAC/B;CAEA,MAAM,QAAQ,OAAO,UAAU,YAAY,MAAM,MAAM,CAAC;CACxD,MAAM,OAAO,OAAO,eAAe,YAAY,MAAM,MAAM,CAAC;CAC5D,MAAM,SAAS,YAAY,UAAU,MAAM,KAAK,CAAC,OAAO;CACxD,MAAM,YAAY,OAAO;CACzB,MAAM,UAAU,YAAY,UAAU,MAAM;CAC5C,MAAM,YAAY,YAAY,UAAU,MAAM,KAAK,CAAC,OAAO;CAE3D,OAAO;EACL;EACA;EACA,OAAO,UAAU,OAAO,OAAO,eAAe,KAAK;EACnD,iBAAiB,SAAS,IAAI,MAAM,KAAK,SAAS;EAClD;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,aAAa;GACX,cAAc,MAAS;GACvB,SAAS,IAAI,MAAM,KAAK,KAAK;EAC/B;EACA;EACA,QAAQ,YAAY,YAAY,UAAU,UAAU,YAAY,YAAY;CAC9E;AACF"}
+{"version":3,"file":"use-mutation.js","names":[],"sources":["../../src/hooks/use-mutation.ts"],"sourcesContent":["\"use client\";\n\nimport { useContext, useRef, useState } from \"react\";\n\nimport { RegistryContext, useAtomValue } from \"@effect/atom-react\";\nimport { Cause, Effect, Exit, Option, type Schedule } from \"effect\";\nimport { AsyncResult, Atom, AtomRegistry } from \"effect/unstable/reactivity\";\n\nimport type { EnsMutationAtomFactory } from \"../atoms/mutation.js\";\nimport type { EnsMutationExecutionOptions, EnsMutationOptions } from \"../mutation/options.js\";\nimport type { EnsMutationResult } from \"../mutation/result.js\";\nimport { useEnsforgeContext } from \"../provider/context.js\";\nimport { errorFromCause } from \"../query/result.js\";\n\nexport const makeMutationHook =\n  <Parameters, Success, Failure>(factory: EnsMutationAtomFactory<Parameters, Success, Failure>) =>\n  (\n    options: EnsMutationOptions<Parameters, Success, Failure> = {},\n  ): EnsMutationResult<Parameters, Success, Failure> => {\n    const { defaults, sdk } = useEnsforgeContext();\n    const registry = useContext(RegistryContext);\n    const atomRef = useRef<ReturnType<typeof factory> | undefined>(undefined);\n    const [parameters, setParameters] = useState<Parameters | undefined>(undefined);\n    if (atomRef.current === undefined) atomRef.current = factory(sdk);\n    const atom = atomRef.current;\n    const result = useAtomValue(atom);\n    const retry =\n      options.retry ??\n      (defaults.mutations?.retry as false | Schedule.Schedule<unknown, Failure> | undefined) ??\n      false;\n\n    const mutateEffect = (nextParameters: Parameters): Effect.Effect<Success, Failure> => {\n      const effect = Effect.sync(() => {\n        setParameters(nextParameters);\n        registry.set(atom, nextParameters);\n      }).pipe(\n        Effect.andThen(\n          AtomRegistry.getResult(registry, atom, {\n            suspendOnWaiting: true,\n          }),\n        ),\n      );\n      return retry === false ? effect : effect.pipe(Effect.retry(retry));\n    };\n\n    const notifyExit = (\n      exit: Exit.Exit<Success, Failure>,\n      nextParameters: Parameters,\n      local: EnsMutationExecutionOptions<Parameters, Success, Failure> | undefined,\n    ) => {\n      options.onExit?.(exit, nextParameters);\n      local?.onExit?.(exit, nextParameters);\n    };\n\n    const mutateAsync = async (nextParameters: Parameters): Promise<Success> => {\n      const exit = await Effect.runPromiseExit(mutateEffect(nextParameters));\n      notifyExit(exit, nextParameters, undefined);\n      if (Exit.isSuccess(exit)) return exit.value;\n      throw Cause.squash(exit.cause);\n    };\n\n    const mutate = (\n      nextParameters: Parameters,\n      local?: EnsMutationExecutionOptions<Parameters, Success, Failure>,\n    ) => {\n      void Effect.runPromiseExit(mutateEffect(nextParameters)).then((exit) =>\n        notifyExit(exit, nextParameters, local),\n      );\n    };\n\n    const cause = Option.getOrNull(AsyncResult.cause(result));\n\n    return {\n      cause,\n      data: Option.getOrUndefined(AsyncResult.value(result)),\n      error: cause === null ? null : errorFromCause(cause),\n      interrupt: () => registry.set(atom, Atom.Interrupt),\n      isFailure: AsyncResult.isFailure(result),\n      isInitial: AsyncResult.isInitial(result) && !result.waiting,\n      isSuccess: AsyncResult.isSuccess(result) && !result.waiting,\n      isWaiting: result.waiting,\n      mutate,\n      mutateAsync,\n      mutateEffect,\n      parameters,\n      reset: () => {\n        setParameters(undefined);\n        registry.set(atom, Atom.Reset);\n      },\n      result,\n    };\n  };\n"],"mappings":";;;;;;;;;;AAcA,MAAa,oBACoB,aAE7B,UAA4D,CAAC,MACT;CACpD,MAAM,EAAE,UAAU,QAAQ,mBAAmB;CAC7C,MAAM,WAAW,WAAW,eAAe;CAC3C,MAAM,UAAU,OAA+C,MAAS;CACxE,MAAM,CAAC,YAAY,iBAAiB,SAAiC,MAAS;CAC9E,IAAI,QAAQ,YAAY,QAAW,QAAQ,UAAU,QAAQ,GAAG;CAChE,MAAM,OAAO,QAAQ;CACrB,MAAM,SAAS,aAAa,IAAI;CAChC,MAAM,QACJ,QAAQ,SACP,SAAS,WAAW,SACrB;CAEF,MAAM,gBAAgB,mBAAgE;EACpF,MAAM,SAAS,OAAO,WAAW;GAC/B,cAAc,cAAc;GAC5B,SAAS,IAAI,MAAM,cAAc;EACnC,CAAC,CAAC,CAAC,KACD,OAAO,QACL,aAAa,UAAU,UAAU,MAAM,EACrC,kBAAkB,KACpB,CAAC,CACH,CACF;EACA,OAAO,UAAU,QAAQ,SAAS,OAAO,KAAK,OAAO,MAAM,KAAK,CAAC;CACnE;CAEA,MAAM,cACJ,MACA,gBACA,UACG;EACH,QAAQ,SAAS,MAAM,cAAc;EACrC,OAAO,SAAS,MAAM,cAAc;CACtC;CAEA,MAAM,cAAc,OAAO,mBAAiD;EAC1E,MAAM,OAAO,MAAM,OAAO,eAAe,aAAa,cAAc,CAAC;EACrE,WAAW,MAAM,gBAAgB,MAAS;EAC1C,IAAI,KAAK,UAAU,IAAI,GAAG,OAAO,KAAK;EACtC,MAAM,MAAM,OAAO,KAAK,KAAK;CAC/B;CAEA,MAAM,UACJ,gBACA,UACG;EACH,AAAK,OAAO,eAAe,aAAa,cAAc,CAAC,CAAC,CAAC,MAAM,SAC7D,WAAW,MAAM,gBAAgB,KAAK,CACxC;CACF;CAEA,MAAM,QAAQ,OAAO,UAAU,YAAY,MAAM,MAAM,CAAC;CAExD,OAAO;EACL;EACA,MAAM,OAAO,eAAe,YAAY,MAAM,MAAM,CAAC;EACrD,OAAO,UAAU,OAAO,OAAO,eAAe,KAAK;EACnD,iBAAiB,SAAS,IAAI,MAAM,KAAK,SAAS;EAClD,WAAW,YAAY,UAAU,MAAM;EACvC,WAAW,YAAY,UAAU,MAAM,KAAK,CAAC,OAAO;EACpD,WAAW,YAAY,UAAU,MAAM,KAAK,CAAC,OAAO;EACpD,WAAW,OAAO;EAClB;EACA;EACA;EACA;EACA,aAAa;GACX,cAAc,MAAS;GACvB,SAAS,IAAI,MAAM,KAAK,KAAK;EAC/B;EACA;CACF;AACF"}

package/dist/hooks/use-query.d.ts

@@ -1,10 +1,10 @@
-import { EnsQueryAtomFactory } from "../atoms/query.js";
-import { UseEnsQueryParameters } from "../query/options.js";
-import { EnsQueryResult } from "../query/result.js";
+import { UseEnsAtomParameters } from "../query/options.js";
+import { EnsAtomFactory } from "../atoms/query.js";
+import { EnsAtomResult } from "../query/result.js";
 import { AsyncResult, Atom, AtomRegistry } from "effect/unstable/reactivity";
 //#region src/hooks/use-query.d.ts
-declare const makeQueryHook: <Parameters extends object, Success, Failure>(factory: EnsQueryAtomFactory<Parameters, Success, Failure>) => <Selected = Success>(input: UseEnsQueryParameters<Parameters, Success, Selected>) => EnsQueryResult<Selected, Failure>;
-declare const prefetchQueryAtom: <Success, Failure>(registry: AtomRegistry.AtomRegistry, atom: Atom.Atom<AsyncResult.AsyncResult<Success, Failure>>, signal?: AbortSignal) => Promise<Success>;
+declare const makeQueryHook: <Parameters extends object, Success, Failure>(factory: EnsAtomFactory<Parameters, Success, Failure>) => <Mapped = Success>(input: UseEnsAtomParameters<Parameters, Success, Failure, Mapped>) => EnsAtomResult<Mapped, Failure>;
+declare const prefetchAtom: <Success, Failure>(registry: AtomRegistry.AtomRegistry, atom: Atom.Atom<AsyncResult.AsyncResult<Success, Failure>>, signal?: AbortSignal) => Promise<Success>;
 //#endregion
-export { makeQueryHook, prefetchQueryAtom };
+export { makeQueryHook, prefetchAtom };
 //# sourceMappingURL=use-query.d.ts.map

package/dist/hooks/use-query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-query.d.ts","names":[],"sources":["../../src/hooks/use-query.ts"],"mappings":";;;;;cAiGa,gBACV,2BAA2B,SAAS,SACnC,SAAS,oBAAoB,YAAY,SAAS,cAEnD,WAAW,SACV,OAAO,sBAAsB,YAAY,SAAS,cACjD,eAAe,UAAU;cAGjB,oBAAqB,SAAS,SACzC,UAAU,aAAa,cACvB,MAAM,KAAK,KAAK,YAAY,YAAY,SAAS,WACjD,SAAS,gBACR,QAAQ"}
+{"version":3,"file":"use-query.d.ts","names":[],"sources":["../../src/hooks/use-query.ts"],"mappings":";;;;;cAiFa,gBACV,2BAA2B,SAAS,SACnC,SAAS,eAAe,YAAY,SAAS,cAE9C,SAAS,SACR,OAAO,qBAAqB,YAAY,SAAS,SAAS,YACzD,cAAc,QAAQ;cAGd,eAAgB,SAAS,SACpC,UAAU,aAAa,cACvB,MAAM,KAAK,KAAK,YAAY,YAAY,SAAS,WACjD,SAAS,gBACR,QAAQ"}

package/dist/hooks/use-query.js

@@ -1,81 +1,53 @@
 "use client";
 
+import { resolveEnsAtomOptions } from "../query/options.js";
 import { useEnsforgeContext } from "../provider/context.js";
 import { errorFromCause, resultUpdatedAt } from "../query/result.js";
-import { resolveEnsQueryOptions } from "../query/options.js";
 import { Effect, Option } from "effect";
 import { AsyncResult, Atom, AtomRegistry } from "effect/unstable/reactivity";
 import { RegistryContext, useAtomValue } from "@effect/atom-react";
-import { useContext, useEffect, useRef } from "react";
+import { useContext } from "react";
 
 //#region src/hooks/use-query.ts
 const disabledAtom = Atom.make(AsyncResult.initial());
-const splitQueryParameters = (input) => {
-	const { query, ...parameters } = input;
-	return [parameters, query];
+const splitAtomParameters = (input) => {
+	const { atom, enabled = true, map, ...parameters } = input;
+	return {
+		atom,
+		enabled,
+		map,
+		parameters
+	};
 };
 const useQueryAtom = (factory, input) => {
 	const { defaults, sdk } = useEnsforgeContext();
 	const registry = useContext(RegistryContext);
-	const [parameters, query] = splitQueryParameters(input);
-	const options = resolveEnsQueryOptions(defaults.queries, query);
-	const enabled = query?.enabled ?? true;
-	const atom = factory(sdk, parameters, options);
+	const { atom: atomOptions, enabled, map, parameters } = splitAtomParameters(input);
+	const atom = factory(sdk, parameters, resolveEnsAtomOptions(defaults.atoms, atomOptions));
 	const rawResult = useAtomValue(enabled ? atom : disabledAtom);
-	const result = query?.select === void 0 ? rawResult : AsyncResult.map(rawResult, query.select);
-	const staleCheckedAtom = useRef(void 0);
-	useEffect(() => {
-		if (staleCheckedAtom.current === atom) return;
-		staleCheckedAtom.current = atom;
-		if (!enabled || !AsyncResult.isSuccess(rawResult)) return;
-		if (Date.now() - rawResult.timestamp >= options.staleTime) registry.refresh(atom);
-	}, [
-		atom,
-		enabled,
-		options.staleTime,
-		rawResult,
-		registry
-	]);
-	useEffect(() => {
-		if (!enabled || options.refetchInterval === false) return;
-		const interval = globalThis.setInterval(() => registry.refresh(atom), options.refetchInterval);
-		return () => globalThis.clearInterval(interval);
-	}, [
-		atom,
-		enabled,
-		options.refetchInterval,
-		registry
-	]);
-	const refetchEffect = () => {
+	const result = map === void 0 ? rawResult : AsyncResult.map(rawResult, map);
+	const refreshEffect = () => {
 		const effect = Effect.sync(() => registry.refresh(atom)).pipe(Effect.andThen(AtomRegistry.getResult(registry, atom, { suspendOnWaiting: true })));
-		return query?.select === void 0 ? effect : effect.pipe(Effect.map(query.select));
+		return map === void 0 ? effect : effect.pipe(Effect.map(map));
 	};
 	const cause = Option.getOrNull(AsyncResult.cause(result));
-	const data = Option.getOrUndefined(AsyncResult.value(result));
-	const isPending = AsyncResult.isInitial(result);
-	const isError = AsyncResult.isFailure(result);
-	const isSuccess = AsyncResult.isSuccess(result);
 	return {
 		cause,
-		data,
+		data: Option.getOrUndefined(AsyncResult.value(result)),
 		error: cause === null ? null : errorFromCause(cause),
-		fetchStatus: result.waiting ? "fetching" : "idle",
-		isError,
-		isFetching: result.waiting,
-		isLoading: isPending && result.waiting,
-		isPending,
-		isRefetching: !isPending && result.waiting,
-		isSuccess,
-		refetch: () => Effect.runPromise(refetchEffect()),
-		refetchEffect,
+		isFailure: AsyncResult.isFailure(result),
+		isInitial: AsyncResult.isInitial(result),
+		isSuccess: AsyncResult.isSuccess(result),
+		isWaiting: result.waiting,
+		refresh: () => Effect.runPromise(refreshEffect()),
+		refreshEffect,
 		result,
-		status: isPending ? "pending" : isError ? "error" : "success",
 		updatedAt: resultUpdatedAt(result)
 	};
 };
 const makeQueryHook = (factory) => (input) => useQueryAtom(factory, input);
-const prefetchQueryAtom = (registry, atom, signal) => Effect.runPromise(AtomRegistry.getResult(registry, atom, { suspendOnWaiting: true }), { signal });
+const prefetchAtom = (registry, atom, signal) => Effect.runPromise(AtomRegistry.getResult(registry, atom, { suspendOnWaiting: true }), { signal });
 
 //#endregion
-export { makeQueryHook, prefetchQueryAtom, useQueryAtom };
+export { makeQueryHook, prefetchAtom, useQueryAtom };
 //# sourceMappingURL=use-query.js.map

package/dist/hooks/use-query.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-query.js","names":[],"sources":["../../src/hooks/use-query.ts"],"sourcesContent":["\"use client\";\n\nimport { useContext, useEffect, useRef } from \"react\";\n\nimport { useAtomValue, RegistryContext } from \"@effect/atom-react\";\nimport { Effect, Option } from \"effect\";\nimport { AsyncResult, Atom, AtomRegistry } from \"effect/unstable/reactivity\";\n\nimport type { EnsQueryAtomFactory } from \"../atoms/query.js\";\nimport { useEnsforgeContext } from \"../provider/context.js\";\nimport {\n  resolveEnsQueryOptions,\n  type EnsQueryOptions,\n  type UseEnsQueryParameters,\n} from \"../query/options.js\";\nimport { errorFromCause, resultUpdatedAt, type EnsQueryResult } from \"../query/result.js\";\n\nconst disabledAtom = Atom.make(AsyncResult.initial<unknown, unknown>());\n\nconst splitQueryParameters = <Parameters extends object, Success, Selected>(\n  input: UseEnsQueryParameters<Parameters, Success, Selected>,\n): readonly [Parameters, EnsQueryOptions<Success, Selected> | undefined] => {\n  const { query, ...parameters } = input;\n  return [parameters as Parameters, query];\n};\n\nexport const useQueryAtom = <Parameters extends object, Success, Failure, Selected = Success>(\n  factory: EnsQueryAtomFactory<Parameters, Success, Failure>,\n  input: UseEnsQueryParameters<Parameters, Success, Selected>,\n): EnsQueryResult<Selected, Failure> => {\n  const { defaults, sdk } = useEnsforgeContext();\n  const registry = useContext(RegistryContext);\n  const [parameters, query] = splitQueryParameters(input);\n  const options = resolveEnsQueryOptions(defaults.queries, query);\n  const enabled = query?.enabled ?? true;\n  const atom = factory(sdk, parameters, options);\n  const activeAtom = (enabled ? atom : disabledAtom) as Atom.Atom<\n    AsyncResult.AsyncResult<Success, Failure>\n  >;\n  const rawResult = useAtomValue(activeAtom);\n  const result: AsyncResult.AsyncResult<Selected, Failure> =\n    query?.select === undefined\n      ? (rawResult as unknown as AsyncResult.AsyncResult<Selected, Failure>)\n      : AsyncResult.map(rawResult, query.select);\n  const staleCheckedAtom = useRef<Atom.Atom<unknown> | undefined>(undefined);\n\n  useEffect(() => {\n    if (staleCheckedAtom.current === atom) return;\n    staleCheckedAtom.current = atom;\n    if (!enabled || !AsyncResult.isSuccess(rawResult)) return;\n    if (Date.now() - rawResult.timestamp >= options.staleTime) registry.refresh(atom);\n  }, [atom, enabled, options.staleTime, rawResult, registry]);\n\n  useEffect(() => {\n    if (!enabled || options.refetchInterval === false) return;\n    const interval = globalThis.setInterval(() => registry.refresh(atom), options.refetchInterval);\n    return () => globalThis.clearInterval(interval);\n  }, [atom, enabled, options.refetchInterval, registry]);\n\n  const refetchEffect = (): Effect.Effect<Selected, Failure> => {\n    const effect = Effect.sync(() => registry.refresh(atom)).pipe(\n      Effect.andThen(\n        AtomRegistry.getResult(registry, atom, {\n          suspendOnWaiting: true,\n        }),\n      ),\n    );\n    return query?.select === undefined\n      ? (effect as unknown as Effect.Effect<Selected, Failure>)\n      : effect.pipe(Effect.map(query.select));\n  };\n\n  const cause = Option.getOrNull(AsyncResult.cause(result));\n  const data = Option.getOrUndefined(AsyncResult.value(result));\n  const isPending = AsyncResult.isInitial(result);\n  const isError = AsyncResult.isFailure(result);\n  const isSuccess = AsyncResult.isSuccess(result);\n\n  return {\n    cause,\n    data,\n    error: cause === null ? null : errorFromCause(cause),\n    fetchStatus: result.waiting ? \"fetching\" : \"idle\",\n    isError,\n    isFetching: result.waiting,\n    isLoading: isPending && result.waiting,\n    isPending,\n    isRefetching: !isPending && result.waiting,\n    isSuccess,\n    refetch: () => Effect.runPromise(refetchEffect()),\n    refetchEffect,\n    result,\n    status: isPending ? \"pending\" : isError ? \"error\" : \"success\",\n    updatedAt: resultUpdatedAt(result),\n  };\n};\n\nexport const makeQueryHook =\n  <Parameters extends object, Success, Failure>(\n    factory: EnsQueryAtomFactory<Parameters, Success, Failure>,\n  ) =>\n  <Selected = Success>(\n    input: UseEnsQueryParameters<Parameters, Success, Selected>,\n  ): EnsQueryResult<Selected, Failure> =>\n    useQueryAtom(factory, input);\n\nexport const prefetchQueryAtom = <Success, Failure>(\n  registry: AtomRegistry.AtomRegistry,\n  atom: Atom.Atom<AsyncResult.AsyncResult<Success, Failure>>,\n  signal?: AbortSignal,\n): Promise<Success> =>\n  Effect.runPromise(AtomRegistry.getResult(registry, atom, { suspendOnWaiting: true }), {\n    signal,\n  });\n"],"mappings":";;;;;;;;;;;AAiBA,MAAM,eAAe,KAAK,KAAK,YAAY,QAA0B,CAAC;AAEtE,MAAM,wBACJ,UAC0E;CAC1E,MAAM,EAAE,OAAO,GAAG,eAAe;CACjC,OAAO,CAAC,YAA0B,KAAK;AACzC;AAEA,MAAa,gBACX,SACA,UACsC;CACtC,MAAM,EAAE,UAAU,QAAQ,mBAAmB;CAC7C,MAAM,WAAW,WAAW,eAAe;CAC3C,MAAM,CAAC,YAAY,SAAS,qBAAqB,KAAK;CACtD,MAAM,UAAU,uBAAuB,SAAS,SAAS,KAAK;CAC9D,MAAM,UAAU,OAAO,WAAW;CAClC,MAAM,OAAO,QAAQ,KAAK,YAAY,OAAO;CAI7C,MAAM,YAAY,aAHE,UAAU,OAAO,YAGI;CACzC,MAAM,SACJ,OAAO,WAAW,SACb,YACD,YAAY,IAAI,WAAW,MAAM,MAAM;CAC7C,MAAM,mBAAmB,OAAuC,MAAS;CAEzE,gBAAgB;EACd,IAAI,iBAAiB,YAAY,MAAM;EACvC,iBAAiB,UAAU;EAC3B,IAAI,CAAC,WAAW,CAAC,YAAY,UAAU,SAAS,GAAG;EACnD,IAAI,KAAK,IAAI,IAAI,UAAU,aAAa,QAAQ,WAAW,SAAS,QAAQ,IAAI;CAClF,GAAG;EAAC;EAAM;EAAS,QAAQ;EAAW;EAAW;CAAQ,CAAC;CAE1D,gBAAgB;EACd,IAAI,CAAC,WAAW,QAAQ,oBAAoB,OAAO;EACnD,MAAM,WAAW,WAAW,kBAAkB,SAAS,QAAQ,IAAI,GAAG,QAAQ,eAAe;EAC7F,aAAa,WAAW,cAAc,QAAQ;CAChD,GAAG;EAAC;EAAM;EAAS,QAAQ;EAAiB;CAAQ,CAAC;CAErD,MAAM,sBAAwD;EAC5D,MAAM,SAAS,OAAO,WAAW,SAAS,QAAQ,IAAI,CAAC,CAAC,CAAC,KACvD,OAAO,QACL,aAAa,UAAU,UAAU,MAAM,EACrC,kBAAkB,KACpB,CAAC,CACH,CACF;EACA,OAAO,OAAO,WAAW,SACpB,SACD,OAAO,KAAK,OAAO,IAAI,MAAM,MAAM,CAAC;CAC1C;CAEA,MAAM,QAAQ,OAAO,UAAU,YAAY,MAAM,MAAM,CAAC;CACxD,MAAM,OAAO,OAAO,eAAe,YAAY,MAAM,MAAM,CAAC;CAC5D,MAAM,YAAY,YAAY,UAAU,MAAM;CAC9C,MAAM,UAAU,YAAY,UAAU,MAAM;CAC5C,MAAM,YAAY,YAAY,UAAU,MAAM;CAE9C,OAAO;EACL;EACA;EACA,OAAO,UAAU,OAAO,OAAO,eAAe,KAAK;EACnD,aAAa,OAAO,UAAU,aAAa;EAC3C;EACA,YAAY,OAAO;EACnB,WAAW,aAAa,OAAO;EAC/B;EACA,cAAc,CAAC,aAAa,OAAO;EACnC;EACA,eAAe,OAAO,WAAW,cAAc,CAAC;EAChD;EACA;EACA,QAAQ,YAAY,YAAY,UAAU,UAAU;EACpD,WAAW,gBAAgB,MAAM;CACnC;AACF;AAEA,MAAa,iBAET,aAGA,UAEA,aAAa,SAAS,KAAK;AAE/B,MAAa,qBACX,UACA,MACA,WAEA,OAAO,WAAW,aAAa,UAAU,UAAU,MAAM,EAAE,kBAAkB,KAAK,CAAC,GAAG,EACpF,OACF,CAAC"}
+{"version":3,"file":"use-query.js","names":[],"sources":["../../src/hooks/use-query.ts"],"sourcesContent":["\"use client\";\n\nimport { useContext } from \"react\";\n\nimport { RegistryContext, useAtomValue } from \"@effect/atom-react\";\nimport { Effect, Option } from \"effect\";\nimport { AsyncResult, Atom, AtomRegistry } from \"effect/unstable/reactivity\";\n\nimport type { EnsAtomFactory } from \"../atoms/query.js\";\nimport { useEnsforgeContext } from \"../provider/context.js\";\nimport {\n  resolveEnsAtomOptions,\n  type EnsAtomOptions,\n  type UseEnsAtomParameters,\n} from \"../query/options.js\";\nimport { errorFromCause, resultUpdatedAt, type EnsAtomResult } from \"../query/result.js\";\n\nconst disabledAtom = Atom.make(AsyncResult.initial<unknown, unknown>());\n\ninterface SplitAtomParameters<Parameters, Success, Failure, Mapped> {\n  readonly atom: EnsAtomOptions<Failure> | undefined;\n  readonly enabled: boolean;\n  readonly map: ((value: Success) => Mapped) | undefined;\n  readonly parameters: Parameters;\n}\n\nconst splitAtomParameters = <Parameters extends object, Success, Failure, Mapped>(\n  input: UseEnsAtomParameters<Parameters, Success, Failure, Mapped>,\n): SplitAtomParameters<Parameters, Success, Failure, Mapped> => {\n  const { atom, enabled = true, map, ...parameters } = input;\n  return { atom, enabled, map, parameters: parameters as Parameters };\n};\n\nexport const useQueryAtom = <Parameters extends object, Success, Failure, Mapped = Success>(\n  factory: EnsAtomFactory<Parameters, Success, Failure>,\n  input: UseEnsAtomParameters<Parameters, Success, Failure, Mapped>,\n): EnsAtomResult<Mapped, Failure> => {\n  const { defaults, sdk } = useEnsforgeContext();\n  const registry = useContext(RegistryContext);\n  const { atom: atomOptions, enabled, map, parameters } = splitAtomParameters(input);\n  const options = resolveEnsAtomOptions(defaults.atoms, atomOptions);\n  const atom = factory(sdk, parameters, options);\n  const activeAtom = (enabled ? atom : disabledAtom) as Atom.Atom<\n    AsyncResult.AsyncResult<Success, Failure>\n  >;\n  const rawResult = useAtomValue(activeAtom);\n  const result: AsyncResult.AsyncResult<Mapped, Failure> =\n    map === undefined\n      ? (rawResult as unknown as AsyncResult.AsyncResult<Mapped, Failure>)\n      : AsyncResult.map(rawResult, map);\n\n  const refreshEffect = (): Effect.Effect<Mapped, Failure> => {\n    const effect = Effect.sync(() => registry.refresh(atom)).pipe(\n      Effect.andThen(\n        AtomRegistry.getResult(registry, atom, {\n          suspendOnWaiting: true,\n        }),\n      ),\n    );\n    return map === undefined\n      ? (effect as unknown as Effect.Effect<Mapped, Failure>)\n      : effect.pipe(Effect.map(map));\n  };\n\n  const cause = Option.getOrNull(AsyncResult.cause(result));\n\n  return {\n    cause,\n    data: Option.getOrUndefined(AsyncResult.value(result)),\n    error: cause === null ? null : errorFromCause(cause),\n    isFailure: AsyncResult.isFailure(result),\n    isInitial: AsyncResult.isInitial(result),\n    isSuccess: AsyncResult.isSuccess(result),\n    isWaiting: result.waiting,\n    refresh: () => Effect.runPromise(refreshEffect()),\n    refreshEffect,\n    result,\n    updatedAt: resultUpdatedAt(result),\n  };\n};\n\nexport const makeQueryHook =\n  <Parameters extends object, Success, Failure>(\n    factory: EnsAtomFactory<Parameters, Success, Failure>,\n  ) =>\n  <Mapped = Success>(\n    input: UseEnsAtomParameters<Parameters, Success, Failure, Mapped>,\n  ): EnsAtomResult<Mapped, Failure> =>\n    useQueryAtom(factory, input);\n\nexport const prefetchAtom = <Success, Failure>(\n  registry: AtomRegistry.AtomRegistry,\n  atom: Atom.Atom<AsyncResult.AsyncResult<Success, Failure>>,\n  signal?: AbortSignal,\n): Promise<Success> =>\n  Effect.runPromise(AtomRegistry.getResult(registry, atom, { suspendOnWaiting: true }), {\n    signal,\n  });\n"],"mappings":";;;;;;;;;;;AAiBA,MAAM,eAAe,KAAK,KAAK,YAAY,QAA0B,CAAC;AAStE,MAAM,uBACJ,UAC8D;CAC9D,MAAM,EAAE,MAAM,UAAU,MAAM,KAAK,GAAG,eAAe;CACrD,OAAO;EAAE;EAAM;EAAS;EAAiB;CAAyB;AACpE;AAEA,MAAa,gBACX,SACA,UACmC;CACnC,MAAM,EAAE,UAAU,QAAQ,mBAAmB;CAC7C,MAAM,WAAW,WAAW,eAAe;CAC3C,MAAM,EAAE,MAAM,aAAa,SAAS,KAAK,eAAe,oBAAoB,KAAK;CAEjF,MAAM,OAAO,QAAQ,KAAK,YADV,sBAAsB,SAAS,OAAO,WACV,CAAC;CAI7C,MAAM,YAAY,aAHE,UAAU,OAAO,YAGI;CACzC,MAAM,SACJ,QAAQ,SACH,YACD,YAAY,IAAI,WAAW,GAAG;CAEpC,MAAM,sBAAsD;EAC1D,MAAM,SAAS,OAAO,WAAW,SAAS,QAAQ,IAAI,CAAC,CAAC,CAAC,KACvD,OAAO,QACL,aAAa,UAAU,UAAU,MAAM,EACrC,kBAAkB,KACpB,CAAC,CACH,CACF;EACA,OAAO,QAAQ,SACV,SACD,OAAO,KAAK,OAAO,IAAI,GAAG,CAAC;CACjC;CAEA,MAAM,QAAQ,OAAO,UAAU,YAAY,MAAM,MAAM,CAAC;CAExD,OAAO;EACL;EACA,MAAM,OAAO,eAAe,YAAY,MAAM,MAAM,CAAC;EACrD,OAAO,UAAU,OAAO,OAAO,eAAe,KAAK;EACnD,WAAW,YAAY,UAAU,MAAM;EACvC,WAAW,YAAY,UAAU,MAAM;EACvC,WAAW,YAAY,UAAU,MAAM;EACvC,WAAW,OAAO;EAClB,eAAe,OAAO,WAAW,cAAc,CAAC;EAChD;EACA;EACA,WAAW,gBAAgB,MAAM;CACnC;AACF;AAEA,MAAa,iBAET,aAGA,UAEA,aAAa,SAAS,KAAK;AAE/B,MAAa,gBACX,UACA,MACA,WAEA,OAAO,WAAW,aAAa,UAAU,UAAU,MAAM,EAAE,kBAAkB,KAAK,CAAC,GAAG,EACpF,OACF,CAAC"}

package/dist/hooks/use-suspense-query.d.ts

@@ -1,15 +1,16 @@
-import { EnsQueryAtomFactory } from "../atoms/query.js";
-import { EnsQueryOptions } from "../query/options.js";
+import { EnsAtomOptions } from "../query/options.js";
+import { EnsAtomFactory } from "../atoms/query.js";
 //#region src/hooks/use-suspense-query.d.ts
-type UseEnsSuspenseQueryParameters<Parameters, Success, Selected = Success> = Parameters & {
-  readonly query?: Omit<EnsQueryOptions<Success, Selected>, "enabled">;
+type UseEnsSuspenseAtomParameters<Parameters, Success, Failure, Mapped = Success> = Parameters & {
+  readonly atom?: EnsAtomOptions<Failure>;
+  readonly map?: (value: Success) => Mapped;
 };
-interface EnsSuspenseQueryResult<Success> {
+interface EnsSuspenseAtomResult<Success> {
   readonly data: Success;
-  readonly isFetching: boolean;
+  readonly isWaiting: boolean;
   readonly updatedAt: number;
 }
-declare const makeSuspenseQueryHook: <Parameters extends object, Success, Failure>(factory: EnsQueryAtomFactory<Parameters, Success, Failure>) => <Selected = Success>(input: UseEnsSuspenseQueryParameters<Parameters, Success, Selected>) => EnsSuspenseQueryResult<Selected>;
+declare const makeSuspenseQueryHook: <Parameters extends object, Success, Failure>(factory: EnsAtomFactory<Parameters, Success, Failure>) => <Mapped = Success>(input: UseEnsSuspenseAtomParameters<Parameters, Success, Failure, Mapped>) => EnsSuspenseAtomResult<Mapped>;
 //#endregion
-export { EnsSuspenseQueryResult, UseEnsSuspenseQueryParameters, makeSuspenseQueryHook };
+export { EnsSuspenseAtomResult, UseEnsSuspenseAtomParameters, makeSuspenseQueryHook };
 //# sourceMappingURL=use-suspense-query.d.ts.map

package/dist/hooks/use-suspense-query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-suspense-query.d.ts","names":[],"sources":["../../src/hooks/use-suspense-query.ts"],"mappings":";;;KAYY,8BAA8B,YAAY,SAAS,WAAW,WAAW;WAC1E,QAAQ,KAAK,gBAAgB,SAAS;;UAGhC,uBAAuB;WAC7B,MAAM;WACN;WACA;;cAGE,wBACV,2BAA2B,SAAS,SACnC,SAAS,oBAAoB,YAAY,SAAS,cAEnD,WAAW,SACV,OAAO,8BAA8B,YAAY,SAAS,cACzD,uBAAuB"}
+{"version":3,"file":"use-suspense-query.d.ts","names":[],"sources":["../../src/hooks/use-suspense-query.ts"],"mappings":";;;KAYY,6BACV,YACA,SACA,SACA,SAAS,WACP;WACO,OAAO,eAAe;WACtB,OAAO,OAAO,YAAY;;UAGpB,sBAAsB;WAC5B,MAAM;WACN;WACA;;cAGE,wBACV,2BAA2B,SAAS,SACnC,SAAS,eAAe,YAAY,SAAS,cAE9C,SAAS,SACR,OAAO,6BAA6B,YAAY,SAAS,SAAS,YACjE,sBAAsB"}

package/dist/hooks/use-suspense-query.js

@@ -1,18 +1,18 @@
 "use client";
 
+import { resolveEnsAtomOptions } from "../query/options.js";
 import { useEnsforgeContext } from "../provider/context.js";
-import { resolveEnsQueryOptions } from "../query/options.js";
 import { useAtomSuspense } from "@effect/atom-react";
 
 //#region src/hooks/use-suspense-query.ts
 const makeSuspenseQueryHook = (factory) => (input) => {
 	const { defaults, sdk } = useEnsforgeContext();
-	const { query, ...parameters } = input;
-	const atom = factory(sdk, parameters, resolveEnsQueryOptions(defaults.queries, query));
+	const { atom: atomOptions, map, ...parameters } = input;
+	const atom = factory(sdk, parameters, resolveEnsAtomOptions(defaults.atoms, atomOptions));
 	const result = useAtomSuspense(atom, { suspendOnWaiting: false });
 	return {
-		data: query?.select === void 0 ? result.value : query.select(result.value),
-		isFetching: result.waiting,
+		data: map === void 0 ? result.value : map(result.value),
+		isWaiting: result.waiting,
 		updatedAt: result.timestamp
 	};
 };

package/dist/hooks/use-suspense-query.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-suspense-query.js","names":[],"sources":["../../src/hooks/use-suspense-query.ts"],"sourcesContent":["\"use client\";\n\nimport { useAtomSuspense } from \"@effect/atom-react\";\n\nimport type { EnsQueryAtomFactory } from \"../atoms/query.js\";\nimport { useEnsforgeContext } from \"../provider/context.js\";\nimport {\n  resolveEnsQueryOptions,\n  type EnsQueryOptions,\n  type UseEnsQueryParameters,\n} from \"../query/options.js\";\n\nexport type UseEnsSuspenseQueryParameters<Parameters, Success, Selected = Success> = Parameters & {\n  readonly query?: Omit<EnsQueryOptions<Success, Selected>, \"enabled\">;\n};\n\nexport interface EnsSuspenseQueryResult<Success> {\n  readonly data: Success;\n  readonly isFetching: boolean;\n  readonly updatedAt: number;\n}\n\nexport const makeSuspenseQueryHook =\n  <Parameters extends object, Success, Failure>(\n    factory: EnsQueryAtomFactory<Parameters, Success, Failure>,\n  ) =>\n  <Selected = Success>(\n    input: UseEnsSuspenseQueryParameters<Parameters, Success, Selected>,\n  ): EnsSuspenseQueryResult<Selected> => {\n    const { defaults, sdk } = useEnsforgeContext();\n    const { query, ...parameters } = input as UseEnsQueryParameters<Parameters, Success, Selected>;\n    const options = resolveEnsQueryOptions(defaults.queries, query);\n    const atom = factory(sdk, parameters as Parameters, options);\n    const result = useAtomSuspense(atom, { suspendOnWaiting: false });\n\n    return {\n      data:\n        query?.select === undefined\n          ? (result.value as unknown as Selected)\n          : query.select(result.value),\n      isFetching: result.waiting,\n      updatedAt: result.timestamp,\n    };\n  };\n"],"mappings":";;;;;;;AAsBA,MAAa,yBAET,aAGA,UACqC;CACrC,MAAM,EAAE,UAAU,QAAQ,mBAAmB;CAC7C,MAAM,EAAE,OAAO,GAAG,eAAe;CAEjC,MAAM,OAAO,QAAQ,KAAK,YADV,uBAAuB,SAAS,SAAS,KACC,CAAC;CAC3D,MAAM,SAAS,gBAAgB,MAAM,EAAE,kBAAkB,MAAM,CAAC;CAEhE,OAAO;EACL,MACE,OAAO,WAAW,SACb,OAAO,QACR,MAAM,OAAO,OAAO,KAAK;EAC/B,YAAY,OAAO;EACnB,WAAW,OAAO;CACpB;AACF"}
+{"version":3,"file":"use-suspense-query.js","names":[],"sources":["../../src/hooks/use-suspense-query.ts"],"sourcesContent":["\"use client\";\n\nimport { useAtomSuspense } from \"@effect/atom-react\";\n\nimport type { EnsAtomFactory } from \"../atoms/query.js\";\nimport { useEnsforgeContext } from \"../provider/context.js\";\nimport {\n  resolveEnsAtomOptions,\n  type EnsAtomOptions,\n  type UseEnsAtomParameters,\n} from \"../query/options.js\";\n\nexport type UseEnsSuspenseAtomParameters<\n  Parameters,\n  Success,\n  Failure,\n  Mapped = Success,\n> = Parameters & {\n  readonly atom?: EnsAtomOptions<Failure>;\n  readonly map?: (value: Success) => Mapped;\n};\n\nexport interface EnsSuspenseAtomResult<Success> {\n  readonly data: Success;\n  readonly isWaiting: boolean;\n  readonly updatedAt: number;\n}\n\nexport const makeSuspenseQueryHook =\n  <Parameters extends object, Success, Failure>(\n    factory: EnsAtomFactory<Parameters, Success, Failure>,\n  ) =>\n  <Mapped = Success>(\n    input: UseEnsSuspenseAtomParameters<Parameters, Success, Failure, Mapped>,\n  ): EnsSuspenseAtomResult<Mapped> => {\n    const { defaults, sdk } = useEnsforgeContext();\n    const {\n      atom: atomOptions,\n      map,\n      ...parameters\n    } = input as UseEnsAtomParameters<Parameters, Success, Failure, Mapped>;\n    const options = resolveEnsAtomOptions(defaults.atoms, atomOptions);\n    const atom = factory(sdk, parameters as Parameters, options);\n    const result = useAtomSuspense(atom, { suspendOnWaiting: false });\n\n    return {\n      data: map === undefined ? (result.value as unknown as Mapped) : map(result.value),\n      isWaiting: result.waiting,\n      updatedAt: result.timestamp,\n    };\n  };\n"],"mappings":";;;;;;;AA4BA,MAAa,yBAET,aAGA,UACkC;CAClC,MAAM,EAAE,UAAU,QAAQ,mBAAmB;CAC7C,MAAM,EACJ,MAAM,aACN,KACA,GAAG,eACD;CAEJ,MAAM,OAAO,QAAQ,KAAK,YADV,sBAAsB,SAAS,OAAO,WACI,CAAC;CAC3D,MAAM,SAAS,gBAAgB,MAAM,EAAE,kBAAkB,MAAM,CAAC;CAEhE,OAAO;EACL,MAAM,QAAQ,SAAa,OAAO,QAA8B,IAAI,OAAO,KAAK;EAChF,WAAW,OAAO;EAClB,WAAW,OAAO;CACpB;AACF"}

package/dist/hooks/wrapping.d.ts

@@ -1,14 +1,14 @@
-import { UseEnsQueryParameters } from "../query/options.js";
-import { EnsSuspenseQueryResult, UseEnsSuspenseQueryParameters } from "./use-suspense-query.js";
-import { EnsQueryResult } from "../query/result.js";
+import { UseEnsAtomParameters } from "../query/options.js";
+import { EnsSuspenseAtomResult, UseEnsSuspenseAtomParameters } from "./use-suspense-query.js";
+import { EnsAtomResult } from "../query/result.js";
 import { EnsMutationOptions } from "../mutation/options.js";
 import { EnsMutationResult } from "../mutation/result.js";
 import "../index.js";
 //#region src/hooks/wrapping.d.ts
-declare const useFuses: <Selected = import("@ensforge/core").GetFusesResult>(input: UseEnsQueryParameters<import("@ensforge/core").WrapperReadParameters, import("@ensforge/core").GetFusesResult, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetCanonicalResourceError>;
-declare const useFusesSuspense: <Selected = import("@ensforge/core").GetFusesResult>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").WrapperReadParameters, import("@ensforge/core").GetFusesResult, Selected>) => EnsSuspenseQueryResult<Selected>;
-declare const useWrapperExpiry: <Selected = import("@ensforge/core").GetWrapperExpiryResult>(input: UseEnsQueryParameters<import("@ensforge/core").WrapperReadParameters, import("@ensforge/core").GetWrapperExpiryResult, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetCanonicalResourceError>;
-declare const useWrapperExpirySuspense: <Selected = import("@ensforge/core").GetWrapperExpiryResult>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").WrapperReadParameters, import("@ensforge/core").GetWrapperExpiryResult, Selected>) => EnsSuspenseQueryResult<Selected>;
+declare const useFuses: <Mapped = import("@ensforge/core").GetFusesResult>(input: UseEnsAtomParameters<import("@ensforge/core").WrapperReadParameters, import("@ensforge/core").GetFusesResult, import("@ensforge/core").GetCanonicalResourceError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").GetCanonicalResourceError>;
+declare const useFusesSuspense: <Mapped = import("@ensforge/core").GetFusesResult>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").WrapperReadParameters, import("@ensforge/core").GetFusesResult, import("@ensforge/core").GetCanonicalResourceError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
+declare const useWrapperExpiry: <Mapped = import("@ensforge/core").GetWrapperExpiryResult>(input: UseEnsAtomParameters<import("@ensforge/core").WrapperReadParameters, import("@ensforge/core").GetWrapperExpiryResult, import("@ensforge/core").GetCanonicalResourceError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").GetCanonicalResourceError>;
+declare const useWrapperExpirySuspense: <Mapped = import("@ensforge/core").GetWrapperExpiryResult>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").WrapperReadParameters, import("@ensforge/core").GetWrapperExpiryResult, import("@ensforge/core").GetCanonicalResourceError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
 declare const useExtendSubnameExpiry: (options?: EnsMutationOptions<import("@ensforge/core").ExtendSubnameExpiryParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").ExtendSubnameExpiryParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 declare const useSetChildFuses: (options?: EnsMutationOptions<import("@ensforge/core").SetChildFusesParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").SetChildFusesParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 declare const useSetFuses: (options?: EnsMutationOptions<import("@ensforge/core").SetFusesParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").SetFusesParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;

package/dist/hooks/wrapping.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrapping.d.ts","names":[],"sources":["../../src/hooks/wrapping.ts"],"mappings":";;;;;;;cAea,WAAQ,oCAAA,gBAAA,OAAA,+CAAA,gDAAA,gBAAA,cAAA,eAAA,mCAAA;cACR,mBAAgB,oCAAA,gBAAA,OAAA,uDAAA,gDAAA,gBAAA,cAAA,uBAAA;cAChB,mBAAgB,oCAAA,wBAAA,OAAA,+CAAA,gDAAA,wBAAA,cAAA,eAAA,mCAAA;cAChB,2BAAwB,oCAAA,wBAAA,OAAA,uDAAA,gDAAA,wBAAA,cAAA,uBAAA;cAExB,yBAAsB,UAAtB,4CAAsB,wDAAA,8CAAA,gBAAA,2CAAA,wDAAA,8CAAA;cACtB,mBAAgB,UAAhB,4CAAgB,kDAAA,8CAAA,gBAAA,2CAAA,kDAAA,8CAAA;cAChB,cAAW,UAAX,4CAAW,6CAAA,8CAAA,gBAAA,2CAAA,6CAAA,8CAAA;cACX,gBAAa,UAAb,4CAAa,+CAAA,8CAAA,gBAAA,2CAAA,+CAAA,8CAAA;cACb,cAAW,UAAX,4CAAW,6CAAA,yCAAA,gBAAA,2CAAA,6CAAA,yCAAA"}
+{"version":3,"file":"wrapping.d.ts","names":[],"sources":["../../src/hooks/wrapping.ts"],"mappings":";;;;;;;cAea,WAAQ,kCAAA,gBAAA,OAAA,8CAAA,gDAAA,yCAAA,2BAAA,YAAA,cAAA,iCAAA;cACR,mBAAgB,kCAAA,gBAAA,OAAA,sDAAA,gDAAA,yCAAA,2BAAA,YAAA,sBAAA;cAChB,mBAAgB,kCAAA,wBAAA,OAAA,8CAAA,gDAAA,iDAAA,2BAAA,YAAA,cAAA,iCAAA;cAChB,2BAAwB,kCAAA,wBAAA,OAAA,sDAAA,gDAAA,iDAAA,2BAAA,YAAA,sBAAA;cAExB,yBAAsB,UAAtB,4CAAsB,wDAAA,8CAAA,gBAAA,2CAAA,wDAAA,8CAAA;cACtB,mBAAgB,UAAhB,4CAAgB,kDAAA,8CAAA,gBAAA,2CAAA,kDAAA,8CAAA;cAChB,cAAW,UAAX,4CAAW,6CAAA,8CAAA,gBAAA,2CAAA,6CAAA,8CAAA;cACX,gBAAa,UAAb,4CAAa,+CAAA,8CAAA,gBAAA,2CAAA,+CAAA,8CAAA;cACb,cAAW,UAAX,4CAAW,6CAAA,yCAAA,gBAAA,2CAAA,6CAAA,yCAAA"}

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-import { EnsforgeInvalidation, invalidateEnsforge, invalidateEnsforgeEffect, makeInvalidationKeys } from "./cache/invalidation.js";
-import { prefetchEnsforge, prefetchEnsforgeEffect } from "./cache/prefetch.js";
-import { CreateEnsforgeRegistryOptions, createEnsforgeRegistry } from "./cache/registry.js";
+import { EnsAtomDefaults, EnsAtomOptions, EnsAtomSwrOptions, ResolvedEnsAtomOptions, ResolvedEnsAtomSwrOptions, UseEnsAtomParameters, defaultEnsAtomOptions } from "./query/options.js";
+import { Invalidation, invalidate, invalidateEffect, makeInvalidationKeys } from "./cache/invalidation.js";
+import { prefetch, prefetchEffect } from "./cache/prefetch.js";
+import { CreateRegistryOptions, createRegistry } from "./cache/registry.js";
 import "./cache.js";
-import { EnsQueryDefaults, EnsQueryOptions, ResolvedEnsQueryOptions, UseEnsQueryParameters, defaultEnsQueryOptions } from "./query/options.js";
-import { EnsSuspenseQueryResult, UseEnsSuspenseQueryParameters, makeSuspenseQueryHook } from "./hooks/use-suspense-query.js";
+import { EnsSuspenseAtomResult, UseEnsSuspenseAtomParameters, makeSuspenseQueryHook } from "./hooks/use-suspense-query.js";
 import { useCallsStatus, useCallsStatusSuspense, useEstimateCalls, useEstimateCallsSuspense, useExecuteWritePlan, usePrepareCalls, usePrepareCallsSuspense, useResumeCalls, useSendCalls, useSimulateCalls, useSimulateCallsSuspense, useWalletCapabilities, useWalletCapabilitiesSuspense } from "./hooks/batch.js";
 import { useHasRegistryRoles, useHasRegistryRolesSuspense, useHasResolverRoles, useHasResolverRolesSuspense, useNameCapabilities, useNameCapabilitiesSuspense, useOperatorApproval, useOperatorApprovalSuspense, useRecordPermissions, useRecordPermissionsSuspense, useRegistryCapabilities, useRegistryCapabilitiesSuspense, useRegistryRoles, useRegistryRolesSuspense, useRequiredAuthorization, useRequiredAuthorizationSuspense, useResolverCapabilities, useResolverCapabilitiesSuspense, useResolverDelegateApproval, useResolverDelegateApprovalSuspense, useResolverRoles, useResolverRolesSuspense, useTokenApproval, useTokenApprovalSuspense, useWrapperPermissions, useWrapperPermissionsSuspense, useWriteTarget, useWriteTargetSuspense } from "./hooks/capabilities.js";
 import { useClaimDnsName, useDnsClaimStatus, useDnsClaimStatusSuspense, useDnsImportPlan, useDnsImportPlanSuspense, useDnsRecord, useDnsRecordSuspense, useDnsRecords, useDnsRecordsSuspense, useHasDnsRecords, useHasDnsRecordsSuspense, useImportDnsName, useSetDnsRecords, useSetZoneHash, useZoneHash, useZoneHashSuspense } from "./hooks/dns.js";
@@ -18,13 +18,13 @@ import { useAlias, useAliasSuspense, useCreateResolver, useGetOrCreateResolver,
 import { useClearPrimaryName, usePrimaryName, usePrimaryNameSuspense, useSetContractPrimaryName, useSetPrimaryName, useSetPrimaryNameForAddress } from "./hooks/reverse.js";
 import { useCreateSubname, useDeleteSubname, useSetSubnameExpiry, useSetSubnameManager, useSetSubnameRecord, useSetSubnameResolver, useTransferSubname } from "./hooks/subnames.js";
 import { useExtendSubnameExpiry, useFuses, useFusesSuspense, useSetChildFuses, useSetFuses, useUnwrapName, useWrapName, useWrapperExpiry, useWrapperExpirySuspense } from "./hooks/wrapping.js";
-import { EnsFetchStatus, EnsQueryResult, EnsQueryStatus } from "./query/result.js";
+import { EnsAtomResult } from "./query/result.js";
 import { useReadBatch, useReadBatchSettled, useRecords } from "./hooks/generic.js";
-import { InvalidateEnsforge, useInvalidateEnsforge } from "./hooks/use-cache.js";
-import { EnsMutationCallbacks, EnsMutationOptions } from "./mutation/options.js";
-import { EnsMutationResult, EnsMutationStatus } from "./mutation/result.js";
+import { Invalidate, useInvalidate } from "./hooks/use-cache.js";
+import { EnsMutationDefaults, EnsMutationExecutionOptions, EnsMutationOptions } from "./mutation/options.js";
+import { EnsMutationResult } from "./mutation/result.js";
 import { makeMutationHook } from "./hooks/use-mutation.js";
-import { makeQueryHook, prefetchQueryAtom } from "./hooks/use-query.js";
+import { makeQueryHook, prefetchAtom } from "./hooks/use-query.js";
 import "./hooks/index.js";
 import { EnsforgeReactDefaults } from "./provider/context.js";
 import { EnsforgeProvider, EnsforgeProviderProps } from "./provider/ensforge-provider.js";
@@ -32,4 +32,4 @@ import { useEnsforge, useEnsforgeRegistry } from "./provider/hooks.js";
 import "./provider/index.js";
 import { Ensforge } from "@ensforge/sdk";
 export type * from "@ensforge/sdk";
-export { type CreateEnsforgeRegistryOptions, type EnsFetchStatus, type EnsMutationCallbacks, type EnsMutationOptions, type EnsMutationResult, type EnsMutationStatus, type EnsQueryDefaults, type EnsQueryOptions, type EnsQueryResult, type EnsQueryStatus, type EnsSuspenseQueryResult, Ensforge, type EnsforgeInvalidation, EnsforgeProvider, type EnsforgeProviderProps, type EnsforgeReactDefaults, type InvalidateEnsforge, type ResolvedEnsQueryOptions, type UseEnsQueryParameters, type UseEnsSuspenseQueryParameters, createEnsforgeRegistry, defaultEnsQueryOptions, invalidateEnsforge, invalidateEnsforgeEffect, makeInvalidationKeys, makeMutationHook, makeQueryHook, makeSuspenseQueryHook, prefetchEnsforge, prefetchEnsforgeEffect, prefetchQueryAtom, useAbi, useAbiSuspense, useAddress, useAddressSuspense, useAddresses, useAddressesSuspense, useAlias, useAliasSuspense, useApproveMigration, useApproveName, useApprovePaymentToken, useApproveRenewalPayment, useAvatar, useAvatarSuspense, useCallsStatus, useCallsStatusSuspense, useCanonicalResource, useCanonicalResourceSuspense, useClaimDnsName, useClearAvatar, useClearNameApproval, useClearPrimaryName, useClearRecords, useCommitName, useCommitmentStatus, useCommitmentStatusSuspense, useCompleteRegistration, useContentHash, useContentHashSuspense, useCreateResolver, useCreateSubname, useData, useDataSuspense, useDeleteSubname, useDnsClaimStatus, useDnsClaimStatusSuspense, useDnsImportPlan, useDnsImportPlanSuspense, useDnsRecord, useDnsRecordSuspense, useDnsRecords, useDnsRecordsSuspense, useEnsEvents, useEnsEventsSuspense, useEnsforge, useEnsforgeRegistry, useEstimateCalls, useEstimateCallsSuspense, useExecuteWritePlan, useExpiry, useExpirySuspense, useExtendSubnameExpiry, useFuses, useFusesSuspense, useGetOrCreateResolver, useGrantRegistryRoles, useGrantResolverRoles, useGrantResolverRootRoles, useHasDnsRecords, useHasDnsRecordsSuspense, useHasRegistryRoles, useHasRegistryRolesSuspense, useHasResolverRoles, useHasResolverRolesSuspense, useImportDnsName, useInterface, useInterfaceSuspense, useInvalidateEnsforge, useIsAvailable, useIsAvailableSuspense, useIsMigrated, useIsMigratedSuspense, useIsPaymentTokenSupported, useIsPaymentTokenSupportedSuspense, useIsRenewable, useIsRenewableSuspense, useIsReserved, useIsReservedSuspense, useIsWrapped, useIsWrappedSuspense, useManager, useManagerSuspense, useMigrateName, useMigrateNames, useMigrationEligibility, useMigrationEligibilitySuspense, useMigrationPlan, useMigrationPlanSuspense, useMigrationStatus, useMigrationStatusSuspense, useMigrationTarget, useMigrationTargetSuspense, useNameCapabilities, useNameCapabilitiesSuspense, useNameHistory, useNameHistorySuspense, useNameRecord, useNameRecordSuspense, useNameState, useNameStateSuspense, useNameStatus, useNameStatusSuspense, useOperatorApproval, useOperatorApprovalSuspense, useOwner, useOwnerSuspense, usePredictResolverAddress, usePredictResolverAddressSuspense, usePrepareCalls, usePrepareCallsSuspense, usePrimaryName, usePrimaryNameSuspense, useProtocol, useProtocolSuspense, usePubkey, usePubkeySuspense, useReadBatch, useReadBatchSettled, useReclaimName, useRecordPermissions, useRecordPermissionsSuspense, useRecords, useRegisterName, useRegisterNames, useRegistrant, useRegistrantSuspense, useRegistrationCommitment, useRegistrationCommitmentSuspense, useRegistrationParameters, useRegistrationParametersSuspense, useRegistrationPlan, useRegistrationPlanSuspense, useRegistrationPrice, useRegistrationPriceSuspense, useRegistry, useRegistryCapabilities, useRegistryCapabilitiesSuspense, useRegistryRoles, useRegistryRolesSuspense, useRegistrySuspense, useRenewName, useRenewNames, useRenewalPrice, useRenewalPriceSuspense, useRequiredAuthorization, useRequiredAuthorizationSuspense, useResolve, useResolveBatch, useResolveBatchSuspense, useResolveSuspense, useResolveWithResolver, useResolveWithResolverSuspense, useResolver, useResolverCapabilities, useResolverCapabilitiesSuspense, useResolverDelegateApproval, useResolverDelegateApprovalSuspense, useResolverRoles, useResolverRolesSuspense, useResolverSuspense, useResolverVersion, useResolverVersionSuspense, useResumeCalls, useRevokeRegistryRoles, useRevokeResolverRoles, useRevokeResolverRootRoles, useSendCalls, useSetAbi, useSetAddress, useSetAddresses, useSetAlias, useSetAvatar, useSetChildFuses, useSetContentHash, useSetContractPrimaryName, useSetData, useSetDnsRecords, useSetFuses, useSetInterface, useSetManager, useSetName, useSetOperatorApproval, useSetPrimaryName, useSetPrimaryNameForAddress, useSetPubkey, useSetRecordPermissions, useSetRecords, useSetResolver, useSetResolverAndRecords, useSetResolverDelegateApproval, useSetSubnameExpiry, useSetSubnameManager, useSetSubnameRecord, useSetSubnameResolver, useSetText, useSetTexts, useSetTtl, useSetZoneHash, useSimulateCalls, useSimulateCallsSuspense, useText, useTextSuspense, useTexts, useTextsSuspense, useTokenApproval, useTokenApprovalSuspense, useTokenId, useTokenIdSuspense, useTransferName, useTransferRegistrant, useTransferSubname, useTtl, useTtlSuspense, useUnwrapName, useUpgradeResolver, useWalletCapabilities, useWalletCapabilitiesSuspense, useWatchEnsEvents, useWrapName, useWrapperExpiry, useWrapperExpirySuspense, useWrapperPermissions, useWrapperPermissionsSuspense, useWriteTarget, useWriteTargetSuspense, useZoneHash, useZoneHashSuspense };
+export { type CreateRegistryOptions, type EnsAtomDefaults, type EnsAtomOptions, type EnsAtomResult, type EnsAtomSwrOptions, type EnsMutationDefaults, type EnsMutationExecutionOptions, type EnsMutationOptions, type EnsMutationResult, type EnsSuspenseAtomResult, Ensforge, EnsforgeProvider, type EnsforgeProviderProps, type EnsforgeReactDefaults, type Invalidate, type Invalidation, type ResolvedEnsAtomOptions, type ResolvedEnsAtomSwrOptions, type UseEnsAtomParameters, type UseEnsSuspenseAtomParameters, createRegistry, defaultEnsAtomOptions, invalidate, invalidateEffect, makeInvalidationKeys, makeMutationHook, makeQueryHook, makeSuspenseQueryHook, prefetch, prefetchAtom, prefetchEffect, useAbi, useAbiSuspense, useAddress, useAddressSuspense, useAddresses, useAddressesSuspense, useAlias, useAliasSuspense, useApproveMigration, useApproveName, useApprovePaymentToken, useApproveRenewalPayment, useAvatar, useAvatarSuspense, useCallsStatus, useCallsStatusSuspense, useCanonicalResource, useCanonicalResourceSuspense, useClaimDnsName, useClearAvatar, useClearNameApproval, useClearPrimaryName, useClearRecords, useCommitName, useCommitmentStatus, useCommitmentStatusSuspense, useCompleteRegistration, useContentHash, useContentHashSuspense, useCreateResolver, useCreateSubname, useData, useDataSuspense, useDeleteSubname, useDnsClaimStatus, useDnsClaimStatusSuspense, useDnsImportPlan, useDnsImportPlanSuspense, useDnsRecord, useDnsRecordSuspense, useDnsRecords, useDnsRecordsSuspense, useEnsEvents, useEnsEventsSuspense, useEnsforge, useEnsforgeRegistry, useEstimateCalls, useEstimateCallsSuspense, useExecuteWritePlan, useExpiry, useExpirySuspense, useExtendSubnameExpiry, useFuses, useFusesSuspense, useGetOrCreateResolver, useGrantRegistryRoles, useGrantResolverRoles, useGrantResolverRootRoles, useHasDnsRecords, useHasDnsRecordsSuspense, useHasRegistryRoles, useHasRegistryRolesSuspense, useHasResolverRoles, useHasResolverRolesSuspense, useImportDnsName, useInterface, useInterfaceSuspense, useInvalidate, useIsAvailable, useIsAvailableSuspense, useIsMigrated, useIsMigratedSuspense, useIsPaymentTokenSupported, useIsPaymentTokenSupportedSuspense, useIsRenewable, useIsRenewableSuspense, useIsReserved, useIsReservedSuspense, useIsWrapped, useIsWrappedSuspense, useManager, useManagerSuspense, useMigrateName, useMigrateNames, useMigrationEligibility, useMigrationEligibilitySuspense, useMigrationPlan, useMigrationPlanSuspense, useMigrationStatus, useMigrationStatusSuspense, useMigrationTarget, useMigrationTargetSuspense, useNameCapabilities, useNameCapabilitiesSuspense, useNameHistory, useNameHistorySuspense, useNameRecord, useNameRecordSuspense, useNameState, useNameStateSuspense, useNameStatus, useNameStatusSuspense, useOperatorApproval, useOperatorApprovalSuspense, useOwner, useOwnerSuspense, usePredictResolverAddress, usePredictResolverAddressSuspense, usePrepareCalls, usePrepareCallsSuspense, usePrimaryName, usePrimaryNameSuspense, useProtocol, useProtocolSuspense, usePubkey, usePubkeySuspense, useReadBatch, useReadBatchSettled, useReclaimName, useRecordPermissions, useRecordPermissionsSuspense, useRecords, useRegisterName, useRegisterNames, useRegistrant, useRegistrantSuspense, useRegistrationCommitment, useRegistrationCommitmentSuspense, useRegistrationParameters, useRegistrationParametersSuspense, useRegistrationPlan, useRegistrationPlanSuspense, useRegistrationPrice, useRegistrationPriceSuspense, useRegistry, useRegistryCapabilities, useRegistryCapabilitiesSuspense, useRegistryRoles, useRegistryRolesSuspense, useRegistrySuspense, useRenewName, useRenewNames, useRenewalPrice, useRenewalPriceSuspense, useRequiredAuthorization, useRequiredAuthorizationSuspense, useResolve, useResolveBatch, useResolveBatchSuspense, useResolveSuspense, useResolveWithResolver, useResolveWithResolverSuspense, useResolver, useResolverCapabilities, useResolverCapabilitiesSuspense, useResolverDelegateApproval, useResolverDelegateApprovalSuspense, useResolverRoles, useResolverRolesSuspense, useResolverSuspense, useResolverVersion, useResolverVersionSuspense, useResumeCalls, useRevokeRegistryRoles, useRevokeResolverRoles, useRevokeResolverRootRoles, useSendCalls, useSetAbi, useSetAddress, useSetAddresses, useSetAlias, useSetAvatar, useSetChildFuses, useSetContentHash, useSetContractPrimaryName, useSetData, useSetDnsRecords, useSetFuses, useSetInterface, useSetManager, useSetName, useSetOperatorApproval, useSetPrimaryName, useSetPrimaryNameForAddress, useSetPubkey, useSetRecordPermissions, useSetRecords, useSetResolver, useSetResolverAndRecords, useSetResolverDelegateApproval, useSetSubnameExpiry, useSetSubnameManager, useSetSubnameRecord, useSetSubnameResolver, useSetText, useSetTexts, useSetTtl, useSetZoneHash, useSimulateCalls, useSimulateCallsSuspense, useText, useTextSuspense, useTexts, useTextsSuspense, useTokenApproval, useTokenApprovalSuspense, useTokenId, useTokenIdSuspense, useTransferName, useTransferRegistrant, useTransferSubname, useTtl, useTtlSuspense, useUnwrapName, useUpgradeResolver, useWalletCapabilities, useWalletCapabilitiesSuspense, useWatchEnsEvents, useWrapName, useWrapperExpiry, useWrapperExpirySuspense, useWrapperPermissions, useWrapperPermissionsSuspense, useWriteTarget, useWriteTargetSuspense, useZoneHash, useZoneHashSuspense };

package/dist/index.js

@@ -1,11 +1,11 @@
 "use client";
 
-import { invalidateEnsforge, invalidateEnsforgeEffect, makeInvalidationKeys } from "./cache/invalidation.js";
-import { prefetchEnsforge, prefetchEnsforgeEffect } from "./cache/prefetch.js";
-import { createEnsforgeRegistry } from "./cache/registry.js";
+import { invalidate, invalidateEffect, makeInvalidationKeys } from "./cache/invalidation.js";
+import { prefetch, prefetchEffect } from "./cache/prefetch.js";
+import { createRegistry } from "./cache/registry.js";
+import { defaultEnsAtomOptions } from "./query/options.js";
 import { makeMutationHook } from "./hooks/use-mutation.js";
-import { defaultEnsQueryOptions } from "./query/options.js";
-import { makeQueryHook, prefetchQueryAtom } from "./hooks/use-query.js";
+import { makeQueryHook, prefetchAtom } from "./hooks/use-query.js";
 import { makeSuspenseQueryHook } from "./hooks/use-suspense-query.js";
 import { useCallsStatus, useCallsStatusSuspense, useEstimateCalls, useEstimateCallsSuspense, useExecuteWritePlan, usePrepareCalls, usePrepareCallsSuspense, useResumeCalls, useSendCalls, useSimulateCalls, useSimulateCallsSuspense, useWalletCapabilities, useWalletCapabilitiesSuspense } from "./hooks/batch.js";
 import { useHasRegistryRoles, useHasRegistryRolesSuspense, useHasResolverRoles, useHasResolverRolesSuspense, useNameCapabilities, useNameCapabilitiesSuspense, useOperatorApproval, useOperatorApprovalSuspense, useRecordPermissions, useRecordPermissionsSuspense, useRegistryCapabilities, useRegistryCapabilitiesSuspense, useRegistryRoles, useRegistryRolesSuspense, useRequiredAuthorization, useRequiredAuthorizationSuspense, useResolverCapabilities, useResolverCapabilitiesSuspense, useResolverDelegateApproval, useResolverDelegateApprovalSuspense, useResolverRoles, useResolverRolesSuspense, useTokenApproval, useTokenApprovalSuspense, useWrapperPermissions, useWrapperPermissionsSuspense, useWriteTarget, useWriteTargetSuspense } from "./hooks/capabilities.js";
@@ -22,9 +22,9 @@ import { useClearPrimaryName, usePrimaryName, usePrimaryNameSuspense, useSetCont
 import { useCreateSubname, useDeleteSubname, useSetSubnameExpiry, useSetSubnameManager, useSetSubnameRecord, useSetSubnameResolver, useTransferSubname } from "./hooks/subnames.js";
 import { useExtendSubnameExpiry, useFuses, useFusesSuspense, useSetChildFuses, useSetFuses, useUnwrapName, useWrapName, useWrapperExpiry, useWrapperExpirySuspense } from "./hooks/wrapping.js";
 import { useReadBatch, useReadBatchSettled, useRecords } from "./hooks/generic.js";
-import { useInvalidateEnsforge } from "./hooks/use-cache.js";
+import { useInvalidate } from "./hooks/use-cache.js";
 import { EnsforgeProvider } from "./provider/ensforge-provider.js";
 import { useEnsforge, useEnsforgeRegistry } from "./provider/hooks.js";
 import { Ensforge } from "@ensforge/sdk";
 
-export { Ensforge, EnsforgeProvider, createEnsforgeRegistry, defaultEnsQueryOptions, invalidateEnsforge, invalidateEnsforgeEffect, makeInvalidationKeys, makeMutationHook, makeQueryHook, makeSuspenseQueryHook, prefetchEnsforge, prefetchEnsforgeEffect, prefetchQueryAtom, useAbi, useAbiSuspense, useAddress, useAddressSuspense, useAddresses, useAddressesSuspense, useAlias, useAliasSuspense, useApproveMigration, useApproveName, useApprovePaymentToken, useApproveRenewalPayment, useAvatar, useAvatarSuspense, useCallsStatus, useCallsStatusSuspense, useCanonicalResource, useCanonicalResourceSuspense, useClaimDnsName, useClearAvatar, useClearNameApproval, useClearPrimaryName, useClearRecords, useCommitName, useCommitmentStatus, useCommitmentStatusSuspense, useCompleteRegistration, useContentHash, useContentHashSuspense, useCreateResolver, useCreateSubname, useData, useDataSuspense, useDeleteSubname, useDnsClaimStatus, useDnsClaimStatusSuspense, useDnsImportPlan, useDnsImportPlanSuspense, useDnsRecord, useDnsRecordSuspense, useDnsRecords, useDnsRecordsSuspense, useEnsEvents, useEnsEventsSuspense, useEnsforge, useEnsforgeRegistry, useEstimateCalls, useEstimateCallsSuspense, useExecuteWritePlan, useExpiry, useExpirySuspense, useExtendSubnameExpiry, useFuses, useFusesSuspense, useGetOrCreateResolver, useGrantRegistryRoles, useGrantResolverRoles, useGrantResolverRootRoles, useHasDnsRecords, useHasDnsRecordsSuspense, useHasRegistryRoles, useHasRegistryRolesSuspense, useHasResolverRoles, useHasResolverRolesSuspense, useImportDnsName, useInterface, useInterfaceSuspense, useInvalidateEnsforge, useIsAvailable, useIsAvailableSuspense, useIsMigrated, useIsMigratedSuspense, useIsPaymentTokenSupported, useIsPaymentTokenSupportedSuspense, useIsRenewable, useIsRenewableSuspense, useIsReserved, useIsReservedSuspense, useIsWrapped, useIsWrappedSuspense, useManager, useManagerSuspense, useMigrateName, useMigrateNames, useMigrationEligibility, useMigrationEligibilitySuspense, useMigrationPlan, useMigrationPlanSuspense, useMigrationStatus, useMigrationStatusSuspense, useMigrationTarget, useMigrationTargetSuspense, useNameCapabilities, useNameCapabilitiesSuspense, useNameHistory, useNameHistorySuspense, useNameRecord, useNameRecordSuspense, useNameState, useNameStateSuspense, useNameStatus, useNameStatusSuspense, useOperatorApproval, useOperatorApprovalSuspense, useOwner, useOwnerSuspense, usePredictResolverAddress, usePredictResolverAddressSuspense, usePrepareCalls, usePrepareCallsSuspense, usePrimaryName, usePrimaryNameSuspense, useProtocol, useProtocolSuspense, usePubkey, usePubkeySuspense, useReadBatch, useReadBatchSettled, useReclaimName, useRecordPermissions, useRecordPermissionsSuspense, useRecords, useRegisterName, useRegisterNames, useRegistrant, useRegistrantSuspense, useRegistrationCommitment, useRegistrationCommitmentSuspense, useRegistrationParameters, useRegistrationParametersSuspense, useRegistrationPlan, useRegistrationPlanSuspense, useRegistrationPrice, useRegistrationPriceSuspense, useRegistry, useRegistryCapabilities, useRegistryCapabilitiesSuspense, useRegistryRoles, useRegistryRolesSuspense, useRegistrySuspense, useRenewName, useRenewNames, useRenewalPrice, useRenewalPriceSuspense, useRequiredAuthorization, useRequiredAuthorizationSuspense, useResolve, useResolveBatch, useResolveBatchSuspense, useResolveSuspense, useResolveWithResolver, useResolveWithResolverSuspense, useResolver, useResolverCapabilities, useResolverCapabilitiesSuspense, useResolverDelegateApproval, useResolverDelegateApprovalSuspense, useResolverRoles, useResolverRolesSuspense, useResolverSuspense, useResolverVersion, useResolverVersionSuspense, useResumeCalls, useRevokeRegistryRoles, useRevokeResolverRoles, useRevokeResolverRootRoles, useSendCalls, useSetAbi, useSetAddress, useSetAddresses, useSetAlias, useSetAvatar, useSetChildFuses, useSetContentHash, useSetContractPrimaryName, useSetData, useSetDnsRecords, useSetFuses, useSetInterface, useSetManager, useSetName, useSetOperatorApproval, useSetPrimaryName, useSetPrimaryNameForAddress, useSetPubkey, useSetRecordPermissions, useSetRecords, useSetResolver, useSetResolverAndRecords, useSetResolverDelegateApproval, useSetSubnameExpiry, useSetSubnameManager, useSetSubnameRecord, useSetSubnameResolver, useSetText, useSetTexts, useSetTtl, useSetZoneHash, useSimulateCalls, useSimulateCallsSuspense, useText, useTextSuspense, useTexts, useTextsSuspense, useTokenApproval, useTokenApprovalSuspense, useTokenId, useTokenIdSuspense, useTransferName, useTransferRegistrant, useTransferSubname, useTtl, useTtlSuspense, useUnwrapName, useUpgradeResolver, useWalletCapabilities, useWalletCapabilitiesSuspense, useWatchEnsEvents, useWrapName, useWrapperExpiry, useWrapperExpirySuspense, useWrapperPermissions, useWrapperPermissionsSuspense, useWriteTarget, useWriteTargetSuspense, useZoneHash, useZoneHashSuspense };
+export { Ensforge, EnsforgeProvider, createRegistry, defaultEnsAtomOptions, invalidate, invalidateEffect, makeInvalidationKeys, makeMutationHook, makeQueryHook, makeSuspenseQueryHook, prefetch, prefetchAtom, prefetchEffect, useAbi, useAbiSuspense, useAddress, useAddressSuspense, useAddresses, useAddressesSuspense, useAlias, useAliasSuspense, useApproveMigration, useApproveName, useApprovePaymentToken, useApproveRenewalPayment, useAvatar, useAvatarSuspense, useCallsStatus, useCallsStatusSuspense, useCanonicalResource, useCanonicalResourceSuspense, useClaimDnsName, useClearAvatar, useClearNameApproval, useClearPrimaryName, useClearRecords, useCommitName, useCommitmentStatus, useCommitmentStatusSuspense, useCompleteRegistration, useContentHash, useContentHashSuspense, useCreateResolver, useCreateSubname, useData, useDataSuspense, useDeleteSubname, useDnsClaimStatus, useDnsClaimStatusSuspense, useDnsImportPlan, useDnsImportPlanSuspense, useDnsRecord, useDnsRecordSuspense, useDnsRecords, useDnsRecordsSuspense, useEnsEvents, useEnsEventsSuspense, useEnsforge, useEnsforgeRegistry, useEstimateCalls, useEstimateCallsSuspense, useExecuteWritePlan, useExpiry, useExpirySuspense, useExtendSubnameExpiry, useFuses, useFusesSuspense, useGetOrCreateResolver, useGrantRegistryRoles, useGrantResolverRoles, useGrantResolverRootRoles, useHasDnsRecords, useHasDnsRecordsSuspense, useHasRegistryRoles, useHasRegistryRolesSuspense, useHasResolverRoles, useHasResolverRolesSuspense, useImportDnsName, useInterface, useInterfaceSuspense, useInvalidate, useIsAvailable, useIsAvailableSuspense, useIsMigrated, useIsMigratedSuspense, useIsPaymentTokenSupported, useIsPaymentTokenSupportedSuspense, useIsRenewable, useIsRenewableSuspense, useIsReserved, useIsReservedSuspense, useIsWrapped, useIsWrappedSuspense, useManager, useManagerSuspense, useMigrateName, useMigrateNames, useMigrationEligibility, useMigrationEligibilitySuspense, useMigrationPlan, useMigrationPlanSuspense, useMigrationStatus, useMigrationStatusSuspense, useMigrationTarget, useMigrationTargetSuspense, useNameCapabilities, useNameCapabilitiesSuspense, useNameHistory, useNameHistorySuspense, useNameRecord, useNameRecordSuspense, useNameState, useNameStateSuspense, useNameStatus, useNameStatusSuspense, useOperatorApproval, useOperatorApprovalSuspense, useOwner, useOwnerSuspense, usePredictResolverAddress, usePredictResolverAddressSuspense, usePrepareCalls, usePrepareCallsSuspense, usePrimaryName, usePrimaryNameSuspense, useProtocol, useProtocolSuspense, usePubkey, usePubkeySuspense, useReadBatch, useReadBatchSettled, useReclaimName, useRecordPermissions, useRecordPermissionsSuspense, useRecords, useRegisterName, useRegisterNames, useRegistrant, useRegistrantSuspense, useRegistrationCommitment, useRegistrationCommitmentSuspense, useRegistrationParameters, useRegistrationParametersSuspense, useRegistrationPlan, useRegistrationPlanSuspense, useRegistrationPrice, useRegistrationPriceSuspense, useRegistry, useRegistryCapabilities, useRegistryCapabilitiesSuspense, useRegistryRoles, useRegistryRolesSuspense, useRegistrySuspense, useRenewName, useRenewNames, useRenewalPrice, useRenewalPriceSuspense, useRequiredAuthorization, useRequiredAuthorizationSuspense, useResolve, useResolveBatch, useResolveBatchSuspense, useResolveSuspense, useResolveWithResolver, useResolveWithResolverSuspense, useResolver, useResolverCapabilities, useResolverCapabilitiesSuspense, useResolverDelegateApproval, useResolverDelegateApprovalSuspense, useResolverRoles, useResolverRolesSuspense, useResolverSuspense, useResolverVersion, useResolverVersionSuspense, useResumeCalls, useRevokeRegistryRoles, useRevokeResolverRoles, useRevokeResolverRootRoles, useSendCalls, useSetAbi, useSetAddress, useSetAddresses, useSetAlias, useSetAvatar, useSetChildFuses, useSetContentHash, useSetContractPrimaryName, useSetData, useSetDnsRecords, useSetFuses, useSetInterface, useSetManager, useSetName, useSetOperatorApproval, useSetPrimaryName, useSetPrimaryNameForAddress, useSetPubkey, useSetRecordPermissions, useSetRecords, useSetResolver, useSetResolverAndRecords, useSetResolverDelegateApproval, useSetSubnameExpiry, useSetSubnameManager, useSetSubnameRecord, useSetSubnameResolver, useSetText, useSetTexts, useSetTtl, useSetZoneHash, useSimulateCalls, useSimulateCallsSuspense, useText, useTextSuspense, useTexts, useTextsSuspense, useTokenApproval, useTokenApprovalSuspense, useTokenId, useTokenIdSuspense, useTransferName, useTransferRegistrant, useTransferSubname, useTtl, useTtlSuspense, useUnwrapName, useUpgradeResolver, useWalletCapabilities, useWalletCapabilitiesSuspense, useWatchEnsEvents, useWrapName, useWrapperExpiry, useWrapperExpirySuspense, useWrapperPermissions, useWrapperPermissionsSuspense, useWriteTarget, useWriteTargetSuspense, useZoneHash, useZoneHashSuspense };

package/dist/mutation/options.d.ts

@@ -1,12 +1,14 @@
+import { Exit, Schedule } from "effect";
 //#region src/mutation/options.d.ts
-interface EnsMutationCallbacks<Parameters, Success, Failure> {
-  readonly onError?: (error: Failure | Error, parameters: Parameters) => void;
-  readonly onSettled?: (data: Success | undefined, error: Failure | Error | null, parameters: Parameters) => void;
-  readonly onSuccess?: (data: Success, parameters: Parameters) => void;
+interface EnsMutationExecutionOptions<Parameters, Success, Failure> {
+  readonly onExit?: (exit: Exit.Exit<Success, Failure>, parameters: Parameters) => void;
 }
-interface EnsMutationOptions<Parameters, Success, Failure> extends EnsMutationCallbacks<Parameters, Success, Failure> {
-  readonly retry?: false | number;
+interface EnsMutationOptions<Parameters, Success, Failure> extends EnsMutationExecutionOptions<Parameters, Success, Failure> {
+  readonly retry?: false | Schedule.Schedule<unknown, Failure>;
+}
+interface EnsMutationDefaults {
+  readonly retry?: false | Schedule.Schedule<unknown, unknown>;
 }
 //#endregion
-export { EnsMutationCallbacks, EnsMutationOptions };
+export { EnsMutationDefaults, EnsMutationExecutionOptions, EnsMutationOptions };
 //# sourceMappingURL=options.d.ts.map

package/dist/mutation/options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"options.d.ts","names":[],"sources":["../../src/mutation/options.ts"],"mappings":";UAAiB,qBAAqB,YAAY,SAAS;WAChD,WAAW,OAAO,UAAU,OAAO,YAAY;WAC/C,aACP,MAAM,qBACN,OAAO,UAAU,cACjB,YAAY;WAEL,aAAa,MAAM,SAAS,YAAY;;UAGlC,mBAAmB,YAAY,SAAS,iBAAiB,qBACxE,YACA,SACA;WAES"}
+{"version":3,"file":"options.d.ts","names":[],"sources":["../../src/mutation/options.ts"],"mappings":";;UAEiB,4BAA4B,YAAY,SAAS;WACvD,UAAU,MAAM,KAAK,KAAK,SAAS,UAAU,YAAY;;UAGnD,mBACf,YACA,SACA,iBACQ,4BAA4B,YAAY,SAAS;WAChD,gBAAgB,SAAS,kBAAkB;;UAGrC;WACN,gBAAgB,SAAS"}

package/dist/mutation/result.d.ts

@@ -1,25 +1,23 @@
-import { EnsMutationCallbacks } from "./options.js";
+import { EnsMutationExecutionOptions } from "./options.js";
 import { Cause, Effect } from "effect";
 import { AsyncResult } from "effect/unstable/reactivity";
 //#region src/mutation/result.d.ts
-type EnsMutationStatus = "idle" | "pending" | "success" | "error";
 interface EnsMutationResult<Parameters, Success, Failure> {
   readonly cause: Cause.Cause<Failure> | null;
   readonly data: Success | undefined;
   readonly error: Failure | Error | null;
-  readonly interrupt: () => void;
-  readonly isError: boolean;
-  readonly isIdle: boolean;
-  readonly isPending: boolean;
-  readonly isSuccess: boolean;
-  readonly mutate: (parameters: Parameters, callbacks?: EnsMutationCallbacks<Parameters, Success, Failure>) => void;
+  readonly mutate: (parameters: Parameters, options?: EnsMutationExecutionOptions<Parameters, Success, Failure>) => void;
   readonly mutateAsync: (parameters: Parameters) => Promise<Success>;
   readonly mutateEffect: (parameters: Parameters) => Effect.Effect<Success, Failure>;
+  readonly interrupt: () => void;
+  readonly isFailure: boolean;
+  readonly isInitial: boolean;
+  readonly isSuccess: boolean;
+  readonly isWaiting: boolean;
   readonly parameters: Parameters | undefined;
   readonly reset: () => void;
   readonly result: AsyncResult.AsyncResult<Success, Failure>;
-  readonly status: EnsMutationStatus;
 }
 //#endregion
-export { EnsMutationResult, EnsMutationStatus };
+export { EnsMutationResult };
 //# sourceMappingURL=result.d.ts.map

package/dist/mutation/result.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"result.d.ts","names":[],"sources":["../../src/mutation/result.ts"],"mappings":";;;;KAKY;UAEK,kBAAkB,YAAY,SAAS;WAC7C,OAAO,MAAM,MAAM;WACnB,MAAM;WACN,OAAO,UAAU;WACjB;WACA;WACA;WACA;WACA;WACA,SACP,YAAY,YACZ,YAAY,qBAAqB,YAAY,SAAS;WAE/C,cAAc,YAAY,eAAe,QAAQ;WACjD,eAAe,YAAY,eAAe,OAAO,OAAO,SAAS;WACjE,YAAY;WACZ;WACA,QAAQ,YAAY,YAAY,SAAS;WACzC,QAAQ"}
+{"version":3,"file":"result.d.ts","names":[],"sources":["../../src/mutation/result.ts"],"mappings":";;;;UAKiB,kBAAkB,YAAY,SAAS;WAC7C,OAAO,MAAM,MAAM;WACnB,MAAM;WACN,OAAO,UAAU;WACjB,SACP,YAAY,YACZ,UAAU,4BAA4B,YAAY,SAAS;WAEpD,cAAc,YAAY,eAAe,QAAQ;WACjD,eAAe,YAAY,eAAe,OAAO,OAAO,SAAS;WACjE;WACA;WACA;WACA;WACA;WACA,YAAY;WACZ;WACA,QAAQ,YAAY,YAAY,SAAS"}

package/dist/provider/context.d.ts

@@ -1,8 +1,10 @@
-import { EnsQueryDefaults } from "../query/options.js";
+import { EnsAtomDefaults } from "../query/options.js";
+import { EnsMutationDefaults } from "../mutation/options.js";
 import { Ensforge } from "@ensforge/sdk";
 //#region src/provider/context.d.ts
 interface EnsforgeReactDefaults {
-  readonly queries?: EnsQueryDefaults;
+  readonly atoms?: EnsAtomDefaults;
+  readonly mutations?: EnsMutationDefaults;
 }
 //#endregion
 export { EnsforgeReactDefaults };