@atlasauth/angular 0.13.0 → 0.15.0

package/dist/esm2022/lib/components/flow-controller.mjs

@@ -1,5 +1,5 @@
 import { signal } from '@angular/core';
-import { advanceWithCaptcha, atlasCaptchaLabels, createCaptchaController, createPasskeySignInController, createPasskeySignUp, createSignUp, finishPasskeySignUp, fetchInstanceSettings, fetchLastSignInMethod, startSignInWithAtlas, createMfaEnrollment, acknowledgeRecoveryCodes, pendingRecoveryCodes, mfaChoicesFrom, prepareSecondFactorCode, resendSignUpVerification, flowNeedsCaptcha, signInCaptchaOptions, flowFromPending, initialFlow, nextStep, offeredFirstFactors, pollAttempt, prepareFactor, planFirstFactor, shouldKeepPolling, PolicyAcceptanceController, loadPolicies, } from '@atlasauth/js';
+import { advanceWithCaptcha, atlasCaptchaLabels, attemptPasswordHoldProof, preparePasswordHoldProof, createCaptchaController, createPasskeySignInController, createPasskeySignUp, createSignUp, finishPasskeySignUp, fetchInstanceSettings, fetchLastSignInMethod, startSignInWithAtlas, createMfaEnrollment, acknowledgeExistingAccount, acknowledgeRecoveryCodes, pendingExistingAccountNotice, pendingRecoveryCodes, mfaChoicesFrom, prepareSecondFactorCode, resendSignUpVerification, flowNeedsCaptcha, signInCaptchaOptions, flowFromPending, initialFlow, nextStep, offeredFirstFactors, pollAttempt, prepareFactor, planFirstFactor, shouldKeepPolling, PolicyAcceptanceController, loadPolicies, } from '@atlasauth/js';
 import { EN_US, translate } from '../i18n';
 /**
  * The server-driven sign-in / sign-up engine, shared by `<atlas-sign-in>` and
@@ -19,6 +19,7 @@ export class AtlasFlowController {
     client;
     reload;
     t;
+    holdExistingAccountNotice;
     state;
     /**
      * The instance's public sign-in / sign-up settings (captcha, sign-up fields,
@@ -81,10 +82,13 @@ export class AtlasFlowController {
     identifier = '';
     constructor(client, reload, pending, 
     /** Resolves the captcha messages' catalog keys. Defaults to en-US. */
-    t = (key) => translate(EN_US, key)) {
+    t = (key) => translate(EN_US, key), 
+    /** Wait for {@link continueAfterExistingAccount} (`<atlas-sign-up>` draws the notice). */
+    holdExistingAccountNotice = false) {
         this.client = client;
         this.reload = reload;
         this.t = t;
+        this.holdExistingAccountNotice = holdExistingAccountNotice;
         // Seeded from a redirect that came back mid-flow (e.g. OAuth needing a second
         // factor) so the user resumes at the demanded step instead of starting over.
         this.state = signal(pending ? flowFromPending(pending) : initialFlow);
@@ -151,9 +155,27 @@ export class AtlasFlowController {
     firstFactors() {
         const attempt = this.state().attempt;
         const step = attempt ? nextStep(attempt) : null;
-        return step?.kind === 'collect_first_factor'
-            ? offeredFirstFactors(step.strategies, this.settings()?.emailDelivery)
-            : [];
+        if (step?.kind !== 'collect_first_factor')
+            return [];
+        const offered = offeredFirstFactors(step.strategies, this.settings()?.emailDelivery);
+        const proof = this.holdProof();
+        return proof && !offered.includes(proof) ? [...offered, proof] : offered;
+    }
+    /**
+     * The emailed proof a password hold still waits on (`FlowState.passwordHold`): the
+     * code, or a link where the instance verifies by link only. Null with no hold, once
+     * proven, or while the app cannot deliver email.
+     */
+    holdProof() {
+        const hold = this.state().passwordHold;
+        if (!hold || hold.released || this.settings()?.emailDelivery?.available === false)
+            return null;
+        return this.settings()?.account?.emailVerification === 'link' ? 'email_link' : 'email_code';
+    }
+    /** Back from the emailed factor to the password field. */
+    usePassword() {
+        this.preparedFactor.set(null);
+        this.state.update((current) => ({ ...current, prepared: null, pollSecret: null, errors: [] }));
     }
     /**
      * True when email + password sign-up cannot complete because the app cannot
@@ -170,16 +192,21 @@ export class AtlasFlowController {
     /**
      * Ask the server to email a sign-in code for the current `needs_first_factor`
      * step (`POST …/prepare_first_factor`); the form then collects the code, which
-     * {@link submit} posts as the `email_code` strategy.
+     * {@link submit} posts as the `email_code` strategy. While a password hold waits
+     * on it ({@link holdProof}), this emails that proof instead.
      */
     async prepare(strategy) {
         if (!this.firstFactors().includes(strategy))
             return;
+        const proof = this.holdProof();
         this.state.update((current) => ({ ...current, busy: true, errors: [] }));
-        const next = await prepareFactor(this.client, this.state(), strategy);
+        const next = strategy === proof
+            ? await preparePasswordHoldProof(this.client, this.state(), proof)
+            : await prepareFactor(this.client, this.state(), strategy);
         this.setState(next);
         if (!next.errors.length)
             this.preparedFactor.set(strategy);
+        this.syncPolling();
     }
     /** Keep both captchas in step with the settings and the flow's current step. */
     syncCaptcha() {
@@ -195,8 +222,12 @@ export class AtlasFlowController {
         this.signUpCaptchaDrawn.set(this.signUpCaptcha.needed);
     }
     setState(next) {
-        const previousId = this.state().attempt?.id ?? null;
+        const previous = this.state();
+        const previousId = previous.attempt?.id ?? null;
         this.state.set(next);
+        // A proven hold goes back to the password field.
+        if (next.passwordHold?.released && !previous.passwordHold?.released)
+            this.preparedFactor.set(null);
         // A prepared factor belongs to the first-factor step it was sent for.
         if (next.attempt?.status !== 'needs_first_factor')
             this.preparedFactor.set(null);
@@ -232,6 +263,11 @@ export class AtlasFlowController {
      */
     async submit(values) {
         this.state.update((current) => ({ ...current, busy: true, errors: [] }));
+        // A code that lifts a password hold goes to its own attempt, not this sign-in.
+        if (this.preparedFactor() === 'email_code' && this.holdProof() === 'email_code') {
+            this.setState(await attemptPasswordHoldProof(this.client, this.state(), values.code ?? ''));
+            return;
+        }
         const out = await advanceWithCaptcha(this.client, this.state(), values, {
             captcha: this.captcha,
             identifier: this.identifier,
@@ -327,10 +363,24 @@ export class AtlasFlowController {
     async saveRecoveryCodes() {
         await this.finish(acknowledgeRecoveryCodes(this.state()));
     }
+    /** The address belonged to an existing account: the notice is up until {@link continueAfterExistingAccount}. */
+    existingAccountNotice() {
+        return pendingExistingAccountNotice(this.state());
+    }
+    /** The user read the notice: finish the sign-up. */
+    async continueAfterExistingAccount() {
+        await this.finish(acknowledgeExistingAccount(this.state()));
+    }
     async finish(next) {
         // An enrolment's recovery codes are shown first; `saveRecoveryCodes` finishes.
         if (pendingRecoveryCodes(next)) {
-            this.setState({ ...next, busy: false });
+            // The ticket dies in 60 seconds and saving the codes can take longer: redeem it now,
+            // and `saveRecoveryCodes` finishes. A refused exchange keeps the ticket, so the save reports it.
+            this.setState({ ...next, busy: true });
+            const res = next.ticket
+                ? await this.client.post('/v1/client/tickets/exchange', { attempt_id: next.attempt.id, ticket: next.ticket })
+                : null;
+            this.setState({ ...next, busy: false, ticket: res?.ok ? null : next.ticket });
             return;
         }
         if (next.attempt?.status === 'complete') {
@@ -345,6 +395,10 @@ export class AtlasFlowController {
                 });
                 exchanged = res.ok;
             }
+            if (exchanged && this.holdExistingAccountNotice && pendingExistingAccountNotice(next)) {
+                this.setState({ ...next, ticket: null, busy: false });
+                return;
+            }
             const kept = exchanged && (await this.reload());
             this.setState({ ...next, busy: false, sessionKept: kept });
         }
@@ -401,4 +455,4 @@ export class AtlasFlowController {
         this.signUpCaptcha.destroy();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-controller.js","sourceRoot":"","sources":["../../../../src/lib/components/flow-controller.ts"],"names":[],"mappings":"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","sourcesContent":["import { WritableSignal, signal } from '@angular/core';\nimport {\n  FapiClient,\n  advanceWithCaptcha,\n  atlasCaptchaLabels,\n  createCaptchaController,\n  createPasskeySignInController,\n  createPasskeySignUp,\n  createSignUp,\n  finishPasskeySignUp,\n  fetchInstanceSettings,\n  fetchLastSignInMethod,\n  startSignInWithAtlas,\n  createMfaEnrollment,\n  acknowledgeRecoveryCodes,\n  pendingRecoveryCodes,\n  mfaChoicesFrom,\n  prepareSecondFactorCode,\n  resendSignUpVerification,\n  flowNeedsCaptcha,\n  signInCaptchaOptions,\n  flowFromPending,\n  initialFlow,\n  nextStep,\n  offeredFirstFactors,\n  pollAttempt,\n  prepareFactor,\n  planFirstFactor,\n  shouldKeepPolling,\n  PolicyAcceptanceController,\n  loadPolicies,\n  type CaptchaController,\n  type FlowState,\n  type InstanceSettings,\n  type MfaChoices,\n  type MfaEnrollmentController,\n  type MfaEnrollmentState,\n  type PasskeySignInController,\n} from '@atlasauth/js';\nimport { EN_US, translate } from '../i18n';\n\n/**\n * The server-driven sign-in / sign-up engine, shared by `<atlas-sign-in>` and\n * `<atlas-sign-up>` — the Angular counterpart of React's `useFlow` hook.\n *\n * It owns no decision about what comes next: every status comes back from the\n * server via `advance`, and this controller only posts whatever the current step\n * needs and re-renders the returned status. State lives in a signal so templates\n * update whether the app runs zoned or zoneless.\n *\n * `<atlas-sign-up>` starts the attempt with {@link create}\n * (`POST /v1/client/sign_ups`); the emailed-code step then runs through the same\n * {@link submit}. Both flows draw the instance's captcha (from\n * {@link loadSettings}) when it is required.\n */\nexport class AtlasFlowController {\n  readonly state: WritableSignal<FlowState>;\n  /**\n   * The instance's public sign-in / sign-up settings (captcha, sign-up fields,\n   * legal consent) from `GET /v1/appearance`; null until {@link loadSettings}\n   * resolves, or when the server could not be reached.\n   */\n  readonly settings = signal<InstanceSettings | null>(null);\n  /**\n   * The method this browser last signed in with (`password`, `oauth_github`, …)\n   * for the \"Last used\" hint; null when none, or the instance turned it off.\n   */\n  readonly lastMethod = signal<string | null>(null);\n  /** The sign-in captcha (identifier step / `needs_captcha` challenge). */\n  readonly captcha: CaptchaController = createCaptchaController(undefined, {\n    // The Atlas captcha's words follow the form's catalog (read when drawn).\n    atlasLabels: () => atlasCaptchaLabels(this.t),\n  });\n  /** The sign-up captcha (the create-account step). */\n  readonly signUpCaptcha: CaptchaController = createCaptchaController(undefined, {\n    atlasLabels: () => atlasCaptchaLabels(this.t),\n  });\n  /** Whether {@link captcha} currently draws a widget (for templates). */\n  readonly captchaDrawn = signal(false);\n  /** Whether {@link signUpCaptcha} currently draws a widget (for templates). */\n  readonly signUpCaptchaDrawn = signal(false);\n  /**\n   * The first factor the server was asked to send ({@link prepare}) on the\n   * current `needs_first_factor` step — the form then collects its code. Null\n   * otherwise.\n   */\n  readonly preparedFactor = signal<'email_code' | null>(null);\n  /**\n   * \"Email me a code instead\" at the second factor ({@link sendEmailSecondFactor}):\n   * in flight, where the code went, or why it was not sent. Null until asked,\n   * and again once the flow leaves that step.\n   */\n  readonly emailSecondFactor = signal<{ busy?: boolean; sentTo?: string; error?: string } | null>(null);\n  /** \"Text me a code instead\" at the second factor ({@link sendSmsSecondFactor}): as {@link emailSecondFactor}. */\n  readonly smsSecondFactor = signal<{ busy?: boolean; sentTo?: string; error?: string } | null>(null);\n  /**\n   * The MFA enrolment step (`needs_mfa_enrollment`): the authenticator app's\n   * setup (QR code, setup key) or a texted code. Started and reset with the flow.\n   */\n  readonly enrollment: MfaEnrollmentController;\n  /** {@link enrollment}'s state, for templates. */\n  readonly enrollmentState: WritableSignal<MfaEnrollmentState>;\n  /**\n   * The instance's policies (terms, privacy, …) for the create-account form:\n   * {@link create} sends their acceptances and reloads them after a refusal.\n   */\n  readonly policies = new PolicyAcceptanceController([]);\n  /**\n   * Passkey sign-in (the \"Sign in with a passkey\" button and passkey autofill on\n   * the identifier field). The outcome goes through the same completion as every sign-in.\n   */\n  readonly passkey: PasskeySignInController;\n  /** Whether this browser can run WebAuthn; `<atlas-sign-in>` sets it after it is created in a browser. */\n  readonly passkeySupported = signal(false);\n  private pollTimer: ReturnType<typeof setInterval> | null = null;\n  private identifier = '';\n\n  constructor(\n    private readonly client: FapiClient,\n    private readonly reload: () => Promise<boolean>,\n    pending: { id: string; status: string } | null,\n    /** Resolves the captcha messages' catalog keys. Defaults to en-US. */\n    private readonly t: (key: string) => string = (key) => translate(EN_US, key),\n  ) {\n    // Seeded from a redirect that came back mid-flow (e.g. OAuth needing a second\n    // factor) so the user resumes at the demanded step instead of starting over.\n    this.state = signal<FlowState>(pending ? flowFromPending(pending) : initialFlow);\n    this.enrollment = createMfaEnrollment(this.client, () => this.mfaChoices());\n    this.enrollmentState = signal<MfaEnrollmentState>(this.enrollment.state);\n    this.enrollment.subscribe((next) => this.enrollmentState.set(next));\n    this.passkey = createPasskeySignInController({\n      client: this.client,\n      onStart: () => this.state.update((current) => ({ ...current, busy: true, errors: [] })),\n      onResult: (next) => this.finish(next),\n      captcha: () => this.captcha,\n      cancelledMessage: () => this.t('signIn.passkeyCancelled'),\n    });\n    this.syncCaptcha();\n    this.syncEnrollment();\n  }\n\n  /** Why \"Continue with Atlas\" could not start (the server's message); null otherwise. */\n  readonly signInWithAtlasError = signal<string | null>(null);\n\n  /**\n   * \"Continue with Atlas\" (when `settings().signInWithAtlas` is set): starts the\n   * SSO sign-in and sends the browser to Atlas.\n   */\n  async signInWithAtlas(connectionId: string): Promise<void> {\n    if (typeof window === 'undefined') return;\n    this.signInWithAtlasError.set(null);\n    const started = await startSignInWithAtlas(this.client, connectionId, window.location.href);\n    if ('url' in started) window.location.assign(started.url);\n    else this.signInWithAtlasError.set(started.error);\n  }\n\n  /** \"Sign in with a passkey\" is offered: the first step, the instance turned passkey sign-in on, and the browser can. */\n  passkeyOffered(): boolean {\n    return this.passkeySupported() && !this.state().attempt && this.settings()?.passkeySignIn === true;\n  }\n\n  /** What the app lets the MFA steps offer (from {@link settings}). */\n  mfaChoices(): MfaChoices {\n    return mfaChoicesFrom(this.settings()?.account);\n  }\n\n  /** Start the enrolment step for its attempt, or reset it once the flow leaves. */\n  private syncEnrollment(): void {\n    const attempt = this.state().attempt;\n    if (attempt?.status === 'needs_mfa_enrollment' && attempt.id) this.enrollment.start(attempt.id);\n    else this.enrollment.reset();\n  }\n\n  /** Fetch the instance's public settings and draw whatever captcha they require. */\n  async loadSettings(): Promise<void> {\n    const loaded = await fetchInstanceSettings(this.client);\n    if (loaded) {\n      this.settings.set(loaded);\n      this.syncCaptcha();\n      if (loaded.account.lastSignInMethod) this.lastMethod.set(await fetchLastSignInMethod(this.client));\n    }\n  }\n\n  /**\n   * The first factors to offer on a `needs_first_factor` step: the server's list\n   * without email code / link while the app cannot deliver email\n   * (`settings.emailDelivery.available === false`). Empty on any other step.\n   */\n  firstFactors(): string[] {\n    const attempt = this.state().attempt;\n    const step = attempt ? nextStep(attempt) : null;\n    return step?.kind === 'collect_first_factor'\n      ? offeredFirstFactors(step.strategies, this.settings()?.emailDelivery)\n      : [];\n  }\n\n  /**\n   * True when email + password sign-up cannot complete because the app cannot\n   * send the verification email (`settings.emailDelivery.passwordSignUp === false`):\n   * `<atlas-sign-up>` shows the \"can't send email\" notice instead of the form.\n   */\n  signUpEmailUnavailable(): boolean {\n    return this.settings()?.emailDelivery.passwordSignUp === false;\n  }\n\n  /** False when a password reset email cannot be delivered — hide \"Forgot password?\". */\n  passwordResetAvailable(): boolean {\n    return this.settings()?.emailDelivery.passwordReset !== false;\n  }\n\n  /**\n   * Ask the server to email a sign-in code for the current `needs_first_factor`\n   * step (`POST …/prepare_first_factor`); the form then collects the code, which\n   * {@link submit} posts as the `email_code` strategy.\n   */\n  async prepare(strategy: 'email_code'): Promise<void> {\n    if (!this.firstFactors().includes(strategy)) return;\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n    const next = await prepareFactor(this.client, this.state(), strategy);\n    this.setState(next);\n    if (!next.errors.length) this.preparedFactor.set(strategy);\n  }\n\n  /** Keep both captchas in step with the settings and the flow's current step. */\n  private syncCaptcha(): void {\n    const settings = this.settings();\n    const state = this.state();\n    this.captcha.configure(\n      signInCaptchaOptions(settings?.captchaFlows.signIn, state, () => void this.submit({})),\n    );\n    const signUpFlow = settings?.captchaFlows.signUp;\n    this.signUpCaptcha.configure({\n      flow: signUpFlow,\n      active: !state.attempt && flowNeedsCaptcha(signUpFlow),\n    });\n    this.captchaDrawn.set(this.captcha.needed);\n    this.signUpCaptchaDrawn.set(this.signUpCaptcha.needed);\n  }\n\n  private setState(next: FlowState): void {\n    const previousId = this.state().attempt?.id ?? null;\n    this.state.set(next);\n    // A prepared factor belongs to the first-factor step it was sent for.\n    if (next.attempt?.status !== 'needs_first_factor') this.preparedFactor.set(null);\n    // An emailed second-factor code belongs to the second-factor step of this attempt.\n    if (next.attempt?.status !== 'needs_second_factor' || (next.attempt?.id ?? null) !== previousId) {\n      this.emailSecondFactor.set(null);\n      this.smsSecondFactor.set(null);\n    }\n    this.syncCaptcha();\n    this.syncEnrollment();\n    this.autoSend();\n  }\n\n  private autoSentFor: string | null = null;\n  /**\n   * With no password on offer, email the code as soon as the server asks for a\n   * first factor — once per attempt, so a failed send waits for the user's retry\n   * (the \"Email me a code\" button) instead of looping.\n   */\n  private autoSend(): void {\n    const id = this.state().attempt?.id ?? null;\n    if (!id || this.autoSentFor === id || this.preparedFactor()) return;\n    if (planFirstFactor(this.firstFactors()).autoSend !== 'email_code') return;\n    this.autoSentFor = id;\n    void this.prepare('email_code');\n  }\n\n  /**\n   * Advance the flow with the values the user typed. On completion, exchange the\n   * one-time ticket for cookies over a same-origin request (FAPI is cross-origin\n   * and cannot set the cookie on its own response), then re-boot so the rest of\n   * the app sees a signed-in user.\n   */\n  async submit(values: Record<string, string>): Promise<void> {\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n\n    const out = await advanceWithCaptcha(this.client, this.state(), values, {\n      captcha: this.captcha,\n      identifier: this.identifier,\n      t: this.t,\n    });\n    this.identifier = out.identifier;\n    await this.finish(out.state);\n  }\n\n  /** Load the sign-up's policies into {@link policies} (`<atlas-sign-up>` calls it on init). */\n  async loadPolicies(locale?: string): Promise<void> {\n    this.policies.setPolicies(await loadPolicies(this.client, { locale }));\n  }\n\n  /** The user declined a policy a sign-in was waiting on: cancel the attempt and say why. */\n  declinePolicy(title: string): void {\n    this.state.set({\n      ...initialFlow,\n      errors: [{ code: 'POLICY_DECLINED', message: this.t('policy.declined').replace('{policy}', title) }],\n    });\n  }\n\n  /**\n   * Create an account (`POST /v1/client/sign_ups`) from a create-account form's\n   * values — email, password and any configured sign-up fields — carrying the\n   * sign-up captcha's token when the instance requires one. The emailed code is\n   * then posted with {@link submit}.\n   */\n  async create(values: Record<string, string>, consent = true): Promise<void> {\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n    const next = await createSignUp(this.client, values, {\n      consent,\n      captcha: this.signUpCaptcha,\n      t: this.t,\n      policies: this.policies,\n    });\n    await this.finish(next);\n  }\n\n  /**\n   * \"Email me a code instead\" at the second factor (the instance's\n   * `account.emailSecondFactor`): mails a code to the account's verified email;\n   * it is then posted with {@link submit} like any 2FA code.\n   */\n  async sendEmailSecondFactor(): Promise<void> {\n    await this.sendSecondFactorCode('email_code', this.emailSecondFactor);\n  }\n\n  /**\n   * \"Text me a code instead\" at the second factor (where the app offers texted\n   * codes, {@link mfaChoices}`().sms`): texts a code to the account's enrolled\n   * phone; it is then posted with {@link submit} like any 2FA code.\n   */\n  async sendSmsSecondFactor(): Promise<void> {\n    await this.sendSecondFactorCode('sms', this.smsSecondFactor);\n  }\n\n  private async sendSecondFactorCode(\n    strategy: 'sms' | 'email_code',\n    out: WritableSignal<{ busy?: boolean; sentTo?: string; error?: string } | null>,\n  ): Promise<void> {\n    const id = this.state().attempt?.id;\n    if (!id) return;\n    out.set({ busy: true });\n    try {\n      const { sentTo } = await prepareSecondFactorCode(this.client, id, strategy);\n      out.set({ sentTo });\n    } catch (error) {\n      out.set({ error: error instanceof Error ? error.message : this.t('error.generic') });\n    }\n  }\n\n  /** Resend a sign-up's emailed code / link (the earlier one stops working). */\n  async resendSignUp(): Promise<void> {\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n    this.state.set(await resendSignUpVerification(this.client, this.state()));\n  }\n\n  /**\n   * Start a passkey-only sign-up (`POST /v1/client/sign_ups/passkey`) from the\n   * create-account form's values — no password. Offered when the instance's\n   * `account.passkeySignUp` is set.\n   */\n  async createWithPasskey(values: Record<string, string>, consent = true): Promise<void> {\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n    await this.finish(await createPasskeySignUp(this.client, values, { consent, captcha: this.signUpCaptcha, t: this.t, policies: this.policies }));\n  }\n\n  /** The passkey-only sign-up's last step: create the passkey, and with it the account. */\n  async createPasskey(): Promise<void> {\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n    await this.finish(await finishPasskeySignUp(this.client, this.state(), { t: this.t }));\n  }\n\n  /**\n   * The recovery codes an MFA enrolment just completed the sign-in with, shown\n   * once before it finishes ({@link saveRecoveryCodes}); null otherwise. They\n   * live only in this controller's memory.\n   */\n  recoveryCodes(): string[] | null {\n    return pendingRecoveryCodes(this.state());\n  }\n\n  /** \"I've saved my codes\": forget the recovery codes and finish the sign-in. */\n  async saveRecoveryCodes(): Promise<void> {\n    await this.finish(acknowledgeRecoveryCodes(this.state()));\n  }\n\n  private async finish(next: FlowState): Promise<void> {\n    // An enrolment's recovery codes are shown first; `saveRecoveryCodes` finishes.\n    if (pendingRecoveryCodes(next)) {\n      this.setState({ ...next, busy: false });\n      return;\n    }\n    if (next.attempt?.status === 'complete') {\n      // Stays busy until this browser actually holds the session: the completion\n      // alone says nothing about whether the cookie was kept.\n      this.setState({ ...next, busy: true });\n      let exchanged = true;\n      if (next.ticket) {\n        const res = await this.client.post('/v1/client/tickets/exchange', {\n          attempt_id: (next.attempt as { id?: string }).id,\n          ticket: next.ticket,\n        });\n        exchanged = res.ok;\n      }\n      const kept = exchanged && (await this.reload());\n      this.setState({ ...next, busy: false, sessionKept: kept });\n    } else {\n      this.setState(next);\n      // A magic-link step may now be pollable (a link opened on another device).\n      this.syncPolling();\n    }\n  }\n\n  /** Start/stop the §5.3 magic-link poll to match the current state. */\n  syncPolling(): void {\n    if (shouldKeepPolling(this.state())) {\n      this.startPolling();\n    } else {\n      this.stopPolling();\n    }\n  }\n\n  private startPolling(): void {\n    if (this.pollTimer) return;\n    this.pollTimer = setInterval(() => {\n      void (async () => {\n        const { state: next, ticket } = await pollAttempt(this.client, this.state());\n        this.setState(next);\n        // e.g. a passkey sign-up whose email was just proven: only this tab can go on.\n        if (!ticket && !shouldKeepPolling(next)) this.stopPolling();\n        if (!ticket || !next.attempt) return;\n\n        // The ticket is exchanged by a normal request, so no session token ever\n        // appears in a URL.\n        const res = await this.client.post('/v1/client/tickets/exchange', {\n          attempt_id: (next.attempt as { id?: string }).id,\n          ticket,\n        });\n        const kept = res.ok && (await this.reload());\n        this.setState({ ...this.state(), sessionKept: kept });\n        this.stopPolling();\n      })();\n    }, 2_000);\n  }\n\n  private stopPolling(): void {\n    if (this.pollTimer) {\n      clearInterval(this.pollTimer);\n      this.pollTimer = null;\n    }\n  }\n\n  /** Release the poll timer and the captcha widgets — call from the component's `ngOnDestroy`. */\n  destroy(): void {\n    this.passkey.stopAutofill();\n    this.stopPolling();\n    this.captcha.destroy();\n    this.signUpCaptcha.destroy();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-controller.js","sourceRoot":"","sources":["../../../../src/lib/components/flow-controller.ts"],"names":[],"mappings":"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","sourcesContent":["import { WritableSignal, signal } from '@angular/core';\nimport {\n  FapiClient,\n  advanceWithCaptcha,\n  atlasCaptchaLabels,\n  attemptPasswordHoldProof,\n  preparePasswordHoldProof,\n  createCaptchaController,\n  createPasskeySignInController,\n  createPasskeySignUp,\n  createSignUp,\n  finishPasskeySignUp,\n  fetchInstanceSettings,\n  fetchLastSignInMethod,\n  startSignInWithAtlas,\n  createMfaEnrollment,\n  acknowledgeExistingAccount,\n  acknowledgeRecoveryCodes,\n  pendingExistingAccountNotice,\n  pendingRecoveryCodes,\n  mfaChoicesFrom,\n  prepareSecondFactorCode,\n  resendSignUpVerification,\n  flowNeedsCaptcha,\n  signInCaptchaOptions,\n  flowFromPending,\n  initialFlow,\n  nextStep,\n  offeredFirstFactors,\n  pollAttempt,\n  prepareFactor,\n  planFirstFactor,\n  shouldKeepPolling,\n  PolicyAcceptanceController,\n  loadPolicies,\n  type CaptchaController,\n  type FlowState,\n  type InstanceSettings,\n  type MfaChoices,\n  type MfaEnrollmentController,\n  type MfaEnrollmentState,\n  type PasskeySignInController,\n} from '@atlasauth/js';\nimport { EN_US, translate } from '../i18n';\n\n/**\n * The server-driven sign-in / sign-up engine, shared by `<atlas-sign-in>` and\n * `<atlas-sign-up>` — the Angular counterpart of React's `useFlow` hook.\n *\n * It owns no decision about what comes next: every status comes back from the\n * server via `advance`, and this controller only posts whatever the current step\n * needs and re-renders the returned status. State lives in a signal so templates\n * update whether the app runs zoned or zoneless.\n *\n * `<atlas-sign-up>` starts the attempt with {@link create}\n * (`POST /v1/client/sign_ups`); the emailed-code step then runs through the same\n * {@link submit}. Both flows draw the instance's captcha (from\n * {@link loadSettings}) when it is required.\n */\nexport class AtlasFlowController {\n  readonly state: WritableSignal<FlowState>;\n  /**\n   * The instance's public sign-in / sign-up settings (captcha, sign-up fields,\n   * legal consent) from `GET /v1/appearance`; null until {@link loadSettings}\n   * resolves, or when the server could not be reached.\n   */\n  readonly settings = signal<InstanceSettings | null>(null);\n  /**\n   * The method this browser last signed in with (`password`, `oauth_github`, …)\n   * for the \"Last used\" hint; null when none, or the instance turned it off.\n   */\n  readonly lastMethod = signal<string | null>(null);\n  /** The sign-in captcha (identifier step / `needs_captcha` challenge). */\n  readonly captcha: CaptchaController = createCaptchaController(undefined, {\n    // The Atlas captcha's words follow the form's catalog (read when drawn).\n    atlasLabels: () => atlasCaptchaLabels(this.t),\n  });\n  /** The sign-up captcha (the create-account step). */\n  readonly signUpCaptcha: CaptchaController = createCaptchaController(undefined, {\n    atlasLabels: () => atlasCaptchaLabels(this.t),\n  });\n  /** Whether {@link captcha} currently draws a widget (for templates). */\n  readonly captchaDrawn = signal(false);\n  /** Whether {@link signUpCaptcha} currently draws a widget (for templates). */\n  readonly signUpCaptchaDrawn = signal(false);\n  /**\n   * The first factor the server was asked to send ({@link prepare}) on the\n   * current `needs_first_factor` step — the form then collects its code. Null\n   * otherwise.\n   */\n  readonly preparedFactor = signal<'email_code' | 'email_link' | null>(null);\n  /**\n   * \"Email me a code instead\" at the second factor ({@link sendEmailSecondFactor}):\n   * in flight, where the code went, or why it was not sent. Null until asked,\n   * and again once the flow leaves that step.\n   */\n  readonly emailSecondFactor = signal<{ busy?: boolean; sentTo?: string; error?: string } | null>(null);\n  /** \"Text me a code instead\" at the second factor ({@link sendSmsSecondFactor}): as {@link emailSecondFactor}. */\n  readonly smsSecondFactor = signal<{ busy?: boolean; sentTo?: string; error?: string } | null>(null);\n  /**\n   * The MFA enrolment step (`needs_mfa_enrollment`): the authenticator app's\n   * setup (QR code, setup key) or a texted code. Started and reset with the flow.\n   */\n  readonly enrollment: MfaEnrollmentController;\n  /** {@link enrollment}'s state, for templates. */\n  readonly enrollmentState: WritableSignal<MfaEnrollmentState>;\n  /**\n   * The instance's policies (terms, privacy, …) for the create-account form:\n   * {@link create} sends their acceptances and reloads them after a refusal.\n   */\n  readonly policies = new PolicyAcceptanceController([]);\n  /**\n   * Passkey sign-in (the \"Sign in with a passkey\" button and passkey autofill on\n   * the identifier field). The outcome goes through the same completion as every sign-in.\n   */\n  readonly passkey: PasskeySignInController;\n  /** Whether this browser can run WebAuthn; `<atlas-sign-in>` sets it after it is created in a browser. */\n  readonly passkeySupported = signal(false);\n  private pollTimer: ReturnType<typeof setInterval> | null = null;\n  private identifier = '';\n\n  constructor(\n    private readonly client: FapiClient,\n    private readonly reload: () => Promise<boolean>,\n    pending: { id: string; status: string } | null,\n    /** Resolves the captcha messages' catalog keys. Defaults to en-US. */\n    private readonly t: (key: string) => string = (key) => translate(EN_US, key),\n    /** Wait for {@link continueAfterExistingAccount} (`<atlas-sign-up>` draws the notice). */\n    private readonly holdExistingAccountNotice = false,\n  ) {\n    // Seeded from a redirect that came back mid-flow (e.g. OAuth needing a second\n    // factor) so the user resumes at the demanded step instead of starting over.\n    this.state = signal<FlowState>(pending ? flowFromPending(pending) : initialFlow);\n    this.enrollment = createMfaEnrollment(this.client, () => this.mfaChoices());\n    this.enrollmentState = signal<MfaEnrollmentState>(this.enrollment.state);\n    this.enrollment.subscribe((next) => this.enrollmentState.set(next));\n    this.passkey = createPasskeySignInController({\n      client: this.client,\n      onStart: () => this.state.update((current) => ({ ...current, busy: true, errors: [] })),\n      onResult: (next) => this.finish(next),\n      captcha: () => this.captcha,\n      cancelledMessage: () => this.t('signIn.passkeyCancelled'),\n    });\n    this.syncCaptcha();\n    this.syncEnrollment();\n  }\n\n  /** Why \"Continue with Atlas\" could not start (the server's message); null otherwise. */\n  readonly signInWithAtlasError = signal<string | null>(null);\n\n  /**\n   * \"Continue with Atlas\" (when `settings().signInWithAtlas` is set): starts the\n   * SSO sign-in and sends the browser to Atlas.\n   */\n  async signInWithAtlas(connectionId: string): Promise<void> {\n    if (typeof window === 'undefined') return;\n    this.signInWithAtlasError.set(null);\n    const started = await startSignInWithAtlas(this.client, connectionId, window.location.href);\n    if ('url' in started) window.location.assign(started.url);\n    else this.signInWithAtlasError.set(started.error);\n  }\n\n  /** \"Sign in with a passkey\" is offered: the first step, the instance turned passkey sign-in on, and the browser can. */\n  passkeyOffered(): boolean {\n    return this.passkeySupported() && !this.state().attempt && this.settings()?.passkeySignIn === true;\n  }\n\n  /** What the app lets the MFA steps offer (from {@link settings}). */\n  mfaChoices(): MfaChoices {\n    return mfaChoicesFrom(this.settings()?.account);\n  }\n\n  /** Start the enrolment step for its attempt, or reset it once the flow leaves. */\n  private syncEnrollment(): void {\n    const attempt = this.state().attempt;\n    if (attempt?.status === 'needs_mfa_enrollment' && attempt.id) this.enrollment.start(attempt.id);\n    else this.enrollment.reset();\n  }\n\n  /** Fetch the instance's public settings and draw whatever captcha they require. */\n  async loadSettings(): Promise<void> {\n    const loaded = await fetchInstanceSettings(this.client);\n    if (loaded) {\n      this.settings.set(loaded);\n      this.syncCaptcha();\n      if (loaded.account.lastSignInMethod) this.lastMethod.set(await fetchLastSignInMethod(this.client));\n    }\n  }\n\n  /**\n   * The first factors to offer on a `needs_first_factor` step: the server's list\n   * without email code / link while the app cannot deliver email\n   * (`settings.emailDelivery.available === false`). Empty on any other step.\n   */\n  firstFactors(): string[] {\n    const attempt = this.state().attempt;\n    const step = attempt ? nextStep(attempt) : null;\n    if (step?.kind !== 'collect_first_factor') return [];\n    const offered = offeredFirstFactors(step.strategies, this.settings()?.emailDelivery);\n    const proof = this.holdProof();\n    return proof && !offered.includes(proof) ? [...offered, proof] : offered;\n  }\n\n  /**\n   * The emailed proof a password hold still waits on (`FlowState.passwordHold`): the\n   * code, or a link where the instance verifies by link only. Null with no hold, once\n   * proven, or while the app cannot deliver email.\n   */\n  holdProof(): 'email_code' | 'email_link' | null {\n    const hold = this.state().passwordHold;\n    if (!hold || hold.released || this.settings()?.emailDelivery?.available === false) return null;\n    return this.settings()?.account?.emailVerification === 'link' ? 'email_link' : 'email_code';\n  }\n\n  /** Back from the emailed factor to the password field. */\n  usePassword(): void {\n    this.preparedFactor.set(null);\n    this.state.update((current) => ({ ...current, prepared: null, pollSecret: null, errors: [] }));\n  }\n\n  /**\n   * True when email + password sign-up cannot complete because the app cannot\n   * send the verification email (`settings.emailDelivery.passwordSignUp === false`):\n   * `<atlas-sign-up>` shows the \"can't send email\" notice instead of the form.\n   */\n  signUpEmailUnavailable(): boolean {\n    return this.settings()?.emailDelivery.passwordSignUp === false;\n  }\n\n  /** False when a password reset email cannot be delivered — hide \"Forgot password?\". */\n  passwordResetAvailable(): boolean {\n    return this.settings()?.emailDelivery.passwordReset !== false;\n  }\n\n  /**\n   * Ask the server to email a sign-in code for the current `needs_first_factor`\n   * step (`POST …/prepare_first_factor`); the form then collects the code, which\n   * {@link submit} posts as the `email_code` strategy. While a password hold waits\n   * on it ({@link holdProof}), this emails that proof instead.\n   */\n  async prepare(strategy: 'email_code' | 'email_link'): Promise<void> {\n    if (!this.firstFactors().includes(strategy)) return;\n    const proof = this.holdProof();\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n    const next =\n      strategy === proof\n        ? await preparePasswordHoldProof(this.client, this.state(), proof)\n        : await prepareFactor(this.client, this.state(), strategy);\n    this.setState(next);\n    if (!next.errors.length) this.preparedFactor.set(strategy);\n    this.syncPolling();\n  }\n\n  /** Keep both captchas in step with the settings and the flow's current step. */\n  private syncCaptcha(): void {\n    const settings = this.settings();\n    const state = this.state();\n    this.captcha.configure(\n      signInCaptchaOptions(settings?.captchaFlows.signIn, state, () => void this.submit({})),\n    );\n    const signUpFlow = settings?.captchaFlows.signUp;\n    this.signUpCaptcha.configure({\n      flow: signUpFlow,\n      active: !state.attempt && flowNeedsCaptcha(signUpFlow),\n    });\n    this.captchaDrawn.set(this.captcha.needed);\n    this.signUpCaptchaDrawn.set(this.signUpCaptcha.needed);\n  }\n\n  private setState(next: FlowState): void {\n    const previous = this.state();\n    const previousId = previous.attempt?.id ?? null;\n    this.state.set(next);\n    // A proven hold goes back to the password field.\n    if (next.passwordHold?.released && !previous.passwordHold?.released) this.preparedFactor.set(null);\n    // A prepared factor belongs to the first-factor step it was sent for.\n    if (next.attempt?.status !== 'needs_first_factor') this.preparedFactor.set(null);\n    // An emailed second-factor code belongs to the second-factor step of this attempt.\n    if (next.attempt?.status !== 'needs_second_factor' || (next.attempt?.id ?? null) !== previousId) {\n      this.emailSecondFactor.set(null);\n      this.smsSecondFactor.set(null);\n    }\n    this.syncCaptcha();\n    this.syncEnrollment();\n    this.autoSend();\n  }\n\n  private autoSentFor: string | null = null;\n  /**\n   * With no password on offer, email the code as soon as the server asks for a\n   * first factor — once per attempt, so a failed send waits for the user's retry\n   * (the \"Email me a code\" button) instead of looping.\n   */\n  private autoSend(): void {\n    const id = this.state().attempt?.id ?? null;\n    if (!id || this.autoSentFor === id || this.preparedFactor()) return;\n    if (planFirstFactor(this.firstFactors()).autoSend !== 'email_code') return;\n    this.autoSentFor = id;\n    void this.prepare('email_code');\n  }\n\n  /**\n   * Advance the flow with the values the user typed. On completion, exchange the\n   * one-time ticket for cookies over a same-origin request (FAPI is cross-origin\n   * and cannot set the cookie on its own response), then re-boot so the rest of\n   * the app sees a signed-in user.\n   */\n  async submit(values: Record<string, string>): Promise<void> {\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n\n    // A code that lifts a password hold goes to its own attempt, not this sign-in.\n    if (this.preparedFactor() === 'email_code' && this.holdProof() === 'email_code') {\n      this.setState(await attemptPasswordHoldProof(this.client, this.state(), values.code ?? ''));\n      return;\n    }\n    const out = await advanceWithCaptcha(this.client, this.state(), values, {\n      captcha: this.captcha,\n      identifier: this.identifier,\n      t: this.t,\n    });\n    this.identifier = out.identifier;\n    await this.finish(out.state);\n  }\n\n  /** Load the sign-up's policies into {@link policies} (`<atlas-sign-up>` calls it on init). */\n  async loadPolicies(locale?: string): Promise<void> {\n    this.policies.setPolicies(await loadPolicies(this.client, { locale }));\n  }\n\n  /** The user declined a policy a sign-in was waiting on: cancel the attempt and say why. */\n  declinePolicy(title: string): void {\n    this.state.set({\n      ...initialFlow,\n      errors: [{ code: 'POLICY_DECLINED', message: this.t('policy.declined').replace('{policy}', title) }],\n    });\n  }\n\n  /**\n   * Create an account (`POST /v1/client/sign_ups`) from a create-account form's\n   * values — email, password and any configured sign-up fields — carrying the\n   * sign-up captcha's token when the instance requires one. The emailed code is\n   * then posted with {@link submit}.\n   */\n  async create(values: Record<string, string>, consent = true): Promise<void> {\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n    const next = await createSignUp(this.client, values, {\n      consent,\n      captcha: this.signUpCaptcha,\n      t: this.t,\n      policies: this.policies,\n    });\n    await this.finish(next);\n  }\n\n  /**\n   * \"Email me a code instead\" at the second factor (the instance's\n   * `account.emailSecondFactor`): mails a code to the account's verified email;\n   * it is then posted with {@link submit} like any 2FA code.\n   */\n  async sendEmailSecondFactor(): Promise<void> {\n    await this.sendSecondFactorCode('email_code', this.emailSecondFactor);\n  }\n\n  /**\n   * \"Text me a code instead\" at the second factor (where the app offers texted\n   * codes, {@link mfaChoices}`().sms`): texts a code to the account's enrolled\n   * phone; it is then posted with {@link submit} like any 2FA code.\n   */\n  async sendSmsSecondFactor(): Promise<void> {\n    await this.sendSecondFactorCode('sms', this.smsSecondFactor);\n  }\n\n  private async sendSecondFactorCode(\n    strategy: 'sms' | 'email_code',\n    out: WritableSignal<{ busy?: boolean; sentTo?: string; error?: string } | null>,\n  ): Promise<void> {\n    const id = this.state().attempt?.id;\n    if (!id) return;\n    out.set({ busy: true });\n    try {\n      const { sentTo } = await prepareSecondFactorCode(this.client, id, strategy);\n      out.set({ sentTo });\n    } catch (error) {\n      out.set({ error: error instanceof Error ? error.message : this.t('error.generic') });\n    }\n  }\n\n  /** Resend a sign-up's emailed code / link (the earlier one stops working). */\n  async resendSignUp(): Promise<void> {\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n    this.state.set(await resendSignUpVerification(this.client, this.state()));\n  }\n\n  /**\n   * Start a passkey-only sign-up (`POST /v1/client/sign_ups/passkey`) from the\n   * create-account form's values — no password. Offered when the instance's\n   * `account.passkeySignUp` is set.\n   */\n  async createWithPasskey(values: Record<string, string>, consent = true): Promise<void> {\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n    await this.finish(await createPasskeySignUp(this.client, values, { consent, captcha: this.signUpCaptcha, t: this.t, policies: this.policies }));\n  }\n\n  /** The passkey-only sign-up's last step: create the passkey, and with it the account. */\n  async createPasskey(): Promise<void> {\n    this.state.update((current) => ({ ...current, busy: true, errors: [] }));\n    await this.finish(await finishPasskeySignUp(this.client, this.state(), { t: this.t }));\n  }\n\n  /**\n   * The recovery codes an MFA enrolment just completed the sign-in with, shown\n   * once before it finishes ({@link saveRecoveryCodes}); null otherwise. They\n   * live only in this controller's memory.\n   */\n  recoveryCodes(): string[] | null {\n    return pendingRecoveryCodes(this.state());\n  }\n\n  /** \"I've saved my codes\": forget the recovery codes and finish the sign-in. */\n  async saveRecoveryCodes(): Promise<void> {\n    await this.finish(acknowledgeRecoveryCodes(this.state()));\n  }\n\n  /** The address belonged to an existing account: the notice is up until {@link continueAfterExistingAccount}. */\n  existingAccountNotice(): boolean {\n    return pendingExistingAccountNotice(this.state());\n  }\n\n  /** The user read the notice: finish the sign-up. */\n  async continueAfterExistingAccount(): Promise<void> {\n    await this.finish(acknowledgeExistingAccount(this.state()));\n  }\n\n  private async finish(next: FlowState): Promise<void> {\n    // An enrolment's recovery codes are shown first; `saveRecoveryCodes` finishes.\n    if (pendingRecoveryCodes(next)) {\n      // The ticket dies in 60 seconds and saving the codes can take longer: redeem it now,\n      // and `saveRecoveryCodes` finishes. A refused exchange keeps the ticket, so the save reports it.\n      this.setState({ ...next, busy: true });\n      const res = next.ticket\n        ? await this.client.post('/v1/client/tickets/exchange', { attempt_id: (next.attempt as { id?: string }).id, ticket: next.ticket })\n        : null;\n      this.setState({ ...next, busy: false, ticket: res?.ok ? null : next.ticket });\n      return;\n    }\n    if (next.attempt?.status === 'complete') {\n      // Stays busy until this browser actually holds the session: the completion\n      // alone says nothing about whether the cookie was kept.\n      this.setState({ ...next, busy: true });\n      let exchanged = true;\n      if (next.ticket) {\n        const res = await this.client.post('/v1/client/tickets/exchange', {\n          attempt_id: (next.attempt as { id?: string }).id,\n          ticket: next.ticket,\n        });\n        exchanged = res.ok;\n      }\n      if (exchanged && this.holdExistingAccountNotice && pendingExistingAccountNotice(next)) {\n        this.setState({ ...next, ticket: null, busy: false });\n        return;\n      }\n      const kept = exchanged && (await this.reload());\n      this.setState({ ...next, busy: false, sessionKept: kept });\n    } else {\n      this.setState(next);\n      // A magic-link step may now be pollable (a link opened on another device).\n      this.syncPolling();\n    }\n  }\n\n  /** Start/stop the §5.3 magic-link poll to match the current state. */\n  syncPolling(): void {\n    if (shouldKeepPolling(this.state())) {\n      this.startPolling();\n    } else {\n      this.stopPolling();\n    }\n  }\n\n  private startPolling(): void {\n    if (this.pollTimer) return;\n    this.pollTimer = setInterval(() => {\n      void (async () => {\n        const { state: next, ticket } = await pollAttempt(this.client, this.state());\n        this.setState(next);\n        // e.g. a passkey sign-up whose email was just proven: only this tab can go on.\n        if (!ticket && !shouldKeepPolling(next)) this.stopPolling();\n        if (!ticket || !next.attempt) return;\n\n        // The ticket is exchanged by a normal request, so no session token ever\n        // appears in a URL.\n        const res = await this.client.post('/v1/client/tickets/exchange', {\n          attempt_id: (next.attempt as { id?: string }).id,\n          ticket,\n        });\n        const kept = res.ok && (await this.reload());\n        this.setState({ ...this.state(), sessionKept: kept });\n        this.stopPolling();\n      })();\n    }, 2_000);\n  }\n\n  private stopPolling(): void {\n    if (this.pollTimer) {\n      clearInterval(this.pollTimer);\n      this.pollTimer = null;\n    }\n  }\n\n  /** Release the poll timer and the captcha widgets — call from the component's `ngOnDestroy`. */\n  destroy(): void {\n    this.passkey.stopAutofill();\n    this.stopPolling();\n    this.captcha.destroy();\n    this.signUpCaptcha.destroy();\n  }\n}\n"]}

package/dist/esm2022/lib/components/sign-in.component.mjs

@@ -108,6 +108,9 @@ export class SignInComponent {
       [captcha]="flow.captchaDrawn() ? flow.captcha : null"
       [firstFactors]="flow.firstFactors()"
       [preparedFactor]="flow.preparedFactor()"
+      [passwordHold]="flow.state().passwordHold ?? null"
+      [holdProof]="flow.holdProof()"
+      (usePassword)="flow.usePassword()"
       [offerEmailSecondFactor]="flow.settings()?.account?.emailSecondFactor === true"
       [emailedSecondFactor]="flow.emailSecondFactor()"
       (submitFlow)="submitIdentifier($event)"
@@ -137,7 +140,7 @@ export class SignInComponent {
         {{ t('signIn.noAccount') }} <a class="atlas-link" [href]="href">{{ t('signIn.signUpLink') }}</a>
       </p>
     }
-  `, isInline: true, dependencies: [{ kind: "component", type: AttemptFlowComponent, selector: "atlas-attempt-flow", inputs: ["attempt", "busy", "errors", "sessionKept", "titleKey", "captcha", "firstFactors", "preparedFactor", "offerEmailSecondFactor", "emailedSecondFactor", "offerSmsSecondFactor", "textedSecondFactor", "enrollment", "enrollmentState", "emailVerification"], outputs: ["submitFlow", "chooseFactor", "emailSecondFactor", "smsSecondFactor", "resend", "policyDeclined"] }, { kind: "component", type: RecoveryCodesComponent, selector: "atlas-recovery-codes", inputs: ["codes", "busy"], outputs: ["saved"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+  `, isInline: true, dependencies: [{ kind: "component", type: AttemptFlowComponent, selector: "atlas-attempt-flow", inputs: ["attempt", "busy", "errors", "sessionKept", "titleKey", "captcha", "firstFactors", "preparedFactor", "passwordHold", "holdProof", "offerEmailSecondFactor", "emailedSecondFactor", "offerSmsSecondFactor", "textedSecondFactor", "enrollment", "enrollmentState", "emailVerification"], outputs: ["submitFlow", "chooseFactor", "usePassword", "emailSecondFactor", "smsSecondFactor", "resend", "policyDeclined"] }, { kind: "component", type: RecoveryCodesComponent, selector: "atlas-recovery-codes", inputs: ["codes", "busy"], outputs: ["saved"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SignInComponent, decorators: [{
             type: Component,
@@ -172,6 +175,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
       [captcha]="flow.captchaDrawn() ? flow.captcha : null"
       [firstFactors]="flow.firstFactors()"
       [preparedFactor]="flow.preparedFactor()"
+      [passwordHold]="flow.state().passwordHold ?? null"
+      [holdProof]="flow.holdProof()"
+      (usePassword)="flow.usePassword()"
       [offerEmailSecondFactor]="flow.settings()?.account?.emailSecondFactor === true"
       [emailedSecondFactor]="flow.emailSecondFactor()"
       (submitFlow)="submitIdentifier($event)"
@@ -208,4 +214,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
             }], signUpUrl: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sign-in.component.js","sourceRoot":"","sources":["../../../../src/lib/components/sign-in.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  Input,\n  OnDestroy,\n  OnInit,\n  computed,\n  effect,\n  inject,\n} from '@angular/core';\nimport { lastUsedMethodLabel, passkeysSupported, signUp as hostedSignUp } from '@atlasauth/js';\nimport { AtlasService } from '../atlas.service';\nimport { translate } from '../i18n';\nimport { AttemptFlowComponent } from './attempt-flow.component';\nimport { RecoveryCodesComponent } from './recovery-codes.component';\nimport { AtlasFlowController } from './flow-controller';\n\n/**\n * `<atlas-sign-in>` — the full, multi-step sign-in flow driven entirely by the\n * server-side attempt status. The Angular peer of React's `<SignIn/>`. Draws the\n * instance's sign-in captcha when it is required (always-on, or a\n * `needs_captcha` challenge).\n *\n * ```html\n * <atlas-sign-in *atlasSignedOut afterUrl=\"/dashboard\"></atlas-sign-in>\n * ```\n */\n@Component({\n  selector: 'atlas-sign-in',\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [AttemptFlowComponent, RecoveryCodesComponent],\n  template: `\n    @if (lastUsedLabel(); as label) {\n      <p class=\"atlas-text atlas-last-used-hint\" data-atlas=\"last-used\" [attr.data-atlas-method]=\"flow.lastMethod()\">\n        {{ t('signIn.lastUsed') }}: {{ label }}\n      </p>\n    }\n    @if (atlasConnection(); as connectionId) {\n      <button type=\"button\" class=\"atlas-social-button\" data-atlas-provider=\"atlas\" (click)=\"flow.signInWithAtlas(connectionId)\">\n        {{ t('signIn.continueWithAtlas') }}\n      </button>\n      @if (flow.signInWithAtlasError(); as message) {\n        <p class=\"atlas-error\" role=\"alert\">{{ message }}</p>\n      }\n    }\n    @if (flow.recoveryCodes(); as codes) {\n      <atlas-recovery-codes [codes]=\"codes\" [busy]=\"flow.state().busy\" (saved)=\"flow.saveRecoveryCodes()\"></atlas-recovery-codes>\n    } @else {\n    <atlas-attempt-flow\n      [attempt]=\"flow.state().attempt\"\n      [busy]=\"flow.state().busy\"\n      [errors]=\"flow.state().errors\"\n      [sessionKept]=\"flow.state().sessionKept\"\n      titleKey=\"signIn.title\"\n      [captcha]=\"flow.captchaDrawn() ? flow.captcha : null\"\n      [firstFactors]=\"flow.firstFactors()\"\n      [preparedFactor]=\"flow.preparedFactor()\"\n      [offerEmailSecondFactor]=\"flow.settings()?.account?.emailSecondFactor === true\"\n      [emailedSecondFactor]=\"flow.emailSecondFactor()\"\n      (submitFlow)=\"submitIdentifier($event)\"\n      (chooseFactor)=\"flow.prepare($event)\"\n      [offerSmsSecondFactor]=\"flow.settings() !== null && flow.mfaChoices().sms\"\n      [textedSecondFactor]=\"flow.smsSecondFactor()\"\n      [enrollment]=\"flow.enrollment\"\n      [enrollmentState]=\"flow.enrollmentState()\"\n      (emailSecondFactor)=\"flow.sendEmailSecondFactor()\"\n      (smsSecondFactor)=\"flow.sendSmsSecondFactor()\"\n      (policyDeclined)=\"flow.declinePolicy($event)\"\n    ></atlas-attempt-flow>\n    }\n    @if (flow.passkeyOffered() && !flow.recoveryCodes()) {\n      <button\n        type=\"button\"\n        class=\"atlas-social-button atlas-passkey-button\"\n        data-atlas-passkey-sign-in=\"\"\n        [disabled]=\"flow.state().busy\"\n        (click)=\"flow.passkey.signIn()\"\n      >\n        {{ t('signIn.passkeyButton') }}\n      </button>\n    }\n    @if (flow.state().attempt?.status !== 'complete' && signUpHref(); as href) {\n      <p class=\"atlas-footer\" data-atlas-sign-up-prompt=\"\">\n        {{ t('signIn.noAccount') }} <a class=\"atlas-link\" [href]=\"href\">{{ t('signIn.signUpLink') }}</a>\n      </p>\n    }\n  `,\n})\nexport class SignInComponent implements OnInit, OnDestroy {\n  private readonly atlas = inject(AtlasService);\n\n  /** Where to send the user once the flow completes. Reserved for host routing. */\n  @Input() afterUrl?: string;\n  /**\n   * Where \"No account? Sign up\" goes. Default: the instance's hosted sign-up\n   * page (carrying the visitor's referral). `null` hides it. Always shown, never\n   * only after a failed sign-in, so it says nothing about whether an email has an account.\n   */\n  @Input() signUpUrl?: string | null;\n\n  protected t(key: string): string {\n    return translate(this.atlas.localization, key);\n  }\n\n  /** \"Last used: Password\" on the identifier step, when the instance shows the hint. */\n  protected lastUsedLabel(): string | null {\n    if (this.flow.state().attempt) return null;\n    return lastUsedMethodLabel(this.flow.lastMethod(), (key) => this.t(key));\n  }\n\n  /** The \"Sign in with Atlas\" connection, on the first step, when the instance has it on. */\n  protected atlasConnection(): string | null {\n    if (this.flow.state().attempt || this.flow.recoveryCodes()) return null;\n    return this.flow.settings()?.signInWithAtlas?.connectionId ?? null;\n  }\n\n  protected signUpHref(): string | null {\n    if (this.signUpUrl === null) return null;\n    if (this.signUpUrl) return this.signUpUrl;\n    try {\n      return hostedSignUp({\n        frontendApi: this.atlas.frontendApi,\n        redirectUrl: this.afterUrl ?? (typeof window !== 'undefined' ? window.location.href : undefined),\n        navigate: false,\n      });\n    } catch {\n      return null;\n    }\n  }\n\n  protected readonly flow = new AtlasFlowController(\n    this.atlas.createFapiClient(),\n    () => this.atlas.reload(),\n    // Resume mid-flow if an OAuth redirect came back owing a second factor.\n    this.atlas.pendingAttempt,\n    (key) => translate(this.atlas.localization, key),\n  );\n\n  // Passkey autofill runs while the first step offers passkeys (a computed, so it re-arms only when that changes).\n  private readonly passkeyOffered = computed(() => this.flow.passkeyOffered());\n  protected readonly passkeyAutofill = effect(() => (this.passkeyOffered() ? this.flow.passkey.armAutofill() : this.flow.passkey.stopAutofill()));\n\n  protected submitIdentifier(values: Record<string, string>): void {\n    this.flow.passkey.stopAutofill();\n    void this.flow.submit(values);\n  }\n\n  ngOnInit(): void {\n    if (typeof window !== 'undefined') this.flow.passkeySupported.set(passkeysSupported());\n    // If seeded from a pending attempt that is already pollable, start polling.\n    this.flow.syncPolling();\n    // §5 the instance's captcha settings (switching captcha on in the dashboard\n    // draws it here with no code change) and email delivery (no emailed-code\n    // option while the app cannot send email).\n    if (typeof window !== 'undefined') void this.flow.loadSettings();\n  }\n\n  ngOnDestroy(): void {\n    this.flow.destroy();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sign-in.component.js","sourceRoot":"","sources":["../../../../src/lib/components/sign-in.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  Input,\n  OnDestroy,\n  OnInit,\n  computed,\n  effect,\n  inject,\n} from '@angular/core';\nimport { lastUsedMethodLabel, passkeysSupported, signUp as hostedSignUp } from '@atlasauth/js';\nimport { AtlasService } from '../atlas.service';\nimport { translate } from '../i18n';\nimport { AttemptFlowComponent } from './attempt-flow.component';\nimport { RecoveryCodesComponent } from './recovery-codes.component';\nimport { AtlasFlowController } from './flow-controller';\n\n/**\n * `<atlas-sign-in>` — the full, multi-step sign-in flow driven entirely by the\n * server-side attempt status. The Angular peer of React's `<SignIn/>`. Draws the\n * instance's sign-in captcha when it is required (always-on, or a\n * `needs_captcha` challenge).\n *\n * ```html\n * <atlas-sign-in *atlasSignedOut afterUrl=\"/dashboard\"></atlas-sign-in>\n * ```\n */\n@Component({\n  selector: 'atlas-sign-in',\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [AttemptFlowComponent, RecoveryCodesComponent],\n  template: `\n    @if (lastUsedLabel(); as label) {\n      <p class=\"atlas-text atlas-last-used-hint\" data-atlas=\"last-used\" [attr.data-atlas-method]=\"flow.lastMethod()\">\n        {{ t('signIn.lastUsed') }}: {{ label }}\n      </p>\n    }\n    @if (atlasConnection(); as connectionId) {\n      <button type=\"button\" class=\"atlas-social-button\" data-atlas-provider=\"atlas\" (click)=\"flow.signInWithAtlas(connectionId)\">\n        {{ t('signIn.continueWithAtlas') }}\n      </button>\n      @if (flow.signInWithAtlasError(); as message) {\n        <p class=\"atlas-error\" role=\"alert\">{{ message }}</p>\n      }\n    }\n    @if (flow.recoveryCodes(); as codes) {\n      <atlas-recovery-codes [codes]=\"codes\" [busy]=\"flow.state().busy\" (saved)=\"flow.saveRecoveryCodes()\"></atlas-recovery-codes>\n    } @else {\n    <atlas-attempt-flow\n      [attempt]=\"flow.state().attempt\"\n      [busy]=\"flow.state().busy\"\n      [errors]=\"flow.state().errors\"\n      [sessionKept]=\"flow.state().sessionKept\"\n      titleKey=\"signIn.title\"\n      [captcha]=\"flow.captchaDrawn() ? flow.captcha : null\"\n      [firstFactors]=\"flow.firstFactors()\"\n      [preparedFactor]=\"flow.preparedFactor()\"\n      [passwordHold]=\"flow.state().passwordHold ?? null\"\n      [holdProof]=\"flow.holdProof()\"\n      (usePassword)=\"flow.usePassword()\"\n      [offerEmailSecondFactor]=\"flow.settings()?.account?.emailSecondFactor === true\"\n      [emailedSecondFactor]=\"flow.emailSecondFactor()\"\n      (submitFlow)=\"submitIdentifier($event)\"\n      (chooseFactor)=\"flow.prepare($event)\"\n      [offerSmsSecondFactor]=\"flow.settings() !== null && flow.mfaChoices().sms\"\n      [textedSecondFactor]=\"flow.smsSecondFactor()\"\n      [enrollment]=\"flow.enrollment\"\n      [enrollmentState]=\"flow.enrollmentState()\"\n      (emailSecondFactor)=\"flow.sendEmailSecondFactor()\"\n      (smsSecondFactor)=\"flow.sendSmsSecondFactor()\"\n      (policyDeclined)=\"flow.declinePolicy($event)\"\n    ></atlas-attempt-flow>\n    }\n    @if (flow.passkeyOffered() && !flow.recoveryCodes()) {\n      <button\n        type=\"button\"\n        class=\"atlas-social-button atlas-passkey-button\"\n        data-atlas-passkey-sign-in=\"\"\n        [disabled]=\"flow.state().busy\"\n        (click)=\"flow.passkey.signIn()\"\n      >\n        {{ t('signIn.passkeyButton') }}\n      </button>\n    }\n    @if (flow.state().attempt?.status !== 'complete' && signUpHref(); as href) {\n      <p class=\"atlas-footer\" data-atlas-sign-up-prompt=\"\">\n        {{ t('signIn.noAccount') }} <a class=\"atlas-link\" [href]=\"href\">{{ t('signIn.signUpLink') }}</a>\n      </p>\n    }\n  `,\n})\nexport class SignInComponent implements OnInit, OnDestroy {\n  private readonly atlas = inject(AtlasService);\n\n  /** Where to send the user once the flow completes. Reserved for host routing. */\n  @Input() afterUrl?: string;\n  /**\n   * Where \"No account? Sign up\" goes. Default: the instance's hosted sign-up\n   * page (carrying the visitor's referral). `null` hides it. Always shown, never\n   * only after a failed sign-in, so it says nothing about whether an email has an account.\n   */\n  @Input() signUpUrl?: string | null;\n\n  protected t(key: string): string {\n    return translate(this.atlas.localization, key);\n  }\n\n  /** \"Last used: Password\" on the identifier step, when the instance shows the hint. */\n  protected lastUsedLabel(): string | null {\n    if (this.flow.state().attempt) return null;\n    return lastUsedMethodLabel(this.flow.lastMethod(), (key) => this.t(key));\n  }\n\n  /** The \"Sign in with Atlas\" connection, on the first step, when the instance has it on. */\n  protected atlasConnection(): string | null {\n    if (this.flow.state().attempt || this.flow.recoveryCodes()) return null;\n    return this.flow.settings()?.signInWithAtlas?.connectionId ?? null;\n  }\n\n  protected signUpHref(): string | null {\n    if (this.signUpUrl === null) return null;\n    if (this.signUpUrl) return this.signUpUrl;\n    try {\n      return hostedSignUp({\n        frontendApi: this.atlas.frontendApi,\n        redirectUrl: this.afterUrl ?? (typeof window !== 'undefined' ? window.location.href : undefined),\n        navigate: false,\n      });\n    } catch {\n      return null;\n    }\n  }\n\n  protected readonly flow = new AtlasFlowController(\n    this.atlas.createFapiClient(),\n    () => this.atlas.reload(),\n    // Resume mid-flow if an OAuth redirect came back owing a second factor.\n    this.atlas.pendingAttempt,\n    (key) => translate(this.atlas.localization, key),\n  );\n\n  // Passkey autofill runs while the first step offers passkeys (a computed, so it re-arms only when that changes).\n  private readonly passkeyOffered = computed(() => this.flow.passkeyOffered());\n  protected readonly passkeyAutofill = effect(() => (this.passkeyOffered() ? this.flow.passkey.armAutofill() : this.flow.passkey.stopAutofill()));\n\n  protected submitIdentifier(values: Record<string, string>): void {\n    this.flow.passkey.stopAutofill();\n    void this.flow.submit(values);\n  }\n\n  ngOnInit(): void {\n    if (typeof window !== 'undefined') this.flow.passkeySupported.set(passkeysSupported());\n    // If seeded from a pending attempt that is already pollable, start polling.\n    this.flow.syncPolling();\n    // §5 the instance's captcha settings (switching captcha on in the dashboard\n    // draws it here with no code change) and email delivery (no emailed-code\n    // option while the app cannot send email).\n    if (typeof window !== 'undefined') void this.flow.loadSettings();\n  }\n\n  ngOnDestroy(): void {\n    this.flow.destroy();\n  }\n}\n"]}