@morscherlab/mint-sdk 1.2.0-beta.3 → 1.2.0-beta.5

package/src/templates/presetControlSchemas.ts

@@ -0,0 +1,258 @@
+import {
+  CONCENTRATION_UNITS,
+  ICONS,
+  PLATE_FORMAT_OPTIONS,
+} from './controlSchemaConstants'
+import type {
+  BioTemplateControlSchema,
+} from './controlSchemaTypes'
+import {
+  templateControlSchemas,
+} from './templateControlSchemas'
+import type {
+  TemplatePresetId,
+} from './types'
+
+export const presetControlSchemas = {
+  'wellplate-screen': {
+    ...templateControlSchemas['plate-map'],
+    ...templateControlSchemas['dose-response'],
+    sampleNames: {
+      ...templateControlSchemas['plate-map'].sampleNames,
+      default: ['Control', 'Treatment'],
+    },
+  },
+  'qpcr-expression': {
+    sampleNames: {
+      type: 'tags',
+      label: 'Samples',
+      default: ['Control', 'Treatment'],
+      section: 'samples',
+      sectionLabel: 'Samples',
+      sectionSubtitle: 'Expression groups',
+      view: 'design',
+      sidebar: { icon: ICONS.samples, iconColor: '#10b981', iconBg: '#d1fae5' },
+    },
+    targets: {
+      type: 'tags',
+      label: 'Targets',
+      default: ['ACTB', 'GAPDH'],
+      section: 'assay',
+      sectionLabel: 'Assay',
+      view: 'design',
+      sidebar: { icon: ICONS.plate, iconColor: '#6366f1', iconBg: '#e0e7ff' },
+    },
+    ...templateControlSchemas['qpcr-plate'],
+  },
+  'lcms-batch': {
+    sampleNames: {
+      type: 'tags',
+      label: 'Samples',
+      default: ['S001', 'S002'],
+      section: 'samples',
+      sectionLabel: 'Samples',
+      sectionSubtitle: 'Batch samples',
+      view: 'run',
+      sidebar: { icon: ICONS.samples, iconColor: '#10b981', iconBg: '#d1fae5' },
+    },
+    featureNames: {
+      type: 'tags',
+      label: 'Features',
+      default: ['Glucose', 'Lactate'],
+      section: 'features',
+      sectionLabel: 'Features',
+      view: 'analysis',
+      sidebar: { icon: ICONS.table, iconColor: '#0ea5e9', iconBg: '#e0f2fe' },
+    },
+    ...templateControlSchemas['instrument-run'],
+    ...templateControlSchemas['assay-matrix'],
+  },
+  'targeted-metabolomics': {
+    sampleNames: {
+      type: 'tags',
+      label: 'Samples',
+      default: ['S001', 'S002'],
+      section: 'samples',
+      sectionLabel: 'Samples',
+      sectionSubtitle: 'Unknowns and QC pool',
+      view: 'run',
+      sidebar: { icon: ICONS.samples, iconColor: '#10b981', iconBg: '#d1fae5' },
+    },
+    metaboliteNames: {
+      type: 'tags',
+      label: 'Metabolites',
+      default: ['Glucose', 'Lactate', 'Pyruvate'],
+      section: 'features',
+      sectionLabel: 'Metabolites',
+      sectionSubtitle: 'Quantitation panel',
+      view: 'analysis',
+      sidebar: { icon: ICONS.table, iconColor: '#0ea5e9', iconBg: '#e0f2fe' },
+    },
+    internalStandards: {
+      type: 'tags',
+      label: 'Internal standards',
+      default: ['Stable isotope internal standard mix'],
+      section: 'standards',
+      sectionLabel: 'Standards',
+      sectionSubtitle: 'Calibration and internal standards',
+      view: 'analysis',
+      sidebar: { icon: ICONS.dose, iconColor: '#8b5cf6', iconBg: '#ede9fe' },
+    },
+    standardConcentrations: {
+      type: 'tags',
+      label: 'Calibration levels',
+      default: ['0.1', '1', '10', '100'],
+      section: 'standards',
+      view: 'analysis',
+    },
+    concentrationUnit: {
+      label: 'Concentration unit',
+      default: 'uM',
+      options: CONCENTRATION_UNITS,
+      section: 'standards',
+      view: 'analysis',
+    },
+    responseUnit: {
+      label: 'Response unit',
+      default: 'peak area ratio',
+      section: 'readout',
+      sectionLabel: 'Readout',
+      view: 'analysis',
+      sidebar: { icon: ICONS.table, iconColor: '#0ea5e9', iconBg: '#e0f2fe' },
+    },
+    instrument: {
+      ...templateControlSchemas['instrument-run'].instrument,
+      default: 'LC-MS',
+    },
+    method: {
+      ...templateControlSchemas['instrument-run'].method,
+      default: 'Targeted metabolomics',
+    },
+    prepType: {
+      ...templateControlSchemas['sample-prep'].prepType,
+      default: 'extraction',
+    },
+    outputVolume: templateControlSchemas['sample-prep'].outputVolume,
+    includeQc: templateControlSchemas['instrument-run'].includeQc,
+  },
+  'elisa-assay': {
+    sampleNames: {
+      type: 'tags',
+      label: 'Samples',
+      default: ['Control', 'Treatment'],
+      section: 'samples',
+      sectionLabel: 'Samples',
+      sectionSubtitle: 'Unknowns and controls',
+      view: 'design',
+      sidebar: { icon: ICONS.samples, iconColor: '#10b981', iconBg: '#d1fae5' },
+    },
+    analyte: {
+      label: 'Analyte',
+      default: 'Analyte',
+      section: 'standards',
+      sectionLabel: 'Standards',
+      sectionSubtitle: 'Calibration setup',
+      view: 'analysis',
+      sidebar: { icon: ICONS.dose, iconColor: '#8b5cf6', iconBg: '#ede9fe' },
+    },
+    standardConcentrations: {
+      type: 'tags',
+      label: 'Standards',
+      default: ['1000', '100', '10', '1'],
+      section: 'standards',
+      view: 'analysis',
+    },
+    unit: {
+      label: 'Concentration unit',
+      default: 'pg/mL',
+      options: ['pg/mL', 'ng/mL', 'ug/mL', 'nM', 'uM'],
+      section: 'standards',
+      view: 'analysis',
+    },
+    responseUnit: {
+      label: 'Response unit',
+      default: 'OD450',
+      section: 'readout',
+      sectionLabel: 'Readout',
+      view: 'analysis',
+      sidebar: { icon: ICONS.table, iconColor: '#0ea5e9', iconBg: '#e0f2fe' },
+    },
+    plateName: {
+      label: 'Plate name',
+      default: 'ELISA plate',
+      section: 'layout',
+      sectionLabel: 'Layout',
+      sectionSubtitle: 'Plate geometry',
+      view: 'design',
+      sidebar: { icon: ICONS.plate, iconColor: '#6366f1', iconBg: '#e0e7ff' },
+    },
+    plateFormat: {
+      label: 'Format',
+      default: 96,
+      options: PLATE_FORMAT_OPTIONS,
+      section: 'layout',
+      view: 'design',
+    },
+  },
+  'flow-cytometry-assay': {
+    sampleNames: {
+      type: 'tags',
+      label: 'Samples',
+      default: ['Control', 'Treatment'],
+      section: 'samples',
+      sectionLabel: 'Samples',
+      sectionSubtitle: 'Assay groups',
+      view: 'design',
+      sidebar: { icon: ICONS.samples, iconColor: '#10b981', iconBg: '#d1fae5' },
+    },
+    markers: {
+      ...templateControlSchemas['flow-cytometry-panel'].markers,
+      default: ['CD3', 'CD4', 'CD8'],
+    },
+    featureNames: {
+      type: 'tags',
+      label: 'Readouts',
+      default: ['CD3+ cells', 'CD4+ cells', 'CD8+ cells'],
+      section: 'features',
+      sectionLabel: 'Readouts',
+      sectionSubtitle: 'Assay matrix columns',
+      view: 'analysis',
+      sidebar: { icon: ICONS.table, iconColor: '#0ea5e9', iconBg: '#e0f2fe' },
+    },
+    instrument: {
+      ...templateControlSchemas['flow-cytometry-panel'].instrument,
+      default: 'Flow cytometer',
+    },
+    includeDefaultControls: templateControlSchemas['flow-cytometry-panel'].includeDefaultControls,
+  },
+  'western-blot-assay': {
+    sampleNames: {
+      type: 'tags',
+      label: 'Samples',
+      default: ['Control', 'Treatment'],
+      section: 'samples',
+      sectionLabel: 'Samples',
+      sectionSubtitle: 'Blot lanes and groups',
+      view: 'design',
+      sidebar: { icon: ICONS.samples, iconColor: '#10b981', iconBg: '#d1fae5' },
+    },
+    targets: {
+      type: 'tags',
+      label: 'Targets',
+      default: ['Target protein'],
+      section: 'assay',
+      sectionLabel: 'Assay',
+      sectionSubtitle: 'Protein targets',
+      view: 'design',
+      sidebar: { icon: ICONS.table, iconColor: '#0ea5e9', iconBg: '#e0f2fe' },
+    },
+    loadingControl: {
+      label: 'Loading control',
+      default: 'ACTB',
+      section: 'normalization',
+      sectionLabel: 'Normalization',
+      view: 'analysis',
+      sidebar: { icon: ICONS.settings, iconColor: '#6366f1', iconBg: '#e0e7ff' },
+    },
+  },
+} satisfies Record<TemplatePresetId, BioTemplateControlSchema>

package/src/templates/presets.ts

@@ -0,0 +1,179 @@
+import type { TemplateId, TemplatePresetId } from './types'
+
+import { templateIdentifierMatches, templateSearchMatches } from './lookup'
+
+export interface BioTemplatePresetEntry {
+  name: TemplatePresetId
+  label: string
+  category: 'bio-template-preset'
+  purpose: string
+  templates: readonly TemplateId[]
+  aliases: readonly string[]
+  python_import: string
+  python_example: string
+  frontend_import: string
+  frontend_adapters: readonly string[]
+  components: readonly string[]
+}
+
+export const bioTemplatePresets = [
+  {
+    name: 'wellplate-screen',
+    label: 'Well-plate screen',
+    category: 'bio-template-preset',
+    purpose: 'Plate map, sample sheet, and dose-response payloads for plate-based screening assays.',
+    templates: ['plate-map', 'sample-sheet', 'dose-response'],
+    aliases: [
+      'wellplate',
+      'well-plate screen',
+      'drug screen',
+      'plate screen',
+      'dose response plate',
+      'dose design',
+      'dose planner',
+    ],
+    python_import: 'from mint_sdk.templates import create_wellplate_screen_collection, save_template_collection',
+    python_example: 'create_wellplate_screen_collection(samples=["Control", "Treatment"], compounds={"Drug A": [10, 1, 0.1]}, unit="uM")',
+    frontend_import: "import { createWellPlateScreenCollection, toPlateMapEditorState, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
+    frontend_adapters: ['toPlateMapEditorState', 'toTemplateDataFrame', 'toDoseConditions'],
+    components: ['PlateMapEditor', 'WellPlate', 'DataFrame', 'DoseCalculator'],
+  },
+  {
+    name: 'qpcr-expression',
+    label: 'qPCR expression',
+    category: 'bio-template-preset',
+    purpose: 'Sample metadata and qPCR/ddPCR plate layout for target-expression assays.',
+    templates: ['sample-sheet', 'qpcr-plate'],
+    aliases: ['qpcr', 'qPCR', 'rt-qpcr', 'ddpcr', 'gene expression', 'primer plate'],
+    python_import: 'from mint_sdk.templates import create_qpcr_expression_collection, save_template_collection',
+    python_example: 'create_qpcr_expression_collection(samples=["Control", "Treatment"], targets=["ACTB", "GAPDH"], replicates=3)',
+    frontend_import: "import { createQpcrExpressionCollection, toQpcrWellPlateWells, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
+    frontend_adapters: ['toTemplateDataFrame', 'toQpcrDataFrame', 'toQpcrWellPlateWells'],
+    components: ['DataFrame', 'WellPlate', 'SampleSelector'],
+  },
+  {
+    name: 'lcms-batch',
+    label: 'LC-MS batch',
+    category: 'bio-template-preset',
+    purpose: 'Sample metadata, instrument queue, and assay matrix payloads for omics acquisition batches.',
+    templates: ['sample-sheet', 'instrument-run', 'assay-matrix'],
+    aliases: [
+      'lcms',
+      'lc-ms',
+      'mass spec batch',
+      'omics batch',
+      'metabolomics',
+      'metabolism',
+      'metabolite profiling',
+      'run queue',
+      'sequence table',
+    ],
+    python_import: 'from mint_sdk.templates import create_lcms_batch_collection, save_template_collection',
+    python_example: 'create_lcms_batch_collection(samples=["S001", "S002"], features=["Glucose", "Lactate"], instrument="LC-MS")',
+    frontend_import: "import { createLcmsBatchCollection, toAssayMatrixSampleOptions, toInstrumentRunDataFrame, toInstrumentRunScheduleEvents, toInstrumentRunSteps, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
+    frontend_adapters: ['toTemplateDataFrame', 'toInstrumentRunDataFrame', 'toInstrumentRunSteps', 'toInstrumentRunScheduleEvents', 'toAssayMatrixDataFrame', 'toAssayMatrixSampleOptions'],
+    components: ['DataFrame', 'ExperimentTimeline', 'ScheduleCalendar', 'ChartContainer', 'SampleSelector'],
+  },
+  {
+    name: 'targeted-metabolomics',
+    label: 'Targeted metabolomics',
+    category: 'bio-template-preset',
+    purpose: 'Sample metadata, extraction prep, internal standards, LC/GC-MS sequence, calibration curve, and metabolite readout matrix for quantitative metabolomics.',
+    templates: ['sample-sheet', 'sample-prep', 'reagent-list', 'instrument-run', 'calibration-curve', 'assay-matrix'],
+    aliases: [
+      'targeted metabolomics',
+      'quantitative metabolomics',
+      'lc-ms metabolomics',
+      'gc-ms metabolomics',
+      'targeted lcms',
+      'metabolite quantitation',
+      'mass spec quantitation',
+      'internal standards',
+      'peak area ratio',
+    ],
+    python_import: 'from mint_sdk.templates import create_targeted_metabolomics_collection, save_template_collection',
+    python_example: 'create_targeted_metabolomics_collection(samples=["S001", "S002"], metabolites=["Glucose", "Lactate"], internal_standards=["13C Glucose"], instrument="LC-MS")',
+    frontend_import: "import { createTargetedMetabolomicsCollection, toInstrumentRunDataFrame, toCalibrationCurveDataFrame, toAssayMatrixDataFrame, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
+    frontend_adapters: ['toTemplateDataFrame', 'toSamplePrepDataFrame', 'toReagentDataFrame', 'toInstrumentRunDataFrame', 'toInstrumentRunSteps', 'toInstrumentRunScheduleEvents', 'toCalibrationCurveDataFrame', 'toAssayMatrixDataFrame', 'toAssayMatrixSampleOptions'],
+    components: ['DataFrame', 'ReagentList', 'ExperimentTimeline', 'ScheduleCalendar', 'FitPanel', 'ChartContainer', 'SampleSelector'],
+  },
+  {
+    name: 'elisa-assay',
+    label: 'ELISA assay',
+    category: 'bio-template-preset',
+    purpose: 'Plate layout, sample metadata, standard curve, and readout matrix for ELISA and plate-reader assays.',
+    templates: ['plate-map', 'sample-sheet', 'calibration-curve', 'assay-matrix'],
+    aliases: ['elisa', 'plate reader assay', 'standard curve plate', 'absorbance assay', 'immunoassay'],
+    python_import: 'from mint_sdk.templates import create_elisa_assay_collection, save_template_collection',
+    python_example: 'create_elisa_assay_collection(samples=["Control", "Treatment"], analyte="IL-6", standard_concentrations=[1000, 100, 10, 1], unit="pg/mL")',
+    frontend_import: "import { createElisaAssayCollection, toPlateMapEditorState, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
+    frontend_adapters: ['toPlateMapEditorState', 'toTemplateDataFrame', 'toCalibrationCurveDataFrame'],
+    components: ['PlateMapEditor', 'WellPlate', 'DataFrame', 'FitPanel', 'ChartContainer'],
+  },
+  {
+    name: 'flow-cytometry-assay',
+    label: 'Flow cytometry assay',
+    category: 'bio-template-preset',
+    purpose: 'Sample metadata, antibody marker panel, compensation controls, and readout matrix for flow-cytometry assays.',
+    templates: ['sample-sheet', 'flow-cytometry-panel', 'assay-matrix'],
+    aliases: [
+      'flow cytometry',
+      'facs',
+      'facs panel',
+      'flow panel',
+      'immune phenotyping',
+      'immunophenotyping',
+    ],
+    python_import: 'from mint_sdk.templates import create_flow_cytometry_assay_collection, save_template_collection',
+    python_example: 'create_flow_cytometry_assay_collection(samples=["Control", "Treatment"], markers=["CD3", "CD4", "CD8"], instrument="BD LSRFortessa")',
+    frontend_import: "import { createFlowCytometryAssayCollection, toFlowPanelDataFrame, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
+    frontend_adapters: ['toTemplateDataFrame', 'toFlowPanelDataFrame', 'toAssayMatrixDataFrame'],
+    components: ['DataFrame', 'SampleSelector', 'ChartContainer'],
+  },
+  {
+    name: 'western-blot-assay',
+    label: 'Western blot assay',
+    category: 'bio-template-preset',
+    purpose: 'Sample metadata, antibody/reagent list, protocol steps, and normalized protein readout matrix for Western blot assays.',
+    templates: ['sample-sheet', 'reagent-list', 'protocol-steps', 'assay-matrix'],
+    aliases: ['western blot', 'western-blot', 'immunoblot', 'protein blot', 'protein expression'],
+    python_import: 'from mint_sdk.templates import create_western_blot_assay_collection, save_template_collection',
+    python_example: 'create_western_blot_assay_collection(samples=["Control", "Treatment"], targets=["pERK", "ERK"], loading_control="ACTB")',
+    frontend_import: "import { createWesternBlotAssayCollection, toReagentDataFrame, toProtocolDataFrame, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
+    frontend_adapters: ['toTemplateDataFrame', 'toReagentDataFrame', 'toProtocolDataFrame'],
+    components: ['DataFrame', 'ReagentList', 'ExperimentTimeline', 'SampleSelector'],
+  },
+] as const satisfies readonly BioTemplatePresetEntry[]
+
+export function listBioTemplatePresets(): readonly BioTemplatePresetEntry[] {
+  return bioTemplatePresets
+}
+
+export function getBioTemplatePresetInfo(name: string): BioTemplatePresetEntry | undefined {
+  return bioTemplatePresets.find(entry => {
+    const identifiers = [
+      entry.name,
+      entry.label,
+      ...entry.aliases,
+    ]
+    return templateIdentifierMatches(name, identifiers)
+  })
+}
+
+export function searchBioTemplatePresets(query: string): readonly BioTemplatePresetEntry[] {
+  const normalized = query.trim().toLowerCase()
+  if (!normalized) return bioTemplatePresets
+
+  return bioTemplatePresets.filter(entry => templateSearchMatches(normalized, [
+    entry.name,
+    entry.label,
+    entry.purpose,
+    entry.python_import,
+    entry.python_example,
+    entry.frontend_import,
+    ...entry.templates,
+    ...entry.aliases,
+    ...entry.frontend_adapters,
+    ...entry.components,
+  ]))
+}

package/src/templates/protocolAdapters.ts

@@ -0,0 +1,69 @@
+import { getTemplateData } from './templateEnvelopes'
+import { validateProtocolStepsData } from './templateValidators'
+import type {
+  ProtocolColumnsAdapterResult,
+  ProtocolDataFrameAdapterResult,
+  ProtocolRowsAdapterResult,
+  ProtocolStepsAdapterResult,
+  ProtocolStepsTemplate,
+  ProtocolStepsTemplateData,
+} from './types'
+
+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',
+  }
+}

package/src/templates/protocolNormalizers.ts

@@ -0,0 +1,37 @@
+import type {
+  ProtocolStepRecord,
+  TimeCourseCondition,
+  TimePoint,
+} from './types'
+import { idFromName } from './builderIdUtils'
+
+export function normalizeTimePoint(timepoint: TimePoint): TimePoint {
+  return {
+    ...timepoint,
+    metadata: timepoint.metadata ?? {},
+  }
+}
+
+export function normalizeCondition(condition: TimeCourseCondition): TimeCourseCondition {
+  return {
+    ...condition,
+    metadata: condition.metadata ?? {},
+  }
+}
+
+export function normalizeProtocolStep(
+  step: Partial<ProtocolStepRecord> & { name: string },
+  index: number
+): ProtocolStepRecord {
+  return {
+    id: step.id ?? idFromName(step.name, `step-${index + 1}`),
+    type: step.type ?? 'custom',
+    name: step.name,
+    description: step.description,
+    duration: step.duration,
+    status: step.status ?? 'pending',
+    parameters: step.parameters ?? {},
+    order: step.order ?? index,
+    metadata: step.metadata ?? {},
+  }
+}

package/src/templates/protocolStepsBuilder.ts

@@ -0,0 +1,36 @@
+import { idFromName } from './builderIdUtils'
+import { normalizeProtocolStep } from './protocolNormalizers'
+import { createTemplateEnvelope } from './templateEnvelopes'
+import { validateProtocolStepsData } from './templateValidators'
+import type {
+  CreateProtocolStepsTemplateOptions,
+  ProtocolStepRecord,
+  ProtocolStepsTemplate,
+  ProtocolStepsTemplateData,
+} from './types'
+
+export function createProtocolStepsTemplate(
+  options: CreateProtocolStepsTemplateOptions
+): ProtocolStepsTemplate {
+  const steps = options.steps.map((step, index): ProtocolStepRecord => {
+    if (typeof step === 'string') {
+      return {
+        id: idFromName(step, `step-${index + 1}`),
+        type: 'custom',
+        name: step,
+        status: 'pending',
+        parameters: {},
+        order: index,
+        metadata: {},
+      }
+    }
+    return normalizeProtocolStep(step, index)
+  }).sort((a, b) => a.order - b.order)
+
+  const data: ProtocolStepsTemplateData = {
+    steps,
+    metadata: options.metadata ?? {},
+  }
+  validateProtocolStepsData(data)
+  return createTemplateEnvelope('protocol-steps', data, options.metadata ?? {})
+}

package/src/templates/qpcrAdapters.ts

@@ -0,0 +1,104 @@
+import type { Well } from '../types'
+import { getTemplateData } from './templateEnvelopes'
+import { validateQpcrPlateData } from './templateValidators'
+import type {
+  QpcrColumnsAdapterResult,
+  QpcrDataFrameAdapterResult,
+  QpcrPlateTemplate,
+  QpcrPlateTemplateData,
+  QpcrRowsAdapterResult,
+  QpcrWellMapAdapterResult,
+} from './types'
+
+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,
+    ]
+  }))
+}
+
+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]
+}