@ic-reactor/react 3.7.0 → 3.8.0

package/src/auth/types.ts

@@ -1,4 +1,5 @@
-import type { Identity } from "@icp-sdk/core/agent"
+import type { Identity, SignIdentity } from "@icp-sdk/core/agent"
+import type { PartialIdentity } from "@icp-sdk/core/identity"
 import type { Principal } from "@icp-sdk/core/principal"
 
 export interface SignedIdentityAttributes {
@@ -6,9 +7,21 @@ export interface SignedIdentityAttributes {
   signature: Uint8Array
 }
 
+/**
+ * The 32-byte nonce issued by the relying-party canister.
+ *
+ * A function (or promise) lets the Internet Identity window open while the
+ * nonce is still being fetched, so the popup is opened inside the user gesture
+ * instead of after it. `@icp-sdk/auth` v8 requires the function form; v7
+ * accepts the promise form. IC Reactor normalizes whichever you pass to the
+ * shape the installed client expects.
+ */
+export type IdentityAttributeNonce =
+  Uint8Array | Promise<Uint8Array> | (() => Uint8Array | Promise<Uint8Array>)
+
 export interface IdentityAttributeRequest {
   keys: string[]
-  nonce: Uint8Array
+  nonce: IdentityAttributeNonce
 }
 
 export interface IdentityAttributeValues {
@@ -26,15 +39,102 @@ export interface IdentityAttributeResult {
   completedAt: string
 }
 
+/**
+ * The providers that Internet Identity supports for one-click sign-in. Only
+ * these three reach the underlying auth client.
+ */
 type IdentityAttributeOpenIdProviderAlias = "google" | "apple" | "microsoft"
 
+/**
+ * An OpenID provider, either as a well-known alias or as a raw issuer URL.
+ *
+ * The two forms are **not** interchangeable, and what each one does depends on
+ * where it is passed:
+ *
+ * - An alias (`"google" | "apple" | "microsoft"`) is forwarded to the auth
+ *   client, which adds an `openid` search param to the identity provider URL so
+ *   the user signs in through that provider directly.
+ * - Any other string is treated as a raw issuer URL and is **never** forwarded
+ *   to the auth client, so it never affects how the user signs in. It is only
+ *   meaningful when passed to {@link IdentityAttributesManager.requestOpenId}
+ *   (or `identityAttributeKeys`), which scopes the requested keys to
+ *   `openid:<issuer>:<key>`. Passed anywhere else it has no effect at all.
+ */
 export type IdentityAttributeOpenIdProvider =
   IdentityAttributeOpenIdProviderAlias | (string & {})
 
+/** Session key algorithm used for each sign-in. */
+export type AuthClientKeyType = "ECDSA" | "Ed25519"
+
+/** Structural shape of an `@icp-sdk/auth` `AuthClientStorage`. */
+export interface AuthClientStorageLike {
+  get(key: string): Promise<string | CryptoKeyPair | null>
+  set(key: string, value: string | CryptoKeyPair): Promise<void>
+  remove(key: string): Promise<void>
+}
+
+/** Idle-session configuration forwarded to the underlying AuthClient. */
+export interface AuthClientIdleOptions {
+  /** Called once the user has been idle for `idleTimeout` ms. */
+  onIdle?: () => unknown
+  /** Idle timeout in ms. @default 600_000 (10 minutes) */
+  idleTimeout?: number
+  /** Treat scroll events as activity. @default false */
+  captureScroll?: boolean
+  /** Scroll debounce in ms. @default 100 */
+  scrollDebounce?: number
+  /** Disable idle detection entirely. @default false */
+  disableIdle?: boolean
+  /**
+   * Disable the built-in idle callback, which signs the user out and reloads
+   * the page. @default false
+   */
+  disableDefaultIdleCallback?: boolean
+}
+
 export interface AuthenticationClientOptions {
+  /** Identity provider URL. @default "https://id.ai/authorize" */
   identityProvider?: string | URL
+  /** `window.open` features string for the identity provider popup. */
   windowOpenerFeatures?: string
+  /**
+   * Provider for one-click sign-in.
+   *
+   * Only the `"google" | "apple" | "microsoft"` aliases reach the auth client.
+   * Any other value is dropped here and has **no effect** — raw issuer URLs are
+   * only meaningful on `requestOpenId`, where they scope the requested keys.
+   * @see {@link IdentityAttributeOpenIdProvider}
+   */
   openIdProvider?: IdentityAttributeOpenIdProvider
+  /**
+   * Derivation origin for the identity provider.
+   *
+   * Required when the app is served from more than one origin (e.g. a custom
+   * domain plus `<canisterId>.icp0.io`) and every origin must resolve to the
+   * same principal.
+   * @see https://github.com/dfinity/internet-identity/blob/main/docs/internet-identity-spec.adoc
+   */
+  derivationOrigin?: string | URL
+  /** Persistent storage backend. @default IndexedDB */
+  storage?: AuthClientStorageLike
+  /**
+   * Session key algorithm. Use `"Ed25519"` when the storage backend cannot
+   * hold a `CryptoKey`. @default "ECDSA"
+   */
+  keyType?: AuthClientKeyType
+  /**
+   * Idle timeout configuration. Pass `{ disableIdle: true }` to opt out of the
+   * default behaviour, which signs the user out and reloads after 10 minutes.
+   */
+  idleOptions?: AuthClientIdleOptions
+  /** An existing identity to authenticate via delegation. */
+  identity?: SignIdentity | PartialIdentity
+  /**
+   * How the client talks to the identity provider. `"redirect"` requires
+   * `@icp-sdk/auth` v8 or later and is ignored by older versions.
+   * @default "window"
+   */
+  transport?: "window" | "redirect"
 }
 
 export interface AuthClientSignInOptions {
@@ -48,36 +148,52 @@ export interface AuthenticationSignInOptions
   onError?: (error?: string) => void | Promise<void>
 }
 
-export interface RequestIdentityAttributesParameters {
+export interface RequestIdentityAttributesParameters extends AuthenticationClientOptions {
   keys: string[]
-  nonce: Uint8Array
-  identityProvider?: string | URL
-  openIdProvider?: IdentityAttributeOpenIdProvider
-  windowOpenerFeatures?: string
+  nonce: IdentityAttributeNonce
+  /**
+   * Sign in as part of the same identity-provider interaction.
+   * @default true
+   */
   signIn?: boolean
   maxTimeToLive?: bigint
   targets?: Principal[]
 }
 
-export interface RequestOpenIdIdentityAttributesParameters {
-  nonce: Uint8Array
+export interface RequestOpenIdIdentityAttributesParameters extends Omit<
+  RequestIdentityAttributesParameters,
+  "openIdProvider"
+> {
+  /**
+   * Provider the requested `keys` are scoped to, producing
+   * `openid:<issuer>:<key>`.
+   *
+   * Passing one of the `"google" | "apple" | "microsoft"` aliases additionally
+   * routes sign-in through that provider, so the user grants attribute access
+   * in the same step. A raw issuer URL only scopes the keys.
+   * @see {@link IdentityAttributeOpenIdProvider}
+   */
   openIdProvider: IdentityAttributeOpenIdProvider
-  keys: string[]
-  identityProvider?: string | URL
-  windowOpenerFeatures?: string
-  signIn?: boolean
-  maxTimeToLive?: bigint
-  targets?: Principal[]
 }
 
+/**
+ * Structural subset of `@icp-sdk/auth`'s `AuthClient` that IC Reactor relies
+ * on. Declared locally so `@icp-sdk/auth` stays an optional peer dependency.
+ */
 export interface AuthClientLike {
   getIdentity(): Promise<Identity> | Identity
   isAuthenticated(): Promise<boolean> | boolean
   signIn(options?: AuthClientSignInOptions): Promise<Identity>
   signOut(options?: { returnTo?: string }): Promise<void>
-  requestAttributes(
-    params: IdentityAttributeRequest
-  ): Promise<SignedIdentityAttributes>
+  requestAttributes(params: {
+    keys: string[]
+    // Widened across `@icp-sdk/auth` v7 (value or promise) and v8 (thunk).
+    // Method-shorthand parameters are bivariant, so both real signatures are
+    // assignable to this one.
+    nonce: Uint8Array | Promise<Uint8Array> | (() => Promise<Uint8Array>)
+  }): Promise<SignedIdentityAttributes>
+  /** Present from `@icp-sdk/auth` v8; used to detect the nonce contract. */
+  memoize?<T>(produce: () => T | Promise<T>): Promise<T>
 }
 
 export interface AuthState {

package/src/createActorHooks.ts

@@ -34,18 +34,18 @@ import {
   UseMutationResult,
   InfiniteData,
 } from "@tanstack/react-query"
-import { useActorQuery } from "./hooks/useActorQuery"
-import { useActorSuspenseQuery } from "./hooks/useActorSuspenseQuery"
-import { useActorInfiniteQuery } from "./hooks/useActorInfiniteQuery"
-import { useActorSuspenseInfiniteQuery } from "./hooks/useActorSuspenseInfiniteQuery"
-import { useActorMutation } from "./hooks/useActorMutation"
+import { useActorQuery } from "./hooks/useActorQuery.js"
+import { useActorSuspenseQuery } from "./hooks/useActorSuspenseQuery.js"
+import { useActorInfiniteQuery } from "./hooks/useActorInfiniteQuery.js"
+import { useActorSuspenseInfiniteQuery } from "./hooks/useActorSuspenseInfiniteQuery.js"
+import { useActorMutation } from "./hooks/useActorMutation.js"
 import {
   useActorMethod,
   UseActorMethodParameters,
-} from "./hooks/useActorMethod"
-import { InfiniteQueryConfig } from "./createInfiniteQuery"
-import { SuspenseInfiniteQueryConfig } from "./createSuspenseInfiniteQuery"
-import { QueryConfig, SuspenseQueryConfig, MutationConfig } from "./types"
+} from "./hooks/useActorMethod.js"
+import { InfiniteQueryConfig } from "./createInfiniteQuery.js"
+import { SuspenseInfiniteQueryConfig } from "./createSuspenseInfiniteQuery.js"
+import { QueryConfig, SuspenseQueryConfig, MutationConfig } from "./types.js"
 
 export type ActorHooks<Service, Transform extends TransformKey> = {
   useActorQuery: {

package/src/createInfiniteQuery.ts

@@ -43,8 +43,8 @@ import {
   InfiniteQueryObserverOptions,
 } from "@tanstack/react-query"
 import { CallConfig } from "@icp-sdk/core/agent"
-import { NoInfer } from "./types"
-import { mergeFactoryQueryKey, normalizeQueryData } from "./utils"
+import { NoInfer } from "./types.js"
+import { mergeFactoryQueryKey, normalizeQueryData } from "./utils.js"
 
 type InfiniteQueryFactoryFn<
   Service,

package/src/createMutation.ts

@@ -39,7 +39,7 @@ import type {
   MutationResult,
   MutationHookOptions,
   NoInfer,
-} from "./types"
+} from "./types.js"
 
 // ============================================================================
 // Internal helpers

package/src/createQuery.ts

@@ -44,8 +44,8 @@ import type {
   QueryResult,
   QueryFactoryConfig,
   NoInfer,
-} from "./types"
-import { buildChainedSelect } from "./utils"
+} from "./types.js"
+import { buildChainedSelect } from "./utils.js"
 
 // ============================================================================
 // Internal Implementation

package/src/createSuspenseInfiniteQuery.ts

@@ -45,8 +45,8 @@ import {
   InfiniteQueryObserverOptions,
 } from "@tanstack/react-query"
 import { CallConfig } from "@icp-sdk/core/agent"
-import { NoInfer } from "./types"
-import { mergeFactoryQueryKey, normalizeQueryData } from "./utils"
+import { NoInfer } from "./types.js"
+import { mergeFactoryQueryKey, normalizeQueryData } from "./utils.js"
 
 type SuspenseInfiniteFactoryCallOptions = {
   queryKey?: QueryKey

package/src/createSuspenseQuery.ts

@@ -34,8 +34,8 @@ import type {
   SuspenseQueryResult,
   SuspenseQueryFactoryConfig,
   NoInfer,
-} from "./types"
-import { buildChainedSelect } from "./utils"
+} from "./types.js"
+import { buildChainedSelect } from "./utils.js"
 
 // ============================================================================
 // Internal Implementation

package/src/defineReactor.ts

@@ -33,8 +33,26 @@
  *   name: "index",
  *   idlFactory: indexIdl,
  *   clientManager: ledger.clientManager,
+ *   authentication: ledger.authentication, // one Internet Identity session
  * })
  * ```
+ *
+ * @example Internet Identity is wired up out of the box
+ * ```typescript
+ * const { useAuth, useIdentityAttributes } = defineReactor<_SERVICE>({
+ *   name: "backend",
+ *   idlFactory,
+ *   // Needed when the app is served from more than one origin.
+ *   auth: { derivationOrigin: "https://app.example.com" },
+ * })
+ *
+ * function LoginButton() {
+ *   const { login, logout, isAuthenticated, principal } = useAuth()
+ *   return isAuthenticated
+ *     ? <button onClick={() => logout()}>{principal?.toText()}</button>
+ *     : <button onClick={() => login()}>Sign in</button>
+ * }
+ * ```
  */
 import { ClientManager, Reactor, DisplayReactor } from "@ic-reactor/core"
 import type {
@@ -45,7 +63,14 @@ import type {
   DisplayReactorParameters,
 } from "@ic-reactor/core"
 import { QueryClient } from "@tanstack/react-query"
-import { createActorHooks, ActorHooks } from "./createActorHooks"
+import { createActorHooks, ActorHooks } from "./createActorHooks.js"
+import { AuthenticationManager } from "./auth/authentication-manager.js"
+import { IdentityAttributesManager } from "./auth/identity-attributes-manager.js"
+import { createIdentityAttributeHooks } from "./auth/createIdentityAttributeHooks.js"
+import type { UseIdentityAttributesReturn } from "./auth/createIdentityAttributeHooks.js"
+import { createAuthHooks } from "./hooks/createAuthHooks.js"
+import type { CreateAuthHooksReturn } from "./hooks/createAuthHooks.js"
+import type { AuthenticationManagerParameters } from "./auth/authentication-manager.js"
 
 /** Options shared by both the standard and display variants of defineReactor. */
 export interface DefineReactorSharedParameters
@@ -55,13 +80,35 @@ export interface DefineReactorSharedParameters
   /**
    * Reuse an existing ClientManager (e.g. to share one agent across canisters).
    * When omitted, a ClientManager is created from the agent options below.
+   *
+   * A supplied or adopted manager brings its own agent and QueryClient, so
+   * `agentOptions` and `queryClient` apply only when this call creates one.
    */
   clientManager?: ClientManager
   /**
-   * Reuse an existing QueryClient. When omitted, the provided ClientManager's
-   * QueryClient is reused, or a new one is created.
+   * QueryClient for a ClientManager created by this call.
+   *
+   * Ignored when `clientManager` or `authentication` is supplied — queries run
+   * against that manager's own QueryClient, which is what is returned.
    */
   queryClient?: QueryClient
+  /**
+   * Reuse an existing AuthenticationManager, so several reactors share one
+   * Internet Identity session. When omitted, one is created for this reactor.
+   *
+   * Its `clientManager` is adopted for this reactor, so sign-in updates the
+   * same agent the reactor calls through. Supplying a different `clientManager`
+   * alongside it is rejected.
+   */
+  authentication?: AuthenticationManager
+  /**
+   * Internet Identity options forwarded to the AuthenticationManager
+   * (`identityProvider`, `derivationOrigin`, `idleOptions`, `storage`, …).
+   *
+   * Mutually exclusive with `authentication`: a manager built elsewhere is
+   * already configured, so these could not be applied to it.
+   */
+  auth?: Omit<AuthenticationManagerParameters, "clientManager">
 }
 
 /** Parameters for a standard (raw Candid types) reactor. */
@@ -83,11 +130,17 @@ export type DefineReactorResult<
   Service,
   Transform extends TransformKey,
   R extends Reactor<Service, Transform>,
-> = ActorHooks<Service, Transform> & {
-  reactor: R
-  clientManager: ClientManager
-  queryClient: QueryClient
-}
+> = ActorHooks<Service, Transform> &
+  CreateAuthHooksReturn & {
+    reactor: R
+    clientManager: ClientManager
+    queryClient: QueryClient
+    /** Internet Identity session manager backing `useAuth`. */
+    authentication: AuthenticationManager
+    /** Signed identity attribute requests backing `useIdentityAttributes`. */
+    identityAttributes: IdentityAttributesManager
+    useIdentityAttributes: () => UseIdentityAttributesReturn
+  }
 
 export function defineReactor<Service = BaseActor>(
   params: DefineDisplayReactorParameters<Service>
@@ -104,6 +157,8 @@ export function defineReactor<Service = BaseActor>(
   const {
     clientManager: providedClientManager,
     queryClient: providedQueryClient,
+    authentication: providedAuthentication,
+    auth,
     display,
     agentOptions,
     name,
@@ -112,18 +167,44 @@ export function defineReactor<Service = BaseActor>(
     pollingOptions,
   } = params as DefineDisplayReactorParameters<Service>
 
-  const queryClient =
-    providedQueryClient ??
-    providedClientManager?.queryClient ??
-    new QueryClient()
+  // A shared AuthenticationManager updates the identity on its own
+  // ClientManager. Giving this reactor a different one would leave its calls
+  // anonymous after sign-in, so adopt the manager's rather than building a new
+  // one, and refuse an explicit mismatch instead of splitting them silently.
+  if (
+    providedClientManager &&
+    providedAuthentication &&
+    providedAuthentication.clientManager !== providedClientManager
+  ) {
+    throw new Error(
+      `[ic-reactor] defineReactor("${name}") received an \`authentication\` manager bound to a different \`clientManager\`. ` +
+        `Sign-in would update the authentication manager's agent while this reactor calls through another one, ` +
+        `leaving its calls anonymous. Pass \`clientManager: authentication.clientManager\`, or omit \`clientManager\` to adopt it.`
+    )
+  }
+
+  // `auth` configures a manager this call would build; an existing one is
+  // already constructed, so these options could only be dropped on the floor.
+  if (providedAuthentication && auth) {
+    throw new Error(
+      `[ic-reactor] defineReactor("${name}") received both \`authentication\` and \`auth\`. ` +
+        `The supplied manager is already configured, so \`auth\` (${Object.keys(auth).join(", ")}) would be ignored. ` +
+        `Pass those options where that AuthenticationManager is created, or drop \`authentication\` to build one here.`
+    )
+  }
 
   const clientManager =
     providedClientManager ??
+    providedAuthentication?.clientManager ??
     new ClientManager({
-      queryClient,
+      queryClient: providedQueryClient ?? new QueryClient(),
       agentOptions,
     })
 
+  // Always report the QueryClient actually in use: when a ClientManager is
+  // supplied or adopted, its own QueryClient is the one queries run against.
+  const queryClient = clientManager.queryClient
+
   const reactorConfig = {
     clientManager,
     name,
@@ -146,5 +227,46 @@ export function defineReactor<Service = BaseActor>(
 
   const hooks = createActorHooks(reactor)
 
-  return { ...hooks, reactor, clientManager, queryClient }
+  // Auth is built on first use. `AuthenticationManager` dynamically imports the
+  // optional `@icp-sdk/auth` peer as soon as it is constructed, and reactors
+  // that never touch authentication should not pay for that.
+  let authenticationInstance: AuthenticationManager | undefined
+  const getAuthentication = () =>
+    (authenticationInstance ??=
+      providedAuthentication ??
+      new AuthenticationManager({ ...auth, clientManager }))
+
+  let identityAttributesInstance: IdentityAttributesManager | undefined
+  const getIdentityAttributes = () =>
+    (identityAttributesInstance ??= new IdentityAttributesManager(
+      getAuthentication()
+    ))
+
+  let authHooks: CreateAuthHooksReturn | undefined
+  const getAuthHooks = () =>
+    (authHooks ??= createAuthHooks(getAuthentication()))
+
+  let attributeHooks:
+    ReturnType<typeof createIdentityAttributeHooks> | undefined
+  const getAttributeHooks = () =>
+    (attributeHooks ??= createIdentityAttributeHooks(getIdentityAttributes()))
+
+  return {
+    ...hooks,
+    reactor,
+    clientManager,
+    queryClient,
+    // Stable wrappers: the hook call order inside them never changes, so the
+    // rules of hooks still hold.
+    useAuth: () => getAuthHooks().useAuth(),
+    useAgentState: () => getAuthHooks().useAgentState(),
+    useUserPrincipal: () => getAuthHooks().useUserPrincipal(),
+    useIdentityAttributes: () => getAttributeHooks().useIdentityAttributes(),
+    get authentication() {
+      return getAuthentication()
+    },
+    get identityAttributes() {
+      return getIdentityAttributes()
+    },
+  }
 }

package/src/hooks/createAuthHooks.ts

@@ -1,6 +1,6 @@
 import { useSyncExternalStore, useEffect, useRef, useMemo } from "react"
-import type { AuthenticationManager } from "../auth/authentication-manager"
-import type { AuthState, AuthenticationSignInOptions } from "../auth/types"
+import type { AuthenticationManager } from "../auth/authentication-manager.js"
+import type { AuthState, AuthenticationSignInOptions } from "../auth/types.js"
 import type { AgentState } from "@ic-reactor/core"
 import type { Principal } from "@icp-sdk/core/principal"
 import type { Identity } from "@icp-sdk/core/agent"
@@ -90,7 +90,9 @@ export const createAuthHooks = (
     // Track if we've already initialized to avoid duplicate calls
     const initializedRef = useRef(false)
 
-    // Auto-initialize on first mount to restore previous session
+    // Auto-initialize on first mount to restore previous session.
+    // `prepareClient` also warms up the AuthClient so a later `login()` can
+    // open the identity provider window inside the click handler.
     useEffect(() => {
       if (!initializedRef.current) {
         initializedRef.current = true
@@ -99,6 +101,9 @@ export const createAuthHooks = (
           .catch(() => undefined)
           .then(() => clientManager.initialize())
           .then(() => authentication.authenticate())
+          // Failures are already reflected in authState/agentState; without
+          // this the rejection escapes as an unhandled promise rejection.
+          .catch(() => undefined)
       }
     }, [])
 

package/src/hooks/useActorInfiniteQuery.ts

@@ -16,7 +16,7 @@ import {
   ReactorReturnErr,
 } from "@ic-reactor/core"
 import { CallConfig } from "@icp-sdk/core/agent"
-import { normalizeQueryData } from "../utils"
+import { normalizeQueryData } from "../utils.js"
 
 /**
  * Parameters for useActorInfiniteQuery hook.

package/src/hooks/useActorSuspenseInfiniteQuery.ts

@@ -16,7 +16,7 @@ import {
   ReactorReturnErr,
 } from "@ic-reactor/core"
 import { CallConfig } from "@icp-sdk/core/agent"
-import { normalizeQueryData } from "../utils"
+import { normalizeQueryData } from "../utils.js"
 
 /**
  * Parameters for useActorSuspenseInfiniteQuery hook.

package/src/index.ts

@@ -3,21 +3,21 @@
 export * from "@ic-reactor/core"
 
 // Re-export hooks
-export * from "./hooks"
+export * from "./hooks/index.js"
 
 // Validation utilities for React
-export * from "./validation"
+export * from "./validation.js"
 
 // React-specific exports
-export * from "./createActorHooks"
-export * from "./defineReactor"
+export * from "./createActorHooks.js"
+export * from "./defineReactor.js"
 
-export * from "./createQuery"
-export * from "./createSuspenseQuery"
-export * from "./createInfiniteQuery"
-export * from "./createSuspenseInfiniteQuery"
-export * from "./createMutation"
+export * from "./createQuery.js"
+export * from "./createSuspenseQuery.js"
+export * from "./createInfiniteQuery.js"
+export * from "./createSuspenseInfiniteQuery.js"
+export * from "./createMutation.js"
 
-export * from "./auth"
+export * from "./auth/index.js"
 
-export * from "./types"
+export * from "./types.js"

package/src/defineReactor.test.ts

@@ -1,70 +0,0 @@
-import { describe, it, expect } from "vitest"
-import { ClientManager, Reactor, DisplayReactor } from "@ic-reactor/core"
-import { QueryClient } from "@tanstack/react-query"
-import { defineReactor } from "./defineReactor"
-import { ActorMethod } from "@icp-sdk/core/agent"
-
-const idlFactory = ({ IDL }: any) =>
-  IDL.Service({
-    greet: IDL.Func([IDL.Text], [IDL.Text], ["query"]),
-  })
-
-interface TestActor {
-  greet: ActorMethod<[string], string>
-}
-
-const baseConfig = {
-  name: "test",
-  idlFactory,
-  canisterId: "rrkah-fqaaa-aaaaa-aaaaq-cai",
-}
-
-describe("defineReactor", () => {
-  it("bootstraps a standard Reactor with hooks and infrastructure", () => {
-    const result = defineReactor<TestActor>(baseConfig)
-
-    expect(result.reactor).toBeInstanceOf(Reactor)
-    expect(result.reactor).not.toBeInstanceOf(DisplayReactor)
-    expect(result.clientManager).toBeInstanceOf(ClientManager)
-    expect(result.queryClient).toBeInstanceOf(QueryClient)
-    expect(typeof result.useActorQuery).toBe("function")
-    expect(typeof result.useActorMutation).toBe("function")
-  })
-
-  it("creates a DisplayReactor when display is true", () => {
-    const result = defineReactor<TestActor>({ ...baseConfig, display: true })
-
-    expect(result.reactor).toBeInstanceOf(DisplayReactor)
-  })
-
-  it("wires the reactor to the created ClientManager and QueryClient", () => {
-    const { reactor, clientManager, queryClient } =
-      defineReactor<TestActor>(baseConfig)
-
-    expect(reactor.clientManager).toBe(clientManager)
-    expect(clientManager.queryClient).toBe(queryClient)
-  })
-
-  it("reuses an existing ClientManager and its QueryClient", () => {
-    const queryClient = new QueryClient()
-    const clientManager = new ClientManager({ queryClient })
-
-    const result = defineReactor<TestActor>({ ...baseConfig, clientManager })
-
-    expect(result.clientManager).toBe(clientManager)
-    expect(result.queryClient).toBe(queryClient)
-    expect(result.reactor.clientManager).toBe(clientManager)
-  })
-
-  it("lets multiple reactors share one ClientManager", () => {
-    const ledger = defineReactor<TestActor>({ ...baseConfig, name: "ledger" })
-    const index = defineReactor<TestActor>({
-      ...baseConfig,
-      name: "index",
-      clientManager: ledger.clientManager,
-    })
-
-    expect(index.clientManager).toBe(ledger.clientManager)
-    expect(index.reactor).not.toBe(ledger.reactor)
-  })
-})