@icp-sdk/auth 10.0.1 → 11.0.0

package/README.md

@@ -7,146 +7,32 @@ Authentication library for Internet Computer web apps.
 
 > Still using `@dfinity/auth-client`? Migrate to [`@icp-sdk/auth`](https://js.icp.build/auth/latest/upgrading/v4)!
 
----
-
 ## Installation
 
-You can install the `@icp-sdk/auth` package with your package manager of choice:
-
-### npm
-
-```shell
-npm install @icp-sdk/auth
-```
-
-### pnpm
-
-```shell
-pnpm add @icp-sdk/auth
-```
-
-### yarn
-
 ```shell
-yarn add @icp-sdk/auth
+npm install @icp-sdk/auth @icp-sdk/core
 ```
 
-> Note: this package is only meant to be used in **browser** environments.
-
-## Usage Example
+This package is only meant to be used in **browser** environments.
 
-Here's a simple example of how to use the `@icp-sdk/auth` package to authenticate a user with Internet Identity on an Internet Computer web app:
+## Usage
 
 ```typescript
 import { AuthClient } from '@icp-sdk/auth/client';
 
 const authClient = new AuthClient();
 
-// restore an existing session if there is one, otherwise sign in
-let identity;
-try {
-  identity = authClient.isAuthenticated()
-    ? await authClient.getIdentity()
-    : await authClient.signIn();
-} catch (error) {
-  console.error('Sign-in failed:', error);
-  throw error;
-}
+await authClient.signIn();
+const identity = await authClient.getIdentity();
+console.log('Signed in as', identity.getPrincipal().toText());
 
-console.log('Identity:', identity.getPrincipal().toString());
-
-// later, to end the session
 await authClient.signOut();
 ```
 
-### One-Click OpenID Sign-In
-
-Skip the Internet Identity authentication method screen and offer sign-in options like Google directly in your app:
-
-```typescript
-const authClient = new AuthClient({
-  openIdProvider: 'google', // or 'apple' or 'microsoft'
-});
-```
-
-### Requesting Identity Attributes
-
-Internet Identity can provide signed identity attributes (e.g., email) alongside authentication. Your backend canister initiates the flow by issuing a nonce tied to the action — this way, even if an attribute bundle is intercepted, it can't be replayed or used for a different action.
-
-Here's a registration flow where the backend needs the user's email:
-
-```typescript
-import { AuthClient } from '@icp-sdk/auth/client';
-import { AttributesIdentity } from '@icp-sdk/core/identity';
-import { HttpAgent, Actor } from '@icp-sdk/core/agent';
-import { Principal } from '@icp-sdk/core/principal';
-
-const authClient = new AuthClient();
-
-// the backend issues a nonce scoped to registration —
-// this starts the action and binds the upcoming attributes to it
-const anonymousAgent = await HttpAgent.create();
-const backend = Actor.createActor(backendIdl, { agent: anonymousAgent, canisterId });
-const nonce: Uint8Array = await backend.registerBegin();
-
-// sign-in and attribute request happen in parallel — the user sees a single II interaction
-try {
-  const signInPromise = authClient.signIn();
-  const attributesPromise = authClient.requestAttributes({ keys: ['email'], nonce });
-
-  const identity = await signInPromise;
-  const { data, signature } = await attributesPromise;
-
-  // wrap the identity so the signed attributes are included in the canister call
-  const identityWithAttributes = new AttributesIdentity({
-    inner: identity,
-    attributes: { data, signature },
-    signer: { canisterId: Principal.fromText('rdmx6-jaaaa-aaaaa-aaadq-cai') }, // Internet Identity canister ID
-  });
-  const agent = await HttpAgent.create({ identity: identityWithAttributes });
-  const app = Actor.createActor(appIdl, { agent, canisterId });
-
-  // the backend verifies the nonce, origin, and timestamp, then extracts the email
-  await app.registerFinish();
-} catch (error) {
-  console.error('Registration failed:', error);
-}
-```
-
-The signed attribute bundle includes implicit fields that your backend canister should verify:
-
-- **`implicit:nonce`** — ties the attributes to a specific canister-initiated action, preventing replay and cross-action reuse. Must originate from the backend, not the frontend.
-- **`implicit:origin`** — the requesting origin, verified by the canister to prevent a malicious dapp from forwarding attribute bundles to your backend.
-- **`implicit:issued_at_timestamp_ns`** — issuance timestamp, allowing the canister to reject stale attributes even if the nonce hasn't expired yet.
-
-> Attributes can also be requested after sign-in — for example, when a user later triggers an action like linking an email. The flow is the same: the backend issues a nonce for that action, the frontend calls `requestAttributes`, and the backend verifies the result.
-
-#### OpenID-Scoped Attributes
-
-When using one-click sign-in, attributes can be scoped to the OpenID provider. Scoped attributes have implicit consent — the user authenticates and shares attributes in a single step without an additional prompt:
-
-```typescript
-import { AuthClient, scopedKeys } from '@icp-sdk/auth/client';
-
-const authClient = new AuthClient({
-  openIdProvider: 'google',
-});
-
-const nonce: Uint8Array = await backend.registerBegin();
-const signInPromise = authClient.signIn();
-// requests name, email, and verified_email from the
-// Google account linked to the user's Internet Identity
-const attributesPromise = authClient.requestAttributes({
-  keys: scopedKeys({ openIdProvider: 'google' }),
-  nonce,
-});
-
-await signInPromise;
-const { data, signature } = await attributesPromise;
-// ... wrap with AttributesIdentity and complete the action as above
-```
+## Documentation
 
-Additional documentation can be found [here](https://js.icp.build/auth/latest/).
+- [Guides](https://docs.internetcomputer.org/guides/authentication/internet-identity/): project setup, identity attributes, one-click sign-in, enterprise SSO, and shared sessions across subdomains.
+- [API reference and upgrade guides](https://js.icp.build/auth/latest/).
 
 ## Contributing
 

package/dist/esm/client/auth-client.d.ts

@@ -1,6 +1,7 @@
 import { type HttpAgentOptions, type Identity } from '@icp-sdk/core/agent';
 import { Principal } from '@icp-sdk/core/principal';
 import type { CredentialStorage } from './credential-storage.js';
+import { type SsoStatus } from './sso-status.js';
 import { type StateStorage } from './state-storage.js';
 export type OpenIdProvider = 'google' | 'apple' | 'microsoft';
 export declare const OPENID_PROVIDER_URLS: {
@@ -175,8 +176,17 @@ export type AuthClientCreateOptions = AuthClientBaseOptions & ({
      * When set, the identity provider URL includes an `sso` search param so
      * the user authenticates via that organization's own provider.
      *
-     * A value that is not a domain with an optional port throws. Use
-     * {@link isValidSsoDomain} to check a domain the user typed.
+     * The value is trimmed, lowercased and IDNA-encoded, and has to be a
+     * domain and nothing else: no scheme, port, path, query, fragment or
+     * userinfo. A loopback host (`localhost`, `127.0.0.1`, or a name under
+     * `.localhost`) is accepted too, with a port, for a local mock provider.
+     *
+     * The client checks the domain with Internet Identity as soon as it is
+     * built, and {@link AuthClient.getSsoStatus} reports the answer. A value
+     * that is not a domain is reported as `invalid`, with the reason, rather
+     * than thrown, so a
+     * client can be built from whatever the user typed; a sign-in with it
+     * opens Internet Identity, which explains the error on its own screen.
      */
     ssoDomain?: string;
 });
@@ -322,29 +332,65 @@ export declare class AuthClient {
      */
     getStatus(): SessionStatus;
     /**
-     * Watches who is signed in here, and returns a function that stops watching.
+     * Whether the organization domain this client was built with can be signed
+     * in with, or `undefined` for a client built without `ssoDomain`.
+     *
+     * Synchronous, and the same object until the answer changes, like
+     * {@link getStatus}; {@link subscribe} says when to read it again. A client
+     * built with `ssoDomain` starts checking as soon as it is built: it asks
+     * Internet Identity to resolve the domain, then reads the result
+     * until it is final, so `checking` lasts until Internet Identity answers.
+     * Building the client also warms Internet Identity's cache for the domain, so
+     * a sign-in that follows starts without waiting on the fetch.
+     *
+     * {@link signIn} proceeds in every state: Internet Identity resolves the
+     * domain itself during the sign-in, and explains a failure, a value that is
+     * not a domain included, on its own screen.
+     *
+     * @example
+     * const client = new AuthClient({ ssoDomain: input.value });
+     * client.subscribe(() => render(client.getSsoStatus()));
+     * render(client.getSsoStatus());
+     */
+    getSsoStatus(): SsoStatus | undefined;
+    /**
+     * Checks the organization domain again, for a "Try again" button.
+     *
+     * The status goes back to `checking` and then to the new answer. Calling it
+     * while an `unavailable` answer's `retryAfter` is still in the future is
+     * harmless: Internet Identity does not fetch again before then, so the answer
+     * comes back the same at once. Nothing re-checks on its own once `retryAfter`
+     * passes. Does nothing for an `invalid` domain, which no retry can fix, or for
+     * a client built without `ssoDomain`.
+     */
+    refreshSsoStatus(): void;
+    /**
+     * Watches who is signed in here, and the SSO status of a client built with
+     * `ssoDomain`, and returns a function that stops watching.
      *
-     * `getStatus()` and the predicates beside it are snapshots, so an application
-     * rendering on them needs to be told when to read again. The record changes
-     * for reasons that are nothing to do with this client — another tab signing
-     * out, a sibling subdomain publishing a sign-in, a peer client on this page
-     * re-issuing silently — and this is how those arrive.
+     * `getStatus()`, `getSsoStatus()` and the predicates beside them are
+     * snapshots, so an application rendering on them needs to be told when to read
+     * again. The record changes for reasons that are nothing to do with this
+     * client: another tab signing out, a sibling subdomain publishing a sign-in,
+     * a peer client on this page re-issuing silently. The SSO status changes when
+     * Internet Identity answers. This is how both arrive.
      *
-     * Fired once the record is readable, so a listener asking who is signed in
-     * sees what it was told about. It says that something changed and not what: a
-     * listener reads the answer it wants, which for most is `getStatus()`.
+     * Fired once the new answer is readable, so a listener sees what it was told
+     * about. It says that something changed and not what: a listener reads the
+     * answer it wants, `getStatus()` or `getSsoStatus()`.
      *
      * What it does not cover is the identity being replaced under an application
      * that holds one — an app delegation rotating is deliberately invisible, and
      * nothing about who is signed in has changed when it does.
-     * @param listener - Called after the record changes.
+     * @param listener - Called after the record or the SSO status changes.
      * @returns A function that unregisters it.
      */
     subscribe(listener: () => void): () => void;
     /**
      * Releases what this client hooked: the browser listeners, the state
-     * subscription, and the refresh the identity has scheduled. Call it when
-     * discarding a client, so nothing it registered outlives it.
+     * subscription, the refresh the identity has scheduled, and an SSO domain
+     * check still in progress. Call it when discarding a client, so nothing it
+     * registered outlives it.
      */
     dispose(): void;
     signIn(options?: AuthClientSignInOptions): Promise<Identity>;
@@ -360,9 +406,10 @@ export declare class AuthClient {
      *
      * In 'window' mode the callback lets the identity provider window open while the
      * nonce is still resolving, avoiding a perceived delay before the user sees
-     * the prompt; auto-close of the signer transport channel is temporarily
-     * disabled while awaiting so the window cannot be closed out from under the
-     * pending flow.
+     * the prompt; the signer keeps the channel open while the request waits for
+     * its nonce. In both modes the request takes its place with the signer when
+     * this method is called, so it can be issued alongside `signIn` in either
+     * order.
      *
      * @param params - Request parameters.
      * @param params.keys - Attribute keys to request (e.g. `['email', 'name']`).

package/dist/esm/client/auth-client.js

@@ -13,6 +13,7 @@ import { SessionIdentity } from './session-identity.js';
 import { SessionMinter } from './session-minter.js';
 import { slotsFor } from './slots.js';
 import { normalizeSsoDomain } from './sso.js';
+import { createSsoDomainService, SsoStatusChecker } from './sso-status.js';
 import { LocalStateStorage } from './state-storage.js';
 /**
  * The lock one signer interaction at a time holds.
@@ -111,6 +112,8 @@ export class AuthClient {
     // interaction rather than two.
     #interactions = 0;
     #channelLock;
+    // Set only for a client built with `ssoDomain`.
+    #sso;
     constructor(options = {}) {
         this.#options = options;
         this.#credentialStorage = options.credentialStorage ?? new IdbCredentialStorage();
@@ -182,12 +185,26 @@ export class AuthClient {
             identityProviderUrl.searchParams.set('openid', OPENID_PROVIDER_URLS[options.openIdProvider]);
         }
         if (options.ssoDomain !== undefined) {
-            identityProviderUrl.searchParams.set('sso', normalizeSsoDomain(options.ssoDomain));
+            let domain;
+            try {
+                domain = normalizeSsoDomain(options.ssoDomain);
+            }
+            catch (error) {
+                domain = { invalid: error instanceof Error ? error.message : String(error) };
+            }
+            // A value that is not a domain goes to Internet Identity as typed, which
+            // explains it on its own screen.
+            identityProviderUrl.searchParams.set('sso', typeof domain === 'string' ? domain : options.ssoDomain.trim());
             // The SSO ceremony starts before a delegation is requested, so the
             // channel carries the derivation origin too late to resolve the client.
             if (options.derivationOrigin !== undefined) {
                 identityProviderUrl.searchParams.set('derivationOrigin', options.derivationOrigin.toString());
             }
+            const canisterId = this.#canisterId;
+            this.#sso = new SsoStatusChecker(domain, () => createSsoDomainService({ canisterId, agentOptions: options.agentOptions }), () => {
+                for (const listener of [...this.#listeners])
+                    listener();
+            });
         }
         // `prompt` and `hint` are Internet Identity extensions, so they ride on the
         // authorize URL rather than in the ICRC request. Baking them in here, as
@@ -321,6 +338,43 @@ export class AuthClient {
         }
         return this.#status;
     }
+    /**
+     * Whether the organization domain this client was built with can be signed
+     * in with, or `undefined` for a client built without `ssoDomain`.
+     *
+     * Synchronous, and the same object until the answer changes, like
+     * {@link getStatus}; {@link subscribe} says when to read it again. A client
+     * built with `ssoDomain` starts checking as soon as it is built: it asks
+     * Internet Identity to resolve the domain, then reads the result
+     * until it is final, so `checking` lasts until Internet Identity answers.
+     * Building the client also warms Internet Identity's cache for the domain, so
+     * a sign-in that follows starts without waiting on the fetch.
+     *
+     * {@link signIn} proceeds in every state: Internet Identity resolves the
+     * domain itself during the sign-in, and explains a failure, a value that is
+     * not a domain included, on its own screen.
+     *
+     * @example
+     * const client = new AuthClient({ ssoDomain: input.value });
+     * client.subscribe(() => render(client.getSsoStatus()));
+     * render(client.getSsoStatus());
+     */
+    getSsoStatus() {
+        return this.#sso?.status;
+    }
+    /**
+     * Checks the organization domain again, for a "Try again" button.
+     *
+     * The status goes back to `checking` and then to the new answer. Calling it
+     * while an `unavailable` answer's `retryAfter` is still in the future is
+     * harmless: Internet Identity does not fetch again before then, so the answer
+     * comes back the same at once. Nothing re-checks on its own once `retryAfter`
+     * passes. Does nothing for an `invalid` domain, which no retry can fix, or for
+     * a client built without `ssoDomain`.
+     */
+    refreshSsoStatus() {
+        this.#sso?.refresh();
+    }
     /** Reads the record and builds the answer `getStatus` hands out. */
     #readStatus() {
         const record = this.#stateStorage.get(this.#slots.state);
@@ -336,22 +390,24 @@ export class AuthClient {
             : { state: 'signed-in-elsewhere', principal, expiresAtMs };
     }
     /**
-     * Watches who is signed in here, and returns a function that stops watching.
+     * Watches who is signed in here, and the SSO status of a client built with
+     * `ssoDomain`, and returns a function that stops watching.
      *
-     * `getStatus()` and the predicates beside it are snapshots, so an application
-     * rendering on them needs to be told when to read again. The record changes
-     * for reasons that are nothing to do with this client — another tab signing
-     * out, a sibling subdomain publishing a sign-in, a peer client on this page
-     * re-issuing silently — and this is how those arrive.
+     * `getStatus()`, `getSsoStatus()` and the predicates beside them are
+     * snapshots, so an application rendering on them needs to be told when to read
+     * again. The record changes for reasons that are nothing to do with this
+     * client: another tab signing out, a sibling subdomain publishing a sign-in,
+     * a peer client on this page re-issuing silently. The SSO status changes when
+     * Internet Identity answers. This is how both arrive.
      *
-     * Fired once the record is readable, so a listener asking who is signed in
-     * sees what it was told about. It says that something changed and not what: a
-     * listener reads the answer it wants, which for most is `getStatus()`.
+     * Fired once the new answer is readable, so a listener sees what it was told
+     * about. It says that something changed and not what: a listener reads the
+     * answer it wants, `getStatus()` or `getSsoStatus()`.
      *
      * What it does not cover is the identity being replaced under an application
      * that holds one — an app delegation rotating is deliberately invisible, and
      * nothing about who is signed in has changed when it does.
-     * @param listener - Called after the record changes.
+     * @param listener - Called after the record or the SSO status changes.
      * @returns A function that unregisters it.
      */
     subscribe(listener) {
@@ -365,10 +421,12 @@ export class AuthClient {
     }
     /**
      * Releases what this client hooked: the browser listeners, the state
-     * subscription, and the refresh the identity has scheduled. Call it when
-     * discarding a client, so nothing it registered outlives it.
+     * subscription, the refresh the identity has scheduled, and an SSO domain
+     * check still in progress. Call it when discarding a client, so nothing it
+     * registered outlives it.
      */
     dispose() {
+        this.#sso?.dispose();
         // Recorded, because the constructor starts the restore without awaiting it:
         // a client disposed while one is in flight would otherwise have an identity
         // installed afterwards, scheduling refreshes nobody can stop.
@@ -438,18 +496,14 @@ export class AuthClient {
         this.#interactions += 1;
     }
     /**
-     * Opens the signer channel and takes the lock that makes this the only
-     * interaction on it.
+     * Takes the lock that makes this the only interaction on the signer channel.
      *
-     * One method because the order is the whole point. A popup may only be opened
-     * from the task the click started, so nothing may be asked of the browser
-     * before `openChannel` — two lock requests in front of it were enough for
-     * Chromium to refuse the window — and the lock has to be taken as soon as it
-     * is open. Two callers doing that by hand is one place too many for the order
-     * to come out backwards.
+     * Called right after a request is handed to the signer, which opens the
+     * channel within that call: a popup may only be opened from the task the
+     * click started, and lock requests in front of it were enough for Chromium to
+     * refuse the window, so the lock is asked for once the window exists.
      */
-    async #openSignerChannel() {
-        await this.#signer.openChannel();
+    #takeChannelLock() {
         if (this.#channelLock === undefined) {
             const lock = stealLock(CHANNEL_LOCK);
             // Whoever took the channel has already renavigated the window this one was
@@ -519,14 +573,11 @@ export class AuthClient {
         // carry across the round trip for the return leg to trust.
         const raw = options?.returnTo;
         const returnTo = raw === undefined ? undefined : this.memoize(() => sameOriginTarget(raw)?.href ?? null);
-        // Start session-key acquisition BEFORE opening the channel, awaiting it only
-        // after. In the redirect flow the acquisition's first `transport.memoize`
-        // runs synchronously when invoked, so its in-flight bump lands in the same
-        // tick `signIn` is called — holding the transport's batch flush from the
-        // very start of the flow rather than only after the `openChannel` await.
-        // Under `Promise.all([signIn, requestAttributes])` this is what keeps a
-        // faster concurrent request from flushing before this flow's delegation
-        // request is buffered.
+        // Session-key acquisition starts on the call, and the delegation request
+        // that needs it is handed to the signer on the call too, as a promise of the
+        // request. The signer places it in call order there, so in the redirect
+        // flow it replays into the slot it was sent from whatever the key costs on
+        // either load, and a `requestAttributes` issued alongside keeps its own.
         const sessionKeyPromise = this.#urlTransport
             ? this.#ensureSessionKeyForRedirectFlow(this.#urlTransport)
             : this.#ensureSessionKeyForWindowFlow().then((key) => ({ key }));
@@ -536,9 +587,21 @@ export class AuthClient {
         // surfacing as an unhandled rejection. The `await` below still observes a
         // rejection and propagates it when reached.
         void sessionKeyPromise.catch(() => undefined);
-        // Must stay the first await: it opens the signer window, which the browser
-        // allows only in the tick the click started.
-        await this.#openSignerChannel();
+        // Opens the signer window within the call, which the browser allows only in
+        // the tick the click started, so nothing before it may ask the browser for
+        // anything.
+        const sessionChainPromise = requestSessionDelegation(this.#signer, sessionKeyPromise.then(({ key }) => ({
+            sessionPublicKey: key.getPublicKey().toDer(),
+            // Both bounds are sent only where the caller asked, so the provider's
+            // own defaults apply otherwise rather than numbers this library
+            // invented. How long a sign-in lasts is the provider's policy, narrowed
+            // by what the user chooses at consent and by an organization's cap.
+            maxTimeToLive: options?.maxTimeToLive,
+            maxTimeToIdle: options?.maxTimeToIdle,
+            derivationOrigin: this.#options.derivationOrigin?.toString(),
+        })));
+        void sessionChainPromise.catch(() => undefined);
+        this.#takeChannelLock();
         // The other lock a ceremony needs, taken once the window is open for the
         // same reason. Stolen rather than queued for, so the newer intent wins and
         // the loser learns of it before writing anything.
@@ -570,16 +633,7 @@ export class AuthClient {
                 // an identity whose first request fails for a reason nothing explains.
                 throw new Error('A session needs a key that can sign');
             }
-            const sessionChain = await requestSessionDelegation(this.#signer, {
-                sessionPublicKey: key.getPublicKey().toDer(),
-                // Both bounds are sent only where the caller asked, so the provider's
-                // own defaults apply otherwise rather than numbers this library
-                // invented. How long a sign-in lasts is the provider's policy, narrowed
-                // by what the user chooses at consent and by an organization's cap.
-                maxTimeToLive: options?.maxTimeToLive,
-                maxTimeToIdle: options?.maxTimeToIdle,
-                derivationOrigin: this.#options.derivationOrigin?.toString(),
-            });
+            const sessionChain = await sessionChainPromise;
             // The chain comes from the signer over a transport shared with others, so
             // the key it delegates to is checked here rather than assumed. A chain for
             // another key mints nothing, and failing now names the cause instead of
@@ -667,21 +721,10 @@ export class AuthClient {
         if (!this.#credentialStorage.durable) {
             throw new Error('A redirect sign-in needs a credential store that survives the navigation, and this one does not. Use a durable store or the window transport.');
         }
-        // Acquire the key inside a `memoize` producer so the transport holds its
-        // batch flush across the (async) key read/create + storage write. The
-        // transport coalesces concurrently issued requests into one redirect by
-        // flushing on a macrotask once no memoize producer is in flight; without
-        // this hold, a faster concurrent request (e.g. the nonce path of
-        // `requestAttributes`) buffers first and trips that flush before this flow's
-        // delegation request — issued only once the key is ready — is buffered,
-        // splitting what should be one redirect into two.
-        //
-        // The key is captured in a closure, not read back after the producer: on the
-        // FIRST load the producer sets `acquired`, so the delegation request that
-        // follows is issued with no intervening storage read — a read there would
-        // re-open the very flush gap this closes. The producer is skipped on the
-        // replay load (its result is journaled), where the key is instead read from
-        // the pending slot.
+        // Acquired inside a `memoize` producer, so the first load journals which key
+        // this ceremony started with. The key is captured in a closure on the first
+        // load, where the producer runs; on the replay load the producer is skipped
+        // (its result is journaled) and the key is read from the pending slot.
         //
         // What is journaled is the key's *public* half: not a secret, it survives the
         // redirect as text, and on the return load it says whether the pending slot
@@ -720,9 +763,10 @@ export class AuthClient {
      *
      * In 'window' mode the callback lets the identity provider window open while the
      * nonce is still resolving, avoiding a perceived delay before the user sees
-     * the prompt; auto-close of the signer transport channel is temporarily
-     * disabled while awaiting so the window cannot be closed out from under the
-     * pending flow.
+     * the prompt; the signer keeps the channel open while the request waits for
+     * its nonce. In both modes the request takes its place with the signer when
+     * this method is called, so it can be issued alongside `signIn` in either
+     * order.
      *
      * @param params - Request parameters.
      * @param params.keys - Attribute keys to request (e.g. `['email', 'name']`).
@@ -746,15 +790,21 @@ export class AuthClient {
     async #runRequestAttributes(params) {
         // In redirect mode the nonce is journaled (base64, since the journal is
         // JSON) so the replay on the return load signs against the same bytes.
-        const nonceBytes = this.#urlTransport
-            ? fromBase64(await this.#urlTransport.memoize(async () => toBase64(await params.nonce())))
-            : await this.#resolveNonce(params.nonce);
-        const response = await this.#signer.sendRequest({
+        const nonce = this.#urlTransport
+            ? this.#urlTransport.memoize(async () => toBase64(await params.nonce()))
+            : params.nonce().then(toBase64);
+        // Handed to the signer on the call, as a promise of the request: the signer
+        // window opens within the call while the nonce is still on its way, and the
+        // request keeps its place in call order however long the nonce takes on
+        // either load of a redirect flow.
+        const responsePromise = this.#signer.sendRequest(nonce.then((value) => ({
             jsonrpc: '2.0',
             id: globalThis.crypto.randomUUID(),
             method: 'ii-icrc3-attributes',
-            params: { keys: params.keys, nonce: toBase64(nonceBytes) },
-        });
+            params: { keys: params.keys, nonce: value },
+        })));
+        this.#takeChannelLock();
+        const response = await responsePromise;
         if ('error' in response) {
             throw new Error(response.error.message);
         }
@@ -835,24 +885,6 @@ export class AuthClient {
             }
         }
     }
-    // Popup-mode nonce resolution. Start the fetch, then open the transport
-    // channel so the identity provider window is visible while we wait, and
-    // suspend auto-close so it can't fire mid-await (e.g. due to a close
-    // scheduled by a prior request on the same signer). The original auto-close
-    // setting is restored before sendRequest, so the next response resumes
-    // normal close behaviour.
-    async #resolveNonce(nonce) {
-        const value = nonce();
-        await this.#openSignerChannel();
-        const previousAutoClose = this.#signer.autoCloseTransportChannel;
-        this.#signer.autoCloseTransportChannel = false;
-        try {
-            return await value;
-        }
-        finally {
-            this.#signer.autoCloseTransportChannel = previousAutoClose;
-        }
-    }
     /**
      * Mints ahead of the next request when the page comes back, if one is due.
      *