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

package/src/templates/qpcrExpressionCollectionBuilder.ts

@@ -1,33 +0,0 @@
-import { createQpcrPlateTemplate } from './qpcrPlateBuilder'
-import { createSampleSheetTemplate } from './sampleSheetBuilder'
-import { presetSampleRecords } from './sampleNormalizers'
-import { createTemplateCollection } from './templateEnvelopes'
-import type {
-  CreateQpcrExpressionCollectionOptions,
-  TemplateCollectionEnvelope,
-} from './types'
-
-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,96 +0,0 @@
-import { idFromName } from './builderIdUtils'
-import { wellIdsForFormat } from './plateGeometry'
-import {
-  normalizeQpcrSample,
-  normalizeQpcrTarget,
-} from './runNormalizers'
-import { createTemplateEnvelope } from './templateEnvelopes'
-import { validateQpcrPlateData } from './templateValidators'
-import type {
-  CreateQpcrPlateTemplateOptions,
-  QpcrPlateTemplate,
-  QpcrPlateTemplateData,
-  QpcrReaction,
-  QpcrSample,
-  QpcrTarget,
-} from './types'
-
-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,77 +0,0 @@
-import { getTemplateData } from './templateEnvelopes'
-import { validateReagentListData } from './templateValidators'
-import type {
-  ReagentColumnsAdapterResult,
-  ReagentDataFrameAdapterResult,
-  ReagentListItemsAdapterResult,
-  ReagentListTemplate,
-  ReagentListTemplateData,
-  ReagentRowsAdapterResult,
-} from './types'
-
-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',
-  }
-}

package/src/templates/reagentListBuilder.ts

@@ -1,30 +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'
-
-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,63 +0,0 @@
-import { getTemplateData } from './templateEnvelopes'
-import { validateSamplePrepData } from './templateValidators'
-import type {
-  SamplePrepColumnsAdapterResult,
-  SamplePrepDataFrameAdapterResult,
-  SamplePrepRowsAdapterResult,
-  SamplePrepTemplate,
-  SamplePrepTemplateData,
-} from './types'
-
-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',
-  }
-}

package/src/templates/samplePrepBuilder.ts

@@ -1,51 +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'
-
-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,75 +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'
-
-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,
-  }))
-}
-
-function sampleColumnKey(columnId: string): string {
-  const aliases: Record<string, string> = {
-    sample_id: 'sampleId',
-    plate_id: 'plateId',
-    well_id: 'wellId',
-  }
-  return aliases[columnId] ?? columnId
-}

package/src/templates/sampleSheetBuilder.ts

@@ -1,23 +0,0 @@
-import { normalizeSampleRecord } from './sampleNormalizers'
-import { createTemplateEnvelope } from './templateEnvelopes'
-import { validateSampleSheetData } from './templateValidators'
-import type {
-  CreateSampleSheetTemplateOptions,
-  SampleSheetTemplate,
-  SampleSheetTemplateData,
-} from './types'
-
-export function createSampleSheetTemplate(
-  options: CreateSampleSheetTemplateOptions
-): SampleSheetTemplate {
-  const data: SampleSheetTemplateData = {
-    samples: options.samples.map(normalizeSampleRecord),
-    columns: options.columns ?? [
-      { id: 'sampleId', label: 'Sample ID', type: 'string', required: true, groupable: false },
-      { id: 'name', label: 'Name', type: 'string', required: false, groupable: false },
-    ],
-    groups: options.groups ?? [],
-  }
-  validateSampleSheetData(data)
-  return createTemplateEnvelope('sample-sheet', data, options.metadata ?? {})
-}

package/src/templates/targetedMetabolomicsCollectionBuilder.ts

@@ -1,79 +0,0 @@
-import { createAssayMatrixTemplate } from './assayMatrixBuilder'
-import { createCalibrationCurveTemplate } from './calibrationCurveBuilder'
-import { createInstrumentRunTemplate } from './instrumentRunBuilder'
-import { createReagentListTemplate } from './reagentListBuilder'
-import { createSamplePrepTemplate } from './samplePrepBuilder'
-import { createSampleSheetTemplate } from './sampleSheetBuilder'
-import { presetSampleRecords } from './sampleNormalizers'
-import {
-  firstFeatureName,
-  normalizeInternalStandardReagents,
-  normalizeMetaboliteFeatures,
-  targetedMetabolomicsRunItems,
-} from './targetedMetabolomicsHelpers'
-import { createTemplateCollection } from './templateEnvelopes'
-import type {
-  CreateTargetedMetabolomicsCollectionOptions,
-  TemplateCollectionEnvelope,
-} from './types'
-
-export function createTargetedMetabolomicsCollection(
-  options: CreateTargetedMetabolomicsCollectionOptions = {}
-): TemplateCollectionEnvelope {
-  const sampleRecords = presetSampleRecords(options.samples ?? ['S001', 'S002'])
-  const responseUnit = options.responseUnit ?? 'peak area ratio'
-  const concentrationUnit = options.concentrationUnit ?? 'uM'
-  const metaboliteFeatures = normalizeMetaboliteFeatures(
-    options.metabolites ?? ['Glucose', 'Lactate', 'Pyruvate'],
-    responseUnit,
-  )
-  const sampleSheet = createSampleSheetTemplate({ samples: sampleRecords })
-  const samplePrep = createSamplePrepTemplate({
-    samples: sampleRecords.map(sample => sample.sampleId),
-    prepType: options.prepType ?? 'extraction',
-    protocolName: 'Metabolomics sample preparation',
-    outputVolume: options.outputVolume ?? 50,
-    metadata: { assay: 'targeted-metabolomics' },
-  })
-  const reagents = createReagentListTemplate({
-    reagents: normalizeInternalStandardReagents(
-      options.internalStandards ?? ['Stable isotope internal standard mix'],
-    ),
-    metadata: { assay: 'targeted-metabolomics' },
-  })
-  const calibrationCurve = createCalibrationCurveTemplate({
-    concentrations: options.standardConcentrations ?? [0.1, 1, 10, 100],
-    analyte: options.calibrationAnalyte ?? firstFeatureName(metaboliteFeatures, 'Metabolite panel'),
-    unit: concentrationUnit,
-    responseUnit,
-    model: 'linear-weighted-1-x',
-    includeQc: options.includeQc,
-    metadata: { assay: 'targeted-metabolomics' },
-  })
-  const instrumentRun = createInstrumentRunTemplate({
-    items: targetedMetabolomicsRunItems(
-      sampleRecords,
-      calibrationCurve.data.points,
-      options.includeQc !== false,
-    ),
-    method: options.method ?? 'Targeted metabolomics',
-    instrument: options.instrument ?? 'LC-MS',
-    includeBlanks: false,
-    includeQc: false,
-    metadata: { assay: 'targeted-metabolomics' },
-  })
-  const assayMatrix = createAssayMatrixTemplate({
-    samples: sampleRecords.map(sample => ({
-      sampleId: sample.sampleId,
-      name: sample.name,
-      group: sample.group,
-      metadata: sample.metadata ?? {},
-    })),
-    features: metaboliteFeatures,
-    metadata: { assay: 'targeted-metabolomics', responseUnit },
-  })
-  return createTemplateCollection(
-    [sampleSheet, samplePrep, reagents, instrumentRun, calibrationCurve, assayMatrix],
-    { preset: 'targeted-metabolomics', ...(options.metadata ?? {}) }
-  )
-}