@morscherlab/mint-sdk 1.0.0-beta.1 → 1.0.0-beta.3

package/src/templates/adapters.ts

@@ -0,0 +1,785 @@
+import type {
+  DataFrameColumn,
+  PlateCondition,
+  PlateMapEditorState,
+  SelectOption,
+  Well,
+} from '../types'
+import {
+  getTemplateData,
+  validateAssayMatrixData,
+  validateCalibrationCurveData,
+  validateDoseResponseData,
+  validateFlowCytometryPanelData,
+  validateInstrumentRunData,
+  validatePlateMapData,
+  validateProtocolStepsData,
+  validateQpcrPlateData,
+  validateReagentListData,
+  validateSamplePrepData,
+  validateSampleSheetData,
+  validateTimeCourseData,
+} from './builders'
+import type {
+  AssayMatrixColumnsAdapterResult,
+  AssayMatrixDataFrameAdapterResult,
+  AssayMatrixRowsAdapterResult,
+  AssayMatrixTemplate,
+  AssayMatrixTemplateData,
+  BioTemplateEnvelope,
+  CalibrationCurveColumnsAdapterResult,
+  CalibrationCurveDataFrameAdapterResult,
+  CalibrationCurveRowsAdapterResult,
+  CalibrationCurveTemplate,
+  CalibrationCurveTemplateData,
+  DataFrameTemplate,
+  DoseConditionsAdapterResult,
+  DoseResponseTemplate,
+  DoseResponseTemplateData,
+  FlowCytometryPanelTemplate,
+  FlowCytometryPanelTemplateData,
+  FlowPanelColumnsAdapterResult,
+  FlowPanelDataFrameAdapterResult,
+  FlowPanelRowsAdapterResult,
+  InstrumentRunColumnsAdapterResult,
+  InstrumentRunDataFrameAdapterResult,
+  InstrumentRunRowsAdapterResult,
+  InstrumentRunTemplate,
+  InstrumentRunTemplateData,
+  PlateMapEditorAdapterResult,
+  PlateMapTemplate,
+  PlateMapTemplateData,
+  ProtocolColumnsAdapterResult,
+  ProtocolDataFrameAdapterResult,
+  ProtocolRowsAdapterResult,
+  ProtocolStepsAdapterResult,
+  ProtocolStepsTemplate,
+  ProtocolStepsTemplateData,
+  QpcrColumnsAdapterResult,
+  QpcrDataFrameAdapterResult,
+  QpcrPlateTemplate,
+  QpcrPlateTemplateData,
+  QpcrRowsAdapterResult,
+  QpcrWellMapAdapterResult,
+  ReagentColumnsAdapterResult,
+  ReagentDataFrameAdapterResult,
+  ReagentListItemsAdapterResult,
+  ReagentListTemplate,
+  ReagentListTemplateData,
+  ReagentRowsAdapterResult,
+  SampleColumnsAdapterResult,
+  SampleDataFrameAdapterResult,
+  SampleOptionsAdapterResult,
+  SamplePrepColumnsAdapterResult,
+  SamplePrepDataFrameAdapterResult,
+  SamplePrepRowsAdapterResult,
+  SamplePrepTemplate,
+  SamplePrepTemplateData,
+  SampleRowsAdapterResult,
+  SampleSheetTemplate,
+  SampleSheetTemplateData,
+  TimeCourseColumnsAdapterResult,
+  TimeCourseDataFrameAdapterResult,
+  TimeCourseRowsAdapterResult,
+  TimeCourseStepsAdapterResult,
+  TimeCourseTemplate,
+  TimeCourseTemplateData,
+  TemplateDataFrameAdapterResult,
+  WellMapAdapterResult,
+} from './types'
+
+const CONDITION_COLORS = [
+  '#3B82F6',
+  '#10B981',
+  '#EF4444',
+  '#F59E0B',
+  '#8B5CF6',
+  '#F97316',
+  '#06B6D4',
+  '#14B8A6',
+  '#6B7280',
+]
+
+export function toPlateMapEditorState(
+  template: PlateMapTemplate | PlateMapTemplateData
+): PlateMapEditorAdapterResult {
+  const data = getTemplateData(template, 'plate-map')
+  validatePlateMapData(data)
+  const activePlateId = data.activePlateId ?? data.plates[0].id
+  return {
+    plates: data.plates,
+    activePlateId,
+    samples: data.samples,
+    selectedWells: data.selectedWells ?? [],
+    activeSampleId: data.activeSampleId,
+  } satisfies PlateMapEditorState
+}
+
+export function toWellPlateWells(
+  template: PlateMapTemplate | PlateMapTemplateData,
+  plateId?: string
+): WellMapAdapterResult {
+  const state = toPlateMapEditorState(template)
+  const plate = state.plates.find(candidate => candidate.id === (plateId ?? state.activePlateId))
+    ?? state.plates[0]
+  return plate.wells
+}
+
+export function toSampleRows(
+  template: SampleSheetTemplate | SampleSheetTemplateData
+): SampleRowsAdapterResult {
+  const data = getTemplateData(template, 'sample-sheet')
+  validateSampleSheetData(data)
+  return data.samples.map(sample => ({
+    sampleId: sample.sampleId,
+    name: sample.name,
+    group: sample.group,
+    batch: sample.batch,
+    replicate: sample.replicate,
+    plateId: sample.plateId,
+    wellId: sample.wellId,
+    ...(sample.metadata ?? {}),
+  }))
+}
+
+export function toSampleColumns(
+  template: SampleSheetTemplate | SampleSheetTemplateData
+): SampleColumnsAdapterResult {
+  const data = getTemplateData(template, 'sample-sheet')
+  validateSampleSheetData(data)
+  return data.columns.map((column): DataFrameColumn<Record<string, unknown>> => ({
+    key: sampleColumnKey(column.id),
+    label: column.label,
+    sortable: true,
+    align: column.type === 'number' || column.type === 'integer' ? 'right' : 'left',
+  }))
+}
+
+export function toSampleDataFrame(
+  template: SampleSheetTemplate | SampleSheetTemplateData
+): SampleDataFrameAdapterResult {
+  return {
+    data: toSampleRows(template),
+    columns: toSampleColumns(template),
+    rowKey: 'sampleId',
+  }
+}
+
+export function toSampleOptions(
+  template: SampleSheetTemplate | SampleSheetTemplateData
+): SampleOptionsAdapterResult {
+  const data = getTemplateData(template, 'sample-sheet')
+  validateSampleSheetData(data)
+  return data.samples.map((sample): SelectOption<string> => ({
+    value: sample.sampleId,
+    label: sample.name ?? sample.sampleId,
+    description: [sample.group, sample.batch].filter(Boolean).join(' / ') || undefined,
+  }))
+}
+
+export function toSamplePrepRows(
+  template: SamplePrepTemplate | SamplePrepTemplateData
+): SamplePrepRowsAdapterResult {
+  const data = getTemplateData(template, 'sample-prep')
+  validateSamplePrepData(data)
+  return [...data.steps]
+    .sort((a, b) => a.order - b.order)
+    .map(step => ({
+      id: step.id,
+      order: step.order,
+      type: step.type,
+      name: step.name,
+      sourceSampleId: step.sourceSampleId,
+      sourceWellId: step.sourceWellId,
+      destinationSampleId: step.destinationSampleId,
+      destinationWellId: step.destinationWellId,
+      reagentId: step.reagentId,
+      inputVolume: step.inputVolume,
+      outputVolume: step.outputVolume,
+      volumeUnit: step.volumeUnit,
+      durationMin: step.durationMin,
+      status: step.status,
+      protocolName: data.protocolName,
+      ...(step.metadata ?? {}),
+    }))
+}
+
+export function toSamplePrepColumns(): SamplePrepColumnsAdapterResult {
+  return [
+    { key: 'order', label: 'Order', sortable: true, align: 'right' },
+    { key: 'type', label: 'Type', sortable: true },
+    { key: 'name', label: 'Step', sortable: true },
+    { key: 'sourceSampleId', label: 'Source', sortable: true },
+    { key: 'sourceWellId', label: 'Source well', sortable: true },
+    { key: 'destinationSampleId', label: 'Destination', sortable: true },
+    { key: 'destinationWellId', label: 'Destination well', sortable: true },
+    { key: 'reagentId', label: 'Reagent', sortable: true },
+    { key: 'inputVolume', label: 'Input', sortable: true, align: 'right' },
+    { key: 'outputVolume', label: 'Output', sortable: true, align: 'right' },
+    { key: 'volumeUnit', label: 'Unit', sortable: true },
+    { key: 'status', label: 'Status', sortable: true },
+  ]
+}
+
+export function toSamplePrepDataFrame(
+  template: SamplePrepTemplate | SamplePrepTemplateData
+): SamplePrepDataFrameAdapterResult {
+  return {
+    data: toSamplePrepRows(template),
+    columns: toSamplePrepColumns(),
+    rowKey: 'id',
+  }
+}
+
+export function toDoseConditions(
+  template: DoseResponseTemplate | DoseResponseTemplateData
+): DoseConditionsAdapterResult {
+  const data = getTemplateData(template, 'dose-response')
+  validateDoseResponseData(data)
+  return data.compounds.map((compound, index): PlateCondition => ({
+    label: compound.name,
+    color: String(compound.metadata?.color ?? CONDITION_COLORS[index % CONDITION_COLORS.length]),
+    concentrations: compound.concentrations,
+    unit: data.unit,
+  }))
+}
+
+export function toDoseLayoutState(
+  template: DoseResponseTemplate | DoseResponseTemplateData
+): PlateMapEditorState | undefined {
+  const data = getTemplateData(template, 'dose-response')
+  validateDoseResponseData(data)
+  return data.layout ? toPlateMapEditorState(data.layout) : undefined
+}
+
+export function toCalibrationCurveRows(
+  template: CalibrationCurveTemplate | CalibrationCurveTemplateData
+): CalibrationCurveRowsAdapterResult {
+  const data = getTemplateData(template, 'calibration-curve')
+  validateCalibrationCurveData(data)
+  return [...data.points]
+    .sort((a, b) => a.order - b.order)
+    .map(point => ({
+      id: point.id,
+      order: point.order,
+      role: point.role,
+      level: point.level,
+      concentration: point.concentration,
+      unit: point.unit,
+      expectedResponse: point.expectedResponse,
+      response: point.response,
+      replicate: point.replicate,
+      include: point.include,
+      status: point.status,
+      analyte: data.analyte,
+      model: data.model,
+      ...(point.metadata ?? {}),
+    }))
+}
+
+export function toCalibrationCurveColumns(): CalibrationCurveColumnsAdapterResult {
+  return [
+    { key: 'order', label: 'Order', sortable: true, align: 'right' },
+    { key: 'role', label: 'Role', sortable: true },
+    { key: 'level', label: 'Level', sortable: true },
+    { key: 'concentration', label: 'Concentration', sortable: true, align: 'right' },
+    { key: 'unit', label: 'Unit', sortable: true },
+    { key: 'expectedResponse', label: 'Expected', sortable: true, align: 'right' },
+    { key: 'response', label: 'Response', sortable: true, align: 'right' },
+    { key: 'replicate', label: 'Replicate', sortable: true, align: 'right' },
+    { key: 'include', label: 'Include', sortable: true },
+    { key: 'status', label: 'Status', sortable: true },
+  ]
+}
+
+export function toCalibrationCurveDataFrame(
+  template: CalibrationCurveTemplate | CalibrationCurveTemplateData
+): CalibrationCurveDataFrameAdapterResult {
+  return {
+    data: toCalibrationCurveRows(template),
+    columns: toCalibrationCurveColumns(),
+    rowKey: 'id',
+  }
+}
+
+export function toTimeCourseRows(
+  template: TimeCourseTemplate | TimeCourseTemplateData
+): TimeCourseRowsAdapterResult {
+  const data = getTemplateData(template, 'time-course')
+  validateTimeCourseData(data)
+  const timepoints = new Map(data.timepoints.map(timepoint => [timepoint.id, timepoint]))
+  const conditions = new Map(data.conditions.map(condition => [condition.id, condition]))
+
+  return data.samples.map(sample => {
+    const timepoint = timepoints.get(sample.timepointId)
+    const condition = conditions.get(sample.conditionId)
+    return {
+      sampleId: sample.sampleId,
+      condition: condition?.name ?? sample.conditionId,
+      timepoint: timepoint?.label ?? sample.timepointId,
+      value: timepoint?.value,
+      unit: timepoint?.unit,
+      replicate: sample.replicate,
+      ...(sample.metadata ?? {}),
+    }
+  })
+}
+
+export function toTimeCourseColumns(): TimeCourseColumnsAdapterResult {
+  return [
+    { key: 'sampleId', label: 'Sample ID', sortable: true },
+    { key: 'condition', label: 'Condition', sortable: true },
+    { key: 'timepoint', label: 'Time Point', sortable: true },
+    { key: 'value', label: 'Value', sortable: true, align: 'right' },
+    { key: 'unit', label: 'Unit', sortable: true },
+    { key: 'replicate', label: 'Replicate', sortable: true, align: 'right' },
+  ]
+}
+
+export function toTimeCourseDataFrame(
+  template: TimeCourseTemplate | TimeCourseTemplateData
+): TimeCourseDataFrameAdapterResult {
+  return {
+    data: toTimeCourseRows(template),
+    columns: toTimeCourseColumns(),
+    rowKey: 'sampleId',
+  }
+}
+
+export function toTimeCourseSteps(
+  template: TimeCourseTemplate | TimeCourseTemplateData
+): TimeCourseStepsAdapterResult {
+  const data = getTemplateData(template, 'time-course')
+  validateTimeCourseData(data)
+  return data.timepoints.map((timepoint, index) => ({
+    id: timepoint.id,
+    type: 'measurement',
+    name: timepoint.label,
+    description: `${data.conditions.length} condition${data.conditions.length === 1 ? '' : 's'}`,
+    status: 'pending',
+    order: index,
+    parameters: {
+      value: timepoint.value,
+      unit: timepoint.unit,
+    },
+  }))
+}
+
+export function toProtocolSteps(
+  template: ProtocolStepsTemplate | ProtocolStepsTemplateData
+): ProtocolStepsAdapterResult {
+  const data = getTemplateData(template, 'protocol-steps')
+  validateProtocolStepsData(data)
+  return [...data.steps]
+    .sort((a, b) => a.order - b.order)
+    .map(step => ({
+      id: step.id,
+      type: step.type,
+      name: step.name,
+      description: step.description,
+      duration: step.duration,
+      status: step.status,
+      parameters: step.parameters,
+      order: step.order,
+    }))
+}
+
+export function toProtocolRows(
+  template: ProtocolStepsTemplate | ProtocolStepsTemplateData
+): ProtocolRowsAdapterResult {
+  const data = getTemplateData(template, 'protocol-steps')
+  validateProtocolStepsData(data)
+  return [...data.steps]
+    .sort((a, b) => a.order - b.order)
+    .map(step => ({
+      id: step.id,
+      order: step.order,
+      type: step.type,
+      name: step.name,
+      description: step.description,
+      duration: step.duration,
+      status: step.status,
+      ...(step.metadata ?? {}),
+    }))
+}
+
+export function toProtocolColumns(): ProtocolColumnsAdapterResult {
+  return [
+    { key: 'order', label: 'Order', sortable: true, align: 'right' },
+    { key: 'name', label: 'Name', sortable: true },
+    { key: 'type', label: 'Type', sortable: true },
+    { key: 'duration', label: 'Duration', sortable: true, align: 'right' },
+    { key: 'status', label: 'Status', sortable: true },
+    { key: 'description', label: 'Description', sortable: true },
+  ]
+}
+
+export function toProtocolDataFrame(
+  template: ProtocolStepsTemplate | ProtocolStepsTemplateData
+): ProtocolDataFrameAdapterResult {
+  return {
+    data: toProtocolRows(template),
+    columns: toProtocolColumns(),
+    rowKey: 'id',
+  }
+}
+
+export function toAssayMatrixRows(
+  template: AssayMatrixTemplate | AssayMatrixTemplateData
+): AssayMatrixRowsAdapterResult {
+  const data = getTemplateData(template, 'assay-matrix')
+  validateAssayMatrixData(data)
+  const measurements = new Map(
+    data.measurements.map(measurement => [
+      `${measurement.sampleId}:${measurement.featureId}`,
+      measurement.value ?? null,
+    ])
+  )
+
+  return data.samples.map(sample => {
+    const row: Record<string, unknown> = {
+      sampleId: sample.sampleId,
+      name: sample.name,
+      group: sample.group,
+      ...(sample.metadata ?? {}),
+    }
+    for (const feature of data.features) {
+      row[feature.id] = measurements.get(`${sample.sampleId}:${feature.id}`) ?? null
+    }
+    return row
+  })
+}
+
+export function toAssayMatrixColumns(
+  template: AssayMatrixTemplate | AssayMatrixTemplateData
+): AssayMatrixColumnsAdapterResult {
+  const data = getTemplateData(template, 'assay-matrix')
+  validateAssayMatrixData(data)
+  return [
+    { key: 'sampleId', label: 'Sample ID', sortable: true },
+    { key: 'name', label: 'Name', sortable: true },
+    { key: 'group', label: 'Group', sortable: true },
+    ...data.features.map(feature => ({
+      key: feature.id,
+      label: feature.unit ? `${feature.name} (${feature.unit})` : feature.name,
+      sortable: true,
+      align: 'right' as const,
+    })),
+  ]
+}
+
+export function toAssayMatrixDataFrame(
+  template: AssayMatrixTemplate | AssayMatrixTemplateData
+): AssayMatrixDataFrameAdapterResult {
+  return {
+    data: toAssayMatrixRows(template),
+    columns: toAssayMatrixColumns(template),
+    rowKey: 'sampleId',
+  }
+}
+
+export function toReagentListItems(
+  template: ReagentListTemplate | ReagentListTemplateData
+): ReagentListItemsAdapterResult {
+  const data = getTemplateData(template, 'reagent-list')
+  validateReagentListData(data)
+  return data.reagents.map(reagent => ({
+    id: reagent.id,
+    name: reagent.name,
+    catalogNumber: reagent.catalogNumber,
+    lotNumber: reagent.lotNumber,
+    expiryDate: reagent.expiryDate,
+    storageCondition: reagent.storageCondition,
+    location: reagent.location,
+    stockLevel: reagent.stockLevel,
+    stockUnit: reagent.stockUnit,
+    supplier: reagent.supplier,
+    url: reagent.url,
+  }))
+}
+
+export function toReagentRows(
+  template: ReagentListTemplate | ReagentListTemplateData
+): ReagentRowsAdapterResult {
+  const data = getTemplateData(template, 'reagent-list')
+  validateReagentListData(data)
+  return data.reagents.map(reagent => ({
+    id: reagent.id,
+    name: reagent.name,
+    kind: reagent.kind,
+    catalogNumber: reagent.catalogNumber,
+    lotNumber: reagent.lotNumber,
+    expiryDate: reagent.expiryDate,
+    storageCondition: reagent.storageCondition,
+    location: reagent.location,
+    stockLevel: reagent.stockLevel,
+    stockUnit: reagent.stockUnit,
+    supplier: reagent.supplier,
+    concentration: reagent.concentration,
+    ...(reagent.metadata ?? {}),
+  }))
+}
+
+export function toReagentColumns(): ReagentColumnsAdapterResult {
+  return [
+    { key: 'name', label: 'Name', sortable: true },
+    { key: 'kind', label: 'Kind', sortable: true },
+    { key: 'catalogNumber', label: 'Catalog', sortable: true },
+    { key: 'lotNumber', label: 'Lot', sortable: true },
+    { key: 'expiryDate', label: 'Expiry', sortable: true },
+    { key: 'storageCondition', label: 'Storage', sortable: true },
+    { key: 'location', label: 'Location', sortable: true },
+    { key: 'stockLevel', label: 'Stock', sortable: true, align: 'right' },
+    { key: 'stockUnit', label: 'Unit', sortable: true },
+    { key: 'supplier', label: 'Supplier', sortable: true },
+  ]
+}
+
+export function toReagentDataFrame(
+  template: ReagentListTemplate | ReagentListTemplateData
+): ReagentDataFrameAdapterResult {
+  return {
+    data: toReagentRows(template),
+    columns: toReagentColumns(),
+    rowKey: 'id',
+  }
+}
+
+export function toFlowPanelRows(
+  template: FlowCytometryPanelTemplate | FlowCytometryPanelTemplateData
+): FlowPanelRowsAdapterResult {
+  const data = getTemplateData(template, 'flow-cytometry-panel')
+  validateFlowCytometryPanelData(data)
+  return data.markers.map(marker => {
+    const markerControls = data.controls
+      .filter(control => control.markerId === marker.id)
+      .map(control => control.name)
+      .join(', ')
+    return {
+      id: marker.id,
+      marker: marker.marker,
+      fluorophore: marker.fluorophore,
+      detector: marker.detector,
+      clone: marker.clone,
+      reagentId: marker.reagentId,
+      purpose: marker.purpose,
+      compensationRequired: marker.compensationRequired,
+      controls: markerControls,
+      instrument: data.instrument,
+      ...(marker.metadata ?? {}),
+    }
+  })
+}
+
+export function toFlowPanelColumns(): FlowPanelColumnsAdapterResult {
+  return [
+    { key: 'marker', label: 'Marker', sortable: true },
+    { key: 'fluorophore', label: 'Fluorophore', sortable: true },
+    { key: 'detector', label: 'Detector', sortable: true },
+    { key: 'clone', label: 'Clone', sortable: true },
+    { key: 'purpose', label: 'Purpose', sortable: true },
+    { key: 'compensationRequired', label: 'Compensation', sortable: true },
+    { key: 'controls', label: 'Controls' },
+    { key: 'instrument', label: 'Instrument', sortable: true },
+  ]
+}
+
+export function toFlowPanelDataFrame(
+  template: FlowCytometryPanelTemplate | FlowCytometryPanelTemplateData
+): FlowPanelDataFrameAdapterResult {
+  return {
+    data: toFlowPanelRows(template),
+    columns: toFlowPanelColumns(),
+    rowKey: 'id',
+  }
+}
+
+export function toInstrumentRunRows(
+  template: InstrumentRunTemplate | InstrumentRunTemplateData
+): InstrumentRunRowsAdapterResult {
+  const data = getTemplateData(template, 'instrument-run')
+  validateInstrumentRunData(data)
+  const methods = new Map(data.methods.map(method => [method.id, method]))
+  return [...data.items]
+    .sort((a, b) => a.order - b.order)
+    .map(item => {
+      const method = methods.get(item.methodId)
+      return {
+        id: item.id,
+        order: item.order,
+        kind: item.kind,
+        sampleId: item.sampleId,
+        name: item.name ?? item.sampleId ?? item.kind,
+        method: method?.name ?? item.methodId,
+        vial: item.vial,
+        plateId: item.plateId,
+        wellId: item.wellId,
+        injectionVolume: item.injectionVolume,
+        expectedDurationMin: item.expectedDurationMin,
+        status: item.status,
+        instrument: data.instrument ?? method?.instrument,
+        ...(item.metadata ?? {}),
+      }
+    })
+}
+
+export function toInstrumentRunColumns(): InstrumentRunColumnsAdapterResult {
+  return [
+    { key: 'order', label: 'Order', sortable: true, align: 'right' },
+    { key: 'kind', label: 'Kind', sortable: true },
+    { key: 'sampleId', label: 'Sample ID', sortable: true },
+    { key: 'name', label: 'Name', sortable: true },
+    { key: 'method', label: 'Method', sortable: true },
+    { key: 'vial', label: 'Vial', sortable: true },
+    { key: 'wellId', label: 'Well', sortable: true },
+    { key: 'injectionVolume', label: 'Injection', sortable: true, align: 'right' },
+    { key: 'expectedDurationMin', label: 'Duration', sortable: true, align: 'right' },
+    { key: 'status', label: 'Status', sortable: true },
+    { key: 'instrument', label: 'Instrument', sortable: true },
+  ]
+}
+
+export function toInstrumentRunDataFrame(
+  template: InstrumentRunTemplate | InstrumentRunTemplateData
+): InstrumentRunDataFrameAdapterResult {
+  return {
+    data: toInstrumentRunRows(template),
+    columns: toInstrumentRunColumns(),
+    rowKey: 'id',
+  }
+}
+
+export function toQpcrRows(
+  template: QpcrPlateTemplate | QpcrPlateTemplateData
+): QpcrRowsAdapterResult {
+  const data = getTemplateData(template, 'qpcr-plate')
+  validateQpcrPlateData(data)
+  const samples = new Map(data.samples.map(sample => [sample.sampleId, sample]))
+  const targets = new Map(data.targets.map(target => [target.id, target]))
+
+  return data.reactions.map(reaction => {
+    const sample = reaction.sampleId ? samples.get(reaction.sampleId) : undefined
+    const target = targets.get(reaction.targetId)
+    return {
+      id: reaction.id,
+      wellId: reaction.wellId,
+      sampleId: reaction.sampleId,
+      sample: sample?.name ?? reaction.sampleId ?? reaction.controlKind,
+      group: sample?.group,
+      targetId: reaction.targetId,
+      target: target?.name ?? reaction.targetId,
+      replicate: reaction.replicate,
+      controlKind: reaction.controlKind,
+      cq: reaction.cq ?? null,
+      quantity: reaction.quantity ?? null,
+      flags: reaction.flags.join(', '),
+      instrument: data.instrument,
+      chemistry: data.chemistry,
+      ...(reaction.metadata ?? {}),
+    }
+  })
+}
+
+export function toQpcrColumns(): QpcrColumnsAdapterResult {
+  return [
+    { key: 'wellId', label: 'Well', sortable: true },
+    { key: 'sample', label: 'Sample', sortable: true },
+    { key: 'group', label: 'Group', sortable: true },
+    { key: 'target', label: 'Target', sortable: true },
+    { key: 'replicate', label: 'Replicate', sortable: true, align: 'right' },
+    { key: 'controlKind', label: 'Control', sortable: true },
+    { key: 'cq', label: 'Cq', sortable: true, align: 'right' },
+    { key: 'quantity', label: 'Quantity', sortable: true, align: 'right' },
+    { key: 'flags', label: 'Flags' },
+  ]
+}
+
+export function toQpcrDataFrame(
+  template: QpcrPlateTemplate | QpcrPlateTemplateData
+): QpcrDataFrameAdapterResult {
+  return {
+    data: toQpcrRows(template),
+    columns: toQpcrColumns(),
+    rowKey: 'id',
+  }
+}
+
+export function toQpcrWellPlateWells(
+  template: QpcrPlateTemplate | QpcrPlateTemplateData
+): QpcrWellMapAdapterResult {
+  const data = getTemplateData(template, 'qpcr-plate')
+  validateQpcrPlateData(data)
+  return Object.fromEntries(data.reactions.map(reaction => {
+    const [row, col] = wellPositionFromId(reaction.wellId)
+    return [
+      reaction.wellId,
+      {
+        id: reaction.wellId,
+        row,
+        col,
+        state: 'filled' as const,
+        sampleType: reaction.sampleId ?? reaction.controlKind,
+        value: reaction.cq ?? undefined,
+        metadata: {
+          reactionId: reaction.id,
+          sampleId: reaction.sampleId,
+          targetId: reaction.targetId,
+          replicate: reaction.replicate,
+          controlKind: reaction.controlKind,
+        },
+      } satisfies Well,
+    ]
+  }))
+}
+
+export function toTemplateDataFrame(
+  template: DataFrameTemplate | BioTemplateEnvelope<unknown>
+): TemplateDataFrameAdapterResult {
+  switch (template.template_id) {
+    case 'sample-sheet':
+      return toSampleDataFrame(template as SampleSheetTemplate)
+    case 'sample-prep':
+      return toSamplePrepDataFrame(template as SamplePrepTemplate)
+    case 'calibration-curve':
+      return toCalibrationCurveDataFrame(template as CalibrationCurveTemplate)
+    case 'time-course':
+      return toTimeCourseDataFrame(template as TimeCourseTemplate)
+    case 'protocol-steps':
+      return toProtocolDataFrame(template as ProtocolStepsTemplate)
+    case 'assay-matrix':
+      return toAssayMatrixDataFrame(template as AssayMatrixTemplate)
+    case 'reagent-list':
+      return toReagentDataFrame(template as ReagentListTemplate)
+    case 'flow-cytometry-panel':
+      return toFlowPanelDataFrame(template as FlowCytometryPanelTemplate)
+    case 'instrument-run':
+      return toInstrumentRunDataFrame(template as InstrumentRunTemplate)
+    case 'qpcr-plate':
+      return toQpcrDataFrame(template as QpcrPlateTemplate)
+    default:
+      throw new Error(`Template '${String(template.template_id)}' does not expose a DataFrame adapter.`)
+  }
+}
+
+export function toWellMapArray(wells: Record<string, Well>): Well[] {
+  return Object.values(wells)
+}
+
+function wellPositionFromId(wellId: string): [number, number] {
+  const match = /^([A-Z]+)([1-9][0-9]*)$/.exec(wellId.toUpperCase())
+  if (!match) {
+    throw new Error(`Invalid well id '${wellId}'.`)
+  }
+  const row = [...match[1]].reduce((value, char) => value * 26 + char.charCodeAt(0) - 64, 0) - 1
+  const col = Number(match[2]) - 1
+  return [row, col]
+}
+
+function sampleColumnKey(columnId: string): string {
+  const aliases: Record<string, string> = {
+    sample_id: 'sampleId',
+    plate_id: 'plateId',
+    well_id: 'wellId',
+  }
+  return aliases[columnId] ?? columnId
+}