@morscherlab/mint-sdk 1.0.0-rc.2 → 1.0.0-rc.4

package/src/templates/instrumentRunAdapters.ts

@@ -0,0 +1,163 @@
+import type {
+  ProtocolStep,
+  ScheduleEvent,
+} from '../types'
+import { getTemplateData } from './templateEnvelopes'
+import { validateInstrumentRunData } from './templateValidators'
+import type {
+  InstrumentRunColumnsAdapterResult,
+  InstrumentRunDataFrameAdapterResult,
+  InstrumentRunRowsAdapterResult,
+  InstrumentRunScheduleEventsAdapterResult,
+  InstrumentRunStepsAdapterResult,
+  InstrumentRunTemplate,
+  InstrumentRunTemplateData,
+} from './types'
+import {
+  addMinutes,
+  dateFromMetadata,
+  instrumentRunScheduleColor,
+  instrumentRunScheduleStatus,
+  instrumentRunStepStatus,
+  instrumentRunStepType,
+} from './instrumentRunAdapterHelpers'
+
+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',
+  }
+}
+
+/** Convert an instrument-run template into ExperimentTimeline protocol steps for acquisition queue previews. */
+export function toInstrumentRunSteps(
+  template: InstrumentRunTemplate | InstrumentRunTemplateData
+): InstrumentRunStepsAdapterResult {
+  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): ProtocolStep => {
+      const method = methods.get(item.methodId)
+      const name = item.name ?? item.sampleId ?? item.kind
+      return {
+        id: item.id,
+        type: instrumentRunStepType(item.kind),
+        name,
+        description: [
+          item.kind,
+          method?.name,
+          item.vial ? `Vial ${item.vial}` : undefined,
+          item.wellId ? `Well ${item.wellId}` : undefined,
+        ]
+          .filter(Boolean)
+          .join(' / '),
+        duration: item.expectedDurationMin,
+        status: instrumentRunStepStatus(item.status),
+        parameters: {
+          kind: item.kind,
+          sampleId: item.sampleId,
+          methodId: item.methodId,
+          method: method?.name,
+          vial: item.vial,
+          plateId: item.plateId,
+          wellId: item.wellId,
+          injectionVolume: item.injectionVolume,
+          instrument: data.instrument ?? method?.instrument,
+        },
+        order: item.order,
+      }
+    })
+}
+
+/** Convert an instrument-run template into readonly ScheduleCalendar events ordered by run queue timing. */
+export function toInstrumentRunScheduleEvents(
+  template: InstrumentRunTemplate | InstrumentRunTemplateData
+): InstrumentRunScheduleEventsAdapterResult {
+  const data = getTemplateData(template, 'instrument-run')
+  validateInstrumentRunData(data)
+  const methods = new Map(data.methods.map(method => [method.id, method]))
+  let cursor = dateFromMetadata(data.metadata, ['scheduledStart', 'runStart', 'start', 'startedAt'])
+    ?? new Date('2024-01-01T08:00:00.000Z')
+
+  return [...data.items]
+    .sort((a, b) => a.order - b.order)
+    .map((item): ScheduleEvent => {
+      const method = methods.get(item.methodId)
+      const start = dateFromMetadata(item.metadata, ['scheduledStart', 'start', 'startedAt']) ?? cursor
+      const end = dateFromMetadata(item.metadata, ['scheduledEnd', 'end', 'completedAt'])
+        ?? addMinutes(start, Math.max(item.expectedDurationMin ?? 10, 1))
+      cursor = end
+
+      return {
+        id: item.id,
+        title: item.name ?? item.sampleId ?? item.kind,
+        start: start.toISOString(),
+        end: end.toISOString(),
+        color: instrumentRunScheduleColor(item.kind),
+        status: instrumentRunScheduleStatus(item.status),
+        draggable: false,
+        resizable: false,
+        metadata: {
+          kind: item.kind,
+          sampleId: item.sampleId,
+          methodId: item.methodId,
+          method: method?.name,
+          vial: item.vial,
+          plateId: item.plateId,
+          wellId: item.wellId,
+          injectionVolume: item.injectionVolume,
+          instrument: data.instrument ?? method?.instrument,
+        },
+      }
+    })
+}

package/src/templates/instrumentRunBuilder.ts

@@ -0,0 +1,97 @@
+import { idFromName } from './builderIdUtils'
+import {
+  normalizeInstrumentMethod,
+  normalizeInstrumentRunItem,
+} from './runNormalizers'
+import { createTemplateEnvelope } from './templateEnvelopes'
+import { validateInstrumentRunData } from './templateValidators'
+import type {
+  CreateInstrumentRunTemplateOptions,
+  InstrumentRunItem,
+  InstrumentRunTemplate,
+  InstrumentRunTemplateData,
+} from './types'
+
+export function createInstrumentRunTemplate(
+  options: CreateInstrumentRunTemplateOptions
+): InstrumentRunTemplate {
+  const method = typeof options.method === 'string' || options.method === undefined
+    ? {
+        id: idFromName(options.method ?? 'Default method', 'method-1'),
+        name: options.method ?? 'Default method',
+        instrument: options.instrument,
+        metadata: {},
+      }
+    : normalizeInstrumentMethod(options.method, options.instrument)
+  const items: InstrumentRunItem[] = []
+  let order = 1
+
+  if (options.includeBlanks !== false) {
+    items.push({
+      id: 'blank-start',
+      order,
+      kind: 'blank',
+      name: 'Blank start',
+      methodId: method.id,
+      status: 'planned',
+      metadata: {},
+    })
+    order += 1
+  }
+
+  if (options.includeQc !== false) {
+    items.push({
+      id: 'qc-start',
+      order,
+      kind: 'qc',
+      name: 'QC start',
+      methodId: method.id,
+      status: 'planned',
+      metadata: {},
+    })
+    order += 1
+  }
+
+  for (const [index, item] of options.items.entries()) {
+    if (typeof item !== 'string') {
+      const normalized = normalizeInstrumentRunItem(item, method.id, order, index)
+      items.push(normalized)
+      order = Math.max(order, normalized.order + 1)
+      continue
+    }
+    const sampleId = idFromName(item, `sample-${index + 1}`)
+    items.push({
+      id: `${sampleId}-run`,
+      order,
+      kind: 'sample',
+      sampleId,
+      name: item,
+      methodId: method.id,
+      status: 'planned',
+      metadata: {},
+    })
+    order += 1
+  }
+
+  if (options.includeQc !== false) {
+    items.push({
+      id: 'qc-end',
+      order,
+      kind: 'qc',
+      name: 'QC end',
+      methodId: method.id,
+      status: 'planned',
+      metadata: {},
+    })
+  }
+
+  const data: InstrumentRunTemplateData = {
+    runId: 'run-1',
+    instrument: options.instrument,
+    methods: [method],
+    items,
+    metadata: options.metadata ?? {},
+  }
+  validateInstrumentRunData(data)
+  return createTemplateEnvelope('instrument-run', data, options.metadata ?? {})
+}

package/src/templates/lcmsBatchCollectionBuilder.ts

@@ -0,0 +1,38 @@
+import { createAssayMatrixTemplate } from './assayMatrixBuilder'
+import { createInstrumentRunTemplate } from './instrumentRunBuilder'
+import { createSampleSheetTemplate } from './sampleSheetBuilder'
+import { presetSampleRecords } from './sampleNormalizers'
+import { createTemplateCollection } from './templateEnvelopes'
+import type {
+  CreateLcmsBatchCollectionOptions,
+  TemplateCollectionEnvelope,
+} from './types'
+
+export function createLcmsBatchCollection(
+  options: CreateLcmsBatchCollectionOptions = {}
+): TemplateCollectionEnvelope {
+  const sampleRecords = presetSampleRecords(options.samples ?? ['S001', 'S002'])
+  const sampleSheet = createSampleSheetTemplate({ samples: sampleRecords })
+  const instrumentRun = createInstrumentRunTemplate({
+    items: sampleRecords.map(sample => ({
+      sampleId: sample.sampleId,
+      name: sample.name ?? sample.sampleId,
+    })),
+    method: options.method ?? 'Default method',
+    instrument: options.instrument ?? 'LC-MS',
+    includeQc: options.includeQc,
+  })
+  const assayMatrix = createAssayMatrixTemplate({
+    samples: sampleRecords.map(sample => ({
+      sampleId: sample.sampleId,
+      name: sample.name,
+      group: sample.group,
+      metadata: sample.metadata ?? {},
+    })),
+    features: options.features ?? ['Glucose', 'Lactate'],
+  })
+  return createTemplateCollection(
+    [sampleSheet, instrumentRun, assayMatrix],
+    { preset: 'lcms-batch', ...(options.metadata ?? {}) }
+  )
+}

package/src/templates/plateGeometry.ts

@@ -0,0 +1,62 @@
+import type { WellPlateFormat } from '../types'
+
+const PLATE_DIMENSIONS: Record<number, readonly [number, number]> = {
+  6: [2, 3],
+  12: [3, 4],
+  24: [4, 6],
+  48: [6, 8],
+  54: [6, 9],
+  96: [8, 12],
+  384: [16, 24],
+}
+
+export function wellIdsForFormat(format: number): string[] {
+  const dimensions = PLATE_DIMENSIONS[format]
+  if (!dimensions) {
+    throw new Error(`Unsupported plate format '${format}'.`)
+  }
+  const [rows, cols] = dimensions
+  return Array.from({ length: rows }, (_, row) =>
+    Array.from({ length: cols }, (_col, col) => `${rowLabel(row)}${col + 1}`)
+  ).flat()
+}
+
+export function assertWellInFormat(wellId: string, format: number): void {
+  const dimensions = PLATE_DIMENSIONS[format]
+  if (!dimensions) {
+    throw new Error(`Unsupported plate format '${format}'.`)
+  }
+  const match = /^([A-Z]+)([1-9][0-9]*)$/.exec(wellId.toUpperCase())
+  if (!match) {
+    throw new Error(`Invalid well id '${wellId}'.`)
+  }
+  const row = rowIndex(match[1])
+  const col = Number(match[2]) - 1
+  const [rows, cols] = dimensions
+  if (row < 0 || col < 0 || row >= rows || col >= cols) {
+    throw new Error(`Well '${wellId}' is outside a ${format}-well plate.`)
+  }
+}
+
+export function readPlateFormat(value: unknown, fallback: WellPlateFormat): WellPlateFormat {
+  const parsed = typeof value === 'number'
+    ? value
+    : typeof value === 'string'
+      ? Number(value)
+      : Number.NaN
+  return parsed in PLATE_DIMENSIONS ? (parsed as WellPlateFormat) : fallback
+}
+
+function rowLabel(index: number): string {
+  let label = ''
+  let current = index
+  while (true) {
+    label = String.fromCharCode(65 + (current % 26)) + label
+    current = Math.floor(current / 26) - 1
+    if (current < 0) return label
+  }
+}
+
+function rowIndex(label: string): number {
+  return [...label].reduce((value, char) => value * 26 + char.charCodeAt(0) - 64, 0) - 1
+}

package/src/templates/plateMapAdapters.ts

@@ -0,0 +1,36 @@
+import type {
+  PlateMapEditorState,
+} from '../types'
+import { getTemplateData } from './templateEnvelopes'
+import { validatePlateMapData } from './templateValidators'
+import type {
+  PlateMapEditorAdapterResult,
+  PlateMapTemplate,
+  PlateMapTemplateData,
+  WellMapAdapterResult,
+} from './types'
+
+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
+}

package/src/templates/plateMapBuilder.ts

@@ -0,0 +1,43 @@
+import { DEFAULT_SAMPLE_COLORS } from './builderDefaults'
+import { sampleIdFromName } from './builderIdUtils'
+import { createTemplateEnvelope } from './templateEnvelopes'
+import type {
+  CreatePlateMapTemplateOptions,
+  PlateMapTemplate,
+  TemplateSample,
+} from './types'
+
+export function createPlateMapTemplate(
+  options: CreatePlateMapTemplateOptions = {}
+): PlateMapTemplate {
+  const {
+    id = 'plate-1',
+    name = 'Plate 1',
+    format = 96,
+    samples = [],
+    metadata = {},
+  } = options
+
+  const sampleDefinitions = samples.map((sample, index): TemplateSample => {
+    if (typeof sample !== 'string') return sample
+    return {
+      id: sampleIdFromName(sample, index),
+      name: sample,
+      color: DEFAULT_SAMPLE_COLORS[index % DEFAULT_SAMPLE_COLORS.length],
+    }
+  })
+
+  return createTemplateEnvelope('plate-map', {
+    plates: [
+      {
+        id,
+        name,
+        format,
+        wells: {},
+      },
+    ],
+    samples: sampleDefinitions,
+    activePlateId: id,
+    selectedWells: [],
+  }, metadata)
+}

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>