fix(auth): preserve phone login identity across step8 retries

background.js

@@ -2993,14 +2993,22 @@ function isPhoneActivationForNumber(activation, phoneNumber) {
 
 async function setEmailStateSilently(email, options = {}) {
   const currentState = await getState();
-  const updates = buildRegistrationEmailStateUpdates(currentState, {
+  const preserveAccountIdentity = Boolean(options?.preserveAccountIdentity);
-    currentEmail: email,
+  const updates = preserveAccountIdentity
-    preservePrevious: Boolean(options?.preservePrevious),
+    ? buildFlowRegistrationEmailStateUpdates(currentState, {
-    source: options?.source || '',
+        currentEmail: email,
-  });
+        preservePrevious: Boolean(options?.preservePrevious),
+        preserveAccountIdentity: true,
+        source: options?.source || '',
+      })
+    : buildRegistrationEmailStateUpdates(currentState, {
+        currentEmail: email,
+        preservePrevious: Boolean(options?.preservePrevious),
+        source: options?.source || '',
+      });
   const normalizedEmail = updates.email;
 
-  if (normalizedEmail) {
+  if (!preserveAccountIdentity && normalizedEmail) {
     updates.accountIdentifierType = 'email';
     updates.accountIdentifier = normalizedEmail;
     updates.phoneNumber = '';
@@ -3009,7 +3017,7 @@ async function setEmailStateSilently(email, options = {}) {
     updates.signupPhoneCompletedActivation = null;
     updates.signupPhoneVerificationRequestedAt = null;
     updates.signupPhoneVerificationPurpose = '';
-  } else if (String(currentState?.accountIdentifierType || '').trim().toLowerCase() === 'email') {
+  } else if (!preserveAccountIdentity && String(currentState?.accountIdentifierType || '').trim().toLowerCase() === 'email') {
     updates.accountIdentifierType = null;
     updates.accountIdentifier = '';
   }

background/steps/fetch-login-code.js

@@ -31,6 +31,7 @@
       reuseOrCreateTab,
       sendToContentScriptResilient,
       buildRegistrationEmailStateUpdates = null,
+      persistRegistrationEmailState = null,
       phoneVerificationHelpers = null,
       setState,
       shouldUseCustomRegistrationEmail,
@@ -181,10 +182,17 @@
       }
 
       const displayedEmail = normalizeStep8VerificationTargetEmail(result?.displayedEmail || resolvedEmail);
-      await setState({
+      if (typeof persistRegistrationEmailState === 'function') {
-        email: resolvedEmail,
+        await persistRegistrationEmailState(latestState, resolvedEmail, {
-        step8VerificationTargetEmail: displayedEmail,
+          source: 'step8_add_email',
-      });
+          preserveAccountIdentity: true,
+        });
+      } else {
+        await setState({
+          email: resolvedEmail,
+          step8VerificationTargetEmail: displayedEmail,
+        });
+      }
 
       return {
         state: {
@@ -535,6 +543,8 @@
           }
         },
         targetEmail: fixedTargetEmail,
+        maxResendRequests: mail.provider === '2925' ? 1 : undefined,
+        initialPollMaxAttempts: mail.provider === '2925' ? 5 : undefined,
         resendIntervalMs: mail.provider === LUCKMAIL_PROVIDER
           ? 15000
           : ((mail.provider === HOTMAIL_PROVIDER || mail.provider === '2925')

background/steps/oauth-login.js

@@ -71,9 +71,7 @@
     }
 
     function shouldPreferStep7PhoneSignupIdentity(state = {}) {
-      const frozenSignupMethod = normalizeStep7IdentifierType(state?.resolvedSignupMethod);
       return canUseConfiguredPhoneSignup(state)
-        && frozenSignupMethod !== 'email'
         && hasStep7PhoneSignupIdentity(state);
     }
 

background/verification-flow.js

@@ -874,6 +874,7 @@
         onResendRequestedAt,
         maxRounds: _ignoredMaxRounds,
         maxResendRequests: _ignoredMaxResendRequests,
+        initialPollMaxAttempts: _ignoredInitialPollMaxAttempts,
         ...cleanPollOverrides
       } = pollOverrides;
       const basePayload = {
@@ -927,6 +928,7 @@
         onResendRequestedAt,
         maxRounds: _ignoredMaxRounds,
         maxResendRequests: _ignoredMaxResendRequests,
+        initialPollMaxAttempts: _ignoredInitialPollMaxAttempts,
         ...cleanPollOverrides
       } = pollOverrides;
 
@@ -982,6 +984,7 @@
       let filterAfterTimestamp = cleanPollOverrides.filterAfterTimestamp ?? getVerificationPollPayload(step, state).filterAfterTimestamp;
       const maxResendRequests = resolveMaxResendRequests(pollOverrides);
       const maxRounds = maxResendRequests + 1;
+      const initialPollMaxAttempts = Math.max(0, Math.floor(Number(pollOverrides.initialPollMaxAttempts) || 0));
       let usedResendRequests = 0;
 
       for (let round = 1; round <= maxRounds; round++) {
@@ -1002,6 +1005,9 @@
           filterAfterTimestamp,
           excludeCodes: [...rejectedCodes],
         });
+        if (round === 1 && initialPollMaxAttempts > 0) {
+          payload.maxAttempts = initialPollMaxAttempts;
+        }
 
         try {
           const timedPoll = await applyMailPollingTimeBudget(
@@ -1307,6 +1313,7 @@
             disableTimeBudgetCap: Boolean(options.disableTimeBudgetCap),
             getRemainingTimeMs: options.getRemainingTimeMs,
             maxResendRequests: remainingAutomaticResendCount,
+            initialPollMaxAttempts: options.initialPollMaxAttempts,
             resendIntervalMs,
             lastResendAt,
             onResendRequestedAt: updateFilterAfterTimestampForVerificationStep,

tests/background-step6-retry-limit.test.js

@@ -592,7 +592,7 @@ test('step 7 keeps phone login after step 8 stores an unbound email for phone si
   const phoneSignupState = {
     phoneVerificationEnabled: true,
     signupMethod: 'phone',
-    resolvedSignupMethod: 'phone',
+    resolvedSignupMethod: 'email',
     email: 'bound.step8@example.com',
     accountIdentifierType: 'email',
     accountIdentifier: 'bound.step8@example.com',

tests/background-step7-recovery.test.js

@@ -266,6 +266,7 @@ test('step 8 submits add-email before polling the email verification code', asyn
     resolvedStates: [],
     setStates: [],
     mailStates: [],
+    persistCalls: [],
   };
 
   const executor = api.createStep8Executor({
@@ -300,6 +301,9 @@ test('step 8 submits add-email before polling the email verification code', asyn
     isTabAlive: async () => true,
     isVerificationMailPollingError: () => false,
     LUCKMAIL_PROVIDER: 'luckmail-api',
+    persistRegistrationEmailState: async (state, email, options) => {
+      calls.persistCalls.push({ state, email, options });
+    },
     resolveSignupEmailForFlow: async (state, options = {}) => {
       calls.resolvedStates.push(state);
       calls.resolveOptions = options;
@@ -338,14 +342,14 @@ test('step 8 submits add-email before polling the email verification code', asyn
   assert.equal(calls.contentMessages.length, 1);
   assert.equal(calls.resolvedStates.length, 1);
   assert.equal(calls.resolveOptions.preserveAccountIdentity, true);
+  assert.equal(calls.persistCalls.length, 1);
+  assert.equal(calls.persistCalls[0].email, 'new.user@example.com');
+  assert.equal(calls.persistCalls[0].options.preserveAccountIdentity, true);
+  assert.equal(calls.persistCalls[0].options.source, 'step8_add_email');
   assert.equal(calls.mailStates[0].email, 'new.user@example.com');
   assert.equal(calls.resolvedVerification.state.email, 'new.user@example.com');
   assert.equal(calls.resolvedVerification.options.targetEmail, 'new.user@example.com');
   assert.deepStrictEqual(calls.setStates, [
-    {
-      email: 'new.user@example.com',
-      step8VerificationTargetEmail: 'new.user@example.com',
-    },
     {
       step8VerificationTargetEmail: 'new.user@example.com',
     },
@@ -407,6 +411,14 @@ test('step 8 reruns step 7 with preserved phone login identity after add-email v
     isTabAlive: async () => true,
     isVerificationMailPollingError: () => false,
     LUCKMAIL_PROVIDER: 'luckmail-api',
+    persistRegistrationEmailState: async (_state, email, options) => {
+      assert.equal(email, 'new.user@example.com');
+      assert.equal(options.preserveAccountIdentity, true);
+      runtimeState = {
+        ...runtimeState,
+        email,
+      };
+    },
     resolveSignupEmailForFlow: async (_state, options = {}) => {
       assert.equal(options.preserveAccountIdentity, true);
       runtimeState = {
@@ -944,7 +956,7 @@ test('step 8 completes when polling fails but recovery probe shows oauth consent
   ]);
 });
 
-test('step 8 uses a fixed 10-minute lookback window and disables resend interval for 2925 mailbox polling', async () => {
+test('step 8 uses a fixed 10-minute lookback window and delays 2925 resend until after one full poll', async () => {
   let capturedOptions = null;
   let ensureCalls = 0;
   let ensureOptions = null;
@@ -1036,6 +1048,8 @@ test('step 8 uses a fixed 10-minute lookback window and disables resend interval
   ]);
   assert.equal(capturedOptions.filterAfterTimestamp, 300000);
   assert.equal(capturedOptions.resendIntervalMs, 0);
+  assert.equal(capturedOptions.maxResendRequests, 1);
+  assert.equal(capturedOptions.initialPollMaxAttempts, 5);
   assert.equal(capturedOptions.targetEmail, '');
   assert.equal(capturedOptions.beforeSubmit, undefined);
   assert.equal(typeof capturedOptions.getRemainingTimeMs, 'function');

tests/verification-flow-polling.test.js

@@ -835,6 +835,77 @@ test('verification flow keeps 2925 mailbox polling at 15 refresh attempts even w
   assert.ok(pollCall.options.timeoutMs >= 250000);
 });
 
+test('verification flow delays 2925 login resend until after the first full mailbox poll fails', async () => {
+  const events = [];
+  const pollMaxAttempts = [];
+  let pollCalls = 0;
+
+  const helpers = api.createVerificationFlowHelpers({
+    addLog: async () => {},
+    chrome: { tabs: { update: async () => {} } },
+    CLOUDFLARE_TEMP_EMAIL_PROVIDER: 'cloudflare-temp-email',
+    completeStepFromBackground: async () => {},
+    confirmCustomVerificationStepBypassRequest: async () => ({ confirmed: true }),
+    getHotmailVerificationPollConfig: () => ({}),
+    getHotmailVerificationRequestTimestamp: () => 0,
+    getState: async () => ({}),
+    getTabId: async () => 1,
+    HOTMAIL_PROVIDER: 'hotmail-api',
+    isStopError: () => false,
+    LUCKMAIL_PROVIDER: 'luckmail-api',
+    MAIL_2925_VERIFICATION_INTERVAL_MS: 15000,
+    MAIL_2925_VERIFICATION_MAX_ATTEMPTS: 15,
+    pollCloudflareTempEmailVerificationCode: async () => ({}),
+    pollHotmailVerificationCode: async () => ({}),
+    pollLuckmailVerificationCode: async () => ({}),
+    sendToContentScript: async (_source, message) => {
+      if (message.type === 'RESEND_VERIFICATION_CODE') {
+        events.push('resend');
+        return { resent: true };
+      }
+      if (message.type === 'FILL_CODE') {
+        events.push('fill');
+      }
+      return {};
+    },
+    sendToContentScriptResilient: async () => ({}),
+    sendToMailContentScriptResilient: async (_mail, message) => {
+      events.push('poll');
+      pollMaxAttempts.push(message.payload.maxAttempts);
+      pollCalls += 1;
+      return pollCalls === 1
+        ? { error: '步骤 8：邮箱轮询结束，但未获取到验证码。' }
+        : { code: '654321', emailTimestamp: 123 };
+    },
+    setState: async () => {},
+    setStepStatus: async () => {},
+    sleepWithStop: async () => {},
+    throwIfStopped: () => {},
+    VERIFICATION_POLL_MAX_ROUNDS: 5,
+  });
+
+  await helpers.resolveVerificationStep(
+    8,
+    {
+      email: 'user@example.com',
+      mailProvider: '2925',
+      lastLoginCode: null,
+    },
+    { provider: '2925', label: '2925 邮箱' },
+    {
+      maxResendRequests: 1,
+      initialPollMaxAttempts: 5,
+      requestFreshCodeFirst: false,
+      filterAfterTimestamp: 123,
+      resendIntervalMs: 0,
+    }
+  );
+
+  assert.deepStrictEqual(events.slice(0, 3), ['poll', 'resend', 'poll']);
+  assert.deepStrictEqual(pollMaxAttempts.slice(0, 2), [5, 15]);
+  assert.equal(events.filter((event) => event === 'resend').length, 1);
+});
+
 test('verification flow keeps Hotmail request timestamp filtering on the first poll', async () => {
   const pollPayloads = [];