/** Site constants, routes per entity type, labels and colours shared by pages and components. */

export const SITE_NAME = 'AI Atlas';
export const SITE_URL = (process.env.NEXT_PUBLIC_SITE_URL ?? 'https://www.ai-atlas.co').replace(/\/$/, '');
export const TAGLINE = 'The temporal knowledge graph of the AI ecosystem';
export const DESCRIPTION =
  'AI Atlas is a continuously reconstructed, source-attributed, historical map of the global AI ecosystem: models, organizations, research, providers and pricing, benchmarks, hardware, frameworks, datasets and tools — every number answers who said it, when, where, and how it was extracted.';
export const CONTACT_EMAIL = 'contact@spboucher.ai';
export const AUTHOR_NAME = 'Simon-Pierre Boucher';
/** Theme tokens mirrored from globals.css (`--canvas`) for the manifest and `<meta theme-color>` — they cannot read CSS variables. */
export const THEME_LIGHT = '#f6f6f3';
export const THEME_DARK = '#0b0d11';
export const HOST_NAME = 'MacLustr';
export const HOST_URL = 'https://www.maclustr.io';
export const PUBLIC_API_BASE = 'https://www.ai-atlas.co/api/v1';
export const BOT_UA = 'AIAtlasBot';

/** Entity type → URL path segment (plural). Types not listed fall back to /explore/<type>/<slug> → generic entity page. */
export const TYPE_PATH: Record<string, string> = {
  model: 'models',
  company: 'companies',
  organization: 'companies',
  lab: 'companies',
  university: 'companies',
  paper: 'papers',
  provider: 'providers',
  benchmark: 'benchmarks',
  hardware: 'hardware',
  framework: 'frameworks',
  library: 'frameworks',
  runtime: 'frameworks',
  dataset: 'datasets',
  tool: 'tools',
  agent: 'tools',
  mcp_server: 'tools',
  product: 'tools',
  repository: 'repositories',
  model_family: 'families',
  artifact: 'artifacts',
  license: 'licenses',
};
/** URL path segment → API mount + canonical entity types accepted there. */
export const PATH_TYPES: Record<string, { label: string; singular: string; types: string[]; api: string }> = {
  models: { label: 'Models', singular: 'Model', types: ['model', 'quantization'], api: 'models' },
  companies: { label: 'Companies', singular: 'Company', types: ['company', 'organization', 'lab', 'university'], api: 'companies' },
  papers: { label: 'Research', singular: 'Paper', types: ['paper'], api: 'papers' },
  providers: { label: 'Providers', singular: 'Provider', types: ['provider'], api: 'providers' },
  benchmarks: { label: 'Benchmarks', singular: 'Benchmark', types: ['benchmark'], api: 'benchmarks' },
  hardware: { label: 'Hardware', singular: 'Hardware', types: ['hardware'], api: 'hardware' },
  frameworks: { label: 'Frameworks', singular: 'Framework', types: ['framework', 'library', 'runtime'], api: 'frameworks' },
  datasets: { label: 'Datasets', singular: 'Dataset', types: ['dataset'], api: 'datasets' },
  tools: { label: 'Tools', singular: 'Tool', types: ['tool', 'agent', 'mcp_server', 'product'], api: 'tools' },
  repositories: { label: 'Repositories', singular: 'Repository', types: ['repository'], api: 'entities' },
  families: { label: 'Families', singular: 'Family', types: ['model_family'], api: 'families' },
  artifacts: { label: 'Artifacts', singular: 'Artifact', types: ['artifact'], api: 'models' },
  licenses: { label: 'Licenses', singular: 'License', types: ['license'], api: 'entities' },
};

export const TYPE_LABELS: Record<string, string> = {
  model: 'Model',
  company: 'Company',
  organization: 'Organization',
  lab: 'Lab',
  university: 'University',
  researcher: 'Researcher',
  paper: 'Paper',
  dataset: 'Dataset',
  benchmark: 'Benchmark',
  provider: 'Provider',
  framework: 'Framework',
  library: 'Library',
  runtime: 'Runtime',
  repository: 'Repository',
  tool: 'Tool',
  agent: 'Agent',
  mcp_server: 'MCP server',
  product: 'Product',
  hardware: 'Hardware',
  quantization: 'Quantization',
  license: 'License',
  regulation: 'Regulation',
  incident: 'Incident',
  release: 'Release',
  conference: 'Conference',
  country: 'Country',
  robot: 'Robot',
  data_center: 'Data center',
  standard: 'Standard',
  funding_round: 'Funding round',
  acquisition: 'Acquisition',
  course: 'Course',
  job: 'Job',
  model_family: 'Family',
  artifact: 'Artifact',
};
export const TYPE_LABELS_PLURAL: Record<string, string> = {
  model: 'Models',
  company: 'Companies',
  organization: 'Organizations',
  lab: 'Labs',
  university: 'Universities',
  researcher: 'Researchers',
  paper: 'Papers',
  dataset: 'Datasets',
  benchmark: 'Benchmarks',
  provider: 'Providers',
  framework: 'Frameworks',
  library: 'Libraries',
  runtime: 'Runtimes',
  repository: 'Repositories',
  tool: 'Tools',
  agent: 'Agents',
  mcp_server: 'MCP servers',
  product: 'Products',
  hardware: 'Hardware',
  quantization: 'Quantizations',
  license: 'Licenses',
  regulation: 'Regulations',
  incident: 'Incidents',
  release: 'Releases',
  conference: 'Conferences',
  country: 'Countries',
  robot: 'Robots',
  data_center: 'Data centers',
  standard: 'Standards',
  funding_round: 'Funding rounds',
  acquisition: 'Acquisitions',
  course: 'Courses',
  job: 'Jobs',
  model_family: 'Families',
  artifact: 'Artifacts',
};
export function typeLabel(t: string, pluralForm = false): string {
  return (pluralForm ? TYPE_LABELS_PLURAL[t] : TYPE_LABELS[t]) ?? t.replace(/_/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
}

/** Badge colour family per entity type (CSS variables `--type-<key>` in globals.css). */
export const TYPE_COLOR_KEY: Record<string, string> = {
  model: 'model',
  quantization: 'model',
  model_family: 'model',
  artifact: 'model',
  license: 'tool',
  company: 'company',
  organization: 'company',
  lab: 'company',
  university: 'company',
  researcher: 'company',
  paper: 'paper',
  provider: 'provider',
  benchmark: 'benchmark',
  hardware: 'hardware',
  robot: 'hardware',
  data_center: 'hardware',
  framework: 'framework',
  library: 'framework',
  runtime: 'framework',
  repository: 'framework',
  dataset: 'dataset',
  tool: 'tool',
  agent: 'tool',
  mcp_server: 'tool',
  product: 'tool',
};

export const routes = {
  home: () => '/',
  search: (q: string, type?: string) => `/search?q=${encodeURIComponent(q)}${type ? `&type=${encodeURIComponent(type)}` : ''}`,
  models: () => '/models',
  companies: () => '/companies',
  papers: () => '/papers',
  providers: () => '/providers',
  benchmarks: () => '/benchmarks',
  hardware: () => '/hardware',
  frameworks: () => '/frameworks',
  datasets: () => '/datasets',
  tools: () => '/tools',
  changes: () => '/changes',
  changesDay: (date: string) => `/changes/${date}`,
  timeline: (q?: { entity?: string; year?: string; category?: string }) => {
    const p = new URLSearchParams();
    if (q?.entity) p.set('entity', q.entity);
    if (q?.year) p.set('year', q.year);
    if (q?.category) p.set('category', q.category);
    const s = p.toString();
    return s ? `/timeline?${s}` : '/timeline';
  },
  compare: (ids?: string[]) => (ids?.length ? `/compare?ids=${ids.map(encodeURIComponent).join(',')}` : '/compare'),
  prices: () => '/prices',
  hardwareFit: (q?: { memory_gb?: number | string; quant?: string; context?: number | string }) => {
    const p = new URLSearchParams();
    if (q?.memory_gb !== undefined && q.memory_gb !== '') p.set('memory_gb', String(q.memory_gb));
    if (q?.quant) p.set('quant', q.quant);
    if (q?.context !== undefined && q.context !== '') p.set('context', String(q.context));
    const s = p.toString();
    return s ? `/hardware/fit?${s}` : '/hardware/fit';
  },
  benchmark: (slug: string, q?: { config?: string; model?: string }) => {
    const p = new URLSearchParams();
    if (q?.config) p.set('config', q.config);
    if (q?.model) p.set('model', q.model);
    const s = p.toString();
    return `/benchmarks/${encodeURIComponent(slug)}${s ? `?${s}` : ''}`;
  },
  diff: (q?: { a?: string; b?: string; scope?: string }) => {
    const p = new URLSearchParams();
    if (q?.a) p.set('a', q.a);
    if (q?.b) p.set('b', q.b);
    if (q?.scope && q.scope !== 'all') p.set('scope', q.scope);
    const s = p.toString();
    return s ? `/diff?${s}` : '/diff';
  },
  graph: (slug?: string, depth?: 1 | 2) => (slug ? `/graph/${encodeURIComponent(slug)}${depth === 2 ? '?depth=2' : ''}` : '/graph'),
  /** Entity page "as of" view (History tab). */
  entityAsOf: (e: { entity_type: string; slug: string }, date: string) => `${routes.entity(e)}?tab=history&asof=${encodeURIComponent(date)}`,
  /** Entity page History tab, optionally filtered to one property (deep link from the evidence drawer). */
  entityHistory: (e: { entity_type: string; slug: string }, property?: string) => `${routes.entity(e)}?tab=history${property ? `&property=${encodeURIComponent(property)}` : ''}`,
  // ---- 1.1 routes (pages built by the D1–D3 streams; the shell links to them from here)
  frontier: () => '/frontier',
  pulse: () => '/pulse',
  open: () => '/open',
  families: () => '/families',
  family: (slug: string) => `/families/${encodeURIComponent(slug)}`,
  timeMachine: (date?: string) => (date ? `/time-machine?date=${encodeURIComponent(date)}` : '/time-machine'),
  calculator: () => '/calculator',
  runLocally: () => '/run-locally',
  findAModel: () => '/find-a-model',
  artifact: (slug: string) => `/artifacts/${encodeURIComponent(slug)}`,
  agents: () => '/agents',
  licenses: () => '/licenses',
  claim: (id: string) => `/claims/${encodeURIComponent(id)}`,
  watchlist: () => '/watchlist',
  benchmarkMatrix: () => '/benchmarks?view=matrix',
  admin: (section?: string) => (section ? `/admin/${section}` : '/admin'),
  explore: () => '/explore',
  exploreType: (t: string) => `/explore/${encodeURIComponent(t)}`,
  methodology: () => '/methodology',
  sources: () => '/sources',
  about: () => '/about',
  developers: () => '/developers',
  bot: () => '/bot',
  listing: (type: string) => {
    const p = TYPE_PATH[type];
    return p ? `/${p}` : `/explore/${encodeURIComponent(type)}`;
  },
  /** Canonical URL of any entity: /models/<slug>, /companies/<slug>, … or /explore/<type>/<slug>. */
  entity: (e: { entity_type: string; slug: string }) => {
    const p = TYPE_PATH[e.entity_type];
    return p ? `/${p}/${encodeURIComponent(e.slug)}` : `/explore/${encodeURIComponent(e.entity_type)}/${encodeURIComponent(e.slug)}`;
  },
};

export const exploreNav = [
  { href: '/models', label: 'Models', type: 'model' },
  { href: '/companies', label: 'Companies', type: 'company' },
  { href: '/papers', label: 'Research', type: 'paper' },
  { href: '/providers', label: 'Providers & Pricing', type: 'provider' },
  { href: '/benchmarks', label: 'Benchmarks', type: 'benchmark' },
  { href: '/hardware', label: 'Hardware', type: 'hardware' },
  { href: '/frameworks', label: 'Frameworks', type: 'framework' },
  { href: '/datasets', label: 'Datasets', type: 'dataset' },
  { href: '/tools', label: 'Tools', type: 'tool' },
];
/** Desktop header: `AI Atlas | Models · Frontier · Benchmarks · Prices · Research · Graph · Changes · More ▾`. */
export const primaryNav = [
  { href: '/models', label: 'Models' },
  { href: '/frontier', label: 'Frontier' },
  { href: '/benchmarks', label: 'Benchmarks' },
  { href: '/prices', label: 'Prices' },
  { href: '/papers', label: 'Research' },
  { href: '/graph', label: 'Graph' },
  { href: '/changes', label: 'Changes' },
];
export type NavItem = { href: string; label: string; hint?: string; type?: string };
export type NavGroup = { label: string; items: NavItem[] };
/** "More ▾" panel (desktop) and the mobile "More" sheet: the full site, grouped. */
export const moreGroups: NavGroup[] = [
  {
    label: 'Explore',
    items: [
      { href: '/companies', label: 'Organizations', type: 'company' },
      { href: '/providers', label: 'Providers', type: 'provider' },
      { href: '/hardware', label: 'Hardware', type: 'hardware' },
      { href: '/datasets', label: 'Datasets', type: 'dataset' },
      { href: '/frameworks', label: 'Frameworks', type: 'framework' },
      { href: '/agents', label: 'Agents & Tools', type: 'tool' },
      { href: '/open', label: 'Open Models', type: 'model' },
      { href: '/families', label: 'Families', type: 'model' },
    ],
  },
  {
    label: 'Intelligence',
    items: [
      { href: '/compare', label: 'Compare' },
      { href: '/calculator', label: 'Calculator', hint: 'Cost of a workload across providers' },
      { href: '/run-locally', label: 'Run locally', hint: 'Which models fit your hardware' },
      { href: '/find-a-model', label: 'Find a model' },
      { href: '/pulse', label: 'Pulse' },
      { href: '/watchlist', label: 'Watchlist' },
    ],
  },
  {
    label: 'Temporal',
    items: [
      { href: '/timeline', label: 'Timeline' },
      { href: '/time-machine', label: 'Time Machine', hint: 'The atlas as of any date' },
      { href: '/diff', label: 'Diff', hint: 'What changed between two dates' },
    ],
  },
  {
    label: 'About',
    items: [
      { href: '/sources', label: 'Sources' },
      { href: '/methodology', label: 'Methodology' },
      { href: '/developers', label: 'API' },
      { href: '/about', label: 'About' },
    ],
  },
];
/** Flat "More" list in the order required by the spec (desktop panel columns are built from `moreGroups`). */
export const moreNav: NavItem[] = moreGroups.flatMap((g) => g.items);
/** Mobile bottom tab bar: Home · Models · Changes · Search · More. */
export const mobileTabs = [
  { href: '/', label: 'Home' },
  { href: '/models', label: 'Models' },
  { href: '/changes', label: 'Changes' },
];
/** Footer columns. */
export const footerGroups: NavGroup[] = [
  { label: 'Explore', items: [...exploreNav.map((n) => ({ href: n.href, label: n.label })), { href: '/open', label: 'Open models' }, { href: '/families', label: 'Families' }] },
  { label: 'Intelligence', items: [{ href: '/frontier', label: 'Frontier' }, { href: '/compare', label: 'Compare' }, { href: '/prices', label: 'Prices' }, { href: '/calculator', label: 'Calculator' }, { href: '/run-locally', label: 'Run locally' }, { href: '/find-a-model', label: 'Find a model' }, { href: '/graph', label: 'Knowledge graph' }, { href: '/pulse', label: 'Pulse' }] },
  { label: 'Temporal', items: [{ href: '/changes', label: 'Changes' }, { href: '/timeline', label: 'Timeline' }, { href: '/time-machine', label: 'Time machine' }, { href: '/diff', label: 'Diff two dates' }, { href: '/watchlist', label: 'Watchlist' }] },
  { label: 'About', items: [{ href: '/about', label: 'About' }, { href: '/methodology', label: 'Methodology' }, { href: '/sources', label: 'Sources' }, { href: '/developers', label: 'API / Developers' }, { href: '/bot', label: 'AIAtlasBot' }] },
];
/** "Signature products" strip on the homepage. */
export const signatureProducts: NavItem[] = [
  { href: '/frontier', label: 'Frontier', hint: 'Who leads, on what, since when' },
  { href: '/graph', label: 'Knowledge graph', hint: 'Every entity, every relation' },
  { href: '/graph', label: 'Lineage', hint: 'Base → fine-tune → quantization' },
  { href: '/time-machine', label: 'Time machine', hint: 'The atlas as of any date' },
  { href: '/diff', label: 'Diff the AI world', hint: 'Two dates, every change' },
  { href: '/prices', label: 'Price intelligence', hint: 'USD per 1M tokens, over time' },
  { href: '/calculator', label: 'Cost vs performance', hint: 'Pareto view of models' },
  { href: '/benchmarks?view=matrix', label: 'Benchmark matrix', hint: 'Models × benchmarks' },
  { href: '/open', label: 'Open model frontier', hint: 'Best open weights, tracked' },
  { href: '/run-locally', label: 'Local model finder', hint: 'What fits your machine' },
  { href: '/methodology', label: 'Field-level provenance', hint: 'Who said it, when, where' },
  { href: '/changes', label: 'Change history', hint: 'Nothing is overwritten' },
];
/** Type prefixes understood by the command palette (`m:claude`). */
export const PALETTE_PREFIXES: Record<string, { types: string[]; label: string }> = {
  m: { types: ['model', 'quantization', 'artifact'], label: 'Models' },
  b: { types: ['benchmark'], label: 'Benchmarks' },
  o: { types: ['company', 'organization', 'lab', 'university'], label: 'Organizations' },
  p: { types: ['provider'], label: 'Providers' },
  h: { types: ['hardware'], label: 'Hardware' },
};

/** Change-event vocabulary (sdk/facts.py MATERIAL_PROPERTIES + writer): label, colour family. */
export const EVENT_TYPE_LABELS: Record<string, string> = {
  NEW_MODEL: 'New model',
  NEW_COMPANY: 'New company',
  NEW_PROVIDER: 'New provider',
  NEW_PAPER: 'New paper',
  NEW_DATASET: 'New dataset',
  NEW_BENCHMARK: 'New benchmark',
  NEW_FRAMEWORK: 'New framework',
  NEW_HARDWARE: 'New hardware',
  NEW_TOOL: 'New tool',
  NEW_REPOSITORY: 'New repository',
  NEW_ORGANIZATION: 'New organization',
  NEW_ENTITY: 'New entity',
  MODEL_UPDATED: 'Model updated',
  PRICE_CHANGED: 'Price changed',
  PROVIDER_LISTED: 'Listed by provider',
  CONTEXT_CHANGED: 'Context window changed',
  MAX_OUTPUT_CHANGED: 'Max output changed',
  STATUS_CHANGED: 'Status changed',
  LICENSE_CHANGED: 'License changed',
  OPENNESS_CHANGED: 'Openness changed',
  PARAMETERS_CHANGED: 'Parameters changed',
  RELEASE_DATE_CHANGED: 'Release date changed',
  KNOWLEDGE_CUTOFF_CHANGED: 'Knowledge cutoff changed',
  CAPABILITIES_CHANGED: 'Capabilities changed',
  RATE_LIMIT_CHANGED: 'Rate limit changed',
  SPEC_CHANGED: 'Spec changed',
  DEPRECATION_ANNOUNCED: 'Deprecation announced',
  RETIREMENT_ANNOUNCED: 'Retirement announced',
  BENCHMARK_RESULT: 'Benchmark result',
  BENCHMARK_UPDATED: 'Benchmark updated',
  ANNOUNCEMENT: 'Announcement',
  RELEASE: 'Release',
  VERSION_RELEASED: 'Version released',
  PROPERTY_CHANGED: 'Property changed',
  DOCUMENT_CHANGED: 'Document changed',
};
export function eventLabel(t: string): string {
  return EVENT_TYPE_LABELS[t] ?? t.toLowerCase().replace(/_/g, ' ').replace(/^\w/, (c) => c.toUpperCase());
}
/** Colour family for an event type: accent-2 (amber) for money, positive for new, warning/danger for deprecations. */
export function eventTone(t: string): 'new' | 'price' | 'warn' | 'danger' | 'bench' | 'neutral' {
  if (t.startsWith('NEW_') || t === 'RELEASE' || t === 'VERSION_RELEASED') return 'new';
  if (t === 'PRICE_CHANGED' || t === 'PROVIDER_LISTED') return 'price';
  if (t === 'DEPRECATION_ANNOUNCED') return 'warn';
  if (t === 'RETIREMENT_ANNOUNCED') return 'danger';
  if (t.startsWith('BENCHMARK')) return 'bench';
  return 'neutral';
}

export const CATEGORY_LABELS: Record<string, string> = {
  model: 'Models',
  company: 'Companies',
  paper: 'Research',
  dataset: 'Datasets',
  benchmark: 'Benchmarks',
  provider: 'Providers & pricing',
  price: 'Pricing',
  framework: 'Frameworks',
  repository: 'Repositories',
  tool: 'Tools',
  hardware: 'Hardware',
  regulation: 'Regulation',
  incident: 'Incidents',
  release: 'Releases',
  document: 'Documents',
  announcement: 'Announcements',
};
export function categoryLabel(c: string): string {
  return CATEGORY_LABELS[c] ?? c.replace(/_/g, ' ').replace(/^\w/, (x) => x.toUpperCase());
}

export const IMPORTANCE_LABELS: Record<number, string> = { 0: 'Minor', 1: 'Notable', 2: 'Important', 3: 'Major' };

/** Human labels for attribute keys (docs/CONNECTORS.md property vocabulary). */
export const PROPERTY_LABELS: Record<string, string> = {
  family: 'Family',
  version: 'Version',
  release_date: 'Release date',
  status: 'Status',
  openness: 'Openness',
  license: 'License',
  architecture: 'Architecture',
  parameter_count: 'Parameters',
  active_parameter_count: 'Active parameters',
  is_moe: 'Mixture of experts',
  modalities: 'Modalities',
  modalities_input: 'Input modalities',
  modalities_output: 'Output modalities',
  context_length: 'Context window',
  max_output_tokens: 'Max output',
  knowledge_cutoff: 'Knowledge cutoff',
  training_data_cutoff: 'Training data cutoff',
  languages: 'Languages',
  tool_calling: 'Tool calling',
  structured_output: 'Structured output',
  reasoning: 'Reasoning',
  vision: 'Vision',
  audio: 'Audio',
  fine_tuning_available: 'Fine-tuning available',
  tokenizer: 'Tokenizer',
  api_model_id: 'API model id',
  api_alias: 'API alias',
  official_url: 'Official page',
  model_card_url: 'Model card',
  paper_url: 'Paper',
  repository_url: 'Repository',
  hf_repo: 'Hugging Face repo',
  pipeline_tag: 'Pipeline tag',
  base_model: 'Base model',
  quantization: 'Quantization',
  quant_format: 'Quantization format',
  file_size_gb: 'File size',
  deprecation_date: 'Deprecation date',
  retirement_date: 'Retirement date',
  retirement_tentative: 'Retirement tentative',
  'metric.downloads': 'Downloads',
  'metric.likes': 'Likes',
  'metric.stars': 'Stars',
  'metric.forks': 'Forks',
  country: 'Country',
  headquarters: 'Headquarters',
  founded: 'Founded',
  website: 'Website',
  domains: 'Domains',
  hf_org: 'Hugging Face org',
  github_org: 'GitHub org',
  org_kind: 'Kind',
  legal_name: 'Legal name',
  founders: 'Founders',
  leadership: 'Leadership',
  employee_count: 'Employees',
  pricing_url: 'Pricing page',
  docs_url: 'Documentation',
  regions: 'Regions',
  features: 'Features',
  authors: 'Authors',
  published_at: 'Published',
  updated_at: 'Updated',
  abstract: 'Abstract',
  arxiv_id: 'arXiv id',
  doi: 'DOI',
  categories: 'Categories',
  primary_category: 'Primary category',
  pdf_url: 'PDF',
  code_url: 'Code',
  venue: 'Venue',
  category: 'Category',
  task: 'Task',
  metric: 'Metric',
  unit: 'Unit',
  creator: 'Creator',
  paper: 'Paper',
  known_limitations: 'Known limitations',
  methodology: 'Methodology',
  kind: 'Kind',
  memory_gb: 'Memory',
  memory_type: 'Memory type',
  memory_bandwidth_gbs: 'Memory bandwidth',
  tdp_watts: 'TDP',
  runtimes: 'Runtimes',
  manufacturer: 'Manufacturer',
  spec_url: 'Spec sheet',
  price_usd: 'Price (USD)',
  compute_fp16_tflops: 'FP16 compute',
  latest_version: 'Latest version',
  latest_release_at: 'Latest release',
  language: 'Language',
  topics: 'Topics',
  pypi: 'PyPI',
  modality: 'Modality',
  size: 'Size',
  publisher: 'Publisher',
  description: 'Description',
};
export function propertyLabel(k: string): string {
  return PROPERTY_LABELS[k] ?? k.replace(/^metric\./, '').replace(/_/g, ' ').replace(/^\w/, (c) => c.toUpperCase());
}
/** Attribute keys that are URLs (rendered as links). */
export const URL_KEYS = new Set(['official_url', 'model_card_url', 'paper_url', 'repository_url', 'website', 'pricing_url', 'docs_url', 'pdf_url', 'code_url', 'spec_url']);
/** Soft / long text properties rendered as prose, not in the spec table. */
export const PROSE_KEYS = new Set(['description', 'abstract', 'summary', 'tagline', 'availability_note', 'notes', 'training_data_notes', 'safety_notes', 'hardware_requirements', 'known_limitations', 'methodology']);

export const PREDICATE_LABELS: Record<string, { out: string; in: string }> = {
  develops: { out: 'Develops', in: 'Developed by' },
  owns: { out: 'Owns', in: 'Owned by' },
  operates: { out: 'Operates', in: 'Operated by' },
  available_through: { out: 'Available through', in: 'Serves' },
  evaluated_on: { out: 'Evaluated on', in: 'Evaluated models' },
  described_by: { out: 'Described by', in: 'Describes' },
  derived_from: { out: 'Derived from', in: 'Derivatives' },
  fine_tuned_from: { out: 'Fine-tuned from', in: 'Fine-tunes' },
  quantized_from: { out: 'Quantized from', in: 'Quantizations' },
  distilled_from: { out: 'Distilled from', in: 'Distillations' },
  merged_from: { out: 'Merged from', in: 'Merged into' },
  superseded_by: { out: 'Superseded by', in: 'Supersedes' },
  runs_on: { out: 'Runs on', in: 'Runs' },
  uses: { out: 'Uses', in: 'Used by' },
  manufactures: { out: 'Manufactures', in: 'Manufactured by' },
  funded_by: { out: 'Funded by', in: 'Funds' },
  acquired: { out: 'Acquired', in: 'Acquired by' },
  authored: { out: 'Authored', in: 'Authors' },
  works_at: { out: 'Works at', in: 'People' },
  uses_dataset: { out: 'Trained on', in: 'Used to train' },
  evaluates_on: { out: 'Evaluates on', in: 'Evaluated by' },
  integrates: { out: 'Integrates', in: 'Integrated by' },
  published_by: { out: 'Published by', in: 'Publications' },
};
export function predicateLabel(p: string, direction: 'out' | 'in'): string {
  return PREDICATE_LABELS[p]?.[direction] ?? p.replace(/_/g, ' ').replace(/^\w/, (c) => c.toUpperCase());
}

export const OPENNESS_LABELS: Record<string, string> = { 'open-weights': 'Open weights', 'open-source': 'Open source', proprietary: 'Proprietary', restricted: 'Restricted' };
export const STATUS_LABELS: Record<string, string> = {
  active: 'Active',
  preview: 'Preview',
  deprecated: 'Deprecated',
  retired: 'Retired',
  announced: 'Announced',
  'limited-availability': 'Limited availability',
  unknown: 'Unknown',
};
export const TIER_LABELS: Record<number, string> = { 1: 'Official', 2: 'Quality secondary', 3: 'Community', 4: 'Unverified' };

export const EXAMPLE_QUERIES = [
  'open models with more than 100B parameters',
  'cheapest model with 1M context',
  'models released in 2026',
  'Anthropic',
  'GPQA leaderboard',
  'MoE models with 128k context',
];