@opentrons/components 0.1.6-alpha.8 → 0.1.7-alpha.0

package/src/organisms/CommandText/useCommandTextString/utils/commandText/getPipettingCommandText.ts

@@ -0,0 +1,196 @@
+import { getLabwareDefURI } from '@opentrons/shared-data'
+
+import { getFinalLabwareLocation } from '../getFinalLabwareLocation'
+import { getWellRange } from '../getWellRange'
+import { getLabwareDisplayLocation } from '../getLabwareDisplayLocation'
+import { getLabwareName } from '../getLabwareName'
+import { getLoadedLabware } from '../getLoadedLabware'
+import { getLabwareDefinitionsFromCommands } from '../getLabwareDefinitionsFromCommands'
+import { getFinalMoveToAddressableAreaCmd } from '../getFinalAddressableAreaCmd'
+import { getAddressableAreaDisplayName } from '../getAddressableAreaDisplayName'
+import type { PipetteName, RunTimeCommand } from '@opentrons/shared-data'
+import type { GetCommandText } from '../..'
+
+export const getPipettingCommandText = ({
+  command,
+  allRunDefs,
+  commandTextData,
+  robotType,
+  t,
+}: GetCommandText): string => {
+  const labwareId =
+    command != null && 'labwareId' in command.params
+      ? (command.params.labwareId as string)
+      : ''
+  const wellName =
+    command != null && 'wellName' in command.params
+      ? command.params.wellName
+      : ''
+
+  const allPreviousCommands = commandTextData?.commands.slice(
+    0,
+    commandTextData.commands.findIndex(c => c.id === command?.id)
+  )
+  const labwareLocation =
+    allPreviousCommands != null
+      ? getFinalLabwareLocation(
+          labwareId,
+          allPreviousCommands as RunTimeCommand[]
+        )
+      : null
+
+  const displayLocation = getLabwareDisplayLocation({
+    loadedLabwares: commandTextData?.labware ?? [],
+    location: labwareLocation?.locationSequence ?? labwareLocation?.location,
+    robotType,
+    allRunDefs,
+    loadedModules: commandTextData?.modules ?? [],
+    t,
+  })
+
+  const labwareName =
+    commandTextData != null
+      ? getLabwareName({
+          loadedLabwares: commandTextData.labware ?? [],
+          labwareId,
+          allRunDefs,
+        })
+      : null
+
+  switch (command?.commandType) {
+    case 'aspirate': {
+      const { volume, flowRate } = command.params
+      return t('aspirate', {
+        well_name: wellName,
+        labware: labwareName,
+        labware_location: displayLocation,
+        volume,
+        flow_rate: flowRate,
+      })
+    }
+    case 'dispense': {
+      const { volume, flowRate, pushOut } = command.params
+      return pushOut != null
+        ? t('dispense_push_out', {
+            well_name: wellName,
+            labware: labwareName,
+            labware_location: displayLocation,
+            volume,
+            flow_rate: flowRate,
+            push_out_volume: pushOut,
+          })
+        : t('dispense', {
+            well_name: wellName,
+            labware: labwareName,
+            labware_location: displayLocation,
+            volume,
+            flow_rate: flowRate,
+          })
+    }
+    case 'blowout': {
+      const { flowRate } = command.params
+      return t('blowout', {
+        well_name: wellName,
+        labware: labwareName,
+        labware_location: displayLocation,
+        flow_rate: flowRate,
+      })
+    }
+    case 'dropTip': {
+      const loadedLabware =
+        commandTextData != null
+          ? getLoadedLabware(commandTextData.labware ?? [], labwareId)
+          : null
+      const labwareDefinitions =
+        commandTextData != null
+          ? getLabwareDefinitionsFromCommands(
+              commandTextData.commands as RunTimeCommand[]
+            )
+          : null
+      const labwareDef = labwareDefinitions?.find(
+        lw => getLabwareDefURI(lw) === loadedLabware?.definitionUri
+      )
+      return Boolean(labwareDef?.parameters.isTiprack)
+        ? t('return_tip', {
+            well_name: wellName,
+            labware: labwareName,
+            labware_location: displayLocation,
+          })
+        : t('drop_tip', {
+            well_name: wellName,
+            labware: labwareName,
+          })
+    }
+    case 'pickUpTip': {
+      const pipetteId = command.params.pipetteId
+      const pipetteName:
+        | PipetteName
+        | undefined = commandTextData?.pipettes.find(
+        pipette => pipette.id === pipetteId
+      )?.pipetteName
+
+      return t('pickup_tip', {
+        well_range:
+          allPreviousCommands != null
+            ? getWellRange(
+                pipetteId,
+                allPreviousCommands as RunTimeCommand[],
+                wellName as string,
+                pipetteName
+              )
+            : null,
+        labware: labwareName,
+        labware_location: displayLocation,
+      })
+    }
+    case 'dropTipInPlace': {
+      const cmd = getFinalMoveToAddressableAreaCmd(allPreviousCommands ?? [])
+
+      if (cmd != null) {
+        const displayName = getAddressableAreaDisplayName([cmd], cmd?.id, t)
+        return t('dropping_tip_in_trash', { trash: displayName })
+      } else {
+        return t('drop_tip_in_place')
+      }
+    }
+    case 'dispenseInPlace': {
+      const { volume, flowRate } = command.params
+      return t('dispense_in_place', { volume, flow_rate: flowRate })
+    }
+    case 'blowOutInPlace': {
+      const { flowRate } = command.params
+      return t('blowout_in_place', { flow_rate: flowRate })
+    }
+    case 'aspirateInPlace': {
+      const { flowRate, volume } = command.params
+      return t('aspirate_in_place', { volume, flow_rate: flowRate })
+    }
+    case 'airGapInPlace': {
+      const { volume } = command.params
+      return t('air_gap_in_place', { volume })
+    }
+    case 'sealPipetteToTip': {
+      return t('sealing_to_location', {
+        labware: labwareName,
+        location: displayLocation,
+      })
+    }
+    case 'unsealPipetteFromTip': {
+      return t('unsealing_from_location', {
+        labware: labwareName,
+        location: displayLocation,
+      })
+    }
+    case 'pressureDispense': {
+      const { flowRate, volume } = command.params
+      return t('pressurizing_to_dispense', { volume, flow_rate: flowRate })
+    }
+    default: {
+      console.warn(
+        'PipettingCommandText encountered a command with an unrecognized commandType: ',
+        command
+      )
+      return ''
+    }
+  }
+}

package/src/organisms/CommandText/useCommandTextString/utils/commandText/getPrepareToAspirateCommandText.ts

@@ -0,0 +1,20 @@
+import { getPipetteSpecsV2 } from '@opentrons/shared-data'
+
+import type { PrepareToAspirateRunTimeCommand } from '@opentrons/shared-data/command'
+import type { HandlesCommands } from '../types'
+
+export function getPrepareToAspirateCommandText({
+  command,
+  commandTextData,
+  t,
+}: HandlesCommands<PrepareToAspirateRunTimeCommand>): string {
+  const { pipetteId } = command.params
+  const pipetteName = commandTextData?.pipettes.find(
+    pip => pip.id === pipetteId
+  )?.pipetteName
+
+  return t('prepare_to_aspirate', {
+    pipette:
+      pipetteName != null ? getPipetteSpecsV2(pipetteName)?.displayName : '',
+  })
+}

package/src/organisms/CommandText/useCommandTextString/utils/commandText/getRailLightsCommandText.ts

@@ -0,0 +1,15 @@
+import type { RunTimeCommand } from '@opentrons/shared-data/command'
+import type { HandlesCommands } from '../types'
+
+type HandledCommands = Extract<RunTimeCommand, { commandType: 'setRailLights' }>
+
+export type GetRailLightsCommandText = HandlesCommands<HandledCommands>
+
+export function getRailLightsCommandText({
+  command,
+  t,
+}: GetRailLightsCommandText): string {
+  return command.params.on
+    ? t('turning_rail_lights_on')
+    : t('turning_rail_lights_off')
+}

package/src/organisms/CommandText/useCommandTextString/utils/commandText/getTCRunExtendedProfileCommandText.ts

@@ -0,0 +1,67 @@
+import { formatDurationLabeled } from '../formatDuration'
+import type {
+  TCRunExtendedProfileRunTimeCommand,
+  TCProfileCycle,
+  AtomicProfileStep,
+} from '@opentrons/shared-data/command'
+import type { GetTCRunExtendedProfileCommandTextResult } from '../..'
+import type { HandlesCommands } from '../types'
+
+export interface TCProfileStepText {
+  kind: 'step'
+  stepText: string
+}
+
+export interface TCProfileCycleText {
+  kind: 'cycle'
+  cycleText: string
+  stepTexts: TCProfileStepText[]
+}
+
+export function getTCRunExtendedProfileCommandText({
+  command,
+  t,
+}: HandlesCommands<TCRunExtendedProfileRunTimeCommand>): GetTCRunExtendedProfileCommandTextResult {
+  const { profileElements } = command.params
+
+  const stepText = ({
+    celsius,
+    holdSeconds,
+  }: AtomicProfileStep): TCProfileStepText => ({
+    kind: 'step',
+    stepText: t('tc_run_profile_steps', {
+      celsius,
+      duration: formatDurationLabeled({ seconds: holdSeconds }),
+    }).trim(),
+  })
+
+  const stepTexts = (cycle: AtomicProfileStep[]): TCProfileStepText[] =>
+    cycle.map(stepText)
+
+  const startingCycleText = (cycle: TCProfileCycle): string =>
+    t('tc_starting_extended_profile_cycle', {
+      repetitions: cycle.repetitions,
+    })
+
+  const cycleText = (cycle: TCProfileCycle): TCProfileCycleText => ({
+    kind: 'cycle',
+    cycleText: startingCycleText(cycle),
+    stepTexts: stepTexts(cycle.steps),
+  })
+  const profileElementTexts = (
+    profile: Array<TCProfileCycle | AtomicProfileStep>
+  ): Array<TCProfileStepText | TCProfileCycleText> =>
+    profile.map(element =>
+      Object.hasOwn(element, 'repetitions')
+        ? cycleText(element as TCProfileCycle)
+        : stepText(element as AtomicProfileStep)
+    )
+
+  return {
+    kind: 'thermocycler/runExtendedProfile',
+    commandText: t('tc_starting_extended_profile', {
+      elementCount: profileElements.length,
+    }),
+    profileElementTexts: profileElementTexts(profileElements),
+  }
+}

package/src/organisms/CommandText/useCommandTextString/utils/commandText/getTCRunProfileCommandText.ts

@@ -0,0 +1,29 @@
+import { formatDurationLabeled } from '../formatDuration'
+import type { TCRunProfileRunTimeCommand } from '@opentrons/shared-data/command'
+import type { GetTCRunProfileCommandTextResult } from '../..'
+import type { HandlesCommands } from '../types'
+
+export function getTCRunProfileCommandText({
+  command,
+  t,
+}: HandlesCommands<TCRunProfileRunTimeCommand>): GetTCRunProfileCommandTextResult {
+  const { profile } = command.params
+
+  const stepTexts = profile.map(
+    ({ holdSeconds, celsius }: { holdSeconds: number; celsius: number }) =>
+      t('tc_run_profile_steps', {
+        celsius,
+        duration: formatDurationLabeled({ seconds: holdSeconds }),
+      }).trim()
+  )
+
+  const startingProfileText = t('tc_starting_profile', {
+    stepCount: Object.keys(stepTexts).length,
+  })
+
+  return {
+    kind: 'thermocycler/runProfile',
+    commandText: startingProfileText,
+    stepTexts,
+  }
+}

package/src/organisms/CommandText/useCommandTextString/utils/commandText/getTemperatureCommandText.ts

@@ -0,0 +1,49 @@
+import type {
+  TemperatureModuleAwaitTemperatureCreateCommand,
+  TemperatureModuleSetTargetTemperatureCreateCommand,
+  TCSetTargetBlockTemperatureCreateCommand,
+  TCSetTargetLidTemperatureCreateCommand,
+  HeaterShakerSetTargetTemperatureCreateCommand,
+  RunTimeCommand,
+} from '@opentrons/shared-data'
+import type { HandlesCommands } from '../types'
+
+export type TemperatureCreateCommand =
+  | TemperatureModuleSetTargetTemperatureCreateCommand
+  | TemperatureModuleAwaitTemperatureCreateCommand
+  | TCSetTargetBlockTemperatureCreateCommand
+  | TCSetTargetLidTemperatureCreateCommand
+  | HeaterShakerSetTargetTemperatureCreateCommand
+
+const T_KEYS_BY_COMMAND_TYPE: {
+  [commandType in TemperatureCreateCommand['commandType']]: string
+} = {
+  'temperatureModule/setTargetTemperature': 'setting_temperature_module_temp',
+  'temperatureModule/waitForTemperature': 'waiting_to_reach_temp_module',
+  'thermocycler/setTargetBlockTemperature': 'setting_thermocycler_block_temp',
+  'thermocycler/setTargetLidTemperature': 'setting_thermocycler_lid_temp',
+  'heaterShaker/setTargetTemperature': 'setting_hs_temp',
+}
+
+type HandledCommands = Extract<
+  RunTimeCommand,
+  { commandType: keyof typeof T_KEYS_BY_COMMAND_TYPE }
+>
+
+type GetTemperatureCommandText = HandlesCommands<HandledCommands>
+
+export const getTemperatureCommandText = ({
+  command,
+  t,
+}: GetTemperatureCommandText): string => {
+  return t(T_KEYS_BY_COMMAND_TYPE[command.commandType], {
+    temp:
+      command.params?.celsius != null
+        ? t('degrees_c', { temp: command.params.celsius })
+        : t('target_temperature'),
+    hold_time_seconds:
+      'holdTimeSeconds' in command.params
+        ? command.params.holdTimeSeconds ?? '0'
+        : '0',
+  })
+}

package/src/organisms/CommandText/useCommandTextString/utils/commandText/getUnknownCommandText.ts

@@ -0,0 +1,5 @@
+import type { GetCommandText } from '../..'
+
+export function getUnknownCommandText({ command }: GetCommandText): string {
+  return JSON.stringify(command)
+}

package/src/organisms/CommandText/useCommandTextString/utils/commandText/getWaitForDurationCommandText.ts

@@ -0,0 +1,11 @@
+import type { WaitForDurationRunTimeCommand } from '@opentrons/shared-data/command'
+import type { HandlesCommands } from '../types'
+
+export function getWaitForDurationCommandText({
+  command,
+  t,
+}: HandlesCommands<WaitForDurationRunTimeCommand>): string {
+  const { seconds, message } = command.params
+
+  return t('wait_for_duration', { seconds, message: message ?? '' })
+}

package/src/organisms/CommandText/useCommandTextString/utils/commandText/getWaitForResumeCommandText.ts

@@ -0,0 +1,11 @@
+import type { WaitForResumeRunTimeCommand } from '@opentrons/shared-data/command'
+import type { HandlesCommands } from '../types'
+
+export function getWaitForResumeCommandText({
+  command,
+  t,
+}: HandlesCommands<WaitForResumeRunTimeCommand>): string {
+  return command.params?.message != null && command.params.message !== ''
+    ? command.params.message
+    : t('wait_for_resume')
+}

package/src/organisms/CommandText/useCommandTextString/utils/commandText/index.ts

@@ -0,0 +1,26 @@
+export * from './getLoadCommandText'
+export * from './getTemperatureCommandText'
+export * from './getTCRunProfileCommandText'
+export * from './getTCRunExtendedProfileCommandText'
+export * from './getHSShakeSpeedCommandText'
+export * from './getMoveToSlotCommandText'
+export * from './getMoveRelativeCommandText'
+export * from './getMoveToCoordinatesCommandText'
+export * from './getMoveToWellCommandText'
+export * from './getMoveLabwareCommandText'
+export * from './getConfigureForVolumeCommandText'
+export * from './getConfigureNozzleLayoutCommandText'
+export * from './getPrepareToAspirateCommandText'
+export * from './getMoveToAddressableAreaCommandText'
+export * from './getMoveToAddressableAreaForDropTipCommandText'
+export * from './getDirectTranslationCommandText'
+export * from './getWaitForDurationCommandText'
+export * from './getWaitForResumeCommandText'
+export * from './getDelayCommandText'
+export * from './getCommentCommandText'
+export * from './getCustomCommandText'
+export * from './getUnknownCommandText'
+export * from './getPipettingCommandText'
+export * from './getLiquidProbeCommandText'
+export * from './getRailLightsCommandText'
+export * from './getAbsorbanceReaderCommandText'

package/src/organisms/CommandText/useCommandTextString/utils/formatDuration.ts

@@ -0,0 +1,44 @@
+import padStart from 'lodash/padStart'
+import type { Duration } from 'date-fns'
+/**
+ * utility to format a date-fns duration object to hh:mm:ss
+ * @param duration date-fns duration object
+ * @returns string in format hh:mm:ss, e.g. 03:15:45
+ */
+export function formatDuration(duration: Duration): string {
+  const { hours, minutes, seconds } = timestampDetails(duration)
+
+  return `${hours}:${minutes}:${seconds}`
+}
+
+export function formatDurationLabeled(duration: Duration): string {
+  const { hours, minutes, seconds } = timestampDetails(duration, 1)
+
+  return `${hours}h ${minutes}m ${seconds}s`
+}
+
+function timestampDetails(
+  duration: Duration,
+  padHoursTo?: number
+): { hours: string; minutes: string; seconds: string } {
+  const paddingWithDefault = padHoursTo ?? 2
+  const days = duration?.days ?? 0
+  const hours = duration?.hours ?? 0
+  const minutes = duration?.minutes ?? 0
+  const seconds = duration?.seconds ?? 0
+
+  const totalSeconds = seconds + minutes * 60 + hours * 3600 + days * 24 * 3600
+
+  const normalizedHours = Math.floor(totalSeconds / 3600)
+  const normalizedMinutes = Math.floor((totalSeconds % 3600) / 60)
+  const normalizedSeconds = totalSeconds % 60
+
+  const paddedHours = padStart(
+    normalizedHours.toString(),
+    paddingWithDefault,
+    '0'
+  )
+  const paddedMinutes = padStart(normalizedMinutes.toString(), 2, '0')
+  const paddedSeconds = padStart(normalizedSeconds.toString(), 2, '0')
+  return { hours: paddedHours, minutes: paddedMinutes, seconds: paddedSeconds }
+}

package/src/organisms/CommandText/useCommandTextString/utils/getAddressableAreaDisplayName.ts

@@ -0,0 +1,62 @@
+import type {
+  AddressableAreaName,
+  MoveToAddressableAreaParams,
+  RunTimeCommand,
+} from '@opentrons/shared-data'
+import type { TFunction } from 'i18next'
+
+export function getAddressableAreaDisplayName(
+  commands: RunTimeCommand[] | undefined,
+  commandId: string,
+  t: TFunction
+): string {
+  const addressableAreaCommand = (commands ?? []).find(
+    command => command.id === commandId
+  )
+
+  if (
+    addressableAreaCommand == null ||
+    !('addressableAreaName' in addressableAreaCommand.params)
+  ) {
+    return ''
+  }
+
+  const addressableAreaName: MoveToAddressableAreaParams['addressableAreaName'] =
+    addressableAreaCommand.params.addressableAreaName
+
+  if (addressableAreaName.includes('movableTrash')) {
+    const slotName = getMovableTrashSlot(addressableAreaName)
+    return t('trash_bin_in_slot', { slot_name: slotName })
+  } else if (addressableAreaName.includes('WasteChute')) {
+    return t('waste_chute')
+  } else if (addressableAreaName === 'fixedTrash') {
+    return t('fixed_trash')
+  } else {
+    return addressableAreaName
+  }
+}
+
+const getMovableTrashSlot = (
+  addressableAreaName: AddressableAreaName
+): string => {
+  switch (addressableAreaName) {
+    case 'movableTrashA1':
+      return 'A1'
+    case 'movableTrashA3':
+      return 'A3'
+    case 'movableTrashB1':
+      return 'B1'
+    case 'movableTrashB3':
+      return 'B3'
+    case 'movableTrashC1':
+      return 'C1'
+    case 'movableTrashC3':
+      return 'C3'
+    case 'movableTrashD1':
+      return 'D1'
+    case 'movableTrashD3':
+      return 'D3'
+    default:
+      return ''
+  }
+}

package/src/organisms/CommandText/useCommandTextString/utils/getFinalAddressableAreaCmd.ts

@@ -0,0 +1,20 @@
+import { findLastAt } from './helpers'
+import type { RunTimeCommand } from '@opentrons/shared-data'
+/**
+ * given a list of commands and a labwareId, calculate the resulting location
+ * of the corresponding labware after all given commands are executed
+ * @param commands list of commands to search within
+ * @returns The last command related to addressable areas.
+ */
+export function getFinalMoveToAddressableAreaCmd(
+  commands: RunTimeCommand[]
+): RunTimeCommand | null {
+  const [cmd] = findLastAt(
+    commands,
+    (c: RunTimeCommand) =>
+      c.commandType === 'moveToAddressableArea' ||
+      c.commandType === 'moveToAddressableAreaForDropTip'
+  )
+
+  return cmd ?? null
+}

package/src/organisms/CommandText/useCommandTextString/utils/getFinalLabwareLocation.ts

@@ -0,0 +1,46 @@
+import { findLastAt } from './helpers'
+
+import type {
+  LabwareLocation,
+  RunTimeCommand,
+  LoadLabwareRunTimeCommand,
+  MoveLabwareRunTimeCommand,
+  LabwareLocationSequence,
+} from '@opentrons/shared-data'
+
+/**
+ * given a list of commands and a labwareId, calculate the resulting location
+ * of the corresponding labware after all given commands are executed
+ * @param labwareId target labware
+ * @param commands list of commands to search within
+ * @returns LabwareLocation object of the resulting location of the target labware after all commands execute
+ */
+export function getFinalLabwareLocation(
+  labwareId: string,
+  commands: RunTimeCommand[]
+): { location?: LabwareLocation; locationSequence?: LabwareLocationSequence } {
+  const [lastMove, lastMoveIndex] = findLastAt(
+    commands,
+    (c: RunTimeCommand): c is MoveLabwareRunTimeCommand =>
+      c.commandType === 'moveLabware' && c.params.labwareId === labwareId
+  )
+
+  const [lastLoad, lastLoadIndex] = findLastAt(
+    commands,
+    (c: RunTimeCommand): c is LoadLabwareRunTimeCommand =>
+      c.commandType === 'loadLabware' && c.result?.labwareId === labwareId
+  )
+  if (lastMoveIndex > lastLoadIndex) {
+    return {
+      location: lastMove?.params?.newLocation,
+      locationSequence: lastMove?.result?.immediateDestinationLocationSequence,
+    }
+  } else if (lastLoadIndex > lastMoveIndex) {
+    return {
+      location: lastLoad?.params?.location,
+      locationSequence: lastLoad?.result?.locationSequence,
+    }
+  } else {
+    return {}
+  }
+}

package/src/organisms/CommandText/useCommandTextString/utils/getLabwareDefinitionsFromCommands.ts

@@ -0,0 +1,59 @@
+import { getLabwareDefURI } from '@opentrons/shared-data'
+
+import type {
+  LabwareDefinition2,
+  RunTimeCommand,
+  LoadLabwareRunTimeCommand,
+  LoadLidRunTimeCommand,
+} from '@opentrons/shared-data'
+
+// Note: This is an O(n) operation.
+export function getLabwareDefinitionsFromCommands(
+  commands: RunTimeCommand[]
+): LabwareDefinition2[] {
+  return commands.reduce<LabwareDefinition2[]>(
+    (acc, command) => [
+      ...getLabwareDefinitionFromCommand(command, acc),
+      ...acc,
+    ],
+    []
+  )
+}
+
+function getNewLabwareDefinitions(
+  newDefinitions: Array<LabwareDefinition2 | null | undefined>,
+  knownDefinitions: LabwareDefinition2[]
+): LabwareDefinition2[] {
+  return newDefinitions.filter(
+    (maybeNewDef): maybeNewDef is LabwareDefinition2 =>
+      maybeNewDef != null &&
+      !knownDefinitions.some(
+        knownDef => getLabwareDefURI(knownDef) === getLabwareDefURI(maybeNewDef)
+      )
+  )
+}
+
+const isLoadCommand = (
+  command: RunTimeCommand
+): command is LoadLabwareRunTimeCommand | LoadLidRunTimeCommand =>
+  ['loadLabware', 'loadLid', 'loadLidStack'].includes(command.commandType)
+
+function getLabwareDefinitionFromCommand(
+  command: RunTimeCommand,
+  known: LabwareDefinition2[]
+): LabwareDefinition2[] {
+  if (isLoadCommand(command)) {
+    return getNewLabwareDefinitions([command.result?.definition], known)
+  }
+  if (command.commandType === 'flexStacker/setStoredLabware') {
+    return getNewLabwareDefinitions(
+      [
+        command.result?.primaryLabwareDefinition,
+        command.result?.adapterLabwareDefinition,
+        command.result?.lidLabwareDefinition,
+      ],
+      known
+    )
+  }
+  return []
+}