import { sql, type SQL } from 'drizzle-orm';
import type { FastifyPluginAsyncZod } from 'fastify-type-provider-zod';
import { z } from 'zod';
import type { Database } from '@cancerindex/database';
import { descendantIds } from '../lib/descendants.js';
import { BadRequest } from '../lib/errors.js';
import { boolQuery } from '../lib/pagination.js';
import { resolveCancer, resolveDrug, resolveGene, resolveTrial, resolveVariant } from '../lib/resolve.js';
import { AnyRecord, num, ok, respond } from '../lib/respond.js';

/**
 * Knowledge-graph routes (SPEC §18, §80).
 *
 *  GET /graph/:type/:id?limit=&rel=&context=&includeDerived=  → contextual neighbourhood of one entity
 *  GET /graph/:type/:id/paths                                   → cancer → gene → variant → drug → approval → trials chains (cancer only)
 *
 * Two families of links, never merged: source-native `knowledge_edges` rows (CIViC, ChEMBL, openFDA)
 * kept with their native evidence level, direction and cancer context, aggregated per
 * (neighbour, relationship, direction, level, source); and `derived: true` registry counts computed
 * at query time (trial_conditions, trial_interventions, cancer_gene_frequencies, drug_approvals,
 * civic_evidence_items). CancerIndex never infers an edge.
 *
 * The SQL is intentionally duplicated from `apps/web/src/lib/queries/graph.ts`: that module is
 * `server-only` and bound to the Next.js database helpers, so it cannot be imported here. Keep the
 * two in step when changing thresholds or ordering.
 */

const TYPES = ['cancer', 'gene', 'variant', 'drug', 'trial'] as const;
type FocusType = (typeof TYPES)[number];
type NodeType = FocusType | 'approval';

const ACTIVE = ['RECRUITING', 'NOT_YET_RECRUITING', 'ENROLLING_BY_INVITATION', 'ACTIVE_NOT_RECRUITING'];
const FREQ_MIN = 0.05;
const CASES_MIN = 20;
const TRIAL_LIMIT = 10;
const MAX_DESCENDANTS = 600;
const SRC = { clinicaltrials: 'CI-SOURCE-00000004', civic: 'CI-SOURCE-00000006' } as const;

const inList = (ids: string[]): SQL => sql`(${sql.join(ids.map((i) => sql`${i}`), sql`, `)})`;
const activeList = (): SQL => sql`(${sql.join(ACTIVE.map((s) => sql`${s}`), sql`, `)})`;
const LEVEL_RANK = sql`CASE upper(coalesce(ke.evidence_level, '')) WHEN 'A' THEN 0 WHEN 'FDA ORIG' THEN 0 WHEN 'B' THEN 1 WHEN '4' THEN 1 WHEN 'C' THEN 2 WHEN '3' THEN 2 WHEN 'D' THEN 3 WHEN '2' THEN 3 WHEN 'E' THEN 4 WHEN '1' THEN 4 WHEN '' THEN 99 ELSE 50 END`;
const CIVIC_LEVEL_RANK = sql`CASE e.evidence_level WHEN 'A' THEN 0 WHEN 'B' THEN 1 WHEN 'C' THEN 2 WHEN 'D' THEN 3 WHEN 'E' THEN 4 ELSE 99 END`;

interface Node {
  type: NodeType;
  id: string;
  ref: string | null;
  label: string;
  sublabel?: string | null;
  href: string;
}
interface Edge {
  relationshipType: string;
  outgoing: boolean;
  direction: string | null;
  evidenceLevel: string | null;
  evidenceCategory: string;
  cancerContext: Array<{ id: string; name: string; slug: string }>;
  supportCount: number;
  sourceIds: string[];
  provenanceIds: number[];
  derived: boolean;
  detail?: string | null;
  date?: string | null;
  via?: { type: NodeType; id: string; label: string; href: string } | null;
}
interface Link {
  node: Node;
  edge: Edge;
}
interface Derived {
  relationshipType: string;
  total: number;
  links: Link[];
}

const href = (type: NodeType, ref: string): string => (type === 'cancer' ? `/cancer/${ref}` : type === 'gene' ? `/gene/${ref}` : type === 'variant' ? `/variant/${ref}` : type === 'drug' ? `/drug/${ref}` : type === 'trial' ? `/trial/${ref}` : ref);
const pct = (v: number) => `${(v * 100).toFixed(v >= 0.1 ? 0 : 1)} %`;

async function resolveFocus(db: Database, type: FocusType, ref: string): Promise<Node & { ref: string }> {
  switch (type) {
    case 'cancer': {
      const c = await resolveCancer(db, ref);
      const r = await db.execute<{ canonical_name: string; entity_type: string }>(sql`SELECT canonical_name, entity_type FROM cancers WHERE id = ${c.id}`);
      return { type, id: c.id, ref: c.slug, label: r[0]?.canonical_name ?? c.slug, sublabel: r[0]?.entity_type ?? null, href: href(type, c.slug) };
    }
    case 'gene': {
      const g = await resolveGene(db, ref);
      const r = await db.execute<{ name: string | null }>(sql`SELECT name FROM genes WHERE id = ${g.id}`);
      return { type, id: g.id, ref: g.symbol, label: g.symbol, sublabel: r[0]?.name ?? null, href: href(type, g.symbol) };
    }
    case 'variant': {
      const v = await resolveVariant(db, ref);
      const r = await db.execute<{ label: string; variant_type: string | null }>(sql`SELECT coalesce(gene_symbol || ' ', '') || name AS label, variant_type FROM variants WHERE id = ${v.id}`);
      return { type, id: v.id, ref: v.slug, label: r[0]?.label ?? v.slug, sublabel: r[0]?.variant_type ?? null, href: href(type, v.slug) };
    }
    case 'drug': {
      const d = await resolveDrug(db, ref);
      const r = await db.execute<{ name: string; kind: string | null }>(sql`SELECT name, kind FROM drugs WHERE id = ${d.id}`);
      return { type, id: d.id, ref: d.slug, label: r[0]?.name ?? d.slug, sublabel: r[0]?.kind ?? null, href: href(type, d.slug) };
    }
    case 'trial': {
      const t = await resolveTrial(db, ref);
      const r = await db.execute<{ brief_title: string; overall_status: string | null }>(sql`SELECT brief_title, overall_status FROM clinical_trials WHERE id = ${t.id}`);
      return { type, id: t.id, ref: t.nctId, label: r[0]?.brief_title ?? t.nctId, sublabel: r[0]?.overall_status ?? null, href: href(type, t.nctId) };
    }
  }
}

// ------------------------------------------------------------------ source-native edges

type KeRow = {
  relationship_type: string;
  outgoing: boolean;
  ctx_only: boolean;
  n_type: NodeType;
  n_id: string;
  n_ref: string | null;
  n_label: string | null;
  n_sublabel: string | null;
  via_type: NodeType | null;
  via_id: string | null;
  via_ref: string | null;
  via_label: string | null;
  direction: string | null;
  evidence_level: string | null;
  evidence_category: string;
  source_id: string;
  support: string;
  edge_ids: number[];
  provenance_ids: number[];
  context_ids: string[];
  last_seen: Date | null;
  total: string;
};

async function knowledgeEdges(db: Database, focus: Node, limit: number, rel: string | null, contextId: string | null): Promise<KeRow[]> {
  const t = focus.type;
  const id = focus.id;
  const ctx = t === 'cancer' ? sql`OR (${id} = ANY(ke.cancer_context_ids) AND ke.source_entity_id <> ${id} AND ke.target_entity_id <> ${id})` : sql``;
  const relF = rel ? sql`AND ke.relationship_type = ${rel}` : sql``;
  const ctxF = contextId ? sql`AND ${contextId} = ANY(ke.cancer_context_ids)` : sql``;
  return db.execute<KeRow>(sql`
    WITH e AS (
      SELECT ke.relationship_type,
             (ke.source_entity_type = ${t} AND ke.source_entity_id = ${id}) AS outgoing,
             (ke.source_entity_id <> ${id} AND ke.target_entity_id <> ${id}) AS ctx_only,
             CASE WHEN ke.source_entity_id = ${id} THEN ke.target_entity_type ELSE ke.source_entity_type END AS n_type,
             CASE WHEN ke.source_entity_id = ${id} THEN ke.target_entity_id ELSE ke.source_entity_id END AS n_id,
             CASE WHEN ke.source_entity_id <> ${id} AND ke.target_entity_id <> ${id} THEN ke.target_entity_type END AS via_type,
             CASE WHEN ke.source_entity_id <> ${id} AND ke.target_entity_id <> ${id} THEN ke.target_entity_id END AS via_id,
             ke.direction, ke.evidence_level, ke.evidence_category, ke.source_id, ke.id, ke.provenance_ids, ke.cancer_context_ids, ke.support_count, ke.last_seen_at, ${LEVEL_RANK} AS lvl
      FROM knowledge_edges ke
      WHERE ke.status = 'active' AND ((ke.source_entity_type = ${t} AND ke.source_entity_id = ${id}) OR (ke.target_entity_type = ${t} AND ke.target_entity_id = ${id}) ${ctx}) ${relF} ${ctxF}
    ), a AS (
      SELECT relationship_type, outgoing, ctx_only, n_type, n_id, via_type, via_id, direction, evidence_level, evidence_category, source_id, min(lvl) AS lvl,
             sum(support_count) AS support, array_agg(id ORDER BY id) AS edge_ids,
             (SELECT array_agg(DISTINCT x::int ORDER BY x::int) FROM unnest(string_to_array(string_agg(array_to_string(provenance_ids, ','), ','), ',')) x WHERE x <> '') AS provenance_ids,
             (SELECT array_agg(DISTINCT x ORDER BY x) FROM unnest(string_to_array(string_agg(array_to_string(cancer_context_ids, ','), ','), ',')) x WHERE x <> '') AS context_ids,
             max(last_seen_at) AS last_seen
      FROM e GROUP BY 1,2,3,4,5,6,7,8,9,10,11
    ), r AS (
      SELECT a.*, row_number() OVER (PARTITION BY a.relationship_type ORDER BY a.lvl, a.support DESC, a.last_seen DESC NULLS LAST, a.n_id, a.via_id) AS rn,
             count(*) OVER (PARTITION BY a.relationship_type) AS total
      FROM a
    )
    SELECT r.relationship_type, r.outgoing, r.ctx_only, r.n_type, r.n_id, r.via_type, r.via_id, r.direction, r.evidence_level, r.evidence_category, r.source_id,
           r.support, r.edge_ids, r.provenance_ids, r.context_ids, r.last_seen, r.total,
           coalesce(c.slug, g.symbol, v.slug, d.slug) AS n_ref,
           coalesce(c.canonical_name, g.symbol, coalesce(v.gene_symbol || ' ', '') || v.name, d.name) AS n_label,
           coalesce(c.entity_type, g.name, v.variant_type, d.kind) AS n_sublabel,
           coalesce(vc.slug, vg.symbol, vv.slug, vd.slug) AS via_ref,
           coalesce(vc.canonical_name, vg.symbol, coalesce(vv.gene_symbol || ' ', '') || vv.name, vd.name) AS via_label
    FROM r
    LEFT JOIN cancers c ON r.n_type = 'cancer' AND c.id = r.n_id
    LEFT JOIN genes g ON r.n_type = 'gene' AND g.id = r.n_id
    LEFT JOIN variants v ON r.n_type = 'variant' AND v.id = r.n_id
    LEFT JOIN drugs d ON r.n_type = 'drug' AND d.id = r.n_id
    LEFT JOIN cancers vc ON r.via_type = 'cancer' AND vc.id = r.via_id
    LEFT JOIN genes vg ON r.via_type = 'gene' AND vg.id = r.via_id
    LEFT JOIN variants vv ON r.via_type = 'variant' AND vv.id = r.via_id
    LEFT JOIN drugs vd ON r.via_type = 'drug' AND vd.id = r.via_id
    WHERE r.rn <= ${limit}
    ORDER BY r.relationship_type, r.rn`);
}

// ------------------------------------------------------------------ derived registry links

const total = (rows: Array<{ total: string }>) => (rows.length ? num(rows[0]!.total) : 0);

async function frequencyLinks(db: Database, side: 'cancer' | 'gene', focus: Node, ids: string[], limit: number): Promise<Derived> {
  type Row = { gene_id: string; symbol: string; is_cancer_gene: boolean; cancer_id: string; cancer_slug: string; cancer_name: string; alteration_type: string; cases_affected: number; cases_profiled: number; frequency: number; study_id: string; source_id: string; provenance_id: number; cohorts: string; total: string };
  const where = side === 'cancer' ? sql`f.cancer_id IN ${inList(ids)} AND f.gene_id IS NOT NULL` : sql`f.gene_id = ${focus.id} AND f.cancer_id IS NOT NULL`;
  const part = side === 'cancer' ? sql`f.gene_id` : sql`f.cancer_id`;
  const order = side === 'cancer' ? sql`g.is_cancer_gene DESC, f.frequency DESC, g.symbol` : sql`f.frequency DESC, c.canonical_name`;
  const rows = await db.execute<Row>(sql`
    WITH f AS (
      SELECT f.gene_id, f.cancer_id, f.alteration_type, f.cases_affected, f.cases_profiled, f.frequency, f.provenance_id, co.study_id, co.source_id,
             count(*) OVER (PARTITION BY ${part}) AS cohorts, row_number() OVER (PARTITION BY ${part} ORDER BY f.cases_profiled DESC, f.frequency DESC, f.id) AS rn
      FROM cancer_gene_frequencies f JOIN genomic_cohorts co ON co.id = f.cohort_id
      WHERE ${where} AND f.frequency >= ${FREQ_MIN} AND f.cases_affected >= ${CASES_MIN}
    )
    SELECT f.*, g.symbol, g.is_cancer_gene, c.slug AS cancer_slug, c.canonical_name AS cancer_name, count(*) OVER() AS total
    FROM f JOIN genes g ON g.id = f.gene_id JOIN cancers c ON c.id = f.cancer_id WHERE f.rn = 1 ORDER BY ${order} LIMIT ${limit}`);
  return {
    relationshipType: 'ALTERED_IN',
    total: total(rows),
    links: rows.map((r) => ({
      node: side === 'cancer' ? { type: 'gene', id: r.gene_id, ref: r.symbol, label: r.symbol, sublabel: r.is_cancer_gene ? 'cancer gene' : null, href: href('gene', r.symbol) } : { type: 'cancer', id: r.cancer_id, ref: r.cancer_slug, label: r.cancer_name, href: href('cancer', r.cancer_slug) },
      edge: {
        relationshipType: 'ALTERED_IN',
        outgoing: side === 'gene',
        direction: null,
        evidenceLevel: null,
        evidenceCategory: 'observed_data',
        cancerContext: [{ id: r.cancer_id, name: r.cancer_name, slug: r.cancer_slug }],
        supportCount: num(r.cohorts),
        sourceIds: [r.source_id],
        provenanceIds: [r.provenance_id],
        derived: true,
        detail: `${r.cases_affected} / ${r.cases_profiled} cases (${pct(r.frequency)}) · ${r.alteration_type} · ${r.study_id}`,
        frequency: r.frequency,
        casesAffected: r.cases_affected,
        casesProfiled: r.cases_profiled,
        cohorts: num(r.cohorts),
      } as Edge,
    })),
  };
}

const trialNode = (r: { id: string; nct_id: string; overall_status: string | null; phases: string[] }): Node => ({ type: 'trial', id: r.id, ref: r.nct_id, label: r.nct_id, sublabel: [r.phases.join('/'), r.overall_status].filter(Boolean).join(' · ') || null, href: href('trial', r.nct_id) });

async function cancerTrialLinks(db: Database, focus: Node, ids: string[], limit: number): Promise<Derived> {
  type Row = { id: string; nct_id: string; brief_title: string; overall_status: string | null; phases: string[]; last_update_posted_date: string | null; cancer_id: string; cancer_slug: string; cancer_name: string; match_type: string; total: string; active: string };
  const rows = await db.execute<Row>(sql`
    WITH m AS (SELECT DISTINCT ON (tc.trial_id) tc.trial_id, tc.cancer_id, tc.match_type FROM trial_conditions tc WHERE tc.cancer_id IN ${inList(ids)} ORDER BY tc.trial_id, (tc.cancer_id = ${focus.id}) DESC, tc.id)
    SELECT t.id, t.nct_id, t.brief_title, t.overall_status, t.phases, t.last_update_posted_date, m.cancer_id, c.slug AS cancer_slug, c.canonical_name AS cancer_name, m.match_type,
           count(*) OVER() AS total, count(*) FILTER (WHERE t.overall_status IN ${activeList()}) OVER() AS active
    FROM m JOIN clinical_trials t ON t.id = m.trial_id JOIN cancers c ON c.id = m.cancer_id
    ORDER BY t.last_update_posted_date DESC NULLS LAST, t.nct_id LIMIT ${limit}`);
  const tot = total(rows);
  const active = rows.length ? num(rows[0]!.active) : 0;
  return {
    relationshipType: 'STUDIED_IN',
    total: tot,
    links: rows.map((r) => ({
      node: trialNode(r),
      edge: { relationshipType: 'STUDIED_IN', outgoing: true, direction: null, evidenceLevel: null, evidenceCategory: 'observed_data', cancerContext: [{ id: r.cancer_id, name: r.cancer_name, slug: r.cancer_slug }], supportCount: 1, sourceIds: [SRC.clinicaltrials], provenanceIds: [], derived: true, detail: `${r.brief_title} · condition mapped ${r.match_type}`, date: r.last_update_posted_date, trialsTotal: tot, trialsActive: active } as Edge,
    })),
  };
}

async function cancerDrugTrialLinks(db: Database, focus: Node, ids: string[], limit: number): Promise<Derived> {
  type Row = { drug_id: string; slug: string; name: string; kind: string | null; trials: string; active: string; last: string | null; total: string };
  const rows = await db.execute<Row>(sql`
    SELECT ti.drug_id, d.slug, d.name, d.kind, count(DISTINCT ti.trial_id) AS trials, count(DISTINCT ti.trial_id) FILTER (WHERE t.overall_status IN ${activeList()}) AS active, max(t.last_update_posted_date) AS last, count(*) OVER() AS total
    FROM trial_conditions tc JOIN trial_interventions ti ON ti.trial_id = tc.trial_id AND ti.drug_id IS NOT NULL JOIN clinical_trials t ON t.id = tc.trial_id JOIN drugs d ON d.id = ti.drug_id
    WHERE tc.cancer_id IN ${inList(ids)} GROUP BY ti.drug_id, d.slug, d.name, d.kind ORDER BY trials DESC, d.name LIMIT ${limit}`);
  return {
    relationshipType: 'INVESTIGATED_IN_TRIALS',
    total: total(rows),
    links: rows.map((r) => ({
      node: { type: 'drug', id: r.drug_id, ref: r.slug, label: r.name, sublabel: r.kind, href: href('drug', r.slug) },
      edge: { relationshipType: 'INVESTIGATED_IN_TRIALS', outgoing: false, direction: null, evidenceLevel: null, evidenceCategory: 'observed_data', cancerContext: [{ id: focus.id, name: focus.label, slug: focus.ref ?? '' }], supportCount: num(r.trials), sourceIds: [SRC.clinicaltrials], provenanceIds: [], derived: true, detail: `${num(r.trials)} trials (${num(r.active)} active) · roll-up of the cancer and its descendants`, date: r.last, trialsTotal: num(r.trials), trialsActive: num(r.active) } as Edge,
    })),
  };
}

async function approvalLinks(db: Database, side: 'cancer' | 'drug', focus: Node, ids: string[], limit: number): Promise<Derived> {
  type Row = { id: number; drug_id: string; drug_slug: string; drug_name: string; kind: string | null; cancer_id: string | null; cancer_slug: string | null; cancer_name: string | null; tumor_agnostic: boolean; jurisdiction: string; authority: string; indication: string; approval_date: string | null; status: string; source_id: string; provenance_id: number; total: string };
  const where = side === 'cancer' ? sql`a.cancer_id IN ${inList(ids)} AND NOT EXISTS (SELECT 1 FROM knowledge_edges ke WHERE ke.relationship_type = 'APPROVED_FOR' AND ke.source_entity_id = a.drug_id AND ke.target_entity_id = ${focus.id})` : sql`a.drug_id = ${focus.id} AND (a.cancer_id IS NULL OR NOT EXISTS (SELECT 1 FROM knowledge_edges ke WHERE ke.relationship_type = 'APPROVED_FOR' AND ke.source_entity_id = a.drug_id AND ke.target_entity_id = a.cancer_id))`;
  const rows = await db.execute<Row>(sql`
    SELECT a.id, a.drug_id, d.slug AS drug_slug, d.name AS drug_name, d.kind, a.cancer_id, c.slug AS cancer_slug, c.canonical_name AS cancer_name, a.tumor_agnostic, a.jurisdiction, a.authority, a.indication, a.approval_date, a.status, a.source_id, a.provenance_id, count(*) OVER() AS total
    FROM drug_approvals a JOIN drugs d ON d.id = a.drug_id LEFT JOIN cancers c ON c.id = a.cancer_id WHERE ${where} ORDER BY a.approval_date DESC NULLS LAST, a.id LIMIT ${limit}`);
  return {
    relationshipType: 'APPROVED_FOR',
    total: total(rows),
    links: rows.map((r) => {
      const node: Node =
        side === 'cancer'
          ? { type: 'drug', id: r.drug_id, ref: r.drug_slug, label: r.drug_name, sublabel: r.kind, href: href('drug', r.drug_slug) }
          : r.cancer_id && r.cancer_slug && r.cancer_name
            ? { type: 'cancer', id: r.cancer_id, ref: r.cancer_slug, label: r.cancer_name, href: href('cancer', r.cancer_slug) }
            : { type: 'approval', id: `approval:${r.id}`, ref: null, label: `${r.authority} · ${r.jurisdiction}${r.approval_date ? ` · ${r.approval_date.slice(0, 4)}` : ''}`, sublabel: r.indication, href: `/drug/${r.drug_slug}#approvals` };
      return {
        node,
        edge: { relationshipType: 'APPROVED_FOR', outgoing: side === 'drug', direction: null, evidenceLevel: r.status, evidenceCategory: 'regulatory_status', cancerContext: r.cancer_id && r.cancer_slug && r.cancer_name ? [{ id: r.cancer_id, name: r.cancer_name, slug: r.cancer_slug }] : [], supportCount: 1, sourceIds: [r.source_id], provenanceIds: [r.provenance_id], derived: true, detail: `${r.authority} (${r.jurisdiction}) · ${r.status}${r.tumor_agnostic ? ' · tumour-agnostic' : ''}`, date: r.approval_date, jurisdiction: r.jurisdiction, authority: r.authority, status: r.status, indication: r.indication, tumorAgnostic: r.tumor_agnostic } as Edge,
      };
    }),
  };
}

async function geneVariantLinks(db: Database, focus: Node, limit: number): Promise<Derived> {
  type Row = { id: string; slug: string; name: string; variant_type: string | null; ev: string; context_ids: string[] | null; provenance_ids: number[] | null; total: string };
  const rows = await db.execute<Row>(sql`
    WITH ev AS (
      SELECT vid, count(*) AS ev, (array_agg(DISTINCT e.cancer_id) FILTER (WHERE e.cancer_id IS NOT NULL))[1:5] AS context_ids, (array_agg(DISTINCT e.provenance_id))[1:20] AS provenance_ids
      FROM civic_evidence_items e CROSS JOIN LATERAL unnest(e.variant_ids) vid WHERE e.status = 'ACCEPTED' AND (${focus.id} = ANY(e.gene_ids) OR ${focus.label} = ANY(e.gene_symbols)) GROUP BY vid
    )
    SELECT v.id, v.slug, v.name, v.variant_type, coalesce(ev.ev, 0) AS ev, ev.context_ids, ev.provenance_ids, count(*) OVER() AS total
    FROM variants v LEFT JOIN ev ON ev.vid = v.id WHERE v.gene_id = ${focus.id} ORDER BY coalesce(ev.ev, 0) DESC, v.name LIMIT ${limit}`);
  return {
    relationshipType: 'HAS_VARIANT',
    total: total(rows),
    links: rows.map((r) => ({
      node: { type: 'variant', id: r.id, ref: r.slug, label: r.name, sublabel: r.variant_type, href: href('variant', r.slug) },
      edge: { relationshipType: 'HAS_VARIANT', outgoing: true, direction: null, evidenceLevel: null, evidenceCategory: num(r.ev) > 0 ? 'curated_evidence' : 'observed_data', cancerContext: (r.context_ids ?? []).map((id) => ({ id, name: id, slug: '' })), supportCount: num(r.ev), sourceIds: [SRC.civic], provenanceIds: r.provenance_ids ?? [], derived: true, detail: `${num(r.ev)} accepted CIViC evidence items` } as Edge,
    })),
  };
}

async function variantEvidenceLinks(db: Database, focus: Node, limit: number): Promise<Derived> {
  type Row = { cancer_id: string; slug: string; name: string; items: string; levels: string[] | null; best: string | null; sens: string; res: string; supports: string; does_not: string; provenance_ids: number[]; total: string };
  const rows = await db.execute<Row>(sql`
    SELECT e.cancer_id, c.slug, c.canonical_name AS name, count(*) AS items, array_agg(DISTINCT e.evidence_level ORDER BY e.evidence_level) FILTER (WHERE e.evidence_level IS NOT NULL) AS levels, min(e.evidence_level) AS best,
           count(*) FILTER (WHERE e.significance ILIKE '%SENSITIV%') AS sens, count(*) FILTER (WHERE e.significance ILIKE '%RESIST%') AS res,
           count(*) FILTER (WHERE e.evidence_direction = 'SUPPORTS') AS supports, count(*) FILTER (WHERE e.evidence_direction = 'DOES_NOT_SUPPORT') AS does_not,
           (array_agg(DISTINCT e.provenance_id))[1:50] AS provenance_ids, count(*) OVER() AS total
    FROM civic_evidence_items e JOIN cancers c ON c.id = e.cancer_id WHERE e.status = 'ACCEPTED' AND ${focus.id} = ANY(e.variant_ids)
    GROUP BY e.cancer_id, c.slug, c.canonical_name ORDER BY min(${CIVIC_LEVEL_RANK}), items DESC, c.canonical_name LIMIT ${limit}`);
  return {
    relationshipType: 'HAS_EVIDENCE_IN',
    total: total(rows),
    links: rows.map((r) => {
      const sens = num(r.sens);
      const res = num(r.res);
      return {
        node: { type: 'cancer', id: r.cancer_id, ref: r.slug, label: r.name, href: href('cancer', r.slug) },
        edge: { relationshipType: 'HAS_EVIDENCE_IN', outgoing: true, direction: sens && res ? 'mixed' : sens ? 'sensitivity' : res ? 'resistance' : num(r.supports) && !num(r.does_not) ? 'supports' : num(r.does_not) ? 'does not support' : null, evidenceLevel: r.best, evidenceCategory: 'curated_evidence', cancerContext: [{ id: r.cancer_id, name: r.name, slug: r.slug }], supportCount: num(r.items), sourceIds: [SRC.civic], provenanceIds: r.provenance_ids ?? [], derived: true, levels: r.levels ?? [], sensitivity: sens, resistance: res, supports: num(r.supports), doesNotSupport: num(r.does_not) } as Edge,
      };
    }),
  };
}

async function variantDrugCivicLinks(db: Database, focus: Node, limit: number): Promise<Derived> {
  type Row = { drug_id: string; slug: string; name: string; kind: string | null; items: string; best: string | null; sens: string; res: string; context_ids: string[] | null; provenance_ids: number[]; total: string };
  const rows = await db.execute<Row>(sql`
    SELECT tid AS drug_id, d.slug, d.name, d.kind, count(*) AS items, min(e.evidence_level) AS best, count(*) FILTER (WHERE e.significance ILIKE '%SENSITIV%') AS sens, count(*) FILTER (WHERE e.significance ILIKE '%RESIST%') AS res,
           (array_agg(DISTINCT e.cancer_id) FILTER (WHERE e.cancer_id IS NOT NULL))[1:5] AS context_ids, (array_agg(DISTINCT e.provenance_id))[1:50] AS provenance_ids, count(*) OVER() AS total
    FROM civic_evidence_items e CROSS JOIN LATERAL unnest(e.therapy_ids) tid JOIN drugs d ON d.id = tid
    WHERE e.status = 'ACCEPTED' AND e.evidence_type = 'PREDICTIVE' AND ${focus.id} = ANY(e.variant_ids)
      AND NOT EXISTS (SELECT 1 FROM knowledge_edges ke WHERE ke.relationship_type = 'PREDICTS_RESPONSE_TO' AND ke.source_entity_id = ${focus.id} AND ke.target_entity_id = tid)
    GROUP BY tid, d.slug, d.name, d.kind ORDER BY min(${CIVIC_LEVEL_RANK}), items DESC, d.name LIMIT ${limit}`);
  return {
    relationshipType: 'PREDICTS_RESPONSE_TO',
    total: total(rows),
    links: rows.map((r) => {
      const sens = num(r.sens);
      const res = num(r.res);
      return {
        node: { type: 'drug', id: r.drug_id, ref: r.slug, label: r.name, sublabel: r.kind, href: href('drug', r.slug) },
        edge: { relationshipType: 'PREDICTS_RESPONSE_TO', outgoing: true, direction: sens && res ? 'mixed' : sens ? 'sensitivity' : res ? 'resistance' : null, evidenceLevel: r.best, evidenceCategory: 'curated_evidence', cancerContext: (r.context_ids ?? []).map((id) => ({ id, name: id, slug: '' })), supportCount: num(r.items), sourceIds: [SRC.civic], provenanceIds: r.provenance_ids ?? [], derived: true, detail: `${num(r.items)} accepted predictive items aggregated from CIViC (no knowledge edge yet)` } as Edge,
      };
    }),
  };
}

async function drugTrialLinks(db: Database, focus: Node, limit: number): Promise<Derived> {
  type Row = { id: string; nct_id: string; brief_title: string; overall_status: string | null; phases: string[]; last_update_posted_date: string | null; context_ids: string[] | null; total: string; active: string };
  const rows = await db.execute<Row>(sql`
    SELECT t.id, t.nct_id, t.brief_title, t.overall_status, t.phases, t.last_update_posted_date,
           (SELECT (array_agg(DISTINCT tc.cancer_id))[1:5] FROM trial_conditions tc WHERE tc.trial_id = t.id AND tc.cancer_id IS NOT NULL) AS context_ids,
           count(*) OVER() AS total, count(*) FILTER (WHERE t.overall_status IN ${activeList()}) OVER() AS active
    FROM (SELECT DISTINCT trial_id FROM trial_interventions WHERE drug_id = ${focus.id}) ti JOIN clinical_trials t ON t.id = ti.trial_id
    ORDER BY t.last_update_posted_date DESC NULLS LAST, t.nct_id LIMIT ${limit}`);
  const tot = total(rows);
  const active = rows.length ? num(rows[0]!.active) : 0;
  return {
    relationshipType: 'STUDIED_IN',
    total: tot,
    links: rows.map((r) => ({
      node: trialNode(r),
      edge: { relationshipType: 'STUDIED_IN', outgoing: true, direction: null, evidenceLevel: null, evidenceCategory: 'observed_data', cancerContext: (r.context_ids ?? []).map((id) => ({ id, name: id, slug: '' })), supportCount: 1, sourceIds: [SRC.clinicaltrials], provenanceIds: [], derived: true, detail: r.brief_title, date: r.last_update_posted_date, trialsTotal: tot, trialsActive: active } as Edge,
    })),
  };
}

async function drugCancerTrialLinks(db: Database, focus: Node, limit: number): Promise<Derived> {
  type Row = { cancer_id: string; slug: string; name: string; trials: string; active: string; last: string | null; total: string };
  const rows = await db.execute<Row>(sql`
    SELECT tc.cancer_id, c.slug, c.canonical_name AS name, count(DISTINCT tc.trial_id) AS trials, count(DISTINCT tc.trial_id) FILTER (WHERE t.overall_status IN ${activeList()}) AS active, max(t.last_update_posted_date) AS last, count(*) OVER() AS total
    FROM trial_interventions ti JOIN trial_conditions tc ON tc.trial_id = ti.trial_id AND tc.cancer_id IS NOT NULL JOIN clinical_trials t ON t.id = ti.trial_id JOIN cancers c ON c.id = tc.cancer_id
    WHERE ti.drug_id = ${focus.id} GROUP BY tc.cancer_id, c.slug, c.canonical_name ORDER BY trials DESC, c.canonical_name LIMIT ${limit}`);
  return {
    relationshipType: 'INVESTIGATED_IN_TRIALS',
    total: total(rows),
    links: rows.map((r) => ({
      node: { type: 'cancer', id: r.cancer_id, ref: r.slug, label: r.name, href: href('cancer', r.slug) },
      edge: { relationshipType: 'INVESTIGATED_IN_TRIALS', outgoing: true, direction: null, evidenceLevel: null, evidenceCategory: 'observed_data', cancerContext: [{ id: r.cancer_id, name: r.name, slug: r.slug }], supportCount: num(r.trials), sourceIds: [SRC.clinicaltrials], provenanceIds: [], derived: true, detail: `${num(r.trials)} trials (${num(r.active)} active) · conditions mapped to this cancer only`, date: r.last, trialsTotal: num(r.trials), trialsActive: num(r.active) } as Edge,
    })),
  };
}

async function trialLinks(db: Database, focus: Node, limit: number): Promise<Derived[]> {
  type CRow = { cancer_id: string; slug: string; name: string; match_type: string; condition_text: string; total: string };
  type DRow = { drug_id: string; slug: string; name: string; kind: string | null; match_type: string; intervention_type: string | null; iname: string; total: string };
  const [conds, ints] = await Promise.all([
    db.execute<CRow>(sql`SELECT tc.cancer_id, c.slug, c.canonical_name AS name, tc.match_type, tc.condition_text, count(*) OVER() AS total FROM trial_conditions tc JOIN cancers c ON c.id = tc.cancer_id WHERE tc.trial_id = ${focus.id} ORDER BY c.canonical_name LIMIT ${limit}`),
    db.execute<DRow>(sql`SELECT ti.drug_id, d.slug, d.name, d.kind, ti.match_type, ti.intervention_type, ti.name AS iname, count(*) OVER() AS total FROM trial_interventions ti JOIN drugs d ON d.id = ti.drug_id WHERE ti.trial_id = ${focus.id} ORDER BY d.name LIMIT ${limit}`),
  ]);
  return [
    {
      relationshipType: 'CONDITION_OF',
      total: total(conds),
      links: conds.map((r) => ({ node: { type: 'cancer', id: r.cancer_id, ref: r.slug, label: r.name, href: href('cancer', r.slug) }, edge: { relationshipType: 'CONDITION_OF', outgoing: false, direction: null, evidenceLevel: null, evidenceCategory: 'observed_data', cancerContext: [{ id: r.cancer_id, name: r.name, slug: r.slug }], supportCount: 1, sourceIds: [SRC.clinicaltrials], provenanceIds: [], derived: true, detail: `registry condition "${r.condition_text}" mapped ${r.match_type}`, matchType: r.match_type } as Edge })),
    },
    {
      relationshipType: 'INTERVENTION_OF',
      total: total(ints),
      links: ints.map((r) => ({ node: { type: 'drug', id: r.drug_id, ref: r.slug, label: r.name, sublabel: r.kind, href: href('drug', r.slug) }, edge: { relationshipType: 'INTERVENTION_OF', outgoing: false, direction: null, evidenceLevel: null, evidenceCategory: 'observed_data', cancerContext: [], supportCount: 1, sourceIds: [SRC.clinicaltrials], provenanceIds: [], derived: true, detail: `registry intervention "${r.iname}" (${r.intervention_type ?? 'type not stated'}) mapped ${r.match_type}`, matchType: r.match_type } as Edge })),
    },
  ];
}

async function cancerNames(db: Database, ids: Iterable<string>): Promise<Map<string, { id: string; name: string; slug: string }>> {
  const uniq = [...new Set(ids)].filter(Boolean);
  if (uniq.length === 0) return new Map();
  const rows = await db.execute<{ id: string; slug: string; name: string }>(sql`SELECT id, slug, canonical_name AS name FROM cancers WHERE id IN ${inList(uniq)}`);
  return new Map(rows.map((r) => [r.id, { id: r.id, slug: r.slug, name: r.name }]));
}

async function focusIds(db: Database, focus: Node): Promise<string[]> {
  if (focus.type !== 'cancer') return [];
  const ids = await descendantIds(db, focus.id);
  return ids.length > MAX_DESCENDANTS ? [focus.id, ...ids.filter((i) => i !== focus.id).slice(0, MAX_DESCENDANTS - 1)] : ids;
}

// ------------------------------------------------------------------ routes

export const graphRoutes: FastifyPluginAsyncZod = async (app) => {
  const params = z.object({ type: z.enum(TYPES).describe('Entity type'), id: z.string().min(1).max(200).describe('CI id, slug, HGNC symbol or NCT id') });

  app.get(
    '/graph/:type/:id',
    {
      schema: {
        tags: ['graph'],
        summary: 'Contextual neighbourhood of one entity: source-native knowledge edges (with cancer context, direction, evidence level, provenance) plus derived registry links',
        params,
        querystring: z.object({
          limit: z.coerce.number().int().min(1).max(200).default(25).describe('Edges per relationship type (trials default 10)'),
          rel: z.string().trim().toUpperCase().max(40).optional().describe('Only this relationship type (e.g. PREDICTS_RESPONSE_TO)'),
          context: z.string().trim().max(200).optional().describe('Only knowledge edges whose cancer context includes this cancer (CI id or slug)'),
          includeDerived: boolQuery.describe('Include derived registry links (default true)'),
        }),
        response: ok(AnyRecord),
      },
    },
    async (req) => {
      const db = app.db;
      const focus = await resolveFocus(db, req.params.type, req.params.id);
      const q = req.query;
      const includeDerived = q.includeDerived ?? true;
      const rel = q.rel || null;
      const contextId = q.context ? (await resolveCancer(db, q.context)).id : null;
      const ids = await focusIds(db, focus);
      const trialLimit = q.limit === 25 ? TRIAL_LIMIT : q.limit;

      const tasks: Array<Promise<Derived | Derived[]>> = [];
      if (includeDerived) {
        switch (focus.type) {
          case 'cancer':
            tasks.push(cancerTrialLinks(db, focus, ids, trialLimit), frequencyLinks(db, 'cancer', focus, ids, q.limit), approvalLinks(db, 'cancer', focus, ids, q.limit), cancerDrugTrialLinks(db, focus, ids, q.limit));
            break;
          case 'gene':
            tasks.push(geneVariantLinks(db, focus, q.limit), frequencyLinks(db, 'gene', focus, [], q.limit));
            break;
          case 'variant':
            tasks.push(variantEvidenceLinks(db, focus, q.limit), variantDrugCivicLinks(db, focus, q.limit));
            break;
          case 'drug':
            tasks.push(drugTrialLinks(db, focus, trialLimit), drugCancerTrialLinks(db, focus, q.limit), approvalLinks(db, 'drug', focus, [], q.limit));
            break;
          case 'trial':
            tasks.push(trialLinks(db, focus, q.limit));
            break;
        }
      }
      const [ke, ...derivedRaw] = await Promise.all([focus.type === 'trial' ? Promise.resolve([] as KeRow[]) : knowledgeEdges(db, focus, q.limit, rel, contextId), ...tasks]);
      let derived = derivedRaw.flat();
      if (rel) derived = derived.filter((d) => d.relationshipType === rel);
      if (contextId) derived = derived.map((d) => ({ ...d, links: d.links.filter((l) => l.edge.cancerContext.some((c) => c.id === contextId)) })).filter((d) => d.links.length);

      const ctxIds = new Set<string>();
      for (const r of ke) for (const c of r.context_ids ?? []) ctxIds.add(c);
      for (const d of derived) for (const l of d.links) for (const c of l.edge.cancerContext) if (!c.slug) ctxIds.add(c.id);
      const names = await cancerNames(db, ctxIds);
      const ctx = (list: string[] | null | undefined) => (list ?? []).map((id) => names.get(id) ?? { id, name: id, slug: '' }).sort((a, b) => a.name.localeCompare(b.name));

      const neighbors = new Map<string, { node: Node; edges: Edge[] }>();
      const groups: Record<string, number> = {};
      const sources = new Set<string>();
      let truncated = false;
      const push = (node: Node, edge: Edge, total: number) => {
        const k = `${node.type}:${node.id}`;
        const cur = neighbors.get(k) ?? { node, edges: [] };
        cur.edges.push(edge);
        neighbors.set(k, cur);
        groups[edge.relationshipType] = Math.max(groups[edge.relationshipType] ?? 0, total);
        for (const s of edge.sourceIds) sources.add(s);
      };
      for (const r of ke) {
        if (!r.n_ref || !r.n_label) continue;
        push(
          { type: r.n_type, id: r.n_id, ref: r.n_ref, label: r.n_label, sublabel: r.n_sublabel, href: href(r.n_type, r.n_ref) },
          {
            relationshipType: r.relationship_type,
            outgoing: r.outgoing,
            direction: r.direction,
            evidenceLevel: r.evidence_level,
            evidenceCategory: r.evidence_category,
            cancerContext: ctx(r.context_ids),
            supportCount: num(r.support),
            sourceIds: [r.source_id],
            provenanceIds: (r.provenance_ids ?? []).map(Number),
            derived: false,
            detail: (r.edge_ids?.length ?? 1) > 1 ? `${r.edge_ids.length} source records aggregated` : null,
            date: r.last_seen ? new Date(r.last_seen).toISOString().slice(0, 10) : null,
            via: r.ctx_only && r.via_type && r.via_id && r.via_ref && r.via_label ? { type: r.via_type, id: r.via_id, label: r.via_label, href: href(r.via_type, r.via_ref) } : null,
            knowledgeEdgeIds: r.edge_ids,
          } as Edge,
          num(r.total),
        );
      }
      for (const d of derived) {
        for (const l of d.links) {
          l.edge.cancerContext = l.edge.cancerContext.map((c) => (c.slug ? c : (names.get(c.id) ?? c)));
          push(l.node, l.edge, d.total);
        }
      }
      const shown: Record<string, number> = {};
      for (const nb of neighbors.values()) for (const e of nb.edges) shown[e.relationshipType] = (shown[e.relationshipType] ?? 0) + 1;
      for (const [k, tot] of Object.entries(groups)) if ((shown[k] ?? 0) < tot) truncated = true;

      const data = {
        node: focus,
        neighbors: [...neighbors.values()],
        groups,
        truncated,
        limits: { perRelationship: q.limit, trials: trialLimit, descendantsRolledUp: ids.length },
        thresholds: { cohortFrequencyMin: FREQ_MIN, cohortCasesAffectedMin: CASES_MIN },
        note: 'Edges are source-native (never inferred by CancerIndex) and keep their native evidence level; rows with derived=true are counts read from registries (ClinicalTrials.gov, GDC/cBioPortal cohorts, approval records).',
      };
      return respond(app, data, sources);
    },
  );

  app.get(
    '/graph/:type/:id/paths',
    {
      schema: {
        tags: ['graph'],
        summary: 'Strongest cancer → gene → variant → drug → approval → trials chains (cancer focus only), ranked by evidence level then support',
        params,
        querystring: z.object({ limit: z.coerce.number().int().min(1).max(50).default(8) }),
        response: ok(AnyRecord),
      },
    },
    async (req) => {
      if (req.params.type !== 'cancer') throw new BadRequest('paths are built for cancer foci only');
      const db = app.db;
      const focus = await resolveFocus(db, 'cancer', req.params.id);
      const ids = await focusIds(db, focus);
      type Row = {
        variant_id: string; variant_slug: string; variant_name: string; gene_id: string; symbol: string; drug_id: string; drug_slug: string; drug_name: string;
        evidence_level: string | null; direction: string | null; support: string; source_ids: string[]; provenance_ids: number[]; context_ids: string[];
        frequency: number | null; cases_affected: number | null; cases_profiled: number | null; cohorts: string | null;
        approval_id: number | null; jurisdiction: string | null; authority: string | null; approval_date: string | null; approval_status: string | null; approval_cancer_id: string | null; approval_cancer_name: string | null; tumor_agnostic: boolean | null; approvals: string | null;
        trials: string | null; active_trials: string | null;
      };
      const rows = await db.execute<Row>(sql`
        WITH ids AS (SELECT unnest(ARRAY[${sql.join(ids.map((i) => sql`${i}`), sql`, `)}]::varchar[]) AS id),
        ed AS (
          SELECT ke.source_entity_id AS variant_id, ke.target_entity_id AS drug_id, min(${LEVEL_RANK}) AS lvl, min(ke.evidence_level) AS evidence_level, min(ke.direction) AS direction,
                 sum(ke.support_count) AS support, array_agg(DISTINCT ke.source_id) AS source_ids,
                 (SELECT (array_agg(DISTINCT x::int ORDER BY x::int))[1:50] FROM unnest(string_to_array(string_agg(array_to_string(ke.provenance_ids, ','), ','), ',')) x WHERE x <> '') AS provenance_ids,
                 (SELECT array_agg(DISTINCT x ORDER BY x) FROM unnest(string_to_array(string_agg(array_to_string(ke.cancer_context_ids, ','), ','), ',')) x WHERE x <> '' AND x IN (SELECT id FROM ids)) AS context_ids
          FROM knowledge_edges ke
          WHERE ke.status = 'active' AND ke.relationship_type = 'PREDICTS_RESPONSE_TO' AND ke.direction = 'sensitivity' AND ke.source_entity_type = 'variant' AND ke.target_entity_type = 'drug'
            AND ke.cancer_context_ids && (SELECT array_agg(id)::text[] FROM ids)
          GROUP BY ke.source_entity_id, ke.target_entity_id
        ),
        fq AS (
          SELECT DISTINCT ON (f.gene_id) f.gene_id, f.frequency, f.cases_affected, f.cases_profiled, count(*) OVER (PARTITION BY f.gene_id) AS cohorts
          FROM cancer_gene_frequencies f WHERE f.cancer_id IN (SELECT id FROM ids) AND f.gene_id IS NOT NULL AND f.cases_affected >= ${CASES_MIN}
          ORDER BY f.gene_id, f.cases_profiled DESC, f.frequency DESC
        )
        SELECT ed.variant_id, v.slug AS variant_slug, v.name AS variant_name, g.id AS gene_id, g.symbol, ed.drug_id, d.slug AS drug_slug, d.name AS drug_name,
               ed.evidence_level, ed.direction, ed.support, ed.source_ids, ed.provenance_ids, ed.context_ids,
               fq.frequency, fq.cases_affected, fq.cases_profiled, fq.cohorts,
               ap.id AS approval_id, ap.jurisdiction, ap.authority, ap.approval_date, ap.status AS approval_status, ap.cancer_id AS approval_cancer_id, ac.canonical_name AS approval_cancer_name, ap.tumor_agnostic, ap.approvals,
               tr.trials, tr.active_trials
        FROM ed JOIN variants v ON v.id = ed.variant_id JOIN genes g ON g.id = v.gene_id JOIN drugs d ON d.id = ed.drug_id
        LEFT JOIN fq ON fq.gene_id = g.id
        LEFT JOIN LATERAL (
          SELECT a.id, a.jurisdiction, a.authority, a.approval_date, a.status, a.cancer_id, a.tumor_agnostic, count(*) OVER() AS approvals
          FROM drug_approvals a WHERE a.drug_id = ed.drug_id AND (a.cancer_id IN (SELECT id FROM ids) OR a.tumor_agnostic)
          ORDER BY (a.cancer_id IS NOT NULL) DESC, a.approval_date ASC NULLS LAST, a.id LIMIT 1
        ) ap ON true
        LEFT JOIN cancers ac ON ac.id = ap.cancer_id
        LEFT JOIN LATERAL (
          SELECT count(DISTINCT ti.trial_id) AS trials, count(DISTINCT ti.trial_id) FILTER (WHERE t.overall_status IN ${activeList()}) AS active_trials
          FROM trial_interventions ti JOIN trial_conditions tc ON tc.trial_id = ti.trial_id AND tc.cancer_id IN (SELECT id FROM ids) JOIN clinical_trials t ON t.id = ti.trial_id
          WHERE ti.drug_id = ed.drug_id
        ) tr ON true
        ORDER BY ed.lvl, ed.support DESC, fq.frequency DESC NULLS LAST, g.symbol, v.name, d.name
        LIMIT ${req.query.limit}`);
      const names = await cancerNames(db, rows.flatMap((r) => r.context_ids ?? []));
      const sources = new Set<string>(['clinicaltrials', 'openfda']);
      const chains = rows.map((r) => {
        for (const s of r.source_ids ?? []) sources.add(s);
        return {
          cancer: { id: focus.id, slug: focus.ref, name: focus.label },
          gene: { id: r.gene_id, symbol: r.symbol, frequency: r.frequency, casesAffected: r.cases_affected, casesProfiled: r.cases_profiled, cohorts: num(r.cohorts), claim: 'observed_data' },
          variant: { id: r.variant_id, slug: r.variant_slug, name: r.variant_name },
          drug: { id: r.drug_id, slug: r.drug_slug, name: r.drug_name },
          edge: { relationshipType: 'PREDICTS_RESPONSE_TO', evidenceLevel: r.evidence_level, direction: r.direction, supportCount: num(r.support), sourceIds: r.source_ids ?? [], provenanceIds: (r.provenance_ids ?? []).map(Number), cancerContext: (r.context_ids ?? []).map((id) => names.get(id) ?? { id, name: id, slug: '' }), claim: 'curated_evidence' },
          approval: r.approval_id ? { id: Number(r.approval_id), jurisdiction: r.jurisdiction, authority: r.authority, approvalDate: r.approval_date, status: r.approval_status, cancerId: r.approval_cancer_id, cancerName: r.approval_cancer_name, tumorAgnostic: !!r.tumor_agnostic, total: num(r.approvals), claim: 'regulatory_status' } : null,
          trials: r.trials !== null && r.trials !== undefined ? { total: num(r.trials), active: num(r.active_trials), claim: 'observed_data' } : null,
        };
      });
      return respond(app, { node: focus, chains, descendantsRolledUp: ids.length, ranking: 'evidence level (native CIViC A–E), then support count, then cohort frequency', note: 'Each hop keeps its own claim category; a missing hop is null, never filled in. Not treatment guidance.' }, sources);
    },
  );
};