Potential RNAi Target Region Identification

In order to find which genes our RNA interference (RNAi) should target in our protein bait, we needed to identify genes specific to the Vespa velutina (i.e., Asian hornet) and validate that these would, in fact, interfere with the development of the larvae. The primary objective of this was to validate the selected genes i.e V-ATPase, VgR and chitin synthase genes (chs1 and chs2) in V. velutinaas potential targets for RNA interference (RNAi). These genes were chosen because V-ATPase is crucial for cellular processes, VgR is linked to reproduction and behavior, and Chitin Synthase is essential for larval development and molting, making them strong candidates for disrupting the hornet's life cycle. This validation is carried out using publicly available whole-genome sequencing (WGS) data, genome annotation, and RNA-Seq data from adult samples.

Methodology

The pipeline for the target gene identification can be seen in Figure 1.

Figure 1: Overview of the Methodology Pipeline for Target Gene Identification

Panel A: Collection of genomic datasets for V. velutina.

Panel B: Variant analysis within the V. velutina population. This step involved extracting all copies of the target gene sequences from V. velutina datasets, mapping them to the reference genome, and identifying exons present in all copies. Variant calling was performed to determine conserved exonic regions across V. velutina strains.

Panel C: Off-target analysis. Selected regions were analyzed using BLAST against the Apocrita clade (wasps, bees, ants) via the Apocrita database. Each selected region underwent off-target analysis, and only regions with few off-target hits were retained.

Panel D: Downstream analysis of target regions. The final target regions were selected based on intermediate GC content and low RNA secondary structure stability. Targets with highly stable secondary structures were excluded using ViennaRNA fold for secondary structure analysis.

Data Collection

We collected publicly available whole genome sequencing (WGS) data, genome annotation, and expression (RNA-Seq) data for V. velutina . Ideally we would have used WGS dataset of different V. velutina strains for this analysis but since only four WGS datasets were available we decided to incorporate four RNA-seq datasets too [see Table 1] (Vontas, Katsavou, and Mavridis 2020; Zhang, Zhang, and Zhu 2010; Lu and Shen 2024; Jin et al. 2015). All these datasets belong to adult V. velutina samples. These datasets were downloaded using sratoolkit (“Home · Ncbi/Sra-Tools Wiki · GitHub,” n.d.). The following script was used for this purpose.

            

            
        #!/bin/bash
        
        ## load required modules
        module load gcc sratoolkit
        
        # Variables
        WORKDIR="/work/FAC/FBM/DMF/yschaerl/default/Vespa_Biocontrol/00.Target_Gene"
        cd "$WORKDIR/00.Data/WGS_RNAseq_Datasets"
        
        SampleIDs="$WORKDIR/00.Data/WGS_RNAseq_Datasets/SRR_Acc_List.txt"
        OUTPUT_DIR="$WORKDIR/00.Data/WGS_RNAseq_Datasets/samples"
        OUTPUT_DIR="/nas/FAC/FBM/DMF/yschaerl/default/D2c/00.data"
        
        # Check if URL list file exists
        if [ ! -f "$SampleIDs" ]; then
            echo "URL list file not found: $SampleIDs"
            exit 1
        fi
        
        # Create output directory
        mkdir -p "$OUTPUT_DIR"
        
        # Download data
        while IFS= read -r RunID; do
            # wget -P "$OUTPUT_DIR" "$url"
            prefetch --output-directory ${OUTPUT_DIR} ${RunID}
            fasterq-dump --split-files --outdir ${OUTPUT_DIR} ${RunID}
        done < "$SampleIDs"
        
        echo "Data download completed. Files are in $OUTPUT_DIR"
            
            
        

Table 1: Datasets used for identification of potential target genes. All datasets are available at NCBI.

Data Type	Accession Number	Source Database
WGS	ERR3316181	NCBI
WGS	ERR3316182	NCBI
WGS	ERR3316183	NCBI
WGS	ERR3316184	NCBI
RNA-Seq	SRR22217221	NCBI
RNA-Seq	SRR22217222	NCBI
RNA-Seq	ERR6338384	NCBI
RNA-Seq	ERR6338396	NCBI

The quality of the downloaded data was subsequently assessed using TrimGalore (“FelixKrueger/TrimGalore: A Wrapper around Cutadapt and FastQC to Consistently Apply Adapter and Quality Trimming to FastQ Files, with Extra Functionality for RRBS Data,” n.d.) and FASTQC (“Babraham Bioinformatics - FastQC A Quality Control Tool for High Throughput Sequence Data,” n.d.) tools.

Selection of Target Gene Regions

Variant Analysis within copies/isoforms annotated in Vespa velutina genome:

The sequences of the target genes (Vacuolar ATPase, VgR, and Chitin Synthase) were extracted from the genome using the Vespa velutina genome annotation by a custom script. For each gene, all isoforms/copies were aligned using Clustal Omega (Sievers et al. 2011). The msa2vcf.py script (“Pinbo/Msa2snp: SNP and Indel Calls from Multiple Sequence Alignment (MSA),” n.d.) was then used to identify conserved exonic regions across isoforms.

          
      # Usage
      # 1. Extract Gene Sequences
      WORKDIR="/path/to/your/working/directory"
      GFF_FILE=$WORKDIR/"00.Data/GCF_912470025.1/genomic.gff"
      FASTA_FILE=$WORKDIR/"00.Data/GCF_912470025.1/GCF_912470025.1_iVesVel2.1_genomic.fna"
      TARGET_SEQ_OUT_DIR=$WORKDIR/"01.Chitin-Synthase/00.sequences"
      TARGET_SEQ_OUTPUT_FILE=$TARGET_SEQ_OUT_DIR/"V_Vespa.Chitin_Synthase.fa"
      GENE_NAME="LOC124951980"
      ./scripts/00.01.extract_gene_sequences.sh $GFF_FILE $FASTA_FILE $TARGET_SEQ_OUT_DIR $TARGET_SEQ_OUTPUT_FILE $GENE_NAME
          
      

Variant Analysis within V. velutina population:

Due to the availability of only one reference genome, we used public RNAseq and WGS datasets for V. velutina (see Table 2). These datasets were mapped to the reference genome of V. velutina, and GATK (McKenna et al. 2010) was used for variant calling on the selected gene exons to identify conserved regions within the population.

  
      # 2. Multiple Sequence Alignment and Variant Calling in cases of multicopy gene (Optional)
      ./scripts/00.02.MSA_target_gene.clustal.sh $TARGET_SEQ_OUTPUT_FILE "../01.Chitin-Synthase/01.clustal" "V_Vespa.Chitin_Synthase"
      # 3. Variant Calling
      ./scripts/01.03.map_reads.sh
      ./scripts/01.05.GATK_Variant_Calling.sh
      ./scripts/01.06.GATK_JointGenotyping.sh
  
      

Off-Target Analysis

To assess potential off-target effects, BLAST searches were performed, comparing the V. velutina chitin synthase and other target gene sequences against the genomes of non-target species. The analysis revealed that some species possess highly similar genomic regions, making it difficult to avoid off-target effects using RNAi alone. As shown in Figure 2, the potential RNAi regions are 100% identical hits (sequence matches) in Vespa Crabro (i.e., European hornet) genome. We address this challenge using our hardware (read more here: link), which integrates physical barriers with an AI tool capable of distinguishing between these genomically similar hornet species (read more here: link to AI section).

        

      
      # 4. RNAi Target Analysis
      ./scripts/01.07.RNAi_Target.sh
      
      # 5. Off-Target Analysis
      cd /path/to/your/genomes/directory
      ./datasets download genome taxon apocrita \
        --assembly-level chromosome,contig \
        --dehydrated \
        --exclude-atypical \
        --exclude-multi-isolate \
        --filename offtarget_Genomes.apcrita.subset.zip \
        --include genome
      
      unzip  offtarget_Genomes.apcrita.subset.zip -d offtarget_Genomes_apcrita_subset
      ./datasets rehydrate --directory offtarget_Genomes_apcrita_subset
      
      makeblastdb -in "$(ls ../ncbi_dataset/data/*/* |\ grep -v "alternate" | tr '\n' ' ')"\
       -dbtype nucl \
       -parse_seqids \
       -out apcrita_db
      
      # Run BLAST:
      QUERY=$WORKDIR/"01.Chitin-Synthase/02.RNAi.Target/Conserved_Exon_Regions.25_bp.Start_AA.GC.fa"
      blastn -query $QUERY \
      -db $DB_blast \
      -outfmt "6 qseqid sseqid pident length mismatch gapopen qstart qend sstart send evalue bitscore staxids sskingdoms"\
      -word_size 7 \
      -out blast_results.txt
      
      
      

Figure 2: Identification of target genes in the Asian hornet and potential off-targets.

Target sequences are indicated on the y-axis, while off-target species are given on x-axis. The scores represent the bit scores from BLAST, reflecting the sequence similarity between BLAST hits in off-target species and the RNAi target regions.

Downstream off-target analysis was conducted in R (version 4.4.1). For reproducibility of our downstream analysis, we developed an R flaxboard application for this analysis available at out gitlab. We submitted this application as our contribution (bronze medal criteria), details which can be found on contributions page [link].

Tools Used

• SRA Toolkit: For data download.
• TrimGalore and FastQC: For quality control.
• Clustal Omega: For sequence alignment.
• GATK: For variant calling.
• BLAST: For off-target analysis.
• Shiny: For interactive RNAi off-target analysis.
• msa2vcf.py: For variant analysis across isoforms.

Next Steps and Future Work

Moving forward, we plan to expand our analysis to include differential expression of target regions in larval and adult hornets. Additionally, we'll refine our off-target analysis by incorporating further RNAi efficiency metrics and enhancing the app’s functionality based on user feedback.

Shiny App for Off-Target Analysis

To streamline the off-target analysis of potential RNAi target sequences, we developed a Shiny app that provides an interactive way to visualize off-target hits from BLAST results. This app enhances reproducibility of our results. It allows users to upload BLAST output files, analyze the data, and easily generate heatmaps and summary tables.

Key Features

The user interface is designed for simplicity, featuring a sidebar for input controls and a main panel for data visualization. Users can upload input files and customize the number of species displayed in the heatmap using a slider, allowing flexible exploration of off-target effects. It shows:

• Heatmap of off-target hits across species for RNAi target sequences.
• A summary table with GC content and off-target species names.

How it works

Users upload BLAST results from their own analysis or blast_results.txt files generated by our code. The app processes the BLAST data, calculates off-target matches across various species, and generates a heatmap showing the distribution of off-target regions across different species.

A table provides additional information, including the GC content and off-target species names for each RNAi target. The heatmap helps visualize regions that might cause off-target effects, guiding the final selection of RNAi targets.

Figure 3: Shiny App Interface.

Users can upload their BLAST output files into the app for off-target analysis. The app visualizes results in an interactive heatmap and provides a summary table displaying relevant metrics such as GC content and off-target species information. This intuitive interface allows researchers to explore and assess RNAi target specificity efficiently.

This Shiny app ensures reproducibility and flexibility, making it easier for other students/researchers to reproduce the analysis and verify results for their own datasets. The app is open-source and available for download on GitLab as part of our project submission.

Image Recognition for Differentiation Between Vespa velutina and Vespa crabro

Given the genomic similarities across various hornet species, particularly within the target gene regions, it was essential to incorporate an additional layer of specificity to ensure exclusive targeting of the Asian hornet. To achieve this, we utilised an existing image recognition software VespAI, originally designed to differentiate between the Asian hornet and the European hornet (O’Shea-Wheller et al. 2024).

Methodology

Adapting VespAI model

The VespAI software, based on YOLOv5 (v6.0/6.1) deep learning model, is designed for real-time object detection (Jocher 2020). YOLOv5 breaks object detection from images and videos into three key stages: First, it uses a backbone to scan the image and pick up important features like edges and shapes. Then, in the neck, it combines those features from different parts of the image to identify objects of different sizes. Finally, the head makes the actual predictions, figuring out where the objects are and what they are. This structure enables YOLOv5 to balance speed and accuracy, making it suitable for real-time applications such as security monitoring and autonomous vehicles. In VespAI's case, it is adapted for hornet detection.

We downloaded the VespAI software from their GitHub (“Andrw3000/Vespai,” n.d.) and adapted it for our project by developing a script RunModel.py, that allowed us to import images and test its hornet identification capabilities. This script accepts an image and the frame size for model inference, generating an image with a prediction label. To ensure the software's accuracy, we curated a custom dataset of approximately 15 images, sourced from royalty-free images on iNaturalist website (“iNaturalist,” n.d.) and from experts in hornet research whom we interviewed during our human practices. This dataset was used to validate the software by comparing its results to those from the original dataset used by the VespAI creators (see Figure 4 and 5). Through this comparison, we aimed to assess how well the model performed when applied to data different from the training dataset, testing whether it could correctly differentiate between Asian and European hornets. We found that the software performs best with top-view images of the insect. Additionally, the size of the insect impacts the model’s inference (see Figure 4). While we could modify the parameter in the code to adjust the area around the Asian hornet, this change needed to be made manually for each image. Currently, automated image scaling is not supported by existing recognition methods. To simplify the process and avoid complex post-processing, we decided to use a fixed frame that would work on images taken from our box at a consistent distance (link to relevant section of the box).

                

                
                    #!/usr/bin/env python
                    import os
                    import sys
                    import cv2
                    import torch
            
                    # Check for command line arguments
                    if len(sys.argv) != 3:
                        print("Usage: python script.py <image_path> <size>")
                        sys.exit(1)
            
                    image_path = sys.argv[1]
                    size = int(sys.argv[2])
            
                    # Load the model
                    # Set root directory to the parent directory of the script location
                    root_dir = os.path.abspath('/home/igem/Desktop/iGEM_VespaDetector')
            
                    # Define paths relative to the root directory
                    yolo_dir = os.path.join(root_dir, 'vespai', 'models', 'yolov5')
                    model_dir = os.path.join(root_dir, 'vespai', 'models', 'yolov5-params', 'yolov5s-all-but-22ip.pt')
                    model = torch.hub.load(yolo_dir, 'custom', path=model_dir, source='local', _verbose=True)
            
                    # Read and prepare the image
                    img = cv2.cvtColor(cv2.imread(image_path), cv2.COLOR_BGR2RGB)
            
                    # Perform inference
                    results = model([img], size=size)
            
                    # Print results
                    results.show()
                
                
            

Integrating VespAI and hardware:

We integrated VespAI with hardware that includes a camera and servo motors using the script given below (and on our GitLab). The camera captures five images in 0.5-second intervals every 10 seconds to ensure multiple frames for model analysis, improving identification reliability. To learn more about the integration between our software and hardware, please go to our Hardware page: [LINK]

                    

                    
                      #!/usr/bin/env python
                      # modules for model
                      import os
                      import sys
                      import cv2
                      import glob
                      import torch
                  
                      # modules for Camera
                      import time
                      from picamera2 import Picamera2, Preview
                      import libcamera
    
                      from libcamera import controls
                      from datetime import datetime
                  
                      # Motor
                      from gpiozero import MotionSensor, Servo
                      from signal import pause
                      from adafruit_servokit import ServoKit
                  
                      ############################################################################
                      # SETUP directories and load AI MODEL                                      #
                      ############################################################################
                  
                      # Set root directory to the parent directory of the script location
                      root_dir = os.path.abspath('/home/igem/Desktop/iGEM_VespaDetector')
                  
                      # Define paths relative to the root directory
                      yolo_dir = os.path.join(root_dir, 'vespai', 'models', 'yolov5')
                      model_dir = os.path.join(root_dir, 'vespai', 'models', 'yolov5-params', 'yolov5s-all-but-22ip.pt')
                      save_dir = os.path.join(root_dir, 'unilausanne', 'ImageRecognitionAI', 'results')
                  
                      # Create the save directory if it doesn't exist
                      os.makedirs(save_dir, exist_ok=True)
                  
                      # Add the YOLO directory to the system path
                      sys.path.insert(0, yolo_dir)
                  
                      # Change the working directory to the YOLO directory
                      os.chdir(yolo_dir)
                  
                      # load yolo model
                      model = torch.hub.load(yolo_dir, 'custom', path=model_dir, source='local', _verbose=True)
                  
                      ############################################################################
                      # Functions                                                                #
                      ############################################################################
                  
                      def is_vespa_velutina_detected(res):
                          vespa_velutina_detected = False
                          confidence_levels = []
                          for name, confidence in zip(res["name"].items(), res["confidence"].items()):
                              if name[1] == "Vespa velutina":
                                  vespa_velutina_detected = True
                                  confidence_levels.append(confidence[1])
                          if vespa_velutina_detected and max(confidence_levels, default=0) >= 0.2:
                              return True
                          return False
                  
                      # controlling doors
                      def open_door1():
                          kit.servo[0].angle=180
                  
                      def close_door1():
                          kit.servo[0].angle=0
                  
                      def open_door3():
                          kit.servo[1].angle=0
                  
                      def close_door3():
                          kit.servo[1].angle=90
                  
                      ################################
                      #  Initialize Motor and sensor #
                      ################################
                  
                      # pi camera
                      picam = Picamera2()
                      config = picam.create_preview_configuration(main={"size": (1600, 1200)}) # resolution
                      picam.configure(config)
                      picam.start()
                      picam.set_controls({"AfMode": controls.AfModeEnum.Continuous, "AfSpeed": controls.AfSpeedEnum.Fast})
                      time.sleep(2)  # Allow the camera to focus
                  
                      # motion sensor
                      MOTION_SENSOR_PIN = 24  # Raspberry Pi GPIO pin connected to the OUTPUT pin of the motion sensor
                      motion_sensor = MotionSensor(MOTION_SENSOR_PIN)
                  
                      # Servo Pin
                      kit = ServoKit(channels=16)
                  
                      ################################
                      #  Initialize doors settings   #
                      ################################
                  
                      print("Initializing: Turing Servo1 to 180: open door 1 and close door 2")
                      open_door1()
                      time.sleep(1)
                  
                      print("Initializing: Turing Servo2 to 90: close door 3")
                      close_door3()
                      time.sleep(1)
                  
                      try:
                          while True:
                  
                              ##################
                              # CAMERA-detect  #
                              ##################
                              current_date = datetime.now().strftime("%Y-%m-%d")
                              current_time = datetime.now().strftime("%H-%M-%S")
                  
                              date_dir = os.path.join(save_dir, current_date)
                              os.makedirs(date_dir, exist_ok=True)
                  
                              time_dir = os.path.join(date_dir, current_time)
                              os.makedirs(time_dir, exist_ok=True)
                  
                              # Capture 5 images with a 0.5-second delay between each
                              for i in range(5):
                                  image_path = os.path.join(time_dir, f"image_{i}.jpg")
                                  picam.capture_file(image_path)
                                  print(f"Captured {image_path}")
                                  time.sleep(0.5)
                  
                              captured_images = sorted(glob.glob(os.path.join(time_dir, "*.jpg")))
                              imgs = [cv2.cvtColor(cv2.imread(f), cv2.COLOR_BGR2RGB) for f in captured_images]
                  
                              # Perform inference on captured images
                              results = model(imgs, size=350)
                  
                              vespa_detected = any(is_vespa_velutina_detected(result) for result in results.pandas().xyxy)
                              print(vespa_detected)
                  
                              #########
                              # MOTOR #
                  
                              if vespa_detected:
                  
                                  print("Turning servo1 180 to 0: open door 2 and close door 1")
                                  close_door1()
                                  time.sleep(1)
                  
                                  vespa_eating = True
                                  while vespa_eating:
                                      motion_sensor.wait_for_motion()
                                      print("Motion detected: Vespa is ready to leave and wipe away its generation :) !")
                                      open_door1()
                                      time.sleep(1)
                                      open_door3()
                                      time.sleep(1)
                  
                                      motion_sensor.wait_for_no_motion()
                                      close_door3()
                                      time.sleep(1)
                                      open_door1()
                                      time.sleep(1)
                                      vespa_eating = False
                  
                              else:
                                  print("Turning Servo1 from 0 to 180: open door 1 and close door 2")
                                  open_door1()
                                  time.sleep(1)
                                  close_door3()
                                  time.sleep(1)
                  
                      except KeyboardInterrupt:
                          GPIO.cleanup()
               
                    
                
                  

We also considered different scenarios that might occur in the field and integrated these into our software and hardware. For example, if both an Asian and a European hornet appear in the frame together, the door that makes the protein bait accessible will not open, as the system requires clearer identification. However, if an Asian hornet and another insect, such as a bee or fly, are present, the door will open, since the model is not currently trained to differentiate between non-hornet insects. This limitation presents an opportunity for future development, where we can apply transfer learning techniques to further refine the model, enabling it to accurately detect other insects and prevent false triggers within our specific box setup.

We also tested the script on off-targets (see Figures 2 and 6), especially on the species found in the target gene identification process. The results show that the species that are at risk of being affected by our RNA interference strategy would be spared thanks to our hardware with VespAI integration. All these off-target species are detected as non V. velutina by VespAI and hence would not be provided access to the protein bait area.

Future Directions:

Since the Asian hornet is yet understudied, it is not easy to find many images for this invasive species. Thereby, in the future we would like to explore the opportunity to train the image recognition model with synthetic images to allow the study of such understudied species. Additionally, we would like to apply transfer learning techniques to further refine the model, enabling it to accurately detect other non-hornet insects and prevent false triggers within our box setup.

References

• Vontas, John, Eva Katsavou, and Konstantinos Mavridis. 2020. “Cytochrome P450-Based Metabolic Insecticide Resistance in Anopheles and Aedes Mosquito Vectors: Muddying the Waters.” Pesticide Biochemistry and Physiology 170 (November): 104666. https://doi.org/10.1016/j.pestbp.2020.104666.
• Zhang, X., J. Zhang, and K. Y. Zhu. 2010. “Chitosan/Double-Stranded RNA Nanoparticle-Mediated RNA Interference to Silence Chitin Synthase Genes through Larval Feeding in the African Malaria Mosquito (Anopheles Gambiae).” Insect Molecular Biology 19 (5): 683–93. https://doi.org/10.1111/j.1365-2583.2010.01029.x.
• Lu, Juan, and Jie Shen. 2024. “Target Genes for RNAi in Pest Control: A Comprehensive Overview.” March. https://www.schweizerbart.de/papers/entomologia/detail/44/104639/Target_genes_for_RNAi_in_pest_control_A_comprehensive_overview.
• Jin, Shuangxia, Nameirakpam D. Singh, Lebin Li, Xianlong Zhang, and Henry Daniell. 2015. “Engineered Chloroplast dsRNA Silences Cytochrome P450 Monooxygenase, V-ATPase and Chitin Synthase Genes in the Insect Gut and Disrupts Helicoverpa Armigera Larval Development and Pupation.” Plant Biotechnology Journal 13 (3): 435–46. https://doi.org/10.1111/pbi.12355.
• “Home · NCBI/SRA-Tools Wiki · GitHub.” n.d. Accessed August 27, 2024. https://github.com/ncbi/sra-tools/wiki.
• “FelixKrueger/TrimGalore: A Wrapper around Cutadapt and FastQC to Consistently Apply Adapter and Quality Trimming to FastQ Files, with Extra Functionality for RRBS Data.” n.d. Accessed September 29, 2024. https://github.com/FelixKrueger/TrimGalore.
• “Babraham Bioinformatics - FastQC A Quality Control Tool for High Throughput Sequence Data.” n.d. Accessed September 29, 2024. https://www.bioinformatics.babraham.ac.uk/projects/fastqc/.
• Sievers, Fabian, Andreas Wilm, David Dineen, Toby J. Gibson, Kevin Karplus, Weizhong Li, Rodrigo Lopez, et al. 2011. “Fast, Scalable Generation of High-Quality Protein Multiple Sequence Alignments Using Clustal Omega.” Molecular Systems Biology 7 (October): 539. https://doi.org/10.1038/msb.2011.75.
• “Pinbo/Msa2snp: SNP and Indel Calls from Multiple Sequence Alignment (MSA).” n.d. Accessed September 27, 2024. https://github.com/pinbo/msa2snp.
• McKenna, Aaron, Matthew Hanna, Eric Banks, Andrey Sivachenko, Kristian Cibulskis, Andrew Kernytsky, Kiran Garimella, et al. 2010. “The Genome Analysis Toolkit: A MapReduce Framework for Analyzing next-Generation DNA Sequencing Data.” September. https://doi.org/10.1101/gr.107524.110.
• Camacho, Christiam, George Coulouris, Vahram Avagyan, Ning Ma, Jason Papadopoulos, Kevin Bealer, and Thomas L. Madden. 2009. “BLAST+: Architecture and Applications.” BMC Bioinformatics 10 (1): 421. https://doi.org/10.1186/1471-2105-10-421.
• O’Shea-Wheller, Thomas A., Andrew Corbett, Juliet L. Osborne, Mario Recker, and Peter J. Kennedy. 2024. “VespAI: A Deep Learning-Based System for the Detection of Invasive Hornets.” Communications Biology 7 (1): 1–11. https://doi.org/10.1038/s42003-024-05979-z.