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

package/src/templates/builders.ts

@@ -1,122 +0,0 @@
-export {
-  bioTemplatePresetControlValuesToOptions,
-} from './builderPresetControls'
-
-export type {
-  BioTemplateControlValues,
-} from './builderPresetControls'
-
-export {
-  createPlateMapTemplate,
-} from './plateMapBuilder'
-
-export {
-  createSampleSheetTemplate,
-} from './sampleSheetBuilder'
-
-export {
-  createSamplePrepTemplate,
-} from './samplePrepBuilder'
-
-export {
-  createDoseResponseTemplate,
-} from './doseResponseBuilder'
-
-export {
-  createCalibrationCurveTemplate,
-} from './calibrationCurveBuilder'
-
-export {
-  createTimeCourseTemplate,
-} from './timeCourseBuilder'
-
-export {
-  createProtocolStepsTemplate,
-} from './protocolStepsBuilder'
-
-export {
-  createAssayMatrixTemplate,
-} from './assayMatrixBuilder'
-
-export {
-  createReagentListTemplate,
-} from './reagentListBuilder'
-
-export {
-  createFlowCytometryPanelTemplate,
-} from './flowCytometryPanelBuilder'
-
-export {
-  createInstrumentRunTemplate,
-} from './instrumentRunBuilder'
-
-export {
-  createQpcrPlateTemplate,
-} from './qpcrPlateBuilder'
-
-export {
-  createQpcrExpressionCollection,
-} from './qpcrExpressionCollectionBuilder'
-
-export {
-  createLcmsBatchCollection,
-} from './lcmsBatchCollectionBuilder'
-
-export {
-  createTargetedMetabolomicsCollection,
-} from './targetedMetabolomicsCollectionBuilder'
-
-export {
-  createElisaAssayCollection,
-} from './elisaAssayCollectionBuilder'
-
-export {
-  createFlowCytometryAssayCollection,
-} from './flowCytometryAssayCollectionBuilder'
-
-export {
-  createWesternBlotAssayCollection,
-} from './westernBlotAssayCollectionBuilder'
-
-export {
-  createDefaultBioTemplate,
-} from './defaultBioTemplateBuilder'
-
-export {
-  createBioTemplatePackCollection,
-} from './templatePackCollectionBuilder'
-
-export {
-  createWellPlateScreenCollection,
-} from './wellPlateScreenCollectionBuilder'
-
-export {
-  createBioTemplatePresetCollection,
-  createBioTemplatePresetCollectionFromControls,
-} from './templatePresetCollectionBuilder'
-
-export {
-  assertTemplateEnvelope,
-  createTemplateCollection,
-  createTemplateEnvelope,
-  ensureTemplateEnvelope,
-  ensureTemplateFromCollection,
-  extractTemplateCollection,
-  getTemplateData,
-  TEMPLATE_COLLECTION_KEY,
-} from './templateEnvelopes'
-
-export {
-  validateAssayMatrixData,
-  validateCalibrationCurveData,
-  validateDoseResponseData,
-  validateFlowCytometryPanelData,
-  validateInstrumentRunData,
-  validatePlateMapData,
-  validateProtocolStepsData,
-  validateQpcrPlateData,
-  validateReagentListData,
-  validateSamplePrepData,
-  validateSampleSheetData,
-  validateTimeCourseData,
-} from './templateValidators'

package/src/templates/calibrationCurveAdapters.ts

@@ -1,59 +0,0 @@
-import { getTemplateData } from './templateEnvelopes'
-import { validateCalibrationCurveData } from './templateValidators'
-import type {
-  CalibrationCurveColumnsAdapterResult,
-  CalibrationCurveDataFrameAdapterResult,
-  CalibrationCurveRowsAdapterResult,
-  CalibrationCurveTemplate,
-  CalibrationCurveTemplateData,
-} from './types'
-
-export function toCalibrationCurveRows(
-  template: CalibrationCurveTemplate | CalibrationCurveTemplateData
-): CalibrationCurveRowsAdapterResult {
-  const data = getTemplateData(template, 'calibration-curve')
-  validateCalibrationCurveData(data)
-  return [...data.points]
-    .sort((a, b) => a.order - b.order)
-    .map(point => ({
-      id: point.id,
-      order: point.order,
-      role: point.role,
-      level: point.level,
-      concentration: point.concentration,
-      unit: point.unit,
-      expectedResponse: point.expectedResponse,
-      response: point.response,
-      replicate: point.replicate,
-      include: point.include,
-      status: point.status,
-      analyte: data.analyte,
-      model: data.model,
-      ...(point.metadata ?? {}),
-    }))
-}
-
-export function toCalibrationCurveColumns(): CalibrationCurveColumnsAdapterResult {
-  return [
-    { key: 'order', label: 'Order', sortable: true, align: 'right' },
-    { key: 'role', label: 'Role', sortable: true },
-    { key: 'level', label: 'Level', sortable: true },
-    { key: 'concentration', label: 'Concentration', sortable: true, align: 'right' },
-    { key: 'unit', label: 'Unit', sortable: true },
-    { key: 'expectedResponse', label: 'Expected', sortable: true, align: 'right' },
-    { key: 'response', label: 'Response', sortable: true, align: 'right' },
-    { key: 'replicate', label: 'Replicate', sortable: true, align: 'right' },
-    { key: 'include', label: 'Include', sortable: true },
-    { key: 'status', label: 'Status', sortable: true },
-  ]
-}
-
-export function toCalibrationCurveDataFrame(
-  template: CalibrationCurveTemplate | CalibrationCurveTemplateData
-): CalibrationCurveDataFrameAdapterResult {
-  return {
-    data: toCalibrationCurveRows(template),
-    columns: toCalibrationCurveColumns(),
-    rowKey: 'id',
-  }
-}

package/src/templates/calibrationCurveBuilder.ts

@@ -1,99 +0,0 @@
-import { idFromName } from './builderIdUtils'
-import {
-  normalizeCalibrationAcceptance,
-  normalizeCalibrationPoint,
-} from './calibrationNormalizers'
-import { createTemplateEnvelope } from './templateEnvelopes'
-import { validateCalibrationCurveData } from './templateValidators'
-import type {
-  CalibrationCurveTemplate,
-  CalibrationCurveTemplateData,
-  CalibrationPoint,
-  CreateCalibrationCurveTemplateOptions,
-} from './types'
-
-export function createCalibrationCurveTemplate(
-  options: CreateCalibrationCurveTemplateOptions
-): CalibrationCurveTemplate {
-  const unit = options.unit ?? 'uM'
-  const points: CalibrationPoint[] = []
-  let order = 1
-
-  if (options.includeBlank !== false) {
-    points.push({
-      id: 'blank',
-      order,
-      role: 'blank',
-      level: 'Blank',
-      concentration: 0,
-      unit,
-      replicate: 1,
-      include: true,
-      status: 'planned',
-      metadata: {},
-    })
-    order += 1
-  }
-
-  const standardValues: number[] = []
-  for (const [index, concentration] of options.concentrations.entries()) {
-    if (typeof concentration !== 'number') {
-      const point = normalizeCalibrationPoint(concentration, unit, order, index)
-      points.push(point)
-      if (point.role === 'standard') standardValues.push(point.concentration)
-      order = Math.max(order, point.order + 1)
-      continue
-    }
-    standardValues.push(concentration)
-    points.push({
-      id: `std-${index + 1}`,
-      order,
-      role: 'standard',
-      level: `Standard ${index + 1}`,
-      concentration,
-      unit,
-      replicate: 1,
-      include: true,
-      status: 'planned',
-      metadata: {},
-    })
-    order += 1
-  }
-
-  if (options.includeQc !== false) {
-    const positiveValues = [...standardValues].filter(value => value > 0).sort((a, b) => a - b)
-    const qcValues = positiveValues.length === 0
-      ? []
-      : positiveValues[0] === positiveValues[positiveValues.length - 1]
-        ? [positiveValues[0]]
-        : [positiveValues[0], positiveValues[positiveValues.length - 1]]
-    for (const [index, concentration] of qcValues.entries()) {
-      const level = index === 0 ? 'QC low' : 'QC high'
-      points.push({
-        id: idFromName(level, `qc-${index + 1}`),
-        order,
-        role: 'qc',
-        level,
-        concentration,
-        unit,
-        replicate: 1,
-        include: true,
-        status: 'planned',
-        metadata: {},
-      })
-      order += 1
-    }
-  }
-
-  const data: CalibrationCurveTemplateData = {
-    analyte: options.analyte ?? 'Analyte',
-    model: options.model ?? 'linear',
-    xUnit: unit,
-    responseUnit: options.responseUnit ?? 'response',
-    points,
-    acceptance: normalizeCalibrationAcceptance(options.acceptance, options.includeBlank !== false),
-    metadata: options.metadata ?? {},
-  }
-  validateCalibrationCurveData(data)
-  return createTemplateEnvelope('calibration-curve', data, options.metadata ?? {})
-}

package/src/templates/calibrationNormalizers.ts

@@ -1,60 +0,0 @@
-import type {
-  CalibrationAcceptance,
-  CalibrationPoint,
-  CalibrationPointInput,
-  CompoundDoseSeries,
-  ControlDefinition,
-} from './types'
-import { idFromName } from './builderIdUtils'
-
-export function normalizeCompound(compound: CompoundDoseSeries): CompoundDoseSeries {
-  return {
-    ...compound,
-    concentrations: [...compound.concentrations].sort((a, b) => b - a),
-    metadata: compound.metadata ?? {},
-  }
-}
-
-export function normalizeCalibrationAcceptance(
-  acceptance?: Partial<CalibrationAcceptance>,
-  requireBlank = true
-): CalibrationAcceptance {
-  return {
-    minRSquared: acceptance?.minRSquared ?? 0.99,
-    standardTolerancePercent: acceptance?.standardTolerancePercent ?? 15,
-    qcTolerancePercent: acceptance?.qcTolerancePercent ?? 20,
-    requireBlank: acceptance?.requireBlank ?? requireBlank,
-    metadata: acceptance?.metadata ?? {},
-  }
-}
-
-export function normalizeCalibrationPoint(
-  point: CalibrationPointInput,
-  unit: string,
-  order: number,
-  index: number
-): CalibrationPoint {
-  const role = point.role ?? 'standard'
-  const level = point.level || `${role.charAt(0).toUpperCase()}${role.slice(1)} ${index + 1}`
-  return {
-    id: point.id || idFromName(level, `${role}-${index + 1}`),
-    order: point.order ?? order,
-    role,
-    level,
-    concentration: point.concentration ?? 0,
-    unit: point.unit || unit,
-    expectedResponse: point.expectedResponse,
-    response: point.response,
-    replicate: point.replicate ?? 1,
-    include: point.include ?? true,
-    status: point.status ?? 'planned',
-    metadata: point.metadata ?? {},
-  }
-}
-
-export function normalizeControl(control: ControlDefinition): ControlDefinition {
-  return {
-    ...control,
-    metadata: control.metadata ?? {},
-  }
-}

package/src/templates/catalog.ts

@@ -1,245 +0,0 @@
-import type { TemplateId } from './types'
-
-import { templateIdentifierMatches, templateSearchMatches } from './lookup'
-
-export interface BioTemplateCatalogEntry {
-  name: TemplateId
-  template_id: TemplateId
-  template_version: string
-  label: string
-  category: 'bio-data'
-  purpose: string
-  aliases: readonly string[]
-  python_import: string
-  python_example: string
-  frontend_import: string
-  frontend_adapters: readonly string[]
-  components: readonly string[]
-  add_command: string
-}
-
-export const bioTemplateCatalog = [
-  {
-    name: 'plate-map',
-    template_id: 'plate-map',
-    template_version: '1.0',
-    label: 'Plate map',
-    category: 'bio-data',
-    purpose: 'Plate layout, wells, sample assignments, and sample legend data.',
-    aliases: ['wellplate', 'well-plate', 'plate layout', 'plate-map editor'],
-    python_import: 'from mint_sdk.templates import PlateMapTemplate, save_template',
-    python_example: 'PlateMapTemplate.create_96_well(name="Plate 1", samples=["Control", "Treatment"])',
-    frontend_import: "import { toPlateMapEditorState, toWellPlateWells } from '@morscherlab/mint-sdk/templates'",
-    frontend_adapters: ['toPlateMapEditorState', 'toWellPlateWells'],
-    components: ['PlateMapEditor', 'WellPlate', 'SampleLegend'],
-    add_command: 'mint add data-template plate-map --page',
-  },
-  {
-    name: 'sample-sheet',
-    template_id: 'sample-sheet',
-    template_version: '1.0',
-    label: 'Sample sheet',
-    category: 'bio-data',
-    purpose: 'Tabular sample metadata, display columns, and group definitions.',
-    aliases: ['sample metadata', 'sample table', 'metadata sheet', 'csv samples'],
-    python_import: 'from mint_sdk.templates import SampleSheetTemplate, save_template',
-    python_example: 'SampleSheetTemplate.from_rows([{"sample_id": "S001", "name": "Control 1", "group": "Control"}])',
-    frontend_import: "import { toTemplateDataFrame, toSampleOptions } from '@morscherlab/mint-sdk/templates'",
-    frontend_adapters: ['toTemplateDataFrame', 'toSampleDataFrame', 'toSampleRows', 'toSampleColumns', 'toSampleOptions'],
-    components: ['DataFrame', 'SampleSelector', 'AutoGroupModal', 'GroupAssigner'],
-    add_command: 'mint add data-template sample-sheet --page',
-  },
-  {
-    name: 'sample-prep',
-    template_id: 'sample-prep',
-    template_version: '1.0',
-    label: 'Sample prep',
-    category: 'bio-data',
-    purpose: 'Extraction, dilution, normalization, transfer, source/destination, volume, reagent, and status steps.',
-    aliases: ['sample preparation', 'extraction', 'dilution', 'normalization', 'prep steps'],
-    python_import: 'from mint_sdk.templates import SamplePrepTemplate, save_template',
-    python_example: 'SamplePrepTemplate.create(["S001", "S002"], prep_type="extraction", output_volume=50)',
-    frontend_import: "import { toSamplePrepDataFrame, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
-    frontend_adapters: ['toTemplateDataFrame', 'toSamplePrepDataFrame', 'toSamplePrepRows', 'toSamplePrepColumns'],
-    components: ['DataFrame', 'ProtocolStepEditor', 'SampleSelector', 'WellPlate'],
-    add_command: 'mint add data-template sample-prep --page',
-  },
-  {
-    name: 'dose-response',
-    template_id: 'dose-response',
-    template_version: '1.0',
-    label: 'Dose response',
-    category: 'bio-data',
-    purpose: 'Compounds, concentration series, controls, replicates, and optional plate layout.',
-    aliases: [
-      'drug response',
-      'concentration series',
-      'dose curve',
-      'dose design',
-      'dose planner',
-      'dose calculator',
-      'drp',
-    ],
-    python_import: 'from mint_sdk.templates import ControlDefinition, DoseResponseTemplate, save_template',
-    python_example: 'DoseResponseTemplate.create({"Compound A": [10, 1, 0.1]}, unit="uM", replicates=3)',
-    frontend_import: "import { toDoseConditions, toDoseLayoutState } from '@morscherlab/mint-sdk/templates'",
-    frontend_adapters: ['toDoseConditions', 'toDoseLayoutState'],
-    components: ['DoseCalculator', 'ReagentEditor', 'WellPlate'],
-    add_command: 'mint add data-template dose-response --page',
-  },
-  {
-    name: 'calibration-curve',
-    template_id: 'calibration-curve',
-    template_version: '1.0',
-    label: 'Calibration curve',
-    category: 'bio-data',
-    purpose: 'Standard curves, blank/QC points, fitted model settings, and acceptance thresholds.',
-    aliases: ['standard curve', 'calibration', 'quantitation', 'qc acceptance', 'calibrator'],
-    python_import: 'from mint_sdk.templates import CalibrationCurveTemplate, save_template',
-    python_example: 'CalibrationCurveTemplate.create([0.1, 1, 10, 100], analyte="Glucose", unit="uM")',
-    frontend_import: "import { toCalibrationCurveDataFrame, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
-    frontend_adapters: ['toTemplateDataFrame', 'toCalibrationCurveDataFrame', 'toCalibrationCurveRows', 'toCalibrationCurveColumns'],
-    components: ['DataFrame', 'FitPanel', 'ChartContainer'],
-    add_command: 'mint add data-template calibration-curve --page',
-  },
-  {
-    name: 'time-course',
-    template_id: 'time-course',
-    template_version: '1.0',
-    label: 'Time course',
-    category: 'bio-data',
-    purpose: 'Longitudinal time points, conditions, replicates, and scheduled samples.',
-    aliases: ['longitudinal', 'time series', 'sampling schedule', 'kinetics'],
-    python_import: 'from mint_sdk.templates import TimeCourseTemplate, save_template',
-    python_example: 'TimeCourseTemplate.create([0, 6, 24], unit="hour", conditions=["Control", "Treatment"], replicates=3)',
-    frontend_import: "import { toTemplateDataFrame, toTimeCourseSteps } from '@morscherlab/mint-sdk/templates'",
-    frontend_adapters: ['toTemplateDataFrame', 'toTimeCourseDataFrame', 'toTimeCourseRows', 'toTimeCourseSteps', 'toTimeCourseColumns'],
-    components: ['ExperimentTimeline', 'DataFrame', 'ScheduleCalendar'],
-    add_command: 'mint add data-template time-course --page',
-  },
-  {
-    name: 'protocol-steps',
-    template_id: 'protocol-steps',
-    template_version: '1.0',
-    label: 'Protocol steps',
-    category: 'bio-data',
-    purpose: 'Ordered experiment protocol steps, durations, statuses, and run-sheet parameters.',
-    aliases: ['protocol', 'run sheet', 'workflow', 'method steps', 'sop'],
-    python_import: 'from mint_sdk.templates import ProtocolStepsTemplate, save_template',
-    python_example: 'ProtocolStepsTemplate.create(["Seed cells", "Add treatment", "Measure viability"])',
-    frontend_import: "import { toProtocolSteps, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
-    frontend_adapters: ['toTemplateDataFrame', 'toProtocolSteps', 'toProtocolDataFrame'],
-    components: ['ExperimentTimeline', 'ProtocolStepEditor', 'DataFrame'],
-    add_command: 'mint add data-template protocol-steps --page',
-  },
-  {
-    name: 'assay-matrix',
-    template_id: 'assay-matrix',
-    template_version: '1.0',
-    label: 'Assay matrix',
-    category: 'bio-data',
-    purpose: 'Sample-by-feature measurement matrices for omics, plate-reader, and marker assays.',
-    aliases: ['omics matrix', 'measurement matrix', 'readout matrix', 'feature table'],
-    python_import: 'from mint_sdk.templates import AssayMatrixTemplate, save_template',
-    python_example: 'AssayMatrixTemplate.create(samples=["S001", "S002"], features=["Lactate", "Glucose"])',
-    frontend_import: "import { toAssayMatrixSampleOptions, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
-    frontend_adapters: ['toTemplateDataFrame', 'toAssayMatrixDataFrame', 'toAssayMatrixRows', 'toAssayMatrixColumns', 'toAssayMatrixSampleOptions'],
-    components: ['DataFrame', 'ChartContainer', 'SampleSelector'],
-    add_command: 'mint add data-template assay-matrix --page',
-  },
-  {
-    name: 'reagent-list',
-    template_id: 'reagent-list',
-    template_version: '1.0',
-    label: 'Reagent list',
-    category: 'bio-data',
-    purpose: 'Experiment reagents, catalog numbers, lots, storage, locations, and stock status.',
-    aliases: ['reagents', 'inventory', 'antibodies', 'primers', 'compound stocks'],
-    python_import: 'from mint_sdk.templates import ReagentListTemplate, save_template',
-    python_example: 'ReagentListTemplate.create(["DMSO", "Compound A", "Anti-HA antibody"])',
-    frontend_import: "import { toReagentListItems, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
-    frontend_adapters: ['toTemplateDataFrame', 'toReagentDataFrame', 'toReagentListItems'],
-    components: ['ReagentList', 'DataFrame', 'ReagentEditor'],
-    add_command: 'mint add data-template reagent-list --page',
-  },
-  {
-    name: 'flow-cytometry-panel',
-    template_id: 'flow-cytometry-panel',
-    template_version: '1.0',
-    label: 'Flow cytometry panel',
-    category: 'bio-data',
-    purpose: 'Flow-cytometry markers, fluorophores, detectors, compensation controls, and panel metadata.',
-    aliases: ['flow panel', 'facs panel', 'cytometry panel', 'antibody panel'],
-    python_import: 'from mint_sdk.templates import FlowCytometryPanelTemplate, save_template',
-    python_example: 'FlowCytometryPanelTemplate.create(["CD3", "CD4", "CD8"], instrument="BD LSRFortessa")',
-    frontend_import: "import { toFlowPanelDataFrame, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
-    frontend_adapters: ['toTemplateDataFrame', 'toFlowPanelDataFrame', 'toFlowPanelRows', 'toFlowPanelColumns'],
-    components: ['DataFrame', 'ReagentList', 'SampleSelector'],
-    add_command: 'mint add data-template flow-cytometry-panel --page',
-  },
-  {
-    name: 'instrument-run',
-    template_id: 'instrument-run',
-    template_version: '1.0',
-    label: 'Instrument run',
-    category: 'bio-data',
-    purpose: 'Instrument sequence tables, sample queues, methods, QC, blanks, and acquisition status.',
-    aliases: ['run queue', 'sequence table', 'sample queue', 'lcms run', 'instrument sequence', 'batch run'],
-    python_import: 'from mint_sdk.templates import InstrumentRunTemplate, save_template',
-    python_example: 'InstrumentRunTemplate.create(["S001", "S002"], instrument="LC-MS")',
-    frontend_import: "import { toInstrumentRunDataFrame, toInstrumentRunScheduleEvents, toInstrumentRunSteps, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
-    frontend_adapters: ['toTemplateDataFrame', 'toInstrumentRunDataFrame', 'toInstrumentRunRows', 'toInstrumentRunColumns', 'toInstrumentRunSteps', 'toInstrumentRunScheduleEvents'],
-    components: ['DataFrame', 'ExperimentTimeline', 'ScheduleCalendar', 'SampleSelector'],
-    add_command: 'mint add data-template instrument-run --page',
-  },
-  {
-    name: 'qpcr-plate',
-    template_id: 'qpcr-plate',
-    template_version: '1.0',
-    label: 'qPCR plate',
-    category: 'bio-data',
-    purpose: 'qPCR/ddPCR plate layouts, samples, targets, replicate reactions, controls, and Cq fields.',
-    aliases: ['qpcr', 'qPCR', 'ddpcr', 'rt-qpcr', 'gene expression', 'primer plate'],
-    python_import: 'from mint_sdk.templates import QpcrPlateTemplate, save_template',
-    python_example: 'QpcrPlateTemplate.create(samples=["Control", "Treatment"], targets=["ACTB", "GAPDH"], replicates=3)',
-    frontend_import: "import { toQpcrDataFrame, toQpcrWellPlateWells, toTemplateDataFrame } from '@morscherlab/mint-sdk/templates'",
-    frontend_adapters: ['toTemplateDataFrame', 'toQpcrDataFrame', 'toQpcrRows', 'toQpcrColumns', 'toQpcrWellPlateWells'],
-    components: ['DataFrame', 'WellPlate', 'SampleSelector'],
-    add_command: 'mint add data-template qpcr-plate --page',
-  },
-] as const satisfies readonly BioTemplateCatalogEntry[]
-
-export function listBioTemplateCatalog(): readonly BioTemplateCatalogEntry[] {
-  return bioTemplateCatalog
-}
-
-export function getBioTemplateInfo(name: string): BioTemplateCatalogEntry | undefined {
-  return bioTemplateCatalog.find(entry => {
-    const identifiers = [
-      entry.name,
-      entry.template_id,
-      entry.label,
-      ...entry.aliases,
-    ]
-    return templateIdentifierMatches(name, identifiers)
-  })
-}
-
-export function searchBioTemplateCatalog(query: string): readonly BioTemplateCatalogEntry[] {
-  const normalized = query.trim().toLowerCase()
-  if (!normalized) return bioTemplateCatalog
-
-  return bioTemplateCatalog.filter(entry => templateSearchMatches(normalized, [
-    entry.name,
-    entry.template_id,
-    entry.label,
-    entry.purpose,
-    entry.python_import,
-    entry.python_example,
-    entry.frontend_import,
-    entry.add_command,
-    ...entry.aliases,
-    ...entry.frontend_adapters,
-    ...entry.components,
-  ]))
-}

package/src/templates/componentBindingCatalog.ts

@@ -1,90 +0,0 @@
-import type { TemplateId } from './types'
-
-interface ComponentBinding {
-  id: string
-  template_id: TemplateId
-  component: string
-  adapters: readonly string[]
-  props: readonly string[]
-  description: string
-  importPath: '@morscherlab/mint-sdk'
-}
-
-export const templateComponentBindings = {
-  'plate-map': [
-    binding('plate-map', 'PlateMapEditor', ['toPlateMapEditorState'], ['modelValue', 'format', 'samples'], 'Edit plate layouts from plate-map template data.'),
-    binding('plate-map', 'WellPlate', ['toWellPlateWells'], ['format', 'wells', 'sampleColors', 'legendItems'], 'Render the active plate as a well grid.'),
-  ],
-  'sample-sheet': [
-    binding('sample-sheet', 'DataFrame', ['toTemplateDataFrame'], ['data', 'columns', 'rowKey'], 'Render sample metadata as a sortable table.'),
-    binding('sample-sheet', 'SampleSelector', ['toSampleOptions'], ['samples', 'modelValue'], 'Select samples from sample-sheet records.'),
-  ],
-  'sample-prep': [
-    binding('sample-prep', 'DataFrame', ['toTemplateDataFrame'], ['data', 'columns', 'rowKey'], 'Render preparation steps as a table.'),
-  ],
-  'dose-response': [
-    binding('dose-response', 'DoseCalculator', ['toDoseConditions'], ['mode', 'targetWells'], 'Configure serial dilution and apply concentrations to wells.'),
-    binding('dose-response', 'WellPlate', ['toDoseLayoutState'], ['format', 'wells', 'sampleColors', 'legendItems'], 'Render the optional dose-response plate layout.'),
-  ],
-  'calibration-curve': [
-    binding('calibration-curve', 'DataFrame', ['toTemplateDataFrame'], ['data', 'columns', 'rowKey'], 'Render standards, QC, blanks, and response values.'),
-  ],
-  'time-course': [
-    binding('time-course', 'ExperimentTimeline', ['toTimeCourseSteps'], ['modelValue', 'orientation'], 'Render time points as an ordered timeline.'),
-    binding('time-course', 'DataFrame', ['toTemplateDataFrame'], ['data', 'columns', 'rowKey'], 'Render longitudinal samples as a table.'),
-  ],
-  'protocol-steps': [
-    binding('protocol-steps', 'ExperimentTimeline', ['toProtocolSteps'], ['modelValue', 'orientation', 'editable'], 'Render protocol steps as an editable timeline.'),
-    binding('protocol-steps', 'DataFrame', ['toTemplateDataFrame'], ['data', 'columns', 'rowKey'], 'Render protocol steps as a table.'),
-  ],
-  'assay-matrix': [
-    binding('assay-matrix', 'DataFrame', ['toTemplateDataFrame'], ['data', 'columns', 'rowKey'], 'Render sample-by-feature measurements.'),
-    binding('assay-matrix', 'SampleSelector', ['toAssayMatrixSampleOptions'], ['samples', 'modelValue'], 'Select samples from assay-matrix records.'),
-  ],
-  'reagent-list': [
-    binding('reagent-list', 'ReagentList', ['toReagentListItems'], ['modelValue'], 'Render reagents with lot, storage, and stock metadata.'),
-    binding('reagent-list', 'DataFrame', ['toTemplateDataFrame'], ['data', 'columns', 'rowKey'], 'Render reagents as a table.'),
-  ],
-  'flow-cytometry-panel': [
-    binding('flow-cytometry-panel', 'DataFrame', ['toTemplateDataFrame'], ['data', 'columns', 'rowKey'], 'Render markers, fluorophores, detectors, and controls.'),
-  ],
-  'instrument-run': [
-    binding('instrument-run', 'DataFrame', ['toTemplateDataFrame'], ['data', 'columns', 'rowKey'], 'Render acquisition queues, methods, QC, and run status.'),
-    binding(
-      'instrument-run',
-      'ScheduleCalendar',
-      ['toInstrumentRunScheduleEvents'],
-      ['modelValue', 'events', 'view', 'readonly', 'showNavigation', 'showViewToggle'],
-      'Render acquisition queues as a scheduled run calendar.',
-    ),
-    binding(
-      'instrument-run',
-      'ExperimentTimeline',
-      ['toInstrumentRunSteps'],
-      ['modelValue', 'orientation', 'showDuration', 'editable'],
-      'Render acquisition queues as an ordered run timeline.',
-    ),
-  ],
-  'qpcr-plate': [
-    binding('qpcr-plate', 'WellPlate', ['toQpcrWellPlateWells'], ['format', 'wells', 'sampleColors', 'legendItems'], 'Render qPCR reactions on a well plate.'),
-    binding('qpcr-plate', 'DataFrame', ['toTemplateDataFrame'], ['data', 'columns', 'rowKey'], 'Render qPCR reactions, targets, controls, and Cq values.'),
-  ],
-} satisfies Record<TemplateId, readonly ComponentBinding[]>
-
-function binding(
-  templateId: TemplateId,
-  component: string,
-  adapters: readonly string[],
-  props: readonly string[],
-  description: string
-): ComponentBinding {
-  return {
-    id: `${templateId}:${component}`,
-    template_id: templateId,
-    component,
-    adapters,
-    props,
-    description,
-    importPath: '@morscherlab/mint-sdk',
-  }
-}