Add independent PayPal hosted binding mode

tests/background-account-history-settings.test.js

@@ -230,6 +230,7 @@ return {
   assert.equal(api.normalizePersistentSettingValue('phoneSignupReloginAfterBindEmailEnabled', 0), false);
   assert.equal(api.normalizePersistentSettingValue('plusPaymentMethod', 'gopay'), 'gopay');
   assert.equal(api.normalizePersistentSettingValue('plusPaymentMethod', 'gpc-helper'), 'gpc-helper');
+  assert.equal(api.normalizePersistentSettingValue('plusPaymentMethod', 'paypal-hosted'), 'paypal-hosted');
   assert.equal(api.normalizePersistentSettingValue('plusPaymentMethod', 'paypal'), 'paypal');
   assert.equal(api.normalizePersistentSettingValue('plusPaymentMethod', 'unknown'), 'paypal');
   assert.equal(api.normalizePersistentSettingValue('plusAccountAccessStrategy', 'sub2api_codex_session'), 'sub2api_codex_session');

tests/flow-capabilities-module.test.js

@@ -212,7 +212,7 @@ test('flow capability registry exposes editable Plus account access strategies f
 
   assert.deepEqual(
     capabilityState.availablePlusAccountAccessStrategies,
-    ['oauth', 'sub2api_codex_session']
+    ['oauth', 'cpa_codex_session', 'sub2api_codex_session']
   );
   assert.equal(capabilityState.requestedPlusAccountAccessStrategy, 'sub2api_codex_session');
   assert.equal(capabilityState.effectivePlusAccountAccessStrategy, 'sub2api_codex_session');
@@ -236,7 +236,7 @@ test('flow capability registry exposes editable Plus account access strategies f
 
   assert.deepEqual(
     capabilityState.availablePlusAccountAccessStrategies,
-    ['oauth', 'cpa_codex_session']
+    ['oauth', 'cpa_codex_session', 'sub2api_codex_session']
   );
   assert.equal(capabilityState.requestedPlusAccountAccessStrategy, 'cpa_codex_session');
   assert.equal(capabilityState.effectivePlusAccountAccessStrategy, 'cpa_codex_session');
@@ -244,7 +244,7 @@ test('flow capability registry exposes editable Plus account access strategies f
   assert.equal(capabilityState.stepDefinitionOptions.plusAccountAccessStrategy, 'cpa_codex_session');
 });
 
-test('flow capability registry forces OAuth when the current target only supports OAuth', () => {
+test('flow capability registry keeps Plus account access strategies independent from the current target', () => {
   const api = loadApi();
   const registry = api.createFlowCapabilityRegistry();
 
@@ -258,9 +258,34 @@ test('flow capability registry forces OAuth when the current target only support
     },
   });
 
-  assert.deepEqual(capabilityState.availablePlusAccountAccessStrategies, ['oauth']);
+  assert.deepEqual(
+    capabilityState.availablePlusAccountAccessStrategies,
+    ['oauth', 'cpa_codex_session', 'sub2api_codex_session']
+  );
   assert.equal(capabilityState.requestedPlusAccountAccessStrategy, 'cpa_codex_session');
-  assert.equal(capabilityState.effectivePlusAccountAccessStrategy, 'oauth');
-  assert.equal(capabilityState.canEditPlusAccountAccessStrategy, false);
-  assert.equal(capabilityState.stepDefinitionOptions.plusAccountAccessStrategy, 'oauth');
+  assert.equal(capabilityState.effectivePlusAccountAccessStrategy, 'cpa_codex_session');
+  assert.equal(capabilityState.canEditPlusAccountAccessStrategy, true);
+  assert.equal(capabilityState.stepDefinitionOptions.plusAccountAccessStrategy, 'cpa_codex_session');
+});
+
+test('flow capability registry forces SUB2API session import only for contribution mode Plus runs', () => {
+  const api = loadApi();
+  const registry = api.createFlowCapabilityRegistry();
+
+  const capabilityState = registry.resolveSidepanelCapabilities({
+    state: {
+      activeFlowId: 'openai',
+      openaiIntegrationTargetId: 'cpa',
+      signupMethod: 'email',
+      plusModeEnabled: true,
+      accountContributionEnabled: true,
+      plusAccountAccessStrategy: 'cpa_codex_session',
+    },
+  });
+
+  assert.deepEqual(capabilityState.availablePlusAccountAccessStrategies, ['sub2api_codex_session']);
+  assert.equal(capabilityState.requestedPlusAccountAccessStrategy, 'cpa_codex_session');
+  assert.equal(capabilityState.effectivePlusAccountAccessStrategy, 'sub2api_codex_session');
+  assert.equal(capabilityState.canEditPlusAccountAccessStrategy, false);
+  assert.equal(capabilityState.stepDefinitionOptions.plusAccountAccessStrategy, 'sub2api_codex_session');
 });

tests/gopay-utils.test.js

@@ -23,6 +23,8 @@ test('GoPay utils normalize manual OTP input', () => {
 
 test('GoPay utils keeps GPC helper payment method distinct', () => {
   const api = loadGoPayUtils();
+  assert.equal(api.normalizePlusPaymentMethod('paypal-hosted'), 'paypal-hosted');
+  assert.equal(api.normalizePlusPaymentMethod('paypal_direct'), 'paypal-hosted');
   assert.equal(api.normalizePlusPaymentMethod('gpc-helper'), 'gpc-helper');
   assert.equal(api.normalizePlusPaymentMethod('gopay'), 'gopay');
   assert.equal(api.normalizePlusPaymentMethod('unknown'), 'paypal');

tests/plus-account-access-strategy.test.js

@@ -115,19 +115,21 @@ return {
 `)();
 }
 
-test('sidepanel keeps requested Plus account strategy while OAuth-only targets force the effective value', () => {
+test('sidepanel keeps requested Plus account strategy while contribution mode forces SUB2API', () => {
   const api = buildHarness(
     `{
       canShowPlusSettings: true,
-      runtimeLocks: { plusModeEnabled: true },
+      runtimeLocks: { plusModeEnabled: true, accountContribution: true },
       canEditPlusAccountAccessStrategy: false,
-      effectivePlusAccountAccessStrategy: 'oauth',
+      availablePlusAccountAccessStrategies: ['sub2api_codex_session'],
+      effectivePlusAccountAccessStrategy: 'sub2api_codex_session',
     }`,
     `{
       activeFlowId: 'openai',
       panelMode: 'cpa',
       plusPaymentMethod: 'paypal',
-      plusAccountAccessStrategy: 'sub2api_codex_session',
+      accountContributionEnabled: true,
+      plusAccountAccessStrategy: 'cpa_codex_session',
     }`
   );
 
@@ -135,10 +137,10 @@ test('sidepanel keeps requested Plus account strategy while OAuth-only targets f
 
   assert.equal(api.rowPlusAccountAccessStrategy.style.display, '');
   assert.equal(api.selectPlusAccountAccessStrategy.disabled, true);
-  assert.equal(api.selectPlusAccountAccessStrategy.dataset.requestedValue, 'sub2api_codex_session');
-  assert.equal(api.selectPlusAccountAccessStrategy.value, 'oauth');
-  assert.equal(api.getRequestedPlusAccountAccessStrategy(), 'sub2api_codex_session');
-  assert.match(api.plusAccountAccessStrategyCaption.textContent, /OAuth/);
+  assert.equal(api.selectPlusAccountAccessStrategy.dataset.requestedValue, 'cpa_codex_session');
+  assert.equal(api.selectPlusAccountAccessStrategy.value, 'sub2api_codex_session');
+  assert.equal(api.getRequestedPlusAccountAccessStrategy(), 'cpa_codex_session');
+  assert.match(api.plusAccountAccessStrategyCaption.textContent, /SUB2API/);
 });
 
 test('sidepanel enables SUB2API session strategy selection when the current Plus target supports it', () => {
@@ -283,6 +285,7 @@ return {
         plusAccountAccessStrategy: 'sub2api_codex_session',
         signupMethod: 'email',
         phoneSignupReloginAfterBindEmailEnabled: false,
+        accountContributionEnabled: false,
       },
     },
     {
@@ -294,6 +297,7 @@ return {
         plusAccountAccessStrategy: 'sub2api_codex_session',
         signupMethod: 'email',
         phoneSignupReloginAfterBindEmailEnabled: false,
+        accountContributionEnabled: false,
       },
     },
   ]);

tests/plus-checkout-address-input.test.js

@@ -38,7 +38,7 @@ test('plus checkout content script can be injected repeatedly on the same page',
   assert.equal(context.__MULTIPAGE_PLUS_CHECKOUT_READY__, true);
 });
 
-function createPlusCheckoutMessageHarness({ checkoutSessionId = 'cs_test_123' } = {}) {
+function createPlusCheckoutMessageHarness({ checkoutSessionId = 'cs_test_123', checkoutResponse = null } = {}) {
   const attrs = new Map();
   let listener = null;
   const fetchCalls = [];
@@ -84,7 +84,7 @@ function createPlusCheckoutMessageHarness({ checkoutSessionId = 'cs_test_123' }
         return {
           ok: true,
           status: 200,
-          json: async () => ({ checkout_session_id: checkoutSessionId }),
+          json: async () => (checkoutResponse || { checkout_session_id: checkoutSessionId }),
         };
       }
       throw new Error(`unexpected fetch url: ${url}`);
@@ -153,6 +153,40 @@ test('CREATE_PLUS_CHECKOUT uses ID/IDR and openai_llc merchant path for GoPay',
   });
 });
 
+test('CREATE_PLUS_CHECKOUT uses hosted US/USD checkout for PayPal no-card binding', async () => {
+  const hostedUrl = 'https://pay.openai.com/c/pay/cs_hosted_123';
+  const harness = createPlusCheckoutMessageHarness({
+    checkoutSessionId: 'cs_hosted',
+    checkoutResponse: {
+      checkout_session_id: 'cs_hosted',
+      next_action: {
+        redirect_to_url: {
+          url: hostedUrl,
+        },
+      },
+    },
+  });
+
+  const result = await harness.send({
+    type: 'CREATE_PLUS_CHECKOUT',
+    source: 'test',
+    payload: { paymentMethod: 'paypal-hosted' },
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.checkoutUrl, 'https://chatgpt.com/checkout/openai_llc/cs_hosted');
+  assert.equal(result.hostedCheckoutUrl, hostedUrl);
+  assert.equal(result.preferredCheckoutUrl, hostedUrl);
+  assert.equal(result.country, 'US');
+  assert.equal(result.currency, 'USD');
+
+  const checkoutCall = harness.fetchCalls.find((call) => call.url === 'https://chatgpt.com/backend-api/payments/checkout');
+  assert.ok(checkoutCall);
+  const payload = JSON.parse(checkoutCall.options.body);
+  assert.equal(payload.checkout_ui_mode, 'hosted');
+  assert.deepEqual(payload.billing_details, { country: 'US', currency: 'USD' });
+});
+
 function extractFunction(name) {
   const plainStart = source.indexOf(`function ${name}(`);
   const asyncStart = source.indexOf(`async function ${name}(`);

tests/plus-checkout-create-wait.test.js

@@ -288,6 +288,113 @@ test('GoPay plus checkout create forwards gopay payment method to the checkout c
   assert.deepStrictEqual(events[0]?.payload, { paymentMethod: 'gopay' });
 });
 
+test('PayPal no-card binding create waits for hosted success and does not use the old PayPal tail', async () => {
+  const events = [];
+  let currentUrl = 'https://chatgpt.com/';
+  const executor = api.createPlusCheckoutCreateExecutor({
+    addLog: async (message, level = 'info') => {
+      events.push({ type: 'log', message, level });
+    },
+    chrome: {
+      tabs: {
+        create: async (payload) => {
+          events.push({ type: 'tab-create', payload });
+          return { id: 55, url: payload.url, status: 'complete' };
+        },
+        update: async (tabId, payload) => {
+          currentUrl = payload.url;
+          events.push({ type: 'tab-update', tabId, payload });
+          return { id: tabId, url: currentUrl, status: 'complete' };
+        },
+        get: async (tabId) => ({ id: tabId, url: currentUrl, status: 'complete' }),
+      },
+    },
+    completeNodeFromBackground: async (step, payload) => {
+      events.push({ type: 'complete', step, payload });
+    },
+    ensureContentScriptReadyOnTabUntilStopped: async (source, tabId, options) => {
+      events.push({ type: 'ready', source, tabId, options });
+    },
+    fetch: async (url) => {
+      events.push({ type: 'fetch', url });
+      assert.equal(url, 'https://www.meiguodizhi.com/api/v1/dz');
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({
+          address: {
+            Address: '1 Main St',
+            City: 'New York',
+            State: 'New York',
+            Zip_Code: '10001',
+          },
+        }),
+      };
+    },
+    registerTab: async (source, tabId) => {
+      events.push({ type: 'register', source, tabId });
+    },
+    sendTabMessageUntilStopped: async (tabId, source, message) => {
+      events.push({ type: 'tab-message', tabId, source, message });
+      if (message.type === 'CREATE_PLUS_CHECKOUT') {
+        return {
+          checkoutUrl: 'https://chatgpt.com/checkout/openai_llc/cs_hosted',
+          preferredCheckoutUrl: 'https://pay.openai.com/c/pay/cs_hosted',
+          hostedCheckoutUrl: 'https://pay.openai.com/c/pay/cs_hosted',
+          country: 'US',
+          currency: 'USD',
+        };
+      }
+      if (message.type === 'RUN_PAYPAL_HOSTED_OPENAI_CHECKOUT_STEP') {
+        currentUrl = 'https://chatgpt.com/backend-api/payments/success?session_id=cs_hosted';
+        return { clicked: true };
+      }
+      if (message.type === 'PLUS_CHECKOUT_GET_STATE') {
+        return { hostedVerificationVisible: false };
+      }
+      throw new Error(`unexpected message type ${message.type}`);
+    },
+    setState: async (payload) => {
+      events.push({ type: 'set-state', payload });
+    },
+    sleepWithStop: async (ms) => {
+      events.push({ type: 'sleep', ms });
+    },
+    waitForTabCompleteUntilStopped: async () => {
+      events.push({ type: 'tab-complete' });
+    },
+  });
+
+  await executor.executePlusCheckoutCreate({
+    plusPaymentMethod: 'paypal-hosted',
+    plusHostedCheckoutOauthDelaySeconds: 0,
+  });
+
+  assert.deepStrictEqual(
+    events.find((event) => event.type === 'tab-message' && event.message.type === 'CREATE_PLUS_CHECKOUT')?.message?.payload,
+    { paymentMethod: 'paypal-hosted' }
+  );
+  assert.equal(
+    events.find((event) => event.type === 'tab-update')?.payload?.url,
+    'https://pay.openai.com/c/pay/cs_hosted'
+  );
+  const statePayload = events.find((event) => event.type === 'set-state')?.payload || {};
+  assert.equal(statePayload.plusCheckoutSource, 'paypal-hosted');
+  assert.equal(statePayload.plusCheckoutCountry, 'US');
+  assert.equal(statePayload.plusCheckoutCurrency, 'USD');
+  assert.equal(statePayload.plusReturnUrl, '');
+  assert.equal(events.some((event) => event.type === 'tab-message' && event.message.type === 'FILL_PLUS_BILLING_AND_SUBMIT'), false);
+  assert.deepStrictEqual(events.find((event) => event.type === 'complete'), {
+    type: 'complete',
+    step: 'plus-checkout-create',
+    payload: {
+      plusReturnUrl: 'https://chatgpt.com/backend-api/payments/success?session_id=cs_hosted',
+      plusHostedCheckoutCompleted: true,
+      plusHostedCheckoutOauthDelaySeconds: 0,
+    },
+  });
+});
+
 test('Plus checkout content routes billing operations through the operation delay gate', async () => {
   const { checkoutEvents, send } = createCheckoutContentHarness();
 

tests/sidepanel-flow-source-registry.test.js

@@ -123,6 +123,7 @@ return {
       plusAccountAccessStrategy: 'oauth',
       signupMethod: 'email',
       phoneSignupReloginAfterBindEmailEnabled: false,
+      accountContributionEnabled: false,
     },
   });
   assert.deepEqual(api.calls[1], { type: 'render', stepIds: [88] });

tests/sidepanel-plus-payment-method.test.js

@@ -113,7 +113,7 @@ return {
   assert.deepEqual(api.getStepIds(), [7]);
   assert.deepEqual(api.calls[0], {
     type: 'getSteps',
-    options: { activeFlowId: 'openai', plusModeEnabled: true, plusPaymentMethod: 'gopay', plusAccountAccessStrategy: 'oauth', signupMethod: 'email', phoneSignupReloginAfterBindEmailEnabled: false },
+    options: { activeFlowId: 'openai', plusModeEnabled: true, plusPaymentMethod: 'gopay', plusAccountAccessStrategy: 'oauth', signupMethod: 'email', phoneSignupReloginAfterBindEmailEnabled: false, accountContributionEnabled: false },
   });
   assert.deepEqual(api.calls[1], { type: 'render', stepIds: [7] });
 });
@@ -188,6 +188,67 @@ return { updatePlusModeUI, selectPlusPaymentMethod, rowPayPalAccount };
   assert.equal(api.rowPayPalAccount.style.display, '');
 });
 
+test('sidepanel Plus UI separates PayPal account mode from PayPal no-card binding mode', () => {
+  const bundle = [
+    extractFunction('normalizePlusPaymentMethod'),
+    extractFunction('normalizePlusAccountAccessStrategy'),
+    extractFunction('getSelectedPlusPaymentMethod'),
+    extractFunction('getRequestedPlusAccountAccessStrategy'),
+    extractFunction('normalizeGpcHelperPhoneModeValue'),
+    extractFunction('getGpcHelperAutoModeEnabled'),
+    extractFunction('normalizeGpcAutoModePermissionValue'),
+    extractFunction('getGpcAutoModePermissionFromPayload'),
+    extractFunction('shouldPreserveSelectedGpcAutoMode'),
+    extractFunction('hasGpcAutoModePermissionField'),
+    extractFunction('isGpcAutoModePermissionDenied'),
+    extractFunction('normalizeGpcOtpChannelValue'),
+    extractFunction('updatePlusModeUI'),
+  ].join('\n');
+
+  const api = new Function(`
+let latestState = { plusPaymentMethod: 'paypal-hosted' };
+let currentPlusPaymentMethod = 'paypal-hosted';
+let currentPlusAccountAccessStrategy = 'oauth';
+const inputPlusModeEnabled = { checked: true };
+const selectPlusPaymentMethod = { value: 'paypal-hosted', style: { display: 'none' } };
+const GPC_HELPER_PHONE_MODE_AUTO = 'auto';
+const GPC_HELPER_PHONE_MODE_MANUAL = 'manual';
+const PLUS_ACCOUNT_ACCESS_STRATEGY_OAUTH = 'oauth';
+const PLUS_ACCOUNT_ACCESS_STRATEGY_SUB2API_CODEX_SESSION = 'sub2api_codex_session';
+const PLUS_ACCOUNT_ACCESS_STRATEGY_CPA_CODEX_SESSION = 'cpa_codex_session';
+const DEFAULT_PLUS_ACCOUNT_ACCESS_STRATEGY = PLUS_ACCOUNT_ACCESS_STRATEGY_OAUTH;
+const plusPaymentMethodCaption = { textContent: '' };
+const rowPayPalAccount = { style: { display: '' } };
+const rowHostedCheckoutVerificationUrl = { style: { display: 'none' } };
+const rowHostedCheckoutPhone = { style: { display: 'none' } };
+const rowPlusHostedCheckoutOauthDelay = { style: { display: 'none' } };
+${bundle}
+return {
+  updatePlusModeUI,
+  selectPlusPaymentMethod,
+  rowPayPalAccount,
+  plusPaymentMethodCaption,
+  rows: { rowHostedCheckoutVerificationUrl, rowHostedCheckoutPhone, rowPlusHostedCheckoutOauthDelay },
+};
+`)();
+
+  api.updatePlusModeUI();
+
+  assert.equal(api.rowPayPalAccount.style.display, 'none');
+  assert.equal(api.rows.rowHostedCheckoutVerificationUrl.style.display, '');
+  assert.equal(api.rows.rowHostedCheckoutPhone.style.display, '');
+  assert.equal(api.rows.rowPlusHostedCheckoutOauthDelay.style.display, '');
+  assert.match(api.plusPaymentMethodCaption.textContent, /无卡直绑/);
+
+  api.selectPlusPaymentMethod.value = 'paypal';
+  api.updatePlusModeUI();
+
+  assert.equal(api.rowPayPalAccount.style.display, '');
+  assert.equal(api.rows.rowHostedCheckoutVerificationUrl.style.display, 'none');
+  assert.equal(api.rows.rowHostedCheckoutPhone.style.display, 'none');
+  assert.equal(api.rows.rowPlusHostedCheckoutOauthDelay.style.display, 'none');
+});
+
 test('sidepanel Plus UI can hide Plus controls when the shared flow capability registry disables them', () => {
   const bundle = [
     extractFunction('normalizePlusPaymentMethod'),
@@ -303,7 +364,7 @@ return {
   assert.deepEqual(api.getStepIds(), [13]);
   assert.deepEqual(api.calls[0], {
     type: 'getSteps',
-    options: { activeFlowId: 'openai', plusModeEnabled: true, plusPaymentMethod: 'gpc-helper', plusAccountAccessStrategy: 'oauth', signupMethod: 'email', phoneSignupReloginAfterBindEmailEnabled: false },
+    options: { activeFlowId: 'openai', plusModeEnabled: true, plusPaymentMethod: 'gpc-helper', plusAccountAccessStrategy: 'oauth', signupMethod: 'email', phoneSignupReloginAfterBindEmailEnabled: false, accountContributionEnabled: false },
   });
 });
 

tests/step-definitions-module.test.js

@@ -14,6 +14,7 @@ test('step definitions module exposes ordered normal and Plus step metadata', ()
     phoneSignupReloginAfterBindEmailEnabled: true,
   });
   const plusSteps = api.getSteps({ plusModeEnabled: true });
+  const hostedSteps = api.getSteps({ plusModeEnabled: true, plusPaymentMethod: 'paypal-hosted' });
   const plusPhoneSteps = api.getSteps({ plusModeEnabled: true, signupMethod: 'phone' });
   const plusPhoneReloginSteps = api.getSteps({
     plusModeEnabled: true,
@@ -211,6 +212,27 @@ test('step definitions module exposes ordered normal and Plus step metadata', ()
   assert.equal(plusSteps[5].title, '创建 Plus Checkout');
   assert.equal(plusSteps[7].title, 'PayPal 登录与授权');
 
+  assert.deepStrictEqual(
+    hostedSteps.map((step) => step.key),
+    [
+      'open-chatgpt',
+      'submit-signup-email',
+      'fill-password',
+      'fetch-signup-code',
+      'fill-profile',
+      'plus-checkout-create',
+      'oauth-login',
+      'fetch-login-code',
+      'confirm-oauth',
+      'platform-verify',
+    ]
+  );
+  assert.equal(hostedSteps.some((step) => step.key === 'plus-checkout-billing'), false);
+  assert.equal(hostedSteps.some((step) => step.key === 'paypal-approve'), false);
+  assert.equal(hostedSteps.some((step) => step.key === 'plus-checkout-return'), false);
+  assert.deepStrictEqual(api.getStepIds({ plusModeEnabled: true, plusPaymentMethod: 'paypal-hosted' }), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+  assert.equal(api.getLastStepId({ plusModeEnabled: true, plusPaymentMethod: 'paypal-hosted' }), 10);
+
   assert.deepStrictEqual(
     goPaySteps.map((step) => step.key),
     [
@@ -279,6 +301,16 @@ test('Plus session strategy swaps the OAuth tail for a single SUB2API import nod
       previousNodeId: 'plus-checkout-return',
       expectedStepIds: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
     },
+    {
+      label: 'paypal-hosted',
+      options: {
+        plusModeEnabled: true,
+        plusPaymentMethod: 'paypal-hosted',
+        plusAccountAccessStrategy: 'sub2api_codex_session',
+      },
+      previousNodeId: 'plus-checkout-create',
+      expectedStepIds: [1, 2, 3, 4, 5, 6, 7],
+    },
     {
       label: 'gopay',
       options: {
@@ -360,6 +392,16 @@ test('Plus session strategy swaps the OAuth tail for a single CPA import node',
       previousNodeId: 'plus-checkout-return',
       expectedStepIds: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
     },
+    {
+      label: 'paypal-hosted',
+      options: {
+        plusModeEnabled: true,
+        plusPaymentMethod: 'paypal-hosted',
+        plusAccountAccessStrategy: 'cpa_codex_session',
+      },
+      previousNodeId: 'plus-checkout-create',
+      expectedStepIds: [1, 2, 3, 4, 5, 6, 7],
+    },
     {
       label: 'gopay',
       options: {