diff --git a/.circleci/config.yml b/.circleci/config.yml
index 140e3116d..52d58fc09 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -1,52 +1,6 @@
 version: 2.1
 jobs:
-  build-with-wormhole:
-    docker:
-      - image: 'emscripten/emsdk:3.1.8'
-    resource_class: medium
-
-    working_directory: ~/checkout
-
-    steps:
-      - checkout
-
-      - run:
-          name: Build WASM WORMHOLE
-          command: |
-            bash build-wasm.sh WORMHOLE
-
-      - run:
-          name: Check artifacts
-          working_directory: build-wasm
-          command: |
-            ARTIFACT_BASE="bergamot-translator-worker"
-            ARTIFACT_SUFFIX="with-wormhole"
-            ARTIFACT_FINAL=$ARTIFACT_BASE-$ARTIFACT_SUFFIX
-
-            if [[ -f "$ARTIFACT_BASE.js" && -f "$ARTIFACT_BASE.wasm" ]]; then
-              echo "Artifacts Successfully Generated"
-              mkdir ../artifacts
-              cp $ARTIFACT_BASE.wasm ../artifacts/$ARTIFACT_FINAL.wasm
-              cp $ARTIFACT_BASE.js ../artifacts/$ARTIFACT_FINAL.js
-              cd ../artifacts
-              shasum -a 256 $ARTIFACT_FINAL.wasm $ARTIFACT_FINAL.js >> sha256-filesize-$ARTIFACT_SUFFIX
-              ls -lsa $ARTIFACT_FINAL.wasm $ARTIFACT_FINAL.js >> sha256-filesize-$ARTIFACT_SUFFIX
-              cp ../BERGAMOT_VERSION .
-            else
-              echo "Failure: Artifacts Not Present"
-              exit 1
-            fi
-
-      - persist_to_workspace:
-          root: .
-          paths:
-            - artifacts/*
-
-      - store_artifacts:
-          path: "artifacts"
-          destination: "wasm-wormhole"
-
-  build-without-wormhole:
+  build:
     docker:
       - image: 'emscripten/emsdk:3.1.8'
     resource_class: medium
@@ -66,8 +20,7 @@ jobs:
           working_directory: build-wasm
           command: |
             ARTIFACT_BASE="bergamot-translator-worker"
-            ARTIFACT_SUFFIX="without-wormhole"
-            ARTIFACT_FINAL=$ARTIFACT_BASE-$ARTIFACT_SUFFIX
+            ARTIFACT_FINAL=$ARTIFACT_BASE
 
             if [[ -f "$ARTIFACT_BASE.js" && -f "$ARTIFACT_BASE.wasm" ]]; then
               echo "Artifacts Successfully Generated"
@@ -75,8 +28,8 @@ jobs:
               cp $ARTIFACT_BASE.wasm ../artifacts/$ARTIFACT_FINAL.wasm
               cp $ARTIFACT_BASE.js ../artifacts/$ARTIFACT_FINAL.js
               cd ../artifacts
-              shasum -a 256 $ARTIFACT_FINAL.wasm $ARTIFACT_FINAL.js >> sha256-filesize-$ARTIFACT_SUFFIX
-              ls -lsa $ARTIFACT_FINAL.wasm $ARTIFACT_FINAL.js >> sha256-filesize-$ARTIFACT_SUFFIX
+              shasum -a 256 $ARTIFACT_FINAL.wasm $ARTIFACT_FINAL.js >> sha256-filesize
+              ls -lsa $ARTIFACT_FINAL.wasm $ARTIFACT_FINAL.js >> sha256-filesize
             else
               echo "Failure: Artifacts Not Present"
               exit 1
@@ -89,7 +42,7 @@ jobs:
 
       - store_artifacts:
           path: "artifacts"
-          destination: "wasm-without-wormhole"
+          destination: "wasm"
 
   publish_to_github:
     docker:
@@ -106,18 +59,13 @@ jobs:
                 name: "Publish Release on GitHub"
                 command: |
                   export TAG_VERSION=$(cat ./artifacts/BERGAMOT_VERSION)
-                  cat ./artifacts/sha256-filesize-without-wormhole ./artifacts/sha256-filesize-with-wormhole >> ./artifacts/sha256-filesize
-                  rm ./artifacts/sha256-filesize-without-wormhole ./artifacts/sha256-filesize-with-wormhole ./artifacts/BERGAMOT_VERSION
+                  rm ./artifacts/BERGAMOT_VERSION
                   ghr -t ${GHTOKEN} -u ${CIRCLE_PROJECT_USERNAME} -r ${CIRCLE_PROJECT_REPONAME} -c ${CIRCLE_SHA1} -delete ${TAG_VERSION} ./artifacts/
 
 workflows:
   build:
       jobs:
-          - build-with-wormhole:
-              filters:
-                tags:
-                  only: /^v.*/
-          - build-without-wormhole:
+          - build:
               filters:
                 tags:
                   only: /^v.*/
@@ -128,7 +76,6 @@ workflows:
                 branches:
                   ignore: /.*/
               requires:
-                - build-without-wormhole
-                - build-with-wormhole
+                - build
 
 
diff --git a/.github/workflows/arm.yml b/.github/workflows/arm.yml
new file mode 100644
index 000000000..2ee14548d
--- /dev/null
+++ b/.github/workflows/arm.yml
@@ -0,0 +1,139 @@
+name: ARM
+'on':
+  push:
+    branches:
+    - main
+    - ci-sandbox
+  pull_request:
+    branches:
+    - '**'
+env:
+  ccache_basedir: ${{ github.workspace }}
+  ccache_dir: "${{ github.workspace }}/.ccache"
+  ccache_compilercheck: content
+  ccache_compress: 'true'
+  ccache_compresslevel: 9
+  ccache_maxsize: 200M
+  ccache_cmake: -DCMAKE_CXX_COMPILER_LAUNCHER=ccache -DCMAKE_C_COMPILER_LAUNCHER=ccache
+  ndk: "${{ github.workspace }}/android-ndk-r23b"
+  abi: "arm64-v8a"
+  minsdk_version : 28
+  android_platform: 28
+
+jobs:
+  ubuntu:
+    name: "arm-v8a cross-compile via Android NDK"
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+      with:
+        submodules: recursive
+
+    - name: Install prerequisites
+      run: |
+          wget -c --quiet https://dl.google.com/android/repository/android-ndk-r23b-linux.zip
+          unzip -qq android-ndk-r23b-linux.zip
+          sudo apt-get -y install ccache cmake
+
+    - name: Generate ccache_vars for ccache based on machine
+      shell: bash
+      id: ccache_vars
+      run: |-
+        echo "::set-output name=hash::$(echo ${{ env.ccache_compilercheck }})"
+        echo "::set-output name=timestamp::$(date '+%Y-%m-%dT%H.%M.%S')"
+
+    - name: Cache-op for build-cache through ccache
+      uses: actions/cache@v2
+      with:
+        path: ${{ env.ccache_dir }}
+        key: ccache-${{ matrix.identifier }}-${{ steps.ccache_vars.outputs.hash }}-${{ github.ref }}-${{ steps.ccache_vars.outputs.timestamp }}
+        restore-keys: |-
+          ccache-${{ matrix.identifier }}-${{ steps.ccache_vars.outputs.hash }}-${{ github.ref }}
+          ccache-${{ matrix.identifier }}-${{ steps.ccache_vars.outputs.hash }}
+          ccache-${{ matrix.identifier }}
+
+    - name: ccache environment setup
+      run: |-
+        echo "CCACHE_COMPILER_CHECK=${{ env.ccache_compilercheck }}" >> $GITHUB_ENV
+        echo "CCACHE_BASEDIR=${{ env.ccache_basedir }}" >> $GITHUB_ENV
+        echo "CCACHE_COMPRESS=${{ env.ccache_compress }}" >> $GITHUB_ENV
+        echo "CCACHE_COMPRESSLEVEL=${{ env.ccache_compresslevel }}" >> $GITHUB_ENV
+        echo "CCACHE_DIR=${{ env.ccache_dir }}" >> $GITHUB_ENV
+        echo "CCACHE_MAXSIZE=${{ env.ccache_maxsize }}" >> $GITHUB_ENV
+
+    - name: ccache prolog
+      run: |-
+        ccache -s # Print current cache stats
+        ccache -z # Zero cache entry
+
+    - name: Generate buildfiles for bergamot-translator on android via cmake
+      run: |-
+        mkdir -p build 
+        cd build
+        NDK=${{ env.ndk }}
+        ABI=${{ env.abi }}
+        MINSDK_VERSION=${{ env.minsdk_version }}
+        ANDROID_PLATFORM=android-${{ env.android_platform }}
+        OTHER_ANDROID_ARGS=(
+            -DANDROID_ARM_NEON=TRUE
+        )
+        OTHER_MARIAN_ARGS=(
+            -DCOMPILE_CUDA=off
+            -DCOMPILE_CPU=on
+            -DCMAKE_HAVE_THREADS_LIBRARY=1
+            -DCMAKE_USE_WIN32_THREADS_INIT=0
+            -DCMAKE_USE_PTHREADS_INIT=1
+            -DTHREADS_PREFER_PTHREAD_FLAG=ON
+            -DBUILD_ARCH=armv8-a
+            # -DCOMPILE_WITHOUT_EXCEPTIONS=on # Apparently this can reduce the binary size, let's see.
+            -DSSPLIT_USE_INTERNAL_PCRE2=ON
+        )
+        # Additionally list variables finally configured.
+        cmake -L \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_TOOLCHAIN_FILE=$NDK/build/cmake/android.toolchain.cmake \
+            -DANDROID_TOOLCHAIN=clang \
+            -DANDROID_ABI=$ABI \
+            -DANDROID_PLATFORM=$ANDROID_PLATFORM \
+            -DANDROID_NATIVE_API_LEVEL=$MINSDKVERSION \
+            -DANDROID_TOOLCHAIN_NAME=arm-linux-androideabi-4.8 \
+            -DANDROID_STL=c++_static \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache -DCMAKE_C_COMPILER_LAUNCHER=ccache \
+            "${OTHER_ANDROID_ARGS[@]}" "${OTHER_MARIAN_ARGS[@]}" \
+            ..
+
+
+    - name : Build bergamot-translator for android
+      working-directory: build
+      run: |-
+          make -j2 
+
+    - name: ccache epilog
+      run: 'ccache -s # Print current cache stats'
+
+    - uses: actions/upload-artifact@v2
+      with:
+        path: ${{github.workspace}}/build/app/bergamot
+
+
+  # Disable release for now.
+  # release:
+  #   name: Release Latest Build
+  #   runs-on: ubuntu-latest
+  #   needs: [ubuntu]
+  #   if: github.ref == 'refs/heads/master'
+  #   steps:
+  #    - name: Download artifacts
+  #      uses: actions/download-artifact@v2
+  #     
+  #    - name: Update GitHub prerelease
+  #      uses: marvinpinto/action-automatic-releases@latest
+  #      with:
+  #        repo_token: ${{ secrets.GITHUB_TOKEN }}
+  #        automatic_release_tag: latest
+  #        prerelease: true
+  #        title: "Latest Build"
+  #        files: |
+  #          artifact/marian-decoder
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index da3c37018..830924c2c 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -21,215 +21,143 @@ env:
   ccache_cmake: -DCMAKE_CXX_COMPILER_LAUNCHER=ccache -DCMAKE_C_COMPILER_LAUNCHER=ccache
 
 jobs:
-    python-ubuntu:
+    build-wheels:
       strategy:
-        fail-fast: false
         matrix:
-          include:
-              - name: "Ubuntu 18.04 / py3.6"
-                os: "ubuntu-18.04"
-                python-version: "3.6"
-              - name: "Ubuntu 18.04 / py3.7"
-                os: "ubuntu-18.04"
-                python-version: "3.7"
-              - name: "Ubuntu 20.04 / py3.8"
-                os: "ubuntu-20.04"
-                python-version: "3.8"
-              - name: "Ubuntu 20.04 / py3.9"
-                os: "ubuntu-20.04"
-                python-version: "3.9"
-              - name: "Ubuntu 20.04 / py3.10"
-                os: "ubuntu-20.04"
-                python-version: "3.10"
-
-      name: ${{ matrix.name }}
-      runs-on: ${{ matrix.os }}
-      steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-        with:
-          submodules: recursive
-
-      - name: Set up Python
-        uses: actions/setup-python@v2
-        with:
-          python-version: ${{ matrix.python-version }}
-
-
-      - name: Install Dependencies
-        run: |-
-          sudo apt-get update
-          sudo apt-get install -y \
-            ccache  libprotobuf-dev protobuf-compiler \
-            python3-setuptools python3-pybind11 
-
-      - name: Install MKL
-        run: |-
-          wget -qO- "https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS-2019.PUB" | sudo apt-key add -
-          sudo sh -c "echo deb https://apt.repos.intel.com/mkl all main > /etc/apt/sources.list.d/intel-mkl.list"
-          sudo apt-get update -o Dir::Etc::sourcelist="/etc/apt/sources.list.d/intel-mkl.list"
-          sudo apt-get install -y --no-install-recommends intel-mkl-64bit-2020.0-088
-
-      - name: Generate ccache_vars for ccache based on machine
-        shell: bash
-        id: ccache_vars
-        run: |-
-          echo "::set-output name=hash::$(echo ${{ env.ccache_compilercheck }})"
-          echo "::set-output name=timestamp::$(date '+%Y-%m-%dT%H.%M.%S')"
-
-      - name: Cache-op for build-cache through ccache
-        uses: actions/cache@v2
-        with:
-          path: ${{ env.ccache_dir }}
-          key: ccache-${{ matrix.name }}-${{ steps.ccache_vars.outputs.hash }}-${{ github.ref }}-${{ steps.ccache_vars.outputs.timestamp }}
-          restore-keys: |-
-            ccache-${{ matrix.name }}-${{ steps.ccache_vars.outputs.hash }}-${{ github.ref }}
-            ccache-${{ matrix.name }}-${{ steps.ccache_vars.outputs.hash }}
-            ccache-${{ matrix.name }}
-      - name: ccache environment setup
-        run: |-
-          echo "CCACHE_COMPILER_CHECK=${{ env.ccache_compilercheck }}" >> $GITHUB_ENV
-          echo "CCACHE_BASEDIR=${{ env.ccache_basedir }}" >> $GITHUB_ENV
-          echo "CCACHE_COMPRESS=${{ env.ccache_compress }}" >> $GITHUB_ENV
-          echo "CCACHE_COMPRESSLEVEL=${{ env.ccache_compresslevel }}" >> $GITHUB_ENV
-          echo "CCACHE_DIR=${{ env.ccache_dir }}" >> $GITHUB_ENV
-          echo "CCACHE_MAXSIZE=${{ env.ccache_maxsize }}" >> $GITHUB_ENV
-
-      - name: ccache prolog
-        run: |-
-          ccache -s # Print current cache stats
-          ccache -z # Zero cache entry
-
-      - name: Inject local version identifier for non tag builds
-        if: ${{ !startsWith(github.ref, 'refs/tags/v') }}
-        run: |-
-          echo "PYTHON_LOCAL_VERSION_IDENTIFIER=$(git rev-parse --short HEAD)" >> $GITHUB_ENV
+          os: [ubuntu-latest, macos-latest]
+        fail-fast: false
 
-      - name: setup.py 
-        run: |-
-          python3 -m pip install wheel
-          BUILD_ARCH=core-avx-i python3 setup.py bdist_wheel --universal
+      name: "cibuildwheel / ${{ matrix.os }}"
+      runs-on: ${{ matrix.os }}
 
-      # We're happy with just compile for the moment, so cache gets some seeding.
-      - name: Install onto root python lib
-        run: |-
-          python3 -m pip install --ignore-installed dist/bergamot-*.whl 
+      steps:
+        - uses: actions/checkout@v2
+          with:
+            submodules: recursive
 
-      - name: Fetch models from translateLocally repository.
-        run: |-
-          python3 -m bergamot download -m en-de-tiny
-          python3 -m bergamot download -m de-en-tiny
-          python3 -m bergamot ls
+        - name: Generate ccache_vars for ccache based on machine
+          shell: bash
+          id: ccache_vars
+          run: |-
+            echo "::set-output name=hash::$(echo ${{ env.ccache_compilercheck }})"
+            echo "::set-output name=timestamp::$(date '+%Y-%m-%dT%H.%M.%S')"
 
-      - name: Fetch models from opus repository.
-        run: |-
-          python3 -m bergamot download -m eng-fin-tiny -r opus
-          python3 -m bergamot ls -r opus
+        - name: Cache-op for build-cache through ccache
+          uses: actions/cache@v2
+          with:
+            path: ${{ env.ccache_dir }}
+            key: ccache-cibuildwheel-${{ matrix.os }}-${{ steps.ccache_vars.outputs.hash }}-${{ github.ref }}-${{ steps.ccache_vars.outputs.timestamp }}
+            restore-keys: |-
+              ccache-cibuildwheel-${{ matrix.os }}-${{ steps.ccache_vars.outputs.hash }}-${{ github.ref }}
+              ccache-cibuildwheel-${{ matrix.os }}-${{ steps.ccache_vars.outputs.hash }}
+              ccache-cibuildwheel-${{ matrix.os }}
 
-      - name: Run the sample python script shipped with module
-        run: |-
-          python3 -m bergamot translate --model en-de-tiny <<< "Hello World"
-          python3 -m bergamot translate --model en-de-tiny de-en-tiny <<< "Hello World"
-          python3 -m bergamot translate --model eng-fin-tiny --repository opus <<< "Hello World"
+        - name: ccache environment setup
+          run: |-
+            mkdir -p ${{ env.ccache_dir }}
 
-      - name: ccache epilog
-        run: 'ccache -s # Print current cache stats'
+        - name: Inject local version identifier for non tag builds
+          if: ${{ !startsWith(github.ref, 'refs/tags/v') }}
+          run: |-
+            echo "PYTHON_LOCAL_VERSION_IDENTIFIER=$(git rev-parse --short HEAD)" >> $GITHUB_ENV
 
-      - uses: actions/upload-artifact@v2
-        with:
-            path: ${{github.workspace}}/dist/bergamot-*.whl
+        - name: Apply MacOS patch
+          if: ${{ startsWith(runner.os, 'mac') }}
+          run: |
+            patch -p1 < patches/01-marian-fstream-for-macos.patch
 
+        - name: Build wheels
+          uses: pypa/cibuildwheel@v2.6.1
+          # to supply options, put them in 'env', like:
+          env:
+            CIBW_ENVIRONMENT_LINUX:
+              BUILD_ARCH=core-avx-i
+              USE_CCACHE=1
+              CCACHE_COMPILER_CHECK=${{ env.ccache_compilercheck }}
+              CCACHE_COMPRESS=${{ env.ccache_compress }}
+              CCACHE_COMPRESSLEVEL=${{ env.ccache_compresslevel }}
+              CCACHE_MAXSIZE=${{ env.ccache_maxsize }}
+              PYTHON_LOCAL_VERSION_IDENTIFIER=${{ env.PYTHON_LOCAL_VERSION_IDENTIFIER }}
+              CCACHE_DIR=/host/${{ env.ccache_dir }}
+              CCACHE_BASEDIR=/host/${{ env.ccache_basedir }}
+
+            CIBW_ENVIRONMENT_MACOS:
+              BUILD_ARCH=core-avx-i
+              USE_CCACHE=1
+              CCACHE_COMPILER_CHECK=${{ env.ccache_compilercheck }}
+              CCACHE_COMPRESS=${{ env.ccache_compress }}
+              CCACHE_COMPRESSLEVEL=${{ env.ccache_compresslevel }}
+              CCACHE_MAXSIZE=${{ env.ccache_maxsize }}
+              PYTHON_LOCAL_VERSION_IDENTIFIER=${{ env.PYTHON_LOCAL_VERSION_IDENTIFIER }}
+              CCACHE_DIR=${{ env.ccache_dir }}
+              CCACHE_BASEDIR=${{ env.ccache_basedir }}
+              MACOSX_DEPLOYMENT_TARGET=10.9
+
+            CIBW_BEFORE_BUILD_LINUX: |
+              yum install -y ccache
+
+              # Install Intel MKL.
+              yum-config-manager -y --add-repo https://yum.repos.intel.com/mkl/setup/intel-mkl.repo
+              yum install -y intel-mkl
+
+              chmod -R a+rwx /host/${{ env.ccache_dir }}
+
+              ccache -s # Print current cache stats
+              ccache -z # Zero cache entry
+
+            CIBW_BEFORE_BUILD_MACOS: |
+              brew install openblas protobuf ccache boost pybind11
+              chmod -R a+rwx ${{ env.ccache_dir }}
+              ccache -s # Print current cache stats
+              ccache -z # Zero cache entry
+
+            CIBW_BUILD: "cp{36,37,38,39,310}-*manylinux_x86_64 cp{36,37,38,39,310}-macosx_x86_64"
+
+            CIBW_BEFORE_TEST: |
+              ccache -s # Print current ccache stats
+
+            CIBW_TEST_COMMAND: |
+              # The wheels are installed automatically and available.
+
+              # Fetch models from translateLocally repository.
+              python3 -m bergamot download -m en-de-tiny
+              python3 -m bergamot download -m de-en-tiny
+              python3 -m bergamot ls
+
+              # Fetch models from opus repository.
+              python3 -m bergamot download -m eng-fin-tiny -r opus
+              python3 -m bergamot ls -r opus
+
+              # Run the sample python script shipped with module
+              python3 -m bergamot translate --model en-de-tiny <<< "Hello World"
+              python3 -m bergamot translate --model en-de-tiny de-en-tiny <<< "Hello World"
+              python3 -m bergamot translate --model eng-fin-tiny --repository opus <<< "Hello World"
+
+
+        - uses: actions/upload-artifact@v2
+          with:
+            name: wheels
+            path: ./wheelhouse/*.whl
 
-    python-macos:
-      name: "MacOS 10.15 / py3.10"
-      runs-on: "macos-10.15"
+    upload-wheels:
+      name: "Upload wheels to PyPI"
+      runs-on: ubuntu-latest
+      if: ${{ startsWith(github.ref, 'refs/tags/v') }}
+      needs: [build-wheels]
       steps:
-      - name: Checkout
-        uses: actions/checkout@v2
+      - name: Download artifacts
+        uses: actions/download-artifact@v2
         with:
-          submodules: recursive
-      - name: Install Dependencies
-        run: |-
-          brew update
-          brew install openblas protobuf ccache boost pybind11 
-          brew install coreutils findutils libarchive 
+          name: wheels
 
-      - name: Generate ccache_vars for ccache based on machine
-        shell: bash
-        id: ccache_vars
-        run: |-
-          echo "::set-output name=hash::$(echo ${{ env.ccache_compilercheck }})"
-          echo "::set-output name=timestamp::$(date '+%Y-%m-%dT%H.%M.%S')"
-      - name: Cache-op for build-cache through ccache
-        uses: actions/cache@v2
-        with:
-          path: ${{ env.ccache_dir }}
-          key: ccache-${{ job.id }}-${{ steps.ccache_vars.outputs.hash }}-${{ github.ref }}-${{ steps.ccache_vars.outputs.timestamp }}
-          restore-keys: |-
-            ccache-${{ job.id }}-${{ steps.ccache_vars.outputs.hash }}-${{ github.ref }}
-            ccache-${{ job.id }}-${{ steps.ccache_vars.outputs.hash }}
-            ccache-${{ job.id }}
-
-      - name: ccache environment setup
-        run: |-
-          echo "CCACHE_COMPILER_CHECK=${{ env.ccache_compilercheck }}" >> $GITHUB_ENV
-          echo "CCACHE_BASEDIR=${{ env.ccache_basedir }}" >> $GITHUB_ENV
-          echo "CCACHE_COMPRESS=${{ env.ccache_compress }}" >> $GITHUB_ENV
-          echo "CCACHE_COMPRESSLEVEL=${{ env.ccache_compresslevel }}" >> $GITHUB_ENV
-          echo "CCACHE_DIR=${{ env.ccache_dir }}" >> $GITHUB_ENV
-          echo "CCACHE_MAXSIZE=${{ env.ccache_maxsize }}" >> $GITHUB_ENV
-
-      - name: ccache prolog
-        run: |-
-          ccache -s # Print current cache stats
-          ccache -z # Zero cache entry
-
-      - name: Apply required patches
-        run: |-
-            patch -p1 < patches/01-marian-fstream-for-macos.patch
-
-      # Appears to be required per GitHub CI; 
-      - name: Set MACOSX DEPLOYMENT TARGET via environment variable
-        run: |-
-            echo "MACOSX_DEPLOYMENT_TARGET=10.15" >> $GITHUB_ENV
-
-      - name: Inject local version identifier for non tag builds
-        if: ${{ !startsWith(github.ref, 'refs/tags/v') }}
-        run: |-
-          echo "PYTHON_LOCAL_VERSION_IDENTIFIER=$(git rev-parse --short HEAD)" >> $GITHUB_ENV
-
-      - name: setup.py 
-        run: |-
-          python3 -m pip install --upgrade packaging wheel
-          BUILD_ARCH=core-avx-i python3 setup.py bdist_wheel --universal
-
-      # We're happy with just compile for the moment, so cache gets some seeding.
-      - name: Install onto root python lib
-        run: |-
-          python3 -m pip install dist/bergamot-*.whl 
-
-      - name: Fetch models from translateLocally repository.
-        run: |-
-          python3 -m bergamot download -m en-de-tiny
-          python3 -m bergamot download -m de-en-tiny
-
-      - name: Fetch models from opus repository.
-        run: |-
-          python3 -m bergamot download -m eng-fin-tiny -r opus
-          python3 -m bergamot ls -r opus
-
-      - name: Run the sample python script shipped with module
-        run: |-
-          python3 -m bergamot translate --model en-de-tiny <<< "Hello World"
-          python3 -m bergamot translate --model en-de-tiny de-en-tiny <<< "Hello World"
-          python3 -m bergamot translate --model eng-fin-tiny --repository opus <<< "Hello World"
-
-      - name: ccache epilog
-        run: 'ccache -s # Print current cache stats'
+      - name: Publish wheels to PyPI
+        env:
+          TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
+          TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
+        run: |
+          python3 -m pip install twine
+          twine upload *.whl
 
-      - uses: actions/upload-artifact@v2
-        with:
-            path: ${{github.workspace}}/dist/bergamot-*.whl
 
     build-wasm:
       name: "emscripten"
@@ -253,7 +181,7 @@ jobs:
             echo "CCACHE_MAXSIZE=${{ env.ccache_maxsize }}" >> $GITHUB_ENV
             # https://emscripten.org/docs/compiling/Building-Projects.html#using-a-compiler-wrapper
             echo "EM_COMPILER_WRAPPER=ccache" >> $GITHUB_ENV
-            
+
         # This need to be run before setup, so ccache build caching doesn't complain.
         - name: Obtain emsdk sources
           run: |
@@ -304,16 +232,15 @@ jobs:
             ccache -s # Print current cache stats
             ccache -z # Zero cache entry
 
-        # WORMHOLE=off
-        - name: "Configure builds for WORMHOLE=off"
+        - name: "Configure builds"
           run: |
-            mkdir -p build-wasm-without-wormhole
-            cd build-wasm-without-wormhole
-            emcmake cmake -DCOMPILE_WASM=on -DWORMHOLE=off ..
+            mkdir -p build-wasm
+            cd build-wasm
+            emcmake cmake -DCOMPILE_WASM=on ..
 
 
-        - name: "Compile with WORMHOLE=off"
-          working-directory: build-wasm-without-wormhole
+        - name: "Compile"
+          working-directory: build-wasm
           run: |
             emmake make -j2
 
@@ -322,43 +249,25 @@ jobs:
             ccache -s # Print current cache stats
 
         - name: Import GEMM library from a separate wasm module
-          working-directory: build-wasm-without-wormhole
+          working-directory: build-wasm
           run: bash ../wasm/patch-artifacts-import-gemm-module.sh
 
+        # Setup nodejs-18, as nodejs-14 provided by emsdk fails when running
+        # and newer version of node allows us to use fetch().
+        - name: Setup nodejs
+          uses: actions/setup-node@v3
+          with:
+            node-version: 18
 
-        # WORMHOLE=on
-        - name: "Configure builds for WORMHOLE=on"
-          run: |
-            mkdir -p build-wasm-with-wormhole
-            cd build-wasm-with-wormhole
-            emcmake cmake -DCOMPILE_WASM=on -DWORMHOLE=on ..
-
-
-        - name: "Compile with WORMHOLE=on"
-          working-directory: build-wasm-with-wormhole
-          run: |
-            emmake make -j2
-
-        - name: ccache epilog
-          run: |
-            ccache -s # Print current cache stats
-
-        - name: Instantiate simd wormhole
-          working-directory: build-wasm-with-wormhole
-          run: bash ../wasm/patch-artifacts-enable-wormhole.sh
-
-        - name: Import GEMM library from a separate wasm module
-          working-directory: build-wasm-with-wormhole
-          run: bash ../wasm/patch-artifacts-import-gemm-module.sh
-
-        # Rename the wormhole on builds
-        - name: Rename artefacts with wormhole
-          working-directory: build-wasm-with-wormhole
+        - name: Test run
+          working-directory: wasm
           run: |
-                mv bergamot-translator-worker{,-with-wormhole}.js
-                mv bergamot-translator-worker{,-with-wormhole}.js.bak
-                mv bergamot-translator-worker{,-with-wormhole}.wasm
+            cp ../build-wasm/bergamot-translator-worker.{js,wasm} ./
+            npm install jsdom
 
+            # --unhandled-rejections make the script exit with a non-zero code (at least on node-14).
+            # So leaving this here.
+            node --unhandled-rejections=strict node-test.js
 
         # Upload both together.
         - name: Upload wasm artifact
@@ -367,25 +276,49 @@ jobs:
             name: wasm-artefacts
             if-no-files-found: error
             path: |
-                # Without wormhole
-                ${{github.workspace}}/build-wasm-without-wormhole/bergamot-translator-worker.js
-                ${{github.workspace}}/build-wasm-without-wormhole/bergamot-translator-worker.wasm
-                ${{github.workspace}}/build-wasm-without-wormhole/bergamot-translator-worker.js.bak
+                ${{github.workspace}}/build-wasm/bergamot-translator-worker.js
+                ${{github.workspace}}/build-wasm/bergamot-translator-worker.wasm
+                ${{github.workspace}}/build-wasm/bergamot-translator-worker.js.bak
+
+
+    upload-wasm:
+      name: "Upload node package to NPM"
+      runs-on: ubuntu-latest
+      if: ${{ startsWith(github.ref, 'refs/tags/v') }}
+      needs: [build-wasm]
+      steps:
+      - name: Download artifacts
+        uses: actions/download-artifact@v2
+        with:
+          name: wasm-artefacts
+          path: wasm/module/worker
+
+      - uses: actions/setup-node@v3
+        with:
+          node-version: '18.x'
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
 
-                ${{github.workspace}}/build-wasm-with-wormhole/bergamot-translator-worker-with-wormhole.js
-                ${{github.workspace}}/build-wasm-with-wormhole/bergamot-translator-worker-with-wormhole.wasm
-                ${{github.workspace}}/build-wasm-with-wormhole/bergamot-translator-worker-with-wormhole.js.bak
 
   # Try to upload a release using https://github.com/marvinpinto/actions/issues/177#issuecomment-917605585 as a model
     release-latest:
       name: Release Latest Build
       runs-on: ubuntu-latest
-      needs: [python-ubuntu, python-macos, build-wasm]
+      needs: [build-wheels, build-wasm]
       if: github.ref == 'refs/heads/main'
       steps:
        - name: Download artifacts
          uses: actions/download-artifact@v2
-        
+
+       # Leave the below be, it will be useful.
+       - name: List downloaded assets
+         run: |
+           find ./
+
        - name: Update GitHub prerelease
          uses: marvinpinto/action-automatic-releases@latest
          with:
@@ -394,16 +327,14 @@ jobs:
            prerelease: true
            title: "Latest Build"
            files: |
-                artifact/*.whl
-                wasm-artefacts/build-wasm-without-wormhole/bergamot-translator-worker.js
-                wasm-artefacts/build-wasm-without-wormhole/bergamot-translator-worker.wasm
-                wasm-artefacts/build-wasm-with-wormhole/bergamot-translator-worker-with-wormhole.js
-                wasm-artefacts/build-wasm-with-wormhole/bergamot-translator-worker-with-wormhole.wasm
-  
+                wheels/*.whl
+                wasm-artefacts/bergamot-translator-worker.js
+                wasm-artefacts/bergamot-translator-worker.wasm
+
     release-version:
-      name: Release version 
+      name: Release version
       runs-on: ubuntu-latest
-      needs: [python-ubuntu, python-macos, build-wasm]
+      needs: [build-wheels, build-wasm]
       permissions:
         contents: "write"
         packages: "write"
@@ -412,7 +343,12 @@ jobs:
       steps:
        - name: Download artifacts
          uses: actions/download-artifact@v2
-  
+
+       # Leave the below be, it will be useful.
+       - name: List downloaded assets
+         run: |
+           find ./
+
        - name: Update GitHub release
          uses: marvinpinto/action-automatic-releases@latest
          with:
@@ -421,13 +357,11 @@ jobs:
            prerelease: false
            title: "${{ github.ref_name }}"
            files: |
-                artifact/*.whl
-                wasm-artefacts/build-wasm-without-wormhole/bergamot-translator-worker.js
-                wasm-artefacts/build-wasm-without-wormhole/bergamot-translator-worker.wasm
-                wasm-artefacts/build-wasm-with-wormhole/bergamot-translator-worker-with-wormhole.js
-                wasm-artefacts/build-wasm-with-wormhole/bergamot-translator-worker-with-wormhole.wasm
+                wheels/*.whl
+                wasm-artefacts/bergamot-translator-worker.js
+                wasm-artefacts/bergamot-translator-worker.wasm
+
 
-  
     python-checks:
       name: "formatting and typechecks"
       runs-on: "ubuntu-latest"
@@ -441,15 +375,15 @@ jobs:
             python3 -m pip install black isort pytype
       - name: "Formatting checks: black, isort"
         run: |
-            python3 -m black --check bindings/python/ setup.py doc/conf.py
+            python3 -m black --diff --check bindings/python/ setup.py doc/conf.py
             python3 -m isort --profile black --diff --check bindings/python setup.py doc/conf.py
       - name: "Static typing checks: pytype"
         run: |-
             python3 -m pytype bindings/python
 
     docs:
-      runs-on: ubuntu-18.04
-      needs: [python-ubuntu]
+      runs-on: ubuntu-latest
+      needs: [build-wheels]
       steps:
         - name: Checkout
           uses: actions/checkout@v2
@@ -478,8 +412,8 @@ jobs:
         # Patches the BERGAMOT_VERSION file used by sphinx-docs at run time to
         # obtain names like 'main' or 'ci-sandbox' to not confuse with version
         # based documentation built separately.
-        - name: Deploy-time patch version 
-          run: | 
+        - name: Deploy-time patch version
+          run: |
               echo ${{steps.tag.outputs.result }} > BERGAMOT_VERSION
 
         - name: Set up Doxygen
@@ -502,7 +436,7 @@ jobs:
           working-directory: ./doc
           run: |
             python3 -m pip install -r requirements.txt
-            python3 -m pip install ${{github.workspace}}/artifact/bergamot-*-cp37*.whl
+            python3 -m pip install --find-links=${{github.workspace}}/wheels bergamot
 
         - name: Build documentation
           working-directory: ./doc
@@ -513,16 +447,16 @@ jobs:
           uses: JamesIves/github-pages-deploy-action@4.1.3
           if: ${{ github.event_name == 'push' && github.repository == 'browsermt/bergamot-translator' }}
           with:
-            repository-name: 'browsermt/docs' 
+            repository-name: 'browsermt/docs'
             branch: gh-pages # The branch the action should deploy to.
             folder: './doc/build/' # The folder the action should deploy.
-            target-folder: '${{ steps.tag.outputs.result }}' 
+            target-folder: '${{ steps.tag.outputs.result }}'
             ssh-key: ${{ secrets.BERGAMOT_SSH_PRIVATE_KEY }}
 
         # This artifact contains the HTML output of Sphinx only.
         # With index.html at the root of the produced zip file.
         # For use for maintainers to download the zip and check render of
-        # documentation while generated at pull-request. 
+        # documentation while generated at pull-request.
         - name: Upload documentation
           uses: actions/upload-artifact@v2
           if: ${{ github.event_name == 'pull_request'}}
@@ -530,4 +464,3 @@ jobs:
             name: api-docs
             path: ./doc/build/
             if-no-files-found: error
-
diff --git a/.github/workflows/coding-styles.yml b/.github/workflows/coding-styles.yml
index 81bdf3361..b13345601 100644
--- a/.github/workflows/coding-styles.yml
+++ b/.github/workflows/coding-styles.yml
@@ -1,8 +1,6 @@
 name: "Coding Style"
 
-env:
-    clang_version: 10
-on: 
+on:
   push:
     branches: [ main, ci-sandbox ]
   pull_request:
@@ -20,9 +18,9 @@ jobs:
 
         - name: Install dependencies
           run: |
-            sudo apt-get update 
+            sudo apt-get update
             sudo apt-get install -y build-essential cmake
-            sudo apt-get install -y clang-format clang-tidy-${{ env.clang_version }}
+            sudo apt-get install -y clang-format clang-tidy
 
         - name: Run clang-format
           run:
@@ -32,13 +30,13 @@ jobs:
         - name: Prepare build, compilation database etc.
           run: |
               mkdir -p build
-              cd build 
+              cd build
               cmake \
                 -DUSE_WASM_COMPATIBLE_SOURCE=off -DCMAKE_EXPORT_COMPILE_COMMANDS=on \
-                -DCMAKE_C_COMPILER=clang-${{ env.clang_version }} -DCMAKE_CXX_COMPILER=clang++-${{ env.clang_version }} \
+                -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ \
                 ..
 
         - name: Run clang-tidy
           run: |
-              run-clang-tidy-${{ env.clang_version }} -p build "$PWD/src/.*"
-              run-clang-tidy-${{ env.clang_version }} -p build "$PWD/app/.*"
+              run-clang-tidy -p build "$PWD/src/.*"
+              run-clang-tidy -p build "$PWD/app/.*"
diff --git a/.github/workflows/native.yml b/.github/workflows/native.yml
index 8ee8c5c5f..505381cbc 100644
--- a/.github/workflows/native.yml
+++ b/.github/workflows/native.yml
@@ -21,15 +21,15 @@ jobs:
       fail-fast: false
       matrix:
         include:
-        - name: Ubuntu 18.04 full
-          os: ubuntu-18.04
-          identifier: ubuntu_1804_full
+        - name: Ubuntu 22.04 full
+          os: ubuntu-22.04
+          identifier: ubuntu_2204_full
           cmake: -DCOMPILE_TESTS=on
           brt_tags: ""
           unittests: 'true'
-        - name: Ubuntu 18.04 minimal
-          os: ubuntu-18.04
-          identifier: ubuntu_1804_minimal
+        - name: Ubuntu 22.04 minimal
+          os: ubuntu-22.04
+          identifier: ubuntu_2204_minimal
           cmake: -DCOMPILE_TESTS=on -DUSE_WASM_COMPATIBLE_SOURCE=on
           brt_tags: "'#wasm'"
           unittests: 'false'
@@ -55,12 +55,10 @@ jobs:
     - name: Install Dependencies
       run: |-
         sudo apt-get update
-        sudo apt-get install -y \
-          libgoogle-perftools-dev libprotobuf-dev protobuf-compiler \
-          libboost-all-dev ccache
+        sudo apt-get install -y libprotobuf-dev protobuf-compiler libboost-all-dev ccache libunwind-dev libgoogle-perftools-dev
     - name: Install MKL
       run: |-
-        wget -qO- "https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS-2019.PUB" | sudo apt-key add -
+        wget -qO- "https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB" | sudo apt-key add -
         sudo sh -c "echo deb https://apt.repos.intel.com/mkl all main > /etc/apt/sources.list.d/intel-mkl.list"
         sudo apt-get update -o Dir::Etc::sourcelist="/etc/apt/sources.list.d/intel-mkl.list"
         sudo apt-get install -y --no-install-recommends intel-mkl-64bit-2020.0-088
@@ -140,15 +138,15 @@ jobs:
       fail-fast: false
       matrix:
         include:
-        - name: MacOS 10.15 full
-          os: macos-10.15
-          identifier: mac_1015_full
+        - name: MacOS 12 full
+          os: macos-12
+          identifier: mac_12_full
           cmake: -DCOMPILE_TESTS=on -DUSE_APPLE_ACCELERATE=off -DUSE_FBGEMM=off -DUSE_STATIC_LIBS=off
           brt_tags: ""
           unittests: 'true'
-        - name: MacOS 10.15 minimal
-          os: macos-10.15
-          identifier: mac_1015_minimal
+        - name: MacOS 12 minimal
+          os: macos-12
+          identifier: mac_12_minimal
           cmake: -DCOMPILE_TESTS=on -DUSE_APPLE_ACCELERATE=off -DUSE_FBGEMM=off -DUSE_STATIC_LIBS=on -DUSE_WASM_COMPATIBLE_SOURCE=on
           brt_tags: "'#wasm'"
           unittests: 'false'
diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml
index 569020452..a0ff86b84 100644
--- a/.github/workflows/windows.yml
+++ b/.github/workflows/windows.yml
@@ -7,7 +7,7 @@ on:
     branches: [ '**' ]
 
 env:
-  MKL_URL: "https://romang.blob.core.windows.net/mariandev/ci/mkl-2020.1-windows-static.zip"
+  MKL_URL: "https://data.statmt.org/romang/marian-regression-tests/ci/mkl-2020.1-windows-static.zip"
   CCACHE_BASEDIR: "${{ github.workspace }}"
   CCACHE_DIR: "${{ github.workspace }}\\ccache"
   CCACHE_COMPILERCHECK: content
diff --git a/.gitignore b/.gitignore
index 64c1aa3a7..94b32949c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -17,9 +17,13 @@ _deps
 
 
 wasm/test_page/node_modules
-build-wasm
+/build
+/build-native
+/build-wasm
+/emsdk
 models
-wasm/test_page/js/bergamot-translator-worker.*
+wasm/module/worker/bergamot-translator-worker.*
+wasm/module/browsermt-bergamot-translator-*.tgz
 
 # VSCode
 .vscode
diff --git a/3rd_party/CMakeLists.txt b/3rd_party/CMakeLists.txt
index 1888d6da6..eac898eb9 100644
--- a/3rd_party/CMakeLists.txt
+++ b/3rd_party/CMakeLists.txt
@@ -19,6 +19,12 @@ target_include_directories(marian PUBLIC ${INCDIRS})
 get_property(INCLUDE_DIRECTORIES DIRECTORY ssplit-cpp/src PROPERTY INCLUDE_DIRECTORIES)
 target_include_directories(ssplit PUBLIC ${INCLUDE_DIRECTORIES})
 
+get_property(COMPILE_DEFINITIONS DIRECTORY marian-dev PROPERTY COMPILE_DEFINITIONS) 
+target_compile_definitions(marian PUBLIC ${COMPILE_DEFINITIONS})
+
+get_property(COMPILE_OPTIONS DIRECTORY marian-dev PROPERTY COMPILE_OPTIONS) 
+target_compile_options(marian PUBLIC ${COMPILE_OPTIONS})
+
 # Compilation flags 
 get_directory_property(CMAKE_C_FLAGS DIRECTORY marian-dev DEFINITION CMAKE_C_FLAGS) 
 get_directory_property(CMAKE_CXX_FLAGS DIRECTORY marian-dev DEFINITION CMAKE_CXX_FLAGS) 
diff --git a/3rd_party/marian-dev b/3rd_party/marian-dev
index 199201eb8..ecda59e61 160000
--- a/3rd_party/marian-dev
+++ b/3rd_party/marian-dev
@@ -1 +1 @@
-Subproject commit 199201eb89b2941afdadb14164e936d412f897ad
+Subproject commit ecda59e6105fb1d7935892c3bacfbc9562b235f1
diff --git a/3rd_party/ssplit-cpp b/3rd_party/ssplit-cpp
index 49fde6df7..a311f9865 160000
--- a/3rd_party/ssplit-cpp
+++ b/3rd_party/ssplit-cpp
@@ -1 +1 @@
-Subproject commit 49fde6df7ee9199aedb9571be800448192e3515c
+Subproject commit a311f9865ade34db1e8e080e6cc146f55dafb067
diff --git a/BERGAMOT_VERSION b/BERGAMOT_VERSION
index 79b0815e6..a423f7f06 100644
--- a/BERGAMOT_VERSION
+++ b/BERGAMOT_VERSION
@@ -1 +1 @@
-v0.4.4
+v0.4.5
diff --git a/CMakeLists.txt b/CMakeLists.txt
index dc51acf80..d8a2d00cb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -14,6 +14,10 @@ project(bergamot_translator CXX C)
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
+# Generate a compile_commands.json in the build directory. The compile commands allow
+# code editors to understand the build process and provide static analysis of the code.
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
 # Note that with CMake MSVC build, the option CMAKE_BUILD_TYPE is automatically derived from the key
 # 'configurationType' in CMakeSettings.json configurations
 if(NOT CMAKE_BUILD_TYPE)
@@ -113,7 +117,6 @@ message(STATUS "Project version: ${PROJECT_VERSION_STRING_FULL}")
 
 if(COMPILE_WASM)
   # See https://github.com/emscripten-core/emscripten/blob/main/src/settings.js
-  set(WORMHOLE ON CACHE BOOL "Use WASM wormhole in intgemm https://bugzilla.mozilla.org/show_bug.cgi?id=1672160")
   list(APPEND WASM_COMPILE_FLAGS
     -O3
     # Preserve whitespaces in JS even for release builds; this doesn't increase wasm binary size
diff --git a/README.md b/README.md
index b70c818ec..05c3c3d25 100644
--- a/README.md
+++ b/README.md
@@ -41,12 +41,7 @@ To build a version that translates with higher speeds on Firefox Nightly browser
 
        The wasm artifacts (.js and .wasm files) will be available in the build directory ("build-wasm" in this case).
 
-   2. Enable SIMD Wormhole via Wasm instantiation API in generated artifacts
-       ```bash
-       bash ../wasm/patch-artifacts-enable-wormhole.sh
-       ```
-
-   3. Patch generated artifacts to import GEMM library from a separate wasm module
+   2. Patch generated artifacts to import GEMM library from a separate wasm module
        ```bash
        bash ../wasm/patch-artifacts-import-gemm-module.sh
        ```
@@ -57,7 +52,7 @@ To build a version that runs on all browsers (including Firefox Nightly) but tra
       ```bash
       mkdir build-wasm
       cd build-wasm
-      emcmake cmake -DCOMPILE_WASM=on -DWORMHOLE=off ../
+      emcmake cmake -DCOMPILE_WASM=on ../
       emmake make -j2
       ```
 
@@ -80,7 +75,7 @@ git submodule update --init --recursive
 ### Using Native version
 
 The builds generate library that can be integrated to any project. All the public header files are specified in `src` folder.\
-A short example of how to use the APIs is provided in `app/main.cpp` file.
+A short example of how to use the APIs is provided in `app/bergamot.cpp` file.
 
 ### Using WASM version
 
diff --git a/bergamot-translator-tests b/bergamot-translator-tests
index 7984d140a..a04432d79 160000
--- a/bergamot-translator-tests
+++ b/bergamot-translator-tests
@@ -1 +1 @@
-Subproject commit 7984d140aef00489699d0b7711fa942816224294
+Subproject commit a04432d7921bfa1dd62bc2e5cdca46b226f256de
diff --git a/bindings/python/CMakeLists.txt b/bindings/python/CMakeLists.txt
index 70b1a2535..16e3e48d3 100644
--- a/bindings/python/CMakeLists.txt
+++ b/bindings/python/CMakeLists.txt
@@ -1,4 +1,4 @@
-find_package(Python COMPONENTS Interpreter Development REQUIRED)
+find_package(Python COMPONENTS Interpreter Development.Module REQUIRED)
 
 message("Using Python: " ${Python_EXECUTABLE})
 
diff --git a/bindings/python/README.md b/bindings/python/README.md
new file mode 100644
index 000000000..3797b7dea
--- /dev/null
+++ b/bindings/python/README.md
@@ -0,0 +1,14 @@
+# bergamot-translator
+
+The [Bergamot project](https://browser.mt/) adds and improves client-side
+machine translation in a web browser.
+
+This package provides Python bindings to bergamot-translator developed as part
+of the Bergamot Project and extras assorted in a package to enable further use
+of the library developed for local-translation on the consumer machine.
+
+Bergamot is a consortium coordinated by the University of Edinburgh with
+partners Charles University in Prague, the University of Sheffield, University
+of Tartu, and Mozilla.
+
+
diff --git a/bindings/python/bergamot.cpp b/bindings/python/bergamot.cpp
index 5e9e830f9..2ffb2267e 100644
--- a/bindings/python/bergamot.cpp
+++ b/bindings/python/bergamot.cpp
@@ -116,7 +116,7 @@ class ServicePyAdapter {
     return responses;
   }
 
- private /*functions*/:
+  private /*functions*/:
   static Service make_service(const Service::Config &config) {
     py::scoped_ostream_redirect outstream(std::cout,                                 // std::ostream&
                                           py::module_::import("sys").attr("stdout")  // Python output
@@ -130,7 +130,7 @@ class ServicePyAdapter {
     return Service(config);
   }
 
- private /*data*/:
+  private /*data*/:
   Service service_;
 };
 
diff --git a/bindings/python/repository.py b/bindings/python/repository.py
index 7f89035c8..9667c7242 100644
--- a/bindings/python/repository.py
+++ b/bindings/python/repository.py
@@ -75,22 +75,38 @@ def __init__(self, name, url):
             os.makedirs(directory, exist_ok=True)
 
         self.models_file_path = os.path.join(self.dirs["config"], "models.json")
-        self.update()
+        self.data = self._load_data(self.models_file_path)
+
+        # Update inverse lookup.
+        self.data_by_code = {}
+        for model in self.data["models"]:
+            self.data_by_code[model["code"]] = model
 
     @property
     def name(self) -> str:
         return self._name
 
+    def _load_data(self, models_file_path):
+        """
+        Load model data from existing file. If file does not exist, download from the web.
+        """
+        if os.path.exists(models_file_path):
+            # File already exists, prefer to work with this.
+            # A user is expected to update manually if model's already
+            # downloaded and setup.
+            with open(models_file_path) as model_file:
+                return json.load(model_file)
+        else:
+            # We are running for the first time.
+            # Try to fetch this file from the internet.
+            self.update()
+            with open(models_file_path) as model_file:
+                return json.load(model_file)
+
     def update(self) -> None:
         inventory = requests.get(self.url).text
         with open(self.models_file_path, "w+") as models_file:
             models_file.write(inventory)
-        self.data = json.loads(inventory)
-
-        # Update inverse lookup.
-        self.data_by_code = {}
-        for model in self.data["models"]:
-            self.data_by_code[model["code"]] = model
 
     def models(self, filter_downloaded: bool = True) -> t.List[str]:
         codes = []
@@ -121,7 +137,24 @@ def download(self, model_identifier: str):
         download_resource(model["url"], save_location)
 
         with tarfile.open(save_location) as model_archive:
-            model_archive.extractall(self.dirs["models"])
+
+            def is_within_directory(directory, target):
+                abs_directory = os.path.abspath(directory)
+                abs_target = os.path.abspath(target)
+
+                prefix = os.path.commonprefix([abs_directory, abs_target])
+
+                return prefix == abs_directory
+
+            def safe_extract(tar, path=".", members=None, *, numeric_owner=False):
+                for member in tar.getmembers():
+                    member_path = os.path.join(path, member.name)
+                    if not is_within_directory(path, member_path):
+                        raise Exception("Attempted Path Traversal in Tar File")
+
+                tar.extractall(path, members, numeric_owner=numeric_owner)
+
+            safe_extract(model_archive, self.dirs["models"])
             fprefix = self._archive_name_without_extension(model["url"])
             model_dir = os.path.join(self.dirs["models"], fprefix)
             symlink = os.path.join(self.dirs["models"], model["code"])
diff --git a/build-wasm.sh b/build-wasm.sh
index ff12013d1..443907232 100755
--- a/build-wasm.sh
+++ b/build-wasm.sh
@@ -2,34 +2,6 @@
 set -e
 set -x
 
-# Usage
-Usage="Build translator to wasm (with/without wormhole).
-
-Usage: $(basename "$0") [WORMHOLE]
-
-    where:
-    WORMHOLE      An optional string argument
-                  - when specified on command line, builds wasm artifacts with wormhole
-                  - when not specified (the default behaviour), builds wasm artifacts without wormhole."
-
-if [ "$#" -gt 1 ]; then
-  echo "Illegal number of parameters passed"
-  echo "$Usage"
-  exit
-fi
-
-WORMHOLE=false
-
-if [ "$#" -eq 1 ]; then
-  if [ "$1" = "WORMHOLE" ]; then
-    WORMHOLE=true
-  else
-    echo "Illegal parameter passed"
-    echo "$Usage"
-    exit
-  fi
-fi
-
 # Run script from the context of the script-containing directory
 cd "$(dirname $0)"
 
@@ -66,20 +38,28 @@ if [ ! -d ${BUILD_DIRECTORY} ]; then
 fi
 cd ${BUILD_DIRECTORY}
 
-if [ "$WORMHOLE" = true ]; then
-  emcmake cmake -DCOMPILE_WASM=on ../
-else
-  emcmake cmake -DCOMPILE_WASM=on -DWORMHOLE=off ../
-fi
+emcmake cmake -DCOMPILE_WASM=on ../
 emmake make -j2
 
-#     2. Enable SIMD Wormhole via Wasm instantiation API in generated artifacts
-if [ "$WORMHOLE" = true ]; then
-  bash ../wasm/patch-artifacts-enable-wormhole.sh
-fi
-
-#     3. Import GEMM library from a separate wasm module
+#     2. Import GEMM library from a separate wasm module
 bash ../wasm/patch-artifacts-import-gemm-module.sh
 
+set +x
+echo ""
+echo "Build complete"
+echo ""
+echo "  ./build-wasm/bergamot-translator-worker.js"
+echo "  ./build-wasm/bergamot-translator-worker.wasm"
+
+WASM_SIZE=$(wc -c bergamot-translator-worker.wasm | awk '{print $1}')
+GZIP_SIZE=$(gzip -c bergamot-translator-worker.wasm | wc -c | xargs) # xargs trims the whitespace
+
+# Convert it to human readable.
+WASM_SIZE="$(awk 'BEGIN {printf "%.2f",'$WASM_SIZE'/1048576}')M ($WASM_SIZE bytes)"
+GZIP_SIZE="$(awk 'BEGIN {printf "%.2f",'$GZIP_SIZE'/1048576}')M ($GZIP_SIZE bytes)"
+
+echo "  Uncompressed wasm size: $WASM_SIZE"
+echo "  Compressed wasm size: $GZIP_SIZE"
+
 # The artifacts (.js and .wasm files) will be available in the build directory
 exit 0
diff --git a/setup.py b/setup.py
index 85fa685ff..ed4c6dc81 100644
--- a/setup.py
+++ b/setup.py
@@ -16,6 +16,7 @@
     "win-arm64": "ARM64",
 }
 
+
 # A CMakeExtension needs a sourcedir instead of a file list.
 # The name must be the _single_ output extension from the CMake build.
 # If you need multiple extensions, see scikit-build.
@@ -48,12 +49,11 @@ def build_extension(self, ext):
             f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={extdir}",
             f"-DPYTHON_EXECUTABLE={sys.executable}",
             f"-DCMAKE_BUILD_TYPE={cfg}",  # not used on MSVC, but no harm
-            f"-DCMAKE_CXX_COMPILER_LAUNCHER=ccache",
-            f"-DCMAKE_C_COMPILER_LAUNCHER=ccache",
             f"-DCOMPILE_PYTHON=ON",
             f"-DSSPLIT_USE_INTERNAL_PCRE2=ON",
             f"-DBUILD_ARCH={build_arch}",
         ]
+
         build_args = ["-t", "_bergamot"]
         # Adding CMake arguments set as environment variable
         # (needed e.g. to build for ARM OSx on conda-forge)
@@ -63,6 +63,13 @@ def build_extension(self, ext):
         # In this example, we pass in the version to C++. You might not need to.
         cmake_args += [f"-DEXAMPLE_VERSION_INFO={self.distribution.get_version()}"]
 
+        use_ccache = os.environ.get("USE_CCACHE", "0") == "1"
+        if use_ccache:
+            cmake_args += [
+                f"-DCMAKE_CXX_COMPILER_LAUNCHER=ccache",
+                f"-DCMAKE_C_COMPILER_LAUNCHER=ccache",
+            ]
+
         if self.compiler.compiler_type != "msvc":
             # Using Ninja-build since it a) is available as a wheel and b)
             # multithreads automatically. MSVC would require all variables be
@@ -78,7 +85,6 @@ def build_extension(self, ext):
                     pass
 
         else:
-
             # Single config generators are handled "normally"
             single_config = any(x in cmake_generator for x in {"NMake", "Ninja"})
 
@@ -130,14 +136,15 @@ def build_extension(self, ext):
 
 # Import the README and use it as the long-description.
 # Note: this will only work if 'README.md' is present in your MANIFEST.in file!
-with io.open(os.path.join(here, "README.md"), encoding="utf-8") as f:
+long_description = ""
+with io.open(os.path.join(here, "bindings/python/README.md"), encoding="utf-8") as f:
     long_description = "\n" + f.read()
 
 version = None
 with open(os.path.join(here, "BERGAMOT_VERSION")) as f:
     version = f.read().strip()
     suffix = os.environ.get("PYTHON_LOCAL_VERSION_IDENTIFIER", None)
-    if suffix is not None:
+    if suffix:
         version = "{}+{}".format(version, suffix)
 
 
@@ -191,8 +198,9 @@ def run(self):
     author="Jerin Philip",
     author_email="jerinphilip@live.in",
     url="https://github.com/browsermt/bergamot-translator/",
-    description="Bergamot translator python binding.",
-    long_description="",
+    description="Translate text-content locally in your machine across langauges.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
     ext_modules=[CMakeExtension("bergamot/_bergamot")],
     cmdclass={"build_py": build_py, "build_ext": CMakeBuild},
     zip_safe=False,
@@ -201,10 +209,40 @@ def run(self):
     python_requires=">=3.6",
     packages=["bergamot"],
     package_dir={"bergamot": "bindings/python"},
-    install_requires=["requests", "pyyaml", "appdirs"],
+    install_requires=["requests", "pyyaml>=5.1", "appdirs"],
     entry_points={
         "console_scripts": [
             "bergamot = bergamot.__main__:main",
         ],
     },
+    # Classifiers help users find your project by categorizing it.
+    #
+    # For a list of valid classifiers, see https://pypi.org/classifiers/
+    classifiers=[  # Optional
+        # How mature is this project? Common values are
+        #   3 - Alpha
+        #   4 - Beta
+        #   5 - Production/Stable
+        "Development Status :: 3 - Alpha",
+        # Indicate who your project is intended for
+        "Intended Audience :: Developers",
+        "Topic :: Software Development :: Build Tools",
+        # Pick your license as you wish
+        "License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)",
+        # Specify the Python versions you support here. In particular, ensure
+        # that you indicate you support Python 3. These classifiers are *not*
+        # checked by 'pip install'. See instead 'python_requires' below.
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3 :: Only",
+    ],
+    project_urls={
+        "Bug Reports": "https://github.com/browsermt/bergamot-translator/issues",
+        "Source": "https://github.com/browsermt/bergamot-translator/",
+        "Documentation": "https://browser.mt/docs/main/python.html",
+    },
 )
diff --git a/src/translator/byte_array_util.cpp b/src/translator/byte_array_util.cpp
index 183dea3c0..c7515e797 100644
--- a/src/translator/byte_array_util.cpp
+++ b/src/translator/byte_array_util.cpp
@@ -91,21 +91,24 @@ AlignedMemory loadFileToMemory(const std::string& path, size_t alignment) {
   return alignedMemory;
 }
 
-AlignedMemory getModelMemoryFromConfig(marian::Ptr<marian::Options> options) {
+std::vector<AlignedMemory> getModelMemoryFromConfig(marian::Ptr<marian::Options> options) {
   auto models = options->get<std::vector<std::string>>("models");
-  ABORT_IF(models.size() != 1, "Loading multiple binary models is not supported for now as it is not necessary.");
-
-  // If binary model we load into aligned memory. If .npz we leave it be to
-  // return empty aligned memory, thus allowing traditional file system loads.
-  if (marian::io::isBin(models[0])) {
-    AlignedMemory alignedMemory = loadFileToMemory(models[0], 256);
-    return alignedMemory;
-  } else if (marian::io::isNpz(models[0])) {
-    return AlignedMemory();
-  } else {
-    ABORT("Unknown extension for model: {}, should be one of `.bin` or `.npz`", models[0]);
+
+  std::vector<AlignedMemory> modelMemories(models.size());
+  for (size_t i = 0; i < models.size(); ++i) {
+    const auto model = models[i];
+    if (marian::io::isBin(model)) {
+      modelMemories[i] = loadFileToMemory(model, 256);
+    } else if (marian::io::isNpz(model)) {
+      // if any of the models are npz format, we revert to loading from file for all models.
+      LOG(debug, "Encountered an npz file {}; will use file loading for {} models", model, models.size());
+      return {};
+    } else {
+      ABORT("Unknown extension for model: {}, should be one of `.bin` or `.npz`", model);
+    }
   }
-  return AlignedMemory();
+
+  return modelMemories;
 }
 
 AlignedMemory getShortlistMemoryFromConfig(marian::Ptr<marian::Options> options) {
@@ -153,7 +156,7 @@ AlignedMemory getQualityEstimatorModel(MemoryBundle& memoryBundle, const marian:
 
 MemoryBundle getMemoryBundleFromConfig(marian::Ptr<marian::Options> options) {
   MemoryBundle memoryBundle;
-  memoryBundle.model = getModelMemoryFromConfig(options);
+  memoryBundle.models = getModelMemoryFromConfig(options);
   memoryBundle.shortlist = getShortlistMemoryFromConfig(options);
   getVocabsMemoryFromConfig(options, memoryBundle.vocabs);
   memoryBundle.ssplitPrefixFile = getSsplitPrefixFileMemoryFromConfig(options);
diff --git a/src/translator/byte_array_util.h b/src/translator/byte_array_util.h
index b445b3dec..851a175fd 100644
--- a/src/translator/byte_array_util.h
+++ b/src/translator/byte_array_util.h
@@ -5,7 +5,7 @@ namespace marian {
 namespace bergamot {
 
 AlignedMemory loadFileToMemory(const std::string& path, size_t alignment);
-AlignedMemory getModelMemoryFromConfig(marian::Ptr<marian::Options> options);
+std::vector<AlignedMemory> getModelMemoryFromConfig(marian::Ptr<marian::Options> options);
 AlignedMemory getQualityEstimatorModel(const marian::Ptr<marian::Options>& options);
 AlignedMemory getQualityEstimatorModel(MemoryBundle& memoryBundle, const marian::Ptr<marian::Options>& options);
 AlignedMemory getShortlistMemoryFromConfig(marian::Ptr<marian::Options> options);
diff --git a/src/translator/definitions.h b/src/translator/definitions.h
index b3bc1019b..efba3f9f6 100644
--- a/src/translator/definitions.h
+++ b/src/translator/definitions.h
@@ -19,8 +19,8 @@ typedef AlignedVector<char> AlignedMemory;
 /// Memory bundle for all byte-arrays.
 /// Can be a set/subset of model, shortlist, vocabs and ssplitPrefixFile bytes.
 struct MemoryBundle {
-  AlignedMemory model{};      ///< Byte-array of model (aligned to 256)
-  AlignedMemory shortlist{};  ///< Byte-array of shortlist (aligned to 64)
+  std::vector<AlignedMemory> models{};  ///< Byte-array of model (each element is aligned to 256)
+  AlignedMemory shortlist{};            ///< Byte-array of shortlist (aligned to 64)
 
   /// Vector of vocabulary memories (aligned to 64).
   /// If two vocabularies are the same (based on the filenames), two entries (shared
diff --git a/src/translator/threadsafe_batching_pool.cpp b/src/translator/threadsafe_batching_pool.cpp
index 0a1a28d4e..29ad35a97 100644
--- a/src/translator/threadsafe_batching_pool.cpp
+++ b/src/translator/threadsafe_batching_pool.cpp
@@ -10,7 +10,7 @@ namespace bergamot {
 
 template <class BatchingPoolType>
 template <class... Args>
-ThreadsafeBatchingPool<BatchingPoolType>::ThreadsafeBatchingPool(Args &&... args)
+ThreadsafeBatchingPool<BatchingPoolType>::ThreadsafeBatchingPool(Args &&...args)
     : backend_(std::forward<Args>(args)...), enqueued_(0), shutdown_(false) {}
 
 template <class BatchingPoolType>
@@ -20,7 +20,7 @@ ThreadsafeBatchingPool<BatchingPoolType>::~ThreadsafeBatchingPool() {
 
 template <class BatchingPoolType>
 template <class... Args>
-void ThreadsafeBatchingPool<BatchingPoolType>::enqueueRequest(Args &&... args) {
+void ThreadsafeBatchingPool<BatchingPoolType>::enqueueRequest(Args &&...args) {
   std::unique_lock<std::mutex> lock(mutex_);
   assert(!shutdown_);
   enqueued_ += backend_.enqueueRequest(std::forward<Args>(args)...);
@@ -43,7 +43,7 @@ void ThreadsafeBatchingPool<BatchingPoolType>::shutdown() {
 
 template <class BatchingPoolType>
 template <class... Args>
-size_t ThreadsafeBatchingPool<BatchingPoolType>::generateBatch(Args &&... args) {
+size_t ThreadsafeBatchingPool<BatchingPoolType>::generateBatch(Args &&...args) {
   std::unique_lock<std::mutex> lock(mutex_);
   work_.wait(lock, [this]() { return enqueued_ || shutdown_; });
   size_t sentencesInBatch = backend_.generateBatch(std::forward<Args>(args)...);
diff --git a/src/translator/threadsafe_batching_pool.h b/src/translator/threadsafe_batching_pool.h
index fdbf36cdc..9f46abb94 100644
--- a/src/translator/threadsafe_batching_pool.h
+++ b/src/translator/threadsafe_batching_pool.h
@@ -34,14 +34,14 @@ template <class BatchingPoolType>
 class ThreadsafeBatchingPool {
  public:
   template <class... Args>
-  ThreadsafeBatchingPool(Args &&... args);
+  ThreadsafeBatchingPool(Args &&...args);
   ~ThreadsafeBatchingPool();
 
   template <class... Args>
-  void enqueueRequest(Args &&... args);
+  void enqueueRequest(Args &&...args);
 
   template <class... Args>
-  size_t generateBatch(Args &&... args);
+  size_t generateBatch(Args &&...args);
 
   // Removes any pending requests from the batching pool.
   void clear();
diff --git a/src/translator/translation_model.cpp b/src/translator/translation_model.cpp
index 3f91ebb47..6f8dd4dc8 100644
--- a/src/translator/translation_model.cpp
+++ b/src/translator/translation_model.cpp
@@ -61,24 +61,35 @@ void TranslationModel::loadBackend(size_t idx) {
   graph->getBackend()->configureDevice(options_);
   graph->reserveWorkspaceMB(options_->get<size_t>("workspace"));
 
-  // Marian Model: Load from memoryBundle or shortList
-  if (memory_.model.size() > 0 &&
-      memory_.model.begin() !=
-          nullptr) {  // If we have provided a byte array that contains the model memory, we can initialise the
-                      // model from there, as opposed to from reading in the config file
-    ABORT_IF((uintptr_t)memory_.model.begin() % 256 != 0,
-             "The provided memory is not aligned to 256 bytes and will crash when vector instructions are used on it.");
-    if (options_->get<bool>("check-bytearray", false)) {
-      ABORT_IF(!validateBinaryModel(memory_.model, memory_.model.size()),
-               "The binary file is invalid. Incomplete or corrupted download?");
-    }
-    const std::vector<const void *> container = {
-        memory_.model.begin()};  // Marian supports multiple models initialised in this manner hence std::vector.
-                                 // However we will only ever use 1 during decoding.
+  // if memory_.models is populated, then all models were of binary format
+  if (memory_.models.size() >= 1) {
+    const std::vector<const void *> container = std::invoke([&]() {
+      std::vector<const void *> model_ptrs(memory_.models.size());
+      for (size_t i = 0; i < memory_.models.size(); ++i) {
+        const AlignedMemory &model = memory_.models[i];
+
+        ABORT_IF(model.size() == 0 || model.begin() == nullptr, "The provided memory is empty. Cannot load the model.");
+        ABORT_IF(
+            (uintptr_t)model.begin() % 256 != 0,
+            "The provided memory is not aligned to 256 bytes and will crash when vector instructions are used on it.");
+        if (options_->get<bool>("check-bytearray", false)) {
+          ABORT_IF(!validateBinaryModel(model, model.size()),
+                   "The binary file is invalid. Incomplete or corrupted download?");
+        }
+
+        model_ptrs[i] = model.begin();
+        LOG(debug, "Loaded model {} of {} from memory", (i + 1), model_ptrs.size());
+      }
+      return model_ptrs;
+    });
+
     scorerEnsemble = createScorers(options_, container);
   } else {
+    // load npz format models, or a mixture of binary/npz formats
     scorerEnsemble = createScorers(options_);
+    LOG(debug, "Loaded {} model(s) from file", scorerEnsemble.size());
   }
+
   for (auto scorer : scorerEnsemble) {
     scorer->init(graph);
     if (shortlistGenerator_) {
diff --git a/wasm/README.md b/wasm/README.md
index 883f80dc5..0f3f77426 100644
--- a/wasm/README.md
+++ b/wasm/README.md
@@ -4,7 +4,9 @@ All the instructions below are meant to run from the current directory.
 
 ## Using JS APIs
 
-Please refer to the file `test_page/js/worker.js` that demonstrates how to use the bergamot translator in JavaScript via a `<script>` tag.
+See [node-test.js](./node-test.js) for an annotated example of how to use the WASM module. Most of the code from it can also be used in a browser context.
+
+Alternatively refer to the file `test_page/js/worker.js` that demonstrates how to use the bergamot translator in JavaScript via a `<script>` tag.
 
 ## Demo
 
@@ -30,18 +32,8 @@ Please refer to the file `test_page/js/worker.js` that demonstrates how to use t
 
     Provide the folder containing the wasm artifacts as the first argument of `start_server.sh` script (`../../build-wasm` in this case).
 
-* Open any of the browsers below
-    * Firefox Nightly +87: make sure the following prefs are on (about:config)
-        ```
-        dom.postMessage.sharedArrayBuffer.bypassCOOP_COEP.insecure.enabled = true
-        javascript.options.wasm_simd = true
-        javascript.options.wasm_simd_wormhole = true
-        ```
-
-    * Chrome Canary +90: start with the following argument
-        ```
-        --js-flags="--experimental-wasm-simd"
-        ```
+* Open any browser (tested with latest Chrome/Firefox/Safari)
+
 
 * Browse to the following page:
     ```
diff --git a/wasm/bindings/service_bindings.cpp b/wasm/bindings/service_bindings.cpp
index d56615dc6..54675a498 100644
--- a/wasm/bindings/service_bindings.cpp
+++ b/wasm/bindings/service_bindings.cpp
@@ -48,7 +48,7 @@ MemoryBundle prepareMemoryBundle(AlignedMemory* modelMemory, AlignedMemory* shor
                                  std::vector<AlignedMemory*> uniqueVocabsMemories,
                                  AlignedMemory* qualityEstimatorMemory) {
   MemoryBundle memoryBundle;
-  memoryBundle.model = std::move(*modelMemory);
+  memoryBundle.models.emplace_back(std::move(*modelMemory));
   memoryBundle.shortlist = std::move(*shortlistMemory);
   memoryBundle.vocabs = std::move(prepareVocabsSmartMemories(uniqueVocabsMemories));
   if (qualityEstimatorMemory != nullptr) {
diff --git a/wasm/module/README.md b/wasm/module/README.md
new file mode 100644
index 000000000..4f6b153ba
--- /dev/null
+++ b/wasm/module/README.md
@@ -0,0 +1,238 @@
+# Installation
+
+```bash
+npm install @browsermt/bergamot-translator
+```
+
+# Quick start
+
+```js
+import {BatchTranslator} from "@browsermt/bergamot-translator/translator.js";
+
+const translator = new BatchTranslator();
+
+const response = await translator.translate({
+  from: "en",
+  to: "es",
+  text: "Hello <em>world</em>!",
+  html: true
+});
+
+console.log(response.target.text);
+
+// Stops worker threads
+translator.delete();
+```
+
+# Throughput vs Latency
+
+This package comes with two translator implementations:
+
+- [LatencyOptimisedTranslator](#latencyoptimisedtranslator) is more useful for an interactive session, say like Google Translate, where you're only working on translating one input at a time.
+- [BatchTranslator](#batchtranslator) is optimised for processing a large number of translations as fast as possible (but individual translations might take some time), e.g. translating a large number of strings or all paragraphs in a document.
+
+## LantencyOptimisedTranslator
+
+Translator best suited for interactive usage. Runs with a single worker thread and a batch-size of 1 to give you a response as quickly as possible. It will cancel any pending translations that aren't currently being processed if you submit a new one.
+
+```js
+const translator = new LatencyOptimisedTranslator({
+  pivotLanguage?: string?,
+  registryUrl?: string,
+  workerUrl?: string,
+  downloadTimeout?: number,
+  cacheSize?: number,
+  useNativeIntGemm?: boolean,
+})
+```
+
+- `pivotLanguage` - language code for the language to use as an intermediate if there is no direct translation model available. Defaults to `"en"`. Set to `null` to disable pivoting.
+- `registryUrl` - url to a list of models and their paths. Defaults to `https://storage.googleapis.com/bergamot-models-sandbox/0.3.3/registry.json`.
+- `workerUrl` - url to `translator-worker.js`. Defaults to `"worker/translator-worker.js"` relative to the path of `translator.js`.
+- `downloadTimeout` - Maximum time we're attempting to download model files before failing. Defaults to `60000` or 60 seconds. Set to `0` to disable.
+- `cacheSize` - Maximum number of sentences in kept translation cache (per worker, workers do not share their cache). This is an ideal maximum as it is a hash-map, in practice about 1/3th is occupied. If set to `0`, translation cache is disabled (the default).
+- `useNativeIntGemm` - Try to link to native IntGEMM implementation when loading the WASM binary. This is only implemented in the privileged extension context of Firefox Nightly. If it fails, it will always fall back to the included implementation. Defaults to `false`.
+
+### translate()
+
+```js
+const {request, target: {text:string}} = await translator.translate({
+  from: string,
+  to: string,
+  text: string,
+  html?: boolean,
+  qualityScores?: boolean
+})
+```
+
+Submits a translation request. Multiple of these are processed in a batch. A batch will be started the next tick (if there is a worker available).
+
+- `from` - language code of the source language, e.g. `"de"`
+- `to` - language code of the target language, e.g. `"en"`
+- `text` - string of text to translate, e.g. `"Hallo Welt!"`
+- `html` - boolean indicating whether `text` contains just plain text or HTML
+- `qualityScores` - whether to calculate quality scores. Not all models support this, and you need to load a separate quality scores model file for it. Quality scores are returned as `<font x-bergamot-sentence-quality="">` and `<font x-bergamot-word-quality="">` wrapped around sentences and words in the output. When enabled, the output is always HTML, regardless of whether the input was.
+
+Returns:
+
+A promise to a translation response object, with `target.text` being the text or HTML of the translated output, and `request` a reference to the original translation request.
+
+### delete()
+
+```js
+translator.delete()
+```
+
+Cancels all pending requests with a `CancelledError` and terminates the worker immediately. This will free all the resources used.
+
+In a nodejs context you'll need to call this, otherwise your script won't exit because the translator will still be listening for messages from the worker.
+
+## BatchTranslator
+
+```js
+const translator = new BatchTranslator({
+  pivotLanguage?: string?,
+  registryUrl?: string,
+  workerUrl?: string,
+  downloadTimeout?: number,
+  cacheSize?: number,
+  useNativeIntGemm?: boolean,
+  workers?: number,
+  batchSize?: number,
+})
+```
+
+General translator options:
+
+See [LatencyOptimisedTranslator](#latencyoptimisedtranslator).
+
+BatchTranslator-specific options:
+
+- `workers` - Number of worker threads. These are full-on instances of the translator, with their own copy of the model loaded. This is an upper bound. If not that many workers can be fed, it won't create new ones. Minimally 1. Default is `1`.
+- `batchSize` - Number of translation requests per batch. All sentences from all translation requests are packed into a bunch of matrix operations. With a larger batch size the translator has more material to find ideal sets of sentences for filling the matrix. However, you'll only get the results for each of the requests in a batch once the whole batch is finished. Defaults to 8.
+
+### translate()
+
+```js
+const {target: {text:string}} = await translator.translate({
+  from: string,
+  to: string,
+  text: string,
+  html?: boolean,
+  qualityScores?: boolean,
+  priority?: number
+})
+```
+
+Submits a translation request. Multiple of these are processed in a batch. A batch will be started the next tick (if there is a worker available).
+
+- (See [LatencyOptimisedTranslator.translate()](#translate) for most options)
+- `priority` - When grouping translation requests into batches to give to workers, requests with a lower number are considered first. For example, if you're translating a web page, you can give requests of parts that are in the current frame a lower number to make sure they're processed first.
+
+### remove()
+
+```js
+translator.remove(request => {
+  // true deletes the request from the queue.
+  return true;
+})
+```
+
+Removes requests from the translation queue, i.e. only when they haven't been sent to a worker yet.
+
+The filter function should return true-ish for each request that should be cancelled. Their promises are rejected with a `CancelledError` error.
+
+
+### delete()
+
+```js
+translator.delete()
+```
+
+Cancels all pending requests with a `CancelledError` and terminates all workers immediately. This will free all the resources used.
+
+
+# Models
+
+Both translators accept a `backing` option, which tells it where to get model data and the translation engine implementation from. They default to using `BergamotTranslator` which gets its models from the same repository as [firefox-translations](https://github.com/mozilla/firefox-translations).
+
+To customize the model, reimplement the `loadModelRegistry` and `loadTranslationModel` methods.
+
+`loadModelRegistry()` has the hard requirement to return a promise to a list that looks like `{from: string, to: string, ...}[]`. The `from` and `to` keys are used as key for model selection.
+
+`loadTranslationModel()` should return a promise with ArrayBuffers for `model`, `shortlist`, `vocabs`, and optionally `qualityModel`. It can include a `config` object as well.
+
+Example of an alternative implementation that loads models from data.statmt.org, i.e. the same as [translateLocally](https://translateLocally.com):
+
+```js
+class CustomBacking extends TranslatorBacking {
+    async loadModelRegistery() {
+        const response = await fetch('https://translatelocally.com/models.json');
+        const {models} = await response.json();
+
+        // Add 'from' and 'to' keys for each model. Since theoretically a model
+        // can have multiple froms keys in TranslateLocally, we do a little
+        // product here.
+        return models.reduce((list, model) => {
+            try {
+                const to = first(Intl.getCanonicalLocales(model.trgTag));
+                for (let from of Intl.getCanonicalLocales(Object.keys(model.srcTags))) {
+                    list.push({from, to, model});
+                }
+            } catch (err) {
+                console.log('Skipped model', model, 'because', err);
+            }
+
+            return list;
+        }, []);
+    }
+
+    async loadTranslationModel({from, to}) {
+        // Find that model in the registry which will tell us about its files
+        const entries = (await this.registry).filter(model => model.from === from && model.to === to);
+
+        // Prefer tiny models above non-tiny ones
+        entries.sort(({model: a}, {model: b}) => (a.shortName.indexOf('tiny') === -1 ? 1 : 0) - (b.shortName.indexOf('tiny') === -1 ? 1 : 0));
+
+        if (!entries)
+            throw new Error(`No model for '${from}' -> '${to}'`);
+
+        const entry = entries[0].model;
+
+        const response = await fetch(entry.url, {
+            integrity: `sha256-${entry.checksum}`
+        });
+
+        // pako from https://www.npmjs.com/package/pako
+        const archive = pako.inflate(await response.arrayBuffer());
+
+        // untar from https://www.npmjs.com/package/js-untar
+        const files = await untar(archive.buffer);
+
+        const find = (filename) => {
+            const found = files.find(file => file.name.match(/(?:^|\/)([^\/]+)$/)[1] === filename)
+            if (found === undefined)
+                throw new Error(`Could not find '${filename}' in model archive`);
+            return found;
+        };
+
+        // YAML.parse is found in worker/translator-worker.js
+        const config = YAML.parse(find('config.intgemm8bitalpha.yml').readAsString());
+
+        const model = find(config.models[0]).buffer;
+
+        const vocabs = config.vocabs.map(vocab => find(vocab).buffer);
+
+        const shortlist = find(config.shortlist[0]).buffer;
+
+        // Return the buffers
+        return {model, vocabs, shortlist, config};
+    }
+}
+
+const translator = new BatchTranslator(options, new CustomBacking(options));
+```
+
+# Supported languages
+
+See https://github.com/mozilla/firefox-translations-models#currently-supported-languages. You may need to set the `registryUrl` option to point to the latest release.
\ No newline at end of file
diff --git a/wasm/module/main.js b/wasm/module/main.js
new file mode 100644
index 000000000..d712a2199
--- /dev/null
+++ b/wasm/module/main.js
@@ -0,0 +1,21 @@
+import * as readline from 'node:readline/promises';
+import {stdin, stdout} from 'node:process';
+import {BatchTranslator} from "./translator.js";
+
+const rl = readline.createInterface({input: stdin, output: stdout});
+
+const translator = new BatchTranslator();
+
+for await (const line of rl) {
+	const response = await translator.translate({
+		from: "en",
+		to: "es",
+		text: line,
+		html: false,
+		qualityScores: false
+	});
+
+	console.log(response.target.text);
+}
+
+translator.delete();
diff --git a/wasm/module/package.json b/wasm/module/package.json
new file mode 100644
index 000000000..f30464665
--- /dev/null
+++ b/wasm/module/package.json
@@ -0,0 +1,39 @@
+{
+  "name": "@browsermt/bergamot-translator",
+  "version": "0.4.9",
+  "description": "Cross platform C++ library focusing on optimized machine translation on the consumer-grade device.",
+  "homepage": "https://github.com/browsermt/bergamot-translator#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/browsermt/bergamot-translator.git"
+  },
+  "keywords": [
+    "machine",
+    "translation"
+  ],
+  "author": "",
+  "license": "MPL-2.0",
+  "bugs": {
+    "url": "https://github.com/browsermt/bergamot-translator/issues"
+  },
+  "type": "module",
+  "main": "translator.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "files": [
+    "worker/bergamot-translator-worker.js",
+    "worker/bergamot-translator-worker.wasm",
+    "worker/translator-worker.js",
+    "translator.js",
+    "main.js"
+  ],
+  "config": {
+    "emscripten_version": "3.1.8"
+  },
+  "scripts": {
+    "prepare": "test -f worker/bergamot-translator-worker.wasm || npm run build",
+    "build": "mkdir -p ../../build-wasm && docker run --rm -v $(realpath ../../):/src -v $(realpath ../../build-wasm):/build -v $(pwd)/worker:/dst -w /build emscripten/emsdk:$npm_package_config_emscripten_version sh -c \"emcmake cmake -DCOMPILE_WASM=on -DWORMHOLE=off /src && emmake make -j2 && cp bergamot-translator-worker.wasm bergamot-translator-worker.js /dst\"",
+    "test": "echo \"Hello world!\" | node main.js"
+  }
+}
diff --git a/wasm/module/translator.js b/wasm/module/translator.js
new file mode 100644
index 000000000..f27c07653
--- /dev/null
+++ b/wasm/module/translator.js
@@ -0,0 +1,879 @@
+/**
+ * @typedef {Object} TranslationRequest
+ * @property {String} from
+ * @property {String} to
+ * @property {String} text
+ * @property {Boolean} html
+ * @property {Integer?} priority
+ */
+
+/**
+ * @typedef {Object} TranslationResponse
+ * @property {TranslationRequest} request
+ * @property {{text: string}} target
+ */
+
+/**
+ * NodeJS compatibility, a thin WebWorker layer around node:worker_threads.
+ */
+if (!(typeof window !== 'undefined' && window.Worker)) {
+    globalThis.Worker = class {
+        #worker;
+
+        constructor(url) {
+            this.#worker = new Promise(async (accept) => {
+                const {Worker} = await import(/* webpackIgnore: true */ 'node:worker_threads');
+                accept(new Worker(url));
+            });
+        }
+
+        addEventListener(eventName, callback) {
+            this.#worker.then(worker => worker.on(eventName, (data) => callback({data})));
+        }
+
+        postMessage(message) {
+            this.#worker.then(worker => worker.postMessage(message));
+        }
+
+        terminate() {
+            this.#worker.then(worker => worker.terminate());
+        }
+    }
+}
+
+/**
+ * Thrown when a pending translation is replaced by another newer pending
+ * translation.
+ */
+export class SupersededError extends Error {}
+
+
+/**
+ * Thrown when a translation was removed from the queue.
+ */
+export class CancelledError extends Error {}
+
+
+/**
+ * Wrapper around bergamot-translator loading and model management.
+ */
+ export class TranslatorBacking {
+    
+    /**
+     * @param {{
+     *  cacheSize?: number,
+     *  useNativeIntGemm?: boolean,
+     *  downloadTimeout?: number,
+     *  registryUrl?: string
+     *  pivotLanguage?: string?
+     *  onerror?: (err: Error)
+     * }} options
+     */
+    constructor(options) {
+        this.options = options || {};
+
+        this.registryUrl = this.options.registryUrl || 'https://bergamot.s3.amazonaws.com/models/index.json';
+
+        this.downloadTimeout = 'downloadTimeout' in this.options ? parseInt(this.options.downloadTimeout) : 60000;
+
+        /**
+         * registry of all available models and their urls
+         * @type {Promise<Model[]>}
+         */
+        this.registry = this.loadModelRegistery();
+
+        /**
+         * Map of downloaded model data files as buffers per model.
+         * @type {Map<{from:string,to:string}, Promise<Map<string,ArrayBuffer>>>}
+         */
+        this.buffers = new Map();
+
+        /**
+         * @type {string?}
+         */
+        this.pivotLanguage = 'pivotLanguage' in this.options ? options.pivotLanguage : 'en';
+        
+        /**
+         * A map of language-pairs to a list of models you need for it.
+         * @type {Map<{from:string,to:string}, Promise<{from:string,to:string}[]>>}
+         */
+        this.models = new Map();
+
+        /**
+         * Error handler for all errors that are async, not tied to a specific
+         * call and that are unrecoverable.
+         * @type {(error: Error)}
+         */
+        this.onerror = this.options.onerror || (err => console.error('WASM Translation Worker error:', err));
+    }
+
+    /**
+     * Loads a worker thread, and wraps it in a message passing proxy. I.e. it
+     * exposes the entire interface of TranslationWorker here, and all calls
+     * to it are async. Do note that you can only pass arguments that survive
+     * being copied into a message. 
+     * @return {Promise<{worker:Worker, exports:Proxy<TranslationWorker>}>}
+     */
+    async loadWorker() {
+        const worker = new Worker(new URL('./worker/translator-worker.js', import.meta.url));
+
+        /**
+         * Incremental counter to derive request/response ids from.
+         */
+        let serial = 0;
+
+        /**
+         * Map of pending requests
+         * @type {Map<number,{accept:(any), reject:(Error)}>}
+         */
+        const pending = new Map();
+
+        // Function to send requests
+        const call = (name, ...args) => new Promise((accept, reject) => {
+            const id = ++serial;
+            pending.set(id, {
+                accept,
+                reject,
+                callsite: { // for debugging which call caused the error
+                    message: `${name}(${args.map(arg => String(arg)).join(', ')})`,
+                    stack: new Error().stack
+                }
+            });
+            worker.postMessage({id, name, args});
+        });
+
+        // … receive responses
+        worker.addEventListener('message', function({data: {id, result, error}}) {
+            if (!pending.has(id)) {
+                console.debug('Received message with unknown id:', arguments[0]);
+                throw new Error(`BergamotTranslator received response from worker to unknown call '${id}'`);
+            }
+
+            const {accept, reject, callsite} = pending.get(id);
+            pending.delete(id);
+
+            if (error !== undefined)
+                reject(Object.assign(new Error(), error, {
+                    message: error.message + ` (response to ${callsite.message})`,
+                    stack: error.stack ? `${error.stack}\n${callsite.stack}` : callsite.stack
+                }));
+            else
+                accept(result);
+        });
+
+        // … and general errors
+        worker.addEventListener('error', this.onerror.bind(this));
+
+        // Await initialisation. This will also nicely error out if the WASM
+        // runtime fails to load.
+        await call('initialize', this.options);
+
+        /**
+         * Little wrapper around the message passing api of Worker to make it
+         * easy to await a response to a sent message. This wraps the worker in
+         * a Proxy so you can treat it as if it is an instance of the
+         * TranslationWorker class that lives inside the worker. All function
+         * calls to it are transparently passed through the message passing
+         * channel.
+         */
+        return {
+            worker,
+            exports: new Proxy({}, {
+                get(target, name, receiver) {
+                    // Prevent this object from being marked "then-able"
+                    if (name !== 'then')
+                        return (...args) => call(name, ...args);
+                }
+            })
+        };
+    }
+
+    /**
+     * Loads the model registry. Uses the registry shipped with this extension,
+     * but formatted a bit easier to use, and future-proofed to be swapped out
+     * with a TranslateLocally type registry.
+     * @return {Promise<{
+     *   from: string,
+     *   to: string,
+     *   files: {
+     *     [part:string]: {
+     *       name: string,
+     *       size: number,
+     *       expectedSha256Hash: string
+     *     }
+     *   }[]
+     * }>}
+     */
+    async loadModelRegistery() {
+        const response = await fetch(this.registryUrl, {credentials: 'omit'});
+        const registry = await response.json();
+
+        // Add 'from' and 'to' keys for each model.
+        return Array.from(Object.entries(registry), ([key, files]) => {
+            return {
+                from: key.substring(0, 2),
+                to: key.substring(2, 4),
+                files
+            }
+        });
+    }
+
+    /**
+     * Gets or loads translation model data. Caching wrapper around
+     * `loadTranslationModel()`.
+     * @param {{from:string, to:string}}
+     * @return {Promise<{
+     *   model: ArrayBuffer,
+     *   vocab: ArrayBuffer,
+     *   shortlist: ArrayBuffer,
+     *   qualityModel: ArrayBuffer?
+     * }>}
+     */
+    getTranslationModel({from, to}, options) {
+        const key = JSON.stringify({from, to});
+
+        if (!this.buffers.has(key)) {
+            const promise = this.loadTranslationModel({from, to}, options);
+
+            // set the promise so we return the same promise when its still pending
+            this.buffers.set(key, promise);
+
+            // But if loading fails, remove the promise again so we can try again later
+            promise.catch(err => this.buffers.delete(key))
+        }
+
+        return this.buffers.get(key);
+    }
+
+    /**
+     * Downloads a translation model and returns a set of
+     * ArrayBuffers. These can then be passed to a TranslationWorker thread
+     * to instantiate a TranslationModel inside the WASM vm.
+     * @param {{from:string, to:string}}
+     * @param {{signal:AbortSignal?}?}
+     * @return {Promise<{
+     *   model: ArrayBuffer,
+     *   vocab: ArrayBuffer,
+     *   shortlist: ArrayBuffer,
+     *   qualityModel: ArrayBuffer?
+     *   config: string?
+     * }>}
+     */
+    async loadTranslationModel({from, to}, options) {
+        performance.mark(`loadTranslationModule.${JSON.stringify({from, to})}`);
+
+        // Find that model in the registry which will tell us about its files
+        const entries = (await this.registry).filter(model => model.from == from && model.to == to);
+
+        if (!entries)
+            throw new Error(`No model for '${from}' -> '${to}'`);
+
+        const files = entries[0].files;
+
+        const abort = () => reject(new CancelledError('abort signal'));
+
+        // Promise that resolves (or rejects really) when the abort signal hits
+        const escape = new Promise((accept, reject) => {
+            if (options?.signal)
+                options.signal.addEventListener('abort', abort);
+        });
+
+        // Download all files mentioned in the registry entry. Race the promise
+        // of all fetch requests, and a promise that rejects on the abort signal
+        const buffers = Object.fromEntries(await Promise.race([
+            Promise.all(Object.entries(files).map(async ([part, file]) => {
+                // Special case where qualityModel is not part of the model, and this
+                // should also catch the `config` case.
+                if (file === undefined || file.name === undefined)
+                    return [part, null];
+
+                try {
+                    return [part, await this.fetch(file.name, file.expectedSha256Hash, options)];
+                } catch (cause) {
+                    throw new Error(`Could not fetch ${file.name} for ${from}->${to} model`, {cause});
+                }
+            })),
+            escape
+        ]));
+
+        // Nothing to abort now, clean up abort promise
+        if (options?.signal)
+            options.signal.removeEventListener('abort', abort);
+
+        performance.measure('loadTranslationModel', `loadTranslationModule.${JSON.stringify({from, to})}`);
+
+        let vocabs = [];
+
+        if (buffers.vocab)
+            vocabs = [buffers.vocab]
+        else if (buffers.trgvocab && buffers.srcvocab)
+            vocabs = [buffers.srcvocab, buffers.trgvocab]
+        else
+            throw new Error(`Could not identify vocab files for ${from}->${to} model among: ${Array.from(Object.keys(files)).join(' ')}`);
+
+        let config = {};
+
+        // For the Ukrainian models we need to override the gemm-precision
+        if (files.model.name.endsWith('intgemm8.bin'))
+            config['gemm-precision'] = 'int8shiftAll';
+
+        // If quality estimation is used, we need to turn off skip-cost. Turning
+        // this off causes quite the slowdown.
+        if (files.qualityModel)
+            config['skip-cost'] = false;
+
+        // Allow the registry to also specify marian configuration parameters
+        if (files.config)
+            Object.assign(config, files.config);
+
+        // Translate to generic bergamot-translator format that also supports
+        // separate vocabularies for input & output language, and calls 'lex'
+        // a more descriptive 'shortlist'.
+        return {
+            model: buffers.model,
+            shortlist: buffers.lex,
+            vocabs,
+            qualityModel: buffers.qualityModel,
+            config
+        };
+    }
+
+    /**
+     * Helper to download file from the web. Verifies the checksum.
+     * @param {string} url
+     * @param {string?} checksum sha256 checksum as hexadecimal string
+     * @param {{signal:AbortSignal}?} extra fetch options
+     * @returns {Promise<ArrayBuffer>}
+     */
+    async fetch(url, checksum, extra) {
+        // Rig up a timeout cancel signal for our fetch
+        const controller = new AbortController();
+        const abort = () => controller.abort();
+
+        const timeout = this.downloadTimeout ? setTimeout(abort, this.downloadTimeout) : null;
+
+        try {
+            // Also maintain the original abort signal
+            if (extra?.signal)
+                extra.signal.addEventListener('abort', abort);
+
+            const options = {
+                credentials: 'omit',
+                signal: controller.signal,
+            };
+
+            if (checksum)
+                options['integrity'] = `sha256-${this.hexToBase64(checksum)}`;
+
+            // Disable the integrity check for NodeJS because of
+            // https://github.com/nodejs/undici/issues/1594
+            if (typeof window === 'undefined')
+                delete options['integrity'];
+
+            // Start downloading the url, using the hex checksum to ask
+            // `fetch()` to verify the download using subresource integrity 
+            const response = await fetch(url, options);
+
+            // Finish downloading (or crash due to timeout)
+            return await response.arrayBuffer();
+
+        } finally {
+            if (timeout)
+                clearTimeout(timeout);
+
+            if (extra?.signal)
+                extra.signal.removeEventListener('abort', abort);
+        }
+    }
+
+    /**
+     * Converts the hexadecimal hashes from the registry to something we can use with
+     * the fetch() method.
+     */
+    hexToBase64(hexstring) {
+        return btoa(hexstring.match(/\w{2}/g).map(function(a) {
+            return String.fromCharCode(parseInt(a, 16));
+        }).join(""));
+    }
+
+    /**
+     * Crappy named method that gives you a list of models to translate from
+     * one language into the other. Generally this will be the same as you
+     * just put in if there is a direct model, but it could return a list of
+     * two models if you need to pivot through a third language.
+     * Returns just [{from:str,to:str}...]. To be used something like this:
+     * ```
+     * const models = await this.getModels(from, to);
+     * models.forEach(({from, to}) => {
+     *   const buffers = await this.loadTranslationModel({from,to});
+     *   [TranslationWorker].loadTranslationModel({from,to}, buffers)
+     * });
+     * ```
+     * @returns {Promise<TranslationModel[]>}
+     */
+    getModels({from, to}) {
+        const key = JSON.stringify({from, to});
+
+        // Note that the `this.models` map stores Promises. This so that
+        // multiple calls to `getModels` that ask for the same model will
+        // return the same promise, and the actual lookup is only done once.
+        // The lookup is async because we need to await `this.registry`
+        if (!this.models.has(key))
+            this.models.set(key, this.findModels(from, to));
+
+        return this.models.get(key);
+    }
+
+    /**
+     * Find model (or model pair) to translate from `from` to `to`.
+     * @param {string} from
+     * @param {string} to
+     * @returns {Promise<TranslationModel[]>}
+     */
+    async findModels(from, to) {
+        const registry = await this.registry;
+
+        let direct = [], outbound = [], inbound = [];
+
+        registry.forEach(model => {
+            if (model.from === from && model.to === to)
+                direct.push(model);
+            else if (model.from === from && model.to === this.pivotLanguage)
+                outbound.push(model);
+            else if (model.to === to && model.from === this.pivotLanguage)
+                inbound.push(model);
+        });
+
+        if (direct.length)
+            return [direct[0]];
+
+        if (outbound.length && inbound.length)
+            return [outbound[0], inbound[0]];
+
+        throw new Error(`No model available to translate from '${from}' to '${to}'`);
+    }
+}
+
+/**
+ * Translator balancing between throughput and latency. Can use multiple worker
+ * threads.
+ */
+export class BatchTranslator {
+    /**
+     * @param {{
+     *  cacheSize?: number,
+     *  useNativeIntGemm?: boolean,
+     *  workers?: number,
+     *  batchSize?: number,
+     *  downloadTimeout?: number,
+     *  workerUrl?: string,
+     *  registryUrl?: string
+     *  pivotLanguage?: string?
+     * }} options
+     */
+    constructor(options, backing) {
+        if (!backing)
+            backing = new TranslatorBacking(options);
+
+        this.backing = backing;
+
+        /**
+         * @type {Array<{idle:Boolean, worker:Proxy}>} List of active workers
+         * (and a flag to mark them idle or not)
+         */
+        this.workers = [];
+
+        /**
+         * Maximum number of workers
+         * @type {number} 
+         */
+        this.workerLimit = Math.max(options?.workers || 0, 1);
+
+        /**
+         * List of batches we push() to & shift() from using `enqueue`.
+         * @type {{
+         *    id: number,
+         *    key: string,
+         *    priority: number,
+         *    models: TranslationModel[],
+         *    requests: Array<{
+         *      request: TranslationRequest,
+         *      resolve: (response: TranslationResponse),
+         *      reject: (error: Error)
+         *    }>
+         * }}
+         */
+        this.queue = [];
+
+        /**
+         * batch serial to help keep track of batches when debugging
+         * @type {Number}
+         */
+        this.batchSerial = 0;
+
+        /**
+         * Number of requests in a batch before it is ready to be translated in
+         * a single call. Bigger is better for throughput (better matrix packing)
+         * but worse for latency since you'll have to wait for the entire batch
+         * to be translated.
+         * @type {Number}
+         */
+        this.batchSize = Math.max(options?.batchSize || 8, 1);
+
+        this.onerror = options?.onerror || (err => console.error('WASM Translation Worker error:', err));
+    }
+    
+    /**
+     * Destructor that stops and cleans up.
+     */
+    async delete() {
+        // Empty the queue
+        this.remove(() => true);
+
+        // Terminate the workers
+        this.workers.forEach(({worker}) => worker.terminate());
+    }
+
+    /**
+     * Makes sure queued work gets send to a worker. Will delay it till `idle`
+     * to make sure the batches have been filled to some degree. Will keep
+     * calling itself as long as there is work in the queue, but it does not
+     * hurt to call it multiple times. This function always returns immediately.
+     */
+    notify() {
+        setTimeout(async () => {
+            // Is there work to be done?
+            if (!this.queue.length)
+                return;
+
+            // Find an idle worker
+            let worker = this.workers.find(worker => worker.idle);
+
+            // No worker free, but space for more?
+            if (!worker && this.workers.length < this.workerLimit) {
+                try {
+                    // Claim a place in the workers array (but mark it busy so
+                    // it doesn't get used by any other `notify()` calls).
+                    const placeholder = {idle: false};
+                    this.workers.push(placeholder);
+
+                    // adds `worker` and `exports` props
+                    Object.assign(placeholder, await this.backing.loadWorker());
+
+                    // At this point we know our new worker will be usable.
+                    worker = placeholder;
+                } catch (e) {
+                    this.onerror(new Error(`Could not initialise translation worker: ${e.message}`));
+                }
+            }
+
+            // If no worker, that's the end of it.
+            if (!worker)
+                return;
+
+            // Up to this point, this function has not used await, so no
+            // chance that another call stole our batch since we did the check
+            // at the beginning of this function and JavaScript is only
+            // cooperatively parallel.
+            const batch = this.queue.shift();
+
+            // Put this worker to work, marking as busy
+            worker.idle = false;
+            try {
+                await this.consumeBatch(batch, worker.exports);
+            } catch (e) {
+                batch.requests.forEach(({reject}) => reject(e));
+            }
+            worker.idle = true;
+
+            // Is there more work to be done? Do another idleRequest
+            if (this.queue.length)
+                this.notify();
+        });
+    }
+
+    /**
+     * The only real public call you need!
+     * ```
+     * const {target: {text:string}} = await this.translate({
+     *   from: 'de',
+     *   to: 'en',
+     *   text: 'Hallo Welt!',
+     *   html: false, // optional
+     *   priority: 0 // optional, like `nice` lower numbers are translated first
+     * })
+     * ```
+     * @param {TranslationRequest} request
+     * @returns {Promise<TranslationResponse>}
+     */
+    translate(request) {
+        const {from, to, priority} = request;
+
+        return new Promise(async (resolve, reject) => {
+            try {
+                // Batching key: only requests with the same key can be batched
+                // together. Think same translation model, same options.
+                const key = JSON.stringify({from, to});
+
+                // (Fetching models first because if we would do it between looking
+                // for a batch and making a new one, we end up with a race condition.)
+                const models = await this.backing.getModels(request);
+                
+                // Put the request and its callbacks into a fitting batch
+                this.enqueue({key, models, request, resolve, reject, priority});
+
+                // Tell a worker to pick up the work at some point.
+                this.notify();
+            } catch (e) {
+                reject(e);
+            }
+        });
+    }
+
+    /**
+     * Prune pending requests by testing each one of them to whether they're
+     * still relevant. Used to prune translation requests from tabs that got
+     * closed.
+     * @param {(request:TranslationRequest) => boolean} filter evaluates to true if request should be removed
+     */
+    remove(filter) {
+        const queue = this.queue;
+
+        this.queue = [];
+
+        queue.forEach(batch => {
+            batch.requests.forEach(({request, resolve, reject}) => {
+                if (filter(request)) {
+                    // Add error.request property to match response.request for
+                    // a resolve() callback. Pretty useful if you don't want to
+                    // do all kinds of Funcion.bind() dances.
+                    reject(Object.assign(new CancelledError('removed by filter'), {request}));
+                    return;
+                }
+
+                this.enqueue({
+                    key: batch.key,
+                    priority: batch.priority,
+                    models: batch.models,
+                    request,
+                    resolve,
+                    reject
+                });
+            });
+        });
+    }
+
+    /**
+     * Internal function used to put a request in a batch that still has space.
+     * Also responsible for keeping the batches in order of priority. Called by
+     * `translate()` but also used when filtering pending requests.
+     * @param {{request:TranslateRequest, models:TranslationModel[], key:String, priority:Number?, resolve:(TranslateResponse)=>any, reject:(Error)=>any}}
+     */
+    enqueue({key, models, request, resolve, reject, priority}) {
+        if (priority === undefined)
+            priority = 0;
+         // Find a batch in the queue that we can add to
+         // (TODO: can we search backwards? that would speed things up)
+        let batch = this.queue.find(batch => {
+            return batch.key === key
+                && batch.priority === priority
+                && batch.requests.length < this.batchSize
+        });
+
+        // No batch or full batch? Queue up a new one
+        if (!batch) {
+            batch = {id: ++this.batchSerial, key, priority, models, requests: []};
+            this.queue.push(batch);
+            this.queue.sort((a, b) => a.priority - b.priority);
+        }
+
+        batch.requests.push({request, resolve, reject});
+    }
+
+    /**
+     * Internal method that uses a worker thread to process a batch. You can
+     * wait for the batch to be done by awaiting this call. You should only
+     * then reuse the worker otherwise you'll just clog up its message queue.
+     */
+    async consumeBatch(batch, worker) {
+        performance.mark('BergamotBatchTranslator.start');
+
+        // Make sure the worker has all necessary models loaded. If not, tell it
+        // first to load them.
+        await Promise.all(batch.models.map(async ({from, to}) => {
+            if (!await worker.hasTranslationModel({from, to})) {
+                const buffers = await this.backing.getTranslationModel({from, to});
+                await worker.loadTranslationModel({from, to}, buffers);
+            }
+        }));
+
+        // Call the worker to translate. Only sending the actually necessary
+        // parts of the batch to avoid trying to send things that don't survive
+        // the message passing API between this thread and the worker thread.
+        const responses = await worker.translate({
+            models: batch.models.map(({from, to}) => ({from, to})),
+            texts: batch.requests.map(({request: {text, html, qualityScores}}) => ({
+                text: text.toString(),
+                html: !!html,
+                qualityScores: !!qualityScores
+            }))
+        });
+
+        // Responses are in! Connect them back to their requests and call their
+        // callbacks.
+        batch.requests.forEach(({request, resolve, reject}, i) => {
+            // TODO: look at response.ok and reject() if it is false
+            resolve({
+                request, // Include request for easy reference? Will allow you
+                         // to specify custom properties and use that to link
+                         // request & response back to each other.
+                ...responses[i] // {target: {text: String}}
+            });
+        });
+        
+        performance.measure('BergamotBatchTranslator', 'BergamotBatchTranslator.start');
+    }
+}
+
+
+/**
+ * Translator optimised for interactive use.
+ */
+export class LatencyOptimisedTranslator {
+    /**
+     * @type {TranslatorBacking}
+     */
+    backing;
+
+    /**
+     * @type {Promise<{idle:boolean, worker:Worker, exports:Proxy<TranslationWorker>}>}
+     */
+    worker;
+
+    /**
+     * @type {{request: TranslationRequest, accept:(TranslationResponse), reject:(Error)} | null}
+     */
+    pending;
+
+    /**
+     * @param {{
+     *  cacheSize?: number,
+     *  useNativeIntGemm?: boolean,
+     *  downloadTimeout?: number,
+     *  workerUrl?: string,
+     *  registryUrl?: string
+     *  pivotLanguage?: string?
+     * }} options
+     */
+    constructor(options, backing) {
+        if (!backing)
+            backing = new TranslatorBacking(options);
+
+        this.backing = backing;
+
+        // Exposing the this.loadWorker() returned promise through this.worker
+        // so that you can use that to catch any errors that happened during
+        // loading.
+        this.worker = this.backing.loadWorker().then(worker => ({...worker, idle:true}));
+    }
+
+    /**
+     * Destructor that stops and cleans up.
+     */
+    async delete() {
+        // Cancel pending translation
+        if (this.pending) {
+            this.pending.reject(new CancelledError('translator got deleted'));
+            this.pending = null;
+        }
+
+        // Terminate the worker (I don't care if this fails)
+        try {
+            const {worker} = await this.worker;
+            worker.terminate();
+        } finally {
+            this.worker = null;
+        }
+    }
+    
+    /**
+     * Sets `request` as the next translation to process. If there was already
+     * a translation waiting to be processed, their promise is rejected with a
+     * SupersededError.
+     * @param {TranslationRequest} request
+     * @return {Promise<TranslationResponse>}
+     */
+    translate(request, options) {
+        if (this.pending)
+            this.pending.reject(new SupersededError());
+        
+        return new Promise((accept, reject) => {
+            const pending = {request, accept, reject, options};
+
+            if (options?.signal) {
+                options.signal.addEventListener('abort', e => {
+                    reject(new CancelledError('abort signal'));
+                    if (this.pending === pending)
+                        this.pending = null;
+                });
+            }
+
+            this.pending = pending;
+            this.notify();
+        });
+    }
+    
+    notify() {
+        setTimeout(async () => {
+            if (!this.pending)
+                return;
+
+            // Catch errors such as the worker not working
+            try {
+                // Possibly wait for the worker to finish loading. After it loaded
+                // these calls are pretty much instantaneous.
+                const worker = await this.worker;
+
+                // Is another notify() call hogging the worker? Then stop.
+                if (!worker.idle)
+                    return;
+
+                // Claim the pending translation request.
+                const {request, accept, reject, options} = this.pending;
+                this.pending = null;
+
+                // Mark the worker as occupied
+                worker.idle = false;
+                    
+                try {
+                    const models = await this.backing.getModels(request)
+
+                    await Promise.all(models.map(async ({from, to}) => {
+                        if (!await worker.exports.hasTranslationModel({from, to})) {
+                            const buffers = await this.backing.getTranslationModel({from, to}, {signal: options?.signal});
+                            await worker.exports.loadTranslationModel({from, to}, buffers);
+                        }
+                    }));
+
+                    const {text, html, qualityScores} = request;
+                    const responses = await worker.exports.translate({
+                        models: models.map(({from,to}) => ({from, to})),
+                        texts: [{text, html, qualityScores}]
+                    });
+
+                    accept({request, ...responses[0]});
+                } catch (e) {
+                    reject(e);
+                }
+
+                worker.idle = true;
+
+                // Is there more work to be done? Do another idleRequest
+                if (this.pending)
+                    this.notify();
+            } catch (e) {
+                this.backing.onerror(e);
+            }
+        });
+    }
+}
diff --git a/wasm/module/worker/package.json b/wasm/module/worker/package.json
new file mode 100644
index 000000000..a2091cee3
--- /dev/null
+++ b/wasm/module/worker/package.json
@@ -0,0 +1,3 @@
+{
+	"type": "commonjs"
+}
\ No newline at end of file
diff --git a/wasm/module/worker/translator-worker.js b/wasm/module/worker/translator-worker.js
new file mode 100644
index 000000000..24ff29ad2
--- /dev/null
+++ b/wasm/module/worker/translator-worker.js
@@ -0,0 +1,475 @@
+/**
+ * Wrapper around the dirty bits of Bergamot's WASM bindings.
+ */
+
+// Global because importScripts is global.
+var Module = {};
+
+/**
+ * node.js compatibility: Fake GlobalWorkerScope that emulates being inside a
+ * WebWorker
+ */
+if (typeof self === 'undefined') {
+    global.Module = Module;
+
+    global.self = new class GlobalWorkerScope {
+        /** @type {import("node:worker_threads").MessagePort} */
+        #port;
+
+        constructor() {
+            const {parentPort} = require(/* webpackIgnore: true */ 'node:worker_threads');
+            this.#port = parentPort;
+        }
+
+        /**
+         * Add event listener to listen for messages posted to the worker.
+         * @param {string} eventName
+         * @param {(object)} callback
+         */
+        addEventListener(eventName, callback) {
+            this.#port.on(eventName, (data) => callback({data}));
+        }
+
+        /**
+         * Post message outside, to the owner of the Worker.
+         * @param {any} message
+         */
+        postMessage(message) {
+            this.#port.postMessage(message);
+        }
+
+        /**
+         * @param {...string} scripts - Paths to scripts to import in that order
+         */
+        importScripts(...scripts) {
+            const {readFileSync} = require(/* webpackIgnore: true */ 'node:fs');
+            const {join} = require(/* webpackIgnore: true */ 'node:path');
+            for (let pathname of scripts) {
+                const script = readFileSync(join(__dirname, pathname), {encoding: 'utf-8'});
+                eval.call(global, script);
+            }
+        }
+
+        /**
+         * Adds support for local file urls. Assumes anything that doesn't start
+         * with "http" to be a local path.
+         * @param {string} url - path or url
+         * @param {object?} options - See `fetch()` options
+         * @return {Promise<Response>}
+         */
+        async fetch(url, options) {
+            if (url.protocol === 'file:') {
+                const {readFile} = require(/* webpackIgnore: true */ 'node:fs/promises');
+                const buffer = await readFile(url.pathname);
+                const blob = new Blob([buffer]);
+                return new Response(blob, {
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {
+                        'Content-Type': 'application/wasm',
+                        'Content-Length': blob.size.toString()
+                    }
+                });
+            }
+
+            return await fetch(url, options);
+        }
+
+        get location() {
+            return new URL(`file://${__filename}`);
+        }
+    }
+}
+
+class YAML {
+    /**
+     * Parses YAML into dictionary. Does not interpret types, all values are a
+     * string or a list of strings. No support for objects other than the top
+     * level.
+     * @param {string} yaml
+     * @return {{[string]: string | string[]}}
+     */
+    static parse(yaml) {
+        const out = {};
+
+        yaml.split('\n').reduce((key, line, i) => {
+            let match;
+            if (match = line.match(/^\s*-\s+(.+?)$/)) {
+                if (!Array.isArray(out[key]))
+                    out[key] = out[key].trim() ? [out[key]] : [];
+                out[key].push(match[1].trim());
+            }
+            else if (match = line.match(/^\s*([A-Za-z0-9_][A-Za-z0-9_-]*):\s*(.*)$/)) {
+                key = match[1];
+                out[key] = match[2].trim();
+            }
+            else if (!line.trim()) {
+                // whitespace, ignore
+            }
+            else {
+                throw Error(`Could not parse line ${i+1}: "${line}"`);
+            }
+            return key;
+        }, null);
+
+        return out;
+    }
+
+    /**
+     * Turns an object into a YAML string. No support for objects, only simple
+     * types and lists of simple types.
+     * @param {{[string]: string | number | boolean | string[]}} data
+     * @return {string}
+     */
+    static stringify(data) {
+        return Object.entries(data).reduce((str, [key, value]) => {
+            let valstr = '';
+            if (Array.isArray(value))
+                valstr = value.map(val => `\n  - ${val}`).join('');
+            else if (typeof value === 'number' || typeof value === 'boolean' || value.match(/^\d*(\.\d+)?$/))
+                valstr = `${value}`;
+            else
+                valstr = `${value}`; // Quote?
+
+            return `${str}${key}: ${valstr}\n`;
+        }, '');
+    }
+}
+
+/**
+ * Wrapper around the bergamot-translator exported module that hides the need
+ * of working with C++ style data structures and does model management.
+ */
+class BergamotTranslatorWorker {
+    /**
+     * Map of expected symbol -> name of fallback symbol for functions that can
+     * be swizzled for a faster implementation. Firefox Nightly makes use of
+     * this.
+     */
+    static GEMM_TO_FALLBACK_FUNCTIONS_MAP = {
+        'int8_prepare_a': 'int8PrepareAFallback',
+        'int8_prepare_b': 'int8PrepareBFallback',
+        'int8_prepare_b_from_transposed': 'int8PrepareBFromTransposedFallback',
+        'int8_prepare_b_from_quantized_transposed': 'int8PrepareBFromQuantizedTransposedFallback',
+        'int8_prepare_bias': 'int8PrepareBiasFallback',
+        'int8_multiply_and_add_bias': 'int8MultiplyAndAddBiasFallback',
+        'int8_select_columns_of_b': 'int8SelectColumnsOfBFallback'
+    };
+
+    /**
+     * Name of module exported by Firefox Nightly that exports an optimised
+     * implementation of the symbols mentioned above.
+     */
+    static NATIVE_INT_GEMM = 'mozIntGemm';
+
+    /**
+     * Empty because we can't do async constructors yet. It is the
+     * responsibility of whoever owns this WebWorker to call `initialize()`.
+     */
+    constructor(options) {}
+
+    /**
+     * Instantiates a new translation worker with optional options object.
+     * If this call succeeds, the WASM runtime is loaded and ready.
+     * 
+     * Available options are:
+     *   useNativeIntGemm: {true | false} defaults to false. If true, it will
+     *                     attempt to link to the intgemm module available in
+     *                     Firefox Nightly which makes translations much faster.
+     *          cacheSize: {Number} defaults to 0 which disables translation
+     *                     cache entirely. Note that this is a theoretical
+     *                     upper bound. In practice it will use about 1/3th of
+     *                     the cache specified here. 2^14 is not a bad starting
+     *                     value.
+     * @param {{useNativeIntGemm: boolean, cacheSize: number}} options
+     */
+    async initialize(options) {
+        this.options = options || {};
+        this.models = new Map(); // Map<str,Promise<TranslationModel>>
+        this.module = await this.loadModule();
+        this.service = await this.loadTranslationService();
+    }
+
+    /**
+     * Tries to load native IntGEMM module for bergamot-translator. If that
+     * fails because it or any of the expected functions is not available, it
+     * falls back to using the naive implementations that come with the wasm
+     * binary itself through `linkFallbackIntGemm()`.
+     * @param {{env: {memory: WebAssembly.Memory}}} info
+     * @return {{[method:string]: (...any) => any}}
+     */
+    linkNativeIntGemm(info) {
+        if (!WebAssembly['mozIntGemm']) {
+            console.warn('Native gemm requested but not available, falling back to embedded gemm');
+            return this.linkFallbackIntGemm(info);
+        }
+
+        const instance = new WebAssembly.Instance(WebAssembly['mozIntGemm'](), {
+            '': {memory: info['env']['memory']}
+        });
+
+        if (!Array.from(Object.keys(BergamotTranslatorWorker.GEMM_TO_FALLBACK_FUNCTIONS_MAP)).every(fun => instance.exports[fun])) {
+            console.warn('Native gemm is missing expected functions, falling back to embedded gemm');
+            return this.linkFallbackIntGemm(info);
+        }
+
+        return instance.exports;
+    }
+
+    /**
+     * Links intgemm functions that are already available in the wasm binary,
+     * but just exports them under the name that is expected by
+     * bergamot-translator.
+     * @param {{env: {memory: WebAssembly.Memory}}} info
+     * @return {{[method:string]: (...any) => any}}
+     */
+    linkFallbackIntGemm(info) {
+        const mapping = Object.entries(BergamotTranslatorWorker.GEMM_TO_FALLBACK_FUNCTIONS_MAP).map(([key, name]) => {
+            return [key, (...args) => Module['asm'][name](...args)]
+        });
+
+        return Object.fromEntries(mapping);
+    }
+
+    /**
+     * Internal method. Reads and instantiates the WASM binary. Returns a
+     * promise for the exported Module object that contains all the classes
+     * and functions exported by bergamot-translator.
+     * @return {Promise<BergamotTranslator>}
+     */
+    loadModule() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const response = await self.fetch(new URL('./bergamot-translator-worker.wasm', self.location));
+
+                Object.assign(Module, {
+                    instantiateWasm: (info, accept) => {
+                        try {
+                            WebAssembly.instantiateStreaming(response, {
+                                ...info,
+                                'wasm_gemm': this.options.useNativeIntGemm
+                                    ? this.linkNativeIntGemm(info)
+                                    : this.linkFallbackIntGemm(info)
+                            }).then(({instance}) => accept(instance)).catch(reject);
+                        } catch (err) {
+                            reject(err);
+                        }
+                        return {};
+                    },
+                    onRuntimeInitialized: () => {
+                        resolve(Module);
+                    }
+                });
+
+                // Emscripten glue code. Webpack et al. should not mangle the `Module` property name!
+                self.Module = Module;
+                self.importScripts('bergamot-translator-worker.js');
+            } catch (err) {
+                reject(err);
+            }
+        });
+    }
+
+    /**
+     * Internal method. Instantiates a BlockingService()
+     * @return {BergamotTranslator.BlockingService}
+     */
+    loadTranslationService() {
+        return new this.module.BlockingService({
+            cacheSize: Math.max(this.options.cacheSize || 0, 0)
+        });
+    }
+
+    /**
+     * Returns whether a model has already been loaded in this worker. Marked
+     * async because the message passing interface we use expects async methods.
+     * @param {{from:string, to:string}}
+     * @return boolean
+     */ 
+    hasTranslationModel({from,to}) {
+        const key = JSON.stringify({from,to});
+        return this.models.has(key);
+    }
+
+    /**
+     * Loads a translation model from a set of file buffers. After this, the
+     * model is available to translate with and `hasTranslationModel()` will
+     * return true for this pair.
+     * @param {{from:string, to:string}}
+     * @param {{
+     *   model: ArrayBuffer,
+     *   shortlist: ArrayBuffer,
+     *   vocabs: ArrayBuffer[],
+     *   qualityModel: ArrayBuffer?,
+     *   config?: {
+     *     [key:string]: string
+     *   }
+     * }} buffers
+     */ 
+    loadTranslationModel({from, to}, buffers) {
+        // This because service_bindings.cpp:prepareVocabsSmartMemories :(
+        const uniqueVocabs = buffers.vocabs.filter((vocab, index, vocabs) => {
+            return !vocabs.slice(0, index).includes(vocab);
+        });
+
+        const [modelMemory, shortlistMemory, qualityModel, ...vocabMemory] = [
+            this.prepareAlignedMemoryFromBuffer(buffers.model, 256),
+            this.prepareAlignedMemoryFromBuffer(buffers.shortlist, 64),
+            buffers.qualityModel // optional quality model
+                ? this.prepareAlignedMemoryFromBuffer(buffers.qualityModel, 64)
+                : null,
+            ...uniqueVocabs.map(vocab => this.prepareAlignedMemoryFromBuffer(vocab, 64))
+        ];
+
+        const vocabs = new this.module.AlignedMemoryList();
+        vocabMemory.forEach(vocab => vocabs.push_back(vocab));
+
+        // Defaults
+        let modelConfig = YAML.parse(`
+            beam-size: 1
+            normalize: 1.0
+            word-penalty: 0
+            cpu-threads: 0
+            gemm-precision: int8shiftAlphaAll
+            skip-cost: true
+        `);
+
+        if (buffers.config)
+            Object.assign(modelConfig, buffers.config);
+
+        // WASM marian is only compiled with support for shiftedAll.
+        if (modelConfig['gemm-precision'] === 'int8')
+            modelConfig['gemm-precision'] = 'int8shiftAll';
+
+        // Override these
+        Object.assign(modelConfig, YAML.parse(`
+            alignment: soft
+            quiet: true
+            quiet-translation: true
+            max-length-break: 128
+            mini-batch-words: 1024
+            workspace: 128
+            max-length-factor: 2.0
+        `));
+
+        const key = JSON.stringify({from,to});
+        this.models.set(key, new this.module.TranslationModel(YAML.stringify(modelConfig), modelMemory, shortlistMemory, vocabs, qualityModel));
+    }
+
+    /**
+     * Frees up memory used by old translation model. Does nothing if model is
+     * already deleted.
+     * @param {{from:string, to:string}}
+     */
+    freeTranslationModel({from, to}) {
+        const key = JSON.stringify({from,to});
+        
+        if (!this.models.has(key))
+            return;
+        
+        const model = this.models.get(key);
+        this.models.delete(key);
+
+        model.delete();
+    }
+
+    /**
+     * Internal function. Copies the data from an ArrayBuffer into memory that
+     * can be used inside the WASM vm by Marian.
+     * @param {{ArrayBuffer}} buffer
+     * @param {number} alignmentSize
+     * @return {BergamotTranslator.AlignedMemory}
+     */
+    prepareAlignedMemoryFromBuffer(buffer, alignmentSize) {
+        const bytes = new Int8Array(buffer);
+        const memory = new this.module.AlignedMemory(bytes.byteLength, alignmentSize);
+        memory.getByteArrayView().set(bytes);
+        return memory;
+    }
+
+    /**
+     * Public. Does actual translation work. You have to make sure that the
+     * models necessary for translating text are already loaded before calling
+     * this method. Returns a promise with translation responses.
+     * @param {{models: {from:string, to:string}[], texts: {text: string, html: boolean}[]}}
+     * @return {Promise<{target: {text: string}}[]>}
+     */
+    translate({models, texts}) {
+        // Convert texts array into a std::vector<std::string>.
+        let input = new this.module.VectorString();
+        texts.forEach(({text}) => input.push_back(text));
+
+        // Extracts the texts[].html options into ResponseOption objects
+        let options = new this.module.VectorResponseOptions();
+        texts.forEach(({html, qualityScores}) => options.push_back({alignment: false, html, qualityScores}));
+
+        // Turn our model names into a list of TranslationModel pointers
+        const translationModels = models.map(({from,to}) => {
+            const key = JSON.stringify({from,to});
+            return this.models.get(key);
+        });
+
+        // translate the input, which is a vector<String>; the result is a vector<Response>
+        const responses = models.length > 1
+            ? this.service.translateViaPivoting(...translationModels, input, options)
+            : this.service.translate(...translationModels, input, options);
+        
+        input.delete();
+        options.delete();
+
+        // Convert the Response WASM wrappers into native JavaScript types we
+        // can send over the 'wire' (message passing) in the same format as we
+        // use in bergamot-translator.
+        const translations = texts.map((_, i) => ({
+            target: {
+                text: responses.get(i).getTranslatedText()
+            }
+        }));
+
+        responses.delete();
+
+        return translations;
+    }
+}
+
+/**
+ * Because you can't put an Error object in a message. But you can post a
+ * generic object!
+ * @param {Error} error
+ * @return {{
+ *  name: string?,
+ *  message: string?,
+ *  stack: string?
+ * }}
+ */
+function cloneError(error) {
+    return {
+        name: error.name,
+        message: error.message,
+        stack: error.stack
+    };
+}
+
+// (Constructor doesn't really do anything, we need to call `initialize()`
+// first before using it. That happens from outside the worker.)
+const worker = new BergamotTranslatorWorker();
+
+self.addEventListener('message', async function({data: {id, name, args}}) {
+    if (!id)
+        console.error('Received message without id', arguments[0]);
+
+    try {
+        if (typeof worker[name] !== 'function')
+            throw TypeError(`worker[${name}] is not a function`);
+
+        // Using `Promise.resolve` to await any promises that worker[name]
+        // possibly returns.
+        const result = await Promise.resolve(Reflect.apply(worker[name], worker, args));
+        self.postMessage({id, result});
+    } catch (error) {
+        self.postMessage({
+            id,
+            error: cloneError(error)
+        })
+    }
+});
diff --git a/wasm/node-test.js b/wasm/node-test.js
new file mode 100755
index 000000000..8734858f5
--- /dev/null
+++ b/wasm/node-test.js
@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+
+/**
+ * A note upfront: the bergamot-translator API is pretty low level, and
+ * embedding it successfully requires some knowledge about the WebWorkers and
+ * WebAssembly APIs. This script tries to demonstrate the bergamot-translator
+ * API with as little of that boiler plate code as possible.
+ * See the wasm/test_page code for a fully fleshed out demo in a web context.
+ */
+
+// For node we use the fs module to read local files. In a web context you can
+// use `fetch()` for everything.
+const fs = require('fs');
+
+// Read wasm binary into a blob, which will be loaded by
+// bergamot-translator-worker.js in a minute. In a web context, you'd be using
+// `fetch(...).then(response => response.blob())` for this, but Node does not
+// implement `fetch("file://...")` yet.
+const wasmBinary = fs.readFileSync('./bergamot-translator-worker.wasm');
+
+// Read wasm runtime code that bridges the bergmot-translator binary with JS.
+const wasmRuntime = fs.readFileSync('./bergamot-translator-worker.js', {encoding: 'utf8'});
+
+// Initialise the `Module` object. By adding methods and options to this, we can
+// affect how bergamot-translator interacts with JavaScript. See 
+// https://emscripten.org/docs/api_reference/module.html for all available
+// options. It is important that this object is initialised in the same scope
+// but before `bergamot-translation-worker.js` is executed. Once that script
+// executes, it defines the exported methods as properties of this Module
+// object.
+global.Module = {
+  wasmBinary,
+  onRuntimeInitialized
+};
+
+// Execute bergamot-translation-worker.js in this scope. This will also,
+// indirectly, call the onRuntimeInitialized function defined below and
+// referenced in the `Module` object above.
+eval.call(global, wasmRuntime);
+
+/**
+ * Called from inside the bergamot-translation-worker.js script once the wasm
+ * module is initialized. At this point that `Module` object that was
+ * initialised above will have all the classes defined in the
+ * bergamot-translator API available on it.
+ */
+async function onRuntimeInitialized() {
+  // Root url for our models for now.
+  const root = 'https://storage.googleapis.com/bergamot-models-sandbox/0.3.1';
+
+  // Urls of data files necessary to create a translation model for
+  // English -> German. Note: list is in order of TranslationModel's arguments.
+  // The `alignment` value is used later on to load each part of the model with
+  // the correct alignment.
+  const files = [
+    // Neural network and weights:
+    {url: `${root}/ende/model.ende.intgemm.alphas.bin`, alignment: 256},
+    
+    // Lexical shortlist which is mainly a speed improvement method, not
+    // strictly necessary:
+    {url: `${root}/ende/lex.50.50.ende.s2t.bin`, alignment: 64},
+    
+    // Vocabulary, maps the input and output nodes of the neural network to
+    // strings. Note: "deen" may look the wrong way around but vocab is the same
+    // between de->en and en->de models.
+    {url: `${root}/ende/vocab.deen.spm`, alignment: 64},
+  ];
+
+  // Download model data and load it into aligned memory. AlignedMemory is a
+  // necessary wrapper around allocated memory inside the WASM environment.
+  // The value of `alignment` is specific for which part of the model we're
+  // loading. See https://en.wikipedia.org/wiki/Data_structure_alignment for a
+  // more general explanation.
+  const [modelMem, shortlistMem, vocabMem] = await Promise.all(files.map(async (file) => {
+    const response = await fetch(file.url);
+    const blob = await response.blob();
+    const buffer = await blob.arrayBuffer();
+    const bytes = new Int8Array(buffer);
+    const memory = new Module.AlignedMemory(bytes.byteLength, file.alignment);
+    memory.getByteArrayView().set(bytes);
+    return memory;
+  }));
+
+  // Set up translation service. This service translates a batch of text per
+  // call. The larger the batch, the faster the translation (in words per
+  // second) happens, but the longer you have to wait for all of them to finish.
+  // The constructor expects an object with options, but only one option is
+  // currently supported: `cacheSize`. Setting this to `0` disables the
+  // translation cache.
+  // **Note**: cacheSize is the theoretical maximum number of sentences that
+  // will be cached. In practise, about 1/3 of that will actually be used.
+  // See https://github.com/XapaJIaMnu/translateLocally/pull/75
+  const service = new Module.BlockingService({cacheSize: 0});
+
+  // Put vocab into its own std::vector<AlignedMemory>. Most models for the
+  // Bergamot project only have one vocabulary that is shared by both the input
+  // and output side of the translator. But in theory, you could have one for
+  // the input side and a different one for the output side. Hence: a list.
+  const vocabs = new Module.AlignedMemoryList();
+  vocabs.push_back(vocabMem);
+
+  // Config yaml (split as array to allow for indentation without adding tabs
+  // or spaces to the strings themselves.)
+  // See https://marian-nmt.github.io/docs/cmd/marian-decoder/ for the meaning
+  // of most of these options and what other options might be available.
+  const config = [
+    'beam-size: 1',
+    'normalize: 1.0',
+    'word-penalty: 0',
+    'alignment: soft', // is necessary if you want to use HTML at any point
+    'max-length-break: 128',
+    'mini-batch-words: 1024',
+    'workspace: 128',
+    'max-length-factor: 2.0',
+    'skip-cost: true',
+    'gemm-precision: int8shiftAll', // is necessary for speed and compatibility with Mozilla's models.
+  ].join('\n');
+
+  // Setup up model with config yaml and AlignedMemory objects. Optionally a
+  // quality estimation model can also be loaded but this is not demonstrated
+  // here. Generally you don't need it, and many models don't include the data
+  // file necessary to use it anyway.
+  const model = new Module.TranslationModel(config, modelMem, shortlistMem, vocabs, /*qualityModel=*/ null);
+
+  // Construct std::vector<std::string> inputs; This is our batch!
+  const input = new Module.VectorString();
+  input.push_back('<p>Hello world! Let us write a second sentence.</p> &amp; <p>Goodbye World!</p>');
+  input.push_back('This is a second example without HTML & entities.');
+
+  // Construct std::vector<ResponseOptions>, one entry per input. Note that
+  // all these three properties of your ResponseOptions object need to be
+  // specified for each entry.
+  // `qualityScores`: related to quality models not explained here. Set this
+  //   to `false`.
+  // `alignment`: computes alignment scores that maps parts of the input text
+  //   to parts of the output text. There is currently no way to get these
+  //   mappings out through the JavaScript API so I suggest you set this to
+  //   `false` as well.
+  // `html`: is the input HTML? If so, the HTML will be parsed and the markup
+  //   will be copied back into the translated output. Note: HTML has to be
+  //   valid HTML5, with proper closing tags and everything since the HTML
+  //   parser built into bergamot-translator does no error correction. Output
+  //   of e.g. `Element.innerHTML` meets this criteria.
+  const options = new Module.VectorResponseOptions();
+  options.push_back({qualityScores: false, alignment: false, html: true});
+  options.push_back({qualityScores: false, alignment: false, html: false});
+
+  // Size of `input` and `options` has to match.
+  console.assert(input.size() === options.size());
+
+  // Translate our batch of 2 requests. Output will be another vector of type 
+  // `std::vector<Response>`.
+  const output = service.translate(model, input, options);
+
+  console.assert(false);
+
+  // Number of outputs is number of inputs.
+  console.assert(input.size() === output.size());
+
+  for (let i = 0; i < output.size(); ++i) {
+    // Get output from std::vector<Response>.
+    const translation = output.get(i).getTranslatedText();
+
+    // Print raw translation for inspection.
+    console.log(translation)
+  }
+
+  // Clean-up: unlike the objects in JavaScript, the objects in the WASM
+  // environment are not automatically cleaned up when they're no longer
+  // referenced. That is why we manually have to call `delete()` on them
+  // when we're done with them.
+  input.delete();
+  options.delete();
+  output.delete();
+}
diff --git a/wasm/patch-artifacts-enable-wormhole.sh b/wasm/patch-artifacts-enable-wormhole.sh
deleted file mode 100644
index e39988b4e..000000000
--- a/wasm/patch-artifacts-enable-wormhole.sh
+++ /dev/null
@@ -1,36 +0,0 @@
-#!/bin/bash
-usage="Patch wasm artifacts to enable wormhole via APIs that compile and instantiate wasm module.
-
-Usage: $(basename "$0") [WASM_ARTIFACTS_FOLDER]
-
-    where:
-    WASM_ARTIFACTS_FOLDER    Folder containing wasm artifacts
-                             (An optional argument, if unspecified the default is: current folder)"
-
-if [ "$#" -gt 1 ]; then
-    echo "Illegal number of parameters passed"
-    echo "$usage"
-    exit
-fi
-
-# Parse wasm artifacts folder if provided via script argument or set it to default
-WASM_ARTIFACTS_FOLDER=$PWD
-if [ "$#" -eq 1 ]; then
-    if [ ! -e "$1" ]; then
-        echo "Error: Folder \""$1"\" doesn't exist"
-        exit
-    fi
-    WASM_ARTIFACTS_FOLDER="$1"
-fi
-
-WASM_ARTIFACTS="$WASM_ARTIFACTS_FOLDER/bergamot-translator-worker.js"
-if [ ! -e "$WASM_ARTIFACTS" ]; then
-    echo "Error: Artifact \"$WASM_ARTIFACTS\" doesn't exist"
-    exit
-fi
-
-echo "Patching \"$WASM_ARTIFACTS\" to enable wormhole via APIs that compile and instantiate wasm module"
-sed -i.bak 's/WebAssembly.instantiateStreaming[[:space:]]*([[:space:]]*response[[:space:]]*,[[:space:]]*info[[:space:]]*)/WebAssembly.instantiateStreaming(response, info, {simdWormhole:true})/g' $WASM_ARTIFACTS
-sed -i.bak 's/WebAssembly.instantiate[[:space:]]*([[:space:]]*binary[[:space:]]*,[[:space:]]*info[[:space:]]*)/WebAssembly.instantiate(binary, info, {simdWormhole:true})/g' $WASM_ARTIFACTS
-sed -i.bak 's/WebAssembly.Module[[:space:]]*([[:space:]]*bytes[[:space:]]*)/WebAssembly.Module(bytes, {simdWormhole:true})/g' $WASM_ARTIFACTS
-echo "Done"
diff --git a/wasm/test_page/css/index.css b/wasm/test_page/css/index.css
index 6ed642232..11521a156 100644
--- a/wasm/test_page/css/index.css
+++ b/wasm/test_page/css/index.css
@@ -14,20 +14,33 @@ body {
   padding: 1rem;
 }
 
+[hidden] {
+  display: none;
+}
+
 .app {
   padding: 1rem;
   display: grid;
-  grid: "from swap to" 1fr "status status status" auto / 1fr auto 1fr;
+  grid: "from swap to" auto "credits credits credits" min-content / 1fr auto 1fr;
   grid-gap: 1rem;
   overflow: hidden;
-  min-height: 400px;
+  min-height: 100%;
   max-width: 1024px;
-  margin: 1em auto;
+  margin: 0 auto;
+}
+
+.swap::before {
+  display: inline-block;
+  content: '↔️';
 }
 
 @media screen and (max-width: 640px) {
   .app {
-    grid: "from from" auto "status swap" auto "to to" auto / 1fr;
+    grid: "from from" auto "swap swap" auto "to to" auto "credits credits" auto / 1fr;
+  }
+
+  .swap::before {
+    content: '↕️';
   }
 }
 
@@ -35,6 +48,8 @@ body {
   display: grid;
   grid-template-rows: auto 1fr;
   grid-gap: 1rem;
+  max-height: 100%;
+  overflow: hidden;
 }
 
 label {
@@ -67,19 +82,25 @@ label {
   font-size: 1.1rem;
 }
 
-#status {
-  grid-area: status;
-  text-align: center;
-  align-self: center;
+.credits {
+  grid-area: credits;
 }
 
-textarea, .output-area {
+.credits img {
+  float: left;
+  margin: 1em 0;
+}
+
+textarea, [contenteditable], .output-area {
   padding: 1rem;
   font-family: sans-serif;
   font-size: 1rem;
   resize: none;
   border-radius: 2px;
   border: 1px solid #ccc;
+  min-height: 100px;
+  max-height: 100%;
+  overflow: auto;
 }
 
 button {
@@ -96,6 +117,7 @@ button:hover {
 
 #output {
   background-color: #f4f4f4;
+  position: relative;
 }
 
 .output-area [x-bergamot-word-score].bad {
@@ -115,4 +137,32 @@ button:hover {
 
 .output-area [x-bergamot-sentence-index].highlight-sentence {
   background: rgba(255, 255, 128, 0.8);
-}
\ No newline at end of file
+}
+
+.app.translating #output::after {
+  position: absolute;
+  bottom: 4px;
+  right: 4px;
+  content: 'Translating…';
+}
+
+/* Loading indicator takes priority, so below the .translating selector */
+.app.loading #output::after {
+  position: absolute;
+  bottom: 4px;
+  right: 4px;
+  content: 'Loading translation model…';
+}
+
+.app {
+  position: relative;
+}
+
+#unsupported-browser {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background: white;
+}
diff --git a/wasm/test_page/index.html b/wasm/test_page/index.html
index 3f48117e1..124857e23 100644
--- a/wasm/test_page/index.html
+++ b/wasm/test_page/index.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html>
   <head>
-    <title>Mozilla Translations</title>
+    <title>Bergamot Translations</title>
     <link rel="stylesheet" href="css/index.css" />
     <meta http-equiv="Content-Type" content="text/html;charset=UTF-8" />
     <meta
@@ -16,9 +16,9 @@
           From
           <select id="lang-from" name="from" class="lang-select"></select>
         </label>
-        <textarea id="input" name="input"></textarea>
+        <div id="input" contenteditable="true"></div>
       </div>
-      <button class="swap" title="swap">↔️</button>
+      <button class="swap" title="swap"></button>
       <div class="panel panel--to">
         <label>
           To
@@ -26,8 +26,16 @@
         </label>
         <div id="output" class="output-area"></div>
       </div>
-      <div class="footer" id="status"></div>
+      <div id="unsupported-browser" hidden>
+        <p>Your CPU or browser is not able to run Bergamot translator.</p>
+        <p>Try using Firefox or a Chromium based browser with <a href="https://webassembly.org/roadmap/">Fixed-width SIMD support</a>.</p>
+        <p>If you already are, you might be using a CPU that does not have support for SSE4.1 instructions.</p>
+      </div>
+      <footer class="credits">
+        <img src="logos.png" alt="Logos of the OPUS project, the Bergamot project and the European Union.">
+        <p>This project has received funding from the European Union’s Horizon 2020 research and innovation programme under grant agreement No 825303.</p>
+      </footer>
     </div>
-    <script src="js/index.js"></script>
+    <script type="module" src="js/index.js"></script>
   </body>
 </html>
diff --git a/wasm/test_page/js/index.js b/wasm/test_page/js/index.js
index b1c308e8b..56cbfdc72 100644
--- a/wasm/test_page/js/index.js
+++ b/wasm/test_page/js/index.js
@@ -1,156 +1,215 @@
-let worker;
-let modelRegistry;
+import {LatencyOptimisedTranslator, TranslatorBacking, CancelledError, SupersededError} from '../node_modules/@browsermt/bergamot-translator/translator.js';
 
-const $ = selector => document.querySelector(selector);
-const status = message => ($("#status").innerText = message);
-
-const langFrom = $("#lang-from");
-const langTo = $("#lang-to");
-
-if (window.Worker) {
-  worker = new Worker("js/worker.js");
-  worker.postMessage(["import"]);
+function $(selector) {
+  return document.querySelector(selector);
 }
 
-document.querySelector("#input").addEventListener("keyup", function (event) {
-  translateCall();
-});
-
-const _prepareTranslateOptions = (paragraphs) => {
-  const translateOptions = [];
-  paragraphs.forEach(paragraph => {
-    // Each option object can be different for each entry. But to keep the test page simple,
-    // we just keep all the options same (specifically avoiding parsing the input to determine
-    // html/non-html text)
-    translateOptions.push({"isQualityScores": true, "isHtml": true});
-  });
-  return translateOptions;
-};
+function $$(selector) {
+  return document.querySelectorAll(selector);
+}
 
-const textToHTML = (text) => {
+function encodeHTML(text) {
   const div = document.createElement('div');
   div.appendChild(document.createTextNode(text));
   return div.innerHTML;
-};
-
-const translateCall = () => {
-  const text = document.querySelector("#input").value;
-  if (!text.trim().length) return;
-
-  const paragraphs = text.split(/\n+/).map(textToHTML); // escape HTML 
-  const translateOptions = _prepareTranslateOptions(paragraphs);
-  const lngFrom = langFrom.value;
-  const lngTo = langTo.value;
-  worker.postMessage(["translate", lngFrom, lngTo, paragraphs, translateOptions]);
-};
-
-const addQualityClasses = (root) => {
-  // You can do this wit CSS variables, calc() and min/max, but JS is just easier
+}
 
-  root.querySelectorAll('[x-bergamot-sentence-score]').forEach(el => {
+function addQualityIndicators() {
+  $$('#output [x-bergamot-sentence-score]').forEach(el => {
     // The threshold is ln(0.5) (https://github.com/browsermt/bergamot-translator/pull/370#issuecomment-1058123399)
-    el.classList.toggle('bad', parseFloat(el.getAttribute('x-bergamot-sentence-score')) < -0.6931);
+    el.classList.toggle('bad', parseFloat(el.getAttribute('x-bergamot-sentence-score')) < Math.log(0.5));
   });
 
-  root.querySelectorAll('[x-bergamot-word-score]').forEach(el => {
+  $$('#output [x-bergamot-word-score]').forEach(el => {
     // The threshold is ln(0.5) (https://github.com/browsermt/bergamot-translator/pull/370#issuecomment-1058123399)
-    el.classList.toggle('bad', parseFloat(el.getAttribute('x-bergamot-word-score')) < -0.6931);
+    el.classList.toggle('bad', parseFloat(el.getAttribute('x-bergamot-word-score')) < Math.log(0.5));
   });
 
   // Add tooltips to each (sub)word with sentence and word score.
-  root.querySelectorAll('[x-bergamot-sentence-score] > [x-bergamot-word-score]').forEach(el => {
+  $$('#output [x-bergamot-sentence-score] > [x-bergamot-word-score]').forEach(el => {
     const sentenceScore = parseFloat(el.parentNode.getAttribute('x-bergamot-sentence-score'));
     const wordScore = parseFloat(el.getAttribute('x-bergamot-word-score'));
-    el.title = `Sentence: ${sentenceScore}  Word: ${wordScore}`;
+    el.title = `Sentence: ${Math.exp(sentenceScore).toFixed(2)}  Word: ${Math.exp(wordScore).toFixed(2)}`;
   });
 }
 
-worker.onmessage = function (e) {
-  if (e.data[0] === "translate_reply" && e.data[1]) {
-    // Clear output of previous translation
-    document.querySelector("#output").innerHTML = '';
-
-    // Add each translation in its own div to have a known root in which the
-    // sentence ids are unique. Used for highlighting sentences.
-    e.data[1].forEach(translatedHTML => {
-      const translation = document.createElement('div');
-      translation.classList.add('translation');
-      translation.innerHTML = translatedHTML;
-      addQualityClasses(translation);
-      document.querySelector("#output").appendChild(translation);
-    });
-  } else if (e.data[0] === "load_model_reply" && e.data[1]) {
-    status(e.data[1]);
-    translateCall();
-  } else if (e.data[0] === "import_reply" && e.data[1]) {
-    modelRegistry = e.data[1];
-    init();
+function highlightSentence(element) {
+  const sentence = element.parentNode.hasAttribute('x-bergamot-sentence-index')
+    ? element.parentNode.getAttribute('x-bergamot-sentence-index')
+    : null;
+  $$('#output font[x-bergamot-sentence-index]').forEach(el => {
+    el.classList.toggle('highlight-sentence', el.getAttribute('x-bergamot-sentence-index') === sentence);
+  })
+}
+
+/**
+ * Very minimal WISYWIG editor. Just keyboard shortcuts for the IYKYK crowd.
+ */
+class Editor {
+  constructor(root) {
+    this.isApple = window.navigator.platform.startsWith('Mac');
+
+    this.root = root;
+    this.root.addEventListener('keydown', this.onkeydown.bind(this));
+
+    this.mapping = {
+      "b": "bold",
+      "i": "italic",
+      "u": "underline",
+    };
   }
-};
-
-const loadModel = () => {
-  const lngFrom = langFrom.value;
-  const lngTo = langTo.value;
-  if (lngFrom !== lngTo) {
-    status(`Installing model...`);
-    console.log(`Loading model '${lngFrom}${lngTo}'`);
-    worker.postMessage(["load_model", lngFrom, lngTo]);
-  } else {
-    const input = textToHTML(document.querySelector("#input").value);
-    document.querySelector("#output").innerHTML = input;
+
+  onkeydown(event) {
+    if (!(this.isApple ? event.metaKey : event.ctrlKey))
+      return;
+
+    if (!(event.key in this.mapping))
+      return;
+
+    document.execCommand(this.mapping[event.key], false, null);
+
+    event.preventDefault();
   }
-};
-
-langFrom.addEventListener("change", e => {
-  loadModel();
-});
-
-langTo.addEventListener("change", e => {
-  loadModel();
-});
-
-$(".swap").addEventListener("click", e => {
-  [langFrom.value, langTo.value] = [langTo.value, langFrom.value];
-  $("#input").value = $("#output").innerText;
-  loadModel();
-});
-
-$('#output').addEventListener('mouseover', e => {
-  const root = e.target.closest('.translation');
-  const sentence = e.target.parentNode.hasAttribute('x-bergamot-sentence-index') ? e.target.parentNode.getAttribute('x-bergamot-sentence-index') : null;  
-  document.querySelectorAll('#output font[x-bergamot-sentence-index]').forEach(el => {
-    el.classList.toggle('highlight-sentence', el.getAttribute('x-bergamot-sentence-index') === sentence && el.closest('.translation') === root);
-  })
-})
+}
+
+async function main() {
+  const options = {
+    cacheSize: 2^13,
+    downloadTimeout: null // Disable timeout
+  };
+  
+  const backing = new TranslatorBacking(options);
+
+  let pending = 0; // Number of pending requests
+
+  // Patch the fetch() function to track number of pending requests
+  backing.fetch = async function(...args) {
+    try {
+      $('.app').classList.toggle('loading', ++pending > 0);
+      return await TranslatorBacking.prototype.fetch.call(backing, ...args);
+    } finally {
+      $('.app').classList.toggle('loading', --pending > 0);
+    }
+  };
 
-function init() {
-  // Populate langs
-  const langs = Array.from(new Set(Object.keys(modelRegistry).reduce((acc, key) => acc.concat([key.substr(0, 2), key.substr(2, 2)]), [])));
-  const langNames = new Intl.DisplayNames(undefined, {type: "language"});
+  // Wait for the language model registry to load. Once it is loaded, use
+  // it to fill the "from" and "to" language selection dropdowns.
+  await backing.registry.then(models => {
+    const names = new Intl.DisplayNames(['en'], {type: 'language'});
 
-  // Sort languages by display name
-  langs.sort((a, b) => langNames.of(a).localeCompare(langNames.of(b)));
+    ['from', 'to'].forEach(field => {
+      const languages = new Set(models.map(model => model[field]));
+      const select = $(`#lang-${field}`);
 
-  // Populate the dropdowns 
-  langs.forEach(code => {
-    const name = langNames.of(code);
-    langFrom.innerHTML += `<option value="${code}">${name}</option>`;
-    langTo.innerHTML += `<option value="${code}">${name}</option>`;
+      const pairs = Array.from(languages, code => ({code, name: names.of(code)}));
+      
+      pairs.sort(({name: a}, {name: b}) => a.localeCompare(b));
+
+      pairs.forEach(({name, code}) => {
+        select.add(new Option(name, code));
+      })
+    });
+
+    $('#lang-from').value = 'en';
+    $('#lang-to').value = 'es';
   });
 
-  // try to guess input language from user agent
-  let myLang = navigator.language;
-  if (myLang) {
-    myLang = myLang.split("-")[0];
-    let langIndex = langs.indexOf(myLang);
-    if (langIndex > -1) {
-      console.log("guessing input language is", myLang);
-      langFrom.value = myLang;
+  // Intentionally do this after querying backing.registry to make sure that
+  // that request is fired off first. Now we can start thinking about loading
+  // the WASM binary etc.
+  const translator = new LatencyOptimisedTranslator(options, backing);
+
+  let abortController = new AbortController();
+
+  const translate = async () => {
+    try {
+      const from = $('#lang-from').value;
+      const to = $('#lang-to').value;
+      
+      // Querying models to see whether quality estimation is supported by all
+      // of them.
+      const models = await backing.getModels({from, to});
+      const qualityScores = models.every(model => 'qualityModel' in model.files);
+
+      $('.app').classList.add('translating');
+
+      const response = await translator.translate({
+        from,
+        to,
+        text: $('#input').innerHTML,
+        html: true,
+        qualityScores
+      }, {signal: abortController.signal});
+
+      $('#output').innerHTML = response.target.text;
+      $('#output').classList.toggle('has-quality-scores', qualityScores);
+
+      if (qualityScores)
+        addQualityIndicators();
+
+    } catch (error) {
+      // Ignore errors caused by changing the language pair (which triggers abort())
+      if (error.constructor === CancelledError) {
+        return;
+      }
+      
+      // Ignore 'errors' caused by typing too fast or by changing the language
+      // pair while a translation was still in progress (or being loaded)
+      if (error.constructor === SupersededError || error.constructor === CancelledError)
+        return;
+
+      // Ignore errors caused by selecting a bad pair (e.g. en -> en)
+      if (error.message.startsWith('No model available to translate from'))
+        return;
+
+      alert(`Error during translation: ${error}\n\n${error.stack}`);
+    } finally {
+      const worker = await Promise.race([translator.worker, Promise.resolve(null)]);
+      $('.app').classList.toggle('translating', worker === null || !worker.idle);
     }
   }
 
-  // find first output lang that *isn't* input language
-  langTo.value = langs.find(code => code !== langFrom.value);
-  // load this model
-  loadModel();
+  const reset = async () => {
+    // Cancel any pending loading/translation
+    abortController.abort();
+
+    // Reset abort controller to a fresh un-aborted one
+    abortController = new AbortController();
+
+    // Clear output to make it more clear something is happening
+    $('#output').innerHTML = '';
+
+    // Immediately start loading the new selection
+    translate();
+  }
+
+  $('button.swap').addEventListener('click', () => {
+    const tmp = $('#lang-from').value;
+    $('#lang-from').value = $('#lang-to').value;
+    $('#lang-to').value = tmp;
+    translate();
+  })
+
+  // Simple WYSIWYG controls
+  const editor = new Editor($('#input'));
+
+  // Translate on any change
+  $('#input').addEventListener('input', translate);
+  $('#lang-from').addEventListener('input', reset);
+  $('#lang-to').addEventListener('input', reset);
+
+  // Hook up sentence boundary highlighting if that information is available.
+  $('#output').addEventListener('mouseover', (e) => highlightSentence(e.target))
+
+  // Wait for bergamot-translator to load. This could throw a CompileError
+  // which we want to catch so we can show "oh noes browser not supported!"
+  translator.worker.catch(error => {
+    // Catch CompileErrors because for those we know what to do.
+    if (error.name === 'CompileError')
+      $('#unsupported-browser').hidden = false;
+    else
+      throw error;
+  });
 }
+
+main();
diff --git a/wasm/test_page/js/worker.js b/wasm/test_page/js/worker.js
deleted file mode 100644
index 3327d8a3a..000000000
--- a/wasm/test_page/js/worker.js
+++ /dev/null
@@ -1,352 +0,0 @@
-// All variables specific to translation service
-var translationService = undefined;
-
-// Model registry
-let modelRegistry = undefined;
-
-// A map of language-pair to TranslationModel object
-var languagePairToTranslationModels = new Map();
-
-const BERGAMOT_TRANSLATOR_MODULE = "bergamot-translator-worker.js";
-const MODEL_REGISTRY = "../models/registry.json";
-const MODEL_ROOT_URL = "../models/";
-const PIVOT_LANGUAGE = 'en';
-
-// Information corresponding to each file type
-const fileInfo = [
-  {"type": "model", "alignment": 256},
-  {"type": "lex", "alignment": 64},
-  {"type": "vocab", "alignment": 64},
-  {"type": "qualityModel", "alignment": 64}
-];
-
-const encoder = new TextEncoder(); // string to utf-8 converter
-const decoder = new TextDecoder(); // utf-8 to string converter
-
-const start = Date.now();
-let moduleLoadStart;
-var Module = {
-  preRun: [function() {
-    log(`Time until Module.preRun: ${(Date.now() - start) / 1000} secs`);
-    moduleLoadStart = Date.now();
-  }],
-  onRuntimeInitialized: async function() {
-    log(`Wasm Runtime initialized Successfully (preRun -> onRuntimeInitialized) in ${(Date.now() - moduleLoadStart) / 1000} secs`);
-    const response = await fetch(MODEL_REGISTRY);
-    modelRegistry = await response.json();
-    postMessage([`import_reply`, modelRegistry]);
-  }
-};
-
-const log = (message) => {
-  console.debug(message);
-}
-
-onmessage = async function(e) {
-  const command = e.data[0];
-  log(`Message '${command}' received from main script`);
-  let result = "";
-  if (command === 'import') {
-      importScripts(BERGAMOT_TRANSLATOR_MODULE);
-  } else if (command === 'load_model') {
-      let start = Date.now();
-      let from = e.data[1];
-      let to = e.data[2];
-      try {
-        await constructTranslationService();
-        await constructTranslationModel(from, to);
-        log(`Model '${from}${to}' successfully constructed. Time taken: ${(Date.now() - start) / 1000} secs`);
-        result = "Model successfully loaded";
-      } catch (error) {
-        log(`Model '${from}${to}' construction failed: '${error.message}'`);
-        result = "Model loading failed";
-      }
-      log(`'${command}' command done, Posting message back to main script`);
-      postMessage([`${command}_reply`, result]);
-  } else if (command === 'translate') {
-      const from = e.data[1];
-      const to = e.data[2];
-      const input = e.data[3];
-      const translateOptions = e.data[4];
-      let inputWordCount = 0;
-      let inputBlockElements = 0;
-      input.forEach(sentence => {
-        inputWordCount += sentence.trim().split(" ").filter(word => word.trim() !== "").length;
-        inputBlockElements++;
-      })
-      let start = Date.now();
-      try {
-        log(`Blocks to translate: ${inputBlockElements}`);
-        result = translate(from, to, input, translateOptions);
-        const secs = (Date.now() - start) / 1000;
-        log(`Translation '${from}${to}' Successful. Speed: ${Math.round(inputWordCount / secs)} WPS (${inputWordCount} words in ${secs} secs)`);
-      } catch (error) {
-        log(`Error: ${error.message}`);
-      }
-      log(`'${command}' command done, Posting message back to main script`);
-      postMessage([`${command}_reply`, result]);
-  }
-}
-
-// Instantiates the Translation Service
-const constructTranslationService = async () => {
-  if (!translationService) {
-    var translationServiceConfig = {cacheSize: 20000};
-    log(`Creating Translation Service with config: ${translationServiceConfig}`);
-    translationService = new Module.BlockingService(translationServiceConfig);
-    log(`Translation Service created successfully`);
-  }
-}
-
-// Constructs translation model(s) for the source and target language pair (using
-// pivoting if required).
-const constructTranslationModel = async (from, to) => {
-  // Delete all previously constructed translation models and clear the map
-  languagePairToTranslationModels.forEach((value, key) => {
-    log(`Destructing model '${key}'`);
-    value.delete();
-  });
-  languagePairToTranslationModels.clear();
-
-  if (_isPivotingRequired(from, to)) {
-    // Pivoting requires 2 translation models
-    const languagePairSrcToPivot = _getLanguagePair(from, PIVOT_LANGUAGE);
-    const languagePairPivotToTarget = _getLanguagePair(PIVOT_LANGUAGE, to);
-    await Promise.all([_constructTranslationModelHelper(languagePairSrcToPivot),
-                      _constructTranslationModelHelper(languagePairPivotToTarget)]);
-  }
-  else {
-    // Non-pivoting case requires only 1 translation model
-    await _constructTranslationModelHelper(_getLanguagePair(from, to));
-  }
-}
-
-// Translates text from source language to target language (via pivoting if necessary).
-const translate = (from, to, input, translateOptions) => {
-  let vectorResponseOptions, vectorSourceText, vectorResponse;
-  try {
-    // Prepare the arguments (vectorResponseOptions and vectorSourceText (vector<string>)) of Translation API and call it.
-    // Result is a vector<Response> where each of its item corresponds to one item of vectorSourceText in the same order.
-    vectorResponseOptions = _prepareResponseOptions(translateOptions);
-    vectorSourceText = _prepareSourceText(input);
-
-    if (_isPivotingRequired(from, to)) {
-      // Translate via pivoting
-      const translationModelSrcToPivot = _getLoadedTranslationModel(from, PIVOT_LANGUAGE);
-      const translationModelPivotToTarget = _getLoadedTranslationModel(PIVOT_LANGUAGE, to);
-      vectorResponse = translationService.translateViaPivoting(translationModelSrcToPivot,
-                                                              translationModelPivotToTarget,
-                                                              vectorSourceText,
-                                                              vectorResponseOptions);
-    }
-    else {
-      // Translate without pivoting
-      const translationModel = _getLoadedTranslationModel(from, to);
-      vectorResponse = translationService.translate(translationModel, vectorSourceText, vectorResponseOptions);
-    }
-
-    // Parse all relevant information from vectorResponse
-    const listTranslatedText = _parseTranslatedText(vectorResponse);
-    const listSourceText = _parseSourceText(vectorResponse);
-    const listTranslatedTextSentences = _parseTranslatedTextSentences(vectorResponse);
-    const listSourceTextSentences = _parseSourceTextSentences(vectorResponse);
-
-    log(`Source text: ${listSourceText}`);
-    log(`Translated text: ${listTranslatedText}`);
-    log(`Translated sentences: ${JSON.stringify(listTranslatedTextSentences)}`);
-    log(`Source sentences: ${JSON.stringify(listSourceTextSentences)}`);
-
-    return listTranslatedText;
-  } finally {
-    // Necessary clean up
-    if (vectorSourceText != null) vectorSourceText.delete();
-    if (vectorResponseOptions != null) vectorResponseOptions.delete();
-    if (vectorResponse != null) vectorResponse.delete();
-  }
-}
-
-// Downloads file from a url and returns the array buffer
-const _downloadAsArrayBuffer = async(url) => {
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw Error(`Downloading ${url} failed: HTTP ${response.status} - ${response.statusText}`);
-  }
-  return response.arrayBuffer();
-}
-
-// Constructs and initializes the AlignedMemory from the array buffer and alignment size
-const _prepareAlignedMemoryFromBuffer = async (buffer, alignmentSize) => {
-  var byteArray = new Int8Array(buffer);
-  var alignedMemory = new Module.AlignedMemory(byteArray.byteLength, alignmentSize);
-  const alignedByteArrayView = alignedMemory.getByteArrayView();
-  alignedByteArrayView.set(byteArray);
-  return alignedMemory;
-}
-
-async function prepareAlignedMemory(file, languagePair) {
-  const fileName = `${MODEL_ROOT_URL}/${languagePair}/${modelRegistry[languagePair][file.type].name}`;
-  const buffer = await _downloadAsArrayBuffer(fileName);
-  const alignedMemory = await _prepareAlignedMemoryFromBuffer(buffer, file.alignment);
-  log(`"${file.type}" aligned memory prepared. Size:${alignedMemory.size()} bytes, alignment:${file.alignment}`);
-  return alignedMemory;
-}
-
-const _constructTranslationModelHelper = async (languagePair) => {
-  log(`Constructing translation model ${languagePair}`);
-
-  /*Set the Model Configuration as YAML formatted string.
-    For available configuration options, please check: https://marian-nmt.github.io/docs/cmd/marian-decoder/
-    Vocab files are re-used in both translation directions.
-    DO NOT CHANGE THE SPACES BETWEEN EACH ENTRY OF CONFIG
-  */
-  const modelConfig = `beam-size: 1
-normalize: 1.0
-word-penalty: 0
-max-length-break: 128
-mini-batch-words: 1024
-workspace: 128
-max-length-factor: 2.0
-skip-cost: false
-cpu-threads: 0
-quiet: true
-quiet-translation: true
-gemm-precision: int8shiftAlphaAll
-alignment: soft
-`;
-
-  const promises = [];
-  fileInfo.filter(file => modelRegistry[languagePair].hasOwnProperty(file.type))
-  .map((file) => {
-      promises.push(prepareAlignedMemory(file, languagePair));
-  });
-
-  const alignedMemories = await Promise.all(promises);
-
-  log(`Translation Model config: ${modelConfig}`);
-  log(`Aligned memory sizes: Model:${alignedMemories[0].size()} Shortlist:${alignedMemories[1].size()} Vocab:${alignedMemories[2].size()}`);
-  const alignedVocabMemoryList = new Module.AlignedMemoryList();
-  alignedVocabMemoryList.push_back(alignedMemories[2]);
-  let translationModel;
-  if (alignedMemories.length === fileInfo.length) {
-    log(`QE:${alignedMemories[3].size()}`);
-    translationModel = new Module.TranslationModel(modelConfig, alignedMemories[0], alignedMemories[1], alignedVocabMemoryList, alignedMemories[3]);
-  }
-  else {
-    translationModel = new Module.TranslationModel(modelConfig, alignedMemories[0], alignedMemories[1], alignedVocabMemoryList, null);
-  }
-  languagePairToTranslationModels.set(languagePair, translationModel);
-}
-
-const _isPivotingRequired = (from, to) => {
-  return (from !== PIVOT_LANGUAGE) && (to !== PIVOT_LANGUAGE);
-}
-
-const _getLanguagePair = (srcLang, tgtLang) => {
-  return `${srcLang}${tgtLang}`;
-}
-
-const _getLoadedTranslationModel = (srcLang, tgtLang) => {
-  const languagePair = _getLanguagePair(srcLang, tgtLang);
-  if (!languagePairToTranslationModels.has(languagePair)) {
-    throw Error(`Translation model '${languagePair}' not loaded`);
-  }
-  return languagePairToTranslationModels.get(languagePair);
-}
-
-const _parseTranslatedText = (vectorResponse) => {
-  const result = [];
-  for (let i = 0; i < vectorResponse.size(); i++) {
-    const response = vectorResponse.get(i);
-    result.push(response.getTranslatedText());
-  }
-  return result;
-}
-
-const _parseTranslatedTextSentences = (vectorResponse) => {
-  const result = [];
-  for (let i = 0; i < vectorResponse.size(); i++) {
-    const response = vectorResponse.get(i);
-    result.push(_getTranslatedSentences(response));
-  }
-  return result;
-}
-
-const _parseSourceText = (vectorResponse) => {
-  const result = [];
-  for (let i = 0; i < vectorResponse.size(); i++) {
-    const response = vectorResponse.get(i);
-    result.push(response.getOriginalText());
-  }
-  return result;
-}
-
-const _parseSourceTextSentences = (vectorResponse) => {
-  const result = [];
-  for (let i = 0; i < vectorResponse.size(); i++) {
-    const response = vectorResponse.get(i);
-    result.push(_getSourceSentences(response));
-  }
-  return result;
-}
-
-const _prepareResponseOptions = (translateOptions) => {
-  let vectorResponseOptions = new Module.VectorResponseOptions;
-  translateOptions.forEach(translateOption => {
-    vectorResponseOptions.push_back({
-      qualityScores: translateOption["isQualityScores"],
-      alignment: true,
-      html: translateOption["isHtml"]
-    });
-  });
-  if (vectorResponseOptions.size() == 0) {
-    vectorResponseOptions.delete();
-    throw Error(`No Translation Options provided`);
-  }
-  return vectorResponseOptions;
-}
-
-const _prepareSourceText = (input) => {
-  let vectorSourceText = new Module.VectorString;
-  input.forEach(paragraph => {
-    // prevent empty paragraph - it breaks the translation
-    if (paragraph.trim() === "") {
-      return;
-    }
-    vectorSourceText.push_back(paragraph.trim())
-  })
-  if (vectorSourceText.size() == 0) {
-    vectorSourceText.delete();
-    throw Error(`No text provided to translate`);
-  }
-  return vectorSourceText;
-}
-
-const _getTranslatedSentences = (response) => {
-  const sentences = [];
-  const text = response.getTranslatedText();
-  for (let sentenceIndex = 0; sentenceIndex < response.size(); sentenceIndex++) {
-    const utf8SentenceByteRange = response.getTranslatedSentence(sentenceIndex);
-    sentences.push(_getSubString(text, utf8SentenceByteRange));
-  }
-  return sentences;
-}
-
-const _getSourceSentences = (response) => {
-  const sentences = [];
-  const text = response.getOriginalText();
-  for (let sentenceIndex = 0; sentenceIndex < response.size(); sentenceIndex++) {
-    const utf8SentenceByteRange = response.getSourceSentence(sentenceIndex);
-    sentences.push(_getSubString(text, utf8SentenceByteRange));
-  }
-  return sentences;
-}
-
-/*
- * Returns a substring of text (a string). The substring is represented by
- * byteRange (begin and end endices) within the utf-8 encoded version of the text.
- */
-const _getSubString = (text, utf8ByteRange) => {
-  const textUtf8ByteView = encoder.encode(text);
-  const substringUtf8ByteView = textUtf8ByteView.subarray(utf8ByteRange.begin, utf8ByteRange.end);
-  return decoder.decode(substringUtf8ByteView);
-}
diff --git a/wasm/test_page/logos.png b/wasm/test_page/logos.png
new file mode 100644
index 000000000..7646f3ca2
Binary files /dev/null and b/wasm/test_page/logos.png differ
diff --git a/wasm/test_page/package-lock.json b/wasm/test_page/package-lock.json
index 065c92de8..22d229647 100644
--- a/wasm/test_page/package-lock.json
+++ b/wasm/test_page/package-lock.json
@@ -5,18 +5,28 @@
   "packages": {
     "": {
       "dependencies": {
+        "@browsermt/bergamot-translator": "file:../module",
         "cors": "^2.8.5",
-        "express": "^4.17.1",
+        "express": "^4.18.2",
         "nocache": "^2.1.0"
       }
     },
+    "../module": {
+      "name": "@browsermt/bergamot-translator",
+      "version": "0.4.8",
+      "license": "MPL-2.0"
+    },
+    "node_modules/@browsermt/bergamot-translator": {
+      "resolved": "../module",
+      "link": true
+    },
     "node_modules/accepts": {
-      "version": "1.3.7",
-      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.7.tgz",
-      "integrity": "sha512-Il80Qs2WjYlJIBNzNkK6KYqlVMTbZLXgHx2oT0pU/fjRHyEp+PEfEPY0R3WCwAGVOtauxh1hOxNgIf5bv7dQpA==",
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
       "dependencies": {
-        "mime-types": "~2.1.24",
-        "negotiator": "0.6.2"
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
       },
       "engines": {
         "node": ">= 0.6"
@@ -28,39 +38,54 @@
       "integrity": "sha1-ml9pkFGx5wczKPKgCJaLZOopVdI="
     },
     "node_modules/body-parser": {
-      "version": "1.19.0",
-      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.19.0.tgz",
-      "integrity": "sha512-dhEPs72UPbDnAQJ9ZKMNTP6ptJaionhP5cBb541nXPlW60Jepo9RV/a4fX4XWW9CuFNK22krhrj1+rgzifNCsw==",
+      "version": "1.20.1",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.1.tgz",
+      "integrity": "sha512-jWi7abTbYwajOytWCQc37VulmWiRae5RyTpaCyDcS5/lMdtwSz5lOpDE67srw/HYe35f1z3fDQw+3txg7gNtWw==",
       "dependencies": {
-        "bytes": "3.1.0",
+        "bytes": "3.1.2",
         "content-type": "~1.0.4",
         "debug": "2.6.9",
-        "depd": "~1.1.2",
-        "http-errors": "1.7.2",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "http-errors": "2.0.0",
         "iconv-lite": "0.4.24",
-        "on-finished": "~2.3.0",
-        "qs": "6.7.0",
-        "raw-body": "2.4.0",
-        "type-is": "~1.6.17"
+        "on-finished": "2.4.1",
+        "qs": "6.11.0",
+        "raw-body": "2.5.1",
+        "type-is": "~1.6.18",
+        "unpipe": "1.0.0"
       },
       "engines": {
-        "node": ">= 0.8"
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
       }
     },
     "node_modules/bytes": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.0.tgz",
-      "integrity": "sha512-zauLjrfCG+xvoyaqLoV8bLVXXNGC4JqlxFCutSDWA6fJrTo2ZuvLYTqZ7aHBLZSMOopbzwv8f+wZcVzfVTI2Dg==",
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
       "engines": {
         "node": ">= 0.8"
       }
     },
+    "node_modules/call-bind": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz",
+      "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==",
+      "dependencies": {
+        "function-bind": "^1.1.1",
+        "get-intrinsic": "^1.0.2"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
     "node_modules/content-disposition": {
-      "version": "0.5.3",
-      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.3.tgz",
-      "integrity": "sha512-ExO0774ikEObIAEV9kDo50o+79VCUdEB6n6lzKgGwupcVeRlhrj3qGAfwq8G6uBJjkqLrhT0qEYFcWng8z1z0g==",
+      "version": "0.5.4",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
+      "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
       "dependencies": {
-        "safe-buffer": "5.1.2"
+        "safe-buffer": "5.2.1"
       },
       "engines": {
         "node": ">= 0.6"
@@ -75,9 +100,9 @@
       }
     },
     "node_modules/cookie": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.4.0.tgz",
-      "integrity": "sha512-+Hp8fLp57wnUSt0tY0tHEXh4voZRDnoIrZPqlo3DPiI4y9lwg/jqx+1Om94/W6ZaPDOUbnjOt/99w66zk+l1Xg==",
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.5.0.tgz",
+      "integrity": "sha512-YZ3GUyn/o8gfKJlnlX7g7xq4gyO6OSuhGPKaaGssGB2qgDUS0gPgtTvoyZLTt9Ab6dC4hfc9dV5arkvc/OCmrw==",
       "engines": {
         "node": ">= 0.6"
       }
@@ -108,27 +133,31 @@
       }
     },
     "node_modules/depd": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz",
-      "integrity": "sha1-m81S4UwJd2PnSbJ0xDRu0uVgtak=",
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
       "engines": {
-        "node": ">= 0.6"
+        "node": ">= 0.8"
       }
     },
     "node_modules/destroy": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.0.4.tgz",
-      "integrity": "sha1-l4hXRCxEdJ5CBmE+N5RiBYJqvYA="
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
+      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
     },
     "node_modules/ee-first": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
-      "integrity": "sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0="
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="
     },
     "node_modules/encodeurl": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
-      "integrity": "sha1-rT/0yG7C0CkyL1oCw6mmBslbP1k=",
+      "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==",
       "engines": {
         "node": ">= 0.8"
       }
@@ -136,48 +165,49 @@
     "node_modules/escape-html": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
-      "integrity": "sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg="
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow=="
     },
     "node_modules/etag": {
       "version": "1.8.1",
       "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
-      "integrity": "sha1-Qa4u62XvpiJorr/qg6x9eSmbCIc=",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
       "engines": {
         "node": ">= 0.6"
       }
     },
     "node_modules/express": {
-      "version": "4.17.1",
-      "resolved": "https://registry.npmjs.org/express/-/express-4.17.1.tgz",
-      "integrity": "sha512-mHJ9O79RqluphRrcw2X/GTh3k9tVv8YcoyY4Kkh4WDMUYKRZUq0h1o0w2rrrxBqM7VoeUVqgb27xlEMXTnYt4g==",
+      "version": "4.18.2",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.18.2.tgz",
+      "integrity": "sha512-5/PsL6iGPdfQ/lKM1UuielYgv3BUoJfz1aUwU9vHZ+J7gyvwdQXFEBIEIaxeGf0GIcreATNyBExtalisDbuMqQ==",
       "dependencies": {
-        "accepts": "~1.3.7",
+        "accepts": "~1.3.8",
         "array-flatten": "1.1.1",
-        "body-parser": "1.19.0",
-        "content-disposition": "0.5.3",
+        "body-parser": "1.20.1",
+        "content-disposition": "0.5.4",
         "content-type": "~1.0.4",
-        "cookie": "0.4.0",
+        "cookie": "0.5.0",
         "cookie-signature": "1.0.6",
         "debug": "2.6.9",
-        "depd": "~1.1.2",
+        "depd": "2.0.0",
         "encodeurl": "~1.0.2",
         "escape-html": "~1.0.3",
         "etag": "~1.8.1",
-        "finalhandler": "~1.1.2",
+        "finalhandler": "1.2.0",
         "fresh": "0.5.2",
+        "http-errors": "2.0.0",
         "merge-descriptors": "1.0.1",
         "methods": "~1.1.2",
-        "on-finished": "~2.3.0",
+        "on-finished": "2.4.1",
         "parseurl": "~1.3.3",
         "path-to-regexp": "0.1.7",
-        "proxy-addr": "~2.0.5",
-        "qs": "6.7.0",
+        "proxy-addr": "~2.0.7",
+        "qs": "6.11.0",
         "range-parser": "~1.2.1",
-        "safe-buffer": "5.1.2",
-        "send": "0.17.1",
-        "serve-static": "1.14.1",
-        "setprototypeof": "1.1.1",
-        "statuses": "~1.5.0",
+        "safe-buffer": "5.2.1",
+        "send": "0.18.0",
+        "serve-static": "1.15.0",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
         "type-is": "~1.6.18",
         "utils-merge": "1.0.1",
         "vary": "~1.1.2"
@@ -187,16 +217,16 @@
       }
     },
     "node_modules/finalhandler": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.1.2.tgz",
-      "integrity": "sha512-aAWcW57uxVNrQZqFXjITpW3sIUQmHGG3qSb9mUah9MgMC4NeWhNOlNjXEYq3HjRAvL6arUviZGGJsBg6z0zsWA==",
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.2.0.tgz",
+      "integrity": "sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg==",
       "dependencies": {
         "debug": "2.6.9",
         "encodeurl": "~1.0.2",
         "escape-html": "~1.0.3",
-        "on-finished": "~2.3.0",
+        "on-finished": "2.4.1",
         "parseurl": "~1.3.3",
-        "statuses": "~1.5.0",
+        "statuses": "2.0.1",
         "unpipe": "~1.0.0"
       },
       "engines": {
@@ -204,9 +234,9 @@
       }
     },
     "node_modules/forwarded": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.1.2.tgz",
-      "integrity": "sha1-mMI9qxF1ZXuMBXPozszZGw/xjIQ=",
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
       "engines": {
         "node": ">= 0.6"
       }
@@ -214,24 +244,64 @@
     "node_modules/fresh": {
       "version": "0.5.2",
       "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
-      "integrity": "sha1-PYyt2Q2XZWn6g1qx+OSyOhBWBac=",
+      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
       "engines": {
         "node": ">= 0.6"
       }
     },
+    "node_modules/function-bind": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
+      "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A=="
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.3.tgz",
+      "integrity": "sha512-QJVz1Tj7MS099PevUG5jvnt9tSkXN8K14dxQlikJuPt4uD9hHAHjLyLBiLR5zELelBdD9QNRAXZzsJx0WaDL9A==",
+      "dependencies": {
+        "function-bind": "^1.1.1",
+        "has": "^1.0.3",
+        "has-symbols": "^1.0.3"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
+      "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
+      "dependencies": {
+        "function-bind": "^1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz",
+      "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
     "node_modules/http-errors": {
-      "version": "1.7.2",
-      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.7.2.tgz",
-      "integrity": "sha512-uUQBt3H/cSIVfch6i1EuPNy/YsRSOUBXTVfZ+yR7Zjez3qjBz6i9+i4zjNaoqcoFVI4lQJ5plg63TvGfRSDCRg==",
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
+      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
       "dependencies": {
-        "depd": "~1.1.2",
-        "inherits": "2.0.3",
-        "setprototypeof": "1.1.1",
-        "statuses": ">= 1.5.0 < 2",
-        "toidentifier": "1.0.0"
+        "depd": "2.0.0",
+        "inherits": "2.0.4",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "toidentifier": "1.0.1"
       },
       "engines": {
-        "node": ">= 0.6"
+        "node": ">= 0.8"
       }
     },
     "node_modules/iconv-lite": {
@@ -246,9 +316,9 @@
       }
     },
     "node_modules/inherits": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
-      "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4="
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
     },
     "node_modules/ipaddr.js": {
       "version": "1.9.1",
@@ -261,7 +331,7 @@
     "node_modules/media-typer": {
       "version": "0.3.0",
       "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
-      "integrity": "sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g=",
+      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
       "engines": {
         "node": ">= 0.6"
       }
@@ -291,19 +361,19 @@
       }
     },
     "node_modules/mime-db": {
-      "version": "1.45.0",
-      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.45.0.tgz",
-      "integrity": "sha512-CkqLUxUk15hofLoLyljJSrukZi8mAtgd+yE5uO4tqRZsdsAJKv0O+rFMhVDRJgozy+yG6md5KwuXhD4ocIoP+w==",
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
       "engines": {
         "node": ">= 0.6"
       }
     },
     "node_modules/mime-types": {
-      "version": "2.1.28",
-      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.28.tgz",
-      "integrity": "sha512-0TO2yJ5YHYr7M2zzT7gDU1tbwHxEUWBCLt0lscSNpcdAfFyJOVEpRYNS7EXVcTLNj/25QO8gulHC5JtTzSE2UQ==",
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
       "dependencies": {
-        "mime-db": "1.45.0"
+        "mime-db": "1.52.0"
       },
       "engines": {
         "node": ">= 0.6"
@@ -312,12 +382,12 @@
     "node_modules/ms": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
-      "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g="
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A=="
     },
     "node_modules/negotiator": {
-      "version": "0.6.2",
-      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.2.tgz",
-      "integrity": "sha512-hZXc7K2e+PgeI1eDBe/10Ard4ekbfrrqG8Ep+8Jmf4JID2bNg7NvCPOZN+kfF574pFQI7mum2AUqDidoKqcTOw==",
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
+      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
       "engines": {
         "node": ">= 0.6"
       }
@@ -338,10 +408,18 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/object-inspect": {
+      "version": "1.12.3",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz",
+      "integrity": "sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
     "node_modules/on-finished": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.3.0.tgz",
-      "integrity": "sha1-IPEzZIGwg811M3mSoWlxqi2QaUc=",
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
       "dependencies": {
         "ee-first": "1.1.1"
       },
@@ -363,11 +441,11 @@
       "integrity": "sha1-32BBeABfUi8V60SQ5yR6G/qmf4w="
     },
     "node_modules/proxy-addr": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.6.tgz",
-      "integrity": "sha512-dh/frvCBVmSsDYzw6n926jv974gddhkFPfiN8hPOi30Wax25QZyZEGveluCgliBnqmuM+UJmBErbAUFIoDbjOw==",
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
       "dependencies": {
-        "forwarded": "~0.1.2",
+        "forwarded": "0.2.0",
         "ipaddr.js": "1.9.1"
       },
       "engines": {
@@ -375,11 +453,17 @@
       }
     },
     "node_modules/qs": {
-      "version": "6.7.0",
-      "resolved": "https://registry.npmjs.org/qs/-/qs-6.7.0.tgz",
-      "integrity": "sha512-VCdBRNFTX1fyE7Nb6FYoURo/SPe62QCaAyzJvUjwRaIsc+NePBEniHlvxFmmX56+HZphIGtV0XeCirBtpDrTyQ==",
+      "version": "6.11.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.11.0.tgz",
+      "integrity": "sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==",
+      "dependencies": {
+        "side-channel": "^1.0.4"
+      },
       "engines": {
         "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
     "node_modules/range-parser": {
@@ -391,12 +475,12 @@
       }
     },
     "node_modules/raw-body": {
-      "version": "2.4.0",
-      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.4.0.tgz",
-      "integrity": "sha512-4Oz8DUIwdvoa5qMJelxipzi/iJIi40O5cGV1wNYp5hvZP8ZN0T+jiNkL0QepXs+EsQ9XJ8ipEDoiH70ySUJP3Q==",
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.1.tgz",
+      "integrity": "sha512-qqJBtEyVgS0ZmPGdCFPWJ3FreoqvG4MVQln/kCgF7Olq95IbOp0/BWyMwbdtn4VTvkM8Y7khCQ2Xgk/tcrCXig==",
       "dependencies": {
-        "bytes": "3.1.0",
-        "http-errors": "1.7.2",
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
         "iconv-lite": "0.4.24",
         "unpipe": "1.0.0"
       },
@@ -405,9 +489,23 @@
       }
     },
     "node_modules/safe-buffer": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ]
     },
     "node_modules/safer-buffer": {
       "version": "2.1.2",
@@ -415,64 +513,77 @@
       "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="
     },
     "node_modules/send": {
-      "version": "0.17.1",
-      "resolved": "https://registry.npmjs.org/send/-/send-0.17.1.tgz",
-      "integrity": "sha512-BsVKsiGcQMFwT8UxypobUKyv7irCNRHk1T0G680vk88yf6LBByGcZJOTJCrTP2xVN6yI+XjPJcNuE3V4fT9sAg==",
+      "version": "0.18.0",
+      "resolved": "https://registry.npmjs.org/send/-/send-0.18.0.tgz",
+      "integrity": "sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg==",
       "dependencies": {
         "debug": "2.6.9",
-        "depd": "~1.1.2",
-        "destroy": "~1.0.4",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
         "encodeurl": "~1.0.2",
         "escape-html": "~1.0.3",
         "etag": "~1.8.1",
         "fresh": "0.5.2",
-        "http-errors": "~1.7.2",
+        "http-errors": "2.0.0",
         "mime": "1.6.0",
-        "ms": "2.1.1",
-        "on-finished": "~2.3.0",
+        "ms": "2.1.3",
+        "on-finished": "2.4.1",
         "range-parser": "~1.2.1",
-        "statuses": "~1.5.0"
+        "statuses": "2.0.1"
       },
       "engines": {
         "node": ">= 0.8.0"
       }
     },
     "node_modules/send/node_modules/ms": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz",
-      "integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg=="
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
     },
     "node_modules/serve-static": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.14.1.tgz",
-      "integrity": "sha512-JMrvUwE54emCYWlTI+hGrGv5I8dEwmco/00EvkzIIsR7MqrHonbD9pO2MOfFnpFntl7ecpZs+3mW+XbQZu9QCg==",
+      "version": "1.15.0",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.15.0.tgz",
+      "integrity": "sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g==",
       "dependencies": {
         "encodeurl": "~1.0.2",
         "escape-html": "~1.0.3",
         "parseurl": "~1.3.3",
-        "send": "0.17.1"
+        "send": "0.18.0"
       },
       "engines": {
         "node": ">= 0.8.0"
       }
     },
     "node_modules/setprototypeof": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.1.1.tgz",
-      "integrity": "sha512-JvdAWfbXeIGaZ9cILp38HntZSFSo3mWg6xGcJJsd+d4aRMOqauag1C63dJfDw7OaMYwEbHMOxEZ1lqVRYP2OAw=="
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw=="
+    },
+    "node_modules/side-channel": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz",
+      "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==",
+      "dependencies": {
+        "call-bind": "^1.0.0",
+        "get-intrinsic": "^1.0.2",
+        "object-inspect": "^1.9.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
     },
     "node_modules/statuses": {
-      "version": "1.5.0",
-      "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz",
-      "integrity": "sha1-Fhx9rBd2Wf2YEfQ3cfqZOBR4Yow=",
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
+      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
       "engines": {
-        "node": ">= 0.6"
+        "node": ">= 0.8"
       }
     },
     "node_modules/toidentifier": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.0.tgz",
-      "integrity": "sha512-yaOH/Pk/VEhBWWTlhI+qXxDFXlejDGcQipMlyxda9nthulaxLZUNcUqFxokp0vcYnvteJln5FNQDRrxj3YcbVw==",
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
       "engines": {
         "node": ">=0.6"
       }
@@ -492,7 +603,7 @@
     "node_modules/unpipe": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
-      "integrity": "sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw=",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
       "engines": {
         "node": ">= 0.8"
       }
@@ -515,13 +626,16 @@
     }
   },
   "dependencies": {
+    "@browsermt/bergamot-translator": {
+      "version": "file:../module"
+    },
     "accepts": {
-      "version": "1.3.7",
-      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.7.tgz",
-      "integrity": "sha512-Il80Qs2WjYlJIBNzNkK6KYqlVMTbZLXgHx2oT0pU/fjRHyEp+PEfEPY0R3WCwAGVOtauxh1hOxNgIf5bv7dQpA==",
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
       "requires": {
-        "mime-types": "~2.1.24",
-        "negotiator": "0.6.2"
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
       }
     },
     "array-flatten": {
@@ -530,33 +644,44 @@
       "integrity": "sha1-ml9pkFGx5wczKPKgCJaLZOopVdI="
     },
     "body-parser": {
-      "version": "1.19.0",
-      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.19.0.tgz",
-      "integrity": "sha512-dhEPs72UPbDnAQJ9ZKMNTP6ptJaionhP5cBb541nXPlW60Jepo9RV/a4fX4XWW9CuFNK22krhrj1+rgzifNCsw==",
+      "version": "1.20.1",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.1.tgz",
+      "integrity": "sha512-jWi7abTbYwajOytWCQc37VulmWiRae5RyTpaCyDcS5/lMdtwSz5lOpDE67srw/HYe35f1z3fDQw+3txg7gNtWw==",
       "requires": {
-        "bytes": "3.1.0",
+        "bytes": "3.1.2",
         "content-type": "~1.0.4",
         "debug": "2.6.9",
-        "depd": "~1.1.2",
-        "http-errors": "1.7.2",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "http-errors": "2.0.0",
         "iconv-lite": "0.4.24",
-        "on-finished": "~2.3.0",
-        "qs": "6.7.0",
-        "raw-body": "2.4.0",
-        "type-is": "~1.6.17"
+        "on-finished": "2.4.1",
+        "qs": "6.11.0",
+        "raw-body": "2.5.1",
+        "type-is": "~1.6.18",
+        "unpipe": "1.0.0"
       }
     },
     "bytes": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.0.tgz",
-      "integrity": "sha512-zauLjrfCG+xvoyaqLoV8bLVXXNGC4JqlxFCutSDWA6fJrTo2ZuvLYTqZ7aHBLZSMOopbzwv8f+wZcVzfVTI2Dg=="
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg=="
+    },
+    "call-bind": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz",
+      "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==",
+      "requires": {
+        "function-bind": "^1.1.1",
+        "get-intrinsic": "^1.0.2"
+      }
     },
     "content-disposition": {
-      "version": "0.5.3",
-      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.3.tgz",
-      "integrity": "sha512-ExO0774ikEObIAEV9kDo50o+79VCUdEB6n6lzKgGwupcVeRlhrj3qGAfwq8G6uBJjkqLrhT0qEYFcWng8z1z0g==",
+      "version": "0.5.4",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
+      "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
       "requires": {
-        "safe-buffer": "5.1.2"
+        "safe-buffer": "5.2.1"
       }
     },
     "content-type": {
@@ -565,9 +690,9 @@
       "integrity": "sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA=="
     },
     "cookie": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.4.0.tgz",
-      "integrity": "sha512-+Hp8fLp57wnUSt0tY0tHEXh4voZRDnoIrZPqlo3DPiI4y9lwg/jqx+1Om94/W6ZaPDOUbnjOt/99w66zk+l1Xg=="
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.5.0.tgz",
+      "integrity": "sha512-YZ3GUyn/o8gfKJlnlX7g7xq4gyO6OSuhGPKaaGssGB2qgDUS0gPgtTvoyZLTt9Ab6dC4hfc9dV5arkvc/OCmrw=="
     },
     "cookie-signature": {
       "version": "1.0.6",
@@ -592,106 +717,135 @@
       }
     },
     "depd": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz",
-      "integrity": "sha1-m81S4UwJd2PnSbJ0xDRu0uVgtak="
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw=="
     },
     "destroy": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.0.4.tgz",
-      "integrity": "sha1-l4hXRCxEdJ5CBmE+N5RiBYJqvYA="
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
+      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg=="
     },
     "ee-first": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
-      "integrity": "sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0="
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="
     },
     "encodeurl": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
-      "integrity": "sha1-rT/0yG7C0CkyL1oCw6mmBslbP1k="
+      "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w=="
     },
     "escape-html": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
-      "integrity": "sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg="
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow=="
     },
     "etag": {
       "version": "1.8.1",
       "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
-      "integrity": "sha1-Qa4u62XvpiJorr/qg6x9eSmbCIc="
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg=="
     },
     "express": {
-      "version": "4.17.1",
-      "resolved": "https://registry.npmjs.org/express/-/express-4.17.1.tgz",
-      "integrity": "sha512-mHJ9O79RqluphRrcw2X/GTh3k9tVv8YcoyY4Kkh4WDMUYKRZUq0h1o0w2rrrxBqM7VoeUVqgb27xlEMXTnYt4g==",
+      "version": "4.18.2",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.18.2.tgz",
+      "integrity": "sha512-5/PsL6iGPdfQ/lKM1UuielYgv3BUoJfz1aUwU9vHZ+J7gyvwdQXFEBIEIaxeGf0GIcreATNyBExtalisDbuMqQ==",
       "requires": {
-        "accepts": "~1.3.7",
+        "accepts": "~1.3.8",
         "array-flatten": "1.1.1",
-        "body-parser": "1.19.0",
-        "content-disposition": "0.5.3",
+        "body-parser": "1.20.1",
+        "content-disposition": "0.5.4",
         "content-type": "~1.0.4",
-        "cookie": "0.4.0",
+        "cookie": "0.5.0",
         "cookie-signature": "1.0.6",
         "debug": "2.6.9",
-        "depd": "~1.1.2",
+        "depd": "2.0.0",
         "encodeurl": "~1.0.2",
         "escape-html": "~1.0.3",
         "etag": "~1.8.1",
-        "finalhandler": "~1.1.2",
+        "finalhandler": "1.2.0",
         "fresh": "0.5.2",
+        "http-errors": "2.0.0",
         "merge-descriptors": "1.0.1",
         "methods": "~1.1.2",
-        "on-finished": "~2.3.0",
+        "on-finished": "2.4.1",
         "parseurl": "~1.3.3",
         "path-to-regexp": "0.1.7",
-        "proxy-addr": "~2.0.5",
-        "qs": "6.7.0",
+        "proxy-addr": "~2.0.7",
+        "qs": "6.11.0",
         "range-parser": "~1.2.1",
-        "safe-buffer": "5.1.2",
-        "send": "0.17.1",
-        "serve-static": "1.14.1",
-        "setprototypeof": "1.1.1",
-        "statuses": "~1.5.0",
+        "safe-buffer": "5.2.1",
+        "send": "0.18.0",
+        "serve-static": "1.15.0",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
         "type-is": "~1.6.18",
         "utils-merge": "1.0.1",
         "vary": "~1.1.2"
       }
     },
     "finalhandler": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.1.2.tgz",
-      "integrity": "sha512-aAWcW57uxVNrQZqFXjITpW3sIUQmHGG3qSb9mUah9MgMC4NeWhNOlNjXEYq3HjRAvL6arUviZGGJsBg6z0zsWA==",
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.2.0.tgz",
+      "integrity": "sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg==",
       "requires": {
         "debug": "2.6.9",
         "encodeurl": "~1.0.2",
         "escape-html": "~1.0.3",
-        "on-finished": "~2.3.0",
+        "on-finished": "2.4.1",
         "parseurl": "~1.3.3",
-        "statuses": "~1.5.0",
+        "statuses": "2.0.1",
         "unpipe": "~1.0.0"
       }
     },
     "forwarded": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.1.2.tgz",
-      "integrity": "sha1-mMI9qxF1ZXuMBXPozszZGw/xjIQ="
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow=="
     },
     "fresh": {
       "version": "0.5.2",
       "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
-      "integrity": "sha1-PYyt2Q2XZWn6g1qx+OSyOhBWBac="
+      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q=="
+    },
+    "function-bind": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
+      "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A=="
+    },
+    "get-intrinsic": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.3.tgz",
+      "integrity": "sha512-QJVz1Tj7MS099PevUG5jvnt9tSkXN8K14dxQlikJuPt4uD9hHAHjLyLBiLR5zELelBdD9QNRAXZzsJx0WaDL9A==",
+      "requires": {
+        "function-bind": "^1.1.1",
+        "has": "^1.0.3",
+        "has-symbols": "^1.0.3"
+      }
+    },
+    "has": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
+      "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
+      "requires": {
+        "function-bind": "^1.1.1"
+      }
+    },
+    "has-symbols": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz",
+      "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A=="
     },
     "http-errors": {
-      "version": "1.7.2",
-      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.7.2.tgz",
-      "integrity": "sha512-uUQBt3H/cSIVfch6i1EuPNy/YsRSOUBXTVfZ+yR7Zjez3qjBz6i9+i4zjNaoqcoFVI4lQJ5plg63TvGfRSDCRg==",
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
+      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
       "requires": {
-        "depd": "~1.1.2",
-        "inherits": "2.0.3",
-        "setprototypeof": "1.1.1",
-        "statuses": ">= 1.5.0 < 2",
-        "toidentifier": "1.0.0"
+        "depd": "2.0.0",
+        "inherits": "2.0.4",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "toidentifier": "1.0.1"
       }
     },
     "iconv-lite": {
@@ -703,9 +857,9 @@
       }
     },
     "inherits": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
-      "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4="
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
     },
     "ipaddr.js": {
       "version": "1.9.1",
@@ -715,7 +869,7 @@
     "media-typer": {
       "version": "0.3.0",
       "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
-      "integrity": "sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g="
+      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ=="
     },
     "merge-descriptors": {
       "version": "1.0.1",
@@ -733,27 +887,27 @@
       "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg=="
     },
     "mime-db": {
-      "version": "1.45.0",
-      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.45.0.tgz",
-      "integrity": "sha512-CkqLUxUk15hofLoLyljJSrukZi8mAtgd+yE5uO4tqRZsdsAJKv0O+rFMhVDRJgozy+yG6md5KwuXhD4ocIoP+w=="
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="
     },
     "mime-types": {
-      "version": "2.1.28",
-      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.28.tgz",
-      "integrity": "sha512-0TO2yJ5YHYr7M2zzT7gDU1tbwHxEUWBCLt0lscSNpcdAfFyJOVEpRYNS7EXVcTLNj/25QO8gulHC5JtTzSE2UQ==",
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
       "requires": {
-        "mime-db": "1.45.0"
+        "mime-db": "1.52.0"
       }
     },
     "ms": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
-      "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g="
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A=="
     },
     "negotiator": {
-      "version": "0.6.2",
-      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.2.tgz",
-      "integrity": "sha512-hZXc7K2e+PgeI1eDBe/10Ard4ekbfrrqG8Ep+8Jmf4JID2bNg7NvCPOZN+kfF574pFQI7mum2AUqDidoKqcTOw=="
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
+      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg=="
     },
     "nocache": {
       "version": "2.1.0",
@@ -765,10 +919,15 @@
       "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
       "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM="
     },
+    "object-inspect": {
+      "version": "1.12.3",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz",
+      "integrity": "sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g=="
+    },
     "on-finished": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.3.0.tgz",
-      "integrity": "sha1-IPEzZIGwg811M3mSoWlxqi2QaUc=",
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
       "requires": {
         "ee-first": "1.1.1"
       }
@@ -784,18 +943,21 @@
       "integrity": "sha1-32BBeABfUi8V60SQ5yR6G/qmf4w="
     },
     "proxy-addr": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.6.tgz",
-      "integrity": "sha512-dh/frvCBVmSsDYzw6n926jv974gddhkFPfiN8hPOi30Wax25QZyZEGveluCgliBnqmuM+UJmBErbAUFIoDbjOw==",
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
       "requires": {
-        "forwarded": "~0.1.2",
+        "forwarded": "0.2.0",
         "ipaddr.js": "1.9.1"
       }
     },
     "qs": {
-      "version": "6.7.0",
-      "resolved": "https://registry.npmjs.org/qs/-/qs-6.7.0.tgz",
-      "integrity": "sha512-VCdBRNFTX1fyE7Nb6FYoURo/SPe62QCaAyzJvUjwRaIsc+NePBEniHlvxFmmX56+HZphIGtV0XeCirBtpDrTyQ=="
+      "version": "6.11.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.11.0.tgz",
+      "integrity": "sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==",
+      "requires": {
+        "side-channel": "^1.0.4"
+      }
     },
     "range-parser": {
       "version": "1.2.1",
@@ -803,20 +965,20 @@
       "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg=="
     },
     "raw-body": {
-      "version": "2.4.0",
-      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.4.0.tgz",
-      "integrity": "sha512-4Oz8DUIwdvoa5qMJelxipzi/iJIi40O5cGV1wNYp5hvZP8ZN0T+jiNkL0QepXs+EsQ9XJ8ipEDoiH70ySUJP3Q==",
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.1.tgz",
+      "integrity": "sha512-qqJBtEyVgS0ZmPGdCFPWJ3FreoqvG4MVQln/kCgF7Olq95IbOp0/BWyMwbdtn4VTvkM8Y7khCQ2Xgk/tcrCXig==",
       "requires": {
-        "bytes": "3.1.0",
-        "http-errors": "1.7.2",
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
         "iconv-lite": "0.4.24",
         "unpipe": "1.0.0"
       }
     },
     "safe-buffer": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="
     },
     "safer-buffer": {
       "version": "2.1.2",
@@ -824,57 +986,67 @@
       "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="
     },
     "send": {
-      "version": "0.17.1",
-      "resolved": "https://registry.npmjs.org/send/-/send-0.17.1.tgz",
-      "integrity": "sha512-BsVKsiGcQMFwT8UxypobUKyv7irCNRHk1T0G680vk88yf6LBByGcZJOTJCrTP2xVN6yI+XjPJcNuE3V4fT9sAg==",
+      "version": "0.18.0",
+      "resolved": "https://registry.npmjs.org/send/-/send-0.18.0.tgz",
+      "integrity": "sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg==",
       "requires": {
         "debug": "2.6.9",
-        "depd": "~1.1.2",
-        "destroy": "~1.0.4",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
         "encodeurl": "~1.0.2",
         "escape-html": "~1.0.3",
         "etag": "~1.8.1",
         "fresh": "0.5.2",
-        "http-errors": "~1.7.2",
+        "http-errors": "2.0.0",
         "mime": "1.6.0",
-        "ms": "2.1.1",
-        "on-finished": "~2.3.0",
+        "ms": "2.1.3",
+        "on-finished": "2.4.1",
         "range-parser": "~1.2.1",
-        "statuses": "~1.5.0"
+        "statuses": "2.0.1"
       },
       "dependencies": {
         "ms": {
-          "version": "2.1.1",
-          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz",
-          "integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg=="
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
         }
       }
     },
     "serve-static": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.14.1.tgz",
-      "integrity": "sha512-JMrvUwE54emCYWlTI+hGrGv5I8dEwmco/00EvkzIIsR7MqrHonbD9pO2MOfFnpFntl7ecpZs+3mW+XbQZu9QCg==",
+      "version": "1.15.0",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.15.0.tgz",
+      "integrity": "sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g==",
       "requires": {
         "encodeurl": "~1.0.2",
         "escape-html": "~1.0.3",
         "parseurl": "~1.3.3",
-        "send": "0.17.1"
+        "send": "0.18.0"
       }
     },
     "setprototypeof": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.1.1.tgz",
-      "integrity": "sha512-JvdAWfbXeIGaZ9cILp38HntZSFSo3mWg6xGcJJsd+d4aRMOqauag1C63dJfDw7OaMYwEbHMOxEZ1lqVRYP2OAw=="
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw=="
+    },
+    "side-channel": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz",
+      "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==",
+      "requires": {
+        "call-bind": "^1.0.0",
+        "get-intrinsic": "^1.0.2",
+        "object-inspect": "^1.9.0"
+      }
     },
     "statuses": {
-      "version": "1.5.0",
-      "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz",
-      "integrity": "sha1-Fhx9rBd2Wf2YEfQ3cfqZOBR4Yow="
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
+      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ=="
     },
     "toidentifier": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.0.tgz",
-      "integrity": "sha512-yaOH/Pk/VEhBWWTlhI+qXxDFXlejDGcQipMlyxda9nthulaxLZUNcUqFxokp0vcYnvteJln5FNQDRrxj3YcbVw=="
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA=="
     },
     "type-is": {
       "version": "1.6.18",
@@ -888,7 +1060,7 @@
     "unpipe": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
-      "integrity": "sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw="
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ=="
     },
     "utils-merge": {
       "version": "1.0.1",
diff --git a/wasm/test_page/package.json b/wasm/test_page/package.json
index 20af6d2ab..622b48c1a 100644
--- a/wasm/test_page/package.json
+++ b/wasm/test_page/package.json
@@ -1,7 +1,14 @@
 {
   "dependencies": {
+    "@browsermt/bergamot-translator": "file:../module",
     "cors": "^2.8.5",
-    "express": "^4.17.1",
+    "express": "^4.18.2",
     "nocache": "^2.1.0"
+  },
+  "config": {
+    "port": 80
+  },
+  "scripts": {
+    "start": "node ./bergamot-httpserver.js $npm_package_config_port 1 0"
   }
 }
diff --git a/wasm/test_page/start_server.sh b/wasm/test_page/start_server.sh
index 59d455d14..5b6eeb0a3 100644
--- a/wasm/test_page/start_server.sh
+++ b/wasm/test_page/start_server.sh
@@ -24,7 +24,7 @@ fi
 # Prepare a list all wasm artifacts to be copied and copy them to the destination folder
 ARTIFACTS_BASE_NAME="bergamot-translator-worker"
 ARTIFACTS="$1/$ARTIFACTS_BASE_NAME.js $1/$ARTIFACTS_BASE_NAME.wasm"
-ARTIFACTS_DESTINATION_FOLDER=$SCRIPT_ABSOLUTE_PATH/js
+ARTIFACTS_DESTINATION_FOLDER=$SCRIPT_ABSOLUTE_PATH/../module/worker
 
 for i in $ARTIFACTS; do
     [ -f "$i" ] || breaks