// REPORT view — per-LLM breakdown is the hero. // What each cluster actually measures, in one sentence. Surfaced as a // caption row under the cluster name so the table stops being a wall of // numbers without context. Sourced from the cluster definitions in // engine/components.js. const CLUSTER_DESC = { semanticRelevance: 'Does the page answer the queries it should? Embedding similarity + heading-section coherence.', intentCoverage: 'Coverage across definition / mechanics / alternatives / follow-up facets — does it answer the WHOLE question or one slice?', trustReliability: 'Numeric claims with sources, confident phrasing, consistent terminology — what makes an LLM treat this as authoritative.', contentClarity: 'Sentence length, paragraph rhythm, concrete examples. Per-language readability formula.', entityAuthority: 'Schema, Wikipedia, external profiles, brand disambiguation. Can an LLM tell which entity this page is about?', citationPotential: 'Standalone quotable lines, stats, tables, FAQ pairs. The shape of content LLMs lift verbatim.', structureReadability: 'Schema.org blocks, clean HTML, robots access, llms.txt. The crawlability layer.', freshness: 'Last-Modified header, ISO dateModified in JSON-LD, current-year references. Perplexity weights this 4× more than Claude does.', crossReference: 'Reddit / GitHub / Wikipedia / YouTube / G2 mentions. Off-page signal that you exist outside your own site.', toolActionability: 'Pricing, sign-up, API docs, server-rendered. Does the page give the user something to DO?' }; // What each platform-score column means, used in a tooltip and short caption. const PLATFORM_DESC = { chatgpt: 'Wikipedia + structured references + brand reputation dominate (Bing-backed, E-E-A-T heavy).', claude: 'Long-form coherence, copyright hygiene, citation discipline. Evergreen bias.', gemini: 'Schema.org + entity authority + Knowledge Graph anchoring. Cleanly parseable HTML.', perplexity: 'Freshness-driven (82% of citations under 30 days) + quotable spans + lexical match.', googleAio: 'Reddit + community signals + Knowledge Graph + featured-snippet format.', deepseek: 'Dense-embedding semantic match + clean technical prose + markdown/code blocks.' }; function Report({ data }) { const composite = data.score; // Claude-written recommendations. The /api/recommendations endpoint takes // the heuristic fixes and rewrites them as concrete, paste-able prose // (title + rewrite + why). Was previously unwired in the React tree — // user reported "tavsiyeler nerede?" because the heuristic FIX LIST was // the only thing on the page and didn't read as advice. const [recs, setRecs] = React.useState({ state: 'idle', items: [], provider: '', note: '' }); React.useEffect(() => { // Bail when we have no domain yet (first paint shows the demo dataset). if (!data?.domain || !data?.fixes?.length) return; let cancelled = false; setRecs({ state: 'loading', items: [], provider: '', note: '' }); (async () => { try { const r = await fetch('/api/recommendations', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ domain: data.domain, brand: data.brand || data.domain, // Shape the heuristic fixes into what /api/recommendations expects fixes: data.fixes.slice(0, 6).map(f => ({ component: f.cluster, impact: f.impact, text: `${f.title}. ${f.detail}` })), components: Object.fromEntries((data.clusters || []).map(c => [c.id, { score: c.score, label: c.label }])), lang: (document.documentElement.lang || 'en').slice(0, 2) }) }); const j = await r.json(); if (cancelled) return; if (!j?.ok) throw new Error(j?.error || 'recs failed'); setRecs({ state: 'ready', items: j.items || [], provider: j.provider || '', note: j.note || '' }); } catch (e) { if (cancelled) return; setRecs({ state: 'error', items: [], provider: '', note: String(e?.message || e) }); } })(); return () => { cancelled = true; }; }, [data?.domain, data?.score]); // refetch when scan changes // Derive a few status tags from the actual scan data instead of using // hardcoded mocks. Previously the status row showed "FILTERS PASSED / // SCHEMA VALID / FRESHNESS WEAK / GEMINI -2 WoW / PERPLEXITY +6 WoW" // regardless of what was scanned — confusing because they looked real. const tags = React.useMemo(() => { const out = []; const clusterById = Object.fromEntries((data.clusters || []).map(c => [c.id, c])); const fresh = clusterById.freshness; const struct = clusterById.structureReadability; const trust = clusterById.trustReliability; if (struct && struct.score >= 0.75) out.push({ kind: 'ok', label: 'SCHEMA STRONG' }); if (fresh && fresh.score < 0.5) out.push({ kind: 'warn', label: 'FRESHNESS WEAK' }); if (trust && trust.score < 0.5) out.push({ kind: 'crit', label: 'TRUST LOW' }); const platforms = data.platforms || []; if (platforms.length >= 2) { const best = platforms.reduce((b, p) => p.score > b.score ? p : b, platforms[0]); const worst = platforms.reduce((w, p) => p.score < w.score ? p : w, platforms[0]); if (best.score - worst.score >= 30) { out.push({ kind: 'info', label: `${best.name.toUpperCase()} >${(best.score - worst.score).toFixed(0)}pt > ${worst.name.toUpperCase()}` }); } const cited = platforms.filter(p => p.cited).length; if (cited === platforms.length) out.push({ kind: 'ok', label: 'CITED ON ALL' }); else if (cited === 0) out.push({ kind: 'crit', label: 'CITED ON NONE' }); else out.push({ kind: 'warn', label: `CITED ON ${cited}/${platforms.length}` }); } return out.slice(0, 5); }, [data]); // One-line interpretation of the composite score. Uses the score band, not // just the grade letter, so the band can shift as the algorithm updates. const verdict = React.useMemo(() => { if (composite >= 80) return 'Strong. LLMs cite you confidently. Focus on freshness + cross-reference to defend.'; if (composite >= 65) return 'Solid. The fundamentals are right; the fix list below is incremental work, not surgery.'; if (composite >= 50) return 'Borderline. LLMs occasionally cite you. Two or three of the top fixes will move the needle visibly.'; if (composite >= 35) return 'Weak. The page is parseable but missing the signals retrievers reward. Start at the top of the fix list.'; return 'Critical. Hard filters or major signal gaps make the page mostly invisible. Address the top fix before anything else.'; }, [composite]); return (
{/* status bar */}
TARGET: {data.domain} BRAND: {data.brand} SCANNED: {new Date(data.scannedAt).toLocaleString()} DURATION: {(data.scanMs/1000).toFixed(2)}s
{(data.brand || data.domain || "REPORT").slice(0, 24).toUpperCase()} EXPORT
{/* HOW TO READ — explanatory callout above the report. Without it users land on a wall of numbers and ask "what am I looking at?" */}
// HOW TO READ THIS REPORT

The big number is your composite score (0-100) — a 70/30 blend of cluster-weighted signals and live LLM probe results. Below that, six per-LLM scores show how each engine specifically would rate you (same signals, different weights). Then 10 cluster scores show WHERE the score came from, and the prioritised fix list shows WHAT to do about it. Start at the top of the fix list — it's sorted by expected lift.

// VERDICT

{verdict}

{/* COMPOSITE STRIP */}
COMPOSITE / 100
{data.grade}
7d
30-DAY TREND
70% from 10 weighted signals × penalty multiplier · 30% from live LLM citation probes. Higher = more likely to be cited in answer text.
EXECUTIVE SUMMARY

{data.summary}

{tags.length === 0 ? No standout signals — see clusters below. : tags.map((t, i) => {t.label})}
PER-LLM AT A GLANCE
{data.platforms.map((p) => (
{p.name} {p.score}
))}
{/* PER-LLM HERO — six vertical readouts */}
// PER-LLM PLATFORM SCORES

How each engine sees you.

Same 10 signals, re-weighted to each engine's documented citation bias. The big number is HEURISTIC (always available — derived from your cluster scores); MENTION / CITATION rates come from LIVE API probes (require the matching API key). "CITED" = the engine cited or mentioned you in at least one probe; if you don't have its API key, a positive heuristic score still earns the badge.

{data.platforms.length} platforms · heuristic + live blend
{data.platforms.map((p) => (
{p.cited ? "CITED" : "NOT CITED"}
{p.name}
{p.provider}
· 7D
MENTION
{(p.mentionRate * 100).toFixed(0)}%
CITATION
{(p.citationRate * 100).toFixed(0)}%
AVG POS
{p.avgPosition.toFixed(1)}
PROBES
{p.probesCited}/{p.probesRun}
SAMPLE QUERY
{p.sampleQuery}
{p.sampleAnswer}
))}
{/* RECOMMENDATIONS — Claude-written, paste-able. Sits right after the per-LLM hero so users see ACTIONABLE prose before the deep cluster tables. Falls back to the heuristic fix list if Claude is offline. */}
// RECOMMENDATIONS · WHAT TO DO

Concrete fixes, written for you.

Each card is a paste-able rewrite — actual copy, schema, or HTML you can drop onto your page. Generated by Claude from your top 6 fixes + cluster scores. Start at the top; each one is ranked by expected lift.

{recs.state === 'ready' && recs.provider} {recs.state === 'loading' && 'Generating…'} {recs.state === 'error' && 'Recommendations offline'}
{recs.state === 'idle' && (
Run a scan to get tailored recommendations.
)} {recs.state === 'loading' && (
▣ Claude is writing concrete fixes for {data.domain}…
typically 6-12s
)} {recs.state === 'error' && (
Couldn't reach the recommendations service: {recs.note}
Falling back to the heuristic fix list below — same ranked order, just less prose.
)} {recs.state === 'ready' && recs.items.length === 0 && (
No recommendations generated. {recs.note}
)} {recs.state === 'ready' && recs.items.length > 0 && ( <> {recs.note && (
ⓘ {recs.note}
)}
{recs.items.map((rec, i) => { const tagColor = { rewrite: 'var(--info)', add: 'var(--accent)', restructure: 'var(--warn)', remove: 'var(--crit)' }[rec.tag] || 'var(--ink-dim)'; return (
REC/{String(i + 1).padStart(2, "0")} {rec.tag && ( {rec.tag} )} {rec.component && ( · {rec.component} )}

{rec.title}

{rec.rewrite && ( 
                          {rec.rewrite}
)} {rec.why && (
Why: {rec.why}
)}
); })}
)}
{/* CLUSTERS — detail */}
// 10 CLUSTER SCORES

Signal-by-signal breakdown.

Each cluster scores a different aspect of "would an LLM cite this?". WEIGHT = how much the cluster contributes to the composite. SCORE = how well your page does on it (0-100). CONTRIB = weight × score = points contributed to the composite. Lowest scores with the highest weights are where to focus — the fix list below ranks them automatically.

composite = Σ ( weighti × scorei )
#CLUSTERWEIGHTSCOREBARCONTRIB
{data.clusters.map((c, i) => { const contrib = c.weight * c.score * 100; const desc = CLUSTER_DESC[c.id]; return (
{String(i + 1).padStart(2, "0")} {c.label} ×{c.weight.toFixed(2)} {(c.score * 100).toFixed(0)} +{contrib.toFixed(1)}
{desc && (
{desc}
)}
); })}
{/* SPIDERS */}
// 8 SPIDER PERSONAS

Each crawls with a different objective.

Each spider re-scores the same page through one specific lens. Disagreement between spiders is the signal: if RETRIEVAL and CITATION are high but ENTITY is low, your page is technically retrievable but the LLM doesn't know which brand it's about. The narrowest spider score tells you the layer to fix first. The Agents view shows them running live.

retrieval · citation · intent · entity · trust · freshness · actionability · multimodal
{data.spiders.map((s) => { const pct = (s.score * 100).toFixed(0); return (
{s.label} {pct}
FOCUS · {s.focus}
); })}
{/* FIXES — heuristic backup view, complementary to RECOMMENDATIONS above */}
// FIX LIST · technical breakdown

Same fixes, ranked numerically.

The terse heuristic version of the recommendations above — useful when you want to see the raw expected-lift math or filter by cluster. EXPECTED LIFT = weight × (1 − score) is the max points you'd gain. EFFORT (XS / S / M / L) is a rough engineering estimate.

lift = weight × (1 − score) · top {data.fixes?.length || 0}
{data.fixes.map((f, i) => (
{f.lift}
EXPECTED LIFT
FIX/{String(i+1).padStart(2,"0")} {f.cluster}

{f.title}

{f.detail}

EFFORT
{f.effort}
↗
))}
{/* RAW PROBES */}
// RAW PROBE LOG

Every query, every model, every response.

The actual buyer-intent queries we ran against each LLM, with the verbatim responses. "UNDER-INDEXED" doesn't mean the score is wrong — it means the LLM's answer for that query didn't mention or cite the brand. Click each row to see the sample query + response. Useful for "why does Gemini not cite us for X?" debugging.

{data.platforms.length} models
{data.platforms.map((p) => (
{p.name} probes returned {p.probesCited}/{p.probesRun} with brand mention mention {(p.mentionRate*100).toFixed(0)}% cite {(p.citationRate*100).toFixed(0)}% {p.cited ? "● PASS" : "● UNDER-INDEXED"}
PROBE 1/8 · {p.sampleQuery}
→ {p.sampleAnswer}
))}
); } window.Report = Report;