// ==UserScript==
// @name         Mútuo
// @description  Quem não te segue de volta no Instagram, direto no Safari do iPhone.
// @version      1.3.1
// @match        https://www.instagram.com/*
// @run-at       document-idle
// @inject-into  auto
// @grant        GM.getValue
// @grant        GM.setValue
// @grant        GM.deleteValue
// @updateURL    https://usemutuo.com.br/iphone/mutuo.user.js
// @downloadURL  https://usemutuo.com.br/iphone/mutuo.user.js
// ==/UserScript==
/* Gerado por ferramentas/gerar-iphone.mjs: a fonte é extensao/ e celular/. Não edite aqui. */
(function () {
  'use strict';
  if (window.top !== window || document.getElementById('mutuo-botao')) return;

  function abrirMutuo() {
/* Mútuo: motor gerado por ferramentas/motor-celular.mjs. Não edite: a fonte é extensao/. */
(function () {
  'use strict';
  if (window.__mutuoMotor) return;

  /*
   * O cookie da sessão. O Android entrega pelo CookieManager (que enxerga o que
   * o document.cookie não enxerga); a ponte só responde por ds_user_id e
   * csrftoken, que é o que o motor pede.
   */
  const cookiesNativos = {
    async get({ name }) {
      let valor = '';
      try {
        if (window.MutuoNativo) valor = String(window.MutuoNativo.cookie(name) || '');
      } catch (e) { valor = ''; }
      if (!valor) {
        const achado = document.cookie.split('; ').find((c) => c.startsWith(name + '='));
        valor = achado ? decodeURIComponent(achado.slice(name.length + 1)) : '';
      }
      return valor ? { value: valor } : null;
    },
  };

  /*
   * A "aba do Instagram" da extensão é a própria página (ver o topo de
   * ferramentas/motor-celular.mjs). sendMessage entrega a mensagem ao ouvinte
   * que extensao/ponte.js registrou, e devolve o que ele responder. A aba
   * nunca é nossa para fechar: remove não faz nada.
   */
  let ouvinteDaPonte = null;
  const chrome = {
    runtime: {
      onMessage: { addListener(f) { ouvinteDaPonte = f; } },
      sendMessage: () => Promise.resolve(),
    },
    tabs: {
      query: async () => [{ id: 1 }],
      create: async () => ({ id: 1 }),
      remove: async () => {},
      sendMessage: (id, mensagem) => new Promise((responder) => {
        if (!ouvinteDaPonte) { responder(undefined); return; }
        let respondeu = false;
        const assincrono = ouvinteDaPonte(mensagem, {}, (r) => { respondeu = true; responder(r); });
        if (assincrono !== true && !respondeu) responder(undefined);
      }),
    },
  };

/*
 * A amostra do plano FREE.
 *
 * Fica em módulo próprio porque é a única peça do limite que é lógica pura —
 * sem rede, sem tela — e por isso a única que dá para testar sozinha. As regras
 * abaixo parecem óbvias e nenhuma delas é: cada uma corresponde a uma conta
 * real que ficaria mal servida.
 */

/**
 * Junta duas listas alternando entre elas, sem repetir ninguém, até o limite.
 *
 * Alterna em vez de fatiar metade de cada uma por causa das contas
 * desequilibradas, que são a maioria: quem segue 8 pessoas e tem 600 seguidores
 * receberia 8 + 25 = 33 perfis analisados num corte fixo, e recebe os 50 aqui.
 *
 * Quem aparece nas duas listas entra uma vez só: é a MESMA pessoa, e ocuparia
 * duas vagas da amostra à toa.
 *
 * @param {{pk: string}[]} listaA
 * @param {{pk: string}[]} listaB
 * @param {number} limite
 * @returns {{pk: string}[]}
 */
function amostrar(listaA = [], listaB = [], limite = 0) {
  const vistos = new Set();
  const amostra = [];
  const maior = Math.max(listaA.length, listaB.length);

  for (let i = 0; i < maior && amostra.length < limite; i += 1) {
    for (const pessoa of [listaA[i], listaB[i]]) {
      // O pk vira texto: `1` e `'1'` são a MESMA pessoa, e um Set não converte
      // tipo. Se uma das listas vier com pk numérico, a dedupe silenciosamente
      // parava de funcionar e a amostra de 50 viraria 25 pessoas reais.
      const chave = pessoa && String(pessoa.pk);
      if (!pessoa || vistos.has(chave) || amostra.length >= limite) continue;
      vistos.add(chave);
      amostra.push(pessoa);
    }
  }

  return amostra;
}


/*
 * O ritmo das ações que ESCREVEM na conta (seguir, deixar de seguir).
 *
 * Fica em módulo próprio porque é aritmética pura — e porque estes números são
 * a diferença entre uma ferramenta e uma conta bloqueada. Mexer aqui muda o
 * risco de quem usa, então cada valor tem um motivo escrito.
 *
 * O QUE O INSTAGRAM PUNE não é o total, é o PADRÃO. Três coisas, nesta ordem:
 *
 *   1. Rajada. Cinco ações em cinco segundos e depois dois minutos parado é
 *      assinatura de script. Era exatamente o que a extensão fazia antes: o
 *      freio limitava o volume por janela, mas dentro da janela as ações saíam
 *      coladas. Por isso o intervalo agora é POR AÇÃO.
 *   2. Cadência constante. Uma ação a cada 18 segundos, cravado, é tão
 *      identificável quanto a rajada. Por isso o intervalo é SORTEADO a cada
 *      vez, dentro de uma faixa.
 *   3. Volume por dia. É o que gera o "action block" (`feedback_required`),
 *      que trava ações por 24 horas a uma semana — e cada bloqueio deixa o
 *      próximo mais provável. Daí o teto de 24 horas, que antes não existia:
 *      nada impedia 800 ações num dia.
 *
 * OS VALORES DE HOJE (16/08/2026) SÃO OS DA SEGUNDA RODADA. A primeira, de
 * 15/08, mirava ~35 minutos a cada 100 contas — ~170 ações/hora com teto de 200
 * por dia — e ficava acima do que eu recomendava. A conta do dono levou "action
 * block", que é exatamente o gatilho que estava escrito aqui, e ele escolheu
 * desacelerar: ~75 ações/hora, teto de 100 por dia, ~1h20 a cada 100 contas.
 *
 * Continua valendo, e agora com um caso concreto por trás: SE A CONTA VOLTAR A
 * LEVAR BLOQUEIO, o caminho é aumentar os intervalos e diminuir o teto — nunca o
 * contrário.
 */

const RITMO = {
  // Entre uma conta e a seguinte, sorteado a cada vez.
  minMs: 28000,
  maxMs: 50000,
  // Uma parada mais longa de tempos em tempos — imita quem larga a tela e
  // volta. Sem ela, uma hora de intervalos curtos ainda desenha uma linha reta.
  // Mais curta na contagem (a cada 25, não 40) e mais longa no relógio: a linha
  // reta que ela quebra fica mais evidente quanto mais longa é a sessão.
  pausaACada: 25,
  pausaMs: 300000, // 5 min
};

/*
 * Teto de ações num período de 24 horas CORRIDAS, contando tudo que escreve
 * (seguir, deixar de seguir, Close Friends).
 *
 * Rolante, e não "por dia do calendário", de propósito: zerando à meia-noite,
 * dava para fazer 100 às 23h e mais 100 à 0h05 — 200 em dez minutos, que é
 * justamente o volume que derruba conta.
 */
const TETO_24H = 100;

/** Teto de rajada: quantas ações cabem numa janela curta. */
const MAX_ACOES_POR_JANELA = 10;
const JANELA_MS = 120000;

/*
 * O CLOSE FRIENDS, UMA PESSOA POR PEDIDO (17/09/2026).
 *
 * Até esta data um pedido levava 50 pessoas, e cem contas eram duas chamadas.
 * O caminho que o site usa hoje (o Bloks, em instagram.js) leva uma só, então a
 * ação em massa passou a ser uma sequência de pedidos, como o unfollow. O ritmo
 * dela é outro, e mais rápido, por dois motivos medidos na própria tela do
 * Instagram: ela manda um pedido a cada toque, no ritmo em que a pessoa toca, e
 * avisa que "não enviamos notificações quando você edita sua lista Amigos
 * Próximos". Ninguém é alcançado, que é o que distingue esta escrita de seguir.
 *
 * Mais rápido não é sem freio: intervalo SORTEADO entre pedidos (cadência fixa
 * é assinatura de script, como no unfollow) e uma pausa a cada 25. Cem contas
 * ficam em cerca de 9 minutos, dito na confirmação antes de começar.
 */
const RITMO_CLOSE = {
  minMs: 2500,
  maxMs: 6000,
  pausaACada: 25,
  pausaMs: 45000,
};

/*
 * Quantas alterações do Close Friends valem UMA ação nos contadores de 2
 * minutos e de 24 horas.
 *
 * Aqueles tetos foram calibrados para seguir e deixar de seguir, que é o que o
 * Instagram pune. Contar cada pessoa do Close Friends como uma ação faria uma
 * lista de cem gastar o dia inteiro de unfollow, por uma escrita que não chega a
 * ninguém. Até 17/09/2026 a conta já era por pedido, e um pedido levava 50; 25
 * é a metade disso, porque agora o volume de requisições é maior. A TRAVA
 * pós-bloqueio não entra nessa conta: ela vale para cada pedido, sem desconto.
 *
 * SE UMA CONTA LEVAR BLOQUEIO LOGO DEPOIS DE MEXER NO CLOSE FRIENDS, este número
 * e o `RITMO_CLOSE` são os primeiros a mudar: diminuir um, alongar o outro.
 */
const CLOSE_POR_ACAO = 25;

/**
 * Quanto esperar antes da próxima ação.
 * @param {{minMs:number, maxMs:number}} faixa
 * @param {() => number} sorteio  injetável para o teste ser determinístico
 */
function intervaloEntreAcoes(sorteio = Math.random, faixa = RITMO) {
  return Math.round(faixa.minMs + sorteio() * (faixa.maxMs - faixa.minMs));
}

/**
 * A pausa longa cai depois desta ação? (1-based: a 25ª, a 50ª…)
 * @param {number} feitas
 * @param {{pausaACada:number}} ritmo  `RITMO` (unfollow) ou `RITMO_CLOSE`
 */
function toca(feitas, ritmo = RITMO) {
  return feitas > 0 && feitas % ritmo.pausaACada === 0;
}

/**
 * Quanto tempo, em segundos, N contas devem levar — o número que aparece na
 * confirmação, antes de qualquer coisa acontecer.
 *
 * Usa a MÉDIA do intervalo. Não é promessa: o sorteio pode puxar para cima ou
 * para baixo, e uma espera do teto de rajada entra por fora. Melhor um número
 * honesto e aproximado do que nenhum — sem ele, quem clica achando que são
 * segundos abandona no meio.
 */
function segundosPara(n, ritmo = RITMO) {
  if (n <= 0) return 0;
  const media = (ritmo.minMs + ritmo.maxMs) / 2;
  const pausas = Math.floor(Math.max(0, n - 1) / ritmo.pausaACada);
  return Math.round((n * media + pausas * ritmo.pausaMs) / 1000);
}

/*
 * ---------------------------------------------------------------------------
 * DEPOIS DE UM BLOQUEIO
 * ---------------------------------------------------------------------------
 *
 * Os freios acima existem para o bloqueio não acontecer. Estes existem para o
 * SEGUNDO não acontecer — e são a parte que faltava.
 *
 * O que acontecia até 16/08/2026: a ação levava `feedback_required`, a operação
 * parava, a tela dizia "pare por hoje", e nada impedia um novo clique trinta
 * segundos depois. Continuar batendo numa conta recém-bloqueada é o que
 * transforma 24 horas de bloqueio em uma semana, e uma semana em conta marcada.
 * O aviso sozinho não segura ninguém: quem está no meio de uma limpeza de 400
 * contas tenta de novo, e a extensão deixava.
 *
 * Então a trava é da FERRAMENTA, e não um pedido:
 *
 *   - "action block" (`feedback_required`/spam) → 24 h sem nenhuma escrita;
 *   - "espere alguns minutos" (rate limit) → 1 h. É um aviso mais leve, e um
 *     castigo de 24 horas para ele seria desproporcional — mas zero também
 *     estava errado, porque é o Instagram dizendo, com todas as letras, que o
 *     ritmo está alto demais AGORA.
 *
 * Verificação (`challenge`) NÃO entra aqui de propósito: a mesma exceção cobre
 * sessão expirada e 401/403, e travar a ferramenta por 24 horas porque alguém
 * precisou refazer o login seria punir o usuário por um problema que ele
 * resolve em dez segundos.
 *
 * E a trava TEM SAÍDA (`dispensada`). A primeira versão não tinha, e estava
 * errada: a conta é de quem usa, e uma trava sem saída é a ferramenta decidindo
 * no lugar do dono — pior ainda num produto vendido, onde ela vira 24 horas de
 * tela morta que ninguém pediu. Esperar continua sendo o certo, e é o padrão;
 * dispensar é escolha explícita, e mantém o teto reduzido da retomada.
 */
const CASTIGO = {
  bloqueio: 24 * 60 * 60 * 1000,
  desacelerar: 60 * 60 * 1000,
};

/*
 * Passada a trava, a conta não volta ao ritmo cheio de uma vez: por 72 horas o
 * teto do dia cai para 40.
 *
 * Voltar direto a 100 no dia seguinte a um bloqueio é repetir o volume que
 * causou o bloqueio, com a conta ainda marcada — a janela em que o Instagram
 * está mais sensível é justamente a de logo depois.
 */
const RETOMADA_MS = 72 * 60 * 60 * 1000;
const TETO_RETOMADA = 40;

/**
 * A conta pode escrever agora, e com que teto — dado o último bloqueio.
 *
 * Lógica pura para poder ser testada: recebe o registro guardado
 * (`{ em, tipo }` ou nada) e o instante, devolve a situação.
 *
 * @param {{em:number, tipo:string}|null|undefined} bloqueio
 * @param {number} agora
 */
function situacaoDaConta(bloqueio, agora = Date.now()) {
  const em = Number(bloqueio?.em) || 0;
  const livre = { travada: false, faltam: 0, teto: TETO_24H, retomando: false, tipo: '' };
  if (!em) return livre;

  const tipo = bloqueio.tipo === 'desacelerar' ? 'desacelerar' : 'bloqueio';

  /*
   * Marca no futuro (relógio do computador adiantado, ou mexido) conta como
   * AGORA, e não como "já passou". Ignorar devolveria a conta ao ritmo cheio no
   * dia do bloqueio, que é o pior momento possível; o custo do outro lado é uma
   * espera indevida que se resolve acertando o relógio.
   */
  const desde = Math.max(0, agora - em);

  /*
   * Dispensada à mão: a espera cai, mas o resto NÃO. A data do bloqueio continua
   * valendo, então o teto reduzido da retomada segue de pé pelas 72 horas — quem
   * dispensou a trava pediu para tentar de novo, não para voltar ao volume que
   * causou o bloqueio.
   */
  if (bloqueio.dispensada !== true && desde < CASTIGO[tipo]) {
    return {
      travada: true,
      faltam: Math.ceil((CASTIGO[tipo] - desde) / 1000),
      teto: 0,
      retomando: false,
      tipo,
    };
  }

  if (tipo === 'bloqueio' && desde < RETOMADA_MS) {
    return { travada: false, faltam: 0, teto: TETO_RETOMADA, retomando: true, tipo };
  }

  return livre;
}

/**
 * O novo registro de recusa SUBSTITUI o que já está guardado?
 *
 * A regra é uma só: **o leve não apaga o grave**. Um "desacelerar" (1 h) não
 * pode tomar o lugar de um "action block", porque o que sobra do action block
 * depois da espera é o teto reduzido de 72 horas — e trocar o registro joga
 * fora justamente essa parte.
 *
 * O caso que fez esta função existir, e que a guarda anterior não pegava: quem
 * DISPENSA a trava está fazendo o que o aviso manda (tentar de novo). Se a ação
 * falhar — e ela falha, se o Instagram ainda estiver bloqueando —, a recusa
 * costuma vir como HTTP 429, que é classificado como "desacelerar". Com a
 * guarda presa a `travada`, esse desacelerar apagava o action block, e UMA HORA
 * depois a conta voltava ao teto cheio, sem aviso nenhum. O castigo de 72 horas
 * evaporava exatamente para quem já tinha sido bloqueado uma vez.
 *
 * Vive aqui, e não em `app.js`, para poder ser testada: é a única proteção que
 * sobra depois da dispensa, e ela estava no único arquivo que nenhum teste
 * alcança.
 *
 * @param {{em:number, tipo:string, dispensada?:boolean}|null|undefined} atual
 * @param {'bloqueio'|'desacelerar'} tipoNovo
 * @param {number} agora
 */
function deveRegistrar(atual, tipoNovo, agora = Date.now()) {
  // Um action block sempre entra: ele é o mais grave, e reinicia a contagem.
  if (tipoNovo !== 'desacelerar') return true;

  const situacao = situacaoDaConta(atual, agora);

  // Enquanto o action block ainda pesa — travando OU segurando o teto — ele manda.
  return !(situacao.tipo === 'bloqueio' && (situacao.travada || situacao.retomando));
}

/** O mesmo tempo, escrito para quem vai ler na tela. */
function tempoEmTexto(segundos) {
  if (segundos < 60) return 'menos de um minuto';

  const minutos = Math.round(segundos / 60);
  if (minutos < 60) return `cerca de ${minutos} minuto${minutos > 1 ? 's' : ''}`;

  const horas = Math.floor(minutos / 60);
  const resto = minutos % 60;
  const h = `${horas} hora${horas > 1 ? 's' : ''}`;
  return resto ? `cerca de ${h} e ${resto} min` : `cerca de ${h}`;
}


/*
 * Exportar a lista para arquivo — recurso do plano PRO.
 *
 * Módulo próprio porque é lógica pura (dados entram, texto sai) e por isso
 * testável sozinha. Quem baixa o arquivo é o app.js.
 *
 * O arquivo é montado NO NAVEGADOR e salvo pelo próprio navegador. Não há
 * upload, não há servidor, e não é preciso pedir a permissão `downloads` ao
 * Chrome: um Blob mais um link com `download` bastam. É a mesma regra que vale
 * para o resto da extensão — os seus dados não saem da sua máquina.
 */

/** As colunas do CSV, na ordem. */
const COLUNAS = [
  ['username', (p) => p.username],
  ['nome', (p) => p.full_name || ''],
  ['relacao', (p) => p.relacao],
  ['genero', (p) => p.genero],
  ['close_friends', (p) => (p.close ? 'sim' : 'nao')],
  ['privado', (p) => (p.is_private ? 'sim' : 'nao')],
  ['verificado', (p) => (p.is_verified ? 'sim' : 'nao')],
  ['perfil', (p) => `https://www.instagram.com/${p.username}/`],
];

/*
 * As colunas da BUSCA POR NICHO. Outra lista, e não um remendo na de cima: a
 * base exporta relação e gênero (que a busca não tem), e a busca exporta nota,
 * votos da rede, categoria, local e bio (que a base não tem). Espremer as duas
 * numa lista só daria um arquivo com metade das colunas sempre vazias.
 *
 * A BIO ENTRA COM AS QUEBRAS DE LINHA DESFEITAS: é texto de terceiro, escrito
 * livremente, e uma bio de quatro linhas quebraria a planilha em quatro. O
 * escape contra fórmula (`campoCsv`) importa ainda mais aqui do que na base —
 * bio é o campo mais livre que existe no Instagram.
 */
const COLUNAS_NICHO = [
  ['username', (p) => p.username],
  ['nome', (p) => p.full_name || ''],
  ['nota', (p) => p.nota],
  ['pessoas_da_sua_rede', (p) => p.votos || 0],
  ['categoria', (p) => p.categoria || ''],
  ['local', (p) => p.endereco || ''],
  ['bio', (p) => String(p.bio || '').replace(/\s+/g, ' ').trim()],
  ['privado', (p) => (p.is_private ? 'sim' : 'nao')],
  ['verificado', (p) => (p.is_verified ? 'sim' : 'nao')],
  ['perfil', (p) => `https://www.instagram.com/${p.username}/`],
];

/*
 * Escapa um campo do CSV.
 *
 * Aspas duplicadas e o campo inteiro entre aspas quando houver vírgula, aspas
 * ou quebra de linha — um `full_name` do Instagram pode ter qualquer um dos
 * três, e um único nome com vírgula desalinharia a planilha inteira.
 *
 * O apóstrofo na frente de `=`, `+`, `-` e `@` não é capricho: sem ele, um nome
 * começando com `=` vira FÓRMULA ao abrir no Excel ou no Google Sheets. É a
 * injeção de fórmula em CSV, e o dado aqui vem de perfis de terceiros.
 */
function campoCsv(valor) {
  let texto = String(valor ?? '');

  if (/^[=+\-@\t\r]/.test(texto)) {
    texto = "'" + texto;
  }

  return /[",\n\r;]/.test(texto) ? '"' + texto.replace(/"/g, '""') + '"' : texto;
}

/**
 * A lista em CSV.
 *
 * Separador `;` e BOM no começo: é o que faz o Excel em português abrir o
 * arquivo com as colunas separadas e os acentos corretos, que é onde essa lista
 * costuma acabar. Sem os dois, a planilha abre tudo numa coluna só.
 */
function paraCsv(pessoas, colunas = COLUNAS) {
  const linhas = [colunas.map(([nome]) => nome).join(';')];

  for (const p of pessoas) {
    linhas.push(colunas.map(([, ler]) => campoCsv(ler(p))).join(';'));
  }

  return '' + linhas.join('\r\n') + '\r\n';
}

/**
 * A mesma lista em JSON, para quem vai reprocessar em vez de abrir na planilha.
 * Traz o pk, que o CSV não traz: na planilha ele só atrapalha, mas em código é
 * a única identificação que não muda quando a pessoa troca de @.
 */
function paraJson(pessoas, meta = {}) {
  return JSON.stringify({ ...meta, contas: pessoas }, null, 2);
}

/**
 * Nome do arquivo com a data — quem exporta duas vezes precisa saber qual é
 * qual, e "mutuo (3).csv" não diz nada.
 *
 * @param {string} extensao  'csv' ou 'json'
 * @param {Date} quando
 */
function nomeDoArquivo(extensao, quando, prefixo = 'mutuo') {
  const d = quando;
  const p = (n) => String(n).padStart(2, '0');
  const carimbo = `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`
    + `_${p(d.getHours())}${p(d.getMinutes())}`;
  return `${prefixo}_${carimbo}.${extensao}`;
}


/*
 * Histórico de mudanças entre sincronizações — recurso do plano PRO.
 *
 * Módulo próprio por ser lógica pura: duas bases entram, uma lista de eventos
 * sai. Nada de rede, nada de tela.
 *
 * O QUE ELE NÃO PODE FAZER, e é a razão de existir separado com teste próprio:
 * comparar duas leituras PARCIAIS. No plano FREE cada sincronização lê uma
 * amostra de 50 perfis, e a amostra seguinte pode ser outra gente — quem saiu
 * dela não "deixou de te seguir", só não foi sorteado desta vez. Marcar isso
 * como perda seria acusar pessoas erradas, que é o pior defeito possível num
 * histórico de seguidores. Por isso `compararBases` exige que AS DUAS leituras
 * sejam completas e, na dúvida, devolve lista vazia.
 */

const TIPOS = {
  perdeu: 'perdeu',       // deixou de te seguir
  ganhou: 'ganhou',       // começou a te seguir
  segui: 'segui',         // você passou a seguir
  deixei: 'deixei',       // você deixou de seguir
};

/*
 * Uma leitura serve de base de comparação? Só se tiver lido tudo — e "tudo"
 * precisa ser CONFERIDO, não declarado.
 *
 * `parcial` é escrito à mão como `false` no caminho completo, então sozinho ele
 * não prova nada: uma coleta que terminasse cedo sem erro (uma página sem
 * `next_max_id` antes da hora) entraria aqui como completa, e todo seguidor que
 * faltou viraria um evento "deixou de te seguir". Numa base de 2000 que parou em
 * 1200, seriam 800 acusações falsas.
 *
 * Por isso a comparação com o total que o próprio perfil anuncia. A margem de
 * 10% existe porque os dois números divergem por natureza: o perfil conta contas
 * desativadas que as listas não devolvem mais.
 */
const MARGEM = 0.9;

function bateComOTotal(lidos, total) {
  if (!Number.isFinite(total) || total <= 0) return true; // sem total, não dá para conferir
  return Number.isFinite(lidos) && lidos >= total * MARGEM;
}

function completa(base) {
  if (!base || !Array.isArray(base.followers) || !Array.isArray(base.following)) return false;

  const a = base.analise;
  if (!a || a.plano !== 'pro' || a.parcial) return false;

  return bateComOTotal(a.lidosSeguidores, a.totalSeguidores)
    && bateComOTotal(a.lidosSeguindo, a.totalSeguindo);
}

const porPk = (lista) => new Map(lista.map((u) => [String(u.pk), u]));

/**
 * O que mudou entre duas leituras completas.
 *
 * @param {object|null} anterior  a base guardada antes desta sincronização
 * @param {object} nova           a base recém-lida
 * @param {number} quando         timestamp do evento
 * @returns {{em:number, tipo:string, pk:string, username:string, full_name:string}[]}
 *   vazio quando não dá para comparar — a primeira leitura de todas, ou
 *   qualquer uma das duas sendo parcial.
 */
function compararBases(anterior, nova, quando) {
  if (!completa(anterior) || !completa(nova)) return [];

  const eventos = [];
  const registrar = (tipo, u) => eventos.push({
    em: quando,
    tipo,
    pk: String(u.pk),
    // O nome vai junto: a pessoa pode sumir da base depois, e um histórico que
    // só guarda o pk vira uma lista de números.
    username: u.username || '',
    full_name: u.full_name || '',
  });

  const seguidoresAntes = porPk(anterior.followers);
  const seguidoresAgora = porPk(nova.followers);
  const seguindoAntes = porPk(anterior.following);
  const seguindoAgora = porPk(nova.following);

  for (const [pk, u] of seguidoresAntes) {
    if (!seguidoresAgora.has(pk)) registrar(TIPOS.perdeu, u);
  }
  for (const [pk, u] of seguidoresAgora) {
    if (!seguidoresAntes.has(pk)) registrar(TIPOS.ganhou, u);
  }
  for (const [pk, u] of seguindoAgora) {
    if (!seguindoAntes.has(pk)) registrar(TIPOS.segui, u);
  }
  for (const [pk, u] of seguindoAntes) {
    if (!seguindoAgora.has(pk)) registrar(TIPOS.deixei, u);
  }

  return eventos;
}

/*
 * Quantos eventos ficam guardados. O `chrome.storage.local` tem limite de
 * espaço, e um histórico que cresce para sempre acabaria derrubando a gravação
 * da BASE — que é o dado que não pode se perder. Os mais novos ficam.
 */
const TETO_HISTORICO = 2000;

/** Junta os eventos novos aos guardados, do mais recente para o mais antigo. */
function juntarHistorico(guardado, novos) {
  // `guardado` nulo virava um `null` dentro do array, e `renderHistorico`
  // estourava ao ler `e.tipo` — protegido hoje só pelo Array.isArray de quem
  // carrega, que é longe demais daqui.
  return [...(novos || [])].concat(guardado || []).slice(0, TETO_HISTORICO);
}


/*
 * A PONTE — content script em instagram.com.
 *
 * POR QUE ELA EXISTE (18/08/2026).
 *
 * As rotas REST de amizade morreram e a escrita passou para
 * `POST /api/graphql`. Só que o Instagram RECUSA essa mutação quando ela parte
 * da extensão: responde `error: 1357004` ("Feche e abra a janela do seu
 * navegador novamente"), que é o código do `fb_dtsg` inválido.
 *
 * Não é o token, e isso foi medido, não suposto. A MESMA chamada, com o MESMO
 * token e o MESMO conjunto de cabeçalhos, disparada de dentro de uma página do
 * instagram.com, responde 200 com o JSON certo. A única diferença que sobra é a
 * origem: `chrome-extension://…` de um lado, `https://www.instagram.com` do
 * outro. Ler o Instagram deixa passar; ESCREVER não.
 *
 * Daí a ponte: a requisição sai de uma página do instagram.com, na sessão da
 * própria pessoa. Repare no que isso NÃO é — não há Origin reescrito, nem
 * User-Agent trocado, nem nada fingindo ser o que não é. A requisição é mesmo
 * da página. É a mesma regra que já governava os cabeçalhos neste projeto:
 * parecer com o site legítimo por SER o site legítimo, nunca por disfarce.
 *
 * ELA É UM CANO BURRO, DE PROPÓSITO. Repassa a requisição e devolve o que
 * voltou, cru: status, texto e o claim. Nada de decidir se a resposta é recusa
 * da conta, caminho errado ou bloqueio — essa classificação vive em
 * `instagram.js` (`recusaDaConta`), é o que segura os freios da conta, e está
 * coberta por teste. Duplicá-la aqui criaria um segundo lugar para ela
 * divergir, que é exatamente como um freio deixa de frear sem ninguém notar.
 */

/**
 * Os tokens do cliente web, raspados de um HTML do Instagram.
 *
 * `bkv` é a versão do Bloks (`WebBloksVersioningID`), que o pedido do Close
 * Friends leva na URL desde 17/09/2026. Mora no mesmo bloco de configuração que
 * o `fb_dtsg`, e por isso sai daqui e não de uma constante que envelheceria.
 */
function tokensDoHtml(html) {
  const pegar = (re) => {
    const achado = html.match(re);
    return achado ? achado[1] : '';
  };
  return {
    dtsg: pegar(/"DTSGInitialData",\[\],\{"token":"([^"]+)"/),
    lsd: pegar(/"LSD",\[\],\{"token":"([^"]+)"/),
    rev: pegar(/"__spin_r":(\d+)/),
    bkv: pegar(/"WebBloksVersioningID",\[\],\{"versioningID":"([0-9a-f]+)"/),
  };
}

chrome.runtime.onMessage.addListener((msg, remetente, responder) => {
  if (!msg || typeof msg.tipo !== 'string' || !msg.tipo.startsWith('mutuo-')) {
    return undefined;
  }

  if (msg.tipo === 'mutuo-ping') {
    responder({ ok: true });
    return undefined;
  }

  if (msg.tipo === 'mutuo-tokens') {
    (async () => {
      let tk = tokensDoHtml(document.documentElement.innerHTML);

      /*
       * O HTML da SPA já montada pode ter perdido o bloco inicial. Nesse caso
       * vale buscar a home — daqui é mesma origem, então o custo é só a
       * requisição, e ela responde o HTML logado. Faltar só o `bkv` também
       * busca: sem ele o Close Friends não sai, e o custo é o mesmo.
       */
      if (!tk.dtsg || !tk.bkv) {
        try {
          const html = await (await fetch('/', { credentials: 'include' })).text();
          tk = tokensDoHtml(html);
        } catch (erro) {
          responder({ ok: false, erro: String((erro && erro.message) || erro) });
          return;
        }
      }

      responder({ ok: true, ...tk });
    })();
    return true;
  }

  if (msg.tipo === 'mutuo-fetch') {
    (async () => {
      try {
        const res = await fetch(msg.url, {
          method: msg.metodo || 'GET',
          credentials: 'include',
          headers: msg.cabecalhos || {},
          body: msg.corpo,
        });
        responder({
          ok: true,
          status: res.status,
          url: res.url,
          redirected: res.redirected,
          claim: res.headers.get('x-ig-set-www-claim'),
          texto: await res.text(),
        });
      } catch (erro) {
        responder({ ok: false, erro: String((erro && erro.message) || erro) });
      }
    })();
    return true;
  }

  return undefined;
});

/*
 * Anuncia-se ao carregar. A tela pode estar esperando por esta aba — foi ela
 * que mandou abrir — e esperar por um aviso é mais barato que ficar sondando.
 * Sem ninguém ouvindo, `sendMessage` rejeita; aqui isso é normal, não erro.
 */
chrome.runtime.sendMessage({ tipo: 'mutuo-ponte-pronta' }).catch(() => {});


/*
 * Coleta de seguidores e seguindo pelos endpoints internos do Instagram —
 * os mesmos que o site chama quando você rola a lista.
 *
 * As requisições partem do SEU navegador, com a SUA sessão (os cookies que já
 * estão no instagram.com). Nada passa por servidor nenhum. É por isso que este
 * modelo não corre o risco de "IP de datacenter" que uma versão hospedada
 * correria.
 *
 * O ritmo e as paradas abaixo são proteção, não detalhe — portados das decisões
 * do backend original. Ler estes endpoints ainda contraria os Termos de Uso do
 * Instagram, e o risco prático é a conta receber um pedido de verificação.
 * REDUZIR as pausas ou insistir contra uma verificação é o caminho para o
 * bloqueio. Se for mexer, aumente as pausas — nunca diminua.
 */

const APP_ID = '936619743392459';
const BASE = 'https://www.instagram.com';

/*
 * OS CABEÇALHOS QUE O SITE ENVIA E NÓS NÃO ENVIÁVAMOS (18/08/2026).
 *
 * Sintoma: escrever deixou de funcionar, e o diagnóstico apontava para a rota
 * errada. `/api/v1/web/friendships/{pk}/follow/` passou a responder 404, e a
 * conclusão natural — "a rota morreu" — estava errada. A prova veio de
 * `show_many/`: MESMA rota, 200 no site do Instagram e 404 aqui, na mesma
 * sessão e no mesmo navegador. Rota igual e resposta diferente só sobra uma
 * explicação: o que vai junto da requisição.
 *
 * Capturado do próprio site, na aba Network, ao clicar em Seguir:
 *
 *   x-asbd-id        359341
 *   x-ig-www-claim   hmac.AR0Y_…      (derivado da sessão, muda)
 *   x-instagram-ajax 1045433650       (o número do BUILD, não "1")
 *
 * Note o que NÃO é feito aqui: nada de trocar o User-Agent nem de fingir ser o
 * aplicativo de celular. Estes são os cabeçalhos do cliente WEB, mandados do
 * navegador da própria pessoa — ficar mais parecido com o site legítimo é o
 * oposto de disfarce, e é o que a regra do projeto pede.
 */
const ASBD_ID = '359341';

/*
 * O build do site. Envelhece a cada atualização do Instagram, e é o primeiro
 * suspeito quando escrever voltar a falhar com HTML. Para renovar: F12 no
 * instagram.com, aba Network, qualquer requisição, header `x-instagram-ajax`.
 */
const AJAX_BUILD = '1045433650';

/*
 * O claim vem do servidor e volta para ele na requisição seguinte. Começa em
 * '0', que é o que um cliente sem claim manda — e é aceito. Guardado só em
 * memória, de propósito: é derivado da sessão, e persistir um claim de uma
 * sessão encerrada mandaria credencial velha em toda chamada.
 */
let wwwClaim = '0';

/** Aprende o claim que o servidor mandou, se mandou. */
function guardarClaim(res) {
  /*
   * O `?.` não é frouxidão: o claim é OPCIONAL, e uma resposta sem ele — ou
   * sem `headers` legíveis — não pode derrubar a chamada que já deu certo.
   * Sem esta guarda, um `TypeError` aqui matava a coleta INTEIRA depois de o
   * Instagram já ter respondido os dados; foi o que quebrou cinco arquivos de
   * teste de uma vez, e em produção teria quebrado a sincronização.
   */
  const novo = res.headers?.get?.('x-ig-set-www-claim');
  if (novo) wwwClaim = novo;
}

/** Os cabeçalhos comuns a leitura e escrita. */
async function cabecalhos(csrf, extras = {}) {
  return {
    'x-ig-app-id': APP_ID,
    'x-csrftoken': await csrfAtual(csrf),
    'x-requested-with': 'XMLHttpRequest',
    'x-asbd-id': ASBD_ID,
    'x-ig-www-claim': wwwClaim,
    'x-instagram-ajax': AJAX_BUILD,
    ...extras,
  };
}
const PAGE_SIZE = 50;

// Faixa de pausa entre páginas, mais uma pausa longa periódica. Cadência
// constante é fácil de detectar; por isso o valor é sorteado a cada página.
//
// Estes valores foram REDUZIDOS a pedido, para a coleta ser mais rápida. O
// ritmo ainda existe, e ainda é proteção: são os endpoints internos, e uma
// enxurrada de requisições continua podendo render um pedido de verificação.
// A favor da redução: aqui a coleta sai do SEU navegador, com o SEU IP
// residencial — bem menos suspeito que um servidor. Se quiser mais velocidade,
// saiba que é por sua conta e risco; se começar a tomar verificação, aumente
// estes números de volta.
const PACE = {
  minDelayMs: 900,
  maxDelayMs: 2200,
  longPauseEvery: 15,
  longPauseMs: 8000,
};

function delay(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

async function pace(page) {
  const span = PACE.maxDelayMs - PACE.minDelayMs;
  await delay(PACE.minDelayMs + Math.random() * span);

  // A cada N páginas, uma pausa mais longa — imita quem para para ler.
  if (page % PACE.longPauseEvery === 0) {
    await delay(PACE.longPauseMs);
  }
}

async function cookie(name) {
  const found = await cookiesNativos.get({ url: BASE + '/', name });
  return found ? found.value : '';
}

/** Erros que a interface trata de formas diferentes. */
class ChallengeError extends Error {}
class NotLoggedInError extends Error {}
class RateLimitError extends Error {}
class ActionBlockedError extends Error {}
/*
 * O PERFIL de outra pessoa não abriu — e isso não é problema da SUA conta.
 * Nasceu com a busca por nicho, que lê listas de terceiros: ver o comentário
 * em `recusaDaConta`.
 */
class PerfilFechadoError extends Error {}

/*
 * O `csrftoken` do cookie, sempre relido na hora.
 *
 * Ele NÃO é fixo: o Instagram troca esse cookie de tempos em tempos, e uma
 * sincronização leva minutos e centenas de requisições. Guardar o valor do
 * começo e usar até o fim é o que fazia as ESCRITAS começarem a receber a
 * página em HTML no meio do caminho, enquanto as leituras seguiam normais —
 * GET o Instagram deixa passar, POST com token velho ele recusa. O parâmetro
 * fica como reserva para quando o cookie não puder ser lido.
 */
async function csrfAtual(guardado) {
  const doCookie = await cookie('csrftoken').catch(() => '');
  return doCookie || guardado || '';
}

async function apiGet(path, csrf) {
  const res = await fetch(BASE + path, {
    method: 'GET',
    headers: await cabecalhos(csrf, { accept: '*/*' }),
    // Inclui os cookies do instagram.com. Só é possível porque o manifest
    // declara host_permissions para instagram.com.
    credentials: 'include',
  });
  guardarClaim(res);
  return res;
}

/** O texto como objeto, ou `null` se não for JSON (a página em HTML, por ex.). */
/*
 * O PREFIXO ANTI-SEQUESTRO DE JSON, e por que ele precisa cair aqui.
 *
 * O `/api/graphql` da Meta responde com `for (;;);` grudado na frente do JSON
 * (e, em alguns caminhos, `)]}'`). É proteção antiga contra ler JSON por tag
 * <script>, e não é opcional nem negociável: vem do servidor.
 *
 * Sem tirar o prefixo, `JSON.parse` estoura, `comoJson` devolve `null`, e o
 * código conclui "não é JSON, logo o caminho está errado" — que foi exatamente
 * o que aconteceu em 18/08/2026: a mutação respondia HTTP 200 com 232 bytes, a
 * extensão caía para as rotas REST mortas, e a tela mostrava o erro DELAS. O
 * corpo de 232 bytes era a mensagem de erro real, ilegível por causa do prefixo.
 *
 * Vale para resposta BOA e para resposta de ERRO: as duas vêm prefixadas.
 */
function comoJson(texto) {
  const limpo = String(texto).replace(/^\s*(for\s*\(;;\);|\)\]\}'?,?)\s*/, '');
  try {
    return JSON.parse(limpo);
  } catch {
    return null;
  }
}

/*
 * A recusa é da CONTA ou do CAMINHO?
 *
 * É a pergunta mais importante do arquivo, e a resposta errada custa caro nas
 * duas direções:
 *
 *   - tratar recusa da CONTA como caminho errado faz o código TENTAR OUTRA
 *     ROTA. Insistir depois de um bloqueio é o comportamento que a plataforma
 *     pune, e era o que acontecia quando a verificação chegava como página em
 *     HTML (a mesma assinatura de "rota que não existe");
 *   - pior ainda, uma recusa em JSON que passe como resposta boa vira DADO:
 *     `{"message":"challenge_required"}` não tem `followed_by`, e
 *     `Boolean(undefined)` é `false` — a pessoa passaria a constar como "não te
 *     segue de volta", e alguém deixaria de seguir quem o segue.
 *
 * Por isso a classificação é uma só, aqui, usada por TODAS as camadas: leitura
 * de página, escrita, estado individual e lista de Close Friends. Devolve o erro
 * a lançar, ou `null` quando a resposta não é recusa da conta.
 */
function recusaDaConta(res, data, { deTerceiro = false } = {}) {
  const msg = String(data?.message || '').toLowerCase();
  const destino = res.redirected ? String(res.url || '') : '';

  if (res.status === 429 || msg.includes('wait a few minutes') || msg.includes('rate limit')) {
    return new RateLimitError(
      'O Instagram pediu para desacelerar' + (data?.message ? ` ("${data.message}")` : '') + '.'
    );
  }

  // feedback_required / spam = "action block": pare, não repita.
  if (data?.spam || msg.includes('feedback_required') || msg.includes('spam')) {
    return new ActionBlockedError(
      'O Instagram bloqueou temporariamente esta ação. É o "action block" — pare por hoje e tente novamente mais tarde.'
    );
  }

  // O redirecionamento é a pista que existia e era jogada fora: uma sessão em
  // checkpoint responde a QUALQUER rota mandando para a página de verificação.
  if (msg.includes('challenge') || msg.includes('checkpoint') || destino.includes('/challenge/')) {
    return new ChallengeError(
      'O Instagram pediu verificação. Confirme sua conta no app e tente mais tarde.'
    );
  }

  if (msg.includes('login_required') || msg.includes('not authorized')
    || destino.includes('/accounts/login')) {
    return new NotLoggedInError(
      'O Instagram não reconheceu a sessão. Abra o instagram.com, confirme que está logado e tente de novo.'
    );
  }

  if (res.status === 401 || res.status === 403) {
    /*
     * MESMO STATUS, DOIS SIGNIFICADOS — e é o perfil que está sendo lido que
     * separa os dois.
     *
     * Lendo a SUA conta, 403 é a sua sessão: expirou, ou o Instagram quer
     * verificação. Lendo a lista de OUTRA PESSOA (a busca por nicho faz isso
     * dezenas de vezes), 403 é quase sempre a coisa mais banal do mundo: a
     * conta é privada e você não a segue. Nada aconteceu com a sua sessão.
     *
     * Sem esta distinção, uma única conta privada no meio das sementes
     * derrubaria a busca inteira com "sua sessão pode ter expirado" — um susto
     * inventado, que ainda mandaria a pessoa refazer um login que está em dia.
     * As outras recusas (429, action block, challenge) NÃO se dividem assim:
     * essas são da sua conta, quem quer que se esteja lendo, e param tudo.
     */
    if (deTerceiro) {
      return new PerfilFechadoError('O perfil não abriu para a sua conta (HTTP '
        + res.status + ') — normalmente é uma conta privada que você não segue.');
    }
    return new ChallengeError(
      'O Instagram recusou o acesso. Sua sessão pode ter expirado, ou a conta '
      + 'precisa de verificação. Entre no Instagram pelo navegador e tente de novo.'
    );
  }

  return null;
}

/*
 * Procura, na resposta do perfil, quantas pessoas o Instagram diz que estão no
 * seu Close Friends.
 *
 * Por que procurar em vez de ler um campo fixo: a extensão só consegue CONTAR
 * quem ela conhece — e o Close Friends guarda também quem saiu das suas listas
 * (deixou de te seguir, desativou a conta). Esses não aparecem em lugar nenhum
 * que o navegador possa ler, então a contagem local fica menor que a do
 * aplicativo. Se o próprio Instagram mandar o número em algum campo, ele é a
 * verdade e não custa requisição nenhuma.
 *
 * A busca é por NOME de campo (`bestie`/`close_friend` + `count`) porque esse
 * nome já mudou antes e mudará de novo; fixar um só faria a leitura morrer em
 * silêncio na próxima renomeação.
 */
function contagemDeBesties(objeto, profundidade = 0) {
  if (!objeto || typeof objeto !== 'object' || profundidade > 2) return null;

  for (const [chave, valor] of Object.entries(objeto)) {
    if (Number.isFinite(valor)
      && /(bestie|close_?friend)/i.test(chave)
      && /count|total|num/i.test(chave)) {
      return valor;
    }
  }

  // Um nível abaixo: o Instagram costuma aninhar contagens em subobjetos.
  for (const valor of Object.values(objeto)) {
    const achado = contagemDeBesties(valor, profundidade + 1);
    if (achado !== null) return achado;
  }

  return null;
}

/**
 * Quem está logado neste navegador. Devolve null se não houver sessão —
 * a interface então pede para a pessoa entrar no Instagram primeiro.
 */
async function currentUser() {
  const id = await cookie('ds_user_id');
  if (!id) {
    return null;
  }

  const csrf = await cookie('csrftoken');
  let username = '';
  let profilePic = '';
  /*
   * Os totais da conta, do jeito que o Instagram os conta.
   *
   * Vêm de graça nesta mesma resposta, e são o que permite dizer "337 perfis
   * restantes" no plano FREE sem coletar os 337 — que é justamente o que o
   * limite existe para evitar. `null` quando a resposta não os trouxer: é
   * "não sei", e não pode virar zero.
   */
  let totais = { seguidores: null, seguindo: null, closeFriends: null };

  try {
    const res = await apiGet(`/api/v1/users/${id}/info/`, csrf);
    const data = await res.json();
    username = data?.user?.username || '';
    profilePic = data?.user?.profile_pic_url || '';

    const numero = (v) => (Number.isFinite(v) ? v : null);
    totais = {
      seguidores: numero(data?.user?.follower_count),
      seguindo: numero(data?.user?.following_count),
      closeFriends: contagemDeBesties(data?.user),
    };
  } catch {
    // O username e a foto são só enfeite; a coleta funciona sem eles.
  }

  /*
   * Se o perfil do aplicativo não trouxer a contagem, a versão WEB do mesmo
   * perfil é a segunda (e última) chance de tê-la de graça: são respostas
   * diferentes, montadas por lados diferentes do Instagram. Uma requisição, e
   * só quando a primeira não respondeu.
   */
  if (totais.closeFriends === null && username) {
    try {
      const res = await apiGet(
        `/api/v1/users/web_profile_info/?username=${encodeURIComponent(username)}`, csrf
      );
      const doWeb = comoJson(await res.text())?.data?.user;
      totais.closeFriends = contagemDeBesties(doWeb);

      // Quando nem aqui há contagem, deixa registrado O QUE existe — é o que
      // permite reconhecer o campo no dia em que ele voltar com outro nome.
      if (totais.closeFriends === null && doWeb) {
        const candidatos = Object.keys(doWeb).filter((k) => /bestie|close/i.test(k));
        console.info('[Mútuo] contagem de Close Friends: o perfil não manda. '
          + `Campos parecidos: ${candidatos.join(', ') || 'nenhum'}.`);
      }
    } catch {
      // Continua sem a contagem: a tela cai para o que ela mesma consegue contar.
    }
  }

  return { id, csrf, username, profilePic, totais };
}

/*
 * Quando a coleta recebe a página em vez de JSON, uma pergunta decide o que
 * fazer, e ela não pode depender de ninguém abrir o console: a SESSÃO deixou de
 * valer, ou a ROTA deixou de existir?
 *
 * Uma requisição a outra rota REST responde isso. Se ela devolver JSON com os
 * dados da conta, a sessão está boa e o problema é só daquele endereço; se ela
 * também devolver a página, o que caiu foi o acesso da extensão como um todo.
 * Custa uma requisição, e só acontece depois que algo já falhou.
 */
async function diagnosticar(userId, csrf) {
  try {
    const res = await apiGet(`/api/v1/users/${userId}/info/`, csrf);
    const data = comoJson(await res.text());

    if (data && data.user) {
      return 'A sua sessão continua valendo (os dados da conta foram lidos agora), '
        + 'então foi este endereço que o Instagram desativou para o navegador.';
    }
    return 'Outra rota da API respondeu do mesmo jeito, então o Instagram parou de '
      + 'aceitar as chamadas desta extensão — não é um endereço só.';
  } catch {
    return 'Não foi possível confirmar se o problema é a sessão ou o endereço.';
  }
}

/*
 * Formatos conhecidos de pedir uma página da lista, na ordem em que se tenta.
 *
 * O `search_surface` é o que o site manda quando você abre "seguidores" — sem
 * ele, o pedido tem cara de chamada avulsa, e o Instagram já respondeu com um
 * redirecionamento para a home em vez de recusar direito. Não custa nada
 * mandar, e a variante sem parâmetro nenhum existe porque um dia o `count` foi
 * justamente o motivo da recusa numa rota irmã.
 */
const FORMATOS_LISTA = [
  { nome: 'count + search_surface', query: `count=${PAGE_SIZE}&search_surface=follow_list_page` },
  { nome: 'count', query: `count=${PAGE_SIZE}` },
  { nome: 'sem parâmetro', query: '' },
];

// O que funcionou nesta sessão. Sem isso, cada página pagaria de novo o preço
// de descobrir o formato certo.
let formatoLista = null;

function montarPathLista(kind, userId, formato, maxId) {
  const partes = [];
  if (formato.query) partes.push(formato.query);
  if (maxId) partes.push(`max_id=${encodeURIComponent(maxId)}`);
  return `/api/v1/friendships/${userId}/${kind}/`
    + (partes.length ? '?' + partes.join('&') : '');
}

async function fetchPage(kind, userId, csrf, maxId) {
  /*
   * O formato memorizado vem primeiro, mas os outros continuam de reserva NA
   * MESMA chamada. Antes, memorizar significava descartar as alternativas: se o
   * Instagram deixasse de aceitar aquele formato no meio da sincronização,
   * todas as páginas seguintes falhavam sem tentar os outros — e, como
   * `formatoLista` nunca voltava a `null`, toda sincronização daquela sessão
   * falhava igual, ainda gastando uma requisição de diagnóstico por tentativa.
   */
  const candidatos = formatoLista
    ? [formatoLista, ...FORMATOS_LISTA.filter((f) => f !== formatoLista)]
    : FORMATOS_LISTA;

  let ultimo = null;
  for (const formato of candidatos) {
    try {
      const data = await fetchPageComFormato(kind, userId, csrf, maxId, formato);
      formatoLista = formato;
      return data;
    } catch (error) {
      // Só troca de formato quando o Instagram não entendeu o pedido. Recusa de
      // verdade — verificação, desacelerar, bloqueio — interrompe na hora.
      if (!(error instanceof EndpointError)) {
        throw error;
      }
      formatoLista = null; // o memorizado deixou de valer
      ultimo = error;
      await pace(1);
    }
  }

  // Nenhum formato foi entendido: só agora vale gastar uma requisição para
  // saber se o que caiu foi a sessão ou o endereço.
  throw new EndpointError(ultimo.message + ' ' + await diagnosticar(userId, csrf));
}

async function fetchPageComFormato(kind, userId, csrf, maxId, formato) {
  const path = montarPathLista(kind, userId, formato, maxId);

  const res = await apiGet(path, csrf);

  const texto = await res.text();
  const data = comoJson(texto);

  // Recusa da conta antes de qualquer coisa — inclusive antes de concluir que
  // "não é JSON, logo é o formato errado".
  const recusa = recusaDaConta(res, data);
  if (recusa) throw recusa;

  if (!data) {
    const html = texto.trimStart().startsWith('<');
    const desvio = res.redirected ? `; redirecionou para ${res.url}` : '';
    throw new EndpointError(
      `a página de ${kind === 'followers' ? 'seguidores' : 'seguindo'} (${formato.nome}) `
      + `respondeu HTTP ${res.status} com ${html ? 'HTML' : texto.length + ' bytes'} `
      + `em vez de JSON${desvio}.`
    );
  }

  if (data.status !== 'ok') {
    throw new Error(data.message || 'O Instagram recusou a coleta.');
  }

  return data;
}

// --- Ações que ESCREVEM na conta (seguir / deixar de seguir) --------------
//
// Diferente de tudo acima, isto altera sua conta no Instagram. Ação em ritmo
// de robô é o que a plataforma pune com mais rigor (o "action block"). Por isso
// os freios que cercam estas funções (uma por vez, teto diário, intervalo
// mínimo, parar diante de bloqueio) vivem em app.js e NÃO podem ser afrouxados
// "para ir mais rápido" — é a decisão registrada no projeto original.

/*
 * Uma rota que responde HTML (a página do site) em vez de JSON não é um erro
 * da ação: é o caminho errado. O Instagram devolve a SPA com HTTP 200 nesse
 * caso, então "200 sem JSON" precisa ser um erro DIFERENTE — é o que deixa
 * definirBesties() tentar a variante seguinte em vez de desistir.
 */
class EndpointError extends Error {}

async function apiPost(path, csrf, body = '', tipoConteudo = 'application/x-www-form-urlencoded') {
  const res = await fetch(BASE + path, {
    method: 'POST',
    headers: await cabecalhos(csrf, { 'content-type': tipoConteudo, accept: '*/*' }),
    credentials: 'include',
    body,
  });

  guardarClaim(res);

  // Lê como texto e só então tenta JSON: assim dá para dizer O QUE voltou.
  const texto = await res.text();
  const data = comoJson(texto);

  /*
   * ANTES de decidir que "não é JSON, logo é a rota errada".
   *
   * Uma sessão em verificação responde à ESCRITA com a página do site em HTML,
   * ou redirecionando para /challenge/ — a mesma assinatura de rota inexistente.
   * Sem esta checagem, `acaoDeAmizade` lia isso como "tente o próximo caminho" e
   * disparava mais duas ESCRITAS numa conta que acabara de recusar a primeira.
   */
  const recusa = recusaDaConta(res, data);
  if (recusa) throw recusa;

  if (!data) {
    const html = texto.trimStart().startsWith('<');
    const desvio = res.redirected ? ' e redirecionou para ' + res.url : '';
    throw new EndpointError(
      path + ' respondeu HTTP ' + res.status + ' com '
      + (html ? 'HTML' : texto.length + ' bytes') + ' em vez de JSON' + desvio + '.'
    );
  }

  if (data.status !== 'ok') {
    // Sem o status HTTP e os campos, "a ação foi recusada" não diz nada a quem
    // for investigar depois — e uma recusa de escrita é justamente o que mais
    // precisa ser diagnosticável.
    const detalhe = data.message
      ? String(data.message)
      : `HTTP ${res.status}, campos: ${Object.keys(data).join(', ') || 'nenhum'}`;
    throw new Error(detalhe);
  }

  return data;
}

/*
 * Onde pedir para seguir / deixar de seguir, na ordem em que se tenta.
 *
 * A rota `/api/v1/friendships/create|destroy/{pk}/` é a do APLICATIVO DE
 * CELULAR. Pelo navegador ela não responde: devolve a página do site em HTML
 * com HTTP 200 — e, por ser 200, isso NÃO aparece em vermelho no console. O
 * clique parecia não fazer nada porque o erro só existia no aviso do topo da
 * página, fora da tela de quem estava rolado na lista.
 *
 * É o mesmo padrão das leituras que já falhavam por serem rotas de aplicativo:
 * `friendships/show_many/` responde 404 e `friendships/besties/` responde 400
 * "useragent mismatch". O que o site instagram.com usa, e o que funciona com a
 * sessão do navegador, é `/api/v1/web/friendships/{pk}/follow|unfollow/`.
 *
 * As de aplicativo ficam por último em vez de sumir: custam nada enquanto a
 * primeira funciona (a que respondeu é memorizada) e cobrem o dia em que o
 * Instagram mexer na rota web. A ordem é que não pode inverter.
 */
const ROTAS_SEGUIR = [
  { nome: 'web', path: (pk) => `/api/v1/web/friendships/${pk}/follow/` },
  { nome: 'web antiga', path: (pk) => `/web/friendships/${pk}/follow/` },
  { nome: 'aplicativo', path: (pk) => `/api/v1/friendships/create/${pk}/` },
];

const ROTAS_DEIXAR = [
  { nome: 'web', path: (pk) => `/api/v1/web/friendships/${pk}/unfollow/` },
  { nome: 'web antiga', path: (pk) => `/web/friendships/${pk}/unfollow/` },
  { nome: 'aplicativo', path: (pk) => `/api/v1/friendships/destroy/${pk}/` },
];

// A rota que respondeu nesta sessão, por tipo de ação. Sem isto, toda ação
// pagaria de novo o preço de descobrir o caminho certo — e cada tentativa a
// mais é uma requisição de ESCRITA a mais, que é o que os freios existem para
// conter.
const rotaBoa = { seguir: null, deixar: null };

/*
 * Dispara a ação na primeira rota que responder JSON.
 *
 * Só troca de rota diante de `EndpointError` — "veio a página em vez de JSON",
 * ou seja, o caminho está errado. Recusa de verdade (bloqueio, verificação,
 * pedido de desacelerar) interrompe na hora: insistir por outro caminho depois
 * de um "action block" é exatamente o comportamento que faz a conta ser punida.
 */
async function acaoDeAmizade(tipo, rotas, pk, csrf) {
  // A memorizada primeiro, mas as outras continuam de reserva NA MESMA
  // chamada: quando a rota memorizada cai, quem clicou perderia a ação (e uma
  // vaga na janela de 5 por 2 minutos) só para descobrir isso na tentativa
  // seguinte. Tentar de novo aqui é seguro porque "veio a página em HTML"
  // significa que nada foi escrito.
  const candidatos = rotaBoa[tipo]
    ? [rotaBoa[tipo], ...rotas.filter((r) => r !== rotaBoa[tipo])]
    : rotas;
  const falhas = [];

  for (const rota of candidatos) {
    try {
      const data = await apiPost(rota.path(pk), csrf);
      rotaBoa[tipo] = rota;
      return data;
    } catch (error) {
      if (!(error instanceof EndpointError)) {
        throw error;
      }
      // A rota memorizada deixou de valer: volta a procurar na próxima vez.
      rotaBoa[tipo] = null;
      falhas.push(`${rota.nome}: ${error.message}`);
      console.warn('[Mútuo] ação por', rota.nome, '—', error.message);
    }
  }

  /*
   * TODAS as tentativas na mensagem, não só a última.
   *
   * Guardar só a última mandava quem fosse investigar para o lugar errado: a
   * última é sempre a rota de APLICATIVO, que é a reserva e que sabidamente
   * responde HTML pelo navegador. Lendo aquilo, a conclusão óbvia — e errada —
   * é que o defeito está nela. O defeito está em a rota WEB, que vem primeiro,
   * ter falhado antes; e essa parte não aparecia.
   */
  throw new EndpointError(
    'nenhum caminho respondeu — ' + falhas.join(' | ')
  );
}

/*
 * O que a resposta diz sobre a relação depois da ação.
 *
 * As duas famílias de rota respondem de formas diferentes, e as duas contam a
 * mesma coisa:
 *   - web:        { status: 'ok', result: 'following' | 'requested' | 'unfollowed' }
 *   - aplicativo: { status: 'ok', friendship_status: { following, outgoing_request } }
 */
function relacaoDepois(data) {
  const fs = data.friendship_status || {};
  const result = String(data.result || '');

  return {
    following: result ? result === 'following' : Boolean(fs.following),
    pending: result ? result === 'requested' : Boolean(fs.outgoing_request),
  };
}

// --- Escrita pelo GraphQL do site (18/08/2026) ----------------------------
/*
 * POR QUE ESTE CAMINHO EXISTE, E POR QUE ELE VEM PRIMEIRO.
 *
 * As rotas REST de amizade morreram. `/api/v1/web/friendships/{pk}/follow/`
 * responde 404 e `/api/v1/friendships/create/{pk}/` devolve a página do site
 * com HTTP 200. E não é cabeçalho faltando, como se supôs de manhã: a MESMA
 * chamada, disparada de dentro de instagram.com com a sessão logada e todos os
 * cabeçalhos do site, responde exatamente igual. `friendships/show_many/`
 * também. A rota acabou — não há o que consertar nela.
 *
 * O que o site usa hoje, capturado da aba Network ao clicar em Seguir:
 *
 *   POST /api/graphql
 *   fb_api_req_friendly_name   usePolarisFollowUserFollowMutation
 *   doc_id                     27767812149509802
 *   variables                  {"target_user_id":"<pk>"}
 *
 * e a resposta vem como
 *
 *   { data: { xdt_create_friendship: { friendship_status: { following } } } }
 *
 * O `doc_id` é o identificador da consulta PUBLICADA, e muda quando o Instagram
 * republica o cliente web. É o primeiro suspeito quando escrever voltar a
 * falhar: F12 no instagram.com, aba Network, clique em Seguir, campo `doc_id`.
 *
 * As rotas REST continuam abaixo como reserva em vez de sumir — custam nada
 * enquanto esta funciona, e cobrem o dia em que o GraphQL mudar antes de nós.
 */
const MUTACOES = {
  seguir: {
    nome: 'usePolarisFollowUserFollowMutation',
    docId: '27767812149509802',
    campo: 'xdt_create_friendship',
  },
  deixar: {
    nome: 'usePolarisFollowUserUnfollowMutation',
    docId: '25174972798866458',
    campo: 'xdt_destroy_friendship',
  },
};

// --- A ponte com uma aba do Instagram -------------------------------------
/*
 * POR QUE A ESCRITA NÃO SAI DAQUI (18/08/2026).
 *
 * O Instagram recusa a mutação de amizade quando ela parte da extensão:
 * responde `error: 1357004`, o código do `fb_dtsg` inválido. E não é o token —
 * isso foi MEDIDO: a mesma chamada, com o mesmo token e os mesmos cabeçalhos,
 * disparada de dentro de uma página do instagram.com, responde 200 com o JSON
 * certo. A única diferença que sobra é a origem da requisição. Ler ele deixa
 * passar da extensão; escrever, não.
 *
 * Por isso a ESCRITA passa por `ponte.js`, um content script em
 * instagram.com. Nada é disfarçado: a requisição é mesmo da página, na sessão
 * da própria pessoa. A alternativa seria reescrever o cabeçalho `Origin` com
 * `declarativeNetRequest` — que é disfarce, pede permissão nova, e contraria a
 * regra deste projeto que já tinha recusado trocar o User-Agent pelo mesmo
 * motivo.
 *
 * A LEITURA CONTINUA SAINDO DAQUI, e isso não é descuido. A regra antiga
 * ("a extensão nunca abre página do Instagram") nasceu de uma versão que abria
 * abas para contornar recusas de LEITURA — e ali era desnecessário, a causa
 * real era um `csrftoken` velho. Aqui não há alternativa, e ela foi procurada.
 * Se um dia a leitura falhar de novo, a resposta continua sendo consertar a
 * leitura, não mandá-la pela ponte.
 */

let abaPonte = null;

/*
 * SÓ FECHAMOS O QUE NÓS ABRIMOS.
 *
 * Se a pessoa já tinha o Instagram aberto, aquela aba é dela — fechá-la seria
 * a ferramenta mexendo em algo que não é seu. `abaNossa` é o que separa os dois
 * casos, e é por isso que ele existe em vez de simplesmente fechar sempre.
 */
let abaNossa = false;
let temporizadorFechar = null;

/*
 * A aba fecha por OCIOSIDADE, não ao fim de "uma ação".
 *
 * Um clique solto é uma requisição; "deixar de seguir em massa" são centenas,
 * espaçadas por até 50s, durante mais de uma hora. Fechar ao fim de cada ação
 * faria a aba abrir e fechar centenas de vezes — pior que deixá-la aberta, e
 * mais lento, porque cada abertura custa o carregamento do Instagram inteiro.
 * Um relógio que se renova a cada uso cobre os dois casos com uma regra só.
 */
const OCIOSO_MS = 15000;

function agendarFechamento() {
  if (!abaNossa || abaPonte === null) return;
  if (temporizadorFechar) clearTimeout(temporizadorFechar);
  temporizadorFechar = setTimeout(() => {
    fecharAPonte();
  }, OCIOSO_MS);
}

function fecharAPonte() {
  const id = abaPonte;
  const nossa = abaNossa;
  abaPonte = null;
  abaNossa = false;
  if (temporizadorFechar) {
    clearTimeout(temporizadorFechar);
    temporizadorFechar = null;
  }
  if (nossa && id !== null) {
    Promise.resolve(chrome.tabs.remove(id)).catch(() => {});
  }
}

/*
 * Fechar a tela do Mútuo também fecha a aba que ela abriu. Sem isto, sair no
 * meio de uma operação deixaria a aba órfã na barra — e ela é justamente o que
 * a pessoa não queria ver.
 */
if (typeof window !== 'undefined' && typeof window.addEventListener === 'function') {
  window.addEventListener('pagehide', () => fecharAPonte());
}

async function pontePronta(idAba) {
  try {
    const resposta = await chrome.tabs.sendMessage(idAba, { tipo: 'mutuo-ping' });
    return Boolean(resposta && resposta.ok);
  } catch {
    // Aba fechada, ou aberta ANTES desta versão da extensão: nesses casos o
    // content script não está lá, e sondar é como se descobre — sem erro.
    return false;
  }
}

async function abaDoInstagram() {
  if (abaPonte !== null && await pontePronta(abaPonte)) return abaPonte;

  // Uma aba que a pessoa já tenha aberto serve, e é a mais barata.
  const abertas = await chrome.tabs.query({ url: 'https://www.instagram.com/*' });
  for (const aba of abertas) {
    if (await pontePronta(aba.id)) {
      abaPonte = aba.id;
      abaNossa = false; // é dela, não nossa
      return abaPonte;
    }
  }

  /*
   * Nenhuma serve: abre uma, EM SEGUNDO PLANO (`active: false`). Roubar o foco
   * no meio de uma operação de centenas de contas seria pior que o problema.
   */
  const nova = await chrome.tabs.create({ url: BASE + '/', active: false });
  for (let tentativa = 0; tentativa < 40; tentativa += 1) {
    await delay(500);
    if (await pontePronta(nova.id)) {
      abaPonte = nova.id;
      abaNossa = true;
      return abaPonte;
    }
  }

  // Não ficou pronta: a aba que abrimos não serve para nada e sai da barra.
  Promise.resolve(chrome.tabs.remove(nova.id)).catch(() => {});

  throw new EndpointError(
    'a aba do Instagram não ficou pronta em 20s — confira se você está logado em instagram.com.'
  );
}

async function falarComAPonte(mensagem) {
  const aba = await abaDoInstagram();
  let resposta;
  try {
    resposta = await chrome.tabs.sendMessage(aba, mensagem);
  } catch (erro) {
    /*
     * A aba morreu no meio — ou continua viva e só não respondeu. Nos dois
     * casos `fecharAPonte` resolve: se era NOSSA, tenta removê-la (se já foi,
     * o remove falha calado); se era da pessoa, não encosta. Zerar só o
     * `abaPonte`, como era antes, perdia o id de uma aba possivelmente viva —
     * e ela ficaria órfã na barra, que é exatamente o que não pode acontecer.
     */
    fecharAPonte();
    throw new EndpointError('a aba do Instagram não respondeu — ' + ((erro && erro.message) || erro));
  }
  agendarFechamento();

  if (!resposta || !resposta.ok) {
    throw new EndpointError('a ponte falhou — ' + ((resposta && resposta.erro) || 'sem resposta'));
  }
  return resposta;
}

/*
 * A resposta da ponte com a MESMA CARA da do `fetch`, para que `comoJson`,
 * `recusaDaConta` e `guardarClaim` continuem valendo sem uma linha de mudança.
 * O caminho da ponte é novo; a classificação da resposta é a testada.
 */
function comoResposta(bruta) {
  return {
    status: bruta.status,
    url: bruta.url,
    redirected: bruta.redirected,
    headers: {
      get: (nome) => (String(nome).toLowerCase() === 'x-ig-set-www-claim' ? (bruta.claim || null) : null),
    },
    text: async () => bruta.texto,
  };
}

/*
 * `fb_dtsg` e `lsd` NÃO são cookies: vêm embutidos no HTML do site, e sem eles
 * o GraphQL recusa a escrita. Ficam só em memória, pelo mesmo motivo do
 * `wwwClaim` — são derivados da sessão, e persistir mandaria credencial velha
 * na sessão seguinte.
 *
 * O `__rev` (o build do site) sai do mesmo HTML. É o que AJAX_BUILD era como
 * constante e envelhecia sozinho; aqui ele chega fresco a cada leitura.
 */
let tokensWeb = null;

async function obterTokens(renovar = false) {
  if (tokensWeb && !renovar) return tokensWeb;

  /*
   * Os tokens vêm da PONTE, e não de um `fetch` daqui, por dois motivos. O
   * primeiro é que ela já os tem: `fb_dtsg` e `lsd` estão no HTML da página em
   * que ela vive, então o custo é zero requisição. O segundo é coerência — o
   * token que vai ser usado numa requisição da página é o token daquela página.
   */
  const resposta = await falarComAPonte({ tipo: 'mutuo-tokens' });

  if (!resposta.dtsg) {
    throw new NotLoggedInError(
      'Não foi possível ler os tokens do Instagram. Abra o instagram.com numa aba e confira se você está logado.'
    );
  }

  tokensWeb = {
    dtsg: resposta.dtsg,
    lsd: resposta.lsd || '',
    rev: resposta.rev || AJAX_BUILD,
    // A versão do Bloks, que o Close Friends exige desde 17/09/2026. Vazia
    // quando a ponte é de antes dela; quem precisa confere e diz o que faltou.
    bkv: resposta.bkv || '',
    logado: true,
  };
  return tokensWeb;
}

/*
 * O `jazoest` é uma soma de verificação do PRÓPRIO fb_dtsg — o site calcula, não
 * busca. Copiar um valor fixo daqui seria o mesmo erro do AJAX_BUILD: casa hoje
 * e desencontra na primeira troca de token.
 */
function jazoest(dtsg) {
  let soma = 0;
  for (const letra of dtsg) soma += letra.charCodeAt(0);
  return '2' + soma;
}

async function mutacaoAmizade(tipo, pk, csrf, jaRenovou = false) {
  const { nome, docId, campo } = MUTACOES[tipo];
  const tk = await obterTokens();

  const corpo = new URLSearchParams({
    av: await cookie('ds_user_id'),
    __d: 'www',
    __user: '0',
    __a: '1',
    __req: 'a',
    dpr: '1',
    __ccg: 'EXCELLENT',
    __rev: tk.rev,
    __comet_req: '7',
    fb_dtsg: tk.dtsg,
    jazoest: jazoest(tk.dtsg),
    lsd: tk.lsd,
    __spin_r: tk.rev,
    __spin_b: 'trunk',
    __spin_t: String(Math.floor(Date.now() / 1000)),
    fb_api_caller_class: 'RelayModern',
    fb_api_req_friendly_name: nome,
    server_timestamps: 'true',
    variables: JSON.stringify({ target_user_id: String(pk) }),
    doc_id: docId,
  });

  const res = comoResposta(await falarComAPonte({
    tipo: 'mutuo-fetch',
    url: BASE + '/api/graphql',
    metodo: 'POST',
    cabecalhos: await cabecalhos(csrf, {
      'content-type': 'application/x-www-form-urlencoded',
      accept: '*/*',
      'x-fb-friendly-name': nome,
      'x-fb-lsd': tk.lsd,
      'x-instagram-ajax': tk.rev,
    }),
    corpo: corpo.toString(),
  }));

  guardarClaim(res);

  const texto = await res.text();
  const data = comoJson(texto);

  // Recusa da conta antes de qualquer conclusão sobre o caminho — mesma ordem
  // do apiPost, e pelo mesmo motivo: insistir depois de um bloqueio é o que faz
  // a conta ser punida.
  const recusa = recusaDaConta(res, data);
  if (recusa) throw recusa;

  if (!data) {
    const html = texto.trimStart().startsWith('<');
    /*
     * O TRECHO DO CORPO ENTRA NA MENSAGEM quando não é HTML. "respondeu 232
     * bytes" mandou uma rodada inteira de investigação para o lugar errado —
     * os 232 bytes ERAM a resposta, dizendo o motivo, e ninguém os leu.
     */
    const trecho = html ? '' : ' — começa com: ' + texto.trim().slice(0, 160);
    throw new EndpointError(
      '/api/graphql (' + nome + ') respondeu HTTP ' + res.status + ' com '
      + (html ? 'HTML' : texto.length + ' bytes') + ' em vez de JSON.' + trecho
    );
  }

  const status = data.data && data.data[campo] && data.data[campo].friendship_status;

  /*
   * Token vencido responde JSON de erro, não HTML — e a correção é buscar o
   * HTML de novo, não trocar de caminho. Uma renovação só: numa sessão que caiu
   * de vez, tentar sem limite viraria laço de ESCRITA, que é justamente o que
   * os freios existem para impedir.
   */
  if (!status) {
    const diagnostico = JSON.stringify(data.errors || data.error || data).slice(0, 300);

    /*
     * 1357004 É O CÓDIGO DO fb_dtsg RECUSADO — "Feche e abra a janela do seu
     * navegador novamente", na tradução da Meta. Ele não casa com /dtsg|token/,
     * porque o corpo traz só o número; sem tratá-lo pelo número, a renovação
     * nunca acontecia e a escrita caía direto para as rotas REST mortas.
     */
    const tokenRecusado = data.error === 1357004
      || /dtsg|token|login|sessão|session/i.test(diagnostico);

    if (!jaRenovou && tokenRecusado) {
      await obterTokens(true);
      return mutacaoAmizade(tipo, pk, csrf, true);
    }

    /*
     * Renovou e continuou recusando: aí o token não é o problema. As duas
     * informações que separam as hipóteses restantes vão na mensagem —
     * "html logado" diz se o HTML lido era o da sessão (se NÃO, o token é
     * anônimo e a correção é a leitura do HTML); se era SIM e ainda assim
     * recusou, o que sobra é a origem da requisição, e aí a correção é outra.
     */
    throw new EndpointError(
      '/api/graphql (' + nome + ') respondeu JSON sem friendship_status: ' + diagnostico
      + ' [html logado: ' + (tk.logado ? 'sim' : 'NAO')
      + '; renovado: ' + (jaRenovou ? 'sim' : 'nao') + ']'
    );
  }

  // A forma que `relacaoDepois` já entende — a mesma das rotas de aplicativo.
  return { friendship_status: status };
}

/*
 * GraphQL primeiro, REST como reserva.
 *
 * Só cai para a reserva diante de `EndpointError` ("o caminho está errado").
 * Bloqueio, verificação ou pedido de desacelerar interrompem na hora, sem
 * gastar uma segunda ESCRITA numa conta que acabou de recusar a primeira.
 */
async function escrever(tipo, rotas, pk, csrf) {
  try {
    return await mutacaoAmizade(tipo, pk, csrf);
  } catch (error) {
    if (!(error instanceof EndpointError)) throw error;
    console.warn('[Mútuo] GraphQL não respondeu —', error.message, '— tentando as rotas REST antigas.');

    /*
     * A FALHA DO GRAPHQL ENTRA NA MENSAGEM FINAL. Pela terceira vez neste
     * arquivo, um erro escondeu a própria causa: mandar só para o console
     * deixava a tela mostrar as três rotas REST, que são a reserva e que
     * sabidamente respondem 404 e HTML. Quem lê conclui que o defeito está
     * nelas — e o defeito está no caminho primário, que nem aparecia.
     *
     * A ausência da parte "GraphQL:" nesta mensagem também vira informação:
     * significa que este código não está rodando.
     */
    try {
      return await acaoDeAmizade(tipo, rotas, pk, csrf);
    } catch (erroRest) {
      if (!(erroRest instanceof EndpointError)) throw erroRest;
      throw new EndpointError('GraphQL: ' + error.message + '  ||  REST: ' + erroRest.message);
    }
  }
}

/**
 * Seguir uma conta. Se a conta for privada, o Instagram registra um PEDIDO em
 * vez de seguir na hora — nesse caso volta { pending: true, following: false }.
 */
async function seguir(pk, csrf) {
  return relacaoDepois(await escrever('seguir', ROTAS_SEGUIR, pk, csrf));
}

/** Deixar de seguir uma conta. */
async function deixarDeSeguir(pk, csrf) {
  const { following } = relacaoDepois(await escrever('deixar', ROTAS_DEIXAR, pk, csrf));
  return { following };
}

// --- Close Friends (Melhores amigos) --------------------------------------
//
// Também ESCREVE na conta. Até 17/09/2026 o endpoint aceitava um LOTE de 50
// pessoas por requisição; o caminho que o site usa hoje (o Bloks, mais abaixo)
// leva UMA pessoa por pedido, e o ritmo da ação em massa passou a ser o de
// `RITMO_CLOSE`, em ritmo.js.

const BESTIES_PAGE = 200;

/*
 * ATENÇÃO: esta leitura é o CAMINHO DE RESERVA, não o principal.
 *
 * `GET /api/v1/friendships/besties/` é servido pelo lado do APLICATIVO DE
 * CELULAR. Com a sessão do navegador ele responde HTTP 400 "useragent mismatch"
 * — o Instagram compara o User-Agent com o app declarado e recusa. Não adianta
 * mexer no `count`: o parâmetro nunca foi o problema.
 *
 * Fazer a extensão passar por aplicativo de celular resolveria no papel e é
 * exatamente o que NÃO se faz aqui: trocar o User-Agent de uma sessão logada é
 * um dos sinais mais fortes de conta invadida, e o preço é verificação ou
 * bloqueio. O caminho principal passou a ser o `is_bestie` que vem junto da
 * coleta de seguidores (veja `collect`), que não custa requisição nenhuma.
 *
 * Isto aqui fica de pé para o caso de a coleta não trazer o campo, e porque
 * repetir uma LEITURA não altera nada na conta. Ainda assim ela não roda contra
 * pedido de desaceleração nem contra verificação — esses interrompem na hora.
 */
/*
 * Onde pedir a lista, e com que parâmetros.
 *
 * O caminho `/api/v1/web/` vem primeiro pelo mesmo motivo que resolveu o
 * "deixar de seguir": é a família que o site instagram.com usa e que responde à
 * sessão do navegador, enquanto a de aplicativo recusa com "useragent
 * mismatch". Se ele responder, esta lista é a ÚNICA fonte completa do Close
 * Friends — o `is_bestie` que vem junto da coleta só enxerga quem ainda está
 * nas suas listas, e quem entrou no Close Friends e depois deixou de te seguir
 * (ou desativou a conta) continua lá para o Instagram e some daqui.
 */
const CAMINHOS_BESTIES = [
  { nome: 'web', base: '/api/v1/web/friendships/besties/' },
  { nome: 'aplicativo', base: '/api/v1/friendships/besties/' },
];

const QUERIES_BESTIES = [
  { nome: `count=${BESTIES_PAGE}`, query: `count=${BESTIES_PAGE}` },
  { nome: 'sem count', query: '' },
  { nome: 'count=50', query: 'count=50' },
];

const VARIANTES_LEITURA_BESTIES = CAMINHOS_BESTIES.flatMap((caminho) =>
  QUERIES_BESTIES.map((q) => ({
    nome: `${caminho.nome}, ${q.nome}`,
    caminho: caminho.nome,
    base: caminho.base,
    query: q.query,
  })));

let varianteLeituraBesties = null;

/*
 * Quando TODAS as variantes recusam o pedido, o motivo não é passageiro: é o
 * endpoint do aplicativo de celular recusando a sessão do navegador, e a sessão
 * não vira app entre uma sincronização e outra. Guarda o motivo e devolve ele
 * na hora nas próximas vezes — insistir seria gastar requisição da conta para
 * receber a mesma recusa.
 */
let leituraBestiesRecusada = '';

function montarPathBesties(variante, maxId) {
  const partes = [];
  if (variante.query) partes.push(variante.query);
  if (maxId) partes.push(`max_id=${encodeURIComponent(maxId)}`);
  return variante.base + (partes.length ? '?' + partes.join('&') : '');
}

/**
 * Uma página da lista. Devolve `null` quando a recusa parece ser do PEDIDO
 * (parâmetro que o Instagram não aceita mais), para quem chamou tentar a
 * variante seguinte. Recusa que é da CONTA — desacelerar, verificação, sessão
 * expirada — sempre lança, e nunca vira motivo para outra tentativa.
 */
async function lerPaginaBesties(path, csrf) {
  const r = await apiGet(path, csrf);
  const res = { status: r.status, texto: await r.text() };

  if (res.status === 401 || res.status === 403) {
    throw new ChallengeError(
      'O Instagram recusou a leitura do Close Friends. Sua sessão pode ter expirado.'
    );
  }

  const texto = res.texto;
  const data = comoJson(texto);

  // A mensagem do próprio Instagram é o que diz o que houve — sem ela, todo
  // erro daqui vira "não deu certo" e não há como agir.
  const msg = String(data?.message || '');
  const baixa = msg.toLowerCase();

  if (res.status === 429 || baixa.includes('wait a few minutes') || baixa.includes('rate limit')) {
    throw new RateLimitError(
      'o Instagram pediu para desacelerar' + (msg ? ` ("${msg}")` : '') + '.'
    );
  }

  if (baixa.includes('challenge') || baixa.includes('checkpoint')) {
    // Nunca insistir contra uma verificação — é o padrão que leva ao bloqueio.
    throw new ChallengeError(
      'O Instagram pediu verificação para ler o Close Friends. Confirme sua conta no app e tente mais tarde.'
    );
  }

  if (baixa.includes('login_required') || baixa.includes('not authorized')) {
    throw new ChallengeError(
      'O Instagram não reconheceu a sessão ao ler o Close Friends. Abra o instagram.com, confirme que está logado e tente de novo.'
    );
  }

  if (!data) {
    const html = texto.trimStart().startsWith('<');
    throw new EndpointError(
      `${path} respondeu HTTP ${res.status} com ${html ? 'HTML' : texto.length + ' bytes'} `
      + 'em vez de JSON — o endpoint da lista de Close Friends mudou.'
    );
  }

  if (Array.isArray(data.users)) {
    return data;
  }

  // JSON legítimo, sem a lista: o pedido foi recusado. Deixa quem chamou tentar
  // a próxima variante, guardando o que o Instagram disse para o caso de todas
  // falharem.
  const detalhe = msg
    ? `HTTP ${res.status}: "${msg}"`
    : `HTTP ${res.status}, campos: ${Object.keys(data).join(', ') || 'nenhum'}`;
  const erro = new Error(detalhe);
  erro.recusaDePedido = true;
  // É uma incompatibilidade declarada pelo servidor, não uma variação de
  // parâmetro. Trocar `count` não muda o User-Agent do navegador; no máximo
  // vale confirmar a mesma variante pela aba antes de parar.
  erro.naoRepetir = baixa.includes('useragent mismatch');
  return erro;
}

// Quantas pessoas cabem numa consulta de estado de amizade. É leitura em lote:
// o site usa isso para descobrir o estado de uma lista inteira sem uma
// requisição por pessoa.
const LOTE_STATUS = 100;

/**
 * Descobre quem está no Close Friends perguntando o ESTADO DE AMIZADE das
 * pessoas, em lotes.
 *
 * `friendships/show_many/` é POST, mas é leitura: não altera nada, só responde
 * o que já é verdade. É o mesmo `friendship_status` que volta quando se clica
 * numa estrela — e ele traz `is_bestie`.
 *
 * Este é o caminho para quando a coleta de seguidores não traz `is_bestie`
 * embutido. Custa uma requisição a cada 100 pessoas, então só vale a pena
 * sobre os SEGUIDORES: o Instagram não deixa ninguém entrar no Close Friends
 * sem seguir você, então essa lista já contém todo mundo que pode estar lá.
 *
 * @param {string[]} pks  os seguidores
 * @param {string} csrf
 * @param {(lidos:number, total:number)=>void} onProgress
 * @returns {Promise<Set<string>|null>}
 *   `null` quando a resposta não fala de Close Friends — do mesmo jeito que na
 *   coleta, "não sei" nunca pode virar "não tem ninguém".
 */
/*
 * Formas conhecidas de perguntar o estado de amizade de um lote.
 *
 * `user_ids` separado por vírgula é o formato antigo; a lista como array JSON é
 * o que a web passou a mandar. Uma rota que não entende o corpo devolve a
 * página em HTML — que aqui vira `EndpointError` e faz tentar a seguinte.
 */
const FORMATOS_STATUS = [
  {
    nome: 'user_ids em formulário',
    tipo: 'application/x-www-form-urlencoded',
    corpo: (pks) => new URLSearchParams({ user_ids: pks.join(',') }).toString(),
  },
  {
    nome: 'user_ids em JSON',
    tipo: 'application/json',
    corpo: (pks) => JSON.stringify({ user_ids: pks }),
  },
];

let formatoStatus = null;

async function statusDeUmLote(pks, csrf) {
  // Memorizado primeiro, os outros de reserva na mesma chamada — mesmo motivo
  // de `fetchPage`: memorizar não pode significar perder as alternativas.
  const candidatos = formatoStatus
    ? [formatoStatus, ...FORMATOS_STATUS.filter((f) => f !== formatoStatus)]
    : FORMATOS_STATUS;
  let ultimo = null;

  for (const formato of candidatos) {
    try {
      const data = await apiPost(
        '/api/v1/friendships/show_many/', csrf, formato.corpo(pks), formato.tipo
      );
      formatoStatus = formato;
      return data;
    } catch (error) {
      // Só troca de formato quando o pedido não foi entendido. Recusa de
      // verdade (bloqueio, verificação) interrompe na hora, como sempre.
      if (!(error instanceof EndpointError)) {
        throw error;
      }
      formatoStatus = null; // o memorizado deixou de valer
      ultimo = new EndpointError(`${formato.nome}: ${error.message}`);
    }
  }

  throw ultimo;
}

/**
 * Descobre o Close Friends perguntando o estado de amizade UMA PESSOA POR VEZ.
 *
 * É o caminho caro, e existe porque os baratos morreram: `show_many/` responde
 * HTTP 404 (a rota foi removida) e `besties/` só atende o aplicativo de
 * celular. `show/{pk}/` é o que o site chama ao abrir um perfil, e é a última
 * rota conhecida que devolve `friendship_status` para o navegador.
 *
 * Custa uma requisição por pessoa, então antes de varrer tudo ele PERGUNTA POR
 * UMA e confere se a resposta sequer fala de Close Friends. Se não falar,
 * desiste tendo gasto uma requisição — não duzentas.
 *
 * @param {string[]} pks
 * @param {string} csrf
 * @param {(lidos:number, total:number)=>void} onProgress
 * @returns {Promise<Set<string>>}
 */
/*
 * Ritmo desta varredura, separado do PACE das páginas de propósito.
 *
 * Aqui é uma requisição por pessoa, e uma conta com 10 mil seguidores levaria
 * horas no ritmo página-a-página. O acerto foi trocar "uma de cada vez, devagar"
 * por "um punhado de cada vez, com pausa entre os punhados": quatro requisições
 * simultâneas é o que o próprio site dispara ao carregar uma tela, então não é
 * um padrão estranho — o que chama atenção é a cadência constante e o volume por
 * minuto, e é isso que a pausa entre grupos segura.
 *
 * Se a conta começar a levar verificação, o caminho é DIMINUIR a concorrência ou
 * aumentar as pausas — nunca o contrário.
 */
const ESTADO = {
  concorrencia: 4,
  minDelayMs: 500,
  maxDelayMs: 1200,
  pausaLongaACada: 25, // grupos, ou seja ~100 pessoas
  pausaLongaMs: 5000,
};

async function estadoDeAmizade(pk, csrf) {
  const res = await apiGet(`/api/v1/friendships/show/${pk}/`, csrf);
  const texto = await res.text();
  const data = comoJson(texto);

  /*
   * A checagem aqui não é formalidade: esta função roda MILHARES de vezes por
   * varredura, e é a única cujo resultado vira relação entre pessoas. Sem ela,
   * uma recusa no meio do caminho seguia como se fosse resposta boa — os campos
   * ausentes viravam `false`, e quem te segue passava a constar como "não te
   * segue de volta". Além disso, a varredura continuaria pelas outras milhares
   * de contas contra uma conta que o Instagram acabou de sinalizar.
   */
  const recusa = recusaDaConta(res, data);
  if (recusa) throw recusa;

  if (!data) {
    throw new EndpointError(
      `o estado de amizade individual respondeu HTTP ${res.status} sem JSON.`
    );
  }

  if (data.status && data.status !== 'ok') {
    throw new Error(String(data.message || 'o Instagram recusou a consulta de estado de amizade.'));
  }

  return data;
}

/*
 * Percorre uma lista de pks perguntando o estado de amizade de cada um, no
 * ritmo do ESTADO acima, e entrega os grupos à medida que chegam.
 *
 * Duas leituras diferentes usam isto — o Close Friends (`is_bestie`) e a
 * relação de quem segue quem (`followed_by`) —, e as duas dependem das MESMAS
 * três proteções, que é por isso que a mecânica é uma só: a sonda que desiste
 * na primeira resposta quando a fonte não serve, a concorrência de 4 com pausa
 * entre os grupos, e a entrega parcial para que interromper no meio não jogue
 * fora o que já custou requisição.
 *
 * @param {string[]} pks
 * @param {string} csrf
 * @param {string} exigido   campo que a resposta PRECISA trazer para a varredura
 *                           fazer sentido — a sonda confere só ele
 * @param {(lidos:number, total:number, pares:[string, object][])=>void} aoGrupo
 */
async function varrerEstados(pks, csrf, exigido, aoGrupo) {
  if (!pks.length) return;

  // A sonda: a primeira resposta decide se vale varrer o resto. Uma requisição
  // gasta em vez de dez mil, quando a fonte não serve.
  const primeira = await estadoDeAmizade(pks[0], csrf);
  if (!(exigido in primeira)) {
    const erro = new Error(
      `o estado de amizade individual não traz o campo ${exigido} `
      + `(campos: ${Object.keys(primeira).join(', ') || 'nenhum'}).`
    );
    erro.semCampo = true;
    throw erro;
  }

  await aoGrupo(1, pks.length, [[String(pks[0]), primeira]]);

  let grupo = 0;
  for (let i = 1; i < pks.length; i += ESTADO.concorrencia) {
    grupo += 1;

    const span = ESTADO.maxDelayMs - ESTADO.minDelayMs;
    await delay(ESTADO.minDelayMs + Math.random() * span);
    if (grupo % ESTADO.pausaLongaACada === 0) {
      await delay(ESTADO.pausaLongaMs);
    }

    const pedaco = pks.slice(i, i + ESTADO.concorrencia);

    /*
     * `allSettled`, e não `all`: com `all`, uma única falha entre as quatro
     * jogava fora as outras três respostas JÁ PAGAS — e, numa varredura de 50
     * contas, um tropeço na 48ª descartava as 47 anteriores junto com as
     * requisições que elas custaram. Entrega o que respondeu e só então propaga
     * o erro, para quem chamou ficar com o que deu certo.
     */
    const respostas = await Promise.allSettled(pedaco.map((pk) => estadoDeAmizade(pk, csrf)));

    const boas = [];
    let falha = null;
    for (let j = 0; j < pedaco.length; j += 1) {
      if (respostas[j].status === 'fulfilled') boas.push([String(pedaco[j]), respostas[j].value]);
      else if (!falha) falha = respostas[j].reason;
    }

    // Entrega o pedaço lido ANTES do fim: numa base grande, quem interromper no
    // meio não pode perder o que já custou requisição.
    if (boas.length) await aoGrupo(i + boas.length, pks.length, boas);

    // Recusa da conta (verificação, bloqueio, desacelerar) interrompe aqui, com
    // o que já foi lido preservado pelo callback acima.
    if (falha) throw falha;
  }
}

async function bestiesUmAUm(pks, csrf, aoLer = () => {}) {
  const marcados = new Set();

  await varrerEstados(pks, csrf, 'is_bestie', async (lidos, total, pares) => {
    const parciais = [];
    for (const [pk, data] of pares) {
      const bestie = Boolean(data.is_bestie);
      if (bestie) marcados.add(pk);
      parciais.push([pk, bestie]);
    }
    await aoLer(lidos, total, parciais);
  });

  return marcados;
}

/**
 * Quem, dentre estas contas, segue você de volta — e quem está no seu Close
 * Friends, que vem na mesma resposta e por isso sai de graça.
 *
 * É o que sustenta o limite do plano FREE. Sem isto, dizer "esta pessoa não te
 * segue de volta" exigiria a lista INTEIRA de seguidores: alguém que está na
 * página 40 dessa lista apareceria como "não te segue" se a coleta parasse na
 * página 1. Errar isso seria o pior defeito possível aqui — a pessoa deixaria
 * de seguir quem a segue. Perguntando conta a conta, o custo passa a ser uma
 * requisição por pessoa analisada (50, no FREE) e a resposta é exata.
 *
 * @param {string[]} pks
 * @param {string} csrf
 * @param {(lidos:number, total:number)=>void} aoLer
 * @returns {Promise<Map<string, {segueVoce:boolean, voceSegue:boolean, bestie:boolean}>>}
 */
async function relacaoUmAUm(pks, csrf, aoLer = () => {}) {
  const relacoes = new Map();

  await varrerEstados(pks, csrf, 'followed_by', async (lidos, total, pares) => {
    for (const [pk, data] of pares) {
      relacoes.set(pk, {
        segueVoce: Boolean(data.followed_by),
        voceSegue: Boolean(data.following),
        bestie: Boolean(data.is_bestie),
      });
    }
    await aoLer(lidos, total);
  });

  return relacoes;
}

/**
 * Pergunta ao Instagram, AGORA, se a pessoa segue você, antes de deixar de
 * seguir alguém que a base marcou como "não te segue de volta".
 *
 * FB-02 (06/10/2026, em `FEEDBACK.md`): uma cliente PRO com 9.835 contas viu
 * marcada como "não te segue de volta" uma pessoa que a seguia, e a tela
 * oferecia "Deixar de seguir 373" em cima dessa marcação. No PRO a relação sai
 * do CRUZAMENTO das listas, e ele erra em dois casos que a extensão não
 * enxerga: a pessoa passou a seguir depois da última leitura, ou o Instagram
 * devolveu a lista de seguidores incompleta sem erro nenhum. Os dois terminam
 * na mesma escrita irreversível contra quem segue a cliente.
 *
 * É uma LEITURA (`friendships/show/{pk}/`, a mesma do FREE em `relacaoUmAUm`)
 * antes de cada escrita, e só para quem a base diz que não segue: o unfollow
 * em massa já espaça as escritas de 28 a 50 s, e uma leitura dentro desse
 * intervalo não muda o volume por minuto que o Instagram pune.
 *
 * Sem o campo `followed_by` não há como afirmar nada, e a resposta é ERRO, não
 * "pode deixar": na dúvida, ninguém deixa de ser seguido. Recusa da conta
 * (verificação, bloqueio, desacelerar) sobe como em todo o arquivo.
 *
 * @param {string} pk
 * @param {string} csrf
 * @returns {Promise<{segueVoce:boolean, voceSegue:boolean, deixar:boolean}>}
 *   `deixar` só é verdadeiro quando a pessoa NÃO segue você e você AINDA a segue.
 */
async function conferirAntesDeDeixar(pk, csrf) {
  const data = await estadoDeAmizade(pk, csrf);
  if (!('followed_by' in data) || !('following' in data)) {
    throw new Error(
      'não deu para confirmar com o Instagram se esta conta segue você, e por isso '
      + 'ela não foi deixada de seguir.'
    );
  }
  const segueVoce = Boolean(data.followed_by);
  const voceSegue = Boolean(data.following);
  return { segueVoce, voceSegue, deixar: !segueVoce && voceSegue };
}

async function bestiesPorStatus(pks, csrf, onProgress = () => {}) {
  const marcados = new Set();
  let lidos = 0;
  let lote = 0;

  for (let i = 0; i < pks.length; i += LOTE_STATUS) {
    const pedaco = pks.slice(i, i + LOTE_STATUS);
    lote += 1;

    const data = await statusDeUmLote(pedaco, csrf);

    const status = data.friendship_statuses || {};

    // A CHAVE existir é o que prova que esta resposta sabe de Close Friends.
    // Se o primeiro lote não souber, os outros também não vão saber: desiste
    // agora, em vez de gastar dezenas de requisições da conta para nada.
    const sabe = Object.values(status).some((fs) => fs && 'is_bestie' in fs);
    if (!sabe) {
      if (lote > 1) {
        return marcados;
      }
      // Dizer O QUE veio, não só que faltou: sem isso, "não deu" some no
      // console e não dá para saber se a resposta veio vazia, veio de outra
      // conta ou veio com outros campos.
      const exemplo = Object.values(status)[0];
      const campos = exemplo ? Object.keys(exemplo).join(', ') : 'nenhum';
      const erro = new Error(
        `a resposta de amizade veio com ${Object.keys(status).length} contas, `
        + `sem o campo is_bestie (campos: ${campos}).`
      );
      erro.semCampo = true;
      throw erro;
    }

    for (const [pk, fs] of Object.entries(status)) {
      if (fs && fs.is_bestie) {
        marcados.add(String(pk));
      }
    }

    lidos += pedaco.length;
    onProgress(lidos, pks.length);

    if (i + LOTE_STATUS < pks.length) {
      await pace(lote);
    }
  }

  return marcados;
}

/**
 * Lê a lista atual de Melhores amigos da própria conta (só os pks).
 * Serve para a extensão saber quem já está lá antes de mexer em qualquer coisa.
 */
async function coletarBesties(user) {
  if (leituraBestiesRecusada) {
    throw new Error(leituraBestiesRecusada);
  }

  const candidatas = varianteLeituraBesties
    ? [varianteLeituraBesties, ...VARIANTES_LEITURA_BESTIES.filter((v) => v !== varianteLeituraBesties)]
    : VARIANTES_LEITURA_BESTIES;

  const recusas = [];
  const caminhosMortos = new Set();

  let soIncompatibilidade = true;

  for (const variante of candidatas) {
    if (caminhosMortos.has(variante.caminho)) continue;

    /*
     * `lerPaginaBesties` DEVOLVE o erro quando a recusa é do pedido, mas LANÇA
     * `EndpointError` quando vem HTML — que é justamente o modo de falha para o
     * qual esta cascata existe (rota que não existe responde a página do site
     * com HTTP 200). Sem este try, o primeiro caminho a responder HTML abortava
     * o laço inteiro e o segundo caminho nunca era tentado.
     */
    let primeira;
    try {
      primeira = await lerPaginaBesties(montarPathBesties(variante, null), user.csrf);
    } catch (error) {
      if (!(error instanceof EndpointError)) throw error;
      primeira = error;
    }

    if (primeira instanceof Error) {
      recusas.push(`${variante.nome} → ${primeira.message}`);

      // "useragent mismatch" é recusa do ENDEREÇO, não do parâmetro: trocar o
      // `count` não muda o User-Agent. Descarta as outras variantes deste
      // caminho em vez de gastar requisições da conta para ouvir a mesma coisa
      // — mas segue para o próximo caminho, que é outro endereço e pode não
      // ter a mesma exigência.
      if (primeira.naoRepetir) {
        caminhosMortos.add(variante.caminho);
        continue;
      }

      // Qualquer recusa que NÃO seja incompatibilidade declarada pode ser
      // passageira — e passageira não pode desligar a fonte pelo resto da
      // sessão (ver a memória logo abaixo).
      soIncompatibilidade = false;

      // Pausa antes da próxima tentativa: duas leituras coladas é o que a
      // plataforma lê como robô.
      await pace(1);
      continue;
    }

    varianteLeituraBesties = variante;
    return await paginarBesties(user, variante, primeira);
  }

  varianteLeituraBesties = null;
  const motivo = 'o Instagram recusou o pedido da lista (' + recusas.join('; ') + ').';

  /*
   * Só vira recusa PERMANENTE quando todas as recusas foram incompatibilidade
   * declarada ("useragent mismatch"), que de fato não muda entre uma
   * sincronização e outra. Guardar um "Something went wrong" passageiro
   * desligava a única fonte completa do Close Friends pelo resto da sessão,
   * mesmo depois de o problema passar.
   */
  if (soIncompatibilidade) {
    leituraBestiesRecusada = motivo;
  }
  throw new Error(motivo);
}

/** Continua a leitura a partir da primeira página, que já veio boa. */
async function paginarBesties(user, variante, primeira) {
  const out = [];
  let data = primeira;
  let maxId = null;
  let page = 0;

  // Teto de páginas: guarda contra um next_max_id que não termina nunca.
  while (page < 60) {
    page += 1;

    for (const u of data.users) {
      out.push(String(u.pk));
    }

    const proximo = data.next_max_id ? String(data.next_max_id) : '';
    if (!proximo || proximo === maxId) {
      break;
    }
    maxId = proximo;

    await pace(page);

    const seguinte = await lerPaginaBesties(montarPathBesties(variante, maxId), user.csrf);
    if (seguinte instanceof Error) {
      // Recusa no meio da paginação: entregar o pedaço lido seria pior que
      // falhar — a lista incompleta substituiria a boa e apagaria estrelas de
      // gente que ESTÁ no Close Friends. Falha, e a leitura anterior fica.
      throw new Error(
        `a lista veio pela metade (${out.length} lidos) e o Instagram recusou a página seguinte `
        + `(${seguinte.message}).`
      );
    }
    data = seguinte;
  }

  return out;
}

/*
 * Formas conhecidas de falar com o set_besties. O Instagram já mudou este
 * caminho mais de uma vez, e uma rota que não existe volta a PÁGINA em HTML com
 * HTTP 200 — não um 404. Por isso: tenta uma, e só troca de variante quando a
 * resposta não é JSON (EndpointError). Erro de verdade (bloqueio, verificação,
 * recusa) interrompe na hora, sem ficar repetindo a escrita em outras rotas.
 *
 * Repetir um `add` de quem já está na lista não faz nada — é por isso que a
 * cascata é segura.
 *
 * DESDE 17/09/2026 É A RESERVA: as três responderam HTTP 404 com HTML na conta
 * do dono, pela versão da loja. Ficam pelo mesmo motivo das rotas REST de
 * seguir: custam nada enquanto o Bloks responde, e cobrem o dia em que ele
 * mudar antes de nós.
 */
const VARIANTES_BESTIES = [
  {
    nome: 'api/v1 + formulário',
    path: '/api/v1/friendships/set_besties/',
    tipo: 'application/x-www-form-urlencoded',
    corpo: (add, remove) => new URLSearchParams({
      add: JSON.stringify(add),
      remove: JSON.stringify(remove),
      module: 'favorites_home_list',
      source: 'audience_manager',
    }).toString(),
  },
  {
    nome: 'api/v1 + JSON',
    path: '/api/v1/friendships/set_besties/',
    tipo: 'application/json',
    corpo: (add, remove) => JSON.stringify({
      add,
      remove,
      module: 'favorites_home_list',
      source: 'audience_manager',
    }),
  },
  {
    nome: 'web + formulário',
    path: '/web/friendships/set_besties/',
    tipo: 'application/x-www-form-urlencoded',
    corpo: (add, remove) => new URLSearchParams({
      add: JSON.stringify(add),
      remove: JSON.stringify(remove),
    }).toString(),
  },
];

// Qual variante respondeu como API nesta sessão. Assim a cascata acontece uma
// vez só, e não a cada lote.
let varianteBesties = null;

/**
 * Adiciona e/ou remove um LOTE de pessoas do Close Friends numa requisição só.
 *
 * @param {string[]} add    pks a adicionar
 * @param {string[]} remove pks a remover
 * @returns {Promise<{confirmados: Set<string>, semStatus: boolean}>}
 *   `confirmados` são os pks que o Instagram devolveu como close friends.
 *   `semStatus` avisa que a resposta veio sem essa confirmação por pessoa —
 *   nesse caso quem chamou assume o lote pelo `status: ok`.
 */
async function definirBestiesRest(add, remove, csrf) {
  const listaAdd = add.map(String);
  const listaRemove = remove.map(String);

  // A que já funcionou vem primeiro; as outras ficam de reserva para o dia em
  // que o Instagram mudar o caminho no meio de uma sessão.
  const candidatas = varianteBesties
    ? [varianteBesties, ...VARIANTES_BESTIES.filter((v) => v !== varianteBesties)]
    : VARIANTES_BESTIES;
  const pistas = [];
  let data = null;

  for (const v of candidatas) {
    try {
      data = await apiPost(v.path, csrf, v.corpo(listaAdd, listaRemove), v.tipo);
      varianteBesties = v;
      break;
    } catch (error) {
      if (!(error instanceof EndpointError)) {
        throw error; // erro real do Instagram: não insiste em outra rota
      }
      pistas.push(`${v.nome}: ${error.message}`);
      console.warn('[Mútuo] set_besties —', v.nome, '→', error.message);
    }
  }

  if (!data) {
    varianteBesties = null;
    throw new EndpointError(
      'Nenhuma das rotas conhecidas do Close Friends respondeu como API. '
      + 'O Instagram provavelmente mudou o endpoint. Detalhe: ' + pistas.join(' | ')
    );
  }

  const status = data.friendship_statuses || {};
  const confirmados = new Set();
  for (const [pk, fs] of Object.entries(status)) {
    if (fs && fs.is_bestie) {
      confirmados.add(String(pk));
    }
  }

  return { confirmados, semStatus: Object.keys(status).length === 0 };
}

// --- Close Friends pelo Bloks do site (17/09/2026) ------------------------
/*
 * POR QUE ESTE CAMINHO EXISTE, E POR QUE ELE VEM PRIMEIRO.
 *
 * O `set_besties` morreu. Em 17/09/2026 as três formas conhecidas responderam
 * HTTP 404 com HTML, na conta do dono e pela versão 1.0.6 da loja: o mesmo fim
 * que as rotas REST de seguir tiveram em 18/08.
 *
 * O que o site usa hoje foi CAPTURADO, não suposto. Os scripts públicos do
 * Instagram não traziam nada do Close Friends (a tela só carrega logada), então
 * uma sonda no console de instagram.com/accounts/close_friends/ registrou o
 * pedido que sai ao desmarcar uma pessoa:
 *
 *   POST /async/wbloks/fetch/?appid=com.instagram.portable_settings.privacy
 *        .close_friends_screen.make_close_friend&type=action&__bkv=<versão>
 *   params={"user_id":480923199,"should_not_make_close_friend":true}
 *
 * e a resposta veio como `for (;;);{"__ar":1,"payload":{"layout":{...}}}`.
 *
 * TRÊS DIFERENÇAS para o que existia, e cada uma mudou código:
 *
 *   - UMA PESSOA POR PEDIDO. O lote de 50 acabou, e quem dita o ritmo da ação
 *     em massa passou a ser `RITMO_CLOSE`, em ritmo.js.
 *   - O `__bkv` é a versão publicada do Bloks, como o `doc_id` é a da consulta
 *     GraphQL. Aqui ele não é constante: vem do HTML da página
 *     (`WebBloksVersioningID`), lido pela ponte junto do `fb_dtsg`, e por isso
 *     acompanha o site sozinho.
 *   - A RESPOSTA NÃO DIZ, POR PESSOA, SE DEU CERTO. Ela é a tela nova, não um
 *     status. Por isso a primeira escrita de cada sessão é CONFERIDA
 *     (`bestiesConferido`, abaixo).
 *
 * O corpo é o que `getAsyncParams("POST")` monta no cliente web, e o site não
 * manda cabeçalho próprio neste pedido (`webBloksFetchJson`, lido no script do
 * Instagram). Aqui é igual: parecer com o site por SER o site.
 */
const APP_CLOSE_FRIEND = 'com.instagram.portable_settings.privacy.close_friends_screen.make_close_friend';

/*
 * Códigos de erro do `for (;;);{...}` da Meta que mudam o que fazer:
 *
 *   1357001  sessão caída (o "Not Logged In" do cliente web);
 *   1357004  `fb_dtsg` recusado, o mesmo de `mutacaoAmizade`: renova uma vez;
 *   1390008  recurso bloqueado para a conta ("Você está temporariamente
 *            bloqueado"). É o action block dito do jeito da Meta, e liga a
 *            trava. AINDA NÃO FOI VISTO neste pedido: está aqui porque tratar
 *            um bloqueio como erro qualquer deixaria a pessoa clicar de novo.
 *
 * Qualquer outro código PARA sem tentar a reserva: um erro que não se conhece
 * pode ser recusa da conta, e insistir por outro caminho é o que pune a conta.
 */
const ERRO_SEM_SESSAO = 1357001;
const ERRO_DTSG = 1357004;
const ERRO_BLOQUEADO = 1390008;

function textoDoErroMeta(data) {
  return [data.errorSummary, data.errorDescription]
    .filter(Boolean)
    .map((t) => String(t).replace(/<[^>]*>/g, ''))
    .join(': ');
}

async function acaoCloseFriend(pk, entrar, csrf, jaRenovou = false) {
  const tk = await obterTokens();

  if (!tk.bkv) {
    throw new EndpointError(
      'a versão do Bloks (WebBloksVersioningID) não veio no HTML do Instagram, e sem ela o pedido do '
      + 'Close Friends não tem como sair.'
    );
  }

  const url = BASE + '/async/wbloks/fetch/?' + new URLSearchParams({
    appid: APP_CLOSE_FRIEND,
    type: 'action',
    __bkv: tk.bkv,
  });

  /*
   * O `user_id` vai como NÚMERO, como o site manda, e montado à mão: passar o pk
   * por `Number()` arredondaria um id maior que 2^53. Quem chama já garantiu que
   * são só dígitos.
   */
  const corpo = new URLSearchParams({
    __d: 'www',
    __user: '0',
    __a: '1',
    __req: 'b',
    dpr: '1',
    __ccg: 'EXCELLENT',
    __rev: tk.rev,
    __comet_req: '7',
    fb_dtsg: tk.dtsg,
    jazoest: jazoest(tk.dtsg),
    lsd: tk.lsd,
    __spin_r: tk.rev,
    __spin_b: 'trunk',
    __spin_t: String(Math.floor(Date.now() / 1000)),
    params: `{"user_id":${pk},"should_not_make_close_friend":${entrar ? 'false' : 'true'}}`,
  });

  const res = comoResposta(await falarComAPonte({
    tipo: 'mutuo-fetch',
    url,
    metodo: 'POST',
    cabecalhos: { 'content-type': 'application/x-www-form-urlencoded;charset=UTF-8' },
    corpo: corpo.toString(),
  }));

  const texto = await res.text();
  const data = comoJson(texto);

  // Recusa da conta antes de qualquer conclusão sobre o caminho, na mesma
  // ordem de `apiPost` e `mutacaoAmizade`. O texto do erro da Meta entra como
  // `message`, que é onde `recusaDaConta` procura.
  const recusa = recusaDaConta(res, data && { ...data, message: data.message || textoDoErroMeta(data) });
  if (recusa) throw recusa;

  if (!data) {
    const html = texto.trimStart().startsWith('<');
    const trecho = html ? '' : ': começa com ' + texto.trim().slice(0, 160);
    throw new EndpointError(
      '/async/wbloks/fetch (Close Friends) respondeu HTTP ' + res.status + ' com '
      + (html ? 'HTML' : texto.length + ' bytes') + ' em vez de JSON' + trecho + '.'
    );
  }

  if (data.redirect) {
    const destino = String(data.redirect);
    if (destino.includes('/challenge')) {
      throw new ChallengeError('O Instagram pediu verificação. Confirme sua conta no app e tente mais tarde.');
    }
    if (destino.includes('/accounts/login')) {
      throw new NotLoggedInError(
        'O Instagram não reconheceu a sessão. Abra o instagram.com, confirme que está logado e tente de novo.'
      );
    }
    throw new Error('O Instagram redirecionou o pedido do Close Friends para ' + destino + '.');
  }

  if (data.error) {
    if (data.error === ERRO_DTSG && !jaRenovou) {
      await obterTokens(true);
      return acaoCloseFriend(pk, entrar, csrf, true);
    }
    if (data.error === ERRO_DTSG) {
      throw new EndpointError('/async/wbloks/fetch (Close Friends) recusou o fb_dtsg mesmo depois de renovar.');
    }
    if (data.error === ERRO_SEM_SESSAO) {
      throw new NotLoggedInError(
        'O Instagram não reconheceu a sessão. Abra o instagram.com, confirme que está logado e tente de novo.'
      );
    }
    if (data.error === ERRO_BLOQUEADO) {
      throw new ActionBlockedError(
        'O Instagram bloqueou temporariamente esta ação. É o "action block": pare por hoje e tente novamente mais tarde.'
      );
    }
    throw new Error(
      'O Instagram recusou o pedido do Close Friends'
      + (textoDoErroMeta(data) ? ' ("' + textoDoErroMeta(data) + '")' : '')
      + ' (erro ' + data.error + ').'
    );
  }

  if (!data.payload) {
    throw new EndpointError(
      '/async/wbloks/fetch (Close Friends) respondeu JSON sem payload: ' + JSON.stringify(data).slice(0, 300)
    );
  }

  return data;
}

/*
 * A primeira escrita de cada sessão é conferida no Instagram, e só ela.
 *
 * O Bloks responde com a tela, não com o estado da pessoa. Sem conferir, um
 * formato que o Instagram aceite e ignore (o de ADICIONAR foi deduzido do de
 * remover, que é o capturado) pintaria estrelas que não existem na conta, uma
 * operação em massa inteira delas. Conferir TODAS dobraria as requisições; a
 * primeira basta para provar que o caminho faz o que se espera, e as seguintes
 * usam o mesmo formato. Depois de uma falha, a próxima confere de novo.
 */
let bestiesConferido = false;

/**
 * Coloca ou tira UMA pessoa do Close Friends.
 *
 * @param {string} pk
 * @param {boolean} entrar  `true` adiciona, `false` remove
 * @param {string} csrf
 * @returns {Promise<{dentro: boolean, conferido: boolean}>}
 *   `dentro` é o estado depois do pedido. `conferido` diz se ele foi LIDO no
 *   Instagram; quando não foi, é o pedido aceito.
 */
async function definirBestie(pk, entrar, csrf) {
  const id = String(pk);
  if (!/^\d+$/.test(id)) {
    throw new Error('Close Friends: identificador de conta inválido (' + id + ').');
  }

  try {
    await acaoCloseFriend(id, entrar, csrf);
  } catch (error) {
    if (!(error instanceof EndpointError)) throw error;
    console.warn('[Mútuo] Bloks do Close Friends não respondeu:', error.message, '(tentando o set_besties antigo)');

    // A falha do caminho primário entra na mensagem final, pelo motivo escrito
    // em `escrever`: mostrar só a reserva manda investigar o lugar errado.
    try {
      const r = await definirBestiesRest(entrar ? [id] : [], entrar ? [] : [id], csrf);
      return { dentro: r.semStatus ? entrar : r.confirmados.has(id), conferido: !r.semStatus };
    } catch (erroRest) {
      if (!(erroRest instanceof EndpointError)) throw erroRest;
      throw new EndpointError('Bloks: ' + error.message + '  ||  REST: ' + erroRest.message);
    }
  }

  if (bestiesConferido) return { dentro: entrar, conferido: false };

  // Um respiro antes de ler: perguntar no mesmo instante da escrita arrisca ler
  // o estado de antes, e acusar de falha um pedido que deu certo.
  await delay(1500);
  const estado = await estadoDeAmizade(id, csrf);

  if (typeof estado.is_bestie !== 'boolean') {
    // Sem o campo não há como conferir, e isso não é prova de falha. Fica
    // registrado, e as próximas não gastam uma leitura cada para ouvir o mesmo.
    console.warn('[Mútuo] o estado de amizade veio sem is_bestie; o Close Friends segue sem conferência.');
    bestiesConferido = true;
    return { dentro: entrar, conferido: false };
  }

  if (estado.is_bestie !== entrar) {
    throw new Error(
      'O Instagram aceitou o pedido do Close Friends, mas a conta continua '
      + (entrar ? 'FORA' : 'DENTRO') + ' da lista. Nada foi marcado aqui; sincronize para conferir.'
    );
  }

  bestiesConferido = true;
  return { dentro: estado.is_bestie, conferido: true };
}

/**
 * O ponto de uma coleta: o que precisa ser guardado para continuar de onde
 * parou, e nada além disso. Tudo aqui é serializável de propósito, ele vai
 * para o `chrome.storage`, e um `Set` viraria `{}` no caminho.
 *
 * @typedef {object} PontoDaColeta
 * @property {'followers'|'following'} kind
 * @property {string|null} maxId    o cursor da PRÓXIMA página a pedir
 * @property {number} page          quantas páginas já foram lidas
 * @property {string[]} cursores    os cursores já vistos (a guarda contra laço)
 * @property {object[]} pessoas     tudo que já foi lido
 * @property {string[]|null} marcados  quem veio com `is_bestie` verdadeiro
 * @property {number} comCampo      quantos TROUXERAM o campo `is_bestie`
 * @property {boolean} parcial      a leitura foi cortada pelo teto do plano
 * @property {boolean} completa     a lista acabou; não há o que retomar
 */

/**
 * Monta o resultado da coleta a partir de um ponto.
 *
 * Existe um lugar só para essa conta de propósito: a régua de cobertura do
 * `is_bestie` decide se as estrelas guardadas são SUBSTITUÍDAS ou UNIDAS, e
 * ela vale tanto para uma coleta que acabou agora quanto para uma que foi
 * retomada do storage. Duas cópias dessa régua divergiriam sem ninguém notar,
 * e o sintoma seria estrela sumindo.
 *
 * @param {PontoDaColeta} ponto
 */
function coletaDoPonto(ponto) {
  const marcados = ponto.marcados ? new Set(ponto.marcados) : null;

  /*
   * A lista de Close Friends só vale como autoritativa se PRATICAMENTE TODO
   * mundo trouxe o campo. Com cobertura parcial ela vira "sei de alguns", e
   * quem chamou precisa unir com o que já sabia em vez de substituir — senão
   * as estrelas de quem ficou de fora somem.
   */
  const cobertura = ponto.pessoas.length ? ponto.comCampo / ponto.pessoas.length : 0;

  return {
    pessoas: ponto.pessoas,
    besties: marcados,
    bestiesParcial: Boolean(marcados) && cobertura < 0.99,
    parcial: Boolean(ponto.parcial),
  };
}

/*
 * De quantas em quantas páginas o ponto é oferecido a quem chamou.
 *
 * Dez páginas são ~500 pessoas e uns 20 segundos: perder isso porque a aba
 * fechou é aceitável. Gravar a cada página seria reescrever a base inteira no
 * storage a cada segundo e meio, numa coleta que já é longa.
 */
const PAGINAS_POR_PONTO = 10;

/**
 * Coleta uma lista inteira, página a página, respeitando o ritmo.
 *
 * @param {'followers'|'following'} kind
 * @param {{id:string, csrf:string}} user
 * @param {(kind:string, total:number, page:number)=>void} onProgress
 * @param {{limite?:number, retomar?:PontoDaColeta|null, aoAvancar?:(p:PontoDaColeta)=>void}} opcoes
 * @returns {Promise<{pessoas: object[], besties: Set<string>|null, bestiesParcial: boolean, parcial: boolean}>}
 *   `besties` são os pks que ESTA resposta marcou como Close Friends, ou `null`
 *   quando o Instagram não mandou o campo — que é bem diferente de "ninguém".
 *
 * **INTERROMPER NÃO PODE CUSTAR O QUE JÁ FOI LIDO** (30/08/2026). Numa conta de
 * oito mil seguidores a coleta são centenas de requisições, e o Instagram
 * interrompe antes do fim com frequência, verificação, "desacelere". Até esta
 * data, a interrupção jogava fora tudo: a pessoa recomeçava do zero, tomava a
 * mesma recusa mais ou menos no mesmo lugar, e a base nunca fechava. Foi o que
 * um cliente pagante relatou (FB-01, em `FEEDBACK.md`), e a resposta certa não
 * é apressar a leitura: é não perder o que ela já custou.
 *
 * Daí `retomar` e `aoAvancar`. O ponto é oferecido de tempos em tempos, vai
 * junto do erro que interrompe, e a tentativa seguinte continua do cursor
 * guardado em vez de pedir a página 1 de novo.
 */
async function collect(kind, user, onProgress, opcoes = {}) {
  /*
   * `limite` é o teto do plano FREE: para de paginar assim que junta essa
   * quantidade de pessoas. É um freio de COLETA, não de exibição — a diferença
   * importa por dois motivos: numa conta com dez mil seguidores ele troca
   * duzentas requisições por uma (e requisição é o que faz o Instagram pedir
   * verificação), e o que não foi lido não fica guardado no navegador esperando
   * alguém abrir o DevTools.
   */
  const limite = Number.isFinite(opcoes.limite) ? opcoes.limite : Infinity;

  /*
   * O ponto guardado só serve para a MESMA lista e para uma leitura do mesmo
   * tamanho. Um parcial de `following` não continua `followers`, seriam listas
   * diferentes coladas numa só —, e um parcial lido com o teto do FREE não vira
   * base do PRO: ele parou por decisão de plano, não por falta de página, e
   * retomá-lo entregaria como completa uma leitura que nunca foi tentada
   * inteira.
   */
  const retomada = (
    opcoes.retomar
    && opcoes.retomar.kind === kind
    && Array.isArray(opcoes.retomar.pessoas)
    && opcoes.retomar.pessoas.length > 0
    && !opcoes.retomar.completa
    && !Number.isFinite(limite)
  ) ? opcoes.retomar : null;

  const aoAvancar = typeof opcoes.aoAvancar === 'function' ? opcoes.aoAvancar : null;

  const out = retomada ? retomada.pessoas.slice() : [];
  let parcial = false;

  /*
   * O Instagram costuma mandar `is_bestie` junto de cada pessoa NESTA MESMA
   * resposta. Quando manda, é a melhor fonte possível do Close Friends: vem do
   * próprio Instagram, não custa uma requisição a mais e não depende do
   * `friendships/besties/`, que responde "useragent mismatch" à sessão do
   * navegador por ser um caminho do aplicativo de celular.
   *
   * Começa `null` de propósito. Enquanto ninguém trouxer o campo, o que se sabe
   * é NADA — e nada não pode virar "a lista está vazia", que apagaria as
   * estrelas de quem está no Close Friends.
   */
  let marcados = retomada && retomada.marcados ? new Set(retomada.marcados) : null;
  // Quantas pessoas TROUXERAM o campo, contra o total lido. Sem isso, uma única
  // pessoa com `is_bestie` fazia a lista inteira passar por autoritativa, e as
  // estrelas de todo o resto eram apagadas na gravação.
  let comCampo = retomada ? (retomada.comCampo || 0) : 0;

  let maxId = retomada ? (retomada.maxId || null) : null;
  // A contagem de páginas continua de onde parou, e não zera: o teto abaixo
  // existe contra paginação infinita, e reiniciá-lo a cada retomada devolveria
  // exatamente o laço que ele impede.
  let page = retomada ? (retomada.page || 0) : 0;
  // Teto de páginas e memória do cursor: as duas guardas que `paginarBesties`
  // já tinha e esta função não. Um `next_max_id` que se repete (cursor expirado,
  // resposta vazia com o mesmo cursor) faria o laço pedir a mesma página para
  // sempre, contra a conta, sem erro nenhum.
  const TETO_PAGINAS = 400;
  const cursosVistos = new Set(retomada ? (retomada.cursores || []) : []);
  // Um pedido de desaceleração por página era rearmado a cada página: numa
  // coleta longa isso vira horas insistindo contra um limite que já falou.
  let desaceleracoes = 0;

  /*
   * A primeira página DESTA rodada quando se está retomando. Serve a duas
   * decisões abaixo, as duas sobre cursor morto, o Instagram expira os
   * `max_id`, e um ponto guardado ontem pode não valer mais hoje.
   */
  let primeiraDaRetomada = Boolean(retomada);

  const ponto = () => ({
    kind,
    maxId,
    page,
    cursores: [...cursosVistos],
    pessoas: out.slice(),
    marcados: marcados ? [...marcados] : null,
    comCampo,
    parcial,
    completa: false,
  });

  try {
    while (page < TETO_PAGINAS) {
      page += 1;

      let data;
      try {
        data = await fetchPage(kind, user.id, user.csrf, maxId);
      } catch (error) {
        if (error instanceof RateLimitError && desaceleracoes < 2) {
          desaceleracoes += 1;
          await delay(30000);
          data = await fetchPage(kind, user.id, user.csrf, maxId);
        } else {
          throw error;
        }
      }

      const gente = data.users || [];

      /*
       * Retomada que volta com página VAZIA: o cursor guardado provavelmente
       * morreu. Seguir daqui seria pior que recomeçar, a coleta terminaria
       * sozinha, com metade da base, e passaria por completa. Então joga fora o
       * ponto e relê a lista do zero, ao custo de uma requisição.
       */
      if (primeiraDaRetomada && gente.length === 0) {
        primeiraDaRetomada = false;
        out.length = 0;
        marcados = null;
        comCampo = 0;
        maxId = null;
        page = 0;
        cursosVistos.clear();
        await pace(1);
        continue;
      }
      primeiraDaRetomada = false;

      for (const u of gente) {
        // A CHAVE existir é o que prova que esta resposta fala de Close Friends.
        // Testar o valor não serviria: `false` e "não veio" são a mesma coisa.
        if ('is_bestie' in u) {
          comCampo += 1;
          if (!marcados) {
            marcados = new Set();
          }
          if (u.is_bestie) {
            marcados.add(String(u.pk));
          }
        }

        out.push({
          pk: String(u.pk),
          username: u.username,
          full_name: u.full_name || '',
          is_private: Boolean(u.is_private),
          is_verified: Boolean(u.is_verified),
          profile_pic_url: u.profile_pic_url || '',
        });
      }

      onProgress(kind, out.length, page);

      // O limite pode cair no meio de uma página: corta na conta certa, porque o
      // número que a tela promete ("50 perfis analisados") tem de ser o número
      // que foi lido de fato.
      if (out.length >= limite) {
        out.length = limite;
        // Só é "parcial" se de fato havia mais para ler: uma conta que segue
        // exatamente 50 pessoas foi lida por inteiro, e não pode aparecer como
        // cortada nem oferecer desbloqueio de coisa nenhuma.
        parcial = Boolean(data.next_max_id);
        break;
      }

      const proximo = data.next_max_id ? String(data.next_max_id) : '';
      if (!proximo || cursosVistos.has(proximo)) {
        // Cursor repetido é fim de lista com defeito, não convite a insistir.
        break;
      }
      cursosVistos.add(proximo);
      maxId = proximo;

      /*
       * O ponto é oferecido DEPOIS de o cursor avançar, e não antes: ele diz
       * "tudo até aqui está lido, peça a próxima a partir deste cursor". Fora
       * de ordem, uma página voltaria a ser pedida na retomada e as pessoas
       * dela entrariam duas vezes.
       */
      if (aoAvancar && page % PAGINAS_POR_PONTO === 0) {
        await aoAvancar(ponto());
      }

      await pace(page);
    }
  } catch (error) {
    /*
     * O QUE JÁ CUSTOU REQUISIÇÃO VAI JUNTO DO ERRO. Quem chamou decide se
     * guarda; aqui só não se joga fora.
     *
     * A exceção é a retomada que caiu na primeira página SEM o Instagram
     * recusar a conta: aí o suspeito é o cursor guardado, e devolver o mesmo
     * ponto faria toda tentativa futura bater na mesma pedra. `null` diz
     * "descarte o que estava guardado". Recusa da CONTA (verificação,
     * desacelerar, bloqueio, sessão caída) é outra história, o cursor continua
     * bom, e é justamente aí que perder milhares de perfis lidos seria o
     * defeito que esta função existe para não ter.
     */
    if (error && typeof error === 'object' && !('ponto' in error)) {
      error.ponto = (primeiraDaRetomada && error instanceof EndpointError) ? null : ponto();
    }
    throw error;
  }

  /*
   * O ponto final vai junto do resultado. Quem chamou precisa dele para gravar
   * "esta lista está fechada", reler `followers` inteira só porque `following`
   * caiu no meio seria gastar centenas de requisições contra uma conta que o
   * Instagram acabou de interromper.
   */
  const final = { ...ponto(), pessoas: out, completa: true };
  return { ...coletaDoPonto(final), ponto: final };
}

// --- Descobrir perfis de um nicho -----------------------------------------
//
// A busca por nicho (24/08/2026) lê DUAS coisas que o resto do arquivo não
// lia: a lista de "seguindo" de OUTRAS pessoas, e o perfil de quem aparece
// nelas. As decisões — quem vira semente, o que conta ponto — estão em
// `nicho.js`, que é lógica pura e tem teste. Aqui ficam só as requisições.
//
// POR QUE A LISTA DOS OUTROS, e não uma rota de "sugestões": porque
// `/api/v1/friendships/{pk}/following/` é a MESMA rota que a extensão já usa
// para você, apontada para outro id. Ela é a única fonte de descoberta que este
// projeto pode afirmar que funciona — as rotas de sugestão do aplicativo
// (`discover/chaining/`) são da família que responde "useragent mismatch" ou
// 404 ao navegador, exatamente como `show_many/` e `besties/`. Construir o
// recurso sobre uma rota não verificada seria repetir o erro que já custou
// duas investigações neste arquivo.
//
// E POR QUE UMA PÁGINA POR SEMENTE: as listas do Instagram vêm da mais recente
// para a mais antiga, então a primeira página é quem a pessoa passou a seguir
// há menos tempo — o interesse mais atual, que é justamente o que se procura
// num nicho. Ler a lista inteira de oitenta pessoas seriam milhares de
// requisições, que é o volume que faz o Instagram pedir verificação.

/** A pausa entre leituras, para quem orquestra uma busca de fora. */
async function pausaDeLeitura(n = 1) {
  await pace(n);
}

/*
 * Uma página do "seguindo" de outra pessoa.
 *
 * Usa o formato de lista JÁ MEMORIZADO pela sincronização e não cascateia entre
 * os três: numa busca são dezenas de perfis, e um perfil que não abre gastaria
 * três requisições mais o diagnóstico para dizer o que a primeira já disse. Se
 * o formato ainda não foi descoberto nesta sessão, a primeira semente paga o
 * preço normal (`fetchPage`) e as outras aproveitam a memória.
 */
async function paginaDeTerceiro(kind, pk, csrf, maxId) {
  if (!formatoLista) {
    return fetchPage(kind, pk, csrf, maxId);
  }

  const path = montarPathLista(kind, pk, formatoLista, maxId);
  const res = await apiGet(path, csrf);
  const texto = await res.text();
  const data = comoJson(texto);

  // Recusa da conta antes de tudo — com `deTerceiro`, que é o que impede um
  // perfil privado de virar "sua sessão expirou".
  const recusa = recusaDaConta(res, data, { deTerceiro: true });
  if (recusa) throw recusa;

  if (!data) {
    // 200 sem JSON continua significando o que sempre significou aqui: o
    // caminho, e não a pessoa. Quem chama conta quantos vieram seguidos — vários
    // em sequência é rota morta, e aí a busca inteira para.
    const html = texto.trimStart().startsWith('<');
    throw new EndpointError(`a lista de ${kind} de ${pk} respondeu HTTP ${res.status} `
      + `com ${html ? 'HTML' : texto.length + ' bytes'} em vez de JSON.`);
  }

  if (data.status !== 'ok') {
    throw new PerfilFechadoError(data.message || 'O Instagram não devolveu a lista deste perfil.');
  }

  return data;
}

/**
 * Uma lista de outra pessoa: `'following'` (quem ela segue) ou `'followers'`
 * (quem a segue). Uma página por padrão — ver o comentário da seção.
 *
 * As DUAS existem porque servem a coisas diferentes numa busca por nicho: quem
 * um perfil do ramo SEGUE são, em boa parte, outros perfis do ramo; quem o
 * SEGUE é o público daquele assunto. Ler só uma delas deixava metade do nicho
 * invisível.
 *
 * @param {'following'|'followers'} kind
 * @param {string} pk       o id do perfil a ler
 * @param {string} csrf     reserva; o token é relido do cookie a cada chamada
 * @param {{paginas?: number}} opcoes
 */
async function listaDeTerceiro(kind, pk, csrf, { paginas = 1 } = {}) {
  const out = [];
  let maxId = null;

  for (let pagina = 1; pagina <= paginas; pagina += 1) {
    const data = await paginaDeTerceiro(kind, pk, csrf, maxId);

    for (const u of data.users || []) {
      out.push({
        pk: String(u.pk),
        username: u.username || '',
        full_name: u.full_name || '',
        is_private: Boolean(u.is_private),
        is_verified: Boolean(u.is_verified),
        profile_pic_url: u.profile_pic_url || '',
      });
    }

    maxId = data.next_max_id ? String(data.next_max_id) : '';
    if (!maxId) break;
    if (pagina < paginas) await pace(pagina);
  }

  return out;
}

/** Atalho para a lista mais usada — e o nome pelo qual os testes a conhecem. */
async function seguindoDe(pk, csrf, opcoes) {
  return listaDeTerceiro('following', pk, csrf, opcoes);
}

/*
 * Onde a pessoa diz que está, quando ela diz.
 *
 * Procura por NOME de campo, e não por um caminho fixo, pelo mesmo motivo de
 * `contagemDeBesties`: esses campos só existem em conta profissional, mudam de
 * lugar entre a resposta do aplicativo e a da web, e já mudaram de nome antes.
 * `business_address_json` é uma STRING com JSON dentro — não é engano de
 * leitura, é como o Instagram manda.
 *
 * Isto é o endereço que a PRÓPRIA CONTA publicou no perfil, não localização
 * inferida: a extensão não olha IP, não olha GPS e não tem como. Quando não há
 * nada publicado, a busca cai para o que estiver escrito na bio — que também é
 * texto que a pessoa escolheu publicar.
 */
function enderecoDoPerfil(user) {
  if (!user || typeof user !== 'object') return '';

  const partes = [];

  const bruto = user.business_address_json;
  if (typeof bruto === 'string' && bruto.includes('{')) {
    try {
      const endereco = JSON.parse(bruto);
      for (const campo of ['street_address', 'city_name', 'region_name', 'zip_code']) {
        if (endereco[campo]) partes.push(String(endereco[campo]));
      }
    } catch {
      // Endereço ilegível não pode derrubar a leitura do perfil inteiro.
    }
  }

  if (!partes.length) {
    for (const campo of ['address_street', 'city_name', 'zip']) {
      if (user[campo]) partes.push(String(user[campo]));
    }
  }

  return partes.join(', ');
}

/*
 * As duas maneiras de pedir um perfil, na ordem em que se tenta.
 *
 * A do aplicativo vem primeiro AQUI, ao contrário da regra geral do arquivo,
 * por um motivo concreto: é a rota que `currentUser()` já usa todo dia e
 * responde, e ela aceita o `pk` — que é o que a busca tem em mãos. A web
 * precisa do @, que também temos, e fica como reserva. A que responder é
 * memorizada, como nos outros caminhos deste arquivo.
 */
const FONTES_PERFIL = [
  {
    nome: 'aplicativo',
    path: ({ pk }) => (pk ? `/api/v1/users/${pk}/info/` : ''),
    extrair: (d) => d?.user,
  },
  {
    nome: 'web',
    path: ({ username }) => (username
      ? `/api/v1/users/web_profile_info/?username=${encodeURIComponent(username)}`
      : ''),
    extrair: (d) => d?.data?.user,
  },
];

let fontePerfil = null;

/**
 * O perfil de alguém: bio, categoria e endereço declarado.
 * Custa UMA requisição — é a parte cara da busca, e por isso ela só acontece
 * para os melhores candidatos da peneira barata.
 */
async function perfilDe({ pk, username }, csrf) {
  const candidatas = fontePerfil
    ? [fontePerfil, ...FONTES_PERFIL.filter((f) => f !== fontePerfil)]
    : FONTES_PERFIL;

  let ultimo = null;

  for (const fonte of candidatas) {
    const path = fonte.path({ pk, username });
    if (!path) continue;

    const res = await apiGet(path, csrf);
    const texto = await res.text();
    const data = comoJson(texto);

    const recusa = recusaDaConta(res, data, { deTerceiro: true });
    // Perfil que não abre é resposta final: tentar a outra fonte com a mesma
    // conta privada só gastaria a segunda requisição para ouvir o mesmo não.
    if (recusa instanceof PerfilFechadoError) throw recusa;
    if (recusa) throw recusa;

    const user = fonte.extrair(data);
    if (!user) {
      ultimo = new EndpointError(`o perfil (${fonte.nome}) respondeu HTTP ${res.status} `
        + `sem os dados da conta.`);
      fontePerfil = null;
      continue;
    }

    fontePerfil = fonte;

    return {
      pk: String(user.pk || user.id || pk || ''),
      username: user.username || username || '',
      full_name: user.full_name || '',
      bio: user.biography || '',
      categoria: user.category || user.category_name || user.business_category_name || '',
      endereco: enderecoDoPerfil(user),
      seguidores: Number.isFinite(user.follower_count)
        ? user.follower_count
        : (Number.isFinite(user.edge_followed_by?.count) ? user.edge_followed_by.count : null),
      is_private: Boolean(user.is_private),
      is_verified: Boolean(user.is_verified),
      profile_pic_url: user.profile_pic_url || '',
    };
  }

  throw ultimo || new EndpointError('nenhuma rota de perfil respondeu.');
}

/*
 * A BUSCA DO PRÓPRIO INSTAGRAM, por texto (24/08/2026).
 *
 * Nasceu de um caso que a busca por rede não tinha como resolver: procurar uma
 * PESSOA ("tais") devolvia nada. E não era defeito da régua — era a fonte. Os
 * candidatos vinham só do que a sua rede segue, então quem ninguém da sua rede
 * segue simplesmente não existia para a busca, por mais que o nome batesse.
 *
 * Aqui é o contrário: uma requisição pergunta ao índice do Instagram inteiro
 * quem responde por aquele texto. Barato (uma chamada por termo) e é
 * exatamente o que a lupa do aplicativo faz.
 *
 * MAS ELA É EXTRA, NÃO A BASE — e a diferença importa. As duas primeiras
 * variantes são caminhos que este projeto NÃO pode afirmar que respondem à
 * sessão do navegador (a família `fbsearch`/`search` é do aplicativo, e é
 * justamente a que já morreu em `show_many/` e `besties/`). Por isso, quando
 * nenhuma responder, esta função devolve LISTA VAZIA em vez de erro: a busca
 * continua pela rede, que é a fonte que se sabe que funciona. O que ela nunca
 * engole é recusa da CONTA — verificação e "desacelere" sobem como em todo o
 * resto do arquivo.
 */
const VARIANTES_BUSCA = [
  {
    nome: 'web topsearch',
    path: (q) => `/api/v1/web/search/topsearch/?context=blended&query=${q}&include_reel=false`,
  },
  { nome: 'fbsearch', path: (q) => `/api/v1/fbsearch/topsearch/?context=blended&query=${q}` },
  { nome: 'users/search', path: (q) => `/api/v1/users/search/?q=${q}&count=30` },
];

let varianteBusca = null;

/*
 * As respostas vêm em dois formatos: `users: [{ user: {...} }]` (topsearch, que
 * mistura perfis, lugares e hashtags numa resposta só) e `users: [{...}]`
 * (users/search). Ler os dois é uma linha; escolher um e torcer seria mais uma
 * fonte morrendo em silêncio.
 */
function pessoasDaBusca(data) {
  const brutos = Array.isArray(data?.users) ? data.users : [];
  const saida = [];

  for (const item of brutos) {
    const u = item?.user || item;
    if (!u || !u.pk || !u.username) continue;
    saida.push({
      pk: String(u.pk),
      username: u.username,
      full_name: u.full_name || '',
      is_private: Boolean(u.is_private),
      is_verified: Boolean(u.is_verified),
      profile_pic_url: u.profile_pic_url || '',
    });
  }

  return saida;
}

/**
 * Perfis que o Instagram devolve para um texto. Lista vazia quando nenhuma das
 * variantes responde — ver o comentário da seção.
 */
async function buscarPorTexto(termo, csrf) {
  const q = encodeURIComponent(String(termo || '').trim());
  if (!q) return [];

  const candidatas = varianteBusca
    ? [varianteBusca, ...VARIANTES_BUSCA.filter((v) => v !== varianteBusca)]
    : VARIANTES_BUSCA;

  for (const variante of candidatas) {
    const res = await apiGet(variante.path(q), csrf);
    const texto = await res.text();
    const data = comoJson(texto);

    // `deTerceiro`: um 403 aqui é a busca recusada, não a sua sessão caindo.
    const recusa = recusaDaConta(res, data, { deTerceiro: true });
    if (recusa && !(recusa instanceof PerfilFechadoError)) throw recusa;

    const pessoas = data ? pessoasDaBusca(data) : [];
    if (pessoas.length) {
      varianteBusca = variante;
      return pessoas;
    }

    // Resposta boa e vazia é resposta: o termo não achou ninguém, e trocar de
    // variante para ouvir o mesmo vazio só gastaria requisição.
    if (data && data.status === 'ok') {
      varianteBusca = variante;
      return [];
    }

    varianteBusca = null;
    console.info(`[Mútuo] busca por texto (${variante.nome}) não respondeu: HTTP ${res.status}.`);
  }

  return [];
}


  window.__mutuoMotor = { currentUser, collect, relacaoUmAUm, amostrar, coletaDoPonto, deixarDeSeguir, conferirAntesDeDeixar, paraCsv, paraJson, nomeDoArquivo, compararBases, juntarHistorico, coletarBesties, definirBestie, RITMO, TETO_24H, MAX_ACOES_POR_JANELA, JANELA_MS, intervaloEntreAcoes, toca, segundosPara, tempoEmTexto, situacaoDaConta, deveRegistrar, ActionBlockedError, RateLimitError, ChallengeError, NotLoggedInError, EndpointError, TIPOS, RITMO_CLOSE, CLOSE_POR_ACAO };
})();

;
(function () {
  'use strict';
  if (window.__mutuoLicenca) return;
  // O chrome.storage.local que o licenca.js espera, sobre o GM.getValue. Sem
  // o Userscripts (na simulação), fica em memória: na dúvida, FREE.
  const memoria = {};
  const temGM = typeof GM !== 'undefined' && GM.getValue && GM.setValue && GM.deleteValue;
  const chrome = { storage: { local: {
    async get(nome) { return { [nome]: temGM ? await GM.getValue(nome) : memoria[nome] }; },
    async set(obj) { for (const [k, v] of Object.entries(obj)) { if (temGM) await GM.setValue(k, v); else memoria[k] = v; } },
    async remove(nome) { if (temGM) await GM.deleteValue(nome); else delete memoria[nome]; },
  } } };

/*
 * Verificação do recibo do PRO — o lado da extensão.
 *
 * O servidor (`netlify/functions/licenca.mjs`) assina um recibo curto quando a
 * chave de licença é válida. Aqui ele é conferido com a chave PÚBLICA, que não
 * é segredo: ela só permite verificar, nunca produzir. É por isso que a
 * assinatura é assimétrica — com HMAC, a chave capaz de emitir recibos estaria
 * dentro da extensão, e dentro da extensão não existe segredo.
 *
 * O QUE ISTO IMPEDE: alguém editar o recibo guardado no `chrome.storage` para
 * esticar a validade ou se dar PRO. Sem a chave privada, a assinatura não
 * acompanha a edição.
 *
 * O QUE ISTO NÃO IMPEDE, e é bom não fingir que impede: quem editar o próprio
 * `app.js` pula a verificação inteira. Extensão é JavaScript na máquina de quem
 * usa. O objetivo é que burlar exija saber programar — a R$ 5,90/mês, isso
 * basta; proteção além disso custaria mais do que o desvio.
 */

/*
 * A chave pública do par em uso, gerado em 15/08/2026 por
 * `ferramentas/gerar-chaves.mjs`. A privada correspondente vive só nas
 * variáveis de ambiente do Netlify.
 *
 * Este é o SEGUNDO par: o primeiro foi descartado no mesmo dia porque a chave
 * privada apareceu na saída de um `netlify env:set` (o comando ecoa o valor
 * recebido) e, com ela, qualquer pessoa emitiria recibos válidos. Trocar custou
 * nada porque ainda não havia cliente algum — depois da primeira venda,
 * trocar significa que todo mundo precisa reativar.
 */
const CHAVE_PUBLICA = `-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1+c4cTuokEt23TjoexPiiqbMysbx
KMCm1l8T580q13h6jrG/hvg/kSbVvBHbToniGdYOhdljh/1JvKeCCpE/vw==
-----END PUBLIC KEY-----`;

function bytesDoPem(pem) {
  const limpo = String(pem).replace(/-----[^-]+-----/g, '').replace(/\s+/g, '');
  const bin = atob(limpo);
  return Uint8Array.from(bin, (c) => c.charCodeAt(0));
}

function deBase64Url(texto) {
  const bin = atob(String(texto).replace(/-/g, '+').replace(/_/g, '/'));
  return Uint8Array.from(bin, (c) => c.charCodeAt(0));
}

/**
 * Confere o recibo e devolve o conteúdo, ou `null` se ele não presta.
 *
 * `null` cobre tudo que dá errado — assinatura inválida, formato estranho,
 * conteúdo que não é JSON. Quem chama trata como "não é PRO", que é a resposta
 * segura para qualquer defeito aqui: na dúvida, FREE.
 *
 * @param {string} recibo   o que o servidor devolveu
 * @param {string} publica  injetável para o teste usar um par próprio
 */
async function verificarRecibo(recibo, publica = CHAVE_PUBLICA) {
  const [corpo, assinatura] = String(recibo || '').split('.');
  if (!corpo || !assinatura) return null;

  try {
    const chave = await crypto.subtle.importKey(
      'spki', bytesDoPem(publica),
      { name: 'ECDSA', namedCurve: 'P-256' }, false, ['verify']
    );

    const ok = await crypto.subtle.verify(
      { name: 'ECDSA', hash: 'SHA-256' }, chave,
      deBase64Url(assinatura), new TextEncoder().encode(corpo)
    );
    if (!ok) return null;

    return JSON.parse(new TextDecoder().decode(deBase64Url(corpo)));
  } catch {
    return null;
  }
}

/**
 * O recibo está valendo AGORA?
 *
 * A validade curta é o que faz cancelamento e estorno terem efeito: passado o
 * prazo, a extensão precisa perguntar de novo ao servidor. Enquanto vale, ela
 * funciona offline — quem pagou não fica na mão se o servidor cair ou a
 * internet faltar.
 */
function reciboValido(conteudo, agora = Date.now()) {
  return Boolean(conteudo && conteudo.plano === 'pro' && Number(conteudo.ate) > agora);
}


/*
 * O plano de quem está usando: FREE ou PRO.
 *
 * A extensão guarda duas coisas: a CHAVE que a pessoa colou e o RECIBO que o
 * servidor assinou. O recibo é o que vale no dia a dia — ele diz "é PRO até tal
 * data" e é conferido com a chave pública embutida (`recibo.js`), então editá-lo
 * no `chrome.storage` não adianta.
 *
 * A chave fica guardada para RENOVAR sozinha quando o recibo vence. Sem isso, a
 * pessoa teria que colar a chave de novo a cada poucos dias, o que ninguém
 * aceita — e com isso, um cancelamento ou estorno tem efeito em dias, porque a
 * renovação passa pelo servidor de novo.
 *
 * O recibo também diz QUANDO A LICENÇA VENCE (`expira`), que é outra data e
 * outro assunto: é dela que sai o aviso "seu PRO vence em 3 dias". Sem esse
 * campo, a extensão só descobriria o vencimento depois de já ter perdido o
 * PRO — e a pessoa veria o produto desligar sem nunca ter sido avisada, que é
 * como se perde uma renovação que ela faria de bom grado.
 *
 * O que NUNCA sai daqui para o servidor: @, seguidores, listas. Só a chave.
 */


const STORAGE = 'ig_manager_licenca';

/*
 * O endereço do servidor de licença.
 *
 * Fixo no código porque é ele que a CSP do manifest libera em `connect-src` —
 * um endereço configurável seria uma porta para apontar a extensão a um
 * servidor que responde "sim" para qualquer chave.
 */
const SERVIDOR = 'https://usemutuo.com.br/.netlify/functions/licenca';

/*
 * De quanto em quanto tempo tentar renovar depois que o recibo vence.
 *
 * Sem esta espera, uma extensão aberta o dia todo com o servidor fora do ar
 * tentaria a cada render — dezenas de requisições por minuto contra um serviço
 * que já não responde.
 */
const ESPERA_APOS_FALHA = 60 * 60 * 1000; // 1 hora

async function carregarLicenca() {
  const guardado = await chrome.storage.local.get(STORAGE);
  const dados = guardado[STORAGE] || {};
  return {
    chave: dados.chave || '',
    recibo: dados.recibo || '',
    /*
     * Quando a última consulta FALHOU — não "quando foi a última consulta".
     *
     * A diferença já custou um defeito: o campo se chamava `ultimaTentativa` e
     * era gravado também no SUCESSO, enquanto quem o lia usava como "faz pouco
     * que falhou, não insista". Uma ativação bem-sucedida passava a bloquear a
     * consulta da hora seguinte — inclusive a que descobre o vencimento —, e a
     * tela dizia "não consegui confirmar a renovação" sem ter tentado nada.
     */
    ultimaFalha: dados.ultimaFalha || 0,
  };
}

async function salvarLicenca(licenca) {
  await chrome.storage.local.set({ [STORAGE]: licenca });
}

async function esquecerLicenca() {
  await chrome.storage.local.remove(STORAGE);
}

/**
 * Pergunta ao servidor se a chave vale e devolve o recibo assinado.
 *
 * Os erros são separados por CAUSA porque a tela responde diferente a cada uma:
 * chave errada é digitação (a pessoa corrige), licença vencida é cobrança (ela
 * precisa renovar), e falha de rede não é culpa dela nenhuma.
 *
 * @returns {{ok: true, recibo: string} | {ok: false, erro: string, mensagem: string}}
 */
async function consultarServidor(chave) {
  /*
   * Sem servidor configurado, responde na hora. Tentar `fetch('')` daria erro
   * de rede — a mesma mensagem de "verifique sua conexão" que aparece quando a
   * internet caiu —, e a pessoa ficaria tentando de novo achando que é com ela.
   */
  if (!SERVIDOR) {
    return {
      ok: false,
      erro: 'sem_servidor',
      mensagem: 'A ativação por chave ainda não está disponível nesta versão.',
    };
  }

  let res;
  try {
    res = await fetch(SERVIDOR, {
      method: 'POST',
      headers: { 'content-type': 'application/json' },
      body: JSON.stringify({ chave }),
    });
  } catch {
    return {
      ok: false,
      erro: 'rede',
      mensagem: 'Não consegui falar com o servidor. Verifique sua conexão e tente de novo.',
    };
  }

  let corpo = null;
  try {
    corpo = await res.json();
  } catch { /* resposta sem JSON cai no tratamento abaixo */ }

  if (res.ok && corpo?.recibo) return { ok: true, recibo: corpo.recibo };

  /*
   * O `status` vem junto porque "não vale" tem dois significados muito
   * diferentes: uma licença REVOGADA (estorno) acabou para sempre, e uma
   * VENCIDA volta a valer no minuto em que o pagamento entrar. Quem decide o
   * que fazer com a chave guardada é `planoAtual`, e sem este campo ele não
   * teria como separar os dois.
   */
  return {
    ok: false,
    erro: corpo?.erro || 'servidor',
    status: corpo?.status || '',
    mensagem: corpo?.mensagem || 'O servidor não conseguiu confirmar esta chave agora.',
  };
}

/**
 * Ativa uma chave: consulta, confere a assinatura e guarda.
 *
 * A conferência da assinatura acontece AQUI, e não só no servidor, porque é ela
 * que garante que o recibo guardado veio de quem tem a chave privada. Sem isso,
 * bastaria responder `{"recibo":"qualquer coisa"}` de um servidor forjado.
 */
async function ativar(chave, agora = Date.now()) {
  const resposta = await consultarServidor(chave);
  if (!resposta.ok) return resposta;

  const conteudo = await verificarRecibo(resposta.recibo);
  if (!reciboValido(conteudo, agora)) {
    return {
      ok: false,
      erro: 'recibo',
      mensagem: 'O servidor respondeu algo que não consegui verificar. Tente de novo em alguns minutos.',
    };
  }

  // Deu certo: não há falha a espaçar. Zerar é o que devolve à extensão o
  // direito de perguntar de novo assim que houver motivo.
  await salvarLicenca({ chave, recibo: resposta.recibo, ultimaFalha: 0 });
  return { ok: true, conteudo };
}

/*
 * A partir de quantos dias avisar que a licença está para vencer.
 *
 * Sete é o mesmo prazo do recibo, e não por acaso: o recibo é a única coisa que
 * traz a data do vencimento, e ele é renovado no máximo a cada sete dias. Um
 * aviso mais longo que isso mostraria uma contagem que pode já ter sido
 * renovada no servidor sem a extensão saber.
 */
const DIAS_DE_AVISO = 7;

const DIA = 24 * 60 * 60 * 1000;

/**
 * A LICENÇA passou da data? (não confundir com o recibo, que é `reciboValido`)
 *
 * `null` é o vitalício e `undefined` é o recibo emitido por um servidor antigo,
 * que ainda não mandava o campo. Os dois respondem "não venceu": tratar a falta
 * do dado como vencimento derrubaria para FREE justamente quem pagou mais caro.
 */
function licencaVencida(conteudo, agora = Date.now()) {
  const quando = conteudo?.expira;
  if (quando === null || quando === undefined) return false;
  return Number(quando) <= agora;
}

const emDias = (dias) => (dias === 1 ? 'amanhã' : `em ${dias} dias`);
const dataBr = (ms) => new Date(Number(ms)).toLocaleDateString('pt-BR');

/**
 * O que dizer a quem está com o PRO perto de acabar — ou `null` quando não há
 * nada a dizer (vitalício, prazo ainda longe, recibo velho sem a data).
 *
 * É lógica PURA e mora aqui, e não na tela, porque é regra de licença: quando
 * avisar, com que texto, e com qual saída. A tela só pinta o que vier.
 *
 * `faixa` separa o que merece uma faixa no topo do que basta aparecer no selo
 * do plano. Quem cancelou já sabe que cancelou — repetir isso numa faixa por
 * três semanas ensina a ignorar faixas, e a que importa (o vencimento chegando)
 * viria no mesmo lugar já gasto.
 *
 * @param {object|null} conteudo  o recibo já verificado
 */
function avisoDeRenovacao(conteudo, agora = Date.now()) {
  const quando = conteudo?.expira;
  if (quando === null || quando === undefined) return null;

  const dias = Math.ceil((Number(quando) - agora) / DIA);
  const data = dataBr(quando);

  /*
   * A data passou e o PRO continua ligado: é o recibo ainda valendo enquanto o
   * servidor não confirma a renovação. Não é hora de dizer "acabou" (pode ter
   * renovado e a notícia não ter chegado) nem de ficar calado — o texto conta
   * exatamente o que se sabe.
   */
  if (dias <= 0) {
    return {
      tipo: 'atrasada',
      dias: 0,
      faixa: true,
      curto: 'renovação não confirmada',
      texto: `A sua licença venceu em ${data} e eu não consegui confirmar a renovação. `
        + 'O PRO segue ligado por enquanto; se a cobrança não passou, renove para não perdê-lo.',
      acao: 'Renovar',
    };
  }

  /*
   * Cancelada é o único caso em que a data é o FIM, e não uma cobrança que vai
   * acontecer sozinha. Por isso o texto é outro e a saída também: aqui a pessoa
   * precisa assinar de novo, não esperar.
   */
  if (conteudo.situacao === 'cancelada') {
    return {
      tipo: 'cancelada',
      dias,
      faixa: dias <= DIAS_DE_AVISO,
      curto: `até ${data}`,
      texto: `A sua assinatura foi cancelada. O PRO vale até ${data} (${emDias(dias)}) `
        + 'e depois a extensão volta para o plano FREE.',
      acao: 'Assinar de novo',
    };
  }

  if (dias > DIAS_DE_AVISO) return null;

  return {
    tipo: 'vence',
    dias,
    faixa: true,
    curto: `vence ${emDias(dias)}`,
    texto: `O seu PRO vence ${emDias(dias)} (${data}). A assinatura renova sozinha quando a `
      + 'cobrança passa — se ela falhar, a extensão volta para o plano FREE.',
    acao: 'Ver os planos',
  };
}

/**
 * O plano de agora — chamado toda vez que a extensão abre.
 *
 * Enquanto o recibo vale, não fala com o servidor: quem pagou continua
 * funcionando offline, e o servidor não recebe uma chamada por abertura de aba.
 * Vencido, tenta renovar com a chave guardada.
 *
 * A EXCEÇÃO é a data da licença ter passado. Aí o recibo, mesmo dentro do
 * prazo, está falando do passado: a assinatura ou renovou (e a data mudou no
 * servidor) ou acabou. Perguntar é o que evita os dois enganos possíveis —
 * mostrar "venceu" para quem já pagou de novo, e dar até uma semana de PRO
 * depois do fim para quem parou de pagar.
 *
 * Na dúvida, FREE. Só um recibo verificado e dentro do prazo libera o PRO. Mas
 * "na dúvida" é o servidor DIZER que não vale — não é o servidor estar fora do
 * ar: nesse caso o recibo que ainda está no prazo segura o PRO, que é
 * exatamente a folga para a qual ele existe.
 *
 * @returns {{pro: boolean, motivo: string, conteudo?: object, mensagem?: string}}
 */
async function planoAtual(agora = Date.now()) {
  const licenca = await carregarLicenca();
  if (!licenca.chave && !licenca.recibo) return { pro: false, motivo: 'sem licenca' };

  const conteudo = await verificarRecibo(licenca.recibo);
  const noPrazo = reciboValido(conteudo, agora);

  if (noPrazo && !licencaVencida(conteudo, agora)) {
    return { pro: true, motivo: 'recibo valido', conteudo };
  }

  if (!licenca.chave) return { pro: false, motivo: 'recibo vencido sem chave' };

  // Não insiste em servidor fora do ar a cada abertura. Quem ainda tem recibo
  // no prazo não é derrubado enquanto a próxima tentativa não chega.
  if (agora - licenca.ultimaFalha < ESPERA_APOS_FALHA) {
    return noPrazo
      ? { pro: true, motivo: 'renovacao nao confirmada', conteudo }
      : { pro: false, motivo: 'aguardando nova tentativa' };
  }

  const resultado = await ativar(licenca.chave, agora);
  if (resultado.ok) return { pro: true, motivo: 'renovado', conteudo: resultado.conteudo };

  /*
   * Falhou: guarda a tentativa para espaçar a próxima. A CHAVE fica — só some
   * quando o servidor diz que ela não vale mais (revogada ou inexistente), e
   * não quando a internet caiu.
   */
  await salvarLicenca({ ...licenca, ultimaFalha: agora });

  /*
   * ESQUECER A CHAVE É DEFINITIVO, então só acontece quando não há volta:
   * a licença foi revogada (estorno, disputa) ou não existe mais.
   *
   * Vencimento NÃO entra nessa lista, e foi assim que isto começou errado:
   * quem pagasse com três dias de atraso voltava a ter licença válida no
   * servidor, mas a extensão já tinha apagado a chave — e a pessoa precisava
   * caçar o e-mail da compra para colar de novo o que nunca deixou de ser
   * dela. Guardada a chave, o PRO volta sozinho na abertura seguinte.
   */
  const semVolta = resultado.erro === 'nao_encontrada'
    || (resultado.erro === 'invalida' && resultado.status === 'revogada');

  if (semVolta) {
    await esquecerLicenca();
    return { pro: false, motivo: resultado.erro, mensagem: resultado.mensagem };
  }

  if (resultado.erro === 'invalida') {
    /*
     * O RECIBO É DESCARTADO, mesmo ainda no prazo — e este é o par da regra
     * acima, não uma exceção a ela.
     *
     * O servidor acabou de dizer que a licença não vale; guardar um papel que
     * afirma o contrário faria o PRO voltar na abertura seguinte, porque
     * dentro da espera entre tentativas quem responde é o recibo. A extensão
     * ficaria piscando entre PRO e FREE de hora em hora.
     *
     * A folga do recibo existe para o servidor CALADO (fora do ar, sem
     * internet), não para o servidor que respondeu "não". A chave fica, e é
     * ela que traz o PRO de volta quando o pagamento entrar.
     */
    await salvarLicenca({ chave: licenca.chave, recibo: '', ultimaFalha: agora });
    return {
      pro: false,
      motivo: 'vencida',
      mensagem: `${resultado.mensagem} Assim que o pagamento entrar, o PRO volta `
        + 'sozinho — a chave continua guardada aqui.',
    };
  }

  return noPrazo
    ? { pro: true, motivo: 'renovacao nao confirmada', conteudo, mensagem: resultado.mensagem }
    : { pro: false, motivo: 'falha temporaria', mensagem: resultado.mensagem };
}


  window.__mutuoLicenca = { planoAtual, ativar, avisoDeRenovacao };
})();
;
/*
 * A ponte do Mútuo no iPhone (28/09/2026; pelo Userscripts desde 13/10/2026).
 *
 * No Android, as telas e o Instagram são duas páginas e o app nativo faz a
 * ponte entre elas. No iPhone não há app: o Userscripts roda este arquivo
 * DENTRO da página do Instagram aberta no Safari, no toque do botão do Mútuo,
 * e esta ponte faz o papel do app. Ela oferece as mesmas duas interfaces, com os mesmos nomes:
 *
 *   - `MutuoNativo`, que o executor usa (cookie, evento, versão);
 *   - `MutuoApp`, que as telas usam (entrar, analisar, fechar…).
 *
 * Assim o motor, o executor e as telas são os MESMOS arquivos do Android.
 *
 * A montagem (ferramentas/gerar-iphone.mjs) põe antes desta ponte o motor e
 * depois dela o executor e as telas. As telas ficam numa shadow root, para o
 * CSS do Instagram não mexer nelas nem o delas no Instagram.
 */
(function () {
  'use strict';

  const VERSAO = "iphone-1.3.1";

  // Tocar no botão de novo só reabre as telas: o motor já está na página.
  window.__mutuoJaAberto = false;
  if (window.__mutuoHost) {
    window.__mutuoHost.style.display = 'block';
    if (window.MutuoApp) window.MutuoApp.conta();
    window.__mutuoJaAberto = true;
    return;
  }

  function lerCookie(nome) {
    const achado = document.cookie.split('; ').find((c) => c.startsWith(nome + '='));
    return achado ? decodeURIComponent(achado.slice(nome.length + 1)) : '';
  }

  function logado() {
    return /^\d+$/.test(lerCookie('ds_user_id'));
  }

  function enviar(json) {
    if (typeof window.mutuoEvento === 'function') window.mutuoEvento(json);
  }

  // Onde o executor guarda o ponto da leitura que continua de onde parou: o
  // armazenamento do Userscripts, como a chave. Sem ele (na simulação), memória.
  const memoria = {};
  const temGM = typeof GM !== 'undefined' && GM.getValue && GM.setValue && GM.deleteValue;
  window.__mutuoArmazem = {
    ler: async (k) => (temGM ? GM.getValue(k) : memoria[k]),
    gravar: async (k, v) => { if (temGM) await GM.setValue(k, v); else memoria[k] = v; },
    apagar: async (k) => { if (temGM) await GM.deleteValue(k); else delete memoria[k]; },
  };

  window.MutuoNativo = {
    cookie: (nome) => (nome === 'ds_user_id' || nome === 'csrftoken' ? lerCookie(nome) : ''),
    evento: (json) => enviar(json),
    versao: () => VERSAO,
  };

  window.MutuoApp = {
    estado: () => JSON.stringify({
      logado: logado(),
      versao: VERSAO,
      fecharSempre: true,
      textoSair: 'Fechar',
      notaEntrar: 'Toque em Entrar, faça o login no Instagram e depois toque no botão do Mútuo de novo. O Mútuo não vê a sua senha, e nada sai do seu telefone.',
    }),
    entrar() {
      window.__mutuoHost.style.display = 'none';
      if (!/^\/accounts\/login/.test(location.pathname)) location.href = '/accounts/login/';
    },
    conta() {
      if (window.__mutuoConta) window.__mutuoConta();
    },
    temPonto() {
      return window.__mutuoTemPonto ? window.__mutuoTemPonto() : Promise.resolve(false);
    },
    analisar() {
      if (window.__mutuoRodar) window.__mutuoRodar();
    },
    // No iPhone o botão do topo é "Fechar": esconde as telas e deixa a conta
    // do Instagram como está. Sair da conta é pelo próprio Instagram.
    sair() {
      window.__mutuoHost.style.display = 'none';
    },
    abrirPerfil(usuario) {
      if (!/^[A-Za-z0-9._]{1,30}$/.test(usuario || '')) return;
      window.open('https://www.instagram.com/' + usuario + '/', '_blank');
    },
    // Os planos abrem no Safari, numa aba nova: a compra é na Kiwify, pela
    // página de sempre, e o Instagram fica onde estava.
    abrirPlanos() {
      window.open('https://usemutuo.com.br/pro', '_blank');
    },
    // O plano e a ativação da chave (etapa 1.2, 13/10/2026). Quem decide é o
    // licenca.js da extensão (window.__mutuoLicenca): na dúvida, FREE. As
    // duas respondem por Promise, ao contrário do resto desta ponte.
    async plano() {
      const L = window.__mutuoLicenca;
      if (!L) return { pro: false, motivo: 'sem licenca' };
      try {
        const p = await L.planoAtual();
        return { pro: p.pro, motivo: p.motivo, mensagem: p.mensagem || '', aviso: p.conteudo ? L.avisoDeRenovacao(p.conteudo) : null };
      } catch (e) {
        return { pro: false, motivo: 'erro', mensagem: 'Não consegui conferir o plano agora.' };
      }
    },
    async ativarChave(chave) {
      const L = window.__mutuoLicenca;
      if (!L) return { ok: false, mensagem: 'A ativação não está disponível nesta versão.' };
      try {
        const r = await L.ativar(String(chave || '').trim().toUpperCase());
        return r.ok ? { ok: true } : { ok: false, mensagem: r.mensagem || 'Não consegui ativar esta chave.' };
      } catch (e) {
        return { ok: false, mensagem: 'Não consegui ativar agora. Tente de novo em alguns minutos.' };
      }
    },
    // Deixar de seguir (1.0.0, 13/10/2026). Quem decide e freia é o
    // executor; aqui só o recado. Respondem por Promise, como o plano.
    situacaoDeixar(quantas) {
      return window.__mutuoSituacaoDeixar ? window.__mutuoSituacaoDeixar(quantas) : Promise.resolve(null);
    },
    filaDeixar() {
      return window.__mutuoFilaDeixar ? window.__mutuoFilaDeixar() : Promise.resolve(null);
    },
    deixar(pessoas) {
      if (window.__mutuoDeixar) window.__mutuoDeixar(pessoas);
    },
    continuarDeixar() {
      if (window.__mutuoDeixar) window.__mutuoDeixar(null);
    },
    pararDeixar() {
      if (window.__mutuoPararDeixar) window.__mutuoPararDeixar();
    },
    descartarFila() {
      return window.__mutuoDescartarFila ? window.__mutuoDescartarFila() : Promise.resolve();
    },
    // Close Friends (1.3.0): adicionar ou remover, no ritmo da extensão.
    situacaoClose(quantas) {
      return window.__mutuoSituacaoClose ? window.__mutuoSituacaoClose(quantas) : Promise.resolve(null);
    },
    closeFriends(tipo, pessoas) {
      if (window.__mutuoCloseFriends) window.__mutuoCloseFriends(tipo, pessoas);
    },
    // Histórico (1.2.0): a lista de mudanças guardada, conferida no executor.
    historico() {
      return window.__mutuoHistorico ? window.__mutuoHistorico() : Promise.resolve({ ok: false, eventos: [] });
    },
    // Exportar (1.1.0). Responde por Promise; o arquivo sai no mesmo toque.
    exportar(formato, pessoas, filtro, conta) {
      return window.__mutuoExportar ? window.__mutuoExportar(formato, pessoas, filtro, conta) : Promise.resolve({ ok: false, mensagem: 'Exportar não está disponível nesta versão.' });
    },
    copiar(texto) {
      try { navigator.clipboard.writeText(texto); } catch (e) { /* sem área de transferência */ }
    },
  };

  // O lugar das telas: por cima de tudo, rolando por conta própria.
  const host = document.createElement('div');
  Object.assign(host.style, {
    position: 'fixed', inset: '0', zIndex: '2147483647', overflowY: 'auto',
    webkitOverflowScrolling: 'touch',
  });
  window.__mutuoHost = host;
  window.__mutuoRaiz = host.attachShadow({ mode: 'open' });
  document.documentElement.appendChild(host);
})();

;
/*
 * O executor do Mútuo no Android (28/09/2026).
 *
 * Roda DENTRO da página do Instagram, que fica escondida atrás das telas do
 * app, injetado depois do motor (`motor.js`, gerado de extensao/instagram.js).
 * Não desenha nada: faz a leitura e conta cada passo às telas por eventos
 * (`MutuoNativo.evento`), que o app repassa. Separar assim é o que deixa o
 * Instagram fora da vista: a pessoa só o vê na hora de entrar na conta.
 *
 * A leitura é a do plano FREE da extensão (`lerAteOLimite`, em app.js): uma
 * página de cada lista, a amostra de 50 e a pergunta individual por perfil.
 * No PRO, desde a 1.0.0 (13/10/2026), deixa de seguir: ver o fim do arquivo.
 *
 * O diagnóstico que acompanha o resultado não leva @ nem nome de ninguém.
 */
(function () {
  'use strict';
  if (window.__mutuoRodar || !window.__mutuoMotor) return;

  const M = window.__mutuoMotor;
  const LIMITE_FREE = 50;

  function avisar(evento) {
    try {
      if (window.MutuoNativo) window.MutuoNativo.evento(JSON.stringify(evento));
    } catch (e) {
      // sem ponte (fora do app): não há a quem contar
    }
  }

  function numero(v) {
    return Number.isFinite(v) ? v : null;
  }

  // `ordem` é a posição na coleta, a única noção de tempo que o Instagram dá
  // (as listas vêm da mais recente para a mais antiga): é o "mais recentes" dos
  // filtros do PRO, como em `cruzar` (extensao/app.js).
  function pessoa(p, ordem) {
    return {
      pk: String(p.pk),
      username: String(p.username || ''),
      nome: String(p.full_name || ''),
      foto: String(p.profile_pic_url || ''),
      verificado: Boolean(p.is_verified),
      privado: Boolean(p.is_private),
      ordem: Number.isFinite(ordem) ? ordem : 0,
    };
  }

  function diagnostico(etapas, inicio, fim) {
    const ua = navigator.userAgent;
    return [
      'Mútuo no celular',
      'app: ' + (window.MutuoNativo && window.MutuoNativo.versao ? window.MutuoNativo.versao() : '?'),
      'navegador: ' + (/Chrome\//.test(ua) ? 'chrome ' + ((ua.match(/Chrome\/([\d.]+)/) || [])[1] || '?') : 'safari ' + ((ua.match(/Version\/([\d.]+)/) || [])[1] || '?')),
      'tempo: ' + Math.round((Date.now() - inicio) / 1000) + ' s',
      ...(notaPerfil ? [notaPerfil] : []),
      ...etapas,
      fim,
    ].join('\n');
  }

  /*
   * A conta SEM pedir o perfil (etapa 1.4, 13/10/2026, 0.8.0).
   *
   * No iPhone do dono, `users/{id}/info/` respondeu HTTP 429 em todos os
   * testes, pelas duas identidades (app id de computador e de celular): o
   * diagnóstico da 0.7.0 mostrou "reserva HTTP 429". É a mesma rota que o
   * Radar leva 429 desde 07/10. Insistir nela a cada abertura é pedir para o
   * Instagram endurecer com a conta, então o celular deixou de chamá-la.
   *
   * O id e o csrf vêm do cookie, como no motor. O @ e a foto vêm da própria
   * página: a barra de baixo do Instagram no celular tem o link do seu perfil
   * com a sua foto. Os números, no PRO, vêm da leitura, que CONTA; no FREE
   * ficam sem número, que é "não sei", e não zero.
   */
  let notaPerfil = '';
  function lerCookie(nome) {
    let v = '';
    try { if (window.MutuoNativo) v = String(window.MutuoNativo.cookie(nome) || ''); } catch (e) { v = ''; }
    if (!v) {
      const achado = document.cookie.split('; ').find((c) => c.startsWith(nome + '='));
      v = achado ? decodeURIComponent(achado.slice(nome.length + 1)) : '';
    }
    return v;
  }
  const RESERVADOS = /^(explore|reels|direct|accounts|stories|p|reel|tv|about|legal|developer|web|emails|challenge|session|graphql|api)$/;
  function perfilDaPagina(id) {
    // 1. O link do perfil na barra de baixo: o único link de @ com foto que
    //    fica preso ao pé da tela.
    const alto = window.innerHeight || document.documentElement.clientHeight;
    for (const a of document.querySelectorAll('a[href]')) {
      const m = (a.getAttribute('href') || '').match(/^\/([A-Za-z0-9._]{1,30})\/?$/);
      if (!m || RESERVADOS.test(m[1])) continue;
      const img = a.querySelector('img');
      if (!img) continue;
      const r = a.getBoundingClientRect();
      if (r.height > 0 && r.top > alto - 140) return { username: m[1], foto: img.currentSrc || img.src || '', de: 'barra' };
    }
    // 2. O JSON que a página carrega: o "username" mais perto do seu id.
    try {
      for (const s of document.querySelectorAll('script:not([src])')) {
        const txt = s.textContent || '';
        const k = txt.indexOf(id);
        if (k < 0) continue;
        const janela = txt.slice(Math.max(0, k - 600), k + 600);
        const m = janela.match(/\\?"username\\?"\s*:\s*\\?"([A-Za-z0-9._]{1,30})\\?"/);
        if (m) return { username: m[1], foto: '', de: 'json' };
      }
    } catch (e) { /* sem JSON legível, fica sem @ */ }
    return { username: '', foto: '', de: 'nenhum' };
  }

  async function lerConta() {
    const id = lerCookie('ds_user_id');
    if (!/^\d+$/.test(id)) {
      avisar({ tipo: 'sem-sessao' });
      return null;
    }
    const p = perfilDaPagina(id);
    notaPerfil = 'perfil: da página (' + p.de + '), sem pedido';
    const sessao = { id, csrf: lerCookie('csrftoken'), username: p.username, profilePic: p.foto, totais: { seguidores: null, seguindo: null, closeFriends: null } };
    avisar({ tipo: 'conta', username: sessao.username, foto: sessao.profilePic, seguidores: null, seguindo: null });
    return sessao;
  }

  window.__mutuoConta = function () {
    lerConta().catch((erro) => avisar({ tipo: 'erro', texto: (erro && erro.message) || 'Não consegui ler a sua conta.' }));
  };

  // ---------------------------------------------------------------------------
  // PRO: as duas listas inteiras, e a relação sai do cruzamento (etapa 1.3,
  // 13/10/2026). É o `lerBaseInteira` de extensao/app.js: o mesmo `collect`,
  // no mesmo ritmo, e a leitura continua de onde parou (FB-01). O ponto fica
  // no armazém da ponte (no iPhone, o GM.getValue do Userscripts), vale 24 h e
  // só para a mesma conta, como na extensão.
  // ---------------------------------------------------------------------------
  const PONTO = 'ig_manager_coleta';
  const UM_DIA = 24 * 60 * 60 * 1000;
  const memoria = {};
  const armazem = window.__mutuoArmazem || {
    ler: async (k) => memoria[k],
    gravar: async (k, v) => { memoria[k] = v; },
    apagar: async (k) => { delete memoria[k]; },
  };

  // O plano é conferido AQUI, e não só na tela: o botão é uma linha no
  // DevTools, e a regra da extensão é travar no handler. Na dúvida, FREE.
  async function ehPro() {
    try {
      return Boolean(window.__mutuoLicenca && (await window.__mutuoLicenca.planoAtual()).pro);
    } catch (e) {
      return false;
    }
  }

  async function pontoGuardado(sessao) {
    try {
      const g = await armazem.ler(PONTO);
      if (g && g.conta === sessao.id && Date.now() - g.quando < UM_DIA) return g;
      if (g) await armazem.apagar(PONTO);
    } catch (e) { /* sem ponto guardado, a leitura começa do zero */ }
    return null;
  }

  const fmt = (n) => Number(n).toLocaleString('pt-BR');

  async function lerBaseInteira(sessao, etapas) {
    const guardado = await pontoGuardado(sessao);
    const pontos = { followers: (guardado && guardado.followers) || null, following: (guardado && guardado.following) || null };
    if (guardado) etapas.push('retomada: ' + ['followers', 'following'].map((k) => k + ' ' + ((pontos[k] && pontos[k].pessoas.length) || 0)).join(', '));

    const gravar = async () => {
      // Falhar em guardar progresso não pode derrubar uma leitura que vai bem.
      try { await armazem.gravar(PONTO, { conta: sessao.id, quando: Date.now(), followers: pontos.followers, following: pontos.following }); } catch (e) { etapas.push('ponto não gravado'); }
    };
    const t = sessao.totais || {};
    const ROTULO = { followers: 'Lendo quem segue você…', following: 'Lendo quem você segue…' };
    const TOTAL = { followers: numero(t.seguidores), following: numero(t.seguindo) };
    const BASE = { followers: 4, following: 52 };

    const ler = async (kind) => {
      const jaTenho = pontos[kind];
      if (jaTenho && jaTenho.completa) return M.coletaDoPonto(jaTenho);
      const progresso = (k, lidos) => {
        const total = TOTAL[kind];
        const frac = total ? Math.min(1, lidos / total) : 0;
        avisar({
          tipo: 'progresso',
          texto: ROTULO[kind] + ' ' + fmt(lidos) + (total ? ' de ' + fmt(total) : ''),
          pct: BASE[kind] + Math.round(frac * 44),
        });
      };
      try {
        const coleta = await M.collect(kind, sessao, progresso, {
          retomar: jaTenho,
          aoAvancar: async (ponto) => { pontos[kind] = ponto; await gravar(); },
        });
        pontos[kind] = coleta.ponto;
        await gravar();
        return coleta;
      } catch (erro) {
        if (erro && typeof erro === 'object' && 'ponto' in erro) {
          pontos[kind] = erro.ponto;
          await gravar();
        }
        throw erro;
      }
    };

    const coletaSeguidores = await ler('followers');
    const seguidores = coletaSeguidores.pessoas;
    etapas.push('seguidores: ' + seguidores.length + ' lidos' + (TOTAL.followers ? ' de ' + TOTAL.followers : ''));
    const coletaSeguindo = await ler('following');
    const seguindo = coletaSeguindo.pessoas;
    etapas.push('seguindo: ' + seguindo.length + ' lidos' + (TOTAL.following ? ' de ' + TOTAL.following : ''));
    try { await armazem.apagar(PONTO); } catch (e) { /* o ponto vence sozinho em 24 h */ }

    // O cruzamento de extensao/app.js (`cruzar`): quem você segue e não te
    // segue, quem te segue e você não segue, e quem está nas duas.
    const meSegue = new Set(seguidores.map((p) => String(p.pk)));
    const euSigo = new Set(seguindo.map((p) => String(p.pk)));
    // A ordem do `cruzar`: seguidores primeiro, depois quem só está em seguindo.
    const ordem = new Map();
    for (const p of [...seguidores, ...seguindo]) if (!ordem.has(String(p.pk))) ordem.set(String(p.pk), ordem.size);
    const comOrdem = (p) => pessoa(p, ordem.get(String(p.pk)));
    const porNome = (a, b) => a.username.localeCompare(b.username);
    // O `is_bestie` que veio junto da coleta, como `juntarBesties` (extensao/app.js).
    const daColeta = coletaSeguidores.besties || coletaSeguindo.besties
      ? new Set([...(coletaSeguidores.besties || []), ...(coletaSeguindo.besties || [])].map(String)) : null;
    return {
      listas: { seguidores, seguindo },
      besties: { daColeta, parcial: Boolean(coletaSeguidores.bestiesParcial || coletaSeguindo.bestiesParcial) },
      analisados: new Set([...meSegue, ...euSigo]).size,
      naoTeSegue: seguindo.filter((p) => !meSegue.has(String(p.pk))).map(comOrdem).sort(porNome),
      voceNaoSegue: seguidores.filter((p) => !euSigo.has(String(p.pk))).map(comOrdem).sort(porNome),
      mutuos: seguindo.filter((p) => meSegue.has(String(p.pk))).map(comOrdem).sort(porNome),
    };
  }

  window.__mutuoTemPonto = async function () {
    const id = lerCookie('ds_user_id');
    const sessao = /^\d+$/.test(id) ? { id } : null;
    return Boolean(sessao && (await pontoGuardado(sessao)));
  };

  // ---------------------------------------------------------------------------
  // PRO: HISTÓRICO (1.2.0, 13/10/2026). A comparação é a de
  // extensao/historico.js, sem cópia, e com a regra que a sustenta: duas
  // leituras PARCIAIS nunca se comparam, porque "não veio desta vez" não é
  // "deixou de te seguir", e acusar pessoa errada é o pior defeito possível
  // num histórico.
  //
  // O que é do celular: o total do perfil, com que a extensão confere se a
  // leitura veio inteira, não existe aqui (`users/{id}/info/` responde 429 no
  // iPhone, etapa 1.4). No lugar dele vai a LEITURA COMPLETA ANTERIOR: a nova
  // precisa ter pelo menos 90% dela (a MARGEM de historico.js), dos dois lados.
  // Uma queda real de mais de 10% entre duas leituras é rara; uma leitura que
  // terminou cedo sem erro marcaria centenas de pessoas de uma vez.
  //
  // A base guardada é enxuta ([pk, @, nome]) e de UMA conta: trocou a conta,
  // base e histórico somem, como na extensão.
  // ---------------------------------------------------------------------------
  const BASE = 'mutuo_base';
  const HISTORICO = 'ig_manager_historico';
  const enxuta = (lista) => lista.map((p) => [String(p.pk), String(p.username || ''), String(p.full_name || '')]);
  const inteira = (lista) => (lista || []).map(([pk, username, full_name]) => ({ pk, username, full_name }));

  async function lerHistorico(id) {
    try {
      const h = await armazem.ler(HISTORICO);
      if (h && h.conta === id && Array.isArray(h.eventos)) return h.eventos;
    } catch (e) { /* sem histórico guardado */ }
    return [];
  }

  async function registrarHistorico(id, listas, etapas) {
    try {
      let anterior = null;
      try { anterior = await armazem.ler(BASE); } catch (e) { anterior = null; }
      // Outra conta no mesmo iPhone: o que era da anterior sai inteiro, como
      // na extensão (a trava pós-bloqueio também, porque ela é sobre AQUELA
      // conta). A política de privacidade, seção 8, diz isso.
      if (anterior && anterior.conta !== id) {
        await armazem.apagar(BASE);
        await armazem.apagar(HISTORICO);
        await armazem.apagar('mutuo_besties');
        await armazem.apagar(ACOES);
        anterior = null;
      }
      const agora = Date.now();
      const nova = {
        followers: listas.seguidores,
        following: listas.seguindo,
        analise: {
          plano: 'pro', parcial: false,
          lidosSeguidores: listas.seguidores.length, lidosSeguindo: listas.seguindo.length,
          // O "total" é a leitura anterior: ver o topo desta seção.
          totalSeguidores: anterior ? anterior.analise.lidosSeguidores : null,
          totalSeguindo: anterior ? anterior.analise.lidosSeguindo : null,
        },
      };
      let eventos = [];
      let comparou = false;
      if (anterior) {
        const antes = { followers: inteira(anterior.followers), following: inteira(anterior.following), analise: anterior.analise };
        eventos = M.compararBases(antes, nova, agora);
        comparou = eventos.length > 0 || (nova.analise.lidosSeguidores >= anterior.analise.lidosSeguidores * 0.9
          && nova.analise.lidosSeguindo >= anterior.analise.lidosSeguindo * 0.9);
        if (eventos.length) {
          const h = await lerHistorico(id);
          await armazem.gravar(HISTORICO, { conta: id, eventos: M.juntarHistorico(h, eventos) });
        }
      }
      // Uma leitura recusada não vira base: a próxima compara com a última boa.
      if (!anterior || comparou) {
        await armazem.gravar(BASE, {
          conta: id, em: agora,
          followers: enxuta(listas.seguidores), following: enxuta(listas.seguindo),
          analise: { plano: 'pro', parcial: false, lidosSeguidores: listas.seguidores.length, lidosSeguindo: listas.seguindo.length },
        });
      }
      const conta = (t) => eventos.filter((e) => e.tipo === t).length;
      etapas.push('histórico: ' + (!anterior ? 'primeira leitura' : comparou ? eventos.length + ' mudanças' : 'leitura menor que 90% da anterior, não comparada'));
      return {
        primeira: !anterior,
        comparou,
        desde: anterior ? anterior.em : null,
        perdeu: conta(M.TIPOS.perdeu), ganhou: conta(M.TIPOS.ganhou),
        total: (await lerHistorico(id)).length,
      };
    } catch (e) {
      etapas.push('histórico: não gravado');
      return null;
    }
  }

  // O que você mesmo deixou de seguir entra no ato, e sai da base guardada:
  // senão a próxima comparação registraria de novo (como `registrarAcaoNoHistorico`
  // e `removerDeSeguindo`, em extensao/app.js).
  async function registrarDeixei(id, p) {
    try {
      const h = await lerHistorico(id);
      await armazem.gravar(HISTORICO, { conta: id, eventos: M.juntarHistorico(h, [{ em: Date.now(), tipo: M.TIPOS.deixei, pk: String(p.pk), username: p.username || '', full_name: '' }]) });
      const base = await armazem.ler(BASE);
      if (base && base.conta === id) {
        base.following = base.following.filter(([pk]) => pk !== String(p.pk));
        base.analise.lidosSeguindo = base.following.length;
        await armazem.gravar(BASE, base);
      }
    } catch (e) { /* o histórico não pode derrubar a fila */ }
  }

  window.__mutuoHistorico = async function () {
    if (!(await ehPro())) return { ok: false, eventos: [] };
    const id = lerCookie('ds_user_id');
    return { ok: true, eventos: /^\d+$/.test(id) ? await lerHistorico(id) : [] };
  };

  // ---------------------------------------------------------------------------
  // PRO: CLOSE FRIENDS (1.3.0, 13/10/2026). A leitura é a de `resolverBesties`
  // (extensao/app.js) nas duas primeiras fontes: a lista completa
  // (`coletarBesties`), que é a única que enxerga quem saiu das suas listas, e,
  // se ela falhar, o `is_bestie` que veio junto da coleta. As duas fontes caras
  // (estado em lote e uma pergunta por pessoa) ficam de fora no celular: são
  // centenas de pedidos a mais numa leitura que já é longa.
  //
  // A escrita é o `definirBestie` da extensão (o Bloks, pela ponte), com o
  // RITMO_CLOSE e o CLOSE_POR_ACAO de extensao/ritmo.js: cada 25 pessoas valem
  // uma ação no teto do dia, e a trava pós-bloqueio é olhada antes de CADA
  // pedido. Como na extensão, não há fila: o Close Friends guardado é
  // atualizado a cada pessoa, e repetir o pedido só manda quem ainda falta.
  // ---------------------------------------------------------------------------
  const BESTIES = 'mutuo_besties';

  async function lerBesties(id) {
    try {
      const b = await armazem.ler(BESTIES);
      if (b && b.conta === id && Array.isArray(b.pks)) return b;
    } catch (e) { /* sem Close Friends guardado */ }
    return null;
  }

  async function resolverBesties(sessao, besties, etapas) {
    const guardado = await lerBesties(sessao.id);
    let lista = null;
    let fonte = '';
    try {
      lista = new Set((await M.coletarBesties(sessao)).map(String));
      fonte = 'lista';
    } catch (e) {
      etapas.push('close friends, lista: ' + ((e && e.constructor && e.constructor.name) || 'Error'));
    }
    if (!lista && besties && besties.daColeta) {
      lista = besties.daColeta;
      fonte = 'coleta';
      // Cobertura parcial do campo: une com o que já se sabia, em vez de
      // apagar as estrelas de quem ficou de fora (`coletaDoPonto`).
      if (besties.parcial && guardado) for (const pk of guardado.pks) lista.add(pk);
    }
    // Esvaziar é a única mudança que não dá para conferir: mantém e avisa.
    if (lista && lista.size === 0 && guardado && guardado.pks.length) {
      etapas.push('close friends: veio vazio, mantido o anterior');
      lista = null;
    }
    if (lista) {
      try { await armazem.gravar(BESTIES, { conta: sessao.id, pks: [...lista], lidoEm: Date.now(), fonte }); } catch (e) { /* fica para a próxima */ }
      etapas.push('close friends: ' + lista.size + ' (' + fonte + ')');
      return { pks: [...lista], lido: true };
    }
    etapas.push('close friends: não lido');
    return { pks: guardado ? guardado.pks : [], lido: false };
  }

  window.__mutuoSituacaoClose = async function (quantas) {
    const estado = await lerAcoes();
    const conta = M.situacaoDaConta(estado.bloqueio);
    const porta = podeAgir(estado);
    const acoesLivres = porta.parar ? 0 : Math.max(0, conta.teto - estado.timestamps.length);
    const cabem = Math.min(Number(quantas) || 0, acoesLivres * M.CLOSE_POR_ACAO);
    const s = M.segundosPara(cabem, M.RITMO_CLOSE);
    return { cabem, tempo: M.tempoEmTexto(s), motivo: porta.parar ? porta.motivo : '' };
  };

  /**
   * @param {'add'|'remove'} tipo
   * @param {Array<{pk:string, username:string}>} pessoas
   */
  window.__mutuoCloseFriends = async function (tipo, pessoas) {
    if (deixando) return;
    deixando = true;
    parar = false;
    const inicio = Date.now();
    const entrar = tipo === 'add';
    const titulo = entrar ? 'Adicionando ao Close Friends…' : 'Removendo do Close Friends…';
    const etapas = ['close friends: ' + tipo];
    const lista = (pessoas || []).filter((p) => /^\d+$/.test(String(p.pk)));
    const total = lista.length;
    let feitos = 0;
    let aplicados = 0;
    let erro = null;
    let freio = '';
    const contar = (texto) => avisar({ tipo: 'deixar-progresso', titulo, texto, feitos: aplicados, rotulo: entrar ? 'adicionada' : 'removida', processados: feitos, total, pct: total ? Math.round((feitos / total) * 100) : 0 });

    try {
      if (!(await ehPro())) { avisar({ tipo: 'deixar-fim', titulo: 'Close Friends', texto: 'O Close Friends em massa é do plano PRO.', feitos: 0, faltam: 0 }); return; }
      const id = lerCookie('ds_user_id');
      if (!/^\d+$/.test(id)) { avisar({ tipo: 'sem-sessao' }); return; }
      const csrf = lerCookie('csrftoken');
      await manterTelaAcesa(true);
      contar('Começando…');

      for (const p of lista) {
        if (parar) break;
        if (feitos > 0) {
          const longa = M.toca(feitos, M.RITMO_CLOSE);
          const espera = longa ? M.RITMO_CLOSE.pausaMs : M.intervaloEntreAcoes(Math.random, M.RITMO_CLOSE);
          for (let s = Math.ceil(espera / 1000); s > 0 && !parar; s -= 1) {
            contar(longa ? 'Pausa para não acelerar demais. Faltam ' + s + ' s.' : 'Próxima em ' + s + ' s.');
            await esperar(1000);
          }
          if (parar) break;
        }
        // CLOSE_POR_ACAO pedidos valem uma ação; a trava, sem desconto.
        if (feitos % M.CLOSE_POR_ACAO === 0) {
          let porta = podeAgir(await lerAcoes());
          while (!porta.ok && !porta.parar && !parar) {
            for (let s = porta.faltam; s > 0 && !parar; s -= 1) {
              contar('Limite de ' + M.MAX_ACOES_POR_JANELA + ' a cada 2 minutos. Continua em ' + s + ' s.');
              await esperar(1000);
            }
            porta = podeAgir(await lerAcoes());
          }
          if (parar) break;
          if (!porta.ok) { freio = porta.motivo; break; }
          const estado = await lerAcoes();
          estado.timestamps.push(Date.now());
          await gravarAcoes(estado);
        } else {
          const porta = podeAgir(await lerAcoes());
          if (porta.parar && M.situacaoDaConta((await lerAcoes()).bloqueio).travada) { freio = porta.motivo; break; }
        }
        contar((entrar ? 'Adicionando @' : 'Removendo @') + p.username + '…');
        const r = await M.definirBestie(String(p.pk), entrar, csrf);
        feitos += 1;
        if (r.dentro === entrar) aplicados += 1;
        try {
          const b = (await lerBesties(id)) || { conta: id, pks: [], lidoEm: 0, fonte: 'mutuo' };
          const s = new Set(b.pks);
          if (r.dentro) s.add(String(p.pk)); else s.delete(String(p.pk));
          b.pks = [...s];
          await armazem.gravar(BESTIES, b);
        } catch (e) { /* a próxima leitura corrige */ }
        avisar({ tipo: 'close-um', pk: String(p.pk), dentro: Boolean(r.dentro) });
      }
    } catch (e) {
      erro = e;
      const t = e instanceof M.ActionBlockedError ? 'bloqueio' : (e instanceof M.RateLimitError ? 'desacelerar' : '');
      if (t) {
        const estado = await lerAcoes();
        if (M.deveRegistrar(estado.bloqueio, t)) { estado.bloqueio = { em: Date.now(), tipo: t }; await gravarAcoes(estado); }
      }
    } finally {
      await manterTelaAcesa(false);
      deixando = false;
    }

    const verbo = entrar ? 'adicionadas ao' : 'removidas do';
    const naoConfirmadas = feitos - aplicados;
    const ressalva = naoConfirmadas > 0 ? ' O Instagram não confirmou ' + naoConfirmadas + '; leia a conta de novo para conferir.' : '';
    let texto;
    if (erro) {
      const trava = erro instanceof M.ActionBlockedError ? ' O Mútuo vai ficar parado por 24 horas.' : erro instanceof M.RateLimitError ? ' O Mútuo vai ficar parado por 1 hora.' : '';
      texto = 'Parou em ' + aplicados + ' de ' + total + '. ' + (erro.message || '') + trava;
      etapas.push('erro: ' + ((erro.constructor && erro.constructor.name) || 'Error') + ': ' + (erro.message || ''));
    } else if (parar) {
      texto = 'Parado por você: ' + aplicados + ' de ' + total + ' ' + verbo + ' Close Friends.' + ressalva;
    } else if (freio) {
      texto = 'Parou em ' + aplicados + ' de ' + total + '. ' + freio + ressalva;
    } else {
      texto = 'Pronto: ' + aplicados + ' ' + verbo + ' Close Friends.' + ressalva;
    }
    etapas.push('feitos: ' + feitos + ', confirmados: ' + aplicados + ', de ' + total);
    avisar({ tipo: 'deixar-fim', titulo: 'Close Friends', texto, feitos: aplicados, rotulo: entrar ? 'adicionada' : 'removida', total, faltam: total - feitos, diagnostico: diagnostico(etapas, inicio, erro ? 'fim: erro' : 'fim: ok') });
  };

  // ---------------------------------------------------------------------------
  // PRO: EXPORTAR (1.1.0, 13/10/2026). O CSV e o JSON são os de
  // extensao/exportar.js, sem cópia: o mesmo `;` com BOM que o Excel em
  // português abre, e o mesmo apóstrofo contra fórmula. As colunas são só as
  // que o celular sabe: gênero e Close Friends não existem aqui, e uma coluna
  // "nao" para quem não foi lido afirmaria o que o Mútuo não sabe.
  //
  // O plano é conferido aqui. `proConfirmado` guarda o que a leitura completa
  // já conferiu, para o arquivo sair no mesmo toque: o Safari pode recusar um
  // download que chega depois de uma espera.
  // ---------------------------------------------------------------------------
  let proConfirmado = false;
  const RELACAO = { naoTeSegue: 'Não te segue de volta', voceNaoSegue: 'Você não segue', mutuos: 'Mútuo' };
  const COLUNAS_CELULAR = [
    ['username', (p) => p.username],
    ['nome', (p) => p.full_name || ''],
    ['relacao', (p) => p.relacao],
    ['privado', (p) => (p.is_private ? 'sim' : 'nao')],
    ['verificado', (p) => (p.is_verified ? 'sim' : 'nao')],
    ['perfil', (p) => 'https://www.instagram.com/' + p.username + '/'],
  ];

  function baixar(nome, conteudo, tipo) {
    const url = URL.createObjectURL(new Blob([conteudo], { type: tipo }));
    const a = document.createElement('a');
    a.href = url;
    a.download = nome;
    a.style.display = 'none';
    document.documentElement.appendChild(a);
    a.click();
    a.remove();
    setTimeout(() => URL.revokeObjectURL(url), 60000);
  }

  /**
   * @param {'csv'|'json'} formato
   * @param {Array<{pk, username, nome, privado, verificado, lista}>} pessoas  o que o filtro mostra
   * @param {string} filtro  o filtro em texto, para o JSON dizer de onde a lista saiu
   */
  window.__mutuoExportar = function (formato, pessoas, filtro, conta) {
    const gerar = () => {
      const linhas = (pessoas || []).map((p) => ({
        pk: String(p.pk),
        username: String(p.username || ''),
        full_name: String(p.nome || ''),
        relacao: RELACAO[p.lista] || '',
        is_private: Boolean(p.privado),
        is_verified: Boolean(p.verificado),
      }));
      if (!linhas.length) return { ok: false, mensagem: 'Não há contas no filtro atual para exportar.' };
      const agora = new Date();
      if (formato === 'json') {
        baixar(M.nomeDoArquivo('json', agora), M.paraJson(linhas, {
          conta: conta ? '@' + conta : '', exportadoEm: agora.toISOString(), filtro: filtro || 'Todos', total: linhas.length,
        }), 'application/json');
      } else {
        baixar(M.nomeDoArquivo('csv', agora), M.paraCsv(linhas, COLUNAS_CELULAR), 'text/csv;charset=utf-8');
      }
      return { ok: true, total: linhas.length };
    };
    if (proConfirmado) return Promise.resolve(gerar());
    return ehPro().then((pro) => (pro ? gerar() : { ok: false, mensagem: 'Exportar é do plano PRO.' }));
  };

  let rodando = false;
  window.__mutuoRodar = async function () {
    if (rodando) return;
    rodando = true;
    const inicio = Date.now();
    if (await ehPro()) {
      proConfirmado = true;
      const etapas = ['plano: pro'];
      try {
        avisar({ tipo: 'progresso', texto: 'Conferindo a sua conta…', pct: 2 });
        const sessao = await lerConta();
        if (!sessao) return;
        const r = await lerBaseInteira(sessao, etapas);
        // A leitura inteira CONTOU: o cartão mostra o que foi lido, que vale
        // mais que o que o perfil diz (e não depende de o perfil responder).
        avisar({
          tipo: 'conta',
          username: sessao.username || '',
          foto: sessao.profilePic || '',
          seguidores: r.voceNaoSegue.length + r.mutuos.length,
          seguindo: r.naoTeSegue.length + r.mutuos.length,
        });
        etapas.push('resultado: ' + r.mutuos.length + ' mútuos, ' + r.naoTeSegue.length + ' não seguem de volta, ' + r.voceNaoSegue.length + ' você não segue');
        const { listas, besties, ...cruzado } = r;
        const novidades = await registrarHistorico(sessao.id, listas, etapas);
        avisar({ tipo: 'progresso', texto: 'Conferindo o seu Close Friends…', pct: 98 });
        const close = await resolverBesties(sessao, besties, etapas);
        avisar({ tipo: 'resultado', plano: 'pro', restantes: 0, ...cruzado, novidades, closeFriends: close.pks, closeLido: close.lido, diagnostico: diagnostico(etapas, inicio, 'fim: ok') });
      } catch (erro) {
        const tipo = (erro && erro.constructor && erro.constructor.name) || 'Error';
        avisar({
          tipo: 'erro',
          texto: ((erro && erro.message) || 'A leitura parou.') + ' O que já foi lido ficou guardado: toque em Tentar de novo, mais tarde, e a leitura continua de onde parou.',
          diagnostico: diagnostico(etapas, inicio, 'erro: ' + tipo + ': ' + ((erro && erro.message) || '')),
        });
      } finally {
        rodando = false;
      }
      return;
    }
    const etapas = [];

    try {
      avisar({ tipo: 'progresso', texto: 'Conferindo a sua conta…', pct: 4 });
      const sessao = await lerConta();
      if (!sessao) return;
      etapas.push('sessão: ok');

      avisar({ tipo: 'progresso', texto: 'Lendo quem você segue…', pct: 10 });
      const seguindo = await M.collect('following', sessao, () => {}, { limite: LIMITE_FREE });
      etapas.push('seguindo: ' + seguindo.pessoas.length + ' lidos');

      avisar({ tipo: 'progresso', texto: 'Lendo quem segue você…', pct: 18 });
      const seguidores = await M.collect('followers', sessao, () => {}, { limite: LIMITE_FREE });
      etapas.push('seguidores: ' + seguidores.pessoas.length + ' lidos');

      const amostra = M.amostrar(seguindo.pessoas, seguidores.pessoas, LIMITE_FREE);
      const relacoes = amostra.length
        ? await M.relacaoUmAUm(amostra.map((p) => p.pk), sessao.csrf, (lidos, total) => {
          avisar({ tipo: 'progresso', texto: 'Analisando os perfis… ' + lidos + ' de ' + total, pct: 20 + Math.round((lidos / total) * 78) });
        })
        : new Map();
      etapas.push('amostra: ' + amostra.length + ', relações lidas: ' + relacoes.size);

      const r = (p) => relacoes.get(p.pk) || {};
      const mutuos = amostra.filter((p) => r(p).voceSegue && r(p).segueVoce).map(pessoa);
      const naoTeSegue = amostra.filter((p) => r(p).voceSegue && !r(p).segueVoce).map(pessoa);
      const voceNaoSegue = amostra.filter((p) => !r(p).voceSegue && r(p).segueVoce).map(pessoa);
      etapas.push('resultado: ' + mutuos.length + ' mútuos, ' + naoTeSegue.length + ' não seguem de volta, ' + voceNaoSegue.length + ' você não segue');

      // O mesmo "~N restantes" da extensão: aproximado, e a tela diz isso.
      const t = sessao.totais || {};
      const total = (numero(t.seguidores) || 0) + (numero(t.seguindo) || 0);
      const restantes = total > amostra.length ? total - amostra.length : 0;

      avisar({
        tipo: 'resultado',
        analisados: amostra.length,
        restantes,
        mutuos,
        naoTeSegue,
        voceNaoSegue,
        diagnostico: diagnostico(etapas, inicio, 'fim: ok'),
      });
    } catch (erro) {
      const tipo = (erro && erro.constructor && erro.constructor.name) || 'Error';
      avisar({
        tipo: 'erro',
        texto: (erro && erro.message) || 'A análise falhou.',
        diagnostico: diagnostico(etapas, inicio, 'erro: ' + tipo + ': ' + ((erro && erro.message) || '')),
      });
    } finally {
      rodando = false;
    }
  };

  // ---------------------------------------------------------------------------
  // PRO: DEIXAR DE SEGUIR (13/10/2026, 1.0.0). É o `executarUnfollowEmMassa`
  // de extensao/app.js, com os mesmos freios, que vêm de extensao/ritmo.js
  // pelo motor, sem cópia:
  //
  //   - uma conta por vez, com intervalo SORTEADO (RITMO) e a pausa longa a
  //     cada 25; a primeira sai na hora;
  //   - os três portões de `podeAgir`: a trava depois de um bloqueio, o teto de
  //     24 horas corridas e o de rajada (10 a cada 2 minutos);
  //   - FB-02: antes de cada escrita, o Instagram diz se a pessoa segue você.
  //     Quem segue é poupado; na dúvida (erro na conferência), ninguém é
  //     deixado de seguir;
  //   - "action block" trava 24 h, "desacelerar" trava 1 h (`deveRegistrar`).
  //
  // O que muda no celular é só o que o celular pede: a fila fica guardada
  // (o iPhone congela a página quando a tela apaga ou o Safari sai da frente,
  // e a fila continua de onde parou), e a tela fica acesa enquanto roda
  // (Screen Wake Lock, no Safari desde o iOS 16.4).
  // ---------------------------------------------------------------------------
  const ACOES = 'ig_manager_acoes';
  const FILA = 'mutuo_fila_deixar';
  const SETE_DIAS = 7 * UM_DIA;

  async function lerAcoes() {
    let g = null;
    try { g = await armazem.ler(ACOES); } catch (e) { g = null; }
    const estado = g && typeof g === 'object' ? g : {};
    const agora = Date.now();
    return {
      timestamps: (Array.isArray(estado.timestamps) ? estado.timestamps : []).filter((t) => agora - t < UM_DIA),
      bloqueio: estado.bloqueio && Number(estado.bloqueio.em) ? estado.bloqueio : null,
    };
  }

  async function gravarAcoes(estado) {
    try { await armazem.gravar(ACOES, estado); } catch (e) { /* o teto volta a valer na próxima leitura */ }
  }

  // Os portões de `podeAgir` (extensao/app.js), na mesma ordem e com o mesmo texto.
  function podeAgir(estado) {
    const conta = M.situacaoDaConta(estado.bloqueio);
    if (conta.travada) {
      const oQueHouve = conta.tipo === 'desacelerar' ? 'O Instagram pediu para desacelerar' : 'O Instagram bloqueou as ações desta conta ("action block")';
      return { ok: false, parar: true, faltam: conta.faltam, motivo: oQueHouve + '. O Mútuo está parado para a conta se recuperar: insistir agora é o que faz o próximo bloqueio ser mais longo. Volta a funcionar em ' + M.tempoEmTexto(conta.faltam) + '.' };
    }
    const agora = Date.now();
    const doDia = estado.timestamps.filter((t) => agora - t < UM_DIA);
    if (doDia.length >= conta.teto) {
      const faltam = Math.max(1, Math.ceil((UM_DIA - (agora - Math.min(...doDia))) / 1000));
      return { ok: false, parar: true, faltam, motivo: 'Teto de ' + conta.teto + ' contas em 24 horas atingido' + (conta.retomando ? ' (reduzido, porque a conta levou um bloqueio há pouco)' : '') + '. Isso é proteção contra o bloqueio da sua conta. Dá para continuar em ' + M.tempoEmTexto(faltam) + '.' };
    }
    const recentes = doDia.filter((t) => agora - t < M.JANELA_MS);
    if (recentes.length >= M.MAX_ACOES_POR_JANELA) {
      return { ok: false, faltam: Math.max(1, Math.ceil((M.JANELA_MS - (agora - Math.min(...recentes))) / 1000)) };
    }
    return { ok: true };
  }

  async function filaGuardada(id) {
    try {
      const f = await armazem.ler(FILA);
      if (f && f.conta === id && Date.now() - f.criada < SETE_DIAS && Array.isArray(f.pessoas) && f.pessoas.length) return f;
      if (f) await armazem.apagar(FILA);
    } catch (e) { /* sem fila guardada */ }
    return null;
  }

  // O que a tela precisa para a confirmação: quantas cabem hoje e quanto tempo levam.
  window.__mutuoSituacaoDeixar = async function (quantas) {
    const estado = await lerAcoes();
    const conta = M.situacaoDaConta(estado.bloqueio);
    const porta = podeAgir(estado);
    const cabem = porta.parar ? 0 : Math.max(0, conta.teto - estado.timestamps.length);
    const hoje = Math.min(Number(quantas) || 0, cabem);
    return { cabem, teto: conta.teto, hoje, segundos: M.segundosPara(hoje), tempo: M.tempoEmTexto(M.segundosPara(hoje)), motivo: porta.parar ? porta.motivo : '' };
  };

  window.__mutuoFilaDeixar = async function () {
    const id = lerCookie('ds_user_id');
    const f = /^\d+$/.test(id) ? await filaGuardada(id) : null;
    return f ? { faltam: f.pessoas.length, total: f.total, feitos: f.feitos } : null;
  };

  window.__mutuoDescartarFila = async function () {
    try { await armazem.apagar(FILA); } catch (e) { /* vence sozinha em 7 dias */ }
  };

  let tela = null;
  // O pedido pode nunca responder (visto no Chromium sem tela): a fila não
  // espera por ele mais de 2 s. Tela acesa é ajuda, não condição.
  async function manterTelaAcesa(sim) {
    try {
      if (sim && !tela && navigator.wakeLock) {
        tela = await Promise.race([navigator.wakeLock.request('screen'), esperar(2000).then(() => null)]);
      }
      if (!sim && tela) { await tela.release(); tela = null; }
    } catch (e) { tela = null; }
  }
  // O Safari solta a trava da tela quando a página sai da frente; ao voltar, pede de novo.
  if (typeof document.addEventListener === 'function') {
    document.addEventListener('visibilitychange', () => {
      if (deixando && document.visibilityState === 'visible') { tela = null; manterTelaAcesa(true); }
    });
  }

  let deixando = false;
  let parar = false;
  window.__mutuoPararDeixar = function () { parar = true; };

  const esperar = (ms) => new Promise((ok) => setTimeout(ok, ms));

  /**
   * Deixa de seguir as pessoas escolhidas, ou continua a fila guardada.
   * @param {Array<{pk:string, username:string}>|null} escolhidas  null = continuar
   */
  window.__mutuoDeixar = async function (escolhidas) {
    if (deixando) return;
    deixando = true;
    parar = false;
    const inicio = Date.now();
    const etapas = ['deixar de seguir'];
    let fila = null;
    let feitos = 0;
    let mantidos = 0;
    let processados = 0;
    let erro = null;
    let freio = '';

    const contar = (texto, extra = {}) => avisar({
      tipo: 'deixar-progresso', texto, feitos, mantidos, processados, total: fila ? fila.total : 0,
      pct: fila && fila.total ? Math.round(((fila.total - fila.pessoas.length) / fila.total) * 100) : 0, ...extra,
    });

    try {
      // O plano é conferido aqui, como na leitura: o botão é só tela.
      if (!(await ehPro())) {
        avisar({ tipo: 'deixar-fim', texto: 'Deixar de seguir é do plano PRO.', feitos: 0, mantidos: 0, faltam: 0 });
        return;
      }
      const id = lerCookie('ds_user_id');
      if (!/^\d+$/.test(id)) { avisar({ tipo: 'sem-sessao' }); return; }
      const csrf = lerCookie('csrftoken');

      if (Array.isArray(escolhidas) && escolhidas.length) {
        const vistos = new Set();
        const pessoas = escolhidas
          .map((p) => ({ pk: String(p.pk), username: String(p.username || '') }))
          .filter((p) => /^\d+$/.test(p.pk) && !vistos.has(p.pk) && vistos.add(p.pk));
        fila = { conta: id, criada: Date.now(), total: pessoas.length, feitos: 0, pessoas };
      } else {
        fila = await filaGuardada(id);
        if (!fila) { avisar({ tipo: 'deixar-fim', texto: 'Não há nada para continuar.', feitos: 0, mantidos: 0, faltam: 0 }); return; }
        etapas.push('retomada: faltam ' + fila.pessoas.length + ' de ' + fila.total);
      }
      const gravarFila = async () => {
        try {
          if (fila.pessoas.length) await armazem.gravar(FILA, fila);
          else await armazem.apagar(FILA);
        } catch (e) { etapas.push('fila não gravada'); }
      };
      await gravarFila();
      await manterTelaAcesa(true);
      etapas.push('tela acesa: ' + (tela ? 'sim' : 'não'));
      contar('Começando…');

      while (fila.pessoas.length && !parar) {
        const pessoa = fila.pessoas[0];

        // FB-02: o ritmo anda por `processados` (inclusive as poupadas).
        if (processados > 0) {
          const longa = M.toca(processados);
          const espera = longa ? M.RITMO.pausaMs : M.intervaloEntreAcoes();
          for (let s = Math.ceil(espera / 1000); s > 0 && !parar; s -= 1) {
            contar(longa ? 'Pausa de ' + Math.round(M.RITMO.pausaMs / 60000) + ' min para não acelerar demais. Faltam ' + s + ' s.' : 'Próxima em ' + s + ' s.');
            await esperar(1000);
          }
          if (parar) break;
        }

        // Os portões. O de rajada se espera; a trava e o teto do dia param.
        let porta = podeAgir(await lerAcoes());
        while (!porta.ok && !porta.parar && !parar) {
          for (let s = porta.faltam; s > 0 && !parar; s -= 1) {
            contar('Limite de ' + M.MAX_ACOES_POR_JANELA + ' a cada 2 minutos. Continua em ' + s + ' s.');
            await esperar(1000);
          }
          porta = podeAgir(await lerAcoes());
        }
        if (parar) break;
        if (!porta.ok) { freio = porta.motivo; break; }

        contar('Conferindo @' + pessoa.username + '…');
        const r = await M.conferirAntesDeDeixar(pessoa.pk, csrf);
        if (r.deixar) {
          // Conta ANTES de disparar, como toda ação que escreve na extensão.
          const estado = await lerAcoes();
          estado.timestamps.push(Date.now());
          await gravarAcoes(estado);
          contar('Deixando de seguir @' + pessoa.username + '…');
          await M.deixarDeSeguir(pessoa.pk, csrf);
          await registrarDeixei(id, pessoa);
          feitos += 1;
          fila.feitos = (fila.feitos || 0) + 1;
          avisar({ tipo: 'deixar-um', pk: pessoa.pk, como: 'deixado' });
        } else if (r.segueVoce) {
          mantidos += 1;
          avisar({ tipo: 'deixar-um', pk: pessoa.pk, como: 'mantido', voceSegue: r.voceSegue });
        } else {
          avisar({ tipo: 'deixar-um', pk: pessoa.pk, como: 'jaNaoSegue' });
        }
        fila.pessoas.shift();
        processados += 1;
        await gravarFila();
      }
    } catch (e) {
      erro = e;
      // A trava da extensão: o leve não apaga o grave (`deveRegistrar`).
      const tipo = e instanceof M.ActionBlockedError ? 'bloqueio' : (e instanceof M.RateLimitError ? 'desacelerar' : '');
      if (tipo) {
        const estado = await lerAcoes();
        if (M.deveRegistrar(estado.bloqueio, tipo)) { estado.bloqueio = { em: Date.now(), tipo }; await gravarAcoes(estado); }
      }
    } finally {
      await manterTelaAcesa(false);
      deixando = false;
    }

    const faltam = fila ? fila.pessoas.length : 0;
    const poupadas = mantidos ? ' ' + mantidos + (mantidos > 1 ? ' contas seguem você e foram mantidas.' : ' conta segue você e foi mantida.') : '';
    let texto;
    if (erro) {
      const tipo = (erro.constructor && erro.constructor.name) || 'Error';
      const trava = erro instanceof M.ActionBlockedError ? ' O Mútuo vai ficar parado por 24 horas: insistir agora é o que faz o próximo bloqueio ser mais longo.'
        : erro instanceof M.RateLimitError ? ' O Mútuo vai ficar parado por 1 hora: é o aviso que vem antes do bloqueio de verdade.' : '';
      texto = 'Parou depois de deixar de seguir ' + feitos + '. ' + (erro.message || '') + trava + poupadas;
      etapas.push('erro: ' + tipo + ': ' + (erro.message || ''));
    } else if (parar) {
      texto = 'Parado por você: deixou de seguir ' + feitos + '.' + poupadas;
    } else if (freio) {
      texto = 'Deixou de seguir ' + feitos + ' e parou. ' + freio + poupadas;
    } else {
      texto = 'Pronto: deixou de seguir ' + feitos + (feitos === 1 ? ' conta.' : ' contas.') + poupadas;
    }
    etapas.push('feitos: ' + feitos + ', mantidos: ' + mantidos + ', processados: ' + processados + ', faltam: ' + faltam);
    avisar({ tipo: 'deixar-fim', texto, feitos, mantidos, faltam, diagnostico: diagnostico(etapas, inicio, erro ? 'fim: erro' : 'fim: ok') });
  };

  avisar({ tipo: 'pronto' });
})();

;
(function () {
  'use strict';
  const raiz = window.__mutuoRaiz;
  const CSS = ":host { display: block; background: var(--bg); color-scheme: light dark; }\n/* Mútuo no Android. As cores são as da extensão (extensao/app.css). */\n\n:host {\n  --bg: #f4f5f7;\n  --surface: #ffffff;\n  --border: #e2e5ea;\n  --text: #171a20;\n  --text-muted: #626b7a;\n  --accent: #c81e6e;\n  --accent-strong: #a3164f;\n  --accent-soft: #fae6ef;\n  --danger: #b3261e;\n  --radius: 14px;\n  --shadow: 0 1px 2px rgba(16, 24, 40, .06), 0 4px 12px rgba(16, 24, 40, .05);\n  --font: -apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, \"Helvetica Neue\", Arial, sans-serif;\n}\n\n@media (prefers-color-scheme: dark) {\n  :host {\n    --bg: #101318;\n    --surface: #171b22;\n    --border: #2a313c;\n    --text: #e8eaee;\n    --text-muted: #9aa4b2;\n    --accent: #f45a9c;\n    --accent-strong: #ff86bb;\n    --accent-soft: #2f1626;\n    --danger: #f2a29c;\n    --shadow: 0 1px 2px rgba(0, 0, 0, .3), 0 4px 12px rgba(0, 0, 0, .25);\n  }\n}\n\n* { box-sizing: border-box; -webkit-tap-highlight-color: transparent; }\n[hidden] { display: none !important; }\n\n.corpo { margin: 0; min-height: 100%; }\n.corpo {\n  background: var(--bg);\n  color: var(--text);\n  font: 16px/1.5 var(--font);\n  display: flex;\n  flex-direction: column;\n  min-height: 100vh;\n}\n\n.topo {\n  position: sticky; top: 0; z-index: 2;\n  display: flex; align-items: center; justify-content: space-between;\n  padding: 12px 16px;\n  background: var(--bg);\n  border-bottom: 1px solid var(--border);\n}\n.marca { display: flex; align-items: center; gap: 10px; font-weight: 700; font-size: 1.35rem; }\n.marca img { border-radius: 8px; }\n\nmain { flex: 1; padding: 20px 16px 8px; width: 100%; max-width: 560px; margin: 0 auto; }\n\n.tela {\n  display: flex; flex-direction: column; align-items: center; text-align: center;\n  gap: 14px; padding-top: 6vh;\n}\n.tela.topo-alinhado { padding-top: 0; align-items: stretch; text-align: left; }\n\nh1 { font-size: 1.6rem; line-height: 1.2; margin: 6px 0 0; }\nh2 { font-size: 1.3rem; margin: 0; }\nh3 { font-size: 1rem; margin: 10px 0 0; }\np { margin: 0; }\n.apagado { color: var(--text-muted); }\n.nota { color: var(--text-muted); font-size: .88rem; max-width: 34ch; }\n.tela.topo-alinhado .nota { max-width: none; }\n\n.icone-grande { border-radius: 22px; box-shadow: var(--shadow); margin-top: 8px; }\n\n.botao {\n  width: 100%; border: 0; border-radius: 12px;\n  background: var(--accent); color: #fff;\n  font: 600 1.05rem var(--font); padding: 16px;\n  box-shadow: var(--shadow);\n}\n.botao:active { background: var(--accent-strong); }\n.botao.secundario { background: var(--surface); color: var(--accent); border: 1px solid var(--accent); box-shadow: none; }\n.botao-texto { background: none; border: 0; color: var(--accent); font: 600 .95rem var(--font); padding: 8px; }\n.botao-texto.pequeno { display: block; margin: 18px auto 0; font-size: .85rem; }\n\n/* O convite ao PRO, no resultado: nota e botão juntos, num cartão. */\n.pro:not([hidden]) {\n  display: flex; flex-direction: column; gap: 12px;\n  background: var(--surface); border: 1px solid var(--border); border-radius: var(--radius); padding: 16px;\n}\n\n.conta {\n  width: 100%; display: flex; align-items: center; gap: 14px; text-align: left;\n  background: var(--surface); border: 1px solid var(--border); border-radius: var(--radius);\n  padding: 16px; box-shadow: var(--shadow);\n}\n.conta strong { display: block; font-size: 1.1rem; }\n\n.avatar {\n  flex: none; width: 44px; height: 44px; border-radius: 50%;\n  background: var(--accent-soft); color: var(--accent); overflow: hidden;\n  display: grid; place-items: center; font-weight: 700; text-transform: uppercase;\n}\n.avatar.grande { width: 60px; height: 60px; font-size: 1.4rem; }\n.avatar img { width: 100%; height: 100%; border-radius: 50%; object-fit: cover; display: block; }\n\n.barra { width: 100%; height: 10px; border-radius: 999px; background: var(--border); overflow: hidden; }\n.barra span { display: block; height: 100%; width: 4%; background: var(--accent); border-radius: 999px; transition: width .4s ease; }\n.girando {\n  width: 36px; height: 36px; border-radius: 50%;\n  border: 4px solid var(--border); border-top-color: var(--accent);\n  animation: gira .9s linear infinite;\n}\n@keyframes gira { to { transform: rotate(360deg); } }\n@media (prefers-reduced-motion: reduce) { .girando { animation: none; } .barra span { transition: none; } }\n\n.cards { display: grid; grid-template-columns: repeat(3, 1fr); gap: 8px; }\n.card {\n  display: flex; flex-direction: column; align-items: flex-start; gap: 2px;\n  background: var(--surface); border: 1px solid var(--border); border-radius: var(--radius);\n  padding: 12px 10px; text-align: left; color: var(--text); font: inherit;\n}\n.card[aria-selected=\"true\"] { border-color: var(--accent); box-shadow: inset 0 0 0 1px var(--accent); }\n.card.destaque .card-num { color: var(--accent); }\n.card-num { font-size: 1.6rem; font-weight: 700; line-height: 1.1; }\n.card-rot { font-size: .78rem; color: var(--text-muted); line-height: 1.25; }\n\n.lista { list-style: none; margin: 0; padding: 0; background: var(--surface); border: 1px solid var(--border); border-radius: var(--radius); }\n.lista li { display: flex; align-items: center; gap: 12px; padding: 10px 12px; border-top: 1px solid var(--border); }\n.lista li:first-child { border-top: 0; }\n.lista .quem { flex: 1; min-width: 0; }\n.lista .quem strong, .lista .quem span { display: block; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }\n.lista .quem span { color: var(--text-muted); font-size: .85rem; }\n.lista .vazio { color: var(--text-muted); justify-content: center; padding: 18px; }\n.abrir { flex: none; border: 1px solid var(--border); background: var(--bg); color: var(--text); border-radius: 999px; font: 600 .82rem var(--font); padding: 7px 12px; }\n\n.rodape {\n  display: flex; justify-content: space-between; gap: 8px;\n  padding: 12px 16px 16px; color: var(--text-muted); font-size: .78rem;\n}\n\n/* O plano e a chave (etapa 1.2). O selo diz o plano em texto, não só em cor. */\n.selo { font-size: .8rem; font-weight: 700; letter-spacing: .04em; text-transform: uppercase; color: var(--text-muted); background: var(--surface); border: 1px solid var(--border); border-radius: 999px; padding: 4px 12px; }\n.selo.ativo { color: #fff; background: var(--accent); border-color: var(--accent); }\n.aviso { font-size: .88rem; color: var(--text); background: var(--accent-soft); border-radius: var(--radius); padding: 10px 14px; max-width: none; }\n.pro label { font-size: .9rem; font-weight: 600; text-align: left; }\n.campo { width: 100%; font: 600 1rem var(--mono, ui-monospace, monospace); letter-spacing: .04em; padding: 14px; border: 1px solid var(--border); border-radius: 10px; background: var(--bg); color: var(--text); }\n.botao:disabled { opacity: .6; }\n\n/* Deixar de seguir (1.0.0). A barra fica presa ao pé da rolagem da lista. */\n.barra-acao:not([hidden]) {\n  position: sticky; bottom: 0; z-index: 1;\n  display: flex; align-items: center; gap: 10px;\n  margin: 0 -16px; padding: 12px 16px calc(12px + env(safe-area-inset-bottom));\n  background: var(--bg); border-top: 1px solid var(--border);\n}\n.barra-acao .botao { flex: 1; padding: 14px; }\n.barra-acao .botao-texto { flex: none; }\n.lista li.marcavel { cursor: pointer; }\n.marca-caixa {\n  flex: none; width: 24px; height: 24px; border-radius: 7px;\n  border: 2px solid var(--border); background: var(--surface);\n  display: grid; place-items: center; color: #fff; font-size: .9rem; font-weight: 700;\n}\n.lista li[aria-checked=\"true\"] .marca-caixa { background: var(--accent); border-color: var(--accent); }\n.lista li[aria-checked=\"true\"] .marca-caixa::after { content: \"✓\"; }\n\n/* Filtros e exportar (1.1.0): os chips rolam de lado, sem quebrar a página. */\n.filtros-pro:not([hidden]) { display: flex; flex-direction: column; gap: 8px; }\n.chips { display: flex; gap: 6px; overflow-x: auto; padding-bottom: 2px; scrollbar-width: none; }\n.chips::-webkit-scrollbar { display: none; }\n.chip { flex: none; border: 1px solid var(--border); background: var(--surface); color: var(--text); border-radius: 999px; font: 600 .82rem var(--font); padding: 7px 12px; }\n.chip[aria-pressed=\"true\"] { background: var(--accent); border-color: var(--accent); color: #fff; }\n.linha-exportar { display: flex; align-items: center; gap: 8px; }\n.linha-exportar #contagem { flex: 1; font-size: .85rem; }\n\n/* Histórico (1.2.0): o que houve vai escrito, nunca só na cor. */\n.historico-quando { flex: none; width: 4.6em; color: var(--text-muted); font-size: .8rem; }\n.historico-oque { display: block; font-size: .85rem; color: var(--text-muted); }\n.lista .quem .historico-oque.perdeu { color: var(--danger); }\n";
  try {
    const folha = new CSSStyleSheet();
    folha.replaceSync(CSS);
    raiz.adoptedStyleSheets = [folha];
  } catch (e) {
    const estilo = document.createElement('style');
    estilo.textContent = CSS;
    raiz.appendChild(estilo);
  }
  function montar(no) {
    if (typeof no === 'string') return document.createTextNode(no);
    const el = document.createElement(no[0]);
    for (const [k, v] of Object.entries(no[1])) el.setAttribute(k, v);
    for (const filho of no.slice(2)) el.appendChild(montar(filho));
    return el;
  }
  raiz.appendChild(montar(["div",{"class":"corpo"},["header",{"class":"topo"},["div",{"class":"marca"},["img",{"src":"data:image/png;base64,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","alt":"","width":"32","height":"32"}],["span",{},"Mútuo"]],["button",{"id":"sair","class":"botao-texto","type":"button","hidden":""},"Sair"]],["main",{},["section",{"id":"s-carregando","class":"tela"},["div",{"class":"girando","aria-hidden":"true"}],["p",{"class":"apagado"},"Abrindo…"]],["section",{"id":"s-entrar","class":"tela","hidden":""},["img",{"class":"icone-grande","src":"data:image/png;base64,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","alt":"","width":"96","height":"96"}],["h1",{},"Descubra quem não te segue de volta"],["p",{"class":"apagado"},"Veja quem não retribui, quem você não segue de volta e quem são os seus mútuos, direto no celular."],["button",{"id":"entrar","class":"botao","type":"button"},"Entrar com o Instagram"],["p",{"class":"nota","id":"nota-entrar"},"O login é feito na própria tela do Instagram: o Mútuo não vê a sua senha. A análise acontece no seu telefone, e nada sai dele."]],["section",{"id":"s-inicio","class":"tela","hidden":""},["div",{"class":"conta"},["span",{"class":"avatar grande","id":"conta-foto"}],["div",{},["strong",{"id":"conta-nome"},"Carregando a sua conta…"],["span",{"class":"apagado","id":"conta-numeros"}]]],["p",{"id":"selo-plano","class":"selo","hidden":""}],["p",{"id":"aviso-plano","class":"aviso","hidden":""}],["button",{"id":"analisar","class":"botao","type":"button"},"Analisar 50 perfis"],["p",{"id":"nota-analisar","class":"nota"},"O plano grátis analisa 50 perfis da sua conta, no ritmo que protege você de bloqueio. Leva cerca de um minuto."],["div",{"id":"bloco-fila","class":"pro","hidden":""},["p",{"id":"fila-texto","class":"nota"}],["button",{"id":"fila-continuar","class":"botao","type":"button"},"Continuar a deixar de seguir"],["button",{"id":"fila-descartar","class":"botao-texto","type":"button"},"Descartar a fila"]],["button",{"id":"abrir-chave","class":"botao-texto","type":"button","hidden":""},"Já comprou o PRO? Ativar a chave"],["div",{"id":"bloco-chave","class":"pro","hidden":""},["label",{"for":"chave"},"Cole a chave que chegou no e-mail da compra"],["input",{"id":"chave","class":"campo","type":"text","autocomplete":"off","autocapitalize":"characters","autocorrect":"off","spellcheck":"false","placeholder":"MUTUO-XXXX-XXXX-XXXX"}],["button",{"id":"ativar","class":"botao","type":"button"},"Ativar o PRO"],["p",{"id":"chave-msg","class":"nota","hidden":""}]]],["section",{"id":"s-analisando","class":"tela","hidden":""},["h2",{},"Analisando…"],["div",{"class":"barra"},["span",{"id":"barra"}]],["p",{"id":"progresso","class":"apagado"},"Conferindo a sua conta…"],["p",{"class":"nota"},"Pode deixar o app aberto. O ritmo é devagar de propósito: é o que protege a sua conta."]],["section",{"id":"s-resultado","class":"tela topo-alinhado","hidden":""},["p",{"id":"res-titulo","class":"apagado"}],["div",{"class":"cards","role":"tablist"},["button",{"class":"card destaque","type":"button","data-lista":"naoTeSegue","role":"tab"},["span",{"class":"card-num","id":"n-naoTeSegue"},"0"],["span",{"class":"card-rot"},"Não te seguem de volta"]],["button",{"class":"card","type":"button","data-lista":"voceNaoSegue","role":"tab"},["span",{"class":"card-num","id":"n-voceNaoSegue"},"0"],["span",{"class":"card-rot"},"Você não segue de volta"]],["button",{"class":"card","type":"button","data-lista":"mutuos","role":"tab"},["span",{"class":"card-num","id":"n-mutuos"},"0"],["span",{"class":"card-rot"},"Mútuos"]]],["div",{"id":"bloco-historico","class":"pro","hidden":""},["p",{"id":"historico-resumo","class":"nota"}],["button",{"id":"ver-historico","class":"botao secundario","type":"button"},"Ver histórico"]],["h3",{"id":"lista-titulo"}],["div",{"id":"bloco-filtros","class":"filtros-pro","hidden":""},["div",{"class":"chips","role":"group","aria-label":"Mostrar"},["button",{"class":"chip","type":"button","data-filtro":"todos","aria-pressed":"true"},"Todos"],["button",{"class":"chip","type":"button","data-filtro":"verificados","aria-pressed":"false"},"Verificados"],["button",{"class":"chip","type":"button","data-filtro":"naoverificados","aria-pressed":"false"},"Não verificados"],["button",{"class":"chip","type":"button","data-filtro":"privados","aria-pressed":"false"},"Privados"],["button",{"class":"chip","type":"button","data-filtro":"publicos","aria-pressed":"false"},"Públicos"]],["div",{"class":"chips","role":"group","aria-label":"Close Friends"},["button",{"class":"chip","type":"button","data-close":"todos","aria-pressed":"true"},"Close Friends: todos"],["button",{"class":"chip","type":"button","data-close":"sim","aria-pressed":"false"},"★ No Close Friends"],["button",{"class":"chip","type":"button","data-close":"nao","aria-pressed":"false"},"Fora do Close Friends"]],["div",{"class":"chips","role":"group","aria-label":"Ordenar"},["button",{"class":"chip","type":"button","data-ordem":"az","aria-pressed":"true"},"A–Z"],["button",{"class":"chip","type":"button","data-ordem":"recentes","aria-pressed":"false"},"Mais recentes"],["button",{"class":"chip","type":"button","data-ordem":"antigos","aria-pressed":"false"},"Mais antigos"]],["div",{"class":"linha-exportar"},["span",{"id":"contagem","class":"apagado"}],["button",{"id":"exportar-csv","class":"abrir","type":"button"},"Exportar CSV"],["button",{"id":"exportar-json","class":"abrir","type":"button"},"JSON"]],["p",{"id":"exportar-msg","class":"nota","hidden":""}],["p",{"id":"nota-close","class":"nota","hidden":""},"Não deu para ler o seu Close Friends agora. As estrelas mostram só o que foi marcado pelo Mútuo; leia a conta de novo mais tarde."]],["p",{"id":"nota-marcar","class":"nota","hidden":""},"Toque nas contas para marcar, e depois em Ações."],["ul",{"id":"lista","class":"lista"}],["div",{"id":"barra-deixar","class":"barra-acao","hidden":""},["button",{"id":"marcar-todas","class":"botao-texto","type":"button"},"Marcar todas"],["button",{"id":"deixar","class":"botao","type":"button","disabled":""},"Ações (0)"]],["p",{"id":"restantes","class":"nota","hidden":""}],["div",{"id":"bloco-pro","class":"pro","hidden":""},["p",{"class":"nota"},"O plano PRO analisa a sua conta inteira e deixa de seguir, no ritmo que protege a sua conta."],["button",{"id":"planos","class":"botao","type":"button"},"Ver os planos do PRO"]],["button",{"id":"de-novo","class":"botao secundario","type":"button"},"Analisar de novo"]],["section",{"id":"s-acoes","class":"tela","hidden":""},["h2",{"id":"acoes-titulo"},"O que fazer com elas?"],["button",{"id":"acao-deixar","class":"botao","type":"button"},"Deixar de seguir"],["button",{"id":"acao-add","class":"botao","type":"button"},"★ Adicionar ao Close Friends"],["button",{"id":"acao-remove","class":"botao secundario","type":"button"},"Remover do Close Friends"],["p",{"id":"acoes-nota","class":"nota"}],["button",{"id":"acoes-voltar","class":"botao-texto","type":"button"},"Voltar"]],["section",{"id":"s-confirmar","class":"tela","hidden":""},["h2",{"id":"conf-titulo"},"Deixar de seguir?"],["p",{"id":"conf-texto"}],["p",{"id":"conf-nota","class":"nota"},"Antes de cada conta, o Mútuo confere com o Instagram: quem segue você é mantido. Deixar de seguir não se desfaz."],["p",{"class":"nota"},"Deixe o Safari aberto nesta aba até terminar. O Mútuo mantém a tela acesa; se ela apagar, a fila pausa e continua de onde parou."],["button",{"id":"conf-sim","class":"botao","type":"button"},"Deixar de seguir"],["button",{"id":"conf-nao","class":"botao secundario","type":"button"},"Voltar"]],["section",{"id":"s-deixando","class":"tela","hidden":""},["h2",{"id":"deixando-titulo"},"Deixando de seguir…"],["div",{"class":"barra"},["span",{"id":"barra-deixando"}]],["p",{"id":"deixando-contas","class":"apagado"}],["p",{"id":"deixando-status"}],["p",{"id":"deixando-nota","class":"nota","data-deixar":"1"},"Os mesmos tempos da extensão do computador: uma conta a cada 28 a 50 segundos, uma pausa de 5 minutos a cada 25 e no máximo 100 por dia. É o que protege a sua conta de bloqueio."],["button",{"id":"parar","class":"botao secundario","type":"button"},"Parar"],["button",{"id":"deixando-voltar","class":"botao","type":"button","hidden":""},"Voltar à lista"]],["section",{"id":"s-historico","class":"tela topo-alinhado","hidden":""},["h2",{},"Histórico"],["p",{"id":"historico-sub","class":"nota"}],["ul",{"id":"historico-lista","class":"lista"}],["button",{"id":"historico-voltar","class":"botao secundario","type":"button"},"Voltar à lista"]],["section",{"id":"s-erro","class":"tela","hidden":""},["h2",{},"Não deu certo"],["p",{"id":"erro-texto"}],["button",{"id":"tentar","class":"botao","type":"button"},"Tentar de novo"]],["button",{"id":"copiar","class":"botao-texto pequeno","type":"button","hidden":""},"Copiar diagnóstico"]],["footer",{"class":"rodape"},["span",{},"Nada sai do seu telefone."],["span",{"id":"versao"}]]]));
})();
;
/*
 * As telas do Mútuo no Android (28/09/2026).
 *
 * Esta página é do app (file:///android_asset/app/), não do Instagram. Ela não
 * lê nada sozinha: pede ao app pela ponte `MutuoApp` (entrar, analisar, sair)
 * e recebe o andamento por `mutuoEvento`, que o app chama com o que o executor
 * contou lá da página do Instagram, escondida atrás desta.
 *
 * No iPhone as mesmas telas abrem por cima da página do Instagram, dentro de
 * uma shadow root (`window.__mutuoRaiz`, montada por ferramentas/gerar-iphone.mjs),
 * e a ponte `MutuoApp` é a do Userscripts. Por isso tudo aqui procura na raiz, e
 * não direto no document.
 *
 * Dado do Instagram entra por textContent, nunca por innerHTML: a regra da
 * extensão vale igual aqui.
 */
(function () {
  'use strict';

  const raiz = window.__mutuoRaiz || document;
  const $ = (id) => raiz.getElementById(id);
  const app = window.MutuoApp || null;
  const TELAS = ['carregando', 'entrar', 'inicio', 'analisando', 'resultado', 'acoes', 'confirmar', 'deixando', 'historico', 'erro'];
  const TITULOS = {
    naoTeSegue: 'Não te seguem de volta',
    voceNaoSegue: 'Você não segue de volta',
    mutuos: 'Vocês se seguem',
  };

  let fecharSempre = false;
  let resultado = null;
  let listaAtual = 'naoTeSegue';
  let mostrando = 100;
  let diagnostico = '';
  // Deixar de seguir (1.0.0): quem está marcado, por pk, na lista "Não te seguem de volta".
  const marcados = new Set();
  // Filtros e ordem do PRO (1.1.0), os mesmos da extensão (filtrarPessoas).
  let filtro = 'todos';
  let ordem = 'az';
  // Close Friends (1.3.0): quem está, e se a leitura deu certo.
  let closeSet = new Set();
  let closeLido = false;
  let filtroClose = 'todos';
  let contaAtual = '';
  const ROTULO_FILTRO = { verificados: 'Verificados', naoverificados: 'Não verificados', privados: 'Privados', publicos: 'Públicos' };
  const ROTULO_ORDEM = { recentes: 'mais recentes', antigos: 'mais antigos' };

  function mostrar(nome) {
    for (const t of TELAS) $('s-' + t).hidden = t !== nome;
    $('copiar').hidden = !diagnostico || (nome !== 'resultado' && nome !== 'erro' && nome !== 'deixando');
    if (raiz.host) raiz.host.scrollTop = 0; else window.scrollTo(0, 0);
  }

  function logado(sim) {
    $('sair').hidden = !sim && !fecharSempre;
  }

  function pintarAvatar(el, foto, nome) {
    el.textContent = (nome || '?').replace(/^@/, '').charAt(0);
    if (!/^https:\/\//.test(foto || '')) return;
    // A foto vem do CDN do Instagram, entregue pelo app (fotoDoInstagram, em
    // MainActivity). Se não abrir, fica a inicial.
    const img = document.createElement('img');
    img.alt = '';
    img.decoding = 'async';
    img.onload = () => { el.textContent = ''; el.appendChild(img); };
    img.src = foto;
  }

  function fmt(n) {
    return Number.isFinite(n) ? n.toLocaleString('pt-BR') : '?';
  }

  function mostrarConta(e) {
    if (e.username) contaAtual = e.username;
    $('conta-nome').textContent = e.username ? '@' + e.username : 'Conta conectada';
    // Sem número é "não sei", e a linha fica vazia: no iPhone os números só
    // vêm da leitura completa do PRO, que conta (etapa 1.4).
    $('conta-numeros').textContent = Number.isFinite(e.seguidores)
      ? fmt(e.seguidores) + ' seguidores · ' + fmt(e.seguindo) + ' seguindo'
      : '';
    pintarAvatar($('conta-foto'), e.foto, e.username);
  }

  // Só o PRO, só a lista de quem não te segue, e só onde a ponte sabe deixar.
  function podeDeixar() {
    return Boolean(ehPro && app && app.deixar && resultado && resultado.plano === 'pro' && listaAtual === 'naoTeSegue');
  }
  // Marcar vale nas três listas do PRO: o Close Friends age em qualquer uma.
  function podeMarcar() {
    return Boolean(ehPro && app && app.deixar && resultado && resultado.plano === 'pro');
  }

  function pintarBarraDeixar() {
    const pode = podeMarcar() && visiveis().length > 0;
    $('barra-deixar').hidden = !pode;
    $('nota-marcar').hidden = !pode;
    if (!pode) return;
    $('deixar').textContent = 'Ações (' + marcados.size + ')';
    $('deixar').disabled = marcados.size === 0;
    $('marcar-todas').textContent = marcados.size && marcados.size === visiveis().length ? 'Desmarcar todas' : 'Marcar todas';
  }

  function pintarNumeros() {
    $('n-naoTeSegue').textContent = resultado.naoTeSegue.length;
    $('n-voceNaoSegue').textContent = resultado.voceNaoSegue.length;
    $('n-mutuos').textContent = resultado.mutuos.length;
  }

  function comFiltros() {
    return Boolean(ehPro && resultado && resultado.plano === 'pro');
  }

  // A lista da aba, filtrada e ordenada. Fora do PRO, a lista como veio.
  function visiveis() {
    const todas = (resultado && resultado[listaAtual]) || [];
    if (!comFiltros()) return todas;
    const f = todas.filter((p) => {
      if (filtro === 'verificados' && !p.verificado) return false;
      if (filtro === 'naoverificados' && p.verificado) return false;
      if (filtro === 'privados' && !p.privado) return false;
      if (filtro === 'publicos' && p.privado) return false;
      if (filtroClose === 'sim' && !closeSet.has(p.pk)) return false;
      if (filtroClose === 'nao' && closeSet.has(p.pk)) return false;
      return true;
    });
    if (ordem === 'recentes') return f.slice().sort((a, b) => a.ordem - b.ordem);
    if (ordem === 'antigos') return f.slice().sort((a, b) => b.ordem - a.ordem);
    return f.slice().sort((a, b) => a.username.localeCompare(b.username));
  }

  function descreverFiltro() {
    return [TITULOS[listaAtual], ROTULO_FILTRO[filtro], { sim: 'No Close Friends', nao: 'Fora do Close Friends' }[filtroClose], ROTULO_ORDEM[ordem]].filter(Boolean).join(' + ');
  }

  function pintarFiltros(pessoas) {
    const pode = comFiltros();
    $('bloco-filtros').hidden = !pode;
    if (!pode) return;
    for (const c of raiz.querySelectorAll('[data-filtro]')) c.setAttribute('aria-pressed', String(c.dataset.filtro === filtro));
    for (const c of raiz.querySelectorAll('[data-ordem]')) c.setAttribute('aria-pressed', String(c.dataset.ordem === ordem));
    for (const c of raiz.querySelectorAll('[data-close]')) c.setAttribute('aria-pressed', String(c.dataset.close === filtroClose));
    $('nota-close').hidden = closeLido;
    const total = (resultado[listaAtual] || []).length;
    $('contagem').textContent = pessoas.length === total ? pessoas.length + ' contas' : pessoas.length + ' de ' + total + ' contas';
    $('exportar-csv').disabled = !pessoas.length;
    $('exportar-json').disabled = !pessoas.length;
  }

  function pintarLista() {
    const pessoas = visiveis();
    pintarFiltros(pessoas);
    const marcar = podeMarcar();
    for (const card of raiz.querySelectorAll('.card')) {
      card.setAttribute('aria-selected', String(card.dataset.lista === listaAtual));
    }
    $('lista-titulo').textContent = TITULOS[listaAtual];
    const ul = $('lista');
    ul.textContent = '';
    if (!pessoas.length) {
      const li = document.createElement('li');
      li.className = 'vazio';
      li.textContent = resultado && resultado.plano === 'pro' ? 'Ninguém nesta lista.' : 'Ninguém nesta amostra.';
      ul.appendChild(li);
      pintarBarraDeixar();
      return;
    }
    // Conta grande tem milhares de linhas: pinta de 100 em 100.
    for (const p of pessoas.slice(0, mostrando)) {
      const li = document.createElement('li');
      const av = document.createElement('span');
      av.className = 'avatar';
      pintarAvatar(av, p.foto, p.username);
      const quem = document.createElement('div');
      quem.className = 'quem';
      const forte = document.createElement('strong');
      forte.textContent = '@' + p.username;
      quem.appendChild(forte);
      // No PRO, o motivo de a conta estar no filtro, escrito (não só em cor).
      const selos = comFiltros() ? [closeSet.has(p.pk) ? '★ Close Friends' : '', p.verificado ? 'Verificado' : '', p.privado ? 'Privado' : ''].filter(Boolean) : [];
      if (p.nome || selos.length) {
        const nome = document.createElement('span');
        nome.textContent = [...selos, p.nome].filter(Boolean).join(' · ');
        quem.appendChild(nome);
      }
      const abrir = document.createElement('button');
      abrir.type = 'button';
      abrir.className = 'abrir';
      abrir.textContent = 'Ver perfil';
      abrir.addEventListener('click', (ev) => { ev.stopPropagation(); if (app) app.abrirPerfil(p.username); });
      if (marcar) {
        const caixa = document.createElement('span');
        caixa.className = 'marca-caixa';
        caixa.setAttribute('aria-hidden', 'true');
        li.className = 'marcavel';
        li.setAttribute('role', 'checkbox');
        li.setAttribute('aria-checked', String(marcados.has(p.pk)));
        li.addEventListener('click', () => {
          if (marcados.has(p.pk)) marcados.delete(p.pk); else marcados.add(p.pk);
          li.setAttribute('aria-checked', String(marcados.has(p.pk)));
          pintarBarraDeixar();
        });
        li.append(caixa, av, quem, abrir);
      } else {
        li.append(av, quem, abrir);
      }
      ul.appendChild(li);
    }
    if (pessoas.length > mostrando) {
      const li = document.createElement('li');
      li.className = 'vazio';
      const mais = document.createElement('button');
      mais.type = 'button';
      mais.className = 'botao-texto';
      mais.textContent = 'Mostrar mais ' + Math.min(100, pessoas.length - mostrando) + ' (de ' + pessoas.length + ')';
      mais.addEventListener('click', () => { mostrando += 100; pintarLista(); });
      li.appendChild(mais);
      ul.appendChild(li);
    }
    pintarBarraDeixar();
  }

  function mostrarResultado(e) {
    resultado = e;
    diagnostico = e.diagnostico || '';
    $('res-titulo').textContent = fmt(e.analisados) + (e.plano === 'pro' ? ' perfis analisados: a sua conta inteira.' : ' perfis analisados.');
    pintarNovidades(e.novidades);
    closeSet = new Set(e.closeFriends || []);
    closeLido = Boolean(e.closeLido);
    filtroClose = 'todos';
    if (e.plano === 'pro' && e.closeFriends) $('res-titulo').textContent += ' ★ ' + closeSet.size + ' no Close Friends' + (closeLido ? '.' : ' (do que o Mútuo marcou).');
    marcados.clear();
    filtro = 'todos';
    ordem = 'az';
    $('exportar-msg').hidden = true;
    pintarNumeros();
    // Diz o que ficou de fora sem prometer o que o app ainda não faz.
    $('restantes').hidden = !e.restantes;
    $('restantes').textContent = '~' + fmt(e.restantes) + ' perfis da sua conta ficaram de fora desta análise.';
    // O botão de planos não depende do "~N restantes": esse número sai do
    // perfil, que o Instagram às vezes não manda (visto no iPhone, 13/10/2026).
    $('bloco-pro').hidden = !(app && app.abrirPlanos) || ehPro;
    mostrando = 100;
    listaAtual = e.naoTeSegue.length ? 'naoTeSegue' : (e.voceNaoSegue.length ? 'voceNaoSegue' : 'mutuos');
    pintarLista();
    mostrar('resultado');
  }

  function mostrarErro(texto) {
    $('erro-texto').textContent = texto;
    mostrar('erro');
  }

  // O app chama esta função com um JSON em texto, montado pelo executor.
  window.mutuoEvento = function (texto) {
    let e;
    try { e = JSON.parse(texto); } catch (x) { return; }

    switch (e.tipo) {
      case 'sessao':
        logado(e.logado);
        if (e.logado) { mostrar('inicio'); } else { mostrar('entrar'); }
        break;
      case 'pronto':
        if (!$('s-inicio').hidden && app) app.conta();
        break;
      case 'conta':
        mostrarConta(e);
        break;
      case 'sem-sessao':
        logado(false);
        mostrar('entrar');
        break;
      case 'progresso':
        mostrar('analisando');
        $('progresso').textContent = e.texto;
        $('barra').style.width = Math.max(4, Math.min(100, e.pct || 0)) + '%';
        break;
      case 'resultado':
        mostrarResultado(e);
        // O plano chega por Promise: com ele confirmado, a lista ganha as caixas de marcar.
        pintarPlano().then(() => { if (!$('s-resultado').hidden) pintarLista(); });
        break;
      case 'erro':
        diagnostico = e.diagnostico || diagnostico;
        mostrarErro(e.texto);
        break;
      case 'deixar-progresso':
        if ($('s-deixando').hidden) abrirDeixando();
        if (e.titulo) $('deixando-titulo').textContent = e.titulo;
        $('deixando-nota').hidden = Boolean(e.titulo);
        $('deixando-status').textContent = e.texto;
        $('barra-deixando').style.width = Math.max(4, Math.min(100, e.pct || 0)) + '%';
        $('deixando-contas').textContent = contasEmTexto(e);
        break;
      case 'deixar-um':
        tirarDaLista(e);
        break;
      case 'close-um':
        if (e.dentro) closeSet.add(e.pk); else closeSet.delete(e.pk);
        marcados.delete(e.pk);
        break;
      case 'deixar-fim':
        diagnostico = e.diagnostico || diagnostico;
        if ($('s-deixando').hidden) abrirDeixando();
        $('deixando-titulo').textContent = e.faltam ? 'Parou' : 'Terminou';
        $('deixando-status').textContent = e.texto;
        $('deixando-contas').textContent = contasEmTexto(e) + (e.faltam ? ' · faltam ' + e.faltam : '');
        if (!e.faltam) $('barra-deixando').style.width = '100%';
        $('deixando-nota').hidden = true;
        $('parar').hidden = true;
        $('deixando-voltar').hidden = false;
        $('deixando-voltar').textContent = resultado && resultado.plano === 'pro' ? 'Voltar à lista' : 'Voltar ao início';
        mostrar('deixando');
        break;
      default:
        break;
    }
  };

  // --- Deixar de seguir (1.0.0) -------------------------------------------
  function contasEmTexto(e) {
    if (e.rotulo) return (e.feitos || 0) + ' ' + e.rotulo + (e.feitos === 1 ? '' : 's') + ' de ' + (e.total || 0);
    return (e.feitos || 0) + ' deixada' + (e.feitos === 1 ? '' : 's') + ' de seguir'
      + (e.mantidos ? ' · ' + e.mantidos + ' mantida' + (e.mantidos === 1 ? '' : 's') + ' (segue você)' : '');
  }

  function abrirDeixando() {
    diagnostico = ''; // o da leitura não é o desta fila; o dela chega no fim
    $('deixando-titulo').textContent = 'Deixando de seguir…';
    $('deixando-status').textContent = 'Começando…';
    $('deixando-contas').textContent = '';
    $('barra-deixando').style.width = '4%';
    $('deixando-nota').hidden = false;
    $('parar').hidden = false;
    $('parar').disabled = false;
    $('parar').textContent = 'Parar';
    $('deixando-voltar').hidden = true;
    mostrar('deixando');
  }

  // O que o Instagram confirmou sai da lista na hora: deixada, ou já não
  // seguida, some; quem segue você vira mútuo.
  function tirarDaLista(e) {
    marcados.delete(e.pk);
    if (!resultado || !resultado.naoTeSegue) return;
    const i = resultado.naoTeSegue.findIndex((p) => p.pk === e.pk);
    if (i < 0) return;
    const [p] = resultado.naoTeSegue.splice(i, 1);
    if (e.como === 'mantido' && e.voceSegue) resultado.mutuos.push(p);
    pintarNumeros();
  }

  let escolhidas = [];
  let acao = 'deixar';
  const plural = (n, um, varios) => n + ' ' + (n === 1 ? um : varios);
  function marcadasVisiveis() {
    return visiveis().filter((p) => marcados.has(p.pk));
  }

  // A tela de ações: só aparece o que vale para as contas marcadas.
  $('deixar').addEventListener('click', () => {
    const m = marcadasVisiveis();
    if (!m.length) return;
    const fora = m.filter((p) => !closeSet.has(p.pk)).length;
    const dentro = m.length - fora;
    $('acoes-titulo').textContent = 'O que fazer com ' + plural(m.length, 'conta marcada?', 'contas marcadas?');
    $('acao-deixar').hidden = !podeDeixar();
    $('acao-deixar').textContent = 'Deixar de seguir ' + plural(m.length, 'conta', 'contas');
    $('acao-add').hidden = !fora || !app.closeFriends;
    $('acao-add').textContent = '★ Adicionar ' + fora + ' ao Close Friends';
    $('acao-remove').hidden = !dentro || !app.closeFriends;
    $('acao-remove').textContent = 'Remover ' + dentro + ' do Close Friends';
    $('acoes-nota').textContent = podeDeixar() ? '' : 'Deixar de seguir fica na lista "Não te seguem de volta".';
    mostrar('acoes');
  });
  $('acoes-voltar').addEventListener('click', () => mostrar('resultado'));

  async function confirmarClose(tipo) {
    acao = tipo;
    const entrar = tipo === 'add';
    escolhidas = marcadasVisiveis().filter((p) => closeSet.has(p.pk) !== entrar).map((p) => ({ pk: p.pk, username: p.username }));
    const n = escolhidas.length;
    $('conf-titulo').textContent = (entrar ? 'Adicionar ' : 'Remover ') + plural(n, 'conta', 'contas') + (entrar ? ' ao Close Friends?' : ' do Close Friends?');
    $('conf-nota').textContent = 'O Instagram não avisa ninguém quando você edita os Amigos Próximos. Uma conta a cada 2,5 a 6 segundos, com uma pausa a cada 25: os mesmos tempos da extensão.';
    $('conf-texto').textContent = 'Conferindo…';
    $('conf-sim').hidden = false;
    $('conf-sim').textContent = entrar ? 'Adicionar' : 'Remover';
    mostrar('confirmar');
    const sit = await app.situacaoClose(n);
    if (!sit) { $('conf-texto').textContent = ''; return; }
    if (!sit.cabem) { $('conf-texto').textContent = sit.motivo || 'Hoje não cabe mais nenhuma.'; $('conf-sim').hidden = true; return; }
    $('conf-texto').textContent = sit.cabem < n
      ? 'Hoje cabem ' + sit.cabem + ', pelo teto do dia que protege a sua conta. Leva ' + sit.tempo + '. Depois, é só repetir: o Mútuo manda só quem ainda falta.'
      : 'Leva ' + sit.tempo + '.';
  }
  $('acao-add').addEventListener('click', () => confirmarClose('add'));
  $('acao-remove').addEventListener('click', () => confirmarClose('remove'));

  $('acao-deixar').addEventListener('click', async () => {
    acao = 'deixar';
    escolhidas = marcadasVisiveis().map((p) => ({ pk: p.pk, username: p.username }));
    if (!escolhidas.length) return;
    const n = escolhidas.length;
    $('conf-titulo').textContent = 'Deixar de seguir ' + n + (n === 1 ? ' conta?' : ' contas?');
    $('conf-nota').textContent = 'Antes de cada conta, o Mútuo confere com o Instagram: quem segue você é mantido. Deixar de seguir não se desfaz.';
    $('conf-sim').textContent = 'Deixar de seguir';
    $('conf-texto').textContent = 'Conferindo…';
    $('conf-sim').hidden = false;
    mostrar('confirmar');
    const sit = await app.situacaoDeixar(n);
    if (!sit) { $('conf-texto').textContent = ''; return; }
    if (!sit.cabem) {
      $('conf-texto').textContent = sit.motivo || 'Hoje não cabe mais nenhuma.';
      $('conf-sim').hidden = true;
      return;
    }
    $('conf-texto').textContent = sit.hoje < n
      ? 'Hoje cabem ' + sit.hoje + ', o teto de ' + sit.teto + ' por dia que protege a sua conta. Elas levam ' + sit.tempo + '. As outras ' + (n - sit.hoje) + ' ficam guardadas, e você continua amanhã.'
      : 'Leva ' + sit.tempo + '. O teto é de ' + sit.teto + ' por dia, e hoje ainda cabem ' + sit.cabem + '.';
  });
  $('conf-sim').addEventListener('click', () => {
    abrirDeixando();
    if (acao === 'deixar') { app.deixar(escolhidas); return; }
    $('deixando-titulo').textContent = acao === 'add' ? 'Adicionando ao Close Friends…' : 'Removendo do Close Friends…';
    $('deixando-nota').hidden = true;
    app.closeFriends(acao, escolhidas);
  });
  $('conf-nao').addEventListener('click', () => mostrar('resultado'));
  $('marcar-todas').addEventListener('click', () => {
    // Como na extensão: age sobre exatamente o que o filtro mostra.
    const lista = visiveis();
    const todas = marcados.size && marcados.size === lista.length;
    marcados.clear();
    if (!todas) for (const p of lista) marcados.add(p.pk);
    pintarLista();
  });
  $('parar').addEventListener('click', () => {
    $('parar').disabled = true;
    $('parar').textContent = 'Parando…';
    app.pararDeixar();
  });
  $('deixando-voltar').addEventListener('click', () => {
    if (resultado && resultado.plano === 'pro') {
      pintarLista();
      mostrar('resultado');
    } else {
      mostrar('inicio');
      pintarPlano();
    }
  });
  if (app && app.continuarDeixar) {
    $('fila-continuar').addEventListener('click', () => { abrirDeixando(); app.continuarDeixar(); });
    $('fila-descartar').addEventListener('click', async () => { await app.descartarFila(); pintarPlano(); });
  }

  // --- Histórico (1.2.0) ----------------------------------------------------
  const ROTULO_EVENTO = {
    perdeu: 'deixou de te seguir',
    ganhou: 'começou a te seguir',
    segui: 'você começou a seguir',
    deixei: 'você deixou de seguir',
  };
  const data = (t) => new Date(t).toLocaleDateString('pt-BR', { day: '2-digit', month: '2-digit' });

  function pintarNovidades(n) {
    const bloco = $('bloco-historico');
    bloco.hidden = !(n && app && app.historico);
    if (bloco.hidden) return;
    let texto;
    if (n.primeira) texto = 'O histórico começa agora: na próxima leitura completa, o Mútuo mostra quem deixou de te seguir e quem começou desde hoje.';
    else if (!n.comparou) texto = 'Esta leitura veio com bem menos contas que a anterior, e por isso não foi comparada: poderia acusar quem não deixou de te seguir. Tente ler de novo mais tarde.';
    else if (!n.perdeu && !n.ganhou) texto = 'Desde a leitura de ' + data(n.desde) + ', ninguém deixou de te seguir e ninguém começou.';
    else texto = 'Desde a leitura de ' + data(n.desde) + ': ' + n.perdeu + (n.perdeu === 1 ? ' deixou' : ' deixaram') + ' de te seguir e ' + n.ganhou + (n.ganhou === 1 ? ' começou.' : ' começaram.');
    $('historico-resumo').textContent = texto;
    $('ver-historico').hidden = !n.total;
    $('ver-historico').textContent = 'Ver histórico (' + n.total + ')';
  }

  $('ver-historico').addEventListener('click', async () => {
    const r = await app.historico();
    const eventos = (r && r.eventos) || [];
    const ul = $('historico-lista');
    ul.textContent = '';
    $('historico-sub').textContent = eventos.length
      ? eventos.length + (eventos.length === 1 ? ' mudança registrada.' : ' mudanças registradas.') + ' As mais novas primeiro.'
      : 'Nada registrado ainda.';
    for (const e of eventos.slice(0, 300)) {
      const li = document.createElement('li');
      const quando = document.createElement('span');
      quando.className = 'historico-quando';
      quando.textContent = data(e.em);
      const quem = document.createElement('div');
      quem.className = 'quem';
      const forte = document.createElement('strong');
      forte.textContent = '@' + e.username;
      const oque = document.createElement('span');
      oque.className = 'historico-oque ' + e.tipo;
      oque.textContent = ROTULO_EVENTO[e.tipo] || e.tipo;
      quem.append(forte, oque);
      const abrir = document.createElement('button');
      abrir.type = 'button';
      abrir.className = 'abrir';
      abrir.textContent = 'Ver perfil';
      abrir.addEventListener('click', () => app.abrirPerfil(e.username));
      li.append(quando, quem, abrir);
      ul.appendChild(li);
    }
    if (eventos.length > 300) {
      const li = document.createElement('li');
      li.className = 'vazio';
      li.textContent = '… e mais ' + (eventos.length - 300) + ' mudanças anteriores.';
      ul.appendChild(li);
    }
    mostrar('historico');
  });
  $('historico-voltar').addEventListener('click', () => mostrar('resultado'));

  $('entrar').addEventListener('click', () => app && app.entrar());
  $('analisar').addEventListener('click', () => { if (app) { diagnostico = ''; app.analisar(); } });
  $('de-novo').addEventListener('click', () => { if (app) { diagnostico = ''; app.analisar(); } });
  $('tentar').addEventListener('click', () => {
    if (!app) return;
    if (JSON.parse(app.estado()).logado) { mostrar('inicio'); app.conta(); pintarPlano(); } else { mostrar('entrar'); }
  });
  $('sair').addEventListener('click', () => app && app.sair());
  // O plano e a chave (etapa 1.2, 13/10/2026). Só existe onde a ponte sabe
  // responder (o iPhone); a decisão é do licenca.js da extensão.
  let ehPro = false;
  async function pintarPlano() {
    if (!app || !app.plano) return;
    const p = await app.plano();
    ehPro = Boolean(p.pro);
    $('selo-plano').hidden = false;
    $('selo-plano').textContent = ehPro ? 'Plano PRO ativo' : 'Plano grátis';
    $('selo-plano').classList.toggle('ativo', ehPro);
    const aviso = (p.aviso && p.aviso.texto) || p.mensagem || '';
    $('aviso-plano').hidden = !aviso;
    $('aviso-plano').textContent = aviso;
    $('abrir-chave').hidden = ehPro;
    if (ehPro) $('bloco-chave').hidden = true;
    // O PRO lê a conta inteira (etapa 1.3). O tempo vem do ritmo da
    // extensão: ~2 s por página de 50, dos dois lados.
    // Uma fila de deixar de seguir que parou (teto do dia, tela apagada, Parar).
    const fila = ehPro && app.filaDeixar ? await app.filaDeixar() : null;
    $('bloco-fila').hidden = !fila;
    if (fila) $('fila-texto').textContent = 'Uma fila de deixar de seguir ficou pela metade: faltam ' + fila.faltam + ' de ' + fila.total + ' contas. Antes de cada uma, o Mútuo confere de novo se ela segue você.';
    const continuar = ehPro && app.temPonto ? await app.temPonto() : false;
    $('analisar').textContent = ehPro ? (continuar ? 'Continuar a leitura' : 'Analisar a conta inteira') : 'Analisar 50 perfis';
    $('nota-analisar').textContent = ehPro
      ? (continuar
        ? 'Uma leitura anterior parou no meio, e o que ela leu está guardado. A leitura continua de onde parou.'
        : 'O PRO lê todos os seus seguidores e quem você segue. Leva uns 2 minutos a cada 2.500 perfis. Deixe o Safari aberto nesta aba até terminar: se a tela apagar, a leitura pausa e continua de onde parou.')
      : 'O plano grátis analisa 50 perfis da sua conta, no ritmo que protege você de bloqueio. Leva cerca de um minuto.';
  }
  if (app && app.ativarChave) {
    $('abrir-chave').addEventListener('click', () => {
      $('abrir-chave').hidden = true;
      $('bloco-chave').hidden = false;
      $('chave').focus();
    });
    $('ativar').addEventListener('click', async () => {
      const msg = $('chave-msg');
      const chave = $('chave').value;
      if (!chave.trim()) { msg.hidden = false; msg.textContent = 'Cole a chave primeiro.'; return; }
      $('ativar').disabled = true;
      msg.hidden = false;
      msg.textContent = 'Conferindo a chave…';
      const r = await app.ativarChave(chave);
      $('ativar').disabled = false;
      if (r.ok) {
        $('chave').value = '';
        msg.hidden = true;
        await pintarPlano();
      } else {
        msg.textContent = r.mensagem;
      }
    });
  }
  $('planos').addEventListener('click', () => app && app.abrirPlanos && app.abrirPlanos());
  $('copiar').addEventListener('click', () => {
    if (app) app.copiar(diagnostico);
    $('copiar').textContent = 'Copiado';
    setTimeout(() => { $('copiar').textContent = 'Copiar diagnóstico'; }, 2000);
  });
  for (const card of raiz.querySelectorAll('.card')) {
    card.addEventListener('click', () => { listaAtual = card.dataset.lista; mostrando = 100; marcados.clear(); $('exportar-msg').hidden = true; pintarLista(); });
  }
  // Trocar o filtro desmarca tudo: marcar e agir valem só para o que está à vista.
  for (const chip of raiz.querySelectorAll('[data-filtro]')) {
    chip.addEventListener('click', () => { filtro = chip.dataset.filtro; mostrando = 100; marcados.clear(); pintarLista(); });
  }
  for (const chip of raiz.querySelectorAll('[data-close]')) {
    chip.addEventListener('click', () => { filtroClose = chip.dataset.close; mostrando = 100; marcados.clear(); pintarLista(); });
  }
  for (const chip of raiz.querySelectorAll('[data-ordem]')) {
    chip.addEventListener('click', () => { ordem = chip.dataset.ordem; mostrando = 100; pintarLista(); });
  }
  async function exportar(formato) {
    if (!app || !app.exportar) return;
    const pessoas = visiveis().map((p) => ({ ...p, lista: listaAtual }));
    const msg = $('exportar-msg');
    const r = await app.exportar(formato, pessoas, descreverFiltro(), contaAtual);
    msg.hidden = false;
    msg.textContent = r && r.ok
      ? r.total + (r.total === 1 ? ' conta exportada.' : ' contas exportadas.') + ' Confira em Arquivos, na pasta Downloads.'
      : (r && r.mensagem) || 'Não consegui exportar.';
  }
  $('exportar-csv').addEventListener('click', () => exportar('csv'));
  $('exportar-json').addEventListener('click', () => exportar('json'));

  // Abertura: com sessão, a tela da conta; sem, a de entrar.
  if (!app) {
    mostrarErro('Esta tela só funciona dentro do app do Mútuo.');
    return;
  }
  const estado = JSON.parse(app.estado());
  $('versao').textContent = 'versão ' + estado.versao;
  // No iPhone o botão do topo fecha as telas (a conta continua no Safari), e
  // entrar é fazer o login na própria página do Instagram.
  fecharSempre = Boolean(estado.fecharSempre);
  if (estado.textoSair) $('sair').textContent = estado.textoSair;
  if (estado.notaEntrar) $('nota-entrar').textContent = estado.notaEntrar;
  logado(estado.logado);
  if (estado.logado) {
    mostrar('inicio');
    app.conta();
    pintarPlano();
  } else {
    mostrar('entrar');
  }
})();

  }

  // O botão é a única coisa que o script faz sozinho. Nada é lido antes do toque.
  const botao = document.createElement('button');
  botao.id = 'mutuo-botao';
  botao.type = 'button';
  botao.setAttribute('aria-label', 'Abrir o Mútuo');
  Object.assign(botao.style, {
    position: 'fixed', right: '14px', bottom: 'calc(76px + env(safe-area-inset-bottom))',
    zIndex: '2147483646', width: '52px', height: '52px', padding: '0', border: '0',
    borderRadius: '16px', background: '#c81e6e', boxShadow: '0 4px 14px rgba(0,0,0,.28)',
    cursor: 'pointer', overflow: 'hidden',
  });
  const img = document.createElement('img');
  img.src = "data:image/png;base64,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";
  img.alt = '';
  Object.assign(img.style, { width: '100%', height: '100%', display: 'block' });
  botao.appendChild(img);
  botao.addEventListener('click', function () {
    if (window.__mutuoHost) {
      window.__mutuoHost.style.display = 'block';
      if (window.MutuoApp) window.MutuoApp.conta();
      return;
    }
    try { abrirMutuo(); } catch (e) { alert('O Mútuo não abriu: ' + (e && e.message ? e.message : e)); }
  });
  document.documentElement.appendChild(botao);
})();