// phone-sms/providers/hero-sms.js — HeroSMS 接码平台适配层
(function attachHeroSmsProvider(root, factory) {
  root.PhoneSmsHeroSmsProvider = factory();
})(typeof self !== 'undefined' ? self : globalThis, function createHeroSmsProviderModule() {
  const PROVIDER_ID = 'hero-sms';
  const DEFAULT_BASE_URL = 'https://hero-sms.com/stubs/handler_api.php';
  const DEFAULT_SERVICE_CODE = 'dr';
  const DEFAULT_SERVICE_LABEL = 'OpenAI';
  const DEFAULT_COUNTRY_ID = 52;
  const DEFAULT_COUNTRY_LABEL = 'Thailand';
  const DEFAULT_REQUEST_TIMEOUT_MS = 20000;
  const DEFAULT_OPERATOR = 'any';
  const DEFAULT_MAX_USES = 3;
  const DEFAULT_PRICE_LOOKUP_ATTEMPTS = 3;
  const DEFAULT_ACQUIRE_RETRY_ROUNDS = 3;
  const DEFAULT_ACQUIRE_RETRY_DELAY_MS = 2000;
  const DEFAULT_POLL_TIMEOUT_MS = 180000;
  const DEFAULT_POLL_INTERVAL_MS = 5000;
  const MAX_PRICE_CANDIDATES = 8;
  const PHONE_CODE_TIMEOUT_ERROR_PREFIX = 'PHONE_CODE_TIMEOUT::';
  const HERO_SMS_ACQUIRE_PRIORITY_COUNTRY = 'country';
  const HERO_SMS_ACQUIRE_PRIORITY_PRICE = 'price';
  const HERO_SMS_ACQUIRE_PRIORITY_PRICE_HIGH = 'price_high';
  const COUNTRY_BY_PHONE_PREFIX = Object.freeze([
    { prefix: '84', id: 10, iso: 'VN', label: 'Vietnam' },
    { prefix: '66', id: 52, iso: 'TH', label: 'Thailand' },
    { prefix: '62', id: 6, iso: 'ID', label: 'Indonesia' },
    { prefix: '44', id: 16, iso: 'GB', label: 'United Kingdom' },
    { prefix: '81', id: 151, iso: 'JP', label: 'Japan' },
    { prefix: '49', id: 43, iso: 'DE', label: 'Germany' },
    { prefix: '33', id: 73, iso: 'FR', label: 'France' },
    { prefix: '1', id: 187, iso: 'US', label: 'USA' },
  ]);

  function normalizeHeroSmsCountryId(value, fallback = DEFAULT_COUNTRY_ID) {
    const parsed = Math.floor(Number(value));
    if (Number.isFinite(parsed) && parsed > 0) return parsed;
    const fallbackParsed = Math.floor(Number(fallback));
    return Number.isFinite(fallbackParsed) && fallbackParsed > 0 ? fallbackParsed : DEFAULT_COUNTRY_ID;
  }

  function normalizeOptionalHeroSmsCountryId(value) {
    const parsed = Math.floor(Number(value));
    return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
  }

  function normalizeHeroSmsCountryLabel(value = '', fallback = DEFAULT_COUNTRY_LABEL) {
    return String(value || '').trim() || fallback;
  }

  function normalizeCountryKey(value) {
    const countryId = normalizeHeroSmsCountryId(value, 0);
    return countryId > 0 ? String(countryId) : '';
  }

  function inferCountryFromPhoneNumber(phoneNumber = '') {
    const digits = String(phoneNumber || '').replace(/\D+/g, '');
    if (!digits) {
      return null;
    }
    const match = COUNTRY_BY_PHONE_PREFIX.find((entry) => digits.startsWith(entry.prefix));
    if (!match) {
      return null;
    }
    return {
      id: normalizeHeroSmsCountryId(match.id, 0),
      iso: match.iso,
      label: normalizeHeroSmsCountryLabel(match.label, `Country #${match.id}`),
    };
  }

  function normalizeHeroSmsMaxPrice(value = '') {
    const rawValue = String(value ?? '').trim();
    if (!rawValue) return '';
    const numeric = Number(rawValue);
    if (!Number.isFinite(numeric) || numeric <= 0) return '';
    return String(Math.round(numeric * 10000) / 10000);
  }

  function normalizeHeroSmsPrice(value) {
    const direct = Number(value);
    if (Number.isFinite(direct) && direct >= 0) {
      return direct;
    }
    const text = String(value ?? '').trim();
    if (!text) {
      return null;
    }
    const matched = text.match(/-?\d+(?:[.,]\d+)?/);
    if (!matched) {
      return null;
    }
    const parsed = Number(String(matched[0] || '').replace(',', '.'));
    return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
  }

  function normalizeHeroSmsPriceLimit(value) {
    if (value === undefined || value === null || String(value).trim() === '') {
      return null;
    }
    const parsed = Number(value);
    if (!Number.isFinite(parsed) || parsed <= 0) {
      return null;
    }
    return Math.round(parsed * 10000) / 10000;
  }

  function normalizeHeroSmsOperator(value = '', fallback = DEFAULT_OPERATOR) {
    const normalized = String(value || '')
      .trim()
      .toLowerCase()
      .replace(/[^a-z0-9_-]+/g, '');
    if (normalized) {
      return normalized;
    }
    const fallbackNormalized = String(fallback || '')
      .trim()
      .toLowerCase()
      .replace(/[^a-z0-9_-]+/g, '');
    return fallbackNormalized || DEFAULT_OPERATOR;
  }

  function normalizeHeroSmsAcquirePriority(value = '') {
    const normalized = String(value || '').trim().toLowerCase();
    if (normalized === HERO_SMS_ACQUIRE_PRIORITY_PRICE) {
      return HERO_SMS_ACQUIRE_PRIORITY_PRICE;
    }
    if (normalized === HERO_SMS_ACQUIRE_PRIORITY_PRICE_HIGH) {
      return HERO_SMS_ACQUIRE_PRIORITY_PRICE_HIGH;
    }
    return HERO_SMS_ACQUIRE_PRIORITY_COUNTRY;
  }

  function normalizeActivationRetryRounds(value) {
    const parsed = Math.floor(Number(value));
    if (!Number.isFinite(parsed) || parsed <= 0) {
      return DEFAULT_ACQUIRE_RETRY_ROUNDS;
    }
    return Math.max(1, Math.min(10, parsed));
  }

  function normalizeActivationRetryDelayMs(value) {
    const parsed = Math.floor(Number(value));
    if (!Number.isFinite(parsed) || parsed <= 0) {
      return DEFAULT_ACQUIRE_RETRY_DELAY_MS;
    }
    return Math.max(500, Math.min(30000, parsed));
  }

  function normalizeHeroSmsCountryFallback(value = []) {
    const source = Array.isArray(value)
      ? value
      : String(value || '')
        .split(/[\r\n,，;；]+/)
        .map((entry) => String(entry || '').trim())
        .filter(Boolean);
    const seen = new Set();
    const normalized = [];
    for (const entry of source) {
      let id = 0;
      let label = '';
      if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
        id = normalizeHeroSmsCountryId(entry.id ?? entry.countryId, 0);
        label = String((entry.label ?? entry.countryLabel) || '').trim();
      } else {
        const text = String(entry || '').trim();
        const structured = text.match(/^(\d+)\s*(?:[:|/-]\s*(.+))?$/);
        id = normalizeHeroSmsCountryId(structured?.[1] || text, 0);
        label = String(structured?.[2] || '').trim();
      }
      if (!id || seen.has(id)) continue;
      seen.add(id);
      normalized.push({ id, label: label || `Country #${id}` });
      if (normalized.length >= 20) break;
    }
    return normalized;
  }

  function normalizeBaseUrl(value = '') {
    const trimmed = String(value || '').trim() || DEFAULT_BASE_URL;
    try {
      return new URL(trimmed).toString();
    } catch {
      return DEFAULT_BASE_URL;
    }
  }

  function buildUrl(config = {}, query = {}) {
    const url = new URL(normalizeBaseUrl(config.baseUrl));
    Object.entries(query || {}).forEach(([key, value]) => {
      if (value === undefined || value === null || value === '') return;
      url.searchParams.set(key, String(value));
    });
    return url.toString();
  }

  function parsePayload(text) {
    const trimmed = String(text || '').trim();
    if (!trimmed) return '';
    if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
      try { return JSON.parse(trimmed); } catch { return trimmed; }
    }
    return trimmed;
  }

  function describePayload(raw) {
    if (typeof raw === 'string') return raw.trim();
    if (raw && typeof raw === 'object') {
      const direct = String(raw.message || raw.msg || raw.error || raw.title || raw.status || '').trim();
      if (direct) return direct;
      try { return JSON.stringify(raw); } catch { return String(raw); }
    }
    return String(raw || '').trim();
  }

  function resolveConfig(state = {}, deps = {}) {
    return {
      apiKey: String(state.heroSmsApiKey || '').trim(),
      baseUrl: state.heroSmsBaseUrl || DEFAULT_BASE_URL,
      operator: normalizeHeroSmsOperator(state.heroSmsOperator, DEFAULT_OPERATOR),
      fetchImpl: deps.fetchImpl || (typeof fetch === 'function' ? fetch.bind(globalThis) : null),
      requestTimeoutMs: deps.requestTimeoutMs || DEFAULT_REQUEST_TIMEOUT_MS,
    };
  }

  function assertApiKey(config) {
    if (!config.apiKey) {
      throw new Error('HeroSMS API Key 缺失，请先在侧边栏保存接码 API Key。');
    }
  }

  async function fetchPayload(config, query, actionLabel = 'HeroSMS request') {
    assertApiKey(config);
    if (query.api_key === undefined && config.apiKey) {
      query = { api_key: config.apiKey, ...query };
    }
    if (!config.fetchImpl) {
      throw new Error('HeroSMS 网络请求实现不可用。');
    }
    const controller = typeof AbortController === 'function' ? new AbortController() : null;
    const timeoutId = controller
      ? setTimeout(() => controller.abort(), Number(config.requestTimeoutMs) || DEFAULT_REQUEST_TIMEOUT_MS)
      : null;
    try {
      const response = await config.fetchImpl(buildUrl(config, query), {
        method: 'GET',
        signal: controller?.signal,
      });
      const text = await response.text();
      const payload = parsePayload(text);
      if (!response.ok) {
        const error = new Error(`${actionLabel}失败：${describePayload(payload) || response.status}`);
        error.payload = payload;
        error.status = response.status;
        throw error;
      }
      return payload;
    } catch (error) {
      if (error?.name === 'AbortError') {
        throw new Error(`${actionLabel}超时。`);
      }
      throw error;
    } finally {
      if (timeoutId) clearTimeout(timeoutId);
    }
  }

  function resolveCountryConfig(state = {}) {
    const hasExplicitPrimaryCountry = Object.prototype.hasOwnProperty.call(state || {}, 'heroSmsCountryId');
    const fallbackList = normalizeHeroSmsCountryFallback(state.heroSmsCountryFallback);
    const primaryCountryId = normalizeOptionalHeroSmsCountryId(state.heroSmsCountryId);
    if (primaryCountryId > 0) {
      return {
        id: primaryCountryId,
        label: normalizeHeroSmsCountryLabel(state.heroSmsCountryLabel),
      };
    }
    if (hasExplicitPrimaryCountry) {
      if (fallbackList.length) {
        const firstFallback = fallbackList[0];
        return {
          id: normalizeOptionalHeroSmsCountryId(firstFallback.id),
          label: normalizeHeroSmsCountryLabel(firstFallback.label, `Country #${firstFallback.id}`),
        };
      }
      return null;
    }
    return {
      id: normalizeHeroSmsCountryId(DEFAULT_COUNTRY_ID, DEFAULT_COUNTRY_ID),
      label: normalizeHeroSmsCountryLabel(state.heroSmsCountryLabel),
    };
  }

  function resolveCountryCandidates(state = {}) {
    const primary = resolveCountryConfig(state);
    const fallbackList = normalizeHeroSmsCountryFallback(state.heroSmsCountryFallback);
    if (!primary || !Number.isFinite(primary.id) || primary.id <= 0) {
      return fallbackList
        .map((entry) => ({
          id: normalizeOptionalHeroSmsCountryId(entry.id),
          label: normalizeHeroSmsCountryLabel(entry.label, `Country #${entry.id}`),
        }))
        .filter((entry) => entry.id > 0);
    }
    const seen = new Set([primary.id]);
    const candidates = [primary];
    fallbackList.forEach((entry) => {
      const id = normalizeOptionalHeroSmsCountryId(entry.id);
      if (!id || seen.has(id)) return;
      seen.add(id);
      candidates.push({ id, label: normalizeHeroSmsCountryLabel(entry.label, `Country #${id}`) });
    });
    return candidates;
  }

  async function fetchBalance(state = {}, deps = {}) {
    const config = resolveConfig(state, deps);
    if (!config.apiKey) {
      throw new Error('HeroSMS API Key 缺失，请先在侧边栏保存接码 API Key。');
    }
    const payload = await fetchPayload(config, { action: 'getBalance' }, 'HeroSMS getBalance');
    const balance = Number(String(describePayload(payload)).replace(/^ACCESS_BALANCE:/i, '').trim());
    return { balance, raw: payload };
  }

  async function fetchPrices(state = {}, countryConfig = resolveCountryConfig(state), deps = {}) {
    const config = resolveConfig(state, deps);
    return fetchPayload(config, {
      action: 'getPrices',
      service: DEFAULT_SERVICE_CODE,
      country: normalizeHeroSmsCountryId(countryConfig?.id),
    }, 'HeroSMS getPrices');
  }

  function shouldUseExpandedPriceLookup(state = {}) {
    if (typeof state?.heroSmsUseExpandedPriceLookup === 'boolean') {
      return state.heroSmsUseExpandedPriceLookup;
    }
    const runningInNode = (
      typeof process !== 'undefined'
      && process
      && process.versions
      && process.versions.node
    );
    return !runningInNode;
  }

  function resolveStockState(payload = {}) {
    const physicalCount = Number(payload.physicalCount);
    if (Number.isFinite(physicalCount)) {
      return { hasStockField: true, stockCount: physicalCount };
    }
    const stockCandidates = [
      payload.count,
      payload.stock,
      payload.available,
      payload.quantity,
      payload.qty,
      payload.left,
      payload.free,
    ]
      .map((value) => Number(value))
      .filter((value) => Number.isFinite(value));
    if (!stockCandidates.length) {
      return { hasStockField: false, stockCount: 0 };
    }
    return { hasStockField: true, stockCount: Math.max(...stockCandidates) };
  }

  function collectPriceCandidates(payload, candidates = []) {
    if (Array.isArray(payload)) {
      payload.forEach((entry) => collectPriceCandidates(entry, candidates));
      return candidates;
    }
    if (!payload || typeof payload !== 'object') {
      return candidates;
    }
    const cost = normalizeHeroSmsPrice(payload.cost);
    if (cost !== null) {
      const stockState = resolveStockState(payload);
      if (!stockState.hasStockField || stockState.stockCount > 0) {
        candidates.push(cost);
      }
    }
    Object.entries(payload).forEach(([key, value]) => {
      const keyedPrice = normalizeHeroSmsPrice(key);
      if (keyedPrice === null) {
        return;
      }
      if (value && typeof value === 'object') {
        const stockState = resolveStockState(value);
        if (stockState.hasStockField && stockState.stockCount > 0) {
          candidates.push(keyedPrice);
        }
        return;
      }
      const numericCount = Number(value);
      if (Number.isFinite(numericCount) && numericCount > 0) {
        candidates.push(keyedPrice);
      }
    });
    Object.values(payload).forEach((value) => collectPriceCandidates(value, candidates));
    return candidates;
  }

  function collectPriceCandidatesIncludingZeroStock(payload, candidates = []) {
    if (Array.isArray(payload)) {
      payload.forEach((entry) => collectPriceCandidatesIncludingZeroStock(entry, candidates));
      return candidates;
    }
    if (!payload || typeof payload !== 'object') {
      return candidates;
    }
    const cost = normalizeHeroSmsPrice(payload.cost);
    if (cost !== null) {
      candidates.push(cost);
    }
    Object.entries(payload).forEach(([key, value]) => {
      const keyedPrice = normalizeHeroSmsPrice(key);
      if (keyedPrice === null) {
        return;
      }
      if (value && typeof value === 'object') {
        if (resolveStockState(value).hasStockField) {
          candidates.push(keyedPrice);
        }
        return;
      }
      if (Number.isFinite(Number(value))) {
        candidates.push(keyedPrice);
      }
    });
    Object.values(payload).forEach((value) => collectPriceCandidatesIncludingZeroStock(value, candidates));
    return candidates;
  }

  function buildSortedUniquePriceCandidates(values = []) {
    return Array.from(
      new Set(
        values
          .map((value) => normalizeHeroSmsPrice(value))
          .filter((value) => value !== null)
          .map((value) => Math.round(value * 10000) / 10000)
      )
    )
      .sort((left, right) => left - right)
      .slice(0, MAX_PRICE_CANDIDATES);
  }

  function isPriceWithinRange(price, minPriceLimit = null, maxPriceLimit = null) {
    const numeric = Number(price);
    if (!Number.isFinite(numeric) || numeric <= 0) {
      return false;
    }
    const normalized = Math.round(numeric * 10000) / 10000;
    if (minPriceLimit !== null && normalized < minPriceLimit) {
      return false;
    }
    if (maxPriceLimit !== null && normalized > maxPriceLimit) {
      return false;
    }
    return true;
  }

  function filterPriceCandidatesWithinRange(prices = [], minPriceLimit = null, maxPriceLimit = null) {
    return (Array.isArray(prices) ? prices : []).filter((price) => (
      isPriceWithinRange(price, minPriceLimit, maxPriceLimit)
    ));
  }

  function filterPriceCandidatesAboveFloor(prices = [], minExclusivePrice = null) {
    const floor = normalizeHeroSmsPrice(minExclusivePrice);
    if (floor === null || floor <= 0) {
      return Array.isArray(prices) ? [...prices] : [];
    }
    return (Array.isArray(prices) ? prices : []).filter((value) => {
      const numeric = Number(value);
      if (!Number.isFinite(numeric) || numeric <= 0) {
        return false;
      }
      return Math.round(numeric * 10000) / 10000 > floor;
    });
  }

  function reorderPriceCandidates(prices = [], acquirePriority = HERO_SMS_ACQUIRE_PRIORITY_COUNTRY, preferredPrice = null) {
    const hasNullTier = Array.isArray(prices)
      && prices.some((value) => value === null || value === undefined || String(value).trim() === '');
    const normalized = buildSortedUniquePriceCandidates(
      (Array.isArray(prices) ? prices : []).filter((value) => (
        !(value === null || value === undefined || String(value).trim() === '')
      ))
    );
    const ordered = acquirePriority === HERO_SMS_ACQUIRE_PRIORITY_PRICE_HIGH
      ? normalized.reverse()
      : normalized;
    const preferred = Number(preferredPrice);
    if (!Number.isFinite(preferred) || preferred <= 0) {
      if (ordered.length) {
        return ordered;
      }
      return hasNullTier ? [null] : [];
    }
    const normalizedPreferred = Math.round(preferred * 10000) / 10000;
    const withoutPreferred = ordered.filter((value) => value !== normalizedPreferred);
    return [normalizedPreferred, ...withoutPreferred];
  }

  function normalizePriceFloorMap(rawMap = {}, normalizeCountryKey) {
    const normalizedMap = new Map();
    if (!rawMap || typeof rawMap !== 'object') {
      return normalizedMap;
    }
    Object.entries(rawMap).forEach(([rawCountryKey, rawPrice]) => {
      const countryKey = String(
        typeof normalizeCountryKey === 'function'
          ? normalizeCountryKey(rawCountryKey)
          : rawCountryKey
      ).trim();
      if (!countryKey) {
        return;
      }
      const normalizedPrice = normalizeHeroSmsPrice(rawPrice);
      if (normalizedPrice === null || normalizedPrice <= 0) {
        return;
      }
      normalizedMap.set(countryKey, Math.round(normalizedPrice * 10000) / 10000);
    });
    return normalizedMap;
  }

  function formatPriceRangeText(minPriceLimit = null, maxPriceLimit = null) {
    const minPrice = normalizeHeroSmsPriceLimit(minPriceLimit);
    const maxPrice = normalizeHeroSmsPriceLimit(maxPriceLimit);
    if (minPrice !== null && maxPrice !== null) {
      return `${minPrice}~${maxPrice}`;
    }
    if (minPrice !== null) {
      return `${minPrice}~`;
    }
    if (maxPrice !== null) {
      return `~${maxPrice}`;
    }
    return 'unbounded';
  }

  function resolvePriceRange(state = {}) {
    const minPriceLimit = normalizeHeroSmsPriceLimit(state?.heroSmsMinPrice);
    const maxPriceLimit = normalizeHeroSmsPriceLimit(state?.heroSmsMaxPrice);
    return {
      minPriceLimit,
      maxPriceLimit,
      hasMinPriceLimit: minPriceLimit !== null,
      hasMaxPriceLimit: maxPriceLimit !== null,
      invalidRange: minPriceLimit !== null && maxPriceLimit !== null && minPriceLimit > maxPriceLimit,
    };
  }

  async function fetchPricePayloads(config, countryConfig, state = {}) {
    const payloads = [];
    const actions = shouldUseExpandedPriceLookup(state)
      ? ['getPricesExtended', 'getPrices']
      : ['getPrices'];
    for (const action of actions) {
      try {
        const query = {
          action,
          service: DEFAULT_SERVICE_CODE,
          country: normalizeHeroSmsCountryId(countryConfig?.id),
        };
        if (action === 'getPricesExtended') {
          query.freePrice = 'true';
        }
        payloads.push(await fetchPayload(config, query, `HeroSMS ${action}`));
      } catch (_) {
        // Price lookup is best-effort; acquisition may still probe a tier.
      }
    }
    return payloads;
  }

  async function persistPricePlanSnapshot(countryConfig, pricePlan, deps = {}) {
    if (typeof deps.setState !== 'function') {
      return;
    }
    const prices = Array.isArray(pricePlan?.prices)
      ? pricePlan.prices.filter((price) => Number.isFinite(Number(price)))
      : [];
    const userLimit = pricePlan?.userLimit === null || pricePlan?.userLimit === undefined
      ? ''
      : String(pricePlan.userLimit);
    await deps.setState({
      heroSmsLastPriceTiers: prices,
      heroSmsLastPriceCountryId: normalizeHeroSmsCountryId(countryConfig?.id, 0),
      heroSmsLastPriceCountryLabel: normalizeHeroSmsCountryLabel(countryConfig?.label, DEFAULT_COUNTRY_LABEL),
      heroSmsLastPriceUserLimit: userLimit,
      heroSmsLastPriceAt: Date.now(),
    });
  }

  async function resolvePricePlan(state = {}, countryConfig = resolveCountryConfig(state), deps = {}) {
    const config = resolveConfig(state, deps);
    for (let attempt = 1; attempt <= DEFAULT_PRICE_LOOKUP_ATTEMPTS; attempt += 1) {
      try {
        const payloads = await fetchPricePayloads(config, countryConfig, state);
        const userLimit = normalizeHeroSmsPriceLimit(state.heroSmsMaxPrice);
        const inStockCandidates = buildSortedUniquePriceCandidates(
          payloads.flatMap((payload) => collectPriceCandidates(payload, []))
        );
        const allCatalogCandidates = buildSortedUniquePriceCandidates(
          payloads.flatMap((payload) => collectPriceCandidatesIncludingZeroStock(payload, []))
        );
        const mergedCandidates = inStockCandidates.length
          ? buildSortedUniquePriceCandidates([...inStockCandidates, ...allCatalogCandidates])
          : [];
        const minCatalogPrice = allCatalogCandidates.length
          ? allCatalogCandidates[0]
          : (mergedCandidates.length ? mergedCandidates[0] : null);
        let plan = null;
        if (userLimit !== null) {
          const bounded = mergedCandidates.filter((price) => price <= userLimit);
          plan = {
            prices: bounded.length > 0 ? bounded : [userLimit],
            userLimit,
            minCatalogPrice,
            syntheticUserLimitProbe: bounded.length <= 0,
          };
        } else if (mergedCandidates.length > 0) {
          plan = {
            prices: mergedCandidates,
            userLimit: null,
            minCatalogPrice,
            syntheticUserLimitProbe: false,
          };
        } else {
          plan = {
            prices: [null],
            userLimit: null,
            minCatalogPrice: null,
            syntheticUserLimitProbe: false,
          };
        }
        await persistPricePlanSnapshot(countryConfig, plan, deps);
        if (
          Array.isArray(plan.prices)
          && plan.prices.length > 0
          && (
            plan.prices.some((price) => Number.isFinite(Number(price)) && Number(price) > 0)
            || plan.syntheticUserLimitProbe
          )
        ) {
          return plan;
        }
      } catch (_) {
        // Retry price lookup before falling back to automatic tier.
      }
    }
    const fallbackPlan = {
      prices: [null],
      userLimit: null,
      minCatalogPrice: null,
      syntheticUserLimitProbe: false,
    };
    await persistPricePlanSnapshot(countryConfig, fallbackPlan, deps);
    return fallbackPlan;
  }

  function extractWrongMaxPrice(payload) {
    if (payload && typeof payload === 'object') {
      const title = String(payload.title || '').trim();
      const minPrice = normalizeHeroSmsPrice(payload.info?.min);
      if (/^WRONG_MAX_PRICE$/i.test(title) && minPrice !== null) {
        return minPrice;
      }
    }
    const text = describePayload(payload);
    const match = text.match(/\bWRONG_MAX_PRICE:(\d+(?:\.\d+)?)\b/i);
    return match ? normalizeHeroSmsPrice(match[1]) : null;
  }

  function isNetworkFetchFailure(error) {
    return /failed to fetch|networkerror|load failed/i.test(String(error?.message || '').trim());
  }

  function isNoNumbersPayload(payload) {
    return /\bNO_NUMBERS\b/i.test(describePayload(payload));
  }

  function isTerminalError(payloadOrMessage) {
    const text = describePayload(payloadOrMessage);
    return /\bNO_BALANCE\b|\bNOT_ENOUGH_BALANCE\b|\bBAD_KEY\b|\bINVALID_KEY\b|\bBANNED\b|\bACCOUNT_BANNED\b|\bWRONG_KEY\b/i.test(text);
  }

  function formatActionName(action = '') {
    const normalized = String(action || '').trim().toLowerCase();
    if (normalized === 'getnumber' || normalized === 'getnumberv2') {
      return '获取手机号';
    }
    if (normalized === 'getstatus' || normalized === 'getstatusv2') {
      return '查询短信状态';
    }
    if (normalized === 'setstatus') {
      return '更新订单状态';
    }
    if (normalized === 'getprices' || normalized === 'getpricesextended') {
      return '查询价格';
    }
    return action ? `${action} 请求` : '请求';
  }

  function createActionFailureError(action, reason = '') {
    const rawReason = describePayload(reason) || '未知错误';
    let normalizedReason = rawReason;
    if (/\bBAD_KEY\b|\bWRONG_KEY\b|\bINVALID_KEY\b/i.test(rawReason)) {
      normalizedReason = 'API Key 无效（BAD_KEY）';
    } else if (/\bNO_BALANCE\b|\bNOT_ENOUGH_BALANCE\b/i.test(rawReason)) {
      normalizedReason = '余额不足';
    } else if (/\bBANNED\b|\bACCOUNT_BANNED\b/i.test(rawReason)) {
      normalizedReason = '账号已被封禁';
    }
    const error = new Error(`HeroSMS ${formatActionName(action)}失败：${normalizedReason}`);
    error.localizedPhoneSmsFailure = true;
    return error;
  }

  async function fetchActivationPayload(config, countryConfig, action, options = {}) {
    const query = {
      action,
      service: DEFAULT_SERVICE_CODE,
      country: normalizeHeroSmsCountryId(countryConfig?.id),
    };
    const operator = normalizeHeroSmsOperator(config?.operator, DEFAULT_OPERATOR);
    if (operator && operator !== DEFAULT_OPERATOR) {
      query.operator = operator;
    }
    if (options.maxPrice !== null && options.maxPrice !== undefined) {
      query.maxPrice = options.maxPrice;
      if (options.fixedPrice !== false) {
        query.fixedPrice = 'true';
      }
    }
    return fetchPayload(config, query, `HeroSMS ${action}`);
  }

  async function requestActivationWithPrice(config, countryConfig, action, maxPrice, options = {}) {
    let nextMaxPrice = maxPrice;
    let retriedWithUpdatedPrice = false;
    let retriedWithoutPrice = false;
    const userLimit = normalizeHeroSmsPriceLimit(options.userLimit);
    const userMinLimit = normalizeHeroSmsPriceLimit(options.userMinLimit);
    while (true) {
      try {
        return await fetchActivationPayload(config, countryConfig, action, {
          maxPrice: nextMaxPrice,
          fixedPrice: options.fixedPrice,
        });
      } catch (error) {
        const updatedMaxPrice = extractWrongMaxPrice(error?.payload || error?.message);
        if (
          nextMaxPrice !== null
          && nextMaxPrice !== undefined
          && !retriedWithUpdatedPrice
          && updatedMaxPrice !== null
        ) {
          if (userLimit !== null && updatedMaxPrice > userLimit) {
            throw new Error(
              `HeroSMS ${formatActionName(action)}失败：价格上限过低，平台要求至少 ${updatedMaxPrice}，已超过当前配置的价格上限 ${userLimit}。`
            );
          }
          if (userMinLimit !== null && updatedMaxPrice < userMinLimit) {
            throw new Error(
              `HeroSMS ${formatActionName(action)}失败：平台要求价格 ${updatedMaxPrice} 低于当前配置的最低购买价 ${userMinLimit}。`
            );
          }
          nextMaxPrice = updatedMaxPrice;
          retriedWithUpdatedPrice = true;
          continue;
        }
        if (
          nextMaxPrice !== null
          && nextMaxPrice !== undefined
          && !retriedWithoutPrice
          && isNetworkFetchFailure(error)
        ) {
          nextMaxPrice = null;
          retriedWithoutPrice = true;
          continue;
        }
        throw error;
      }
    }
  }

  function normalizeActivation(record, fallback = {}) {
    if (!record || typeof record !== 'object' || Array.isArray(record)) {
      return null;
    }
    const activationId = String(record.activationId ?? record.id ?? record.activation ?? '').trim();
    const phoneNumber = String(record.phoneNumber ?? record.number ?? record.phone ?? '').trim();
    if (!activationId || !phoneNumber) {
      return null;
    }
    const statusAction = String(record.statusAction || fallback.statusAction || '').trim();
    return {
      activationId,
      phoneNumber,
      provider: PROVIDER_ID,
      serviceCode: String(record.serviceCode || fallback.serviceCode || DEFAULT_SERVICE_CODE).trim() || DEFAULT_SERVICE_CODE,
      countryId: normalizeHeroSmsCountryId(record.countryId ?? record.country ?? fallback.countryId),
      ...(record.countryLabel
        ? { countryLabel: normalizeHeroSmsCountryLabel(record.countryLabel, fallback.countryLabel) }
        : {}),
      successfulUses: Math.max(0, Math.floor(Number(record.successfulUses ?? fallback.successfulUses) || 0)),
      maxUses: Math.max(1, Math.floor(Number(record.maxUses ?? fallback.maxUses) || DEFAULT_MAX_USES)),
      ...(statusAction ? { statusAction } : {}),
      ...(record.source ? { source: String(record.source || '').trim() } : {}),
    };
  }

  function resolveCountryLabel(state = {}, countryId = DEFAULT_COUNTRY_ID) {
    const countryKey = normalizeCountryKey(countryId);
    const matched = resolveCountryCandidates(state)
      .find((entry) => normalizeCountryKey(entry.id) === countryKey);
    return matched?.label || normalizeHeroSmsCountryLabel('', countryKey ? `Country #${countryKey}` : DEFAULT_COUNTRY_LABEL);
  }

  function resolveActivationCountry(activation = {}, state = {}) {
    const normalizedActivation = normalizeActivation(activation)
      || (activation && typeof activation === 'object' ? activation : {});
    const inferred = inferCountryFromPhoneNumber(normalizedActivation.phoneNumber);
    const rawCountryId = normalizeHeroSmsCountryId(normalizedActivation.countryId, 0);
    const hasExplicitCountry = (
      rawCountryId > 0
      && !(
        normalizedActivation.manualOnly
        && rawCountryId === DEFAULT_COUNTRY_ID
        && inferred?.id
        && inferred.id !== rawCountryId
      )
    );
    const countryId = hasExplicitCountry
      ? rawCountryId
      : normalizeHeroSmsCountryId(inferred?.id, rawCountryId || DEFAULT_COUNTRY_ID);
    const matched = resolveCountryCandidates(state)
      .find((entry) => normalizeHeroSmsCountryId(entry.id, 0) === countryId);
    if (matched) {
      return matched;
    }
    return {
      id: countryId,
      label: normalizeHeroSmsCountryLabel(
        hasExplicitCountry ? normalizedActivation.countryLabel : (inferred?.label || normalizedActivation.countryLabel),
        `Country #${countryId}`
      ),
    };
  }

  function getActivationCountryKey(activation = {}) {
    return normalizeCountryKey(activation?.countryId ?? activation?.country);
  }

  function getActivationPrice(activation = {}) {
    return normalizeHeroSmsPrice(
      activation?.selectedPrice
      ?? activation?.price
      ?? activation?.maxPrice
    );
  }

  function parseActivationPayload(payload, fallback = {}) {
    const normalizedFallback = normalizeActivation(fallback) || (fallback && typeof fallback === 'object' ? fallback : {});
    const direct = normalizeActivation(payload, normalizedFallback);
    if (direct) {
      return direct;
    }
    const text = describePayload(payload);
    const accessNumberMatch = text.match(/^ACCESS_NUMBER:([^:]+):(.+)$/i);
    if (accessNumberMatch) {
      return normalizeActivation({
        activationId: String(accessNumberMatch[1] || '').trim(),
        phoneNumber: String(accessNumberMatch[2] || '').trim(),
        provider: PROVIDER_ID,
        serviceCode: normalizedFallback.serviceCode || DEFAULT_SERVICE_CODE,
        countryId: normalizedFallback.countryId || DEFAULT_COUNTRY_ID,
        successfulUses: normalizedFallback.successfulUses ?? 0,
        maxUses: normalizedFallback.maxUses ?? DEFAULT_MAX_USES,
        statusAction: normalizedFallback.statusAction,
      });
    }
    if (/^ACCESS_READY$/i.test(text) && normalizedFallback?.activationId) {
      return normalizeActivation(normalizedFallback);
    }
    return null;
  }

  function resolveActivationStatusAction(activation = {}) {
    return activation?.statusAction === 'getStatusV2' ? 'getStatusV2' : 'getStatus';
  }

  function extractVerificationCode(rawCode) {
    const trimmed = String(rawCode || '').trim();
    if (!trimmed) {
      return '';
    }
    return trimmed.match(/\b(\d{4,8})\b/)?.[1] || '';
  }

  async function setActivationStatus(state = {}, activation, status, deps = {}, actionLabel = 'HeroSMS setStatus') {
    const normalizedActivation = normalizeActivation(activation);
    if (!normalizedActivation) {
      return '';
    }
    const config = resolveConfig(state, deps);
    const payload = await fetchPayload(config, {
      action: 'setStatus',
      id: normalizedActivation.activationId,
      status: Math.floor(Number(status) || 0),
    }, actionLabel);
    return describePayload(payload);
  }

  async function requestActivation(state = {}, options = {}, deps = {}) {
    const config = resolveConfig(state, deps);
    const allCountryCandidates = resolveCountryCandidates(state);
    if (!allCountryCandidates.length) {
      throw new Error('步骤 9：HeroSMS 未选择国家，请先在接码设置中至少选择 1 个国家。');
    }
    const blockedCountryIds = new Set(
      (Array.isArray(options?.blockedCountryIds) ? options.blockedCountryIds : [])
        .map((value) => normalizeHeroSmsCountryId(value, 0))
        .filter((id) => id > 0)
    );
    let countryCandidates = allCountryCandidates.filter(
      (entry) => !blockedCountryIds.has(normalizeHeroSmsCountryId(entry.id, 0))
    );
    if (!countryCandidates.length) {
      countryCandidates = allCountryCandidates;
      if (blockedCountryIds.size && typeof deps.addLog === 'function') {
        await deps.addLog('步骤 9：已选国家均达到临时收码失败跳过阈值，本轮解除跳过并重新尝试。', 'warn');
      }
    }
    const acquirePriority = normalizeHeroSmsAcquirePriority(state?.heroSmsAcquirePriority);
    const priceRange = resolvePriceRange(state);
    if (priceRange.invalidRange) {
      throw new Error(`HeroSMS 价格区间无效：最低购买价 ${priceRange.minPriceLimit} 高于价格上限 ${priceRange.maxPriceLimit}。`);
    }
    const preferredPriceTier = normalizeHeroSmsPriceLimit(state?.heroSmsPreferredPrice);
    const countryPriceFloorByCountryId = normalizePriceFloorMap(
      options?.countryPriceFloorByCountryId,
      (value) => String(normalizeHeroSmsCountryId(value, 0))
    );
    const requestActions = ['getNumber', 'getNumberV2'];
    const maxAcquireRounds = Math.max(2, normalizeActivationRetryRounds(state?.heroSmsActivationRetryRounds));
    const retryDelayMs = normalizeActivationRetryDelayMs(state?.heroSmsActivationRetryDelayMs);
    let finalNoNumbersByCountry = [];
    let finalLastError = null;
    let finalLastFailureText = '';

    for (let round = 1; round <= maxAcquireRounds; round += 1) {
      if (maxAcquireRounds > 1 && typeof deps.addLog === 'function') {
        await deps.addLog(`步骤 9：HeroSMS 正在获取手机号（第 ${round}/${maxAcquireRounds} 轮）...`, 'info');
      }
      const countryAttempts = countryCandidates.map((countryConfig, index) => ({
        index,
        countryConfig,
        pricePlan: null,
        orderingPrice: Number.POSITIVE_INFINITY,
      }));

      if (
        acquirePriority === HERO_SMS_ACQUIRE_PRIORITY_PRICE
        || acquirePriority === HERO_SMS_ACQUIRE_PRIORITY_PRICE_HIGH
      ) {
        for (const attempt of countryAttempts) {
          const pricePlan = await resolvePricePlan(state, attempt.countryConfig, deps);
          const orderedPrices = reorderPriceCandidates(pricePlan?.prices, acquirePriority, preferredPriceTier);
          const rangeFilteredForRanking = filterPriceCandidatesWithinRange(
            orderedPrices,
            priceRange.minPriceLimit,
            priceRange.maxPriceLimit
          );
          const rankingPrices = rangeFilteredForRanking.length
            ? rangeFilteredForRanking
            : ((priceRange.hasMinPriceLimit || priceRange.hasMaxPriceLimit) ? [] : orderedPrices);
          const numericPrices = rankingPrices
            .map((value) => Number(value))
            .filter((value) => Number.isFinite(value) && value > 0);
          const candidateOrderingPrice = numericPrices.length ? numericPrices[0] : null;
          const cappedByUserLimit = (
            pricePlan?.userLimit !== null
            && pricePlan?.userLimit !== undefined
            && pricePlan?.minCatalogPrice !== null
            && pricePlan?.minCatalogPrice !== undefined
            && Number(pricePlan.minCatalogPrice) > Number(pricePlan.userLimit)
          );
          attempt.pricePlan = pricePlan;
          attempt.orderingPrice = cappedByUserLimit
            ? Number.POSITIVE_INFINITY
            : (candidateOrderingPrice !== null ? candidateOrderingPrice : Number.POSITIVE_INFINITY);
        }
      }

      if (
        (acquirePriority === HERO_SMS_ACQUIRE_PRIORITY_PRICE || acquirePriority === HERO_SMS_ACQUIRE_PRIORITY_PRICE_HIGH)
        && countryAttempts.length > 1
      ) {
        countryAttempts.sort((left, right) => {
          if (left.orderingPrice !== right.orderingPrice) {
            return acquirePriority === HERO_SMS_ACQUIRE_PRIORITY_PRICE_HIGH
              ? (right.orderingPrice - left.orderingPrice)
              : (left.orderingPrice - right.orderingPrice);
          }
          return left.index - right.index;
        });
      }

      const noNumbersByCountry = [];
      const retryableNoNumberCountries = [];
      let lastError = null;
      let lastFailureText = '';

      for (const attempt of countryAttempts) {
        const countryConfig = attempt.countryConfig;
        const countryIdKey = String(normalizeHeroSmsCountryId(countryConfig?.id, 0));
        const countryPriceFloor = countryPriceFloorByCountryId.get(countryIdKey) ?? null;
        const buildFallbackActivation = (requestAction) => ({
          countryId: countryConfig.id,
          ...(requestAction === 'getNumberV2' ? { statusAction: 'getStatusV2' } : {}),
        });
        const pricePlan = attempt.pricePlan || await resolvePricePlan(state, countryConfig, deps);
        let noNumbersObservedInCountry = false;
        const orderedPrices = reorderPriceCandidates(pricePlan.prices, acquirePriority, preferredPriceTier);
        const rangeFilteredPrices = filterPriceCandidatesWithinRange(
          orderedPrices,
          priceRange.minPriceLimit,
          priceRange.maxPriceLimit
        );
        const candidatePrices = rangeFilteredPrices.length
          ? rangeFilteredPrices
          : ((priceRange.hasMinPriceLimit || priceRange.hasMaxPriceLimit) ? [] : orderedPrices);
        const floorFilteredPrices = filterPriceCandidatesAboveFloor(candidatePrices, countryPriceFloor);
        const hasCountryPriceFloor = (
          countryPriceFloor !== null
          && Number.isFinite(Number(countryPriceFloor))
          && Number(countryPriceFloor) > 0
        );
        const hasAlternativeCountries = countryAttempts.some((entry) => (
          String(normalizeHeroSmsCountryId(entry?.countryConfig?.id, 0))
          !== String(normalizeHeroSmsCountryId(countryConfig?.id, 0))
        ));
        const pricesToTry = hasCountryPriceFloor
          ? (floorFilteredPrices.length ? floorFilteredPrices : (hasAlternativeCountries ? [] : candidatePrices.slice(0, 1)))
          : (floorFilteredPrices.length ? floorFilteredPrices : candidatePrices);

        if (typeof deps.addLog === 'function') {
          const rawTierText = Array.isArray(pricePlan?.prices) && pricePlan.prices.length
            ? pricePlan.prices.map((value) => (value === null || value === undefined ? '自动' : String(value))).join(', ')
            : '无';
          await deps.addLog(
            `步骤 9：HeroSMS ${countryConfig.label} 价格方案：档位=[${rawTierText}]，用户上限=${pricePlan?.userLimit ?? '未设置'}，目录最低价=${pricePlan?.minCatalogPrice ?? '未知'}。`,
            'info'
          );
        }

        if (!pricesToTry.length) {
          if (priceRange.hasMinPriceLimit && !rangeFilteredPrices.length) {
            noNumbersByCountry.push(`${countryConfig.label}: 价格区间 ${formatPriceRangeText(priceRange.minPriceLimit, priceRange.maxPriceLimit)} 内暂无可用号码`);
            continue;
          }
          if (
            countryPriceFloor !== null
            && Array.isArray(pricePlan.prices)
            && pricePlan.prices.length > 0
          ) {
            noNumbersByCountry.push(`${countryConfig.label}: 当前回退尝试没有高于 ${countryPriceFloor} 的价格档位`);
            continue;
          }
          if (
            pricePlan.userLimit !== null
            && pricePlan.minCatalogPrice !== null
            && pricePlan.minCatalogPrice > pricePlan.userLimit
          ) {
            noNumbersByCountry.push(`${countryConfig.label}: 价格上限 ${pricePlan.userLimit} 内暂无可用号码；平台最低价=${pricePlan.minCatalogPrice}`);
          } else {
            noNumbersByCountry.push(`${countryConfig.label}: ${lastFailureText || 'NO_NUMBERS'}`);
            retryableNoNumberCountries.push(countryConfig.label);
          }
          continue;
        }

        for (const maxPrice of pricesToTry) {
          for (const requestAction of requestActions) {
            try {
              const fixedPrice = !Boolean(pricePlan.syntheticUserLimitProbe);
              if (typeof deps.addLog === 'function') {
                await deps.addLog(
                  `步骤 9：HeroSMS ${countryConfig.label} 正在尝试${formatActionName(requestAction)}，价格档位 ${maxPrice === null || maxPrice === undefined ? '自动' : maxPrice}。`,
                  'info'
                );
              }
              const payload = await requestActivationWithPrice(config, countryConfig, requestAction, maxPrice, {
                userLimit: pricePlan.userLimit,
                userMinLimit: priceRange.minPriceLimit,
                fixedPrice,
              });
              const activation = parseActivationPayload(payload, buildFallbackActivation(requestAction));
              if (activation) {
                return {
                  ...activation,
                  countryId: normalizeHeroSmsCountryId(countryConfig.id),
                  ...(Number.isFinite(Number(maxPrice)) && Number(maxPrice) > 0
                    ? { selectedPrice: Math.round(Number(maxPrice) * 10000) / 10000 }
                    : {}),
                };
              }
              const payloadText = describePayload(payload);
              if (isNoNumbersPayload(payload)) {
                noNumbersObservedInCountry = true;
                lastFailureText = payloadText || lastFailureText;
                continue;
              }
              if (isTerminalError(payload)) {
                throw createActionFailureError(requestAction, payloadText || 'empty response');
              }
              lastFailureText = payloadText || lastFailureText;
              lastError = createActionFailureError(requestAction, payloadText || 'empty response');
            } catch (error) {
              if (error?.localizedPhoneSmsFailure) {
                throw error;
              }
              const payloadOrMessage = error?.payload || error?.message;
              if (isTerminalError(payloadOrMessage)) {
                throw createActionFailureError(requestAction, payloadOrMessage || 'empty response');
              }
              if (isNoNumbersPayload(payloadOrMessage)) {
                noNumbersObservedInCountry = true;
                lastFailureText = describePayload(payloadOrMessage) || lastFailureText;
                continue;
              }
              lastFailureText = describePayload(payloadOrMessage) || lastFailureText;
              lastError = error;
            }
          }
        }

        if (noNumbersObservedInCountry) {
          const tiersTriedText = pricesToTry
            .map((value) => (value === null || value === undefined ? '自动' : String(value)))
            .join(', ');
          noNumbersByCountry.push(
            `${countryConfig.label}: ${lastFailureText || 'NO_NUMBERS'}${tiersTriedText ? `（已尝试档位：${tiersTriedText}）` : ''}`
          );
          retryableNoNumberCountries.push(countryConfig.label);
        }
      }

      finalNoNumbersByCountry = noNumbersByCountry;
      finalLastError = lastError;
      finalLastFailureText = lastFailureText;
      if (
        noNumbersByCountry.length
        && round < maxAcquireRounds
        && retryableNoNumberCountries.length > 0
      ) {
        if (typeof deps.addLog === 'function') {
          await deps.addLog(
            `步骤 9：HeroSMS 暂无可用号码（第 ${round}/${maxAcquireRounds} 轮）；${Math.ceil(retryDelayMs / 1000)} 秒后重试。国家：${retryableNoNumberCountries.join(', ')}。`,
            'warn'
          );
        }
        await deps.sleepWithStop?.(retryDelayMs);
        continue;
      }
      break;
    }

    if (finalNoNumbersByCountry.length) {
      throw new Error(`HeroSMS 已尝试 ${countryCandidates.length} 个候选国家，均无可用号码：${finalNoNumbersByCountry.join(' | ')}。`);
    }
    if (finalLastError) {
      throw finalLastError;
    }
    throw new Error(`HeroSMS 获取手机号失败，最后状态：${finalLastFailureText || '未知'}。`);
  }

  async function reuseActivation(state = {}, activation, deps = {}) {
    const normalizedActivation = normalizeActivation(activation);
    if (!normalizedActivation) {
      throw new Error('缺少可复用的 HeroSMS 手机号订单。');
    }
    const config = resolveConfig(state, deps);
    const payload = await fetchPayload(config, {
      action: 'reactivate',
      id: normalizedActivation.activationId,
    }, 'HeroSMS reactivate');
    const nextActivation = parseActivationPayload(payload, normalizedActivation);
    if (!nextActivation) {
      throw new Error(`HeroSMS 复用手机号失败：${describePayload(payload) || '空响应'}`);
    }
    return nextActivation;
  }

  async function pollActivationCode(state = {}, activation, options = {}, deps = {}) {
    const normalizedActivation = normalizeActivation(activation);
    if (!normalizedActivation) {
      throw new Error('缺少手机号接码订单。');
    }
    const config = resolveConfig(state, deps);
    const statusAction = resolveActivationStatusAction(normalizedActivation);
    const timeoutMs = Math.max(1000, Number(options.timeoutMs) || DEFAULT_POLL_TIMEOUT_MS);
    const intervalMs = Math.max(1000, Number(options.intervalMs) || DEFAULT_POLL_INTERVAL_MS);
    const maxRoundsRaw = Math.floor(Number(options.maxRounds));
    const maxRounds = Number.isFinite(maxRoundsRaw) && maxRoundsRaw > 0 ? maxRoundsRaw : 0;
    const start = Date.now();
    let lastResponse = '';
    let pollCount = 0;
    const emitWaitingForCode = async (statusText) => {
      if (typeof options.onWaitingForCode === 'function') {
        await options.onWaitingForCode({
          activation: normalizedActivation,
          elapsedMs: Date.now() - start,
          pollCount,
          statusText,
          timeoutMs,
        });
      }
    };

    while (Date.now() - start < timeoutMs) {
      if (maxRounds > 0 && pollCount >= maxRounds) {
        break;
      }
      deps.throwIfStopped?.();
      const payload = await fetchPayload(config, {
        action: statusAction,
        id: normalizedActivation.activationId,
      }, `HeroSMS ${statusAction}`);
      const text = describePayload(payload);
      lastResponse = text;
      pollCount += 1;
      if (typeof options.onStatus === 'function') {
        await options.onStatus({
          activation: normalizedActivation,
          elapsedMs: Date.now() - start,
          pollCount,
          statusText: text,
          timeoutMs,
        });
      }
      const v2Code = (
        payload
        && typeof payload === 'object'
        && !Array.isArray(payload)
        && (
          extractVerificationCode(payload.sms?.code)
          || extractVerificationCode(payload.call?.code)
        )
      );
      if (v2Code) {
        return v2Code;
      }
      const okMatch = text.match(/^STATUS_OK:(.+)$/i);
      if (okMatch) {
        const code = extractVerificationCode(okMatch[1] || '');
        if (code) {
          return code;
        }
        await emitWaitingForCode(text || 'STATUS_OK');
        await deps.sleepWithStop?.(intervalMs);
        continue;
      }
      if (/^STATUS_(WAIT_CODE|WAIT_RETRY|WAIT_RESEND)(?::.+)?$/i.test(text)) {
        await emitWaitingForCode(text);
        await deps.sleepWithStop?.(intervalMs);
        continue;
      }
      if (statusAction === 'getStatusV2' && payload && typeof payload === 'object' && !Array.isArray(payload)) {
        await emitWaitingForCode(text || 'PENDING');
        await deps.sleepWithStop?.(intervalMs);
        continue;
      }
      if (/^STATUS_CANCEL$/i.test(text)) {
        throw new Error('HeroSMS 订单在短信到达前已被取消。');
      }
      throw createActionFailureError(statusAction, text || 'empty response');
    }
    throw new Error(`${PHONE_CODE_TIMEOUT_ERROR_PREFIX}等待手机验证码超时。${lastResponse ? ` HeroSMS 最后状态：${lastResponse}` : ''}`);
  }

  async function finishActivation(state = {}, activation, deps = {}) {
    return setActivationStatus(state, activation, 6, deps, 'HeroSMS setStatus(6)');
  }

  async function cancelActivation(state = {}, activation, deps = {}) {
    return setActivationStatus(state, activation, 8, deps, 'HeroSMS setStatus(8)');
  }

  async function banActivation(state = {}, activation, deps = {}) {
    return setActivationStatus(state, activation, 8, deps, 'HeroSMS setStatus(8)');
  }

  async function requestAdditionalSms(state = {}, activation, deps = {}) {
    return setActivationStatus(state, activation, 3, deps, 'HeroSMS setStatus(3)');
  }

  async function rotateActivation(state = {}, activation, options = {}, deps = {}) {
    const releaseAction = String(options?.releaseAction || '').trim().toLowerCase() === 'ban'
      ? 'ban'
      : 'cancel';
    if (releaseAction === 'ban') {
      await banActivation(state, activation, deps);
    } else {
      await cancelActivation(state, activation, deps);
    }
    return {
      currentTicketId: String(activation?.activationId || ''),
      nextActivation: null,
    };
  }

  function isWaitingStatusText(text) {
    return /^STATUS_(WAIT_CODE|WAIT_RETRY|WAIT_RESEND)(?::.+)?$/i.test(String(text || '').trim());
  }

  function isReadyForFreshSmsText(text) {
    return /^STATUS_WAIT_CODE(?::.+)?$/i.test(String(text || '').trim());
  }

  async function prepareActivationForReuse(state = {}, activation, options = {}, deps = {}) {
    const normalizedActivation = normalizeActivation(activation);
    if (!normalizedActivation) {
      return {
        ok: false,
        reason: 'missing_activation',
        message: '已保存的免费复用手机号记录无效。',
      };
    }
    const config = resolveConfig(state, deps);
    const statusAction = resolveActivationStatusAction(normalizedActivation);
    const timeoutMs = Math.max(1000, Number(options.timeoutMs) || 20000);
    const intervalMs = Math.max(1000, Number(options.intervalMs) || 2000);
    const maxRounds = Math.max(1, Math.floor(Number(options.maxRounds) || 10));
    const start = Date.now();
    let lastStatus = '';
    let prepareRound = 0;
    while (Date.now() - start < timeoutMs && prepareRound < maxRounds) {
      deps.throwIfStopped?.();
      prepareRound += 1;
      try {
        await requestAdditionalSms(state, normalizedActivation, deps);
      } catch (error) {
        return {
          ok: false,
          reason: 'set_status_failed',
          message: error.message || 'HeroSMS 更新订单状态失败。',
          lastStatus,
          prepareRound,
        };
      }
      if (typeof deps.addLog === 'function') {
        await deps.addLog(
          `步骤 9：自动白嫖复用已刷新 ${normalizedActivation.phoneNumber}，${Math.ceil(intervalMs / 1000)} 秒后检查等待状态（${prepareRound}/${maxRounds}）。`,
          'info'
        );
      }
      await deps.sleepWithStop?.(intervalMs);
      try {
        const payload = await fetchPayload(config, {
          action: statusAction,
          id: normalizedActivation.activationId,
        }, `HeroSMS 自动复用${statusAction}`);
        const statusText = describePayload(payload);
        lastStatus = statusText;
        if (typeof deps.addLog === 'function') {
          await deps.addLog(
            `步骤 9：自动白嫖复用号码 ${normalizedActivation.phoneNumber} 状态：${statusText || '空响应'}（${prepareRound}/${maxRounds}）。`,
            'info'
          );
        }
        const v2Waiting = statusAction === 'getStatusV2'
          && payload
          && typeof payload === 'object'
          && !Array.isArray(payload)
          && !payload.sms?.code
          && !payload.call?.code;
        if (isReadyForFreshSmsText(statusText) || isWaitingStatusText(statusText) || v2Waiting) {
          return {
            ok: true,
            activation: normalizedActivation,
          };
        }
        if (/^STATUS_OK:/i.test(statusText)) {
          if (typeof deps.addLog === 'function') {
            await deps.addLog('步骤 9：自动白嫖复用仍看到旧验证码，将再次刷新等待短信状态。', 'warn');
          }
          continue;
        }
        if (/^STATUS_CANCEL$/i.test(statusText)) {
          return {
            ok: false,
            reason: 'activation_cancelled',
            message: 'HeroSMS 订单在自动白嫖复用前已被取消。',
            lastStatus,
            prepareRound,
          };
        }
      } catch (error) {
        return {
          ok: false,
          reason: 'get_status_failed',
          message: error.message || 'HeroSMS 查询短信状态失败。',
          lastStatus,
          prepareRound,
        };
      }
    }
    return {
      ok: false,
      reason: 'prepare_timeout',
      message: `等待已保存手机号进入短信等待状态超时。最后状态：${lastStatus || '未知'}。`,
      lastStatus,
      prepareRound,
    };
  }

  function createProvider(deps = {}) {
    const providerDeps = {
      fetchImpl: deps.fetchImpl,
      sleepWithStop: deps.sleepWithStop,
      throwIfStopped: deps.throwIfStopped,
      addLog: deps.addLog,
      setState: deps.setState,
      requestTimeoutMs: deps.requestTimeoutMs || DEFAULT_REQUEST_TIMEOUT_MS,
    };
    const capabilities = Object.freeze({
      supportsReusableActivation: true,
      supportsAutomaticFreeReuse: true,
      supportsFreeReusePreservation: true,
      supportsPageResend: true,
      supportsPageResendProbe: true,
      requiresCountrySelection: true,
    });
    return {
      id: PROVIDER_ID,
      label: 'HeroSMS',
      capabilities,
      defaultCountryId: DEFAULT_COUNTRY_ID,
      defaultCountryLabel: DEFAULT_COUNTRY_LABEL,
      defaultProduct: DEFAULT_SERVICE_LABEL,
      normalizeCountryId: normalizeHeroSmsCountryId,
      normalizeCountryLabel: normalizeHeroSmsCountryLabel,
      normalizeCountryFallback: normalizeHeroSmsCountryFallback,
      normalizeCountryKey,
      normalizeMaxPrice: normalizeHeroSmsMaxPrice,
      normalizeActivation,
      resolveCountryCandidates,
      resolveCountryLabel,
      resolveActivationCountry,
      getActivationCountryKey,
      getActivationPrice,
      requestActivation: (state, options) => requestActivation(state, options, providerDeps),
      reuseActivation: (state, activation) => reuseActivation(state, activation, providerDeps),
      finishActivation: (state, activation) => finishActivation(state, activation, providerDeps),
      cancelActivation: (state, activation) => cancelActivation(state, activation, providerDeps),
      banActivation: (state, activation) => banActivation(state, activation, providerDeps),
      requestAdditionalSms: (state, activation) => requestAdditionalSms(state, activation, providerDeps),
      rotateActivation: (state, activation, options) => rotateActivation(state, activation, options, providerDeps),
      pollActivationCode: (state, activation, options) => pollActivationCode(state, activation, options, providerDeps),
      prepareActivationForReuse: (state, activation, options) => prepareActivationForReuse(state, activation, options, providerDeps),
      canPersistReusableActivation: () => true,
      canPreserveActivationForFreeReuse: (_state, activation) => {
        const normalizedActivation = normalizeActivation(activation);
        return Boolean(
          normalizedActivation
          && activation
          && typeof activation === 'object'
          && activation.phoneCodeReceived
        );
      },
      shouldUsePageResend: () => true,
      shouldProbePageResend: () => true,
      fetchBalance: (state) => fetchBalance(state, providerDeps),
      fetchPrices: (state, countryConfig) => fetchPrices(state, countryConfig, providerDeps),
      resolvePricePlan: (state, countryConfig) => resolvePricePlan(state, countryConfig, providerDeps),
      resolvePriceRange,
      formatPriceRangeText,
      describePayload,
    };
  }

  return {
    PROVIDER_ID,
    DEFAULT_BASE_URL,
    DEFAULT_COUNTRY_ID,
    DEFAULT_COUNTRY_LABEL,
    DEFAULT_SERVICE_CODE,
    DEFAULT_SERVICE_LABEL,
    createProvider,
    describePayload,
    normalizeHeroSmsCountryFallback,
    normalizeHeroSmsCountryId,
    normalizeHeroSmsCountryLabel,
    normalizeCountryKey,
    normalizeHeroSmsMaxPrice,
    normalizeHeroSmsOperator,
    normalizeActivation,
    resolveActivationCountry,
  };
});