@morscherlab/mint-sdk 1.3.9 → 1.4.0-beta.1

package/src/templates/qpcrAdapters.ts

@@ -1,108 +0,0 @@
-import type { Well } from '../types'
-import { getTemplateData } from './templateEnvelopes'
-import { validateQpcrPlateData } from './templateValidators'
-import type {
-  QpcrColumnsAdapterResult,
-  QpcrDataFrameAdapterResult,
-  QpcrPlateTemplate,
-  QpcrPlateTemplateData,
-  QpcrRowsAdapterResult,
-  QpcrWellMapAdapterResult,
-} from './types'
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-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 ?? {}),
-    }
-  })
-}
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-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' },
-  ]
-}
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-export function toQpcrDataFrame(
-  template: QpcrPlateTemplate | QpcrPlateTemplateData
-): QpcrDataFrameAdapterResult {
-  return {
-    data: toQpcrRows(template),
-    columns: toQpcrColumns(),
-    rowKey: 'id',
-  }
-}
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-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]
-}

package/src/templates/qpcrExpressionCollectionBuilder.ts

@@ -1,34 +0,0 @@
-import { createQpcrPlateTemplate } from './qpcrPlateBuilder'
-import { createSampleSheetTemplate } from './sampleSheetBuilder'
-import { presetSampleRecords } from './sampleNormalizers'
-import { createTemplateCollection } from './templateEnvelopes'
-import type {
-  CreateQpcrExpressionCollectionOptions,
-  TemplateCollectionEnvelope,
-} from './types'
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-export function createQpcrExpressionCollection(
-  options: CreateQpcrExpressionCollectionOptions = {}
-): TemplateCollectionEnvelope {
-  const sampleRecords = presetSampleRecords(options.samples ?? ['Control', 'Treatment'])
-  const sampleSheet = createSampleSheetTemplate({ samples: sampleRecords })
-  const qpcr = createQpcrPlateTemplate({
-    samples: sampleRecords.map(sample => ({
-      sampleId: sample.sampleId,
-      name: sample.name,
-      group: sample.group,
-      metadata: sample.metadata ?? {},
-    })),
-    targets: options.targets ?? ['ACTB', 'GAPDH'],
-    chemistry: options.chemistry,
-    format: options.format,
-    includeNoTemplateControls: options.includeNoTemplateControls,
-    replicates: options.replicates ?? 3,
-    instrument: options.instrument,
-  })
-  return createTemplateCollection(
-    [sampleSheet, qpcr],
-    { preset: 'qpcr-expression', ...(options.metadata ?? {}) }
-  )
-}

package/src/templates/qpcrPlateBuilder.ts

@@ -1,97 +0,0 @@
-import { idFromName } from './builderIdUtils'
-import { wellIdsForFormat } from '../components/WellPlate.geometry'
-import {
-  normalizeQpcrSample,
-  normalizeQpcrTarget,
-} from './runNormalizers'
-import { createTemplateEnvelope } from './templateEnvelopes'
-import { validateQpcrPlateData } from './templateValidators'
-import type {
-  CreateQpcrPlateTemplateOptions,
-  QpcrPlateTemplate,
-  QpcrPlateTemplateData,
-  QpcrReaction,
-  QpcrSample,
-  QpcrTarget,
-} from './types'
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-export function createQpcrPlateTemplate(
-  options: CreateQpcrPlateTemplateOptions
-): QpcrPlateTemplate {
-  const format = options.format ?? 96
-  const replicates = options.replicates ?? 3
-  if (replicates < 1) {
-    throw new Error('qPCR replicates must be at least 1.')
-  }
-
-  const samples = options.samples.map((sample, index): QpcrSample => {
-    if (typeof sample !== 'string') return normalizeQpcrSample(sample)
-    return {
-      sampleId: idFromName(sample, `sample-${index + 1}`),
-      name: sample,
-      metadata: {},
-    }
-  })
-  const targets = options.targets.map((target, index): QpcrTarget => {
-    if (typeof target !== 'string') return normalizeQpcrTarget(target)
-    return {
-      id: idFromName(target, `target-${index + 1}`),
-      name: target,
-      metadata: {},
-    }
-  })
-  const wells = wellIdsForFormat(format)
-  let wellIndex = 0
-  const reactions: QpcrReaction[] = []
-
-  for (const sample of samples) {
-    for (const target of targets) {
-      for (let replicate = 1; replicate <= replicates; replicate += 1) {
-        const wellId = wells[wellIndex]
-        if (!wellId) throw new Error(`qPCR plate format ${format} does not have enough wells.`)
-        reactions.push({
-          id: `${sample.sampleId}-${target.id}-r${replicate}`,
-          wellId,
-          sampleId: sample.sampleId,
-          targetId: target.id,
-          replicate,
-          controlKind: 'sample',
-          flags: [],
-          metadata: {},
-        })
-        wellIndex += 1
-      }
-    }
-  }
-
-  if (options.includeNoTemplateControls !== false) {
-    for (const target of targets) {
-      const wellId = wells[wellIndex]
-      if (!wellId) throw new Error(`qPCR plate format ${format} does not have enough wells.`)
-      reactions.push({
-        id: `ntc-${target.id}`,
-        wellId,
-        targetId: target.id,
-        replicate: 1,
-        controlKind: 'no-template',
-        flags: [],
-        metadata: {},
-      })
-      wellIndex += 1
-    }
-  }
-
-  const data: QpcrPlateTemplateData = {
-    plateId: 'qpcr-plate-1',
-    format,
-    samples,
-    targets,
-    reactions,
-    instrument: options.instrument,
-    chemistry: options.chemistry ?? 'sybr',
-    metadata: options.metadata ?? {},
-  }
-  validateQpcrPlateData(data)
-  return createTemplateEnvelope('qpcr-plate', data, options.metadata ?? {})
-}

package/src/templates/reagentAdapters.ts

@@ -1,81 +0,0 @@
-import { getTemplateData } from './templateEnvelopes'
-import { validateReagentListData } from './templateValidators'
-import type {
-  ReagentColumnsAdapterResult,
-  ReagentDataFrameAdapterResult,
-  ReagentListItemsAdapterResult,
-  ReagentListTemplate,
-  ReagentListTemplateData,
-  ReagentRowsAdapterResult,
-} from './types'
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-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,
-  }))
-}
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-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 ?? {}),
-  }))
-}
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-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 },
-  ]
-}
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-export function toReagentDataFrame(
-  template: ReagentListTemplate | ReagentListTemplateData
-): ReagentDataFrameAdapterResult {
-  return {
-    data: toReagentRows(template),
-    columns: toReagentColumns(),
-    rowKey: 'id',
-  }
-}

package/src/templates/reagentListBuilder.ts

@@ -1,31 +0,0 @@
-import { normalizeReagent } from './assayNormalizers'
-import { idFromName } from './builderIdUtils'
-import { createTemplateEnvelope } from './templateEnvelopes'
-import { validateReagentListData } from './templateValidators'
-import type {
-  CreateReagentListTemplateOptions,
-  ReagentListTemplate,
-  ReagentListTemplateData,
-  ReagentRecord,
-} from './types'
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-export function createReagentListTemplate(
-  options: CreateReagentListTemplateOptions
-): ReagentListTemplate {
-  const reagents = options.reagents.map((reagent, index): ReagentRecord => {
-    if (typeof reagent !== 'string') return normalizeReagent(reagent)
-    return {
-      id: idFromName(reagent, `reagent-${index + 1}`),
-      name: reagent,
-      kind: 'reagent',
-      metadata: {},
-    }
-  })
-  const data: ReagentListTemplateData = {
-    reagents,
-    metadata: options.metadata ?? {},
-  }
-  validateReagentListData(data)
-  return createTemplateEnvelope('reagent-list', data, options.metadata ?? {})
-}

package/src/templates/runNormalizers.ts

@@ -1,63 +0,0 @@
-import type {
-  InstrumentMethod,
-  InstrumentRunItem,
-  QpcrSample,
-  QpcrTarget,
-} from './types'
-import { idFromName } from './builderIdUtils'
-
-export function normalizeInstrumentMethod(
-  method: Partial<InstrumentMethod> & { name?: string },
-  fallbackInstrument?: string
-): InstrumentMethod {
-  const name = method.name || method.id || 'Default method'
-  return {
-    id: method.id || idFromName(name, 'method-1'),
-    name,
-    instrument: method.instrument ?? fallbackInstrument,
-    acquisitionMode: method.acquisitionMode,
-    metadata: method.metadata ?? {},
-  }
-}
-
-export function normalizeInstrumentRunItem(
-  item: Partial<InstrumentRunItem> & { name?: string; sampleId?: string },
-  defaultMethodId: string,
-  fallbackOrder: number,
-  index: number
-): InstrumentRunItem {
-  const kind = item.kind ?? 'sample'
-  const sampleId = item.sampleId || (kind === 'sample'
-    ? idFromName(item.name ?? `Sample ${index + 1}`, `sample-${index + 1}`)
-    : undefined)
-  const label = item.name ?? sampleId ?? kind
-  return {
-    id: item.id || idFromName(label, `${kind}-${index + 1}`),
-    order: item.order ?? fallbackOrder,
-    kind,
-    sampleId,
-    name: item.name,
-    methodId: item.methodId || defaultMethodId,
-    vial: item.vial,
-    plateId: item.plateId,
-    wellId: item.wellId,
-    injectionVolume: item.injectionVolume,
-    expectedDurationMin: item.expectedDurationMin,
-    status: item.status ?? 'planned',
-    metadata: item.metadata ?? {},
-  }
-}
-
-export function normalizeQpcrSample(sample: QpcrSample): QpcrSample {
-  return {
-    ...sample,
-    metadata: sample.metadata ?? {},
-  }
-}
-
-export function normalizeQpcrTarget(target: QpcrTarget): QpcrTarget {
-  return {
-    ...target,
-    metadata: target.metadata ?? {},
-  }
-}

package/src/templates/sampleNormalizers.ts

@@ -1,58 +0,0 @@
-import type {
-  SamplePrepStep,
-  SamplePrepStepInput,
-  SampleRecord,
-} from './types'
-import {
-  idFromName,
-  sampleIdFromName,
-} from './builderIdUtils'
-
-export function normalizeSampleRecord(sample: SampleRecord): SampleRecord {
-  return {
-    ...sample,
-    metadata: sample.metadata ?? {},
-  }
-}
-
-export function presetSampleRecords(samples: Array<string | SampleRecord>): SampleRecord[] {
-  return samples.map((sample, index) => {
-    if (typeof sample !== 'string') return normalizeSampleRecord(sample)
-    return {
-      sampleId: sampleIdFromName(sample, index),
-      name: sample,
-      metadata: {},
-    }
-  })
-}
-
-export function normalizeSamplePrepStep(
-  step: SamplePrepStepInput,
-  prepType: SamplePrepStep['type'],
-  volumeUnit: string,
-  order: number,
-  index: number
-): SamplePrepStep {
-  const type = step.type ?? prepType
-  const sourceSampleId = step.sourceSampleId
-  const name = step.name || `Prepare ${sourceSampleId ?? index + 1}`
-  return {
-    id: step.id || idFromName(name, `${type}-${index + 1}`),
-    order: step.order ?? order,
-    type,
-    name,
-    sourceSampleId,
-    sourcePlateId: step.sourcePlateId,
-    sourceWellId: step.sourceWellId,
-    destinationSampleId: step.destinationSampleId,
-    destinationPlateId: step.destinationPlateId,
-    destinationWellId: step.destinationWellId,
-    reagentId: step.reagentId,
-    inputVolume: step.inputVolume,
-    outputVolume: step.outputVolume,
-    volumeUnit: step.volumeUnit || volumeUnit,
-    durationMin: step.durationMin,
-    status: step.status ?? 'planned',
-    metadata: step.metadata ?? {},
-  }
-}

package/src/templates/samplePrepAdapters.ts

@@ -1,66 +0,0 @@
-import { getTemplateData } from './templateEnvelopes'
-import { validateSamplePrepData } from './templateValidators'
-import type {
-  SamplePrepColumnsAdapterResult,
-  SamplePrepDataFrameAdapterResult,
-  SamplePrepRowsAdapterResult,
-  SamplePrepTemplate,
-  SamplePrepTemplateData,
-} from './types'
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-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 ?? {}),
-    }))
-}
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-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 },
-  ]
-}
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-export function toSamplePrepDataFrame(
-  template: SamplePrepTemplate | SamplePrepTemplateData
-): SamplePrepDataFrameAdapterResult {
-  return {
-    data: toSamplePrepRows(template),
-    columns: toSamplePrepColumns(),
-    rowKey: 'id',
-  }
-}

package/src/templates/samplePrepBuilder.ts

@@ -1,52 +0,0 @@
-import { idFromName } from './builderIdUtils'
-import { normalizeSamplePrepStep } from './sampleNormalizers'
-import { createTemplateEnvelope } from './templateEnvelopes'
-import { validateSamplePrepData } from './templateValidators'
-import type {
-  CreateSamplePrepTemplateOptions,
-  SamplePrepStep,
-  SamplePrepTemplate,
-  SamplePrepTemplateData,
-} from './types'
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-export function createSamplePrepTemplate(
-  options: CreateSamplePrepTemplateOptions
-): SamplePrepTemplate {
-  const prepType = options.prepType ?? 'extraction'
-  const volumeUnit = options.volumeUnit ?? 'uL'
-  const steps: SamplePrepStep[] = []
-  let order = 1
-
-  for (const [index, sample] of options.samples.entries()) {
-    if (typeof sample !== 'string') {
-      const step = normalizeSamplePrepStep(sample, prepType, volumeUnit, order, index)
-      steps.push(step)
-      order = Math.max(order, step.order + 1)
-      continue
-    }
-    const sourceSampleId = idFromName(sample, `sample-${index + 1}`)
-    steps.push({
-      id: `${sourceSampleId}-prep`,
-      order,
-      type: prepType,
-      name: `Prepare ${sample}`,
-      sourceSampleId,
-      destinationSampleId: `${sourceSampleId}-prepared`,
-      inputVolume: options.inputVolume,
-      outputVolume: options.outputVolume,
-      volumeUnit,
-      status: 'planned',
-      metadata: {},
-    })
-    order += 1
-  }
-
-  const data: SamplePrepTemplateData = {
-    protocolName: options.protocolName ?? 'Sample preparation',
-    steps,
-    metadata: options.metadata ?? {},
-  }
-  validateSamplePrepData(data)
-  return createTemplateEnvelope('sample-prep', data, options.metadata ?? {})
-}

package/src/templates/sampleSheetAdapters.ts

@@ -1,79 +0,0 @@
-import type {
-  DataFrameColumn,
-  SelectOption,
-} from '../types'
-import { getTemplateData } from './templateEnvelopes'
-import { validateSampleSheetData } from './templateValidators'
-import type {
-  SampleColumnsAdapterResult,
-  SampleDataFrameAdapterResult,
-  SampleOptionsAdapterResult,
-  SampleRowsAdapterResult,
-  SampleSheetTemplate,
-  SampleSheetTemplateData,
-} from './types'
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-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 ?? {}),
-  }))
-}
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-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',
-  }))
-}
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-export function toSampleDataFrame(
-  template: SampleSheetTemplate | SampleSheetTemplateData
-): SampleDataFrameAdapterResult {
-  return {
-    data: toSampleRows(template),
-    columns: toSampleColumns(template),
-    rowKey: 'sampleId',
-  }
-}
-
-/** @deprecated Scheduled for removal from the core SDK in MINT 1.4; the biology templates move to a dedicated package or the owning plugins. */
-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,
-  }))
-}
-
-function sampleColumnKey(columnId: string): string {
-  const aliases: Record<string, string> = {
-    sample_id: 'sampleId',
-    plate_id: 'plateId',
-    well_id: 'wellId',
-  }
-  return aliases[columnId] ?? columnId
-}