@ensforge/react 0.0.0 → 0.1.1

package/README.md

@@ -4,17 +4,17 @@ Reactive React hooks for building ENS applications.
 
 ## Features
 
-- Queries and mutations for the full Ensforge action surface
-- Request caching, deduplication, retries, and stale-time controls
-- Refetching and Suspense variants for read hooks
-- Typed loading, success, and error states
-- Provider setup from an Ensforge config or existing SDK instance
+- Effect Atom reads and mutations for the full ensforge action surface
+- Shared execution, typed retry schedules, SWR, and idle lifecycle controls
+- Refresh and Suspense variants for read hooks
+- Native `AsyncResult` state with convenient React projections
+- Provider setup from an ensforge config or existing SDK instance
 - Shared cache primitives for prefetching and advanced composition
 
 ## Installation
 
 ```sh
-pnpm add @ensforge/react
+pnpm add @ensforge/react react effect@rc viem
 ```
 
 ## Overview
@@ -35,7 +35,7 @@ import { EnsforgeProvider } from "@ensforge/react";
 </EnsforgeProvider>;
 ```
 
-Use query hooks anywhere below the provider:
+Use read hooks anywhere below the provider:
 
 ```tsx
 import { useAvatar, useOwner } from "@ensforge/react";
@@ -44,11 +44,11 @@ function Profile({ name }: { name: string }) {
   const owner = useOwner({ name });
   const avatar = useAvatar({
     name,
-    query: { staleTime: 60_000 },
+    atom: { swr: { staleTime: "1 minute" } },
   });
 
-  if (owner.isLoading || avatar.isLoading) return <span>Loading…</span>;
-  if (owner.isError) return <span>{owner.error.message}</span>;
+  if (owner.isInitial || avatar.isInitial) return <span>Loading…</span>;
+  if (owner.isFailure) return <span>{owner.error.message}</span>;
 
   return (
     <section>

package/dist/atoms/batch.d.ts

@@ -1,11 +1,11 @@
-import { EnsQueryAtomFactory } from "./query.js";
+import { EnsAtomFactory } from "./query.js";
 import { EnsMutationAtomFactory } from "./mutation.js";
 //#region src/atoms/batch.d.ts
-declare const estimateCallsAtom: EnsQueryAtomFactory<import("@ensforge/core").EstimateCallsParameters, import("@ensforge/core").EstimateCallsResult, import("@ensforge/core").WriteError>;
-declare const getCallsStatusAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCallsStatusParameters, import("@ensforge/core").CallsStatusResult, import("@ensforge/core").WriteError>;
-declare const getWalletCapabilitiesAtom: EnsQueryAtomFactory<import("@ensforge/core").GetWalletCapabilitiesParameters, import("@ensforge/core").WalletCapabilitiesResult, import("@ensforge/core").ConfigError | import("@ensforge/core").WalletError>;
-declare const prepareCallsAtom: EnsQueryAtomFactory<import("@ensforge/core").PrepareCallsParameters, readonly import("@ensforge/core").PreparedWriteCall[], import("@ensforge/core").WriteError>;
-declare const simulateCallsAtom: EnsQueryAtomFactory<import("@ensforge/core").SimulateCallsParameters, readonly import("@ensforge/core").SimulatedWriteCall[], import("@ensforge/core").WriteError>;
+declare const estimateCallsAtom: EnsAtomFactory<import("@ensforge/core").EstimateCallsParameters, import("@ensforge/core").EstimateCallsResult, import("@ensforge/core").WriteError>;
+declare const getCallsStatusAtom: EnsAtomFactory<import("@ensforge/core").GetCallsStatusParameters, import("@ensforge/core").CallsStatusResult, import("@ensforge/core").WriteError>;
+declare const getWalletCapabilitiesAtom: EnsAtomFactory<import("@ensforge/core").GetWalletCapabilitiesParameters, import("@ensforge/core").WalletCapabilitiesResult, import("@ensforge/core").ConfigError | import("@ensforge/core").WalletError>;
+declare const prepareCallsAtom: EnsAtomFactory<import("@ensforge/core").PrepareCallsParameters, readonly import("@ensforge/core").PreparedWriteCall[], import("@ensforge/core").WriteError>;
+declare const simulateCallsAtom: EnsAtomFactory<import("@ensforge/core").SimulateCallsParameters, readonly import("@ensforge/core").SimulatedWriteCall[], import("@ensforge/core").WriteError>;
 declare const createExecuteWritePlanMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ExecuteWritePlanParameters, import("@ensforge/core").WritePlanProgress, import("@ensforge/core").WriteError>;
 declare const createResumeCallsMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ResumeCallsParameters, import("@ensforge/core").NativeBatchResult, import("@ensforge/core").WriteError>;
 declare const createSendCallsMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SendCallsParameters, import("@ensforge/core").SendCallsResult, import("@ensforge/core").WriteError>;

package/dist/atoms/batch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batch.d.ts","names":[],"sources":["../../src/atoms/batch.ts"],"mappings":";;;cAGa,mBAAA,6CAAiB,kDAAA,8CAAA;cACjB,oBAAA,6CAAkB,mDAAA,4CAAA;cAClB,2BAAA,6CAAyB,0DAAA,mDAAA,uCAAA;cAIzB,kBAAA,6CAAgB,0DAAA,8CAAA;cAChB,mBAAA,6CAAiB,2DAAA,+CAAA;cAEjB,oCAAA,gDAAkC,qDAAA,4CAAA;cAIlC,+BAAA,gDAA6B,gDAAA,4CAAA;cAI7B,6BAAA,gDAA2B,8CAAA,0CAAA"}
+{"version":3,"file":"batch.d.ts","names":[],"sources":["../../src/atoms/batch.ts"],"mappings":";;;cAGa,mBAAA,wCAAiB,kDAAA,8CAAA;cACjB,oBAAA,wCAAkB,mDAAA,4CAAA;cAClB,2BAAA,wCAAyB,0DAAA,mDAAA,uCAAA;cAIzB,kBAAA,wCAAgB,0DAAA,8CAAA;cAChB,mBAAA,wCAAiB,2DAAA,+CAAA;cAEjB,oCAAA,gDAAkC,qDAAA,4CAAA;cAIlC,+BAAA,gDAA6B,gDAAA,4CAAA;cAI7B,6BAAA,gDAA2B,8CAAA,0CAAA"}

package/dist/atoms/capabilities.d.ts

@@ -1,6 +1,6 @@
-import { EnsQueryAtomFactory } from "./query.js";
+import { EnsAtomFactory } from "./query.js";
 //#region src/atoms/capabilities.d.ts
-declare const getNameCapabilitiesAtom: EnsQueryAtomFactory<import("@ensforge/core").GetNameCapabilitiesParameters, {
+declare const getNameCapabilitiesAtom: EnsAtomFactory<import("@ensforge/core").GetNameCapabilitiesParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly account: `0x${string}`;
   readonly registry: {
@@ -24,7 +24,7 @@ declare const getNameCapabilitiesAtom: EnsQueryAtomFactory<import("@ensforge/cor
     readonly inherited: boolean;
     readonly extended: boolean;
     readonly permissioned: boolean;
-    readonly authorization: "unknown" | "none" | "owner-delegate" | "role";
+    readonly authorization: "role" | "unknown" | "none" | "owner-delegate";
     readonly profiles: {
       readonly address: boolean;
       readonly text: boolean;
@@ -113,17 +113,17 @@ declare const getNameCapabilitiesAtom: EnsQueryAtomFactory<import("@ensforge/cor
     readonly setExpiry: boolean;
   };
 }, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getOperatorApprovalAtom: EnsQueryAtomFactory<import("@ensforge/core").GetOperatorApprovalParameters, {
+declare const getOperatorApprovalAtom: EnsAtomFactory<import("@ensforge/core").GetOperatorApprovalParameters, {
   readonly owner: `0x${string}`;
   readonly operator: `0x${string}`;
   readonly targets: readonly {
-    readonly kind: "resolver" | "registrar" | "registry" | "wrapper";
+    readonly kind: "registry" | "resolver" | "registrar" | "wrapper";
     readonly address: `0x${string}`;
     readonly supported: boolean;
     readonly approved: boolean;
   }[];
 }, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getRecordPermissionsAtom: EnsQueryAtomFactory<import("@ensforge/core").GetRecordPermissionsParameters, {
+declare const getRecordPermissionsAtom: EnsAtomFactory<import("@ensforge/core").GetRecordPermissionsParameters, {
   readonly resolver: `0x${string}` | null;
   readonly inherited: boolean;
   readonly account: `0x${string}`;
@@ -195,7 +195,7 @@ declare const getRecordPermissionsAtom: EnsQueryAtomFactory<import("@ensforge/co
     readonly resource: bigint | null;
   }[];
 }, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getRegistryCapabilitiesAtom: EnsQueryAtomFactory<import("@ensforge/core").GetRegistryCapabilitiesParameters, {
+declare const getRegistryCapabilitiesAtom: EnsAtomFactory<import("@ensforge/core").GetRegistryCapabilitiesParameters, {
   readonly address: `0x${string}`;
   readonly protocol: "v1" | "v2";
   readonly kind: "registry" | "name-wrapper" | "permissioned-registry" | "wrapper-registry";
@@ -210,7 +210,7 @@ declare const getRegistryCapabilitiesAtom: EnsQueryAtomFactory<import("@ensforge
   readonly transfer: boolean;
   readonly setExpiry: boolean;
 }, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getRegistryRolesAtom: EnsQueryAtomFactory<import("@ensforge/core").GetRegistryRolesParameters, {
+declare const getRegistryRolesAtom: EnsAtomFactory<import("@ensforge/core").GetRegistryRolesParameters, {
   readonly supported: false;
   readonly protocol: "v1" | "v2";
   readonly reason: "RESOLVER_NOT_FOUND" | "ROLE_BASED_PERMISSIONS_UNSUPPORTED";
@@ -222,7 +222,7 @@ declare const getRegistryRolesAtom: EnsQueryAtomFactory<import("@ensforge/core")
   readonly account: `0x${string}`;
   readonly roles: bigint;
 }, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getRequiredAuthorizationAtom: EnsQueryAtomFactory<import("@ensforge/core").GetRequiredAuthorizationParameters, {
+declare const getRequiredAuthorizationAtom: EnsAtomFactory<import("@ensforge/core").GetRequiredAuthorizationParameters, {
   readonly account: `0x${string}`;
   readonly operation: {
     readonly type: "address";
@@ -273,7 +273,7 @@ declare const getRequiredAuthorizationAtom: EnsQueryAtomFactory<import("@ensforg
   } | {
     readonly available: true;
     readonly protocol: "v1" | "v2";
-    readonly kind: "resolver" | "registrar" | "registry" | "name-wrapper" | "wrapper-registry";
+    readonly kind: "registry" | "resolver" | "registrar" | "name-wrapper" | "wrapper-registry";
     readonly address: `0x${string}`;
     readonly operation: {
       readonly type: "address";
@@ -356,13 +356,13 @@ declare const getRequiredAuthorizationAtom: EnsQueryAtomFactory<import("@ensforg
   };
   readonly blockers: readonly ("NAME_NOT_REGISTERED" | "RESOLVER_NOT_FOUND" | "OPERATION_UNSUPPORTED" | "WRAPPER_FUSE" | "TRANSFER_ROLE")[];
 }, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getResolverCapabilitiesAtom: EnsQueryAtomFactory<import("@ensforge/core").GetRegistryCapabilitiesParameters, {
+declare const getResolverCapabilitiesAtom: EnsAtomFactory<import("@ensforge/core").GetRegistryCapabilitiesParameters, {
   readonly address: `0x${string}` | null;
   readonly node: `0x${string}` & import("effect/Brand").Brand<"Namehash">;
   readonly inherited: boolean;
   readonly extended: boolean;
   readonly permissioned: boolean;
-  readonly authorization: "unknown" | "none" | "owner-delegate" | "role";
+  readonly authorization: "role" | "unknown" | "none" | "owner-delegate";
   readonly profiles: {
     readonly address: boolean;
     readonly text: boolean;
@@ -376,7 +376,7 @@ declare const getResolverCapabilitiesAtom: EnsQueryAtomFactory<import("@ensforge
     readonly dnsZone: boolean;
   };
 }, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getResolverDelegateApprovalAtom: EnsQueryAtomFactory<import("@ensforge/core").GetResolverDelegateApprovalParameters, {
+declare const getResolverDelegateApprovalAtom: EnsAtomFactory<import("@ensforge/core").GetResolverDelegateApprovalParameters, {
   readonly supported: false;
   readonly protocol: "v1" | "v2";
   readonly reason: "RESOLVER_NOT_FOUND" | "DELEGATE_APPROVAL_UNSUPPORTED";
@@ -388,7 +388,7 @@ declare const getResolverDelegateApprovalAtom: EnsQueryAtomFactory<import("@ensf
   readonly delegate: `0x${string}`;
   readonly approved: boolean;
 }, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getResolverRolesAtom: EnsQueryAtomFactory<import("@ensforge/core").GetResolverRolesParameters, {
+declare const getResolverRolesAtom: EnsAtomFactory<import("@ensforge/core").GetResolverRolesParameters, {
   readonly supported: false;
   readonly protocol: "v1" | "v2";
   readonly reason: "RESOLVER_NOT_FOUND" | "ROLE_BASED_PERMISSIONS_UNSUPPORTED";
@@ -400,7 +400,7 @@ declare const getResolverRolesAtom: EnsQueryAtomFactory<import("@ensforge/core")
   readonly account: `0x${string}`;
   readonly roles: bigint;
 }, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getTokenApprovalAtom: EnsQueryAtomFactory<import("@ensforge/core").GetRegistryCapabilitiesParameters, {
+declare const getTokenApprovalAtom: EnsAtomFactory<import("@ensforge/core").GetRegistryCapabilitiesParameters, {
   readonly supported: false;
   readonly protocol: "v1" | "v2";
   readonly reason: "PER_TOKEN_APPROVAL_UNSUPPORTED" | "NAME_NOT_TOKENIZED";
@@ -412,7 +412,7 @@ declare const getTokenApprovalAtom: EnsQueryAtomFactory<import("@ensforge/core")
   readonly tokenId: bigint;
   readonly approved: `0x${string}` | null;
 }, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getWrapperPermissionsAtom: EnsQueryAtomFactory<import("@ensforge/core").GetRegistryRolesParameters, {
+declare const getWrapperPermissionsAtom: EnsAtomFactory<import("@ensforge/core").GetRegistryRolesParameters, {
   readonly supported: false;
   readonly protocol: "v1" | "v2";
   readonly reason: "NAME_NOT_WRAPPED";
@@ -444,14 +444,14 @@ declare const getWrapperPermissionsAtom: EnsQueryAtomFactory<import("@ensforge/c
   readonly roles: bigint;
   readonly operatorApproved: boolean;
 }, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getWriteTargetAtom: EnsQueryAtomFactory<import("@ensforge/core").GetWriteTargetParameters, {
+declare const getWriteTargetAtom: EnsAtomFactory<import("@ensforge/core").GetWriteTargetParameters, {
   readonly available: false;
   readonly protocol: "v1" | "v2";
   readonly reason: "NAME_NOT_REGISTERED" | "RESOLVER_NOT_FOUND" | "OPERATION_UNSUPPORTED";
 } | {
   readonly available: true;
   readonly protocol: "v1" | "v2";
-  readonly kind: "resolver" | "registrar" | "registry" | "name-wrapper" | "wrapper-registry";
+  readonly kind: "registry" | "resolver" | "registrar" | "name-wrapper" | "wrapper-registry";
   readonly address: `0x${string}`;
   readonly operation: {
     readonly type: "address";
@@ -500,7 +500,7 @@ declare const getWriteTargetAtom: EnsQueryAtomFactory<import("@ensforge/core").G
   readonly resource: bigint | null;
   readonly inheritedResolver: boolean;
 }, import("@ensforge/core").GetCanonicalResourceError>;
-declare const hasRegistryRolesAtom: EnsQueryAtomFactory<import("@ensforge/core").HasRegistryRolesParameters, {
+declare const hasRegistryRolesAtom: EnsAtomFactory<import("@ensforge/core").HasRegistryRolesParameters, {
   readonly supported: false;
   readonly protocol: "v1" | "v2";
   readonly reason: "RESOLVER_NOT_FOUND" | "ROLE_BASED_PERMISSIONS_UNSUPPORTED";
@@ -513,7 +513,7 @@ declare const hasRegistryRolesAtom: EnsQueryAtomFactory<import("@ensforge/core")
   readonly roles: bigint;
   readonly authorized: boolean;
 }, import("@ensforge/core").GetCanonicalResourceError>;
-declare const hasResolverRolesAtom: EnsQueryAtomFactory<import("@ensforge/core").HasResolverRolesParameters, {
+declare const hasResolverRolesAtom: EnsAtomFactory<import("@ensforge/core").HasResolverRolesParameters, {
   readonly supported: false;
   readonly protocol: "v1" | "v2";
   readonly reason: "RESOLVER_NOT_FOUND" | "ROLE_BASED_PERMISSIONS_UNSUPPORTED";

package/dist/atoms/capabilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"capabilities.d.ts","names":[],"sources":["../../src/atoms/capabilities.ts"],"mappings":";;cAEa,yBAAA,6CAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGnC;cACY,yBAAA,6CAAuB;;;;;;;;;4BAGnC;cACY,0BAAA,6CAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGpC;cACY,6BAAA,6CAA2B;;;;;;;;;;;;;;4BAGvC;cACY,sBAAA,6CAAoB;;;;;;;;;;;4BAGhC;cACY,8BAAA,6CAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGxC;cACY,6BAAA,6CAA2B;;;;;;;;;;;;;;;;;;;4BAGvC;cACY,iCAAA,6CAA+B;;;;;;;;;;;4BAG3C;cACY,sBAAA,6CAAoB;;;;;;;;;;;4BAGhC;cACY,sBAAA,6CAAoB;;;;;;;;;;;4BAGhC;cACY,2BAAA,6CAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGrC;cACY,oBAAA,6CAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAG9B;cACY,sBAAA,6CAAoB;;;;;;;;;;;;4BAGhC;cACY,sBAAA,6CAAoB;;;;;;;;;;;;4BAGhC"}
+{"version":3,"file":"capabilities.d.ts","names":[],"sources":["../../src/atoms/capabilities.ts"],"mappings":";;cAEa,yBAAA,wCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGnC;cACY,yBAAA,wCAAuB;;;;;;;;;4BAGnC;cACY,0BAAA,wCAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGpC;cACY,6BAAA,wCAA2B;;;;;;;;;;;;;;4BAGvC;cACY,sBAAA,wCAAoB;;;;;;;;;;;4BAGhC;cACY,8BAAA,wCAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGxC;cACY,6BAAA,wCAA2B;;;;;;;;;;;;;;;;;;;4BAGvC;cACY,iCAAA,wCAA+B;;;;;;;;;;;4BAG3C;cACY,sBAAA,wCAAoB;;;;;;;;;;;4BAGhC;cACY,sBAAA,wCAAoB;;;;;;;;;;;4BAGhC;cACY,2BAAA,wCAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGrC;cACY,oBAAA,wCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAG9B;cACY,sBAAA,wCAAoB;;;;;;;;;;;;4BAGhC;cACY,sBAAA,wCAAoB;;;;;;;;;;;;4BAGhC"}

package/dist/atoms/dns.d.ts

@@ -1,7 +1,7 @@
-import { EnsQueryAtomFactory } from "./query.js";
+import { EnsAtomFactory } from "./query.js";
 import { EnsMutationAtomFactory } from "./mutation.js";
 //#region src/atoms/dns.d.ts
-declare const getDnsClaimStatusAtom: EnsQueryAtomFactory<import("@ensforge/core").GetDnsClaimStatusParameters, {
+declare const getDnsClaimStatusAtom: EnsAtomFactory<import("@ensforge/core").GetDnsClaimStatusParameters, {
   readonly status: "unsupported";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly reason: "DNS_REGISTRAR_UNAVAILABLE";
@@ -16,7 +16,7 @@ declare const getDnsClaimStatusAtom: EnsQueryAtomFactory<import("@ensforge/core"
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly previousInception: bigint;
 }, import("@ensforge/core").GetDnsClaimStatusError>;
-declare const getDnsImportPlanAtom: EnsQueryAtomFactory<import("@ensforge/core").GetDnsImportPlanParameters, {
+declare const getDnsImportPlanAtom: EnsAtomFactory<import("@ensforge/core").GetDnsImportPlanParameters, {
   readonly status: "unsupported";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly reason: "DNS_REGISTRAR_UNAVAILABLE";
@@ -37,14 +37,14 @@ declare const getDnsImportPlanAtom: EnsQueryAtomFactory<import("@ensforge/core")
     readonly previousInception: bigint;
   };
 }, import("@ensforge/core").GetDnsClaimStatusError>;
-declare const getDnsRecordAtom: EnsQueryAtomFactory<import("@ensforge/core").GetDnsRecordParameters, {
+declare const getDnsRecordAtom: EnsAtomFactory<import("@ensforge/core").GetDnsRecordParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly recordName: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resource: number;
   readonly resolver: `0x${string}` | null;
   readonly value: `0x${string}` | null;
 }, import("@ensforge/core").GetDnsClaimStatusError>;
-declare const getDnsRecordsAtom: EnsQueryAtomFactory<import("@ensforge/core").GetDnsRecordsParameters, {
+declare const getDnsRecordsAtom: EnsAtomFactory<import("@ensforge/core").GetDnsRecordsParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
   readonly records: readonly {
@@ -55,12 +55,12 @@ declare const getDnsRecordsAtom: EnsQueryAtomFactory<import("@ensforge/core").Ge
     readonly value: `0x${string}` | null;
   }[];
 }, import("@ensforge/core").GetDnsClaimStatusError>;
-declare const getZoneHashAtom: EnsQueryAtomFactory<import("@ensforge/core").GetZoneHashParameters, {
+declare const getZoneHashAtom: EnsAtomFactory<import("@ensforge/core").GetZoneHashParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
   readonly value: `0x${string}` | null;
 }, import("@ensforge/core").GetDnsClaimStatusError>;
-declare const hasDnsRecordsAtom: EnsQueryAtomFactory<import("@ensforge/core").HasDnsRecordsParameters, {
+declare const hasDnsRecordsAtom: EnsAtomFactory<import("@ensforge/core").HasDnsRecordsParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly recordName: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;

package/dist/atoms/dns.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dns.d.ts","names":[],"sources":["../../src/atoms/dns.ts"],"mappings":";;;cAGa,uBAAA,6CAAqB;;;;;;;;;;;;;;4BAA2D;cAChF,sBAAA,6CAAoB;;;;;;;;;;;;;;;;;;;;4BAA0D;cAC9E,kBAAA,6CAAgB;;;;;;4BAAsD;cACtE,mBAAA,6CAAiB;;;;;;;;;;4BAAuD;cACxE,iBAAA,6CAAe;;;;4BAAqD;cACpE,mBAAA,6CAAiB;;;;;4BAAuD;cAExE,gCAAA,gDAA8B,iDAAA,8CAAA;cAI9B,iCAAA,gDAA+B,kDAAA,8CAAA;cAI/B,iCAAA,gDAA+B,kDAAA,8CAAA;cAI/B,+BAAA,gDAA6B,gDAAA,8CAAA"}
+{"version":3,"file":"dns.d.ts","names":[],"sources":["../../src/atoms/dns.ts"],"mappings":";;;cAGa,uBAAA,wCAAqB;;;;;;;;;;;;;;4BAA2D;cAChF,sBAAA,wCAAoB;;;;;;;;;;;;;;;;;;;;4BAA0D;cAC9E,kBAAA,wCAAgB;;;;;;4BAAsD;cACtE,mBAAA,wCAAiB;;;;;;;;;;4BAAuD;cACxE,iBAAA,wCAAe;;;;4BAAqD;cACpE,mBAAA,wCAAiB;;;;;4BAAuD;cAExE,gCAAA,gDAA8B,iDAAA,8CAAA;cAI9B,iCAAA,gDAA+B,kDAAA,8CAAA;cAI/B,iCAAA,gDAA+B,kDAAA,8CAAA;cAI/B,+BAAA,gDAA6B,gDAAA,8CAAA"}

package/dist/atoms/events.d.ts

@@ -1,86 +1,86 @@
-import { EnsQueryAtomFactory } from "./query.js";
+import { EnsAtomFactory } from "./query.js";
 //#region src/atoms/events.d.ts
-declare const getEnsEventsAtom: EnsQueryAtomFactory<import("@ensforge/core").GetEnsEventsParameters, readonly {
-  readonly blockNumber: bigint | null;
-  readonly transactionHash: `0x${string}` | null;
+declare const getEnsEventsAtom: EnsAtomFactory<import("@ensforge/core").GetEnsEventsParameters, readonly {
   readonly protocol: "v1" | "v2";
   readonly raw: {
     readonly topics: readonly `0x${string}`[];
     readonly data: `0x${string}`;
     readonly args: unknown;
   };
-  readonly kind: "resolver" | "records" | "ownership" | "commitment" | "manager" | "registration" | "renewal" | "subname" | "migration" | "other";
+  readonly blockNumber: bigint | null;
+  readonly kind: "migration" | "resolver" | "manager" | "commitment" | "records" | "ownership" | "registration" | "renewal" | "subname" | "other";
+  readonly transactionHash: `0x${string}` | null;
   readonly contract: `0x${string}`;
   readonly transactionIndex: number | null;
   readonly logIndex: number | null;
-  readonly contractKind: "resolver" | "registrar" | "registry" | "name-wrapper" | "migration-controller";
+  readonly contractKind: "registry" | "resolver" | "registrar" | "name-wrapper" | "migration-controller";
   readonly eventName: string;
   readonly removed: boolean;
-  readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
   readonly to?: `0x${string}` | undefined;
+  readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
+  readonly tokenId?: bigint | undefined;
+  readonly owner?: `0x${string}` | undefined;
   readonly from?: `0x${string}` | undefined;
+  readonly label?: string | undefined;
   readonly resolver?: `0x${string}` | undefined;
-  readonly owner?: `0x${string}` | undefined;
   readonly node?: `0x${string}` | undefined;
-  readonly label?: string | undefined;
-  readonly tokenId?: bigint | undefined;
   readonly commitment?: `0x${string}` | undefined;
 }[], import("@ensforge/core").GetEnsEventsError>;
-declare const getNameHistoryAtom: EnsQueryAtomFactory<import("@ensforge/core").GetNameHistoryParameters, {
+declare const getNameHistoryAtom: EnsAtomFactory<import("@ensforge/core").GetNameHistoryParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly events: readonly {
-    readonly blockNumber: bigint | null;
-    readonly transactionHash: `0x${string}` | null;
     readonly protocol: "v1" | "v2";
     readonly raw: {
       readonly topics: readonly `0x${string}`[];
       readonly data: `0x${string}`;
       readonly args: unknown;
     };
-    readonly kind: "resolver" | "records" | "ownership" | "commitment" | "manager" | "registration" | "renewal" | "subname" | "migration" | "other";
+    readonly blockNumber: bigint | null;
+    readonly kind: "migration" | "resolver" | "manager" | "commitment" | "records" | "ownership" | "registration" | "renewal" | "subname" | "other";
+    readonly transactionHash: `0x${string}` | null;
     readonly contract: `0x${string}`;
     readonly transactionIndex: number | null;
     readonly logIndex: number | null;
-    readonly contractKind: "resolver" | "registrar" | "registry" | "name-wrapper" | "migration-controller";
+    readonly contractKind: "registry" | "resolver" | "registrar" | "name-wrapper" | "migration-controller";
     readonly eventName: string;
     readonly removed: boolean;
-    readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
     readonly to?: `0x${string}` | undefined;
+    readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
+    readonly tokenId?: bigint | undefined;
+    readonly owner?: `0x${string}` | undefined;
     readonly from?: `0x${string}` | undefined;
+    readonly label?: string | undefined;
     readonly resolver?: `0x${string}` | undefined;
-    readonly owner?: `0x${string}` | undefined;
     readonly node?: `0x${string}` | undefined;
-    readonly label?: string | undefined;
-    readonly tokenId?: bigint | undefined;
     readonly commitment?: `0x${string}` | undefined;
   }[];
 }, import("@ensforge/core").GetEnsEventsError>;
-declare const watchEnsEventsAtom: EnsQueryAtomFactory<import("@ensforge/core").WatchEnsEventsParameters, {
-  readonly blockNumber: bigint | null;
-  readonly transactionHash: `0x${string}` | null;
+declare const watchEnsEventsAtom: EnsAtomFactory<import("@ensforge/core").WatchEnsEventsParameters, {
   readonly protocol: "v1" | "v2";
   readonly raw: {
     readonly topics: readonly `0x${string}`[];
     readonly data: `0x${string}`;
     readonly args: unknown;
   };
-  readonly kind: "resolver" | "records" | "ownership" | "commitment" | "manager" | "registration" | "renewal" | "subname" | "migration" | "other";
+  readonly blockNumber: bigint | null;
+  readonly kind: "migration" | "resolver" | "manager" | "commitment" | "records" | "ownership" | "registration" | "renewal" | "subname" | "other";
+  readonly transactionHash: `0x${string}` | null;
   readonly contract: `0x${string}`;
   readonly transactionIndex: number | null;
   readonly logIndex: number | null;
-  readonly contractKind: "resolver" | "registrar" | "registry" | "name-wrapper" | "migration-controller";
+  readonly contractKind: "registry" | "resolver" | "registrar" | "name-wrapper" | "migration-controller";
   readonly eventName: string;
   readonly removed: boolean;
-  readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
   readonly to?: `0x${string}` | undefined;
+  readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
+  readonly tokenId?: bigint | undefined;
+  readonly owner?: `0x${string}` | undefined;
   readonly from?: `0x${string}` | undefined;
+  readonly label?: string | undefined;
   readonly resolver?: `0x${string}` | undefined;
-  readonly owner?: `0x${string}` | undefined;
   readonly node?: `0x${string}` | undefined;
-  readonly label?: string | undefined;
-  readonly tokenId?: bigint | undefined;
   readonly commitment?: `0x${string}` | undefined;
-}, import("@ensforge/core").GetEnsEventsError | import("effect/Cause").NoSuchElementError>;
+}, import("effect/Cause").NoSuchElementError | import("@ensforge/core").GetEnsEventsError>;
 //#endregion
 export { getEnsEventsAtom, getNameHistoryAtom, watchEnsEventsAtom };
 //# sourceMappingURL=events.d.ts.map

package/dist/atoms/events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"events.d.ts","names":[],"sources":["../../src/atoms/events.ts"],"mappings":";;cAGa,kBAAA,6CAAgB;;;;;;;;;;;;;;;;;;;;;;;;;8BAA4D;cAC5E,oBAAA,6CAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAA8D;cAChF,oBAAA,6CAAkB;;;;;;;;;;;;;;;;;;;;;;;;;4BAA+D,2CAAA"}
+{"version":3,"file":"events.d.ts","names":[],"sources":["../../src/atoms/events.ts"],"mappings":";;cAGa,kBAAA,wCAAgB;;;;;;;;;;;;;;;;;;;;;;;;;8BAA4D;cAC5E,oBAAA,wCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAA8D;cAChF,oBAAA,wCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;0BAA+D,8CAAA"}

package/dist/atoms/generic.d.ts

@@ -1,4 +1,5 @@
-import { EnsQueryAtom, QueryAtomOptions } from "./query.js";
+import { EnsAtomOptions } from "../query/options.js";
+import { EnsAtom } from "./query.js";
 import { EnsReadRequest, Ensforge, GetRecordsError, GetRecordsParameters, GetRecordsResult, GetRecordsSelection, ReadBatchError, ReadBatchOptions, ReadBatchResult, ReadBatchSettledResult, RpcError } from "@ensforge/sdk";
 //#region src/atoms/generic.d.ts
 type ReadRequests = Readonly<Record<string, EnsReadRequest<unknown, unknown>>>;
@@ -6,9 +7,9 @@ interface ReadBatchAtomParameters<Requests extends ReadRequests> {
   readonly options?: ReadBatchOptions;
   readonly requests: Requests;
 }
-declare const getRecordsAtom: <const Selection extends GetRecordsSelection>(sdk: Ensforge, parameters: GetRecordsParameters<Selection>, options: QueryAtomOptions) => EnsQueryAtom<GetRecordsResult<Selection>, GetRecordsError>;
-declare const readBatchAtom: <const Requests extends ReadRequests>(sdk: Ensforge, parameters: ReadBatchAtomParameters<Requests>, options: QueryAtomOptions) => EnsQueryAtom<ReadBatchResult<Requests>, ReadBatchError<Requests>>;
-declare const readBatchSettledAtom: <const Requests extends ReadRequests>(sdk: Ensforge, parameters: ReadBatchAtomParameters<Requests>, options: QueryAtomOptions) => EnsQueryAtom<ReadBatchSettledResult<Requests>, RpcError>;
+declare const getRecordsAtom: <const Selection extends GetRecordsSelection>(sdk: Ensforge, parameters: GetRecordsParameters<Selection>, options?: EnsAtomOptions<GetRecordsError>) => EnsAtom<GetRecordsResult<Selection>, GetRecordsError>;
+declare const readBatchAtom: <const Requests extends ReadRequests>(sdk: Ensforge, parameters: ReadBatchAtomParameters<Requests>, options?: EnsAtomOptions<ReadBatchError<Requests>>) => EnsAtom<ReadBatchResult<Requests>, ReadBatchError<Requests>>;
+declare const readBatchSettledAtom: <const Requests extends ReadRequests>(sdk: Ensforge, parameters: ReadBatchAtomParameters<Requests>, options?: EnsAtomOptions<RpcError>) => EnsAtom<ReadBatchSettledResult<Requests>, RpcError>;
 //#endregion
 export { ReadBatchAtomParameters, getRecordsAtom, readBatchAtom, readBatchSettledAtom };
 //# sourceMappingURL=generic.d.ts.map

package/dist/atoms/generic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generic.d.ts","names":[],"sources":["../../src/atoms/generic.ts"],"mappings":";;;KAgBK,eAAe,SAAS,eAAe;UAE3B,wBAAwB,iBAAiB;WAC/C,UAAU;WACV,UAAU;;cAQR,uBAAwB,kBAAkB,qBACrD,KAAK,UACL,YAAY,qBAAqB,YACjC,SAAS,qBACR,aAAa,iBAAiB,YAAY;cAchC,sBAAuB,iBAAiB,cACnD,KAAK,UACL,YAAY,wBAAwB,WACpC,SAAS,qBACR,aAAa,gBAAgB,WAAW,eAAe;cAc7C,6BAA8B,iBAAiB,cAC1D,KAAK,UACL,YAAY,wBAAwB,WACpC,SAAS,qBACR,aAAa,uBAAuB,WAAW"}
+{"version":3,"file":"generic.d.ts","names":[],"sources":["../../src/atoms/generic.ts"],"mappings":";;;;KAiBK,eAAe,SAAS,eAAe;UAE3B,wBAAwB,iBAAiB;WAC/C,UAAU;WACV,UAAU;;cAQR,uBAAwB,kBAAkB,qBACrD,KAAK,UACL,YAAY,qBAAqB,YACjC,UAAU,eAAe,qBACxB,QAAQ,iBAAiB,YAAY;cAc3B,sBAAuB,iBAAiB,cACnD,KAAK,UACL,YAAY,wBAAwB,WACpC,UAAU,eAAe,eAAe,eACvC,QAAQ,gBAAgB,WAAW,eAAe;cAcxC,6BAA8B,iBAAiB,cAC1D,KAAK,UACL,YAAY,wBAAwB,WACpC,UAAU,eAAe,cACxB,QAAQ,uBAAuB,WAAW"}

package/dist/atoms/generic.js.map

@@ -1 +1 @@
-{"version":3,"file":"generic.js","names":[],"sources":["../../src/atoms/generic.ts"],"sourcesContent":["import type {\n  EnsReadRequest,\n  GetRecordsError,\n  GetRecordsParameters,\n  GetRecordsResult,\n  GetRecordsSelection,\n  ReadBatchError,\n  ReadBatchOptions,\n  ReadBatchResult,\n  ReadBatchSettledResult,\n  RpcError,\n} from \"@ensforge/sdk\";\nimport type { Ensforge } from \"@ensforge/sdk\";\n\nimport { makeQueryAtom, type EnsQueryAtom, type QueryAtomOptions } from \"./query.js\";\n\ntype ReadRequests = Readonly<Record<string, EnsReadRequest<unknown, unknown>>>;\n\nexport interface ReadBatchAtomParameters<Requests extends ReadRequests> {\n  readonly options?: ReadBatchOptions;\n  readonly requests: Requests;\n}\n\nconst getRecordsAtomBase = makeQueryAtom<GetRecordsParameters, GetRecordsResult, GetRecordsError>(\n  \"records\",\n  (sdk) => sdk.records.getRecords,\n);\n\nexport const getRecordsAtom = <const Selection extends GetRecordsSelection>(\n  sdk: Ensforge,\n  parameters: GetRecordsParameters<Selection>,\n  options: QueryAtomOptions,\n): EnsQueryAtom<GetRecordsResult<Selection>, GetRecordsError> =>\n  getRecordsAtomBase(sdk, parameters, options) as EnsQueryAtom<\n    GetRecordsResult<Selection>,\n    GetRecordsError\n  >;\n\nconst readBatchAtomBase = makeQueryAtom<\n  ReadBatchAtomParameters<ReadRequests>,\n  ReadBatchResult<ReadRequests>,\n  ReadBatchError<ReadRequests>\n>(\"batch\", (sdk) => ({\n  effect: ({ options, requests }) => sdk.batch.readBatch.effect(requests, options),\n}));\n\nexport const readBatchAtom = <const Requests extends ReadRequests>(\n  sdk: Ensforge,\n  parameters: ReadBatchAtomParameters<Requests>,\n  options: QueryAtomOptions,\n): EnsQueryAtom<ReadBatchResult<Requests>, ReadBatchError<Requests>> =>\n  readBatchAtomBase(sdk, parameters, options) as EnsQueryAtom<\n    ReadBatchResult<Requests>,\n    ReadBatchError<Requests>\n  >;\n\nconst readBatchSettledAtomBase = makeQueryAtom<\n  ReadBatchAtomParameters<ReadRequests>,\n  ReadBatchSettledResult<ReadRequests>,\n  RpcError\n>(\"batch\", (sdk) => ({\n  effect: ({ options, requests }) => sdk.batch.readBatchSettled.effect(requests, options),\n}));\n\nexport const readBatchSettledAtom = <const Requests extends ReadRequests>(\n  sdk: Ensforge,\n  parameters: ReadBatchAtomParameters<Requests>,\n  options: QueryAtomOptions,\n): EnsQueryAtom<ReadBatchSettledResult<Requests>, RpcError> =>\n  readBatchSettledAtomBase(sdk, parameters, options) as EnsQueryAtom<\n    ReadBatchSettledResult<Requests>,\n    RpcError\n  >;\n"],"mappings":";;;AAuBA,MAAM,qBAAqB,cACzB,YACC,QAAQ,IAAI,QAAQ,UACvB;AAEA,MAAa,kBACX,KACA,YACA,YAEA,mBAAmB,KAAK,YAAY,OAAO;AAK7C,MAAM,oBAAoB,cAIxB,UAAU,SAAS,EACnB,SAAS,EAAE,SAAS,eAAe,IAAI,MAAM,UAAU,OAAO,UAAU,OAAO,EACjF,EAAE;AAEF,MAAa,iBACX,KACA,YACA,YAEA,kBAAkB,KAAK,YAAY,OAAO;AAK5C,MAAM,2BAA2B,cAI/B,UAAU,SAAS,EACnB,SAAS,EAAE,SAAS,eAAe,IAAI,MAAM,iBAAiB,OAAO,UAAU,OAAO,EACxF,EAAE;AAEF,MAAa,wBACX,KACA,YACA,YAEA,yBAAyB,KAAK,YAAY,OAAO"}
+{"version":3,"file":"generic.js","names":[],"sources":["../../src/atoms/generic.ts"],"sourcesContent":["import type {\n  EnsReadRequest,\n  GetRecordsError,\n  GetRecordsParameters,\n  GetRecordsResult,\n  GetRecordsSelection,\n  ReadBatchError,\n  ReadBatchOptions,\n  ReadBatchResult,\n  ReadBatchSettledResult,\n  RpcError,\n} from \"@ensforge/sdk\";\nimport type { Ensforge } from \"@ensforge/sdk\";\n\nimport type { EnsAtomOptions } from \"../query/options.js\";\nimport { makeQueryAtom, type EnsAtom } from \"./query.js\";\n\ntype ReadRequests = Readonly<Record<string, EnsReadRequest<unknown, unknown>>>;\n\nexport interface ReadBatchAtomParameters<Requests extends ReadRequests> {\n  readonly options?: ReadBatchOptions;\n  readonly requests: Requests;\n}\n\nconst getRecordsAtomBase = makeQueryAtom<GetRecordsParameters, GetRecordsResult, GetRecordsError>(\n  \"records\",\n  (sdk) => sdk.records.getRecords,\n);\n\nexport const getRecordsAtom = <const Selection extends GetRecordsSelection>(\n  sdk: Ensforge,\n  parameters: GetRecordsParameters<Selection>,\n  options?: EnsAtomOptions<GetRecordsError>,\n): EnsAtom<GetRecordsResult<Selection>, GetRecordsError> =>\n  getRecordsAtomBase(sdk, parameters, options) as EnsAtom<\n    GetRecordsResult<Selection>,\n    GetRecordsError\n  >;\n\nconst readBatchAtomBase = makeQueryAtom<\n  ReadBatchAtomParameters<ReadRequests>,\n  ReadBatchResult<ReadRequests>,\n  ReadBatchError<ReadRequests>\n>(\"batch\", (sdk) => ({\n  effect: ({ options, requests }) => sdk.batch.readBatch.effect(requests, options),\n}));\n\nexport const readBatchAtom = <const Requests extends ReadRequests>(\n  sdk: Ensforge,\n  parameters: ReadBatchAtomParameters<Requests>,\n  options?: EnsAtomOptions<ReadBatchError<Requests>>,\n): EnsAtom<ReadBatchResult<Requests>, ReadBatchError<Requests>> =>\n  readBatchAtomBase(sdk, parameters, options as EnsAtomOptions<unknown>) as EnsAtom<\n    ReadBatchResult<Requests>,\n    ReadBatchError<Requests>\n  >;\n\nconst readBatchSettledAtomBase = makeQueryAtom<\n  ReadBatchAtomParameters<ReadRequests>,\n  ReadBatchSettledResult<ReadRequests>,\n  RpcError\n>(\"batch\", (sdk) => ({\n  effect: ({ options, requests }) => sdk.batch.readBatchSettled.effect(requests, options),\n}));\n\nexport const readBatchSettledAtom = <const Requests extends ReadRequests>(\n  sdk: Ensforge,\n  parameters: ReadBatchAtomParameters<Requests>,\n  options?: EnsAtomOptions<RpcError>,\n): EnsAtom<ReadBatchSettledResult<Requests>, RpcError> =>\n  readBatchSettledAtomBase(sdk, parameters, options) as EnsAtom<\n    ReadBatchSettledResult<Requests>,\n    RpcError\n  >;\n"],"mappings":";;;AAwBA,MAAM,qBAAqB,cACzB,YACC,QAAQ,IAAI,QAAQ,UACvB;AAEA,MAAa,kBACX,KACA,YACA,YAEA,mBAAmB,KAAK,YAAY,OAAO;AAK7C,MAAM,oBAAoB,cAIxB,UAAU,SAAS,EACnB,SAAS,EAAE,SAAS,eAAe,IAAI,MAAM,UAAU,OAAO,UAAU,OAAO,EACjF,EAAE;AAEF,MAAa,iBACX,KACA,YACA,YAEA,kBAAkB,KAAK,YAAY,OAAkC;AAKvE,MAAM,2BAA2B,cAI/B,UAAU,SAAS,EACnB,SAAS,EAAE,SAAS,eAAe,IAAI,MAAM,iBAAiB,OAAO,UAAU,OAAO,EACxF,EAAE;AAEF,MAAa,wBACX,KACA,YACA,YAEA,yBAAyB,KAAK,YAAY,OAAO"}

package/dist/atoms/migration.d.ts

@@ -1,7 +1,7 @@
-import { EnsQueryAtomFactory } from "./query.js";
+import { EnsAtomFactory } from "./query.js";
 import { EnsMutationAtomFactory } from "./mutation.js";
 //#region src/atoms/migration.d.ts
-declare const getMigrationEligibilityAtom: EnsQueryAtomFactory<import("@ensforge/core").GetMigrationEligibilityParameters, {
+declare const getMigrationEligibilityAtom: EnsAtomFactory<import("@ensforge/core").GetMigrationEligibilityParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly eligible: boolean;
   readonly status: {
@@ -59,7 +59,7 @@ declare const getMigrationEligibilityAtom: EnsQueryAtomFactory<import("@ensforge
   readonly authorized: boolean;
   readonly blockers: readonly ("ENSV2_NOT_ACTIVE" | "NOT_ETH_NAME" | "NAME_NOT_RESERVED" | "PARENT_NOT_MIGRATED" | "NAME_ALREADY_MIGRATED" | "NAME_AVAILABLE" | "ACCOUNT_NOT_OWNER_OR_OPERATOR" | "INVALID_WRAPPER_STATE" | "FROZEN_TOKEN_APPROVAL" | "TRANSFER_DISABLED")[];
 }, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getMigrationPlanAtom: EnsQueryAtomFactory<import("@ensforge/core").GetMigrationPlanParameters, {
+declare const getMigrationPlanAtom: EnsAtomFactory<import("@ensforge/core").GetMigrationPlanParameters, {
   readonly status: "unsupported";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly blockers: readonly ("ENSV2_NOT_ACTIVE" | "NOT_ETH_NAME" | "NAME_NOT_RESERVED" | "PARENT_NOT_MIGRATED" | "NAME_ALREADY_MIGRATED" | "NAME_AVAILABLE" | "ACCOUNT_NOT_OWNER_OR_OPERATOR" | "INVALID_WRAPPER_STATE" | "FROZEN_TOKEN_APPROVAL" | "TRANSFER_DISABLED")[];
@@ -113,7 +113,7 @@ declare const getMigrationPlanAtom: EnsQueryAtomFactory<import("@ensforge/core")
   };
   readonly warnings: readonly ("SUBREGISTRY_IGNORED_FOR_LOCKED_NAME" | "RESOLVER_MAY_BE_PRESERVED")[];
 }, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getMigrationStatusAtom: EnsQueryAtomFactory<import("@ensforge/core").GetMigrationStatusParameters, {
+declare const getMigrationStatusAtom: EnsAtomFactory<import("@ensforge/core").GetMigrationStatusParameters, {
   readonly status: "unsupported";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly reason: "ENSV2_NOT_ACTIVE" | "NOT_ETH_NAME" | "NAME_NOT_RESERVED";
@@ -150,7 +150,7 @@ declare const getMigrationStatusAtom: EnsQueryAtomFactory<import("@ensforge/core
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly registry: `0x${string}`;
 }, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getMigrationTargetAtom: EnsQueryAtomFactory<import("@ensforge/core").GetMigrationStatusParameters, {
+declare const getMigrationTargetAtom: EnsAtomFactory<import("@ensforge/core").GetMigrationStatusParameters, {
   readonly supported: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly reason: "MIGRATION_UNSUPPORTED" | "MIGRATION_NOT_REQUIRED" | "PARENT_NOT_MIGRATED";

package/dist/atoms/migration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"migration.d.ts","names":[],"sources":["../../src/atoms/migration.ts"],"mappings":";;;cAGa,6BAAA,6CAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGvC;cACY,sBAAA,6CAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGhC;cACY,wBAAA,6CAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGlC;cACY,wBAAA,6CAAsB;;;;;;;;;;;;4BAGlC;cAEY,oCAAA,gDAAkC,qDAAA,8CAAA;cAIlC,+BAAA,gDAA6B,gDAAA,4CAAA;cAI7B,gCAAA,gDAA8B,iDAAA,iDAAA"}
+{"version":3,"file":"migration.d.ts","names":[],"sources":["../../src/atoms/migration.ts"],"mappings":";;;cAGa,6BAAA,wCAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGvC;cACY,sBAAA,wCAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGhC;cACY,wBAAA,wCAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGlC;cACY,wBAAA,wCAAsB;;;;;;;;;;;;4BAGlC;cAEY,oCAAA,gDAAkC,qDAAA,8CAAA;cAIlC,+BAAA,gDAA6B,gDAAA,4CAAA;cAI7B,gCAAA,gDAA8B,iDAAA,iDAAA"}