Vercel Optimize

// Auth routes carry user state and must not be cached at CDN edge.

export const AUTH_ROUTE_REGEX =
  /(login|logout|auth|account|dashboard|checkout|cart|profile|session|me)(?:\/|$)/i;

export function isAuthRoute(route) {
  return AUTH_ROUTE_REGEX.test(String(route ?? ''));
}

// Non-cache candidates pass through — errors/slowness on auth routes still warrant investigation.
export function applyAuthDisqualifier(candidate) {
  const cacheKinds = new Set(['uncached_route', 'cache_header_gap']);
  if (!cacheKinds.has(candidate.kind)) return candidate;
  if (!candidate.route) return candidate;
  if (isAuthRoute(candidate.route)) {
    return {
      ...candidate,
      disqualified: true,
      disqualifyReason: 'auth-like route — should not be cached at edge',
    };
  }
  return candidate;
}

// Checkpoint between gate and deep-dive. Asks only when budget was default AND >=1 candidate got skipped — every question is a tax on the user.

import { createHash } from 'node:crypto';
import { formatCandidateLine } from './display-labels.mjs';

const TOP_INVESTIGATING_PREVIEW = 5;
const MAX_FULL_INVESTIGATING_PREVIEW = 10;
export function buildBudgetSummary(gate) {
  const toLaunch = Array.isArray(gate?.toLaunch) ? gate.toLaunch : [];
  const gated = Array.isArray(gate?.gated) ? gate.gated : [];
  const budgetSource = gate?.budget?.source ?? 'default';
  const currentBudget =
    typeof gate?.budget?.maxCandidates === 'number'
      ? gate.budget.maxCandidates
      : (gate?.budget?.maxCandidates === 'all' ? Infinity : 6);

  // Only budget skips can be reached by raising the budget; disqualified/coveredBy can't.
  const skippedByBudget = gated.filter((g) =>
    typeof g.gatedReason === 'string' && g.gatedReason.startsWith('skippedByBudget')
  );
  const skipped = skippedByBudget.length;
  const totalPassed = toLaunch.length + skipped;

  const reasonParts = [];
  if (budgetSource !== 'default') reasonParts.push(`user pre-set budget via ${budgetSource}`);
  if (skipped === 0) reasonParts.push('no candidates skipped by budget');
  const shouldAsk = budgetSource === 'default' && skipped > 0;
  const reason = shouldAsk
    ? `default budget skipped ${skipped} candidate(s); ask user whether to expand`
    : reasonParts.join('; ') || 'no expansion possible';

  const summarize = (c) => ({
    kind: c.kind,
    route: c.route ?? c.hostname ?? null,
    displayRoute: c.displayRoute ?? null,
    o11ySignal: c.o11ySignal ?? null,
    priority: c.priority ?? null,
  });

  const investigatingPreviewCount = typeof currentBudget === 'number' && currentBudget <= MAX_FULL_INVESTIGATING_PREVIEW
    ? currentBudget
    : TOP_INVESTIGATING_PREVIEW;
  const topInvestigating = toLaunch.slice(0, investigatingPreviewCount).map(summarize);
  const topSkipped = skippedByBudget.map(summarize);
  const options = buildOptions(toLaunch.length, skipped);
  const questionText = buildQuestionText({ shouldAsk, totalPassed, currentBudget });
  const printContract = shouldAsk
    ? 'Print chatPreview verbatim by copying exactChatMessage.body as a chat message before asking questionText. Do not summarize, truncate, reorder, shorten, or rewrite options.'
    : null;
  const questionPayload = shouldAsk ? buildQuestionPayload(questionText, options) : null;
  const chatPreview = buildChatPreview({ shouldAsk, totalPassed, currentBudget, skipped, topInvestigating, topSkipped, reason });
  const exactChatMessage = buildExactChatMessage(chatPreview);
  return {
    shouldAsk,
    reason,
    totalPassed,
    currentBudget: currentBudget === Infinity ? 'all' : currentBudget,
    budgetSource,
    skipped,
    topInvestigating,
    topSkipped,
    options,
    printContract,
    chatPreview,
    exactChatMessage,
    printCheck: shouldAsk ? buildPrintCheck({ exactChatMessage, skipped }) : null,
    questionText,
    questionPayload,
  };
}

function buildChatPreview({ shouldAsk, totalPassed, currentBudget, skipped, topInvestigating, topSkipped, reason }) {
  if (!shouldAsk) return `Audit scope: no question needed — ${reason}.`;
  const lines = [];
  lines.push(`Found ${totalPassed} potential issue${totalPassed === 1 ? '' : 's'} worth checking. By default I'll inspect the ${currentBudget} strongest now; ${skipped} will stay in the report for a larger run.`);
  lines.push(`Choose a larger scope if you want broader coverage. More checks take longer.`);
  if (topInvestigating.length > 0) {
    lines.push('');
    lines.push(`Checking now${topInvestigating.length < currentBudget ? ` (${topInvestigating.length} shown)` : ''}:`);
    topInvestigating.forEach((c, i) => lines.push(`  ${i + 1}. ${formatCandidateLine(c)}`));
  }
  if (topSkipped.length > 0) {
    lines.push('');
    lines.push(`Only checked if you expand this run (${topSkipped.length}):`);
    topSkipped.forEach((c, i) => lines.push(`  ${i + 1}. ${formatCandidateLine(c)}`));
  }
  return lines.join('\n');
}

function buildExactChatMessage(body) {
  return {
    body,
    lineCount: body.split('\n').length,
    sha256: createHash('sha256').update(body).digest('hex'),
  };
}

function buildPrintCheck({ exactChatMessage, skipped }) {
  return {
    bodyField: 'exactChatMessage.body',
    sameAs: 'chatPreview',
    requiredLineCount: exactChatMessage.lineCount,
    requiredSha256: exactChatMessage.sha256,
    requiredSkippedRows: skipped,
    requiredSkippedHeading: `Only checked if you expand this run (${skipped}):`,
    forbiddenSummaryPatterns: [
      '\\btop skipped\\b',
      '\\bmore (?:candidate|candidates|routes|entries|items|in gated list)\\b',
      '\\b\\d+\\s*[-–—]\\s*\\d+\\.\\s+\\d+\\s+more\\b',
      '\\betc\\.\\b',
    ],
    instruction: 'The budget message is valid only when every line from exactChatMessage.body is preserved exactly. If you cannot verify that, print exactChatMessage.body again before asking the question.',
  };
}

function buildQuestionText({ shouldAsk, totalPassed, currentBudget }) {
  if (!shouldAsk) return '';
  return `How many potential issues should I check in this run?`;
}

function buildOptions(currentCount, skippedCount) {
  if (skippedCount === 0) return [];
  const total = currentCount + skippedCount;
  return [
    {
      label: `Check ${currentCount} (default)`,
      value: currentCount,
      recommended: true,
      description: 'Fastest first pass; checks the strongest cost and performance signals.',
      rationale: 'fastest first pass; checks the strongest cost and performance signals',
    },
    {
      label: `Check all ${total}`,
      value: 'all',
      recommended: false,
      description: 'Most complete; takes longer because every flagged route is investigated.',
      rationale: 'most complete; takes longer because every flagged route is investigated',
    },
    {
      label: 'Pick a number',
      value: 'custom',
      recommended: false,
      description: `Check more than ${currentCount} without running the full ${total}.`,
      rationale: `checks more than ${currentCount} without running the full ${total}`,
    },
  ];
}

function buildQuestionPayload(questionText, options) {
  return {
    questions: [{
      question: questionText,
      header: 'Audit scope',
      multiSelect: false,
      options: options.map((o) => ({
        label: o.label,
        description: o.description ?? o.rationale,
      })),
    }],
  };
}

export function renderBudgetSummaryMarkdown(s) {
  const lines = [];
  lines.push(`## Audit scope`);
  lines.push('');
  if (!s.shouldAsk) {
    lines.push(`_No question needed — ${s.reason}._`);
    return lines.join('\n');
  }
  for (const ln of s.chatPreview.split('\n')) lines.push(ln);
  lines.push('');
  lines.push('### Options');
  lines.push('');
  for (const o of s.options) {
    const tag = o.recommended ? ' (recommended)' : '';
    lines.push(`- **${o.label}${tag}** — ${o.rationale}`);
  }
  lines.push('');
  lines.push(`**Question:** ${s.questionText}`);
  return lines.join('\n');
}

// Curated doc library — the allow-list for recommender citations.

import { readFile } from 'node:fs/promises';
import { fileURLToPath } from 'node:url';
import { dirname, join } from 'node:path';

const HERE = dirname(fileURLToPath(import.meta.url));
const LIBRARY_PATH = join(HERE, '..', 'references', 'docs-library.json');

let cached;

export async function loadLibrary() {
  if (cached) return cached;
  const raw = await readFile(LIBRARY_PATH, 'utf-8');
  cached = JSON.parse(raw);
  return cached;
}

export async function isKnownUrl(url) {
  const lib = await loadLibrary();
  return lib.urls.some(e => e.url === url);
}

export async function lookupUrl(url) {
  const lib = await loadLibrary();
  return lib.urls.find(e => e.url === url);
}

export async function lookupSkillRule(ref) {
  const lib = await loadLibrary();
  const m = ref.match(/^([\w-]+):([\w-]+)$/);
  if (!m) return undefined;
  return lib.ruleSkillRefs.find(r => r.skill === m[1] && r.rule === m[2]);
}

// Narrow semver subset: "*", "fw@*", "fw@14", "fw@>=15.0.0", "fw@<X", "fw@X.Y", "fw@X.Y.Z", "a || b".
export function matchesFrameworkVersion(pattern, framework, version) {
  if (pattern === '*') return true;

  if (pattern.includes('||')) {
    return pattern.split('||').map(p => p.trim()).some(p =>
      matchesFrameworkVersion(p, framework, version)
    );
  }

  const m = pattern.match(/^([\w-]+)@(.+)$/);
  if (!m) return false;
  const [, fw, range] = m;

  if (fw !== framework) return false;
  if (range === '*') return true;

  const verParts = parseVersion(version);
  if (!verParts) return false;

  let m2 = range.match(/^>=\s*(.+)$/);
  if (m2) {
    const min = parseVersion(m2[1]);
    return min ? compareVersion(verParts, min) >= 0 : false;
  }

  m2 = range.match(/^<\s*(.+)$/);
  if (m2) {
    const max = parseVersion(m2[1]);
    return max ? compareVersion(verParts, max) < 0 : false;
  }

  if (/^\d+$/.test(range)) {
    return verParts[0] === Number(range);
  }

  m2 = range.match(/^(\d+)\.(\d+)$/);
  if (m2) {
    return verParts[0] === Number(m2[1]) && verParts[1] === Number(m2[2]);
  }

  const exact = parseVersion(range);
  if (exact) return compareVersion(verParts, exact) === 0;

  return false;
}

function parseVersion(v) {
  const m = String(v).replace(/^[v^~]+/, '').match(/^(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
  if (!m) return null;
  return [Number(m[1]) || 0, Number(m[2]) || 0, Number(m[3]) || 0];
}

function compareVersion(a, b) {
  for (let i = 0; i < 3; i++) {
    if (a[i] !== b[i]) return a[i] - b[i];
  }
  return 0;
}

// Filtered subset embedded in recommender prompt — LLM never sees URLs for features not in user's stack.
export async function libraryForStack(framework, version) {
  const lib = await loadLibrary();
  const matches = (frameworks) =>
    frameworks.some(p => matchesFrameworkVersion(p, framework, version) || p === '*');
  return {
    urls: lib.urls.filter(e => matches(e.applicableFrameworks)),
    ruleSkillRefs: lib.ruleSkillRefs.filter(r => matches(r.applicableFrameworks)),
  };
}

export async function sanitizeCitations(rec, framework, version) {
  const lib = await loadLibrary();
  const strippedUnknown = [];
  const strippedVersion = [];
  const kept = [];

  for (const cite of rec.citations ?? []) {
    const ruleRef = await lookupSkillRule(cite);
    if (ruleRef) {
      if (matchesFrameworkVersion(ruleRef.applicableFrameworks.join(' || '), framework, version) || ruleRef.applicableFrameworks.includes('*')) {
        kept.push(cite);
      } else {
        strippedVersion.push(cite);
      }
      continue;
    }

    const entry = lib.urls.find(e => e.url === cite);
    if (!entry) {
      strippedUnknown.push(cite);
      continue;
    }
    if (entry.applicableFrameworks.includes('*') ||
        entry.applicableFrameworks.some(p => matchesFrameworkVersion(p, framework, version))) {
      kept.push(cite);
    } else {
      strippedVersion.push(cite);
    }
  }

  rec.citations = kept;
  return { rec, strippedUnknown, strippedVersion };
}

// Maps billing line items to gate coverage so report surfaces uncovered dimensions (Sandbox, AI Gateway, Build, …) as blind spots.

// Service → billing dimension. dim=null means uncovered. Substring match — Vercel billing names are stable but untyped.
const SERVICE_DIMENSION = [
  { match: /^Function Duration$/i,                       dim: 'function-duration' },
  { match: /^Function Invocations$/i,                    dim: 'function-duration' },
  { match: /^Fluid Active CPU$/i,                        dim: 'function-duration' },
  { match: /^Fluid Provisioned Memory$/i,                dim: 'function-duration' },
  { match: /^Edge Requests$/i,                           dim: 'edge-requests' },
  { match: /^Edge Requests.*Additional CPU Duration/i,   dim: 'edge-requests' },
  { match: /^Edge Function Execution Units$/i,           dim: 'edge-requests' },
  { match: /^Edge Middleware Invocations$/i,             dim: 'edge-requests' },
  { match: /^ISR (Reads|Writes)$/i,                      dim: 'isr' },
  { match: /^Speed Insights( Data Points)?$/i,           dim: 'speed-insights' },
  { match: /^Image Optimization/i,                       dim: 'image-optimization' },
  // Indirect: bot-protection gate addresses bandwidth/edge spend.
  { match: /^Fast Data Transfer$/i,                      dim: 'edge-requests' },
  { match: /^Fast Origin Transfer$/i,                    dim: 'edge-requests' },

  // Uncovered.
  { match: /^Sandbox/i,                                  dim: null, family: 'sandbox' },
  { match: /^AI Gateway$/i,                              dim: null, family: 'ai-gateway' },
  { match: /^Build Minutes$/i,                           dim: 'build', family: 'build' },
  { match: /^Build CPU Minutes$/i,                       dim: 'build', family: 'build' },
  { match: /^Private Data Transfer$/i,                   dim: null, family: 'private-network' },
  { match: /^Secure Compute Network$/i,                  dim: null, family: 'private-network' },
  { match: /^Drains Volume$/i,                           dim: null, family: 'drains' },
  { match: /^Observability Events$/i,                    dim: 'observability-events', family: 'observability-events' },
  { match: /^Blob/i,                                     dim: null, family: 'blob' },
  { match: /^Edge Config (Reads|Writes)$/i,              dim: null, family: 'edge-config' },
  { match: /^Runtime Cache/i,                            dim: null, family: 'runtime-cache' },
  { match: /^Microfrontends/i,                           dim: null, family: 'microfrontends' },
  { match: /^Workflow/i,                                 dim: null, family: 'workflow' },
  { match: /^Queue/i,                                    dim: null, family: 'queues' },
  { match: /^Flag Requests$/i,                           dim: null, family: 'flags' },
  { match: /^Flags Explorer/i,                           dim: null, family: 'flags' },
  { match: /^BotID/i,                                    dim: null, family: 'botid' },
  { match: /^Firewall/i,                                 dim: null, family: 'firewall' },
  { match: /^Vercel Agent$/i,                            dim: null, family: 'vercel-agent' },

  // Fixed costs (seats, contracts) — not actionable.
  { match: /^v0 /i,                                      dim: null, family: 'fixed', actionable: false },
  { match: /^Additional Team Seats$/i,                   dim: null, family: 'fixed', actionable: false },
  { match: /^SAML$/i,                                    dim: null, family: 'fixed', actionable: false },
  { match: /^HIPAA BAA$/i,                               dim: null, family: 'fixed', actionable: false },
  { match: /^SIEM Integration$/i,                        dim: null, family: 'fixed', actionable: false },
  { match: /^Web Analytics/i,                            dim: null, family: 'fixed', actionable: false },
  { match: /^Static IPs$/i,                              dim: null, family: 'fixed', actionable: false },
  { match: /^Bulk Redirects$/i,                          dim: null, family: 'fixed', actionable: false },
  { match: /^Preview Deployment Suffix$/i,               dim: null, family: 'fixed', actionable: false },
  { match: /^Rolling Releases$/i,                        dim: null, family: 'fixed', actionable: false },
  { match: /^Observability Plus$/i,                      dim: null, family: 'fixed', actionable: false },
  { match: /^Platform Customer Usage$/i,                 dim: null, family: 'fixed', actionable: false },
  { match: /^Advanced Deployment Protection$/i,          dim: null, family: 'fixed', actionable: false },
];

export function classifyService(serviceName, activeDims) {
  if (!serviceName) return { covered: false, family: 'unknown' };
  for (const e of SERVICE_DIMENSION) {
    if (e.match.test(serviceName)) {
      if (e.dim && activeDims.has(e.dim)) return { covered: true, dim: e.dim };
      return { covered: false, family: e.family ?? 'unknown', actionable: e.actionable ?? true };
    }
  }
  return { covered: false, family: 'unknown', actionable: true };
}

export function computeCostCoverage(usage, gates) {
  const services = Array.isArray(usage?.services) ? usage.services : [];
  const activeDims = new Set(
    (gates ?? [])
      .map((g) => g?.metadata?.billingDimension)
      .filter((d) => typeof d === 'string' && d !== 'mixed')
  );
  let total = 0;
  let covered = 0;
  let uncovered = 0;
  const byFamily = new Map();

  for (const s of services) {
    const billed = Number(s.billedCost ?? 0);
    if (!Number.isFinite(billed) || billed <= 0) continue;
    total += billed;
    const c = classifyService(s.name, activeDims);
    if (c.covered) {
      covered += billed;
      continue;
    }
    uncovered += billed;
    const key = c.family;
    const prev = byFamily.get(key) ?? { family: key, billed: 0, services: [], actionable: c.actionable !== false };
    prev.billed += billed;
    prev.services.push({ name: s.name, billed });
    prev.actionable = prev.actionable && (c.actionable !== false);
    byFamily.set(key, prev);
  }

  const uncoveredByFamily = [...byFamily.values()]
    .sort((a, b) => b.billed - a.billed)
    .map((f) => ({ ...f, services: f.services.sort((a, b) => b.billed - a.billed) }));

  // Pick top gaps globally so multiple families surface (Sandbox + AI Gateway + Build, not 5 Sandbox sub-services). Exclude fixed costs — seats aren't actionable workload.
  const allActionableServices = [];
  for (const family of uncoveredByFamily) {
    if (!family.actionable) continue;
    for (const s of family.services) {
      allActionableServices.push({ name: s.name, billed: s.billed, family: family.family });
    }
  }
  allActionableServices.sort((a, b) => b.billed - a.billed);
  const topGaps = allActionableServices.slice(0, 5).map((s) => ({
    ...s,
    share: total > 0 ? s.billed / total : 0,
  }));
  return { totalBilled: total, coveredBilled: covered, uncoveredBilled: uncovered, uncoveredByFamily, topGaps };
}

export function renderCostCoverageMarkdown(coverage) {
  if (!coverage || !Number.isFinite(coverage.totalBilled) || coverage.totalBilled <= 0) return [];
  const { totalBilled, coveredBilled, uncoveredBilled, topGaps } = coverage;
  const actionableGaps = topGaps.filter((g) => g.share >= 0.01); // 1%+ share
  if (actionableGaps.length === 0) return [];
  const lines = [];
  lines.push('');
  lines.push('### Coverage gaps');
  lines.push('');
  const coveredPct = totalBilled > 0 ? (coveredBilled / totalBilled) * 100 : 0;
  const uncoveredPct = totalBilled > 0 ? (uncoveredBilled / totalBilled) * 100 : 0;
  lines.push(`This audit has metric coverage for **$${coveredBilled.toFixed(0)} (${coveredPct.toFixed(0)}%)** of this bill via function-duration, edge-requests, ISR, middleware, and image-optimization dimensions. **$${uncoveredBilled.toFixed(0)} (${uncoveredPct.toFixed(0)}%)** sits in billed areas this run cannot analyze safely, including the top actionable items below:`);
  lines.push('');
  lines.push('| Service | Billed | Share | Family | Coverage |');
  lines.push('|---|---|---|---|---|');
  for (const g of actionableGaps) {
    lines.push(`| ${escapeCell(g.name)} | $${g.billed.toFixed(2)} | ${(g.share * 100).toFixed(1)}% | ${g.family} | _not analyzed in this run_ |`);
  }
  lines.push('');
  lines.push('_Recommendations in this report address the covered dimensions. The uncovered rows are not ignored; they need a separate investigation before we can make safe recommendations._');
  return lines;
}

function escapeCell(s) {
  return String(s ?? '').replace(/\|/g, '\\|').replace(/\n/g, ' ');
}

const NO_VALUE = '<none>';

export function dedupeRecommendations(recommendations = []) {
  if (!Array.isArray(recommendations)) {
    throw new TypeError('dedupeRecommendations recommendations must be an array');
  }

  const byKey = new Map();
  const order = [];
  for (const rec of recommendations) {
    if (!rec || typeof rec !== 'object' || rec.abstain === true) {
      order.push(rec);
      continue;
    }

    const key = recommendationKey(rec);
    if (!byKey.has(key)) {
      const normalized = withDedupMetadata(rec);
      byKey.set(key, normalized);
      order.push({ __dedupKey: key });
      continue;
    }

    const current = byKey.get(key);
    const merged = mergeDuplicateRecs(current, rec);
    byKey.set(key, merged);
  }

  return order.map((entry) => entry?.__dedupKey ? byKey.get(entry.__dedupKey) : entry);
}

export function recommendationKey(rec) {
  const intent = dedupIntent(rec);
  const bucket = intent === 'cache-control:s-maxage'
    ? NO_VALUE
    : String(rec?.bucket ?? NO_VALUE);
  return JSON.stringify([
    bucket,
    dedupEditTarget(rec),
    primarySkillRule(rec),
    intent,
  ]);
}

export function normalizePath(path) {
  if (typeof path !== 'string' || path.trim() === '') return NO_VALUE;
  return path
    .trim()
    .replace(/\\/g, '/')
    .replace(/^\.\//, '')
    .replace(/\/+/g, '/')
    .replace(/:(\d+)(?::\d+)?$/, '');
}

export function primarySkillRule(rec) {
  const citations = Array.isArray(rec?.citations) ? rec.citations : [];
  return citations.find((c) => typeof c === 'string' && /^[A-Za-z][\w-]*:[A-Za-z][\w-]*$/.test(c)) ?? NO_VALUE;
}

export function fixShape(rec) {
  if (typeof rec?.fixShape === 'string' && rec.fixShape.trim()) {
    return normalizeFixText(rec.fixShape);
  }
  const primaryText = [rec?.fix, rec?.desiredBehavior]
    .filter((v) => typeof v === 'string' && v.trim())
    .join('\n');
  const text = primaryText || rec?.what;
  return normalizeFixText(text);
}

export function dedupIntent(rec) {
  if (isSMaxageCacheHeaderRec(rec)) return 'cache-control:s-maxage';
  if (isCacheLifeRec(rec)) return cacheLifeIntent(rec);
  const sharedFunction = sharedFunctionTarget(rec);
  if (sharedFunction) return `parallel-shared-helper:${sharedFunction}`;
  return fixShape(rec);
}

export function dedupEditTarget(rec) {
  return sharedFunctionTarget(rec) ?? normalizePath(firstAffectedFile(rec));
}

function firstAffectedFile(rec) {
  const direct = affectedFiles(rec);
  const editTarget = referencedCodeFiles(rec, ['fix', 'desiredBehavior', 'currentBehavior'])[0];
  if (editTarget) return editTarget;
  const referenced = referencedCodeFiles(rec)
    .find((file) => direct.includes(file));
  if (referenced) return referenced;
  return Array.isArray(rec?.affectedFiles) ? rec.affectedFiles[0] : null;
}

function affectedFiles(rec) {
  return Array.isArray(rec?.affectedFiles)
    ? rec.affectedFiles.map(normalizePath).filter((file) => file !== NO_VALUE)
    : [];
}

function referencedCodeFiles(rec, fields = ['what', 'why', 'fix', 'currentBehavior', 'desiredBehavior', 'verify']) {
  const text = fields
    .map((field) => rec?.[field])
    .filter((v) => typeof v === 'string' && v.trim())
    .join('\n');
  const matches = text.match(/(?:^|[\s`'"(])((?:\.{1,2}\/|[A-Za-z0-9_.@-]+\/)[A-Za-z0-9_./@[\]()-]+\.(?:mjs|cjs|js|jsx|ts|tsx))/g) ?? [];
  return unique(matches.map((m) =>
    normalizePath(m.replace(/^[\s`'"(]+/, ''))
  ).filter((file) => file !== NO_VALUE));
}

function isSMaxageCacheHeaderRec(rec) {
  const text = [
    rec?.what,
    rec?.why,
    rec?.fix,
    rec?.desiredBehavior,
    ...(Array.isArray(rec?.citations) ? rec.citations : []),
  ].filter(Boolean).join('\n');
  return /\bs-maxage\b/i.test(text) &&
    /\b(?:Cache-Control|CDN cache|cdn-cache|caching\/cdn-cache)\b/i.test(text);
}

function isCacheLifeRec(rec) {
  const text = [
    rec?.candidateRef,
    rec?.what,
    rec?.why,
    rec?.fix,
    rec?.desiredBehavior,
    ...(Array.isArray(rec?.citations) ? rec.citations : []),
  ].filter(Boolean).join('\n');
  return /^isr_overrevalidation:/.test(String(rec?.candidateRef ?? '')) &&
    /\bcacheLife\s*\(|\bcacheLife\b/i.test(text);
}

function sharedFunctionTarget(rec) {
  const rule = primarySkillRule(rec);
  if (!/(?:^|:)async-parallel$|(?:^|:)server-parallel-fetching$|(?:^|:)async-suspense-boundaries$/.test(rule)) {
    return null;
  }
  const text = [
    rec?.what,
    rec?.why,
    rec?.fix,
    rec?.currentBehavior,
    rec?.desiredBehavior,
  ].filter((v) => typeof v === 'string' && v.trim()).join('\n');
  const names = [
    ...text.matchAll(/\b(?:get|fetch|load|read|render|create|generate|filter|resolve)[A-Z][A-Za-z0-9_]*\b/g),
  ].map((m) => m[0]);
  const stop = new Set([
    'getPayload',
    'draftMode',
    'notFound',
    'redirect',
    'Promise',
    'Response',
    'NextResponse',
  ]);
  const candidates = names.filter((name) => !stop.has(name));
  if (candidates.length === 0) return null;
  const score = new Map();
  for (const name of candidates) {
    score.set(name, (score.get(name) ?? 0) + 1);
  }
  return [...score.entries()]
    .sort((a, b) => b[1] - a[1] || text.indexOf(a[0]) - text.indexOf(b[0]))
    .map(([name]) => `function:${name}`)[0] ?? null;
}

function cacheLifeIntent(rec) {
  const text = [
    rec?.what,
    rec?.why,
    rec?.fix,
    rec?.desiredBehavior,
    rec?.verify,
  ].filter(Boolean).join('\n');
  const profiles = unique(
    [...text.matchAll(/\bcacheLife\s*\(\s*['"`]([^'"`]+)['"`]/g)]
      .map((m) => m[1])
  );
  const tags = unique([
    ...[...text.matchAll(/\bcacheTag\s*\(([^)]*)\)/gs)].flatMap((m) => {
      const args = m[1] ?? '';
      return [
        ...[...args.matchAll(/['"]([^'"]+)['"]/g)].map((x) => x[1]),
        ...[...args.matchAll(/`([^`]+)`/g)].map((x) => x[1].includes('${') ? `${x[1].split('${')[0]}*` : x[1]),
      ];
    }),
  ]);
  const invalidation = /\b(?:revalidateTag|updateTag)\s*\(/.test(text) ? 'with-invalidation-api' : 'no-invalidation-api';
  return [
    'next-cache:cache-life',
    profiles.join('|') || NO_VALUE,
    tags.join('|') || NO_VALUE,
    invalidation,
  ].join(':');
}

function unique(values) {
  return Array.from(new Set(values.filter((v) => typeof v === 'string' && v.trim()).map((v) => v.trim()))).sort();
}

function normalizeFixText(text) {
  if (typeof text !== 'string' || text.trim() === '') return NO_VALUE;
  return text
    .toLowerCase()
    .replace(/```[\s\S]*?```/g, ' codeblock ')
    .replace(/`[^`]*`/g, ' code ')
    .replace(/\b\d+(?:\.\d+)?(?:ms|s|%|kb|mb|gb|k|m)?\b/g, '#')
    .replace(/[^a-z0-9#]+/g, ' ')
    .trim()
    .split(/\s+/)
    .slice(0, 80)
    .join(' ') || NO_VALUE;
}

function withDedupMetadata(rec) {
  const existing = normalizedAppliesAlsoTo(rec.appliesAlsoTo);
  const count = Math.max(
    numericCount(rec.corroborationCount),
    1 + existing.length,
  );
  return existing.length > 0 || count > 1
    ? { ...rec, appliesAlsoTo: existing, corroborationCount: count }
    : { ...rec };
}

function mergeDuplicateRecs(a, b) {
  const aScore = recScore(a);
  const bScore = recScore(b);
  const winner = bScore > aScore ? b : a;
  const loser = winner === a ? b : a;
  const winnerExisting = normalizedAppliesAlsoTo(winner.appliesAlsoTo);
  const loserExisting = normalizedAppliesAlsoTo(loser.appliesAlsoTo);
  const appliesAlsoTo = uniqueAppliesAlsoTo([
    ...winnerExisting,
    appliesAlsoEntry(loser),
    ...loserExisting,
  ]);
  const corroborationCount =
    numericCount(winner.corroborationCount) + numericCount(loser.corroborationCount);
  return {
    ...winner,
    appliesAlsoTo,
    corroborationCount: Math.max(corroborationCount, 1 + appliesAlsoTo.length),
  };
}

function recScore(rec) {
  const priority = typeof rec?.priority === 'number' ? rec.priority : 0;
  const quality = typeof rec?.quality?.overall === 'number' ? rec.quality.overall : 0;
  return (priority * 1_000_000_000_000) + signalMagnitude(rec) + quality;
}

function signalMagnitude(rec) {
  const text = [
    rec?.o11ySignal,
    rec?.why,
    rec?.what,
    rec?.impact,
  ].filter((v) => typeof v === 'string' && v.trim()).join('\n');
  const inv = parseNumber(text, /(?:inv|invocations?|function invocations?|requests?)[:=]\s*([\d,]+)/i);
  const p95 = parseNumber(text, /(?:p95|95th percentile(?: duration)?)[:=]?\s*([\d,]+)\s*ms/i);
  const errors = parseNumber(text, /(?:errs|errors?)[:=]\s*([\d,]+)/i);
  const writes = parseNumber(text, /writes[:=]\s*([\d,]+)/i);
  const reads = parseNumber(text, /reads[:=]\s*([\d,]+)/i);
  if (inv != null && p95 != null) return inv * p95;
  if (errors != null) return errors;
  if (writes != null && reads != null) return writes + reads;
  if (inv != null) return inv;
  return 0;
}

function parseNumber(text, re) {
  const match = re.exec(text);
  if (!match) return null;
  const value = Number(String(match[1]).replace(/,/g, ''));
  return Number.isFinite(value) ? value : null;
}

function numericCount(value) {
  return Number.isFinite(value) && value > 0 ? value : 1;
}

function appliesAlsoEntry(rec) {
  return {
    candidateRef: rec?.candidateRef ?? null,
    affectedFiles: Array.isArray(rec?.affectedFiles)
      ? rec.affectedFiles.map(normalizePath).filter((p) => p !== NO_VALUE)
      : [],
    o11ySignal: rec?.o11ySignal ?? null,
    what: rec?.what ?? null,
  };
}

function normalizedAppliesAlsoTo(entries) {
  if (!Array.isArray(entries)) return [];
  return entries
    .filter((e) => e && typeof e === 'object')
    .map((e) => ({
      candidateRef: e.candidateRef ?? null,
      affectedFiles: Array.isArray(e.affectedFiles)
        ? e.affectedFiles.map(normalizePath).filter((p) => p !== NO_VALUE)
        : [],
      o11ySignal: e.o11ySignal ?? null,
      what: e.what ?? null,
    }));
}

function uniqueAppliesAlsoTo(entries) {
  const seen = new Set();
  const out = [];
  for (const entry of entries) {
    const key = JSON.stringify([
      entry.candidateRef ?? NO_VALUE,
      entry.affectedFiles?.join(',') ?? NO_VALUE,
      entry.what ?? NO_VALUE,
    ]);
    if (seen.has(key)) continue;
    seen.add(key);
    out.push(entry);
  }
  return out;
}

// Per-candidate deep-dive query specs. Runs after gate, before sub-agent reads source.
//
// CLI quirks:
//   - Multi `-a` flag is NOT supported. One percentile per query.
//   - External-API "calling route" dim is `origin_route` (NOT `route`).

// Same window as broad pass so rolls are comparable.
import { TIME_WINDOW } from './queries.mjs';

export { TIME_WINDOW };

// Per-query is scoped to one route/hostname, so cardinality stays small — higher than broad-pass caps.
const DEPLOYMENT_LIMIT = 10;
const ERROR_DEPLOYMENT_LIMIT = 30;
const ERROR_CODE_LIMIT = 50;
const WAF_RULE_LIMIT = 20;
const MIDDLEWARE_PATH_LIMIT = 50;
const CALLER_LIMIT = 20;

// OData escapes a literal `'` inside a string by doubling it (`it's` → `it''s`).
export function escapeODataString(s) {
  if (typeof s !== 'string') return '';
  return s.replace(/'/g, "''");
}

export function odataEq(dim, value) {
  return `${dim} eq '${escapeODataString(value)}'`;
}

export function odataAnd(...conds) {
  return conds.filter(Boolean).join(' and ');
}

export const SPEC_GENERATORS = {
  slow_route(c) {
    const route = c.route;
    if (!route) return [];
    const f = odataEq('route', route);
    // cacheBreakdown/bandwidthByCache let sub-agent see miss-path cost on static routes (dynamic='error' can still show p95=900ms over millions of requests).
    return [
      ...latencyPercentiles('latency', 'vercel.function_invocation.function_duration_ms', f),
      ...latencyPercentiles('ttfb', 'vercel.function_invocation.ttfb_ms', f),
      ...latencyPercentiles('cpu', 'vercel.function_invocation.function_cpu_time_ms', f, ['p95']),
      {
        id: 'startTypeSplit',
        metricId: 'vercel.function_invocation.count',
        aggregation: 'sum',
        groupBy: ['function_start_type'],
        filter: f,
        broadPassEquivalent: { key: 'fnStartTypeByRoute', routeFilter: route, projectDims: ['function_start_type'] },
      },
      // function-invocation status (5xx from function) — distinct from request-level status, can't reuse broad-pass.
      {
        id: 'statusDistribution',
        metricId: 'vercel.function_invocation.count',
        aggregation: 'sum',
        groupBy: ['http_status'],
        filter: f,
      },
      {
        id: 'perDeployment',
        metricId: 'vercel.function_invocation.function_duration_ms',
        aggregation: 'p95',
        groupBy: ['deployment_id'],
        filter: f,
        limit: DEPLOYMENT_LIMIT,
      },
      {
        id: 'cacheBreakdown',
        metricId: 'vercel.request.count',
        aggregation: 'sum',
        groupBy: ['cache_result'],
        filter: f,
        broadPassEquivalent: { key: 'requestsByRouteCache', routeFilter: route, projectDims: ['cache_result'] },
      },
      // broad-pass bandwidthByCacheResult is account-wide, so per-route still required.
      {
        id: 'bandwidthByCache',
        metricId: 'vercel.request.fdt_total_bytes',
        aggregation: 'sum',
        groupBy: ['cache_result'],
        filter: f,
      },
    ];
  },

  uncached_route(c) {
    const route = c.route;
    if (!route) return [];
    const f = odataEq('route', route);
    return [
      {
        id: 'cacheBreakdown',
        metricId: 'vercel.request.count',
        aggregation: 'sum',
        groupBy: ['cache_result'],
        filter: f,
        broadPassEquivalent: { key: 'requestsByRouteCache', routeFilter: route, projectDims: ['cache_result'] },
      },
      {
        id: 'methodDistribution',
        metricId: 'vercel.request.count',
        aggregation: 'sum',
        groupBy: ['request_method'],
        filter: f,
        broadPassEquivalent: { key: 'requestsByRouteMethod', routeFilter: route, projectDims: ['request_method'] },
      },
      {
        id: 'botShare',
        metricId: 'vercel.request.fdt_total_bytes',
        aggregation: 'sum',
        groupBy: ['bot_category'],
        filter: f,
      },
      {
        id: 'bandwidthByCache',
        metricId: 'vercel.request.fdt_total_bytes',
        aggregation: 'sum',
        groupBy: ['cache_result'],
        filter: f,
      },
    ];
  },

  cold_start(c) {
    const route = c.route;
    if (!route) return [];
    const f = odataEq('route', route);
    return [
      {
        id: 'startTypeSplit',
        metricId: 'vercel.function_invocation.count',
        aggregation: 'sum',
        groupBy: ['function_start_type'],
        filter: f,
      },
      {
        id: 'coldVsWarmLatencyP95',
        metricId: 'vercel.function_invocation.function_duration_ms',
        aggregation: 'p95',
        groupBy: ['function_start_type'],
        filter: f,
      },
      {
        id: 'coldByDeployment',
        metricId: 'vercel.function_invocation.count',
        aggregation: 'sum',
        groupBy: ['deployment_id'],
        filter: odataAnd(f, odataEq('function_start_type', 'cold')),
        limit: DEPLOYMENT_LIMIT,
      },
    ];
  },

  route_errors(c) {
    const route = c.route;
    if (!route) return [];
    const f = odataEq('route', route);
    return [
      {
        id: 'errorStatusPattern',
        metricId: 'vercel.request.count',
        aggregation: 'sum',
        groupBy: ['http_status'],
        filter: odataAnd(f, "http_status ge '500'"),
      },
      {
        id: 'errorCodes',
        metricId: 'vercel.function_invocation.count',
        aggregation: 'sum',
        groupBy: ['error_code'],
        filter: f,
        limit: ERROR_CODE_LIMIT,
      },
      {
        id: 'errorsByDeployment',
        metricId: 'vercel.function_invocation.count',
        aggregation: 'sum',
        groupBy: ['deployment_id', 'http_status'],
        filter: f,
        limit: ERROR_DEPLOYMENT_LIMIT,
      },
    ];
  },

  external_api_slow(c) {
    const host = c.hostname;
    if (!host) return [];
    const f = odataEq('origin_hostname', host);
    return [
      ...latencyPercentiles('latency', 'vercel.external_api_request.request_duration_ms', f),
      {
        // "calling route" dim is origin_route (verified via metrics schema).
        id: 'callersByRoute',
        metricId: 'vercel.external_api_request.count',
        aggregation: 'sum',
        groupBy: ['origin_route'],
        filter: f,
        limit: CALLER_LIMIT,
      },
      {
        id: 'transferBytes',
        metricId: 'vercel.external_api_request.transfer_bytes',
        aggregation: 'sum',
        groupBy: [],
        filter: f,
      },
    ];
  },

  isr_overrevalidation(c) {
    const route = c.route;
    if (!route) return [];
    const f = odataEq('route', route);
    return [
      {
        id: 'writePattern',
        metricId: 'vercel.isr_operation.write_units',
        aggregation: 'sum',
        groupBy: ['cache_result'],
        filter: f,
      },
      {
        id: 'readPattern',
        metricId: 'vercel.isr_operation.read_units',
        aggregation: 'sum',
        groupBy: ['cache_result'],
        filter: f,
      },
    ];
  },

  cwv_poor(c) {
    const route = c.route;
    if (!route) return [];
    const f = odataEq('route', route);
    return [
      ...latencyPercentiles('lcp', 'vercel.speed_insights_metric.lcp', f, ['p50', 'p75', 'p95']),
      ...latencyPercentiles('inp', 'vercel.speed_insights_metric.inp', f, ['p50', 'p75', 'p95']),
      ...latencyPercentiles('cls', 'vercel.speed_insights_metric.cls', f, ['p50', 'p75', 'p95']),
    ];
  },

  middleware_heavy(_c) {
    // Account-scope. Surface top middleware-paths so recommender has named targets.
    return [
      {
        id: 'topMiddlewarePaths',
        metricId: 'vercel.middleware_invocation.count',
        aggregation: 'sum',
        groupBy: ['request_path'],
        limit: MIDDLEWARE_PATH_LIMIT,
      },
    ];
  },

  platform_fluid_compute(_c) {
    // Broad-pass fnStartTypeByRoute already covers this account-scope rec; runner notes reuse.
    return [];
  },

  platform_bot_protection(_c) {
    return [
      {
        id: 'wafRuleFirings',
        metricId: 'vercel.firewall_action.count',
        aggregation: 'sum',
        groupBy: ['waf_rule_id'],
        limit: WAF_RULE_LIMIT,
      },
    ];
  },

  observability_events_attribution(_c) {
    // Account-scope billing signal; broad-pass usage and existing route/cache/middleware metrics carry the evidence.
    return [];
  },

  usage_spike_triage(_c) {
    // Daily billing breakdown is already in the gate evidence; no per-candidate metrics query exists.
    return [];
  },

  build_minutes_fanout(_c) {
    // Account-scope billing signal + scanner findings carry the evidence; no per-candidate query.
    return [];
  },

  region_misconfig(_c) {
    // Branch 2 (scanner-only) — per-region TTFB metric unavailable today, so no deep-dive query.
    return [];
  },
};

// Scanner-driven kinds skip deep-dive — evidence already in scanner findings (file + line).
export const SCANNER_KINDS = new Set([
  'image_optimization',
  'cache_header_gap',
  'rendering_candidate',
  'use_cache_date_stamp',
  'cache_components_suspense_dedupe',
]);

export function specsForCandidate(candidate) {
  const kind = candidate?.kind;
  if (!kind) return [];
  if (SCANNER_KINDS.has(kind)) return [];
  const gen = SPEC_GENERATORS[kind];
  if (!gen) return [];
  return gen(candidate).map((s) => ({ since: TIME_WINDOW, ...s }));
}

// One spec per percentile — CLI does not support `-a p50 -a p95` multi-aggregation.
function latencyPercentiles(idPrefix, metricId, filter, percentiles = ['p50', 'p75', 'p95', 'p99']) {
  return percentiles.map((p) => ({
    id: `${idPrefix}.${p}`,
    metricId,
    aggregation: p,
    groupBy: [],
    filter,
  }));
}

// Dot-notation spec ids (`latency.p95`) nest under their group prefix.
export function mergeIntoEvidence(results) {
  const out = {};
  for (const r of results) {
    const id = r?.spec?.id;
    if (!id) continue;
    const dot = id.indexOf('.');
    if (dot > -1) {
      const head = id.slice(0, dot);
      const leaf = id.slice(dot + 1);
      if (!out[head]) out[head] = {};
      out[head][leaf] = simplify(r);
    } else {
      out[id] = simplify(r);
    }
  }
  return out;
}

// Avoid leaking raw CLI payload / candidate+spec wrapper into evidence — keep summary-only.
function simplify(r) {
  if (!r || r.ok === false) return { error: r?.error ?? 'unknown' };
  // Check rows before value so tabular results with both stay tabular.
  if (Array.isArray(r.rows)) return r.rows;
  if ('value' in r) return r.value;
  return null;
}

import { canonicalizeRoute } from './route-normalize.mjs';

const KIND_LABELS = new Map([
  ['slow_route', 'Slow route'],
  ['uncached_route', 'Low cache-hit route'],
  ['cold_start', 'Cold starts'],
  ['route_errors', 'Route errors'],
  ['cache_header_gap', 'Missing cache headers'],
  ['image_optimization', 'Image optimization'],
  ['external_api_slow', 'Slow external API'],
  ['isr_overrevalidation', 'ISR over-revalidation'],
  ['middleware_heavy', 'Heavy middleware'],
  ['cwv_poor', 'Poor Core Web Vitals'],
  ['platform_fluid_compute', 'Fluid Compute usage'],
  ['platform_bot_protection', 'Bot traffic'],
  ['rendering_candidate', 'Rendering opportunity'],
  ['missing_cache_headers', 'Missing cache headers'],
  ['max_age_without_s_maxage', 'Browser-only cache header'],
  ['force_dynamic', 'Forced dynamic rendering'],
  ['headers_in_page', 'Dynamic API in page'],
  ['unoptimized_image', 'Image optimization gap'],
  ['large_static_asset', 'Large static asset'],
  ['source_maps_production', 'Production source maps'],
  ['edge_heavy_import', 'Heavy Edge import'],
]);

const SIGNAL_LABELS = new Map([
  ['inv', 'function invocations'],
  ['runs', 'function invocations'],
  ['middleware_inv', 'middleware invocations'],
  ['total_req', 'total requests'],
  ['requests', 'requests'],
  ['p95', '95th percentile duration'],
  ['p75', '75th percentile duration'],
  ['5xx', '5xx error rate'],
  ['errs', '5xx errors'],
  ['rate', '5xx error rate'],
  ['cache', 'cache hit rate'],
  ['get', 'GET request share'],
  ['cold', 'cold start rate'],
  ['writes', 'ISR write units'],
  ['reads', 'ISR read units'],
  ['w/r', 'ISR writes per read'],
  ['ratio', 'ratio'],
  ['host', 'host'],
  ['calls', 'external API calls'],
  ['edge_cost', 'Edge Request cost units'],
  ['bot_protection', 'Bot Protection'],
  ['bot_fdt_pct', 'bot Fast Data Transfer share'],
  ['LCP', 'Largest Contentful Paint (LCP)'],
  ['INP', 'Interaction to Next Paint (INP)'],
  ['CLS', 'Cumulative Layout Shift (CLS)'],
]);

const REQUEST_COUNT_KINDS = new Set([
  'uncached_route',
]);

const PUBLIC_ASSIGNMENT_LABELS = new Map([
  ...SIGNAL_LABELS,
  ['deepDive.latency.p95', 'deepDive latency p95'],
  ['deepDive.cpu.p95', 'deepDive CPU p95'],
  ['deepDive.ttfb.p95', 'deepDive TTFB p95'],
  ['cpu.p95', 'CPU p95'],
  ['latency.p95', 'latency p95'],
  ['ttfb.p95', 'TTFB p95'],
  ['cache_result', 'cache result'],
  ['http_status', 'HTTP status'],
  ['error_code', 'error code'],
  ['status', 'status'],
  ['count', 'count'],
]);

export function formatKind(kind) {
  if (!kind) return 'Candidate';
  if (KIND_LABELS.has(kind)) return KIND_LABELS.get(kind);
  return String(kind)
    .split(/[_-]+/g)
    .filter(Boolean)
    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
    .join(' ') || 'Candidate';
}

export function formatRoute(candidate) {
  const route = candidate?.displayRoute ?? candidate?.route ?? candidate?.hostname ?? null;
  if (route) return String(canonicalizeRoute(route));
  if (Array.isArray(candidate?.files) && candidate.files.length > 0) return candidate.files[0];
  return 'account-wide';
}

export function formatSignal(signal, context = {}) {
  if (typeof signal !== 'string' || signal.trim() === '') return 'no signal recorded';

  const parts = signal
    .split(',')
    .map((part) => part.trim())
    .filter(Boolean)
    .map((part) => formatSignalPart(part, context));

  return parts.length > 0 ? parts.join('; ') : signal;
}

export function formatPublicText(value) {
  if (value == null) return '';
  return normalizeObservedWindowUnits(String(value))
    .replace(/\bo11y\b/gi, 'observability')
    .replace(/\bcache[- ]components gotcha\b/gi, 'Cache Components edge case')
    .replace(/\bcache_result\b(?!\s*=)/g, 'cache result')
    .replace(/\bhttp_status\b(?!\s*=)/g, 'HTTP status')
    .replace(/\berror_code\b(?!\s*=)/g, 'error code')
    .replace(/,(?=\s*([A-Za-z0-9][\w./-]*)=)/g, (match, key) =>
      PUBLIC_ASSIGNMENT_LABELS.has(key) ? '; ' : match
    )
    .replace(/\b([A-Za-z0-9][\w./-]*)=([^,;\s]+)/g, (match, key, rawValue) => {
      const label = PUBLIC_ASSIGNMENT_LABELS.get(key);
      if (!label) return match;
      return `${label}: ${formatSignalValue(key, rawValue)}`;
    })
    .replace(/\b(cache breakdown[^.!?\n;]{0,160}?)\b(?:function\s+)?invocations\b/gi, (match, prefix) =>
      /\bstatus distribution\b/i.test(prefix) ? match : `${prefix}requests`
    )
    .replace(/\b(cache breakdown[^.!?\n;]{0,220}?\bout of\s+[\d,]+)\s+invocations\b/gi, '$1 requests')
    .replace(/\b(cache hits over\s+[\d,.]+(?:\s?(?:K|M|B))?)\s+invocations\b/gi, '$1 requests')
    .replace(/\b(?:function\s+)?invocations\b([^.!?\n;]{0,120}\b(?:empty\s+)?cache result(?: label)?\b)/gi, 'requests$1');
}

export function normalizeObservedWindowUnits(value) {
  if (value == null) return '';
  return String(value)
    .replace(/(?<!\$)\b(\d[\d,.]*(?:\s?(?:K|M|B|KB|MB|GB|TB))?)\/mo\b/gi, '$1/window')
    .replace(/\bmonthly\s+function\s+invocations\b/gi, 'function invocations/window')
    .replace(/\b(requests?|invocations?|GETs|bytes|egress|bandwidth|writes?|reads?|errors?)\/mo\b/gi, '$1/window')
    .replace(/\bmonthly\s+(requests?|invocations?|GETs|bytes|egress|bandwidth|writes?|reads?|errors?)\b/gi, '$1/window')
    .replace(/\b(\d[\d,.]*(?:\s?(?:K|M|B|KB|MB|GB|TB))?)\s+function\s+invocations\s+per month\b/gi, '$1 function invocations/window')
    .replace(/\b(\d[\d,.]*(?:\s?(?:K|M|B|KB|MB|GB|TB))?)\s+(requests?|GETs|invocations?|bytes|writes?|reads?|errors?)\s+per month\b/gi, '$1 $2/window')
    .replace(/\b(\d[\d,.]*(?:\s?(?:K|M|B|KB|MB|GB|TB))?)\/window\s+(requests?|GETs|(?:function\s+)?invocations?|bytes|egress|bandwidth|writes?|reads?|errors?)\b/gi, '$1 $2 in this window')
    .replace(/\b(\d[\d,.]*(?:\s?(?:K|M|B|KB|MB|GB|TB))?)\s+(requests?|GETs|(?:function\s+)?invocations?|bytes|egress|bandwidth|writes?|reads?|errors?)\/window\b/gi, '$1 $2 in this window')
    .replace(/\b(\d[\d,.]*(?:\s?(?:K|M|B|KB|MB|GB|TB))?)\/window\b/gi, '$1 in this window')
    .replace(/\b(requests?|invocations?|GETs|bytes|egress|bandwidth|writes?|reads?|errors?)\/window\b/gi, '$1 in this window');
}

export function formatCandidateLine(candidate) {
  return `${formatKind(candidate?.kind)} on ${formatRoute(candidate)} - ${formatSignal(candidate?.o11ySignal, candidate)}`;
}

export function formatCandidateLabel(candidate) {
  return `${formatKind(candidate?.kind)} on ${formatRoute(candidate)}`;
}

function formatSignalPart(part, context = {}) {
  const eq = part.indexOf('=');
  if (eq === -1) return part;

  const key = part.slice(0, eq).trim();
  const value = part.slice(eq + 1).trim();
  const label = signalLabel(key, context);
  return `${label}: ${formatSignalValue(key, value)}`;
}

function signalLabel(key, context = {}) {
  const kind = typeof context === 'string' ? context : context?.kind;
  if (key === 'inv' && REQUEST_COUNT_KINDS.has(kind)) return 'requests';
  return SIGNAL_LABELS.get(key) ?? humanizeKey(key);
}

function humanizeKey(key) {
  return String(key)
    .replaceAll('.', ' ')
    .replaceAll('_', ' ')
    .replaceAll('-', ' ')
    .trim();
}

function formatSignalValue(key, value) {
  if (key === 'inv' || key === 'runs' || key === 'middleware_inv' || key === 'total_req' || key === 'requests' || key === 'calls' || key === 'errs' || key === 'writes' || key === 'reads') {
    return formatNumberLike(value);
  }
  return value;
}

function formatNumberLike(value) {
  const n = Number(value);
  if (!Number.isFinite(n)) return value;
  return new Intl.NumberFormat('en-US', { maximumFractionDigits: 2 }).format(n);
}