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

package/src/templates/index.ts

@@ -0,0 +1,318 @@
+export {
+  assertTemplateEnvelope,
+  bioTemplatePresetControlValuesToOptions,
+  createBioTemplatePackCollection,
+  createBioTemplatePresetCollection,
+  createBioTemplatePresetCollectionFromControls,
+  createAssayMatrixTemplate,
+  createCalibrationCurveTemplate,
+  createDoseResponseTemplate,
+  createElisaAssayCollection,
+  createFlowCytometryAssayCollection,
+  createWesternBlotAssayCollection,
+  createFlowCytometryPanelTemplate,
+  createInstrumentRunTemplate,
+  createLcmsBatchCollection,
+  createPlateMapTemplate,
+  createProtocolStepsTemplate,
+  createQpcrExpressionCollection,
+  createQpcrPlateTemplate,
+  createReagentListTemplate,
+  createSampleSheetTemplate,
+  createSamplePrepTemplate,
+  createTemplateCollection,
+  createDefaultBioTemplate,
+  createTimeCourseTemplate,
+  createTemplateEnvelope,
+  createWellPlateScreenCollection,
+  ensureTemplateFromCollection,
+  ensureTemplateEnvelope,
+  extractTemplateCollection,
+  getTemplateData,
+  TEMPLATE_COLLECTION_KEY,
+  validateAssayMatrixData,
+  validateCalibrationCurveData,
+  validateDoseResponseData,
+  validateFlowCytometryPanelData,
+  validateInstrumentRunData,
+  validatePlateMapData,
+  validateProtocolStepsData,
+  validateQpcrPlateData,
+  validateReagentListData,
+  validateSampleSheetData,
+  validateSamplePrepData,
+  validateTimeCourseData,
+} from './builders'
+
+export type {
+  BioTemplateControlValues,
+} from './builders'
+
+export {
+  bioTemplateCatalog,
+  getBioTemplateInfo,
+  listBioTemplateCatalog,
+  searchBioTemplateCatalog,
+} from './catalog'
+
+export {
+  bioTemplateControlsToFormSchema,
+  bioTemplateControlsToSectionFormSchemas,
+  bioTemplateControlsToSidebarPanels,
+  createBioTemplateControlToolkit,
+  getBioTemplateControlDefaults,
+  getBioTemplateControlSchema,
+  listBioTemplateControlSchemas,
+  listBioTemplatePresetControlSchemas,
+  requireBioTemplateControlSchema,
+} from './controlSchemas'
+
+export {
+  getBioTemplateComponentProps,
+  getBioTemplateComponentBindings,
+  listBioTemplateComponentBindings,
+  toBioTemplateComponentBindings,
+  toBioTemplateComponentBindingsById,
+  toBioTemplateComponentImports,
+  toBioTemplateComponentProps,
+  toBioTemplateComponentPropsByComponent,
+  toBioTemplateComponentPropsById,
+  toBioTemplateComponentSnippets,
+  toBioTemplateComponentUsage,
+} from './componentBindings'
+
+export type {
+  BioTemplateComponentBindingsById,
+  BioTemplateComponentPropsByComponent,
+  BioTemplateComponentPropsById,
+  BioTemplateComponentPropsLookupOptions,
+} from './componentBindings'
+
+export {
+  bioTemplatePresets,
+  getBioTemplatePresetInfo,
+  listBioTemplatePresets,
+  searchBioTemplatePresets,
+} from './presets'
+
+export {
+  bioTemplatePacks,
+  getBioTemplatePackInfo,
+  listBioTemplatePacks,
+  searchBioTemplatePacks,
+} from './packs'
+
+export {
+  toAssayMatrixColumns,
+  toAssayMatrixDataFrame,
+  toAssayMatrixRows,
+  toCalibrationCurveColumns,
+  toCalibrationCurveDataFrame,
+  toCalibrationCurveRows,
+  toDoseConditions,
+  toDoseLayoutState,
+  toFlowPanelColumns,
+  toFlowPanelDataFrame,
+  toFlowPanelRows,
+  toInstrumentRunColumns,
+  toInstrumentRunDataFrame,
+  toInstrumentRunRows,
+  toPlateMapEditorState,
+  toProtocolColumns,
+  toProtocolDataFrame,
+  toProtocolRows,
+  toProtocolSteps,
+  toQpcrColumns,
+  toQpcrDataFrame,
+  toQpcrRows,
+  toQpcrWellPlateWells,
+  toReagentColumns,
+  toReagentDataFrame,
+  toReagentListItems,
+  toReagentRows,
+  toSampleColumns,
+  toSampleDataFrame,
+  toSampleOptions,
+  toSamplePrepColumns,
+  toSamplePrepDataFrame,
+  toSamplePrepRows,
+  toSampleRows,
+  toTemplateDataFrame,
+  toTimeCourseColumns,
+  toTimeCourseDataFrame,
+  toTimeCourseRows,
+  toTimeCourseSteps,
+  toWellMapArray,
+  toWellPlateWells,
+} from './adapters'
+
+export type {
+  AssayFeature,
+  AssayFeatureType,
+  AssayMatrixColumnsAdapterResult,
+  AssayMatrixDataFrameAdapterResult,
+  AssayMatrixRowsAdapterResult,
+  AssayMatrixTemplate,
+  AssayMatrixTemplateData,
+  AssayMeasurement,
+  AssaySample,
+  BioTemplateEnvelope,
+  CalibrationAcceptance,
+  CalibrationAcceptanceInput,
+  CalibrationCurveColumnsAdapterResult,
+  CalibrationCurveDataFrameAdapterResult,
+  CalibrationCurveRowsAdapterResult,
+  CalibrationCurveTemplate,
+  CalibrationCurveTemplateData,
+  CalibrationModel,
+  CalibrationPoint,
+  CalibrationPointInput,
+  CalibrationPointRole,
+  CalibrationPointStatus,
+  CompoundDoseSeries,
+  ControlDefinition,
+  ControlRole,
+  CreateBioTemplatePackCollectionOptions,
+  CreateAssayMatrixTemplateOptions,
+  CreateCalibrationCurveTemplateOptions,
+  CreateDoseResponseTemplateOptions,
+  CreateElisaAssayCollectionOptions,
+  CreateFlowCytometryAssayCollectionOptions,
+  CreateWesternBlotAssayCollectionOptions,
+  CreateFlowCytometryPanelTemplateOptions,
+  CreateInstrumentRunTemplateOptions,
+  CreateLcmsBatchCollectionOptions,
+  CreatePlateMapTemplateOptions,
+  CreateProtocolStepsTemplateOptions,
+  CreateQpcrExpressionCollectionOptions,
+  CreateQpcrPlateTemplateOptions,
+  CreateReagentListTemplateOptions,
+  CreateSampleSheetTemplateOptions,
+  CreateSamplePrepTemplateOptions,
+  CreateTimeCourseTemplateOptions,
+  CreateWellPlateScreenCollectionOptions,
+  DoseConditionsAdapterResult,
+  DoseResponseTemplate,
+  DoseResponseTemplateData,
+  FlowControlKind,
+  FlowCytometryPanelTemplate,
+  FlowCytometryPanelTemplateData,
+  FlowMarkerPurpose,
+  FlowPanelColumnsAdapterResult,
+  FlowPanelControl,
+  FlowPanelDataFrameAdapterResult,
+  FlowPanelMarker,
+  FlowPanelRowsAdapterResult,
+  InstrumentMethod,
+  InstrumentMethodInput,
+  InstrumentRunColumnsAdapterResult,
+  InstrumentRunDataFrameAdapterResult,
+  InstrumentRunItem,
+  InstrumentRunItemInput,
+  InstrumentRunItemKind,
+  InstrumentRunRowsAdapterResult,
+  InstrumentRunStatus,
+  InstrumentRunTemplate,
+  InstrumentRunTemplateData,
+  DataFrameAdapterResult,
+  DataFrameTemplate,
+  PlateMapEditorAdapterResult,
+  PlateMapTemplate,
+  PlateMapTemplateData,
+  ProtocolColumnsAdapterResult,
+  ProtocolDataFrameAdapterResult,
+  ProtocolRowsAdapterResult,
+  ProtocolStepRecord,
+  ProtocolStepsAdapterResult,
+  ProtocolStepsTemplate,
+  ProtocolStepsTemplateData,
+  QpcrChemistry,
+  QpcrColumnsAdapterResult,
+  QpcrControlKind,
+  QpcrDataFrameAdapterResult,
+  QpcrPlateTemplate,
+  QpcrPlateTemplateData,
+  QpcrReaction,
+  QpcrRowsAdapterResult,
+  QpcrSample,
+  QpcrTarget,
+  QpcrWellMapAdapterResult,
+  ReagentColumnsAdapterResult,
+  ReagentDataFrameAdapterResult,
+  ReagentKind,
+  ReagentListItemsAdapterResult,
+  ReagentListTemplate,
+  ReagentListTemplateData,
+  ReagentRecord,
+  ReagentTemplateInput,
+  ReagentRowsAdapterResult,
+  SampleColumn,
+  SampleColumnType,
+  SampleColumnsAdapterResult,
+  SampleDataFrameAdapterResult,
+  SampleGroupDefinition,
+  SampleOptionsAdapterResult,
+  SamplePrepColumnsAdapterResult,
+  SamplePrepDataFrameAdapterResult,
+  SamplePrepRowsAdapterResult,
+  SamplePrepStatus,
+  SamplePrepStep,
+  SamplePrepStepInput,
+  SamplePrepStepType,
+  SamplePrepTemplate,
+  SamplePrepTemplateData,
+  SampleRecord,
+  SampleRowsAdapterResult,
+  SampleSheetTemplate,
+  SampleSheetTemplateData,
+  TimeCourseColumnsAdapterResult,
+  TimeCourseCondition,
+  TimeCourseDataFrameAdapterResult,
+  TimeCourseRowsAdapterResult,
+  TimeCourseSample,
+  TimeCourseStepsAdapterResult,
+  TimeCourseTemplate,
+  TimeCourseTemplateData,
+  TimePoint,
+  TimeUnit,
+  TemplateId,
+  TemplatePackId,
+  TemplatePresetId,
+  TemplateCollection,
+  TemplateCollectionEnvelope,
+  TemplateDataFrameAdapterResult,
+  TemplateKind,
+  TemplatePlateMap,
+  TemplateSample,
+  TemplateWell,
+  WellMapAdapterResult,
+} from './types'
+
+export type {
+  BioTemplateCatalogEntry,
+} from './catalog'
+
+export type {
+  BioTemplateComponentBinding,
+  BioTemplateComponentImport,
+  BioTemplateComponentPropsBinding,
+  BioTemplateResolvedComponentBinding,
+  BioTemplateComponentSnippet,
+  BioTemplateComponentSnippetOptions,
+  BioTemplateComponentTarget,
+  BioTemplateComponentUsage,
+  BioTemplateComponentUsageOptions,
+} from './componentBindings'
+
+export type {
+  BioTemplateControlSchema,
+  BioTemplateControlTarget,
+} from './controlSchemas'
+
+export type {
+  BioTemplatePresetEntry,
+} from './presets'
+
+export type {
+  BioTemplatePackEntry,
+} from './packs'

package/src/templates/lookup.ts

@@ -0,0 +1,18 @@
+/** Normalize human-facing template lookup terms so spaces, hyphens, and underscores behave the same. */
+export function normalizeTemplateLookupKey(value: string): string {
+  return value.trim().toLowerCase().replace(/[\s_-]+/g, '-')
+}
+
+export function templateIdentifierMatches(query: string, identifiers: readonly string[]): boolean {
+  const normalizedQuery = normalizeTemplateLookupKey(query)
+  return identifiers.some(value => normalizeTemplateLookupKey(value) === normalizedQuery)
+}
+
+export function templateSearchMatches(query: string, values: readonly string[]): boolean {
+  const lowerQuery = query.trim().toLowerCase()
+  const normalizedQuery = normalizeTemplateLookupKey(query)
+  return values.some(value =>
+    value.toLowerCase().includes(lowerQuery)
+    || normalizeTemplateLookupKey(value).includes(normalizedQuery),
+  )
+}

package/src/templates/packs.ts

@@ -0,0 +1,156 @@
+import { bioTemplateCatalog } from './catalog'
+import type { TemplateId, TemplatePackId } from './types'
+
+import { templateIdentifierMatches, templateSearchMatches } from './lookup'
+
+export interface BioTemplatePackEntry {
+  name: TemplatePackId
+  label: string
+  category: 'bio-template-pack'
+  purpose: string
+  templates: readonly TemplateId[]
+  aliases: readonly string[]
+  frontend_adapters: readonly string[]
+  components: readonly string[]
+  add_command: string
+  init_command: string
+  docs_command: string
+}
+
+interface BioTemplatePackDefinition {
+  name: TemplatePackId
+  label: string
+  purpose: string
+  templates: readonly TemplateId[]
+  aliases: readonly string[]
+}
+
+const templateInfoById = new Map(
+  bioTemplateCatalog.map(entry => [entry.template_id, entry]),
+)
+
+function collectTemplateField(
+  templateIds: readonly TemplateId[],
+  field: 'frontend_adapters' | 'components',
+): readonly string[] {
+  const values: string[] = []
+  for (const templateId of templateIds) {
+    const entry = templateInfoById.get(templateId)
+    if (!entry) {
+      throw new Error(`Unknown bio template in pack catalog: ${templateId}`)
+    }
+    for (const value of entry[field]) {
+      if (!values.includes(value)) {
+        values.push(value)
+      }
+    }
+  }
+  return values
+}
+
+function createPack(definition: BioTemplatePackDefinition): BioTemplatePackEntry {
+  return {
+    ...definition,
+    category: 'bio-template-pack',
+    frontend_adapters: collectTemplateField(definition.templates, 'frontend_adapters'),
+    components: collectTemplateField(definition.templates, 'components'),
+    add_command: `mint add data-template-pack ${definition.name} --page`,
+    init_command: `mint init --template ${definition.name}`,
+    docs_command: `mint docs template-pack ${definition.name}`,
+  }
+}
+
+const bioTemplatePackDefinitions = [
+  {
+    name: 'cell-culture-screen',
+    label: 'Cell culture screen',
+    purpose: 'Plate layout, sample metadata, sample prep, reagents, protocol, dose-response, and flow-panel setup.',
+    templates: [
+      'sample-sheet',
+      'sample-prep',
+      'plate-map',
+      'reagent-list',
+      'protocol-steps',
+      'dose-response',
+      'flow-cytometry-panel',
+    ],
+    aliases: ['cell culture', 'screen', 'drug screen', 'plate screen'],
+  },
+  {
+    name: 'omics-assay',
+    label: 'Omics assay',
+    purpose: 'Sample metadata, sample prep, reagents, protocol, instrument run queue, calibration curve, and measurement matrix.',
+    templates: [
+      'sample-sheet',
+      'sample-prep',
+      'reagent-list',
+      'protocol-steps',
+      'instrument-run',
+      'calibration-curve',
+      'assay-matrix',
+    ],
+    aliases: ['omics', 'metabolomics', 'proteomics', 'assay matrix', 'lcms', 'standard curve'],
+  },
+  {
+    name: 'longitudinal-study',
+    label: 'Longitudinal study',
+    purpose: 'Sample metadata, time-course schedule, protocol, and measurement matrix.',
+    templates: [
+      'sample-sheet',
+      'time-course',
+      'protocol-steps',
+      'assay-matrix',
+    ],
+    aliases: ['time series', 'time-course study', 'kinetics', 'longitudinal'],
+  },
+  {
+    name: 'molecular-assay',
+    label: 'Molecular assay',
+    purpose: 'Sample metadata, sample prep, reagents, protocol, instrument run queue, calibration curve, and qPCR/ddPCR plate setup.',
+    templates: [
+      'sample-sheet',
+      'sample-prep',
+      'reagent-list',
+      'protocol-steps',
+      'instrument-run',
+      'calibration-curve',
+      'qpcr-plate',
+    ],
+    aliases: ['molecular', 'qpcr', 'qPCR', 'gene expression', 'rt-qpcr', 'ddpcr'],
+  },
+] as const satisfies readonly BioTemplatePackDefinition[]
+
+export const bioTemplatePacks = bioTemplatePackDefinitions.map(createPack) as readonly BioTemplatePackEntry[]
+
+export function listBioTemplatePacks(): readonly BioTemplatePackEntry[] {
+  return bioTemplatePacks
+}
+
+export function getBioTemplatePackInfo(name: string): BioTemplatePackEntry | undefined {
+  return bioTemplatePacks.find(entry => {
+    const identifiers = [
+      entry.name,
+      entry.label,
+      ...entry.aliases,
+    ]
+    return templateIdentifierMatches(name, identifiers)
+  })
+}
+
+export function searchBioTemplatePacks(query: string): readonly BioTemplatePackEntry[] {
+  const normalized = query.trim().toLowerCase()
+  if (!normalized) return bioTemplatePacks
+
+  return bioTemplatePacks.filter(entry => templateSearchMatches(normalized, [
+    entry.name,
+    entry.label,
+    entry.purpose,
+    entry.add_command,
+    entry.init_command,
+    entry.docs_command,
+    ...entry.templates,
+    ...entry.aliases,
+    ...entry.frontend_adapters,
+    ...entry.components,
+  ]))
+}

package/src/templates/presets.ts

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