@unbox-plus/cli 0.20.4

package/template/lib/enrichment/index.ts

@@ -0,0 +1,188 @@
+// ===== Padrão de enriquecimento de produtos =====
+// Dados que NÃO vêm da Unbox (composição, medidas, origem, EAN, SEO, FAQ, reviews, combos,
+// "compre junto" — e tabela nutricional/alergênicos quando o produto for alimento ou
+// suplemento) ficam aqui, em products.json, indexados pelo SKU. A junção com o produto Unbox
+// é pelo `sku` (produto ou variante). Quem preenche é o briefing, a partir do material real da
+// marca. Todo campo é opcional na prática: o que estiver vazio simplesmente não renderiza.
+//
+// Uso (server-side, ex.: na PDP): getEnrichmentForProduct(product) → mescla com os dados da Unbox.
+// Importar SÓ em Server Components / rotas (o JSON é grande; não use em client components).
+import raw from "./products.json";
+
+export interface NutritionTable {
+  /** "100g" | "Porção" */
+  base: string;
+  observacao?: string;
+  /** ex.: { valor_energetico_kcal: 364.5, sodio_mg: 3557.99, ... } */
+  nutrientes: Record<string, number>;
+}
+
+export interface EnrichmentReview {
+  author: string;
+  stars: number;
+  comment: string;
+}
+
+export interface EnrichmentFaq {
+  question: string;
+  answer: string;
+}
+
+export interface ProductEnrichment {
+  /** chave de junção com a Unbox (variant.sku / product.sku) */
+  sku: string;
+  /** código de família (agrupa variações de tamanho do mesmo produto), ex.: "LINHA_A" */
+  familyCode: string;
+  /** SKU agrupador de variações, ex.: "PAI-LINHA_A" */
+  parentSku: string;
+  name: string;
+  /** descrição curta interna (não SEO) */
+  description: string;
+  weight: { value: number; unit: string } | null;
+  /** composição: ingredientes (alimento), INCI (cosmético), materiais (vestuário/objeto) */
+  ingredients: string;
+  /** passos de uso do produto, exibidos como "Modo de uso" na PDP. Vazio = bloco não aparece. */
+  usage?: string[];
+  origin: string;
+  containsGluten: boolean | null;
+  vegan: boolean | null;
+  allergens: { inIngredients: string; mayContain: string };
+  ean: string;
+  dimensionsCm: { length: number | null; width: number | null; height: number | null } | null;
+  nutrition: NutritionTable | null;
+  seo: { shortDescription: string; longDescriptionHtml: string; keywords: string[]; title: string };
+  /** tags/categorias livres da planilha */
+  tags: string[];
+  /** categorias normalizadas */
+  categoriesOptimized: string[];
+  collections: string[];
+  /** descrição textual de combo sugerido */
+  combo: string;
+  /** SKUs para "Compre junto" */
+  buyTogetherSkus: string[];
+  /** SKUs para "Frequentemente comprados juntos" */
+  frequentlyBoughtSkus: string[];
+  faq: EnrichmentFaq[];
+  reviews: EnrichmentReview[];
+}
+
+const DATA = raw as unknown as Record<string, ProductEnrichment>;
+
+const norm = (sku: unknown): string => String(sku ?? "").trim();
+
+/** Enriquecimento por SKU exato. */
+export function getEnrichmentBySku(sku?: string | number | null): ProductEnrichment | null {
+  const k = norm(sku);
+  return k && DATA[k] ? DATA[k] : null;
+}
+
+// ----- Matching por NOME (a Unbox NÃO expõe SKU/EAN; juntamos pelo nome) -----
+// Estratégia: o título Unbox segue "Nome PT - Nome EN [tamanho]". O nome EN (após o último " - ")
+// é o identificador distintivo. Casamos exigindo que (quase) todos os tokens do nome EN estejam
+// presentes no nome do doc — evita falsos positivos (ex.: "Cilantro Lime" ≠ "Chile & Lime").
+// Adicione aqui palavras a ignorar no matching de nomes (ex.: o nome da sua marca, que
+// costuma aparecer em todos os títulos e por isso não ajuda a diferenciar produtos).
+const STOP = new Set(["de", "do", "da", "com", "e", "em", "para", "the", "a", "o", "no", "na"]);
+const SIZE_RE = /[\d]+[.,]?[\d]*\s*(g|ml|kg|l)\b/gi;
+function nameTokens(s: string): Set<string> {
+  const toks = (s || "")
+    .normalize("NFD").replace(/[̀-ͯ]/g, "")
+    .toLowerCase()
+    .replace(/[®™]/g, "")
+    .replace(SIZE_RE, " ")
+    .replace(/[^a-z0-9\s]/g, " ") // mantém o conteúdo dos parênteses (remove só os símbolos)
+    .split(/\s+/)
+    .filter((t) => t.length > 1 && !STOP.has(t));
+  return new Set(toks);
+}
+/** Tokens do nome EN (parte após o PRIMEIRO " - ", já sem tamanho). */
+function enTokens(title: string): Set<string> {
+  const clean = (title || "").replace(SIZE_RE, " ");
+  const idx = clean.indexOf(" - ");
+  return nameTokens(idx >= 0 ? clean.slice(idx + 3) : clean);
+}
+function containment(small: Set<string>, big: Set<string>): number {
+  if (small.size === 0) return 0;
+  let inter = 0;
+  for (const x of small) if (big.has(x)) inter++;
+  return inter / small.size;
+}
+// Similaridade simétrica (Jaccard) — usada como desempate para separar a família "base" de uma
+// variante com modificador (ex.: "Base" vs "Base Plus"), que empatam no score de containment.
+function jaccard(a: Set<string>, b: Set<string>): number {
+  if (a.size === 0 && b.size === 0) return 0;
+  let inter = 0;
+  for (const x of a) if (b.has(x)) inter++;
+  return inter / (a.size + b.size - inter);
+}
+const NAME_INDEX = Object.values(DATA).map((e) => ({ e, toks: nameTokens(e.name) }));
+const NAME_THRESHOLD = 0.7;
+
+/**
+ * Enriquecimento pelo NOME (ignora tamanho/acentos). Score = melhor de:
+ *  - nome EN do produto contido no nome do doc (casos com nome do doc em inglês), ou
+ *  - nome do doc contido no título completo do produto (casos com nome do doc em PT).
+ * Limiar 0.7 evita falsos positivos (ex.: "Cilantro Lime" não casa com "Chile & Lime").
+ * Empates de score são desempatados pela similaridade Jaccard(título, nome do doc): assim "Paprika"
+ * casa com a família base e não com "Paprika Smoked" (que tem tokens extras).
+ */
+export function getEnrichmentByName(title?: string | null): ProductEnrichment | null {
+  if (!title) return null;
+  const en = enTokens(title);
+  const full = nameTokens(title);
+  if (full.size === 0) return null;
+  let best: ProductEnrichment | null = null;
+  let bestScore = 0;
+  let bestTie = 0;
+  for (const { e, toks } of NAME_INDEX) {
+    const sc = Math.max(containment(en, toks), containment(toks, full));
+    const tie = jaccard(full, toks);
+    if (sc > bestScore || (sc === bestScore && tie > bestTie)) {
+      bestScore = sc; bestTie = tie; best = e;
+    }
+  }
+  return bestScore >= NAME_THRESHOLD ? best : null;
+}
+
+/** Resolve o enriquecimento de um produto Unbox: tenta SKU (produto/variantes) e cai no nome. */
+export function getEnrichmentForProduct(product: any): ProductEnrichment | null {
+  const candidates = [product?.sku, ...((product?.variants ?? []).map((v: any) => v?.sku))].filter(Boolean);
+  for (const c of candidates) {
+    const e = getEnrichmentBySku(c);
+    if (e) return e;
+  }
+  return getEnrichmentByName(product?.title);
+}
+
+/** Lista de enriquecimentos a partir de uma lista de SKUs (ignora os não encontrados). */
+export function getEnrichmentBySkus(skus: string[]): ProductEnrichment[] {
+  return skus.map((s) => getEnrichmentBySku(s)).filter((e): e is ProductEnrichment => !!e);
+}
+
+// ----- Famílias (mesmo familyCode) -----
+// Cada produto Unbox é UM tamanho de uma família; o tamanho vive no título ("297,7 g"), não em
+// variante. Agrupamos pelo `familyCode` da planilha — resolvido por nome, já que a Unbox não expõe
+// SKU e o casamento por nome ignora o tamanho (todos os irmãos compartilham o mesmo nome EN).
+
+const ONE_SIZE_RE = /(\d+(?:[.,]\d+)?)\s*(g|kg|ml|l)\b/i;
+
+/** Extrai peso/volume de um texto livre (ex.: título "Produto X 250 g" → {value: 250, unit: "g"}). */
+export function parseSize(text?: string | null): { value: number; unit: string } | null {
+  if (!text) return null;
+  const m = text.match(ONE_SIZE_RE);
+  if (!m) return null;
+  return { value: parseFloat(m[1].replace(",", ".")), unit: m[2].toLowerCase() };
+}
+
+/** familyCode de um produto Unbox (via SKU ou nome). Agrupa as variações de tamanho. */
+export function getFamilyCode(product: any): string | null {
+  return getEnrichmentForProduct(product)?.familyCode ?? null;
+}
+
+/** Média de avaliações (para rating real vindo da planilha, quando houver). */
+export function reviewStats(e: ProductEnrichment | null): { count: number; average: number } | null {
+  if (!e || e.reviews.length === 0) return null;
+  const count = e.reviews.length;
+  const average = e.reviews.reduce((s, r) => s + (r.stars || 0), 0) / count;
+  return { count, average: Math.round(average * 10) / 10 };
+}

package/template/lib/enrichment/products.json

@@ -0,0 +1 @@
+{}

package/template/lib/env-check.ts

@@ -0,0 +1,47 @@
+// Sanidade das variáveis de ambiente — roda uma vez no boot do servidor (importado pelo
+// lib/config.ts). Não valida segredo (impossível), valida FORMA: um valor que parece prosa
+// ("chave da loja (x-api-key...)") é sinal de que o comentário do .env virou valor no deploy.
+// Presença truthy não é validade — foi essa confusão que derrubou a /api/capi de uma loja.
+import "server-only";
+
+const CHAVES = [
+  "UNBOX_PARTNER_API_KEY", "UNBOX_CAPTCHA_BYPASS", "UNBOX_API_KEY", "UNBOX_USER", "UNBOX_PASS",
+  "UNBOX_SHOP_ID", "UNBOX_SHOP_SLUG", "UNBOX_WEBHOOK_SECRET", "SESSION_SECRET", "REVALIDATE_SECRET",
+  "UNBOX_HOSTED_CHECKOUT_URL", "META_PIXEL_ID", "META_CAPI_TOKEN", "NEXT_PUBLIC_GA_ID",
+  "NEXT_PUBLIC_META_PIXEL_ID", "PREVIEW_PASSWORD", "PIPEDRIVE_API_TOKEN", "PREVIEW_WEBHOOK_URL",
+];
+
+/** Parece comentário/prosa: tem `#`, ou tem espaço, ou é uma frase com acento/parênteses. */
+function pareceProsa(v: string) {
+  return /#/.test(v) || /\s/.test(v.trim()) || /[()áéíóúãõçÁÉÍÓÚÃÕÇ]/.test(v);
+}
+
+let avisado = false;
+export function checkEnv() {
+  if (avisado) return;
+  avisado = true;
+  const problemas: string[] = [];
+  for (const k of CHAVES) {
+    const v = process.env[k];
+    // NUNCA imprime o valor: a lista inclui senha e tokens, e o próprio .env.example sugere
+    // UNBOX_PASS="#minhaSenha$123" — com o `#` ela cairia aqui e iria inteira pro log da Vercel.
+    // Só o nome da variável e o motivo.
+    if (v && pareceProsa(v)) problemas.push(`${k}: contém ${/#/.test(v) ? "'#'" : /\s/.test(v.trim()) ? "espaço" : "acento/parêntese"} (parece comentário copiado como valor)`);
+  }
+  const pixel = process.env.META_PIXEL_ID;
+  if (pixel && !/^\d{5,}$/.test(pixel)) problemas.push("META_PIXEL_ID: não é numérico");
+  const ga = process.env.NEXT_PUBLIC_GA_ID;
+  if (ga && !/^G-[A-Z0-9]{6,}$/i.test(ga)) problemas.push("NEXT_PUBLIC_GA_ID: não tem a forma G-XXXXXXX");
+  const site = process.env.NEXT_PUBLIC_SITE_URL ?? "";
+  if (process.env.NODE_ENV === "production" && (!site || /localhost|127\.0\.0\.1/.test(site) || !site.startsWith("https://"))) {
+    problemas.push("NEXT_PUBLIC_SITE_URL: ausente ou localhost em PRODUÇÃO — canonical, sitemap, robots, Open Graph, JSON-LD e o link de recuperação de carrinho saem apontando para localhost");
+  }
+  if (process.env.NODE_ENV === "production" && (!process.env.SESSION_SECRET || process.env.SESSION_SECRET.includes("dev-insecure"))) {
+    problemas.push("SESSION_SECRET: vazio ou default de desenvolvimento em PRODUÇÃO — a posse dos pedidos (cookie unbox_order_*) fica forjável; gere um valor aleatório longo");
+  }
+  if (problemas.length) {
+    console.warn("\n⚠ [env] valores que parecem COMENTÁRIO copiado como valor (o .env tinha `CHAVE=  # texto`?):");
+    for (const p of problemas) console.warn("   • " + p);
+    console.warn("   Corrija no painel de variáveis do deploy. Enquanto isso, a integração correspondente vai falhar.\n");
+  }
+}

package/template/lib/format.ts

@@ -0,0 +1,130 @@
+// Utilitários puros de formatação/preço — seguros no client e no server (sem segredos).
+
+const BRL = new Intl.NumberFormat("pt-BR", { style: "currency", currency: "BRL" });
+
+/** Formata um número em BRL. Use o `displayAmount` da API quando existir; isto é fallback. */
+export function formatBRL(amount: number | null | undefined): string {
+  if (amount == null || Number.isNaN(amount)) return "—";
+  return BRL.format(amount);
+}
+
+export interface ResolvedPrice {
+  price: number | null;
+  displayPrice: string;
+  compareAt?: string | null; // preço "de" (riscado), se houver
+}
+
+/**
+ * Resolve o preço REAL de uma variante. ⚠️ O preço vive na variante (`variant.pricing[0]`),
+ * NÃO em `product.pricing` (que é só agregado min/max). Acesso defensivo a array vs objeto.
+ */
+export function resolveVariantPrice(variant: any): ResolvedPrice {
+  const p = Array.isArray(variant?.pricing) ? variant.pricing[0] : variant?.pricing;
+  return {
+    price: p?.price ?? null,
+    displayPrice: p?.displayPrice ?? formatBRL(p?.price),
+    compareAt: p?.compareAtPrice?.displayAmount ?? null,
+  };
+}
+
+/** Preço de vitrine a partir do node do catálogo (usa a 1ª variante; fallback no agregado). */
+export function resolveProductPrice(product: any): ResolvedPrice {
+  const v = product?.variants?.[0];
+  if (v) return resolveVariantPrice(v);
+  const agg = Array.isArray(product?.pricing) ? product.pricing[0] : product?.pricing;
+  return { price: agg?.minPrice ?? null, displayPrice: agg?.displayPrice ?? formatBRL(agg?.minPrice), compareAt: null };
+}
+
+/** Aplica % de desconto a um valor (ex.: preview de assinatura) e devolve string BRL. */
+export function applyPercentOff(amount: number, percent: number): string {
+  return formatBRL(amount * (1 - percent / 100));
+}
+
+/** Máscara/normalização simples de CEP (8 dígitos). */
+export function onlyDigits(s: string): string {
+  return (s ?? "").replace(/\D/g, "");
+}
+
+export function maskCep(s: string): string {
+  const d = onlyDigits(s).slice(0, 8);
+  return d.length > 5 ? `${d.slice(0, 5)}-${d.slice(5)}` : d;
+}
+
+/** Máscara de telefone BR — (11) 99999-9999 (celular) ou (11) 9999-9999 (fixo). */
+export function maskPhone(s: string): string {
+  const d = onlyDigits(s).slice(0, 11);
+  if (d.length <= 2) return d.length ? `(${d}` : "";
+  if (d.length <= 6) return `(${d.slice(0, 2)}) ${d.slice(2)}`;
+  if (d.length <= 10) return `(${d.slice(0, 2)}) ${d.slice(2, 6)}-${d.slice(6)}`;
+  return `(${d.slice(0, 2)}) ${d.slice(2, 7)}-${d.slice(7)}`;
+}
+
+/** Máscara de CPF — 000.000.000-00. */
+export function maskCpf(s: string): string {
+  const d = onlyDigits(s).slice(0, 11);
+  if (d.length <= 3) return d;
+  if (d.length <= 6) return `${d.slice(0, 3)}.${d.slice(3)}`;
+  if (d.length <= 9) return `${d.slice(0, 3)}.${d.slice(3, 6)}.${d.slice(6)}`;
+  return `${d.slice(0, 3)}.${d.slice(3, 6)}.${d.slice(6, 9)}-${d.slice(9)}`;
+}
+
+/** Validação de CPF pelos dígitos verificadores (rejeita sequências repetidas). */
+export function isValidCpf(s: string): boolean {
+  const c = onlyDigits(s);
+  if (c.length !== 11 || /^(\d)\1{10}$/.test(c)) return false;
+  let sum = 0;
+  for (let i = 0; i < 9; i++) sum += parseInt(c[i], 10) * (10 - i);
+  let d1 = (sum * 10) % 11;
+  if (d1 === 10) d1 = 0;
+  if (d1 !== parseInt(c[9], 10)) return false;
+  sum = 0;
+  for (let i = 0; i < 10; i++) sum += parseInt(c[i], 10) * (11 - i);
+  let d2 = (sum * 10) % 11;
+  if (d2 === 10) d2 = 0;
+  return d2 === parseInt(c[10], 10);
+}
+
+/** Validação simples de formato de e-mail. */
+export function isValidEmail(s: string): boolean {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test((s ?? "").trim());
+}
+
+// ----- Sanitização de input: bloqueia caracteres que não pertencem ao campo -----
+
+/** Nome próprio: apenas letras (com acento), espaço, apóstrofo, ponto e hífen. */
+export function sanitizeName(s: string): string {
+  return (s ?? "").replace(/[^\p{L}\s'’.-]/gu, "").replace(/\s{2,}/g, " ").replace(/^\s+/, "");
+}
+
+/** E-mail: sem espaços e só caracteres válidos de e-mail. */
+export function sanitizeEmail(s: string): string {
+  return (s ?? "").replace(/\s+/g, "").replace(/[^a-zA-Z0-9@._%+\-]/g, "");
+}
+
+/** Texto de endereço (rua, bairro, complemento): letras, números, espaço e pontuação comum. */
+export function sanitizeText(s: string): string {
+  return (s ?? "").replace(/[^\p{L}\p{N}\s.,'’ºª°#/-]/gu, "").replace(/\s{2,}/g, " ").replace(/^\s+/, "");
+}
+
+/** Número do endereço: dígitos, letras e barra (ex.: 123, 123A, S/N). */
+export function sanitizeHouseNumber(s: string): string {
+  return (s ?? "").replace(/[^0-9A-Za-z/]/g, "");
+}
+
+/** UF: apenas letras, maiúsculas, no máximo 2. */
+export function sanitizeUf(s: string): string {
+  return (s ?? "").toUpperCase().replace(/[^A-Z]/g, "").slice(0, 2);
+}
+
+/** Número do cartão: dígitos agrupados em blocos de 4 (até 19 dígitos). */
+export function maskCardNumber(s: string): string {
+  const d = onlyDigits(s).slice(0, 19);
+  return d.replace(/(.{4})/g, "$1 ").trim();
+}
+
+/** Converte um displayAmount BR ("R$ 1.234,56") em número. Retorna null se inválido. */
+export function parseBRL(s?: string | null): number | null {
+  if (!s) return null;
+  const n = Number(s.replace(/[^\d,.-]/g, "").replace(/\./g, "").replace(",", "."));
+  return Number.isNaN(n) ? null : n;
+}

package/template/lib/icons.ts

@@ -0,0 +1,67 @@
+/**
+ * Registro central de ícones — Phosphor Icons.
+ *
+ * Usamos o entry `/dist/ssr`, que não depende de React Context e portanto
+ * funciona tanto em Server Components quanto em Client Components (App Router).
+ *
+ * Os nomes são exportados com os aliases usados no código (herdados do lucide)
+ * para manter as chamadas JSX existentes; à direita fica o ícone Phosphor real.
+ * Para adicionar um ícone novo, importe de `@phosphor-icons/react/dist/ssr`.
+ */
+export {
+  // Navegação / setas
+  ArrowRight,
+  CaretDown as ChevronDownIcon,
+  CaretUp as ChevronUpIcon,
+  CaretLeft as ChevronLeft,
+  CaretLeft as ChevronLeftIcon,
+  CaretRight as ChevronRight,
+  CaretRight as ChevronRightIcon,
+  DotsThree as MoreHorizontalIcon,
+  List as Menu,
+
+  // Ações
+  MagnifyingGlass as Search,
+  MagnifyingGlass as SearchIcon,
+  Copy,
+  Trash as Trash2,
+  PencilSimple as Pencil,
+  Plus,
+  Minus,
+  Minus as MinusIcon,
+  ArrowsClockwise as RefreshCw,
+  X as XIcon,
+  SignOut as LogOut,
+
+  // Status / feedback
+  Check,
+  Check as CheckIcon,
+  CheckCircle as CheckCircle2,
+  CheckCircle as CircleCheckIcon,
+  XCircle,
+  Info as InfoIcon,
+  Warning as TriangleAlertIcon,
+  WarningOctagon as OctagonXIcon,
+  CircleNotch as Loader2,
+  CircleNotch as Loader2Icon,
+
+  // Comércio / conta
+  ShoppingBag,
+  CreditCard,
+  Tag,
+  Truck,
+  Package,
+  Package as PackageOpen,
+  MapPin,
+  User,
+  Lock,
+  Key as KeyRound,
+  QrCode,
+  Envelope as Mail,
+  ShieldCheck,
+  Gear as Settings,
+  SquaresFour as LayoutDashboard,
+  ListChecks,
+  Pause,
+  SkipForward,
+} from "@phosphor-icons/react/dist/ssr";

package/template/lib/json-ld.ts

@@ -0,0 +1,9 @@
+/** Serializa dado estruturado para dentro de <script type="application/ld+json">.
+ *
+ *  O `<` PRECISA virar \u003c: qualquer string vinda do catálogo (título, descrição, uma
+ *  resposta de FAQ) que contenha `</script>` fecharia a tag e derrubaria o resto da página.
+ *  É a única sanitização necessária aqui, e vale para todo JSON-LD do projeto.
+ */
+export function ldJson(dado: unknown): string {
+  return JSON.stringify(dado).replace(/</g, "\\u003c");
+}

package/template/lib/llms-txt.ts

@@ -0,0 +1,75 @@
+// Montagem do /llms.txt. Separado da rota de propósito: aqui é função pura (dado → texto), o que
+// deixa o formato testável sem subir servidor nem bater na API.
+//
+// Formato: seções em LISTA DE LINKS markdown, como pede a especificação do llms.txt. Arquivo sem
+// link nenhum reprova na auditoria Agent Accessibility do PageSpeed, e um agente que não consegue
+// navegar a partir daqui simplesmente não usa o arquivo.
+import type { CatalogProductItem } from "@/components/catalog/catalog-client";
+
+export interface OpcoesLlms {
+  siteName: string;
+  /** Base absoluta (NEXT_PUBLIC_SITE_URL). Vazio = links relativos. */
+  siteUrl?: string;
+  descricao?: string;
+  categorias: { nome: string; slug: string }[];
+  pixDescontoPct?: number;
+  freteGratisAcimaDe?: number | null;
+  /** O arquivo é para leitura, não é o catálogo: acima disso, o agente segue o link de /produtos. */
+  maxProdutos?: number;
+}
+
+export function montarLlmsTxt(produtos: CatalogProductItem[], o: OpcoesLlms): string {
+  const base = (o.siteUrl ?? "").replace(/\/+$/, "");
+  const link = (caminho: string) => `${base}${caminho}`;
+  const max = o.maxProdutos ?? 60;
+  const linhas: string[] = [`# ${o.siteName}`, ""];
+
+  if (o.descricao?.trim()) linhas.push(`> ${o.descricao.trim()}`, "");
+
+  const categoriasDosProdutos = [...new Set(produtos.flatMap((p) => p.categories))].slice(0, 12);
+  if (categoriasDosProdutos.length) linhas.push(`Categorias: ${categoriasDosProdutos.join(", ")}.`, "");
+
+  if (produtos.length) {
+    linhas.push("## Produtos", "");
+    for (const p of produtos.slice(0, max)) {
+      // Preço e disponibilidade saem do MESMO mapeamento que desenha a vitrine: o esgotado do
+      // painel aparece aqui sozinho, sem ninguém manter uma segunda lista.
+      const detalhe = [p.displayPrice, p.soldOut ? "esgotado" : null, p.weight || null].filter(Boolean).join(" · ");
+      linhas.push(`- [${p.title}](${link(`/produto/${encodeURIComponent(p.slug)}`)})${detalhe ? `: ${detalhe}` : ""}`);
+    }
+    if (produtos.length > max) {
+      linhas.push(`- [Ver o catálogo completo](${link("/produtos")}): mais ${produtos.length - max} produtos`);
+    }
+    linhas.push("");
+  }
+
+  if (o.categorias.length) {
+    linhas.push("## Categorias", "");
+    for (const c of o.categorias.slice(0, 30)) {
+      linhas.push(`- [${c.nome}](${link(`/categoria/${encodeURIComponent(c.slug)}`)})`);
+    }
+    linhas.push("");
+  }
+
+  linhas.push(
+    "## Páginas", "",
+    `- [Início](${link("/")}): destaques e produtos em evidência`,
+    `- [Catálogo](${link("/produtos")}): todos os produtos, com filtros por categoria e preço`,
+    `- [Busca](${link("/busca")}): busca por nome de produto`,
+    `- [Minha conta](${link("/conta")}): acompanhamento de pedidos e assinaturas`,
+    "",
+    "## Políticas", "",
+    `- [Trocas e devoluções](${link("/devolucoes")}): direito de arrependimento de 7 dias (CDC, art. 49)`,
+    `- [Termos de uso](${link("/termos")}): condições de compra`,
+    `- [Política de privacidade](${link("/privacidade")}): tratamento de dados pessoais (LGPD)`,
+    "",
+    "## Como comprar", "",
+    `- Pagamento: Pix${(o.pixDescontoPct ?? 0) > 0 ? ` (${o.pixDescontoPct}% de desconto)` : ""} e cartão de crédito`,
+    "- Entrega: frete calculado por CEP no checkout, para todo o Brasil",
+  );
+  // Só afirma o que a loja tem configurado de fato (mesma regra do resto do template).
+  if (o.freteGratisAcimaDe != null) linhas.push(`- Frete grátis a partir de R$ ${o.freteGratisAcimaDe}`);
+  linhas.push("");
+
+  return linhas.join("\n");
+}

package/template/lib/mockup.ts

@@ -0,0 +1,24 @@
+import "server-only";
+import { hasUnboxCredentials } from "./config";
+
+/**
+ * Único lugar onde "a API falhou" pode virar "resultado vazio". Sem credenciais (modo mockup)
+ * devolve o fallback em silêncio: é o comportamento esperado de um scaffold sem .env. COM
+ * credenciais, loga e RELANÇA — a falha tem que aparecer.
+ *
+ * Por que isso importa: os `.catch(() => [])` espalhados nas páginas tratavam "Unbox fora do
+ * ar" igual a "sem credenciais". Em produção isso produzia home e catálogo VAZIOS com HTTP 200,
+ * que o ISR então CACHEAVA por 5 minutos no lugar da versão boa (o Next só preserva a versão
+ * anterior quando a regeneração lança), sem uma linha de log. E nos layouts de produto e
+ * categoria, virava `notFound()` — 404 real e cacheado na rota mais indexada da loja. Relançar
+ * dá ao ISR a chance de manter a página anterior e ao error.tsx a chance de existir.
+ */
+export async function mockupOr<T, F = T>(promessa: Promise<T>, fallback: F, rotulo: string): Promise<T | F> {
+  try {
+    return await promessa;
+  } catch (e) {
+    if (!hasUnboxCredentials) return fallback;
+    console.error(`[unbox] falha em ${rotulo} COM credenciais configuradas — não é modo mockup:`, e instanceof Error ? e.message : e);
+    throw e;
+  }
+}

package/template/lib/newsletter.ts

@@ -0,0 +1,12 @@
+/**
+ * Para onde vai o e-mail capturado. UM lugar só, lido por todo bloco de captura da loja
+ * (rodapé "conversão", catálogo e a seção `newsletter` da home).
+ *
+ * REGRA: sem destino, o bloco NÃO RENDERIZA. Formulário que engole o e-mail em silêncio é pior
+ * que não ter formulário: a pessoa acha que se cadastrou e a loja não tem o contato. Foi o que
+ * dois blocos desta foundation faziam, com `onSubmit={(e) => e.preventDefault()}`.
+ *
+ * O valor é a URL que recebe o POST do formulário (endpoint do CRM/ESP: Klaviyo, Revi, Mailchimp,
+ * um Route Handler próprio). É `NEXT_PUBLIC_` porque o formulário é HTML no navegador.
+ */
+export const NEWSLETTER_ACTION = process.env.NEXT_PUBLIC_NEWSLETTER_ACTION?.trim() || null;