Foundation: monorepo, schema, provenance SDK, ontology resolver, ranking engine, OncoTree connector

Simon-Pierre Boucher committed 2 mo ago (Sep 8, 2026) Browse files

74 changed files +13,851 −0

added .env.example +34 −0

++# CancerIndex — environment (never commit real values)
++NODE_ENV=development
++DATABASE_URL=postgres://localhost:5432/cancerindex
++DB_POOL_MAX=10
++
++WEB_PORT=8250
++API_PORT=8251
++API_HOST=127.0.0.1
++CI_API_URL=http://127.0.0.1:8251
++NEXT_PUBLIC_SITE_URL=http://localhost:8250
++NEXT_TELEMETRY_DISABLED=1
++
++# Data lake (raw connector payloads, gzip JSON) — outside git
++CI_DATA_DIR=./data
++
++# Admin console (/admin) bearer token
++ADMIN_TOKEN=change-me
++
++# NCBI E-utilities (PubMed, ClinVar) — tool/email are mandatory, api key raises the limit to 10 req/s
++NCBI_TOOL=cancerindex
++NCBI_EMAIL=
++NCBI_API_KEY=
++
++# SEER API (free key from https://api.seer.cancer.gov/) — connector stays "awaiting_credentials" without it
++SEER_API_KEY=
++
++# Optional AI provider for /ask (Phase 5) — the database works without it
++ANTHROPIC_API_KEY=
++OPENAI_API_KEY=
++OPENAI_BASE_URL=
++
++WORKER_CONCURRENCY=4
++CI_MAX_RUN_MINUTES=45
++LOG_LEVEL=info

added .gitignore +15 −0

++node_modules/
++.next/
++dist/
++*.tsbuildinfo
++.env
++.env.*
++!.env.example
++data/raw/
++data/cache/
++data/tmp/
++logs/
++tmp/
++coverage/
++.DS_Store
++.claude/

added .npmrc +2 −0

		`@@ -0,0 +1,2 @@`
1	+auto-install-peers=true
2	+strict-peer-dependencies=false

added CLAUDE.md +82 −0

++# CLAUDE.md — CancerIndex.io (repository guide)
++
++The full product specification (364 sections) lives in `docs/SPEC-original.md`. This file is the
++condensed, operational version every contributor (human or agent) must follow.
++
++## Mission
++Build **the global index of cancer**: a provenance-first, continuously updated, transparently
++sourced oncology ontology connecting epidemiology, genomics, biomarkers, therapies, trials,
++regulatory evidence and literature — for every recognized malignant disease entity, not a list of
++30 common cancers. Not a physician, not a diagnostic tool, no treatment recommendations.
++
++## Non-negotiables (from the spec)
++1. **Provenance first** — no scientific number without a `provenance` row; derived values carry a
++   `formula_version` and their inputs (§2, §250-253). Raw payloads go to the data lake (§26).
++2. **Layers stay separable**: RAW → NORMALIZED → CANONICAL → DERIVED → RANKED → AI (§2).
++3. **Never fake data**: no mock/hardcoded statistics in UI; show "Data not yet available" (§281-283).
++4. **Identifiers are first-class**: keep every upstream ID in `*_codes` / dedicated columns (§347);
++   public IDs are `CI-<NS>-00000001` minted via `mintId` (§6), never DB integers.
++5. **Reconciliation before ingestion**: IDs → curated aliases → normalized strings; LLM only as a
++   *candidate* generator; unknown labels go to `unresolved_labels`, never dropped (§69, §222, §340).
++6. **Time-aware observations**: never overwrite year X with year Y; store both (§71).
++7. **Context on every edge**: cancer context, direction, evidence level, provenance (§29, §244).
++8. **Licensing gate**: no connector goes live before manifest `licenseStatus` is reviewed; IARC/
++   GLOBOCAN stays `review`, SEER `awaiting_credentials` until keys/terms are settled (§10.4, §142).
++9. **Verify docs before coding a connector** — official docs, smoke test with curl, fixture, tests,
++   prove on 10/100/1000 records before a full sync (§224-227). Record `documentationVerifiedAt`.
++10. **Rate limits, idempotency, restartability, anomaly guard** (never mass-delete on a shrunken
++    response) (§90-92, §171, §229).
++11. **Rankings need scope + year + source + formula version + "Why this rank?"** (§33, §183).
++    Composite scores are Phase 2+ (§353).
++12. **Scientific safety labels**: observed / published / curated / regulatory / guideline /
++    computed / AI-generated — never merged (§3). Population survival ≠ individual prognosis (§325).
++
++## Repository layout
++```
++apps/web        Next.js 16 (webpack build, --webpack), Tailwind v4, server components, /api/v1 proxied to apps/api
++apps/api        Fastify /v1 public API (JSON envelope { data, sources, dataRelease })
++workers/        pg-boss scheduler: connector schedules, counters, rankings
++packages/shared     ids, provenance types, normalization, logger
++packages/database   Drizzle schema (snake_case casing), migrations, seed (metrics + geographies only)
++packages/ontology   qualifier rules, CancerResolver (alias/code reconciliation), TOP_LEVEL_CANCERS
++packages/connectors SDK (manifest, HttpClient, RawLake, RunContext, validators) + connectors/<id>/{manifest.ts,index.ts,fixtures/,*.test.ts}
++packages/ranking    counters (entity_counters), ranking engine (snapshots + lineage), trace
++scripts/ci.ts       operator CLI: `pnpm cix connectors|run <id>|run-all|health|sources:sync|counters|rank|stats|trace`
++docs/               architecture, data model, methodology, source policy, ADRs, connector docs
++data/raw            data lake (gitignored) — {source}/{date}/{entity}/{runId}-{part}.jsonl.gz
++```
++
++## Conventions
++- TypeScript strict, ESM, NodeNext imports with `.js` suffix inside packages; web app uses
++  `moduleResolution: bundler` + webpack `extensionAlias` (never import `@cancerindex/connectors` in web).
++- Database: `getDb()` singleton; Drizzle `casing: 'snake_case'`; raw SQL via `sql` template for
++  aggregates. Schema changes = new migration via `pnpm db:generate` (one per integration), never
++  manual prod mutation. Agents developing in parallel use `drizzle-kit push` on their own DB and do
++  **not** commit migration files; the integrator generates the migration.
++- Connector = `class extends Connector` with `manifest`, `healthCheck(ctx)`, `sync(ctx)`; register
++  in `packages/connectors/src/registry.ts`. Use `ctx.http` (rate-limited), `ctx.upsertSourceRecord`
++  (idempotent + raw lake), `ctx.addProvenance`, `ctx.recordUnresolved`, `ctx.cursor` (restart),
++  `ctx.shouldStop()` between pages (time budget), validators from `sdk/validate.ts`.
++- Reconciliation: `new CancerResolver(db)` → `warm()` → `byCode()/byLabel()/resolve()`; store
++  `match_type` on every mapping; enqueue misses with `ctx.recordUnresolved`.
++- Tests: vitest; connector tests run against **fixtures** (sanitized JSON in `fixtures/`), never
++  live APIs; cover normal / empty / pagination / rate-limit / server error / malformed record.
++- UI: scientific-editorial aesthetic (off-white, charcoal, muted neutrals, dense tables, no
++  gradients/cards-everywhere), WCAG-minded, mobile first-class. Every number shows source badge,
++  unit, population, period and a freshness line. Empty state = "Data not yet available".
++- Language: English UI; code comments English; commit messages English.
++
++## Running locally
++```
++createdb cancerindex && cp .env.example .env
++pnpm install && pnpm db:migrate && pnpm db:seed && pnpm cix sources:sync
++pnpm cix run oncotree --mode dry_run   # smoke; then without --mode
++pnpm cix counters && pnpm cix rank
++pnpm dev:api & pnpm dev:web
++```
++
++## Deployment
++MacLustr cluster via `mld` (gateway M1M32): manifest `~/dispatch/apps/cancerindex.json`,
++`mld stage <dir> cancerindex` then `mld deploy cancerindex`. Web :8250, API :8251, PM2 processes
++`cancerindex-web|api|worker|ngrok`, domain www.cancerindex.io (ngrok reserved). Postgres 17 +
++pgvector on the node, database `cancerindex`. Source of truth for the code: spbgit `cancerindex.git`.

added package.json +40 −0

++{
++  "name": "cancerindex",
++  "version": "0.1.0",
++  "private": true,
++  "description": "CancerIndex.io — the global index of cancer: provenance-first oncology ontology, epidemiology, genomics, trials, literature, rankings",
++  "type": "module",
++  "packageManager": "pnpm@11.1.2",
++  "engines": {
++    "node": ">=22"
++  },
++  "scripts": {
++    "build": "pnpm -r --filter './packages/**' run build && pnpm --filter @cancerindex/api run build && pnpm --filter @cancerindex/web run build",
++    "typecheck": "pnpm -r run typecheck",
++    "test": "pnpm -r run test",
++    "db:generate": "pnpm --filter @cancerindex/database run generate",
++    "db:migrate": "pnpm --filter @cancerindex/database run migrate",
++    "db:seed": "pnpm --filter @cancerindex/database run seed",
++    "dev:web": "pnpm --filter @cancerindex/web run dev",
++    "dev:api": "pnpm --filter @cancerindex/api run dev",
++    "worker": "tsx workers/main.ts",
++    "cix": "tsx scripts/ci.ts",
++    "registry": "tsx scripts/build-registry.ts",
++    "registry:check": "tsx scripts/build-registry.ts --check"
++  },
++  "dependencies": {
++    "@cancerindex/connectors": "workspace:*",
++    "@cancerindex/database": "workspace:*",
++    "@cancerindex/ontology": "workspace:*",
++    "@cancerindex/ranking": "workspace:*",
++    "@cancerindex/shared": "workspace:*",
++    "drizzle-orm": "^0.45.0",
++    "postgres": "^3.4.7"
++  },
++  "devDependencies": {
++    "@types/node": "^24.0.0",
++    "tsx": "^4.20.0",
++    "typescript": "^5.9.3",
++    "vitest": "^3.2.0"
++  }
++}

added packages/connectors/package.json +36 −0

++{
++  "name": "@cancerindex/connectors",
++  "version": "0.1.0",
++  "private": true,
++  "type": "module",
++  "exports": {
++    ".": {
++      "types": "./src/index.ts",
++      "default": "./src/index.ts"
++    },
++    "./sdk": {
++      "types": "./src/sdk/index.ts",
++      "default": "./src/sdk/index.ts"
++    }
++  },
++  "scripts": {
++    "build": "tsc -p tsconfig.json --noEmit",
++    "typecheck": "tsc -p tsconfig.json --noEmit",
++    "test": "vitest run --passWithNoTests"
++  },
++  "dependencies": {
++    "@cancerindex/database": "workspace:*",
++    "@cancerindex/ontology": "workspace:*",
++    "@cancerindex/shared": "workspace:*",
++    "drizzle-orm": "^0.45.0",
++    "fast-xml-parser": "^5.2.0",
++    "postgres": "^3.4.7",
++    "yaml": "^2.8.0",
++    "zod": "^4.0.0"
++  },
++  "devDependencies": {
++    "@types/node": "^24.0.0",
++    "typescript": "^5.9.3",
++    "vitest": "^3.2.0"
++  }
++}

added packages/connectors/src/connectors/oncotree/index.ts +185 −0

++import { eq, sql } from 'drizzle-orm';
++import { z } from 'zod';
++import { normalizeLabel, slugify } from '@cancerindex/shared';
++import { anatomicalSites, cancerAliases, cancerAnatomy, cancerCodes, cancerHierarchy, cancers, mintId } from '@cancerindex/database';
++import { CancerResolver } from '@cancerindex/ontology';
++import { Connector, type ConnectorHealth, type RunContext } from '../../sdk/run.js';
++import { manifest } from './manifest.js';
++
++const TumorType = z.object({
++  code: z.string(),
++  name: z.string(),
++  mainType: z.string().nullable().optional(),
++  tissue: z.string().nullable().optional(),
++  parent: z.string().nullable().optional(),
++  level: z.number().int(),
++  externalReferences: z.record(z.string(), z.array(z.string())).default({}),
++  history: z.array(z.string()).default([]),
++  revocations: z.array(z.string()).default([]),
++  precursors: z.array(z.string()).default([]),
++  color: z.string().nullable().optional(),
++});
++type TumorType = z.infer<typeof TumorType>;
++
++const HEME_RE = /lymphoid|myeloid|blood|leukemia|lymphoma|myeloma|histiocyt|mastocyt|plasma cell/i;
++const BENIGN_RE = /\bbenign\b|borderline|\bnevus\b|\bnevi\b|\badenoma\b|hyperplasia|\bcyst\b|hamartoma|\blipoma\b|leiomyoma\b|\bfibroma\b|hemangioma\b|papilloma\b|dysplasia|in situ|\bpolyp\b|schwannoma\b|meningioma\b|paraganglioma\b|pheochromocytoma\b|teratoma\b|thymoma\b/i;
++
++/**
++ * OncoTree connector: maps every OncoTree node onto the canonical cancer set.
++ *  - level-1 "tissue" nodes (parent TISSUE) are anatomical sites, not cancers → anatomical_sites
++ *  - NCIt cross-reference → EXACT_IDENTIFIER match to the NCIt-derived canonical entity
++ *  - otherwise preferred-name match → ONTOLOGY_EXACT
++ *  - otherwise a new canonical entity is created *only* because OncoTree is a recognized ontology
++ *    (CLAUDE.md §340) — flagged with primaryOncotreeCode and no NCIt code.
++ * The OncoTree parent/child structure is stored as hierarchy_type = "oncotree" (levels ≥ 2), and
++ * level-2 nodes are linked to their tissue via cancer_anatomy.
++ */
++export class OncotreeConnector extends Connector {
++  readonly manifest = manifest;
++
++  async healthCheck(ctx: RunContext): Promise<ConnectorHealth> {
++    try {
++      const versions = await ctx.http.json<Array<{ api_identifier: string; release_date: string }>>(`${manifest.access.baseUrl}/versions`);
++      const stable = versions.find((v) => v.api_identifier === 'oncotree_latest_stable');
++      return { status: 'healthy', detail: `latest stable ${stable?.release_date ?? '?'}` };
++    } catch (e) {
++      return { status: 'failing', detail: (e as Error).message };
++    }
++  }
++
++  async sync(ctx: RunContext): Promise<void> {
++    const versions = await ctx.http.json<Array<{ api_identifier: string; release_date: string; visible: boolean }>>(`${manifest.access.baseUrl}/versions`);
++    const stable = versions.find((v) => v.api_identifier === 'oncotree_latest_stable');
++    // Pin to the dated release identifier so the dataset version is reproducible.
++    const dated = versions.find((v) => v.release_date === stable?.release_date && v.api_identifier !== 'oncotree_latest_stable');
++    const version = dated?.api_identifier ?? 'oncotree_latest_stable';
++    ctx.datasetVersion = version;
++    ctx.info(`OncoTree version ${version}`);
++
++    const raw = await ctx.http.json<unknown[]>(`${manifest.access.baseUrl}/tumorTypes?version=${encodeURIComponent(version)}`);
++    const nodes: TumorType[] = [];
++    for (const r of raw) {
++      const parsed = TumorType.safeParse(r);
++      if (!parsed.success) {
++        ctx.counters.validationFailures++;
++        ctx.counters.rejected++;
++        ctx.warn(`invalid tumor type record: ${parsed.error.issues[0]?.message}`);
++        continue;
++      }
++      nodes.push(parsed.data);
++    }
++    ctx.info(`fetched ${nodes.length} tumor types`);
++    if (nodes.length < 500) throw new Error(`anomaly: only ${nodes.length} OncoTree nodes returned (expected ~900) — refusing to persist (CLAUDE.md §171)`);
++    if (ctx.mode === 'dry_run') {
++      ctx.counters.fetched = nodes.length;
++      return;
++    }
++
++    const resolver = new CancerResolver(ctx.db);
++    await resolver.warm();
++    const byCode = new Map(nodes.map((n) => [n.code, n]));
++    const canonicalByOncotree = new Map<string, string>();
++    const siteByOncotree = new Map<string, string>();
++    await ctx.addProvenance({ dataset: 'OncoTree tumor types', datasetVersion: version, sourceUrl: `${manifest.access.baseUrl}/tumorTypes?version=${version}`, evidenceType: 'expert_curation', accessLevel: 'open', methodology: 'OncoTree curated tumor type hierarchy' });
++
++    // Pass 0: tissue roots → anatomical sites
++    for (const node of nodes.filter((n) => n.parent === 'TISSUE')) {
++      await ctx.upsertSourceRecord('tissue', node.code, node);
++      const slug = slugify(node.name);
++      const ncit = node.externalReferences['NCI']?.[0] ?? null;
++      const [existing] = await ctx.db.select({ id: anatomicalSites.id }).from(anatomicalSites).where(eq(anatomicalSites.slug, slug)).limit(1);
++      let siteId = existing?.id;
++      if (!siteId) {
++        siteId = await mintId(ctx.db, 'ANAT');
++        await ctx.db.insert(anatomicalSites).values({ id: siteId, name: node.name, slug, ncitCode: ncit, system: node.tissue ?? node.name });
++      } else await ctx.db.update(anatomicalSites).set({ name: node.name, ncitCode: ncit }).where(eq(anatomicalSites.id, siteId));
++      siteByOncotree.set(node.code, siteId);
++    }
++
++    // Pass 1: resolve / create canonical entities (parents before children thanks to level ordering).
++    for (const node of [...nodes].filter((n) => n.parent !== 'TISSUE').sort((a, b) => a.level - b.level)) {
++      const rec = await ctx.upsertSourceRecord('tumor_type', node.code, node);
++      let cancerId: string | null = null;
++      let matchType = 'UNRESOLVED';
++      const ncitCodes = node.externalReferences['NCI'] ?? [];
++      for (const c of ncitCodes) {
++        const hit = resolver.byCode('ncit', c);
++        if (hit) {
++          cancerId = hit.cancerId;
++          matchType = hit.matchType;
++          break;
++        }
++      }
++      if (!cancerId) {
++        const hit = resolver.byCode('oncotree', node.code);
++        if (hit) {
++          cancerId = hit.cancerId;
++          matchType = hit.matchType;
++        }
++      }
++      if (!cancerId) {
++        const hit = resolver.byLabel(node.name);
++        if (hit && hit.matchType === 'ONTOLOGY_EXACT') {
++          cancerId = hit.cancerId;
++          matchType = hit.matchType;
++        }
++      }
++      if (!cancerId) {
++        // Recognized ontology node without NCIt anchor → new canonical entity (CLAUDE.md §340 satisfied: OncoTree is a recognized ontology).
++        const slugBase = slugify(node.name);
++        let slug = slugBase;
++        for (let i = 2; ; i++) {
++          const [clash] = await ctx.db.select({ id: cancers.id }).from(cancers).where(eq(cancers.slug, slug)).limit(1);
++          if (!clash) break;
++          slug = `${slugBase}-${i}`;
++        }
++        const heme = HEME_RE.test(`${node.tissue ?? ''} ${node.mainType ?? ''} ${node.name}`);
++        cancerId = await mintId(ctx.db, 'CAN');
++        await ctx.db.insert(cancers).values({
++          id: cancerId,
++          slug,
++          canonicalName: node.name,
++          entityType: node.level >= 3 ? 'subtype' : heme ? 'hematologic_malignancy' : 'cancer',
++          malignant: !BENIGN_RE.test(node.name),
++          solidTumor: !heme,
++          hematologic: heme,
++          primaryOncotreeCode: node.code,
++          depth: node.level,
++          classificationVersion: version,
++        });
++        await ctx.db.insert(cancerAliases).values({ cancerId, alias: node.name, normalized: normalizeLabel(node.name), aliasType: 'preferred', sourceId: ctx.sourceId, sourceTerminology: 'OncoTree' }).onConflictDoNothing();
++        matchType = 'EXACT_IDENTIFIER';
++        await ctx.recordChange('cancer', cancerId, 'created', `Created from OncoTree ${node.code} (${node.name})`);
++      } else {
++        await ctx.db.insert(cancerAliases).values({ cancerId, alias: node.name, normalized: normalizeLabel(node.name), aliasType: 'synonym', sourceId: ctx.sourceId, sourceTerminology: 'OncoTree' }).onConflictDoNothing();
++      }
++      canonicalByOncotree.set(node.code, cancerId);
++      await ctx.db.insert(cancerCodes).values({ cancerId, system: 'oncotree', code: node.code, matchType, sourceId: ctx.sourceId, validFrom: stable?.release_date }).onConflictDoNothing();
++      for (const u of node.externalReferences['UMLS'] ?? []) await ctx.db.insert(cancerCodes).values({ cancerId, system: 'umls', code: u, matchType: 'EXACT_IDENTIFIER', sourceId: ctx.sourceId }).onConflictDoNothing();
++      for (const c of ncitCodes) await ctx.db.insert(cancerCodes).values({ cancerId, system: 'ncit', code: c, matchType: 'EXACT_IDENTIFIER', sourceId: ctx.sourceId }).onConflictDoNothing();
++      // Record the OncoTree code on the entity only when it has none yet (first mapping wins; others stay in cancer_codes).
++      await ctx.db.execute(sql`UPDATE cancers SET primary_oncotree_code = ${node.code} WHERE id = ${cancerId} AND primary_oncotree_code IS NULL`);
++      // Level-2 nodes hang directly under a tissue → anatomical relation.
++      if (node.parent && siteByOncotree.has(node.parent)) {
++        await ctx.db.insert(cancerAnatomy).values({ cancerId, siteId: siteByOncotree.get(node.parent)!, relation: 'primary', sourceId: ctx.sourceId }).onConflictDoNothing();
++      }
++      void rec;
++    }
++
++    // Pass 2: hierarchy edges (oncotree dimension), levels ≥ 2 only.
++    let edges = 0;
++    for (const node of nodes) {
++      if (!node.parent || node.parent === 'TISSUE' || siteByOncotree.has(node.parent)) continue;
++      const childId = canonicalByOncotree.get(node.code);
++      const parentId = canonicalByOncotree.get(node.parent);
++      if (!childId || !parentId || childId === parentId) continue;
++      if (!byCode.has(node.parent)) continue;
++      await ctx.db.insert(cancerHierarchy).values({ parentId, childId, hierarchyType: 'oncotree', sourceId: ctx.sourceId }).onConflictDoNothing();
++      edges++;
++    }
++    ctx.info(`tissues ${siteByOncotree.size}; canonical mapped ${canonicalByOncotree.size}; hierarchy edges ${edges}`);
++    ctx.cursor = { version, syncedAt: new Date().toISOString() };
++  }
++}
++
++export const connector = new OncotreeConnector();

added packages/connectors/src/connectors/oncotree/manifest.ts +34 −0

++import { defineManifest } from '../../sdk/manifest.js';
++
++/**
++ * Docs verified 2026-09-08: https://oncotree.mskcc.org (API tab) — GET /api/tumorTypes?version=…,
++ * GET /api/versions, GET /api/mainTypes. Response fields: code, name, mainType, tissue, parent,
++ * level, externalReferences{UMLS[],NCI[]}, history[], revocations[], precursors[], color.
++ * License (repo README, cBioPortal/oncotree): CC BY 4.0.
++ */
++export const manifest = defineManifest({
++  id: 'oncotree',
++  name: 'OncoTree',
++  organization: 'Memorial Sloan Kettering Cancer Center / cBioPortal',
++  category: 'terminology',
++  tier: 0,
++  description: 'Open cancer classification used by cBioPortal and clinical sequencing programs. Provides a tissue-based tumor type hierarchy with NCIt and UMLS cross-references. Used as a second hierarchy dimension and to anchor cohort/genomic sources.',
++  homepage: 'https://oncotree.mskcc.org',
++  docsUrl: 'https://oncotree.mskcc.org/#/home?tab=api',
++  termsUrl: 'https://github.com/cBioPortal/oncotree/blob/master/LICENSE',
++  access: { type: 'api', auth: 'none', baseUrl: 'https://oncotree.mskcc.org/api' },
++  license: 'CC BY 4.0',
++  licenseStatus: 'approved',
++  commercialUse: 'allowed',
++  redistribution: 'attribution',
++  attribution: 'OncoTree (Memorial Sloan Kettering Cancer Center), CC BY 4.0, https://oncotree.mskcc.org',
++  termsReviewedAt: '2026-09-08',
++  updateFrequency: 'Stable releases a few times per year',
++  supportsIncrementalSync: false,
++  entities: ['cancer', 'cancer_hierarchy', 'cancer_codes'],
++  rateLimits: { requestsPerSecond: 2, maxConcurrency: 1 },
++  rawRetention: 'full',
++  documentationVerifiedAt: '2026-09-08',
++  status: 'active',
++  schedule: '0 4 * * 1',
++});

added packages/connectors/src/index.ts +4 −0

++export * from './sdk/index.js';
++export * from './registry.js';
++export * from './sources-sync.js';
++export * from './planned.js';

added packages/connectors/src/planned.ts +60 −0

++import { defineManifest, type ConnectorManifest } from './sdk/manifest.js';
++
++/**
++ * Sources that are registered (visible on /sources with their compliance status) but have no
++ * ingesting connector yet — either because license review is pending (CLAUDE.md §10.4, §142) or
++ * because credentials are required. Nothing here ingests data.
++ */
++export const PLANNED_MANIFESTS: ConnectorManifest[] = [
++  defineManifest({
++    id: 'iarc-globocan',
++    name: 'IARC Global Cancer Observatory (GLOBOCAN)',
++    organization: 'International Agency for Research on Cancer (WHO)',
++    category: 'epidemiology',
++    tier: 0,
++    description: 'Global estimates of cancer incidence, mortality and prevalence by country, sex, age and cancer site. The intended global epidemiology layer of CancerIndex.',
++    homepage: 'https://gco.iarc.who.int/',
++    docsUrl: 'https://gco.iarc.who.int/today/en/about',
++    termsUrl: 'https://gco.iarc.who.int/en/terms-of-use',
++    access: { type: 'api', auth: 'none', baseUrl: 'https://gco.iarc.who.int/' },
++    license: 'IARC/WHO terms of use — redistribution rights under review',
++    licenseStatus: 'review',
++    commercialUse: 'unknown',
++    redistribution: 'unknown',
++    attribution: 'Ferlay J, Ervik M, Lam F, et al. Global Cancer Observatory: Cancer Today. Lyon, France: IARC.',
++    termsNotes:
++      'Terms page is a JavaScript application; automated review on 2026-09-08 could not extract the text. Per CLAUDE.md §10.4 no automated bulk ingestion or republication of GLOBOCAN estimates until a human has reviewed the terms and, if required, obtained permission from IARC. Country/global rankings therefore remain unavailable and are shown as "awaiting license review".',
++    updateFrequency: 'Major releases every ~2 years (GLOBOCAN 2022 current)',
++    supportsIncrementalSync: false,
++    entities: ['epidemiology_observations'],
++    metrics: ['incidence_count', 'mortality_count', 'as_incidence_rate', 'as_mortality_rate', 'prevalence_5y'],
++    rateLimits: { requestsPerSecond: 1, maxConcurrency: 1 },
++    documentationVerifiedAt: '2026-09-08',
++    status: 'review',
++  }),
++  defineManifest({
++    id: 'seer',
++    name: 'SEER (Surveillance, Epidemiology, and End Results)',
++    organization: 'National Cancer Institute',
++    category: 'epidemiology',
++    tier: 0,
++    description: 'US population-based registry statistics: incidence, mortality, survival, stage, age, sex, race/ethnicity. Authoritative for US relative survival.',
++    homepage: 'https://seer.cancer.gov/',
++    docsUrl: 'https://api.seer.cancer.gov/',
++    termsUrl: 'https://seer.cancer.gov/about/terms.html',
++    access: { type: 'api', auth: 'api_key', baseUrl: 'https://api.seer.cancer.gov/rest/' },
++    license: 'US Government work (public domain); SEER*Explorer statistics citable with attribution; API requires a free key',
++    licenseStatus: 'review',
++    commercialUse: 'unknown',
++    redistribution: 'attribution',
++    attribution: 'Surveillance, Epidemiology, and End Results (SEER) Program (www.seer.cancer.gov), National Cancer Institute.',
++    termsNotes: 'Connector is implemented against the SEER API only once a key is present (SEER_API_KEY). Status awaiting_credentials until then. Never present SEER (US) estimates as global.',
++    updateFrequency: 'Annual (April)',
++    supportsIncrementalSync: false,
++    entities: ['epidemiology_observations', 'survival_observations'],
++    metrics: ['incidence_count', 'as_incidence_rate', 'mortality_count', 'as_mortality_rate', 'five_year_survival'],
++    rateLimits: { requestsPerSecond: 2, maxConcurrency: 1 },
++    documentationVerifiedAt: '2026-09-08',
++    status: 'awaiting_credentials',
++  }),
++];

added packages/connectors/src/registry.ts +13 −0

++import type { Connector } from './sdk/run.js';
++import { connector as oncotree } from './connectors/oncotree/index.js';
++
++/**
++ * Connector registry. Order = recommended first-run order (CLAUDE.md §351): terminology first,
++ * then genes, then genomics/trials/literature/variants/evidence, then epidemiology.
++ * Add new connectors here; `pnpm cix sources:sync` seeds their manifests into `sources`.
++ */
++export const CONNECTORS: Connector[] = [oncotree];
++
++export function getConnector(id: string): Connector | undefined {
++  return CONNECTORS.find((c) => c.manifest.id === id);
++}

added packages/connectors/src/sdk/http.ts +162 −0

++import { setTimeout as sleep } from 'node:timers/promises';
++import type { ConnectorManifest } from './manifest.js';
++
++export interface HttpStats {
++  requests: number;
++  failures: number;
++  rateLimitEvents: number;
++  retries: number;
++}
++
++export class HttpError extends Error {
++  constructor(
++    public readonly status: number,
++    public readonly url: string,
++    public readonly bodySnippet: string,
++  ) {
++    super(`HTTP ${status} for ${url}: ${bodySnippet.slice(0, 200)}`);
++  }
++}
++
++/** Token bucket rate limiter (CLAUDE.md §229). */
++class TokenBucket {
++  private tokens: number;
++  private last = Date.now();
++  constructor(
++    private readonly ratePerSec: number,
++    private readonly burst: number,
++  ) {
++    this.tokens = burst;
++  }
++  async take(): Promise<void> {
++    for (;;) {
++      const now = Date.now();
++      this.tokens = Math.min(this.burst, this.tokens + ((now - this.last) / 1000) * this.ratePerSec);
++      this.last = now;
++      if (this.tokens >= 1) {
++        this.tokens -= 1;
++        return;
++      }
++      await sleep(Math.ceil(((1 - this.tokens) / this.ratePerSec) * 1000));
++    }
++  }
++}
++
++class Semaphore {
++  private queue: Array<() => void> = [];
++  private active = 0;
++  constructor(private readonly max: number) {}
++  async acquire(): Promise<() => void> {
++    if (this.active >= this.max) await new Promise<void>((resolve) => this.queue.push(resolve));
++    this.active++;
++    let released = false;
++    return () => {
++      if (released) return;
++      released = true;
++      this.active--;
++      const next = this.queue.shift();
++      if (next) next();
++    };
++  }
++}
++
++export interface HttpClientOptions {
++  userAgent?: string;
++  timeoutMs?: number;
++  headers?: Record<string, string>;
++}
++
++/**
++ * Source-aware HTTP client: token bucket, bounded concurrency, exponential backoff with jitter,
++ * Retry-After respect, request accounting for the ingest run.
++ */
++export class HttpClient {
++  readonly stats: HttpStats = { requests: 0, failures: 0, rateLimitEvents: 0, retries: 0 };
++  private readonly bucket: TokenBucket | null;
++  private readonly sem: Semaphore;
++  private readonly retry: NonNullable<ConnectorManifest['retryPolicy']>;
++  private readonly ua: string;
++  private readonly timeoutMs: number;
++  private readonly headers: Record<string, string>;
++
++  constructor(manifest: ConnectorManifest, opts: HttpClientOptions = {}) {
++    const rps = manifest.rateLimits.requestsPerSecond ?? (manifest.rateLimits.requestsPerMinute ? manifest.rateLimits.requestsPerMinute / 60 : undefined);
++    this.bucket = rps ? new TokenBucket(rps, Math.max(1, Math.ceil(rps))) : null;
++    this.sem = new Semaphore(manifest.rateLimits.maxConcurrency);
++    this.retry = manifest.retryPolicy;
++    // Plain product token only: some WAFs (e.g. oncotree.mskcc.org, Akamai) reject UAs containing URLs/parentheses.
++    this.ua = opts.userAgent ?? `CancerIndex/0.1`;
++    this.timeoutMs = opts.timeoutMs ?? 60_000;
++    this.headers = opts.headers ?? {};
++  }
++
++  /** One attempt: returns the Response (any status) or throws on network error. */
++  private async attempt(url: string, init: RequestInit): Promise<Response> {
++    const release = await this.sem.acquire();
++    try {
++      if (this.bucket) await this.bucket.take();
++      this.stats.requests++;
++      const controller = new AbortController();
++      const timer = setTimeout(() => controller.abort(), this.timeoutMs);
++      try {
++        return await fetch(url, {
++          ...init,
++          headers: { 'user-agent': this.ua, accept: 'application/json, text/plain, */*', ...this.headers, ...(init.headers as Record<string, string> | undefined) },
++          signal: controller.signal,
++        });
++      } finally {
++        clearTimeout(timer);
++      }
++    } finally {
++      release();
++    }
++  }
++
++  async request(url: string, init: RequestInit = {}): Promise<Response> {
++    for (let attempt = 0; ; attempt++) {
++      let res: Response;
++      try {
++        res = await this.attempt(url, init);
++      } catch (err) {
++        if (attempt >= this.retry.maxRetries) {
++          this.stats.failures++;
++          throw err;
++        }
++        this.stats.retries++;
++        await sleep(this.backoff(attempt));
++        continue;
++      }
++      if (res.ok) return res;
++      const body = await res.text().catch(() => '');
++      if (res.status === 429) this.stats.rateLimitEvents++;
++      const retryable = res.status === 429 || res.status >= 500 || res.status === 408;
++      if (!retryable || attempt >= this.retry.maxRetries) {
++        this.stats.failures++;
++        throw new HttpError(res.status, url, body);
++      }
++      const retryAfter = Number(res.headers.get('retry-after'));
++      const delay = Number.isFinite(retryAfter) && retryAfter > 0 ? Math.min(retryAfter * 1000, 120_000) : this.backoff(attempt);
++      this.stats.retries++;
++      await sleep(delay);
++    }
++  }
++
++  async json<T = unknown>(url: string, init?: RequestInit): Promise<T> {
++    const res = await this.request(url, init);
++    return (await res.json()) as T;
++  }
++
++  async text(url: string, init?: RequestInit): Promise<string> {
++    const res = await this.request(url, init);
++    return await res.text();
++  }
++
++  async postJson<T = unknown>(url: string, body: unknown, init: RequestInit = {}): Promise<T> {
++    return this.json<T>(url, { ...init, method: 'POST', headers: { 'content-type': 'application/json', ...(init.headers as Record<string, string> | undefined) }, body: JSON.stringify(body) });
++  }
++
++  private backoff(attempt: number): number {
++    const base = Math.min(this.retry.maxDelayMs, this.retry.baseDelayMs * 2 ** attempt);
++    return Math.round(base / 2 + Math.random() * (base / 2));
++  }
++}

added packages/connectors/src/sdk/index.ts +5 −0

++export * from './manifest.js';
++export * from './http.js';
++export * from './lake.js';
++export * from './run.js';
++export * from './validate.js';

added packages/connectors/src/sdk/lake.ts +105 −0

++import { createWriteStream, existsSync, mkdirSync, createReadStream } from 'node:fs';
++import { mkdir, stat } from 'node:fs/promises';
++import path from 'node:path';
++import { createGzip, createGunzip } from 'node:zlib';
++import { pipeline } from 'node:stream/promises';
++import { createInterface } from 'node:readline';
++import { dataDir } from '@cancerindex/shared';
++
++/**
++ * Raw data lake (CLAUDE.md §26): every source payload retained when licensing allows.
++ * Layout: {CI_DATA_DIR}/raw/{source}/{YYYY-MM-DD}/{entity}/{runId}-{part}.jsonl.gz
++ * A record's `rawPath` is "<file>#<line>" so any canonical value can be traced to its raw payload.
++ */
++export class RawLake {
++  private readonly root: string;
++  private writers = new Map<string, { path: string; stream: ReturnType<typeof createWriteStream>; gz: ReturnType<typeof createGzip>; lines: number; part: number; bytes: number }>();
++  constructor(
++    private readonly source: string,
++    private readonly runId: string,
++    private readonly date = new Date(),
++    root?: string,
++  ) {
++    this.root = root ?? path.join(dataDir(), 'raw');
++  }
++
++  dir(entity: string): string {
++    const day = this.date.toISOString().slice(0, 10);
++    return path.join(this.root, this.source, day, entity);
++  }
++
++  /** Append one raw JSON payload; returns its rawPath reference. */
++  async put(entity: string, payload: unknown): Promise<string> {
++    let w = this.writers.get(entity);
++    if (!w || w.bytes > 64 * 1024 * 1024) {
++      if (w) await this.closeWriter(entity);
++      const part = (w?.part ?? 0) + 1;
++      const dir = this.dir(entity);
++      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
++      const file = path.join(dir, `${this.runId}-${String(part).padStart(3, '0')}.jsonl.gz`);
++      const stream = createWriteStream(file);
++      const gz = createGzip({ level: 6 });
++      gz.pipe(stream);
++      w = { path: file, stream, gz, lines: 0, part, bytes: 0 };
++      this.writers.set(entity, w);
++    }
++    const line = JSON.stringify(payload) + '\n';
++    w.bytes += line.length;
++    const ref = `${w.path}#${w.lines}`;
++    w.lines++;
++    if (!w.gz.write(line)) await new Promise<void>((r) => w!.gz.once('drain', () => r()));
++    return ref;
++  }
++
++  private async closeWriter(entity: string): Promise<void> {
++    const w = this.writers.get(entity);
++    if (!w) return;
++    await new Promise<void>((resolve, reject) => {
++      w.stream.once('finish', () => resolve());
++      w.stream.once('error', reject);
++      w.gz.end();
++    });
++    this.writers.delete(entity);
++  }
++
++  async close(): Promise<void> {
++    for (const entity of [...this.writers.keys()]) await this.closeWriter(entity);
++  }
++
++  /** Read a raw payload back by reference (admin TRACE, reprocessing). */
++  static async read(ref: string): Promise<unknown | null> {
++    const [file, lineStr] = ref.split('#');
++    if (!file || lineStr === undefined) return null;
++    const target = Number(lineStr);
++    const rl = createInterface({ input: createReadStream(file).pipe(createGunzip()) });
++    let i = 0;
++    for await (const line of rl) {
++      if (i === target) {
++        rl.close();
++        return JSON.parse(line);
++      }
++      i++;
++    }
++    return null;
++  }
++}
++
++/** Download a bulk file to the lake (CLAUDE.md §228-230) with checksum + size recorded. */
++export async function downloadBulk(url: string, dest: string, fetchImpl: typeof fetch = fetch, headers: Record<string, string> = {}): Promise<{ path: string; bytes: number; sha256: string }> {
++  await mkdir(path.dirname(dest), { recursive: true });
++  const res = await fetchImpl(url, { headers: { 'user-agent': 'CancerIndex/0.1 (+https://www.cancerindex.io)', ...headers } });
++  if (!res.ok || !res.body) throw new Error(`bulk download failed ${res.status} ${url}`);
++  const { createHash } = await import('node:crypto');
++  const hash = createHash('sha256');
++  const { Transform } = await import('node:stream');
++  const tap = new Transform({
++    transform(chunk, _enc, cb) {
++      hash.update(chunk);
++      cb(null, chunk);
++    },
++  });
++  const { Readable } = await import('node:stream');
++  await pipeline(Readable.fromWeb(res.body as never), tap, createWriteStream(dest));
++  const s = await stat(dest);
++  return { path: dest, bytes: s.size, sha256: hash.digest('hex') };
++}

added packages/connectors/src/sdk/manifest.ts +61 −0

++import { z } from 'zod';
++
++/** Connector manifest (CLAUDE.md §9). Seeds the `sources` table; drives the public /source pages. */
++export const ConnectorManifest = z.object({
++  id: z.string().regex(/^[a-z0-9-]+$/),
++  name: z.string(),
++  organization: z.string(),
++  category: z.enum(['terminology', 'genes', 'genomics', 'variants', 'epidemiology', 'trials', 'literature', 'drugs', 'regulatory', 'evidence', 'pathways', 'funding', 'guidelines']),
++  tier: z.number().int().min(0).max(11),
++  description: z.string(),
++  homepage: z.string().url(),
++  docsUrl: z.string().url().optional(),
++  termsUrl: z.string().url().optional(),
++  access: z.object({
++    type: z.enum(['api', 'bulk', 'rss', 'ftp', 'graphql', 'rest', 'scrape', 'manual']),
++    auth: z.enum(['none', 'api_key', 'oauth', 'account', 'controlled']),
++    baseUrl: z.string().url().optional(),
++  }),
++  license: z.string(),
++  licenseStatus: z.enum(['review', 'approved', 'restricted', 'blocked']),
++  commercialUse: z.enum(['allowed', 'restricted', 'prohibited', 'unknown']),
++  redistribution: z.enum(['allowed', 'attribution', 'restricted', 'prohibited', 'unknown']),
++  attribution: z.string().optional(),
++  termsReviewedAt: z.string().optional(), // YYYY-MM-DD, human review date
++  termsNotes: z.string().optional(),
++  updateFrequency: z.string(),
++  expectedLatency: z.string().optional(),
++  supportsIncrementalSync: z.boolean(),
++  entities: z.array(z.string()),
++  metrics: z.array(z.string()).default([]),
++  rateLimits: z.object({
++    requestsPerSecond: z.number().positive().optional(),
++    requestsPerMinute: z.number().positive().optional(),
++    maxConcurrency: z.number().int().positive().default(1),
++    notes: z.string().optional(),
++  }),
++  retryPolicy: z
++    .object({
++      maxRetries: z.number().int().min(0).default(4),
++      baseDelayMs: z.number().int().min(0).default(500),
++      maxDelayMs: z.number().int().min(0).default(30_000),
++    })
++    .default({ maxRetries: 4, baseDelayMs: 500, maxDelayMs: 30_000 }),
++  rawRetention: z.enum(['full', 'summary', 'none']).default('full'),
++  schemaVersion: z.string().default('1'),
++  documentationVerifiedAt: z.string(), // YYYY-MM-DD, the date official docs were checked (CLAUDE.md §224-225)
++  owner: z.string().default('cancerindex'),
++  status: z.enum(['planned', 'active', 'paused', 'awaiting_credentials', 'review', 'retired']),
++  schedule: z.string().optional(), // cron expression for the worker scheduler
++  anomalyGuard: z
++    .object({
++      /** Refuse to mark records source_missing when the fetched count drops below this ratio of the previous run. */
++      minRatioOfPrevious: z.number().min(0).max(1).default(0.5),
++    })
++    .default({ minRatioOfPrevious: 0.5 }),
++});
++export type ConnectorManifest = z.infer<typeof ConnectorManifest>;
++
++export function defineManifest(m: z.input<typeof ConnectorManifest>): ConnectorManifest {
++  return ConnectorManifest.parse(m);
++}

added packages/connectors/src/sdk/run.ts +0 −0

Binary file not shown.

added packages/connectors/src/sdk/validate.ts +49 −0

++/** Scientific invariants applied to normalized records (CLAUDE.md §110, §154). */
++
++export interface ValidationIssue {
++  field: string;
++  message: string;
++}
++
++export function validateEpidemiology(o: { metric: string; value: number; year: number; lowerCi?: number | null; upperCi?: number | null; unit: string }): ValidationIssue[] {
++  const issues: ValidationIssue[] = [];
++  if (!Number.isFinite(o.value)) issues.push({ field: 'value', message: 'not finite' });
++  if (o.value < 0) issues.push({ field: 'value', message: 'negative count/rate' });
++  if (o.year < 1900 || o.year > new Date().getFullYear() + 30) issues.push({ field: 'year', message: `implausible year ${o.year}` });
++  if (o.lowerCi != null && o.lowerCi > o.value) issues.push({ field: 'lowerCi', message: 'lowerCI > estimate' });
++  if (o.upperCi != null && o.upperCi < o.value) issues.push({ field: 'upperCi', message: 'upperCI < estimate' });
++  if (o.metric.endsWith('_count') && o.unit !== 'count') issues.push({ field: 'unit', message: 'count metric must use unit=count' });
++  if (o.metric.endsWith('_rate') && o.unit !== 'per_100k') issues.push({ field: 'unit', message: 'rate metric must use unit=per_100k' });
++  return issues;
++}
++
++export function validateSurvival(o: { probability?: number | null; durationMonths: number; lowerCi?: number | null; upperCi?: number | null; cohortSize?: number | null }): ValidationIssue[] {
++  const issues: ValidationIssue[] = [];
++  if (o.probability != null && (o.probability < 0 || o.probability > 1)) issues.push({ field: 'probability', message: 'survival must be within [0,1]' });
++  if (o.durationMonths <= 0) issues.push({ field: 'durationMonths', message: 'duration must be positive' });
++  if (o.probability != null && o.lowerCi != null && o.lowerCi > o.probability) issues.push({ field: 'lowerCi', message: 'lowerCI > estimate' });
++  if (o.probability != null && o.upperCi != null && o.upperCi < o.probability) issues.push({ field: 'upperCi', message: 'upperCI < estimate' });
++  if (o.cohortSize != null && o.cohortSize < 0) issues.push({ field: 'cohortSize', message: 'negative cohort' });
++  return issues;
++}
++
++export const TRIAL_PHASES = new Set(['EARLY_PHASE1', 'PHASE1', 'PHASE2', 'PHASE3', 'PHASE4', 'NA']);
++export const TRIAL_STATUSES = new Set(['ACTIVE_NOT_RECRUITING', 'COMPLETED', 'ENROLLING_BY_INVITATION', 'NOT_YET_RECRUITING', 'RECRUITING', 'SUSPENDED', 'TERMINATED', 'WITHDRAWN', 'AVAILABLE', 'NO_LONGER_AVAILABLE', 'TEMPORARILY_NOT_AVAILABLE', 'APPROVED_FOR_MARKETING', 'WITHHELD', 'UNKNOWN']);
++
++export function validateTrial(o: { nctId: string; phases: string[]; overallStatus?: string | null }): ValidationIssue[] {
++  const issues: ValidationIssue[] = [];
++  if (!/^NCT\d{8}$/.test(o.nctId)) issues.push({ field: 'nctId', message: 'malformed NCT id' });
++  for (const p of o.phases) if (!TRIAL_PHASES.has(p)) issues.push({ field: 'phases', message: `unknown phase enum ${p}` });
++  if (o.overallStatus && !TRIAL_STATUSES.has(o.overallStatus)) issues.push({ field: 'overallStatus', message: `unknown status enum ${o.overallStatus}` });
++  return issues;
++}
++
++export function validateFrequency(o: { casesAffected: number; casesProfiled: number }): ValidationIssue[] {
++  const issues: ValidationIssue[] = [];
++  if (o.casesProfiled <= 0) issues.push({ field: 'casesProfiled', message: 'denominator must be positive' });
++  if (o.casesAffected < 0 || o.casesAffected > o.casesProfiled) issues.push({ field: 'casesAffected', message: 'numerator out of range' });
++  return issues;
++}
++
++/** Gene symbol sanity (HGNC style). */
++export const GENE_SYMBOL_RE = /^[A-Z][A-Z0-9-]{0,15}(?:@|orf\d+)?$/i;

added packages/connectors/src/sources-sync.ts +51 −0

++import { eq } from 'drizzle-orm';
++import { type Database, sources, mintId } from '@cancerindex/database';
++import { CONNECTORS } from './registry.js';
++import type { ConnectorManifest } from './sdk/manifest.js';
++
++/** Sync connector manifests into the `sources` registry (CLAUDE.md §95, §142, §307). Idempotent. */
++export async function syncSources(db: Database, extra: ConnectorManifest[] = []): Promise<{ created: number; updated: number }> {
++  let created = 0;
++  let updated = 0;
++  const manifests = [...CONNECTORS.map((c) => c.manifest), ...extra];
++  for (const m of manifests) {
++    const values = {
++      slug: m.id,
++      name: m.name,
++      organization: m.organization,
++      category: m.category,
++      description: m.description,
++      homepage: m.homepage,
++      docsUrl: m.docsUrl ?? null,
++      termsUrl: m.termsUrl ?? null,
++      accessType: m.access.type,
++      accessAuth: m.access.auth,
++      license: m.license,
++      licenseStatus: m.licenseStatus,
++      commercialUse: m.commercialUse,
++      redistribution: m.redistribution,
++      attribution: m.attribution ?? null,
++      licenseReviewedAt: m.termsReviewedAt ? new Date(m.termsReviewedAt) : null,
++      approvedForProduction: m.licenseStatus === 'approved',
++      updateFrequency: m.updateFrequency,
++      supportsIncremental: m.supportsIncrementalSync,
++      entities: m.entities,
++      metrics: m.metrics,
++      rateLimit: m.rateLimits.requestsPerSecond ? `${m.rateLimits.requestsPerSecond} req/s` : m.rateLimits.requestsPerMinute ? `${m.rateLimits.requestsPerMinute} req/min` : null,
++      tier: m.tier,
++      manifest: m as unknown as Record<string, unknown>,
++      updatedAt: new Date(),
++    };
++    const [existing] = await db.select({ id: sources.id, status: sources.status }).from(sources).where(eq(sources.slug, m.id)).limit(1);
++    if (existing) {
++      // Keep runtime status (active/degraded) unless manifest declares a gating status.
++      const gating = ['awaiting_credentials', 'review', 'retired', 'paused'].includes(m.status);
++      await db.update(sources).set({ ...values, ...(gating ? { status: m.status } : {}) }).where(eq(sources.id, existing.id));
++      updated++;
++    } else {
++      await db.insert(sources).values({ id: await mintId(db, 'SOURCE'), ...values, status: m.status });
++      created++;
++    }
++  }
++  return { created, updated };
++}

added packages/connectors/tsconfig.json +8 −0

++{
++  "extends": "../../tsconfig.base.json",
++  "compilerOptions": {
++    "rootDir": ".",
++    "noEmit": true
++  },
++  "include": ["src", "test"]
++}

added packages/connectors/vitest.config.ts +8 −0

++import { defineConfig } from 'vitest/config';
++
++export default defineConfig({
++  test: {
++    include: ['src/**/*.test.ts', 'test/**/*.test.ts'],
++    testTimeout: 20_000,
++  },
++});

added packages/database/drizzle.config.ts +11 −0

++import { defineConfig } from 'drizzle-kit';
++
++export default defineConfig({
++  dialect: 'postgresql',
++  schema: './src/schema/index.ts',
++  out: './migrations',
++  dbCredentials: { url: process.env.DATABASE_URL ?? 'postgres://localhost:5432/cancerindex' },
++  casing: 'snake_case',
++  strict: true,
++  verbose: true,
++});

added packages/database/migrations/0000_small_blazing_skull.sql +936 −0

++CREATE TABLE "audit_log" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"actor" text NOT NULL,
++	"action" text NOT NULL,
++	"entity_type" text,
++	"entity_id" text,
++	"before" jsonb,
++	"after" jsonb,
++	"reason" text,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "change_events" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"entity_type" text NOT NULL,
++	"entity_id" text NOT NULL,
++	"kind" text NOT NULL,
++	"summary" text NOT NULL,
++	"before" jsonb,
++	"after" jsonb,
++	"ingest_run_id" text,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "connector_cursors" (
++	"connector_id" text PRIMARY KEY NOT NULL,
++	"cursor" jsonb DEFAULT '{}'::jsonb NOT NULL,
++	"last_success_at" timestamp with time zone,
++	"last_attempt_at" timestamp with time zone,
++	"paused" boolean DEFAULT false NOT NULL,
++	"health" text DEFAULT 'unknown' NOT NULL,
++	"health_detail" text,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "connector_field_stats" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"connector_id" text NOT NULL,
++	"entity" text NOT NULL,
++	"field" text NOT NULL,
++	"types" text[] DEFAULT '{}' NOT NULL,
++	"seen_count" integer DEFAULT 0 NOT NULL,
++	"null_count" integer DEFAULT 0 NOT NULL,
++	"first_seen_run" text,
++	"last_seen_run" text,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "entity_merges" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"entity_type" text NOT NULL,
++	"keep_id" text NOT NULL,
++	"merge_id" text NOT NULL,
++	"evidence" jsonb DEFAULT '{}'::jsonb NOT NULL,
++	"status" text DEFAULT 'proposed' NOT NULL,
++	"decided_by" text,
++	"decided_at" timestamp with time zone,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "id_sequences" (
++	"namespace" varchar(16) PRIMARY KEY NOT NULL,
++	"next" bigint DEFAULT 1 NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "ingest_runs" (
++	"id" text PRIMARY KEY NOT NULL,
++	"connector_id" text NOT NULL,
++	"source_id" varchar(32) NOT NULL,
++	"mode" text DEFAULT 'incremental' NOT NULL,
++	"status" text DEFAULT 'running' NOT NULL,
++	"started_at" timestamp with time zone DEFAULT now() NOT NULL,
++	"finished_at" timestamp with time zone,
++	"duration_ms" integer,
++	"records_fetched" integer DEFAULT 0 NOT NULL,
++	"records_created" integer DEFAULT 0 NOT NULL,
++	"records_updated" integer DEFAULT 0 NOT NULL,
++	"records_unchanged" integer DEFAULT 0 NOT NULL,
++	"records_rejected" integer DEFAULT 0 NOT NULL,
++	"http_requests" integer DEFAULT 0 NOT NULL,
++	"http_failures" integer DEFAULT 0 NOT NULL,
++	"rate_limit_events" integer DEFAULT 0 NOT NULL,
++	"validation_failures" integer DEFAULT 0 NOT NULL,
++	"schema_drift" jsonb DEFAULT '[]'::jsonb NOT NULL,
++	"cursor_before" jsonb,
++	"cursor_after" jsonb,
++	"error" text,
++	"log" jsonb DEFAULT '[]'::jsonb NOT NULL,
++	"dataset_version" text,
++	"anomaly" text
++);
++--> statement-breakpoint
++CREATE TABLE "provenance" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"public_id" varchar(32),
++	"source_id" varchar(32) NOT NULL,
++	"source_record_id" text,
++	"source_url" text,
++	"dataset" text,
++	"dataset_version" text,
++	"publication_id" varchar(32),
++	"pmid" text,
++	"doi" text,
++	"retrieved_at" timestamp with time zone NOT NULL,
++	"published_at" text,
++	"updated_at_source" text,
++	"geography" text,
++	"population" text,
++	"cohort_size" integer,
++	"methodology" text,
++	"evidence_type" text NOT NULL,
++	"access_level" text DEFAULT 'open' NOT NULL,
++	"confidence" real,
++	"license" text,
++	"ingest_run_id" text,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "source_records" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"source_id" varchar(32) NOT NULL,
++	"entity_kind" text NOT NULL,
++	"source_record_id" text NOT NULL,
++	"payload_hash" text NOT NULL,
++	"raw_path" text,
++	"status" text DEFAULT 'active' NOT NULL,
++	"first_seen_run" text,
++	"last_seen_run" text,
++	"retrieved_at" timestamp with time zone DEFAULT now() NOT NULL,
++	"source_updated_at" timestamp with time zone,
++	"canonical_type" text,
++	"canonical_id" text,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "sources" (
++	"id" varchar(32) PRIMARY KEY NOT NULL,
++	"slug" text NOT NULL,
++	"name" text NOT NULL,
++	"organization" text,
++	"category" text NOT NULL,
++	"description" text,
++	"homepage" text,
++	"docs_url" text,
++	"terms_url" text,
++	"access_type" text NOT NULL,
++	"access_auth" text NOT NULL,
++	"license" text,
++	"license_status" text DEFAULT 'review' NOT NULL,
++	"commercial_use" text DEFAULT 'unknown' NOT NULL,
++	"redistribution" text DEFAULT 'unknown' NOT NULL,
++	"attribution" text,
++	"license_reviewed_at" timestamp with time zone,
++	"approved_for_production" boolean DEFAULT false NOT NULL,
++	"update_frequency" text,
++	"supports_incremental" boolean DEFAULT false NOT NULL,
++	"entities" text[] DEFAULT '{}' NOT NULL,
++	"metrics" text[] DEFAULT '{}' NOT NULL,
++	"rate_limit" text,
++	"status" text DEFAULT 'planned' NOT NULL,
++	"tier" integer DEFAULT 0 NOT NULL,
++	"manifest" jsonb DEFAULT '{}'::jsonb NOT NULL,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "unresolved_labels" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"source_id" varchar(32) NOT NULL,
++	"entity_kind" text NOT NULL,
++	"source_text" text NOT NULL,
++	"normalized" text NOT NULL,
++	"context" jsonb DEFAULT '{}'::jsonb NOT NULL,
++	"count" integer DEFAULT 1 NOT NULL,
++	"status" text DEFAULT 'open' NOT NULL,
++	"suggested_id" text,
++	"suggested_match_type" text,
++	"suggested_score" real,
++	"resolved_id" text,
++	"resolved_by" text,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "anatomical_sites" (
++	"id" varchar(32) PRIMARY KEY NOT NULL,
++	"name" text NOT NULL,
++	"slug" text NOT NULL,
++	"ncit_code" text,
++	"uberon_id" text,
++	"parent_id" varchar(32),
++	"system" text
++);
++--> statement-breakpoint
++CREATE TABLE "cancer_aliases" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"cancer_id" varchar(32) NOT NULL,
++	"alias" text NOT NULL,
++	"normalized" text NOT NULL,
++	"alias_type" text DEFAULT 'synonym' NOT NULL,
++	"source_id" varchar(32),
++	"source_terminology" text,
++	"language" text DEFAULT 'en' NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "cancer_anatomy" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"cancer_id" varchar(32) NOT NULL,
++	"site_id" varchar(32) NOT NULL,
++	"relation" text DEFAULT 'primary' NOT NULL,
++	"source_id" varchar(32)
++);
++--> statement-breakpoint
++CREATE TABLE "cancer_codes" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"cancer_id" varchar(32) NOT NULL,
++	"system" text NOT NULL,
++	"code" text NOT NULL,
++	"match_type" text DEFAULT 'EXACT_IDENTIFIER' NOT NULL,
++	"source_id" varchar(32),
++	"valid_from" text,
++	"valid_to" text
++);
++--> statement-breakpoint
++CREATE TABLE "cancer_hierarchy" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"parent_id" varchar(32) NOT NULL,
++	"child_id" varchar(32) NOT NULL,
++	"hierarchy_type" text NOT NULL,
++	"source_id" varchar(32)
++);
++--> statement-breakpoint
++CREATE TABLE "cancers" (
++	"id" varchar(32) PRIMARY KEY NOT NULL,
++	"slug" text NOT NULL,
++	"canonical_name" text NOT NULL,
++	"short_name" text,
++	"entity_type" text DEFAULT 'cancer' NOT NULL,
++	"malignant" boolean DEFAULT true NOT NULL,
++	"solid_tumor" boolean DEFAULT true NOT NULL,
++	"hematologic" boolean DEFAULT false NOT NULL,
++	"pediatric_relevant" boolean DEFAULT false NOT NULL,
++	"rare_cancer" boolean,
++	"top_level" boolean DEFAULT false NOT NULL,
++	"description" text,
++	"description_provenance_id" integer,
++	"primary_ncit_code" text,
++	"primary_oncotree_code" text,
++	"depth" integer DEFAULT 0 NOT NULL,
++	"status" text DEFAULT 'active' NOT NULL,
++	"merged_into" varchar(32),
++	"deprecated_reason" text,
++	"classification_version" text,
++	"semantic_types" text[] DEFAULT '{}' NOT NULL,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "cohort_definitions" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"name" text NOT NULL,
++	"cancer_id" varchar(32) NOT NULL,
++	"biomarker_ids" text[] DEFAULT '{}' NOT NULL,
++	"variant_ids" text[] DEFAULT '{}' NOT NULL,
++	"stage" text,
++	"attributes" jsonb DEFAULT '{}'::jsonb NOT NULL,
++	"confidence" real,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "geographies" (
++	"id" varchar(32) PRIMARY KEY NOT NULL,
++	"slug" text NOT NULL,
++	"name" text NOT NULL,
++	"kind" text NOT NULL,
++	"iso2" text,
++	"iso3" text,
++	"parent_id" varchar(32),
++	"who_region" text,
++	"population" integer,
++	"population_year" integer
++);
++--> statement-breakpoint
++CREATE TABLE "biomarkers" (
++	"id" varchar(32) PRIMARY KEY NOT NULL,
++	"slug" text NOT NULL,
++	"name" text NOT NULL,
++	"kind" text NOT NULL,
++	"gene_id" varchar(32),
++	"ncit_code" text,
++	"description" text,
++	"measurement" jsonb DEFAULT '{}'::jsonb NOT NULL,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "cancer_gene_frequencies" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"cohort_id" varchar(32) NOT NULL,
++	"cancer_id" varchar(32),
++	"gene_id" varchar(32),
++	"gene_symbol" text NOT NULL,
++	"alteration_type" text DEFAULT 'ssm' NOT NULL,
++	"cases_affected" integer NOT NULL,
++	"cases_profiled" integer NOT NULL,
++	"frequency" real NOT NULL,
++	"rank" integer,
++	"data_release" text,
++	"provenance_id" integer NOT NULL,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "entity_embeddings" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"entity_type" text NOT NULL,
++	"entity_id" text NOT NULL,
++	"model" text NOT NULL,
++	"dimensions" integer NOT NULL,
++	"text_hash" text NOT NULL,
++	"embedding" text,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "gene_aliases" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"gene_id" varchar(32) NOT NULL,
++	"alias" text NOT NULL,
++	"alias_type" text NOT NULL,
++	"source_id" varchar(32)
++);
++--> statement-breakpoint
++CREATE TABLE "genes" (
++	"id" varchar(32) PRIMARY KEY NOT NULL,
++	"hgnc_id" text,
++	"symbol" text NOT NULL,
++	"name" text,
++	"locus_type" text,
++	"locus_group" text,
++	"location" text,
++	"chromosome" text,
++	"ensembl_gene_id" text,
++	"ncbi_gene_id" text,
++	"omim_ids" text[] DEFAULT '{}' NOT NULL,
++	"uniprot_ids" text[] DEFAULT '{}' NOT NULL,
++	"refseq_accession" text,
++	"prev_symbols" text[] DEFAULT '{}' NOT NULL,
++	"alias_symbols" text[] DEFAULT '{}' NOT NULL,
++	"gene_families" text[] DEFAULT '{}' NOT NULL,
++	"status" text DEFAULT 'Approved' NOT NULL,
++	"is_cancer_gene" boolean DEFAULT false NOT NULL,
++	"civic_gene_id" integer,
++	"description" text,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "genomic_cohorts" (
++	"id" varchar(32) PRIMARY KEY NOT NULL,
++	"source_id" varchar(32) NOT NULL,
++	"study_id" text NOT NULL,
++	"name" text NOT NULL,
++	"program" text,
++	"primary_sites" text[] DEFAULT '{}' NOT NULL,
++	"disease_types" text[] DEFAULT '{}' NOT NULL,
++	"cancer_id" varchar(32),
++	"cancer_match_type" text,
++	"case_count" integer,
++	"cases_with_ssm" integer,
++	"data_release" text,
++	"access_level" text DEFAULT 'open' NOT NULL,
++	"url" text,
++	"provenance_id" integer,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "variant_aliases" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"variant_id" varchar(32) NOT NULL,
++	"alias" text NOT NULL,
++	"source_id" varchar(32)
++);
++--> statement-breakpoint
++CREATE TABLE "variant_clinical_significance" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"variant_id" varchar(32) NOT NULL,
++	"clinvar_variation_id" text NOT NULL,
++	"clinical_significance" text NOT NULL,
++	"review_status" text,
++	"star_rating" integer,
++	"last_evaluated" text,
++	"conditions" text[] DEFAULT '{}' NOT NULL,
++	"condition_cancer_ids" text[] DEFAULT '{}' NOT NULL,
++	"origin_simple" text,
++	"number_submitters" integer,
++	"provenance_id" integer NOT NULL,
++	"ingest_run_id" text,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "variants" (
++	"id" varchar(32) PRIMARY KEY NOT NULL,
++	"slug" text NOT NULL,
++	"gene_id" varchar(32),
++	"gene_symbol" text,
++	"name" text NOT NULL,
++	"variant_type" text,
++	"hgvs_g" text,
++	"hgvs_c" text,
++	"hgvs_p" text,
++	"assembly" text,
++	"chromosome" text,
++	"start" integer,
++	"end" integer,
++	"reference_bases" text,
++	"alternate_bases" text,
++	"coordinates" jsonb DEFAULT '[]'::jsonb NOT NULL,
++	"clinvar_variation_id" text,
++	"civic_variant_id" integer,
++	"dbsnp_ids" text[] DEFAULT '{}' NOT NULL,
++	"fusion_partners" text[] DEFAULT '{}' NOT NULL,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "drug_aliases" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"drug_id" varchar(32) NOT NULL,
++	"alias" text NOT NULL,
++	"normalized" text NOT NULL,
++	"alias_type" text DEFAULT 'synonym' NOT NULL,
++	"source_id" varchar(32)
++);
++--> statement-breakpoint
++CREATE TABLE "drug_approvals" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"drug_id" varchar(32) NOT NULL,
++	"cancer_id" varchar(32),
++	"biomarker_ids" text[] DEFAULT '{}' NOT NULL,
++	"tumor_agnostic" boolean DEFAULT false NOT NULL,
++	"jurisdiction" text NOT NULL,
++	"authority" text NOT NULL,
++	"indication" text NOT NULL,
++	"line_of_therapy" text,
++	"disease_stage" text,
++	"approval_type" text,
++	"accelerated" boolean,
++	"conditional" boolean,
++	"approval_date" text,
++	"withdrawal_date" text,
++	"status" text NOT NULL,
++	"application_number" text,
++	"source_id" varchar(32) NOT NULL,
++	"provenance_id" integer NOT NULL,
++	"raw" jsonb,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "drugs" (
++	"id" varchar(32) PRIMARY KEY NOT NULL,
++	"slug" text NOT NULL,
++	"name" text NOT NULL,
++	"kind" text,
++	"ncit_code" text,
++	"chembl_id" text,
++	"civic_therapy_id" integer,
++	"drugbank_id" text,
++	"pubchem_cid" text,
++	"unii" text,
++	"mechanism" text,
++	"target_gene_ids" text[] DEFAULT '{}' NOT NULL,
++	"development_status" text,
++	"description" text,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "treatment_regimens" (
++	"id" varchar(32) PRIMARY KEY NOT NULL,
++	"slug" text NOT NULL,
++	"name" text NOT NULL,
++	"component_drug_ids" text[] DEFAULT '{}' NOT NULL,
++	"modality" text DEFAULT 'drug_combination' NOT NULL,
++	"description" text,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "clinical_trials" (
++	"id" varchar(32) PRIMARY KEY NOT NULL,
++	"nct_id" text NOT NULL,
++	"brief_title" text NOT NULL,
++	"official_title" text,
++	"acronym" text,
++	"study_type" text,
++	"phases" text[] DEFAULT '{}' NOT NULL,
++	"overall_status" text,
++	"why_stopped" text,
++	"start_date" text,
++	"primary_completion_date" text,
++	"completion_date" text,
++	"first_posted_date" text,
++	"last_update_posted_date" text,
++	"results_first_posted_date" text,
++	"has_results" boolean DEFAULT false NOT NULL,
++	"enrollment_count" integer,
++	"enrollment_type" text,
++	"lead_sponsor" text,
++	"lead_sponsor_class" text,
++	"collaborators" text[] DEFAULT '{}' NOT NULL,
++	"conditions" text[] DEFAULT '{}' NOT NULL,
++	"keywords" text[] DEFAULT '{}' NOT NULL,
++	"interventions" jsonb DEFAULT '[]'::jsonb NOT NULL,
++	"arms" jsonb DEFAULT '[]'::jsonb NOT NULL,
++	"primary_outcomes" jsonb DEFAULT '[]'::jsonb NOT NULL,
++	"secondary_outcomes" jsonb DEFAULT '[]'::jsonb NOT NULL,
++	"eligibility" jsonb DEFAULT '{}'::jsonb NOT NULL,
++	"sex" text,
++	"minimum_age" text,
++	"maximum_age" text,
++	"countries" text[] DEFAULT '{}' NOT NULL,
++	"locations_count" integer DEFAULT 0 NOT NULL,
++	"references" jsonb DEFAULT '[]'::jsonb NOT NULL,
++	"brief_summary" text,
++	"is_oncology" boolean DEFAULT true NOT NULL,
++	"source_record_id" integer,
++	"ingest_run_id" text,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "trial_conditions" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"trial_id" varchar(32) NOT NULL,
++	"condition_text" text NOT NULL,
++	"normalized" text NOT NULL,
++	"cancer_id" varchar(32),
++	"match_type" text DEFAULT 'UNRESOLVED' NOT NULL,
++	"confidence" real
++);
++--> statement-breakpoint
++CREATE TABLE "trial_interventions" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"trial_id" varchar(32) NOT NULL,
++	"name" text NOT NULL,
++	"normalized" text NOT NULL,
++	"intervention_type" text,
++	"drug_id" varchar(32),
++	"match_type" text DEFAULT 'UNRESOLVED' NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "trial_locations" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"trial_id" varchar(32) NOT NULL,
++	"facility" text,
++	"city" text,
++	"state" text,
++	"zip" text,
++	"country" text,
++	"status" text,
++	"lat" real,
++	"lng" real
++);
++--> statement-breakpoint
++CREATE TABLE "trial_pulse" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"day" date NOT NULL,
++	"cancer_id" varchar(32),
++	"phase" text,
++	"new_trials" integer NOT NULL,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "literature_counts" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"cancer_id" varchar(32) NOT NULL,
++	"window_key" text NOT NULL,
++	"window_start" text,
++	"window_end" text,
++	"query" text NOT NULL,
++	"count" integer NOT NULL,
++	"provenance_id" integer NOT NULL,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "publication_entity_edges" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"publication_id" varchar(32) NOT NULL,
++	"entity_type" text NOT NULL,
++	"entity_id" text NOT NULL,
++	"method" text NOT NULL,
++	"confidence" real,
++	"status" text DEFAULT 'candidate' NOT NULL,
++	"source_id" varchar(32),
++	"ingest_run_id" text,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "publications" (
++	"id" varchar(32) PRIMARY KEY NOT NULL,
++	"pmid" text,
++	"doi" text,
++	"pmcid" text,
++	"title" text NOT NULL,
++	"abstract" text,
++	"journal" text,
++	"journal_iso" text,
++	"pub_date" text,
++	"pub_year" integer,
++	"publication_types" text[] DEFAULT '{}' NOT NULL,
++	"mesh_terms" jsonb DEFAULT '[]'::jsonb NOT NULL,
++	"authors" jsonb DEFAULT '[]'::jsonb NOT NULL,
++	"language" text,
++	"is_preprint" boolean DEFAULT false NOT NULL,
++	"retracted" boolean DEFAULT false NOT NULL,
++	"retraction_notice" text,
++	"nct_ids" text[] DEFAULT '{}' NOT NULL,
++	"cited_by_count" integer,
++	"source_record_id" integer,
++	"ingest_run_id" text,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "civic_evidence_items" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"civic_id" integer NOT NULL,
++	"name" text,
++	"molecular_profile_id" integer,
++	"molecular_profile_name" text,
++	"gene_symbols" text[] DEFAULT '{}' NOT NULL,
++	"gene_ids" text[] DEFAULT '{}' NOT NULL,
++	"variant_ids" text[] DEFAULT '{}' NOT NULL,
++	"civic_variant_ids" integer[] DEFAULT '{}' NOT NULL,
++	"disease_name" text,
++	"doid" text,
++	"cancer_id" varchar(32),
++	"cancer_match_type" text,
++	"therapy_names" text[] DEFAULT '{}' NOT NULL,
++	"therapy_ids" text[] DEFAULT '{}' NOT NULL,
++	"therapy_interaction_type" text,
++	"evidence_type" text,
++	"evidence_level" text,
++	"evidence_direction" text,
++	"significance" text,
++	"evidence_rating" integer,
++	"status" text,
++	"description" text,
++	"pmid" text,
++	"source_citation" text,
++	"phenotypes" text[] DEFAULT '{}' NOT NULL,
++	"provenance_id" integer NOT NULL,
++	"ingest_run_id" text,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "knowledge_edges" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"source_entity_type" text NOT NULL,
++	"source_entity_id" text NOT NULL,
++	"target_entity_type" text NOT NULL,
++	"target_entity_id" text NOT NULL,
++	"relationship_type" text NOT NULL,
++	"cancer_context_ids" text[] DEFAULT '{}' NOT NULL,
++	"predictive" boolean,
++	"prognostic" boolean,
++	"diagnostic" boolean,
++	"predisposing" boolean,
++	"direction" text,
++	"evidence_level" text,
++	"evidence_score" real,
++	"evidence_category" text DEFAULT 'curated_evidence' NOT NULL,
++	"status" text DEFAULT 'active' NOT NULL,
++	"source_id" varchar(32) NOT NULL,
++	"source_record_id" text,
++	"provenance_ids" integer[] DEFAULT '{}' NOT NULL,
++	"support_count" integer DEFAULT 1 NOT NULL,
++	"first_seen_at" timestamp with time zone DEFAULT now() NOT NULL,
++	"last_seen_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "risk_factors" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"slug" text NOT NULL,
++	"name" text NOT NULL,
++	"kind" text NOT NULL,
++	"classification_authority" text,
++	"classification" text,
++	"description" text,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "epidemiology_observations" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"cancer_id" varchar(32) NOT NULL,
++	"geography_id" varchar(32) NOT NULL,
++	"year" integer NOT NULL,
++	"year_end" integer,
++	"sex" text DEFAULT 'all' NOT NULL,
++	"age_group" text DEFAULT 'all' NOT NULL,
++	"metric" text NOT NULL,
++	"value" double precision NOT NULL,
++	"unit" text NOT NULL,
++	"lower_ci" double precision,
++	"upper_ci" double precision,
++	"standard_population" text,
++	"estimate_type" text DEFAULT 'observed' NOT NULL,
++	"site_definition" text,
++	"source_id" varchar(32) NOT NULL,
++	"provenance_id" integer NOT NULL,
++	"ingest_run_id" text,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "survival_observations" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"cancer_id" varchar(32) NOT NULL,
++	"geography_id" varchar(32),
++	"stage" text,
++	"staging_system" text,
++	"sex" text DEFAULT 'all' NOT NULL,
++	"age_group" text DEFAULT 'all' NOT NULL,
++	"diagnosis_period" text,
++	"survival_type" text NOT NULL,
++	"duration_months" integer NOT NULL,
++	"probability" real,
++	"median_months" real,
++	"cohort_size" integer,
++	"lower_ci" real,
++	"upper_ci" real,
++	"method" text,
++	"source_id" varchar(32) NOT NULL,
++	"provenance_id" integer NOT NULL,
++	"ingest_run_id" text,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "ai_answers" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"kind" text NOT NULL,
++	"subject_id" text,
++	"question_hash" text NOT NULL,
++	"question" text,
++	"answer" jsonb NOT NULL,
++	"model" text NOT NULL,
++	"prompt_version" text NOT NULL,
++	"source_snapshot" jsonb DEFAULT '{}'::jsonb NOT NULL,
++	"data_as_of" timestamp with time zone NOT NULL,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "api_keys" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"key_hash" text NOT NULL,
++	"prefix" text NOT NULL,
++	"label" text,
++	"owner_email" text,
++	"tier" text DEFAULT 'free' NOT NULL,
++	"rate_limit_per_minute" integer DEFAULT 60 NOT NULL,
++	"active" boolean DEFAULT true NOT NULL,
++	"last_used_at" timestamp with time zone,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "entity_counters" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"entity_type" text NOT NULL,
++	"entity_id" text NOT NULL,
++	"trial_count" integer DEFAULT 0 NOT NULL,
++	"active_trial_count" integer DEFAULT 0 NOT NULL,
++	"recruiting_trial_count" integer DEFAULT 0 NOT NULL,
++	"phase3_trial_count" integer DEFAULT 0 NOT NULL,
++	"publication_count" integer DEFAULT 0 NOT NULL,
++	"publication_count_5y" integer DEFAULT 0 NOT NULL,
++	"publication_count_12m" integer DEFAULT 0 NOT NULL,
++	"gene_count" integer DEFAULT 0 NOT NULL,
++	"variant_count" integer DEFAULT 0 NOT NULL,
++	"drug_count" integer DEFAULT 0 NOT NULL,
++	"approved_drug_count" integer DEFAULT 0 NOT NULL,
++	"evidence_count" integer DEFAULT 0 NOT NULL,
++	"cohort_count" integer DEFAULT 0 NOT NULL,
++	"subtype_count" integer DEFAULT 0 NOT NULL,
++	"descendant_count" integer DEFAULT 0 NOT NULL,
++	"epidemiology_obs_count" integer DEFAULT 0 NOT NULL,
++	"survival_obs_count" integer DEFAULT 0 NOT NULL,
++	"completeness" jsonb DEFAULT '{}'::jsonb NOT NULL,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "metric_definitions" (
++	"id" varchar(32) PRIMARY KEY NOT NULL,
++	"slug" text NOT NULL,
++	"name" text NOT NULL,
++	"description" text NOT NULL,
++	"formula" text NOT NULL,
++	"formula_version" text NOT NULL,
++	"unit" text NOT NULL,
++	"higher_is_worse" boolean,
++	"aggregation" text,
++	"valid_dimensions" text[] DEFAULT '{}' NOT NULL,
++	"source_slugs" text[] DEFAULT '{}' NOT NULL,
++	"category" text NOT NULL,
++	"eligibility" jsonb DEFAULT '{}'::jsonb NOT NULL,
++	"experimental" boolean DEFAULT false NOT NULL,
++	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
++	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "ranking_snapshots" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"metric_id" varchar(32) NOT NULL,
++	"metric_slug" text NOT NULL,
++	"scope_key" text NOT NULL,
++	"geography" text DEFAULT 'WORLD' NOT NULL,
++	"sex" text DEFAULT 'all' NOT NULL,
++	"age_group" text DEFAULT 'all' NOT NULL,
++	"year" integer,
++	"entity_level" text DEFAULT 'top' NOT NULL,
++	"formula_version" text NOT NULL,
++	"eligible_entities" integer NOT NULL,
++	"inputs_hash" text NOT NULL,
++	"source_ids" text[] DEFAULT '{}' NOT NULL,
++	"is_current" boolean DEFAULT true NOT NULL,
++	"generated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE TABLE "rankings" (
++	"id" bigserial PRIMARY KEY NOT NULL,
++	"snapshot_id" integer NOT NULL,
++	"metric_slug" text NOT NULL,
++	"scope_key" text NOT NULL,
++	"cancer_id" varchar(32) NOT NULL,
++	"rank" integer NOT NULL,
++	"eligible_entities" integer NOT NULL,
++	"percentile" real NOT NULL,
++	"value" double precision NOT NULL,
++	"unit" text NOT NULL,
++	"confidence" text DEFAULT 'MEDIUM' NOT NULL,
++	"inputs" jsonb DEFAULT '{}'::jsonb NOT NULL,
++	"breakdown" jsonb,
++	"previous_rank" integer,
++	"generated_at" timestamp with time zone DEFAULT now() NOT NULL
++);
++--> statement-breakpoint
++CREATE INDEX "change_events_entity_idx" ON "change_events" USING btree ("entity_type","entity_id","created_at");--> statement-breakpoint
++CREATE UNIQUE INDEX "connector_field_stats_uq" ON "connector_field_stats" USING btree ("connector_id","entity","field");--> statement-breakpoint
++CREATE INDEX "ingest_runs_connector_idx" ON "ingest_runs" USING btree ("connector_id","started_at");--> statement-breakpoint
++CREATE INDEX "provenance_source_idx" ON "provenance" USING btree ("source_id","source_record_id");--> statement-breakpoint
++CREATE INDEX "provenance_pmid_idx" ON "provenance" USING btree ("pmid");--> statement-breakpoint
++CREATE UNIQUE INDEX "source_records_uq" ON "source_records" USING btree ("source_id","entity_kind","source_record_id");--> statement-breakpoint
++CREATE INDEX "source_records_canonical_idx" ON "source_records" USING btree ("canonical_type","canonical_id");--> statement-breakpoint
++CREATE UNIQUE INDEX "sources_slug_uq" ON "sources" USING btree ("slug");--> statement-breakpoint
++CREATE UNIQUE INDEX "unresolved_labels_uq" ON "unresolved_labels" USING btree ("source_id","entity_kind","normalized");--> statement-breakpoint
++CREATE INDEX "unresolved_labels_count_idx" ON "unresolved_labels" USING btree ("status","count");--> statement-breakpoint
++CREATE UNIQUE INDEX "anatomical_sites_slug_uq" ON "anatomical_sites" USING btree ("slug");--> statement-breakpoint
++CREATE UNIQUE INDEX "cancer_aliases_uq" ON "cancer_aliases" USING btree ("cancer_id","normalized","alias_type");--> statement-breakpoint
++CREATE INDEX "cancer_aliases_norm_idx" ON "cancer_aliases" USING btree ("normalized");--> statement-breakpoint
++CREATE UNIQUE INDEX "cancer_anatomy_uq" ON "cancer_anatomy" USING btree ("cancer_id","site_id","relation");--> statement-breakpoint
++CREATE UNIQUE INDEX "cancer_codes_uq" ON "cancer_codes" USING btree ("cancer_id","system","code");--> statement-breakpoint
++CREATE INDEX "cancer_codes_lookup_idx" ON "cancer_codes" USING btree ("system","code");--> statement-breakpoint
++CREATE UNIQUE INDEX "cancer_hierarchy_uq" ON "cancer_hierarchy" USING btree ("parent_id","child_id","hierarchy_type");--> statement-breakpoint
++CREATE INDEX "cancer_hierarchy_child_idx" ON "cancer_hierarchy" USING btree ("child_id");--> statement-breakpoint
++CREATE UNIQUE INDEX "cancers_slug_uq" ON "cancers" USING btree ("slug");--> statement-breakpoint
++CREATE UNIQUE INDEX "cancers_ncit_uq" ON "cancers" USING btree ("primary_ncit_code");--> statement-breakpoint
++CREATE INDEX "cancers_name_idx" ON "cancers" USING btree ("canonical_name");--> statement-breakpoint
++CREATE INDEX "cancers_type_idx" ON "cancers" USING btree ("entity_type","malignant","top_level");--> statement-breakpoint
++CREATE UNIQUE INDEX "geographies_slug_uq" ON "geographies" USING btree ("slug");--> statement-breakpoint
++CREATE INDEX "geographies_iso3_idx" ON "geographies" USING btree ("iso3");--> statement-breakpoint
++CREATE UNIQUE INDEX "biomarkers_slug_uq" ON "biomarkers" USING btree ("slug");--> statement-breakpoint
++CREATE UNIQUE INDEX "cancer_gene_freq_uq" ON "cancer_gene_frequencies" USING btree ("cohort_id","gene_symbol","alteration_type");--> statement-breakpoint
++CREATE INDEX "cancer_gene_freq_cancer_idx" ON "cancer_gene_frequencies" USING btree ("cancer_id","frequency");--> statement-breakpoint
++CREATE INDEX "cancer_gene_freq_gene_idx" ON "cancer_gene_frequencies" USING btree ("gene_id");--> statement-breakpoint
++CREATE UNIQUE INDEX "entity_embeddings_uq" ON "entity_embeddings" USING btree ("entity_type","entity_id","model");--> statement-breakpoint
++CREATE UNIQUE INDEX "gene_aliases_uq" ON "gene_aliases" USING btree ("gene_id","alias","alias_type");--> statement-breakpoint
++CREATE INDEX "gene_aliases_alias_idx" ON "gene_aliases" USING btree ("alias");--> statement-breakpoint
++CREATE UNIQUE INDEX "genes_symbol_uq" ON "genes" USING btree ("symbol");--> statement-breakpoint
++CREATE UNIQUE INDEX "genes_hgnc_uq" ON "genes" USING btree ("hgnc_id");--> statement-breakpoint
++CREATE INDEX "genes_ensembl_idx" ON "genes" USING btree ("ensembl_gene_id");--> statement-breakpoint
++CREATE INDEX "genes_ncbi_idx" ON "genes" USING btree ("ncbi_gene_id");--> statement-breakpoint
++CREATE UNIQUE INDEX "genomic_cohorts_uq" ON "genomic_cohorts" USING btree ("source_id","study_id");--> statement-breakpoint
++CREATE INDEX "genomic_cohorts_cancer_idx" ON "genomic_cohorts" USING btree ("cancer_id");--> statement-breakpoint
++CREATE UNIQUE INDEX "variant_aliases_uq" ON "variant_aliases" USING btree ("variant_id","alias");--> statement-breakpoint
++CREATE UNIQUE INDEX "variant_clinsig_uq" ON "variant_clinical_significance" USING btree ("clinvar_variation_id");--> statement-breakpoint
++CREATE UNIQUE INDEX "variants_slug_uq" ON "variants" USING btree ("slug");--> statement-breakpoint
++CREATE INDEX "variants_gene_idx" ON "variants" USING btree ("gene_id");--> statement-breakpoint
++CREATE INDEX "variants_clinvar_idx" ON "variants" USING btree ("clinvar_variation_id");--> statement-breakpoint
++CREATE INDEX "variants_civic_idx" ON "variants" USING btree ("civic_variant_id");--> statement-breakpoint
++CREATE UNIQUE INDEX "drug_aliases_uq" ON "drug_aliases" USING btree ("drug_id","normalized","alias_type");--> statement-breakpoint
++CREATE INDEX "drug_aliases_norm_idx" ON "drug_aliases" USING btree ("normalized");--> statement-breakpoint
++CREATE INDEX "drug_approvals_drug_idx" ON "drug_approvals" USING btree ("drug_id");--> statement-breakpoint
++CREATE INDEX "drug_approvals_cancer_idx" ON "drug_approvals" USING btree ("cancer_id");--> statement-breakpoint
++CREATE UNIQUE INDEX "drugs_slug_uq" ON "drugs" USING btree ("slug");--> statement-breakpoint
++CREATE INDEX "drugs_ncit_idx" ON "drugs" USING btree ("ncit_code");--> statement-breakpoint
++CREATE INDEX "drugs_civic_idx" ON "drugs" USING btree ("civic_therapy_id");--> statement-breakpoint
++CREATE INDEX "drugs_chembl_idx" ON "drugs" USING btree ("chembl_id");--> statement-breakpoint
++CREATE UNIQUE INDEX "treatment_regimens_slug_uq" ON "treatment_regimens" USING btree ("slug");--> statement-breakpoint
++CREATE UNIQUE INDEX "clinical_trials_nct_uq" ON "clinical_trials" USING btree ("nct_id");--> statement-breakpoint
++CREATE INDEX "clinical_trials_status_idx" ON "clinical_trials" USING btree ("overall_status");--> statement-breakpoint
++CREATE INDEX "clinical_trials_updated_idx" ON "clinical_trials" USING btree ("last_update_posted_date");--> statement-breakpoint
++CREATE INDEX "clinical_trials_sponsor_idx" ON "clinical_trials" USING btree ("lead_sponsor");--> statement-breakpoint
++CREATE UNIQUE INDEX "trial_conditions_uq" ON "trial_conditions" USING btree ("trial_id","normalized");--> statement-breakpoint
++CREATE INDEX "trial_conditions_cancer_idx" ON "trial_conditions" USING btree ("cancer_id");--> statement-breakpoint
++CREATE INDEX "trial_conditions_norm_idx" ON "trial_conditions" USING btree ("normalized");--> statement-breakpoint
++CREATE UNIQUE INDEX "trial_interventions_uq" ON "trial_interventions" USING btree ("trial_id","normalized");--> statement-breakpoint
++CREATE INDEX "trial_interventions_drug_idx" ON "trial_interventions" USING btree ("drug_id");--> statement-breakpoint
++CREATE INDEX "trial_locations_trial_idx" ON "trial_locations" USING btree ("trial_id");--> statement-breakpoint
++CREATE INDEX "trial_locations_country_idx" ON "trial_locations" USING btree ("country");--> statement-breakpoint
++CREATE UNIQUE INDEX "trial_pulse_uq" ON "trial_pulse" USING btree ("day","cancer_id","phase");--> statement-breakpoint
++CREATE UNIQUE INDEX "literature_counts_uq" ON "literature_counts" USING btree ("cancer_id","window_key");--> statement-breakpoint
++CREATE INDEX "literature_counts_window_idx" ON "literature_counts" USING btree ("window_key","count");--> statement-breakpoint
++CREATE UNIQUE INDEX "pub_entity_edges_uq" ON "publication_entity_edges" USING btree ("publication_id","entity_type","entity_id","method");--> statement-breakpoint
++CREATE INDEX "pub_entity_edges_entity_idx" ON "publication_entity_edges" USING btree ("entity_type","entity_id");--> statement-breakpoint
++CREATE UNIQUE INDEX "publications_pmid_uq" ON "publications" USING btree ("pmid");--> statement-breakpoint
++CREATE INDEX "publications_doi_idx" ON "publications" USING btree ("doi");--> statement-breakpoint
++CREATE INDEX "publications_year_idx" ON "publications" USING btree ("pub_year");--> statement-breakpoint
++CREATE INDEX "publications_retracted_idx" ON "publications" USING btree ("retracted");--> statement-breakpoint
++CREATE UNIQUE INDEX "civic_evidence_uq" ON "civic_evidence_items" USING btree ("civic_id");--> statement-breakpoint
++CREATE INDEX "civic_evidence_cancer_idx" ON "civic_evidence_items" USING btree ("cancer_id");--> statement-breakpoint
++CREATE INDEX "civic_evidence_gene_idx" ON "civic_evidence_items" USING btree ("gene_symbols");--> statement-breakpoint
++CREATE UNIQUE INDEX "knowledge_edges_uq" ON "knowledge_edges" USING btree ("source_entity_type","source_entity_id","target_entity_type","target_entity_id","relationship_type","source_id","source_record_id");--> statement-breakpoint
++CREATE INDEX "knowledge_edges_source_idx" ON "knowledge_edges" USING btree ("source_entity_type","source_entity_id","relationship_type");--> statement-breakpoint
++CREATE INDEX "knowledge_edges_target_idx" ON "knowledge_edges" USING btree ("target_entity_type","target_entity_id","relationship_type");--> statement-breakpoint
++CREATE UNIQUE INDEX "risk_factors_slug_uq" ON "risk_factors" USING btree ("slug");--> statement-breakpoint
++CREATE UNIQUE INDEX "epi_obs_uq" ON "epidemiology_observations" USING btree ("cancer_id","geography_id","year","sex","age_group","metric","source_id","site_definition");--> statement-breakpoint
++CREATE INDEX "epi_obs_lookup_idx" ON "epidemiology_observations" USING btree ("metric","geography_id","year","sex");--> statement-breakpoint
++CREATE INDEX "epi_obs_cancer_idx" ON "epidemiology_observations" USING btree ("cancer_id","metric");--> statement-breakpoint
++CREATE INDEX "survival_obs_cancer_idx" ON "survival_observations" USING btree ("cancer_id","survival_type","duration_months");--> statement-breakpoint
++CREATE UNIQUE INDEX "ai_answers_uq" ON "ai_answers" USING btree ("kind","question_hash","prompt_version");--> statement-breakpoint
++CREATE UNIQUE INDEX "api_keys_hash_uq" ON "api_keys" USING btree ("key_hash");--> statement-breakpoint
++CREATE UNIQUE INDEX "entity_counters_uq" ON "entity_counters" USING btree ("entity_type","entity_id");--> statement-breakpoint
++CREATE INDEX "entity_counters_trials_idx" ON "entity_counters" USING btree ("entity_type","active_trial_count");--> statement-breakpoint
++CREATE UNIQUE INDEX "metric_definitions_slug_uq" ON "metric_definitions" USING btree ("slug");--> statement-breakpoint
++CREATE INDEX "ranking_snapshots_lookup_idx" ON "ranking_snapshots" USING btree ("metric_slug","scope_key","is_current");--> statement-breakpoint
++CREATE UNIQUE INDEX "rankings_uq" ON "rankings" USING btree ("snapshot_id","cancer_id");--> statement-breakpoint
++CREATE INDEX "rankings_cancer_idx" ON "rankings" USING btree ("cancer_id","metric_slug");--> statement-breakpoint
++CREATE INDEX "rankings_lookup_idx" ON "rankings" USING btree ("metric_slug","scope_key","rank");
+ \ No newline at end of file

added packages/database/migrations/meta/0000_snapshot.json +6918 −0

++{
++  "id": "7cee03f3-3bb2-47c2-b164-ea15161ffedd",
++  "prevId": "00000000-0000-0000-0000-000000000000",
++  "version": "7",
++  "dialect": "postgresql",
++  "tables": {
++    "public.audit_log": {
++      "name": "audit_log",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "actor": {
++          "name": "actor",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "action": {
++          "name": "action",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "entity_type": {
++          "name": "entity_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "entity_id": {
++          "name": "entity_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "before": {
++          "name": "before",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "after": {
++          "name": "after",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "reason": {
++          "name": "reason",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {},
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.change_events": {
++      "name": "change_events",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "entity_type": {
++          "name": "entity_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "entity_id": {
++          "name": "entity_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "kind": {
++          "name": "kind",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "summary": {
++          "name": "summary",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "before": {
++          "name": "before",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "after": {
++          "name": "after",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "ingest_run_id": {
++          "name": "ingest_run_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "change_events_entity_idx": {
++          "name": "change_events_entity_idx",
++          "columns": [
++            {
++              "expression": "entity_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "entity_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "created_at",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.connector_cursors": {
++      "name": "connector_cursors",
++      "schema": "",
++      "columns": {
++        "connector_id": {
++          "name": "connector_id",
++          "type": "text",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "cursor": {
++          "name": "cursor",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'::jsonb"
++        },
++        "last_success_at": {
++          "name": "last_success_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "last_attempt_at": {
++          "name": "last_attempt_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "paused": {
++          "name": "paused",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": true,
++          "default": false
++        },
++        "health": {
++          "name": "health",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'unknown'"
++        },
++        "health_detail": {
++          "name": "health_detail",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {},
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.connector_field_stats": {
++      "name": "connector_field_stats",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "connector_id": {
++          "name": "connector_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "entity": {
++          "name": "entity",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "field": {
++          "name": "field",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "types": {
++          "name": "types",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "seen_count": {
++          "name": "seen_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "null_count": {
++          "name": "null_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "first_seen_run": {
++          "name": "first_seen_run",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "last_seen_run": {
++          "name": "last_seen_run",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "connector_field_stats_uq": {
++          "name": "connector_field_stats_uq",
++          "columns": [
++            {
++              "expression": "connector_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "entity",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "field",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.entity_merges": {
++      "name": "entity_merges",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "entity_type": {
++          "name": "entity_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "keep_id": {
++          "name": "keep_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "merge_id": {
++          "name": "merge_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "evidence": {
++          "name": "evidence",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'::jsonb"
++        },
++        "status": {
++          "name": "status",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'proposed'"
++        },
++        "decided_by": {
++          "name": "decided_by",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "decided_at": {
++          "name": "decided_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {},
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.id_sequences": {
++      "name": "id_sequences",
++      "schema": "",
++      "columns": {
++        "namespace": {
++          "name": "namespace",
++          "type": "varchar(16)",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "next": {
++          "name": "next",
++          "type": "bigint",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 1
++        }
++      },
++      "indexes": {},
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.ingest_runs": {
++      "name": "ingest_runs",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "text",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "connector_id": {
++          "name": "connector_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "source_id": {
++          "name": "source_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "mode": {
++          "name": "mode",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'incremental'"
++        },
++        "status": {
++          "name": "status",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'running'"
++        },
++        "started_at": {
++          "name": "started_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        },
++        "finished_at": {
++          "name": "finished_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "duration_ms": {
++          "name": "duration_ms",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "records_fetched": {
++          "name": "records_fetched",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "records_created": {
++          "name": "records_created",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "records_updated": {
++          "name": "records_updated",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "records_unchanged": {
++          "name": "records_unchanged",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "records_rejected": {
++          "name": "records_rejected",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "http_requests": {
++          "name": "http_requests",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "http_failures": {
++          "name": "http_failures",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "rate_limit_events": {
++          "name": "rate_limit_events",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "validation_failures": {
++          "name": "validation_failures",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "schema_drift": {
++          "name": "schema_drift",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'[]'::jsonb"
++        },
++        "cursor_before": {
++          "name": "cursor_before",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "cursor_after": {
++          "name": "cursor_after",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "error": {
++          "name": "error",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "log": {
++          "name": "log",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'[]'::jsonb"
++        },
++        "dataset_version": {
++          "name": "dataset_version",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "anomaly": {
++          "name": "anomaly",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        }
++      },
++      "indexes": {
++        "ingest_runs_connector_idx": {
++          "name": "ingest_runs_connector_idx",
++          "columns": [
++            {
++              "expression": "connector_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "started_at",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.provenance": {
++      "name": "provenance",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "public_id": {
++          "name": "public_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "source_id": {
++          "name": "source_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "source_record_id": {
++          "name": "source_record_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "source_url": {
++          "name": "source_url",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "dataset": {
++          "name": "dataset",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "dataset_version": {
++          "name": "dataset_version",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "publication_id": {
++          "name": "publication_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "pmid": {
++          "name": "pmid",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "doi": {
++          "name": "doi",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "retrieved_at": {
++          "name": "retrieved_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "published_at": {
++          "name": "published_at",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "updated_at_source": {
++          "name": "updated_at_source",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "geography": {
++          "name": "geography",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "population": {
++          "name": "population",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "cohort_size": {
++          "name": "cohort_size",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "methodology": {
++          "name": "methodology",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "evidence_type": {
++          "name": "evidence_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "access_level": {
++          "name": "access_level",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'open'"
++        },
++        "confidence": {
++          "name": "confidence",
++          "type": "real",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "license": {
++          "name": "license",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "ingest_run_id": {
++          "name": "ingest_run_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "provenance_source_idx": {
++          "name": "provenance_source_idx",
++          "columns": [
++            {
++              "expression": "source_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "source_record_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "provenance_pmid_idx": {
++          "name": "provenance_pmid_idx",
++          "columns": [
++            {
++              "expression": "pmid",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.source_records": {
++      "name": "source_records",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "source_id": {
++          "name": "source_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "entity_kind": {
++          "name": "entity_kind",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "source_record_id": {
++          "name": "source_record_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "payload_hash": {
++          "name": "payload_hash",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "raw_path": {
++          "name": "raw_path",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "status": {
++          "name": "status",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'active'"
++        },
++        "first_seen_run": {
++          "name": "first_seen_run",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "last_seen_run": {
++          "name": "last_seen_run",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "retrieved_at": {
++          "name": "retrieved_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        },
++        "source_updated_at": {
++          "name": "source_updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "canonical_type": {
++          "name": "canonical_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "canonical_id": {
++          "name": "canonical_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "source_records_uq": {
++          "name": "source_records_uq",
++          "columns": [
++            {
++              "expression": "source_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "entity_kind",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "source_record_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "source_records_canonical_idx": {
++          "name": "source_records_canonical_idx",
++          "columns": [
++            {
++              "expression": "canonical_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "canonical_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.sources": {
++      "name": "sources",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "varchar(32)",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "slug": {
++          "name": "slug",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "name": {
++          "name": "name",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "organization": {
++          "name": "organization",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "category": {
++          "name": "category",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "description": {
++          "name": "description",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "homepage": {
++          "name": "homepage",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "docs_url": {
++          "name": "docs_url",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "terms_url": {
++          "name": "terms_url",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "access_type": {
++          "name": "access_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "access_auth": {
++          "name": "access_auth",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "license": {
++          "name": "license",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "license_status": {
++          "name": "license_status",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'review'"
++        },
++        "commercial_use": {
++          "name": "commercial_use",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'unknown'"
++        },
++        "redistribution": {
++          "name": "redistribution",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'unknown'"
++        },
++        "attribution": {
++          "name": "attribution",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "license_reviewed_at": {
++          "name": "license_reviewed_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "approved_for_production": {
++          "name": "approved_for_production",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": true,
++          "default": false
++        },
++        "update_frequency": {
++          "name": "update_frequency",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "supports_incremental": {
++          "name": "supports_incremental",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": true,
++          "default": false
++        },
++        "entities": {
++          "name": "entities",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "metrics": {
++          "name": "metrics",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "rate_limit": {
++          "name": "rate_limit",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "status": {
++          "name": "status",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'planned'"
++        },
++        "tier": {
++          "name": "tier",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "manifest": {
++          "name": "manifest",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'::jsonb"
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "sources_slug_uq": {
++          "name": "sources_slug_uq",
++          "columns": [
++            {
++              "expression": "slug",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.unresolved_labels": {
++      "name": "unresolved_labels",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "source_id": {
++          "name": "source_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "entity_kind": {
++          "name": "entity_kind",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "source_text": {
++          "name": "source_text",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "normalized": {
++          "name": "normalized",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "context": {
++          "name": "context",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'::jsonb"
++        },
++        "count": {
++          "name": "count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 1
++        },
++        "status": {
++          "name": "status",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'open'"
++        },
++        "suggested_id": {
++          "name": "suggested_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "suggested_match_type": {
++          "name": "suggested_match_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "suggested_score": {
++          "name": "suggested_score",
++          "type": "real",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "resolved_id": {
++          "name": "resolved_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "resolved_by": {
++          "name": "resolved_by",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "unresolved_labels_uq": {
++          "name": "unresolved_labels_uq",
++          "columns": [
++            {
++              "expression": "source_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "entity_kind",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "normalized",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "unresolved_labels_count_idx": {
++          "name": "unresolved_labels_count_idx",
++          "columns": [
++            {
++              "expression": "status",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "count",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.anatomical_sites": {
++      "name": "anatomical_sites",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "varchar(32)",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "name": {
++          "name": "name",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "slug": {
++          "name": "slug",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "ncit_code": {
++          "name": "ncit_code",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "uberon_id": {
++          "name": "uberon_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "parent_id": {
++          "name": "parent_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "system": {
++          "name": "system",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        }
++      },
++      "indexes": {
++        "anatomical_sites_slug_uq": {
++          "name": "anatomical_sites_slug_uq",
++          "columns": [
++            {
++              "expression": "slug",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.cancer_aliases": {
++      "name": "cancer_aliases",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "cancer_id": {
++          "name": "cancer_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "alias": {
++          "name": "alias",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "normalized": {
++          "name": "normalized",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "alias_type": {
++          "name": "alias_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'synonym'"
++        },
++        "source_id": {
++          "name": "source_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "source_terminology": {
++          "name": "source_terminology",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "language": {
++          "name": "language",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'en'"
++        }
++      },
++      "indexes": {
++        "cancer_aliases_uq": {
++          "name": "cancer_aliases_uq",
++          "columns": [
++            {
++              "expression": "cancer_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "normalized",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "alias_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "cancer_aliases_norm_idx": {
++          "name": "cancer_aliases_norm_idx",
++          "columns": [
++            {
++              "expression": "normalized",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.cancer_anatomy": {
++      "name": "cancer_anatomy",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "cancer_id": {
++          "name": "cancer_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "site_id": {
++          "name": "site_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "relation": {
++          "name": "relation",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'primary'"
++        },
++        "source_id": {
++          "name": "source_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        }
++      },
++      "indexes": {
++        "cancer_anatomy_uq": {
++          "name": "cancer_anatomy_uq",
++          "columns": [
++            {
++              "expression": "cancer_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "site_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "relation",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.cancer_codes": {
++      "name": "cancer_codes",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "cancer_id": {
++          "name": "cancer_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "system": {
++          "name": "system",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "code": {
++          "name": "code",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "match_type": {
++          "name": "match_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'EXACT_IDENTIFIER'"
++        },
++        "source_id": {
++          "name": "source_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "valid_from": {
++          "name": "valid_from",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "valid_to": {
++          "name": "valid_to",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        }
++      },
++      "indexes": {
++        "cancer_codes_uq": {
++          "name": "cancer_codes_uq",
++          "columns": [
++            {
++              "expression": "cancer_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "system",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "code",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "cancer_codes_lookup_idx": {
++          "name": "cancer_codes_lookup_idx",
++          "columns": [
++            {
++              "expression": "system",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "code",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.cancer_hierarchy": {
++      "name": "cancer_hierarchy",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "parent_id": {
++          "name": "parent_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "child_id": {
++          "name": "child_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "hierarchy_type": {
++          "name": "hierarchy_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "source_id": {
++          "name": "source_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        }
++      },
++      "indexes": {
++        "cancer_hierarchy_uq": {
++          "name": "cancer_hierarchy_uq",
++          "columns": [
++            {
++              "expression": "parent_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "child_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "hierarchy_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "cancer_hierarchy_child_idx": {
++          "name": "cancer_hierarchy_child_idx",
++          "columns": [
++            {
++              "expression": "child_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.cancers": {
++      "name": "cancers",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "varchar(32)",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "slug": {
++          "name": "slug",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "canonical_name": {
++          "name": "canonical_name",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "short_name": {
++          "name": "short_name",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "entity_type": {
++          "name": "entity_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'cancer'"
++        },
++        "malignant": {
++          "name": "malignant",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": true,
++          "default": true
++        },
++        "solid_tumor": {
++          "name": "solid_tumor",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": true,
++          "default": true
++        },
++        "hematologic": {
++          "name": "hematologic",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": true,
++          "default": false
++        },
++        "pediatric_relevant": {
++          "name": "pediatric_relevant",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": true,
++          "default": false
++        },
++        "rare_cancer": {
++          "name": "rare_cancer",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "top_level": {
++          "name": "top_level",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": true,
++          "default": false
++        },
++        "description": {
++          "name": "description",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "description_provenance_id": {
++          "name": "description_provenance_id",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "primary_ncit_code": {
++          "name": "primary_ncit_code",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "primary_oncotree_code": {
++          "name": "primary_oncotree_code",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "depth": {
++          "name": "depth",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "status": {
++          "name": "status",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'active'"
++        },
++        "merged_into": {
++          "name": "merged_into",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "deprecated_reason": {
++          "name": "deprecated_reason",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "classification_version": {
++          "name": "classification_version",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "semantic_types": {
++          "name": "semantic_types",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "cancers_slug_uq": {
++          "name": "cancers_slug_uq",
++          "columns": [
++            {
++              "expression": "slug",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "cancers_ncit_uq": {
++          "name": "cancers_ncit_uq",
++          "columns": [
++            {
++              "expression": "primary_ncit_code",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "cancers_name_idx": {
++          "name": "cancers_name_idx",
++          "columns": [
++            {
++              "expression": "canonical_name",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "cancers_type_idx": {
++          "name": "cancers_type_idx",
++          "columns": [
++            {
++              "expression": "entity_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "malignant",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "top_level",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.cohort_definitions": {
++      "name": "cohort_definitions",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "name": {
++          "name": "name",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "cancer_id": {
++          "name": "cancer_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "biomarker_ids": {
++          "name": "biomarker_ids",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "variant_ids": {
++          "name": "variant_ids",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "stage": {
++          "name": "stage",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "attributes": {
++          "name": "attributes",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'::jsonb"
++        },
++        "confidence": {
++          "name": "confidence",
++          "type": "real",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {},
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.geographies": {
++      "name": "geographies",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "varchar(32)",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "slug": {
++          "name": "slug",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "name": {
++          "name": "name",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "kind": {
++          "name": "kind",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "iso2": {
++          "name": "iso2",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "iso3": {
++          "name": "iso3",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "parent_id": {
++          "name": "parent_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "who_region": {
++          "name": "who_region",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "population": {
++          "name": "population",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "population_year": {
++          "name": "population_year",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        }
++      },
++      "indexes": {
++        "geographies_slug_uq": {
++          "name": "geographies_slug_uq",
++          "columns": [
++            {
++              "expression": "slug",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "geographies_iso3_idx": {
++          "name": "geographies_iso3_idx",
++          "columns": [
++            {
++              "expression": "iso3",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.biomarkers": {
++      "name": "biomarkers",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "varchar(32)",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "slug": {
++          "name": "slug",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "name": {
++          "name": "name",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "kind": {
++          "name": "kind",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "gene_id": {
++          "name": "gene_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "ncit_code": {
++          "name": "ncit_code",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "description": {
++          "name": "description",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "measurement": {
++          "name": "measurement",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'::jsonb"
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "biomarkers_slug_uq": {
++          "name": "biomarkers_slug_uq",
++          "columns": [
++            {
++              "expression": "slug",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.cancer_gene_frequencies": {
++      "name": "cancer_gene_frequencies",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "cohort_id": {
++          "name": "cohort_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "cancer_id": {
++          "name": "cancer_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "gene_id": {
++          "name": "gene_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "gene_symbol": {
++          "name": "gene_symbol",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "alteration_type": {
++          "name": "alteration_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'ssm'"
++        },
++        "cases_affected": {
++          "name": "cases_affected",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "cases_profiled": {
++          "name": "cases_profiled",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "frequency": {
++          "name": "frequency",
++          "type": "real",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "rank": {
++          "name": "rank",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "data_release": {
++          "name": "data_release",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "provenance_id": {
++          "name": "provenance_id",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "cancer_gene_freq_uq": {
++          "name": "cancer_gene_freq_uq",
++          "columns": [
++            {
++              "expression": "cohort_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "gene_symbol",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "alteration_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "cancer_gene_freq_cancer_idx": {
++          "name": "cancer_gene_freq_cancer_idx",
++          "columns": [
++            {
++              "expression": "cancer_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "frequency",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "cancer_gene_freq_gene_idx": {
++          "name": "cancer_gene_freq_gene_idx",
++          "columns": [
++            {
++              "expression": "gene_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.entity_embeddings": {
++      "name": "entity_embeddings",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "entity_type": {
++          "name": "entity_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "entity_id": {
++          "name": "entity_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "model": {
++          "name": "model",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "dimensions": {
++          "name": "dimensions",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "text_hash": {
++          "name": "text_hash",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "embedding": {
++          "name": "embedding",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "entity_embeddings_uq": {
++          "name": "entity_embeddings_uq",
++          "columns": [
++            {
++              "expression": "entity_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "entity_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "model",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.gene_aliases": {
++      "name": "gene_aliases",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "gene_id": {
++          "name": "gene_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "alias": {
++          "name": "alias",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "alias_type": {
++          "name": "alias_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "source_id": {
++          "name": "source_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        }
++      },
++      "indexes": {
++        "gene_aliases_uq": {
++          "name": "gene_aliases_uq",
++          "columns": [
++            {
++              "expression": "gene_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "alias",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "alias_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "gene_aliases_alias_idx": {
++          "name": "gene_aliases_alias_idx",
++          "columns": [
++            {
++              "expression": "alias",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.genes": {
++      "name": "genes",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "varchar(32)",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "hgnc_id": {
++          "name": "hgnc_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "symbol": {
++          "name": "symbol",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "name": {
++          "name": "name",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "locus_type": {
++          "name": "locus_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "locus_group": {
++          "name": "locus_group",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "location": {
++          "name": "location",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "chromosome": {
++          "name": "chromosome",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "ensembl_gene_id": {
++          "name": "ensembl_gene_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "ncbi_gene_id": {
++          "name": "ncbi_gene_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "omim_ids": {
++          "name": "omim_ids",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "uniprot_ids": {
++          "name": "uniprot_ids",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "refseq_accession": {
++          "name": "refseq_accession",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "prev_symbols": {
++          "name": "prev_symbols",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "alias_symbols": {
++          "name": "alias_symbols",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "gene_families": {
++          "name": "gene_families",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "status": {
++          "name": "status",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'Approved'"
++        },
++        "is_cancer_gene": {
++          "name": "is_cancer_gene",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": true,
++          "default": false
++        },
++        "civic_gene_id": {
++          "name": "civic_gene_id",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "description": {
++          "name": "description",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "genes_symbol_uq": {
++          "name": "genes_symbol_uq",
++          "columns": [
++            {
++              "expression": "symbol",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "genes_hgnc_uq": {
++          "name": "genes_hgnc_uq",
++          "columns": [
++            {
++              "expression": "hgnc_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "genes_ensembl_idx": {
++          "name": "genes_ensembl_idx",
++          "columns": [
++            {
++              "expression": "ensembl_gene_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "genes_ncbi_idx": {
++          "name": "genes_ncbi_idx",
++          "columns": [
++            {
++              "expression": "ncbi_gene_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.genomic_cohorts": {
++      "name": "genomic_cohorts",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "varchar(32)",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "source_id": {
++          "name": "source_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "study_id": {
++          "name": "study_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "name": {
++          "name": "name",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "program": {
++          "name": "program",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "primary_sites": {
++          "name": "primary_sites",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "disease_types": {
++          "name": "disease_types",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "cancer_id": {
++          "name": "cancer_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "cancer_match_type": {
++          "name": "cancer_match_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "case_count": {
++          "name": "case_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "cases_with_ssm": {
++          "name": "cases_with_ssm",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "data_release": {
++          "name": "data_release",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "access_level": {
++          "name": "access_level",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'open'"
++        },
++        "url": {
++          "name": "url",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "provenance_id": {
++          "name": "provenance_id",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "genomic_cohorts_uq": {
++          "name": "genomic_cohorts_uq",
++          "columns": [
++            {
++              "expression": "source_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "study_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "genomic_cohorts_cancer_idx": {
++          "name": "genomic_cohorts_cancer_idx",
++          "columns": [
++            {
++              "expression": "cancer_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.variant_aliases": {
++      "name": "variant_aliases",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "variant_id": {
++          "name": "variant_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "alias": {
++          "name": "alias",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "source_id": {
++          "name": "source_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        }
++      },
++      "indexes": {
++        "variant_aliases_uq": {
++          "name": "variant_aliases_uq",
++          "columns": [
++            {
++              "expression": "variant_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "alias",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.variant_clinical_significance": {
++      "name": "variant_clinical_significance",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "variant_id": {
++          "name": "variant_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "clinvar_variation_id": {
++          "name": "clinvar_variation_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "clinical_significance": {
++          "name": "clinical_significance",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "review_status": {
++          "name": "review_status",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "star_rating": {
++          "name": "star_rating",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "last_evaluated": {
++          "name": "last_evaluated",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "conditions": {
++          "name": "conditions",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "condition_cancer_ids": {
++          "name": "condition_cancer_ids",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "origin_simple": {
++          "name": "origin_simple",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "number_submitters": {
++          "name": "number_submitters",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "provenance_id": {
++          "name": "provenance_id",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "ingest_run_id": {
++          "name": "ingest_run_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "variant_clinsig_uq": {
++          "name": "variant_clinsig_uq",
++          "columns": [
++            {
++              "expression": "clinvar_variation_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.variants": {
++      "name": "variants",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "varchar(32)",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "slug": {
++          "name": "slug",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "gene_id": {
++          "name": "gene_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "gene_symbol": {
++          "name": "gene_symbol",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "name": {
++          "name": "name",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "variant_type": {
++          "name": "variant_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "hgvs_g": {
++          "name": "hgvs_g",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "hgvs_c": {
++          "name": "hgvs_c",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "hgvs_p": {
++          "name": "hgvs_p",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "assembly": {
++          "name": "assembly",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "chromosome": {
++          "name": "chromosome",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "start": {
++          "name": "start",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "end": {
++          "name": "end",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "reference_bases": {
++          "name": "reference_bases",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "alternate_bases": {
++          "name": "alternate_bases",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "coordinates": {
++          "name": "coordinates",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'[]'::jsonb"
++        },
++        "clinvar_variation_id": {
++          "name": "clinvar_variation_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "civic_variant_id": {
++          "name": "civic_variant_id",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "dbsnp_ids": {
++          "name": "dbsnp_ids",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "fusion_partners": {
++          "name": "fusion_partners",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "variants_slug_uq": {
++          "name": "variants_slug_uq",
++          "columns": [
++            {
++              "expression": "slug",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "variants_gene_idx": {
++          "name": "variants_gene_idx",
++          "columns": [
++            {
++              "expression": "gene_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "variants_clinvar_idx": {
++          "name": "variants_clinvar_idx",
++          "columns": [
++            {
++              "expression": "clinvar_variation_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "variants_civic_idx": {
++          "name": "variants_civic_idx",
++          "columns": [
++            {
++              "expression": "civic_variant_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.drug_aliases": {
++      "name": "drug_aliases",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "drug_id": {
++          "name": "drug_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "alias": {
++          "name": "alias",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "normalized": {
++          "name": "normalized",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "alias_type": {
++          "name": "alias_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'synonym'"
++        },
++        "source_id": {
++          "name": "source_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        }
++      },
++      "indexes": {
++        "drug_aliases_uq": {
++          "name": "drug_aliases_uq",
++          "columns": [
++            {
++              "expression": "drug_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "normalized",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "alias_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "drug_aliases_norm_idx": {
++          "name": "drug_aliases_norm_idx",
++          "columns": [
++            {
++              "expression": "normalized",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.drug_approvals": {
++      "name": "drug_approvals",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "drug_id": {
++          "name": "drug_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "cancer_id": {
++          "name": "cancer_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "biomarker_ids": {
++          "name": "biomarker_ids",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "tumor_agnostic": {
++          "name": "tumor_agnostic",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": true,
++          "default": false
++        },
++        "jurisdiction": {
++          "name": "jurisdiction",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "authority": {
++          "name": "authority",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "indication": {
++          "name": "indication",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "line_of_therapy": {
++          "name": "line_of_therapy",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "disease_stage": {
++          "name": "disease_stage",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "approval_type": {
++          "name": "approval_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "accelerated": {
++          "name": "accelerated",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "conditional": {
++          "name": "conditional",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "approval_date": {
++          "name": "approval_date",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "withdrawal_date": {
++          "name": "withdrawal_date",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "status": {
++          "name": "status",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "application_number": {
++          "name": "application_number",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "source_id": {
++          "name": "source_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "provenance_id": {
++          "name": "provenance_id",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "raw": {
++          "name": "raw",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "drug_approvals_drug_idx": {
++          "name": "drug_approvals_drug_idx",
++          "columns": [
++            {
++              "expression": "drug_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "drug_approvals_cancer_idx": {
++          "name": "drug_approvals_cancer_idx",
++          "columns": [
++            {
++              "expression": "cancer_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.drugs": {
++      "name": "drugs",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "varchar(32)",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "slug": {
++          "name": "slug",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "name": {
++          "name": "name",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "kind": {
++          "name": "kind",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "ncit_code": {
++          "name": "ncit_code",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "chembl_id": {
++          "name": "chembl_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "civic_therapy_id": {
++          "name": "civic_therapy_id",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "drugbank_id": {
++          "name": "drugbank_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "pubchem_cid": {
++          "name": "pubchem_cid",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "unii": {
++          "name": "unii",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "mechanism": {
++          "name": "mechanism",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "target_gene_ids": {
++          "name": "target_gene_ids",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "development_status": {
++          "name": "development_status",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "description": {
++          "name": "description",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "drugs_slug_uq": {
++          "name": "drugs_slug_uq",
++          "columns": [
++            {
++              "expression": "slug",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "drugs_ncit_idx": {
++          "name": "drugs_ncit_idx",
++          "columns": [
++            {
++              "expression": "ncit_code",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "drugs_civic_idx": {
++          "name": "drugs_civic_idx",
++          "columns": [
++            {
++              "expression": "civic_therapy_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "drugs_chembl_idx": {
++          "name": "drugs_chembl_idx",
++          "columns": [
++            {
++              "expression": "chembl_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.treatment_regimens": {
++      "name": "treatment_regimens",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "varchar(32)",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "slug": {
++          "name": "slug",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "name": {
++          "name": "name",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "component_drug_ids": {
++          "name": "component_drug_ids",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "modality": {
++          "name": "modality",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'drug_combination'"
++        },
++        "description": {
++          "name": "description",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "treatment_regimens_slug_uq": {
++          "name": "treatment_regimens_slug_uq",
++          "columns": [
++            {
++              "expression": "slug",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.clinical_trials": {
++      "name": "clinical_trials",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "varchar(32)",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "nct_id": {
++          "name": "nct_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "brief_title": {
++          "name": "brief_title",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "official_title": {
++          "name": "official_title",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "acronym": {
++          "name": "acronym",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "study_type": {
++          "name": "study_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "phases": {
++          "name": "phases",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "overall_status": {
++          "name": "overall_status",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "why_stopped": {
++          "name": "why_stopped",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "start_date": {
++          "name": "start_date",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "primary_completion_date": {
++          "name": "primary_completion_date",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "completion_date": {
++          "name": "completion_date",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "first_posted_date": {
++          "name": "first_posted_date",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "last_update_posted_date": {
++          "name": "last_update_posted_date",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "results_first_posted_date": {
++          "name": "results_first_posted_date",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "has_results": {
++          "name": "has_results",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": true,
++          "default": false
++        },
++        "enrollment_count": {
++          "name": "enrollment_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "enrollment_type": {
++          "name": "enrollment_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "lead_sponsor": {
++          "name": "lead_sponsor",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "lead_sponsor_class": {
++          "name": "lead_sponsor_class",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "collaborators": {
++          "name": "collaborators",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "conditions": {
++          "name": "conditions",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "keywords": {
++          "name": "keywords",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "interventions": {
++          "name": "interventions",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'[]'::jsonb"
++        },
++        "arms": {
++          "name": "arms",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'[]'::jsonb"
++        },
++        "primary_outcomes": {
++          "name": "primary_outcomes",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'[]'::jsonb"
++        },
++        "secondary_outcomes": {
++          "name": "secondary_outcomes",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'[]'::jsonb"
++        },
++        "eligibility": {
++          "name": "eligibility",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'::jsonb"
++        },
++        "sex": {
++          "name": "sex",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "minimum_age": {
++          "name": "minimum_age",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "maximum_age": {
++          "name": "maximum_age",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "countries": {
++          "name": "countries",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "locations_count": {
++          "name": "locations_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "references": {
++          "name": "references",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'[]'::jsonb"
++        },
++        "brief_summary": {
++          "name": "brief_summary",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "is_oncology": {
++          "name": "is_oncology",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": true,
++          "default": true
++        },
++        "source_record_id": {
++          "name": "source_record_id",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "ingest_run_id": {
++          "name": "ingest_run_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "clinical_trials_nct_uq": {
++          "name": "clinical_trials_nct_uq",
++          "columns": [
++            {
++              "expression": "nct_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "clinical_trials_status_idx": {
++          "name": "clinical_trials_status_idx",
++          "columns": [
++            {
++              "expression": "overall_status",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "clinical_trials_updated_idx": {
++          "name": "clinical_trials_updated_idx",
++          "columns": [
++            {
++              "expression": "last_update_posted_date",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "clinical_trials_sponsor_idx": {
++          "name": "clinical_trials_sponsor_idx",
++          "columns": [
++            {
++              "expression": "lead_sponsor",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.trial_conditions": {
++      "name": "trial_conditions",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "trial_id": {
++          "name": "trial_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "condition_text": {
++          "name": "condition_text",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "normalized": {
++          "name": "normalized",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "cancer_id": {
++          "name": "cancer_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "match_type": {
++          "name": "match_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'UNRESOLVED'"
++        },
++        "confidence": {
++          "name": "confidence",
++          "type": "real",
++          "primaryKey": false,
++          "notNull": false
++        }
++      },
++      "indexes": {
++        "trial_conditions_uq": {
++          "name": "trial_conditions_uq",
++          "columns": [
++            {
++              "expression": "trial_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "normalized",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "trial_conditions_cancer_idx": {
++          "name": "trial_conditions_cancer_idx",
++          "columns": [
++            {
++              "expression": "cancer_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "trial_conditions_norm_idx": {
++          "name": "trial_conditions_norm_idx",
++          "columns": [
++            {
++              "expression": "normalized",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.trial_interventions": {
++      "name": "trial_interventions",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "trial_id": {
++          "name": "trial_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "name": {
++          "name": "name",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "normalized": {
++          "name": "normalized",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "intervention_type": {
++          "name": "intervention_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "drug_id": {
++          "name": "drug_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "match_type": {
++          "name": "match_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'UNRESOLVED'"
++        }
++      },
++      "indexes": {
++        "trial_interventions_uq": {
++          "name": "trial_interventions_uq",
++          "columns": [
++            {
++              "expression": "trial_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "normalized",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "trial_interventions_drug_idx": {
++          "name": "trial_interventions_drug_idx",
++          "columns": [
++            {
++              "expression": "drug_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.trial_locations": {
++      "name": "trial_locations",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "trial_id": {
++          "name": "trial_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "facility": {
++          "name": "facility",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "city": {
++          "name": "city",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "state": {
++          "name": "state",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "zip": {
++          "name": "zip",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "country": {
++          "name": "country",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "status": {
++          "name": "status",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "lat": {
++          "name": "lat",
++          "type": "real",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "lng": {
++          "name": "lng",
++          "type": "real",
++          "primaryKey": false,
++          "notNull": false
++        }
++      },
++      "indexes": {
++        "trial_locations_trial_idx": {
++          "name": "trial_locations_trial_idx",
++          "columns": [
++            {
++              "expression": "trial_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "trial_locations_country_idx": {
++          "name": "trial_locations_country_idx",
++          "columns": [
++            {
++              "expression": "country",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.trial_pulse": {
++      "name": "trial_pulse",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "day": {
++          "name": "day",
++          "type": "date",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "cancer_id": {
++          "name": "cancer_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "phase": {
++          "name": "phase",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "new_trials": {
++          "name": "new_trials",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "trial_pulse_uq": {
++          "name": "trial_pulse_uq",
++          "columns": [
++            {
++              "expression": "day",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "cancer_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "phase",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.literature_counts": {
++      "name": "literature_counts",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "cancer_id": {
++          "name": "cancer_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "window_key": {
++          "name": "window_key",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "window_start": {
++          "name": "window_start",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "window_end": {
++          "name": "window_end",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "query": {
++          "name": "query",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "count": {
++          "name": "count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "provenance_id": {
++          "name": "provenance_id",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "literature_counts_uq": {
++          "name": "literature_counts_uq",
++          "columns": [
++            {
++              "expression": "cancer_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "window_key",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "literature_counts_window_idx": {
++          "name": "literature_counts_window_idx",
++          "columns": [
++            {
++              "expression": "window_key",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "count",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.publication_entity_edges": {
++      "name": "publication_entity_edges",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "publication_id": {
++          "name": "publication_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "entity_type": {
++          "name": "entity_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "entity_id": {
++          "name": "entity_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "method": {
++          "name": "method",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "confidence": {
++          "name": "confidence",
++          "type": "real",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "status": {
++          "name": "status",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'candidate'"
++        },
++        "source_id": {
++          "name": "source_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "ingest_run_id": {
++          "name": "ingest_run_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "pub_entity_edges_uq": {
++          "name": "pub_entity_edges_uq",
++          "columns": [
++            {
++              "expression": "publication_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "entity_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "entity_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "method",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "pub_entity_edges_entity_idx": {
++          "name": "pub_entity_edges_entity_idx",
++          "columns": [
++            {
++              "expression": "entity_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "entity_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.publications": {
++      "name": "publications",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "varchar(32)",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "pmid": {
++          "name": "pmid",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "doi": {
++          "name": "doi",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "pmcid": {
++          "name": "pmcid",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "title": {
++          "name": "title",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "abstract": {
++          "name": "abstract",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "journal": {
++          "name": "journal",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "journal_iso": {
++          "name": "journal_iso",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "pub_date": {
++          "name": "pub_date",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "pub_year": {
++          "name": "pub_year",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "publication_types": {
++          "name": "publication_types",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "mesh_terms": {
++          "name": "mesh_terms",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'[]'::jsonb"
++        },
++        "authors": {
++          "name": "authors",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'[]'::jsonb"
++        },
++        "language": {
++          "name": "language",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "is_preprint": {
++          "name": "is_preprint",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": true,
++          "default": false
++        },
++        "retracted": {
++          "name": "retracted",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": true,
++          "default": false
++        },
++        "retraction_notice": {
++          "name": "retraction_notice",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "nct_ids": {
++          "name": "nct_ids",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "cited_by_count": {
++          "name": "cited_by_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "source_record_id": {
++          "name": "source_record_id",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "ingest_run_id": {
++          "name": "ingest_run_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "publications_pmid_uq": {
++          "name": "publications_pmid_uq",
++          "columns": [
++            {
++              "expression": "pmid",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "publications_doi_idx": {
++          "name": "publications_doi_idx",
++          "columns": [
++            {
++              "expression": "doi",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "publications_year_idx": {
++          "name": "publications_year_idx",
++          "columns": [
++            {
++              "expression": "pub_year",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "publications_retracted_idx": {
++          "name": "publications_retracted_idx",
++          "columns": [
++            {
++              "expression": "retracted",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.civic_evidence_items": {
++      "name": "civic_evidence_items",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "civic_id": {
++          "name": "civic_id",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "name": {
++          "name": "name",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "molecular_profile_id": {
++          "name": "molecular_profile_id",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "molecular_profile_name": {
++          "name": "molecular_profile_name",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "gene_symbols": {
++          "name": "gene_symbols",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "gene_ids": {
++          "name": "gene_ids",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "variant_ids": {
++          "name": "variant_ids",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "civic_variant_ids": {
++          "name": "civic_variant_ids",
++          "type": "integer[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "disease_name": {
++          "name": "disease_name",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "doid": {
++          "name": "doid",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "cancer_id": {
++          "name": "cancer_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "cancer_match_type": {
++          "name": "cancer_match_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "therapy_names": {
++          "name": "therapy_names",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "therapy_ids": {
++          "name": "therapy_ids",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "therapy_interaction_type": {
++          "name": "therapy_interaction_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "evidence_type": {
++          "name": "evidence_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "evidence_level": {
++          "name": "evidence_level",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "evidence_direction": {
++          "name": "evidence_direction",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "significance": {
++          "name": "significance",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "evidence_rating": {
++          "name": "evidence_rating",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "status": {
++          "name": "status",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "description": {
++          "name": "description",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "pmid": {
++          "name": "pmid",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "source_citation": {
++          "name": "source_citation",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "phenotypes": {
++          "name": "phenotypes",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "provenance_id": {
++          "name": "provenance_id",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "ingest_run_id": {
++          "name": "ingest_run_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "civic_evidence_uq": {
++          "name": "civic_evidence_uq",
++          "columns": [
++            {
++              "expression": "civic_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "civic_evidence_cancer_idx": {
++          "name": "civic_evidence_cancer_idx",
++          "columns": [
++            {
++              "expression": "cancer_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "civic_evidence_gene_idx": {
++          "name": "civic_evidence_gene_idx",
++          "columns": [
++            {
++              "expression": "gene_symbols",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.knowledge_edges": {
++      "name": "knowledge_edges",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "source_entity_type": {
++          "name": "source_entity_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "source_entity_id": {
++          "name": "source_entity_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "target_entity_type": {
++          "name": "target_entity_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "target_entity_id": {
++          "name": "target_entity_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "relationship_type": {
++          "name": "relationship_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "cancer_context_ids": {
++          "name": "cancer_context_ids",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "predictive": {
++          "name": "predictive",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "prognostic": {
++          "name": "prognostic",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "diagnostic": {
++          "name": "diagnostic",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "predisposing": {
++          "name": "predisposing",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "direction": {
++          "name": "direction",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "evidence_level": {
++          "name": "evidence_level",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "evidence_score": {
++          "name": "evidence_score",
++          "type": "real",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "evidence_category": {
++          "name": "evidence_category",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'curated_evidence'"
++        },
++        "status": {
++          "name": "status",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'active'"
++        },
++        "source_id": {
++          "name": "source_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "source_record_id": {
++          "name": "source_record_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "provenance_ids": {
++          "name": "provenance_ids",
++          "type": "integer[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "support_count": {
++          "name": "support_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 1
++        },
++        "first_seen_at": {
++          "name": "first_seen_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        },
++        "last_seen_at": {
++          "name": "last_seen_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "knowledge_edges_uq": {
++          "name": "knowledge_edges_uq",
++          "columns": [
++            {
++              "expression": "source_entity_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "source_entity_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "target_entity_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "target_entity_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "relationship_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "source_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "source_record_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "knowledge_edges_source_idx": {
++          "name": "knowledge_edges_source_idx",
++          "columns": [
++            {
++              "expression": "source_entity_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "source_entity_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "relationship_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "knowledge_edges_target_idx": {
++          "name": "knowledge_edges_target_idx",
++          "columns": [
++            {
++              "expression": "target_entity_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "target_entity_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "relationship_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.risk_factors": {
++      "name": "risk_factors",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "slug": {
++          "name": "slug",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "name": {
++          "name": "name",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "kind": {
++          "name": "kind",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "classification_authority": {
++          "name": "classification_authority",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "classification": {
++          "name": "classification",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "description": {
++          "name": "description",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "risk_factors_slug_uq": {
++          "name": "risk_factors_slug_uq",
++          "columns": [
++            {
++              "expression": "slug",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.epidemiology_observations": {
++      "name": "epidemiology_observations",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "cancer_id": {
++          "name": "cancer_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "geography_id": {
++          "name": "geography_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "year": {
++          "name": "year",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "year_end": {
++          "name": "year_end",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "sex": {
++          "name": "sex",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'all'"
++        },
++        "age_group": {
++          "name": "age_group",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'all'"
++        },
++        "metric": {
++          "name": "metric",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "value": {
++          "name": "value",
++          "type": "double precision",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "unit": {
++          "name": "unit",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "lower_ci": {
++          "name": "lower_ci",
++          "type": "double precision",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "upper_ci": {
++          "name": "upper_ci",
++          "type": "double precision",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "standard_population": {
++          "name": "standard_population",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "estimate_type": {
++          "name": "estimate_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'observed'"
++        },
++        "site_definition": {
++          "name": "site_definition",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "source_id": {
++          "name": "source_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "provenance_id": {
++          "name": "provenance_id",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "ingest_run_id": {
++          "name": "ingest_run_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "epi_obs_uq": {
++          "name": "epi_obs_uq",
++          "columns": [
++            {
++              "expression": "cancer_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "geography_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "year",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "sex",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "age_group",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "metric",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "source_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "site_definition",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "epi_obs_lookup_idx": {
++          "name": "epi_obs_lookup_idx",
++          "columns": [
++            {
++              "expression": "metric",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "geography_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "year",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "sex",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "epi_obs_cancer_idx": {
++          "name": "epi_obs_cancer_idx",
++          "columns": [
++            {
++              "expression": "cancer_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "metric",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.survival_observations": {
++      "name": "survival_observations",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "cancer_id": {
++          "name": "cancer_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "geography_id": {
++          "name": "geography_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "stage": {
++          "name": "stage",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "staging_system": {
++          "name": "staging_system",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "sex": {
++          "name": "sex",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'all'"
++        },
++        "age_group": {
++          "name": "age_group",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'all'"
++        },
++        "diagnosis_period": {
++          "name": "diagnosis_period",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "survival_type": {
++          "name": "survival_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "duration_months": {
++          "name": "duration_months",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "probability": {
++          "name": "probability",
++          "type": "real",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "median_months": {
++          "name": "median_months",
++          "type": "real",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "cohort_size": {
++          "name": "cohort_size",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "lower_ci": {
++          "name": "lower_ci",
++          "type": "real",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "upper_ci": {
++          "name": "upper_ci",
++          "type": "real",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "method": {
++          "name": "method",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "source_id": {
++          "name": "source_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "provenance_id": {
++          "name": "provenance_id",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "ingest_run_id": {
++          "name": "ingest_run_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "survival_obs_cancer_idx": {
++          "name": "survival_obs_cancer_idx",
++          "columns": [
++            {
++              "expression": "cancer_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "survival_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "duration_months",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.ai_answers": {
++      "name": "ai_answers",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "kind": {
++          "name": "kind",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "subject_id": {
++          "name": "subject_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "question_hash": {
++          "name": "question_hash",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "question": {
++          "name": "question",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "answer": {
++          "name": "answer",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "model": {
++          "name": "model",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "prompt_version": {
++          "name": "prompt_version",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "source_snapshot": {
++          "name": "source_snapshot",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'::jsonb"
++        },
++        "data_as_of": {
++          "name": "data_as_of",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "ai_answers_uq": {
++          "name": "ai_answers_uq",
++          "columns": [
++            {
++              "expression": "kind",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "question_hash",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "prompt_version",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.api_keys": {
++      "name": "api_keys",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "key_hash": {
++          "name": "key_hash",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "prefix": {
++          "name": "prefix",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "label": {
++          "name": "label",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "owner_email": {
++          "name": "owner_email",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "tier": {
++          "name": "tier",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'free'"
++        },
++        "rate_limit_per_minute": {
++          "name": "rate_limit_per_minute",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 60
++        },
++        "active": {
++          "name": "active",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": true,
++          "default": true
++        },
++        "last_used_at": {
++          "name": "last_used_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "api_keys_hash_uq": {
++          "name": "api_keys_hash_uq",
++          "columns": [
++            {
++              "expression": "key_hash",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.entity_counters": {
++      "name": "entity_counters",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "entity_type": {
++          "name": "entity_type",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "entity_id": {
++          "name": "entity_id",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "trial_count": {
++          "name": "trial_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "active_trial_count": {
++          "name": "active_trial_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "recruiting_trial_count": {
++          "name": "recruiting_trial_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "phase3_trial_count": {
++          "name": "phase3_trial_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "publication_count": {
++          "name": "publication_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "publication_count_5y": {
++          "name": "publication_count_5y",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "publication_count_12m": {
++          "name": "publication_count_12m",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "gene_count": {
++          "name": "gene_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "variant_count": {
++          "name": "variant_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "drug_count": {
++          "name": "drug_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "approved_drug_count": {
++          "name": "approved_drug_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "evidence_count": {
++          "name": "evidence_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "cohort_count": {
++          "name": "cohort_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "subtype_count": {
++          "name": "subtype_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "descendant_count": {
++          "name": "descendant_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "epidemiology_obs_count": {
++          "name": "epidemiology_obs_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "survival_obs_count": {
++          "name": "survival_obs_count",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true,
++          "default": 0
++        },
++        "completeness": {
++          "name": "completeness",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'::jsonb"
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "entity_counters_uq": {
++          "name": "entity_counters_uq",
++          "columns": [
++            {
++              "expression": "entity_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "entity_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "entity_counters_trials_idx": {
++          "name": "entity_counters_trials_idx",
++          "columns": [
++            {
++              "expression": "entity_type",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "active_trial_count",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.metric_definitions": {
++      "name": "metric_definitions",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "varchar(32)",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "slug": {
++          "name": "slug",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "name": {
++          "name": "name",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "description": {
++          "name": "description",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "formula": {
++          "name": "formula",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "formula_version": {
++          "name": "formula_version",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "unit": {
++          "name": "unit",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "higher_is_worse": {
++          "name": "higher_is_worse",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "aggregation": {
++          "name": "aggregation",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "valid_dimensions": {
++          "name": "valid_dimensions",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "source_slugs": {
++          "name": "source_slugs",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "category": {
++          "name": "category",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "eligibility": {
++          "name": "eligibility",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'::jsonb"
++        },
++        "experimental": {
++          "name": "experimental",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": true,
++          "default": false
++        },
++        "created_at": {
++          "name": "created_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        },
++        "updated_at": {
++          "name": "updated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "metric_definitions_slug_uq": {
++          "name": "metric_definitions_slug_uq",
++          "columns": [
++            {
++              "expression": "slug",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.ranking_snapshots": {
++      "name": "ranking_snapshots",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "metric_id": {
++          "name": "metric_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "metric_slug": {
++          "name": "metric_slug",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "scope_key": {
++          "name": "scope_key",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "geography": {
++          "name": "geography",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'WORLD'"
++        },
++        "sex": {
++          "name": "sex",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'all'"
++        },
++        "age_group": {
++          "name": "age_group",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'all'"
++        },
++        "year": {
++          "name": "year",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "entity_level": {
++          "name": "entity_level",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'top'"
++        },
++        "formula_version": {
++          "name": "formula_version",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "eligible_entities": {
++          "name": "eligible_entities",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "inputs_hash": {
++          "name": "inputs_hash",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "source_ids": {
++          "name": "source_ids",
++          "type": "text[]",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'"
++        },
++        "is_current": {
++          "name": "is_current",
++          "type": "boolean",
++          "primaryKey": false,
++          "notNull": true,
++          "default": true
++        },
++        "generated_at": {
++          "name": "generated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "ranking_snapshots_lookup_idx": {
++          "name": "ranking_snapshots_lookup_idx",
++          "columns": [
++            {
++              "expression": "metric_slug",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "scope_key",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "is_current",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    },
++    "public.rankings": {
++      "name": "rankings",
++      "schema": "",
++      "columns": {
++        "id": {
++          "name": "id",
++          "type": "bigserial",
++          "primaryKey": true,
++          "notNull": true
++        },
++        "snapshot_id": {
++          "name": "snapshot_id",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "metric_slug": {
++          "name": "metric_slug",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "scope_key": {
++          "name": "scope_key",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "cancer_id": {
++          "name": "cancer_id",
++          "type": "varchar(32)",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "rank": {
++          "name": "rank",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "eligible_entities": {
++          "name": "eligible_entities",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "percentile": {
++          "name": "percentile",
++          "type": "real",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "value": {
++          "name": "value",
++          "type": "double precision",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "unit": {
++          "name": "unit",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true
++        },
++        "confidence": {
++          "name": "confidence",
++          "type": "text",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'MEDIUM'"
++        },
++        "inputs": {
++          "name": "inputs",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "'{}'::jsonb"
++        },
++        "breakdown": {
++          "name": "breakdown",
++          "type": "jsonb",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "previous_rank": {
++          "name": "previous_rank",
++          "type": "integer",
++          "primaryKey": false,
++          "notNull": false
++        },
++        "generated_at": {
++          "name": "generated_at",
++          "type": "timestamp with time zone",
++          "primaryKey": false,
++          "notNull": true,
++          "default": "now()"
++        }
++      },
++      "indexes": {
++        "rankings_uq": {
++          "name": "rankings_uq",
++          "columns": [
++            {
++              "expression": "snapshot_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "cancer_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": true,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "rankings_cancer_idx": {
++          "name": "rankings_cancer_idx",
++          "columns": [
++            {
++              "expression": "cancer_id",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "metric_slug",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        },
++        "rankings_lookup_idx": {
++          "name": "rankings_lookup_idx",
++          "columns": [
++            {
++              "expression": "metric_slug",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "scope_key",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            },
++            {
++              "expression": "rank",
++              "isExpression": false,
++              "asc": true,
++              "nulls": "last"
++            }
++          ],
++          "isUnique": false,
++          "concurrently": false,
++          "method": "btree",
++          "with": {}
++        }
++      },
++      "foreignKeys": {},
++      "compositePrimaryKeys": {},
++      "uniqueConstraints": {},
++      "policies": {},
++      "checkConstraints": {},
++      "isRLSEnabled": false
++    }
++  },
++  "enums": {},
++  "schemas": {},
++  "sequences": {},
++  "roles": {},
++  "policies": {},
++  "views": {},
++  "_meta": {
++    "columns": {},
++    "schemas": {},
++    "tables": {}
++  }
++}
+ \ No newline at end of file

added packages/database/migrations/meta/_journal.json +13 −0

++{
++  "version": "7",
++  "dialect": "postgresql",
++  "entries": [
++    {
++      "idx": 0,
++      "version": "7",
++      "when": 1788858213248,
++      "tag": "0000_small_blazing_skull",
++      "breakpoints": true
++    }
++  ]
++}
+ \ No newline at end of file

added packages/database/package.json +37 −0

++{
++  "name": "@cancerindex/database",
++  "version": "0.1.0",
++  "private": true,
++  "type": "module",
++  "exports": {
++    ".": {
++      "types": "./src/index.ts",
++      "default": "./src/index.ts"
++    },
++    "./schema": {
++      "types": "./src/schema/index.ts",
++      "default": "./src/schema/index.ts"
++    }
++  },
++  "scripts": {
++    "build": "tsc -p tsconfig.json --noEmit",
++    "typecheck": "tsc -p tsconfig.json --noEmit",
++    "test": "vitest run --passWithNoTests",
++    "generate": "drizzle-kit generate",
++    "migrate": "tsx src/migrate.ts",
++    "seed": "tsx src/seed.ts",
++    "studio": "drizzle-kit studio"
++  },
++  "dependencies": {
++    "@cancerindex/shared": "workspace:*",
++    "drizzle-orm": "^0.45.0",
++    "postgres": "^3.4.7"
++  },
++  "devDependencies": {
++    "@types/node": "^24.0.0",
++    "drizzle-kit": "^0.31.0",
++    "tsx": "^4.20.0",
++    "typescript": "^5.9.3",
++    "vitest": "^3.2.0"
++  }
++}

added packages/database/src/client.ts +42 −0

++import postgres from 'postgres';
++import { drizzle, type PostgresJsDatabase } from 'drizzle-orm/postgres-js';
++import * as schema from './schema/index.js';
++
++export type Database = PostgresJsDatabase<typeof schema>;
++
++let _sql: ReturnType<typeof postgres> | null = null;
++let _db: Database | null = null;
++
++export interface DbOptions {
++  url?: string;
++  max?: number;
++}
++
++/** Lazily created singleton; safe from Next.js server components, Fastify and workers alike. */
++export function getSql(opts: DbOptions = {}) {
++  if (!_sql) {
++    const url = opts.url ?? process.env.DATABASE_URL ?? 'postgres://localhost:5432/cancerindex';
++    _sql = postgres(url, {
++      max: opts.max ?? Number(process.env.DB_POOL_MAX ?? 10),
++      idle_timeout: 30,
++      connect_timeout: 10,
++      prepare: true,
++      transform: { undefined: null },
++      onnotice: () => {},
++    });
++  }
++  return _sql;
++}
++
++export function getDb(opts: DbOptions = {}): Database {
++  if (!_db) _db = drizzle(getSql(opts), { schema, casing: 'snake_case' });
++  return _db;
++}
++
++export async function closeDb(): Promise<void> {
++  if (_sql) {
++    await _sql.end({ timeout: 5 });
++    _sql = null;
++    _db = null;
++  }
++}

added packages/database/src/ids.ts +25 −0

++import { sql } from 'drizzle-orm';
++import { formatId, type IdNamespace } from '@cancerindex/shared';
++import type { Database } from './client.js';
++
++/**
++ * Mint stable public identifiers from per-namespace counters (CLAUDE.md §6).
++ * Atomic upsert-increment; `count` ids are reserved in one round trip.
++ */
++export async function mintIds(db: Database, ns: IdNamespace, count = 1): Promise<string[]> {
++  if (count < 1) return [];
++  const rows = await db.execute<{ next: string | number }>(sql`
++    INSERT INTO id_sequences (namespace, next) VALUES (${ns}, ${count + 1})
++    ON CONFLICT (namespace) DO UPDATE SET next = id_sequences.next + ${count}
++    RETURNING next
++  `);
++  const next = Number(rows[0]?.next ?? 0);
++  const first = next - count;
++  return Array.from({ length: count }, (_, i) => formatId(ns, first + i));
++}
++
++export async function mintId(db: Database, ns: IdNamespace): Promise<string> {
++  const [id] = await mintIds(db, ns, 1);
++  if (!id) throw new Error('mint failed');
++  return id;
++}

added packages/database/src/index.ts +5 −0

++export * from './client.js';
++export * from './ids.js';
++export * as schema from './schema/index.js';
++export * from './schema/index.js';
++export { runMigrations } from './migrate.js';

added packages/database/src/migrate.ts +40 −0

++import { migrate } from 'drizzle-orm/postgres-js/migrator';
++import { fileURLToPath } from 'node:url';
++import path from 'node:path';
++import { getDb, getSql, closeDb } from './client.js';
++
++/**
++ * Runs SQL migrations from ./migrations (CLAUDE.md §284). Extensions are created first because
++ * drizzle-kit does not manage them; pgvector is optional and only enabled when available.
++ */
++export async function runMigrations(): Promise<void> {
++  const sql = getSql({ max: 1 });
++  await sql`CREATE EXTENSION IF NOT EXISTS pg_trgm`;
++  await sql`CREATE EXTENSION IF NOT EXISTS unaccent`;
++  const [vec] = await sql`SELECT 1 AS ok FROM pg_available_extensions WHERE name = 'vector'`;
++  if (vec) await sql`CREATE EXTENSION IF NOT EXISTS vector`;
++  else console.warn('[migrate] pgvector not available — semantic search disabled until installed');
++  const here = path.dirname(fileURLToPath(import.meta.url));
++  await migrate(getDb({ max: 1 }), { migrationsFolder: path.resolve(here, '../migrations') });
++  // Trigram indexes for fuzzy search (not expressible in drizzle schema).
++  await sql`CREATE INDEX IF NOT EXISTS cancer_aliases_trgm_idx ON cancer_aliases USING gin (normalized gin_trgm_ops)`;
++  await sql`CREATE INDEX IF NOT EXISTS cancers_name_trgm_idx ON cancers USING gin (lower(canonical_name) gin_trgm_ops)`;
++  await sql`CREATE INDEX IF NOT EXISTS genes_symbol_trgm_idx ON genes USING gin (lower(symbol) gin_trgm_ops)`;
++  await sql`CREATE INDEX IF NOT EXISTS drugs_name_trgm_idx ON drugs USING gin (lower(name) gin_trgm_ops)`;
++  await sql`CREATE INDEX IF NOT EXISTS trials_title_trgm_idx ON clinical_trials USING gin (lower(brief_title) gin_trgm_ops)`;
++  await sql`CREATE INDEX IF NOT EXISTS publications_title_trgm_idx ON publications USING gin (lower(title) gin_trgm_ops)`;
++}
++
++const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
++if (isMain) {
++  runMigrations()
++    .then(async () => {
++      console.log('[migrate] done');
++      await closeDb();
++    })
++    .catch(async (err) => {
++      console.error('[migrate] failed', err);
++      await closeDb();
++      process.exit(1);
++    });
++}

added packages/database/src/schema/_common.ts +23 −0

++import { timestamp, varchar, customType } from 'drizzle-orm/pg-core';
++
++export const createdAt = () => timestamp('created_at', { withTimezone: true }).notNull().defaultNow();
++export const updatedAt = () => timestamp('updated_at', { withTimezone: true }).notNull().defaultNow();
++
++/** Public CancerIndex identifier column (CI-CAN-00000001 …). */
++export const ciId = (name = 'id') => varchar(name, { length: 32 });
++
++/** pgvector column (embedding model is stored alongside, never mix models in one column without it). */
++export const vector = customType<{ data: number[]; driverData: string; config: { dimensions: number } }>({
++  dataType(config) {
++    return `vector(${config?.dimensions ?? 1536})`;
++  },
++  toDriver(value) {
++    return `[${value.join(',')}]`;
++  },
++  fromDriver(value) {
++    return value
++      .slice(1, -1)
++      .split(',')
++      .map((v) => Number(v));
++  },
++});

added packages/database/src/schema/cancers.ts +139 −0

++import { pgTable, text, integer, boolean, bigserial, index, uniqueIndex, real, jsonb } from 'drizzle-orm/pg-core';
++import { ciId, createdAt, updatedAt } from './_common.js';
++
++/** Canonical cancer entity (CLAUDE.md §5). One row per recognized disease concept, never per alias. */
++export const cancers = pgTable(
++  'cancers',
++  {
++    id: ciId().primaryKey(), // CI-CAN-…
++    slug: text('slug').notNull(),
++    canonicalName: text('canonical_name').notNull(),
++    shortName: text('short_name'),
++    entityType: text('entity_type').notNull().default('cancer'), // cancer | cancer_family | histology | subtype | molecular_subtype | hematologic_malignancy | precursor_condition | other
++    malignant: boolean('malignant').notNull().default(true),
++    solidTumor: boolean('solid_tumor').notNull().default(true),
++    hematologic: boolean('hematologic').notNull().default(false),
++    pediatricRelevant: boolean('pediatric_relevant').notNull().default(false),
++    rareCancer: boolean('rare_cancer'), // null = unknown (no incidence data yet)
++    topLevel: boolean('top_level').notNull().default(false), // member of the mutually exclusive global ranking set (§247)
++    description: text('description'),
++    descriptionProvenanceId: integer('description_provenance_id'),
++    primaryNcitCode: text('primary_ncit_code'),
++    primaryOncotreeCode: text('primary_oncotree_code'),
++    depth: integer('depth').notNull().default(0), // depth in the NCIt-derived hierarchy from root "Neoplasm"
++    status: text('status').notNull().default('active'), // active | deprecated | merged
++    mergedInto: ciId('merged_into'),
++    deprecatedReason: text('deprecated_reason'),
++    classificationVersion: text('classification_version'),
++    semanticTypes: text('semantic_types').array().notNull().default([]),
++    createdAt: createdAt(),
++    updatedAt: updatedAt(),
++  },
++  (t) => [
++    uniqueIndex('cancers_slug_uq').on(t.slug),
++    uniqueIndex('cancers_ncit_uq').on(t.primaryNcitCode),
++    index('cancers_name_idx').on(t.canonicalName),
++    index('cancers_type_idx').on(t.entityType, t.malignant, t.topLevel),
++  ],
++);
++
++export const cancerAliases = pgTable(
++  'cancer_aliases',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    cancerId: ciId('cancer_id').notNull(),
++    alias: text('alias').notNull(),
++    normalized: text('normalized').notNull(),
++    aliasType: text('alias_type').notNull().default('synonym'), // preferred | synonym | abbreviation | historical | deprecated | display
++    sourceId: ciId('source_id'),
++    sourceTerminology: text('source_terminology'), // NCIt synonym source (e.g. CTRP, caDSR) or connector id
++    language: text('language').notNull().default('en'),
++  },
++  (t) => [uniqueIndex('cancer_aliases_uq').on(t.cancerId, t.normalized, t.aliasType), index('cancer_aliases_norm_idx').on(t.normalized)],
++);
++
++/** Multi-dimensional hierarchy (CLAUDE.md §4): several trees coexist. */
++export const cancerHierarchy = pgTable(
++  'cancer_hierarchy',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    parentId: ciId('parent_id').notNull(),
++    childId: ciId('child_id').notNull(),
++    hierarchyType: text('hierarchy_type').notNull(), // ncit | oncotree | anatomical | histological | molecular | who | icd | seer
++    sourceId: ciId('source_id'),
++  },
++  (t) => [uniqueIndex('cancer_hierarchy_uq').on(t.parentId, t.childId, t.hierarchyType), index('cancer_hierarchy_child_idx').on(t.childId)],
++);
++
++/** Cross-reference codes (CLAUDE.md §220-221, §347): searchable, never buried in JSON. */
++export const cancerCodes = pgTable(
++  'cancer_codes',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    cancerId: ciId('cancer_id').notNull(),
++    system: text('system').notNull(), // ncit | icd10 | icd10cm | icdo_topography | icdo_morphology | doid | oncotree | umls | mesh | mondo | seer_site | efo | orphanet | gdc_project
++    code: text('code').notNull(),
++    matchType: text('match_type').notNull().default('EXACT_IDENTIFIER'),
++    sourceId: ciId('source_id'),
++    validFrom: text('valid_from'),
++    validTo: text('valid_to'),
++  },
++  (t) => [uniqueIndex('cancer_codes_uq').on(t.cancerId, t.system, t.code), index('cancer_codes_lookup_idx').on(t.system, t.code)],
++);
++
++export const anatomicalSites = pgTable(
++  'anatomical_sites',
++  {
++    id: ciId().primaryKey(), // CI-ANAT-…
++    name: text('name').notNull(),
++    slug: text('slug').notNull(),
++    ncitCode: text('ncit_code'),
++    uberonId: text('uberon_id'),
++    parentId: ciId('parent_id'),
++    system: text('system'), // e.g. Digestive, Respiratory, Hematopoietic
++  },
++  (t) => [uniqueIndex('anatomical_sites_slug_uq').on(t.slug)],
++);
++
++export const cancerAnatomy = pgTable(
++  'cancer_anatomy',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    cancerId: ciId('cancer_id').notNull(),
++    siteId: ciId('site_id').notNull(),
++    relation: text('relation').notNull().default('primary'), // primary | metastatic
++    sourceId: ciId('source_id'),
++  },
++  (t) => [uniqueIndex('cancer_anatomy_uq').on(t.cancerId, t.siteId, t.relation)],
++);
++
++/** Canonical geography (CLAUDE.md §117). */
++export const geographies = pgTable(
++  'geographies',
++  {
++    id: ciId().primaryKey(), // CI-GEO-…
++    slug: text('slug').notNull(),
++    name: text('name').notNull(),
++    kind: text('kind').notNull(), // world | region | who_region | country | subdivision
++    iso2: text('iso2'),
++    iso3: text('iso3'),
++    parentId: ciId('parent_id'),
++    whoRegion: text('who_region'),
++    population: integer('population'),
++    populationYear: integer('population_year'),
++  },
++  (t) => [uniqueIndex('geographies_slug_uq').on(t.slug), index('geographies_iso3_idx').on(t.iso3)],
++);
++
++/** Cohort definitions (CLAUDE.md §218): attribute combinations that are not taxonomy nodes. */
++export const cohortDefinitions = pgTable('cohort_definitions', {
++  id: bigserial('id', { mode: 'number' }).primaryKey(),
++  name: text('name').notNull(),
++  cancerId: ciId('cancer_id').notNull(),
++  biomarkerIds: text('biomarker_ids').array().notNull().default([]),
++  variantIds: text('variant_ids').array().notNull().default([]),
++  stage: text('stage'),
++  attributes: jsonb('attributes').$type<Record<string, unknown>>().notNull().default({}),
++  confidence: real('confidence'),
++  createdAt: createdAt(),
++});

added packages/database/src/schema/drugs.ts +84 −0

++import { pgTable, text, integer, bigserial, index, uniqueIndex, boolean, jsonb } from 'drizzle-orm/pg-core';
++import { ciId, createdAt, updatedAt } from './_common.js';
++
++/** Drugs (CLAUDE.md §7, §344): brand names are aliases, never separate molecules. */
++export const drugs = pgTable(
++  'drugs',
++  {
++    id: ciId().primaryKey(), // CI-DRUG-…
++    slug: text('slug').notNull(),
++    name: text('name').notNull(), // generic / INN preferred
++    kind: text('kind'), // small_molecule | monoclonal_antibody | adc | bispecific | car_t | cell_therapy | gene_therapy | vaccine | radiopharmaceutical | chemotherapy | hormonal | immunotherapy | targeted | other
++    ncitCode: text('ncit_code'),
++    chemblId: text('chembl_id'),
++    civicTherapyId: integer('civic_therapy_id'),
++    drugbankId: text('drugbank_id'),
++    pubchemCid: text('pubchem_cid'),
++    unii: text('unii'),
++    mechanism: text('mechanism'),
++    targetGeneIds: text('target_gene_ids').array().notNull().default([]),
++    developmentStatus: text('development_status'),
++    description: text('description'),
++    createdAt: createdAt(),
++    updatedAt: updatedAt(),
++  },
++  (t) => [uniqueIndex('drugs_slug_uq').on(t.slug), index('drugs_ncit_idx').on(t.ncitCode), index('drugs_civic_idx').on(t.civicTherapyId), index('drugs_chembl_idx').on(t.chemblId)],
++);
++
++export const drugAliases = pgTable(
++  'drug_aliases',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    drugId: ciId('drug_id').notNull(),
++    alias: text('alias').notNull(),
++    normalized: text('normalized').notNull(),
++    aliasType: text('alias_type').notNull().default('synonym'), // generic | brand | development_code | salt | synonym
++    sourceId: ciId('source_id'),
++  },
++  (t) => [uniqueIndex('drug_aliases_uq').on(t.drugId, t.normalized, t.aliasType), index('drug_aliases_norm_idx').on(t.normalized)],
++);
++
++/** Regimens / combinations (CLAUDE.md §53). */
++export const treatmentRegimens = pgTable(
++  'treatment_regimens',
++  {
++    id: ciId().primaryKey(), // CI-TRT-…
++    slug: text('slug').notNull(),
++    name: text('name').notNull(),
++    componentDrugIds: text('component_drug_ids').array().notNull().default([]),
++    modality: text('modality').notNull().default('drug_combination'), // drug | drug_combination | surgery | radiotherapy | transplantation | cell_therapy | surveillance
++    description: text('description'),
++    createdAt: createdAt(),
++  },
++  (t) => [uniqueIndex('treatment_regimens_slug_uq').on(t.slug)],
++);
++
++/** Country-aware regulatory status (CLAUDE.md §13). Never a bare approved=true. */
++export const drugApprovals = pgTable(
++  'drug_approvals',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    drugId: ciId('drug_id').notNull(),
++    cancerId: ciId('cancer_id'),
++    biomarkerIds: text('biomarker_ids').array().notNull().default([]),
++    tumorAgnostic: boolean('tumor_agnostic').notNull().default(false),
++    jurisdiction: text('jurisdiction').notNull(), // US | CA | EU | UK | AU | JP | CH | OTHER
++    authority: text('authority').notNull(), // FDA | Health Canada | EMA | MHRA | TGA | PMDA | Swissmedic
++    indication: text('indication').notNull(),
++    lineOfTherapy: text('line_of_therapy'),
++    diseaseStage: text('disease_stage'),
++    approvalType: text('approval_type'),
++    accelerated: boolean('accelerated'),
++    conditional: boolean('conditional'),
++    approvalDate: text('approval_date'),
++    withdrawalDate: text('withdrawal_date'),
++    status: text('status').notNull(), // approved | conditional | accelerated | withdrawn | superseded
++    applicationNumber: text('application_number'),
++    sourceId: ciId('source_id').notNull(),
++    provenanceId: integer('provenance_id').notNull(),
++    raw: jsonb('raw'),
++    createdAt: createdAt(),
++    updatedAt: updatedAt(),
++  },
++  (t) => [index('drug_approvals_drug_idx').on(t.drugId), index('drug_approvals_cancer_idx').on(t.cancerId)],
++);

added packages/database/src/schema/epidemiology.ts +61 −0

++import { pgTable, text, integer, bigserial, index, uniqueIndex, real, doublePrecision } from 'drizzle-orm/pg-core';
++import { ciId, updatedAt } from './_common.js';
++
++/** Time-aware epidemiology observations (CLAUDE.md §71): never overwrite a year with another. */
++export const epidemiologyObservations = pgTable(
++  'epidemiology_observations',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    cancerId: ciId('cancer_id').notNull(),
++    geographyId: ciId('geography_id').notNull(),
++    year: integer('year').notNull(),
++    yearEnd: integer('year_end'), // for multi-year aggregates (e.g. 2018-2022)
++    sex: text('sex').notNull().default('all'), // all | male | female
++    ageGroup: text('age_group').notNull().default('all'),
++    metric: text('metric').notNull(), // incidence_count | incidence_rate | as_incidence_rate | mortality_count | mortality_rate | as_mortality_rate | prevalence | prevalence_5y
++    value: doublePrecision('value').notNull(),
++    unit: text('unit').notNull(), // count | per_100k
++    lowerCi: doublePrecision('lower_ci'),
++    upperCi: doublePrecision('upper_ci'),
++    standardPopulation: text('standard_population'), // e.g. "US 2000 standard", "World (Segi)"
++    estimateType: text('estimate_type').notNull().default('observed'), // observed | estimated | projected
++    siteDefinition: text('site_definition'), // source's own site label / ICD code range
++    sourceId: ciId('source_id').notNull(),
++    provenanceId: integer('provenance_id').notNull(),
++    ingestRunId: text('ingest_run_id'),
++    updatedAt: updatedAt(),
++  },
++  (t) => [
++    uniqueIndex('epi_obs_uq').on(t.cancerId, t.geographyId, t.year, t.sex, t.ageGroup, t.metric, t.sourceId, t.siteDefinition),
++    index('epi_obs_lookup_idx').on(t.metric, t.geographyId, t.year, t.sex),
++    index('epi_obs_cancer_idx').on(t.cancerId, t.metric),
++  ],
++);
++
++/** Survival requires context (CLAUDE.md §72). */
++export const survivalObservations = pgTable(
++  'survival_observations',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    cancerId: ciId('cancer_id').notNull(),
++    geographyId: ciId('geography_id'),
++    stage: text('stage'),
++    stagingSystem: text('staging_system'),
++    sex: text('sex').notNull().default('all'),
++    ageGroup: text('age_group').notNull().default('all'),
++    diagnosisPeriod: text('diagnosis_period'),
++    survivalType: text('survival_type').notNull(), // overall | relative | cause_specific | progression_free | disease_free | net
++    durationMonths: integer('duration_months').notNull(),
++    probability: real('probability'), // 0..1
++    medianMonths: real('median_months'),
++    cohortSize: integer('cohort_size'),
++    lowerCi: real('lower_ci'),
++    upperCi: real('upper_ci'),
++    method: text('method'),
++    sourceId: ciId('source_id').notNull(),
++    provenanceId: integer('provenance_id').notNull(),
++    ingestRunId: text('ingest_run_id'),
++    updatedAt: updatedAt(),
++  },
++  (t) => [index('survival_obs_cancer_idx').on(t.cancerId, t.survivalType, t.durationMonths)],
++);

added packages/database/src/schema/evidence.ts +89 −0

++import { pgTable, text, integer, bigserial, index, uniqueIndex, boolean, jsonb, real, timestamp } from 'drizzle-orm/pg-core';
++import { ciId, createdAt, updatedAt } from './_common.js';
++
++/** Knowledge graph edge with mandatory context and provenance (CLAUDE.md §28-29, §244). */
++export const knowledgeEdges = pgTable(
++  'knowledge_edges',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    sourceEntityType: text('source_entity_type').notNull(), // cancer | gene | variant | drug | biomarker | trial | publication | pathway | risk_factor
++    sourceEntityId: text('source_entity_id').notNull(),
++    targetEntityType: text('target_entity_type').notNull(),
++    targetEntityId: text('target_entity_id').notNull(),
++    relationshipType: text('relationship_type').notNull(), // HAS_SUBTYPE | OCCURS_IN | ASSOCIATED_WITH | HAS_VARIANT | HAS_BIOMARKER | TREATED_BY | STUDIED_IN | DESCRIBED_BY | TARGETS | APPROVED_FOR | INVESTIGATED_FOR | PREDICTS_RESPONSE_TO | CONFERS_RESISTANCE_TO | PREDISPOSES_TO | PROGNOSTIC_IN | DIAGNOSTIC_OF
++    cancerContextIds: text('cancer_context_ids').array().notNull().default([]),
++    predictive: boolean('predictive'),
++    prognostic: boolean('prognostic'),
++    diagnostic: boolean('diagnostic'),
++    predisposing: boolean('predisposing'),
++    direction: text('direction'), // supports | resistance | sensitivity | neutral | unknown
++    evidenceLevel: text('evidence_level'), // source-native level (e.g. CIViC A-E) — never re-scaled silently
++    evidenceScore: real('evidence_score'),
++    evidenceCategory: text('evidence_category').notNull().default('curated_evidence'), // observed_data | published_evidence | curated_evidence | regulatory_status | clinical_guideline | computed_metric
++    status: text('status').notNull().default('active'), // active | candidate | superseded | retracted_basis
++    sourceId: ciId('source_id').notNull(),
++    sourceRecordId: text('source_record_id'),
++    provenanceIds: integer('provenance_ids').array().notNull().default([]),
++    supportCount: integer('support_count').notNull().default(1),
++    firstSeenAt: timestamp('first_seen_at', { withTimezone: true }).notNull().defaultNow(),
++    lastSeenAt: timestamp('last_seen_at', { withTimezone: true }).notNull().defaultNow(),
++  },
++  (t) => [
++    uniqueIndex('knowledge_edges_uq').on(t.sourceEntityType, t.sourceEntityId, t.targetEntityType, t.targetEntityId, t.relationshipType, t.sourceId, t.sourceRecordId),
++    index('knowledge_edges_source_idx').on(t.sourceEntityType, t.sourceEntityId, t.relationshipType),
++    index('knowledge_edges_target_idx').on(t.targetEntityType, t.targetEntityId, t.relationshipType),
++  ],
++);
++
++/** CIViC evidence items kept in their native structure (CLAUDE.md §10.9). */
++export const civicEvidenceItems = pgTable(
++  'civic_evidence_items',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    civicId: integer('civic_id').notNull(),
++    name: text('name'),
++    molecularProfileId: integer('molecular_profile_id'),
++    molecularProfileName: text('molecular_profile_name'),
++    geneSymbols: text('gene_symbols').array().notNull().default([]),
++    geneIds: text('gene_ids').array().notNull().default([]),
++    variantIds: text('variant_ids').array().notNull().default([]),
++    civicVariantIds: integer('civic_variant_ids').array().notNull().default([]),
++    diseaseName: text('disease_name'),
++    doid: text('doid'),
++    cancerId: ciId('cancer_id'),
++    cancerMatchType: text('cancer_match_type'),
++    therapyNames: text('therapy_names').array().notNull().default([]),
++    therapyIds: text('therapy_ids').array().notNull().default([]), // CI-DRUG-…
++    therapyInteractionType: text('therapy_interaction_type'),
++    evidenceType: text('evidence_type'), // PREDICTIVE | PROGNOSTIC | DIAGNOSTIC | PREDISPOSING | ONCOGENIC | FUNCTIONAL
++    evidenceLevel: text('evidence_level'), // A-E
++    evidenceDirection: text('evidence_direction'), // SUPPORTS | DOES_NOT_SUPPORT
++    significance: text('significance'), // SENSITIVITYRESPONSE | RESISTANCE | …
++    evidenceRating: integer('evidence_rating'),
++    status: text('status'), // ACCEPTED | SUBMITTED | REJECTED
++    description: text('description'),
++    pmid: text('pmid'),
++    sourceCitation: text('source_citation'),
++    phenotypes: text('phenotypes').array().notNull().default([]),
++    provenanceId: integer('provenance_id').notNull(),
++    ingestRunId: text('ingest_run_id'),
++    updatedAt: updatedAt(),
++  },
++  (t) => [uniqueIndex('civic_evidence_uq').on(t.civicId), index('civic_evidence_cancer_idx').on(t.cancerId), index('civic_evidence_gene_idx').on(t.geneSymbols)],
++);
++
++/** Risk factors / carcinogens as first-class entities (CLAUDE.md §74, §133). */
++export const riskFactors = pgTable(
++  'risk_factors',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    slug: text('slug').notNull(),
++    name: text('name').notNull(),
++    kind: text('kind').notNull(), // behavioral | infectious | environmental | occupational | genetic | hormonal | demographic | carcinogen
++    classificationAuthority: text('classification_authority'),
++    classification: text('classification'),
++    description: text('description'),
++    createdAt: createdAt(),
++  },
++  (t) => [uniqueIndex('risk_factors_slug_uq').on(t.slug)],
++);

added packages/database/src/schema/genomics.ts +184 −0

++import { pgTable, text, integer, bigserial, index, uniqueIndex, real, jsonb, boolean, timestamp } from 'drizzle-orm/pg-core';
++import { ciId, createdAt, updatedAt } from './_common.js';
++
++/** Genes — HGNC is authoritative for symbols (CLAUDE.md §11, §143). */
++export const genes = pgTable(
++  'genes',
++  {
++    id: ciId().primaryKey(), // CI-GENE-…
++    hgncId: text('hgnc_id'), // HGNC:11998
++    symbol: text('symbol').notNull(),
++    name: text('name'),
++    locusType: text('locus_type'),
++    locusGroup: text('locus_group'),
++    location: text('location'),
++    chromosome: text('chromosome'),
++    ensemblGeneId: text('ensembl_gene_id'),
++    ncbiGeneId: text('ncbi_gene_id'),
++    omimIds: text('omim_ids').array().notNull().default([]),
++    uniprotIds: text('uniprot_ids').array().notNull().default([]),
++    refseqAccession: text('refseq_accession'),
++    prevSymbols: text('prev_symbols').array().notNull().default([]),
++    aliasSymbols: text('alias_symbols').array().notNull().default([]),
++    geneFamilies: text('gene_families').array().notNull().default([]),
++    status: text('status').notNull().default('Approved'),
++    isCancerGene: boolean('is_cancer_gene').notNull().default(false), // has ≥1 curated cancer edge (derived)
++    civicGeneId: integer('civic_gene_id'),
++    description: text('description'),
++    createdAt: createdAt(),
++    updatedAt: updatedAt(),
++  },
++  (t) => [uniqueIndex('genes_symbol_uq').on(t.symbol), uniqueIndex('genes_hgnc_uq').on(t.hgncId), index('genes_ensembl_idx').on(t.ensemblGeneId), index('genes_ncbi_idx').on(t.ncbiGeneId)],
++);
++
++export const geneAliases = pgTable(
++  'gene_aliases',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    geneId: ciId('gene_id').notNull(),
++    alias: text('alias').notNull(),
++    aliasType: text('alias_type').notNull(), // prev_symbol | alias_symbol | prev_name | alias_name
++    sourceId: ciId('source_id'),
++  },
++  (t) => [uniqueIndex('gene_aliases_uq').on(t.geneId, t.alias, t.aliasType), index('gene_aliases_alias_idx').on(t.alias)],
++);
++
++/** Variants (CLAUDE.md §235-239): coordinates always carry assembly; original + normalized kept. */
++export const variants = pgTable(
++  'variants',
++  {
++    id: ciId().primaryKey(), // CI-VAR-…
++    slug: text('slug').notNull(),
++    geneId: ciId('gene_id'),
++    geneSymbol: text('gene_symbol'),
++    name: text('name').notNull(), // e.g. "V600E", "Exon 19 Deletion", "Amplification"
++    variantType: text('variant_type'), // SO-style: SNV | MNV | insertion | deletion | indel | fusion | amplification | deletion_cna | loss_of_heterozygosity | promoter_mutation | splice | expression | epigenetic | structural | other
++    hgvsG: text('hgvs_g'),
++    hgvsC: text('hgvs_c'),
++    hgvsP: text('hgvs_p'),
++    assembly: text('assembly'), // GRCh37 | GRCh38
++    chromosome: text('chromosome'),
++    start: integer('start'),
++    end: integer('end'),
++    referenceBases: text('reference_bases'),
++    alternateBases: text('alternate_bases'),
++    coordinates: jsonb('coordinates').$type<Array<Record<string, unknown>>>().notNull().default([]), // per-assembly list
++    clinvarVariationId: text('clinvar_variation_id'),
++    civicVariantId: integer('civic_variant_id'),
++    dbsnpIds: text('dbsnp_ids').array().notNull().default([]),
++    fusionPartners: text('fusion_partners').array().notNull().default([]), // [5' gene, 3' gene]
++    createdAt: createdAt(),
++    updatedAt: updatedAt(),
++  },
++  (t) => [uniqueIndex('variants_slug_uq').on(t.slug), index('variants_gene_idx').on(t.geneId), index('variants_clinvar_idx').on(t.clinvarVariationId), index('variants_civic_idx').on(t.civicVariantId)],
++);
++
++export const variantAliases = pgTable(
++  'variant_aliases',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    variantId: ciId('variant_id').notNull(),
++    alias: text('alias').notNull(),
++    sourceId: ciId('source_id'),
++  },
++  (t) => [uniqueIndex('variant_aliases_uq').on(t.variantId, t.alias)],
++);
++
++/** ClinVar interpretations (CLAUDE.md §10.7): structured, never flattened. */
++export const variantClinicalSignificance = pgTable(
++  'variant_clinical_significance',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    variantId: ciId('variant_id').notNull(),
++    clinvarVariationId: text('clinvar_variation_id').notNull(),
++    clinicalSignificance: text('clinical_significance').notNull(),
++    reviewStatus: text('review_status'),
++    starRating: integer('star_rating'),
++    lastEvaluated: text('last_evaluated'),
++    conditions: text('conditions').array().notNull().default([]),
++    conditionCancerIds: text('condition_cancer_ids').array().notNull().default([]),
++    originSimple: text('origin_simple'),
++    numberSubmitters: integer('number_submitters'),
++    provenanceId: integer('provenance_id').notNull(),
++    ingestRunId: text('ingest_run_id'),
++    updatedAt: updatedAt(),
++  },
++  (t) => [uniqueIndex('variant_clinsig_uq').on(t.clinvarVariationId)],
++);
++
++export const biomarkers = pgTable(
++  'biomarkers',
++  {
++    id: ciId().primaryKey(), // CI-BIO-…
++    slug: text('slug').notNull(),
++    name: text('name').notNull(),
++    kind: text('kind').notNull(), // gene_mutation | protein_expression | hormone_receptor | immune_marker | msi | tmb | hrd | ctdna | methylation | signature | cell_surface | other
++    geneId: ciId('gene_id'),
++    ncitCode: text('ncit_code'),
++    description: text('description'),
++    measurement: jsonb('measurement').$type<Record<string, unknown>>().notNull().default({}), // assay/clone/scoring/thresholds (§241-243)
++    createdAt: createdAt(),
++    updatedAt: updatedAt(),
++  },
++  (t) => [uniqueIndex('biomarkers_slug_uq').on(t.slug)],
++);
++
++/** Genomic studies / cohorts (GDC projects, cBioPortal studies…) — original study IDs preserved. */
++export const genomicCohorts = pgTable(
++  'genomic_cohorts',
++  {
++    id: ciId().primaryKey(), // CI-STUDY-…
++    sourceId: ciId('source_id').notNull(),
++    studyId: text('study_id').notNull(), // TCGA-PAAD
++    name: text('name').notNull(),
++    program: text('program'),
++    primarySites: text('primary_sites').array().notNull().default([]),
++    diseaseTypes: text('disease_types').array().notNull().default([]),
++    cancerId: ciId('cancer_id'),
++    cancerMatchType: text('cancer_match_type'),
++    caseCount: integer('case_count'),
++    casesWithSsm: integer('cases_with_ssm'), // denominator for mutation frequencies
++    dataRelease: text('data_release'),
++    accessLevel: text('access_level').notNull().default('open'),
++    url: text('url'),
++    provenanceId: integer('provenance_id'),
++    updatedAt: updatedAt(),
++  },
++  (t) => [uniqueIndex('genomic_cohorts_uq').on(t.sourceId, t.studyId), index('genomic_cohorts_cancer_idx').on(t.cancerId)],
++);
++
++/** Gene alteration frequency per cohort — denominator is mandatory (CLAUDE.md §261-262). */
++export const cancerGeneFrequencies = pgTable(
++  'cancer_gene_frequencies',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    cohortId: ciId('cohort_id').notNull(),
++    cancerId: ciId('cancer_id'),
++    geneId: ciId('gene_id'),
++    geneSymbol: text('gene_symbol').notNull(),
++    alterationType: text('alteration_type').notNull().default('ssm'), // ssm | cnv_gain | cnv_loss | fusion
++    casesAffected: integer('cases_affected').notNull(),
++    casesProfiled: integer('cases_profiled').notNull(),
++    frequency: real('frequency').notNull(),
++    rank: integer('rank'),
++    dataRelease: text('data_release'),
++    provenanceId: integer('provenance_id').notNull(),
++    updatedAt: updatedAt(),
++  },
++  (t) => [uniqueIndex('cancer_gene_freq_uq').on(t.cohortId, t.geneSymbol, t.alterationType), index('cancer_gene_freq_cancer_idx').on(t.cancerId, t.frequency), index('cancer_gene_freq_gene_idx').on(t.geneId)],
++);
++
++export const entityEmbeddings = pgTable(
++  'entity_embeddings',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    entityType: text('entity_type').notNull(),
++    entityId: text('entity_id').notNull(),
++    model: text('model').notNull(),
++    dimensions: integer('dimensions').notNull(),
++    textHash: text('text_hash').notNull(),
++    embedding: text('embedding'), // stored via raw SQL cast to vector(n); model recorded on the row
++    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
++  },
++  (t) => [uniqueIndex('entity_embeddings_uq').on(t.entityType, t.entityId, t.model)],
++);

added packages/database/src/schema/index.ts +9 −0

++export * from './sources.js';
++export * from './cancers.js';
++export * from './genomics.js';
++export * from './drugs.js';
++export * from './trials.js';
++export * from './publications.js';
++export * from './evidence.js';
++export * from './epidemiology.js';
++export * from './rankings.js';

added packages/database/src/schema/publications.ts +68 −0

++import { pgTable, text, integer, bigserial, index, uniqueIndex, boolean, jsonb, real } from 'drizzle-orm/pg-core';
++import { ciId, createdAt, updatedAt } from './_common.js';
++
++/** Publications (CLAUDE.md §10.6, §342): one entity per paper across PubMed/DOI/Europe PMC. */
++export const publications = pgTable(
++  'publications',
++  {
++    id: ciId().primaryKey(), // CI-PUB-…
++    pmid: text('pmid'),
++    doi: text('doi'),
++    pmcid: text('pmcid'),
++    title: text('title').notNull(),
++    abstract: text('abstract'), // stored only where NLM terms permit (abstract text may carry publisher copyright; we store it for indexing, display truncated with link)
++    journal: text('journal'),
++    journalIso: text('journal_iso'),
++    pubDate: text('pub_date'),
++    pubYear: integer('pub_year'),
++    publicationTypes: text('publication_types').array().notNull().default([]),
++    meshTerms: jsonb('mesh_terms').$type<Array<{ descriptor: string; ui?: string; major: boolean; qualifiers?: string[] }>>().notNull().default([]),
++    authors: jsonb('authors').$type<Array<{ name: string; affiliation?: string; orcid?: string }>>().notNull().default([]),
++    language: text('language'),
++    isPreprint: boolean('is_preprint').notNull().default(false),
++    retracted: boolean('retracted').notNull().default(false),
++    retractionNotice: text('retraction_notice'),
++    nctIds: text('nct_ids').array().notNull().default([]),
++    citedByCount: integer('cited_by_count'),
++    sourceRecordId: integer('source_record_id'),
++    ingestRunId: text('ingest_run_id'),
++    createdAt: createdAt(),
++    updatedAt: updatedAt(),
++  },
++  (t) => [uniqueIndex('publications_pmid_uq').on(t.pmid), index('publications_doi_idx').on(t.doi), index('publications_year_idx').on(t.pubYear), index('publications_retracted_idx').on(t.retracted)],
++);
++
++/** publication → entity links (CLAUDE.md §165-166, §271): extraction method + status preserved. */
++export const publicationEntityEdges = pgTable(
++  'publication_entity_edges',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    publicationId: ciId('publication_id').notNull(),
++    entityType: text('entity_type').notNull(), // cancer | gene | variant | drug | biomarker | trial
++    entityId: text('entity_id').notNull(),
++    method: text('method').notNull(), // mesh | dictionary | registry_reference | civic_curation | ner | llm | curator
++    confidence: real('confidence'),
++    status: text('status').notNull().default('candidate'), // candidate | validated | rejected
++    sourceId: ciId('source_id'),
++    ingestRunId: text('ingest_run_id'),
++    createdAt: createdAt(),
++  },
++  (t) => [uniqueIndex('pub_entity_edges_uq').on(t.publicationId, t.entityType, t.entityId, t.method), index('pub_entity_edges_entity_idx').on(t.entityType, t.entityId)],
++);
++
++/** Research activity counts per cancer from PubMed queries — the formula (query string) is stored (CLAUDE.md §251). */
++export const literatureCounts = pgTable(
++  'literature_counts',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    cancerId: ciId('cancer_id').notNull(),
++    windowKey: text('window_key').notNull(), // all | 12m | 5y | 10y | y2015 …
++    windowStart: text('window_start'),
++    windowEnd: text('window_end'),
++    query: text('query').notNull(), // exact PubMed query used
++    count: integer('count').notNull(),
++    provenanceId: integer('provenance_id').notNull(),
++    computedAt: updatedAt(),
++  },
++  (t) => [uniqueIndex('literature_counts_uq').on(t.cancerId, t.windowKey), index('literature_counts_window_idx').on(t.windowKey, t.count)],
++);

added packages/database/src/schema/rankings.ts +138 −0

++import { pgTable, text, integer, bigserial, index, uniqueIndex, real, jsonb, boolean, timestamp, doublePrecision } from 'drizzle-orm/pg-core';
++import { ciId, createdAt, updatedAt } from './_common.js';
++
++/** Metric catalog (CLAUDE.md §250-251): every derived number has a versioned formula. */
++export const metricDefinitions = pgTable(
++  'metric_definitions',
++  {
++    id: ciId().primaryKey(), // CI-METRIC-…
++    slug: text('slug').notNull(), // active_trials | mortality_incidence_ratio | …
++    name: text('name').notNull(),
++    description: text('description').notNull(),
++    formula: text('formula').notNull(),
++    formulaVersion: text('formula_version').notNull(), // ci-mir-v1
++    unit: text('unit').notNull(),
++    higherIsWorse: boolean('higher_is_worse'),
++    aggregation: text('aggregation'),
++    validDimensions: text('valid_dimensions').array().notNull().default([]),
++    sourceSlugs: text('source_slugs').array().notNull().default([]),
++    category: text('category').notNull(), // burden | lethality | trend | rarity | treatment | trials | research | molecular | unmet_need | composite
++    eligibility: jsonb('eligibility').$type<Record<string, unknown>>().notNull().default({}),
++    experimental: boolean('experimental').notNull().default(false),
++    createdAt: createdAt(),
++    updatedAt: updatedAt(),
++  },
++  (t) => [uniqueIndex('metric_definitions_slug_uq').on(t.slug)],
++);
++
++/** Ranking snapshot = one metric × one scope × one formula version at one time (CLAUDE.md §33, §184). */
++export const rankingSnapshots = pgTable(
++  'ranking_snapshots',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    metricId: ciId('metric_id').notNull(),
++    metricSlug: text('metric_slug').notNull(),
++    scopeKey: text('scope_key').notNull(), // e.g. "geo=world|sex=all|age=all|year=2022|level=top"
++    geography: text('geography').notNull().default('WORLD'),
++    sex: text('sex').notNull().default('all'),
++    ageGroup: text('age_group').notNull().default('all'),
++    year: integer('year'),
++    entityLevel: text('entity_level').notNull().default('top'), // top | histology | subtype | rare | all
++    formulaVersion: text('formula_version').notNull(),
++    eligibleEntities: integer('eligible_entities').notNull(),
++    inputsHash: text('inputs_hash').notNull(),
++    sourceIds: text('source_ids').array().notNull().default([]),
++    isCurrent: boolean('is_current').notNull().default(true),
++    generatedAt: timestamp('generated_at', { withTimezone: true }).notNull().defaultNow(),
++  },
++  (t) => [index('ranking_snapshots_lookup_idx').on(t.metricSlug, t.scopeKey, t.isCurrent)],
++);
++
++export const rankings = pgTable(
++  'rankings',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    snapshotId: integer('snapshot_id').notNull(),
++    metricSlug: text('metric_slug').notNull(),
++    scopeKey: text('scope_key').notNull(),
++    cancerId: ciId('cancer_id').notNull(),
++    rank: integer('rank').notNull(),
++    eligibleEntities: integer('eligible_entities').notNull(),
++    percentile: real('percentile').notNull(),
++    value: doublePrecision('value').notNull(),
++    unit: text('unit').notNull(),
++    confidence: text('confidence').notNull().default('MEDIUM'), // HIGH | MEDIUM | LOW | INSUFFICIENT_DATA
++    inputs: jsonb('inputs').$type<Record<string, unknown>>().notNull().default({}), // lineage: observation ids, counts, formula inputs
++    breakdown: jsonb('breakdown').$type<Record<string, number>>(), // composite components
++    previousRank: integer('previous_rank'),
++    generatedAt: timestamp('generated_at', { withTimezone: true }).notNull().defaultNow(),
++  },
++  (t) => [uniqueIndex('rankings_uq').on(t.snapshotId, t.cancerId), index('rankings_cancer_idx').on(t.cancerId, t.metricSlug), index('rankings_lookup_idx').on(t.metricSlug, t.scopeKey, t.rank)],
++);
++
++/** Precomputed counters per entity, refreshed deterministically from canonical relations (CLAUDE.md §287). */
++export const entityCounters = pgTable(
++  'entity_counters',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    entityType: text('entity_type').notNull(),
++    entityId: text('entity_id').notNull(),
++    trialCount: integer('trial_count').notNull().default(0),
++    activeTrialCount: integer('active_trial_count').notNull().default(0),
++    recruitingTrialCount: integer('recruiting_trial_count').notNull().default(0),
++    phase3TrialCount: integer('phase3_trial_count').notNull().default(0),
++    publicationCount: integer('publication_count').notNull().default(0),
++    publicationCount5y: integer('publication_count_5y').notNull().default(0),
++    publicationCount12m: integer('publication_count_12m').notNull().default(0),
++    geneCount: integer('gene_count').notNull().default(0),
++    variantCount: integer('variant_count').notNull().default(0),
++    drugCount: integer('drug_count').notNull().default(0),
++    approvedDrugCount: integer('approved_drug_count').notNull().default(0),
++    evidenceCount: integer('evidence_count').notNull().default(0),
++    cohortCount: integer('cohort_count').notNull().default(0),
++    subtypeCount: integer('subtype_count').notNull().default(0),
++    descendantCount: integer('descendant_count').notNull().default(0),
++    epidemiologyObsCount: integer('epidemiology_obs_count').notNull().default(0),
++    survivalObsCount: integer('survival_obs_count').notNull().default(0),
++    completeness: jsonb('completeness').$type<Record<string, number>>().notNull().default({}),
++    computedAt: updatedAt(),
++  },
++  (t) => [uniqueIndex('entity_counters_uq').on(t.entityType, t.entityId), index('entity_counters_trials_idx').on(t.entityType, t.activeTrialCount)],
++);
++
++/** Public API keys (CLAUDE.md §190-191). */
++export const apiKeys = pgTable(
++  'api_keys',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    keyHash: text('key_hash').notNull(),
++    prefix: text('prefix').notNull(),
++    label: text('label'),
++    ownerEmail: text('owner_email'),
++    tier: text('tier').notNull().default('free'), // free | research | pro | institutional
++    rateLimitPerMinute: integer('rate_limit_per_minute').notNull().default(60),
++    active: boolean('active').notNull().default(true),
++    lastUsedAt: timestamp('last_used_at', { withTimezone: true }),
++    createdAt: createdAt(),
++  },
++  (t) => [uniqueIndex('api_keys_hash_uq').on(t.keyHash)],
++);
++
++/** Cached AI syntheses (CLAUDE.md §44, §322) — model, prompt version and record snapshot recorded. */
++export const aiAnswers = pgTable(
++  'ai_answers',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    kind: text('kind').notNull(), // cancer_summary | ask
++    subjectId: text('subject_id'),
++    questionHash: text('question_hash').notNull(),
++    question: text('question'),
++    answer: jsonb('answer').$type<Record<string, unknown>>().notNull(),
++    model: text('model').notNull(),
++    promptVersion: text('prompt_version').notNull(),
++    sourceSnapshot: jsonb('source_snapshot').$type<Record<string, unknown>>().notNull().default({}),
++    dataAsOf: timestamp('data_as_of', { withTimezone: true }).notNull(),
++    createdAt: createdAt(),
++  },
++  (t) => [uniqueIndex('ai_answers_uq').on(t.kind, t.questionHash, t.promptVersion)],
++);

added packages/database/src/schema/sources.ts +228 −0

++import { pgTable, text, integer, bigint, bigserial, boolean, jsonb, timestamp, index, uniqueIndex, real, varchar } from 'drizzle-orm/pg-core';
++import { ciId, createdAt, updatedAt } from './_common.js';
++
++/** Per-namespace counters for stable public IDs (never exposed, never reused). */
++export const idSequences = pgTable('id_sequences', {
++  namespace: varchar('namespace', { length: 16 }).primaryKey(),
++  next: bigint('next', { mode: 'number' }).notNull().default(1),
++});
++
++/** Source registry + license registry (CLAUDE.md §9, §95, §142). Seeded from connector manifests. */
++export const sources = pgTable(
++  'sources',
++  {
++    id: ciId().primaryKey(), // CI-SOURCE-…
++    slug: text('slug').notNull(), // connector id, e.g. "clinicaltrials"
++    name: text('name').notNull(),
++    organization: text('organization'),
++    category: text('category').notNull(), // terminology | genomics | epidemiology | trials | literature | variants | drugs | regulatory
++    description: text('description'),
++    homepage: text('homepage'),
++    docsUrl: text('docs_url'),
++    termsUrl: text('terms_url'),
++    accessType: text('access_type').notNull(), // api|bulk|rss|ftp|graphql|rest|scrape|manual
++    accessAuth: text('access_auth').notNull(), // none|api_key|oauth|account|controlled
++    license: text('license'),
++    licenseStatus: text('license_status').notNull().default('review'), // review | approved | restricted | blocked
++    commercialUse: text('commercial_use').notNull().default('unknown'), // allowed | restricted | prohibited | unknown
++    redistribution: text('redistribution').notNull().default('unknown'), // allowed | attribution | restricted | prohibited | unknown
++    attribution: text('attribution'),
++    licenseReviewedAt: timestamp('license_reviewed_at', { withTimezone: true }),
++    approvedForProduction: boolean('approved_for_production').notNull().default(false),
++    updateFrequency: text('update_frequency'),
++    supportsIncremental: boolean('supports_incremental').notNull().default(false),
++    entities: text('entities').array().notNull().default([]),
++    metrics: text('metrics').array().notNull().default([]),
++    rateLimit: text('rate_limit'),
++    status: text('status').notNull().default('planned'), // planned | active | paused | degraded | awaiting_credentials | review | retired
++    tier: integer('tier').notNull().default(0),
++    manifest: jsonb('manifest').$type<Record<string, unknown>>().notNull().default({}),
++    createdAt: createdAt(),
++    updatedAt: updatedAt(),
++  },
++  (t) => [uniqueIndex('sources_slug_uq').on(t.slug)],
++);
++
++/** Every connector execution (CLAUDE.md §24, §176). */
++export const ingestRuns = pgTable(
++  'ingest_runs',
++  {
++    id: text('id').primaryKey(), // ING-CLINICALTRIALS-20260908-000019
++    connectorId: text('connector_id').notNull(),
++    sourceId: ciId('source_id').notNull(),
++    mode: text('mode').notNull().default('incremental'), // full | incremental | backfill | dry_run | probe
++    status: text('status').notNull().default('running'), // running | succeeded | failed | partial | aborted
++    startedAt: timestamp('started_at', { withTimezone: true }).notNull().defaultNow(),
++    finishedAt: timestamp('finished_at', { withTimezone: true }),
++    durationMs: integer('duration_ms'),
++    recordsFetched: integer('records_fetched').notNull().default(0),
++    recordsCreated: integer('records_created').notNull().default(0),
++    recordsUpdated: integer('records_updated').notNull().default(0),
++    recordsUnchanged: integer('records_unchanged').notNull().default(0),
++    recordsRejected: integer('records_rejected').notNull().default(0),
++    httpRequests: integer('http_requests').notNull().default(0),
++    httpFailures: integer('http_failures').notNull().default(0),
++    rateLimitEvents: integer('rate_limit_events').notNull().default(0),
++    validationFailures: integer('validation_failures').notNull().default(0),
++    schemaDrift: jsonb('schema_drift').$type<unknown[]>().notNull().default([]),
++    cursorBefore: jsonb('cursor_before'),
++    cursorAfter: jsonb('cursor_after'),
++    error: text('error'),
++    log: jsonb('log').$type<Array<{ t: string; level: string; msg: string }>>().notNull().default([]),
++    datasetVersion: text('dataset_version'),
++    anomaly: text('anomaly'), // set when a destructive update was refused (CLAUDE.md §171)
++  },
++  (t) => [index('ingest_runs_connector_idx').on(t.connectorId, t.startedAt)],
++);
++
++export const connectorCursors = pgTable('connector_cursors', {
++  connectorId: text('connector_id').primaryKey(),
++  cursor: jsonb('cursor').$type<Record<string, unknown>>().notNull().default({}),
++  lastSuccessAt: timestamp('last_success_at', { withTimezone: true }),
++  lastAttemptAt: timestamp('last_attempt_at', { withTimezone: true }),
++  paused: boolean('paused').notNull().default(false),
++  health: text('health').notNull().default('unknown'), // healthy | degraded | failing | review | awaiting_credentials | unknown
++  healthDetail: text('health_detail'),
++  updatedAt: updatedAt(),
++});
++
++/** Schema-drift detection: observed field names/types per connector entity (CLAUDE.md §25). */
++export const connectorFieldStats = pgTable(
++  'connector_field_stats',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    connectorId: text('connector_id').notNull(),
++    entity: text('entity').notNull(),
++    field: text('field').notNull(),
++    types: text('types').array().notNull().default([]),
++    seenCount: integer('seen_count').notNull().default(0),
++    nullCount: integer('null_count').notNull().default(0),
++    firstSeenRun: text('first_seen_run'),
++    lastSeenRun: text('last_seen_run'),
++    updatedAt: updatedAt(),
++  },
++  (t) => [uniqueIndex('connector_field_stats_uq').on(t.connectorId, t.entity, t.field)],
++);
++
++/** Source-native records (idempotency key = source + entity + source record id; CLAUDE.md §91-92). */
++export const sourceRecords = pgTable(
++  'source_records',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    sourceId: ciId('source_id').notNull(),
++    entityKind: text('entity_kind').notNull(),
++    sourceRecordId: text('source_record_id').notNull(),
++    payloadHash: text('payload_hash').notNull(),
++    rawPath: text('raw_path'), // data lake path /raw/{source}/{date}/{entity}/{id}.json.gz
++    status: text('status').notNull().default('active'), // active | deprecated | retracted | withdrawn | source_missing
++    firstSeenRun: text('first_seen_run'),
++    lastSeenRun: text('last_seen_run'),
++    retrievedAt: timestamp('retrieved_at', { withTimezone: true }).notNull().defaultNow(),
++    sourceUpdatedAt: timestamp('source_updated_at', { withTimezone: true }),
++    canonicalType: text('canonical_type'),
++    canonicalId: text('canonical_id'),
++    createdAt: createdAt(),
++    updatedAt: updatedAt(),
++  },
++  (t) => [
++    uniqueIndex('source_records_uq').on(t.sourceId, t.entityKind, t.sourceRecordId),
++    index('source_records_canonical_idx').on(t.canonicalType, t.canonicalId),
++  ],
++);
++
++/** Provenance record (CLAUDE.md §2). Referenced by observations, edges, descriptions, rankings. */
++export const provenance = pgTable(
++  'provenance',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    publicId: ciId('public_id'), // CI-PROV-… (minted lazily when exposed)
++    sourceId: ciId('source_id').notNull(),
++    sourceRecordId: text('source_record_id'),
++    sourceUrl: text('source_url'),
++    dataset: text('dataset'),
++    datasetVersion: text('dataset_version'),
++    publicationId: ciId('publication_id'),
++    pmid: text('pmid'),
++    doi: text('doi'),
++    retrievedAt: timestamp('retrieved_at', { withTimezone: true }).notNull(),
++    publishedAt: text('published_at'),
++    updatedAtSource: text('updated_at_source'),
++    geography: text('geography'),
++    population: text('population'),
++    cohortSize: integer('cohort_size'),
++    methodology: text('methodology'),
++    evidenceType: text('evidence_type').notNull(),
++    accessLevel: text('access_level').notNull().default('open'),
++    confidence: real('confidence'),
++    license: text('license'),
++    ingestRunId: text('ingest_run_id'),
++    createdAt: createdAt(),
++  },
++  (t) => [index('provenance_source_idx').on(t.sourceId, t.sourceRecordId), index('provenance_pmid_idx').on(t.pmid)],
++);
++
++/** Unknown disease/drug labels are never discarded (CLAUDE.md §222). */
++export const unresolvedLabels = pgTable(
++  'unresolved_labels',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    sourceId: ciId('source_id').notNull(),
++    entityKind: text('entity_kind').notNull(), // cancer | drug | gene | biomarker
++    sourceText: text('source_text').notNull(),
++    normalized: text('normalized').notNull(),
++    context: jsonb('context').$type<Record<string, unknown>>().notNull().default({}),
++    count: integer('count').notNull().default(1),
++    status: text('status').notNull().default('open'), // open | mapped | rejected | ignored
++    suggestedId: text('suggested_id'),
++    suggestedMatchType: text('suggested_match_type'),
++    suggestedScore: real('suggested_score'),
++    resolvedId: text('resolved_id'),
++    resolvedBy: text('resolved_by'),
++    createdAt: createdAt(),
++    updatedAt: updatedAt(),
++  },
++  (t) => [uniqueIndex('unresolved_labels_uq').on(t.sourceId, t.entityKind, t.normalized), index('unresolved_labels_count_idx').on(t.status, t.count)],
++);
++
++/** Entity change history (CLAUDE.md §96). */
++export const changeEvents = pgTable(
++  'change_events',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    entityType: text('entity_type').notNull(),
++    entityId: text('entity_id').notNull(),
++    kind: text('kind').notNull(), // created | updated | trial_added | approval_added | ranking_changed | merged | deprecated …
++    summary: text('summary').notNull(),
++    before: jsonb('before'),
++    after: jsonb('after'),
++    ingestRunId: text('ingest_run_id'),
++    createdAt: createdAt(),
++  },
++  (t) => [index('change_events_entity_idx').on(t.entityType, t.entityId, t.createdAt)],
++);
++
++/** Curator/admin audit log (CLAUDE.md §348). */
++export const auditLog = pgTable('audit_log', {
++  id: bigserial('id', { mode: 'number' }).primaryKey(),
++  actor: text('actor').notNull(),
++  action: text('action').notNull(),
++  entityType: text('entity_type'),
++  entityId: text('entity_id'),
++  before: jsonb('before'),
++  after: jsonb('after'),
++  reason: text('reason'),
++  createdAt: createdAt(),
++});
++
++/** Entity merge queue + audit (CLAUDE.md §70). Reversible. */
++export const entityMerges = pgTable('entity_merges', {
++  id: bigserial('id', { mode: 'number' }).primaryKey(),
++  entityType: text('entity_type').notNull(),
++  keepId: text('keep_id').notNull(),
++  mergeId: text('merge_id').notNull(),
++  evidence: jsonb('evidence').$type<Record<string, unknown>>().notNull().default({}),
++  status: text('status').notNull().default('proposed'), // proposed | merged | kept_separate | reverted
++  decidedBy: text('decided_by'),
++  decidedAt: timestamp('decided_at', { withTimezone: true }),
++  createdAt: createdAt(),
++});

added packages/database/src/schema/trials.ts +115 −0

++import { pgTable, text, integer, bigserial, index, uniqueIndex, boolean, jsonb, real, date } from 'drizzle-orm/pg-core';
++import { ciId, createdAt, updatedAt } from './_common.js';
++
++/** ClinicalTrials.gov studies (CLAUDE.md §10.5). */
++export const clinicalTrials = pgTable(
++  'clinical_trials',
++  {
++    id: ciId().primaryKey(), // CI-TRIAL-…
++    nctId: text('nct_id').notNull(),
++    briefTitle: text('brief_title').notNull(),
++    officialTitle: text('official_title'),
++    acronym: text('acronym'),
++    studyType: text('study_type'), // INTERVENTIONAL | OBSERVATIONAL | EXPANDED_ACCESS
++    phases: text('phases').array().notNull().default([]), // EARLY_PHASE1 | PHASE1 | PHASE2 | PHASE3 | PHASE4 | NA
++    overallStatus: text('overall_status'), // RECRUITING | ACTIVE_NOT_RECRUITING | COMPLETED | …
++    whyStopped: text('why_stopped'),
++    startDate: text('start_date'),
++    primaryCompletionDate: text('primary_completion_date'),
++    completionDate: text('completion_date'),
++    firstPostedDate: text('first_posted_date'),
++    lastUpdatePostedDate: text('last_update_posted_date'),
++    resultsFirstPostedDate: text('results_first_posted_date'),
++    hasResults: boolean('has_results').notNull().default(false),
++    enrollmentCount: integer('enrollment_count'),
++    enrollmentType: text('enrollment_type'),
++    leadSponsor: text('lead_sponsor'),
++    leadSponsorClass: text('lead_sponsor_class'),
++    collaborators: text('collaborators').array().notNull().default([]),
++    conditions: text('conditions').array().notNull().default([]), // raw free text
++    keywords: text('keywords').array().notNull().default([]),
++    interventions: jsonb('interventions').$type<Array<{ type: string; name: string; description?: string; otherNames?: string[] }>>().notNull().default([]),
++    arms: jsonb('arms').$type<Array<Record<string, unknown>>>().notNull().default([]),
++    primaryOutcomes: jsonb('primary_outcomes').$type<Array<Record<string, unknown>>>().notNull().default([]),
++    secondaryOutcomes: jsonb('secondary_outcomes').$type<Array<Record<string, unknown>>>().notNull().default([]),
++    eligibility: jsonb('eligibility').$type<Record<string, unknown>>().notNull().default({}),
++    sex: text('sex'),
++    minimumAge: text('minimum_age'),
++    maximumAge: text('maximum_age'),
++    countries: text('countries').array().notNull().default([]),
++    locationsCount: integer('locations_count').notNull().default(0),
++    references: jsonb('references').$type<Array<{ pmid?: string; type?: string; citation?: string }>>().notNull().default([]),
++    briefSummary: text('brief_summary'),
++    isOncology: boolean('is_oncology').notNull().default(true),
++    sourceRecordId: integer('source_record_id'),
++    ingestRunId: text('ingest_run_id'),
++    createdAt: createdAt(),
++    updatedAt: updatedAt(),
++  },
++  (t) => [
++    uniqueIndex('clinical_trials_nct_uq').on(t.nctId),
++    index('clinical_trials_status_idx').on(t.overallStatus),
++    index('clinical_trials_updated_idx').on(t.lastUpdatePostedDate),
++    index('clinical_trials_sponsor_idx').on(t.leadSponsor),
++  ],
++);
++
++/** trial → cancer mapping from free-text conditions (CLAUDE.md §10.5, §221). */
++export const trialConditions = pgTable(
++  'trial_conditions',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    trialId: ciId('trial_id').notNull(),
++    conditionText: text('condition_text').notNull(),
++    normalized: text('normalized').notNull(),
++    cancerId: ciId('cancer_id'),
++    matchType: text('match_type').notNull().default('UNRESOLVED'),
++    confidence: real('confidence'),
++  },
++  (t) => [uniqueIndex('trial_conditions_uq').on(t.trialId, t.normalized), index('trial_conditions_cancer_idx').on(t.cancerId), index('trial_conditions_norm_idx').on(t.normalized)],
++);
++
++export const trialInterventions = pgTable(
++  'trial_interventions',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    trialId: ciId('trial_id').notNull(),
++    name: text('name').notNull(),
++    normalized: text('normalized').notNull(),
++    interventionType: text('intervention_type'), // DRUG | BIOLOGICAL | DEVICE | PROCEDURE | RADIATION | BEHAVIORAL | OTHER
++    drugId: ciId('drug_id'),
++    matchType: text('match_type').notNull().default('UNRESOLVED'),
++  },
++  (t) => [uniqueIndex('trial_interventions_uq').on(t.trialId, t.normalized), index('trial_interventions_drug_idx').on(t.drugId)],
++);
++
++export const trialLocations = pgTable(
++  'trial_locations',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    trialId: ciId('trial_id').notNull(),
++    facility: text('facility'),
++    city: text('city'),
++    state: text('state'),
++    zip: text('zip'),
++    country: text('country'),
++    status: text('status'),
++    lat: real('lat'),
++    lng: real('lng'),
++  },
++  (t) => [index('trial_locations_trial_idx').on(t.trialId), index('trial_locations_country_idx').on(t.country)],
++);
++
++/** Daily trial-creation pulse (derived; CLAUDE.md §332). */
++export const trialPulse = pgTable(
++  'trial_pulse',
++  {
++    id: bigserial('id', { mode: 'number' }).primaryKey(),
++    day: date('day').notNull(),
++    cancerId: ciId('cancer_id'),
++    phase: text('phase'),
++    newTrials: integer('new_trials').notNull(),
++    computedAt: updatedAt(),
++  },
++  (t) => [uniqueIndex('trial_pulse_uq').on(t.day, t.cancerId, t.phase)],
++);

added packages/database/src/seed-data/geographies.ts +101 −0

++/** Canonical geography seed (CLAUDE.md §117). ISO 3166-1; WHO regions per WHO membership lists. */
++export interface GeographySeed {
++  slug: string;
++  name: string;
++  kind: 'world' | 'region' | 'who_region' | 'country' | 'subdivision';
++  iso2?: string;
++  iso3?: string;
++  parentSlug?: string;
++  whoRegion?: string;
++}
++
++const WHO_REGIONS: Array<[string, string]> = [
++  ['who-afro', 'WHO African Region'],
++  ['who-amro', 'WHO Region of the Americas'],
++  ['who-searo', 'WHO South-East Asia Region'],
++  ['who-euro', 'WHO European Region'],
++  ['who-emro', 'WHO Eastern Mediterranean Region'],
++  ['who-wpro', 'WHO Western Pacific Region'],
++];
++
++// [iso2, iso3, name, whoRegion]
++const COUNTRIES: Array<[string, string, string, string]> = [
++  ['US', 'USA', 'United States', 'who-amro'],
++  ['CA', 'CAN', 'Canada', 'who-amro'],
++  ['MX', 'MEX', 'Mexico', 'who-amro'],
++  ['BR', 'BRA', 'Brazil', 'who-amro'],
++  ['AR', 'ARG', 'Argentina', 'who-amro'],
++  ['CL', 'CHL', 'Chile', 'who-amro'],
++  ['CO', 'COL', 'Colombia', 'who-amro'],
++  ['PE', 'PER', 'Peru', 'who-amro'],
++  ['CU', 'CUB', 'Cuba', 'who-amro'],
++  ['GB', 'GBR', 'United Kingdom', 'who-euro'],
++  ['IE', 'IRL', 'Ireland', 'who-euro'],
++  ['FR', 'FRA', 'France', 'who-euro'],
++  ['DE', 'DEU', 'Germany', 'who-euro'],
++  ['IT', 'ITA', 'Italy', 'who-euro'],
++  ['ES', 'ESP', 'Spain', 'who-euro'],
++  ['PT', 'PRT', 'Portugal', 'who-euro'],
++  ['NL', 'NLD', 'Netherlands', 'who-euro'],
++  ['BE', 'BEL', 'Belgium', 'who-euro'],
++  ['CH', 'CHE', 'Switzerland', 'who-euro'],
++  ['AT', 'AUT', 'Austria', 'who-euro'],
++  ['SE', 'SWE', 'Sweden', 'who-euro'],
++  ['NO', 'NOR', 'Norway', 'who-euro'],
++  ['DK', 'DNK', 'Denmark', 'who-euro'],
++  ['FI', 'FIN', 'Finland', 'who-euro'],
++  ['IS', 'ISL', 'Iceland', 'who-euro'],
++  ['PL', 'POL', 'Poland', 'who-euro'],
++  ['CZ', 'CZE', 'Czechia', 'who-euro'],
++  ['HU', 'HUN', 'Hungary', 'who-euro'],
++  ['GR', 'GRC', 'Greece', 'who-euro'],
++  ['RO', 'ROU', 'Romania', 'who-euro'],
++  ['UA', 'UKR', 'Ukraine', 'who-euro'],
++  ['RU', 'RUS', 'Russian Federation', 'who-euro'],
++  ['TR', 'TUR', 'Türkiye', 'who-euro'],
++  ['IL', 'ISR', 'Israel', 'who-euro'],
++  ['EG', 'EGY', 'Egypt', 'who-emro'],
++  ['SA', 'SAU', 'Saudi Arabia', 'who-emro'],
++  ['IR', 'IRN', 'Iran', 'who-emro'],
++  ['PK', 'PAK', 'Pakistan', 'who-emro'],
++  ['MA', 'MAR', 'Morocco', 'who-emro'],
++  ['NG', 'NGA', 'Nigeria', 'who-afro'],
++  ['ZA', 'ZAF', 'South Africa', 'who-afro'],
++  ['KE', 'KEN', 'Kenya', 'who-afro'],
++  ['ET', 'ETH', 'Ethiopia', 'who-afro'],
++  ['GH', 'GHA', 'Ghana', 'who-afro'],
++  ['UG', 'UGA', 'Uganda', 'who-afro'],
++  ['TZ', 'TZA', 'Tanzania', 'who-afro'],
++  ['DZ', 'DZA', 'Algeria', 'who-afro'],
++  ['IN', 'IND', 'India', 'who-searo'],
++  ['BD', 'BGD', 'Bangladesh', 'who-searo'],
++  ['ID', 'IDN', 'Indonesia', 'who-searo'],
++  ['TH', 'THA', 'Thailand', 'who-searo'],
++  ['NP', 'NPL', 'Nepal', 'who-searo'],
++  ['LK', 'LKA', 'Sri Lanka', 'who-searo'],
++  ['CN', 'CHN', 'China', 'who-wpro'],
++  ['JP', 'JPN', 'Japan', 'who-wpro'],
++  ['KR', 'KOR', 'Republic of Korea', 'who-wpro'],
++  ['AU', 'AUS', 'Australia', 'who-wpro'],
++  ['NZ', 'NZL', 'New Zealand', 'who-wpro'],
++  ['SG', 'SGP', 'Singapore', 'who-wpro'],
++  ['MY', 'MYS', 'Malaysia', 'who-wpro'],
++  ['PH', 'PHL', 'Philippines', 'who-wpro'],
++  ['VN', 'VNM', 'Viet Nam', 'who-wpro'],
++];
++
++const US_STATES: Array<[string, string]> = [
++  ['AL', 'Alabama'], ['AK', 'Alaska'], ['AZ', 'Arizona'], ['AR', 'Arkansas'], ['CA', 'California'], ['CO', 'Colorado'], ['CT', 'Connecticut'], ['DE', 'Delaware'], ['DC', 'District of Columbia'], ['FL', 'Florida'], ['GA', 'Georgia'], ['HI', 'Hawaii'], ['ID', 'Idaho'], ['IL', 'Illinois'], ['IN', 'Indiana'], ['IA', 'Iowa'], ['KS', 'Kansas'], ['KY', 'Kentucky'], ['LA', 'Louisiana'], ['ME', 'Maine'], ['MD', 'Maryland'], ['MA', 'Massachusetts'], ['MI', 'Michigan'], ['MN', 'Minnesota'], ['MS', 'Mississippi'], ['MO', 'Missouri'], ['MT', 'Montana'], ['NE', 'Nebraska'], ['NV', 'Nevada'], ['NH', 'New Hampshire'], ['NJ', 'New Jersey'], ['NM', 'New Mexico'], ['NY', 'New York'], ['NC', 'North Carolina'], ['ND', 'North Dakota'], ['OH', 'Ohio'], ['OK', 'Oklahoma'], ['OR', 'Oregon'], ['PA', 'Pennsylvania'], ['RI', 'Rhode Island'], ['SC', 'South Carolina'], ['SD', 'South Dakota'], ['TN', 'Tennessee'], ['TX', 'Texas'], ['UT', 'Utah'], ['VT', 'Vermont'], ['VA', 'Virginia'], ['WA', 'Washington'], ['WV', 'West Virginia'], ['WI', 'Wisconsin'], ['WY', 'Wyoming'],
++];
++
++const CA_PROVINCES: Array<[string, string]> = [
++  ['AB', 'Alberta'], ['BC', 'British Columbia'], ['MB', 'Manitoba'], ['NB', 'New Brunswick'], ['NL', 'Newfoundland and Labrador'], ['NS', 'Nova Scotia'], ['NT', 'Northwest Territories'], ['NU', 'Nunavut'], ['ON', 'Ontario'], ['PE', 'Prince Edward Island'], ['QC', 'Quebec'], ['SK', 'Saskatchewan'], ['YT', 'Yukon'],
++];
++
++export const GEOGRAPHY_SEED: GeographySeed[] = [
++  { slug: 'world', name: 'World', kind: 'world' },
++  ...WHO_REGIONS.map(([slug, name]) => ({ slug, name, kind: 'who_region' as const, parentSlug: 'world' })),
++  ...COUNTRIES.map(([iso2, iso3, name, who]) => ({ slug: name.toLowerCase().replace(/[^a-z0-9]+/g, '-'), name, kind: 'country' as const, iso2, iso3, parentSlug: who, whoRegion: who })),
++  ...US_STATES.map(([code, name]) => ({ slug: `us-${code.toLowerCase()}`, name, kind: 'subdivision' as const, iso2: `US-${code}`, parentSlug: 'united-states', whoRegion: 'who-amro' })),
++  ...CA_PROVINCES.map(([code, name]) => ({ slug: `ca-${code.toLowerCase()}`, name, kind: 'subdivision' as const, iso2: `CA-${code}`, parentSlug: 'canada', whoRegion: 'who-amro' })),
++];

added packages/database/src/seed-data/metrics.ts +285 −0

++/**
++ * Metric catalog (CLAUDE.md §250-252, §352). Every derived number shown on the site references
++ * one of these definitions by slug; the formula text and version are displayed on /methodology.
++ *
++ * Composite scores (CI-IMPACT etc.) are intentionally absent from Phase 1 (§353).
++ */
++export interface MetricSeed {
++  slug: string;
++  name: string;
++  description: string;
++  formula: string;
++  formulaVersion: string;
++  unit: string;
++  higherIsWorse: boolean | null;
++  aggregation: string | null;
++  validDimensions: string[];
++  sourceSlugs: string[];
++  category: string;
++  eligibility: Record<string, unknown>;
++  experimental: boolean;
++}
++
++export const METRIC_CATALOG: MetricSeed[] = [
++  // --- Burden (epidemiology observations) ---
++  {
++    slug: 'incidence_count',
++    name: 'Annual new cases',
++    description: 'Number of new cases diagnosed in the reference year for the population scope. Registry counts are observed; national/global figures may be estimates and are labeled as such.',
++    formula: 'epidemiology_observations.value WHERE metric = incidence_count',
++    formulaVersion: 'ci-incidence-count-v1',
++    unit: 'count',
++    higherIsWorse: true,
++    aggregation: 'none',
++    validDimensions: ['geography', 'sex', 'age_group', 'year'],
++    sourceSlugs: ['cdc-wonder', 'seer', 'iarc-globocan'],
++    category: 'burden',
++    eligibility: { requires: ['incidence_count'], entityLevel: 'top' },
++    experimental: false,
++  },
++  {
++    slug: 'mortality_count',
++    name: 'Annual deaths',
++    description: 'Number of deaths with this cancer as underlying cause in the reference year for the population scope.',
++    formula: 'epidemiology_observations.value WHERE metric = mortality_count',
++    formulaVersion: 'ci-mortality-count-v1',
++    unit: 'count',
++    higherIsWorse: true,
++    aggregation: 'none',
++    validDimensions: ['geography', 'sex', 'age_group', 'year'],
++    sourceSlugs: ['cdc-wonder', 'seer', 'iarc-globocan'],
++    category: 'burden',
++    eligibility: { requires: ['mortality_count'], entityLevel: 'top' },
++    experimental: false,
++  },
++  {
++    slug: 'as_incidence_rate',
++    name: 'Age-standardized incidence rate',
++    description: 'Incidence per 100,000 person-years, age-standardized to the standard population declared by the source. Rates standardized to different standard populations are never compared in one ranking.',
++    formula: 'epidemiology_observations.value WHERE metric = as_incidence_rate (standard_population fixed per scope)',
++    formulaVersion: 'ci-asir-v1',
++    unit: 'per_100k',
++    higherIsWorse: true,
++    aggregation: 'none',
++    validDimensions: ['geography', 'sex', 'year'],
++    sourceSlugs: ['cdc-wonder', 'seer', 'iarc-globocan'],
++    category: 'burden',
++    eligibility: { requires: ['as_incidence_rate'], entityLevel: 'top' },
++    experimental: false,
++  },
++  {
++    slug: 'as_mortality_rate',
++    name: 'Age-standardized mortality rate',
++    description: 'Deaths per 100,000 person-years, age-standardized to the standard population declared by the source.',
++    formula: 'epidemiology_observations.value WHERE metric = as_mortality_rate (standard_population fixed per scope)',
++    formulaVersion: 'ci-asmr-v1',
++    unit: 'per_100k',
++    higherIsWorse: true,
++    aggregation: 'none',
++    validDimensions: ['geography', 'sex', 'year'],
++    sourceSlugs: ['cdc-wonder', 'seer', 'iarc-globocan'],
++    category: 'burden',
++    eligibility: { requires: ['as_mortality_rate'], entityLevel: 'top' },
++    experimental: false,
++  },
++  // --- Lethality ---
++  {
++    slug: 'mortality_incidence_ratio',
++    name: 'Mortality-to-incidence ratio',
++    description: 'Deaths divided by new cases in the same population, year and sex. A crude proxy of lethality; it is not a survival probability and is affected by incidence trends and registration completeness.',
++    formula: 'mortality_count / incidence_count (same geography, year, sex, source family)',
++    formulaVersion: 'ci-mir-v1',
++    unit: 'ratio',
++    higherIsWorse: true,
++    aggregation: 'none',
++    validDimensions: ['geography', 'sex', 'year'],
++    sourceSlugs: ['cdc-wonder', 'seer', 'iarc-globocan'],
++    category: 'lethality',
++    eligibility: { requires: ['incidence_count', 'mortality_count'], minIncidence: 100, entityLevel: 'top' },
++    experimental: false,
++  },
++  {
++    slug: 'five_year_survival',
++    name: '5-year relative survival',
++    description: '5-year relative survival for the diagnosis period and population declared by the source. Population survival statistics do not predict an individual outcome.',
++    formula: 'survival_observations.probability WHERE survival_type = relative AND duration_months = 60 AND stage IS NULL',
++    formulaVersion: 'ci-5ys-v1',
++    unit: 'probability',
++    higherIsWorse: false,
++    aggregation: 'none',
++    validDimensions: ['geography', 'sex', 'diagnosis_period'],
++    sourceSlugs: ['seer'],
++    category: 'lethality',
++    eligibility: { requires: ['five_year_relative_survival'], minCohort: 50, entityLevel: 'top' },
++    experimental: false,
++  },
++  // --- Clinical research (ClinicalTrials.gov) ---
++  {
++    slug: 'active_trials',
++    name: 'Active clinical trials',
++    description: 'Interventional studies registered on ClinicalTrials.gov whose overall status is RECRUITING, NOT_YET_RECRUITING, ENROLLING_BY_INVITATION or ACTIVE_NOT_RECRUITING and whose conditions map to this cancer or one of its descendants in the NCIt hierarchy.',
++    formula: 'COUNT(DISTINCT trial) FROM trial_conditions JOIN clinical_trials WHERE cancer_id IN descendants(cancer) AND study_type = INTERVENTIONAL AND overall_status IN (RECRUITING, NOT_YET_RECRUITING, ENROLLING_BY_INVITATION, ACTIVE_NOT_RECRUITING)',
++    formulaVersion: 'ci-active-trials-v1',
++    unit: 'count',
++    higherIsWorse: false,
++    aggregation: 'descendants',
++    validDimensions: ['entity_level'],
++    sourceSlugs: ['clinicaltrials'],
++    category: 'trials',
++    eligibility: { entityLevel: 'any' },
++    experimental: false,
++  },
++  {
++    slug: 'recruiting_trials',
++    name: 'Recruiting clinical trials',
++    description: 'Interventional studies currently RECRUITING whose conditions map to this cancer or its descendants.',
++    formula: 'COUNT(DISTINCT trial) … overall_status = RECRUITING AND study_type = INTERVENTIONAL',
++    formulaVersion: 'ci-recruiting-trials-v1',
++    unit: 'count',
++    higherIsWorse: false,
++    aggregation: 'descendants',
++    validDimensions: ['entity_level'],
++    sourceSlugs: ['clinicaltrials'],
++    category: 'trials',
++    eligibility: { entityLevel: 'any' },
++    experimental: false,
++  },
++  {
++    slug: 'phase3_trials',
++    name: 'Active Phase III trials',
++    description: 'Active interventional studies with PHASE3 among their phases, mapped to this cancer or its descendants.',
++    formula: 'COUNT(DISTINCT trial) … active statuses AND PHASE3 = ANY(phases)',
++    formulaVersion: 'ci-phase3-trials-v1',
++    unit: 'count',
++    higherIsWorse: false,
++    aggregation: 'descendants',
++    validDimensions: ['entity_level'],
++    sourceSlugs: ['clinicaltrials'],
++    category: 'trials',
++    eligibility: { entityLevel: 'any' },
++    experimental: false,
++  },
++  // --- Research activity (PubMed) ---
++  {
++    slug: 'publications_5y',
++    name: 'Publications, last 5 years',
++    description: 'PubMed records matching the cancer’s MeSH-anchored query (stored verbatim with the count) with a publication date in the last 5 full years plus the current year.',
++    formula: 'literature_counts.count WHERE window_key = 5y (query stored per row)',
++    formulaVersion: 'ci-pubs-5y-v1',
++    unit: 'count',
++    higherIsWorse: false,
++    aggregation: 'none',
++    validDimensions: ['entity_level'],
++    sourceSlugs: ['pubmed'],
++    category: 'research',
++    eligibility: { entityLevel: 'any', requiresQuery: true },
++    experimental: false,
++  },
++  {
++    slug: 'publications_12m',
++    name: 'Publications, last 12 months',
++    description: 'PubMed records matching the cancer’s query with a publication date in the last 12 months.',
++    formula: 'literature_counts.count WHERE window_key = 12m',
++    formulaVersion: 'ci-pubs-12m-v1',
++    unit: 'count',
++    higherIsWorse: false,
++    aggregation: 'none',
++    validDimensions: ['entity_level'],
++    sourceSlugs: ['pubmed'],
++    category: 'research',
++    eligibility: { entityLevel: 'any', requiresQuery: true },
++    experimental: false,
++  },
++  {
++    slug: 'publication_growth',
++    name: 'Publication growth',
++    description: 'Ratio of publications in the last 12 months to the average annual publications over the preceding 5-year window. Values above 1 indicate accelerating literature.',
++    formula: 'publications_12m / (publications_5y_prior / 5)',
++    formulaVersion: 'ci-pub-growth-v1',
++    unit: 'ratio',
++    higherIsWorse: null,
++    aggregation: 'none',
++    validDimensions: ['entity_level'],
++    sourceSlugs: ['pubmed'],
++    category: 'trend',
++    eligibility: { entityLevel: 'any', minPublications5y: 50 },
++    experimental: false,
++  },
++  // --- Molecular knowledge ---
++  {
++    slug: 'curated_evidence_items',
++    name: 'Curated clinical evidence items',
++    description: 'Accepted CIViC evidence items whose disease maps to this cancer or its descendants.',
++    formula: 'COUNT(civic_evidence_items) WHERE status = ACCEPTED AND cancer_id IN descendants(cancer)',
++    formulaVersion: 'ci-civic-evidence-v1',
++    unit: 'count',
++    higherIsWorse: false,
++    aggregation: 'descendants',
++    validDimensions: ['entity_level'],
++    sourceSlugs: ['civic'],
++    category: 'molecular',
++    eligibility: { entityLevel: 'any' },
++    experimental: false,
++  },
++  {
++    slug: 'associated_genes',
++    name: 'Genes with curated or cohort evidence',
++    description: 'Distinct genes linked to this cancer (or descendants) by an accepted CIViC evidence item or by a GDC cohort frequency of at least 5% with ≥ 20 affected cases.',
++    formula: 'COUNT(DISTINCT gene) FROM (civic accepted evidence ∪ gdc frequency ≥ 0.05 AND cases_affected ≥ 20)',
++    formulaVersion: 'ci-genes-v1',
++    unit: 'count',
++    higherIsWorse: false,
++    aggregation: 'descendants',
++    validDimensions: ['entity_level'],
++    sourceSlugs: ['civic', 'gdc'],
++    category: 'molecular',
++    eligibility: { entityLevel: 'any' },
++    experimental: false,
++  },
++  {
++    slug: 'genomic_cohorts',
++    name: 'Public genomic cohorts',
++    description: 'Open-access genomic studies (GDC projects) whose disease maps to this cancer or its descendants.',
++    formula: 'COUNT(genomic_cohorts) WHERE cancer_id IN descendants(cancer)',
++    formulaVersion: 'ci-cohorts-v1',
++    unit: 'count',
++    higherIsWorse: false,
++    aggregation: 'descendants',
++    validDimensions: ['entity_level'],
++    sourceSlugs: ['gdc'],
++    category: 'molecular',
++    eligibility: { entityLevel: 'any' },
++    experimental: false,
++  },
++  // --- Gap indexes (derived; require burden) ---
++  {
++    slug: 'trial_gap',
++    name: 'Trial Gap Index',
++    description: 'Burden percentile minus active-trial percentile within the same scope. Positive values flag cancers with high mortality burden but comparatively few active trials. A quantitative signal, not an accusation (CLAUDE.md §324).',
++    formula: 'percentile(mortality_count) − percentile(active_trials)',
++    formulaVersion: 'ci-trial-gap-v1',
++    unit: 'percentile_points',
++    higherIsWorse: true,
++    aggregation: 'none',
++    validDimensions: ['geography', 'year'],
++    sourceSlugs: ['clinicaltrials', 'cdc-wonder', 'seer', 'iarc-globocan'],
++    category: 'unmet_need',
++    eligibility: { requires: ['mortality_count', 'active_trials'], entityLevel: 'top' },
++    experimental: false,
++  },
++  {
++    slug: 'research_gap',
++    name: 'Research Gap Index',
++    description: 'Burden percentile minus research-activity percentile (publications, last 5 years) within the same scope. Positive values flag cancers with high mortality burden but comparatively little literature.',
++    formula: 'percentile(mortality_count) − percentile(publications_5y)',
++    formulaVersion: 'ci-research-gap-v1',
++    unit: 'percentile_points',
++    higherIsWorse: true,
++    aggregation: 'none',
++    validDimensions: ['geography', 'year'],
++    sourceSlugs: ['pubmed', 'cdc-wonder', 'seer', 'iarc-globocan'],
++    category: 'unmet_need',
++    eligibility: { requires: ['mortality_count', 'publications_5y'], entityLevel: 'top' },
++    experimental: false,
++  },
++];

added packages/database/src/seed.ts +49 −0

++import { fileURLToPath } from 'node:url';
++import path from 'node:path';
++import { eq, sql } from 'drizzle-orm';
++import { getDb, closeDb } from './client.js';
++import { geographies, metricDefinitions } from './schema/index.js';
++import { mintId } from './ids.js';
++import { METRIC_CATALOG } from './seed-data/metrics.js';
++import { GEOGRAPHY_SEED } from './seed-data/geographies.js';
++
++/**
++ * Seeds only system data (CLAUDE.md §358): metric definitions and canonical geographies.
++ * Scientific data is never seeded — it comes from connectors. Sources are synced from connector
++ * manifests by `pnpm cix sources:sync` (lives in the root CLI to avoid a package cycle).
++ */
++export async function seed(): Promise<void> {
++  const db = getDb({ max: 2 });
++  for (const m of METRIC_CATALOG) {
++    const [existing] = await db.select({ id: metricDefinitions.id }).from(metricDefinitions).where(eq(metricDefinitions.slug, m.slug)).limit(1);
++    const values = { ...m, updatedAt: new Date() };
++    if (existing) await db.update(metricDefinitions).set(values).where(eq(metricDefinitions.id, existing.id));
++    else await db.insert(metricDefinitions).values({ id: await mintId(db, 'METRIC'), ...m });
++  }
++  const bySlug = new Map<string, string>();
++  for (const g of GEOGRAPHY_SEED) {
++    const [existing] = await db.select({ id: geographies.id }).from(geographies).where(eq(geographies.slug, g.slug)).limit(1);
++    const parentId = g.parentSlug ? bySlug.get(g.parentSlug) ?? null : null;
++    if (existing) {
++      await db.update(geographies).set({ name: g.name, kind: g.kind, iso2: g.iso2 ?? null, iso3: g.iso3 ?? null, parentId, whoRegion: g.whoRegion ?? null }).where(eq(geographies.id, existing.id));
++      bySlug.set(g.slug, existing.id);
++    } else {
++      const id = await mintId(db, 'GEO');
++      await db.insert(geographies).values({ id, slug: g.slug, name: g.name, kind: g.kind, iso2: g.iso2 ?? null, iso3: g.iso3 ?? null, parentId, whoRegion: g.whoRegion ?? null });
++      bySlug.set(g.slug, id);
++    }
++  }
++  const [{ n }] = (await db.execute<{ n: string }>(sql`SELECT count(*)::text AS n FROM metric_definitions`)) as unknown as [{ n: string }];
++  console.log(`[seed] metrics=${n} geographies=${GEOGRAPHY_SEED.length}`);
++}
++
++const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
++if (isMain) {
++  seed()
++    .then(() => closeDb())
++    .catch(async (e) => {
++      console.error('[seed] failed', e);
++      await closeDb();
++      process.exit(1);
++    });
++}

added packages/database/tsconfig.json +8 −0

++{
++  "extends": "../../tsconfig.base.json",
++  "compilerOptions": {
++    "rootDir": ".",
++    "noEmit": true
++  },
++  "include": ["src", "drizzle.config.ts"]
++}

added packages/ontology/package.json +27 −0

++{
++  "name": "@cancerindex/ontology",
++  "version": "0.1.0",
++  "private": true,
++  "type": "module",
++  "exports": {
++    ".": {
++      "types": "./src/index.ts",
++      "default": "./src/index.ts"
++    }
++  },
++  "scripts": {
++    "build": "tsc -p tsconfig.json --noEmit",
++    "typecheck": "tsc -p tsconfig.json --noEmit",
++    "test": "vitest run --passWithNoTests"
++  },
++  "dependencies": {
++    "@cancerindex/database": "workspace:*",
++    "@cancerindex/shared": "workspace:*",
++    "drizzle-orm": "^0.45.0"
++  },
++  "devDependencies": {
++    "@types/node": "^24.0.0",
++    "typescript": "^5.9.3",
++    "vitest": "^3.2.0"
++  }
++}

added packages/ontology/src/index.ts +3 −0

++export * from './qualifiers.js';
++export * from './reconcile.js';
++export * from './top-level.js';

added packages/ontology/src/qualifiers.ts +76 −0

++/**
++ * NCIt neoplasm concepts that are *qualified disease states* rather than taxonomy nodes
++ * (CLAUDE.md §217-218: "Do not create a unique canonical cancer entity for every arbitrary
++ * combination"). Stage / recurrence / resectability / laterality / treatment-history qualified
++ * concepts are retained as source records and mapped to their base disease, but are not canonical
++ * cancers.
++ *
++ * Rules are deterministic and tested (test/qualifiers.test.ts). When in doubt a concept is KEPT
++ * (a false negative costs an extra node; a false positive loses a real disease entity).
++ */
++
++/** Words that mark a clinical state, never a disease identity. */
++const STATE_WORDS =
++  /\b(stage\s?[0iv]+[abcs]?\d?|stages?\s[0iv]+|recurrent|refractory|relapsed|resectable|unresectable|borderline resectable|localized|locally advanced|advanced|metastatic|progressive|residual|persistent|newly diagnosed|untreated|previously treated|previously untreated|treatment[- ]naive|bilateral|unilateral|synchronous|metachronous|multifocal|multicentric|unifocal|occult|extensive[- ]stage|limited[- ]stage|in remission|in relapse|in complete remission|minimal residual disease|post[- ]?transplant(ation)?|aggravated|complicated|uncomplicated|with (unknown|known) primary site|of unknown primary origin)\b/i;
++
++/** Staging-system suffixes: "… AJCC v8", "… FIGO Stage IIIC". */
++const STAGING_SUFFIX = /\s(by\s)?(ajcc|figo|uicc|inrg|inss|cog|enneking|lugano|ann arbor|binet|rai|durie[- ]salmon|r?-?iss|tnm)(\sv\d+)?(\sstage\s?[0iv]+[abc]?)?$/i;
++
++/** Laterality prefixes only count when followed by an organ-level disease. */
++const LATERALITY_PREFIX = /^(left|right)\s/i;
++
++/**
++ * Recognized disease names that contain a state word as part of their identity.
++ * Kept deliberately short: the regexes above are the primary mechanism.
++ */
++const KEEP_EXACT = new Set(
++  [
++    'Progressive Multifocal Leukoencephalopathy',
++    'Persistent Mullerian Duct Syndrome',
++    'Advanced Sclerosing Systemic Mastocytosis',
++    'Residual Neuroblastoma',
++    'Cancer of Unknown Primary Origin',
++    'Carcinoma of Unknown Primary Origin',
++    'Neoplasm of Unknown Primary Origin',
++    'Adenocarcinoma of Unknown Primary Origin',
++    'Squamous Cell Carcinoma of Unknown Primary Origin',
++    'Neuroendocrine Carcinoma of Unknown Primary Origin',
++    'Melanoma of Unknown Primary Origin',
++    'Metastatic Malignant Neoplasm of Unknown Primary Origin',
++    'Multifocal Motor Neuropathy',
++    'Multicentric Castleman Disease',
++    'Idiopathic Multicentric Castleman Disease',
++    'HHV8-Associated Multicentric Castleman Disease',
++    'Multicentric Reticulohistiocytosis',
++    'Multifocal Langerhans Cell Histiocytosis',
++    'Unifocal Langerhans Cell Histiocytosis',
++    'Multifocal Osteosarcoma',
++    'Synchronous Multiple Primary Malignant Neoplasm',
++    'Metachronous Multiple Primary Malignant Neoplasm',
++    'Occult Breast Carcinoma',
++    'Occult Primary Malignant Neoplasm',
++  ].map((s) => s.toLowerCase()),
++);
++
++/** True when a preferred name denotes a qualified state rather than a disease taxonomy node. */
++export function isQualifiedState(preferredName: string): boolean {
++  const name = preferredName.trim().toLowerCase();
++  if (KEEP_EXACT.has(name)) return false;
++  if (STAGING_SUFFIX.test(name)) return true;
++  if (STATE_WORDS.test(name)) return true;
++  if (LATERALITY_PREFIX.test(name)) return true;
++  return false;
++}
++
++/** Strip qualifiers to find the base disease label (used to attach qualified states to their disease). */
++export function baseDiseaseLabel(preferredName: string): string {
++  let s = preferredName.trim();
++  for (let i = 0; i < 5; i++) {
++    const before = s;
++    s = s.replace(STAGING_SUFFIX, '');
++    s = s.replace(/^(stage\s?[0iv]+[abcs]?\d?|recurrent|refractory|relapsed|resectable|unresectable|borderline resectable|localized|locally advanced|advanced|metastatic|progressive|residual|persistent|newly diagnosed|untreated|previously treated|previously untreated|treatment[- ]naive|bilateral|unilateral|left|right|synchronous|metachronous|multifocal|multicentric|unifocal|occult|extensive[- ]stage|limited[- ]stage)\s+/i, '');
++    s = s.replace(/\s+(stage\s?[0iv]+[abcs]?\d?|in remission|in relapse|in complete remission)$/i, '');
++    if (s === before) break;
++  }
++  return s.trim();
++}

added packages/ontology/src/reconcile.ts +106 −0

++import { and, eq, inArray, sql } from 'drizzle-orm';
++import { normalizeLabel, uninvertMeshTerm, type MatchType } from '@cancerindex/shared';
++import { type Database, cancerAliases, cancerCodes, cancers } from '@cancerindex/database';
++
++export interface CancerMatch {
++  cancerId: string;
++  matchType: MatchType;
++  confidence: number;
++  via: string; // human-readable explanation
++}
++
++/**
++ * Cancer label reconciliation (CLAUDE.md §69): identifiers → curated aliases → normalized strings.
++ * Never uses embeddings or an LLM to merge. Returns null (→ unresolved queue) when unsure.
++ */
++export class CancerResolver {
++  private aliasCache = new Map<string, { cancerId: string; aliasType: string }[]>();
++  private codeCache = new Map<string, string>();
++
++  constructor(private readonly db: Database) {}
++
++  /** Preload alias + code lookups in memory for bulk reconciliation. */
++  async warm(): Promise<void> {
++    const rows = await this.db
++      .select({ cancerId: cancerAliases.cancerId, normalized: cancerAliases.normalized, aliasType: cancerAliases.aliasType })
++      .from(cancerAliases)
++      .innerJoin(cancers, eq(cancers.id, cancerAliases.cancerId))
++      .where(eq(cancers.status, 'active'));
++    this.aliasCache.clear();
++    for (const r of rows) {
++      const arr = this.aliasCache.get(r.normalized) ?? [];
++      arr.push({ cancerId: r.cancerId, aliasType: r.aliasType });
++      this.aliasCache.set(r.normalized, arr);
++    }
++    const codes = await this.db.select({ cancerId: cancerCodes.cancerId, system: cancerCodes.system, code: cancerCodes.code }).from(cancerCodes).where(inArray(cancerCodes.matchType, ['EXACT_IDENTIFIER', 'CURATED_EXACT', 'ONTOLOGY_EXACT']));
++    this.codeCache.clear();
++    for (const c of codes) this.codeCache.set(`${c.system}:${c.code}`, c.cancerId);
++  }
++
++  get warmed(): boolean {
++    return this.aliasCache.size > 0;
++  }
++
++  /** Resolve by external identifier (NCIt code, DOID, OncoTree code, UMLS CUI, MeSH UI…). */
++  byCode(system: string, code: string): CancerMatch | null {
++    const id = this.codeCache.get(`${system}:${code}`);
++    return id ? { cancerId: id, matchType: 'EXACT_IDENTIFIER', confidence: 1, via: `${system}:${code}` } : null;
++  }
++
++  /** Resolve a free-text label. Ambiguous alias hits (≠ 1 distinct cancer) are returned as null. */
++  byLabel(label: string, opts: { allowMeshInversion?: boolean } = {}): CancerMatch | null {
++    const candidates = [label];
++    if (opts.allowMeshInversion && label.includes(',')) candidates.push(uninvertMeshTerm(label));
++    // Common registry phrasings: "Cancer of the X" → "X cancer"; "Carcinoma of X" → "X carcinoma"
++    const m = /^(cancer|carcinoma|neoplasm|tumou?r|sarcoma|lymphoma|leukemia|adenocarcinoma|melanoma) of (the )?(.+)$/i.exec(label);
++    if (m) candidates.push(`${m[3]} ${m[1]}`);
++    for (const c of candidates) {
++      const norm = normalizeLabel(c);
++      if (!norm) continue;
++      const hits = this.aliasCache.get(norm);
++      if (!hits || hits.length === 0) continue;
++      const distinct = [...new Set(hits.map((h) => h.cancerId))];
++      if (distinct.length === 1) {
++        const preferred = hits.some((h) => h.aliasType === 'preferred');
++        return { cancerId: distinct[0]!, matchType: preferred ? 'ONTOLOGY_EXACT' : 'ALIAS', confidence: preferred ? 0.98 : 0.9, via: `alias "${c}"` };
++      }
++      // Ambiguous: prefer the cancer where this string is the preferred name.
++      const pref = hits.filter((h) => h.aliasType === 'preferred');
++      const prefDistinct = [...new Set(pref.map((h) => h.cancerId))];
++      if (prefDistinct.length === 1) return { cancerId: prefDistinct[0]!, matchType: 'ONTOLOGY_EXACT', confidence: 0.9, via: `preferred name "${c}" (alias also used by ${distinct.length - 1} other concept(s))` };
++      return null;
++    }
++    return null;
++  }
++
++  /** Try identifiers first, then labels (CLAUDE.md §143, §221). */
++  resolve(input: { codes?: Array<{ system: string; code: string }>; labels?: string[]; allowMeshInversion?: boolean }): CancerMatch | null {
++    for (const c of input.codes ?? []) {
++      const hit = this.byCode(c.system, c.code);
++      if (hit) return hit;
++    }
++    for (const l of input.labels ?? []) {
++      const hit = this.byLabel(l, { allowMeshInversion: input.allowMeshInversion });
++      if (hit) return hit;
++    }
++    return null;
++  }
++
++  /** Fuzzy suggestion for the curation queue only (never auto-accepted). */
++  async suggest(label: string): Promise<{ cancerId: string; name: string; score: number } | null> {
++    const norm = normalizeLabel(label);
++    if (norm.length < 4) return null;
++    const rows = await this.db.execute<{ cancer_id: string; canonical_name: string; score: number }>(sql`
++      SELECT a.cancer_id, c.canonical_name, similarity(a.normalized, ${norm}) AS score
++      FROM cancer_aliases a JOIN cancers c ON c.id = a.cancer_id
++      WHERE c.status = 'active' AND a.normalized % ${norm}
++      ORDER BY score DESC LIMIT 1`);
++    const r = rows[0];
++    return r && r.score >= 0.6 ? { cancerId: r.cancer_id, name: r.canonical_name, score: Number(r.score) } : null;
++  }
++}
++
++export async function loadCancerIdBySlug(db: Database, slug: string): Promise<string | null> {
++  const [row] = await db.select({ id: cancers.id }).from(cancers).where(and(eq(cancers.slug, slug), eq(cancers.status, 'active'))).limit(1);
++  return row?.id ?? null;
++}

added packages/ontology/src/top-level.ts +75 −0

++/**
++ * Explicitly curated metadata (CLAUDE.md §8 allows curated metadata; §246-247 require a
++ * mutually exclusive top-level set for the global master ranking).
++ *
++ * The top-level set follows the GLOBOCAN / ICD-10 site groups so that registry burden estimates
++ * can be attached without double counting. Each entry maps a site group to its NCIt anchor concept
++ * (codes verified against the EVS REST API on 2026-09-08, NCIt 26.08e) and to the ICD-10 range
++ * used by registries. Codes are recorded on `cancer_codes` with match type CURATED_EXACT.
++ *
++ * This list is *not* the taxonomy — it is a ranking scope definition (entity_level = "top").
++ */
++export interface TopLevelCancer {
++  key: string;
++  name: string; // display name (registry phrasing); the canonical NCIt name is kept on the entity
++  ncit: string;
++  icd10: string[]; // ICD-10 code ranges, e.g. "C33-C34"
++  hematologic?: boolean;
++  globocanCode?: number; // GLOBOCAN cancer code (reference only; ingestion is gated by license review)
++  notes?: string;
++}
++
++export const TOP_LEVEL_CANCERS: TopLevelCancer[] = [
++  { key: 'lip-oral-cavity', name: 'Lip and Oral Cavity Cancer', ncit: 'C9316', icd10: ['C00-C06'], globocanCode: 1 },
++  { key: 'salivary-gland', name: 'Salivary Gland Cancer', ncit: 'C3811', icd10: ['C07-C08'], globocanCode: 2 },
++  { key: 'oropharynx', name: 'Oropharyngeal Cancer', ncit: 'C7398', icd10: ['C09-C10'], globocanCode: 3 },
++  { key: 'nasopharynx', name: 'Nasopharyngeal Cancer', ncit: 'C9321', icd10: ['C11'], globocanCode: 4 },
++  { key: 'hypopharynx', name: 'Hypopharyngeal Cancer', ncit: 'C7190', icd10: ['C12-C13'], globocanCode: 5 },
++  { key: 'esophagus', name: 'Esophageal Cancer', ncit: 'C7478', icd10: ['C15'], globocanCode: 6 },
++  { key: 'stomach', name: 'Stomach Cancer', ncit: 'C9331', icd10: ['C16'], globocanCode: 7 },
++  { key: 'colon', name: 'Colon Cancer', ncit: 'C9242', icd10: ['C18'], globocanCode: 8 },
++  { key: 'rectum', name: 'Rectal Cancer', ncit: 'C7418', icd10: ['C19-C20'], globocanCode: 9 },
++  { key: 'anus', name: 'Anal Cancer', ncit: 'C7379', icd10: ['C21'], globocanCode: 10 },
++  { key: 'liver', name: 'Liver Cancer', ncit: 'C190593', icd10: ['C22'], globocanCode: 11, notes: 'ICD-10 C22 includes intrahepatic bile ducts' },
++  { key: 'gallbladder', name: 'Gallbladder Cancer', ncit: 'C7481', icd10: ['C23-C24'], globocanCode: 12, notes: 'ICD-10 C23-C24 includes extrahepatic biliary tract; NCIt anchor is gallbladder' },
++  { key: 'pancreas', name: 'Pancreatic Cancer', ncit: 'C9005', icd10: ['C25'], globocanCode: 13 },
++  { key: 'larynx', name: 'Laryngeal Cancer', ncit: 'C7484', icd10: ['C32'], globocanCode: 14 },
++  { key: 'lung', name: 'Lung Cancer', ncit: 'C7377', icd10: ['C33-C34'], globocanCode: 15 },
++  { key: 'melanoma-skin', name: 'Melanoma of Skin', ncit: 'C3510', icd10: ['C43'], globocanCode: 16 },
++  { key: 'non-melanoma-skin', name: 'Non-Melanoma Skin Cancer', ncit: 'C4914', icd10: ['C44'], globocanCode: 17, notes: 'registries differ on inclusion (CLAUDE.md §210)' },
++  { key: 'mesothelioma', name: 'Mesothelioma', ncit: 'C4456', icd10: ['C45'], globocanCode: 18 },
++  { key: 'kaposi-sarcoma', name: 'Kaposi Sarcoma', ncit: 'C9087', icd10: ['C46'], globocanCode: 19 },
++  { key: 'breast', name: 'Breast Cancer', ncit: 'C9335', icd10: ['C50'], globocanCode: 20 },
++  { key: 'vulva', name: 'Vulvar Cancer', ncit: 'C7502', icd10: ['C51'], globocanCode: 21 },
++  { key: 'vagina', name: 'Vaginal Cancer', ncit: 'C7410', icd10: ['C52'], globocanCode: 22 },
++  { key: 'cervix', name: 'Cervical Cancer', ncit: 'C9311', icd10: ['C53'], globocanCode: 23 },
++  { key: 'corpus-uteri', name: 'Uterine Corpus Cancer', ncit: 'C3556', icd10: ['C54'], globocanCode: 24 },
++  { key: 'ovary', name: 'Ovarian Cancer', ncit: 'C7431', icd10: ['C56'], globocanCode: 25 },
++  { key: 'penis', name: 'Penile Cancer', ncit: 'C7547', icd10: ['C60'], globocanCode: 26 },
++  { key: 'prostate', name: 'Prostate Cancer', ncit: 'C7378', icd10: ['C61'], globocanCode: 27 },
++  { key: 'testis', name: 'Testicular Cancer', ncit: 'C7251', icd10: ['C62'], globocanCode: 28 },
++  { key: 'kidney', name: 'Kidney Cancer', ncit: 'C7548', icd10: ['C64-C65'], globocanCode: 29 },
++  { key: 'bladder', name: 'Bladder Cancer', ncit: 'C9334', icd10: ['C67'], globocanCode: 30 },
++  { key: 'brain-cns', name: 'Brain and Central Nervous System Cancer', ncit: 'C4627', icd10: ['C70-C72'], globocanCode: 31 },
++  { key: 'thyroid', name: 'Thyroid Cancer', ncit: 'C7510', icd10: ['C73'], globocanCode: 32 },
++  { key: 'hodgkin-lymphoma', name: 'Hodgkin Lymphoma', ncit: 'C9357', icd10: ['C81'], hematologic: true, globocanCode: 33 },
++  { key: 'non-hodgkin-lymphoma', name: 'Non-Hodgkin Lymphoma', ncit: 'C3211', icd10: ['C82-C86', 'C96'], hematologic: true, globocanCode: 34 },
++  { key: 'multiple-myeloma', name: 'Multiple Myeloma', ncit: 'C3242', icd10: ['C88', 'C90'], hematologic: true, globocanCode: 35 },
++  { key: 'leukemia', name: 'Leukemia', ncit: 'C3161', icd10: ['C91-C95'], hematologic: true, globocanCode: 36 },
++];
++
++export const TOP_LEVEL_BY_NCIT = new Map(TOP_LEVEL_CANCERS.map((t) => [t.ncit, t]));
++
++/** NCIt roots used to build the multi-dimensional hierarchy (verified 2026-09-08). */
++export const NCIT_ROOTS = {
++  neoplasm: 'C3262',
++  malignantNeoplasm: 'C9305',
++  neoplasmBySite: 'C3263',
++  neoplasmByMorphology: 'C4741',
++  carcinoma: 'C2916',
++  malignantSolidNeoplasm: 'C132146',
++  hematopoieticLymphoidCellNeoplasm: 'C27134',
++  hematopoieticLymphaticSystemNeoplasm: 'C35813',
++  childhoodMalignantNeoplasm: 'C4005',
++  nervousSystemNeoplasm: 'C3268',
++} as const;

added packages/ontology/test/qualifiers.test.ts +55 −0

++import { describe, expect, it } from 'vitest';
++import { isQualifiedState, baseDiseaseLabel } from '../src/qualifiers.js';
++
++describe('isQualifiedState', () => {
++  it('flags stage / recurrence / resectability concepts', () => {
++    for (const n of [
++      'Stage IV Pancreatic Cancer AJCC v8',
++      'Stage IIIA Lung Cancer AJCC v7',
++      'Recurrent Glioblastoma',
++      'Refractory Acute Myeloid Leukemia',
++      'Relapsed Multiple Myeloma',
++      'Unresectable Hepatocellular Carcinoma',
++      'Locally Advanced Rectal Carcinoma',
++      'Metastatic Breast Carcinoma',
++      'Newly Diagnosed Glioblastoma',
++      'Pancreatic Adenocarcinoma Stage II',
++      'Bilateral Breast Carcinoma',
++      'Recurrent Childhood Acute Lymphoblastic Leukemia',
++    ])
++      expect(isQualifiedState(n), n).toBe(true);
++  });
++  it('keeps recognized diseases whose names start with a qualifier-like word', () => {
++    for (const n of [
++      'Anaplastic Astrocytoma',
++      'Anaplastic Large Cell Lymphoma',
++      'Undifferentiated Pleomorphic Sarcoma',
++      'Invasive Breast Carcinoma',
++      'Childhood Acute Lymphoblastic Leukemia',
++      'Adult T-Cell Leukemia/Lymphoma',
++      'Primary Myelofibrosis',
++      'Primary Central Nervous System Lymphoma',
++      'Therapy-Related Acute Myeloid Leukemia',
++      'Triple-Negative Breast Carcinoma',
++      'EGFR-Mutant Lung Adenocarcinoma',
++      'KRAS G12C-Mutant Non-Small Cell Lung Carcinoma',
++      'High Grade Serous Ovarian Carcinoma',
++      'Low Grade Glioma',
++      'Castration-Resistant Prostate Carcinoma',
++      'Pancreatic Ductal Adenocarcinoma',
++      'Glioblastoma',
++      'Diffuse Large B-Cell Lymphoma',
++      'Acute Myeloid Leukemia with NPM1 Mutation',
++      'Secondary Acute Myeloid Leukemia',
++    ])
++      expect(isQualifiedState(n), n).toBe(false);
++  });
++});
++
++describe('baseDiseaseLabel', () => {
++  it('strips stage and recurrence qualifiers', () => {
++    expect(baseDiseaseLabel('Stage IV Pancreatic Cancer AJCC v8')).toBe('Pancreatic Cancer');
++    expect(baseDiseaseLabel('Recurrent Metastatic Breast Carcinoma')).toBe('Breast Carcinoma');
++    expect(baseDiseaseLabel('Glioblastoma')).toBe('Glioblastoma');
++  });
++});

added packages/ontology/tsconfig.json +8 −0

++{
++  "extends": "../../tsconfig.base.json",
++  "compilerOptions": {
++    "rootDir": ".",
++    "noEmit": true
++  },
++  "include": ["src", "test"]
++}

added packages/ontology/vitest.config.ts +3 −0

++import { defineConfig } from 'vitest/config';
++
++export default defineConfig({ test: { include: ['src/**/*.test.ts', 'test/**/*.test.ts'] } });

added packages/ranking/package.json +28 −0

++{
++  "name": "@cancerindex/ranking",
++  "version": "0.1.0",
++  "private": true,
++  "type": "module",
++  "exports": {
++    ".": {
++      "types": "./src/index.ts",
++      "default": "./src/index.ts"
++    }
++  },
++  "scripts": {
++    "build": "tsc -p tsconfig.json --noEmit",
++    "typecheck": "tsc -p tsconfig.json --noEmit",
++    "test": "vitest run --passWithNoTests"
++  },
++  "dependencies": {
++    "@cancerindex/database": "workspace:*",
++    "@cancerindex/ontology": "workspace:*",
++    "@cancerindex/shared": "workspace:*",
++    "drizzle-orm": "^0.45.0"
++  },
++  "devDependencies": {
++    "@types/node": "^24.0.0",
++    "typescript": "^5.9.3",
++    "vitest": "^3.2.0"
++  }
++}

added packages/ranking/src/counters.ts +140 −0

++import { sql } from 'drizzle-orm';
++import type { Database } from '@cancerindex/database';
++
++const ACTIVE_STATUSES = ['RECRUITING', 'NOT_YET_RECRUITING', 'ENROLLING_BY_INVITATION', 'ACTIVE_NOT_RECRUITING'];
++
++/**
++ * Recompute entity_counters for every active cancer from canonical relations (CLAUDE.md §287).
++ * Trial / evidence / cohort counts aggregate over the NCIt-hierarchy descendants of each cancer
++ * (a lung-cancer trial mapped to "Lung Adenocarcinoma" counts for "Lung Cancer" too).
++ * Deterministic: a full rebuild in one SQL transaction.
++ */
++export async function refreshCounters(db: Database): Promise<number> {
++  await db.execute(sql`
++    CREATE TEMP TABLE IF NOT EXISTS _desc (ancestor varchar(32), descendant varchar(32)) ON COMMIT DROP;
++  `);
++  return db.transaction(async (tx) => {
++    await tx.execute(sql`CREATE TEMP TABLE _desc (ancestor varchar(32), descendant varchar(32)) ON COMMIT DROP`);
++    await tx.execute(sql`
++      INSERT INTO _desc
++      WITH RECURSIVE d AS (
++        SELECT id AS ancestor, id AS descendant, 0 AS depth FROM cancers WHERE status = 'active'
++        UNION
++        SELECT d.ancestor, h.child_id, d.depth + 1 FROM d JOIN cancer_hierarchy h ON h.parent_id = d.descendant
++        WHERE d.depth < 12
++      )
++      SELECT DISTINCT ancestor, descendant FROM d
++    `);
++    await tx.execute(sql`CREATE INDEX ON _desc (descendant)`);
++    await tx.execute(sql`CREATE INDEX ON _desc (ancestor)`);
++    const rows = await tx.execute<{ n: string }>(sql`
++      WITH trial_map AS (
++        SELECT DISTINCT d.ancestor AS cancer_id, t.id AS trial_id, t.overall_status, t.phases, t.study_type
++        FROM trial_conditions tc JOIN _desc d ON d.descendant = tc.cancer_id JOIN clinical_trials t ON t.id = tc.trial_id
++        WHERE tc.cancer_id IS NOT NULL
++      ),
++      trials AS (
++        SELECT cancer_id,
++          count(*) AS trial_count,
++          count(*) FILTER (WHERE study_type = 'INTERVENTIONAL' AND overall_status = ANY(${ACTIVE_STATUSES}::text[])) AS active_trial_count,
++          count(*) FILTER (WHERE study_type = 'INTERVENTIONAL' AND overall_status = 'RECRUITING') AS recruiting_trial_count,
++          count(*) FILTER (WHERE study_type = 'INTERVENTIONAL' AND overall_status = ANY(${ACTIVE_STATUSES}::text[]) AND 'PHASE3' = ANY(phases)) AS phase3_trial_count
++        FROM trial_map GROUP BY cancer_id
++      ),
++      pubs AS (
++        SELECT cancer_id,
++          max(count) FILTER (WHERE window_key = 'all') AS publication_count,
++          max(count) FILTER (WHERE window_key = '5y') AS publication_count_5y,
++          max(count) FILTER (WHERE window_key = '12m') AS publication_count_12m
++        FROM literature_counts GROUP BY cancer_id
++      ),
++      evid AS (
++        SELECT d.ancestor AS cancer_id, count(DISTINCT e.civic_id) AS evidence_count,
++          count(DISTINCT g) FILTER (WHERE g IS NOT NULL) AS civic_gene_count,
++          count(DISTINCT v) FILTER (WHERE v IS NOT NULL) AS variant_count,
++          count(DISTINCT t) FILTER (WHERE t IS NOT NULL) AS drug_count
++        FROM civic_evidence_items e JOIN _desc d ON d.descendant = e.cancer_id
++        LEFT JOIN LATERAL unnest(e.gene_ids) g ON true
++        LEFT JOIN LATERAL unnest(e.variant_ids) v ON true
++        LEFT JOIN LATERAL unnest(e.therapy_ids) t ON true
++        WHERE e.status = 'ACCEPTED' GROUP BY d.ancestor
++      ),
++      cohorts AS (
++        SELECT d.ancestor AS cancer_id, count(DISTINCT c.id) AS cohort_count,
++          count(DISTINCT f.gene_symbol) FILTER (WHERE f.frequency >= 0.05 AND f.cases_affected >= 20) AS gdc_gene_count
++        FROM genomic_cohorts c JOIN _desc d ON d.descendant = c.cancer_id
++        LEFT JOIN cancer_gene_frequencies f ON f.cohort_id = c.id
++        GROUP BY d.ancestor
++      ),
++      appr AS (
++        SELECT d.ancestor AS cancer_id, count(DISTINCT a.drug_id) AS approved_drug_count
++        FROM drug_approvals a JOIN _desc d ON d.descendant = a.cancer_id WHERE a.status IN ('approved','accelerated','conditional') GROUP BY d.ancestor
++      ),
++      epi AS (
++        SELECT cancer_id, count(*) AS n FROM epidemiology_observations GROUP BY cancer_id
++      ),
++      surv AS (
++        SELECT cancer_id, count(*) AS n FROM survival_observations GROUP BY cancer_id
++      ),
++      tree AS (
++        SELECT ancestor AS cancer_id, count(*) - 1 AS descendant_count FROM _desc GROUP BY ancestor
++      ),
++      kids AS (
++        SELECT parent_id AS cancer_id, count(DISTINCT child_id) AS subtype_count FROM cancer_hierarchy GROUP BY parent_id
++      ),
++      ins AS (
++        INSERT INTO entity_counters (entity_type, entity_id, trial_count, active_trial_count, recruiting_trial_count, phase3_trial_count,
++          publication_count, publication_count_5y, publication_count_12m, gene_count, variant_count, drug_count, approved_drug_count,
++          evidence_count, cohort_count, subtype_count, descendant_count, epidemiology_obs_count, survival_obs_count, completeness, computed_at)
++        SELECT 'cancer', c.id,
++          COALESCE(t.trial_count,0), COALESCE(t.active_trial_count,0), COALESCE(t.recruiting_trial_count,0), COALESCE(t.phase3_trial_count,0),
++          COALESCE(p.publication_count,0), COALESCE(p.publication_count_5y,0), COALESCE(p.publication_count_12m,0),
++          GREATEST(COALESCE(e.civic_gene_count,0), COALESCE(g.gdc_gene_count,0)), COALESCE(e.variant_count,0), COALESCE(e.drug_count,0), COALESCE(a.approved_drug_count,0),
++          COALESCE(e.evidence_count,0), COALESCE(g.cohort_count,0), COALESCE(k.subtype_count,0), COALESCE(tr.descendant_count,0), COALESCE(ep.n,0), COALESCE(sv.n,0),
++          jsonb_build_object(
++            'epidemiology', CASE WHEN COALESCE(ep.n,0) > 0 THEN 1 ELSE 0 END,
++            'survival', CASE WHEN COALESCE(sv.n,0) > 0 THEN 1 ELSE 0 END,
++            'trials', CASE WHEN COALESCE(t.trial_count,0) > 0 THEN 1 ELSE 0 END,
++            'literature', CASE WHEN COALESCE(p.publication_count,0) > 0 THEN 1 ELSE 0 END,
++            'genomics', CASE WHEN COALESCE(g.cohort_count,0) > 0 THEN 1 ELSE 0 END,
++            'evidence', CASE WHEN COALESCE(e.evidence_count,0) > 0 THEN 1 ELSE 0 END,
++            'therapies', CASE WHEN COALESCE(a.approved_drug_count,0) > 0 THEN 1 ELSE 0 END
++          ), now()
++        FROM cancers c
++        LEFT JOIN trials t ON t.cancer_id = c.id
++        LEFT JOIN pubs p ON p.cancer_id = c.id
++        LEFT JOIN evid e ON e.cancer_id = c.id
++        LEFT JOIN cohorts g ON g.cancer_id = c.id
++        LEFT JOIN appr a ON a.cancer_id = c.id
++        LEFT JOIN epi ep ON ep.cancer_id = c.id
++        LEFT JOIN surv sv ON sv.cancer_id = c.id
++        LEFT JOIN tree tr ON tr.cancer_id = c.id
++        LEFT JOIN kids k ON k.cancer_id = c.id
++        WHERE c.status = 'active'
++        ON CONFLICT (entity_type, entity_id) DO UPDATE SET
++          trial_count = EXCLUDED.trial_count, active_trial_count = EXCLUDED.active_trial_count, recruiting_trial_count = EXCLUDED.recruiting_trial_count,
++          phase3_trial_count = EXCLUDED.phase3_trial_count, publication_count = EXCLUDED.publication_count, publication_count_5y = EXCLUDED.publication_count_5y,
++          publication_count_12m = EXCLUDED.publication_count_12m, gene_count = EXCLUDED.gene_count, variant_count = EXCLUDED.variant_count, drug_count = EXCLUDED.drug_count,
++          approved_drug_count = EXCLUDED.approved_drug_count, evidence_count = EXCLUDED.evidence_count, cohort_count = EXCLUDED.cohort_count, subtype_count = EXCLUDED.subtype_count,
++          descendant_count = EXCLUDED.descendant_count, epidemiology_obs_count = EXCLUDED.epidemiology_obs_count, survival_obs_count = EXCLUDED.survival_obs_count,
++          completeness = EXCLUDED.completeness, computed_at = now()
++        RETURNING 1
++      )
++      SELECT count(*)::text AS n FROM ins
++    `);
++    // Gene-level counters (cancers linked, evidence items) for gene pages.
++    await tx.execute(sql`
++      INSERT INTO entity_counters (entity_type, entity_id, evidence_count, variant_count, drug_count, trial_count, computed_at)
++      SELECT 'gene', g.id,
++        (SELECT count(*) FROM civic_evidence_items e WHERE e.status = 'ACCEPTED' AND g.id = ANY(e.gene_ids)),
++        (SELECT count(*) FROM variants v WHERE v.gene_id = g.id),
++        (SELECT count(DISTINCT t) FROM civic_evidence_items e, unnest(e.therapy_ids) t WHERE e.status = 'ACCEPTED' AND g.id = ANY(e.gene_ids)),
++        0, now()
++      FROM genes g
++      WHERE EXISTS (SELECT 1 FROM civic_evidence_items e WHERE g.id = ANY(e.gene_ids)) OR EXISTS (SELECT 1 FROM variants v WHERE v.gene_id = g.id) OR EXISTS (SELECT 1 FROM cancer_gene_frequencies f WHERE f.gene_id = g.id)
++      ON CONFLICT (entity_type, entity_id) DO UPDATE SET evidence_count = EXCLUDED.evidence_count, variant_count = EXCLUDED.variant_count, drug_count = EXCLUDED.drug_count, computed_at = now()
++    `);
++    await tx.execute(sql`UPDATE genes g SET is_cancer_gene = EXISTS (SELECT 1 FROM civic_evidence_items e WHERE e.status = 'ACCEPTED' AND g.id = ANY(e.gene_ids)) OR EXISTS (SELECT 1 FROM cancer_gene_frequencies f WHERE f.gene_id = g.id AND f.frequency >= 0.05 AND f.cases_affected >= 20)`);
++    return Number(rows[0]?.n ?? 0);
++  });
++}

added packages/ranking/src/engine.ts +173 −0

++import { and, eq, sql } from 'drizzle-orm';
++import { type Database, metricDefinitions, rankingSnapshots, rankings, entityCounters, cancers } from '@cancerindex/database';
++import { rankEntities, inputsHash, percentiles, type RankInput } from './rank.js';
++
++export interface Scope {
++  geography: string; // WORLD | ISO3 | slug
++  sex: 'all' | 'male' | 'female';
++  ageGroup: string;
++  year: number | null;
++  entityLevel: 'top' | 'all';
++}
++
++export function scopeKey(s: Scope): string {
++  return `geo=${s.geography}|sex=${s.sex}|age=${s.ageGroup}|year=${s.year ?? 'latest'}|level=${s.entityLevel}`;
++}
++
++export interface RankingResult {
++  metricSlug: string;
++  scopeKey: string;
++  eligible: number;
++  snapshotId: number;
++}
++
++/**
++ * Ranking engine (CLAUDE.md §30-35, §245-247, §288). Every snapshot stores scope, formula version,
++ * an inputs hash and per-row lineage (`inputs`) so "Why #4?" and TRACE can be answered.
++ *
++ * Phase 1 ships count-based metrics (trials, literature, molecular) for both entity levels and the
++ * burden/lethality/gap metrics only where epidemiology observations exist for the scope.
++ */
++export async function computeAllRankings(db: Database): Promise<RankingResult[]> {
++  const results: RankingResult[] = [];
++  const defs = await db.select().from(metricDefinitions);
++  const byslug = new Map(defs.map((d) => [d.slug, d]));
++
++  const countMetrics: Array<[string, keyof typeof entityCounters.$inferSelect]> = [
++    ['active_trials', 'activeTrialCount'],
++    ['recruiting_trials', 'recruitingTrialCount'],
++    ['phase3_trials', 'phase3TrialCount'],
++    ['publications_5y', 'publicationCount5y'],
++    ['publications_12m', 'publicationCount12m'],
++    ['curated_evidence_items', 'evidenceCount'],
++    ['associated_genes', 'geneCount'],
++    ['genomic_cohorts', 'cohortCount'],
++  ];
++
++  for (const level of ['top', 'all'] as const) {
++    const scope: Scope = { geography: 'WORLD', sex: 'all', ageGroup: 'all', year: null, entityLevel: level };
++    const counters = await db
++      .select({ id: cancers.id, c: entityCounters })
++      .from(cancers)
++      .innerJoin(entityCounters, and(eq(entityCounters.entityType, 'cancer'), eq(entityCounters.entityId, cancers.id)))
++      .where(level === 'top' ? and(eq(cancers.status, 'active'), eq(cancers.topLevel, true)) : and(eq(cancers.status, 'active'), eq(cancers.malignant, true)));
++    for (const [slug, field] of countMetrics) {
++      const def = byslug.get(slug);
++      if (!def) continue;
++      const items: RankInput[] = counters
++        .map((r) => ({ id: r.id, value: Number(r.c[field] ?? 0), inputs: { counter: field, computedAt: r.c.computedAt } }))
++        .filter((i) => (slug.startsWith('publications') ? i.value > 0 : true)); // publications: only cancers with a stored PubMed query
++      if (items.length === 0) continue;
++      const snap = await persistSnapshot(db, def, scope, items, { descending: true, sourceIds: def.sourceSlugs });
++      results.push(snap);
++    }
++    // Publication growth (derived from two windows).
++    const growthDef = byslug.get('publication_growth');
++    if (growthDef) {
++      const rows = await db.execute<{ cancer_id: string; m12: number; y5: number }>(sql`
++        SELECT cancer_id, max(count) FILTER (WHERE window_key = '12m') AS m12, max(count) FILTER (WHERE window_key = '5y_prior') AS y5
++        FROM literature_counts GROUP BY cancer_id`);
++      const ids = new Set(counters.map((c) => c.id));
++      const items: RankInput[] = rows
++        .filter((r) => ids.has(r.cancer_id) && r.y5 != null && r.m12 != null && Number(r.y5) >= 50)
++        .map((r) => ({ id: r.cancer_id, value: Number(r.m12) / (Number(r.y5) / 5), inputs: { publications_12m: Number(r.m12), publications_5y_prior: Number(r.y5), formula: growthDef.formula } }));
++      if (items.length) results.push(await persistSnapshot(db, growthDef, scope, items, { descending: true, sourceIds: ['pubmed'] }));
++    }
++  }
++
++  // Burden / lethality / gaps per geography-year where observations exist (top level only, §246-247).
++  const scopes = await db.execute<{ geography_id: string; slug: string; iso3: string | null; year: number; sex: string; source_id: string; n: number }>(sql`
++    SELECT o.geography_id, g.slug, g.iso3, o.year, o.sex, o.source_id, count(*) AS n
++    FROM epidemiology_observations o JOIN geographies g ON g.id = o.geography_id JOIN cancers c ON c.id = o.cancer_id
++    WHERE c.top_level AND o.age_group = 'all' AND o.metric IN ('incidence_count','mortality_count','as_incidence_rate','as_mortality_rate')
++    GROUP BY o.geography_id, g.slug, g.iso3, o.year, o.sex, o.source_id HAVING count(*) >= 10`);
++  for (const s of scopes) {
++    const scope: Scope = { geography: s.iso3 ?? s.slug.toUpperCase(), sex: s.sex as Scope['sex'], ageGroup: 'all', year: Number(s.year), entityLevel: 'top' };
++    const obs = await db.execute<{ cancer_id: string; metric: string; value: number; id: number; estimate_type: string; site_definition: string | null }>(sql`
++      SELECT o.cancer_id, o.metric, o.value, o.id, o.estimate_type, o.site_definition FROM epidemiology_observations o JOIN cancers c ON c.id = o.cancer_id
++      WHERE c.top_level AND o.geography_id = ${s.geography_id} AND o.year = ${s.year} AND o.sex = ${s.sex} AND o.age_group = 'all' AND o.source_id = ${s.source_id}`);
++    const byMetric = new Map<string, Map<string, { value: number; id: number; estimate_type: string; site: string | null }>>();
++    for (const o of obs) {
++      if (!byMetric.has(o.metric)) byMetric.set(o.metric, new Map());
++      byMetric.get(o.metric)!.set(o.cancer_id, { value: Number(o.value), id: o.id, estimate_type: o.estimate_type, site: o.site_definition });
++    }
++    for (const metric of ['incidence_count', 'mortality_count', 'as_incidence_rate', 'as_mortality_rate']) {
++      const def = byslug.get(metric);
++      const m = byMetric.get(metric);
++      if (!def || !m) continue;
++      const items: RankInput[] = [...m.entries()].map(([id, v]) => ({ id, value: v.value, confidence: v.estimate_type === 'observed' ? 'HIGH' : 'MEDIUM', inputs: { observationId: v.id, estimateType: v.estimate_type, siteDefinition: v.site, sourceId: s.source_id } }));
++      results.push(await persistSnapshot(db, def, scope, items, { descending: true, sourceIds: [s.source_id] }));
++    }
++    // Mortality-to-incidence ratio
++    const mirDef = byslug.get('mortality_incidence_ratio');
++    const inc = byMetric.get('incidence_count');
++    const mort = byMetric.get('mortality_count');
++    if (mirDef && inc && mort) {
++      const items: RankInput[] = [];
++      for (const [id, i] of inc) {
++        const d = mort.get(id);
++        if (!d || i.value < 100) continue;
++        items.push({ id, value: d.value / i.value, confidence: i.value >= 1000 ? 'HIGH' : 'MEDIUM', inputs: { incidenceObservationId: i.id, mortalityObservationId: d.id, incidence: i.value, deaths: d.value, formula: mirDef.formula } });
++      }
++      if (items.length) results.push(await persistSnapshot(db, mirDef, scope, items, { descending: true, sourceIds: [s.source_id] }));
++    }
++    // Gap indexes: burden percentile − activity percentile
++    if (mort) {
++      const burdenPct = percentiles([...mort.entries()].map(([id, v]) => ({ id, value: v.value })));
++      const counters = await db.select({ id: entityCounters.entityId, trials: entityCounters.activeTrialCount, pubs: entityCounters.publicationCount5y }).from(entityCounters).where(eq(entityCounters.entityType, 'cancer'));
++      const cmap = new Map(counters.map((c) => [c.id, c]));
++      for (const [slug, field] of [
++        ['trial_gap', 'trials'],
++        ['research_gap', 'pubs'],
++      ] as const) {
++        const def = byslug.get(slug);
++        if (!def) continue;
++        const ids = [...mort.keys()].filter((id) => cmap.has(id) && (field === 'trials' || (cmap.get(id)!.pubs ?? 0) > 0));
++        if (ids.length < 5) continue;
++        const actPct = percentiles(ids.map((id) => ({ id, value: Number(cmap.get(id)![field] ?? 0) })));
++        const items: RankInput[] = ids.map((id) => ({ id, value: (burdenPct.get(id) ?? 0) - (actPct.get(id) ?? 0), inputs: { burdenPercentile: burdenPct.get(id), activityPercentile: actPct.get(id), deaths: mort.get(id)!.value, activity: Number(cmap.get(id)![field] ?? 0), formula: def.formula } }));
++        results.push(await persistSnapshot(db, def, scope, items, { descending: true, sourceIds: [s.source_id, ...def.sourceSlugs] }));
++      }
++    }
++  }
++  return results;
++}
++
++async function persistSnapshot(db: Database, def: typeof metricDefinitions.$inferSelect, scope: Scope, items: RankInput[], opts: { descending: boolean; sourceIds: string[] }): Promise<RankingResult> {
++  const key = scopeKey(scope);
++  const ranked = rankEntities(items, { descending: def.higherIsWorse === false ? opts.descending : opts.descending });
++  const hash = await inputsHash(items);
++  return db.transaction(async (tx) => {
++    // Previous rank for change explanation (§311)
++    const prev = await tx.execute<{ cancer_id: string; rank: number }>(sql`
++      SELECT r.cancer_id, r.rank FROM rankings r JOIN ranking_snapshots s ON s.id = r.snapshot_id
++      WHERE s.metric_slug = ${def.slug} AND s.scope_key = ${key} AND s.is_current`);
++    const prevMap = new Map(prev.map((p) => [p.cancer_id, Number(p.rank)]));
++    await tx.update(rankingSnapshots).set({ isCurrent: false }).where(and(eq(rankingSnapshots.metricSlug, def.slug), eq(rankingSnapshots.scopeKey, key), eq(rankingSnapshots.isCurrent, true)));
++    const [snap] = await tx
++      .insert(rankingSnapshots)
++      .values({ metricId: def.id, metricSlug: def.slug, scopeKey: key, geography: scope.geography, sex: scope.sex, ageGroup: scope.ageGroup, year: scope.year, entityLevel: scope.entityLevel, formulaVersion: def.formulaVersion, eligibleEntities: ranked.length, inputsHash: hash, sourceIds: opts.sourceIds, isCurrent: true })
++      .returning({ id: rankingSnapshots.id });
++    const snapshotId = snap!.id;
++    const chunk = 500;
++    for (let i = 0; i < ranked.length; i += chunk) {
++      await tx.insert(rankings).values(
++        ranked.slice(i, i + chunk).map((r) => ({
++          snapshotId,
++          metricSlug: def.slug,
++          scopeKey: key,
++          cancerId: r.id,
++          rank: r.rank,
++          eligibleEntities: r.eligible,
++          percentile: r.percentile,
++          value: r.value,
++          unit: def.unit,
++          confidence: r.confidence ?? 'MEDIUM',
++          inputs: r.inputs ?? {},
++          previousRank: prevMap.get(r.id) ?? null,
++        })),
++      );
++    }
++    return { metricSlug: def.slug, scopeKey: key, eligible: ranked.length, snapshotId };
++  });
++}

added packages/ranking/src/index.ts +4 −0

++export * from './rank.js';
++export * from './counters.js';
++export * from './engine.js';
++export * from './trace.js';

added packages/ranking/src/rank.ts +50 −0

++/**
++ * Pure ranking primitives (CLAUDE.md §155: deterministic given fixed inputs).
++ */
++export interface RankInput {
++  id: string;
++  value: number;
++  /** Optional confidence label carried through to the output. */
++  confidence?: 'HIGH' | 'MEDIUM' | 'LOW' | 'INSUFFICIENT_DATA';
++  inputs?: Record<string, unknown>;
++}
++
++export interface RankOutput extends RankInput {
++  rank: number;
++  percentile: number; // 0..100, 100 = most extreme in the ranking direction
++  eligible: number;
++}
++
++/**
++ * Rank entities. `higherIsWorse === null` means "higher is first" (descending) by convention.
++ * Ties share the same rank (competition ranking: 1,2,2,4). Percentile = share of eligible entities
++ * ranked at or below this entity in the ranking direction.
++ */
++export function rankEntities(items: RankInput[], opts: { descending?: boolean } = {}): RankOutput[] {
++  const desc = opts.descending ?? true;
++  const valid = items.filter((i) => Number.isFinite(i.value));
++  const sorted = [...valid].sort((a, b) => (desc ? b.value - a.value : a.value - b.value) || a.id.localeCompare(b.id));
++  const n = sorted.length;
++  const out: RankOutput[] = [];
++  let rank = 0;
++  for (let i = 0; i < n; i++) {
++    const cur = sorted[i]!;
++    if (i === 0 || cur.value !== sorted[i - 1]!.value) rank = i + 1;
++    out.push({ ...cur, rank, eligible: n, percentile: n === 1 ? 100 : Math.round(((n - rank) / (n - 1)) * 1000) / 10 });
++  }
++  return out;
++}
++
++/** Percentile of each entity for a metric (0..100, higher value → higher percentile). */
++export function percentiles(items: RankInput[]): Map<string, number> {
++  const ranked = rankEntities(items, { descending: true });
++  return new Map(ranked.map((r) => [r.id, r.percentile]));
++}
++
++/** Stable hash of ranking inputs so a snapshot is reproducible/auditable. */
++export async function inputsHash(items: RankInput[]): Promise<string> {
++  const { createHash } = await import('node:crypto');
++  const h = createHash('sha256');
++  for (const i of [...items].sort((a, b) => a.id.localeCompare(b.id))) h.update(`${i.id}=${i.value};`);
++  return h.digest('hex').slice(0, 24);
++}

added packages/ranking/src/trace.ts +51 −0

++import { sql } from 'drizzle-orm';
++import type { Database } from '@cancerindex/database';
++
++/**
++ * Lineage trace (CLAUDE.md §252-253): ranked value → inputs → observation → provenance → raw record.
++ * Supported: rankings/<id>, epidemiology_observations/<id>, cancer_gene_frequencies/<id>, literature_counts/<id>.
++ */
++export async function traceValue(db: Database, table: string, id: string): Promise<Record<string, unknown>> {
++  const out: Record<string, unknown> = { table, id };
++  const prov = async (pid: number | null | undefined) => {
++    if (!pid) return null;
++    const [p] = await db.execute<Record<string, unknown>>(sql`SELECT p.*, s.name AS source_name, s.slug AS source_slug, s.license FROM provenance p JOIN sources s ON s.id = p.source_id WHERE p.id = ${pid}`);
++    if (!p) return null;
++    const [rec] = await db.execute<Record<string, unknown>>(sql`SELECT id, entity_kind, source_record_id, raw_path, payload_hash, retrieved_at, status FROM source_records WHERE source_id = ${p.source_id as string} AND source_record_id = ${(p.source_record_id as string) ?? ''} LIMIT 1`);
++    return { provenance: p, sourceRecord: rec ?? null };
++  };
++  switch (table) {
++    case 'rankings': {
++      const [r] = await db.execute<Record<string, unknown>>(sql`SELECT r.*, s.formula_version, s.inputs_hash, s.generated_at AS snapshot_generated_at, m.formula, m.name AS metric_name FROM rankings r JOIN ranking_snapshots s ON s.id = r.snapshot_id JOIN metric_definitions m ON m.slug = r.metric_slug WHERE r.id = ${Number(id)}`);
++      if (!r) return { ...out, error: 'not found' };
++      out.ranking = r;
++      const inputs = (r.inputs ?? {}) as Record<string, unknown>;
++      for (const k of ['observationId', 'incidenceObservationId', 'mortalityObservationId']) {
++        if (inputs[k]) out[k] = await traceValue(db, 'epidemiology_observations', String(inputs[k]));
++      }
++      return out;
++    }
++    case 'epidemiology_observations': {
++      const [o] = await db.execute<Record<string, unknown>>(sql`SELECT * FROM epidemiology_observations WHERE id = ${Number(id)}`);
++      if (!o) return { ...out, error: 'not found' };
++      return { ...out, observation: o, lineage: await prov(o.provenance_id as number) };
++    }
++    case 'cancer_gene_frequencies': {
++      const [o] = await db.execute<Record<string, unknown>>(sql`SELECT * FROM cancer_gene_frequencies WHERE id = ${Number(id)}`);
++      if (!o) return { ...out, error: 'not found' };
++      return { ...out, frequency: o, lineage: await prov(o.provenance_id as number) };
++    }
++    case 'literature_counts': {
++      const [o] = await db.execute<Record<string, unknown>>(sql`SELECT * FROM literature_counts WHERE id = ${Number(id)}`);
++      if (!o) return { ...out, error: 'not found' };
++      return { ...out, literatureCount: o, lineage: await prov(o.provenance_id as number) };
++    }
++    case 'survival_observations': {
++      const [o] = await db.execute<Record<string, unknown>>(sql`SELECT * FROM survival_observations WHERE id = ${Number(id)}`);
++      if (!o) return { ...out, error: 'not found' };
++      return { ...out, observation: o, lineage: await prov(o.provenance_id as number) };
++    }
++    default:
++      return { ...out, error: 'unsupported table' };
++  }
++}

added packages/ranking/test/rank.test.ts +33 −0

++import { describe, expect, it } from 'vitest';
++import { rankEntities, percentiles, inputsHash } from '../src/rank.js';
++
++describe('rankEntities', () => {
++  it('is deterministic and handles ties with competition ranking', () => {
++    const items = [
++      { id: 'b', value: 10 },
++      { id: 'a', value: 10 },
++      { id: 'c', value: 5 },
++      { id: 'd', value: 1 },
++    ];
++    const r = rankEntities(items);
++    expect(r.map((x) => [x.id, x.rank])).toEqual([
++      ['a', 1],
++      ['b', 1],
++      ['c', 3],
++      ['d', 4],
++    ]);
++    expect(r[0]!.percentile).toBe(100);
++    expect(r[3]!.percentile).toBe(0);
++    expect(rankEntities([...items].reverse())).toEqual(r);
++  });
++  it('drops non-finite values and ranks ascending when requested', () => {
++    const r = rankEntities([{ id: 'x', value: NaN }, { id: 'y', value: 2 }, { id: 'z', value: 1 }], { descending: false });
++    expect(r.map((x) => x.id)).toEqual(['z', 'y']);
++    expect(r[0]!.eligible).toBe(2);
++  });
++  it('percentiles and hash are stable', async () => {
++    const items = [{ id: 'a', value: 3 }, { id: 'b', value: 1 }];
++    expect(percentiles(items).get('a')).toBe(100);
++    expect(await inputsHash(items)).toBe(await inputsHash([...items].reverse()));
++  });
++});

added packages/ranking/tsconfig.json +8 −0

++{
++  "extends": "../../tsconfig.base.json",
++  "compilerOptions": {
++    "rootDir": ".",
++    "noEmit": true
++  },
++  "include": ["src", "test"]
++}

added packages/ranking/vitest.config.ts +3 −0

++import { defineConfig } from 'vitest/config';
++
++export default defineConfig({ test: { include: ['src/**/*.test.ts', 'test/**/*.test.ts'] } });

added packages/shared/package.json +26 −0

++{
++  "name": "@cancerindex/shared",
++  "version": "0.1.0",
++  "private": true,
++  "type": "module",
++  "exports": {
++    ".": {
++      "types": "./src/index.ts",
++      "default": "./src/index.ts"
++    }
++  },
++  "scripts": {
++    "build": "tsc -p tsconfig.json --noEmit",
++    "typecheck": "tsc -p tsconfig.json --noEmit",
++    "test": "vitest run --passWithNoTests"
++  },
++  "dependencies": {
++    "pino": "^9.7.0",
++    "zod": "^4.0.0"
++  },
++  "devDependencies": {
++    "@types/node": "^24.0.0",
++    "typescript": "^5.9.3",
++    "vitest": "^3.2.0"
++  }
++}

added packages/shared/src/env.ts +16 −0

++import path from 'node:path';
++
++export function dataDir(): string {
++  return path.resolve(process.env.CI_DATA_DIR ?? path.join(process.cwd(), 'data'));
++}
++
++export function isProduction(): boolean {
++  return process.env.NODE_ENV === 'production';
++}
++
++export function envInt(name: string, fallback: number): number {
++  const v = process.env[name];
++  if (!v) return fallback;
++  const n = Number(v);
++  return Number.isFinite(n) ? n : fallback;
++}

added packages/shared/src/ids.ts +70 −0

++/**
++ * CancerIndex stable public identifiers (CLAUDE.md §6).
++ *
++ *   CI-CAN-00000001   cancer entity
++ *   CI-GENE-00000001  gene
++ *   CI-VAR-00000001   variant
++ *   CI-DRUG-00000001  drug
++ *   CI-TRIAL-00000001 clinical trial
++ *   CI-PUB-00000001   publication
++ *   CI-BIO-00000001   biomarker
++ *   CI-STUDY-00000001 genomic study / cohort
++ *   CI-METRIC-00000001 metric definition
++ *   CI-SOURCE-00000001 source
++ *   CI-ORG-00000001   organization
++ *   CI-TRT-00000001   treatment / regimen
++ *   CI-ANAT-00000001  anatomical site
++ *   CI-GEO-00000001   geography
++ *   CI-PROV-00000001  provenance record
++ *
++ * IDs are minted from a database sequence per namespace (see @cancerindex/database `mintId`) and
++ * are never reused. Database auto-increment integers are never exposed publicly.
++ */
++export const ID_NAMESPACES = [
++  'CAN',
++  'GENE',
++  'VAR',
++  'DRUG',
++  'TRIAL',
++  'PUB',
++  'BIO',
++  'STUDY',
++  'METRIC',
++  'SOURCE',
++  'ORG',
++  'TRT',
++  'ANAT',
++  'GEO',
++  'PROV',
++  'EDGE',
++  'RANK',
++] as const;
++export type IdNamespace = (typeof ID_NAMESPACES)[number];
++
++export const ID_WIDTH = 8;
++
++export function formatId(ns: IdNamespace, n: number): string {
++  if (!Number.isInteger(n) || n < 1) throw new Error(`invalid id number ${n}`);
++  return `CI-${ns}-${String(n).padStart(ID_WIDTH, '0')}`;
++}
++
++const ID_RE = /^CI-([A-Z]+)-(\d{8,})$/;
++
++export function parseId(id: string): { ns: IdNamespace; n: number } | null {
++  const m = ID_RE.exec(id);
++  if (!m) return null;
++  const ns = m[1] as IdNamespace;
++  if (!ID_NAMESPACES.includes(ns)) return null;
++  return { ns, n: Number(m[2]) };
++}
++
++export function isCiId(id: string, ns?: IdNamespace): boolean {
++  const p = parseId(id);
++  return !!p && (ns ? p.ns === ns : true);
++}
++
++/** Ingest run identifiers: ING-CLINICALTRIALS-20260908-000019 (CLAUDE.md §176). */
++export function formatRunId(connectorId: string, date: Date, seq: number): string {
++  const d = date.toISOString().slice(0, 10).replace(/-/g, '');
++  return `ING-${connectorId.toUpperCase().replace(/[^A-Z0-9]/g, '')}-${d}-${String(seq).padStart(6, '0')}`;
++}

added packages/shared/src/index.ts +5 −0

++export * from './ids.js';
++export * from './provenance.js';
++export * from './normalize.js';
++export * from './logger.js';
++export * from './env.js';

added packages/shared/src/logger.ts +9 −0

++import pino from 'pino';
++
++export const logger = pino({
++  level: process.env.LOG_LEVEL ?? 'info',
++  base: { service: process.env.CI_SERVICE ?? 'cancerindex' },
++  timestamp: pino.stdTimeFunctions.isoTime,
++});
++
++export type Logger = typeof logger;

added packages/shared/src/normalize.ts +40 −0

++/**
++ * String normalization used by reconciliation (CLAUDE.md §69). Deterministic, no LLM.
++ */
++
++const GREEK: Record<string, string> = { α: 'alpha', β: 'beta', γ: 'gamma', δ: 'delta', κ: 'kappa', λ: 'lambda', μ: 'mu' };
++
++export function stripDiacritics(s: string): string {
++  return s.normalize('NFKD').replace(/[̀-ͯ]/g, '');
++}
++
++/** Lowercase, ASCII, punctuation → space, collapse whitespace. Keeps digits (G12C, HER2). */
++export function normalizeLabel(input: string): string {
++  let s = stripDiacritics(input).toLowerCase();
++  s = s.replace(/[αβγδκλμ]/g, (c) => GREEK[c] ?? c);
++  s = s.replace(/['’`"]/g, '');
++  s = s.replace(/[^a-z0-9]+/g, ' ');
++  s = s.replace(/\b(nos|unspecified|not otherwise specified)\b/g, ' ');
++  s = s.replace(/\bcarcinomas\b/g, 'carcinoma').replace(/\bcancers\b/g, 'cancer').replace(/\btumou?rs\b/g, 'tumor').replace(/\btumour\b/g, 'tumor').replace(/\bneoplasms\b/g, 'neoplasm').replace(/\bsarcomas\b/g, 'sarcoma').replace(/\blymphomas\b/g, 'lymphoma').replace(/\bleukaemia\b/g, 'leukemia').replace(/\bleukemias\b/g, 'leukemia');
++  return s.replace(/\s+/g, ' ').trim();
++}
++
++/** "Carcinoma, Non-Small-Cell Lung" (MeSH inverted form) → "Non-Small-Cell Lung Carcinoma". */
++export function uninvertMeshTerm(term: string): string {
++  const parts = term.split(',').map((p) => p.trim());
++  if (parts.length < 2) return term;
++  return [...parts.slice(1), parts[0]].join(' ');
++}
++
++/** URL slug for entity routes. */
++export function slugify(input: string): string {
++  return stripDiacritics(input)
++    .toLowerCase()
++    .replace(/[^a-z0-9]+/g, '-')
++    .replace(/^-+|-+$/g, '')
++    .slice(0, 120);
++}
++
++export function sha256Hex(data: string | Uint8Array): Promise<string> {
++  return import('node:crypto').then(({ createHash }) => createHash('sha256').update(data).digest('hex'));
++}

added packages/shared/src/provenance.ts +85 −0

++import { z } from 'zod';
++
++/** CLAUDE.md §2 — every imported fact carries provenance; every derived value is reproducible. */
++export const EvidenceType = z.enum([
++  'registry',
++  'clinical_trial',
++  'meta_analysis',
++  'systematic_review',
++  'cohort',
++  'case_control',
++  'case_series',
++  'case_report',
++  'preclinical',
++  'regulatory',
++  'guideline',
++  'expert_curation',
++  'database',
++  'computed',
++]);
++export type EvidenceType = z.infer<typeof EvidenceType>;
++
++export const AccessLevel = z.enum(['open', 'registration_required', 'controlled', 'licensed']);
++export type AccessLevel = z.infer<typeof AccessLevel>;
++
++export const ProvenanceInput = z.object({
++  sourceId: z.string(),
++  sourceRecordId: z.string().optional(),
++  sourceUrl: z.string().url().optional(),
++  dataset: z.string().optional(),
++  datasetVersion: z.string().optional(),
++  publicationId: z.string().optional(),
++  pmid: z.string().optional(),
++  doi: z.string().optional(),
++  retrievedAt: z.string().datetime(),
++  publishedAt: z.string().optional(),
++  updatedAt: z.string().optional(),
++  geography: z.string().optional(),
++  population: z.string().optional(),
++  cohortSize: z.number().int().nonnegative().optional(),
++  methodology: z.string().optional(),
++  evidenceType: EvidenceType,
++  accessLevel: AccessLevel,
++  confidence: z.number().min(0).max(1).optional(),
++  license: z.string().optional(),
++  ingestRunId: z.string().optional(),
++});
++export type ProvenanceInput = z.infer<typeof ProvenanceInput>;
++
++/** Data layer a value belongs to (CLAUDE.md §2 — layers stay separable). */
++export const DataLayer = z.enum(['raw', 'normalized', 'canonical', 'derived', 'ranked', 'ai_synthesis']);
++export type DataLayer = z.infer<typeof DataLayer>;
++
++/** Display category for scientific safety (CLAUDE.md §3). */
++export const ClaimCategory = z.enum([
++  'observed_data',
++  'published_evidence',
++  'curated_evidence',
++  'regulatory_status',
++  'clinical_guideline',
++  'computed_metric',
++  'ai_generated_synthesis',
++]);
++export type ClaimCategory = z.infer<typeof ClaimCategory>;
++
++/** Entity mapping confidence (CLAUDE.md §221). */
++export const MatchType = z.enum([
++  'EXACT_IDENTIFIER',
++  'CURATED_EXACT',
++  'ONTOLOGY_EXACT',
++  'CURATED_BROADER',
++  'CURATED_NARROWER',
++  'ALIAS',
++  'PROBABILISTIC',
++  'UNRESOLVED',
++]);
++export type MatchType = z.infer<typeof MatchType>;
++
++/** Derived statistic envelope (CLAUDE.md §2). */
++export interface DerivedValue {
++  metric: string;
++  value: number;
++  computed: true;
++  formulaVersion: string;
++  inputs: string[];
++}

added packages/shared/tsconfig.json +9 −0

++{
++  "extends": "../../tsconfig.base.json",
++  "compilerOptions": {
++    "rootDir": "src",
++    "outDir": "dist",
++    "noEmit": true
++  },
++  "include": ["src"]
++}

added pnpm-lock.yaml +2023 −0

++lockfileVersion: '9.0'
++
++settings:
++  autoInstallPeers: true
++  excludeLinksFromLockfile: false
++
++importers:
++
++  .:
++    dependencies:
++      '@cancerindex/connectors':
++        specifier: workspace:*
++        version: link:packages/connectors
++      '@cancerindex/database':
++        specifier: workspace:*
++        version: link:packages/database
++      '@cancerindex/ontology':
++        specifier: workspace:*
++        version: link:packages/ontology
++      '@cancerindex/ranking':
++        specifier: workspace:*
++        version: link:packages/ranking
++      '@cancerindex/shared':
++        specifier: workspace:*
++        version: link:packages/shared
++      drizzle-orm:
++        specifier: ^0.45.0
++        version: 0.45.2(postgres@3.4.9)
++      postgres:
++        specifier: ^3.4.7
++        version: 3.4.9
++    devDependencies:
++      '@types/node':
++        specifier: ^24.0.0
++        version: 24.13.3
++      tsx:
++        specifier: ^4.20.0
++        version: 4.23.13
++      typescript:
++        specifier: ^5.9.3
++        version: 5.9.3
++      vitest:
++        specifier: ^3.2.0
++        version: 3.2.7(@types/node@24.13.3)(tsx@4.23.13)(yaml@2.9.0)
++
++  packages/connectors:
++    dependencies:
++      '@cancerindex/database':
++        specifier: workspace:*
++        version: link:../database
++      '@cancerindex/ontology':
++        specifier: workspace:*
++        version: link:../ontology
++      '@cancerindex/shared':
++        specifier: workspace:*
++        version: link:../shared
++      drizzle-orm:
++        specifier: ^0.45.0
++        version: 0.45.2(postgres@3.4.9)
++      fast-xml-parser:
++        specifier: ^5.2.0
++        version: 5.11.1
++      postgres:
++        specifier: ^3.4.7
++        version: 3.4.9
++      yaml:
++        specifier: ^2.8.0
++        version: 2.9.0
++      zod:
++        specifier: ^4.0.0
++        version: 4.5.4
++    devDependencies:
++      '@types/node':
++        specifier: ^24.0.0
++        version: 24.13.3
++      typescript:
++        specifier: ^5.9.3
++        version: 5.9.3
++      vitest:
++        specifier: ^3.2.0
++        version: 3.2.7(@types/node@24.13.3)(tsx@4.23.13)(yaml@2.9.0)
++
++  packages/database:
++    dependencies:
++      '@cancerindex/shared':
++        specifier: workspace:*
++        version: link:../shared
++      drizzle-orm:
++        specifier: ^0.45.0
++        version: 0.45.2(postgres@3.4.9)
++      postgres:
++        specifier: ^3.4.7
++        version: 3.4.9
++    devDependencies:
++      '@types/node':
++        specifier: ^24.0.0
++        version: 24.13.3
++      drizzle-kit:
++        specifier: ^0.31.0
++        version: 0.31.10
++      tsx:
++        specifier: ^4.20.0
++        version: 4.23.13
++      typescript:
++        specifier: ^5.9.3
++        version: 5.9.3
++      vitest:
++        specifier: ^3.2.0
++        version: 3.2.7(@types/node@24.13.3)(tsx@4.23.13)(yaml@2.9.0)
++
++  packages/ontology:
++    dependencies:
++      '@cancerindex/database':
++        specifier: workspace:*
++        version: link:../database
++      '@cancerindex/shared':
++        specifier: workspace:*
++        version: link:../shared
++      drizzle-orm:
++        specifier: ^0.45.0
++        version: 0.45.2(postgres@3.4.9)
++    devDependencies:
++      '@types/node':
++        specifier: ^24.0.0
++        version: 24.13.3
++      typescript:
++        specifier: ^5.9.3
++        version: 5.9.3
++      vitest:
++        specifier: ^3.2.0
++        version: 3.2.7(@types/node@24.13.3)(tsx@4.23.13)(yaml@2.9.0)
++
++  packages/ranking:
++    dependencies:
++      '@cancerindex/database':
++        specifier: workspace:*
++        version: link:../database
++      '@cancerindex/ontology':
++        specifier: workspace:*
++        version: link:../ontology
++      '@cancerindex/shared':
++        specifier: workspace:*
++        version: link:../shared
++      drizzle-orm:
++        specifier: ^0.45.0
++        version: 0.45.2(postgres@3.4.9)
++    devDependencies:
++      '@types/node':
++        specifier: ^24.0.0
++        version: 24.13.3
++      typescript:
++        specifier: ^5.9.3
++        version: 5.9.3
++      vitest:
++        specifier: ^3.2.0
++        version: 3.2.7(@types/node@24.13.3)(tsx@4.23.13)(yaml@2.9.0)
++
++  packages/shared:
++    dependencies:
++      pino:
++        specifier: ^9.7.0
++        version: 9.14.0
++      zod:
++        specifier: ^4.0.0
++        version: 4.5.4
++    devDependencies:
++      '@types/node':
++        specifier: ^24.0.0
++        version: 24.13.3
++      typescript:
++        specifier: ^5.9.3
++        version: 5.9.3
++      vitest:
++        specifier: ^3.2.0
++        version: 3.2.7(@types/node@24.13.3)(tsx@4.23.13)(yaml@2.9.0)
++
++packages:
++
++  '@drizzle-team/brocli@0.10.2':
++    resolution: {integrity: sha512-z33Il7l5dKjUgGULTqBsQBQwckHh5AbIuxhdsIxDDiZAzBOrZO6q9ogcWC65kU382AfynTfgNumVcNIjuIua6w==}
++
++  '@esbuild-kit/core-utils@3.3.2':
++    resolution: {integrity: sha512-sPRAnw9CdSsRmEtnsl2WXWdyquogVpB3yZ3dgwJfe8zrOzTsV7cJvmwrKVa+0ma5BoiGJ+BoqkMvawbayKUsqQ==}
++    deprecated: 'Merged into tsx: https://tsx.hirok.io'
++
++  '@esbuild-kit/esm-loader@2.6.5':
++    resolution: {integrity: sha512-FxEMIkJKnodyA1OaCUoEvbYRkoZlLZ4d/eXFu9Fh8CbBBgP5EmZxrfTRyN0qpXZ4vOvqnE5YdRdcrmUUXuU+dA==}
++    deprecated: 'Merged into tsx: https://tsx.hirok.io'
++
++  '@esbuild/aix-ppc64@0.25.12':
++    resolution: {integrity: sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==}
++    engines: {node: '>=18'}
++    cpu: [ppc64]
++    os: [aix]
++
++  '@esbuild/aix-ppc64@0.28.2':
++    resolution: {integrity: sha512-XExcO+dvLKvVtNTibSTBej1NCAbaGhWn9Ww1ZPx80qsahhPFe/8jgWP0IchNe0F3HwkU7n8ejhH8bjonqht8mQ==}
++    engines: {node: '>=18'}
++    cpu: [ppc64]
++    os: [aix]
++
++  '@esbuild/android-arm64@0.18.20':
++    resolution: {integrity: sha512-Nz4rJcchGDtENV0eMKUNa6L12zz2zBDXuhj/Vjh18zGqB44Bi7MBMSXjgunJgjRhCmKOjnPuZp4Mb6OKqtMHLQ==}
++    engines: {node: '>=12'}
++    cpu: [arm64]
++    os: [android]
++
++  '@esbuild/android-arm64@0.25.12':
++    resolution: {integrity: sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==}
++    engines: {node: '>=18'}
++    cpu: [arm64]
++    os: [android]
++
++  '@esbuild/android-arm64@0.28.2':
++    resolution: {integrity: sha512-5YfKeeI8qWfBZIX+u2xZC3Zlb3Os/gLS2sbEKM+I4ZOcsWmHS2WLysCcQZDAFRslDUU5Oiq44gf6PYN1vGwG5A==}
++    engines: {node: '>=18'}
++    cpu: [arm64]
++    os: [android]
++
++  '@esbuild/android-arm@0.18.20':
++    resolution: {integrity: sha512-fyi7TDI/ijKKNZTUJAQqiG5T7YjJXgnzkURqmGj13C6dCqckZBLdl4h7bkhHt/t0WP+zO9/zwroDvANaOqO5Sw==}
++    engines: {node: '>=12'}
++    cpu: [arm]
++    os: [android]
++
++  '@esbuild/android-arm@0.25.12':
++    resolution: {integrity: sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==}
++    engines: {node: '>=18'}
++    cpu: [arm]
++    os: [android]
++
++  '@esbuild/android-arm@0.28.2':
++    resolution: {integrity: sha512-kXXoiPVVGQcnIYGOeaovwOURpniDBpSq4A03qkQ+BMQqtGG6HYap3xne9C1O1yo4TR3qxlCX5IqqmX6fFo2Lqg==}
++    engines: {node: '>=18'}
++    cpu: [arm]
++    os: [android]
++
++  '@esbuild/android-x64@0.18.20':
++    resolution: {integrity: sha512-8GDdlePJA8D6zlZYJV/jnrRAi6rOiNaCC/JclcXpB+KIuvfBN4owLtgzY2bsxnx666XjJx2kDPUmnTtR8qKQUg==}
++    engines: {node: '>=12'}
++    cpu: [x64]
++    os: [android]
++
++  '@esbuild/android-x64@0.25.12':
++    resolution: {integrity: sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==}
++    engines: {node: '>=18'}
++    cpu: [x64]
++    os: [android]
++
++  '@esbuild/android-x64@0.28.2':
++    resolution: {integrity: sha512-O387ite7SzUyCcy3JQX4P4bLtEA7bLLkx+esve5JHnyYfNTxcVpXZo9jhdB0lTKN44gztELTdU7nS8Nr16Fs1Q==}
++    engines: {node: '>=18'}
++    cpu: [x64]
++    os: [android]
++
++  '@esbuild/darwin-arm64@0.18.20':
++    resolution: {integrity: sha512-bxRHW5kHU38zS2lPTPOyuyTm+S+eobPUnTNkdJEfAddYgEcll4xkT8DB9d2008DtTbl7uJag2HuE5NZAZgnNEA==}
++    engines: {node: '>=12'}
++    cpu: [arm64]
++    os: [darwin]
++
++  '@esbuild/darwin-arm64@0.25.12':
++    resolution: {integrity: sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==}
++    engines: {node: '>=18'}
++    cpu: [arm64]
++    os: [darwin]
++
++  '@esbuild/darwin-arm64@0.28.2':
++    resolution: {integrity: sha512-n4KqkOQrraxHJcgjM1RvwbigfQKIKJVpM7xp+KsxiyUSrRdIXnt73VhrPAx0fV44hgfmIVKjxMN9J1t5jySVkw==}
++    engines: {node: '>=18'}
++    cpu: [arm64]
++    os: [darwin]
++
++  '@esbuild/darwin-x64@0.18.20':
++    resolution: {integrity: sha512-pc5gxlMDxzm513qPGbCbDukOdsGtKhfxD1zJKXjCCcU7ju50O7MeAZ8c4krSJcOIJGFR+qx21yMMVYwiQvyTyQ==}
++    engines: {node: '>=12'}
++    cpu: [x64]
++    os: [darwin]
++
++  '@esbuild/darwin-x64@0.25.12':
++    resolution: {integrity: sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==}
++    engines: {node: '>=18'}
++    cpu: [x64]
++    os: [darwin]
++
++  '@esbuild/darwin-x64@0.28.2':
++    resolution: {integrity: sha512-uq6suIWYP37qzGddBKPw5QEQPi6HiLGsO7UmkpfyaYNQ3D+rN6w6WfwH+nuqcGXWvawGwxOEroO4YGnFh95azw==}
++    engines: {node: '>=18'}
++    cpu: [x64]
++    os: [darwin]
++
++  '@esbuild/freebsd-arm64@0.18.20':
++    resolution: {integrity: sha512-yqDQHy4QHevpMAaxhhIwYPMv1NECwOvIpGCZkECn8w2WFHXjEwrBn3CeNIYsibZ/iZEUemj++M26W3cNR5h+Tw==}
++    engines: {node: '>=12'}
++    cpu: [arm64]
++    os: [freebsd]
++
++  '@esbuild/freebsd-arm64@0.25.12':
++    resolution: {integrity: sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==}
++    engines: {node: '>=18'}
++    cpu: [arm64]
++    os: [freebsd]
++
++  '@esbuild/freebsd-arm64@0.28.2':
++    resolution: {integrity: sha512-n+I0BTSRIoy+d6RPKnEVwql5UwBJolytvY4mAOIEJorKlqgPII8ix6slVVrfZ5Tnj7glIZvloylbB/EJPMWEXw==}
++    engines: {node: '>=18'}
++    cpu: [arm64]
++    os: [freebsd]
++
++  '@esbuild/freebsd-x64@0.18.20':
++    resolution: {integrity: sha512-tgWRPPuQsd3RmBZwarGVHZQvtzfEBOreNuxEMKFcd5DaDn2PbBxfwLcj4+aenoh7ctXcbXmOQIn8HI6mCSw5MQ==}
++    engines: {node: '>=12'}
++    cpu: [x64]
++    os: [freebsd]
++
++  '@esbuild/freebsd-x64@0.25.12':
++    resolution: {integrity: sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==}
++    engines: {node: '>=18'}
++    cpu: [x64]
++    os: [freebsd]
++
++  '@esbuild/freebsd-x64@0.28.2':
++    resolution: {integrity: sha512-78XJTJkvPs0kz2w61301PJjXl4g7q3JqiYMZ/M/yVI73EHBrCRTgkhu9oqG7vPqq+a/yadEW8aD+agKlk5xrmg==}
++    engines: {node: '>=18'}
++    cpu: [x64]
++    os: [freebsd]
++
++  '@esbuild/linux-arm64@0.18.20':
++    resolution: {integrity: sha512-2YbscF+UL7SQAVIpnWvYwM+3LskyDmPhe31pE7/aoTMFKKzIc9lLbyGUpmmb8a8AixOL61sQ/mFh3jEjHYFvdA==}
++    engines: {node: '>=12'}
++    cpu: [arm64]
++    os: [linux]
++
++  '@esbuild/linux-arm64@0.25.12':
++    resolution: {integrity: sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==}
++    engines: {node: '>=18'}
++    cpu: [arm64]
++    os: [linux]
++
++  '@esbuild/linux-arm64@0.28.2':
++    resolution: {integrity: sha512-pW4AC0P3it8c7do9MVM4p51FzHzdM/TZrerurgRcHJ2WTa1VQ1CIq18xncfpBJw4ojkiZZrKW2yIBWBP92j6Ug==}
++    engines: {node: '>=18'}
++    cpu: [arm64]
++    os: [linux]
++
++  '@esbuild/linux-arm@0.18.20':
++    resolution: {integrity: sha512-/5bHkMWnq1EgKr1V+Ybz3s1hWXok7mDFUMQ4cG10AfW3wL02PSZi5kFpYKrptDsgb2WAJIvRcDm+qIvXf/apvg==}
++    engines: {node: '>=12'}
++    cpu: [arm]
++    os: [linux]
++
++  '@esbuild/linux-arm@0.25.12':
++    resolution: {integrity: sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==}
++    engines: {node: '>=18'}
++    cpu: [arm]
++    os: [linux]
++
++  '@esbuild/linux-arm@0.28.2':
++    resolution: {integrity: sha512-XlDnu2q5yoqems+xay6wSAcg9DDD7K9RLKZEBOMZm3ckNpJBvOX20tSfby8KfrrhINDyv9V2YVZKY/SpoGJI8w==}
++    engines: {node: '>=18'}
++    cpu: [arm]
++    os: [linux]
++
++  '@esbuild/linux-ia32@0.18.20':
++    resolution: {integrity: sha512-P4etWwq6IsReT0E1KHU40bOnzMHoH73aXp96Fs8TIT6z9Hu8G6+0SHSw9i2isWrD2nbx2qo5yUqACgdfVGx7TA==}
++    engines: {node: '>=12'}
++    cpu: [ia32]
++    os: [linux]
++
++  '@esbuild/linux-ia32@0.25.12':
++    resolution: {integrity: sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==}
++    engines: {node: '>=18'}
++    cpu: [ia32]
++    os: [linux]
++
++  '@esbuild/linux-ia32@0.28.2':
++    resolution: {integrity: sha512-CYbnj78HsIeA+DhgUKgFCfvNsTHFhMMrinUrMZpDXJXKN8T3XViTZ/+wtHeVxEWY8ewSzTFN+nRmSwO2tZaLUQ==}
++    engines: {node: '>=18'}
++    cpu: [ia32]
++    os: [linux]
++
++  '@esbuild/linux-loong64@0.18.20':
++    resolution: {integrity: sha512-nXW8nqBTrOpDLPgPY9uV+/1DjxoQ7DoB2N8eocyq8I9XuqJ7BiAMDMf9n1xZM9TgW0J8zrquIb/A7s3BJv7rjg==}
++    engines: {node: '>=12'}
++    cpu: [loong64]
++    os: [linux]
++
++  '@esbuild/linux-loong64@0.25.12':
++    resolution: {integrity: sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==}
++    engines: {node: '>=18'}
++    cpu: [loong64]
++    os: [linux]
++
++  '@esbuild/linux-loong64@0.28.2':
++    resolution: {integrity: sha512-buwkd8nsph4R+ajRvw0qM5Hja/TXQow3ptzWO2EbG/cqcIkHloRrdlBtQlshyYGTNFvfkfJ5tpPLVkY4DtsPfQ==}
++    engines: {node: '>=18'}
++    cpu: [loong64]
++    os: [linux]
++
++  '@esbuild/linux-mips64el@0.18.20':
++    resolution: {integrity: sha512-d5NeaXZcHp8PzYy5VnXV3VSd2D328Zb+9dEq5HE6bw6+N86JVPExrA6O68OPwobntbNJ0pzCpUFZTo3w0GyetQ==}
++    engines: {node: '>=12'}
++    cpu: [mips64el]
++    os: [linux]
++
++  '@esbuild/linux-mips64el@0.25.12':
++    resolution: {integrity: sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==}
++    engines: {node: '>=18'}
++    cpu: [mips64el]
++    os: [linux]
++
++  '@esbuild/linux-mips64el@0.28.2':
++    resolution: {integrity: sha512-ZVykbDyk7519VwiNb9Lcj9m8XM6v5V9uKPvrEMkkEedVewf+0itkhahp4HDpgERXhwLRpWFypsGbG/J8s0QjJA==}
++    engines: {node: '>=18'}
++    cpu: [mips64el]
++    os: [linux]
++
++  '@esbuild/linux-ppc64@0.18.20':
++    resolution: {integrity: sha512-WHPyeScRNcmANnLQkq6AfyXRFr5D6N2sKgkFo2FqguP44Nw2eyDlbTdZwd9GYk98DZG9QItIiTlFLHJHjxP3FA==}
++    engines: {node: '>=12'}
++    cpu: [ppc64]
++    os: [linux]
++
++  '@esbuild/linux-ppc64@0.25.12':
++    resolution: {integrity: sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==}
++    engines: {node: '>=18'}
++    cpu: [ppc64]
++    os: [linux]
++
++  '@esbuild/linux-ppc64@0.28.2':
++    resolution: {integrity: sha512-CAXl+Dtd9UUuJd8pKKdwh6MLm3MUMiqMPmhZ3tTSXPqfyQ3vDl6R5hZdZ/kYojK4ofXtdfSv1tFq8XzWx3heNQ==}
++    engines: {node: '>=18'}
++    cpu: [ppc64]
++    os: [linux]
++
++  '@esbuild/linux-riscv64@0.18.20':
++    resolution: {integrity: sha512-WSxo6h5ecI5XH34KC7w5veNnKkju3zBRLEQNY7mv5mtBmrP/MjNBCAlsM2u5hDBlS3NGcTQpoBvRzqBcRtpq1A==}
++    engines: {node: '>=12'}
++    cpu: [riscv64]
++    os: [linux]
++
++  '@esbuild/linux-riscv64@0.25.12':
++    resolution: {integrity: sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==}
++    engines: {node: '>=18'}
++    cpu: [riscv64]
++    os: [linux]
++
++  '@esbuild/linux-riscv64@0.28.2':
++    resolution: {integrity: sha512-GeXCej4IQtU1B+QlDV8W/RRvbzI3O/Stss+/bCXv4lZls5WGRtu2a+3JkA3i4qIUlMXpcHebWpF8AkJhATowuA==}
++    engines: {node: '>=18'}
++    cpu: [riscv64]
++    os: [linux]
++
++  '@esbuild/linux-s390x@0.18.20':
++    resolution: {integrity: sha512-+8231GMs3mAEth6Ja1iK0a1sQ3ohfcpzpRLH8uuc5/KVDFneH6jtAJLFGafpzpMRO6DzJ6AvXKze9LfFMrIHVQ==}
++    engines: {node: '>=12'}
++    cpu: [s390x]
++    os: [linux]
++
++  '@esbuild/linux-s390x@0.25.12':
++    resolution: {integrity: sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==}
++    engines: {node: '>=18'}
++    cpu: [s390x]
++    os: [linux]
++
++  '@esbuild/linux-s390x@0.28.2':
++    resolution: {integrity: sha512-3H1weTYZPxt/WOhByszQZybS9w5lKzUn1FDMsgEChbHWQwHYQQRfBxgCcZvPhjHfKyJjIievvMmEUawJrdY9Dg==}
++    engines: {node: '>=18'}
++    cpu: [s390x]
++    os: [linux]
++
++  '@esbuild/linux-x64@0.18.20':
++    resolution: {integrity: sha512-UYqiqemphJcNsFEskc73jQ7B9jgwjWrSayxawS6UVFZGWrAAtkzjxSqnoclCXxWtfwLdzU+vTpcNYhpn43uP1w==}
++    engines: {node: '>=12'}
++    cpu: [x64]
++    os: [linux]
++
++  '@esbuild/linux-x64@0.25.12':
++    resolution: {integrity: sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==}
++    engines: {node: '>=18'}
++    cpu: [x64]
++    os: [linux]
++
++  '@esbuild/linux-x64@0.28.2':
++    resolution: {integrity: sha512-4xTZr1FUmSoQW4XIWmit3tzQrUTZM+N3P0XV8xROKYF50XfI7xeO90+1bZvNwxIufQ9hDQVRJH5YhgPVF8A/HQ==}
++    engines: {node: '>=18'}
++    cpu: [x64]
++    os: [linux]
++
++  '@esbuild/netbsd-arm64@0.25.12':
++    resolution: {integrity: sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==}
++    engines: {node: '>=18'}
++    cpu: [arm64]
++    os: [netbsd]
++
++  '@esbuild/netbsd-arm64@0.28.2':
++    resolution: {integrity: sha512-sSATRjPeDBg3pdgHoQfoYBob11Kk1FGa9lui5RIHZCoCkJa9QKlvl3/vKz2usCmYYjs7ymJR/2Nnsqe+Hjt5nw==}
++    engines: {node: '>=18'}
++    cpu: [arm64]
++    os: [netbsd]
++
++  '@esbuild/netbsd-x64@0.18.20':
++    resolution: {integrity: sha512-iO1c++VP6xUBUmltHZoMtCUdPlnPGdBom6IrO4gyKPFFVBKioIImVooR5I83nTew5UOYrk3gIJhbZh8X44y06A==}
++    engines: {node: '>=12'}
++    cpu: [x64]
++    os: [netbsd]
++
++  '@esbuild/netbsd-x64@0.25.12':
++    resolution: {integrity: sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==}
++    engines: {node: '>=18'}
++    cpu: [x64]
++    os: [netbsd]
++
++  '@esbuild/netbsd-x64@0.28.2':
++    resolution: {integrity: sha512-lqnzCV+mM0gIADaKihiCg6ifgfU2L3h5E33rNQBN1Y4MaVGnzryzmvvf7UHxprpQdE8hpqLolJ9Rl+SkIRDpyw==}
++    engines: {node: '>=18'}
++    cpu: [x64]
++    os: [netbsd]
++
++  '@esbuild/openbsd-arm64@0.25.12':
++    resolution: {integrity: sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==}
++    engines: {node: '>=18'}
++    cpu: [arm64]
++    os: [openbsd]
++
++  '@esbuild/openbsd-arm64@0.28.2':
++    resolution: {integrity: sha512-AL2qJILH7lNjrDmCQDvdxMfAUIv8KMNZOvrwAQ8i8//ntL9FflhOyMJ8OZSMBb8/AWXe3/5v5S20y3zCoZWKoQ==}
++    engines: {node: '>=18'}
++    cpu: [arm64]
++    os: [openbsd]
++
++  '@esbuild/openbsd-x64@0.18.20':
++    resolution: {integrity: sha512-e5e4YSsuQfX4cxcygw/UCPIEP6wbIL+se3sxPdCiMbFLBWu0eiZOJ7WoD+ptCLrmjZBK1Wk7I6D/I3NglUGOxg==}
++    engines: {node: '>=12'}
++    cpu: [x64]
++    os: [openbsd]
++
++  '@esbuild/openbsd-x64@0.25.12':
++    resolution: {integrity: sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==}
++    engines: {node: '>=18'}
++    cpu: [x64]
++    os: [openbsd]
++
++  '@esbuild/openbsd-x64@0.28.2':
++    resolution: {integrity: sha512-QtiuPytchRyC4rwUKhexJdQKvDuZ6hWloi3igqPQNUJCS1/v9EiO3UTOXR6A3FoMo4fnAKbWJdqaIwhOzh8qEw==}
++    engines: {node: '>=18'}
++    cpu: [x64]
++    os: [openbsd]
++
++  '@esbuild/openharmony-arm64@0.25.12':
++    resolution: {integrity: sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==}
++    engines: {node: '>=18'}
++    cpu: [arm64]
++    os: [openharmony]
++
++  '@esbuild/openharmony-arm64@0.28.2':
++    resolution: {integrity: sha512-WkhYDmpTjLvGlScA1rwjRUmhl4k8oXR3cIbtqWmELgU/dFeHHlEllxDvdWcNJV9rbzCexB5vz8gtNewWLgCT7Q==}
++    engines: {node: '>=18'}
++    cpu: [arm64]
++    os: [openharmony]
++
++  '@esbuild/sunos-x64@0.18.20':
++    resolution: {integrity: sha512-kDbFRFp0YpTQVVrqUd5FTYmWo45zGaXe0X8E1G/LKFC0v8x0vWrhOWSLITcCn63lmZIxfOMXtCfti/RxN/0wnQ==}
++    engines: {node: '>=12'}
++    cpu: [x64]
++    os: [sunos]
++
++  '@esbuild/sunos-x64@0.25.12':
++    resolution: {integrity: sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==}
++    engines: {node: '>=18'}
++    cpu: [x64]
++    os: [sunos]
++
++  '@esbuild/sunos-x64@0.28.2':
++    resolution: {integrity: sha512-GPMSkTOtMnv2U2F8gxe4Io6qmVs+YKyp832Etqqxr0hFngmXQ3rzwytelm3GIn7T4VviRUlf3sOgBOiTdvaf7g==}
++    engines: {node: '>=18'}
++    cpu: [x64]
++    os: [sunos]
++
++  '@esbuild/win32-arm64@0.18.20':
++    resolution: {integrity: sha512-ddYFR6ItYgoaq4v4JmQQaAI5s7npztfV4Ag6NrhiaW0RrnOXqBkgwZLofVTlq1daVTQNhtI5oieTvkRPfZrePg==}
++    engines: {node: '>=12'}
++    cpu: [arm64]
++    os: [win32]
++
++  '@esbuild/win32-arm64@0.25.12':
++    resolution: {integrity: sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==}
++    engines: {node: '>=18'}
++    cpu: [arm64]
++    os: [win32]
++
++  '@esbuild/win32-arm64@0.28.2':
++    resolution: {integrity: sha512-PIhhEkE9uPBleRBrQEJpUn7MBnibZzbGzYWPmY3x+YoVg/95zbjB4CxPPOQ8l5tYYM4mMaCthF8/1DIfBQQyWQ==}
++    engines: {node: '>=18'}
++    cpu: [arm64]
++    os: [win32]
++
++  '@esbuild/win32-ia32@0.18.20':
++    resolution: {integrity: sha512-Wv7QBi3ID/rROT08SABTS7eV4hX26sVduqDOTe1MvGMjNd3EjOz4b7zeexIR62GTIEKrfJXKL9LFxTYgkyeu7g==}
++    engines: {node: '>=12'}
++    cpu: [ia32]
++    os: [win32]
++
++  '@esbuild/win32-ia32@0.25.12':
++    resolution: {integrity: sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==}
++    engines: {node: '>=18'}
++    cpu: [ia32]
++    os: [win32]
++
++  '@esbuild/win32-ia32@0.28.2':
++    resolution: {integrity: sha512-YmJbfTlvU7Sdn9BB+4PRES4oB6pxgS37MAONj+hBr/cpXS1aBPKXxNnDbu+QCWPj0o9dgyxeq79g6c5P8KeuYA==}
++    engines: {node: '>=18'}
++    cpu: [ia32]
++    os: [win32]
++
++  '@esbuild/win32-x64@0.18.20':
++    resolution: {integrity: sha512-kTdfRcSiDfQca/y9QIkng02avJ+NCaQvrMejlsB3RRv5sE9rRoeBPISaZpKxHELzRxZyLvNts1P27W3wV+8geQ==}
++    engines: {node: '>=12'}
++    cpu: [x64]
++    os: [win32]
++
++  '@esbuild/win32-x64@0.25.12':
++    resolution: {integrity: sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==}
++    engines: {node: '>=18'}
++    cpu: [x64]
++    os: [win32]
++
++  '@esbuild/win32-x64@0.28.2':
++    resolution: {integrity: sha512-5ebpxr3nWMzrL/rnUI755Jkuee0bHL/Gq0WTF9lvcpv73wAp5eu8MfBUgWK9bhWvZjj7yX8etf/8tI8Ney695g==}
++    engines: {node: '>=18'}
++    cpu: [x64]
++    os: [win32]
++
++  '@jridgewell/sourcemap-codec@1.6.0':
++    resolution: {integrity: sha512-T7jf+5zgsZHwNJ4lvQ7/aezbyk0nNX+zJVWpmHA7VYsEx7a7qr5Rg5IbtJFqkgze5Y2sruq1RUY8Q837Od7iFw==}
++
++  '@napi-rs/lzma-linux-x64-gnu@1.5.1':
++    resolution: {integrity: sha512-oTXEIha4SsuXdTA4Iyskj0kpdx2yVXdhd75c2v3xGrHFfVMsbhTPZU/nMPL4sWKo4pBHm3aucLaqGlF696dTyQ==}
++    engines: {node: ^22.20 || ^24.12 || >=25}
++    cpu: [x64]
++    os: [linux]
++    libc: [glibc]
++
++  '@nodable/entities@3.0.0':
++    resolution: {integrity: sha512-8L9xFeTYKhm49xfIypoe2W5wV1m/3Z58kT+7kR9A8OyFxcPduI4VmxaUMQyKYrRjUoLLSXv6EKKID5Tvj9cUVw==}
++
++  '@pinojs/redact@0.4.0':
++    resolution: {integrity: sha512-k2ENnmBugE/rzQfEcdWHcCY+/FM3VLzH9cYEsbdsoqrvzAKRhUZeRNhAZvB8OitQJ1TBed3yqWtdjzS6wJKBwg==}
++
++  '@rollup/rollup-android-arm-eabi@4.63.1':
++    resolution: {integrity: sha512-UZ8sUxPTiHWYX9QNdJedb1kDZSpS1t/VPWBWGSgqHNi9w3Cu6IXvu2mzbhiTiPvtrqgTQJ+zqiAq2iPIPilpaQ==}
++    cpu: [arm]
++    os: [android]
++
++  '@rollup/rollup-android-arm64@4.63.1':
++    resolution: {integrity: sha512-cQ4nFQABN5cDvDpbvJ7bMStCpnaVxynZrRMfUJYgxcIk9Sh54FIO1vtfkg0B69REjER77ioZ/ov+eAApx/KmLQ==}
++    cpu: [arm64]
++    os: [android]
++
++  '@rollup/rollup-darwin-arm64@4.63.1':
++    resolution: {integrity: sha512-FQNqd1lRy/0QhDk3xeRIkSBiCpXCiDnZO3YLVdcDKN1UBiKToNftCzcXYNLshmPDUMlu2TdeS8tGcsU6f3YF1Q==}
++    cpu: [arm64]
++    os: [darwin]
++
++  '@rollup/rollup-darwin-x64@4.63.1':
++    resolution: {integrity: sha512-pvD16V939D3CloK0+qikpGaxiPrDUXTe7Y5cWOMkMSy7m1cawa8EGy/kXYi/G/cKAC4HDAbSnzCIk1WmsoOKXg==}
++    cpu: [x64]
++    os: [darwin]
++
++  '@rollup/rollup-freebsd-arm64@4.63.1':
++    resolution: {integrity: sha512-pcFGeL2345VwdTnJhA6zLbew+YgWB0qBG2+dMtXjCicf6+rm6kO6cOoh5VnTe0ZMrMRgRyuHmCJxZWrIdzYuOw==}
++    cpu: [arm64]
++    os: [freebsd]
++
++  '@rollup/rollup-freebsd-x64@4.63.1':
++    resolution: {integrity: sha512-mRJlqSRulVzcKq/LKA6ICSIc3K/l4fzlVn/gePn2nXIHy8seRi5z/eeRE0d/XMBxcMldiXtQTSpRj0tkkC3g8Q==}
++    cpu: [x64]
++    os: [freebsd]
++
++  '@rollup/rollup-linux-arm-gnueabihf@4.63.1':
++    resolution: {integrity: sha512-YDUNvVM85TI3g/1OpnqKP1h4NeW/j64DfWMf+G3M809xNk1bJSnpFp4sh83NpmVE5DXnkh8ULor4LTVZKoYLHw==}
++    cpu: [arm]
++    os: [linux]
++    libc: [glibc]
++
++  '@rollup/rollup-linux-arm-musleabihf@4.63.1':
++    resolution: {integrity: sha512-7Mcn71p9ZuQFAj+h+dhQXy/yeLePRS2yKRnmW1DijA9thKO5qap0GNOIQK4yQ6iP3SU0Mrb/yWo8h8vgRba8lw==}
++    cpu: [arm]
++    os: [linux]
++    libc: [musl]
++
++  '@rollup/rollup-linux-arm64-gnu@4.63.1':
++    resolution: {integrity: sha512-4YiLQTX6U4CSl0L9cluep9A9W6UmTfqBDc2/CH6wlu54pl4E7Jn3cOD8oxzvBDEGk/JMKgJ47C8g+radF7mwvg==}
++    cpu: [arm64]
++    os: [linux]
++    libc: [glibc]
++
++  '@rollup/rollup-linux-arm64-musl@4.63.1':
++    resolution: {integrity: sha512-2ra8F7w8OquwZN9z2/fKFnli69wa8PLwaVzRMIPGb13ByMJwC28Fbp8YcVGoUhlYMTt7j5j9bNgpysrN2UM+vw==}
++    cpu: [arm64]
++    os: [linux]
++    libc: [musl]
++
++  '@rollup/rollup-linux-loong64-gnu@4.63.1':
++    resolution: {integrity: sha512-Sy20ncyhjmBP0Ml+UvQbimjlk6VFgjW5uNP+qqwHB00mTE8Bl2C1TuHTlRwK2YoXeZbee5lP2XevBWVkAQAtSQ==}
++    cpu: [loong64]
++    os: [linux]
++    libc: [glibc]
++
++  '@rollup/rollup-linux-loong64-musl@4.63.1':
++    resolution: {integrity: sha512-noITLp8oNjYliPnGWmLyelIHwULGqbHloQHGw1rtxbWhTuWooRpnZarZQJ1y9EUC4szuCusCc+HEpUtxpIwYvA==}
++    cpu: [loong64]
++    os: [linux]
++    libc: [musl]
++
++  '@rollup/rollup-linux-ppc64-gnu@4.63.1':
++    resolution: {integrity: sha512-hlxxXd+F1mWiAcaFR7Sv9ZQT6m6UfI8+Vy/kFJzztq2pDMU/0wZ9sish0iszNZvsQDo8Gc0i5yuFEOz5dDf6fA==}
++    cpu: [ppc64]
++    os: [linux]
++    libc: [glibc]
++
++  '@rollup/rollup-linux-ppc64-musl@4.63.1':
++    resolution: {integrity: sha512-EF7OpqQTQ/BvGqLzUi4rEHuagCV9MugAUXSHemwPW5vxZ75RR+jxO/2j95Ph2dalMpFHSVECjRoioHZgA9zOYA==}
++    cpu: [ppc64]
++    os: [linux]
++    libc: [musl]
++
++  '@rollup/rollup-linux-riscv64-gnu@4.63.1':
++    resolution: {integrity: sha512-wQO3JesW9PRkwlabQ27y7sPfVOOTLRG73I4F2UYHG5PXun3J9U3y+b7ezVKSYbsvSKGQ1k1cq8Qlun4C9kLt3w==}
++    cpu: [riscv64]
++    os: [linux]
++    libc: [glibc]
++
++  '@rollup/rollup-linux-riscv64-musl@4.63.1':
++    resolution: {integrity: sha512-ouAGwhO6wHRXdnOVCOsB0tRFkA7nhNB2Nwax6oECXN0YiN8EYUTBAOudADOB1PI+yDL61TeNx/u7MVCzksNbkQ==}
++    cpu: [riscv64]
++    os: [linux]
++    libc: [musl]
++
++  '@rollup/rollup-linux-s390x-gnu@4.63.1':
++    resolution: {integrity: sha512-q2R38Sn+1J8RxhfJ+T54wSWmyKXWec+9jgDfqO2AtArEqHO5R2aeayp5H5OYLr5UYDVGsVaZPEFUooMhYCdz5A==}
++    cpu: [s390x]
++    os: [linux]
++    libc: [glibc]
++
++  '@rollup/rollup-linux-x64-gnu@4.63.1':
++    resolution: {integrity: sha512-gfI5T24WLLuFfSKw7Go/zDXjAAV0fny0swTaDv+WjK7vqcw4cRhFfdsyKL1n+ukI+ooBxn3bVQnyrn06WpI50w==}
++    cpu: [x64]
++    os: [linux]
++    libc: [glibc]
++
++  '@rollup/rollup-linux-x64-musl@4.63.1':
++    resolution: {integrity: sha512-4h6XqthmB4Hspji84wvgk+ElodTsGj+dbZqHJHHtKxj4mYq0ANSEEPX9ys3moJueqsRjwpaJYH7874Itwnj2ow==}
++    cpu: [x64]
++    os: [linux]
++    libc: [musl]
++
++  '@rollup/rollup-openbsd-x64@4.63.1':
++    resolution: {integrity: sha512-dlfCOa87o1VAYegLQ9EKilx2JCeRofiyPGhTCmqnuXZ6bMPiycO1rq1+sKoulAp7pGLIsTIw+1x5R+zgh5LhhA==}
++    cpu: [x64]
++    os: [openbsd]
++
++  '@rollup/rollup-openharmony-arm64@4.63.1':
++    resolution: {integrity: sha512-cjkLbOlfcm3QGhMM1J5zaZjsw1GggbN6rw9UTSSRrPrR1KkcXnN7Uq9rPw34xImQ9VOY9GN+6u2Zj80B9ptkcw==}
++    cpu: [arm64]
++    os: [openharmony]
++
++  '@rollup/rollup-win32-arm64-msvc@4.63.1':
++    resolution: {integrity: sha512-Li1KdUnWGE4N3e1F/B4RTB1ms+nG4WBgjByO46pkeBVX/2UBsY53xf5vK9WygVmnH3RwncIST7lkSdLSY6P9lg==}
++    cpu: [arm64]
++    os: [win32]
++
++  '@rollup/rollup-win32-ia32-msvc@4.63.1':
++    resolution: {integrity: sha512-t4ZYOSoLTgwhuFMrmTMLx/+i1DQVK7HYqMc6kY46EApwi8X0nIVphzdNoThU3xt6n+N5urG1/gxBdCaKDLavfg==}
++    cpu: [ia32]
++    os: [win32]
++
++  '@rollup/rollup-win32-x64-gnu@4.63.1':
++    resolution: {integrity: sha512-RgroPfMmKlD1RzSDxvwgcPiy2HNQKoYV7OmwIXDsk73uKW5t6B/V8KIy27SMv/FNXFo/oSBtWc9J0X7t91ezZg==}
++    cpu: [x64]
++    os: [win32]
++
++  '@rollup/rollup-win32-x64-msvc@4.63.1':
++    resolution: {integrity: sha512-at8QVep6S3h5Y6gSbdGU06bRY5WJkf6WUduM9YtvYMbYhB1MOFfUgc6kehitQXzOtMSaT70q7f9ydPhpqu821w==}
++    cpu: [x64]
++    os: [win32]
++
++  '@types/chai@5.2.3':
++    resolution: {integrity: sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==}
++
++  '@types/deep-eql@4.0.2':
++    resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==}
++
++  '@types/estree@1.0.9':
++    resolution: {integrity: sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==}
++
++  '@types/node@24.13.3':
++    resolution: {integrity: sha512-Dh8vAsV36ig5wa9OX4pXvMc9D3Veibfw2wix0CUwYODLD8nkj9UsLjASr49nPg+2eKzxhBV+v7L8pXvT4e639Q==}
++
++  '@vitest/expect@3.2.7':
++    resolution: {integrity: sha512-E8eBXaKibuvH2pSZErOjdVb5vF4PbKYcrnluBTYxEk1l/VhhwZg1kZQsdtjq+CsF5CFydf2Rdkz7jDHKSisi3w==}
++
++  '@vitest/mocker@3.2.7':
++    resolution: {integrity: sha512-Trr0hYO9CM3Wj6ksWHRhK9IZpIY6wTMO5u/MqXurMxT57sWBaOPEtP3Oq60ihZuh5JsiagKfz95OcxdEP6dBrA==}
++    peerDependencies:
++      msw: ^2.4.9
++      vite: ^5.0.0 || ^6.0.0 || ^7.0.0-0
++    peerDependenciesMeta:
++      msw:
++        optional: true
++      vite:
++        optional: true
++
++  '@vitest/pretty-format@3.2.7':
++    resolution: {integrity: sha512-KUHlwqVu0sRlhCdyPdQ/wBoTfRahjUky1MubOmYw9fWfIZy1gNoHpuaaQBPAaMaVYdQYHJLurzj8ECCj5OwTqA==}
++
++  '@vitest/runner@3.2.7':
++    resolution: {integrity: sha512-sB9y4ovltoQP+WaUPwmSxO9WIg9Ig694Di5PalVPsYHklAdE027mehpWF2SQSVq+k6sFgaivbTjTJwZLSHbedA==}
++
++  '@vitest/snapshot@3.2.7':
++    resolution: {integrity: sha512-7C+MwShwtBSI5Buwoyg3s/iY1eHL9PKAf+O1wVh/TdnjXUtkoL/9YQtre90i4MtNXM6edP1wJ2zOBpfCyhIS7g==}
++
++  '@vitest/spy@3.2.7':
++    resolution: {integrity: sha512-Q2eQGI6d2L/hBtZ0qNuKcAGid68XK6cv1xsoaIma6PaJhHPoqcEJhYpXZ/5myCMqkNgtP6UKuBhbc0nHKnrkuQ==}
++
++  '@vitest/utils@3.2.7':
++    resolution: {integrity: sha512-x6BDOd7dyo3PFLY3I9/HJ25X/6OurhGXk2/B9gOZNPF7XDVjeBK4k01lQE5uvDpbuheErh91qYuE1E2OEjK3Rw==}
++
++  anynum@1.0.1:
++    resolution: {integrity: sha512-N6//FLET/tXYNM/F6ABca1oH6fWB+KlTt909Le28WMDBk8oaT4vY17DCrwg2MvmuqUKt3Ni4N5dGJ/EoBgcO6A==}
++
++  assertion-error@2.0.1:
++    resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==}
++    engines: {node: '>=12'}
++
++  atomic-sleep@1.0.0:
++    resolution: {integrity: sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ==}
++    engines: {node: '>=8.0.0'}
++
++  buffer-from@1.1.2:
++    resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}
++
++  cac@6.7.14:
++    resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==}
++    engines: {node: '>=8'}
++
++  chai@5.3.3:
++    resolution: {integrity: sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==}
++    engines: {node: '>=18'}
++
++  check-error@2.1.3:
++    resolution: {integrity: sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==}
++    engines: {node: '>= 16'}
++
++  debug@4.4.3:
++    resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}
++    engines: {node: '>=6.0'}
++    peerDependencies:
++      supports-color: '*'
++    peerDependenciesMeta:
++      supports-color:
++        optional: true
++
++  deep-eql@5.0.2:
++    resolution: {integrity: sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==}
++    engines: {node: '>=6'}
++
++  drizzle-kit@0.31.10:
++    resolution: {integrity: sha512-7OZcmQUrdGI+DUNNsKBn1aW8qSoKuTH7d0mYgSP8bAzdFzKoovxEFnoGQp2dVs82EOJeYycqRtciopszwUf8bw==}
++    hasBin: true
++
++  drizzle-orm@0.45.2:
++    resolution: {integrity: sha512-kY0BSaTNYWnoDMVoyY8uxmyHjpJW1geOmBMdSSicKo9CIIWkSxMIj2rkeSR51b8KAPB7m+qysjuHme5nKP+E5Q==}
++    peerDependencies:
++      '@aws-sdk/client-rds-data': '>=3'
++      '@cloudflare/workers-types': '>=4'
++      '@electric-sql/pglite': '>=0.2.0'
++      '@libsql/client': '>=0.10.0'
++      '@libsql/client-wasm': '>=0.10.0'
++      '@neondatabase/serverless': '>=0.10.0'
++      '@op-engineering/op-sqlite': '>=2'
++      '@opentelemetry/api': ^1.4.1
++      '@planetscale/database': '>=1.13'
++      '@prisma/client': '*'
++      '@tidbcloud/serverless': '*'
++      '@types/better-sqlite3': '*'
++      '@types/pg': '*'
++      '@types/sql.js': '*'
++      '@upstash/redis': '>=1.34.7'
++      '@vercel/postgres': '>=0.8.0'
++      '@xata.io/client': '*'
++      better-sqlite3: '>=7'
++      bun-types: '*'
++      expo-sqlite: '>=14.0.0'
++      gel: '>=2'
++      knex: '*'
++      kysely: '*'
++      mysql2: '>=2'
++      pg: '>=8'
++      postgres: '>=3'
++      prisma: '*'
++      sql.js: '>=1'
++      sqlite3: '>=5'
++    peerDependenciesMeta:
++      '@aws-sdk/client-rds-data':
++        optional: true
++      '@cloudflare/workers-types':
++        optional: true
++      '@electric-sql/pglite':
++        optional: true
++      '@libsql/client':
++        optional: true
++      '@libsql/client-wasm':
++        optional: true
++      '@neondatabase/serverless':
++        optional: true
++      '@op-engineering/op-sqlite':
++        optional: true
++      '@opentelemetry/api':
++        optional: true
++      '@planetscale/database':
++        optional: true
++      '@prisma/client':
++        optional: true
++      '@tidbcloud/serverless':
++        optional: true
++      '@types/better-sqlite3':
++        optional: true
++      '@types/pg':
++        optional: true
++      '@types/sql.js':
++        optional: true
++      '@upstash/redis':
++        optional: true
++      '@vercel/postgres':
++        optional: true
++      '@xata.io/client':
++        optional: true
++      better-sqlite3:
++        optional: true
++      bun-types:
++        optional: true
++      expo-sqlite:
++        optional: true
++      gel:
++        optional: true
++      knex:
++        optional: true
++      kysely:
++        optional: true
++      mysql2:
++        optional: true
++      pg:
++        optional: true
++      postgres:
++        optional: true
++      prisma:
++        optional: true
++      sql.js:
++        optional: true
++      sqlite3:
++        optional: true
++
++  es-module-lexer@1.7.0:
++    resolution: {integrity: sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==}
++
++  esbuild@0.18.20:
++    resolution: {integrity: sha512-ceqxoedUrcayh7Y7ZX6NdbbDzGROiyVBgC4PriJThBKSVPWnnFHZAkfI1lJT8QFkOwH4qOS2SJkS4wvpGl8BpA==}
++    engines: {node: '>=12'}
++    hasBin: true
++
++  esbuild@0.25.12:
++    resolution: {integrity: sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==}
++    engines: {node: '>=18'}
++    hasBin: true
++
++  esbuild@0.28.2:
++    resolution: {integrity: sha512-HKVLS8dvII+xoKW9kmqxbRKrnWEXfJJr/FZhhJmiqIB0e053QNYFqOBouTMO/k5sID4MvCiUCvv8b9M4h32wIA==}
++    engines: {node: '>=18'}
++    hasBin: true
++
++  estree-walker@3.0.3:
++    resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==}
++
++  expect-type@1.4.0:
++    resolution: {integrity: sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA==}
++    engines: {node: '>=12.0.0'}
++
++  fast-xml-builder@1.3.1:
++    resolution: {integrity: sha512-pIM/1n3ntFXKYrUZwW7QCK0gAW7XY+wzj1YMIV3tLDvPj/V+zTGJK5e3/4WJfwj0qWw2ElNXiTixda/R+3YSug==}
++
++  fast-xml-parser@5.11.1:
++    resolution: {integrity: sha512-TBw6K/fxoQGGjCmZDw9w/ZwP3uDcnTM4YH/g+PFRWr8sbe5idXtxNN6vITh4+1ruCZaho6uBFurElsA7F0zzgw==}
++    hasBin: true
++
++  fdir@6.5.0:
++    resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==}
++    engines: {node: '>=12.0.0'}
++    peerDependencies:
++      picomatch: ^3 || ^4
++    peerDependenciesMeta:
++      picomatch:
++        optional: true
++
++  fsevents@2.3.3:
++    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
++    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
++    os: [darwin]
++
++  get-tsconfig@4.14.3:
++    resolution: {integrity: sha512-++QEw4DIY7WGoukz+/+A/8dGYPT9l9yIadnmSgZ8Rjr3YVSVDipQSO9CdnJo9ePqFqUUqh+wk9uIaoiAwsiPkA==}
++
++  is-unsafe@2.0.2:
++    resolution: {integrity: sha512-HgbIHPBH0KHHCcjLfGsCvhtPTVxjaAZlXjwdz7/GQC40SjSe4sfQsar8J5VFo8JOSbarkpV0OLG95bbaNd9aAQ==}
++
++  js-tokens@9.0.1:
++    resolution: {integrity: sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==}
++
++  loupe@3.2.1:
++    resolution: {integrity: sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==}
++
++  magic-string@0.30.21:
++    resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
++
++  ms@2.1.3:
++    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
++
++  nanoid@3.3.18:
++    resolution: {integrity: sha512-DTg4MJbGMWkfi6VZFdNt2/caMbQy4Ou+Op/hJQvGEWcnVfoA1QA+xzRKAzw9jD6+GVOOeYr/mIcuDSdug6F6+w==}
++    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
++    hasBin: true
++
++  on-exit-leak-free@2.1.2:
++    resolution: {integrity: sha512-0eJJY6hXLGf1udHwfNftBqH+g73EU4B504nZeKpz1sYRKafAghwxEJunB2O7rDZkL4PGfsMVnTXZ2EjibbqcsA==}
++    engines: {node: '>=14.0.0'}
++
++  path-expression-matcher@1.6.2:
++    resolution: {integrity: sha512-enSlaiat05iasnzmgNxRj8reFdj3puY2QpNgP1aPIaVfT6nn9ICuPoFlKHk8EN22HcwewshO+mN2DGbkCEOtqQ==}
++    engines: {node: '>=14.0.0'}
++
++  pathe@2.0.3:
++    resolution: {integrity: sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==}
++
++  pathval@2.0.1:
++    resolution: {integrity: sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==}
++    engines: {node: '>= 14.16'}
++
++  picocolors@1.1.1:
++    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
++
++  picomatch@4.0.7:
++    resolution: {integrity: sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA==}
++    engines: {node: '>=12'}
++
++  pino-abstract-transport@2.0.0:
++    resolution: {integrity: sha512-F63x5tizV6WCh4R6RHyi2Ml+M70DNRXt/+HANowMflpgGFMAym/VKm6G7ZOQRjqN7XbGxK1Lg9t6ZrtzOaivMw==}
++
++  pino-std-serializers@7.1.0:
++    resolution: {integrity: sha512-BndPH67/JxGExRgiX1dX0w1FvZck5Wa4aal9198SrRhZjH3GxKQUKIBnYJTdj2HDN3UQAS06HlfcSbQj2OHmaw==}
++
++  pino@9.14.0:
++    resolution: {integrity: sha512-8OEwKp5juEvb/MjpIc4hjqfgCNysrS94RIOMXYvpYCdm/jglrKEiAYmiumbmGhCvs+IcInsphYDFwqrjr7398w==}
++    hasBin: true
++
++  postcss@8.5.28:
++    resolution: {integrity: sha512-RRuzqDtt5Y9h3quz5hWhK+TPnsmVs6WwSU6LkJMeY4HstUEDuYTG8UJSdawMRzmzAtV+KEoG8N3Qg2qLy5vM/A==}
++    engines: {node: ^10 || ^12 || >=14}
++
++  postgres@3.4.9:
++    resolution: {integrity: sha512-GD3qdB0x1z9xgFI6cdRD6xu2Sp2WCOEoe3mtnyB5Ee0XrrL5Pe+e4CCnJrRMnL1zYtRDZmQQVbvOttLnKDLnaw==}
++    engines: {node: '>=12'}
++
++  process-warning@5.1.0:
++    resolution: {integrity: sha512-jQSaVHsPgtyw60e1rQ/A+/ArPEj/S8pS/vFnyGa/gYFXrKk/6RuDkoqVDQ5NI5MmS01698ltlAk0NoDBNLujRw==}
++
++  quick-format-unescaped@4.0.4:
++    resolution: {integrity: sha512-tYC1Q1hgyRuHgloV/YXs2w15unPVh8qfu/qCTfhTYamaw7fyhumKa2yGpdSo87vY32rIclj+4fWYQXUMs9EHvg==}
++
++  real-require@0.2.0:
++    resolution: {integrity: sha512-57frrGM/OCTLqLOAh0mhVA9VBMHd+9U7Zb2THMGdBUoZVOtGbJzjxsYGDJ3A9AYYCP4hn6y1TVbaOfzWtm5GFg==}
++    engines: {node: '>= 12.13.0'}
++
++  resolve-pkg-maps@1.0.0:
++    resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==}
++
++  rollup@4.63.1:
++    resolution: {integrity: sha512-3Df9jsstwhccuEfmAMi9l8XUh/GOkVObmFTU7CCVBysEbcOZLl84jCtaAZMcPiMz2EGKsATzQcU+Xr3n/wU6cg==}
++    engines: {node: '>=18.0.0', npm: '>=8.0.0'}
++    hasBin: true
++
++  safe-stable-stringify@2.5.0:
++    resolution: {integrity: sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==}
++    engines: {node: '>=10'}
++
++  siginfo@2.0.0:
++    resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==}
++
++  sonic-boom@4.2.1:
++    resolution: {integrity: sha512-w6AxtubXa2wTXAUsZMMWERrsIRAdrK0Sc+FUytWvYAhBJLyuI4llrMIC1DtlNSdI99EI86KZum2MMq3EAZlF9Q==}
++
++  source-map-js@1.2.1:
++    resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
++    engines: {node: '>=0.10.0'}
++
++  source-map-support@0.5.21:
++    resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==}
++
++  source-map@0.6.1:
++    resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
++    engines: {node: '>=0.10.0'}
++
++  split2@4.2.0:
++    resolution: {integrity: sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==}
++    engines: {node: '>= 10.x'}
++
++  stackback@0.0.2:
++    resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==}
++
++  std-env@3.10.0:
++    resolution: {integrity: sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==}
++
++  strip-literal@3.1.0:
++    resolution: {integrity: sha512-8r3mkIM/2+PpjHoOtiAW8Rg3jJLHaV7xPwG+YRGrv6FP0wwk/toTpATxWYOW0BKdWwl82VT2tFYi5DlROa0Mxg==}
++
++  strnum@2.4.2:
++    resolution: {integrity: sha512-rDG3Ah4TV0k1hWvLSzkZtMmLN9+eS+h3knq4MP6A42Y3Yh5qGNnOUs1jJkoSr8FG5dsL28c7KgkIBzSEykqtuw==}
++
++  thread-stream@3.2.0:
++    resolution: {integrity: sha512-zLBvqpwr4Esa0kRjcrzGU6zL25lePWaCLMx0RQFrmteozIfeNdaMLpG5U7PeHzvlFkAWaRKA9/KVW4F60iB+qw==}
++
++  tinybench@2.9.0:
++    resolution: {integrity: sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==}
++
++  tinyexec@0.3.2:
++    resolution: {integrity: sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==}
++
++  tinyglobby@0.2.17:
++    resolution: {integrity: sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==}
++    engines: {node: '>=12.0.0'}
++
++  tinypool@1.1.1:
++    resolution: {integrity: sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==}
++    engines: {node: ^18.0.0 || >=20.0.0}
++
++  tinyrainbow@2.0.0:
++    resolution: {integrity: sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==}
++    engines: {node: '>=14.0.0'}
++
++  tinyspy@4.0.6:
++    resolution: {integrity: sha512-u8KszXvGfU68hVcZpRHKG28T0krMuv2G5nDhiHaMLen/gIuFEgIJhaJuO69qjnXg5paSrbPMFfx3brNuN8eVSg==}
++    engines: {node: '>=14.0.0'}
++
++  tsx@4.23.13:
++    resolution: {integrity: sha512-BL5MGkRln6aDYhb0xbQlEAGw743BaZYWdbWtdJOBriYJboKgUUYCadFp2/FpBBZquBC/ezNBn7wMMPx7FDZUDw==}
++    engines: {node: '>=18.0.0'}
++    hasBin: true
++
++  typescript@5.9.3:
++    resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
++    engines: {node: '>=14.17'}
++    hasBin: true
++
++  undici-types@7.18.2:
++    resolution: {integrity: sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==}
++
++  vite-node@3.2.4:
++    resolution: {integrity: sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg==}
++    engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0}
++    hasBin: true
++
++  vite@7.3.6:
++    resolution: {integrity: sha512-4XP60spRGjSZFf1qYH+dJIkK2znL3zQfl9KkOV9MkkRR/3Dls0dxaBsQPTloEc5BLXWPL9vsOxopxyKoMmDueg==}
++    engines: {node: ^20.19.0 || >=22.12.0}
++    hasBin: true
++    peerDependencies:
++      '@types/node': ^20.19.0 || >=22.12.0
++      jiti: '>=1.21.0'
++      less: ^4.0.0
++      lightningcss: ^1.21.0
++      sass: ^1.70.0
++      sass-embedded: ^1.70.0
++      stylus: '>=0.54.8'
++      sugarss: ^5.0.0
++      terser: ^5.16.0
++      tsx: ^4.8.1
++      yaml: ^2.4.2
++    peerDependenciesMeta:
++      '@types/node':
++        optional: true
++      jiti:
++        optional: true
++      less:
++        optional: true
++      lightningcss:
++        optional: true
++      sass:
++        optional: true
++      sass-embedded:
++        optional: true
++      stylus:
++        optional: true
++      sugarss:
++        optional: true
++      terser:
++        optional: true
++      tsx:
++        optional: true
++      yaml:
++        optional: true
++
++  vitest@3.2.7:
++    resolution: {integrity: sha512-KrxIJ62Fd89gfysR4WotlgZABiz2dqFPgqGzX7s+CwsqLFomRH7777ZcrOD6+WVAh7khPQP41A+BKbpcJFrdEg==}
++    engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0}
++    hasBin: true
++    peerDependencies:
++      '@edge-runtime/vm': '*'
++      '@types/debug': ^4.1.12
++      '@types/node': ^18.0.0 || ^20.0.0 || >=22.0.0
++      '@vitest/browser': 3.2.7
++      '@vitest/ui': 3.2.7
++      happy-dom: '*'
++      jsdom: '*'
++    peerDependenciesMeta:
++      '@edge-runtime/vm':
++        optional: true
++      '@types/debug':
++        optional: true
++      '@types/node':
++        optional: true
++      '@vitest/browser':
++        optional: true
++      '@vitest/ui':
++        optional: true
++      happy-dom:
++        optional: true
++      jsdom:
++        optional: true
++
++  why-is-node-running@2.3.0:
++    resolution: {integrity: sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==}
++    engines: {node: '>=8'}
++    hasBin: true
++
++  xml-naming@0.3.0:
++    resolution: {integrity: sha512-ghig2TBE/H11aOVgmahA3MhimvkBr6JIYknH/Dhdk10nXwdbIqBJsbfMxpvFPG8bAw77gN29aQWvKpmVoPlvPQ==}
++    engines: {node: '>=16.0.0'}
++
++  yaml@2.9.0:
++    resolution: {integrity: sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA==}
++    engines: {node: '>= 14.6'}
++    hasBin: true
++
++  zod@4.5.4:
++    resolution: {integrity: sha512-sC95tT5iHHH9gtpj6A81kh+NEaRAUFN+qlUPDUbRfOMvNf5QCBqsb3WgvnpVtK5Y+4UfA6KqufotuTvMGiTlsA==}
++
++snapshots:
++
++  '@drizzle-team/brocli@0.10.2': {}
++
++  '@esbuild-kit/core-utils@3.3.2':
++    dependencies:
++      esbuild: 0.18.20
++      source-map-support: 0.5.21
++
++  '@esbuild-kit/esm-loader@2.6.5':
++    dependencies:
++      '@esbuild-kit/core-utils': 3.3.2
++      get-tsconfig: 4.14.3
++
++  '@esbuild/aix-ppc64@0.25.12':
++    optional: true
++
++  '@esbuild/aix-ppc64@0.28.2':
++    optional: true
++
++  '@esbuild/android-arm64@0.18.20':
++    optional: true
++
++  '@esbuild/android-arm64@0.25.12':
++    optional: true
++
++  '@esbuild/android-arm64@0.28.2':
++    optional: true
++
++  '@esbuild/android-arm@0.18.20':
++    optional: true
++
++  '@esbuild/android-arm@0.25.12':
++    optional: true
++
++  '@esbuild/android-arm@0.28.2':
++    optional: true
++
++  '@esbuild/android-x64@0.18.20':
++    optional: true
++
++  '@esbuild/android-x64@0.25.12':
++    optional: true
++
++  '@esbuild/android-x64@0.28.2':
++    optional: true
++
++  '@esbuild/darwin-arm64@0.18.20':
++    optional: true
++
++  '@esbuild/darwin-arm64@0.25.12':
++    optional: true
++
++  '@esbuild/darwin-arm64@0.28.2':
++    optional: true
++
++  '@esbuild/darwin-x64@0.18.20':
++    optional: true
++
++  '@esbuild/darwin-x64@0.25.12':
++    optional: true
++
++  '@esbuild/darwin-x64@0.28.2':
++    optional: true
++
++  '@esbuild/freebsd-arm64@0.18.20':
++    optional: true
++
++  '@esbuild/freebsd-arm64@0.25.12':
++    optional: true
++
++  '@esbuild/freebsd-arm64@0.28.2':
++    optional: true
++
++  '@esbuild/freebsd-x64@0.18.20':
++    optional: true
++
++  '@esbuild/freebsd-x64@0.25.12':
++    optional: true
++
++  '@esbuild/freebsd-x64@0.28.2':
++    optional: true
++
++  '@esbuild/linux-arm64@0.18.20':
++    optional: true
++
++  '@esbuild/linux-arm64@0.25.12':
++    optional: true
++
++  '@esbuild/linux-arm64@0.28.2':
++    optional: true
++
++  '@esbuild/linux-arm@0.18.20':
++    optional: true
++
++  '@esbuild/linux-arm@0.25.12':
++    optional: true
++
++  '@esbuild/linux-arm@0.28.2':
++    optional: true
++
++  '@esbuild/linux-ia32@0.18.20':
++    optional: true
++
++  '@esbuild/linux-ia32@0.25.12':
++    optional: true
++
++  '@esbuild/linux-ia32@0.28.2':
++    optional: true
++
++  '@esbuild/linux-loong64@0.18.20':
++    optional: true
++
++  '@esbuild/linux-loong64@0.25.12':
++    optional: true
++
++  '@esbuild/linux-loong64@0.28.2':
++    optional: true
++
++  '@esbuild/linux-mips64el@0.18.20':
++    optional: true
++
++  '@esbuild/linux-mips64el@0.25.12':
++    optional: true
++
++  '@esbuild/linux-mips64el@0.28.2':
++    optional: true
++
++  '@esbuild/linux-ppc64@0.18.20':
++    optional: true
++
++  '@esbuild/linux-ppc64@0.25.12':
++    optional: true
++
++  '@esbuild/linux-ppc64@0.28.2':
++    optional: true
++
++  '@esbuild/linux-riscv64@0.18.20':
++    optional: true
++
++  '@esbuild/linux-riscv64@0.25.12':
++    optional: true
++
++  '@esbuild/linux-riscv64@0.28.2':
++    optional: true
++
++  '@esbuild/linux-s390x@0.18.20':
++    optional: true
++
++  '@esbuild/linux-s390x@0.25.12':
++    optional: true
++
++  '@esbuild/linux-s390x@0.28.2':
++    optional: true
++
++  '@esbuild/linux-x64@0.18.20':
++    optional: true
++
++  '@esbuild/linux-x64@0.25.12':
++    optional: true
++
++  '@esbuild/linux-x64@0.28.2':
++    optional: true
++
++  '@esbuild/netbsd-arm64@0.25.12':
++    optional: true
++
++  '@esbuild/netbsd-arm64@0.28.2':
++    optional: true
++
++  '@esbuild/netbsd-x64@0.18.20':
++    optional: true
++
++  '@esbuild/netbsd-x64@0.25.12':
++    optional: true
++
++  '@esbuild/netbsd-x64@0.28.2':
++    optional: true
++
++  '@esbuild/openbsd-arm64@0.25.12':
++    optional: true
++
++  '@esbuild/openbsd-arm64@0.28.2':
++    optional: true
++
++  '@esbuild/openbsd-x64@0.18.20':
++    optional: true
++
++  '@esbuild/openbsd-x64@0.25.12':
++    optional: true
++
++  '@esbuild/openbsd-x64@0.28.2':
++    optional: true
++
++  '@esbuild/openharmony-arm64@0.25.12':
++    optional: true
++
++  '@esbuild/openharmony-arm64@0.28.2':
++    optional: true
++
++  '@esbuild/sunos-x64@0.18.20':
++    optional: true
++
++  '@esbuild/sunos-x64@0.25.12':
++    optional: true
++
++  '@esbuild/sunos-x64@0.28.2':
++    optional: true
++
++  '@esbuild/win32-arm64@0.18.20':
++    optional: true
++
++  '@esbuild/win32-arm64@0.25.12':
++    optional: true
++
++  '@esbuild/win32-arm64@0.28.2':
++    optional: true
++
++  '@esbuild/win32-ia32@0.18.20':
++    optional: true
++
++  '@esbuild/win32-ia32@0.25.12':
++    optional: true
++
++  '@esbuild/win32-ia32@0.28.2':
++    optional: true
++
++  '@esbuild/win32-x64@0.18.20':
++    optional: true
++
++  '@esbuild/win32-x64@0.25.12':
++    optional: true
++
++  '@esbuild/win32-x64@0.28.2':
++    optional: true
++
++  '@jridgewell/sourcemap-codec@1.6.0': {}
++
++  '@napi-rs/lzma-linux-x64-gnu@1.5.1':
++    optional: true
++
++  '@nodable/entities@3.0.0': {}
++
++  '@pinojs/redact@0.4.0': {}
++
++  '@rollup/rollup-android-arm-eabi@4.63.1':
++    optional: true
++
++  '@rollup/rollup-android-arm64@4.63.1':
++    optional: true
++
++  '@rollup/rollup-darwin-arm64@4.63.1':
++    optional: true
++
++  '@rollup/rollup-darwin-x64@4.63.1':
++    optional: true
++
++  '@rollup/rollup-freebsd-arm64@4.63.1':
++    optional: true
++
++  '@rollup/rollup-freebsd-x64@4.63.1':
++    optional: true
++
++  '@rollup/rollup-linux-arm-gnueabihf@4.63.1':
++    optional: true
++
++  '@rollup/rollup-linux-arm-musleabihf@4.63.1':
++    optional: true
++
++  '@rollup/rollup-linux-arm64-gnu@4.63.1':
++    optional: true
++
++  '@rollup/rollup-linux-arm64-musl@4.63.1':
++    optional: true
++
++  '@rollup/rollup-linux-loong64-gnu@4.63.1':
++    optional: true
++
++  '@rollup/rollup-linux-loong64-musl@4.63.1':
++    optional: true
++
++  '@rollup/rollup-linux-ppc64-gnu@4.63.1':
++    optional: true
++
++  '@rollup/rollup-linux-ppc64-musl@4.63.1':
++    optional: true
++
++  '@rollup/rollup-linux-riscv64-gnu@4.63.1':
++    optional: true
++
++  '@rollup/rollup-linux-riscv64-musl@4.63.1':
++    optional: true
++
++  '@rollup/rollup-linux-s390x-gnu@4.63.1':
++    optional: true
++
++  '@rollup/rollup-linux-x64-gnu@4.63.1':
++    optional: true
++
++  '@rollup/rollup-linux-x64-musl@4.63.1':
++    optional: true
++
++  '@rollup/rollup-openbsd-x64@4.63.1':
++    optional: true
++
++  '@rollup/rollup-openharmony-arm64@4.63.1':
++    optional: true
++
++  '@rollup/rollup-win32-arm64-msvc@4.63.1':
++    optional: true
++
++  '@rollup/rollup-win32-ia32-msvc@4.63.1':
++    optional: true
++
++  '@rollup/rollup-win32-x64-gnu@4.63.1':
++    optional: true
++
++  '@rollup/rollup-win32-x64-msvc@4.63.1':
++    optional: true
++
++  '@types/chai@5.2.3':
++    dependencies:
++      '@types/deep-eql': 4.0.2
++      assertion-error: 2.0.1
++
++  '@types/deep-eql@4.0.2': {}
++
++  '@types/estree@1.0.9': {}
++
++  '@types/node@24.13.3':
++    dependencies:
++      undici-types: 7.18.2
++
++  '@vitest/expect@3.2.7':
++    dependencies:
++      '@types/chai': 5.2.3
++      '@vitest/spy': 3.2.7
++      '@vitest/utils': 3.2.7
++      chai: 5.3.3
++      tinyrainbow: 2.0.0
++
++  '@vitest/mocker@3.2.7(vite@7.3.6(@types/node@24.13.3)(tsx@4.23.13)(yaml@2.9.0))':
++    dependencies:
++      '@vitest/spy': 3.2.7
++      estree-walker: 3.0.3
++      magic-string: 0.30.21
++    optionalDependencies:
++      vite: 7.3.6(@types/node@24.13.3)(tsx@4.23.13)(yaml@2.9.0)
++
++  '@vitest/pretty-format@3.2.7':
++    dependencies:
++      tinyrainbow: 2.0.0
++
++  '@vitest/runner@3.2.7':
++    dependencies:
++      '@vitest/utils': 3.2.7
++      pathe: 2.0.3
++      strip-literal: 3.1.0
++
++  '@vitest/snapshot@3.2.7':
++    dependencies:
++      '@vitest/pretty-format': 3.2.7
++      magic-string: 0.30.21
++      pathe: 2.0.3
++
++  '@vitest/spy@3.2.7':
++    dependencies:
++      tinyspy: 4.0.6
++
++  '@vitest/utils@3.2.7':
++    dependencies:
++      '@vitest/pretty-format': 3.2.7
++      loupe: 3.2.1
++      tinyrainbow: 2.0.0
++
++  anynum@1.0.1: {}
++
++  assertion-error@2.0.1: {}
++
++  atomic-sleep@1.0.0: {}
++
++  buffer-from@1.1.2: {}
++
++  cac@6.7.14: {}
++
++  chai@5.3.3:
++    dependencies:
++      assertion-error: 2.0.1
++      check-error: 2.1.3
++      deep-eql: 5.0.2
++      loupe: 3.2.1
++      pathval: 2.0.1
++
++  check-error@2.1.3: {}
++
++  debug@4.4.3:
++    dependencies:
++      ms: 2.1.3
++
++  deep-eql@5.0.2: {}
++
++  drizzle-kit@0.31.10:
++    dependencies:
++      '@drizzle-team/brocli': 0.10.2
++      '@esbuild-kit/esm-loader': 2.6.5
++      esbuild: 0.25.12
++      tsx: 4.23.13
++
++  drizzle-orm@0.45.2(postgres@3.4.9):
++    optionalDependencies:
++      postgres: 3.4.9
++
++  es-module-lexer@1.7.0: {}
++
++  esbuild@0.18.20:
++    optionalDependencies:
++      '@esbuild/android-arm': 0.18.20
++      '@esbuild/android-arm64': 0.18.20
++      '@esbuild/android-x64': 0.18.20
++      '@esbuild/darwin-arm64': 0.18.20
++      '@esbuild/darwin-x64': 0.18.20
++      '@esbuild/freebsd-arm64': 0.18.20
++      '@esbuild/freebsd-x64': 0.18.20
++      '@esbuild/linux-arm': 0.18.20
++      '@esbuild/linux-arm64': 0.18.20
++      '@esbuild/linux-ia32': 0.18.20
++      '@esbuild/linux-loong64': 0.18.20
++      '@esbuild/linux-mips64el': 0.18.20
++      '@esbuild/linux-ppc64': 0.18.20
++      '@esbuild/linux-riscv64': 0.18.20
++      '@esbuild/linux-s390x': 0.18.20
++      '@esbuild/linux-x64': 0.18.20
++      '@esbuild/netbsd-x64': 0.18.20
++      '@esbuild/openbsd-x64': 0.18.20
++      '@esbuild/sunos-x64': 0.18.20
++      '@esbuild/win32-arm64': 0.18.20
++      '@esbuild/win32-ia32': 0.18.20
++      '@esbuild/win32-x64': 0.18.20
++
++  esbuild@0.25.12:
++    optionalDependencies:
++      '@esbuild/aix-ppc64': 0.25.12
++      '@esbuild/android-arm': 0.25.12
++      '@esbuild/android-arm64': 0.25.12
++      '@esbuild/android-x64': 0.25.12
++      '@esbuild/darwin-arm64': 0.25.12
++      '@esbuild/darwin-x64': 0.25.12
++      '@esbuild/freebsd-arm64': 0.25.12
++      '@esbuild/freebsd-x64': 0.25.12
++      '@esbuild/linux-arm': 0.25.12
++      '@esbuild/linux-arm64': 0.25.12
++      '@esbuild/linux-ia32': 0.25.12
++      '@esbuild/linux-loong64': 0.25.12
++      '@esbuild/linux-mips64el': 0.25.12
++      '@esbuild/linux-ppc64': 0.25.12
++      '@esbuild/linux-riscv64': 0.25.12
++      '@esbuild/linux-s390x': 0.25.12
++      '@esbuild/linux-x64': 0.25.12
++      '@esbuild/netbsd-arm64': 0.25.12
++      '@esbuild/netbsd-x64': 0.25.12
++      '@esbuild/openbsd-arm64': 0.25.12
++      '@esbuild/openbsd-x64': 0.25.12
++      '@esbuild/openharmony-arm64': 0.25.12
++      '@esbuild/sunos-x64': 0.25.12
++      '@esbuild/win32-arm64': 0.25.12
++      '@esbuild/win32-ia32': 0.25.12
++      '@esbuild/win32-x64': 0.25.12
++
++  esbuild@0.28.2:
++    optionalDependencies:
++      '@esbuild/aix-ppc64': 0.28.2
++      '@esbuild/android-arm': 0.28.2
++      '@esbuild/android-arm64': 0.28.2
++      '@esbuild/android-x64': 0.28.2
++      '@esbuild/darwin-arm64': 0.28.2
++      '@esbuild/darwin-x64': 0.28.2
++      '@esbuild/freebsd-arm64': 0.28.2
++      '@esbuild/freebsd-x64': 0.28.2
++      '@esbuild/linux-arm': 0.28.2
++      '@esbuild/linux-arm64': 0.28.2
++      '@esbuild/linux-ia32': 0.28.2
++      '@esbuild/linux-loong64': 0.28.2
++      '@esbuild/linux-mips64el': 0.28.2
++      '@esbuild/linux-ppc64': 0.28.2
++      '@esbuild/linux-riscv64': 0.28.2
++      '@esbuild/linux-s390x': 0.28.2
++      '@esbuild/linux-x64': 0.28.2
++      '@esbuild/netbsd-arm64': 0.28.2
++      '@esbuild/netbsd-x64': 0.28.2
++      '@esbuild/openbsd-arm64': 0.28.2
++      '@esbuild/openbsd-x64': 0.28.2
++      '@esbuild/openharmony-arm64': 0.28.2
++      '@esbuild/sunos-x64': 0.28.2
++      '@esbuild/win32-arm64': 0.28.2
++      '@esbuild/win32-ia32': 0.28.2
++      '@esbuild/win32-x64': 0.28.2
++
++  estree-walker@3.0.3:
++    dependencies:
++      '@types/estree': 1.0.9
++
++  expect-type@1.4.0: {}
++
++  fast-xml-builder@1.3.1:
++    dependencies:
++      path-expression-matcher: 1.6.2
++      xml-naming: 0.3.0
++
++  fast-xml-parser@5.11.1:
++    dependencies:
++      '@nodable/entities': 3.0.0
++      fast-xml-builder: 1.3.1
++      is-unsafe: 2.0.2
++      path-expression-matcher: 1.6.2
++      strnum: 2.4.2
++      xml-naming: 0.3.0
++
++  fdir@6.5.0(picomatch@4.0.7):
++    optionalDependencies:
++      picomatch: 4.0.7
++
++  fsevents@2.3.3:
++    optional: true
++
++  get-tsconfig@4.14.3:
++    dependencies:
++      resolve-pkg-maps: 1.0.0
++
++  is-unsafe@2.0.2: {}
++
++  js-tokens@9.0.1: {}
++
++  loupe@3.2.1: {}
++
++  magic-string@0.30.21:
++    dependencies:
++      '@jridgewell/sourcemap-codec': 1.6.0
++
++  ms@2.1.3: {}
++
++  nanoid@3.3.18: {}
++
++  on-exit-leak-free@2.1.2: {}
++
++  path-expression-matcher@1.6.2: {}
++
++  pathe@2.0.3: {}
++
++  pathval@2.0.1: {}
++
++  picocolors@1.1.1: {}
++
++  picomatch@4.0.7: {}
++
++  pino-abstract-transport@2.0.0:
++    dependencies:
++      split2: 4.2.0
++
++  pino-std-serializers@7.1.0: {}
++
++  pino@9.14.0:
++    dependencies:
++      '@pinojs/redact': 0.4.0
++      atomic-sleep: 1.0.0
++      on-exit-leak-free: 2.1.2
++      pino-abstract-transport: 2.0.0
++      pino-std-serializers: 7.1.0
++      process-warning: 5.1.0
++      quick-format-unescaped: 4.0.4
++      real-require: 0.2.0
++      safe-stable-stringify: 2.5.0
++      sonic-boom: 4.2.1
++      thread-stream: 3.2.0
++
++  postcss@8.5.28:
++    dependencies:
++      nanoid: 3.3.18
++      picocolors: 1.1.1
++      source-map-js: 1.2.1
++
++  postgres@3.4.9: {}
++
++  process-warning@5.1.0: {}
++
++  quick-format-unescaped@4.0.4: {}
++
++  real-require@0.2.0: {}
++
++  resolve-pkg-maps@1.0.0: {}
++
++  rollup@4.63.1:
++    dependencies:
++      '@types/estree': 1.0.9
++    optionalDependencies:
++      '@napi-rs/lzma-linux-x64-gnu': 1.5.1
++      '@rollup/rollup-android-arm-eabi': 4.63.1
++      '@rollup/rollup-android-arm64': 4.63.1
++      '@rollup/rollup-darwin-arm64': 4.63.1
++      '@rollup/rollup-darwin-x64': 4.63.1
++      '@rollup/rollup-freebsd-arm64': 4.63.1
++      '@rollup/rollup-freebsd-x64': 4.63.1
++      '@rollup/rollup-linux-arm-gnueabihf': 4.63.1
++      '@rollup/rollup-linux-arm-musleabihf': 4.63.1
++      '@rollup/rollup-linux-arm64-gnu': 4.63.1
++      '@rollup/rollup-linux-arm64-musl': 4.63.1
++      '@rollup/rollup-linux-loong64-gnu': 4.63.1
++      '@rollup/rollup-linux-loong64-musl': 4.63.1
++      '@rollup/rollup-linux-ppc64-gnu': 4.63.1
++      '@rollup/rollup-linux-ppc64-musl': 4.63.1
++      '@rollup/rollup-linux-riscv64-gnu': 4.63.1
++      '@rollup/rollup-linux-riscv64-musl': 4.63.1
++      '@rollup/rollup-linux-s390x-gnu': 4.63.1
++      '@rollup/rollup-linux-x64-gnu': 4.63.1
++      '@rollup/rollup-linux-x64-musl': 4.63.1
++      '@rollup/rollup-openbsd-x64': 4.63.1
++      '@rollup/rollup-openharmony-arm64': 4.63.1
++      '@rollup/rollup-win32-arm64-msvc': 4.63.1
++      '@rollup/rollup-win32-ia32-msvc': 4.63.1
++      '@rollup/rollup-win32-x64-gnu': 4.63.1
++      '@rollup/rollup-win32-x64-msvc': 4.63.1
++      fsevents: 2.3.3
++
++  safe-stable-stringify@2.5.0: {}
++
++  siginfo@2.0.0: {}
++
++  sonic-boom@4.2.1:
++    dependencies:
++      atomic-sleep: 1.0.0
++
++  source-map-js@1.2.1: {}
++
++  source-map-support@0.5.21:
++    dependencies:
++      buffer-from: 1.1.2
++      source-map: 0.6.1
++
++  source-map@0.6.1: {}
++
++  split2@4.2.0: {}
++
++  stackback@0.0.2: {}
++
++  std-env@3.10.0: {}
++
++  strip-literal@3.1.0:
++    dependencies:
++      js-tokens: 9.0.1
++
++  strnum@2.4.2:
++    dependencies:
++      anynum: 1.0.1
++
++  thread-stream@3.2.0:
++    dependencies:
++      real-require: 0.2.0
++
++  tinybench@2.9.0: {}
++
++  tinyexec@0.3.2: {}
++
++  tinyglobby@0.2.17:
++    dependencies:
++      fdir: 6.5.0(picomatch@4.0.7)
++      picomatch: 4.0.7
++
++  tinypool@1.1.1: {}
++
++  tinyrainbow@2.0.0: {}
++
++  tinyspy@4.0.6: {}
++
++  tsx@4.23.13:
++    dependencies:
++      esbuild: 0.28.2
++    optionalDependencies:
++      fsevents: 2.3.3
++
++  typescript@5.9.3: {}
++
++  undici-types@7.18.2: {}
++
++  vite-node@3.2.4(@types/node@24.13.3)(tsx@4.23.13)(yaml@2.9.0):
++    dependencies:
++      cac: 6.7.14
++      debug: 4.4.3
++      es-module-lexer: 1.7.0
++      pathe: 2.0.3
++      vite: 7.3.6(@types/node@24.13.3)(tsx@4.23.13)(yaml@2.9.0)
++    transitivePeerDependencies:
++      - '@types/node'
++      - jiti
++      - less
++      - lightningcss
++      - sass
++      - sass-embedded
++      - stylus
++      - sugarss
++      - supports-color
++      - terser
++      - tsx
++      - yaml
++
++  vite@7.3.6(@types/node@24.13.3)(tsx@4.23.13)(yaml@2.9.0):
++    dependencies:
++      esbuild: 0.28.2
++      fdir: 6.5.0(picomatch@4.0.7)
++      picomatch: 4.0.7
++      postcss: 8.5.28
++      rollup: 4.63.1
++      tinyglobby: 0.2.17
++    optionalDependencies:
++      '@types/node': 24.13.3
++      fsevents: 2.3.3
++      tsx: 4.23.13
++      yaml: 2.9.0
++
++  vitest@3.2.7(@types/node@24.13.3)(tsx@4.23.13)(yaml@2.9.0):
++    dependencies:
++      '@types/chai': 5.2.3
++      '@vitest/expect': 3.2.7
++      '@vitest/mocker': 3.2.7(vite@7.3.6(@types/node@24.13.3)(tsx@4.23.13)(yaml@2.9.0))
++      '@vitest/pretty-format': 3.2.7
++      '@vitest/runner': 3.2.7
++      '@vitest/snapshot': 3.2.7
++      '@vitest/spy': 3.2.7
++      '@vitest/utils': 3.2.7
++      chai: 5.3.3
++      debug: 4.4.3
++      expect-type: 1.4.0
++      magic-string: 0.30.21
++      pathe: 2.0.3
++      picomatch: 4.0.7
++      std-env: 3.10.0
++      tinybench: 2.9.0
++      tinyexec: 0.3.2
++      tinyglobby: 0.2.17
++      tinypool: 1.1.1
++      tinyrainbow: 2.0.0
++      vite: 7.3.6(@types/node@24.13.3)(tsx@4.23.13)(yaml@2.9.0)
++      vite-node: 3.2.4(@types/node@24.13.3)(tsx@4.23.13)(yaml@2.9.0)
++      why-is-node-running: 2.3.0
++    optionalDependencies:
++      '@types/node': 24.13.3
++    transitivePeerDependencies:
++      - jiti
++      - less
++      - lightningcss
++      - msw
++      - sass
++      - sass-embedded
++      - stylus
++      - sugarss
++      - supports-color
++      - terser
++      - tsx
++      - yaml
++
++  why-is-node-running@2.3.0:
++    dependencies:
++      siginfo: 2.0.0
++      stackback: 0.0.2
++
++  xml-naming@0.3.0: {}
++
++  yaml@2.9.0: {}
++
++  zod@4.5.4: {}

added pnpm-workspace.yaml +4 −0

++packages:
++  - apps/*
++  - packages/*
++  - workers

added scripts/ci.ts +136 −0

++#!/usr/bin/env tsx
++/**
++ * CancerIndex operator CLI.
++ *
++ *   pnpm cix connectors                      list connectors + health
++ *   pnpm cix run <id> [--mode full|incremental|dry_run] [--max-records N] [--max-minutes M] [--reset-cursor]
++ *   pnpm cix run-all [--max-minutes M]       run every active connector in registry order
++ *   pnpm cix health <id>                     source liveness probe
++ *   pnpm cix sources:sync                    manifests → sources table
++ *   pnpm cix counters                        recompute entity counters
++ *   pnpm cix rank [--scope …]                recompute ranking snapshots
++ *   pnpm cix stats                           table counts
++ *   pnpm cix trace <table> <id>              lineage of a value (rankings/epidemiology/frequency)
++ */
++import { existsSync } from 'node:fs';
++import path from 'node:path';
++import { sql } from 'drizzle-orm';
++
++for (const candidate of [path.resolve(process.cwd(), '.env')]) {
++  if (existsSync(candidate)) {
++    try {
++      process.loadEnvFile(candidate);
++    } catch {
++      /* ignore */
++    }
++  }
++}
++
++const [, , cmd, ...rest] = process.argv;
++const flags: Record<string, string | boolean> = {};
++const positional: string[] = [];
++for (let i = 0; i < rest.length; i++) {
++  const a = rest[i]!;
++  if (a.startsWith('--')) {
++    const k = a.slice(2);
++    const next = rest[i + 1];
++    if (next && !next.startsWith('--')) {
++      flags[k] = next;
++      i++;
++    } else flags[k] = true;
++  } else positional.push(a);
++}
++
++async function main() {
++  const { getDb, closeDb } = await import('@cancerindex/database');
++  const db = getDb();
++  try {
++    switch (cmd) {
++      case 'connectors': {
++        const { CONNECTORS } = await import('@cancerindex/connectors');
++        const rows = await db.execute<{ connector_id: string; health: string; last_success_at: string | null; cursor: unknown }>(sql`SELECT connector_id, health, last_success_at, cursor FROM connector_cursors`);
++        const byId = new Map(rows.map((r) => [r.connector_id, r]));
++        for (const c of CONNECTORS) {
++          const h = byId.get(c.manifest.id);
++          console.log(`${c.manifest.id.padEnd(18)} tier${c.manifest.tier} ${c.manifest.status.padEnd(20)} license=${c.manifest.licenseStatus.padEnd(10)} health=${(h?.health ?? 'never-run').padEnd(12)} last_ok=${h?.last_success_at ?? '-'}`);
++        }
++        break;
++      }
++      case 'sources:sync': {
++        const { syncSources, PLANNED_MANIFESTS } = await import('@cancerindex/connectors');
++        const r = await syncSources(db, PLANNED_MANIFESTS);
++        console.log(`[sources] created=${r.created} updated=${r.updated}`);
++        break;
++      }
++      case 'health': {
++        const { getConnector, RunContext } = await import('@cancerindex/connectors');
++        const c = getConnector(positional[0] ?? '');
++        if (!c) throw new Error(`unknown connector ${positional[0]}`);
++        const [src] = await db.execute<{ id: string }>(sql`SELECT id FROM sources WHERE slug = ${c.manifest.id}`);
++        const ctx = new RunContext(db, c.manifest, src?.id ?? 'CI-SOURCE-00000000', 'probe', { maxMinutes: 1 }, 0);
++        console.log(await c.healthCheck(ctx));
++        break;
++      }
++      case 'run': {
++        const { getConnector, runConnector } = await import('@cancerindex/connectors');
++        const c = getConnector(positional[0] ?? '');
++        if (!c) throw new Error(`unknown connector ${positional[0]}`);
++        const r = await runConnector(db, c, {
++          mode: (flags.mode as never) ?? undefined,
++          maxRecords: flags['max-records'] ? Number(flags['max-records']) : undefined,
++          maxMinutes: flags['max-minutes'] ? Number(flags['max-minutes']) : undefined,
++          resetCursor: !!flags['reset-cursor'],
++        });
++        console.log(`[run] ${r.runId} ${r.status}`, r.counters);
++        if (r.status === 'failed') process.exitCode = 1;
++        break;
++      }
++      case 'run-all': {
++        const { CONNECTORS, runConnector } = await import('@cancerindex/connectors');
++        for (const c of CONNECTORS) {
++          if (c.manifest.status !== 'active') {
++            console.log(`[skip] ${c.manifest.id} (${c.manifest.status})`);
++            continue;
++          }
++          const r = await runConnector(db, c, { maxMinutes: flags['max-minutes'] ? Number(flags['max-minutes']) : undefined });
++          console.log(`[run] ${r.runId} ${r.status}`, r.counters);
++        }
++        break;
++      }
++      case 'counters': {
++        const { refreshCounters } = await import('@cancerindex/ranking');
++        const n = await refreshCounters(db);
++        console.log(`[counters] refreshed ${n} entities`);
++        break;
++      }
++      case 'rank': {
++        const { computeAllRankings } = await import('@cancerindex/ranking');
++        const res = await computeAllRankings(db);
++        for (const r of res) console.log(`[rank] ${r.metricSlug} ${r.scopeKey} eligible=${r.eligible}`);
++        break;
++      }
++      case 'stats': {
++        const tables = ['sources', 'ingest_runs', 'source_records', 'provenance', 'cancers', 'cancer_aliases', 'cancer_hierarchy', 'cancer_codes', 'genes', 'variants', 'drugs', 'clinical_trials', 'trial_conditions', 'publications', 'literature_counts', 'civic_evidence_items', 'genomic_cohorts', 'cancer_gene_frequencies', 'epidemiology_observations', 'survival_observations', 'knowledge_edges', 'unresolved_labels', 'rankings', 'ranking_snapshots'];
++        for (const t of tables) {
++          const [r] = await db.execute<{ n: string }>(sql.raw(`SELECT count(*)::text AS n FROM ${t}`));
++          console.log(`${t.padEnd(28)} ${r?.n}`);
++        }
++        break;
++      }
++      case 'trace': {
++        const { traceValue } = await import('@cancerindex/ranking');
++        console.log(JSON.stringify(await traceValue(db, positional[0] ?? '', positional[1] ?? ''), null, 2));
++        break;
++      }
++      default:
++        console.log('usage: pnpm cix <connectors|run|run-all|health|sources:sync|counters|rank|stats|trace>');
++    }
++  } finally {
++    await closeDb();
++  }
++}
++
++main().catch((e) => {
++  console.error(e);
++  process.exit(1);
++});

added tsconfig.base.json +22 −0

++{
++  "compilerOptions": {
++    "target": "ES2023",
++    "lib": ["ES2023"],
++    "module": "NodeNext",
++    "moduleResolution": "NodeNext",
++    "strict": true,
++    "noUncheckedIndexedAccess": true,
++    "noImplicitOverride": true,
++    "noFallthroughCasesInSwitch": true,
++    "exactOptionalPropertyTypes": false,
++    "esModuleInterop": true,
++    "skipLibCheck": true,
++    "resolveJsonModule": true,
++    "declaration": true,
++    "declarationMap": true,
++    "sourceMap": true,
++    "isolatedModules": true,
++    "verbatimModuleSyntax": true,
++    "forceConsistentCasingInFileNames": true
++  }
++}

added vitest.workspace.ts +1 −0

		`@@ -0,0 +1 @@`
1	+export default ['packages/', 'apps/', 'workers'];
2

spb/cancerindex

Foundation: monorepo, schema, provenance SDK, ontology resolver, ranking engine, OncoTree connector

Theme