aw-spec-cli 0.1.4 → 0.1.6

package/assets/docs/domainspecs/UIVisualization/chart-bubble.md

@@ -1,70 +0,0 @@
-# BubbleChart — Chart Rule
-
-> Load **only when "Bubble" (or "all plots") is in the selection** (see [[domain-requirements]]).
-> Component: `BubbleChart` in `components/charts/generic/BubbleChart.tsx`. Built on [[charting-standards.domain]].
-
-## Purpose
-Multi-dimensional scatter — each point encodes **x, y, size, colour, label** (up to 5 dimensions).
-Use for potency vs MW, portfolio risk/return, effort vs impact, market mapping.
-
-## Props contract
-```ts
-interface BubblePoint { x: number; y: number; size: number; label: string; meta?: Record<string, string|number> }
-interface BubbleSeries { seriesLabel: string; color?: string; points: BubblePoint[] }
-
-interface BubbleChartProps {
-  series: BubbleSeries[]        // REQUIRED — one series per colour/category
-  xLabel: string               // REQUIRED
-  yLabel: string               // REQUIRED
-  sizeLabel?: string           // shown as "Bubble size ∝ …" annotation
-  title?: string
-  xAxisType?: 'linear' | 'log'
-  yAxisType?: 'linear' | 'log'
-  sizeRange?: [number, number] // [minPx, maxPx] bubble diameter (default [8,40])
-  xRefLine?: number; xRefLabel?: string   // optional vertical reference line
-  yRefLine?: number; yRefLabel?: string   // optional horizontal reference line
-  height?: number
-  showLabels?: boolean         // annotate points with their label
-}
-```
-
-## Rules
-- Bubble sizes are **normalised across the whole dataset** to `sizeRange` — pass raw magnitudes;
-  the chart scales them. Don't pre-scale to pixels.
-- Group points into **series by the categorical dimension** (target, region, product line) so
-  colour + legend come for free.
-- Use `xAxisType="log"` / `yAxisType="log"` or pre-`log10` the value (e.g. IC₅₀) — pick one,
-  document it in the axis label.
-
-## Adapter example (agent reference)
-```tsx
-'use client'
-import { BubbleChart } from '@/components/charts/generic'
-import type { Compound } from '@/lib/types/pharma'
-
-export function compoundsToBubbleSeries(compounds: Compound[]) {
-  const targets = [...new Set(compounds.map(c => c.target))]
-  return targets.map(t => ({
-    seriesLabel: t,
-    points: compounds.filter(c => c.target === t).map(c => ({
-      x: c.molecularWeight, y: Math.log10(c.ic50_nM),
-      size: c.selectivityRatio, label: c.name,
-      meta: { Status: c.status, 'IC₅₀': `${c.ic50_nM} nM` },
-    })),
-  }))
-}
-
-export default function CompoundScatterPlot({ compounds, height }: { compounds: Compound[]; height?: number }) {
-  return (
-    <BubbleChart series={compoundsToBubbleSeries(compounds)}
-      xLabel="Molecular Weight (Da)" yLabel="log₁₀(IC₅₀, nM)" sizeLabel="Selectivity Ratio"
-      xRefLine={500} xRefLabel="Ro5 MW limit" sizeRange={[7, 28]} height={height} />
-  )
-}
-```
-
-## Scaffolds when selected
-- generic `BubbleChart` + `app/bubble/page.tsx` + nav tab + optional adapter.
-
-## Related
-- [[charting-standards.domain]] · [[component-contracts.domain]] · [[clean-architecture.domain]]

package/assets/docs/domainspecs/UIVisualization/chart-dimred.md

@@ -1,58 +0,0 @@
-# DimRedPlot — Chart Rule
-
-> Load **only when "Dim. Reduction / PCA / t-SNE / UMAP" (or "all plots") is selected** (see [[domain-requirements]]).
-> Component: `DimRedPlot` in `components/charts/generic/DimRedPlot.tsx`. Built on [[charting-standards.domain]].
-
-## Purpose
-2-D scatter of **pre-computed** dimensionality-reduction coordinates, coloured by group, with
-optional cluster-centroid labels and density contours. Use for single-cell clustering, customer
-segments, NLP embeddings, chemical-space maps, anomaly scatter.
-
-## Props contract
-```ts
-interface DimRedPoint {
-  x: number; y: number         // reduced coordinates (caller ran PCA/t-SNE/UMAP)
-  label: string
-  group: string                // category → colour + legend entry
-  meta?: Record<string, string|number>
-}
-interface DimRedPlotProps {
-  points: DimRedPoint[]        // REQUIRED
-  method?: string              // badge: "PCA", "t-SNE", "UMAP" (default "DR")
-  xLabel?: string; yLabel?: string   // e.g. "PC1 (34.2% var)", "UMAP 1"
-  colorByLabel?: string        // legend header / tooltip ("Cell type", "Segment")
-  showClusterLabels?: boolean  // centroid label per group (default true)
-  showDensityContours?: boolean // KDE contour per group (default false)
-  markerSize?: number          // default 5
-  title?: string; height?: number
-}
-```
-
-## Rules
-- The chart **does not run** PCA/t-SNE/UMAP — coordinates are computed upstream (Python,
-  backend, or a JS lib) and passed in. Document the method in `method` + axis labels.
-- `group` drives colour and the legend; keep group count modest (≤ ~12) for distinct colours.
-- Turn on `showDensityContours` for large, overlapping point clouds; off for small datasets.
-
-## Page/adapter example (agent reference)
-```tsx
-'use client'
-import { DimRedPlot } from '@/components/charts/generic'
-
-// cells already have umap1/umap2 + cellType from the pipeline
-export default function CellUmap({ cells }: { cells: { id: string; umap1: number; umap2: number; cellType: string }[] }) {
-  return (
-    <DimRedPlot
-      points={cells.map(c => ({ x: c.umap1, y: c.umap2, label: c.id, group: c.cellType }))}
-      method="UMAP" xLabel="UMAP 1" yLabel="UMAP 2" colorByLabel="Cell type" showClusterLabels
-    />
-  )
-}
-```
-
-## Scaffolds when selected
-- generic `DimRedPlot` + `app/dimred/page.tsx` + nav tab + optional adapter (+ a place to compute
-  or fetch coordinates).
-
-## Related
-- [[charting-standards.domain]] · [[component-contracts.domain]] · [[clean-architecture.domain]]

package/assets/docs/domainspecs/UIVisualization/chart-heatmap.md

@@ -1,62 +0,0 @@
-# Heatmap — Chart Rule
-
-> Load **only when "Heatmap" (or "all plots") is in the selection** (see [[domain-requirements]]).
-> Component: `Heatmap` in `components/charts/generic/Heatmap.tsx`. Built on [[charting-standards.domain]].
-
-## Purpose
-Colour-encoded grid for a 2-D value matrix. Use for correlation matrices, expression grids
-(log₂FC), confusion matrices, risk tables, cross-asset return grids.
-
-## Props contract
-```ts
-type ColourPreset = 'diverging-purple-red' | 'sequential-teal' | 'sequential-heat' | 'diverging-blue-red'
-
-interface HeatmapProps {
-  matrix: number[][]            // matrix[row][col] — REQUIRED
-  rowLabels: string[]           // y-axis — REQUIRED
-  colLabels: string[]           // x-axis — REQUIRED
-  title?: string
-  unit?: string                 // colour-bar title + tooltip unit (e.g. "log₂FC", "r")
-  colorscale?: ColourPreset | [number, string][]   // default 'diverging-purple-red'
-  zMid?: number                 // centre of a diverging scale (use 0 for FC / correlation)
-  zMin?: number; zMax?: number  // override colour range (defaults to matrix min/max)
-  showCellValues?: boolean      // annotate each cell (default true)
-  cellValuePrecision?: number   // decimals in annotations (default 2)
-  cellValueContrastThreshold?: number  // |value| above → white text (default 1.0)
-  height?: number               // omit for responsive fill
-  reverseRows?: boolean
-}
-```
-
-## Rules
-- `matrix.length === rowLabels.length`; every row length `=== colLabels.length`. Validate in the
-  adapter, not the chart.
-- For **diverging** data (fold-change, correlation) set `zMid={0}` so zero maps to the neutral
-  midpoint; for **sequential** data (counts, intensity) use a `sequential-*` preset and omit `zMid`.
-- Keep cell annotations on for ≤ ~12×12 grids; turn `showCellValues` off for dense matrices.
-
-## Adapter example (agent reference)
-```tsx
-'use client'
-import { Heatmap } from '@/components/charts/generic'
-import type { BiomarkerData } from '@/lib/types/pharma'
-
-export default function BiomarkerHeatmap({ data, height }: { data: BiomarkerData; height?: number }) {
-  return (
-    <Heatmap
-      matrix={data.matrix} rowLabels={data.treatments} colLabels={data.markers}
-      unit="log₂FC" colorscale="diverging-purple-red" zMid={0}
-      showCellValues cellValuePrecision={2} cellValueContrastThreshold={1.5}
-      height={height}
-    />
-  )
-}
-```
-
-## Scaffolds when selected
-- `components/charts/generic/Heatmap.tsx` (from the generic library — always present)
-- `app/heatmap/page.tsx` (example route) + nav tab
-- optional adapter `components/charts/<Domain>Heatmap.tsx`
-
-## Related
-- [[charting-standards.domain]] · [[component-contracts.domain]] · [[clean-architecture.domain]]

package/assets/docs/domainspecs/UIVisualization/chart-network.md

@@ -1,69 +0,0 @@
-# NetworkGraph — Chart Rule
-
-> Load **only when "Network / graph / node-edge" (or "all plots") is selected** (see [[domain-requirements]]).
-> Component: `NetworkGraph` in `components/charts/generic/NetworkGraph.tsx`. Built on [[charting-standards.domain]].
-
-## Purpose
-Force-directed **node-edge** graph rendered with Plotly scatter+line traces; layout is computed
-in-component (Fruchterman-Reingold spring or circular) so **no extra graph library** is needed.
-Use for PPI/pathway networks, microservice/dependency maps, knowledge graphs, org/social graphs.
-
-## Props contract
-```ts
-interface NetworkNode {
-  id: string                   // referenced by edges
-  label: string
-  group?: string               // colour + legend
-  size?: number                // marker size (importance, default 10)
-  meta?: Record<string, string|number>
-}
-interface NetworkEdge {
-  source: string; target: string   // node ids
-  weight?: number              // line thickness (default 1)
-  label?: string               // hover label
-}
-interface NetworkGraphProps {
-  nodes: NetworkNode[]; edges: NetworkEdge[]   // REQUIRED
-  layout?: 'spring' | 'circular'   // default 'spring'
-  springIterations?: number    // default 120 (higher = better layout, slower)
-  showEdgeLabels?: boolean      // default true
-  directed?: boolean            // arrowheads (default false)
-  title?: string; height?: number
-}
-```
-
-## Rules
-- Every edge `source`/`target` MUST reference an existing node `id`. Validate in the adapter;
-  dangling edges are dropped silently.
-- Layout is **deterministic per dataset** (warm-started from a circle) but recomputes when the
-  node/edge set changes — memoise `nodes`/`edges` so it doesn't recompute each render.
-- Keep graphs modest (≲ ~150 nodes) for readable spring layout; above that, pre-cluster or paginate.
-- Set `directed` for DAGs / signalling cascades; leave off for undirected association graphs.
-
-## Page/adapter example (agent reference)
-```tsx
-'use client'
-import { NetworkGraph } from '@/components/charts/generic'
-import type { NetworkNode, NetworkEdge } from '@/components/charts/generic'
-
-const NODES: NetworkNode[] = [
-  { id: 'EGFR', label: 'EGFR', group: 'Receptor', size: 26 },
-  { id: 'RAS',  label: 'RAS',  group: 'GTPase',   size: 22 },
-  { id: 'RAF',  label: 'BRAF', group: 'Kinase',   size: 20 },
-]
-const EDGES: NetworkEdge[] = [
-  { source: 'EGFR', target: 'RAS', weight: 2.5, label: 'activates' },
-  { source: 'RAS',  target: 'RAF', weight: 2,   label: 'activates' },
-]
-
-export default function PathwayNetwork() {
-  return <NetworkGraph nodes={NODES} edges={EDGES} layout="spring" springIterations={150} directed showEdgeLabels />
-}
-```
-
-## Scaffolds when selected
-- generic `NetworkGraph` + `app/network/page.tsx` + nav tab + optional adapter; type the node/edge
-  arrays with `NetworkNode[]` / `NetworkEdge[]` to avoid `meta` literal-type errors.
-
-## Related
-- [[charting-standards.domain]] · [[component-contracts.domain]] · [[clean-architecture.domain]]

package/assets/docs/domainspecs/UIVisualization/chart-parallel.md

@@ -1,75 +0,0 @@
-# ParallelCoordinatesPlot — Chart Rule
-
-> Load **only when "Parallel Coords / parcoords" (or "all plots") is selected** (see [[domain-requirements]]).
-> Component: `ParallelCoordinatesPlot` in `components/charts/generic/ParallelCoordinatesPlot.tsx`.
-> Built on [[charting-standards.domain]]; uses Plotly's native `parcoords` (interactive axis brushing).
-
-## Purpose
-Multi-dimensional data as **polylines crossing parallel vertical axes** — one line per observation.
-Use for multi-parameter optimisation (MPO), ADMET profiles, hyperparameter sweeps, KPI dashboards,
-portfolio metrics.
-
-## Props contract
-```ts
-interface PCDimension {
-  key: string                  // matches a key in each trace's `values`
-  label: string
-  range?: [number, number]     // axis range (auto if omitted)
-  tickFormat?: string          // d3 format, e.g. ".2f", ".0f"
-  invertAxis?: boolean         // for "lower is better" metrics (IC₅₀, p-value)
-}
-interface PCTrace {
-  id: string; label: string
-  colorValue: number           // drives the line colour (continuous)
-  values: Record<string, number>   // one value per dimension key
-  group?: string
-}
-type PCColorscale = 'teal-purple' | 'blue-red' | 'viridis' | 'plasma' | [number, string][]
-
-interface ParallelCoordinatesPlotProps {
-  dimensions: PCDimension[]    // REQUIRED — the axes
-  traces: PCTrace[]            // REQUIRED — one per observation
-  colorLabel?: string          // colour-bar title
-  colorscale?: PCColorscale    // default 'teal-purple'
-  lineOpacity?: number; lineWidth?: number
-  title?: string; height?: number
-}
-```
-
-## Rules
-- `dimensions[].key` must exist in **every** trace's `values`. Validate in the adapter.
-- Use `invertAxis` for metrics where **lower is better** so "good" lines trend the same way.
-- `colorValue` is a single continuous dimension (often the headline metric, e.g. IC₅₀ or score);
-  it maps onto `colorscale`. Brushing on any axis filters interactively — no extra wiring.
-
-## Page/adapter example (agent reference)
-```tsx
-'use client'
-import { ParallelCoordinatesPlot } from '@/components/charts/generic'
-import type { Compound } from '@/lib/types/pharma'
-
-const DIMS = [
-  { key: 'mw',   label: 'MW (Da)',   range: [300, 560] as [number, number], tickFormat: '.0f' },
-  { key: 'logP', label: 'LogP',      range: [1.5, 5.5] as [number, number], tickFormat: '.1f' },
-  { key: 'ic50', label: 'IC₅₀ (nM)', range: [0, 800]   as [number, number], tickFormat: '.0f', invertAxis: true },
-]
-
-export default function MpoParallel({ compounds }: { compounds: Compound[] }) {
-  return (
-    <ParallelCoordinatesPlot
-      dimensions={DIMS}
-      traces={compounds.filter(c => c.ic50_nM <= 800).map(c => ({
-        id: c.id, label: c.name, group: c.status, colorValue: c.ic50_nM,
-        values: { mw: c.molecularWeight, logP: c.logP, ic50: c.ic50_nM },
-      }))}
-      colorLabel="IC₅₀ (nM)" colorscale="teal-purple"
-    />
-  )
-}
-```
-
-## Scaffolds when selected
-- generic `ParallelCoordinatesPlot` + `app/parallel/page.tsx` + nav tab + optional adapter.
-
-## Related
-- [[charting-standards.domain]] · [[component-contracts.domain]] · [[clean-architecture.domain]]

package/assets/docs/domainspecs/UIVisualization/chart-scurve.md

@@ -1,66 +0,0 @@
-# SCurveChart — Chart Rule
-
-> Load **only when "S-Curve / dose-response / sigmoid" (or "all plots") is selected** (see [[domain-requirements]]).
-> Component: `SCurveChart` in `components/charts/generic/SCurveChart.tsx`. Built on [[charting-standards.domain]].
-
-## Purpose
-One or more **sigmoidal (S-shaped)** curves with optional inflection markers. Use for
-dose-response (4-PL / Hill), technology adoption, market penetration, enzyme kinetics, SaaS ramp.
-
-## Props contract
-```ts
-interface SCurvePoint { x: number; y: number }
-interface SCurve {
-  id: string; label: string; color?: string
-  points: SCurvePoint[]        // PRE-COMPUTED by the caller (model runs outside the chart)
-  inflectionX?: number         // e.g. IC₅₀ / midpoint — draws a marker + dashed line
-  inflectionLabel?: string     // "IC₅₀", "EC₅₀", "Midpoint", "Tipping point"
-  metadata?: Record<string, string>  // tooltip enrichment
-}
-interface SCurveChartProps {
-  curves: SCurve[]             // REQUIRED
-  xLabel: string; yLabel: string   // REQUIRED
-  xAxisType?: 'linear' | 'log'
-  referenceY?: number          // horizontal reference (default 50)
-  referenceYLabel?: string
-  yRange?: [number, number]    // default [-5, 108]
-  title?: string; height?: number
-}
-```
-
-## Rules
-- The chart **plots points, it does not fit models** — the caller generates curve points (4-PL,
-  logistic, etc.) and passes them. Provide generators in `lib/utils.ts`
-  (`generate4PLCurve`, `generateLogisticPoints`).
-- `inflectionX` is in the **same x-units** as the points (e.g. `log10(ic50_nM)` if x is log-conc).
-- Use `referenceY={50}` for "50% response/adoption"; set to `undefined` to hide.
-
-## Adapter example (agent reference)
-```tsx
-'use client'
-import { SCurveChart } from '@/components/charts/generic'
-import { PHARMA_COLORS } from '@/components/charts/PlotlyChart'
-import type { DoseResponseCurve } from '@/lib/types/pharma'
-
-export default function DoseResponseChart({ curves, height }: { curves: DoseResponseCurve[]; height?: number }) {
-  return (
-    <SCurveChart
-      curves={curves.map((c, i) => ({
-        id: c.compoundId, label: c.compoundName, color: PHARMA_COLORS[i % PHARMA_COLORS.length],
-        points: c.points.map(p => ({ x: p.logConc, y: p.response })),
-        inflectionX: Math.log10(c.ic50_nM), inflectionLabel: 'IC₅₀',
-        metadata: { Target: c.target, 'Hill slope': c.hillSlope.toFixed(2) },
-      }))}
-      xLabel="log₁₀[Concentration (nM)]" yLabel="% Inhibition"
-      referenceY={50} referenceYLabel="50% Inhibition" height={height}
-    />
-  )
-}
-```
-
-## Scaffolds when selected
-- generic `SCurveChart` + curve generators in `lib/utils.ts` + `app/scurve/` (or `dose-response/`)
-  route + nav tab + optional adapter.
-
-## Related
-- [[charting-standards.domain]] · [[component-contracts.domain]] · [[clean-architecture.domain]]

package/assets/docs/domainspecs/UIVisualization/chart-survival.md

@@ -1,69 +0,0 @@
-# SurvivalCurveChart — Chart Rule
-
-> Load **only when "Survival / Kaplan-Meier / retention" (or "all plots") is selected** (see [[domain-requirements]]).
-> Component: `SurvivalCurveChart` in `components/charts/generic/SurvivalCurveChart.tsx`. Built on [[charting-standards.domain]].
-
-## Purpose
-Kaplan-Meier–style **step-function** curves with optional CI shading, median markers, and a
-significance annotation. Use for clinical OS/PFS, user-cohort retention, component MTTF, churn.
-
-## Props contract
-```ts
-interface SurvivalPoint {
-  time: number
-  survival: number             // 0–1 (×100 applied) or 0–100
-  ciLower?: number; ciUpper?: number   // same scale as survival
-  nAtRisk?: number
-}
-interface SurvivalArm {
-  label: string; color: string        // colour REQUIRED — distinguishes arms
-  points: SurvivalPoint[]
-  medianTime?: number | null          // null = not reached
-}
-interface SurvivalCurveChartProps {
-  arms: SurvivalArm[]          // REQUIRED
-  timeLabel?: string           // default "Time"
-  survivalLabel?: string       // default "Survival Probability (%)"
-  eventLabel?: string          // "Death", "Churn", "Failure" …
-  medianLabel?: string         // "mOS", "mPFS", "Median retention"
-  curveType?: string           // corner badge: "OS", "KM", "Retention"
-  pValue?: string              // "< 0.001", "n.s."
-  showCI?: boolean             // default true (needs ciLower/ciUpper)
-  xMax?: number; height?: number
-}
-```
-
-## Rules
-- Curve is a **step function** (`shape: 'hv'`) — survival is constant between events. Pass points
-  at event/censor times; the chart draws the steps.
-- `survival` accepts either 0–1 or 0–100 — the chart normalises; be consistent within an arm.
-- CI shading requires `ciLower`/`ciUpper` on the points and `showCI` (default on).
-- `medianTime: null` renders "Not reached" — use it, don't fake a value.
-
-## Adapter example (agent reference)
-```tsx
-'use client'
-import { SurvivalCurveChart } from '@/components/charts/generic'
-import type { TrialArm } from '@/lib/types/pharma'
-
-export default function KaplanMeierChart({ arms, height }: { arms: TrialArm[]; height?: number }) {
-  return (
-    <SurvivalCurveChart
-      arms={arms.map(a => ({
-        label: a.name, color: a.color, medianTime: a.medianSurvival,
-        points: a.points.map(p => ({ time: p.time, survival: p.survival,
-          ciLower: p.ciLower, ciUpper: p.ciUpper, nAtRisk: p.nAtRisk })),
-      }))}
-      timeLabel="Days" survivalLabel="Survival Probability (%)" medianLabel="mOS"
-      curveType="OS" pValue="< 0.001" showCI height={height}
-    />
-  )
-}
-```
-
-## Scaffolds when selected
-- generic `SurvivalCurveChart` + `app/survival/` (or `trials/`) route + nav tab + optional adapter;
-  an optional number-at-risk table consumes `nAtRisk`.
-
-## Related
-- [[charting-standards.domain]] · [[component-contracts.domain]] · [[clean-architecture.domain]]

package/assets/docs/domainspecs/UIVisualization/chart-trellis.md

@@ -1,68 +0,0 @@
-# TrellisGrid — Chart Rule
-
-> Load **only when "Trellis / facet / small-multiples" (or "all plots") is selected** (see [[domain-requirements]]).
-> Component: `TrellisGrid` in `components/charts/generic/TrellisGrid.tsx`. Built on [[charting-standards.domain]];
-> uses Plotly subplot `grid`.
-
-## Purpose
-An **N×M grid of the same chart type** — one panel per data subset (small multiples / facets).
-Use for KPI by region, IC₅₀ by target class, sensor readings by machine, feature distributions
-per class.
-
-## Props contract
-```ts
-interface TrellisTrace {
-  type: 'bar' | 'scatter' | 'line' | 'box'
-  x: (string|number)[]; y: number[]
-  label: string; color?: string
-  mode?: 'markers' | 'lines' | 'lines+markers'   // scatter/line only
-}
-interface TrellisPanel { title: string; traces: TrellisTrace[] }
-
-interface TrellisGridProps {
-  panels: TrellisPanel[]       // REQUIRED — one per subset
-  cols?: number                // grid columns (default 3); rows auto
-  xLabel?: string; yLabel?: string   // shared axis labels
-  sharedXAxis?: boolean        // align x-range across panels
-  sharedYAxis?: boolean        // align y-range — ESSENTIAL for fair comparison
-  panelHeight?: number         // px per panel (total = rows × panelHeight)
-  title?: string
-}
-```
-
-## Rules
-- All panels render the **same trace type** — that is the point of small multiples. Don't mix bar
-  and line across panels.
-- Turn on **`sharedYAxis`** whenever comparing magnitudes across panels — otherwise each panel
-  auto-scales and the comparison misleads.
-- `panels` is built by grouping the dataset on the facet dimension (target, region, class) in the
-  adapter/page.
-- `TrellisGrid` sizes by `rows × panelHeight` (it does not fill-parent); pick `panelHeight` for the
-  card and let the page scroll if needed.
-
-## Page/adapter example (agent reference)
-```tsx
-'use client'
-import { TrellisGrid } from '@/components/charts/generic'
-import { PHARMA_COLORS } from '@/components/charts/PlotlyChart'
-import type { Compound } from '@/lib/types/pharma'
-
-export default function Ic50ByTarget({ compounds }: { compounds: Compound[] }) {
-  const targets = [...new Set(compounds.map(c => c.target))]
-  const panels = targets.map((t, i) => {
-    const g = compounds.filter(c => c.target === t).sort((a, b) => a.ic50_nM - b.ic50_nM)
-    return {
-      title: t,
-      traces: [{ type: 'bar' as const, label: t, color: PHARMA_COLORS[i % PHARMA_COLORS.length],
-        x: g.map(c => c.name), y: g.map(c => Math.min(c.ic50_nM, 800)) }],
-    }
-  })
-  return <TrellisGrid panels={panels} cols={4} xLabel="Compound" yLabel="IC₅₀ (nM)" sharedYAxis panelHeight={210} />
-}
-```
-
-## Scaffolds when selected
-- generic `TrellisGrid` + `app/trellis/page.tsx` + nav tab + optional adapter.
-
-## Related
-- [[charting-standards.domain]] · [[component-contracts.domain]] · [[clean-architecture.domain]]

package/assets/docs/domainspecs/UIVisualization/chart-violin.md

@@ -1,61 +0,0 @@
-# ViolinPlot — Chart Rule
-
-> Load **only when "Violin / distribution" (or "all plots") is selected** (see [[domain-requirements]]).
-> Component: `ViolinPlot` in `components/charts/generic/ViolinPlot.tsx`.
-> Built on [[charting-standards.domain]]; uses Plotly's native `violin` (KDE + box computed for you).
-
-## Purpose
-Distribution **shape (KDE)** of a numeric variable across groups, with optional box plot and
-jittered points. Use for biomarker expression by cohort, API latency by endpoint, salary by band,
-any group-wise distribution comparison.
-
-## Props contract
-```ts
-interface ViolinGroup {
-  label: string                // x-axis category
-  values: number[]             // RAW observations — Plotly computes KDE/IQR/whiskers
-  color?: string
-}
-type PointDisplayMode = 'none' | 'outliers' | 'all' | 'suspected'
-
-interface ViolinPlotProps {
-  groups: ViolinGroup[]        // REQUIRED
-  yLabel?: string; xLabel?: string
-  showBox?: boolean            // overlay median/IQR box (default true)
-  showMean?: boolean           // mean line (default false)
-  showPoints?: PointDisplayMode // default 'outliers'
-  side?: 'both' | 'positive' | 'negative'  // split violin for back-to-back compare
-  bandwidth?: 'normal reference' | 'scott' | 'silverman'
-  fillOpacity?: number
-  title?: string; height?: number
-}
-```
-
-## Rules
-- Pass **raw values** — never pre-binned or pre-summarised; the chart computes KDE, quartiles and
-  whiskers. Each group needs enough points (≥ ~10) for a meaningful KDE.
-- Use `showPoints="outliers"` for clinical/quality data; `"all"` only for small n.
-- `side="positive"`/`"negative"` enables split (back-to-back) violins for two-condition compares.
-
-## Page/adapter example (agent reference)
-```tsx
-'use client'
-import { ViolinPlot } from '@/components/charts/generic'
-
-// readings: { group: string; value: number }[]
-export default function ExpressionViolin({ readings }: { readings: { group: string; value: number }[] }) {
-  const groups = [...new Set(readings.map(r => r.group))].map(g => ({
-    label: g, values: readings.filter(r => r.group === g).map(r => r.value),
-  }))
-  return (
-    <ViolinPlot groups={groups} yLabel="Expression (log₂FC)" xLabel="Treatment"
-      showBox showMean showPoints="outliers" />
-  )
-}
-```
-
-## Scaffolds when selected
-- generic `ViolinPlot` + `app/violin/page.tsx` + nav tab + optional adapter.
-
-## Related
-- [[charting-standards.domain]] · [[component-contracts.domain]] · [[clean-architecture.domain]]

package/assets/docs/domainspecs/UIVisualization/chart-volcano.md

@@ -1,63 +0,0 @@
-# VolcanoPlot — Chart Rule
-
-> Load **only when "Volcano" (or "all plots") is selected** (see [[domain-requirements]]).
-> Component: `VolcanoPlot` in `components/charts/generic/VolcanoPlot.tsx`. Built on [[charting-standards.domain]].
-
-## Purpose
-**Magnitude vs. significance** scatter, partitioned into up / down / not-significant by two
-thresholds. Use for differential expression (RNA-seq/proteomics), A/B-test lift vs significance,
-GWAS hits, ML feature importance, adverse-event signals.
-
-## Props contract
-```ts
-interface VolcanoPoint {
-  x: number                    // magnitude (e.g. log₂FC, effect size)
-  y: number                    // significance (e.g. -log₁₀ p-value)
-  label: string
-  meta?: Record<string, string|number>
-}
-interface VolcanoPlotProps {
-  points: VolcanoPoint[]       // REQUIRED
-  xLabel?: string              // default "log₂(Fold Change)"
-  yLabel?: string              // default "-log₁₀(p-value)"
-  foldChangeThreshold?: number // |x| above → "changed" (default 1.0)
-  significanceThreshold?: number // y above → significant (default 1.301 ≈ p<0.05)
-  upColor?: string; downColor?: string; nsColor?: string
-  upLabel?: string; downLabel?: string; nsLabel?: string
-  labelTopN?: number           // annotate top-N by |x·y| (default 10; 0 disables)
-  title?: string; height?: number
-}
-```
-
-## Rules
-- The caller supplies **already-computed** statistics: `x` = effect/log₂FC, `y` = `-log10(p)`.
-  The chart does not run the test.
-- `significanceThreshold` is in **`-log10(p)`** units (1.301 = p 0.05; 2 = p 0.01). State the test
-  basis in `yLabel`.
-- The chart partitions points by the two thresholds and labels the top-N hits — keep `labelTopN`
-  small (≤ 15) to avoid clutter.
-
-## Page/adapter example (agent reference)
-```tsx
-'use client'
-import { VolcanoPlot } from '@/components/charts/generic'
-
-// genes: { name, log2FC, pValue }[]
-export default function DiffExpressionVolcano({ genes }: { genes: { name: string; log2FC: number; pValue: number }[] }) {
-  return (
-    <VolcanoPlot
-      points={genes.map(g => ({ x: g.log2FC, y: -Math.log10(g.pValue), label: g.name,
-        meta: { 'p-value': g.pValue.toExponential(2) } }))}
-      xLabel="log₂(Fold Change)" yLabel="-log₁₀(p-value)"
-      foldChangeThreshold={1} significanceThreshold={1.301}
-      upLabel="Up-regulated" downLabel="Down-regulated" labelTopN={10}
-    />
-  )
-}
-```
-
-## Scaffolds when selected
-- generic `VolcanoPlot` + `app/volcano/page.tsx` + nav tab + optional adapter.
-
-## Related
-- [[charting-standards.domain]] · [[component-contracts.domain]] · [[clean-architecture.domain]]