From e8cc7a379fff352a94f20f271fbbe19219985ec4 Mon Sep 17 00:00:00 2001
From: ivan-aksamentov <ivan.aksamentov@gmail.com>
Date: Tue, 5 Sep 2023 02:32:25 +0200
Subject: [PATCH] feat(web): add sequence sorting prototype

---
 .../src/cli/nextclade_seq_sort.rs             |  8 +-
 packages_rs/nextclade-web/src/build.rs        |  5 ++
 .../components/Autodetect/AutodetectPage.tsx  | 89 +++++++++++++++++++
 .../src/components/Main/DatasetCurrent.tsx    | 44 ++++-----
 .../src/components/Main/DatasetInfo.tsx       | 24 +++++
 .../components/Main/DatasetSelectorList.tsx   | 22 +++++
 .../Main/MainInputFormSequenceFilePicker.tsx  | 16 +++-
 .../src/hooks/useRunSeqAutodetect.ts          | 58 ++++++++++++
 .../nextclade-web/src/io/fetchDatasets.ts     | 24 +++--
 .../src/io/fetchDatasetsIndex.ts              | 28 +++++-
 packages_rs/nextclade-web/src/lib.rs          |  8 ++
 packages_rs/nextclade-web/src/pages/_app.tsx  | 18 +++-
 .../nextclade-web/src/pages/autodetect.tsx    |  1 +
 .../src/state/autodetect.state.ts             | 68 ++++++++++++++
 .../nextclade-web/src/state/dataset.state.ts  | 12 ++-
 packages_rs/nextclade-web/src/wasm/jserr.rs   |  8 ++
 packages_rs/nextclade-web/src/wasm/main.rs    | 12 +--
 packages_rs/nextclade-web/src/wasm/mod.rs     |  2 +
 .../nextclade-web/src/wasm/seq_autodetect.rs  | 59 ++++++++++++
 .../src/workers/launchAnalysis.ts             |  2 +-
 .../src/workers/nextcladeAutodetect.worker.ts | 60 +++++++++++++
 .../src/workers/nextcladeWasm.worker.ts       |  4 +-
 .../nextclade/src/sort/minimizer_search.rs    |  7 ++
 23 files changed, 518 insertions(+), 61 deletions(-)
 create mode 100644 packages_rs/nextclade-web/src/components/Autodetect/AutodetectPage.tsx
 create mode 100644 packages_rs/nextclade-web/src/hooks/useRunSeqAutodetect.ts
 create mode 100644 packages_rs/nextclade-web/src/pages/autodetect.tsx
 create mode 100644 packages_rs/nextclade-web/src/state/autodetect.state.ts
 create mode 100644 packages_rs/nextclade-web/src/wasm/jserr.rs
 create mode 100644 packages_rs/nextclade-web/src/wasm/seq_autodetect.rs
 create mode 100644 packages_rs/nextclade-web/src/workers/nextcladeAutodetect.worker.ts

diff --git a/packages_rs/nextclade-cli/src/cli/nextclade_seq_sort.rs b/packages_rs/nextclade-cli/src/cli/nextclade_seq_sort.rs
index 8cdbe6a6ae..670537bf51 100644
--- a/packages_rs/nextclade-cli/src/cli/nextclade_seq_sort.rs
+++ b/packages_rs/nextclade-cli/src/cli/nextclade_seq_sort.rs
@@ -7,7 +7,7 @@ use log::{info, trace, LevelFilter};
 use nextclade::io::fasta::{FastaReader, FastaRecord, FastaWriter};
 use nextclade::make_error;
 use nextclade::sort::minimizer_index::{MinimizerIndexJson, MINIMIZER_INDEX_ALGO_VERSION};
-use nextclade::sort::minimizer_search::{run_minimizer_search, MinimizerSearchResult};
+use nextclade::sort::minimizer_search::{run_minimizer_search, MinimizerSearchRecord};
 use nextclade::utils::string::truncate;
 use serde::Serialize;
 use std::collections::BTreeMap;
@@ -15,12 +15,6 @@ use std::path::PathBuf;
 use std::str::FromStr;
 use tinytemplate::TinyTemplate;
 
-#[derive(Debug, Clone)]
-struct MinimizerSearchRecord {
-  pub fasta_record: FastaRecord,
-  pub result: MinimizerSearchResult,
-}
-
 pub fn nextclade_seq_sort(args: &NextcladeSeqSortArgs) -> Result<(), Report> {
   check_args(args)?;
 
diff --git a/packages_rs/nextclade-web/src/build.rs b/packages_rs/nextclade-web/src/build.rs
index 9d6b85f9e4..6dcd7284b4 100644
--- a/packages_rs/nextclade-web/src/build.rs
+++ b/packages_rs/nextclade-web/src/build.rs
@@ -16,6 +16,8 @@ use nextclade::qc::qc_run::QcResult;
 use nextclade::run::nextclade_wasm::{
   AnalysisInitialData, AnalysisInput, NextcladeParams, NextcladeParamsRaw, NextcladeResult, OutputTrees,
 };
+use nextclade::sort::minimizer_index::MinimizerIndexJson;
+use nextclade::sort::minimizer_search::{MinimizerSearchRecord, MinimizerSearchResult};
 use nextclade::translate::translate_genes::Translation;
 use nextclade::tree::tree::{AuspiceTree, CladeNodeAttrKeyDesc};
 use nextclade::types::outputs::{NextcladeErrorOutputs, NextcladeOutputs};
@@ -73,4 +75,7 @@ struct _SchemaRoot<'a> {
   _27: DatasetAttributeValue,
   _28: DatasetAttributes,
   _29: DatasetCollectionUrl,
+  _30: MinimizerIndexJson,
+  _31: MinimizerSearchResult,
+  _32: MinimizerSearchRecord,
 }
diff --git a/packages_rs/nextclade-web/src/components/Autodetect/AutodetectPage.tsx b/packages_rs/nextclade-web/src/components/Autodetect/AutodetectPage.tsx
new file mode 100644
index 0000000000..122620cf85
--- /dev/null
+++ b/packages_rs/nextclade-web/src/components/Autodetect/AutodetectPage.tsx
@@ -0,0 +1,89 @@
+import React from 'react'
+import { Col as ColBase, Row as RowBase } from 'reactstrap'
+import { useRecoilValue } from 'recoil'
+import { TableSlimWithBorders } from 'src/components/Common/TableSlim'
+import { Layout } from 'src/components/Layout/Layout'
+import { useTranslationSafe } from 'src/helpers/useTranslationSafe'
+import { autodetectResultsAtom } from 'src/state/autodetect.state'
+import styled from 'styled-components'
+
+const Container = styled.div`
+  margin-top: 1rem;
+  height: 100%;
+  overflow: hidden;
+`
+
+const Row = styled(RowBase)`
+  overflow: hidden;
+  height: 100%;
+`
+
+const Col = styled(ColBase)`
+  overflow: hidden;
+  height: 100%;
+`
+
+const Table = styled(TableSlimWithBorders)`
+  padding-top: 50px;
+
+  & thead {
+    height: 51px;
+    position: sticky;
+    top: -2px;
+    background-color: ${(props) => props.theme.gray700};
+    color: ${(props) => props.theme.gray100};
+  }
+
+  & thead th {
+    margin: auto;
+    text-align: center;
+    vertical-align: middle;
+  }
+`
+
+const TableWrapper = styled.div`
+  height: 100%;
+  overflow-y: auto;
+`
+
+export function AutodetectPage() {
+  const { t } = useTranslationSafe()
+  // const minimizerIndex = useRecoilValue(minimizerIndexAtom)
+  const autodetectResults = useRecoilValue(autodetectResultsAtom)
+
+  return (
+    <Layout>
+      <Container>
+        <Row noGutters>
+          <Col>
+            <TableWrapper>
+              <Table striped>
+                <thead>
+                  <tr>
+                    <th>{'#'}</th>
+                    <th>{t('Seq. name')}</th>
+                    <th>{t('dataset')}</th>
+                    <th>{t('total hits')}</th>
+                    <th>{t('max hit')}</th>
+                  </tr>
+                </thead>
+
+                <tbody>
+                  {autodetectResults.map((res) => (
+                    <tr key={res.fastaRecord.index}>
+                      <td>{res.fastaRecord.index}</td>
+                      <td>{res.fastaRecord.seqName}</td>
+                      <td>{res.result.dataset ?? ''}</td>
+                      <td>{res.result.totalHits}</td>
+                      <td>{res.result.maxNormalizedHit.toFixed(3)}</td>
+                    </tr>
+                  ))}
+                </tbody>
+              </Table>
+            </TableWrapper>
+          </Col>
+        </Row>
+      </Container>
+    </Layout>
+  )
+}
diff --git a/packages_rs/nextclade-web/src/components/Main/DatasetCurrent.tsx b/packages_rs/nextclade-web/src/components/Main/DatasetCurrent.tsx
index af08072012..0c4d5167e4 100644
--- a/packages_rs/nextclade-web/src/components/Main/DatasetCurrent.tsx
+++ b/packages_rs/nextclade-web/src/components/Main/DatasetCurrent.tsx
@@ -1,5 +1,5 @@
 import { isNil } from 'lodash'
-import React, { useCallback, useState } from 'react'
+import React, { useCallback, useMemo, useState } from 'react'
 import { Button, Col, Collapse, Row, UncontrolledAlert } from 'reactstrap'
 import { useRecoilState, useRecoilValue, useResetRecoilState, useSetRecoilState } from 'recoil'
 import styled from 'styled-components'
@@ -82,6 +82,28 @@ export function DatasetCurrent() {
 
   const onCustomizeClicked = useCallback(() => setAdvancedOpen((advancedOpen) => !advancedOpen), [])
 
+  const customize = useMemo(() => {
+    if (datasetCurrent?.path === 'autodetect') {
+      return null
+    }
+
+    return (
+      <Row noGutters>
+        <Col>
+          <ButtonCustomize isOpen={advancedOpen} onClick={onCustomizeClicked} />
+
+          <Collapse isOpen={advancedOpen}>
+            <AdvancedModeExplanationWrapper>
+              <AdvancedModeExplanationContent />
+            </AdvancedModeExplanationWrapper>
+
+            <FilePickerAdvanced />
+          </Collapse>
+        </Col>
+      </Row>
+    )
+  }, [advancedOpen, datasetCurrent?.path, onCustomizeClicked])
+
   if (!datasetCurrent) {
     return null
   }
@@ -105,29 +127,11 @@ export function DatasetCurrent() {
               <ChangeButton type="button" color="secondary" onClick={onChangeClicked}>
                 {t('Change')}
               </ChangeButton>
-              <LinkExternal
-                className="ml-auto mt-auto"
-                href="https://github.com/nextstrain/nextclade_data/blob/release/CHANGELOG.md"
-              >
-                <small>{t('Recent dataset updates')}</small>
-              </LinkExternal>
             </Right>
           </Col>
         </Row>
 
-        <Row noGutters>
-          <Col>
-            <ButtonCustomize isOpen={advancedOpen} onClick={onCustomizeClicked} />
-
-            <Collapse isOpen={advancedOpen}>
-              <AdvancedModeExplanationWrapper>
-                <AdvancedModeExplanationContent />
-              </AdvancedModeExplanationWrapper>
-
-              <FilePickerAdvanced />
-            </Collapse>
-          </Col>
-        </Row>
+        {customize}
       </CurrentDatasetInfoBody>
     </CurrentDatasetInfoContainer>
   )
diff --git a/packages_rs/nextclade-web/src/components/Main/DatasetInfo.tsx b/packages_rs/nextclade-web/src/components/Main/DatasetInfo.tsx
index 0ea36038c6..adb5af26c8 100644
--- a/packages_rs/nextclade-web/src/components/Main/DatasetInfo.tsx
+++ b/packages_rs/nextclade-web/src/components/Main/DatasetInfo.tsx
@@ -21,6 +21,11 @@ export const DatasetInfoLine = styled.p`
   font-size: 0.9rem;
   padding: 0;
   margin: 0;
+
+  &:after {
+    content: ' ';
+    white-space: pre;
+  }
 `
 
 const DatasetInfoBadge = styled(Badge)`
@@ -50,6 +55,10 @@ export function DatasetInfo({ dataset }: DatasetInfoProps) {
     return null
   }
 
+  if (path === 'autodetect') {
+    return <DatasetAutodetectInfo />
+  }
+
   return (
     <DatasetInfoContainer>
       <DatasetName>
@@ -107,3 +116,18 @@ export function DatasetInfo({ dataset }: DatasetInfoProps) {
     </DatasetInfoContainer>
   )
 }
+
+export function DatasetAutodetectInfo() {
+  const { t } = useTranslationSafe()
+
+  return (
+    <DatasetInfoContainer>
+      <DatasetName>
+        <span>{t('Autodetect')}</span>
+      </DatasetName>
+      <DatasetInfoLine>{t('Detect pathogen automatically from sequences')}</DatasetInfoLine>
+      <DatasetInfoLine />
+      <DatasetInfoLine />
+    </DatasetInfoContainer>
+  )
+}
diff --git a/packages_rs/nextclade-web/src/components/Main/DatasetSelectorList.tsx b/packages_rs/nextclade-web/src/components/Main/DatasetSelectorList.tsx
index 6ccdafb799..d2f148b684 100644
--- a/packages_rs/nextclade-web/src/components/Main/DatasetSelectorList.tsx
+++ b/packages_rs/nextclade-web/src/components/Main/DatasetSelectorList.tsx
@@ -18,6 +18,20 @@ import { DatasetInfo } from 'src/components/Main/DatasetInfo'
 //   border-radius: 5px;
 // `
 
+const DATASET_AUTODETECT: Dataset = {
+  path: 'autodetect',
+  enabled: true,
+  official: true,
+  attributes: {
+    name: { value: 'autodetect', valueFriendly: 'Autodetect' },
+    reference: { value: 'autodetect', valueFriendly: 'Autodetect' },
+  },
+  files: {
+    reference: '',
+    pathogenJson: '',
+  },
+}
+
 export const DatasetSelectorUl = styled(ListGroup)`
   flex: 1;
   overflow-y: scroll;
@@ -79,6 +93,14 @@ export function DatasetSelectorList({
   return (
     // <DatasetSelectorContainer>
     <DatasetSelectorUl>
+      {
+        <DatasetSelectorListItem
+          dataset={DATASET_AUTODETECT}
+          onClick={onItemClick(DATASET_AUTODETECT)}
+          isCurrent={areDatasetsEqual(DATASET_AUTODETECT, datasetHighlighted)}
+        />
+      }
+
       {[itemsStartWith, itemsInclude].map((datasets) =>
         datasets.map((dataset) => (
           <DatasetSelectorListItem
diff --git a/packages_rs/nextclade-web/src/components/Main/MainInputFormSequenceFilePicker.tsx b/packages_rs/nextclade-web/src/components/Main/MainInputFormSequenceFilePicker.tsx
index 8b9a0f25ae..afc8a2e8c1 100644
--- a/packages_rs/nextclade-web/src/components/Main/MainInputFormSequenceFilePicker.tsx
+++ b/packages_rs/nextclade-web/src/components/Main/MainInputFormSequenceFilePicker.tsx
@@ -4,6 +4,7 @@ import { Button, Col, Form, FormGroup, Row } from 'reactstrap'
 import { useRecoilState, useRecoilValue } from 'recoil'
 import { MainInputFormSequencesCurrent } from 'src/components/Main/MainInputFormSequencesCurrent'
 import { useRunAnalysis } from 'src/hooks/useRunAnalysis'
+import { useRunSeqAutodetect } from 'src/hooks/useRunSeqAutodetect'
 import { canRunAtom } from 'src/state/results.state'
 import styled from 'styled-components'
 
@@ -46,12 +47,20 @@ export function MainInputFormSequenceFilePicker() {
 
   const icon = useMemo(() => <FileIconFasta />, [])
 
-  const run = useRunAnalysis()
+  const runAnalysis = useRunAnalysis()
+  const runAutodetect = useRunSeqAutodetect()
+
+  const run = useCallback(() => {
+    if (datasetCurrent?.path === 'autodetect') {
+      runAutodetect()
+    } else {
+      runAnalysis()
+    }
+  }, [datasetCurrent?.path, runAnalysis, runAutodetect])
 
   const setSequences = useCallback(
     (inputs: AlgorithmInput[]) => {
       addQryInputs(inputs)
-
       if (shouldRunAutomatically) {
         run()
       }
@@ -62,7 +71,6 @@ export function MainInputFormSequenceFilePicker() {
   const setExampleSequences = useCallback(() => {
     if (datasetCurrent) {
       addQryInputs([new AlgorithmInputDefault(datasetCurrent)])
-
       if (shouldRunAutomatically) {
         run()
       }
@@ -81,7 +89,7 @@ export function MainInputFormSequenceFilePicker() {
   }, [canRun, hasInputErrors, hasRequiredInputs, t])
 
   const LoadExampleLink = useMemo(() => {
-    const cannotLoadExample = hasInputErrors || !datasetCurrent
+    const cannotLoadExample = hasInputErrors || !datasetCurrent || datasetCurrent.path === 'autodetect'
     return (
       <Button color="link" onClick={setExampleSequences} disabled={cannotLoadExample}>
         {t('Load example')}
diff --git a/packages_rs/nextclade-web/src/hooks/useRunSeqAutodetect.ts b/packages_rs/nextclade-web/src/hooks/useRunSeqAutodetect.ts
new file mode 100644
index 0000000000..5a88e510ce
--- /dev/null
+++ b/packages_rs/nextclade-web/src/hooks/useRunSeqAutodetect.ts
@@ -0,0 +1,58 @@
+import { useRouter } from 'next/router'
+import { NextcladeSeqAutodetectWasm } from 'src/gen/nextclade-wasm'
+import { useRecoilCallback } from 'recoil'
+import { ErrorInternal } from 'src/helpers/ErrorInternal'
+import { axiosFetch } from 'src/io/axiosFetch'
+import { autodetectResultAtom, autodetectResultsAtom, minimizerIndexAtom } from 'src/state/autodetect.state'
+import { minimizerIndexVersionAtom } from 'src/state/dataset.state'
+import { MinimizerIndexJson, MinimizerSearchRecord } from 'src/types'
+import { qrySeqInputsStorageAtom } from 'src/state/inputs.state'
+import { getQueryFasta } from 'src/workers/launchAnalysis'
+
+export function useRunSeqAutodetect() {
+  const router = useRouter()
+
+  return useRecoilCallback(
+    ({ set, reset, snapshot: { getPromise } }) =>
+      () => {
+        reset(minimizerIndexAtom)
+        reset(autodetectResultsAtom)
+
+        void router.push('/autodetect', '/autodetect') // eslint-disable-line no-void
+
+        function onResult(res: MinimizerSearchRecord) {
+          set(autodetectResultAtom(res.fastaRecord.index), res)
+        }
+
+        Promise.all([getPromise(qrySeqInputsStorageAtom), getPromise(minimizerIndexVersionAtom)])
+          .then(async ([qrySeqInputs, minimizerIndexVersion]) => {
+            if (!minimizerIndexVersion) {
+              throw new ErrorInternal('Tried to run minimizer search without minimizer index available')
+            }
+            const fasta = await getQueryFasta(qrySeqInputs)
+            const minimizerIndex: MinimizerIndexJson = await axiosFetch(minimizerIndexVersion.path)
+            set(minimizerIndexAtom, minimizerIndex)
+            return runAutodetect(fasta, minimizerIndex, onResult)
+          })
+          .catch((error) => {
+            throw error
+          })
+      },
+    [router],
+  )
+}
+
+function runAutodetect(
+  fasta: string,
+  minimizerIndex: MinimizerIndexJson,
+  onResult: (res: MinimizerSearchRecord) => void,
+) {
+  const nextcladeAutodetect = NextcladeSeqAutodetectWasm.new(JSON.stringify(minimizerIndex))
+
+  function onResultParsed(resStr: string) {
+    const result = JSON.parse(resStr) as MinimizerSearchRecord
+    onResult(result)
+  }
+
+  nextcladeAutodetect.autodetect(fasta, onResultParsed)
+}
diff --git a/packages_rs/nextclade-web/src/io/fetchDatasets.ts b/packages_rs/nextclade-web/src/io/fetchDatasets.ts
index a21063d58e..7f4515d101 100644
--- a/packages_rs/nextclade-web/src/io/fetchDatasets.ts
+++ b/packages_rs/nextclade-web/src/io/fetchDatasets.ts
@@ -9,11 +9,18 @@ import {
   fetchDatasetsIndex,
   filterDatasets,
   findDataset,
+  getCompatibleMinimizerIndexVersion,
   getLatestCompatibleEnabledDatasets,
 } from 'src/io/fetchDatasetsIndex'
 import { getQueryParamMaybe } from 'src/io/getQueryParamMaybe'
 import { useRecoilValue, useSetRecoilState } from 'recoil'
-import { datasetCurrentAtom, datasetsAtom, datasetUpdatedAtom } from 'src/state/dataset.state'
+import {
+  datasetCurrentAtom,
+  datasetsAtom,
+  datasetServerUrlAtom,
+  datasetUpdatedAtom,
+  minimizerIndexVersionAtom,
+} from 'src/state/dataset.state'
 import { useQuery } from 'react-query'
 import { isNil } from 'lodash'
 import urljoin from 'url-join'
@@ -100,27 +107,30 @@ export async function getDatasetServerUrl(urlQuery: ParsedUrlQuery) {
   return toAbsoluteUrl(datasetServerUrl)
 }
 
-export async function initializeDatasets(urlQuery: ParsedUrlQuery) {
-  const datasetServerUrl = await getDatasetServerUrl(urlQuery)
-
+export async function initializeDatasets(datasetServerUrl: string, urlQuery: ParsedUrlQuery = {}) {
   const datasetsIndexJson = await fetchDatasetsIndex(datasetServerUrl)
 
   const { datasets } = getLatestCompatibleEnabledDatasets(datasetServerUrl, datasetsIndexJson)
 
+  const minimizerIndexVersion = await getCompatibleMinimizerIndexVersion(datasetServerUrl, datasetsIndexJson)
+
   // Check if URL params specify dataset params and try to find the corresponding dataset
   const currentDataset = await getDatasetFromUrlParams(urlQuery, datasets)
 
-  return { datasets, currentDataset }
+  return { datasets, currentDataset, minimizerIndexVersion }
 }
 
 /** Refetch dataset index periodically and update the local copy of if */
 export function useUpdatedDatasetIndex() {
+  const datasetServerUrl = useRecoilValue(datasetServerUrlAtom)
   const setDatasetsState = useSetRecoilState(datasetsAtom)
+  const setMinimizerIndexVersion = useSetRecoilState(minimizerIndexVersionAtom)
   useQuery(
     'refetchDatasetIndex',
     async () => {
-      const { currentDataset: _, ...datasetsState } = await initializeDatasets({})
-      setDatasetsState(datasetsState)
+      const { currentDataset: _, minimizerIndexVersion, ...datasets } = await initializeDatasets(datasetServerUrl)
+      setDatasetsState(datasets)
+      setMinimizerIndexVersion(minimizerIndexVersion)
     },
     {
       suspense: false,
diff --git a/packages_rs/nextclade-web/src/io/fetchDatasetsIndex.ts b/packages_rs/nextclade-web/src/io/fetchDatasetsIndex.ts
index d39e3403f9..c1690972f5 100644
--- a/packages_rs/nextclade-web/src/io/fetchDatasetsIndex.ts
+++ b/packages_rs/nextclade-web/src/io/fetchDatasetsIndex.ts
@@ -1,19 +1,21 @@
 import { head, mapValues, sortBy, sortedUniq } from 'lodash'
 import semver from 'semver'
+import { takeFirstMaybe } from 'src/helpers/takeFirstMaybe'
 import urljoin from 'url-join'
 
-import { Dataset, DatasetFiles, DatasetsIndexJson, DatasetsIndexV2Json } from 'src/types'
+import { Dataset, DatasetFiles, DatasetsIndexJson, DatasetsIndexV2Json, MinimizerIndexVersion } from 'src/types'
 import { axiosFetch } from 'src/io/axiosFetch'
 
-const thisVersion = process.env.PACKAGE_VERSION ?? ''
+const MINIMIZER_INDEX_ALGO_VERSION = 'v1'
+const PACKAGE_VERSION = process.env.PACKAGE_VERSION ?? ''
 
 export function isEnabled(dataset: Dataset) {
   return dataset.enabled
 }
 
 export function isCompatible(dataset: Dataset): boolean {
-  const minVersion = dataset.version?.compatibility?.web ?? thisVersion
-  return semver.gte(thisVersion, minVersion)
+  const minVersion = dataset.version?.compatibility?.web ?? PACKAGE_VERSION
+  return semver.gte(PACKAGE_VERSION, minVersion)
 }
 
 export function isLatest(dataset: Dataset): boolean {
@@ -60,3 +62,21 @@ export function filterDatasets(datasets: Dataset[], name?: string, tag?: string)
 export async function fetchDatasetsIndex(datasetServerUrl: string) {
   return axiosFetch<DatasetsIndexJson>(urljoin(datasetServerUrl, 'index.json'))
 }
+
+export async function getCompatibleMinimizerIndexVersion(
+  datasetServerUrl: string,
+  datasetsIndexJson: DatasetsIndexV2Json,
+): Promise<MinimizerIndexVersion | undefined> {
+  let candidates = datasetsIndexJson.minimizerIndex?.filter(
+    (minimizerIndexVer) => MINIMIZER_INDEX_ALGO_VERSION >= minimizerIndexVer.version,
+  )
+  candidates = sortBy(candidates, (candidate) => candidate.version).reverse()
+  const index = takeFirstMaybe(candidates)
+  if (index) {
+    return {
+      ...index,
+      path: urljoin(datasetServerUrl, index.path),
+    }
+  }
+  return undefined
+}
diff --git a/packages_rs/nextclade-web/src/lib.rs b/packages_rs/nextclade-web/src/lib.rs
index f539b360fa..c2c9a50cbe 100644
--- a/packages_rs/nextclade-web/src/lib.rs
+++ b/packages_rs/nextclade-web/src/lib.rs
@@ -1 +1,9 @@
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(start)]
+pub fn main() {
+  wasm_logger::init(wasm_logger::Config::default());
+  console_error_panic_hook::set_once();
+}
+
 mod wasm;
diff --git a/packages_rs/nextclade-web/src/pages/_app.tsx b/packages_rs/nextclade-web/src/pages/_app.tsx
index 20868096e7..660d78ce65 100644
--- a/packages_rs/nextclade-web/src/pages/_app.tsx
+++ b/packages_rs/nextclade-web/src/pages/_app.tsx
@@ -39,7 +39,7 @@ import { ReactQueryDevtools } from 'react-query/devtools'
 
 import { DOMAIN_STRIPPED } from 'src/constants'
 import { parseUrl } from 'src/helpers/parseUrl'
-import { initializeDatasets } from 'src/io/fetchDatasets'
+import { getDatasetServerUrl, initializeDatasets } from 'src/io/fetchDatasets'
 import { fetchSingleDataset } from 'src/io/fetchSingleDataset'
 import { ErrorPopup } from 'src/components/Error/ErrorPopup'
 import Loading from 'src/components/Loading/Loading'
@@ -48,7 +48,12 @@ import { SEO } from 'src/components/Common/SEO'
 import { Plausible } from 'src/components/Common/Plausible'
 import i18n, { changeLocale, getLocaleWithKey } from 'src/i18n/i18n'
 import { theme } from 'src/theme'
-import { datasetCurrentAtom, datasetsAtom } from 'src/state/dataset.state'
+import {
+  datasetCurrentAtom,
+  datasetsAtom,
+  datasetServerUrlAtom,
+  minimizerIndexVersionAtom,
+} from 'src/state/dataset.state'
 import { ErrorBoundary } from 'src/components/Error/ErrorBoundary'
 import { PreviewWarning } from 'src/components/Common/PreviewWarning'
 
@@ -99,7 +104,11 @@ export function RecoilStateInitializer() {
           return datasetInfo
         }
 
-        return initializeDatasets(urlQuery)
+        const datasetServerUrl = await getDatasetServerUrl(urlQuery)
+        set(datasetServerUrlAtom, datasetServerUrl)
+
+        const { datasets, currentDataset, minimizerIndexVersion } = await initializeDatasets(datasetServerUrl, urlQuery)
+        return { datasets, currentDataset, minimizerIndexVersion }
       })
       .catch((error) => {
         // Dataset error is fatal and we want error to be handled in the ErrorBoundary
@@ -107,11 +116,12 @@ export function RecoilStateInitializer() {
         set(globalErrorAtom, sanitizeError(error))
         throw error
       })
-      .then(async ({ datasets, currentDataset }) => {
+      .then(async ({ datasets, currentDataset, minimizerIndexVersion }) => {
         set(datasetsAtom, { datasets })
         const previousDataset = await getPromise(datasetCurrentAtom)
         const dataset = currentDataset ?? previousDataset
         set(datasetCurrentAtom, dataset)
+        set(minimizerIndexVersionAtom, minimizerIndexVersion)
         return dataset
       })
       .then((dataset) => {
diff --git a/packages_rs/nextclade-web/src/pages/autodetect.tsx b/packages_rs/nextclade-web/src/pages/autodetect.tsx
new file mode 100644
index 0000000000..3e1888fdb5
--- /dev/null
+++ b/packages_rs/nextclade-web/src/pages/autodetect.tsx
@@ -0,0 +1 @@
+export { AutodetectPage as default } from 'src/components/Autodetect/AutodetectPage'
diff --git a/packages_rs/nextclade-web/src/state/autodetect.state.ts b/packages_rs/nextclade-web/src/state/autodetect.state.ts
new file mode 100644
index 0000000000..280b180c2f
--- /dev/null
+++ b/packages_rs/nextclade-web/src/state/autodetect.state.ts
@@ -0,0 +1,68 @@
+import { atom, atomFamily, DefaultValue, selector, selectorFamily } from 'recoil'
+import type { MinimizerIndexJson, MinimizerSearchRecord } from 'src/types'
+import { isDefaultValue } from 'src/state/utils/isDefaultValue'
+
+export const minimizerIndexAtom = atom<MinimizerIndexJson>({
+  key: 'minimizerIndexAtom',
+})
+
+const autodetectResultInternalAtom = atomFamily<MinimizerSearchRecord, number>({
+  key: 'autodetectResultInternalAtom',
+})
+
+export const autodetectResultIndicesAtom = atom<number[]>({
+  key: 'autodetectResultIndicesAtom',
+  default: [],
+})
+
+export const autodetectResultAtom = selectorFamily<MinimizerSearchRecord, number>({
+  key: 'autodetectResultAtom',
+
+  get:
+    (index: number) =>
+    ({ get }): MinimizerSearchRecord => {
+      return get(autodetectResultInternalAtom(index))
+    },
+
+  set:
+    (index) =>
+    ({ set, reset }, result: MinimizerSearchRecord | DefaultValue) => {
+      if (isDefaultValue(result)) {
+        reset(autodetectResultInternalAtom(index))
+        reset(autodetectResultIndicesAtom)
+      } else {
+        set(autodetectResultInternalAtom(index), result)
+
+        // Add to the list of indices
+        set(autodetectResultIndicesAtom, (prev) => {
+          if (result && !prev.includes(result.fastaRecord.index)) {
+            return [...prev, result.fastaRecord.index]
+          }
+          return prev
+        })
+      }
+    },
+})
+
+export const autodetectResultsAtom = selector<MinimizerSearchRecord[]>({
+  key: 'analysisResults',
+
+  get({ get }): MinimizerSearchRecord[] {
+    const indices = get(autodetectResultIndicesAtom)
+    return indices.map((index) => get(autodetectResultAtom(index)))
+  },
+
+  set({ get, set, reset }, results: MinimizerSearchRecord[] | DefaultValue) {
+    const seqIndices = get(autodetectResultIndicesAtom)
+
+    // Remove all results
+    seqIndices.forEach((index) => {
+      reset(autodetectResultAtom(index))
+    })
+
+    // If the operation is not 'reset', add the new items
+    if (!isDefaultValue(results)) {
+      results.forEach((result) => set(autodetectResultAtom(result.fastaRecord.index), result))
+    }
+  },
+})
diff --git a/packages_rs/nextclade-web/src/state/dataset.state.ts b/packages_rs/nextclade-web/src/state/dataset.state.ts
index b0c7cb6a44..913ffee912 100644
--- a/packages_rs/nextclade-web/src/state/dataset.state.ts
+++ b/packages_rs/nextclade-web/src/state/dataset.state.ts
@@ -1,7 +1,7 @@
 import { isNil } from 'lodash'
 import { atom, DefaultValue, selector } from 'recoil'
 
-import type { Dataset } from 'src/types'
+import type { Dataset, MinimizerIndexVersion } from 'src/types'
 // import { GENE_OPTION_NUC_SEQUENCE } from 'src/constants'
 import { inputResetAtom } from 'src/state/inputs.state'
 import { persistAtom } from 'src/state/persist/localStorage'
@@ -13,6 +13,11 @@ export interface Datasets {
   datasets: Dataset[]
 }
 
+export const datasetServerUrlAtom = atom<string>({
+  key: 'datasetServerUrlAtom',
+  default: '/',
+})
+
 export const datasetsAtom = atom<Datasets>({
   key: 'datasets',
 })
@@ -55,3 +60,8 @@ export const geneOrderPreferenceAtom = selector({
     return []
   },
 })
+
+export const minimizerIndexVersionAtom = atom<MinimizerIndexVersion | undefined>({
+  key: 'minimizerIndexVersionAtom',
+  default: undefined,
+})
diff --git a/packages_rs/nextclade-web/src/wasm/jserr.rs b/packages_rs/nextclade-web/src/wasm/jserr.rs
new file mode 100644
index 0000000000..a581af4aa3
--- /dev/null
+++ b/packages_rs/nextclade-web/src/wasm/jserr.rs
@@ -0,0 +1,8 @@
+use eyre::Report;
+use nextclade::utils::error::report_to_string;
+use wasm_bindgen::JsError;
+
+/// Converts Result's Err variant from eyre::Report to wasm_bindgen::JsError
+pub fn jserr<T>(result: Result<T, Report>) -> Result<T, JsError> {
+  result.map_err(|report| JsError::new(&report_to_string(&report)))
+}
diff --git a/packages_rs/nextclade-web/src/wasm/main.rs b/packages_rs/nextclade-web/src/wasm/main.rs
index e370f8c013..cac8bb9533 100644
--- a/packages_rs/nextclade-web/src/wasm/main.rs
+++ b/packages_rs/nextclade-web/src/wasm/main.rs
@@ -1,3 +1,4 @@
+use crate::wasm::jserr::jserr;
 use eyre::{Report, WrapErr};
 use itertools::Itertools;
 use nextclade::analyze::virus_properties::{AaMotifsDesc, PhenotypeAttrDesc};
@@ -14,11 +15,6 @@ use std::io::Read;
 use std::str::FromStr;
 use wasm_bindgen::prelude::*;
 
-/// Converts Result's Err variant from eyre::Report to wasm_bindgen::JsError
-fn jserr<T>(result: Result<T, Report>) -> Result<T, JsError> {
-  result.map_err(|report| JsError::new(&report_to_string(&report)))
-}
-
 /// Nextclade WebAssembly module.
 ///
 /// Encapsulates all the Nextclade Rust functionality required for Nextclade Web to operate.
@@ -211,9 +207,3 @@ impl NextcladeWasm {
     ))
   }
 }
-
-#[wasm_bindgen(start)]
-pub fn main() {
-  wasm_logger::init(wasm_logger::Config::default());
-  console_error_panic_hook::set_once();
-}
diff --git a/packages_rs/nextclade-web/src/wasm/mod.rs b/packages_rs/nextclade-web/src/wasm/mod.rs
index 2a043412b4..b5f7dee461 100644
--- a/packages_rs/nextclade-web/src/wasm/mod.rs
+++ b/packages_rs/nextclade-web/src/wasm/mod.rs
@@ -1 +1,3 @@
+pub mod jserr;
 pub mod main;
+pub mod seq_autodetect;
diff --git a/packages_rs/nextclade-web/src/wasm/seq_autodetect.rs b/packages_rs/nextclade-web/src/wasm/seq_autodetect.rs
new file mode 100644
index 0000000000..54cbeab85e
--- /dev/null
+++ b/packages_rs/nextclade-web/src/wasm/seq_autodetect.rs
@@ -0,0 +1,59 @@
+use crate::wasm::jserr::jserr;
+use eyre::WrapErr;
+use nextclade::io::fasta::{FastaReader, FastaRecord};
+use nextclade::io::json::{json_stringify, JsonPretty};
+use nextclade::sort::minimizer_index::MinimizerIndexJson;
+use nextclade::sort::minimizer_search::{run_minimizer_search, MinimizerSearchRecord};
+use nextclade::sort::params::NextcladeSeqSortParams;
+use std::io::Read;
+use std::str::FromStr;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub struct NextcladeSeqAutodetectWasm {
+  minimizer_index: MinimizerIndexJson,
+  search_params: NextcladeSeqSortParams,
+}
+
+#[wasm_bindgen]
+impl NextcladeSeqAutodetectWasm {
+  pub fn new(minimizer_index_json_str: &str) -> Result<NextcladeSeqAutodetectWasm, JsError> {
+    let minimizer_index = jserr(MinimizerIndexJson::from_str(minimizer_index_json_str))?;
+    Ok(Self {
+      minimizer_index,
+      search_params: NextcladeSeqSortParams::default(),
+    })
+  }
+
+  pub fn autodetect(&self, qry_fasta_str: &str, callback: &js_sys::Function) -> Result<(), JsError> {
+    let mut reader = jserr(FastaReader::from_str(&qry_fasta_str).wrap_err_with(|| "When creating fasta reader"))?;
+
+    loop {
+      let mut fasta_record = FastaRecord::default();
+      jserr(reader.read(&mut fasta_record).wrap_err("When reading a fasta record"))?;
+      if fasta_record.is_empty() {
+        break;
+      }
+
+      let result = jserr(
+        run_minimizer_search(&fasta_record, &self.minimizer_index, &self.search_params).wrap_err_with(|| {
+          format!(
+            "When processing sequence #{} '{}'",
+            fasta_record.index, fasta_record.seq_name
+          )
+        }),
+      )?;
+
+      let result_json = jserr(json_stringify(
+        &MinimizerSearchRecord { fasta_record, result },
+        JsonPretty(false),
+      ))?;
+
+      callback
+        .call1(&JsValue::null(), &JsValue::from_str(&result_json))
+        .map_err(|err_val| JsError::new(&format!("{err_val:#?}")))?;
+    }
+
+    Ok(())
+  }
+}
diff --git a/packages_rs/nextclade-web/src/workers/launchAnalysis.ts b/packages_rs/nextclade-web/src/workers/launchAnalysis.ts
index cc4b1c27ec..f7af20736c 100644
--- a/packages_rs/nextclade-web/src/workers/launchAnalysis.ts
+++ b/packages_rs/nextclade-web/src/workers/launchAnalysis.ts
@@ -88,7 +88,7 @@ export async function launchAnalysis(
   }
 }
 
-async function getQueryFasta(inputs: AlgorithmInput[]) {
+export async function getQueryFasta(inputs: AlgorithmInput[]) {
   if (isEmpty(inputs)) {
     throw new Error('Sequence fasta data is not available, but required')
   }
diff --git a/packages_rs/nextclade-web/src/workers/nextcladeAutodetect.worker.ts b/packages_rs/nextclade-web/src/workers/nextcladeAutodetect.worker.ts
new file mode 100644
index 0000000000..c56b3f5b72
--- /dev/null
+++ b/packages_rs/nextclade-web/src/workers/nextcladeAutodetect.worker.ts
@@ -0,0 +1,60 @@
+import 'regenerator-runtime'
+import { ErrorInternal } from 'src/helpers/ErrorInternal'
+import { MinimizerSearchResult } from 'src/types'
+import type { Thread } from 'threads'
+import { expose } from 'threads/worker'
+import { NextcladeSeqAutodetectWasm } from 'src/gen/nextclade-wasm'
+
+/**
+ * Keeps the reference to the WebAssembly module.The module is stateful and requires manual initialization
+ * and teardown.
+ * This cloud be a class instance, but unfortunately we cannot pass classes to/from WebWorkers (yet?).
+ */
+let nextcladeAutodetect: NextcladeSeqAutodetectWasm | undefined
+
+/** Creates the underlying WebAssembly module. */
+async function create(minimizerIndexJsonStr: string) {
+  nextcladeAutodetect = NextcladeSeqAutodetectWasm.new(JSON.stringify(minimizerIndexJsonStr))
+}
+
+/** Destroys the underlying WebAssembly module. */
+async function destroy() {
+  if (!nextcladeAutodetect) {
+    return
+  }
+
+  nextcladeAutodetect.free()
+  nextcladeAutodetect = undefined
+}
+
+async function autodetect(fasta: string, onResult: (r: MinimizerSearchResult) => void): Promise<void> {
+  if (!nextcladeAutodetect) {
+    throw new ErrorModuleNotInitialized('autodetect')
+  }
+
+  function onResultParsed(resStr: string) {
+    const result = JSON.parse(resStr) as MinimizerSearchResult
+    onResult(result)
+  }
+
+  nextcladeAutodetect.autodetect(fasta, onResultParsed)
+}
+
+const worker = {
+  create,
+  destroy,
+  autodetect,
+}
+
+expose(worker)
+
+export type NextcladeSeqAutodetectWasmWorker = typeof worker
+export type NextcladeSeqAutodetectWasmThread = NextcladeSeqAutodetectWasmWorker & Thread
+
+export class ErrorModuleNotInitialized extends ErrorInternal {
+  constructor(fnName: string) {
+    super(
+      `This WebWorker module has not been initialized yet. When calling module.${fnName} Make sure to call 'module.create()' function.`,
+    )
+  }
+}
diff --git a/packages_rs/nextclade-web/src/workers/nextcladeWasm.worker.ts b/packages_rs/nextclade-web/src/workers/nextcladeWasm.worker.ts
index 940f17667f..df51a0a029 100644
--- a/packages_rs/nextclade-web/src/workers/nextcladeWasm.worker.ts
+++ b/packages_rs/nextclade-web/src/workers/nextcladeWasm.worker.ts
@@ -75,8 +75,8 @@ async function getInitialData(): Promise<AnalysisInitialData> {
   if (!nextcladeWasm) {
     throw new ErrorModuleNotInitialized('getInitialData')
   }
-  const aaa = nextcladeWasm.get_initial_data()
-  const initialData = JSON.parse(aaa) as AnalysisInitialData
+  const initialDataStr = nextcladeWasm.get_initial_data()
+  const initialData = JSON.parse(initialDataStr) as AnalysisInitialData
   return {
     ...initialData,
     geneMap: prepareGeneMap(initialData.geneMap),
diff --git a/packages_rs/nextclade/src/sort/minimizer_search.rs b/packages_rs/nextclade/src/sort/minimizer_search.rs
index 112ca1a08f..afd136d2c4 100644
--- a/packages_rs/nextclade/src/sort/minimizer_search.rs
+++ b/packages_rs/nextclade/src/sort/minimizer_search.rs
@@ -17,6 +17,13 @@ pub struct MinimizerSearchResult {
   pub max_normalized_hit: f64,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct MinimizerSearchRecord {
+  pub fasta_record: FastaRecord,
+  pub result: MinimizerSearchResult,
+}
+
 #[allow(clippy::string_slice)]
 pub fn run_minimizer_search(
   fasta_record: &FastaRecord,