@coderoftime/fints 0.2.0 → 0.3.0

package/src/session/dialog-runner.ts

@@ -9,6 +9,13 @@ import type { SignedDialog } from './signed-dialog.js';
 /** Most pages the client fetches for one query, far more than banks send. */
 const maxPages = 1000;
 
+/**
+ * Most further pages of one query that may ask for an approval, as its first page may: enough for a bank that asks anew
+ * for each page of a query of four pages, while the user approves four times per query at most, and loses the pages
+ * approved so far with any approval they cancel.
+ */
+const maxPageApprovals = 3;
+
 /**
  * Most data one query may hold, summed over its pages as `IncomingMessage3.size` measures it: the transport and the
  * parser bound a single response only. The statements and transactions read from them have a budget of their own
@@ -70,20 +77,27 @@ export class DialogRunner {
     return parseBankData(() => query.read(pages));
   }
 
-  /** Sends `order` in `dialog` and completes its approval, which only the `firstPage` of a query may ask for. */
-  private async run(dialog: SignedDialog, order: SegmentSpec, firstPage: boolean): Promise<IncomingMessage3> {
+  /** Sends `order` in `dialog` and completes its approval, which `admitApproval` may refuse (`SignedDialog.send`). */
+  private async run(
+    dialog: SignedDialog,
+    order: SegmentSpec,
+    admitApproval: (() => void) | undefined,
+  ): Promise<IncomingMessage3> {
     try {
-      return firstPage ? await dialog.send(order) : await dialog.sendFurtherPage(order);
+      return await dialog.send(order, admitApproval);
     } catch (error) {
       // The bank rejected the order and the dialog stays usable, or the bank ended the dialog or rejected the PIN and
-      // the dialog is discarded already. A cancelled or failed approval, or a broken connection, leaves the dialog in an
-      // unknown state.
+      // the dialog is discarded already. A cancelled, failed or refused approval, or a broken connection, leaves the
+      // dialog in an unknown state.
       if (!(error instanceof FinTsBankError)) await this.end();
       throw error;
     }
   }
 
-  /** Sends the order built by `order` until the bank has delivered all pages (Formals B.6.3, "Aufsetzpunkt"). */
+  /**
+   * Sends the order built by `order` until the bank has delivered all pages (Formals B.6.3, "Aufsetzpunkt"), and
+   * completes the approval each asks for, that of `maxPageApprovals` further pages at most.
+   */
   private async fetchPages(
     dialog: SignedDialog,
     order: (continuation: string | undefined) => SegmentSpec,
@@ -91,9 +105,22 @@ export class DialogRunner {
     const pages: IncomingMessage3[] = [];
     const seen = new Set<string>();
     let size = 0;
+    let pageApprovals = 0;
+    const admitPageApproval = (): void => {
+      if (pageApprovals === maxPageApprovals) {
+        throw new FinTsProtocolError(
+          `The bank asks for an approval of more than ${maxPageApprovals} further pages of one query; ask for a shorter period`,
+        );
+      }
+      pageApprovals++;
+    };
     let continuation: string | undefined;
     for (;;) {
-      const page = await this.run(dialog, order(continuation), continuation === undefined);
+      const page = await this.run(
+        dialog,
+        order(continuation),
+        continuation === undefined ? undefined : admitPageApproval,
+      );
       pages.push(page);
       size += page.size;
       if (size > maxQueryMebibytes * 1024 * 1024) {

package/src/session/login-guard.ts

@@ -42,9 +42,9 @@ const maxUnreadLogins = 2;
  * access. `FinTsLoginRefusedError` tells which logins count as refused; `judge` decides it for each answer.
  *
  * A refusal counts at once and fails closed: only `remedied` lifts it, within the call that met it (`runCall`), once
- * the session has taken care of a reason it names, each reason once per call, so that a call sends at most three
- * logins the bank refuses. A refusal that outlasts the call is final, and the guard forgets the PIN; only a PIN the
- * user enters anew lifts it (`replacePin`), unless it brings new login data.
+ * the session has taken care of a reason it names, or has failed the call trying, each reason once per call, so that a
+ * call sends at most three logins the bank refuses. A refusal that outlasts the call is final, and the guard forgets
+ * the PIN; only a PIN the user enters anew lifts it (`replacePin`), unless it brings new login data.
  */
 export class LoginGuard implements PinGuard {
   // ECMAScript private, so that neither `util.inspect` nor `JSON.stringify` of the client reaches it.
@@ -143,10 +143,17 @@ export class LoginGuard implements PinGuard {
         // Only the bank's refusal the guard holds names reasons; any other error, a second refusal too, fails the call.
         if (refusal === undefined || error !== refusal || rejected === undefined) throw error;
         const reason = remediableReasons(refusal, rejected).find((r) => !this.pardonedReasons.has(r));
-        if (reason === undefined || !(await remedy(reason, rejected))) throw error;
+        if (reason === undefined) throw error;
         this.pardonedReasons.add(reason);
-        // A closed client keeps the refusal.
-        if (this.#pin !== undefined) this.liftRefusal();
+        // The refusal named a reason the session takes care of, not the PIN, so it does not outlast a remedy that fails,
+        // such as a TAN method prompt the app ends: the call fails with the remedy's own error. On a closed client the
+        // next attempt fails before it sends anything.
+        const remedied = await remedy(reason, rejected).catch((remedyError: unknown) => {
+          this.liftRefusal();
+          throw remedyError;
+        });
+        if (!remedied) throw error;
+        this.liftRefusal();
       }
     }
   }
@@ -172,9 +179,14 @@ export class LoginGuard implements PinGuard {
     return { refusal: this.refusalValue?.feedback, unreadLogins: this.unreadLogins };
   }
 
-  /** Restores what `saveState` returned; a restored refusal is final. */
+  /** Restores what `saveState` returned; a restored refusal is final, also one without return codes. */
   restoreState(saved: LoginGuardState): void {
-    if (saved.refusal !== undefined) this.refusalValue = loginRefusalFor(saved.refusal);
+    if (saved.refusal !== undefined) {
+      this.refusalValue =
+        saved.refusal.length > 0
+          ? loginRefusalFor(saved.refusal)
+          : new FinTsLoginRefusedError([], 'A login was refused, and the saved state no longer tells why');
+    }
     this.unreadLogins = Math.max(0, saved.unreadLogins);
     this.forgetPinIfRefused();
   }
@@ -201,8 +213,11 @@ function remediableReasons(refusal: FinTsLoginRefusedError, method: TanMethod):
   return reasons;
 }
 
-/** Error codes that only say that the message failed, not why: 9050 (the message contains errors) and 9800. */
-const unspecificErrors = new Set(['9050', FeedbackCodes.dialogAborted]);
+/**
+ * Error codes that cannot be about the PIN: 9050 (the message contains errors) and 9800, which only say that the
+ * message failed, and 9955 (the one-step method is not allowed).
+ */
+const errorsNotAboutThePin = new Set(['9050', FeedbackCodes.dialogAborted, '9955']);
 
 /**
  * Whether `feedback`, which refuses a login signed with `method`, names the method as the reason: a 3920 that lists the
@@ -210,12 +225,13 @@ const unspecificErrors = new Set(['9050', FeedbackCodes.dialogAborted]);
  *
  * Only the return codes of the refusal itself count: TAN methods listed earlier say nothing about this login. Banks
  * list two-step methods only, so a 3920 always leaves the one-step method out, also where the login succeeds. After
- * the one-step method a 3920 counts only where the bank names no other error than an unspecific one: any other, such
- * as "Anmeldung fehlgeschlagen", may be about the PIN.
+ * the one-step method a 3920 counts only where the bank names no other error than one not about the PIN: any other,
+ * such as "Anmeldung fehlgeschlagen", may be about it. PIN/TAN B.8.2 has the bank answer a one-step dialog of a user
+ * bound to two-step methods with 9955 and 3920.
  */
 function refusesMethod(feedback: readonly FinTsFeedback[], method: TanMethod): boolean {
   if (method.isOneStep && hasCode(feedback, FeedbackCodes.scaRequired)) return true;
   const allowed = allowedTanMethodsIn(feedback);
   if (allowed.length === 0 || allowed.includes(method.securityFunction)) return false;
-  return !method.isOneStep || feedback.every((f) => !f.isError || unspecificErrors.has(f.code));
+  return !method.isOneStep || feedback.every((f) => !f.isError || errorsNotAboutThePin.has(f.code));
 }

package/src/session/session-setup.ts

@@ -15,7 +15,8 @@ import type { TanSelection } from './tan-selection.js';
  * What has to be settled before a login: the bank parameter data, the synchronization, and through `TanSelection` the
  * TAN method and medium. Each of the dialogs this takes serves one purpose only.
  *
- * Where the bank refuses a login for a reason the session can take care of, `remedied` does so and logs in again.
+ * Where the bank refuses a login for a reason the session can take care of, `remedied` does so and logs in again; so it
+ * does where the limits of bank parameter data that may be outdated keep a login from going out.
  */
 export class SessionSetup {
   constructor(
@@ -59,9 +60,24 @@ export class SessionSetup {
     return new SignedDialog(this.tans.newDialog(), this.session);
   }
 
-  /** Runs `attempt`, which may log in, once more after each refused login `remedy` takes care of. */
-  remedied<T>(attempt: () => Promise<T>): Promise<T> {
-    return this.session.guard.remedied(attempt, (reason, rejected) => this.remedy(reason, rejected));
+  /**
+   * Runs `attempt`, which may log in, once more after each refused login `remedy` takes care of.
+   *
+   * Where the limits of the bank parameter data kept a login from going out (`FinTs3Protocol.stoppedLogin`), it fetches
+   * them anew in an anonymous dialog, once, and runs `attempt` once more: they may be outdated, as saved ones are, and
+   * new ones would come only in answer to the login they rule out. The new limits judge the login built anew, not the
+   * one stopped: it reports version 0 for the parameter data they stand in for, so it may be shorter.
+   */
+  async remedied<T>(attempt: () => Promise<T>): Promise<T> {
+    const run = (): Promise<T> =>
+      this.session.guard.remedied(attempt, (reason, rejected) => this.remedy(reason, rejected));
+    try {
+      return await run();
+    } catch (error) {
+      if (!this.protocol.stoppedLogin(error)) throw error;
+      await this.fetchBankParametersAnonymously(true);
+      return run();
+    }
   }
 
   /**
@@ -97,14 +113,16 @@ export class SessionSetup {
 
   /**
    * Asks for the bank parameter data without logging in, keeps them where there are none from a dialog signed with the
-   * PIN (`ParameterStore.keepAnonymous`), and passes the bank's messages on: all an anonymous dialog tells, since the
-   * TAN methods it lists are not those of a user. A bank that does not answer anonymously is no error, but a failed
-   * connection is: the synchronization would only wait for the same server again.
+   * PIN (`ParameterStore.keepAnonymous`), or with `refresh` their limits only (`ParameterStore.keepRefreshedLimits`),
+   * and passes the bank's messages on: all an anonymous dialog tells, since the TAN methods it lists are not those of a
+   * user. A bank that does not answer anonymously is no error, but a failed connection is: the synchronization would
+   * only wait for the same server again.
    */
-  private async fetchBankParametersAnonymously(): Promise<void> {
+  private async fetchBankParametersAnonymously(refresh = false): Promise<void> {
     try {
       const response = await this.requestBankParametersAnonymously();
-      this.session.parameters.keepAnonymous(response);
+      if (refresh) this.session.parameters.keepRefreshedLimits(response);
+      else this.session.parameters.keepAnonymous(response);
       for (const message of response.bankMessages) this.session.prompts.showBankMessage(message);
     } catch (error) {
       // Optional: the login delivers the parameters as well.

package/src/session/session-state.ts

@@ -38,23 +38,27 @@ export function saveSession(parameters: ParameterStore, guard: LoginGuard, sessi
  * The session saved in `json`, and the parameter data and the guard's refused login restored from it.
  *
  * A missing or damaged state, or one saved for another user, bank, server or protocol version, gives a new session,
- * which only costs a new synchronization. The refused login belongs to the user at the bank, so it comes first: it holds
- * for another server or protocol version as well, and where the rest is damaged; a state saved by the Dart package or
- * an earlier version has none.
+ * which only costs a new synchronization. The refused login and the count of logins whose answer was lost belong to the
+ * user at the bank, so they come first: they hold for another server or protocol version as well, and where the rest is
+ * damaged; a state saved by fints-ts 0.1 or the Dart package 0.2.0 has neither. A damaged section of their own fails
+ * closed: it restores a refusal without return codes, since it may have held one.
  */
 export function restoreSession(json: string | undefined, parameters: ParameterStore, guard: LoginGuard): SessionState {
   if (json === undefined) return new SessionState();
   try {
     const saved: unknown = JSON.parse(json);
     if (!isJsonObject(saved) || saved.format !== stateFormat) return new SessionState();
-    const [server, ...user] = readOptionalList(saved, 'owner', isString) ?? [];
+    // Entries of another type differ like any other value, so that a damaged server entry keeps the refused login.
+    const owner: unknown = saved.owner ?? [];
+    if (!Array.isArray(owner)) return new SessionState();
+    const [server, ...user] = owner as unknown[];
     const expected = userOf(parameters.config);
     if (user.length !== expected.length || user.some((value, i) => value !== expected[i])) return new SessionState();
-    const loginGuard = readOptionalObject(saved, 'loginGuard');
-    if (loginGuard !== undefined) guard.restoreState(guardStateFromJson(loginGuard));
+    const guardState = savedGuardState(saved);
+    if (guardState !== undefined) guard.restoreState(guardState);
     if (server !== hostOf(parameters.config.url) || saved.version !== protocolVersion) return new SessionState();
     const session = SessionState.fromJson(readObject(saved, 'session'));
-    parameters.restoreState(readObject(saved, 'protocol'));
+    parameters.restoreState(readObject(saved, 'protocol'), session.tanMedium);
     return session;
   } catch (error) {
     // Damaged JSON, base64 or parameter data, and values of the wrong type, only cost a new synchronization.
@@ -137,7 +141,9 @@ export class SessionState {
     const state = new SessionState();
     state.useTanMethod(readOptionalString(json, 'tanMethod'), readOptionalString(json, 'tanMedium'));
     if (allowedMethods !== undefined) state.rememberAllowedMethods(allowedMethods);
-    if (sepaAccounts !== undefined) state.cacheSepaAccounts(sepaAccounts, sepaUpdVersion);
+    // fints-ts 0.1 and the Dart package 0.2.0 saved an empty list as well, which completes nothing; without it, the
+    // list is asked for again.
+    if (sepaAccounts !== undefined && sepaAccounts.length > 0) state.cacheSepaAccounts(sepaAccounts, sepaUpdVersion);
     return state;
   }
 
@@ -181,6 +187,17 @@ function guardStateToJson(state: LoginGuardState): JsonObject {
   return { refusal: state.refusal?.map(feedbackToJson) ?? null, unreadLogins: state.unreadLogins };
 }
 
+/** The guard's section of `saved`, `undefined` where there is none; a damaged one is a refusal without return codes. */
+function savedGuardState(saved: JsonObject): LoginGuardState | undefined {
+  try {
+    const json = readOptionalObject(saved, 'loginGuard');
+    return json === undefined ? undefined : guardStateFromJson(json);
+  } catch (error) {
+    if (error instanceof FormatError) return { refusal: [], unreadLogins: 0 };
+    throw error;
+  }
+}
+
 function guardStateFromJson(json: JsonObject): LoginGuardState {
   return {
     refusal: readOptionalList(json, 'refusal', isJsonObject)?.map(feedbackFromJson),

package/src/session/signed-dialog.ts

@@ -1,13 +1,23 @@
 import { requireLatin1 } from '../core/config.js';
 import {
   bankErrorFor,
+  FinTsBankError,
   FinTsLoginDataChangedError,
+  FinTsLoginRefusedError,
   FinTsProtocolError,
   FinTsTanCancelledError,
 } from '../core/errors.js';
-import { allowedTanMethodsIn, FeedbackCodes, hasCode, hasErrors, userWarnings } from '../core/feedback.js';
+import {
+  allowedTanMethodsIn,
+  FeedbackCodes,
+  hasCode,
+  hasErrors,
+  userWarnings,
+  type FinTsFeedback,
+} from '../core/feedback.js';
 import type { TanMethod } from '../tan/tan-models.js';
 import { invalidArgument } from '../util/errors.js';
+import { trimBlanks, withAsciiForms } from '../util/text.js';
 import type { Approval, FinTs3Dialog } from '../v3/dialog.js';
 import { IncomingMessage3 } from '../v3/message.js';
 import type { ParameterStore } from '../v3/parameter-store.js';
@@ -43,8 +53,8 @@ export class SignedDialog {
   }
 
   /** Logs in, which opens the dialog; with `synchronize` the bank also assigns a customer system ID. */
-  async login(synchronize = false): Promise<IncomingMessage3> {
-    return this.settle(await this.dialog.start(synchronize), 'login');
+  login(synchronize = false): Promise<IncomingMessage3> {
+    return this.settleLogin(() => this.dialog.start(synchronize));
   }
 
   /**
@@ -53,27 +63,16 @@ export class SignedDialog {
    */
   async loginWith(order: SegmentSpec): Promise<IncomingMessage3[]> {
     const start = this.dialog.startWith(order);
-    const login = await this.settle(await start.login(), 'login');
+    const login = await this.settleLogin(start.login);
     return [login, await this.settle(await start.order(), 'order')];
   }
 
-  /** Sends `order`, the first page of a query, and completes the approval the bank asks for. */
-  async send(order: SegmentSpec): Promise<IncomingMessage3> {
-    return this.settle(await this.dialog.send(order), 'order');
-  }
-
   /**
-   * Sends `order` for a further page of a query (Formals B.6.3), whose answer must not ask for an approval: the client
-   * completes that of the first page only, so that a bank that asks anew for every page cannot prompt the user once per
-   * page. Throws `FinTsProtocolError` if it asks for one.
+   * Sends `order` and completes the approval the bank asks for. `admitApproval` runs before the user is asked, and
+   * refuses the approval by throwing.
    */
-  async sendFurtherPage(order: SegmentSpec): Promise<IncomingMessage3> {
-    const response = await this.dialog.send(order);
-    this.receive(response, 'order', false);
-    if (this.dialog.approvalAskedIn(response) !== undefined) {
-      throw new FinTsProtocolError('The bank asks for an approval of a further page of the same query');
-    }
-    return response;
+  async send(order: SegmentSpec, admitApproval?: () => void): Promise<IncomingMessage3> {
+    return this.settle(await this.dialog.send(order), 'order', admitApproval);
   }
 
   /**
@@ -104,32 +103,63 @@ export class SignedDialog {
   }
 
   /**
-   * Where `response` answers a login, a request of `kind` other than `order`, or its approval with new login data: ends
-   * the dialog, stops the client from logging in with the old ones, and fails the call with
-   * `FinTsLoginDataChangedError` (Rückmeldungscodes C.6). It runs before any approval, which would cost the user a TAN
-   * for a session that ends anyway. New login data next to an error are the login's refusal already
-   * (`loginRefusalFor`).
+   * Sends the login `send` and settles its answer. New login data next to an error in the answer to its approval are
+   * retired all the same (`retireLoginData`), although the guard counts that error as no refusal; next to an error in
+   * the answer to the login they are its refusal already (`loginRefusalFor`).
+   */
+  private async settleLogin(send: () => Promise<IncomingMessage3>): Promise<IncomingMessage3> {
+    try {
+      return await this.settle(await send(), 'login');
+    } catch (error) {
+      if (
+        !(error instanceof FinTsBankError) ||
+        error instanceof FinTsLoginRefusedError ||
+        !hasCode(error.feedback, FeedbackCodes.newLoginData)
+      ) {
+        throw error;
+      }
+      return this.retireLoginData(error.feedback, 'approval');
+    }
+  }
+
+  /**
+   * Where `response` answers a login, a request of `kind` other than `order`, or its approval with new login data,
+   * retires them (`retireLoginData`). It runs before any approval, which would cost the user a TAN for a session that
+   * ends anyway.
    */
   private async retireOldLoginData(response: IncomingMessage3, kind: RequestKind): Promise<void> {
     if (kind === 'order' || !hasCode(response.feedback, FeedbackCodes.newLoginData)) return;
+    await this.retireLoginData(response.feedback, kind);
+  }
+
+  /**
+   * Ends the dialog, whose answer to a request of `kind` brought new login data with `feedback`, stops the client from
+   * logging in with the old ones, and fails the call with `FinTsLoginDataChangedError` (Rückmeldungscodes C.6).
+   */
+  private async retireLoginData(feedback: readonly FinTsFeedback[], kind: RequestKind): Promise<never> {
     await this.end();
-    const error = new FinTsLoginDataChangedError(response.feedback);
+    const error = new FinTsLoginDataChangedError(feedback);
     throw this.session.guard.judge(error, kind, this.dialog.method) ?? error;
   }
 
   /**
-   * Receives `response`, the answer to a request of `kind`, then completes the approval it asks for; returns it joined
-   * with the response that completes the approval.
+   * Receives `response`, the answer to a request of `kind`, then completes the approval it asks for, once
+   * `admitApproval` has let it; returns it joined with the response that completes the approval.
    *
    * Throws `FinTsProtocolError` if that response asks for an approval once more: the bank has not executed the message
    * then either, and read as done it would report an empty result.
    */
-  private async settle(response: IncomingMessage3, kind: RequestKind): Promise<IncomingMessage3> {
+  private async settle(
+    response: IncomingMessage3,
+    kind: RequestKind,
+    admitApproval?: () => void,
+  ): Promise<IncomingMessage3> {
     const opening = kind !== 'order';
     this.receive(response, kind, opening);
     await this.retireOldLoginData(response, kind);
     const approval = this.dialog.approvalAskedIn(response);
     if (approval === undefined) return response;
+    admitApproval?.();
     const approved = approval.challenge.isDecoupled
       ? await this.awaitAppApproval(approval, opening)
       : await this.enterTan(approval, opening);
@@ -154,8 +184,8 @@ export class SignedDialog {
     if (answer.kind === 'approved') {
       throw invalidArgument('Answered a TAN challenge with an approval in the banking app', 'tanCallback');
     }
-    // NFKC, so that digits of another width, such as those of a Japanese input method, go out as the digits they are.
-    const tan = answer.kind === 'tan' ? answer.tan.normalize('NFKC').trim() : '';
+    // Not NFKC, which also changes characters FinTS 3.0 sends as they are, such as `²`, in a TAN the bank compares.
+    const tan = answer.kind === 'tan' ? trimBlanks(withAsciiForms(answer.tan)) : '';
     if (tan === '') throw new FinTsTanCancelledError();
     const response = await approval.submitTan(requireTanOf(approval.challenge.method, tan));
     this.receive(response, 'approval', opening);

package/src/session/user-prompts.ts

@@ -4,9 +4,16 @@ import { clientClosedError } from '../core/errors.js';
 import type { FinTsFeedback } from '../core/feedback.js';
 import { TanAnswer, type TanChallenge } from '../tan/challenge.js';
 import type { TanMedium, TanMethod } from '../tan/tan-models.js';
+import { optionalFunction, requireFunction } from '../util/arguments.js';
 import { Deferred } from '../util/async.js';
 import { invalidArgument } from '../util/errors.js';
 
+/** The callbacks of `FinTsClientOptions`. */
+type Callbacks = Pick<
+  FinTsClientOptions,
+  'tanCallback' | 'tanMethodSelector' | 'tanMediumSelector' | 'onBankMessage' | 'onWarning' | 'logger'
+>;
+
 /**
  * Everything a session tells the app, asks of it or waits for: the bank's messages, warnings and log, the TAN callback,
  * the selectors and the pauses between status requests.
@@ -23,7 +30,25 @@ export class UserPrompts {
   /** Aborts the waits under way; each wait removes its abort when it is over, or when nothing waits for it any more. */
   private readonly aborts = new Set<() => void>();
 
-  constructor(private readonly options: FinTsClientOptions) {}
+  /** The callbacks as the client was built with them, as in the Dart package, whose options are final. */
+  private readonly options: Callbacks;
+
+  /**
+   * Throws `TypeError` for a `tanCallback` that is no function, and for another callback that is neither a function
+   * nor `undefined` or `null`, which mean none.
+   */
+  constructor(options: FinTsClientOptions) {
+    const tanCallback = requireFunction(options.tanCallback, 'tanCallback');
+    this.options = {
+      // Called on the app's options, which a callback written as a method of them may refer to as `this`.
+      tanCallback: (challenge) => tanCallback.call(options, challenge),
+      tanMethodSelector: optionalFunction(options.tanMethodSelector, 'tanMethodSelector'),
+      tanMediumSelector: optionalFunction(options.tanMediumSelector, 'tanMediumSelector'),
+      onBankMessage: optionalFunction(options.onBankMessage, 'onBankMessage'),
+      onWarning: optionalFunction(options.onWarning, 'onWarning'),
+      logger: optionalFunction(options.logger, 'logger'),
+    };
+  }
 
   /** Ends every wait; the client calls it once. */
   close(): void {
@@ -121,7 +146,7 @@ export class UserPrompts {
     const selector = this.options.tanMethodSelector;
     if (candidates.length === 1 || selector === undefined) return candidates[0]!;
     const chosen = await this.unlessClosed(() => selector(candidates));
-    if (chosen === undefined) return candidates[0]!;
+    if (chosen === undefined || chosen === null) return candidates[0]!;
     const match = candidates.find((m) => m.securityFunction === chosen.securityFunction);
     if (match === undefined) throw invalidArgument('Returned a TAN method the bank did not offer', 'tanMethodSelector');
     return match;
@@ -136,7 +161,7 @@ export class UserPrompts {
     const selector = this.options.tanMediumSelector;
     if (media.length === 1 || selector === undefined) return media[0]!;
     const chosen = await this.unlessClosed(() => selector(media));
-    if (chosen === undefined) return media[0]!;
+    if (chosen === undefined || chosen === null) return media[0]!;
     const match = media.find((m) => m.name === chosen.name);
     if (match === undefined) throw invalidArgument('Returned a TAN medium the bank did not list', 'tanMediumSelector');
     return match;