Fix CI

Merge branch 'master' into sf-osrm-routed
Implement NodeJS based server fully replicating osrm-routed
2023-08-22 20:29:21 +02:00 · 2023-08-22 17:55:10 +02:00 · 2022-10-29 13:26:40 +02:00 · 2022-10-29 13:24:48 +02:00 · 2022-10-26 19:30:27 +02:00 · 2022-10-25 20:26:20 +02:00
2263 changed files with 203291 additions and 106326 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@ -13,11 +13,6 @@ Checks: >
    -bugprone-forward-declaration-namespace,
    -bugprone-sizeof-expression,
    -bugprone-throw-keyword-missing,
-    -bugprone-chained-comparison,
-    -bugprone-incorrect-enable-if,
-    -bugprone-switch-missing-default-case,
-    -bugprone-empty-catch,
-    -bugprone-unchecked-optional-access,
    -clang-analyzer-*,
    -clang-diagnostic-deprecated-declarations,
    -clang-diagnostic-constant-conversion,
@ -54,13 +49,11 @@ Checks: >
    -misc-misplaced-const,
    -misc-definitions-in-headers,
    -misc-unused-parameters,
-    -misc-include-cleaner,
    modernize-concat-nested-namespaces,
    modernize-use-using,
    performance-*,
+    -performance-noexcept-move-constructor,
    -performance-no-int-to-ptr,
-    -performance-enum-size,
-    -performance-avoid-endl,
    readability-*,
    -readability-avoid-const-params-in-decls,
    -readability-braces-around-statements,
@ -89,10 +82,6 @@ Checks: >
    -readability-make-member-function-const,
    -readability-redundant-string-init,
    -readability-non-const-parameter,
-    -readability-redundant-inline-specifier,
-    -readability-avoid-nested-conditional-operator,
-    -readability-avoid-return-with-void-value,
-    -readability-redundant-casting,
    -readability-static-accessed-through-instance
    
 WarningsAsErrors: '*'
--- a/.gitea/workflows/publish-container.yaml
+++ b/.gitea/workflows/publish-container.yaml
@ -1,65 +0,0 @@
-name: Build and Publish Docker Image
-
-on:
-  release:
-    types: [published, prereleased]
-
-env:
-  IMAGE_NAME: openharbor/osrm-backend
-
-jobs:
-  publish:
-    strategy:
-      matrix:
-        docker-base-image: ["debian", "alpine"]
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out the repo
-        uses: actions/checkout@v3
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-
-      - name: Docker meta
-        id: meta
-        uses: docker/metadata-action@v4
-        with:
-          images: ${{ env.IMAGE_NAME }}
-
-      - name: Docker meta - debug
-        id: metadebug
-        uses: docker/metadata-action@v4
-        with:
-          images: ${{ env.IMAGE_NAME }}
-          flavor: |
-            latest=true
-            suffix=-debug,onlatest=true
-
-      - name: Log in to DockerHub
-        uses: docker/login-action@v2
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_ACCESS_TOKEN }}
-
-      - name: Build and push debug image
-        uses: docker/build-push-action@v4
-        with:
-          push: true
-          platforms: linux/amd64,linux/arm64,linux/ppc64le,linux/riscv64
-          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
-          tags: ${{ steps.metadebug.outputs.tags }}
-          build-args: |
-            DOCKER_TAG=${{ join(steps.metadebug.outputs.tags) }}-${{ matrix.docker-base-image }}
-
-      - name: Build and push normal image
-        uses: docker/build-push-action@v4
-        with:
-          push: true
-          platforms: linux/amd64,linux/arm64,linux/ppc64le,linux/riscv64
-          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
-          tags: ${{ steps.meta.outputs.tags }}
-          build-args: |
-            DOCKER_TAG=${{ join(steps.meta.outputs.tags) }}-${{ matrix.docker-base-image }}
--- a/.github/ISSUE_TEMPLATE/question.md
+++ b/.github/ISSUE_TEMPLATE/question.md
@ -0,0 +1,5 @@
+---
+name: Question
+about: Ask a question about OSRM
+labels: question
+---
--- a/.github/workflows/osrm-backend-docker.yml
+++ b/.github/workflows/osrm-backend-docker.yml
@ -6,9 +6,6 @@ on:

 jobs:
  publish:
-    strategy:
-      matrix:
-        docker-base-image: ["debian", "alpine"]
    runs-on: ubuntu-latest
    steps:       
      - name: Check out the repo
@ -56,10 +53,10 @@ jobs:
        with:
          push: true
          platforms: linux/amd64,linux/arm64
-          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
+          file: ./docker/Dockerfile
          tags: ${{ steps.metadebug.outputs.tags  }}
          build-args: |
-            DOCKER_TAG=${{ join(steps.metadebug.outputs.tags ) }}-${{ matrix.docker-base-image }}
+            DOCKER_TAG=${{ join(steps.metadebug.outputs.tags ) }}


      - name: Build container image - assertions
@ -67,10 +64,10 @@ jobs:
        with:
          push: true
          platforms: linux/amd64,linux/arm64
-          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
+          file: ./docker/Dockerfile
          tags: ${{ steps.metaassertions.outputs.tags  }}
          build-args: |
-            DOCKER_TAG=${{ join(steps.metaassertions.outputs.tags ) }}-${{ matrix.docker-base-image }}
+            DOCKER_TAG=${{ join(steps.metaassertions.outputs.tags ) }}

      # build and publish "normal" image as last to get it listed on top
      - name: Build container image - normal
@ -78,7 +75,10 @@ jobs:
        with:
          push: true
          platforms: linux/amd64,linux/arm64
-          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
-          tags: ${{ steps.meta.outputs.tags  }}
+          file: ./docker/Dockerfile
+          tags:  ${{ steps.meta.outputs.tags  }}
          build-args: |
-            DOCKER_TAG=${{ join(steps.meta.outputs.tags ) }}-${{ matrix.docker-base-image }}
+            DOCKER_TAG=${{ join(steps.meta.outputs.tags ) }}            
+
+
+            
--- a/.github/workflows/osrm-backend.yml
+++ b/.github/workflows/osrm-backend.yml
@ -15,13 +15,10 @@ env:
  CCACHE_TEMPDIR: /tmp/.ccache-temp
  CCACHE_COMPRESS: 1
  CASHER_TIME_OUT: 599 # one second less than 10m to avoid 10m timeout error: https://github.com/Project-OSRM/osrm-backend/issues/2742
+  CCACHE_VERSION: 3.3.1
  CMAKE_VERSION: 3.21.2
  ENABLE_NODE_BINDINGS: "ON"

-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
 jobs:
  windows-release-node:
    needs: format-taginfo-docs
@ -29,14 +26,15 @@ jobs:
    continue-on-error: false
    env:
      BUILD_TYPE: Release
+      ENABLE_APPLE_SILICON: "OFF"
    steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v3
    - run: pip install "conan<2.0.0"
    - run: conan --version
    - run: cmake --version
-    - uses: actions/setup-node@v4
+    - uses: actions/setup-node@v3
      with:
-        node-version: 18
+        node-version: 16
    - run: node --version
    - run: npm --version
    - name: Prepare environment
@ -46,32 +44,15 @@ jobs:
        echo PUBLISH=$([[ "${GITHUB_REF:-}" == "refs/tags/v${PACKAGE_JSON_VERSION}" ]] && echo "On" || echo "Off") >> $GITHUB_ENV
    - run: npm install --ignore-scripts
    - run: npm link --ignore-scripts
+    - uses: microsoft/setup-msbuild@v1.1
    - name: Build
+      run: |
+        .\scripts\ci\windows-build.bat
+    - name: Run node tests
      shell: bash
      run: |
-        mkdir build
-        cd build
-        cmake -DCMAKE_BUILD_TYPE=Release -DENABLE_CONAN=ON -DENABLE_NODE_BINDINGS=ON ..
-        cmake --build . --config Release
-        
-    # TODO: MSVC goes out of memory when building our tests
-    # - name: Run tests
-    #   shell: bash
-    #   run: |
-    #     cd build
-    #     cmake --build . --config Release --target tests
-    #     # TODO: run tests
-    # - name: Run node tests
-    #   shell: bash
-    #   run: |
-    #     ./lib/binding/osrm-extract.exe -p profiles/car.lua test/data/monaco.osm.pbf
-
-    #     mkdir -p test/data/ch
-    #     cp test/data/monaco.osrm* test/data/ch/
-    #     ./lib/binding/osrm-contract.exe test/data/ch/monaco.osrm
-
-    #     ./lib/binding/osrm-datastore.exe test/data/ch/monaco.osrm
-    #     node test/nodejs/index.js
+        ./lib/binding/osrm-datastore.exe test/data/ch/monaco.osrm
+        node test/nodejs/index.js
    - name: Build Node package
      shell: bash
      run: ./scripts/ci/node_package.sh
@ -90,15 +71,15 @@ jobs:
        token: ${{ secrets.GITHUB_TOKEN }}

  format-taginfo-docs:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-20.04
    steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v3
    - name: Use Node.js
-      uses: actions/setup-node@v4
+      uses: actions/setup-node@v3
      with:
-        node-version: 18
+        node-version: 16
    - name: Enable Node.js cache
-      uses: actions/cache@v4
+      uses: actions/cache@v3
      with:
        path: ~/.npm
        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
@ -107,7 +88,7 @@ jobs:
    - name: Prepare environment
      run: |
        npm ci --ignore-scripts
-        clang-format-15 --version
+        clang-format-10 --version
    - name: Run checks
      run: |
        ./scripts/check_taginfo.py taginfo.json profiles/car.lua
@ -116,18 +97,38 @@ jobs:
        npm run docs && ./scripts/error_on_dirty.sh
        npm audit --production

-  docker-image-matrix:
-    strategy:
-      matrix:
-        docker-base-image: ["debian", "alpine"]
+  routed-js:
+    runs-on: ubuntu-22.04
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js
+      uses: actions/setup-node@v3
+      with:
+        node-version: 14
+    - name: Enable Node.js cache
+      uses: actions/cache@v2
+      with:
+        path: ~/.npm
+        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+        restore-keys: |
+          ${{ runner.os }}-node-
+    - name: Compile routed-js
+      run: |
+        pushd routed-js 
+        npm ci
+        npx tsc
+        popd
+        ./scripts/error_on_dirty.sh
+
+  docker-image:
    needs: format-taginfo-docs
    runs-on: ubuntu-22.04
    continue-on-error: false
    steps:
      - name: Check out the repo
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
      - name: Enable osm.pbf cache
-        uses: actions/cache@v4
+        uses: actions/cache@v3
        with:
          path: berlin-latest.osm.pbf
          key: v1-berlin-osm-pbf
@ -135,7 +136,7 @@ jobs:
            v1-berlin-osm-pbf
      - name: Docker build
        run: |
-          docker build -t osrm-backend-local -f docker/Dockerfile-${{ matrix.docker-base-image }} .
+          docker build -t osrm-backend-local -f docker/Dockerfile .
      - name: Test Docker image
        run: |
          if [ ! -f "${PWD}/berlin-latest.osm.pbf" ]; then
@ -152,6 +153,7 @@ jobs:
            >&2 echo "No berlin-latest.geojson found"
            exit 1
          fi
+
          # removing `.osrm.nbg` to check that whole pipeline works without it
          rm -rf "${PWD}/berlin-latest.osrm.nbg"

@ -166,167 +168,163 @@ jobs:
    strategy:
      matrix:
        include:
-          - name: gcc-13-debug-cov
+          - name: gcc-9-debug-cov
            continue-on-error: false
-            node: 20
-            runs-on: ubuntu-24.04
+            node: 16
+            runs-on: ubuntu-20.04
            BUILD_TOOLS: ON
            BUILD_TYPE: Debug
-            CCOMPILER: gcc-13
+            CCOMPILER: gcc-9
            CUCUMBER_TIMEOUT: 20000
-            CXXCOMPILER: g++-13
+            CXXCOMPILER: g++-9
            ENABLE_COVERAGE: ON

-          - name: clang-18-debug-asan-ubsan
+          - name: gcc-9-debug-asan-ubsan
            continue-on-error: false
-            node: 20
-            runs-on: ubuntu-24.04
+            node: 16
+            runs-on: ubuntu-20.04
            BUILD_TOOLS: ON
            BUILD_TYPE: Debug
-            CCOMPILER: clang-18
+            CCOMPILER: gcc-9
            CUCUMBER_TIMEOUT: 20000
-            CXXCOMPILER: clang++-18
+            CXXCOMPILER: g++-9
            ENABLE_SANITIZER: ON
            TARGET_ARCH: x86_64-asan-ubsan
            OSRM_CONNECTION_RETRIES: 10
            OSRM_CONNECTION_EXP_BACKOFF_COEF: 1.5

-          - name: clang-18-release
+          - name: clang-6.0-debug
            continue-on-error: false
-            node: 18
-            runs-on: ubuntu-24.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-18
-            CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF
-
-          - name: clang-18-debug
-            continue-on-error: false
-            node: 18
-            runs-on: ubuntu-24.04
+            node: 16
+            runs-on: ubuntu-20.04
            BUILD_TOOLS: ON
            BUILD_TYPE: Debug
-            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-18
+            CCOMPILER: clang-6.0
+            CXXCOMPILER: clang++-6.0
            CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF

-          - name: clang-18-debug-clang-tidy
+          - name: clang-15.0-debug-clang-tidy
            continue-on-error: false
-            node: 18
-            runs-on: ubuntu-24.04
+            node: 16
+            runs-on: ubuntu-22.04
            BUILD_TOOLS: ON
            BUILD_TYPE: Debug
-            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-18
+            CCOMPILER: clang-15
+            CXXCOMPILER: clang++-15
            CUCUMBER_TIMEOUT: 60000
            ENABLE_CLANG_TIDY: ON

-
-          - name: clang-17-release
-            continue-on-error: false
-            node: 18
-            runs-on: ubuntu-24.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: clang-17
-            CXXCOMPILER: clang++-17
-            CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF
-
-          - name: clang-16-release
-            continue-on-error: false
-            node: 18
-            runs-on: ubuntu-24.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: clang-16
-            CXXCOMPILER: clang++-16
-            CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF
-
          - name: conan-linux-debug-asan-ubsan
            continue-on-error: false
-            node: 18
-            runs-on: ubuntu-24.04
+            node: 16
+            runs-on: ubuntu-20.04
            BUILD_TOOLS: ON
            BUILD_TYPE: Release
-            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-18
+            CCOMPILER: clang-11
+            CXXCOMPILER: clang++-11
            ENABLE_CONAN: ON
            ENABLE_SANITIZER: ON
-            ENABLE_LTO: OFF

          - name: conan-linux-release
            continue-on-error: false
-            node: 18
-            runs-on: ubuntu-24.04
+            node: 16
+            runs-on: ubuntu-20.04
            BUILD_TOOLS: ON
            BUILD_TYPE: Release
-            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-18
+            CCOMPILER: clang-6.0
+            CXXCOMPILER: clang++-6.0
            ENABLE_CONAN: ON
-            ENABLE_LTO: OFF
-
-          - name: gcc-14-release
-            continue-on-error: false
-            node: 20
-            runs-on: ubuntu-24.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: gcc-14
-            CXXCOMPILER: g++-14
-            CXXFLAGS: '-Wno-array-bounds -Wno-uninitialized'
-
-          - name: gcc-13-release
-            continue-on-error: false
-            node: 20
-            runs-on: ubuntu-24.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: gcc-13
-            CXXCOMPILER: g++-13
-            CXXFLAGS: '-Wno-array-bounds -Wno-uninitialized'

          - name: gcc-12-release
            continue-on-error: false
-            node: 20
+            node: 16
            runs-on: ubuntu-22.04
            BUILD_TOOLS: ON
            BUILD_TYPE: Release
            CCOMPILER: gcc-12
            CXXCOMPILER: g++-12
+            ENABLE_BENCHMARKS: ON
            CXXFLAGS: '-Wno-array-bounds -Wno-uninitialized'

+          - name: gcc-11-release
+            continue-on-error: false
+            node: 16
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: gcc-11
+            CXXCOMPILER: g++-11
+            ENABLE_BENCHMARKS: ON
+
+          - name: gcc-10-release
+            continue-on-error: false
+            node: 16
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: gcc-10
+            CXXCOMPILER: g++-10
+
+          - name: gcc-9-release
+            continue-on-error: false
+            node: 16
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: gcc-9
+            CXXCOMPILER: g++-9
+            CXXFLAGS: -Wno-cast-function-type
+
+          - name: gcc-9-conan-release-i686
+            continue-on-error: false
+            node: 16
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: gcc-9
+            CFLAGS: "-m32 -msse2 -mfpmath=sse"
+            CXXCOMPILER: g++-9
+            CXXFLAGS: "-m32 -msse2 -mfpmath=sse"
+            TARGET_ARCH: i686
+            ENABLE_CONAN: ON
+            
+          - name: gcc-8-release
+            continue-on-error: false
+            node: 16
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: gcc-8
+            CXXCOMPILER: g++-8
+            CXXFLAGS: -Wno-cast-function-type
+
          - name: conan-linux-release-node
            build_node_package: true
            continue-on-error: false
-            node: 20
-            runs-on: ubuntu-24.04
+            node: 18
+            runs-on: ubuntu-20.04
            BUILD_TYPE: Release
-            CCOMPILER: clang-16
-            CXXCOMPILER: clang++-16
+            CCOMPILER: clang-6.0
+            CXXCOMPILER: clang++-6.0
            ENABLE_CONAN: ON
            NODE_PACKAGE_TESTS_ONLY: ON

          - name: conan-linux-debug-node
            build_node_package: true
            continue-on-error: false
-            node: 20
-            runs-on: ubuntu-24.04
+            node: 18
+            runs-on: ubuntu-20.04
            BUILD_TYPE: Debug
-            CCOMPILER: clang-16
-            CXXCOMPILER: clang++-16
+            CCOMPILER: clang-6.0
+            CXXCOMPILER: clang++-6.0
            ENABLE_CONAN: ON
            NODE_PACKAGE_TESTS_ONLY: ON

          - name: conan-macos-x64-release-node
            build_node_package: true
            continue-on-error: true
-            node: 20
-            runs-on: macos-13 # x86_64
+            node: 18
+            runs-on: macos-11
            BUILD_TYPE: Release
            CCOMPILER: clang
            CXXCOMPILER: clang++
@ -337,14 +335,15 @@ jobs:
          - name: conan-macos-arm64-release-node
            build_node_package: true
            continue-on-error: true
-            node: 20
-            runs-on: macos-14 # arm64 
+            node: 18
+            runs-on: macos-11
            BUILD_TYPE: Release
            CCOMPILER: clang
            CXXCOMPILER: clang++
            CUCUMBER_TIMEOUT: 60000
            ENABLE_ASSERTIONS: ON
            ENABLE_CONAN: ON
+            ENABLE_APPLE_SILICON: ON

    name: ${{ matrix.name}}
    continue-on-error: ${{ matrix.continue-on-error }}
@ -364,51 +363,48 @@ jobs:
      ENABLE_CONAN: ${{ matrix.ENABLE_CONAN }}
      ENABLE_SANITIZER: ${{ matrix.ENABLE_SANITIZER }}
      NODE_PACKAGE_TESTS_ONLY: ${{ matrix.NODE_PACKAGE_TESTS_ONLY }}
+      ENABLE_APPLE_SILICON: ${{ matrix.ENABLE_APPLE_SILICON }}
      TARGET_ARCH: ${{ matrix.TARGET_ARCH }}
      OSRM_CONNECTION_RETRIES: ${{ matrix.OSRM_CONNECTION_RETRIES }}
      OSRM_CONNECTION_EXP_BACKOFF_COEF: ${{ matrix.OSRM_CONNECTION_EXP_BACKOFF_COEF }}
-      ENABLE_LTO: ${{ matrix.ENABLE_LTO }}
    steps:
-    - uses: actions/checkout@v4
-    - name: Build machine architecture
-      run: uname -m
+    - uses: actions/checkout@v3
+
    - name: Use Node.js
-      uses: actions/setup-node@v4
+      uses: actions/setup-node@v3
      with:
        node-version: ${{ matrix.node }}
    - name: Enable Node.js cache
-      uses: actions/cache@v4
+      uses: actions/cache@v3
      with:
        path: ~/.npm
        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
        restore-keys: |
          ${{ runner.os }}-node-
    - name: Enable compiler cache
-      uses: actions/cache@v4
+      uses: actions/cache@v3
      with:
        path: ~/.ccache
        key: ccache-${{ matrix.name }}-${{ github.sha }}
        restore-keys: |
          ccache-${{ matrix.name }}-
    - name: Enable Conan cache
-      uses: actions/cache@v4
+      uses: actions/cache@v3
      with:
        path: ~/.conan
-        key: v9-conan-${{ matrix.name }}-${{ github.sha }}
+        key: v6-conan-${{ matrix.name }}-${{ github.sha }}
        restore-keys: |
-          v9-conan-${{ matrix.name }}-
+          v6-conan-${{ matrix.name }}-
    - name: Enable test cache
-      uses: actions/cache@v4
+      uses: actions/cache@v3
      with:
        path: ${{github.workspace}}/test/cache
        key: v4-test-${{ matrix.name }}-${{ github.sha }}
        restore-keys: |
          v4-test-${{ matrix.name }}-
+
    - name: Prepare environment
      run: |
-        echo "CCACHE_DIR=$HOME/.ccache" >> $GITHUB_ENV
-        mkdir -p $HOME/.ccache
-
        PACKAGE_JSON_VERSION=$(node -e "console.log(require('./package.json').version)")
        echo PUBLISH=$([[ "${GITHUB_REF:-}" == "refs/tags/v${PACKAGE_JSON_VERSION}" ]] && echo "On" || echo "Off") >> $GITHUB_ENV
        echo "OSRM_INSTALL_DIR=${GITHUB_WORKSPACE}/install-osrm" >> $GITHUB_ENV
@ -417,7 +413,6 @@ jobs:
          # We can only set this after checkout once we know the workspace directory
          echo "LSAN_OPTIONS=print_suppressions=0:suppressions=${GITHUB_WORKSPACE}/scripts/ci/leaksanitizer.conf" >> $GITHUB_ENV
          echo "UBSAN_OPTIONS=symbolize=1:halt_on_error=1:print_stacktrace=1:suppressions=${GITHUB_WORKSPACE}/scripts/ci/undefinedsanitizer.conf" >> $GITHUB_ENV
-          echo "ASAN_OPTIONS=print_suppressions=0:suppressions=${GITHUB_WORKSPACE}/scripts/ci/addresssanitizer.conf" >> $GITHUB_ENV
        fi

        if [[ "${RUNNER_OS}" == "Linux" ]]; then
@ -425,39 +420,10 @@ jobs:
        elif [[ "${RUNNER_OS}" == "macOS" ]]; then
          echo "JOBS=$((`sysctl -n hw.ncpu` + 1))" >>  $GITHUB_ENV
        fi
-    # See: https://github.com/actions/toolkit/issues/946#issuecomment-1590016041
-    # We need it to be able to access system folders while restoring cached Boost below
-    - name: Give tar root ownership 
-      if: runner.os == 'Linux' && matrix.ENABLE_CONAN != 'ON'
-      run: sudo chown root /bin/tar && sudo chmod u+s /bin/tar
-    - name: Cache Boost
-      if: runner.os == 'Linux' && matrix.ENABLE_CONAN != 'ON'
-      id: cache-boost
-      uses: actions/cache@v4
-      with:
-        path: |
-          /usr/local/include/boost
-          /usr/local/lib/libboost*
-        key: v1-boost-${{ runner.os }}-${{ runner.arch }}-${{ matrix.runs-on }}
-        restore-keys: |
-          v1-boost-${{ runner.os }}-${{ runner.arch }}-${{ matrix.runs-on }}
-
-    - name: Install Boost
-      if: steps.cache-boost.outputs.cache-hit != 'true' && runner.os == 'Linux' && matrix.ENABLE_CONAN != 'ON'
-      run: |
-        BOOST_VERSION="1.85.0"
-        BOOST_VERSION_FLAVOR="${BOOST_VERSION}-b2-nodocs"
-        wget -q https://github.com/boostorg/boost/releases/download/boost-${BOOST_VERSION}/boost-${BOOST_VERSION_FLAVOR}.tar.gz
-        tar xzf boost-${BOOST_VERSION_FLAVOR}.tar.gz
-        cd boost-${BOOST_VERSION}
-        sudo ./bootstrap.sh
-        sudo ./b2 install
-        cd ..
-        sudo rm -rf boost-${BOOST_VERSION}*

    - name: Install dev dependencies
      run: |
-        python3 -m pip install "conan<2.0.0" || python3 -m pip install "conan<2.0.0" --break-system-packages
+        python3 -m pip install "conan<2.0.0"

        # workaround for issue that GitHub Actions seems to not adding it to PATH after https://github.com/actions/runner-images/pull/6499
        # and that's why CI cannot find conan executable installed above
@ -472,20 +438,34 @@ jobs:
          brew install ccache
        fi

+        # clang
+        if [[ "${CCOMPILER}" == "clang-6.0" ]]; then
+          sudo apt-get update -y && sudo apt-get install clang++-6
+        elif [[ "${CCOMPILER}" == "clang-15" ]]; then
+          wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
+          sudo apt-get update -y && sudo apt-get install software-properties-common
+          sudo add-apt-repository 'deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-15 main'
+          sudo apt-get update -y && sudo apt-get install clang++-15 clang-tidy-15
+          sudo update-alternatives --install /usr/bin/clang-tidy clang-tidy /usr/bin/clang-tidy-15 100000
+        fi
+
        # Linux dev packages
-        if [ "${ENABLE_CONAN}" != "ON" ]; then
+        if [ "${TARGET_ARCH}" != "i686" ] && [ "${ENABLE_CONAN}" != "ON" ]; then
          sudo apt-get update -y
-          sudo apt-get install -y libbz2-dev libxml2-dev libzip-dev liblua5.2-dev
+          sudo apt-get install -y libbz2-dev libxml2-dev libzip-dev liblua5.2-dev libboost-all-dev
          if [[ "${CCOMPILER}" != clang-* ]]; then
            sudo apt-get install -y ${CXXCOMPILER}
          fi
          if [[ "${ENABLE_COVERAGE}" == "ON" ]]; then
            sudo apt-get install -y lcov
          fi
+        elif [[ $TARGET_ARCH == "i686" ]]; then
+          source ./scripts/ci/before_install.${TARGET_ARCH}.sh
+          echo "PKG_CONFIG_PATH=/usr/lib/i386-linux-gnu/pkgconfig:${PKG_CONFIG_PATH}" >> $GITHUB_ENV
        fi

        # TBB
-        TBB_VERSION=2021.12.0
+        TBB_VERSION=2021.3.0
        if [[ "${RUNNER_OS}" == "Linux" ]]; then
          TBB_URL="https://github.com/oneapi-src/oneTBB/releases/download/v${TBB_VERSION}/oneapi-tbb-${TBB_VERSION}-lin.tgz"
        elif [[ "${RUNNER_OS}" == "macOS" ]]; then
@ -495,20 +475,6 @@ jobs:
        tar zxvf onetbb.tgz
        sudo cp -a oneapi-tbb-${TBB_VERSION}/lib/. /usr/local/lib/
        sudo cp -a oneapi-tbb-${TBB_VERSION}/include/. /usr/local/include/
-    - name: Add Clang 18 to list of Conan compilers # workaround for the issue that Conan 1.x doesn't know about Clang 18
-      if: ${{ matrix.ENABLE_CONAN == 'ON' && matrix.CCOMPILER == 'clang-18' }}
-      run: |
-        sudo wget https://github.com/mikefarah/yq/releases/download/v4.9.6/yq_linux_amd64 -O /usr/bin/yq && sudo chmod +x /usr/bin/yq
-
-        conan config init
-        yq eval '.compiler.clang.version += ["18"]' -i "$HOME/.conan/settings.yml"
-    - name: Add Apple-clang 16 to list of Conan compilers # workaround for the issue that Conan 1.x doesn't know about Apple-clang 16
-      if: ${{ matrix.ENABLE_CONAN == 'ON' && matrix.runs-on == 'macos-14' }}
-      run: |
-        sudo wget https://github.com/mikefarah/yq/releases/download/v4.9.6/yq_darwin_arm64 -O /usr/local/bin/yq && sudo chmod +x /usr/local/bin/yq
-
-        conan config init
-        yq eval '.compiler.apple-clang.version += ["16.0"]' -i "$HOME/.conan/settings.yml"
    - name: Prepare build
      run: |
        mkdir ${OSRM_BUILD_DIR}
@ -519,19 +485,23 @@ jobs:
        fi
        echo "CC=${CCOMPILER}" >> $GITHUB_ENV
        echo "CXX=${CXXCOMPILER}" >> $GITHUB_ENV
-        if [[ "${RUNNER_OS}" == "macOS" ]]; then
-          # missing from GCC path, needed for conan builds of libiconv, for example.
-          sudo xcode-select --switch /Library/Developer/CommandLineTools
-          echo "LIBRARY_PATH=${LIBRARY_PATH}:/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib" >> $GITHUB_ENV
-          echo "CPATH=${CPATH}:/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include" >> $GITHUB_ENV
-        fi

    - name: Build and install OSRM
      run: |
        echo "Using ${JOBS} jobs"
        pushd ${OSRM_BUILD_DIR}

-        ccache --zero-stats
+        # handle Apple Silicon cross compilation
+        if [[ "${ENABLE_APPLE_SILICON}" == "ON" ]]; then
+          ARCH=arm64
+          TARGET="${ARCH}-apple-darwin"
+          CFLAGS="$CFLAGS --target=$TARGET"
+          CXXFLAGS="$CXXFLAGS --target=$TARGET"
+          APPLE_SILICON_FLAGS=(-DCMAKE_C_COMPILER_TARGET="$TARGET" -DCMAKE_CXX_COMPILER_TARGET="$TARGET" -DCMAKE_SYSTEM_PROCESSOR="${ARCH}" -DCMAKE_SYSTEM_NAME="Darwin" -DCMAKE_C_FLAGS="$CFLAGS" -DCMAKE_CXX_FLAGS="$CXXFLAGS")
+        else
+          APPLE_SILICON_FLAGS=()
+        fi
+
        cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
                 -DENABLE_CONAN=${ENABLE_CONAN:-OFF} \
                 -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS:-OFF} \
@ -542,14 +512,15 @@ jobs:
                 -DENABLE_SANITIZER=${ENABLE_SANITIZER:-OFF} \
                 -DBUILD_TOOLS=${BUILD_TOOLS:-OFF} \
                 -DENABLE_CCACHE=ON \
-                 -DENABLE_LTO=${ENABLE_LTO:-ON} \
-                 -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR}
+                 -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
+                 "${APPLE_SILICON_FLAGS[@]}"
+
        make --jobs=${JOBS}

-        if [[ "${NODE_PACKAGE_TESTS_ONLY}" != "ON" ]]; then
+        if [[ "${NODE_PACKAGE_TESTS_ONLY}" != "ON" && "${ENABLE_APPLE_SILICON}" != "ON" ]]; then
          make tests --jobs=${JOBS}
          make benchmarks --jobs=${JOBS}
-
+          ccache -s
          sudo make install
          if [[ "${RUNNER_OS}" == "Linux" ]]; then
            echo "LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${OSRM_INSTALL_DIR}/lib" >> $GITHUB_ENV
@ -558,14 +529,17 @@ jobs:
        fi
        popd
    - name: Build example
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' }}
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
      run: |
        mkdir example/build && pushd example/build
        cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE}
        make --jobs=${JOBS}
        popd
+    - name: Install osrm-routed-js dependencies
+      if: ${{ matrix.node != 12 && matrix.ENABLE_APPLE_SILICON != 'ON' && matrix.TARGET_ARCH != 'i686' }}
+      run: cd routed-js && npm ci && npm link && osrm-routed-js --version
    - name: Run all tests
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' }}
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
      run: |
        make -C test/data benchmark

@ -576,66 +550,85 @@ jobs:
        # All tests assume to be run from the build directory
        pushd ${OSRM_BUILD_DIR}
        for i in ./unit_tests/*-tests ; do echo Running $i ; $i ; done
-        if [ -z "${ENABLE_SANITIZER}" ]; then
+        if [ -z "${ENABLE_SANITIZER}" ] && [ "$TARGET_ARCH" != "i686" ]; then
          npm run nodejs-tests
        fi
        popd
        npm test
+    - name: Run benchmarks
+      if: ${{ matrix.ENABLE_BENCHMARKS == 'ON' }}
+      run: |
+        pushd ${OSRM_BUILD_DIR}
+        make --jobs=${JOBS} benchmarks
+        ./src/benchmarks/alias-bench
+        ./src/benchmarks/json-render-bench ../src/benchmarks/portugal_to_korea.json
+        ./src/benchmarks/match-bench ../test/data/ch/monaco.osrm
+        ./src/benchmarks/packedvector-bench
+        ./src/benchmarks/rtree-bench ../test/data/monaco.osrm.ramIndex ../test/data/monaco.osrm.fileIndex ../test/data/monaco.osrm.nbg_nodes
+        popd

-    - name: Use Node 18
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
-      uses: actions/setup-node@v4
+    - name: Use Node 16
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
+      uses: actions/setup-node@v3
      with:
-        node-version: 18
-    - name: Run Node package tests on Node 18
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
+        node-version: 16
+    - name: Run Node package tests on Node 16
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
      run: |
        node --version
        npm run nodejs-tests
-    - name: Use Node 20
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
-      uses: actions/setup-node@v4
+    - name: Use Node 18
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
+      uses: actions/setup-node@v3
      with:
-        node-version: 20
-    - name: Run Node package tests on Node 20
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
+        node-version: 18
+    - name: Run Node package tests on Node 18
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
      run: |
        node --version
        npm run nodejs-tests
    - name: Use Node latest
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
-      uses: actions/setup-node@v4
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
+      uses: actions/setup-node@v3
      with:
        node-version: latest
    - name: Run Node package tests on Node-latest
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' && matrix.ENABLE_APPLE_SILICON != 'ON' }}
      run: |
        node --version
        npm run nodejs-tests

    - name: Upload test logs
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v3
      if: failure()
      with:
        name: logs
        path: test/logs/

-    # - name: Generate code coverage
-    #   if: ${{ matrix.ENABLE_COVERAGE == 'ON' }}
-    #   run: |
-    #     lcov --directory . --capture --output-file coverage.info # capture coverage info
-    #     lcov --remove coverage.info '/usr/*' --output-file coverage.info # filter out system
-    #     lcov --list coverage.info #debug info
-    
-    # # Uploading report to CodeCov
-    # - name: Upload code coverage
-    #   if: ${{ matrix.ENABLE_COVERAGE == 'ON' }}
-    #   uses: codecov/codecov-action@v4
-    #   with:
-    #     files: coverage.info
-    #     name: codecov-osrm-backend
-    #     fail_ci_if_error: true
-    #     verbose: true
+    - name: Generate code coverage
+      if: ${{ matrix.ENABLE_COVERAGE == 'ON' }}
+      run: |
+        lcov --directory . --capture --output-file coverage.info # capture coverage info
+        lcov --remove coverage.info '/usr/*' --output-file coverage.info # filter out system
+        lcov --list coverage.info #debug info
+        # Uploading report to CodeCov
+    - name: Upload code coverage
+      if: ${{ matrix.ENABLE_COVERAGE == 'ON' }}
+      uses: codecov/codecov-action@v1
+      with:
+        files: coverage.info
+        name: codecov-osrm-backend
+        fail_ci_if_error: true
+        verbose: true
+    - name: Check Apple Silicon binary
+      if: ${{  matrix.ENABLE_APPLE_SILICON == 'ON' }}
+      run: |
+        ARCH=$(file ./lib/binding/node_osrm.node | awk '{printf $NF}')
+        if [[ "$ARCH" != "arm64" ]]; then
+          file ./lib/binding/node_osrm.node
+          >&2 echo "Wrong architecture!"
+          exit 1
+        fi
    - name: Build Node package
      if: ${{ matrix.build_node_package }}
      run: ./scripts/ci/node_package.sh
@ -652,135 +645,9 @@ jobs:
        omitNameDuringUpdate: true
        replacesArtifacts: true
        token: ${{ secrets.GITHUB_TOKEN }}
-    - name: Show CCache statistics
-      run: |
-        ccache -p
-        ccache -s
-
-  benchmarks:
-    if: github.event_name == 'pull_request'
-    needs: [format-taginfo-docs]
-    runs-on: self-hosted
-    env:
-      CCOMPILER: clang-16
-      CXXCOMPILER: clang++-16
-      CC: clang-16
-      CXX: clang++-16
-      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      PR_NUMBER: ${{ github.event.pull_request.number }}
-      GITHUB_REPOSITORY: ${{ github.repository }}
-      RUN_BIG_BENCHMARK: ${{ contains(github.event.pull_request.labels.*.name, 'Performance') }}
-    steps: 
-      - name: Checkout PR Branch
-        uses: actions/checkout@v4
-        with:
-          ref: ${{ github.head_ref }}
-          path: pr
-      - name: Activate virtualenv
-        run: |
-          python3 -m venv .venv
-          source .venv/bin/activate
-          echo PATH=$PATH >> $GITHUB_ENV
-          pip install "conan<2.0.0" "requests==2.31.0" "numpy==1.26.4" 
-      - name: Prepare data
-        run: |
-          if [ "$RUN_BIG_BENCHMARK" = "true" ]; then
-              rm -rf ~/data.osm.pbf
-              wget http://download.geofabrik.de/europe/poland-latest.osm.pbf -O ~/data.osm.pbf --quiet
-              gunzip -c ./pr/test/data/poland_gps_traces.csv.gz > ~/gps_traces.csv
-          else
-              if [ ! -f "~/data.osm.pbf" ]; then
-                wget http://download.geofabrik.de/europe/germany/berlin-latest.osm.pbf -O ~/data.osm.pbf
-              else
-                echo "Using cached data.osm.pbf"
-              fi
-              gunzip -c ./pr/test/data/berlin_gps_traces.csv.gz > ~/gps_traces.csv
-          fi
-      - name: Prepare environment
-        run: |
-          echo "CCACHE_DIR=$HOME/.ccache" >> $GITHUB_ENV
-          mkdir -p $HOME/.ccache
-          ccache --zero-stats
-          ccache --max-size=256M
-      - name: Checkout Base Branch
-        uses: actions/checkout@v4
-        with:
-          ref: ${{ github.event.pull_request.base.ref }}
-          path: base
-      - name: Build Base Branch
-        run: |
-          cd base
-          npm ci --ignore-scripts
-          cd ..
-          mkdir base/build
-          cd base/build
-          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_NODE_BINDINGS=ON ..
-          make -j$(nproc)
-          make -j$(nproc) benchmarks
-          cd ..
-          make -C test/data 
-      - name: Build PR Branch
-        run: |
-          cd pr
-          npm ci --ignore-scripts
-          cd ..
-          mkdir -p pr/build
-          cd pr/build
-          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_NODE_BINDINGS=ON ..
-          make -j$(nproc) 
-          make -j$(nproc) benchmarks
-          cd ..
-          make -C test/data 
-      # we run benchmarks in tmpfs to avoid impact of disk IO
-      - name: Create folder for tmpfs 
-        run: |
-          # if by any chance it was mounted before(e.g. due to previous job failed), unmount it
-          sudo umount ~/benchmarks | true
-          rm -rf ~/benchmarks 
-          mkdir -p ~/benchmarks
-      # see https://llvm.org/docs/Benchmarking.html
-      - name: Run PR Benchmarks 
-        run: |
-          sudo cset shield -c 2-3 -k on
-          sudo mount -t tmpfs -o size=4g none ~/benchmarks
-          cp -rf pr/build ~/benchmarks/build
-          cp -rf pr/lib ~/benchmarks/lib
-          mkdir -p ~/benchmarks/test
-          cp -rf pr/test/data ~/benchmarks/test/data
-          cp -rf pr/profiles ~/benchmarks/profiles
-
-          sudo cset shield --exec -- ./pr/scripts/ci/run_benchmarks.sh -f ~/benchmarks -r $(pwd)/pr_results -s $(pwd)/pr -b ~/benchmarks/build -o ~/data.osm.pbf -g ~/gps_traces.csv
-          sudo umount ~/benchmarks
-          sudo cset shield --reset
-      - name: Run Base Benchmarks
-        run: |
-          sudo cset shield -c 2-3 -k on
-          sudo mount -t tmpfs -o size=4g none ~/benchmarks
-          cp -rf base/build ~/benchmarks/build
-          cp -rf base/lib ~/benchmarks/lib
-          mkdir -p ~/benchmarks/test
-          cp -rf base/test/data ~/benchmarks/test/data
-          cp -rf base/profiles ~/benchmarks/profiles
-
-          # TODO: remove it when base branch will have this file at needed location
-          if [ ! -f ~/benchmarks/test/data/portugal_to_korea.json ]; then
-            cp base/src/benchmarks/portugal_to_korea.json ~/benchmarks/test/data/portugal_to_korea.json
-          fi
-          # we intentionally use scripts from PR branch to be able to update them and see results in the same PR
-          sudo cset shield --exec -- cset shield --exec -- ./pr/scripts/ci/run_benchmarks.sh -f ~/benchmarks -r $(pwd)/base_results -s $(pwd)/pr -b ~/benchmarks/build -o ~/data.osm.pbf -g ~/gps_traces.csv
-          sudo umount ~/benchmarks
-          sudo cset shield --reset
-      - name: Post Benchmark Results
-        run: |
-          python3 pr/scripts/ci/post_benchmark_results.py base_results pr_results
-      - name: Show CCache statistics
-        run: |
-          ccache -p
-          ccache -s

  ci-complete:
    runs-on: ubuntu-22.04
-    needs: [build-test-publish, docker-image-matrix, windows-release-node, benchmarks]
+    needs: [build-test-publish, docker-image, routed-js, windows-release-node]
    steps:
    - run: echo "CI complete"
-
--- a/.github/workflows/stale.yml
+++ b/.github/workflows/stale.yml
@ -1,29 +0,0 @@
-name: 'Close stale issues'
-on:
-  # NOTE: uncomment if you want to test changes to this file in PRs CI
-  # pull_request:
-  #   branches:
-  #     - master
-  schedule:
-    - cron: '30 1 * * *' # every day at 1:30am
-permissions:
-  issues: write
-  pull-requests: write
-
-jobs:
-  stale:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/stale@v9
-        with:
-          operations-per-run: 3000
-          stale-issue-message: 'This issue seems to be stale. It will be closed in 30 days if no further activity occurs.'
-          stale-pr-message: 'This PR seems to be stale. Is it still relevant?'
-          days-before-issue-stale: 180 # 6 months
-          days-before-issue-close: 30 # 1 month
-          days-before-pr-stale: 180 # 6 months
-          days-before-pr-close: -1 # never close PRs
-          exempt-issue-labels: 'Do Not Stale,Feature Request,Performance,Bug Report,CI,Starter Task,Refactor,Guidance'
-
-  
-
--- a/.gitignore
+++ b/.gitignore
@ -46,6 +46,7 @@ Thumbs.db
 /example/build/
 /test/data/monaco.osrm*
 /test/data/ch
+/test/data/corech
 /test/data/mld
 /cmake/postinst

--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,64 +1,17 @@
 # Unreleased
  - Changes from 5.27.1
    - Features
-      - ADDED: Route pedestrians over highway=platform [#6993](https://github.com/Project-OSRM/osrm-backend/pull/6993)
-      - REMOVED: Remove all core-CH left-overs [#6920](https://github.com/Project-OSRM/osrm-backend/pull/6920)
-      - ADDED: Add support for a keepalive_timeout flag. [#6674](https://github.com/Project-OSRM/osrm-backend/pull/6674)
      - ADDED: Add support for a default_radius flag. [#6575](https://github.com/Project-OSRM/osrm-backend/pull/6575)
      - ADDED: Add support for disabling feature datasets. [#6666](https://github.com/Project-OSRM/osrm-backend/pull/6666)
-      - ADDED: Add support for opposite approach request parameter. [#6842](https://github.com/Project-OSRM/osrm-backend/pull/6842)
-      - ADDED: Add support for accessing edge flags in `process_segment` [#6658](https://github.com/Project-OSRM/osrm-backend/pull/6658)
    - Build:
-      - CHANGED: Upgrade clang-format to version 15. [#6919](https://github.com/Project-OSRM/osrm-backend/pull/6919)
-      - CHANGED: Use Debian Bookworm as base Docker image [#6904](https://github.com/Project-OSRM/osrm-backend/pull/6904)
-      - CHANGED: Upgrade CI actions to latest versions [#6893](https://github.com/Project-OSRM/osrm-backend/pull/6893)
-      - CHANGED:  Remove outdated warnings #6894 [#6894](https://github.com/Project-OSRM/osrm-backend/pull/6894)
      - ADDED: Add CI job which builds OSRM with gcc 12. [#6455](https://github.com/Project-OSRM/osrm-backend/pull/6455)
      - CHANGED: Upgrade to clang-tidy 15. [#6439](https://github.com/Project-OSRM/osrm-backend/pull/6439)
      - CHANGED: Update actions/cache to v3. [#6420](https://github.com/Project-OSRM/osrm-backend/pull/6420)
      - REMOVED: Drop support of Node 12 & 14. [#6431](https://github.com/Project-OSRM/osrm-backend/pull/6431)
      - ADDED: Add 'load directly' mode to default Cucumber test suite. [#6663](https://github.com/Project-OSRM/osrm-backend/pull/6663)
-      - CHANGED: Fix compilation for Boost 1.85.0 [#6856](https://github.com/Project-OSRM/osrm-backend/pull/6856)
-      - CHANGED: Drop support for Node 16 [#6855](https://github.com/Project-OSRM/osrm-backend/pull/6855)
-      - REMOVED: Remove unused AppVeyor files [#6860](https://github.com/Project-OSRM/osrm-backend/pull/6860)
-      - CHANGED: Upgrade clang-format to version 15 [#6859](https://github.com/Project-OSRM/osrm-backend/pull/6859)
    - NodeJS:
      - CHANGED: Use node-api instead of NAN. [#6452](https://github.com/Project-OSRM/osrm-backend/pull/6452)
    - Misc:
-      - CHANGED: Use std::string_view for key type in json::Object. [#7062](https://github.com/Project-OSRM/osrm-backend/pull/7062)
-      - CHANGED: Use thread_local instead of boost::thread_specific_ptr. [#6991](https://github.com/Project-OSRM/osrm-backend/pull/6991)
-      - CHANGED: Bump flatbuffers to v24.3.25 version. [#6988](https://github.com/Project-OSRM/osrm-backend/pull/6988)
-      - CHANGED: Add .reserve(...) to assembleGeometry function. [#6983](https://github.com/Project-OSRM/osrm-backend/pull/6983)
-      - CHANGED: Get rid of boost::optional leftovers. [#6977](https://github.com/Project-OSRM/osrm-backend/pull/6977)
-      - CHANGED: Use Link Time Optimisation whenever possible. [#6967](https://github.com/Project-OSRM/osrm-backend/pull/6967)
-      - CHANGED: Use struct instead of tuple to define UnpackedPath. [#6974](https://github.com/Project-OSRM/osrm-backend/pull/6974)
-      - CHANGED: Micro performance optimisation in map matching. [#6976](https://github.com/Project-OSRM/osrm-backend/pull/6976)
-      - CHANGED: Re-use priority queue in StaticRTree. [#6952](https://github.com/Project-OSRM/osrm-backend/pull/6952)
-      - CHANGED: Optimise encodePolyline function. [#6940](https://github.com/Project-OSRM/osrm-backend/pull/6940)
-      - CHANGED: Avoid reallocations in base64 encoding. [#6951](https://github.com/Project-OSRM/osrm-backend/pull/6951)
-      - CHANGED: Get rid of unused Boost dependencies. [#6960](https://github.com/Project-OSRM/osrm-backend/pull/6960)
-      - CHANGED: Apply micro-optimisation for Table & Trip APIs. [#6949](https://github.com/Project-OSRM/osrm-backend/pull/6949)
-      - CHANGED: Apply micro-optimisation for Route API. [#6948](https://github.com/Project-OSRM/osrm-backend/pull/6948)
-      - CHANGED: Apply micro-optimisation for Match API. [#6945](https://github.com/Project-OSRM/osrm-backend/pull/6945)
-      - CHANGED: Apply micro-optimisation for Nearest API. [#6944](https://github.com/Project-OSRM/osrm-backend/pull/6944)
-      - CHANGED: Avoid copy of intersection in totalTurnAngle. [#6938](https://github.com/Project-OSRM/osrm-backend/pull/6938)
-      - CHANGED: Use std::unordered_map::emplace instead of operator[] when producing JSONs. [#6936](https://github.com/Project-OSRM/osrm-backend/pull/6936)
-      - CHANGED: Avoid copy of vectors in MakeRoute function. [#6939](https://github.com/Project-OSRM/osrm-backend/pull/6939)
-      - FIXED: Fix bugprone-unused-return-value clang-tidy warning. [#6934](https://github.com/Project-OSRM/osrm-backend/pull/6934)
-      - FIXED: Fix performance-noexcept-move-constructor clang-tidy warning. [#6931](https://github.com/Project-OSRM/osrm-backend/pull/6933)
-      - FIXED: Fix performance-noexcept-swap clang-tidy warning. [#6931](https://github.com/Project-OSRM/osrm-backend/pull/6931)
-      - CHANGED: Use custom struct instead of std::pair in QueryHeap. [#6921](https://github.com/Project-OSRM/osrm-backend/pull/6921)
-      - CHANGED: Use std::string_view::starts_with instead of boost::starts_with. [#6918](https://github.com/Project-OSRM/osrm-backend/pull/6918)
-      - CHANGED: Get rid of boost::math::constants::* and M_PI in favor of std::numbers. [#6916](https://github.com/Project-OSRM/osrm-backend/pull/6916)
-      - CHANGED: Make constants in PackedVector constexpr. [#6917](https://github.com/Project-OSRM/osrm-backend/pull/6917)
-      - CHANGED: Use std::variant instead of mapbox::util::variant. [#6903](https://github.com/Project-OSRM/osrm-backend/pull/6903)
-      - CHANGED: Bump rapidjson to version f9d53419e912910fd8fa57d5705fa41425428c35 [#6906](https://github.com/Project-OSRM/osrm-backend/pull/6906)
-      - CHANGED: Bump mapbox/variant to version 1.2.0 [#6898](https://github.com/Project-OSRM/osrm-backend/pull/6898)
-      - CHANGED: Avoid copy of std::function-based callback in path unpacking [#6895](https://github.com/Project-OSRM/osrm-backend/pull/6895)
-      - CHANGED: Replace boost::hash by std::hash [#6892](https://github.com/Project-OSRM/osrm-backend/pull/6892)
-      - CHANGED: Partial fix migration from boost::optional to std::optional [#6551](https://github.com/Project-OSRM/osrm-backend/issues/6551)
-      - CHANGED: Replace boost::filesystem with std::filesystem [#6432](https://github.com/Project-OSRM/osrm-backend/pull/6432)
-      - CHANGED: Update Conan Boost version to 1.85.0. [#6868](https://github.com/Project-OSRM/osrm-backend/pull/6868)
      - FIXED: Fix an error in a RouteParameters AnnotationsType operator overload. [#6646](https://github.com/Project-OSRM/osrm-backend/pull/6646)
      - ADDED: Add support for "unlimited" to be passed as a value for the default-radius and max-matching-radius flags. [#6599](https://github.com/Project-OSRM/osrm-backend/pull/6599)
      - CHANGED: Allow -1.0 as unlimited for default_radius value. [#6599](https://github.com/Project-OSRM/osrm-backend/pull/6599)
@ -77,23 +30,10 @@
      - FIXED: Added a variable to preprocessor guard in file osrm-backend/include/util/range_table.hpp to solve build error. [#6596](https://github.com/Project-OSRM/osrm-backend/pull/6596)
      - FIXED: Ensure required file check in osrm-routed is correctly enforced. [#6655](https://github.com/Project-OSRM/osrm-backend/pull/6655)
      - FIXED: Correct HTTP docs to reflect summary output dependency on steps parameter. [#6655](https://github.com/Project-OSRM/osrm-backend/pull/6655)
-      - ADDED: Extract prerelease/build information from package semver [#6839](https://github.com/Project-OSRM/osrm-backend/pull/6839)
    - Profiles:
      - FIXED: Bicycle and foot profiles now don't route on proposed ways [#6615](https://github.com/Project-OSRM/osrm-backend/pull/6615)
-      - ADDED: Add optional support of cargo bike exclusion and width to bicyle profile [#7044](https://github.com/Project-OSRM/osrm-backend/pull/7044)
    - Routing:
      - FIXED: Fix adding traffic signal penalties during compression [#6419](https://github.com/Project-OSRM/osrm-backend/pull/6419)
-      - FIXED: Correctly handle compressed traffic signals. [#6724](https://github.com/Project-OSRM/osrm-backend/pull/6724)
-      - FIXED: Fix bug when searching for maneuver overrides [#6739](https://github.com/Project-OSRM/osrm-backend/pull/6739)
-      - FIXED: Remove force-loop checks for routes with u-turns [#6858](https://github.com/Project-OSRM/osrm-backend/pull/6858)
-      - FIXED: Correctly check runtime search conditions for forcing routing steps [#6866](https://github.com/Project-OSRM/osrm-backend/pull/6866)
-    - Map Matching:
-      - CHANGED: Optimise path distance calculation in MLD map matching even more. [#6884](https://github.com/Project-OSRM/osrm-backend/pull/6884)
-      - CHANGED: Optimise path distance calculation in MLD map matching. [#6876](https://github.com/Project-OSRM/osrm-backend/pull/6876)
-      - CHANGED: Optimise R-tree queries in the case of map matching. [#6881](https://github.com/Project-OSRM/osrm-backend/pull/6876)
-    - Debug tiles:
-      - FIXED: Ensure speed layer features have unique ids. [#6726](https://github.com/Project-OSRM/osrm-backend/pull/6726)
-
 # 5.27.1
  - Changes from 5.27.0
    - Misc:
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.18)

-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)

@ -31,48 +31,35 @@ option(ENABLE_ASSERTIONS "Use assertions in release mode" OFF)
 option(ENABLE_DEBUG_LOGGING "Use debug logging in release mode" OFF)
 option(ENABLE_COVERAGE "Build with coverage instrumentalisation" OFF)
 option(ENABLE_SANITIZER "Use memory sanitizer for Debug build" OFF)
-option(ENABLE_LTO "Use Link Time Optimisation" ON)
+option(ENABLE_LTO "Use LTO if available" OFF)
 option(ENABLE_FUZZING "Fuzz testing using LLVM's libFuzzer" OFF)
 option(ENABLE_NODE_BINDINGS "Build NodeJs bindings" OFF)
 option(ENABLE_CLANG_TIDY "Enables clang-tidy checks" OFF)

-
 if (ENABLE_CLANG_TIDY)
  find_program(CLANG_TIDY_COMMAND NAMES clang-tidy)
  if(NOT CLANG_TIDY_COMMAND)
    message(FATAL_ERROR "ENABLE_CLANG_TIDY is ON but clang-tidy is not found!")
  else()
    message(STATUS "Found clang-tidy at ${CLANG_TIDY_COMMAND}")
-    set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND};--warnings-as-errors=*;--header-filter=.*")
+    set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND};--warnings-as-errors=*")
  endif()
 endif()

 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")

 # be compatible with version handling before cmake 3.x
+if (POLICY CMP0048)
+  cmake_policy(SET CMP0048 OLD)
+endif()
 if (POLICY CMP0057)
  cmake_policy(SET CMP0057 NEW)
 endif()
 if (POLICY CMP0074)
  cmake_policy(SET CMP0074 NEW)
 endif()
-if (POLICY CMP0167)
-  cmake_policy(SET CMP0167 NEW)
-endif()
 project(OSRM C CXX)

-
-if(ENABLE_LTO AND (CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo))
-  include(CheckIPOSupported)
-  check_ipo_supported(RESULT LTO_SUPPORTED OUTPUT error)
-  if(LTO_SUPPORTED)
-      message(STATUS "IPO / LTO enabled")
-      set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
-  else()
-      message(FATAL_ERROR "IPO / LTO not supported: <${error}>")
-  endif()
-endif()
-
 # add @loader_path/$ORIGIN to rpath to make binaries relocatable
 if (APPLE)
  set(CMAKE_BUILD_RPATH "@loader_path")
@ -86,17 +73,14 @@ include(JSONParser)
 file(READ "package.json" packagejsonraw)
 sbeParseJson(packagejson packagejsonraw)

-# This regex is not strict enough, but the correct one is too complicated for cmake matching.
-# https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
-if (packagejson.version MATCHES "^([0-9]+)\.([0-9]+)\.([0-9]+)([-+][0-9a-zA-Z.-]+)?$")
-    set(OSRM_VERSION_MAJOR            ${CMAKE_MATCH_1})
-    set(OSRM_VERSION_MINOR            ${CMAKE_MATCH_2})
-    set(OSRM_VERSION_PATCH            ${CMAKE_MATCH_3})
-    set(OSRM_VERSION_PRERELEASE_BUILD ${CMAKE_MATCH_4})
+if (packagejson.version MATCHES "^([0-9]+)\.([0-9]+)\.([0-9]+)")
+    set(OSRM_VERSION_MAJOR ${CMAKE_MATCH_1})
+    set(OSRM_VERSION_MINOR ${CMAKE_MATCH_2})
+    set(OSRM_VERSION_PATCH ${CMAKE_MATCH_3})

-    set(OSRM_VERSION packagejson.version)
+    set(OSRM_VERSION "${OSRM_VERSION_MAJOR}.${OSRM_VERSION_MINOR}.${OSRM_VERSION_PATCH}")
 else()
-    message(FATAL_ERROR "Version from package.json cannot be parsed, expected semver compatible label, but found ${packagejson.version}")
+    message(FATAL_ERROR "Version from package.json cannot be parsed, expected semver compatible X.Y.Z, but found ${packagejson.version}")
 endif()

 if (MSVC)
@ -131,15 +115,15 @@ include(GNUInstallDirs)
 if(CMAKE_SIZEOF_VOID_P EQUAL 8)
  message(STATUS "Building on a 64 bit system")
 else()
-  message(FATAL_ERROR "Building on a 32 bit system is not supported")
+  message(STATUS "Building on a 32 bit system")
 endif()

 include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR}/include/)
 include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/include/)
-include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/generated/include/)
-include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/sol2/include)
+include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/sol2-3.3.0/include)
+include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/variant/include)

-set(BOOST_COMPONENTS date_time iostreams program_options thread unit_test_framework)
+set(BOOST_COMPONENTS date_time chrono filesystem iostreams program_options regex system thread unit_test_framework)

 configure_file(
  ${CMAKE_CURRENT_SOURCE_DIR}/include/util/version.hpp.in
@ -225,10 +209,21 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Og -ggdb")
 endif()

+if(ENABLE_LTO AND (CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo))
+  include(CheckIPOSupported)
+  check_ipo_supported(RESULT LTO_SUPPORTED OUTPUT error)
+  if(LTO_SUPPORTED)
+      message(STATUS "IPO / LTO enabled")
+      set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+  else()
+      message(WARNING "IPO / LTO not supported: <${error}>")
+  endif()
+endif()
+
 set(MAYBE_COVERAGE_LIBRARIES "")
 if (ENABLE_COVERAGE)
  if (NOT CMAKE_BUILD_TYPE MATCHES "Debug")
-    message(ERROR "ENABLE_COVERAGE=ON only makes sense with a Debug build")
+    message(ERROR "ENABLE_COVERAGE=ON only make sense with a Debug build")
  endif()
  message(STATUS "Enabling coverage")
  set(MAYBE_COVERAGE_LIBRARIES "-lgcov")
@ -272,6 +267,7 @@ elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
  add_dependency_defines(-DBOOST_LIB_DIAGNOSTIC)
  add_dependency_defines(-D_CRT_SECURE_NO_WARNINGS)
  add_dependency_defines(-DNOMINMAX) # avoid min and max macros that can break compilation
+  add_dependency_defines(-D_USE_MATH_DEFINES) #needed for M_PI with cmath.h
  add_dependency_defines(-D_WIN32_WINNT=0x0501)
  add_dependency_defines(-DXML_STATIC)
  find_library(ws2_32_LIBRARY_PATH ws2_32)
@ -296,7 +292,6 @@ include_directories(SYSTEM ${MICROTAR_INCLUDE_DIR})

 add_library(MICROTAR OBJECT "${CMAKE_CURRENT_SOURCE_DIR}/third_party/microtar/src/microtar.c")
 set_property(TARGET MICROTAR PROPERTY POSITION_INDEPENDENT_CODE ON)
-
 target_no_warning(MICROTAR unused-variable)
 target_no_warning(MICROTAR format)

@ -314,7 +309,7 @@ add_subdirectory(${FLATBUFFERS_SRC_DIR}
        ${CMAKE_CURRENT_BINARY_DIR}/flatbuffers-build
        EXCLUDE_FROM_ALL)

-set(FMT_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/fmt/include")
+set(FMT_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/fmt-9.1.0/include")
 add_compile_definitions(FMT_HEADER_ONLY)
 include_directories(SYSTEM ${FMT_INCLUDE_DIR})
        
@ -333,16 +328,22 @@ if(ENABLE_CONAN)

  include(${CMAKE_CURRENT_LIST_DIR}/cmake/conan.cmake)

-  conan_check(REQUIRED)
-
-  set(CONAN_BOOST_VERSION "1.85.0@#14265ec82b25d91305bbb3b30d3357f8")
-  set(CONAN_BZIP2_VERSION "1.0.8@#d1b2d5816f25865acf978501dff1f897")
-  set(CONAN_EXPAT_VERSION "2.6.2@#2d385d0d50eb5561006a7ff9e356656b")
-  set(CONAN_LUA_VERSION "5.4.6@#658d6089093cf01992c2737ab2e96763")
-  set(CONAN_TBB_VERSION "2021.12.0@#e56e5b44be8d690530585dd3634c0106")
+  set(CONAN_BOOST_VERSION "1.79.0#96e4902111a2e343a8ba0aa95391bb58")
+  set(CONAN_BZIP2_VERSION "1.0.8#d1b2d5816f25865acf978501dff1f897")
+  set(CONAN_EXPAT_VERSION "2.2.10#916908d4a570ad839edd25322c3268cd")
+  set(CONAN_LUA_VERSION "5.4.4#3ec62efc37cd0a5d80b9e5cb35277360")
+  set(CONAN_TBB_VERSION "2021.3.0#507ec17cbd51a84167e143b20d170eea")
  
  set(CONAN_SYSTEM_INCLUDES ON)

+  # TODO: 
+  # if we link TBB dynamically osrm-extract.exe finishes on the first access to any TBB symbol 
+  # with exit code = -1073741515, which means that program cannot load required DLL.
+  if (MSVC)
+    set(TBB_SHARED False)
+  else()
+    set(TBB_SHARED True)
+  endif()

  set(CONAN_ARGS       
    REQUIRES 
@ -355,16 +356,11 @@ if(ENABLE_CONAN)
    GENERATORS cmake_find_package json  # json generator generates a conanbuildinfo.json in the build folder so (non-CMake) projects can easily parse OSRM's dependencies
    KEEP_RPATHS
    NO_OUTPUT_DIRS
-    OPTIONS boost:without_stacktrace=True # Apple Silicon cross-compilation fails without it
+    OPTIONS boost:filesystem_version=3 # https://stackoverflow.com/questions/73392648/error-with-boost-filesystem-version-in-cmake
+            onetbb:shared=${TBB_SHARED}
+            boost:without_stacktrace=True # Apple Silicon cross-compilation fails without it
    BUILD missing
  )
-
-  # Enable revisions in the conan config
-  execute_process(COMMAND ${CONAN_CMD} config set general.revisions_enabled=1 RESULT_VARIABLE RET_CODE)
-  if(NOT "${RET_CODE}" STREQUAL "0")
-    message(FATAL_ERROR "Error setting revisions for Conan: '${RET_CODE}'")
-  endif()
-
  # explicitly say Conan to use x86 dependencies if build for x86 platforms (https://github.com/conan-io/cmake-conan/issues/141)
  if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
    conan_cmake_run("${CONAN_ARGS};ARCH;x86")
@ -384,10 +380,14 @@ if(ENABLE_CONAN)
  set(Boost_USE_STATIC_LIBS ON)
  find_package(Boost REQUIRED COMPONENTS ${BOOST_COMPONENTS})
  set(Boost_DATE_TIME_LIBRARY "${Boost_date_time_LIB_TARGETS}")
+  set(Boost_CHRONO_LIBRARY "${Boost_chrono_LIB_TARGETS}")
  set(Boost_PROGRAM_OPTIONS_LIBRARY "${Boost_program_options_LIB_TARGETS}")
+  set(Boost_FILESYSTEM_LIBRARY "${Boost_filesystem_LIB_TARGETS}")
  set(Boost_IOSTREAMS_LIBRARY "${Boost_iostreams_LIB_TARGETS}")
  set(Boost_THREAD_LIBRARY "${Boost_thread_LIB_TARGETS}")
+  set(Boost_SYSTEM_LIBRARY "${Boost_system_LIB_TARGETS}")
  set(Boost_ZLIB_LIBRARY "${Boost_zlib_LIB_TARGETS}")
+  set(Boost_REGEX_LIBRARY "${Boost_regex_LIB_TARGETS}")
  set(Boost_UNIT_TEST_FRAMEWORK_LIBRARY "${Boost_unit_test_framework_LIB_TARGETS}")
  

@ -460,17 +460,18 @@ add_dependency_includes(${ZLIB_INCLUDE_DIRS})

 add_dependency_defines(-DBOOST_SPIRIT_USE_PHOENIX_V3)
 add_dependency_defines(-DBOOST_RESULT_OF_USE_DECLTYPE)
-
-# Workaround for https://github.com/boostorg/phoenix/issues/111
-add_dependency_defines(-DBOOST_PHOENIX_STL_TUPLE_H_)
+add_dependency_defines(-DBOOST_FILESYSTEM_NO_DEPRECATED)

 add_definitions(${OSRM_DEFINES})
 include_directories(SYSTEM ${DEPENDENCIES_INCLUDE_DIRS})

 set(BOOST_BASE_LIBRARIES
   ${Boost_DATE_TIME_LIBRARY}
+   ${Boost_CHRONO_LIBRARY}
+   ${Boost_FILESYSTEM_LIBRARY}
   ${Boost_IOSTREAMS_LIBRARY}
-   ${Boost_THREAD_LIBRARY})
+   ${Boost_THREAD_LIBRARY}
+   ${Boost_SYSTEM_LIBRARY})

 set(BOOST_ENGINE_LIBRARIES
  ${Boost_ZLIB_LIBRARY}
@ -489,6 +490,7 @@ endif()

 set(EXTRACTOR_LIBRARIES
    ${BZIP2_LIBRARIES}
+    ${Boost_REGEX_LIBRARY}
    ${BOOST_BASE_LIBRARIES}
    ${CMAKE_THREAD_LIBS_INIT}
    ${EXPAT_LIBRARIES}
@ -593,6 +595,7 @@ if (BUILD_ROUTED)
  set_property(TARGET osrm-routed PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
 endif()

+file(GLOB VariantGlob third_party/variant/include/mapbox/*.hpp)
 file(GLOB FlatbuffersGlob third_party/flatbuffers/include/flatbuffers/*.h)
 file(GLOB LibraryGlob include/osrm/*.hpp)
 file(GLOB ParametersGlob include/engine/api/*_parameters.hpp)
@ -612,6 +615,7 @@ install(FILES ${ContractorHeader} DESTINATION include/osrm/contractor)
 install(FILES ${LibraryGlob} DESTINATION include/osrm)
 install(FILES ${ParametersGlob} DESTINATION include/osrm/engine/api)
 install(FILES ${ApiHeader} DESTINATION include/osrm/engine/api)
+install(FILES ${VariantGlob} DESTINATION include/mapbox)
 install(FILES ${FlatbuffersGlob} DESTINATION include/flatbuffers)
 install(TARGETS osrm-extract DESTINATION bin)
 install(TARGETS osrm-partition DESTINATION bin)
@ -635,10 +639,6 @@ install(TARGETS osrm_guidance DESTINATION lib)
 set(DefaultProfilesDir profiles)
 install(DIRECTORY ${DefaultProfilesDir} DESTINATION share/osrm)

-# Install data geojson files to /usr/local/share/osrm/data by default
-set(DefaultProfilesDir data)
-install(DIRECTORY ${DefaultProfilesDir} DESTINATION share/osrm)
-
 # Setup exporting variables for pkgconfig and subproject
 #

--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -10,7 +10,7 @@ You can add a :+1: emoji reaction to the issue if you want to express interest i

 # Developer

-We use `clang-format` version `15` to consistently format the code base. There is a helper script under `scripts/format.sh`.
+We use `clang-format` version `3.8` to consistently format the code base. There is a helper script under `scripts/format.sh`.
 The format is automatically checked by the `mason-linux-release` job of a Travis CI build.
 To save development time a local hook `.git/hooks/pre-push`
 ```
--- a/README.md
+++ b/README.md
@ -15,12 +15,12 @@ The following services are available via HTTP API, C++ library interface and Nod

 To quickly try OSRM use our [demo server](http://map.project-osrm.org) which comes with both the backend and a frontend on top.

-For a quick introduction about how the road network is represented in OpenStreetMap and how to map specific road network features have a look at [the OSM wiki on routing](https://wiki.openstreetmap.org/wiki/Routing) or [this guide about mapping for navigation](https://web.archive.org/web/20221206013651/https://labs.mapbox.com/mapping/mapping-for-navigation/).
+For a quick introduction about how the road network is represented in OpenStreetMap and how to map specific road network features have a look at [this guide about mapping for navigation](https://www.mapbox.com/mapping/mapping-for-navigation/).

 Related [Project-OSRM](https://github.com/Project-OSRM) repositories:
 - [osrm-frontend](https://github.com/Project-OSRM/osrm-frontend) - User-facing frontend with map. The demo server runs this on top of the backend
 - [osrm-text-instructions](https://github.com/Project-OSRM/osrm-text-instructions) - Text instructions from OSRM route response
- [osrm-backend-docker](https://github.com/project-osrm/osrm-backend/pkgs/container/osrm-backend) - Ready to use Docker images
+- [osrm-backend-docker](https://hub.docker.com/r/osrm/osrm-backend/) - Ready to use Docker images

 ## Documentation

--- a/appveyor.yml
+++ b/appveyor.yml
@ -0,0 +1,15 @@
+os: Visual Studio 2019
+
+# clone directory
+clone_folder: c:\projects\osrm
+
+platform: x64
+
+# no-op for the time being until someone with access to GitHub checks settings will remove integration with AppVeyor
+# https://github.com/Project-OSRM/osrm-backend/pull/6312#issuecomment-1217237055 
+build_script:
+  - EXIT 0
+
+branches:
+  only:
+    - master
--- a/build-local.bat
+++ b/build-local.bat
@ -0,0 +1,32 @@
+@ECHO OFF
+SETLOCAL
+SET EL=0
+
+ECHO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+SET PLATFORM=x64
+SET CONFIGURATION=Release
+::SET LOCAL_DEV=1
+
+FOR /F "tokens=*" %%i in ('git rev-parse --abbrev-ref HEAD') do SET APPVEYOR_REPO_BRANCH=%%i
+ECHO APPVEYOR_REPO_BRANCH^: %APPVEYOR_REPO_BRANCH%
+
+SET PATH=C:\Program Files\7-Zip;%PATH%
+
+powershell Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy Unrestricted -Force
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+CALL appveyor-build.bat
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+GOTO DONE
+
+
+:ERROR
+ECHO ~~~~~~~~~~~~~~~~~~~~~~ ERROR %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ECHO ERRORLEVEL^: %ERRORLEVEL%
+SET EL=%ERRORLEVEL%
+
+:DONE
+ECHO ~~~~~~~~~~~~~~~~~~~~~~ DONE %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+EXIT /b %EL%
--- a/cmake/conan.cmake
+++ b/cmake/conan.cmake
@ -55,7 +55,7 @@ function(_get_msvc_ide_version result)
        set(${result} 15 PARENT_SCOPE)
    elseif(NOT MSVC_VERSION VERSION_LESS 1920 AND MSVC_VERSION VERSION_LESS 1930)
        set(${result} 16 PARENT_SCOPE)
-    elseif(NOT MSVC_VERSION VERSION_LESS 1930 AND MSVC_VERSION VERSION_LESS 1950)
+    elseif(NOT MSVC_VERSION VERSION_LESS 1930 AND MSVC_VERSION VERSION_LESS 1940)
        set(${result} 17 PARENT_SCOPE)
    else()
        message(FATAL_ERROR "Conan: Unknown MSVC compiler version [${MSVC_VERSION}]")
--- a/cmake/warnings.cmake
+++ b/cmake/warnings.cmake
@ -50,7 +50,9 @@ add_warning(all)
 add_warning(extra)
 add_warning(pedantic)
 add_warning(error) # treat all warnings as errors
-if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    add_warning(strict-overflow=2)
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
    add_warning(strict-overflow=1)
 endif()
 add_warning(suggest-override)
@ -64,6 +66,7 @@ add_warning(init-self)
 add_warning(bool-compare)
 add_warning(logical-not-parentheses)
 add_warning(logical-op)
+add_warning(maybe-uninitialized)
 add_warning(misleading-indentation)
 # `no-` prefix is part of warning name(i.e. doesn't mean we are disabling it)
 add_warning(no-return-local-addr)
@ -76,13 +79,15 @@ add_warning(sizeof-array-argument)
 add_warning(switch-bool)
 add_warning(tautological-compare)
 add_warning(trampolines)
-# these warnings are not enabled by default
-# no_warning(name-of-warning)
-no_warning(deprecated-comma-subscript)
-no_warning(comma-subscript)
-no_warning(ambiguous-reversed-operator)
-no_warning(restrict)
-no_warning(free-nonheap-object)
-if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-  no_warning(stringop-overflow)
-endif()
+no_warning(c++17-extensions)
+# TODO: these warnings are not enabled by default, but we consider them as useful and good to enable in the future
+no_warning(implicit-int-conversion)
+no_warning(implicit-float-conversion)
+no_warning(unused-member-function)
+no_warning(old-style-cast)
+no_warning(non-virtual-dtor)
+no_warning(float-conversion)
+no_warning(sign-conversion)
+no_warning(shorten-64-to-32)
+no_warning(padded)
+no_warning(missing-noreturn)
--- a/cucumber.js
+++ b/cucumber.js
@ -3,5 +3,7 @@ module.exports = {
    ch: '--strict --tags ~@stress --tags ~@todo --tags ~@mld -f progress --require features/support --require features/step_definitions',
    todo: '--strict --tags @todo --require features/support --require features/step_definitions',
    all: '--strict --require features/support --require features/step_definitions',
-    mld: '--strict --tags ~@stress --tags ~@todo --tags ~@ch --require features/support --require features/step_definitions -f progress'
+    mld: '--strict --tags ~@stress --tags ~@todo --tags ~@ch --require features/support --require features/step_definitions -f progress',
+    verify_routed_js: '--strict --tags ~@skip_on_routed_js --tags ~@stress --tags ~@todo --tags ~@mld-only -f progress --require features/support --require features/step_definitions',
+    mld_routed_js: '--strict --tags ~@skip_on_routed_js --tags ~@stress --tags ~@todo --tags ~@ch --require features/support --require features/step_definitions -f progress',
 };
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@ -1 +0,0 @@
-Dockerfile-debian
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@ -0,0 +1,67 @@
+FROM debian:bullseye-slim as builder
+ARG DOCKER_TAG
+ARG BUILD_CONCURRENCY
+RUN mkdir -p /src  && mkdir -p /opt
+
+RUN apt-get update && \
+    apt-get -y --no-install-recommends install ca-certificates cmake make git gcc g++ libbz2-dev libxml2-dev wget \
+    libzip-dev libboost1.74-all-dev lua5.4 liblua5.4-dev pkg-config -o APT::Install-Suggests=0 -o APT::Install-Recommends=0
+
+RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
+    ldconfig /usr/local/lib && \
+    git clone --branch v2021.3.0 --single-branch https://github.com/oneapi-src/oneTBB.git && \
+    cd oneTBB && \
+    mkdir build && \
+    cd build && \
+    cmake -DTBB_TEST=OFF -DCMAKE_BUILD_TYPE=Release ..  && \
+    cmake --build . && \
+    cmake --install .
+
+COPY . /src
+WORKDIR /src
+
+RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
+    echo "Building OSRM ${DOCKER_TAG}" && \
+    git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
+    echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
+    mkdir -p build && \
+    cd build && \
+    BUILD_TYPE="Release" && \
+    ENABLE_ASSERTIONS="Off" && \
+    BUILD_TOOLS="Off" && \
+    case ${DOCKER_TAG} in *"-debug"*) BUILD_TYPE="Debug";; esac && \
+    case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On" && BUILD_TOOLS="On";; esac && \
+    echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} BUILD_TOOLS=${BUILD_TOOLS}" && \
+    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DBUILD_TOOLS=${BUILD_TOOLS} -DENABLE_LTO=On && \
+    make -j${NPROC} install && \
+    cd ../profiles && \
+    cp -r * /opt && \
+    strip /usr/local/bin/* && \
+    rm -rf /src
+
+
+# Multistage build to reduce image size - https://docs.docker.com/engine/userguide/eng-image/multistage-build/#use-multi-stage-builds
+# Only the content below ends up in the image, this helps remove /src from the image (which is large)
+FROM debian:bullseye-slim as runstage
+
+COPY --from=builder /usr/local /usr/local
+COPY --from=builder /opt /opt
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends libboost-program-options1.74.0 libboost-regex1.74.0 \
+        libboost-date-time1.74.0 libboost-chrono1.74.0 libboost-filesystem1.74.0 \
+        libboost-iostreams1.74.0 libboost-system1.74.0 libboost-thread1.74.0 \
+        expat liblua5.4-0 && \
+    rm -rf /var/lib/apt/lists/* && \
+# add /usr/local/lib to ldconfig to allow loading libraries from there
+    ldconfig /usr/local/lib
+
+RUN /usr/local/bin/osrm-extract --help && \
+    /usr/local/bin/osrm-routed --help && \
+    /usr/local/bin/osrm-contract --help && \
+    /usr/local/bin/osrm-partition --help && \
+    /usr/local/bin/osrm-customize --help
+
+WORKDIR /opt
+
+EXPOSE 5000
--- a/docker/Dockerfile-alpine
+++ b/docker/Dockerfile-alpine
@ -1,79 +0,0 @@
-FROM alpine:3.21.2 AS alpine-mimalloc
-
-RUN apk update && \
-    apk upgrade && \
-    apk add --no-cache \
-        boost-iostreams \
-        boost-program_options \
-        boost-thread \
-        mimalloc
-
-ENV LD_PRELOAD=/usr/lib/libmimalloc.so.2
-ENV MIMALLOC_LARGE_OS_PAGES=1
-
-
-FROM alpine-mimalloc AS builder
-ARG DOCKER_TAG
-ARG BUILD_CONCURRENCY
-
-RUN mkdir -p /src /opt && \
-    apk add --no-cache \
-    boost-dev \
-    boost-filesystem \
-    clang \
-    cmake \
-    expat-dev \
-    git \
-    libbz2 \
-    libxml2 \
-    lua5.4-dev \
-    make \
-    onetbb-dev
-
-COPY . /src
-WORKDIR /src
-
-RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
-    echo "Building OSRM ${DOCKER_TAG}" && \
-    git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
-    echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
-    mkdir -p build && \
-    cd build && \
-    BUILD_TYPE="Release" && \
-    ENABLE_ASSERTIONS="Off" && \
-    BUILD_TOOLS="Off" && \
-    case ${DOCKER_TAG} in *"-debug"*) BUILD_TYPE="Debug";; esac && \
-    case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On" && BUILD_TOOLS="On";; esac && \
-    echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} BUILD_TOOLS=${BUILD_TOOLS}" && \
-    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DBUILD_TOOLS=${BUILD_TOOLS} -DENABLE_LTO=OFF && \
-    make -j${NPROC} install && \
-    cd ../profiles && \
-    cp -r * /opt && \
-    strip /usr/local/bin/* && \
-    rm -rf /src
-
-
-# Multistage build to reduce image size - https://docs.docker.com/build/building/multi-stage/#use-multi-stage-builds
-# Only the content below ends up in the image, this helps remove /src from the image (which is large)
-FROM alpine-mimalloc AS runstage
-
-COPY --from=builder /usr/local /usr/local
-COPY --from=builder /opt /opt
-
-RUN apk add --no-cache \
-    boost-date_time \
-    expat \
-    lua5.4 \
-    onetbb && \
-    ldconfig /usr/local/lib
-
-RUN /usr/local/bin/osrm-extract --help && \
-    /usr/local/bin/osrm-routed --help && \
-    /usr/local/bin/osrm-contract --help && \
-    /usr/local/bin/osrm-partition --help && \
-    /usr/local/bin/osrm-customize --help
-
-WORKDIR /opt
-
-EXPOSE 5000
-
--- a/docker/Dockerfile-debian
+++ b/docker/Dockerfile-debian
@ -1,76 +0,0 @@
-FROM debian:bookworm-slim AS builder
-ARG DOCKER_TAG
-ARG BUILD_CONCURRENCY
-
-RUN mkdir -p /src /opt && \
-    apt-get update && \
-    apt-get -y --no-install-recommends --no-install-suggests install \
-        ca-certificates \
-        cmake \
-        g++ \
-        gcc \
-        git \
-        libboost1.81-all-dev \
-        libbz2-dev \
-        liblua5.4-dev \
-        libtbb-dev \
-        libxml2-dev \
-        libzip-dev \
-        lua5.4 \
-        make \
-        pkg-config
-
-COPY . /src
-WORKDIR /src
-
-RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
-    export CXXFLAGS="-Wno-array-bounds -Wno-uninitialized -Wno-stringop-overflow" && \
-    echo "Building OSRM ${DOCKER_TAG}" && \
-    git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
-    echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
-    mkdir -p build && \
-    cd build && \
-    BUILD_TYPE="Release" && \
-    ENABLE_ASSERTIONS="Off" && \
-    BUILD_TOOLS="Off" && \
-    case ${DOCKER_TAG} in *"-debug"*) BUILD_TYPE="Debug";; esac && \
-    case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On" && BUILD_TOOLS="On";; esac && \
-    echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} BUILD_TOOLS=${BUILD_TOOLS}" && \
-    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DBUILD_TOOLS=${BUILD_TOOLS} -DENABLE_LTO=On && \
-    make -j${NPROC} install && \
-    cd ../profiles && \
-    cp -r * /opt && \
-    strip /usr/local/bin/* && \
-    rm -rf /src
-
-
-# Multistage build to reduce image size - https://docs.docker.com/build/building/multi-stage/#use-multi-stage-builds
-# Only the content below ends up in the image, this helps remove /src from the image (which is large)
-FROM debian:bookworm-slim AS runstage
-
-COPY --from=builder /usr/local /usr/local
-COPY --from=builder /opt /opt
-
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends --no-install-suggests \
-        expat \
-        libboost-date-time1.81.0 \
-        libboost-iostreams1.81.0 \
-        libboost-program-options1.81.0 \
-        libboost-thread1.81.0 \
-        liblua5.4-0 \
-        libtbb12 && \
-    rm -rf /var/lib/apt/lists/* && \
-# Add /usr/local/lib to ldconfig to allow loading libraries from there
-    ldconfig /usr/local/lib
-
-RUN /usr/local/bin/osrm-extract --help && \
-    /usr/local/bin/osrm-routed --help && \
-    /usr/local/bin/osrm-contract --help && \
-    /usr/local/bin/osrm-partition --help && \
-    /usr/local/bin/osrm-customize --help
-
-WORKDIR /opt
-
-EXPOSE 5000
-
--- a/docker/hooks/build
+++ b/docker/hooks/build
@ -6,8 +6,4 @@
 # ensure that "COPY . /src" is referring to the repo root, not the directory
 # that contains the Dockerfile.
 # This script gets executed with a pwd of wherever the Dockerfile is.
-
-DOCKER_BUILD="docker build --build-arg BUILD_CONCURRENCY=${CONCURRENCY} --build-arg DOCKER_TAG=${DOCKER_TAG:?unset} -t ${IMAGE_NAME:?unset} -f"
-
-$DOCKER_BUILD Dockerfile ..
-$DOCKER_BUILD Dockerfile-alpine ..
+docker build --build-arg BUILD_CONCURRENCY=${CONCURRENCY:-1} --build-arg DOCKER_TAG=${DOCKER_TAG} -t $IMAGE_NAME -f Dockerfile ..
--- a/docs/http.md
+++ b/docs/http.md
@ -35,7 +35,7 @@ To pass parameters to each location some options support an array-like encoding:
 |radiuses        |`{radius};{radius}[;{radius} ...]`                      |Limits the search to given radius in meters.                                                                                                                                                               |
 |generate\_hints |`true` (default), `false`                               |Adds a Hint to the response which can be used in subsequent requests, see `hints` parameter.                                                                                                               |
 |hints           |`{hint};{hint}[;{hint} ...]`                            |Hint from previous request to derive position in street network.                                                                                                                                           |
-|approaches      |`{approach};{approach}[;{approach} ...]`                |Restrict the direction on the road network at a waypoint, relative to the input coordinate.                                                                                                                    |
+|approaches      |`{approach};{approach}[;{approach} ...]`                |Keep waypoints on curbside.                                                                                                                                                                               |
 |exclude         |`{class}[,{class}]`                                     |Additive list of classes to avoid, the order does not matter.                                                                                                                                                  |
 |snapping        |`default` (default), `any`                              |Default snapping avoids is_startpoint (see profile) edges, `any` will snap to any edge in the graph                                                                                                        |
 |skip_waypoints  |`true`, `false` (default)                               |Removes waypoints from the response. Waypoints are still calculated, but not serialized. Could be useful in case you are interested in some other part of the response and do not want to transfer waste data. |
@ -47,7 +47,7 @@ Where the elements follow the following format:
 |bearing     |`{value},{range}` `integer 0 .. 360,integer 0 .. 180`   |
 |radius      |`double >= 0` or `unlimited` (default)                  |
 |hint        |Base64 `string`                                         |
-|approach    |`curb`, `opposite` or `unrestricted` (default)          |
+|approach    |`curb` or `unrestricted` (default)                      |
 |class       |A class name determined by the profile or `none`.       |

 ```
--- a/docs/nodejs/api.md
+++ b/docs/nodejs/api.md
@ -21,7 +21,7 @@ var osrm = new OSRM('network.osrm');
 **Parameters**

 -   `options` **([Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object) \| [String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String))** Options for creating an OSRM object or string to the `.osrm` file. (optional, default `{shared_memory:true}`)
-    -   `options.algorithm` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** The algorithm to use for routing. Can be 'CH', or 'MLD'. Default is 'CH'.
+    -   `options.algorithm` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** The algorithm to use for routing. Can be 'CH', 'CoreCH' or 'MLD'. Default is 'CH'.
               Make sure you prepared the dataset with the correct toolchain.
    -   `options.shared_memory` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Connects to the persistent shared memory datastore.
               This requires you to run `osrm-datastore` prior to creating an `OSRM` object.
@ -63,7 +63,7 @@ Returns the fastest route between two or more coordinates while visiting the way
    -   `options.geometries` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** Returned route geometry format (influences overview and per step). Can also be `geojson`. (optional, default `polyline`)
    -   `options.overview` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** Add overview geometry either `full`, `simplified` according to highest zoom level it could be display on, or not at all (`false`). (optional, default `simplified`)
    -   `options.continue_straight` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Forces the route to keep going straight at waypoints and don't do a uturn even if it would be faster. Default value depends on the profile.
-    -   `options.approaches` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Restrict the direction on the road network at a waypoint, relative to the input coordinate. Can be `null` (unrestricted, default), `curb` or `opposite`.
+    -   `options.approaches` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
                         `null`/`true`/`false`
    -   `options.waypoints` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Indices to coordinates to treat as waypoints. If not supplied, all coordinates are waypoints.  Must include first and last coordinate index.
    -   `options.format` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which output format to use, either `json`, or [`flatbuffers`](https://github.com/Project-OSRM/osrm-backend/tree/master/include/engine/api/flatbuffers).
@ -101,7 +101,7 @@ Note: `coordinates` in the general options only supports a single `{longitude},{
    -   `options.generate_hints` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Whether or not adds a Hint to the response which can be used in subsequent requests. (optional, default `true`)
    -   `options.number` **[Number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)** Number of nearest segments that should be returned.
        Must be an integer greater than or equal to `1`. (optional, default `1`)
-    -   `options.approaches` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Restrict the direction on the road network at a waypoint, relative to the input coordinate. Can be `null` (unrestricted, default), `curb` or `opposite`.
+    -   `options.approaches` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
    -   `options.format` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which output format to use, either `json`, or [`flatbuffers`](https://github.com/Project-OSRM/osrm-backend/tree/master/include/engine/api/flatbuffers).
    -   `options.snapping` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
 -   `callback` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)** 
@ -141,7 +141,7 @@ Optionally returns distance table.
    -   `options.sources` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** An array of `index` elements (`0 <= integer < #coordinates`) to use
                                         location with given index as source. Default is to use all.
    -   `options.destinations` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** An array of `index` elements (`0 <= integer < #coordinates`) to use location with given index as destination. Default is to use all.
-    -   `options.approaches` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Restrict the direction on the road network at a waypoint, relative to the input coordinate.. Can be `null` (unrestricted, default), `curb` or `opposite`.
+    -   `options.approaches` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
    -   `options.fallback_speed` **[Number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Replace `null` responses in result with as-the-crow-flies estimates based on `fallback_speed`.  Value is in metres/second.
    -   `options.fallback_coordinate` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** Either `input` (default) or `snapped`.  If using a `fallback_speed`, use either the user-supplied coordinate (`input`), or the snapped coordinate (`snapped`) for calculating the as-the-crow-flies distance between two points.
    -   `options.scale_factor` **[Number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Multiply the table duration values in the table by this number for more controlled input into a route optimization solver.
@ -298,7 +298,7 @@ Right now, the following combinations are possible:
    -   `options.roundtrip` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Return route is a roundtrip. (optional, default `true`)
    -   `options.source` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** Return route starts at `any` or `first` coordinate. (optional, default `any`)
    -   `options.destination` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** Return route ends at `any` or `last` coordinate. (optional, default `any`)
-    -   `options.approaches` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Restrict the direction on the road network at a waypoint, relative to the input coordinate. Can be `null` (unrestricted, default), `curb` or `opposite`.
+    -   `options.approaches` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
    -   `options.snapping` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`. `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
 -   `callback` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)** 

--- a/example/example.cpp
+++ b/example/example.cpp
@ -57,15 +57,15 @@ int main(int argc, const char *argv[])
    // Execute routing request, this does the heavy lifting
    const auto status = osrm.Route(params, result);

-    auto &json_result = std::get<json::Object>(result);
+    auto &json_result = result.get<json::Object>();
    if (status == Status::Ok)
    {
-        auto &routes = std::get<json::Array>(json_result.values["routes"]);
+        auto &routes = json_result.values["routes"].get<json::Array>();

        // Let's just use the first route
-        auto &route = std::get<json::Object>(routes.values.at(0));
-        const auto distance = std::get<json::Number>(route.values["distance"]).value;
-        const auto duration = std::get<json::Number>(route.values["duration"]).value;
+        auto &route = routes.values.at(0).get<json::Object>();
+        const auto distance = route.values["distance"].get<json::Number>().value;
+        const auto duration = route.values["duration"].get<json::Number>().value;

        // Warn users if extract does not contain the default coordinates from above
        if (distance == 0 || duration == 0)
@ -80,8 +80,8 @@ int main(int argc, const char *argv[])
    }
    else if (status == Status::Error)
    {
-        const auto code = std::get<json::String>(json_result.values["code"]).value;
-        const auto message = std::get<json::String>(json_result.values["message"]).value;
+        const auto code = json_result.values["code"].get<json::String>().value;
+        const auto message = json_result.values["message"].get<json::String>().value;

        std::cout << "Code: " << code << "\n";
        std::cout << "Message: " << code << "\n";
--- a/scripts/ci/addresssanitizer.conf
+++ b/scripts/ci/addresssanitizer.conf
--- a/features/car/traffic_light_penalties.feature
+++ b/features/car/traffic_light_penalties.feature
@ -32,14 +32,14 @@ Feature: Car - Handle traffic lights
            | l    | traffic_signals |

        When I route I should get
-            | from | to | time   | #                             |
+            | from | to | time   | # |
            | 1    | 2  |  11.1s | no turn with no traffic light |
            | 3    | 4  |  13.1s | no turn with traffic light    |
            | g    | j  |  18.7s | turn with no traffic light    |
            | k    | n  |  20.7s | turn with traffic light       |


-    Scenario: Car - Traffic signal direction straight
+    Scenario: Car - Traffic signal direction
        Given the node map
            """
            a-1-b-2-c
@ -112,14 +112,14 @@ Feature: Car - Handle traffic lights



-    Scenario: Car - Encounters a traffic light direction
+    Scenario: Car - Encounters a traffic light
        Given the node map
            """
-              a      f      k      p
-              |      |      |      |
-            b-c-d  h-g-i  l-m-n  q-r-s
-              |      |      |      |
-              e      j      o      t
+              a      f      k
+              |      |      |
+            b-c-d  h-g-i  l-m-n
+              |      |      |
+              e      j      o

            """

@ -131,70 +131,53 @@ Feature: Car - Handle traffic lights
            | fgj   | primary |
            | lmn   | primary |
            | kmo   | primary |
-            | qrs   | primary |
-            | prt   | primary |

        And the nodes
            | node | highway         | traffic_signals:direction |
-            | g    | traffic_signals |                           |
-            | m    | traffic_signals | forward                   |
-            | r    | traffic_signals | backward                  |
+            | g    | traffic_signals | forward                   |
+            | m    | traffic_signals | backward                  |


        When I route I should get
-            # Base case
            | from | to | time   | #                             |
+            | a    | d  | 21.9s  | no turn with no traffic light |
+            | a    | e  | 22.2s  | no turn with traffic light    |
            | a    | b  | 18.7s  | turn with no traffic light    |
-            | a    | e  | 22.2s  | no turn with no traffic light |
-            | a    | d  | 21.9s  | turn with no traffic light    |
-            | e    | b  | 21.9s  | turn with no traffic light    |
-            | e    | a  | 22.2s  | no turn with no traffic light |
+            | e    | b  | 21.9s  | no turn with no traffic light |
+            | e    | a  | 22.2s  | no turn with traffic light    |
            | e    | d  | 18.7s  | turn with no traffic light    |
-            | d    | e  | 21.9s  | turn with no traffic light    |
-            | d    | b  | 11s    | no turn with no traffic light |
+            | d    | e  | 21.9s  | no turn with no traffic light |
+            | d    | b  | 11s    | no turn with traffic light    |
            | d    | a  | 18.7s  | turn with no traffic light    |
-            | b    | a  | 21.9s  | turn with no traffic light    |
-            | b    | d  | 11s    | no turn with no traffic light |
+            | b    | a  | 21.9s  | no turn with no traffic light |
+            | b    | d  | 11s    | no turn with traffic light    |
            | b    | e  | 18.7s  | turn with no traffic light    |
-            # All have traffic lights - 2s penalty
-            | f    | h  | 20.7s  | turn with traffic light       |
+
+            | f    | i  | 23.9s  | no turn with no traffic light |
            | f    | j  | 24.2s  | no turn with traffic light    |
-            | f    | i  | 23.9s  | turn with traffic light       |
-            | j    | h  | 23.9s  | turn with traffic light       |
-            | j    | f  | 24.2s  | no turn with traffic light    |
-            | j    | i  | 20.7s  | turn with traffic light       |
-            | i    | j  | 23.9s  | turn with traffic light       |
-            | i    | h  | 13s    | no turn with traffic light    |
-            | i    | f  | 20.7s  | turn with traffic light       |
-            | h    | f  | 23.9s  | turn with traffic light       |
+            | f    | h  | 20.7s  | turn with no traffic light    |
+            | j    | h  | 21.9s  | no turn with no traffic light |
+            | j    | f  | 22.2s  | no turn with traffic light    |
+            | j    | i  | 18.7s  | turn with no traffic light    |
+            | i    | j  | 21.9s  | no turn with no traffic light |
+            | i    | h  | 11s    | no turn with traffic light    |
+            | i    | f  | 18.7s  | turn with no traffic light    |
+            | h    | f  | 23.9s  | no turn with no traffic light |
            | h    | i  | 13s    | no turn with traffic light    |
-            | h    | j  | 20.7s  | turn with traffic light       |
-            # Front direction have traffic lights - 2s penalty
-            | k    | l  | 20.7s  | turn with traffic light       |
-            | k    | o  | 24.2s  | no turn with traffic light    |
-            | k    | n  | 23.9s  | turn with traffic light       |
-            | o    | l  | 21.9s  | turn with no traffic light    |
-            | o    | k  | 22.2s  | no turn with no traffic light |
-            | o    | n  | 18.7s  | turn with no traffic light    |
-            | n    | o  | 21.9s  | turn with no traffic light    |
-            | n    | l  | 11s    | no turn with no traffic light |
-            | n    | k  | 18.7s  | turn with no traffic light    |
-            | l    | k  | 23.9s  | turn with traffic light       |
-            | l    | n  | 13s    | no turn with traffic light    |
-            | l    | o  | 20.7s  | turn with traffic light       |
-            # Reverse direction have traffic lights - 2s penalty
-            | p    | q  | 18.7s  | turn with no traffic light    |
-            | p    | t  | 22.2s  | no turn with no traffic light |
-            | p    | s  | 21.9s  | turn with no traffic light    |
-            | t    | q  | 23.9s  | turn with traffic light       |
-            | t    | p  | 24.2s  | no turn with traffic light    |
-            | t    | s  | 20.7s  | turn with traffic light       |
-            | s    | t  | 23.9s  | turn with traffic light       |
-            | s    | q  | 13s    | no turn with traffic light    |
-            | s    | p  | 20.7s  | turn with traffic light       |
-            | q    | p  | 21.9s  | turn with no traffic light    |
-            | q    | s  | 11s    | no turn with no traffic light |
-            | q    | t  | 18.7s  | turn with no traffic light    |
+            | h    | j  | 20.7s  | turn with no traffic light    |
+
+            | k    | n  | 21.9s  | no turn with no traffic light |
+            | k    | o  | 22.2s  | no turn with traffic light    |
+            | k    | l  | 18.7s  | turn with no traffic light    |
+            | o    | l  | 23.9s  | no turn with no traffic light |
+            | o    | k  | 24.2s  | no turn with traffic light    |
+            | o    | n  | 20.7s  | turn with no traffic light    |
+            | n    | o  | 23.9s  | no turn with no traffic light |
+            | n    | l  | 13s    | no turn with traffic light    |
+            | n    | k  | 20.7s  | turn with no traffic light    |
+            | l    | k  | 21.9s  | no turn with no traffic light |
+            | l    | n  | 11s    | no turn with traffic light    |
+            | l    | o  | 18.7s  | turn with no traffic light    |


    Scenario: Traffic Signal Geometry
@ -360,106 +343,3 @@ Feature: Car - Handle traffic lights
          | from | to | route   | speed   | weights | time  | distances | a:datasources | a:nodes | a:speed | a:duration |  a:weight |
          | a    | c  | abc,abc | 65 km/h | 22.2,0  | 22.2s | 400m,0m   |           1:0 |  1:2:3  |   18:18 |  11.1:11.1 | 11.1:11.1 |
          | c    | a  | abc,abc | 60 km/h | 24.2,0  | 24.2s | 400m,0m   |           0:1 |  3:2:1  |   18:18 |  11.1:11.1 | 11.1:11.1 |
-
-
-    Scenario: Car - Traffic signal straight direction with edge compression
-        Given the node map
-            """
-            a-1-b - c - d-2-e
-
-            """
-
-        And the ways
-            | nodes | highway |
-            | abcde | primary |
-
-        And the nodes
-            | node | highway         | traffic_signals:direction |
-            | c    | traffic_signals | forward                   |
-
-        When I route I should get
-            | from | to | time   | weight | #                             |
-            | 1    | 2  |  35.3s | 35.3   | no turn with traffic light    |
-            | 2    | 1  |  33.3s | 33.3   | no turn with no traffic light |
-
-
-    Scenario: Car - Traffic signal turn direction with edge compression
-        Given the node map
-            """
-                        d
-                        |
-                        2
-                        |
-            a-1-b - c - f
-                        |
-                        e
-
-                        j
-                        |
-                        4
-                        |
-            g-3-h - i - k
-                        |
-                        l
-
-            """
-
-        And the ways
-            | nodes | highway |
-            | abc   | primary |
-            | cf    | primary |
-            | fd    | primary |
-            | fe    | primary |
-            | ghi   | primary |
-            | ik    | primary |
-            | kj    | primary |
-            | kl    | primary |
-
-        And the nodes
-            | node | highway         | traffic_signals:direction |
-            | k    | traffic_signals | forward                   |
-
-        When I route I should get
-            | from | to | time   | weight | #                          |
-            | 1    | 2  |  44.2s | 44.2   | turn with no traffic light |
-            | 2    | 1  |  41s   | 41     | turn with no traffic light |
-            | 3    | 4  |  46.2s | 46.2   | turn with traffic light    |
-            | 4    | 3  |  41s   | 41     | turn with no traffic light |
-
-
-    Scenario: Car - Traffic signal turn direction with turn restriction
-        Given the node map
-            """
-                        d
-                        |
-                        2
-                        |
-            a-1-b - c - f
-                        |
-                        e
-
-            """
-
-        And the ways
-            | nodes | highway |
-            | abc   | primary |
-            | cf    | primary |
-            | fd    | primary |
-            | fe    | primary |
-
-        And the nodes
-            | node | highway         | traffic_signals:direction |
-            | f    | traffic_signals | forward                   |
-
-        And the relations
-            | type        | way:from | way:to | way:via  | restriction   |
-            | restriction | abc      | fe     | cf       | no_right_turn |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction     |
-            | restriction | df       | fc     | f        | right_turn_only |
-
-        When I route I should get
-            | from | to | time   | weight | #                          |
-            | 1    | 2  |  46.2s | 46.2   | turn with traffic light    |
-            | 2    | 1  |  41s   | 41     | turn with no traffic light |
--- a/features/foot/access.feature
+++ b/features/foot/access.feature
@ -26,15 +26,7 @@ Feature: Foot - Access tags on ways
            | motorway | no     |      |       |
            | motorway | no     | yes  | x     |
            | motorway | no     | no   |       |
-            | platform |        |      | x     |
-            | platform |        | yes  | x     |
-            | platform |        | no   |       |
-            | platform | yes    |      | x     |
-            | platform | yes    | yes  | x     |
-            | platform | yes    | no   |       |
-            | platform | no     |      |       |
-            | platform | no     | yes  | x     |
-            | platform | no     | no   |       |
+

    Scenario: Foot - Overwriting implied acccess on ways
        Then routability should be
--- a/features/guidance/collapse.feature
+++ b/features/guidance/collapse.feature
@ -1061,7 +1061,7 @@ Feature: Collapse
        #    i
        #    """

-        Given the node locations
+        And the node locations
          | node |         lat |         lon |        #id |
          | a    | -33.9644254 | 151.1378673 |   33226063 |
          | b    | -33.9644373 | 151.1377172 | 1072787030 |
--- a/features/guidance/roundabout-left-sided.feature
+++ b/features/guidance/roundabout-left-sided.feature
@ -9,7 +9,7 @@ Feature: Basic Roundabout
            """

    Scenario: Roundabout exit counting for left sided driving
-        Given a grid size of 10 meters
+        And a grid size of 10 meters
        And the node map
            """
                a
@ -33,7 +33,7 @@ Feature: Basic Roundabout
           | a,h       | ab,gh,gh | depart,roundabout turn right exit-3,arrive    |

    Scenario: Mixed Entry and Exit
-        Given a grid size of 10 meters
+        And a grid size of 10 meters
        And the node map
           """
             c   a
--- a/features/lib/osrm_loader.js
+++ b/features/lib/osrm_loader.js
@ -188,11 +188,16 @@ class OSRMLoader {
            this.loader = {shutdown: (cb) => cb() };
        }
        if (this.method === 'datastore') {
-            this.loader.shutdown((err) => {
-              if (err) return callback(err);
-              this.loader = this.sharedLoader;
-              this.sharedLoader.load(inputFile, callback);
-            });
+            // shutdown only if we are switching from another loader type
+            if (this.loader !== this.sharedLoader) {
+                this.loader.shutdown((err) => {
+                    if (err) return callback(err);
+                    this.loader = this.sharedLoader;
+                    this.sharedLoader.load(inputFile, callback);
+                });
+            } else {
+                this.sharedLoader.load(inputFile, callback);
+            }
        } else if (this.method === 'directly') {
            this.loader.shutdown((err) => {
              if (err) return callback(err);
@ -201,12 +206,12 @@ class OSRMLoader {
            });
        } else if (this.method === 'mmap') {
            this.loader.shutdown((err) => {
-              if (err) return callback(err);
-              this.loader = this.mmapLoader;
-              this.mmapLoader.load(inputFile, callback);
+                if (err) return callback(err);
+                this.loader = this.mmapLoader;
+                this.mmapLoader.load(inputFile, callback);
            });
        } else {
-            callback(new Error('*** Unknown load method ' + method));
+            callback(new Error('*** Unknown load method ' + this.method));
        }
    }

--- a/features/options/contract/help.feature
+++ b/features/options/contract/help.feature
@ -0,0 +1,44 @@
+@prepare @options @help
+Feature: osrm-contract command line options: help
+
+    Scenario: osrm-contract - Help should be shown when no options are passed
+        When I try to run "osrm-contract"
+        Then stderr should be empty
+        And stdout should contain /osrm-contract(.exe)? <input.osrm> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--threads"
+        And stdout should contain "--core"
+        And stdout should contain "--segment-speed-file"
+        And it should exit with an error
+
+    Scenario: osrm-contract - Help, short
+        When I run "osrm-contract -h"
+        Then stderr should be empty
+        And stdout should contain /osrm-contract(.exe)? <input.osrm> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--threads"
+        And stdout should contain "--core"
+        And stdout should contain "--segment-speed-file"
+        And it should exit successfully
+
+    Scenario: osrm-contract - Help, long
+        When I run "osrm-contract --help"
+        Then stderr should be empty
+        And stdout should contain /osrm-contract(.exe)? <input.osrm> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--threads"
+        And stdout should contain "--core"
+        And stdout should contain "--segment-speed-file"
+        And it should exit successfully
--- a/features/options/customize/help.feature
+++ b/features/options/customize/help.feature
@ -0,0 +1,38 @@
+@contract @options @help
+Feature: osrm-customize command line options: help
+
+    Scenario: osrm-customize - Help should be shown when no options are passed
+        When I try to run "osrm-customize"
+        Then stderr should be empty
+        And stdout should contain /osrm-customize(.exe)? <input.osrm> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--threads"
+        And it should exit with an error
+
+    Scenario: osrm-customize - Help, short
+        When I run "osrm-customize -h"
+        Then stderr should be empty
+        And stdout should contain /osrm-customize(.exe)? <input.osrm> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--threads"
+        And it should exit successfully
+
+    Scenario: osrm-customize - Help, long
+        When I run "osrm-customize --help"
+        Then stderr should be empty
+        And stdout should contain /osrm-customize(.exe)? <input.osrm> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--threads"
+        And it should exit successfully
--- a/features/options/datastore/datastore.feature
+++ b/features/options/datastore/datastore.feature
@ -33,6 +33,10 @@ Feature: osrm-datastore command line options
        When I try to run "osrm-datastore {processed_file} --dataset-name cucumber/only_metric_test --only-metric"
        Then it should exit successfully

+    Scenario: osrm-datastore - Displaying help should work
+        When I try to run "osrm-datastore {processed_file} --help"
+        Then it should exit successfully
+
    Scenario: osrm-datastore - Errors on invalid path
        When I try to run "osrm-datastore invalid_path.osrm"
        Then stderr should contain "[error] Config contains invalid file paths."
--- a/features/options/extract/help.feature
+++ b/features/options/extract/help.feature
@ -0,0 +1,47 @@
+@extract @options @help
+Feature: osrm-extract command line options: help
+
+    Background:
+        Given the profile "testbot"
+
+    Scenario: osrm-extract - Help should be shown when no options are passed
+        When I run "osrm-extract"
+        Then stderr should be empty
+        And stdout should contain /osrm-extract(.exe)? <input.osm/.osm.bz2/.osm.pbf> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--profile"
+        And stdout should contain "--threads"
+        And stdout should contain "--small-component-size"
+        And it should exit successfully
+
+    Scenario: osrm-extract - Help, short
+        When I run "osrm-extract -h"
+        Then stderr should be empty
+        And stdout should contain /osrm-extract(.exe)? <input.osm/.osm.bz2/.osm.pbf> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--profile"
+        And stdout should contain "--threads"
+        And stdout should contain "--small-component-size"
+        And it should exit successfully
+
+    Scenario: osrm-extract - Help, long
+        When I run "osrm-extract --help"
+        Then stderr should be empty
+        And stdout should contain /osrm-extract(.exe)? <input.osm/.osm.bz2/.osm.pbf> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--profile"
+        And stdout should contain "--threads"
+        And stdout should contain "--small-component-size"
+        And it should exit successfully
--- a/features/options/extract/lua.feature
+++ b/features/options/extract/lua.feature
@ -154,27 +154,3 @@ Feature: osrm-extract lua ways:get_nodes()
        Then it should exit successfully
        And stdout should contain "node 42"
        And stdout should contain "way 42"
-
-    Scenario: osrm-extract flags accessible in process_segment function
-        Given the profile file
-        """
-        functions = require('testbot')
-
-        functions.process_segment = function (profile, segment)
-            print('segment forward ' .. tostring(segment.flags.forward) .. ' backward ' .. tostring(segment.flags.backward))
-        end
-
-        return functions
-        """
-
-        And the node map
-            """
-            a b
-            """
-        And the ways
-            | nodes | oneway |
-            | ab    | yes    |
-        And the data has been saved to disk
-        When I run "osrm-extract --profile {profile_file} {osm_file}"
-        Then it should exit successfully
-        And stdout should contain "segment forward true backward false"
--- a/features/options/partition/help.feature
+++ b/features/options/partition/help.feature
@ -0,0 +1,53 @@
+@partition @options @help
+Feature: osrm-partition command line options: help
+
+    Scenario: osrm-partition - Help should be shown when no options are passed
+        When I try to run "osrm-partition"
+        Then stderr should be empty
+        And stdout should contain /osrm-partition(.exe)? <input.osrm> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--threads"
+        And stdout should contain "--balance"
+        And stdout should contain "--boundary"
+        And stdout should contain "--optimizing-cuts"
+        And stdout should contain "--small-component-size"
+        And stdout should contain "--max-cell-sizes"
+        And it should exit with an error
+
+    Scenario: osrm-partition - Help, short
+        When I run "osrm-partition -h"
+        Then stderr should be empty
+        And stdout should contain /osrm-partition(.exe)? <input.osrm> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--threads"
+        And stdout should contain "--balance"
+        And stdout should contain "--boundary"
+        And stdout should contain "--optimizing-cuts"
+        And stdout should contain "--small-component-size"
+        And stdout should contain "--max-cell-sizes"
+        And it should exit successfully
+
+    Scenario: osrm-partition - Help, long
+        When I run "osrm-partition --help"
+        Then stderr should be empty
+        And stdout should contain /osrm-partition(.exe)? <input.osrm> \[options\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--threads"
+        And stdout should contain "--balance"
+        And stdout should contain "--boundary"
+        And stdout should contain "--optimizing-cuts"
+        And stdout should contain "--small-component-size"
+        And stdout should contain "--max-cell-sizes"
+        And it should exit successfully
--- a/features/options/routed/help.feature
+++ b/features/options/routed/help.feature
@ -0,0 +1,72 @@
+@routed @options @help
+Feature: osrm-routed command line options: help
+
+    Background:
+        Given the profile "testbot"
+
+    @skip_on_routed_js
+    Scenario: osrm-routed - Help should be shown when no options are passed
+        When I run "osrm-routed"
+        Then stderr should be empty
+        And stdout should contain /osrm-routed(.exe)? <base.osrm> \[<options>\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "--trial"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--ip"
+        And stdout should contain "--port"
+        And stdout should contain "--threads"
+        And stdout should contain "--shared-memory"
+        And stdout should contain "--max-viaroute-size"
+        And stdout should contain "--max-trip-size"
+        And stdout should contain "--max-table-size"
+        And stdout should contain "--max-matching-size"
+        And stdout should contain "--default-radius"
+        And it should exit successfully
+
+    @skip_on_routed_js
+    Scenario: osrm-routed - Help, short
+        When I run "osrm-routed -h"
+        Then stderr should be empty
+        And stdout should contain /osrm-routed(.exe)? <base.osrm> \[<options>\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "--trial"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--ip"
+        And stdout should contain "--port"
+        And stdout should contain "--threads"
+        And stdout should contain "--shared-memory"
+        And stdout should contain "--max-viaroute-size"
+        And stdout should contain "--max-trip-size"
+        And stdout should contain "--max-table-size"
+        And stdout should contain "--max-matching-size"
+        And stdout should contain "--default-radius"
+        And it should exit successfully
+
+
+    @skip_on_routed_js
+    Scenario: osrm-routed - Help, long
+        When I run "osrm-routed --help"
+        Then stderr should be empty
+        And stdout should contain /osrm-routed(.exe)? <base.osrm> \[<options>\]:/
+        And stdout should contain "Options:"
+        And stdout should contain "--version"
+        And stdout should contain "--help"
+        And stdout should contain "--verbosity"
+        And stdout should contain "--trial"
+        And stdout should contain "Configuration:"
+        And stdout should contain "--ip"
+        And stdout should contain "--port"
+        And stdout should contain "--threads"
+        And stdout should contain "--shared-memory"
+        And stdout should contain "--max-trip-size"
+        And stdout should contain "--max-table-size"
+        And stdout should contain "--max-table-size"
+        And stdout should contain "--max-matching-size"
+        And stdout should contain "--default-radius"
+        And it should exit successfully
--- a/features/options/routed/invalid.feature
+++ b/features/options/routed/invalid.feature
@ -4,6 +4,7 @@ Feature: osrm-routed command line options: invalid options
    Background:
        Given the profile "testbot"

+    @skip_on_routed_js
    Scenario: osrm-routed - Non-existing option
        When I try to run "osrm-routed --fly-me-to-the-moon"
        Then stdout should be empty
@ -11,6 +12,7 @@ Feature: osrm-routed command line options: invalid options
        And stderr should contain "fly-me-to-the-moon"
        And it should exit with an error

+    @skip_on_routed_js
    Scenario: osrm-routed - Missing file
        When I try to run "osrm-routed over-the-rainbow.osrm"
        Then stderr should contain "over-the-rainbow.osrm"
--- a/features/step_definitions/requests.js
+++ b/features/step_definitions/requests.js
@ -33,6 +33,11 @@ module.exports = function () {
        callback();
    });

+    this.Then(/^HTTP code should be (\d+)$/, (code, callback) => {
+        assert(this.response.statusCode, parseInt(code));
+        callback();
+    });
+
    this.Then(/^status message should be "(.*?)"$/, (message, callback) => {
        try {
            this.json = JSON.parse(this.response.body);
--- a/features/support/env.js
+++ b/features/support/env.js
@ -15,6 +15,8 @@ module.exports = function () {
        this.setDefaultTimeout(this.TIMEOUT);
        this.ROOT_PATH = process.cwd();

+        this.USE_ROUTED_JS = process.env.OSRM_USE_ROUTED_JS || false;
+
        this.TEST_PATH = path.resolve(this.ROOT_PATH, 'test');
        this.CACHE_PATH = path.resolve(this.TEST_PATH, 'cache');
        this.LOGS_PATH = path.resolve(this.TEST_PATH, 'logs');
@ -41,8 +43,8 @@ module.exports = function () {

        this.OSRM_PORT = process.env.OSRM_PORT && parseInt(process.env.OSRM_PORT) || 5000;
        this.OSRM_IP = process.env.OSRM_IP || '127.0.0.1';
-        this.OSRM_CONNECTION_RETRIES = process.env.OSRM_CONNECTION_RETRIES && parseInt(process.env.OSRM_CONNECTION_RETRIES) || 10;
-        this.OSRM_CONNECTION_EXP_BACKOFF_COEF = process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF && parseFloat(process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF) || 1.1;
+        this.OSRM_CONNECTION_RETRIES = process.env.OSRM_CONNECTION_RETRIES && parseInt(process.env.OSRM_CONNECTION_RETRIES) || 100;
+        this.OSRM_CONNECTION_EXP_BACKOFF_COEF = process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF && parseFloat(process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF) || 1.0;

        this.HOST = `http://${this.OSRM_IP}:${this.OSRM_PORT}`;

--- a/features/support/run.js
+++ b/features/support/run.js
@ -39,7 +39,11 @@ module.exports = function () {

    this.runBin = (bin, options, env, callback) => {
        let cmd = path.resolve(util.format('%s/%s%s', this.BIN_PATH, bin, this.EXE));
+        if (this.USE_ROUTED_JS && bin === 'osrm-routed') {
+            cmd = 'osrm-routed-js';
+        }
        let opts = options.split(' ').filter((x) => { return x && x.length > 0; });
+        
        let log = fs.createWriteStream(this.scenarioLogFile, {'flags': 'a'});
        log.write(util.format('*** running %s %s\n', cmd, options));
        // we need to set a large maxbuffer here because we have long running processes like osrm-routed
--- a/features/testbot/annotations.feature
+++ b/features/testbot/annotations.feature
@ -115,4 +115,4 @@ Feature: Annotations

        When I route I should get
            | from | to | route    | a:speed | a:distance            | a:duration | a:nodes |
-            | a    | c  | abc,abc  | 10:10   | 249.9876189:299.962882 | 25:30      | 1:2:3   |
+            | a    | c  | abc,abc  | 10:10   | 249.9876189:299.962882 +- 1e-7 | 25:30      | 1:2:3   |
--- a/features/testbot/approaches.feature
+++ b/features/testbot/approaches.feature
@ -38,41 +38,7 @@ Feature: Approach parameter
            | from | to | approaches        | route    |
            | s    | e  | unrestricted curb | ab,bc,bc |

-    Scenario: Start End same approach, option unrestricted for Start and opposite for End
-        Given the profile "testbot"
-        And the node map
-            """
-               s        e
-            a------b------c
-            """
-
-        And the ways
-            | nodes |
-            | ab    |
-            | bc    |
-
-        When I route I should get
-            | from | to | approaches            | route |
-            | s    | e  | unrestricted opposite | ab,bc |
-
-    Scenario: Start End same approach, option opposite for Start and curb for End
-        Given the profile "testbot"
-        And the node map
-            """
-               s        e
-            a------b------c
-            """
-
-        And the ways
-            | nodes |
-            | ab    |
-            | bc    |
-
-        When I route I should get
-            | from | to | approaches            | route    |
-            | s    | e  | opposite curb         | ab,bc,bc |
-
-    Scenario: Start End different approach, option unrestricted for Start and End
+    Scenario: Start End opposite approach, option unrestricted for Start and End
        Given the profile "testbot"
        And the node map
            """
@ -90,7 +56,7 @@ Feature: Approach parameter
            | from | to | approaches                | route |
            | s    | e  | unrestricted unrestricted | ab,bc |

-    Scenario: Start End different approach, option unrestricted for Start and curb for End
+    Scenario: Start End opposite approach, option unrestricted for Start and curb for End
        Given the profile "testbot"
        And the node map
            """
@ -108,43 +74,6 @@ Feature: Approach parameter
            | from | to | approaches        | route |
            | s    | e  | unrestricted curb | ab,bc |

-    Scenario: Start End different approach, option unrestricted for Start and opposite for End
-        Given the profile "testbot"
-        And the node map
-            """
-               s
-            a------b------c
-                        e
-            """
-
-        And the ways
-            | nodes |
-            | ab    |
-            | bc    |
-
-        When I route I should get
-            | from | to | approaches            | route    |
-            | s    | e  | unrestricted opposite | ab,bc,bc |
-
-    Scenario: Start End different approach, option curb for Start and opposite for End
-        Given the profile "testbot"
-        And the node map
-            """
-               e
-            a------b------c-----------d
-                              s
-            """
-
-        And the ways
-            | nodes |
-            | ab    |
-            | bc    |
-            | cd    |
-
-        When I route I should get
-            | from | to | approaches    | route       |
-            | s    | e  | curb opposite | cd,cd,ab,ab |
-

    ###############
    # Oneway Test #
@ -182,44 +111,10 @@ Feature: Approach parameter
            | bc    | yes    |

        When I route I should get
-            | from | to | approaches        | route |
+            | from | to | approaches        | route    |
            | s    | e  | unrestricted curb | ab,bc |

-    Scenario: Test on oneway segment, Start End same approach, option unrestricted for Start and opposite for End
-        Given the profile "testbot"
-        And the node map
-            """
-               s        e
-            a------b------c
-            """
-
-        And the ways
-            | nodes | oneway |
-            | ab    | yes    |
-            | bc    | yes    |
-
-        When I route I should get
-            | from | to | approaches            | route |
-            | s    | e  | unrestricted opposite | ab,bc |
-
-    Scenario: Test on oneway segment, Start End same approach, option opposite for Start and curb for End
-        Given the profile "testbot"
-        And the node map
-            """
-               s        e
-            a------b------c
-            """
-
-        And the ways
-            | nodes | oneway |
-            | ab    | yes    |
-            | bc    | yes    |
-
-        When I route I should get
-            | from | to | approaches    | route |
-            | s    | e  | opposite curb | ab,bc |
-
-    Scenario: Test on oneway segment, Start End different approach, option unrestricted for Start and End
+    Scenario: Test on oneway segment, Start End opposite approach, option unrestricted for Start and End
        Given the profile "testbot"
        And the node map
            """
@ -237,7 +132,7 @@ Feature: Approach parameter
            | from | to | approaches                | route |
            | s    | e  | unrestricted unrestricted | ab,bc |

-    Scenario: Test on oneway segment, Start End different approach, option unrestricted for Start and curb for End
+    Scenario: Test on oneway segment, Start End opposite approach, option unrestricted for Start and curb for End
        Given the profile "testbot"
        And the node map
            """
@ -255,42 +150,6 @@ Feature: Approach parameter
            | from | to | approaches        | route |
            | s    | e  | unrestricted curb | ab,bc |

-    Scenario: Test on oneway segment, Start End different approach, option unrestricted for Start and opposite for End
-        Given the profile "testbot"
-        And the node map
-            """
-               s
-            a------b------c
-                        e
-            """
-
-        And the ways
-            | nodes | oneway |
-            | ab    | yes    |
-            | bc    | yes    |
-
-        When I route I should get
-            | from | to | approaches            | route |
-            | s    | e  | unrestricted opposite | ab,bc |
-
-    Scenario: Test on oneway segment, Start End different approach, option curb for Start and opposite for End
-        Given the profile "testbot"
-        And the node map
-            """
-               s
-            a------b------c
-                        e
-            """
-
-        And the ways
-            | nodes | oneway |
-            | ab    | yes    |
-            | bc    | yes    |
-
-        When I route I should get
-            | from | to | approaches    | route |
-            | s    | e  | curb opposite | ab,bc |
-
    ##############
    # UTurn Test #
    ##############
@ -316,27 +175,6 @@ Feature: Approach parameter
            | from | to | approaches        | route |
            | s    | e  | unrestricted curb |       |

-    Scenario: UTurn test, router can find a route because uturn authorized to reach opposite side
-        Given the profile "testbot"
-        And the node map
-            """
-               e        s
-            a------b------c
-            """
-
-        And the ways
-            | nodes |
-            | ab    |
-            | bc    |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction |
-            | restriction | bc       | bc     | c        | no_u_turn   |
-
-        When I route I should get
-            | from | to | approaches    | route     |
-            | s    | e  | curb opposite | bc,ab,ab  |
-

    Scenario: UTurn test, router can find a route because he can use the roundabout
        Given the profile "testbot"
@ -360,9 +198,8 @@ Feature: Approach parameter
            | restriction | bc       | bc     | c        | no_u_turn   |

        When I route I should get
-            | from | to | approaches         | route    |
-            | s    | e  | unrestricted curb  | ab,bc,bc |
-            | s    | e  | opposite curb      | ab,bc,bc |
+            | from | to | approaches        | route    |
+            | s    | e  | unrestricted curb | ab,bc,bc |


    Scenario: Start End same approach, option unrestricted for Start and curb for End, left-hand driving
@ -391,32 +228,6 @@ Feature: Approach parameter
            | from | to | approaches        | route |
            | s    | e  | unrestricted curb | ab,bc |

-    Scenario: Start End same approach, option unrestricted for Start and opposite for End, left-hand driving
-        Given the profile file
-        """
-        local functions = require('testbot')
-        local testbot_process_way = functions.process_way
-        functions.process_way = function(profile, way, result)
-          testbot_process_way(profile, way, result)
-          result.is_left_hand_driving = true
-        end
-        return functions
-        """
-        And the node map
-            """
-               s        e
-            a------b------c
-            """
-
-        And the ways
-            | nodes |
-            | ab    |
-            | bc    |
-
-        When I route I should get
-            | from | to | approaches            | route    |
-            | s    | e  | unrestricted opposite | ab,bc,bc |
-

    #######################
    # Left-side countries #
@ -449,8 +260,9 @@ Feature: Approach parameter
        """
        And the node map
            """
-               s       e
+               s
            a------b------c
+                       e
            """

        And the ways
@ -459,50 +271,10 @@ Feature: Approach parameter
            | bc    |

        When I route I should get
-            | from | to | approaches        | route |
-            | s    | e  | unrestricted curb | ab,bc |
+            | from | to | approaches        | route    |
+            | s    | e  | unrestricted curb | ab,bc,bc |

-    Scenario: [Left-hand-side] Start End same approach, option unrestricted for Start and opposite for End
-        Given the profile file "car" initialized with
-        """
-        profile.properties.left_hand_driving = true
-        """
-        And the node map
-            """
-               s       e
-            a------b------c
-            """
-
-        And the ways
-            | nodes |
-            | ab    |
-            | bc    |
-
-        When I route I should get
-            | from | to | approaches             | route    |
-            | s    | e  | unrestricted opposite  | ab,bc,bc |
-
-    Scenario: [Left-hand-side] Start End same approach, option opposite for Start and curb for End
-        Given the profile file "car" initialized with
-        """
-        profile.properties.left_hand_driving = true
-        """
-        And the node map
-            """
-               e      s
-            a------b------c
-            """
-
-        And the ways
-            | nodes |
-            | ab    |
-            | bc    |
-
-        When I route I should get
-            | from | to | approaches     | route    |
-            | s    | e  | opposite curb  | bc,ab,ab |
-
-    Scenario: [Left-hand-side] Start End different approach, option unrestricted for Start and End
+    Scenario: [Left-hand-side] Start End opposite approach, option unrestricted for Start and End
        Given the profile file "car" initialized with
        """
        profile.properties.left_hand_driving = true
@ -523,16 +295,15 @@ Feature: Approach parameter
            | from | to | approaches                | route |
            | s    | e  | unrestricted unrestricted | ab,bc |

-    Scenario: [Left-hand-side] Start End different approach, option unrestricted for Start and curb for End
+    Scenario: [Left-hand-side] Start End opposite approach, option unrestricted for Start and curb for End
        Given the profile file "car" initialized with
        """
        profile.properties.left_hand_driving = true
        """
        And the node map
            """
-               s
+               s      e
            a------b------c
-                      e
            """

        And the ways
@ -541,122 +312,5 @@ Feature: Approach parameter
            | bc    |

        When I route I should get
-            | from | to | approaches        | route    |
-            | s    | e  | unrestricted curb | ab,bc,bc |
-
-    Scenario: [Left-hand-side] Start End different approach, option unrestricted for Start and opposite for End
-        Given the profile file "car" initialized with
-        """
-        profile.properties.left_hand_driving = true
-        """
-        And the node map
-            """
-               s
-            a------b------c
-                      e
-            """
-
-        And the ways
-            | nodes |
-            | ab    |
-            | bc    |
-
-        When I route I should get
-            | from | to | approaches            | route |
-            | s    | e  | unrestricted opposite | ab,bc |
-
-    Scenario: [Left-hand-side] Start End different approach, option curb for Start and opposite for End
-        Given the profile file "car" initialized with
-        """
-        profile.properties.left_hand_driving = true
-        """
-        And the node map
-            """
-               s
-            a------b------c
-                      e
-            """
-
-        And the ways
-            | nodes |
-            | ab    |
-            | bc    |
-
-        When I route I should get
-            | from | to | approaches       | route |
-            | s    | e  | curb opposite    | ab,bc |
-
-
-
-    Scenario: Routes with more than two waypoints - uturns allowed
-        Given the profile "testbot"
-        And the node map
-            """
-               2                 1
-            a------b------c-----------d
-                   |
-               3   |             4
-            e------f------g-----------h
-            |
-            |
-            i
-
-            """
-
-        And the ways
-            | nodes |
-            | ab    |
-            | bc    |
-            | cd    |
-            | bf    |
-            | ef    |
-            | fg    |
-            | gh    |
-            | ei    |
-
-        And the query options
-            | continue_straight | false |
-
-        When I route I should get
-            | waypoints | approaches                                  | locations             | #                                                   |
-            | 1,2,3,4   | curb curb curb curb                         | _,_,_,a,b,f,_,_,i,h,_ | 1,2,2,a,b,f,3,3,i,h,4 (Only u-turn at end of roads) |
-            | 1,2,3,4   | curb unrestricted unrestricted curb         | _,_,_,b,f,_,_,h,_     | 1,2,2,b,f,3,3,h,4     (Can u-turn at 2 and 3)       |
-            | 1,2,3,4   | opposite opposite opposite opposite         | _,d,a,_,_,b,f,i,_,_,_ | 1,d,a,2,2,b,f,i,3,3,4 (Only u-turn at end of roads) |
-            | 1,2,3,4   | opposite unrestricted unrestricted opposite | _,d,_,_,b,f,_,_,_     | 1,d,2,2,b,f,3,3,4     (Can u-turn at 2 and 3)       |
-
-
-    Scenario: Routes with more than two waypoints - uturns forbidden
-        Given the profile "testbot"
-        And the node map
-            """
-               2                 1
-            a------b------c-----------d
-                   |
-               3   |             4
-            e------f------g-----------h
-            |
-            |
-            i
-
-            """
-
-        And the ways
-            | nodes |
-            | ab    |
-            | bc    |
-            | cd    |
-            | bf    |
-            | ef    |
-            | fg    |
-            | gh    |
-            | ei    |
-
-        And the query options
-            | continue_straight | true |
-
-        When I route I should get
-            | waypoints | approaches                                  |  locations            | #                                                   |
-            | 1,2,3,4   | curb curb curb curb                         | _,_,_,a,b,f,_,_,i,h,_ | 1,2,2,a,b,f,3,3,i,h,4 (Only u-turn at end of roads) |
-            | 1,2,3,4   | curb opposite opposite curb                 | _,a,_,_,b,f,i,_,_,h,_ | 1,a,2,2,b,f,i,3,3,h,4 (switches stops with u-turns) |
-            | 1,2,3,4   | opposite opposite opposite opposite         | _,d,a,_,_,b,f,i,_,_,_ | 1,d,a,2,2,b,f,i,3,3,4 (Only u-turn at end of roads) |
-            | 1,2,3,4   | opposite curb curb opposite                 | _,d,_,_,a,b,f,_,_,i,_ | 1,d,2,2,a,b,f,3,3,i,4 (switches stops with u-turns) |
+            | from | to | approaches        | route |
+            | s    | e  | unrestricted curb | ab,bc |
--- a/features/testbot/exclude.feature
+++ b/features/testbot/exclude.feature
@ -80,7 +80,7 @@ Feature: Testbot - Exclude flags
            | a    | c  |          |
            | a    | f  |          |
            | f    | d  | fg,gd,gd |
-
+    @skip_on_routed_js
    Scenario: Testbot - exclude with unsupported exclude combination
        Given the query options
            | exclude | TwoWords2 |
@ -88,7 +88,7 @@ Feature: Testbot - Exclude flags
        When I route I should get
            | from | to | status | message   |
            | a    | d  | 400    | Exclude flag combination is not supported. |
-
+    @skip_on_routed_js
    Scenario: Testbot - exclude with invalid exclude class name
        Given the query options
            | exclude | foo |
--- a/features/testbot/force_step.feature
+++ b/features/testbot/force_step.feature
@ -1,101 +0,0 @@
-@routing @testbot @via
-Feature: Force routing steps
-    Background:
-        Given the profile "testbot"
-
-    Scenario: Direct routes with waypoints on same edge
-        Given the node map
-            """
-              1   2
-            a-------b
-            |       |
-            d-------c
-            |       |
-            e-------f
-              3   4
-            """
-
-        And the ways
-            | nodes | oneway |
-            | ab    | no     |
-            | ad    | no     |
-            | bc    | no     |
-            | cf    | no     |
-            | dc    | no     |
-            | de    | no     |
-            | ef    | yes    |
-
-        When I route I should get
-            | waypoints | approaches        | weight | route          |
-            | 1,2       |                   | 20     | ab,ab          |
-            | 1,2       | curb curb         | 100    | ab,ad,dc,bc,ab |
-            | 2,1       |                   | 20     | ab,ab          |
-            | 2,1       | opposite opposite | 100    | ab,bc,dc,ad,ab |
-            | 3,4       |                   | 20     | ef,ef          |
-            | 4,3       |                   | 100    | ef,cf,dc,de,ef |
-
-    Scenario: Via routes with waypoints on same edge
-        Given the node map
-            """
-              1   2
-            a-------b
-            |       |
-            d-5-----c
-            |       |
-            e-------f
-              3   4
-            """
-
-        And the ways
-            | nodes | oneway |
-            | ab    | no     |
-            | ad    | no     |
-            | bc    | no     |
-            | cf    | no     |
-            | dc    | no     |
-            | de    | no     |
-            | ef    | yes    |
-
-        When I route I should get
-            | waypoints | approaches                     | weight | route                      |
-            | 5,1,2     |                                | 59.8   | dc,ad,ab,ab,ab             |
-            | 5,1,2     | unrestricted curb curb         | 180.2  | dc,bc,ab,ab,ab,ad,dc,bc,ab |
-            | 5,2,1     |                                | 80.2   | dc,bc,ab,ab,ab             |
-            | 5,2,1     | unrestricted opposite opposite | 159.8  | dc,ad,ab,ab,ab,bc,dc,ad,ab |
-            | 5,3,4     |                                | 59.8   | dc,de,ef,ef,ef             |
-            | 5,4,3     |                                | 159.8  | dc,de,ef,ef,ef,cf,dc,de,ef |
-
-
-    Scenario: [U-turns allowed] Via routes with waypoints on same edge
-        Given the node map
-            """
-              1   2
-            a-------b
-            |       |
-            d-5-----c
-            |       |
-            e-------f
-              3   4
-            """
-
-        And the ways
-            | nodes | oneway |
-            | ab    | no     |
-            | ad    | no     |
-            | bc    | no     |
-            | cf    | no     |
-            | dc    | no     |
-            | de    | no     |
-            | ef    | yes    |
-
-        And the query options
-            | continue_straight | false |
-
-        When I route I should get
-            | waypoints | approaches                     | weight | route                      |
-            | 5,1,2     |                                | 59.8   | dc,ad,ab,ab,ab             |
-            | 5,1,2     | unrestricted curb curb         | 180.2  | dc,bc,ab,ab,ab,ad,dc,bc,ab |
-            | 5,2,1     |                                | 79.8   | dc,ad,ab,ab,ab,ab          |
-            | 5,2,1     | unrestricted opposite opposite | 159.8  | dc,ad,ab,ab,ab,bc,dc,ad,ab |
-            | 5,3,4     |                                | 59.8   | dc,de,ef,ef,ef             |
-            | 5,4,3     |                                | 159.8  | dc,de,ef,ef,ef,cf,dc,de,ef |
--- a/features/testbot/load.feature
+++ b/features/testbot/load.feature
@ -32,6 +32,7 @@ Feature: Ways of loading data
        Then stderr should be empty
        And it should exit successfully

+    @skip_on_routed_js
    Scenario: osrm-datastore - Fail if no shared memory blocks are loaded
        When I run "osrm-datastore --spring-clean" with input "Y"
        And I try to run "osrm-routed --shared-memory=1"
--- a/features/testbot/loop.feature
+++ b/features/testbot/loop.feature
@ -75,7 +75,7 @@ Feature: Avoid weird loops caused by rounding errors

    @412 @via
    Scenario: Avoid weird loops 3
-        Given the node map
+        And the node map
            """
            a
            b e
--- a/features/testbot/matching.feature
+++ b/features/testbot/matching.feature
@ -136,6 +136,22 @@ Feature: Basic Map Matching
            | trace | matchings |
            | abcbd | abbd      |

+    Scenario: Testbot - Map matching with core factor
+        Given the contract extra arguments "--core 0.8"
+        Given the node map
+            """
+            a b c d
+                e
+            """
+
+        And the ways
+            | nodes | oneway |
+            | abcd  | no     |
+
+        When I match I should get
+            | trace | timestamps | matchings |
+            | abcd  | 0 1 2 3    | abcd      |
+
    Scenario: Testbot - Map matching with small distortion
        Given the node map
            """
@ -547,6 +563,7 @@ Feature: Basic Map Matching
            | trace | timestamps | code     |
            | abcd  | 0 1 62 63  | NoMatch  |

+    @skip_on_routed_js
    Scenario: Testbot - Map matching invalid waypoints
        Given the node map
            """
@ -564,6 +581,7 @@ Feature: Basic Map Matching
            | trace | code           |
            | abcd  | InvalidOptions |

+    @skip_on_routed_js
    Scenario: Matching fail with waypoints param missing start/end
        Given the node map
            """
@ -772,7 +790,7 @@ Feature: Basic Map Matching
          | 1234  | 1.000135,1,1.000225,1,1.000404,1,1.000449,1 | 1:2:0.4    | 1:2:0.4  | 3.4      |
          | 4321  | 1.000449,1,1.000404,1,1.000225,1,1.000135,1 | 0.4:2:1    | 0.4:2:1  | 3.4      |

-    @match @testbot
+    @match @testbot @skip_on_routed_js
    Scenario: Regression test - add source phantom properly (two phantoms on one edge)
        Given the profile "testbot"
        Given a grid size of 10 meters
--- a/features/testbot/snap_intersection.feature
+++ b/features/testbot/snap_intersection.feature
@ -401,12 +401,12 @@ Feature: Snapping at intersections
        Given the extract extra arguments "--small-component-size=4"

        And the ways
-            | nodes | oneway | # comment  |
-            | ab    | no     |            |
-            | bc    | no     |            |
-            | cd    | no     |            |
-            | fed   | no     |            |
-            | bg    | yes    | small SCC  |
+            | nodes | oneway |
+            | ab    | no     |
+            | bc    | no     |
+            | cd    | no     |
+            | fed   | no     |
+            | bg    | yes    | # small SCC

        And the relations
            | type        | way:from | way:to | node:via | restriction   |
@ -437,14 +437,14 @@ Feature: Snapping at intersections
        Given the extract extra arguments "--small-component-size=4"

        And the ways
-            | nodes | oneway | # comment |
-            | ab    | no     |           |
-            | bc    | no     |           |
-            | cd    | no     |           |
-            | fed   | no     |           |
-            | ghi   | no     |           |
-            | jkl   | no     |           |
-            | bm    | yes    | small SCC |
+            | nodes | oneway |
+            | ab    | no     |
+            | bc    | no     |
+            | cd    | no     |
+            | fed   | no     |
+            | ghi   | no     |
+            | jkl   | no     |
+            | bm    | yes    | # small SCC

        And the relations
            | type        | way:from | way:to | node:via | restriction   |
@ -570,7 +570,8 @@ Feature: Snapping at intersections
            | a,f,k     | ac,cf,cf,fj,kj,kj     | 132.8s | 132.8  |
            | k,f       | ik,fi,fi              | 54.3s  | 54.3   |
            | f,a       | ef,ae,ae              | 66.6s  | 66.6   |
-            | k,f,a     | kj,fj,fj,ef,ae,ae     | 141.4s | 141.4  |
+            | k,f,a     | kj,fj,fj,ef,ae,ae     | 141.4s +- 1e-7 | 141.4 +- 1e-7  |
+

        When I request a travel time matrix I should get
            |   |  a    |   f  |     k |
@ -626,4 +627,4 @@ Feature: Snapping at intersections
            | a,f,k     | ad,df,df,fj,kj,kj    | 105.6s | 105.6  |
            | k,f       | ik,fi,fi             | 54.3s  | 54.3   |
            | f,a       | ef,ae,ae             | 66.6s  | 66.6   |
-            | k,f,a     | ik,fi,fi,ef,ae,ae    | 120.9s | 120.9  |
+            | k,f,a     | ik,fi,fi,ef,ae,ae    | 120.9s +- 1e-7 | 120.9 +- 1e-7  |
--- a/features/testbot/status.feature
+++ b/features/testbot/status.feature
@ -18,7 +18,7 @@ Feature: Status messages
            | from | to | route | status | message                    |
            | a    | b  | ab,ab | 200    |                            |
            | b    | a  | ab,ab | 200    |                            |
-
+    @skip_on_routed_js
    Scenario: No route found
        Given the node map
            """
@ -39,6 +39,7 @@ Feature: Status messages
            | a    | c  |       | 400    | Impossible route between points  |
            | b    | d  |       | 400    | Impossible route between points  |

+    @skip_on_routed_js
    Scenario: Malformed requests
        Given the node locations
            | node | lat  | lon  |
--- a/features/testbot/trip.feature
+++ b/features/testbot/trip.feature
@ -5,6 +5,7 @@ Feature: Basic trip planning
        Given the profile "testbot"
        Given a grid size of 10 meters
    
+    @skip_on_routed_js
    Scenario: Testbot - Trip: Invalid options (like was in test suite for a long time)
        Given the node map
            """
@ -222,7 +223,7 @@ Feature: Basic trip planning
            | waypoints               | trips         | roundtrip | durations |
            | a,b,c,d,e,f,g,h,i,j,k,l | lkjihgfedcbal | true      | 22        |
            | a,b,c,d,e,f,g,h,i,j,k,l | cbakjihgfedl  | false     | 19        |
-
+    @skip_on_routed_js
    Scenario: Testbot - Trip: Unroutable roundtrip with waypoints (less than 10)
        Given the node map
            """
@ -240,7 +241,7 @@ Feature: Basic trip planning
            |  waypoints    | status         | message                                       |
            |  a,b,c,d      | NoTrips        | No trip visiting all destinations possible.  |

-
+    @skip_on_routed_js
    Scenario: Testbot - Trip: Unroutable roundtrip with waypoints (more than 10)
        Given the node map
            """
@ -278,6 +279,7 @@ Feature: Basic trip planning
            | a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p | NoTrips        | No trip visiting all destinations possible.  |

 # Test TFSE
+    @skip_on_routed_js
    Scenario: Testbot - Trip: TFSE with errors
        Given the node map
            """
@ -371,7 +373,7 @@ Feature: Basic trip planning
            |  waypoints  | source | destination | roundtrip | trips   |
            |  a,b,d,e,c  | first  | last        | true      | abedca  |

-
+    @skip_on_routed_js
    Scenario: Testbot - Trip: midway points in isolated roads should return no trips
        Given the node map
            """
--- a/features/testbot/via.feature
+++ b/features/testbot/via.feature
@ -65,6 +65,32 @@ Feature: Via points
            | waypoints | route          | turns                                                      |
            | 1,2,3     | cd,ac,ab,bd,cd | depart,new name right,new name right,new name right,arrive |

+    Scenario: Simple via point with core factor
+        Given the contract extra arguments "--core 0.8"
+        Given the node map
+            """
+            a b c d
+              e f g
+                h i
+                  j
+            """
+
+        And the ways
+            | nodes |
+            | abcd  |
+            | efg   |
+            | hi    |
+            | be    |
+            | cfh   |
+            | dgij  |
+
+        When I route I should get
+            | waypoints | route               |
+            | a,b,c     | abcd,abcd,abcd,abcd |
+            | c,b,a     | abcd,abcd,abcd,abcd |
+            | a,d,j     | abcd,abcd,dgij,dgij |
+            | j,d,a     | dgij,dgij,abcd,abcd |
+
    Scenario: Via point at a dead end
        Given the node map
            """
--- a/features/testbot/weight.feature
+++ b/features/testbot/weight.feature
@ -52,11 +52,11 @@ Feature: Weight tests
            | abc   |

        When I route I should get
-            | waypoints | route   | distances | weights | times   | a:distance                | a:duration | a:weight | a:speed |
-            | s,t       | abc,abc | 20m,0m    | 2,0     | 2s,0s   | 20.03462663              | 2          | 2        | 10      |
-            | t,s       | abc,abc | 20m,0m    | 2,0     | 2s,0s   | 20.03462663              | 2          | 2        | 10      |
-            | s,e       | abc,abc | 40m,0m    | 3.9,0   | 3.9s,0s | 29.94063646:10.01731331 | 3:0.9      | 3:0.9    | 10:11.1  |
-            | e,s       | abc,abc | 40m,0m    | 3.9,0   | 3.9s,0s | 10.01731331:29.94063646 | 0.9:3      | 0.9:3    | 11.1:10  |
+            | waypoints | route   | distances | weights | times   | a:distance                       | a:duration | a:weight | a:speed |
+            | s,t       | abc,abc | 20m,0m    | 2,0     | 2s,0s   | 20.03462663 +- 1e-7              | 2          | 2        | 10      |
+            | t,s       | abc,abc | 20m,0m    | 2,0     | 2s,0s   | 20.03462663 +- 1e-7              | 2          | 2        | 10      |
+            | s,e       | abc,abc | 40m,0m    | 3.9,0   | 3.9s,0s | 29.94063646:10.01731331 +- 1e-7  | 3:0.9      | 3:0.9    | 10:11.1  |
+            | e,s       | abc,abc | 40m,0m    | 3.9,0   | 3.9s,0s | 10.01731331:29.94063646 +- 1e-7  | 0.9:3      | 0.9:3    | 11.1:10  |


    Scenario: Step weights -- way_function: fail if no weight or weight_per_meter property
--- a/features/tile/tile.feature
+++ b/features/tile/tile.feature
@ -0,0 +1,14 @@
+Feature: Tile service
+    Background:
+        Given the profile "testbot"
+    Scenario: Smoke test
+        Given the origin 52.5212,13.3919
+        Given the node map
+            """
+            a b
+            """
+        And the ways
+            | nodes |
+            | ab    |
+        When I request /tile/v1/testbot/tile(8800,5373,14).mvt
+        Then HTTP code should be 200
--- a/generated/include/engine/api/flatbuffers/fbresult_generated.h
+++ b/generated/include/engine/api/flatbuffers/fbresult_generated.h
@ -1,249 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-
-#ifndef FLATBUFFERS_GENERATED_FBRESULT_OSRM_ENGINE_API_FBRESULT_H_
-#define FLATBUFFERS_GENERATED_FBRESULT_OSRM_ENGINE_API_FBRESULT_H_
-
-#include "flatbuffers/flatbuffers.h"
-
-// Ensure the included flatbuffers.h is the same version as when this file was
-// generated, otherwise it may not be compatible.
-static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
-              FLATBUFFERS_VERSION_MINOR == 3 &&
-              FLATBUFFERS_VERSION_REVISION == 25,
-             "Non-compatible flatbuffers version included");
-
-#include "route_generated.h"
-#include "table_generated.h"
-
-namespace osrm {
-namespace engine {
-namespace api {
-namespace fbresult {
-
-struct Error;
-struct ErrorBuilder;
-
-struct FBResult;
-struct FBResultBuilder;
-
-struct Error FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef ErrorBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_CODE = 4,
-    VT_MESSAGE = 6
-  };
-  const ::flatbuffers::String *code() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_CODE);
-  }
-  const ::flatbuffers::String *message() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_MESSAGE);
-  }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyOffset(verifier, VT_CODE) &&
-           verifier.VerifyString(code()) &&
-           VerifyOffset(verifier, VT_MESSAGE) &&
-           verifier.VerifyString(message()) &&
-           verifier.EndTable();
-  }
-};
-
-struct ErrorBuilder {
-  typedef Error Table;
-  ::flatbuffers::FlatBufferBuilder &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_code(::flatbuffers::Offset<::flatbuffers::String> code) {
-    fbb_.AddOffset(Error::VT_CODE, code);
-  }
-  void add_message(::flatbuffers::Offset<::flatbuffers::String> message) {
-    fbb_.AddOffset(Error::VT_MESSAGE, message);
-  }
-  explicit ErrorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<Error> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<Error>(end);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<Error> CreateError(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    ::flatbuffers::Offset<::flatbuffers::String> code = 0,
-    ::flatbuffers::Offset<::flatbuffers::String> message = 0) {
-  ErrorBuilder builder_(_fbb);
-  builder_.add_message(message);
-  builder_.add_code(code);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<Error> CreateErrorDirect(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    const char *code = nullptr,
-    const char *message = nullptr) {
-  auto code__ = code ? _fbb.CreateString(code) : 0;
-  auto message__ = message ? _fbb.CreateString(message) : 0;
-  return osrm::engine::api::fbresult::CreateError(
-      _fbb,
-      code__,
-      message__);
-}
-
-struct FBResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef FBResultBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_ERROR = 4,
-    VT_CODE = 6,
-    VT_DATA_VERSION = 8,
-    VT_WAYPOINTS = 10,
-    VT_ROUTES = 12,
-    VT_TABLE = 14
-  };
-  bool error() const {
-    return GetField<uint8_t>(VT_ERROR, 0) != 0;
-  }
-  const osrm::engine::api::fbresult::Error *code() const {
-    return GetPointer<const osrm::engine::api::fbresult::Error *>(VT_CODE);
-  }
-  const ::flatbuffers::String *data_version() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_DATA_VERSION);
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *waypoints() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *>(VT_WAYPOINTS);
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> *routes() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> *>(VT_ROUTES);
-  }
-  const osrm::engine::api::fbresult::TableResult *table() const {
-    return GetPointer<const osrm::engine::api::fbresult::TableResult *>(VT_TABLE);
-  }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyField<uint8_t>(verifier, VT_ERROR, 1) &&
-           VerifyOffset(verifier, VT_CODE) &&
-           verifier.VerifyTable(code()) &&
-           VerifyOffset(verifier, VT_DATA_VERSION) &&
-           verifier.VerifyString(data_version()) &&
-           VerifyOffset(verifier, VT_WAYPOINTS) &&
-           verifier.VerifyVector(waypoints()) &&
-           verifier.VerifyVectorOfTables(waypoints()) &&
-           VerifyOffset(verifier, VT_ROUTES) &&
-           verifier.VerifyVector(routes()) &&
-           verifier.VerifyVectorOfTables(routes()) &&
-           VerifyOffset(verifier, VT_TABLE) &&
-           verifier.VerifyTable(table()) &&
-           verifier.EndTable();
-  }
-};
-
-struct FBResultBuilder {
-  typedef FBResult Table;
-  ::flatbuffers::FlatBufferBuilder &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_error(bool error) {
-    fbb_.AddElement<uint8_t>(FBResult::VT_ERROR, static_cast<uint8_t>(error), 0);
-  }
-  void add_code(::flatbuffers::Offset<osrm::engine::api::fbresult::Error> code) {
-    fbb_.AddOffset(FBResult::VT_CODE, code);
-  }
-  void add_data_version(::flatbuffers::Offset<::flatbuffers::String> data_version) {
-    fbb_.AddOffset(FBResult::VT_DATA_VERSION, data_version);
-  }
-  void add_waypoints(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints) {
-    fbb_.AddOffset(FBResult::VT_WAYPOINTS, waypoints);
-  }
-  void add_routes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>>> routes) {
-    fbb_.AddOffset(FBResult::VT_ROUTES, routes);
-  }
-  void add_table(::flatbuffers::Offset<osrm::engine::api::fbresult::TableResult> table) {
-    fbb_.AddOffset(FBResult::VT_TABLE, table);
-  }
-  explicit FBResultBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<FBResult> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<FBResult>(end);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<FBResult> CreateFBResult(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    bool error = false,
-    ::flatbuffers::Offset<osrm::engine::api::fbresult::Error> code = 0,
-    ::flatbuffers::Offset<::flatbuffers::String> data_version = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>>> routes = 0,
-    ::flatbuffers::Offset<osrm::engine::api::fbresult::TableResult> table = 0) {
-  FBResultBuilder builder_(_fbb);
-  builder_.add_table(table);
-  builder_.add_routes(routes);
-  builder_.add_waypoints(waypoints);
-  builder_.add_data_version(data_version);
-  builder_.add_code(code);
-  builder_.add_error(error);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<FBResult> CreateFBResultDirect(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    bool error = false,
-    ::flatbuffers::Offset<osrm::engine::api::fbresult::Error> code = 0,
-    const char *data_version = nullptr,
-    const std::vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *waypoints = nullptr,
-    const std::vector<::flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> *routes = nullptr,
-    ::flatbuffers::Offset<osrm::engine::api::fbresult::TableResult> table = 0) {
-  auto data_version__ = data_version ? _fbb.CreateString(data_version) : 0;
-  auto waypoints__ = waypoints ? _fbb.CreateVector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>(*waypoints) : 0;
-  auto routes__ = routes ? _fbb.CreateVector<::flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>>(*routes) : 0;
-  return osrm::engine::api::fbresult::CreateFBResult(
-      _fbb,
-      error,
-      code,
-      data_version__,
-      waypoints__,
-      routes__,
-      table);
-}
-
-inline const osrm::engine::api::fbresult::FBResult *GetFBResult(const void *buf) {
-  return ::flatbuffers::GetRoot<osrm::engine::api::fbresult::FBResult>(buf);
-}
-
-inline const osrm::engine::api::fbresult::FBResult *GetSizePrefixedFBResult(const void *buf) {
-  return ::flatbuffers::GetSizePrefixedRoot<osrm::engine::api::fbresult::FBResult>(buf);
-}
-
-inline bool VerifyFBResultBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<osrm::engine::api::fbresult::FBResult>(nullptr);
-}
-
-inline bool VerifySizePrefixedFBResultBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<osrm::engine::api::fbresult::FBResult>(nullptr);
-}
-
-inline void FinishFBResultBuffer(
-    ::flatbuffers::FlatBufferBuilder &fbb,
-    ::flatbuffers::Offset<osrm::engine::api::fbresult::FBResult> root) {
-  fbb.Finish(root);
-}
-
-inline void FinishSizePrefixedFBResultBuffer(
-    ::flatbuffers::FlatBufferBuilder &fbb,
-    ::flatbuffers::Offset<osrm::engine::api::fbresult::FBResult> root) {
-  fbb.FinishSizePrefixed(root);
-}
-
-}  // namespace fbresult
-}  // namespace api
-}  // namespace engine
-}  // namespace osrm
-
-#endif  // FLATBUFFERS_GENERATED_FBRESULT_OSRM_ENGINE_API_FBRESULT_H_
--- a/generated/include/engine/api/flatbuffers/position_generated.h
+++ b/generated/include/engine/api/flatbuffers/position_generated.h
@ -1,51 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-
-#ifndef FLATBUFFERS_GENERATED_POSITION_OSRM_ENGINE_API_FBRESULT_H_
-#define FLATBUFFERS_GENERATED_POSITION_OSRM_ENGINE_API_FBRESULT_H_
-
-#include "flatbuffers/flatbuffers.h"
-
-// Ensure the included flatbuffers.h is the same version as when this file was
-// generated, otherwise it may not be compatible.
-static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
-              FLATBUFFERS_VERSION_MINOR == 3 &&
-              FLATBUFFERS_VERSION_REVISION == 25,
-             "Non-compatible flatbuffers version included");
-
-namespace osrm {
-namespace engine {
-namespace api {
-namespace fbresult {
-
-struct Position;
-
-FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Position FLATBUFFERS_FINAL_CLASS {
- private:
-  float longitude_;
-  float latitude_;
-
- public:
-  Position()
-      : longitude_(0),
-        latitude_(0) {
-  }
-  Position(float _longitude, float _latitude)
-      : longitude_(::flatbuffers::EndianScalar(_longitude)),
-        latitude_(::flatbuffers::EndianScalar(_latitude)) {
-  }
-  float longitude() const {
-    return ::flatbuffers::EndianScalar(longitude_);
-  }
-  float latitude() const {
-    return ::flatbuffers::EndianScalar(latitude_);
-  }
-};
-FLATBUFFERS_STRUCT_END(Position, 8);
-
-}  // namespace fbresult
-}  // namespace api
-}  // namespace engine
-}  // namespace osrm
-
-#endif  // FLATBUFFERS_GENERATED_POSITION_OSRM_ENGINE_API_FBRESULT_H_
--- a/generated/include/engine/api/flatbuffers/route_generated.h
+++ b/generated/include/engine/api/flatbuffers/route_generated.h
--- a/generated/include/engine/api/flatbuffers/table_generated.h
+++ b/generated/include/engine/api/flatbuffers/table_generated.h
@ -1,149 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-
-#ifndef FLATBUFFERS_GENERATED_TABLE_OSRM_ENGINE_API_FBRESULT_H_
-#define FLATBUFFERS_GENERATED_TABLE_OSRM_ENGINE_API_FBRESULT_H_
-
-#include "flatbuffers/flatbuffers.h"
-
-// Ensure the included flatbuffers.h is the same version as when this file was
-// generated, otherwise it may not be compatible.
-static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
-              FLATBUFFERS_VERSION_MINOR == 3 &&
-              FLATBUFFERS_VERSION_REVISION == 25,
-             "Non-compatible flatbuffers version included");
-
-#include "waypoint_generated.h"
-
-namespace osrm {
-namespace engine {
-namespace api {
-namespace fbresult {
-
-struct TableResult;
-struct TableResultBuilder;
-
-struct TableResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef TableResultBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_DURATIONS = 4,
-    VT_ROWS = 6,
-    VT_COLS = 8,
-    VT_DISTANCES = 10,
-    VT_DESTINATIONS = 12,
-    VT_FALLBACK_SPEED_CELLS = 14
-  };
-  const ::flatbuffers::Vector<float> *durations() const {
-    return GetPointer<const ::flatbuffers::Vector<float> *>(VT_DURATIONS);
-  }
-  uint16_t rows() const {
-    return GetField<uint16_t>(VT_ROWS, 0);
-  }
-  uint16_t cols() const {
-    return GetField<uint16_t>(VT_COLS, 0);
-  }
-  const ::flatbuffers::Vector<float> *distances() const {
-    return GetPointer<const ::flatbuffers::Vector<float> *>(VT_DISTANCES);
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *destinations() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *>(VT_DESTINATIONS);
-  }
-  const ::flatbuffers::Vector<uint32_t> *fallback_speed_cells() const {
-    return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_FALLBACK_SPEED_CELLS);
-  }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyOffset(verifier, VT_DURATIONS) &&
-           verifier.VerifyVector(durations()) &&
-           VerifyField<uint16_t>(verifier, VT_ROWS, 2) &&
-           VerifyField<uint16_t>(verifier, VT_COLS, 2) &&
-           VerifyOffset(verifier, VT_DISTANCES) &&
-           verifier.VerifyVector(distances()) &&
-           VerifyOffset(verifier, VT_DESTINATIONS) &&
-           verifier.VerifyVector(destinations()) &&
-           verifier.VerifyVectorOfTables(destinations()) &&
-           VerifyOffset(verifier, VT_FALLBACK_SPEED_CELLS) &&
-           verifier.VerifyVector(fallback_speed_cells()) &&
-           verifier.EndTable();
-  }
-};
-
-struct TableResultBuilder {
-  typedef TableResult Table;
-  ::flatbuffers::FlatBufferBuilder &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_durations(::flatbuffers::Offset<::flatbuffers::Vector<float>> durations) {
-    fbb_.AddOffset(TableResult::VT_DURATIONS, durations);
-  }
-  void add_rows(uint16_t rows) {
-    fbb_.AddElement<uint16_t>(TableResult::VT_ROWS, rows, 0);
-  }
-  void add_cols(uint16_t cols) {
-    fbb_.AddElement<uint16_t>(TableResult::VT_COLS, cols, 0);
-  }
-  void add_distances(::flatbuffers::Offset<::flatbuffers::Vector<float>> distances) {
-    fbb_.AddOffset(TableResult::VT_DISTANCES, distances);
-  }
-  void add_destinations(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> destinations) {
-    fbb_.AddOffset(TableResult::VT_DESTINATIONS, destinations);
-  }
-  void add_fallback_speed_cells(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> fallback_speed_cells) {
-    fbb_.AddOffset(TableResult::VT_FALLBACK_SPEED_CELLS, fallback_speed_cells);
-  }
-  explicit TableResultBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<TableResult> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<TableResult>(end);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<TableResult> CreateTableResult(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    ::flatbuffers::Offset<::flatbuffers::Vector<float>> durations = 0,
-    uint16_t rows = 0,
-    uint16_t cols = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<float>> distances = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> destinations = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> fallback_speed_cells = 0) {
-  TableResultBuilder builder_(_fbb);
-  builder_.add_fallback_speed_cells(fallback_speed_cells);
-  builder_.add_destinations(destinations);
-  builder_.add_distances(distances);
-  builder_.add_durations(durations);
-  builder_.add_cols(cols);
-  builder_.add_rows(rows);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<TableResult> CreateTableResultDirect(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    const std::vector<float> *durations = nullptr,
-    uint16_t rows = 0,
-    uint16_t cols = 0,
-    const std::vector<float> *distances = nullptr,
-    const std::vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *destinations = nullptr,
-    const std::vector<uint32_t> *fallback_speed_cells = nullptr) {
-  auto durations__ = durations ? _fbb.CreateVector<float>(*durations) : 0;
-  auto distances__ = distances ? _fbb.CreateVector<float>(*distances) : 0;
-  auto destinations__ = destinations ? _fbb.CreateVector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>(*destinations) : 0;
-  auto fallback_speed_cells__ = fallback_speed_cells ? _fbb.CreateVector<uint32_t>(*fallback_speed_cells) : 0;
-  return osrm::engine::api::fbresult::CreateTableResult(
-      _fbb,
-      durations__,
-      rows,
-      cols,
-      distances__,
-      destinations__,
-      fallback_speed_cells__);
-}
-
-}  // namespace fbresult
-}  // namespace api
-}  // namespace engine
-}  // namespace osrm
-
-#endif  // FLATBUFFERS_GENERATED_TABLE_OSRM_ENGINE_API_FBRESULT_H_
--- a/generated/include/engine/api/flatbuffers/waypoint_generated.h
+++ b/generated/include/engine/api/flatbuffers/waypoint_generated.h
@ -1,205 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-
-#ifndef FLATBUFFERS_GENERATED_WAYPOINT_OSRM_ENGINE_API_FBRESULT_H_
-#define FLATBUFFERS_GENERATED_WAYPOINT_OSRM_ENGINE_API_FBRESULT_H_
-
-#include "flatbuffers/flatbuffers.h"
-
-// Ensure the included flatbuffers.h is the same version as when this file was
-// generated, otherwise it may not be compatible.
-static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
-              FLATBUFFERS_VERSION_MINOR == 3 &&
-              FLATBUFFERS_VERSION_REVISION == 25,
-             "Non-compatible flatbuffers version included");
-
-#include "position_generated.h"
-
-namespace osrm {
-namespace engine {
-namespace api {
-namespace fbresult {
-
-struct Uint64Pair;
-
-struct Waypoint;
-struct WaypointBuilder;
-
-FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Uint64Pair FLATBUFFERS_FINAL_CLASS {
- private:
-  uint64_t first_;
-  uint64_t second_;
-
- public:
-  Uint64Pair()
-      : first_(0),
-        second_(0) {
-  }
-  Uint64Pair(uint64_t _first, uint64_t _second)
-      : first_(::flatbuffers::EndianScalar(_first)),
-        second_(::flatbuffers::EndianScalar(_second)) {
-  }
-  uint64_t first() const {
-    return ::flatbuffers::EndianScalar(first_);
-  }
-  uint64_t second() const {
-    return ::flatbuffers::EndianScalar(second_);
-  }
-};
-FLATBUFFERS_STRUCT_END(Uint64Pair, 16);
-
-struct Waypoint FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef WaypointBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_HINT = 4,
-    VT_DISTANCE = 6,
-    VT_NAME = 8,
-    VT_LOCATION = 10,
-    VT_NODES = 12,
-    VT_MATCHINGS_INDEX = 14,
-    VT_WAYPOINT_INDEX = 16,
-    VT_ALTERNATIVES_COUNT = 18,
-    VT_TRIPS_INDEX = 20
-  };
-  const ::flatbuffers::String *hint() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_HINT);
-  }
-  float distance() const {
-    return GetField<float>(VT_DISTANCE, 0.0f);
-  }
-  const ::flatbuffers::String *name() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
-  }
-  const osrm::engine::api::fbresult::Position *location() const {
-    return GetStruct<const osrm::engine::api::fbresult::Position *>(VT_LOCATION);
-  }
-  const osrm::engine::api::fbresult::Uint64Pair *nodes() const {
-    return GetStruct<const osrm::engine::api::fbresult::Uint64Pair *>(VT_NODES);
-  }
-  uint32_t matchings_index() const {
-    return GetField<uint32_t>(VT_MATCHINGS_INDEX, 0);
-  }
-  uint32_t waypoint_index() const {
-    return GetField<uint32_t>(VT_WAYPOINT_INDEX, 0);
-  }
-  uint32_t alternatives_count() const {
-    return GetField<uint32_t>(VT_ALTERNATIVES_COUNT, 0);
-  }
-  uint32_t trips_index() const {
-    return GetField<uint32_t>(VT_TRIPS_INDEX, 0);
-  }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyOffset(verifier, VT_HINT) &&
-           verifier.VerifyString(hint()) &&
-           VerifyField<float>(verifier, VT_DISTANCE, 4) &&
-           VerifyOffset(verifier, VT_NAME) &&
-           verifier.VerifyString(name()) &&
-           VerifyField<osrm::engine::api::fbresult::Position>(verifier, VT_LOCATION, 4) &&
-           VerifyField<osrm::engine::api::fbresult::Uint64Pair>(verifier, VT_NODES, 8) &&
-           VerifyField<uint32_t>(verifier, VT_MATCHINGS_INDEX, 4) &&
-           VerifyField<uint32_t>(verifier, VT_WAYPOINT_INDEX, 4) &&
-           VerifyField<uint32_t>(verifier, VT_ALTERNATIVES_COUNT, 4) &&
-           VerifyField<uint32_t>(verifier, VT_TRIPS_INDEX, 4) &&
-           verifier.EndTable();
-  }
-};
-
-struct WaypointBuilder {
-  typedef Waypoint Table;
-  ::flatbuffers::FlatBufferBuilder &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_hint(::flatbuffers::Offset<::flatbuffers::String> hint) {
-    fbb_.AddOffset(Waypoint::VT_HINT, hint);
-  }
-  void add_distance(float distance) {
-    fbb_.AddElement<float>(Waypoint::VT_DISTANCE, distance, 0.0f);
-  }
-  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
-    fbb_.AddOffset(Waypoint::VT_NAME, name);
-  }
-  void add_location(const osrm::engine::api::fbresult::Position *location) {
-    fbb_.AddStruct(Waypoint::VT_LOCATION, location);
-  }
-  void add_nodes(const osrm::engine::api::fbresult::Uint64Pair *nodes) {
-    fbb_.AddStruct(Waypoint::VT_NODES, nodes);
-  }
-  void add_matchings_index(uint32_t matchings_index) {
-    fbb_.AddElement<uint32_t>(Waypoint::VT_MATCHINGS_INDEX, matchings_index, 0);
-  }
-  void add_waypoint_index(uint32_t waypoint_index) {
-    fbb_.AddElement<uint32_t>(Waypoint::VT_WAYPOINT_INDEX, waypoint_index, 0);
-  }
-  void add_alternatives_count(uint32_t alternatives_count) {
-    fbb_.AddElement<uint32_t>(Waypoint::VT_ALTERNATIVES_COUNT, alternatives_count, 0);
-  }
-  void add_trips_index(uint32_t trips_index) {
-    fbb_.AddElement<uint32_t>(Waypoint::VT_TRIPS_INDEX, trips_index, 0);
-  }
-  explicit WaypointBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<Waypoint> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<Waypoint>(end);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<Waypoint> CreateWaypoint(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    ::flatbuffers::Offset<::flatbuffers::String> hint = 0,
-    float distance = 0.0f,
-    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
-    const osrm::engine::api::fbresult::Position *location = nullptr,
-    const osrm::engine::api::fbresult::Uint64Pair *nodes = nullptr,
-    uint32_t matchings_index = 0,
-    uint32_t waypoint_index = 0,
-    uint32_t alternatives_count = 0,
-    uint32_t trips_index = 0) {
-  WaypointBuilder builder_(_fbb);
-  builder_.add_trips_index(trips_index);
-  builder_.add_alternatives_count(alternatives_count);
-  builder_.add_waypoint_index(waypoint_index);
-  builder_.add_matchings_index(matchings_index);
-  builder_.add_nodes(nodes);
-  builder_.add_location(location);
-  builder_.add_name(name);
-  builder_.add_distance(distance);
-  builder_.add_hint(hint);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<Waypoint> CreateWaypointDirect(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    const char *hint = nullptr,
-    float distance = 0.0f,
-    const char *name = nullptr,
-    const osrm::engine::api::fbresult::Position *location = nullptr,
-    const osrm::engine::api::fbresult::Uint64Pair *nodes = nullptr,
-    uint32_t matchings_index = 0,
-    uint32_t waypoint_index = 0,
-    uint32_t alternatives_count = 0,
-    uint32_t trips_index = 0) {
-  auto hint__ = hint ? _fbb.CreateString(hint) : 0;
-  auto name__ = name ? _fbb.CreateString(name) : 0;
-  return osrm::engine::api::fbresult::CreateWaypoint(
-      _fbb,
-      hint__,
-      distance,
-      name__,
-      location,
-      nodes,
-      matchings_index,
-      waypoint_index,
-      alternatives_count,
-      trips_index);
-}
-
-}  // namespace fbresult
-}  // namespace api
-}  // namespace engine
-}  // namespace osrm
-
-#endif  // FLATBUFFERS_GENERATED_WAYPOINT_OSRM_ENGINE_API_FBRESULT_H_
--- a/include/contractor/contract_excludable_graph.hpp
+++ b/include/contractor/contract_excludable_graph.hpp
@ -61,12 +61,10 @@ inline auto contractExcludableGraph(ContractorGraph contractor_graph_,
        // Add all non-core edges to container
        {
            auto non_core_edges = toEdges<QueryEdge>(contractor_graph);
-            auto new_end = std::remove_if(non_core_edges.begin(),
-                                          non_core_edges.end(),
-                                          [&](const auto &edge) {
-                                              return is_shared_core[edge.source] &&
-                                                     is_shared_core[edge.target];
-                                          });
+            auto new_end =
+                std::remove_if(non_core_edges.begin(), non_core_edges.end(), [&](const auto &edge) {
+                    return is_shared_core[edge.source] && is_shared_core[edge.target];
+                });
            non_core_edges.resize(new_end - non_core_edges.begin());
            edge_container.Insert(std::move(non_core_edges));

@ -77,8 +75,8 @@ inline auto contractExcludableGraph(ContractorGraph contractor_graph_,
        }

        // Extract core graph for further contraction
-        shared_core_graph = contractor_graph.Filter([&is_shared_core](const NodeID node)
-                                                    { return is_shared_core[node]; });
+        shared_core_graph = contractor_graph.Filter(
+            [&is_shared_core](const NodeID node) { return is_shared_core[node]; });
    }

    for (const auto &filter : filters)
--- a/include/contractor/contracted_edge_container.hpp
+++ b/include/contractor/contracted_edge_container.hpp
@ -89,40 +89,37 @@ struct ContractedEdgeContainer

        // Remove all edges that are contained in the old set of edges and set the appropriate flag.
        auto new_end =
-            std::remove_if(new_edges.begin(),
-                           new_edges.end(),
-                           [&](const QueryEdge &edge)
-                           {
-                               // check if the new edge would be sorted before the currend old edge
-                               // if so it is not contained yet in the set of old edges
-                               if (edge_iter == edge_end || mergeCompare(edge, *edge_iter))
-                               {
-                                   return false;
-                               }
+            std::remove_if(new_edges.begin(), new_edges.end(), [&](const QueryEdge &edge) {
+                // check if the new edge would be sorted before the currend old edge
+                // if so it is not contained yet in the set of old edges
+                if (edge_iter == edge_end || mergeCompare(edge, *edge_iter))
+                {
+                    return false;
+                }

-                               // find the first old edge that is equal or greater then the new edge
-                               while (edge_iter != edge_end && mergeCompare(*edge_iter, edge))
-                               {
-                                   BOOST_ASSERT(flags_iter != flags.end());
-                                   edge_iter++;
-                                   flags_iter++;
-                               }
+                // find the first old edge that is equal or greater then the new edge
+                while (edge_iter != edge_end && mergeCompare(*edge_iter, edge))
+                {
+                    BOOST_ASSERT(flags_iter != flags.end());
+                    edge_iter++;
+                    flags_iter++;
+                }

-                               // all new edges will be sorted after the old edges
-                               if (edge_iter == edge_end)
-                               {
-                                   return false;
-                               }
+                // all new edges will be sorted after the old edges
+                if (edge_iter == edge_end)
+                {
+                    return false;
+                }

-                               BOOST_ASSERT(edge_iter != edge_end);
-                               if (mergable(edge, *edge_iter))
-                               {
-                                   *flags_iter = *flags_iter | flag;
-                                   return true;
-                               }
-                               BOOST_ASSERT(mergeCompare(edge, *edge_iter));
-                               return false;
-                           });
+                BOOST_ASSERT(edge_iter != edge_end);
+                if (mergable(edge, *edge_iter))
+                {
+                    *flags_iter = *flags_iter | flag;
+                    return true;
+                }
+                BOOST_ASSERT(mergeCompare(edge, *edge_iter));
+                return false;
+            });

        // append new edges
        edges.insert(edges.end(), new_edges.begin(), new_end);
@ -135,10 +132,10 @@ struct ContractedEdgeContainer
        // enforce sorting for next merge step
        std::vector<unsigned> ordering(edges_size);
        std::iota(ordering.begin(), ordering.end(), 0);
-        tbb::parallel_sort(ordering.begin(),
-                           ordering.end(),
-                           [&](const auto lhs_idx, const auto rhs_idx)
-                           { return mergeCompare(edges[lhs_idx], edges[rhs_idx]); });
+        tbb::parallel_sort(
+            ordering.begin(), ordering.end(), [&](const auto lhs_idx, const auto rhs_idx) {
+                return mergeCompare(edges[lhs_idx], edges[rhs_idx]);
+            });
        auto permutation = util::orderingToPermutation(ordering);

        util::inplacePermutation(edges.begin(), edges.end(), permutation);
--- a/include/contractor/contractor_config.hpp
+++ b/include/contractor/contractor_config.hpp
@ -31,7 +31,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "storage/io_config.hpp"
 #include "updater/updater_config.hpp"

-#include <filesystem>
+#include <boost/filesystem/path.hpp>
+
 #include <string>

 namespace osrm::contractor
@ -46,7 +47,7 @@ struct ContractorConfig final : storage::IOConfig
    }

    // Infer the output names from the path of the .osrm file
-    void UseDefaultOutputNames(const std::filesystem::path &base)
+    void UseDefaultOutputNames(const boost::filesystem::path &base)
    {
        IOConfig::UseDefaultOutputNames(base);
        updater_config.UseDefaultOutputNames(base);
--- a/include/contractor/crc32_processor.hpp
+++ b/include/contractor/crc32_processor.hpp
@ -0,0 +1,128 @@
+#ifndef ITERATOR_BASED_CRC32_H
+#define ITERATOR_BASED_CRC32_H
+
+#if defined(__x86_64__) && !defined(__MINGW64__)
+#include <cpuid.h>
+#endif
+
+#include <boost/crc.hpp> // for boost::crc_32_type
+
+#include <iterator>
+
+namespace osrm::contractor
+{
+
+class IteratorbasedCRC32
+{
+  public:
+    bool UsingHardware() const { return use_hardware_implementation; }
+
+    IteratorbasedCRC32() : crc(0) { use_hardware_implementation = DetectHardwareSupport(); }
+
+    template <class Iterator> unsigned operator()(Iterator iter, const Iterator end)
+    {
+        unsigned crc = 0;
+        while (iter != end)
+        {
+            using value_type = typename std::iterator_traits<Iterator>::value_type;
+            const char *data = reinterpret_cast<const char *>(&(*iter));
+
+            if (use_hardware_implementation)
+            {
+                crc = ComputeInHardware(data, sizeof(value_type));
+            }
+            else
+            {
+                crc = ComputeInSoftware(data, sizeof(value_type));
+            }
+            ++iter;
+        }
+        return crc;
+    }
+
+  private:
+    bool DetectHardwareSupport() const
+    {
+        static const int sse42_bit = 0x00100000;
+        const unsigned ecx = cpuid();
+        const bool sse42_found = (ecx & sse42_bit) != 0;
+        return sse42_found;
+    }
+
+    unsigned ComputeInSoftware(const char *str, unsigned len)
+    {
+        crc_processor.process_bytes(str, len);
+        return crc_processor.checksum();
+    }
+
+    // adapted from http://byteworm.com/2010/10/13/crc32/
+    unsigned ComputeInHardware(const char *str, unsigned len)
+    {
+#if defined(__x86_64__)
+        unsigned q = len / sizeof(unsigned);
+        unsigned r = len % sizeof(unsigned);
+        unsigned *p = (unsigned *)str;
+
+        // crc=0;
+        while (q--)
+        {
+            __asm__ __volatile__(".byte 0xf2, 0xf, 0x38, 0xf1, 0xf1;"
+                                 : "=S"(crc)
+                                 : "0"(crc), "c"(*p));
+            ++p;
+        }
+
+        str = reinterpret_cast<char *>(p);
+        while (r--)
+        {
+            __asm__ __volatile__(".byte 0xf2, 0xf, 0x38, 0xf1, 0xf1;"
+                                 : "=S"(crc)
+                                 : "0"(crc), "c"(*str));
+            ++str;
+        }
+#else
+        (void)str;
+        (void)len;
+#endif
+        return crc;
+    }
+
+    inline unsigned cpuid() const
+    {
+        unsigned eax = 0, ebx = 0, ecx = 0, edx = 0;
+        // on X64 this calls hardware cpuid(.) instr. otherwise a dummy impl.
+        __get_cpuid(1, &eax, &ebx, &ecx, &edx);
+        return ecx;
+    }
+
+#if defined(__MINGW64__) || defined(_MSC_VER) || !defined(__x86_64__)
+    inline void __get_cpuid(int /*param*/,
+                            unsigned * /*eax*/,
+                            unsigned * /*ebx*/,
+                            unsigned *ecx,
+                            unsigned * /*edx*/) const
+    {
+        *ecx = 0;
+    }
+#endif
+
+    boost::crc_optimal<32, 0x1EDC6F41, 0x0, 0x0, true, true> crc_processor;
+    unsigned crc;
+    bool use_hardware_implementation;
+};
+
+struct RangebasedCRC32
+{
+    template <typename Iteratable> unsigned operator()(const Iteratable &iterable)
+    {
+        return crc32(std::begin(iterable), std::end(iterable));
+    }
+
+    bool UsingHardware() const { return crc32.UsingHardware(); }
+
+  private:
+    IteratorbasedCRC32 crc32;
+};
+} // namespace osrm::contractor
+
+#endif /* ITERATOR_BASED_CRC32_H */
--- a/include/contractor/files.hpp
+++ b/include/contractor/files.hpp
@ -9,7 +9,7 @@ namespace osrm::contractor::files
 {
 // reads .osrm.hsgr file
 template <typename ContractedMetricT>
-inline void readGraph(const std::filesystem::path &path,
+inline void readGraph(const boost::filesystem::path &path,
                      std::unordered_map<std::string, ContractedMetricT> &metrics,
                      std::uint32_t &connectivity_checksum)
 {
@ -30,7 +30,7 @@ inline void readGraph(const std::filesystem::path &path,

 // writes .osrm.hsgr file
 template <typename ContractedMetricT>
-inline void writeGraph(const std::filesystem::path &path,
+inline void writeGraph(const boost::filesystem::path &path,
                       const std::unordered_map<std::string, ContractedMetricT> &metrics,
                       const std::uint32_t connectivity_checksum)
 {
--- a/include/customizer/cell_customizer.hpp
+++ b/include/customizer/cell_customizer.hpp
@ -122,8 +122,7 @@ class CellCustomizer
        for (std::size_t level = 1; level < partition.GetNumberOfLevels(); ++level)
        {
            tbb::parallel_for(tbb::blocked_range<std::size_t>(0, partition.GetNumberOfCells(level)),
-                              [&](const tbb::blocked_range<std::size_t> &range)
-                              {
+                              [&](const tbb::blocked_range<std::size_t> &range) {
                                  auto &heap = heaps.local();
                                  for (auto id = range.begin(), end = range.end(); id != end; ++id)
                                  {
--- a/include/customizer/customizer_config.hpp
+++ b/include/customizer/customizer_config.hpp
@ -1,8 +1,9 @@
 #ifndef OSRM_CUSTOMIZE_CUSTOMIZER_CONFIG_HPP
 #define OSRM_CUSTOMIZE_CUSTOMIZER_CONFIG_HPP

+#include <boost/filesystem/path.hpp>
+
 #include <array>
-#include <filesystem>
 #include <string>

 #include "storage/io_config.hpp"
@ -26,7 +27,7 @@ struct CustomizationConfig final : storage::IOConfig
    {
    }

-    void UseDefaultOutputNames(const std::filesystem::path &base)
+    void UseDefaultOutputNames(const boost::filesystem::path &base)
    {
        IOConfig::UseDefaultOutputNames(base);
        updater_config.UseDefaultOutputNames(base);
--- a/include/customizer/edge_based_graph.hpp
+++ b/include/customizer/edge_based_graph.hpp
@ -9,7 +9,7 @@

 #include "storage/shared_memory_ownership.hpp"

-#include <filesystem>
+#include <boost/filesystem/path.hpp>

 namespace osrm::customizer
 {
--- a/include/customizer/files.hpp
+++ b/include/customizer/files.hpp
@ -14,7 +14,7 @@ namespace osrm::customizer::files

 // reads .osrm.cell_metrics file
 template <typename CellMetricT>
-inline void readCellMetrics(const std::filesystem::path &path,
+inline void readCellMetrics(const boost::filesystem::path &path,
                            std::unordered_map<std::string, std::vector<CellMetricT>> &metrics)
 {
    static_assert(std::is_same<CellMetricView, CellMetricT>::value ||
@ -44,7 +44,7 @@ inline void readCellMetrics(const std::filesystem::path &path,
 // writes .osrm.cell_metrics file
 template <typename CellMetricT>
 inline void
-writeCellMetrics(const std::filesystem::path &path,
+writeCellMetrics(const boost::filesystem::path &path,
                 const std::unordered_map<std::string, std::vector<CellMetricT>> &metrics)
 {
    static_assert(std::is_same<CellMetricView, CellMetricT>::value ||
@ -72,7 +72,7 @@ writeCellMetrics(const std::filesystem::path &path,

 // reads .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void readGraph(const std::filesystem::path &path,
+inline void readGraph(const boost::filesystem::path &path,
                      MultiLevelGraphT &graph,
                      std::uint32_t &connectivity_checksum)
 {
@ -88,7 +88,7 @@ inline void readGraph(const std::filesystem::path &path,

 // writes .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void writeGraph(const std::filesystem::path &path,
+inline void writeGraph(const boost::filesystem::path &path,
                       const MultiLevelGraphT &graph,
                       const std::uint32_t connectivity_checksum)
 {
--- a/include/engine/api/base_api.hpp
+++ b/include/engine/api/base_api.hpp
@ -40,10 +40,10 @@ class BaseAPI
        util::json::Array waypoints;
        waypoints.values.resize(parameters.coordinates.size());

-        boost::range::transform(waypoint_candidates,
-                                waypoints.values.begin(),
-                                [this](const PhantomNodeCandidates &candidates)
-                                { return MakeWaypoint(candidates); });
+        boost::range::transform(
+            waypoint_candidates,
+            waypoints.values.begin(),
+            [this](const PhantomNodeCandidates &candidates) { return MakeWaypoint(candidates); });
        return waypoints;
    }

@ -104,8 +104,9 @@ class BaseAPI
        std::transform(waypoint_candidates.begin(),
                       waypoint_candidates.end(),
                       waypoints.begin(),
-                       [this, builder](const PhantomNodeCandidates &candidates)
-                       { return MakeWaypoint(builder, candidates)->Finish(); });
+                       [this, builder](const PhantomNodeCandidates &candidates) {
+                           return MakeWaypoint(builder, candidates)->Finish();
+                       });
        return builder->CreateVector(waypoints);
    }

--- a/include/engine/api/base_parameters.hpp
+++ b/include/engine/api/base_parameters.hpp
@ -33,7 +33,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "engine/hint.hpp"
 #include "util/coordinate.hpp"

-#include <optional>
+#include <boost/optional.hpp>

 #include <algorithm>
 #include <vector>
@ -52,8 +52,7 @@ namespace osrm::engine::api
 *              optional per coordinate
 *  - bearings: limits the search for segments in the road network to given bearing(s) in degree
 *              towards true north in clockwise direction, optional per coordinate
- *  - approaches: force the phantom node to start towards the node with the road country side or
- *                its opposite
+ *  - approaches: force the phantom node to start towards the node with the road country side.
 *
 * \see OSRM, Coordinate, Hint, Bearing, RouteParameters, TableParameters,
 *      NearestParameters, TripParameters, MatchParameters and TileParameters
@ -74,12 +73,12 @@ struct BaseParameters
    };

    std::vector<util::Coordinate> coordinates;
-    std::vector<std::optional<Hint>> hints;
-    std::vector<std::optional<double>> radiuses;
-    std::vector<std::optional<Bearing>> bearings;
-    std::vector<std::optional<Approach>> approaches;
+    std::vector<boost::optional<Hint>> hints;
+    std::vector<boost::optional<double>> radiuses;
+    std::vector<boost::optional<Bearing>> bearings;
+    std::vector<boost::optional<Approach>> approaches;
    std::vector<std::string> exclude;
-    std::optional<OutputFormatType> format = OutputFormatType::JSON;
+    boost::optional<OutputFormatType> format = OutputFormatType::JSON;

    // Adds hints to response which can be included in subsequent requests, see `hints` above.
    bool generate_hints = true;
@ -90,10 +89,10 @@ struct BaseParameters
    SnappingType snapping = SnappingType::Default;

    BaseParameters(std::vector<util::Coordinate> coordinates_ = {},
-                   std::vector<std::optional<Hint>> hints_ = {},
-                   std::vector<std::optional<double>> radiuses_ = {},
-                   std::vector<std::optional<Bearing>> bearings_ = {},
-                   std::vector<std::optional<Approach>> approaches_ = {},
+                   std::vector<boost::optional<Hint>> hints_ = {},
+                   std::vector<boost::optional<double>> radiuses_ = {},
+                   std::vector<boost::optional<Bearing>> bearings_ = {},
+                   std::vector<boost::optional<Approach>> approaches_ = {},
                   bool generate_hints_ = true,
                   std::vector<std::string> exclude = {},
                   const SnappingType snapping_ = SnappingType::Default)
@ -112,8 +111,7 @@ struct BaseParameters
               (approaches.empty() || approaches.size() == coordinates.size()) &&
               std::all_of(bearings.begin(),
                           bearings.end(),
-                           [](const std::optional<Bearing> &bearing_and_range)
-                           {
+                           [](const boost::optional<Bearing> &bearing_and_range) {
                               if (bearing_and_range)
                               {
                                   return bearing_and_range->IsValid();
--- a/include/engine/api/base_result.hpp
+++ b/include/engine/api/base_result.hpp
@ -2,7 +2,7 @@
 #define ENGINE_API_BASE_RESULT_HPP

 #include <flatbuffers/flatbuffers.h>
-#include <variant>
+#include <mapbox/variant.hpp>

 #include <string>

@ -10,7 +10,8 @@

 namespace osrm::engine::api
 {
-using ResultT = std::variant<util::json::Object, std::string, flatbuffers::FlatBufferBuilder>;
+using ResultT =
+    mapbox::util::variant<util::json::Object, std::string, flatbuffers::FlatBufferBuilder>;
 } // namespace osrm::engine::api

 #endif
--- a/include/engine/api/flatbuffers/fbresult.fbs
+++ b/include/engine/api/flatbuffers/fbresult.fbs
@ -14,7 +14,7 @@ table FBResult {
    data_version: string;
    waypoints: [Waypoint]; //Used as 'sources' waypoints for a 'Table' service
    routes: [RouteObject];
-    table: TableResult;
+    table: Table;
 }

 root_type FBResult;
--- a/include/engine/api/flatbuffers/fbresult_generated.h
+++ b/include/engine/api/flatbuffers/fbresult_generated.h
--- a/include/engine/api/flatbuffers/table.fbs
+++ b/include/engine/api/flatbuffers/table.fbs
@ -1,7 +1,7 @@
 include "waypoint.fbs";
 namespace osrm.engine.api.fbresult;

-table TableResult {
+table Table {
    durations: [float];
    rows: ushort;
    cols: ushort;
--- a/include/engine/api/json_factory.hpp
+++ b/include/engine/api/json_factory.hpp
@ -12,7 +12,7 @@
 #include "util/coordinate.hpp"
 #include "util/json_container.hpp"

-#include <optional>
+#include <boost/optional.hpp>

 #include <algorithm>
 #include <iterator>
@ -41,7 +41,7 @@ inline bool hasValidLanes(const guidance::IntermediateIntersection &intersection
    return intersection.lanes.lanes_in_turn > 0;
 }

-util::json::Value coordinateToLonLat(const util::Coordinate &coordinate);
+util::json::Array coordinateToLonLat(const util::Coordinate &coordinate);

 /**
 * Ensures that a bearing value is a whole number, and clamped to the range 0-359
@ -79,7 +79,7 @@ util::json::Object makeGeoJSONGeometry(ForwardIter begin, ForwardIter end)
        coordinates.values.push_back(location);
        coordinates.values.push_back(location);
    }
-    geojson.values["coordinates"] = util::json::Value{std::move(coordinates)};
+    geojson.values["coordinates"] = std::move(coordinates);

    return geojson;
 }
@ -90,7 +90,7 @@ util::json::Object makeRouteStep(guidance::RouteStep step, util::json::Value geo

 util::json::Object makeRoute(const guidance::Route &route,
                             util::json::Array legs,
-                             std::optional<util::json::Value> geometry,
+                             boost::optional<util::json::Value> geometry,
                             const char *weight_name);

 // Creates a Waypoint without Hint, see the Hint overload below
--- a/include/engine/api/match_api.hpp
+++ b/include/engine/api/match_api.hpp
@ -30,14 +30,14 @@ class MatchAPI final : public RouteAPI
                      osrm::engine::api::ResultT &response) const
    {
        BOOST_ASSERT(sub_matchings.size() == sub_routes.size());
-        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
+        if (response.is<flatbuffers::FlatBufferBuilder>())
        {
-            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
+            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
            MakeResponse(sub_matchings, sub_routes, fb_result);
        }
        else
        {
-            auto &json_result = std::get<util::json::Object>(response);
+            auto &json_result = response.get<util::json::Object>();
            MakeResponse(sub_matchings, sub_routes, json_result);
        }
    }
@ -52,10 +52,9 @@ class MatchAPI final : public RouteAPI
            data_version_string = fb_result.CreateString(data_timestamp);
        }

-        auto response = MakeFBResponse(sub_routes,
-                                       fb_result,
-                                       [this, &fb_result, &sub_matchings]()
-                                       { return MakeTracepoints(fb_result, sub_matchings); });
+        auto response = MakeFBResponse(sub_routes, fb_result, [this, &fb_result, &sub_matchings]() {
+            return MakeTracepoints(fb_result, sub_matchings);
+        });

        if (!data_timestamp.empty())
        {
@ -77,19 +76,19 @@ class MatchAPI final : public RouteAPI
                                   sub_routes[index].unpacked_path_segments,
                                   sub_routes[index].source_traversed_in_reverse,
                                   sub_routes[index].target_traversed_in_reverse);
-            route.values.emplace("confidence", sub_matchings[index].confidence);
-            routes.values.emplace_back(std::move(route));
+            route.values["confidence"] = sub_matchings[index].confidence;
+            routes.values.push_back(std::move(route));
        }
        if (!parameters.skip_waypoints)
        {
-            response.values.emplace("tracepoints", MakeTracepoints(sub_matchings));
+            response.values["tracepoints"] = MakeTracepoints(sub_matchings);
        }
-        response.values.emplace("matchings", std::move(routes));
-        response.values.emplace("code", "Ok");
+        response.values["matchings"] = std::move(routes);
+        response.values["code"] = "Ok";
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values.emplace("data_version", data_timestamp);
+            response.values["data_version"] = data_timestamp;
        }
    }

@ -132,13 +131,13 @@ class MatchAPI final : public RouteAPI

            if (tidy_result.can_be_removed[trace_index])
            {
-                waypoints.emplace_back(fbresult::WaypointBuilder(fb_result).Finish());
+                waypoints.push_back(fbresult::WaypointBuilder(fb_result).Finish());
                continue;
            }
            auto matching_index = trace_idx_to_matching_idx[trace_index];
            if (matching_index.NotMatched())
            {
-                waypoints.emplace_back(fbresult::WaypointBuilder(fb_result).Finish());
+                waypoints.push_back(fbresult::WaypointBuilder(fb_result).Finish());
                continue;
            }
            const auto &phantom =
@ -165,7 +164,7 @@ class MatchAPI final : public RouteAPI
            {
                waypoint->add_waypoint_index(matching_index.point_index);
            }
-            waypoints.emplace_back(waypoint->Finish());
+            waypoints.push_back(waypoint->Finish());
        }

        return fb_result.CreateVector(waypoints);
@ -186,23 +185,23 @@ class MatchAPI final : public RouteAPI
        {
            if (tidy_result.can_be_removed[trace_index])
            {
-                waypoints.values.emplace_back(util::json::Null());
+                waypoints.values.push_back(util::json::Null());
                continue;
            }
            auto matching_index = trace_idx_to_matching_idx[trace_index];
            if (matching_index.NotMatched())
            {
-                waypoints.values.emplace_back(util::json::Null());
+                waypoints.values.push_back(util::json::Null());
                continue;
            }
            const auto &phantom =
                sub_matchings[matching_index.sub_matching_index].nodes[matching_index.point_index];
            auto waypoint = BaseAPI::MakeWaypoint({phantom});
-            waypoint.values.emplace("matchings_index", matching_index.sub_matching_index);
-            waypoint.values.emplace("waypoint_index", matching_index.point_index);
-            waypoint.values.emplace("alternatives_count",
-                                    sub_matchings[matching_index.sub_matching_index]
-                                        .alternatives_count[matching_index.point_index]);
+            waypoint.values["matchings_index"] = matching_index.sub_matching_index;
+            waypoint.values["waypoint_index"] = matching_index.point_index;
+            waypoint.values["alternatives_count"] =
+                sub_matchings[matching_index.sub_matching_index]
+                    .alternatives_count[matching_index.point_index];
            // waypoint indices need to be adjusted if route legs were collapsed
            // waypoint parameter assumes there is only one match object
            if (!parameters.waypoints.empty())
@ -217,7 +216,7 @@ class MatchAPI final : public RouteAPI
                    waypoint.values["waypoint_index"] = util::json::Null();
                }
            }
-            waypoints.values.emplace_back(std::move(waypoint));
+            waypoints.values.push_back(std::move(waypoint));
        }

        return waypoints;
--- a/include/engine/api/match_parameters.hpp
+++ b/include/engine/api/match_parameters.hpp
@ -67,7 +67,7 @@ struct MatchParameters : public RouteParameters
    MatchParameters(const std::vector<unsigned> &timestamps_,
                    GapsType gaps_,
                    bool tidy_,
-                    Args &&...args_)
+                    Args &&... args_)
        : MatchParameters(timestamps_, gaps_, tidy_, {}, std::forward<Args>(args_)...)
    {
    }
@ -77,7 +77,7 @@ struct MatchParameters : public RouteParameters
                    GapsType gaps_,
                    bool tidy_,
                    const std::vector<std::size_t> &waypoints_,
-                    Args &&...args_)
+                    Args &&... args_)
        : RouteParameters{std::forward<Args>(args_)..., waypoints_}, timestamps{std::move(
                                                                         timestamps_)},
          gaps(gaps_), tidy(tidy_)
--- a/include/engine/api/nearest_api.hpp
+++ b/include/engine/api/nearest_api.hpp
@ -29,14 +29,14 @@ class NearestAPI final : public BaseAPI
        BOOST_ASSERT(phantom_nodes.size() == 1);
        BOOST_ASSERT(parameters.coordinates.size() == 1);

-        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
+        if (response.is<flatbuffers::FlatBufferBuilder>())
        {
-            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
+            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
            MakeResponse(phantom_nodes, fb_result);
        }
        else
        {
-            auto &json_result = std::get<util::json::Object>(response);
+            auto &json_result = response.get<util::json::Object>();
            MakeResponse(phantom_nodes, json_result);
        }
    }
@ -45,7 +45,7 @@ class NearestAPI final : public BaseAPI
                      flatbuffers::FlatBufferBuilder &fb_result) const
    {
        auto data_timestamp = facade.GetTimestamp();
-        std::optional<flatbuffers::Offset<flatbuffers::String>> data_version_string = std::nullopt;
+        boost::optional<flatbuffers::Offset<flatbuffers::String>> data_version_string = boost::none;
        if (!data_timestamp.empty())
        {
            data_version_string = fb_result.CreateString(data_timestamp);
@ -57,20 +57,20 @@ class NearestAPI final : public BaseAPI
        {
            std::vector<flatbuffers::Offset<fbresult::Waypoint>> waypoints;
            waypoints.resize(phantom_nodes.front().size());
-            std::transform(phantom_nodes.front().begin(),
-                           phantom_nodes.front().end(),
-                           waypoints.begin(),
-                           [this, &fb_result](const PhantomNodeWithDistance &phantom_with_distance)
-                           {
-                               auto &phantom_node = phantom_with_distance.phantom_node;
+            std::transform(
+                phantom_nodes.front().begin(),
+                phantom_nodes.front().end(),
+                waypoints.begin(),
+                [this, &fb_result](const PhantomNodeWithDistance &phantom_with_distance) {
+                    auto &phantom_node = phantom_with_distance.phantom_node;

-                               auto node_values = MakeNodes(phantom_node);
-                               fbresult::Uint64Pair nodes{node_values.first, node_values.second};
+                    auto node_values = MakeNodes(phantom_node);
+                    fbresult::Uint64Pair nodes{node_values.first, node_values.second};

-                               auto waypoint = MakeWaypoint(&fb_result, {phantom_node});
-                               waypoint->add_nodes(&nodes);
-                               return waypoint->Finish();
-                           });
+                    auto waypoint = MakeWaypoint(&fb_result, {phantom_node});
+                    waypoint->add_nodes(&nodes);
+                    return waypoint->Finish();
+                });

            waypoints_vector = fb_result.CreateVector(waypoints);
        }
@ -94,29 +94,28 @@ class NearestAPI final : public BaseAPI
            std::transform(phantom_nodes.front().begin(),
                           phantom_nodes.front().end(),
                           waypoints.values.begin(),
-                           [this](const PhantomNodeWithDistance &phantom_with_distance)
-                           {
+                           [this](const PhantomNodeWithDistance &phantom_with_distance) {
                               auto &phantom_node = phantom_with_distance.phantom_node;
                               auto waypoint = MakeWaypoint({phantom_node});

                               util::json::Array nodes;
-                               nodes.values.reserve(2);

                               auto node_values = MakeNodes(phantom_node);

-                               nodes.values.emplace_back(node_values.first);
-                               nodes.values.emplace_back(node_values.second);
-                               waypoint.values.emplace("nodes", std::move(nodes));
+                               nodes.values.push_back(node_values.first);
+                               nodes.values.push_back(node_values.second);
+                               waypoint.values["nodes"] = std::move(nodes);
+
                               return waypoint;
                           });
-            response.values.emplace("waypoints", std::move(waypoints));
+            response.values["waypoints"] = std::move(waypoints);
        }

-        response.values.emplace("code", "Ok");
+        response.values["code"] = "Ok";
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values.emplace("data_version", data_timestamp);
+            response.values["data_version"] = data_timestamp;
        }
    }

--- a/include/engine/api/route_api.hpp
+++ b/include/engine/api/route_api.hpp
@ -50,14 +50,14 @@ class RouteAPI : public BaseAPI
    {
        BOOST_ASSERT(!raw_routes.routes.empty());

-        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
+        if (response.is<flatbuffers::FlatBufferBuilder>())
        {
-            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
+            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
            MakeResponse(raw_routes, waypoint_candidates, fb_result);
        }
        else
        {
-            auto &json_result = std::get<util::json::Object>(response);
+            auto &json_result = response.get<util::json::Object>();
            MakeResponse(raw_routes, waypoint_candidates, json_result);
        }
    }
@ -77,10 +77,9 @@ class RouteAPI : public BaseAPI
        }

        auto response =
-            MakeFBResponse(raw_routes,
-                           fb_result,
-                           [this, &waypoint_candidates, &fb_result]()
-                           { return BaseAPI::MakeWaypoints(&fb_result, waypoint_candidates); });
+            MakeFBResponse(raw_routes, fb_result, [this, &waypoint_candidates, &fb_result]() {
+                return BaseAPI::MakeWaypoints(&fb_result, waypoint_candidates);
+            });

        if (!data_timestamp.empty())
        {
@ -110,14 +109,14 @@ class RouteAPI : public BaseAPI

        if (!parameters.skip_waypoints)
        {
-            response.values.emplace("waypoints", BaseAPI::MakeWaypoints(waypoint_candidates));
+            response.values["waypoints"] = BaseAPI::MakeWaypoints(waypoint_candidates);
        }
-        response.values.emplace("routes", std::move(jsRoutes));
-        response.values.emplace("code", "Ok");
+        response.values["routes"] = std::move(jsRoutes);
+        response.values["code"] = "Ok";
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values.emplace("data_version", data_timestamp);
+            response.values["data_version"] = data_timestamp;
        }
    }

@ -158,8 +157,8 @@ class RouteAPI : public BaseAPI
    }

    template <typename ForwardIter>
-    std::variant<flatbuffers::Offset<flatbuffers::String>,
-                 flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
+    mapbox::util::variant<flatbuffers::Offset<flatbuffers::String>,
+                          flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
    MakeGeometry(flatbuffers::FlatBufferBuilder &builder, ForwardIter begin, ForwardIter end) const
    {
        if (parameters.geometries == RouteParameters::GeometriesType::Polyline)
@ -172,22 +171,17 @@ class RouteAPI : public BaseAPI
        }
        std::vector<fbresult::Position> coordinates;
        coordinates.resize(std::distance(begin, end));
-        std::transform(begin,
-                       end,
-                       coordinates.begin(),
-                       [](const Coordinate &c)
-                       {
-                           return fbresult::Position{
-                               static_cast<float>(util::toFloating(c.lon).__value),
-                               static_cast<float>(util::toFloating(c.lat).__value)};
-                       });
+        std::transform(begin, end, coordinates.begin(), [](const Coordinate &c) {
+            return fbresult::Position{static_cast<float>(util::toFloating(c.lon).__value),
+                                      static_cast<float>(util::toFloating(c.lat).__value)};
+        });
        return builder.CreateVectorOfStructs(coordinates);
    }

-    std::optional<util::json::Value>
-    MakeGeometry(std::optional<std::vector<Coordinate>> &&annotations) const
+    boost::optional<util::json::Value>
+    MakeGeometry(boost::optional<std::vector<Coordinate>> &&annotations) const
    {
-        std::optional<util::json::Value> json_geometry;
+        boost::optional<util::json::Value> json_geometry;
        if (annotations)
        {
            auto begin = annotations->begin();
@ -340,8 +334,8 @@ class RouteAPI : public BaseAPI
                                  unpacked_path_segments,
                                  source_traversed_in_reverse,
                                  target_traversed_in_reverse);
-        std::vector<guidance::RouteLeg> &legs = legs_info.first;
-        std::vector<guidance::LegGeometry> &leg_geometries = legs_info.second;
+        std::vector<guidance::RouteLeg> legs = legs_info.first;
+        std::vector<guidance::LegGeometry> leg_geometries = legs_info.second;
        auto route = guidance::assembleRoute(legs);

        // Fill legs
@ -360,8 +354,9 @@ class RouteAPI : public BaseAPI
                std::transform(leg.steps.begin(),
                               leg.steps.end(),
                               legSteps.begin(),
-                               [this, &fb_result, &leg_geometry](auto &step)
-                               { return this->MakeFBStep(fb_result, leg_geometry, step); });
+                               [this, &fb_result, &leg_geometry](auto &step) {
+                                   return this->MakeFBStep(fb_result, leg_geometry, step);
+                               });
            }
            auto steps_vector = fb_result.CreateVector(legSteps);

@ -408,8 +403,8 @@ class RouteAPI : public BaseAPI

        // Fill geometry
        auto overview = MakeOverview(leg_geometries);
-        std::variant<flatbuffers::Offset<flatbuffers::String>,
-                     flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
+        mapbox::util::variant<flatbuffers::Offset<flatbuffers::String>,
+                              flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
            geometry;
        if (overview)
        {
@ -426,7 +421,8 @@ class RouteAPI : public BaseAPI
        routeObject.add_legs(legs_vector);
        if (overview)
        {
-            std::visit(GeometryVisitor<fbresult::RouteObjectBuilder>(routeObject), geometry);
+            mapbox::util::apply_visitor(GeometryVisitor<fbresult::RouteObjectBuilder>(routeObject),
+                                        geometry);
        }

        return routeObject.Finish();
@ -442,58 +438,58 @@ class RouteAPI : public BaseAPI
        if (requested_annotations & RouteParameters::AnnotationsType::Speed)
        {
            double prev_speed = 0;
-            speed = GetAnnotations<float>(
-                fb_result,
-                leg_geometry,
-                [&prev_speed](const guidance::LegGeometry::Annotation &anno)
-                {
-                    if (anno.duration < std::numeric_limits<float>::min())
-                    {
-                        return prev_speed;
-                    }
-                    else
-                    {
-                        auto speed = std::round(anno.distance / anno.duration * 10.) / 10.;
-                        prev_speed = speed;
-                        return util::json::clamp_float(speed);
-                    }
-                });
+            speed =
+                GetAnnotations<float>(fb_result,
+                                      leg_geometry,
+                                      [&prev_speed](const guidance::LegGeometry::Annotation &anno) {
+                                          if (anno.duration < std::numeric_limits<float>::min())
+                                          {
+                                              return prev_speed;
+                                          }
+                                          else
+                                          {
+                                              auto speed =
+                                                  round(anno.distance / anno.duration * 10.) / 10.;
+                                              prev_speed = speed;
+                                              return util::json::clamp_float(speed);
+                                          }
+                                      });
        }

        flatbuffers::Offset<flatbuffers::Vector<uint32_t>> duration;
        if (requested_annotations & RouteParameters::AnnotationsType::Duration)
        {
-            duration = GetAnnotations<uint32_t>(fb_result,
-                                                leg_geometry,
-                                                [](const guidance::LegGeometry::Annotation &anno)
-                                                { return anno.duration; });
+            duration = GetAnnotations<uint32_t>(
+                fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
+                    return anno.duration;
+                });
        }

        flatbuffers::Offset<flatbuffers::Vector<uint32_t>> distance;
        if (requested_annotations & RouteParameters::AnnotationsType::Distance)
        {
-            distance = GetAnnotations<uint32_t>(fb_result,
-                                                leg_geometry,
-                                                [](const guidance::LegGeometry::Annotation &anno)
-                                                { return anno.distance; });
+            distance = GetAnnotations<uint32_t>(
+                fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
+                    return anno.distance;
+                });
        }

        flatbuffers::Offset<flatbuffers::Vector<uint32_t>> weight;
        if (requested_annotations & RouteParameters::AnnotationsType::Weight)
        {
-            weight = GetAnnotations<uint32_t>(fb_result,
-                                              leg_geometry,
-                                              [](const guidance::LegGeometry::Annotation &anno)
-                                              { return anno.weight; });
+            weight = GetAnnotations<uint32_t>(
+                fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
+                    return anno.weight;
+                });
        }

        flatbuffers::Offset<flatbuffers::Vector<uint32_t>> datasources;
        if (requested_annotations & RouteParameters::AnnotationsType::Datasources)
        {
-            datasources = GetAnnotations<uint32_t>(fb_result,
-                                                   leg_geometry,
-                                                   [](const guidance::LegGeometry::Annotation &anno)
-                                                   { return anno.datasource; });
+            datasources = GetAnnotations<uint32_t>(
+                fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
+                    return anno.datasource;
+                });
        }
        std::vector<uint32_t> nodes;
        if (requested_annotations & RouteParameters::AnnotationsType::Nodes)
@ -643,7 +639,7 @@ class RouteAPI : public BaseAPI
        stepBuilder.add_rotary_pronunciation(rotary_pronunciation_string);
        stepBuilder.add_intersections(intersections_vector);
        stepBuilder.add_maneuver(maneuver_buffer);
-        std::visit(GeometryVisitor<fbresult::StepBuilder>(stepBuilder), geometry);
+        mapbox::util::apply_visitor(GeometryVisitor<fbresult::StepBuilder>(stepBuilder), geometry);
        return stepBuilder.Finish();
    };

@ -657,8 +653,7 @@ class RouteAPI : public BaseAPI
            step.intersections.begin(),
            step.intersections.end(),
            intersections.begin(),
-            [&fb_result, this](const guidance::IntermediateIntersection &intersection)
-            {
+            [&fb_result, this](const guidance::IntermediateIntersection &intersection) {
                std::vector<flatbuffers::Offset<fbresult::Lane>> lanes;
                if (json::detail::hasValidLanes(intersection))
                {
@ -686,11 +681,11 @@ class RouteAPI : public BaseAPI
                auto bearings_vector = fb_result.CreateVector(intersection.bearings);
                std::vector<flatbuffers::Offset<flatbuffers::String>> classes;
                classes.resize(intersection.classes.size());
-                std::transform(intersection.classes.begin(),
-                               intersection.classes.end(),
-                               classes.begin(),
-                               [&fb_result](const std::string &cls)
-                               { return fb_result.CreateString(cls); });
+                std::transform(
+                    intersection.classes.begin(),
+                    intersection.classes.end(),
+                    classes.begin(),
+                    [&fb_result](const std::string &cls) { return fb_result.CreateString(cls); });
                auto classes_vector = fb_result.CreateVector(classes);
                auto entry_vector = fb_result.CreateVector(intersection.entry);

@ -716,18 +711,18 @@ class RouteAPI : public BaseAPI
                                  unpacked_path_segments,
                                  source_traversed_in_reverse,
                                  target_traversed_in_reverse);
-        std::vector<guidance::RouteLeg> &legs = legs_info.first;
-        std::vector<guidance::LegGeometry> &leg_geometries = legs_info.second;
+        std::vector<guidance::RouteLeg> legs = legs_info.first;
+        std::vector<guidance::LegGeometry> leg_geometries = legs_info.second;

        auto route = guidance::assembleRoute(legs);
-        std::optional<util::json::Value> json_overview = MakeGeometry(MakeOverview(leg_geometries));
+        boost::optional<util::json::Value> json_overview =
+            MakeGeometry(MakeOverview(leg_geometries));

        std::vector<util::json::Value> step_geometries;
        const auto total_step_count =
-            std::accumulate(legs.begin(),
-                            legs.end(),
-                            0,
-                            [](const auto &v, const auto &leg) { return v + leg.steps.size(); });
+            std::accumulate(legs.begin(), legs.end(), 0, [](const auto &v, const auto &leg) {
+                return v + leg.steps.size();
+            });
        step_geometries.reserve(total_step_count);

        for (const auto idx : util::irange<std::size_t>(0UL, legs.size()))
@ -738,8 +733,7 @@ class RouteAPI : public BaseAPI
                legs[idx].steps.begin(),
                legs[idx].steps.end(),
                std::back_inserter(step_geometries),
-                [this, &leg_geometry](const guidance::RouteStep &step)
-                {
+                [this, &leg_geometry](const guidance::RouteStep &step) {
                    if (parameters.geometries == RouteParameters::GeometriesType::Polyline)
                    {
                        return static_cast<util::json::Value>(json::makePolyline<100000>(
@ -783,57 +777,47 @@ class RouteAPI : public BaseAPI
                if (requested_annotations & RouteParameters::AnnotationsType::Speed)
                {
                    double prev_speed = 0;
-                    annotation.values.emplace(
-                        "speed",
-                        GetAnnotations(leg_geometry,
-                                       [&prev_speed](const guidance::LegGeometry::Annotation &anno)
-                                       {
-                                           if (anno.duration < std::numeric_limits<double>::min())
-                                           {
-                                               return prev_speed;
-                                           }
-                                           else
-                                           {
-                                               auto speed =
-                                                   std::round(anno.distance / anno.duration * 10.) /
-                                                   10.;
-                                               prev_speed = speed;
-                                               return util::json::clamp_float(speed);
-                                           }
-                                       }));
+                    annotation.values["speed"] = GetAnnotations(
+                        leg_geometry, [&prev_speed](const guidance::LegGeometry::Annotation &anno) {
+                            if (anno.duration < std::numeric_limits<double>::min())
+                            {
+                                return prev_speed;
+                            }
+                            else
+                            {
+                                auto speed = std::round(anno.distance / anno.duration * 10.) / 10.;
+                                prev_speed = speed;
+                                return util::json::clamp_float(speed);
+                            }
+                        });
                }

                if (requested_annotations & RouteParameters::AnnotationsType::Duration)
                {
-                    annotation.values.emplace(
-                        "duration",
-                        GetAnnotations(leg_geometry,
-                                       [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.duration; }));
+                    annotation.values["duration"] = GetAnnotations(
+                        leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
+                            return anno.duration;
+                        });
                }
                if (requested_annotations & RouteParameters::AnnotationsType::Distance)
                {
-                    annotation.values.emplace(
-                        "distance",
-                        GetAnnotations(leg_geometry,
-                                       [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.distance; }));
+                    annotation.values["distance"] = GetAnnotations(
+                        leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
+                            return anno.distance;
+                        });
                }
                if (requested_annotations & RouteParameters::AnnotationsType::Weight)
                {
-                    annotation.values.emplace(
-                        "weight",
-                        GetAnnotations(leg_geometry,
-                                       [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.weight; }));
+                    annotation.values["weight"] = GetAnnotations(
+                        leg_geometry,
+                        [](const guidance::LegGeometry::Annotation &anno) { return anno.weight; });
                }
                if (requested_annotations & RouteParameters::AnnotationsType::Datasources)
                {
-                    annotation.values.emplace(
-                        "datasources",
-                        GetAnnotations(leg_geometry,
-                                       [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.datasource; }));
+                    annotation.values["datasources"] = GetAnnotations(
+                        leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
+                            return anno.datasource;
+                        });
                }
                if (requested_annotations & RouteParameters::AnnotationsType::Nodes)
                {
@ -844,7 +828,7 @@ class RouteAPI : public BaseAPI
                        nodes.values.push_back(
                            static_cast<std::uint64_t>(facade.GetOSMNodeIDOfNode(node_id)));
                    }
-                    annotation.values.emplace("nodes", std::move(nodes));
+                    annotation.values["nodes"] = std::move(nodes);
                }
                // Add any supporting metadata, if needed
                if (requested_annotations & RouteParameters::AnnotationsType::Datasources)
@ -860,8 +844,8 @@ class RouteAPI : public BaseAPI
                            break;
                        datasource_names.values.push_back(std::string(facade.GetDatasourceName(i)));
                    }
-                    metadata.values.emplace("datasource_names", datasource_names);
-                    annotation.values.emplace("metadata", metadata);
+                    metadata.values["datasource_names"] = datasource_names;
+                    annotation.values["metadata"] = metadata;
                }

                annotations.push_back(std::move(annotation));
@ -996,10 +980,10 @@ class RouteAPI : public BaseAPI
        return result;
    }

-    std::optional<std::vector<Coordinate>>
+    boost::optional<std::vector<Coordinate>>
    MakeOverview(const std::vector<guidance::LegGeometry> &leg_geometries) const
    {
-        std::optional<std::vector<Coordinate>> overview;
+        boost::optional<std::vector<Coordinate>> overview;
        if (parameters.overview != RouteParameters::OverviewType::False)
        {
            const auto use_simplification =
--- a/include/engine/api/route_parameters.hpp
+++ b/include/engine/api/route_parameters.hpp
@ -82,8 +82,8 @@ struct RouteParameters : public BaseParameters
                    const bool alternatives_,
                    const GeometriesType geometries_,
                    const OverviewType overview_,
-                    const std::optional<bool> continue_straight_,
-                    Args &&...args_)
+                    const boost::optional<bool> continue_straight_,
+                    Args &&... args_)
        // Once we perfectly-forward `args` (see #2990) this constructor can delegate to the one
        // below.
        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
@ -100,8 +100,8 @@ struct RouteParameters : public BaseParameters
                    const bool annotations_,
                    const GeometriesType geometries_,
                    const OverviewType overview_,
-                    const std::optional<bool> continue_straight_,
-                    Args &&...args_)
+                    const boost::optional<bool> continue_straight_,
+                    Args &&... args_)
        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
          number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_},
          annotations_type{annotations_ ? AnnotationsType::All : AnnotationsType::None},
@ -118,8 +118,8 @@ struct RouteParameters : public BaseParameters
                    const AnnotationsType annotations_,
                    const GeometriesType geometries_,
                    const OverviewType overview_,
-                    const std::optional<bool> continue_straight_,
-                    Args &&...args_)
+                    const boost::optional<bool> continue_straight_,
+                    Args &&... args_)
        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
          number_of_alternatives{alternatives_ ? 1u : 0u},
          annotations{annotations_ != AnnotationsType::None}, annotations_type{annotations_},
@ -135,9 +135,9 @@ struct RouteParameters : public BaseParameters
                    const bool annotations_,
                    const GeometriesType geometries_,
                    const OverviewType overview_,
-                    const std::optional<bool> continue_straight_,
+                    const boost::optional<bool> continue_straight_,
                    std::vector<std::size_t> waypoints_,
-                    const Args &&...args_)
+                    const Args &&... args_)
        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
          number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_},
          annotations_type{annotations_ ? AnnotationsType::All : AnnotationsType::None},
@ -153,9 +153,9 @@ struct RouteParameters : public BaseParameters
                    const AnnotationsType annotations_,
                    const GeometriesType geometries_,
                    const OverviewType overview_,
-                    const std::optional<bool> continue_straight_,
+                    const boost::optional<bool> continue_straight_,
                    std::vector<std::size_t> waypoints_,
-                    Args &&...args_)
+                    Args &&... args_)
        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
          number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_ !=
                                                                       AnnotationsType::None},
@ -172,7 +172,7 @@ struct RouteParameters : public BaseParameters
    AnnotationsType annotations_type = AnnotationsType::None;
    GeometriesType geometries = GeometriesType::Polyline;
    OverviewType overview = OverviewType::Simplified;
-    std::optional<bool> continue_straight;
+    boost::optional<bool> continue_straight;
    std::vector<std::size_t> waypoints;

    bool IsValid() const
@ -180,9 +180,9 @@ struct RouteParameters : public BaseParameters
        const auto coordinates_ok = coordinates.size() >= 2;
        const auto base_params_ok = BaseParameters::IsValid();
        const auto valid_waypoints =
-            std::all_of(waypoints.begin(),
-                        waypoints.end(),
-                        [this](const auto &w) { return w < coordinates.size(); });
+            std::all_of(waypoints.begin(), waypoints.end(), [this](const auto &w) {
+                return w < coordinates.size();
+            });
        return coordinates_ok && base_params_ok && valid_waypoints;
    }
 };
--- a/include/engine/api/table_api.hpp
+++ b/include/engine/api/table_api.hpp
@ -50,14 +50,14 @@ class TableAPI final : public BaseAPI
                 const std::vector<TableCellRef> &fallback_speed_cells,
                 osrm::engine::api::ResultT &response) const
    {
-        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
+        if (response.is<flatbuffers::FlatBufferBuilder>())
        {
-            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
+            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
            MakeResponse(tables, candidates, fallback_speed_cells, fb_result);
        }
        else
        {
-            auto &json_result = std::get<util::json::Object>(response);
+            auto &json_result = response.get<util::json::Object>();
            MakeResponse(tables, candidates, fallback_speed_cells, json_result);
        }
    }
@ -137,7 +137,7 @@ class TableAPI final : public BaseAPI
            speed_cells = MakeEstimatesTable(fb_result, fallback_speed_cells);
        }

-        fbresult::TableResultBuilder table(fb_result);
+        fbresult::TableBuilder table(fb_result);
        table.add_destinations(destinations);
        table.add_rows(number_of_sources);
        table.add_cols(number_of_destinations);
@ -179,7 +179,7 @@ class TableAPI final : public BaseAPI
        {
            if (!parameters.skip_waypoints)
            {
-                response.values.emplace("sources", MakeWaypoints(candidates));
+                response.values["sources"] = MakeWaypoints(candidates);
            }
            number_of_sources = candidates.size();
        }
@ -187,7 +187,7 @@ class TableAPI final : public BaseAPI
        {
            if (!parameters.skip_waypoints)
            {
-                response.values.emplace("sources", MakeWaypoints(candidates, parameters.sources));
+                response.values["sources"] = MakeWaypoints(candidates, parameters.sources);
            }
        }

@ -195,7 +195,7 @@ class TableAPI final : public BaseAPI
        {
            if (!parameters.skip_waypoints)
            {
-                response.values.emplace("destinations", MakeWaypoints(candidates));
+                response.values["destinations"] = MakeWaypoints(candidates);
            }
            number_of_destinations = candidates.size();
        }
@ -203,37 +203,34 @@ class TableAPI final : public BaseAPI
        {
            if (!parameters.skip_waypoints)
            {
-                response.values.emplace("destinations",
-                                        MakeWaypoints(candidates, parameters.destinations));
+                response.values["destinations"] =
+                    MakeWaypoints(candidates, parameters.destinations);
            }
        }

        if (parameters.annotations & TableParameters::AnnotationsType::Duration)
        {
-            response.values.emplace(
-                "durations",
-                MakeDurationTable(tables.first, number_of_sources, number_of_destinations));
+            response.values["durations"] =
+                MakeDurationTable(tables.first, number_of_sources, number_of_destinations);
        }

        if (parameters.annotations & TableParameters::AnnotationsType::Distance)
        {
-            response.values.emplace(
-                "distances",
-                MakeDistanceTable(tables.second, number_of_sources, number_of_destinations));
+            response.values["distances"] =
+                MakeDistanceTable(tables.second, number_of_sources, number_of_destinations);
        }

        if (parameters.fallback_speed != from_alias<double>(INVALID_FALLBACK_SPEED) &&
            parameters.fallback_speed > 0)
        {
-            response.values.emplace("fallback_speed_cells",
-                                    MakeEstimatesTable(fallback_speed_cells));
+            response.values["fallback_speed_cells"] = MakeEstimatesTable(fallback_speed_cells);
        }

-        response.values.emplace("code", "Ok");
+        response.values["code"] = "Ok";
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values.emplace("data_version", data_timestamp);
+            response.values["data_version"] = data_timestamp;
        }
    }

@ -248,8 +245,9 @@ class TableAPI final : public BaseAPI

        boost::range::transform(candidates,
                                std::back_inserter(waypoints),
-                                [this, &builder](const PhantomNodeCandidates &candidates)
-                                { return BaseAPI::MakeWaypoint(&builder, candidates)->Finish(); });
+                                [this, &builder](const PhantomNodeCandidates &candidates) {
+                                    return BaseAPI::MakeWaypoint(&builder, candidates)->Finish();
+                                });
        return builder.CreateVector(waypoints);
    }

@ -263,8 +261,7 @@ class TableAPI final : public BaseAPI
        boost::range::transform(
            indices,
            std::back_inserter(waypoints),
-            [this, &builder, &candidates](const std::size_t idx)
-            {
+            [this, &builder, &candidates](const std::size_t idx) {
                BOOST_ASSERT(idx < candidates.size());
                return BaseAPI::MakeWaypoint(&builder, candidates[idx])->Finish();
            });
@ -277,17 +274,14 @@ class TableAPI final : public BaseAPI
    {
        std::vector<float> distance_table;
        distance_table.resize(values.size());
-        std::transform(values.begin(),
-                       values.end(),
-                       distance_table.begin(),
-                       [](const EdgeDuration duration)
-                       {
-                           if (duration == MAXIMAL_EDGE_DURATION)
-                           {
-                               return 0.;
-                           }
-                           return from_alias<double>(duration) / 10.;
-                       });
+        std::transform(
+            values.begin(), values.end(), distance_table.begin(), [](const EdgeDuration duration) {
+                if (duration == MAXIMAL_EDGE_DURATION)
+                {
+                    return 0.;
+                }
+                return from_alias<double>(duration) / 10.;
+            });
        return builder.CreateVector(distance_table);
    }

@ -297,17 +291,14 @@ class TableAPI final : public BaseAPI
    {
        std::vector<float> duration_table;
        duration_table.resize(values.size());
-        std::transform(values.begin(),
-                       values.end(),
-                       duration_table.begin(),
-                       [](const EdgeDistance distance)
-                       {
-                           if (distance == INVALID_EDGE_DISTANCE)
-                           {
-                               return 0.;
-                           }
-                           return std::round(from_alias<double>(distance) * 10) / 10.;
-                       });
+        std::transform(
+            values.begin(), values.end(), duration_table.begin(), [](const EdgeDistance distance) {
+                if (distance == INVALID_EDGE_DISTANCE)
+                {
+                    return 0.;
+                }
+                return std::round(from_alias<double>(distance) * 10) / 10.;
+            });
        return builder.CreateVector(duration_table);
    }

@ -317,13 +308,11 @@ class TableAPI final : public BaseAPI
    {
        std::vector<uint32_t> fb_table;
        fb_table.reserve(fallback_speed_cells.size());
-        std::for_each(fallback_speed_cells.begin(),
-                      fallback_speed_cells.end(),
-                      [&](const auto &cell)
-                      {
-                          fb_table.push_back(cell.row);
-                          fb_table.push_back(cell.column);
-                      });
+        std::for_each(
+            fallback_speed_cells.begin(), fallback_speed_cells.end(), [&](const auto &cell) {
+                fb_table.push_back(cell.row);
+                fb_table.push_back(cell.column);
+            });
        return builder.CreateVector(fb_table);
    }

@ -336,8 +325,9 @@ class TableAPI final : public BaseAPI

        boost::range::transform(candidates,
                                std::back_inserter(json_waypoints.values),
-                                [this](const PhantomNodeCandidates &candidates)
-                                { return BaseAPI::MakeWaypoint(candidates); });
+                                [this](const PhantomNodeCandidates &candidates) {
+                                    return BaseAPI::MakeWaypoint(candidates);
+                                });
        return json_waypoints;
    }

@ -348,8 +338,7 @@ class TableAPI final : public BaseAPI
        json_waypoints.values.reserve(indices.size());
        boost::range::transform(indices,
                                std::back_inserter(json_waypoints.values),
-                                [this, &candidates](const std::size_t idx)
-                                {
+                                [this, &candidates](const std::size_t idx) {
                                    BOOST_ASSERT(idx < candidates.size());
                                    return BaseAPI::MakeWaypoint(candidates[idx]);
                                });
@ -370,8 +359,7 @@ class TableAPI final : public BaseAPI
            std::transform(row_begin_iterator,
                           row_end_iterator,
                           json_row.values.begin(),
-                           [](const EdgeDuration duration)
-                           {
+                           [](const EdgeDuration duration) {
                               if (duration == MAXIMAL_EDGE_DURATION)
                               {
                                   return util::json::Value(util::json::Null());
@ -380,8 +368,7 @@ class TableAPI final : public BaseAPI
                               return util::json::Value(
                                   util::json::Number(from_alias<double>(duration) / 10.));
                           });
-
-            json_table.values.push_back(util::json::Value{json_row});
+            json_table.values.push_back(std::move(json_row));
        }
        return json_table;
    }
@ -400,8 +387,7 @@ class TableAPI final : public BaseAPI
            std::transform(row_begin_iterator,
                           row_end_iterator,
                           json_row.values.begin(),
-                           [](const EdgeDistance distance)
-                           {
+                           [](const EdgeDistance distance) {
                               if (distance == INVALID_EDGE_DISTANCE)
                               {
                                   return util::json::Value(util::json::Null());
@ -410,7 +396,7 @@ class TableAPI final : public BaseAPI
                               return util::json::Value(util::json::Number(
                                   std::round(from_alias<double>(distance) * 10) / 10.));
                           });
-            json_table.values.push_back(util::json::Value{json_row});
+            json_table.values.push_back(std::move(json_row));
        }
        return json_table;
    }
@ -420,16 +406,11 @@ class TableAPI final : public BaseAPI
    {
        util::json::Array json_table;
        std::for_each(
-            fallback_speed_cells.begin(),
-            fallback_speed_cells.end(),
-            [&](const auto &cell)
-            {
+            fallback_speed_cells.begin(), fallback_speed_cells.end(), [&](const auto &cell) {
                util::json::Array row;
-                util::json::Value jCellRow{util::json::Number(static_cast<double>(cell.row))};
-                util::json::Value jCellColumn{util::json::Number(static_cast<double>(cell.column))};
-                row.values.push_back(jCellRow);
-                row.values.push_back(jCellColumn);
-                json_table.values.push_back(util::json::Value{row});
+                row.values.push_back(util::json::Number(cell.row));
+                row.values.push_back(util::json::Number(cell.column));
+                json_table.values.push_back(std::move(row));
            });
        return json_table;
    }
--- a/include/engine/api/table_parameters.hpp
+++ b/include/engine/api/table_parameters.hpp
@ -81,7 +81,7 @@ struct TableParameters : public BaseParameters
    template <typename... Args>
    TableParameters(std::vector<std::size_t> sources_,
                    std::vector<std::size_t> destinations_,
-                    Args &&...args_)
+                    Args &&... args_)
        : BaseParameters{std::forward<Args>(args_)...}, sources{std::move(sources_)},
          destinations{std::move(destinations_)}
    {
@ -91,7 +91,7 @@ struct TableParameters : public BaseParameters
    TableParameters(std::vector<std::size_t> sources_,
                    std::vector<std::size_t> destinations_,
                    const AnnotationsType annotations_,
-                    Args &&...args_)
+                    Args &&... args_)
        : BaseParameters{std::forward<Args>(args_)...}, sources{std::move(sources_)},
          destinations{std::move(destinations_)}, annotations{annotations_}
    {
@ -104,7 +104,7 @@ struct TableParameters : public BaseParameters
                    double fallback_speed_,
                    FallbackCoordinateType fallback_coordinate_type_,
                    double scale_factor_,
-                    Args &&...args_)
+                    Args &&... args_)
        : BaseParameters{std::forward<Args>(args_)...}, sources{std::move(sources_)},
          destinations{std::move(destinations_)}, fallback_speed{fallback_speed_},
          fallback_coordinate_type{fallback_coordinate_type_}, annotations{annotations_},
--- a/include/engine/api/trip_api.hpp
+++ b/include/engine/api/trip_api.hpp
@ -27,14 +27,14 @@ class TripAPI final : public RouteAPI
    {
        BOOST_ASSERT(sub_trips.size() == sub_routes.size());

-        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
+        if (response.is<flatbuffers::FlatBufferBuilder>())
        {
-            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
+            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
            MakeResponse(sub_trips, sub_routes, candidates, fb_result);
        }
        else
        {
-            auto &json_result = std::get<util::json::Object>(response);
+            auto &json_result = response.get<util::json::Object>();
            MakeResponse(sub_trips, sub_routes, candidates, json_result);
        }
    }
@ -50,10 +50,10 @@ class TripAPI final : public RouteAPI
            data_version_string = fb_result.CreateString(data_timestamp);
        }

-        auto response = MakeFBResponse(sub_routes,
-                                       fb_result,
-                                       [this, &fb_result, &sub_trips, &candidates]()
-                                       { return MakeWaypoints(fb_result, sub_trips, candidates); });
+        auto response =
+            MakeFBResponse(sub_routes, fb_result, [this, &fb_result, &sub_trips, &candidates]() {
+                return MakeWaypoints(fb_result, sub_trips, candidates);
+            });

        if (!data_timestamp.empty())
        {
@ -79,14 +79,14 @@ class TripAPI final : public RouteAPI
        }
        if (!parameters.skip_waypoints)
        {
-            response.values.emplace("waypoints", MakeWaypoints(sub_trips, candidates));
+            response.values["waypoints"] = MakeWaypoints(sub_trips, candidates);
        }
-        response.values.emplace("trips", std::move(routes));
-        response.values.emplace("code", "Ok");
+        response.values["trips"] = std::move(routes);
+        response.values["code"] = "Ok";
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values.emplace("data_version", data_timestamp);
+            response.values["data_version"] = data_timestamp;
        }
    }

@ -151,8 +151,8 @@ class TripAPI final : public RouteAPI
            BOOST_ASSERT(!trip_index.NotUsed());

            auto waypoint = BaseAPI::MakeWaypoint(candidates[input_index]);
-            waypoint.values.emplace("trips_index", trip_index.sub_trip_index);
-            waypoint.values.emplace("waypoint_index", trip_index.point_index);
+            waypoint.values["trips_index"] = trip_index.sub_trip_index;
+            waypoint.values["waypoint_index"] = trip_index.point_index;
            waypoints.values.push_back(std::move(waypoint));
        }

--- a/include/engine/api/trip_parameters.hpp
+++ b/include/engine/api/trip_parameters.hpp
@ -30,7 +30,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include "engine/api/route_parameters.hpp"

-#include <optional>
+#include <boost/optional.hpp>
 #include <vector>

 namespace osrm::engine::api
@ -60,7 +60,7 @@ struct TripParameters : public RouteParameters
    TripParameters(SourceType source_,
                   DestinationType destination_,
                   bool roundtrip_,
-                   Args &&...args_)
+                   Args &&... args_)
        : RouteParameters{std::forward<Args>(args_)...}, source{source_},
          destination{destination_}, roundtrip{roundtrip_}
    {
--- a/include/engine/approach.hpp
+++ b/include/engine/approach.hpp
@ -36,8 +36,7 @@ namespace osrm::engine
 enum class Approach : std::uint8_t
 {
    CURB = 0,
-    UNRESTRICTED = 1,
-    OPPOSITE = 2
+    UNRESTRICTED = 1

 };
 } // namespace osrm::engine
--- a/include/engine/base64.hpp
+++ b/include/engine/base64.hpp
@ -47,29 +47,24 @@ namespace engine
 // Encodes a chunk of memory to Base64.
 inline std::string encodeBase64(const unsigned char *first, std::size_t size)
 {
-    BOOST_ASSERT(size > 0);
+    std::vector<unsigned char> bytes{first, first + size};
+    BOOST_ASSERT(!bytes.empty());

-    std::string encoded;
-    encoded.reserve(((size + 2) / 3) * 4);
+    std::size_t bytes_to_pad{0};

-    auto padding = (3 - size % 3) % 3;
-
-    BOOST_ASSERT(padding == 0 || padding == 1 || padding == 2);
-
-    for (auto itr = detail::Base64FromBinary(first); itr != detail::Base64FromBinary(first + size);
-         ++itr)
+    while (bytes.size() % 3 != 0)
    {
-        encoded.push_back(*itr);
+        bytes_to_pad += 1;
+        bytes.push_back(0);
    }

-    for (size_t index = 0; index < padding; ++index)
-    {
-        encoded.push_back('=');
-    }
+    BOOST_ASSERT(bytes_to_pad == 0 || bytes_to_pad == 1 || bytes_to_pad == 2);
+    BOOST_ASSERT_MSG(0 == bytes.size() % 3, "base64 input data size is not a multiple of 3");

-    BOOST_ASSERT(encoded.size() == (size + 2) / 3 * 4);
+    std::string encoded{detail::Base64FromBinary{bytes.data()},
+                        detail::Base64FromBinary{bytes.data() + (bytes.size() - bytes_to_pad)}};

-    return encoded;
+    return encoded.append(bytes_to_pad, '=');
 }

 // C++11 standard 3.9.1/1: Plain char, signed char, and unsigned char are three distinct types
--- a/include/engine/datafacade/algorithm_datafacade.hpp
+++ b/include/engine/datafacade/algorithm_datafacade.hpp
@ -55,7 +55,7 @@ template <> class AlgorithmDataFacade<CH>

    virtual EdgeID FindSmallestEdge(const NodeID edge_based_node_from,
                                    const NodeID edge_based_node_to,
-                                    const std::function<bool(const EdgeData &)> &filter) const = 0;
+                                    const std::function<bool(EdgeData)> filter) const = 0;
 };

 template <> class AlgorithmDataFacade<MLD>
--- a/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
+++ b/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
@ -130,10 +130,9 @@ class ContiguousInternalMemoryAlgorithmDataFacade<CH> : public datafacade::Algor
            edge_based_node_from, edge_based_node_to, result);
    }

-    EdgeID
-    FindSmallestEdge(const NodeID edge_based_node_from,
-                     const NodeID edge_based_node_to,
-                     const std::function<bool(const EdgeData &)> &filter) const override final
+    EdgeID FindSmallestEdge(const NodeID edge_based_node_from,
+                            const NodeID edge_based_node_to,
+                            std::function<bool(EdgeData)> filter) const override final
    {
        return m_query_graph.FindSmallestEdge(edge_based_node_from, edge_based_node_to, filter);
    }
@ -177,7 +176,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade

    SharedRTree m_static_rtree;
    std::unique_ptr<SharedGeospatialQuery> m_geospatial_query;
-    std::filesystem::path file_index_path;
+    boost::filesystem::path file_index_path;

    std::optional<extractor::IntersectionBearingsView> intersection_bearings_view;

@ -369,33 +368,33 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
    std::vector<PhantomNodeWithDistance>
    NearestPhantomNodesInRange(const util::Coordinate input_coordinate,
                               const double max_distance,
-                               const std::optional<Bearing> bearing,
+                               const boost::optional<Bearing> bearing,
                               const Approach approach,
                               const bool use_all_edges) const override final
    {
        BOOST_ASSERT(m_geospatial_query.get());

        return m_geospatial_query->NearestPhantomNodes(
-            input_coordinate, approach, max_distance, bearing, use_all_edges);
+            input_coordinate, approach, boost::none, max_distance, bearing, use_all_edges);
    }

    std::vector<PhantomNodeWithDistance>
    NearestPhantomNodes(const util::Coordinate input_coordinate,
                        const size_t max_results,
-                        const std::optional<double> max_distance,
-                        const std::optional<Bearing> bearing,
+                        const boost::optional<double> max_distance,
+                        const boost::optional<Bearing> bearing,
                        const Approach approach) const override final
    {
        BOOST_ASSERT(m_geospatial_query.get());

        return m_geospatial_query->NearestPhantomNodes(
-            input_coordinate, approach, max_results, max_distance, bearing, std::nullopt);
+            input_coordinate, approach, max_results, max_distance, bearing, boost::none);
    }

    PhantomCandidateAlternatives
    NearestCandidatesWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
-                                                     const std::optional<double> max_distance,
-                                                     const std::optional<Bearing> bearing,
+                                                     const boost::optional<double> max_distance,
+                                                     const boost::optional<Bearing> bearing,
                                                     const Approach approach,
                                                     const bool use_all_edges) const override final
    {
@ -441,11 +440,9 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
    {
        auto indexes = extractor::getClassIndexes(class_data);
        std::vector<std::string> classes(indexes.size());
-        std::transform(indexes.begin(),
-                       indexes.end(),
-                       classes.begin(),
-                       [this](const auto index)
-                       { return m_profile_properties->GetClassName(index); });
+        std::transform(indexes.begin(), indexes.end(), classes.begin(), [this](const auto index) {
+            return m_profile_properties->GetClassName(index);
+        });

        return classes;
    }
@ -603,21 +600,15 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
        auto found_range = std::equal_range(
            m_maneuver_overrides.begin(), m_maneuver_overrides.end(), edge_based_node_id, Comp{});

-        results.reserve(std::distance(found_range.first, found_range.second));
-
-        std::for_each(found_range.first,
-                      found_range.second,
-                      [&](const auto &override)
-                      {
-                          std::vector<NodeID> sequence(m_maneuver_override_node_sequences.begin() +
-                                                           override.node_sequence_offset_begin,
-                                                       m_maneuver_override_node_sequences.begin() +
-                                                           override.node_sequence_offset_end);
-                          results.push_back(extractor::ManeuverOverride{std::move(sequence),
-                                                                        override.instruction_node,
-                                                                        override.override_type,
-                                                                        override.direction});
-                      });
+        std::for_each(found_range.first, found_range.second, [&](const auto &override) {
+            std::vector<NodeID> sequence(
+                m_maneuver_override_node_sequences.begin() + override.node_sequence_offset_begin,
+                m_maneuver_override_node_sequences.begin() + override.node_sequence_offset_end);
+            results.push_back(extractor::ManeuverOverride{std::move(sequence),
+                                                          override.instruction_node,
+                                                          override.override_type,
+                                                          override.direction});
+        });
        return results;
    }
 };
--- a/include/engine/datafacade/datafacade_base.hpp
+++ b/include/engine/datafacade/datafacade_base.hpp
@ -35,7 +35,6 @@
 #include <cstddef>

 #include <engine/bearing.hpp>
-#include <optional>
 #include <string>
 #include <string_view>
 #include <utility>
@ -127,21 +126,21 @@ class BaseDataFacade
    virtual std::vector<PhantomNodeWithDistance>
    NearestPhantomNodesInRange(const util::Coordinate input_coordinate,
                               const double max_distance,
-                               const std::optional<Bearing> bearing,
+                               const boost::optional<Bearing> bearing,
                               const Approach approach,
                               const bool use_all_edges) const = 0;

    virtual std::vector<PhantomNodeWithDistance>
    NearestPhantomNodes(const util::Coordinate input_coordinate,
                        const size_t max_results,
-                        const std::optional<double> max_distance,
-                        const std::optional<Bearing> bearing,
+                        const boost::optional<double> max_distance,
+                        const boost::optional<Bearing> bearing,
                        const Approach approach) const = 0;

    virtual PhantomCandidateAlternatives
    NearestCandidatesWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
-                                                     const std::optional<double> max_distance,
-                                                     const std::optional<Bearing> bearing,
+                                                     const boost::optional<double> max_distance,
+                                                     const boost::optional<Bearing> bearing,
                                                     const Approach approach,
                                                     const bool use_all_edges) const = 0;

--- a/include/engine/engine_config.hpp
+++ b/include/engine/engine_config.hpp
@ -31,7 +31,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "storage/storage_config.hpp"
 #include "osrm/datasets.hpp"

-#include <filesystem>
+#include <boost/filesystem/path.hpp>
+
 #include <set>
 #include <string>

@ -53,10 +54,14 @@ namespace osrm::engine
 *
 * In addition, shared memory can be used for datasets loaded with osrm-datastore.
 *
- * You can chose between two algorithms:
+ * You can chose between three algorithms:
 *  - Algorithm::CH
 *      Contraction Hierarchies, extremely fast queries but slow pre-processing. The default right
 * now.
+ *  - Algorithm::CoreCH
+ *      Deprecated, to be removed in v6.0
+ *      Contraction Hierachies with partial contraction for faster pre-processing but slower
+ * queries.
 *  - Algorithm::MLD
 *      Multi Level Dijkstra, moderately fast in both pre-processing and query.
 *
@ -69,6 +74,7 @@ struct EngineConfig final
    enum class Algorithm
    {
        CH,
+        CoreCH, // Deprecated, will be removed in v6.0
        MLD
    };

@ -79,10 +85,10 @@ struct EngineConfig final
    int max_locations_map_matching = -1;
    double max_radius_map_matching = -1.0;
    int max_results_nearest = -1;
-    double default_radius = -1.0;
+    boost::optional<double> default_radius = -1.0;
    int max_alternatives = 3; // set an arbitrary upper bound; can be adjusted by user
    bool use_shared_memory = true;
-    std::filesystem::path memory_file;
+    boost::filesystem::path memory_file;
    bool use_mmap = true;
    Algorithm algorithm = Algorithm::CH;
    std::vector<storage::FeatureDataset> disable_feature_dataset;
--- a/include/engine/geospatial_query.hpp
+++ b/include/engine/geospatial_query.hpp
@ -12,8 +12,6 @@

 #include "osrm/coordinate.hpp"

-#include <optional>
-
 #include <algorithm>
 #include <cmath>
 #include <iterator>
@ -49,51 +47,20 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
        return rtree.SearchInBox(bbox);
    }

-    std::vector<PhantomNodeWithDistance>
-    NearestPhantomNodes(const util::Coordinate input_coordinate,
-                        const Approach approach,
-                        const double max_distance,
-                        const std::optional<Bearing> bearing_with_range,
-                        const std::optional<bool> use_all_edges) const
-    {
-        auto results = rtree.SearchInRange(
-            input_coordinate,
-            max_distance,
-            [this, approach, &input_coordinate, &bearing_with_range, &use_all_edges, max_distance](
-                const CandidateSegment &segment)
-            {
-                auto invalidDistance =
-                    CheckSegmentDistance(input_coordinate, segment, max_distance);
-                if (invalidDistance)
-                {
-                    return std::make_pair(false, false);
-                }
-                auto valid = CheckSegmentExclude(segment) &&
-                             CheckApproach(input_coordinate, segment, approach) &&
-                             (use_all_edges ? HasValidEdge(segment, *use_all_edges)
-                                            : HasValidEdge(segment)) &&
-                             (bearing_with_range ? CheckSegmentBearing(segment, *bearing_with_range)
-                                                 : std::make_pair(true, true));
-                return valid;
-            });
-        return MakePhantomNodes(input_coordinate, results);
-    }
-
    // Returns max_results nearest PhantomNodes that are valid within the provided parameters.
    // Does not filter by small/big component!
    std::vector<PhantomNodeWithDistance>
    NearestPhantomNodes(const util::Coordinate input_coordinate,
                        const Approach approach,
-                        const size_t max_results,
-                        const std::optional<double> max_distance,
-                        const std::optional<Bearing> bearing_with_range,
-                        const std::optional<bool> use_all_edges) const
+                        const boost::optional<size_t> max_results,
+                        const boost::optional<double> max_distance,
+                        const boost::optional<Bearing> bearing_with_range,
+                        const boost::optional<bool> use_all_edges) const
    {
        auto results = rtree.Nearest(
            input_coordinate,
            [this, approach, &input_coordinate, &bearing_with_range, &use_all_edges](
-                const CandidateSegment &segment)
-            {
+                const CandidateSegment &segment) {
                auto valid = CheckSegmentExclude(segment) &&
                             CheckApproach(input_coordinate, segment, approach) &&
                             (use_all_edges ? HasValidEdge(segment, *use_all_edges)
@ -102,10 +69,9 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                                                 : std::make_pair(true, true));
                return valid;
            },
-            [this, &max_distance, max_results, input_coordinate](const std::size_t num_results,
-                                                                 const CandidateSegment &segment)
-            {
-                return (num_results >= max_results) ||
+            [this, &max_distance, &max_results, input_coordinate](const std::size_t num_results,
+                                                                  const CandidateSegment &segment) {
+                return (max_results && num_results >= *max_results) ||
                       (max_distance && max_distance != -1.0 &&
                        CheckSegmentDistance(input_coordinate, segment, *max_distance));
            });
@ -121,9 +87,9 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
    PhantomCandidateAlternatives NearestCandidatesWithAlternativeFromBigComponent(
        const util::Coordinate input_coordinate,
        const Approach approach,
-        const std::optional<double> max_distance,
-        const std::optional<Bearing> bearing_with_range,
-        const std::optional<bool> use_all_edges) const
+        const boost::optional<double> max_distance,
+        const boost::optional<Bearing> bearing_with_range,
+        const boost::optional<bool> use_all_edges) const
    {
        bool has_nearest = false;
        bool has_big_component = false;
@ -141,8 +107,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
             &big_component_coord,
             &big_component_distance,
             &use_all_edges,
-             &bearing_with_range](const CandidateSegment &segment)
-            {
+             &bearing_with_range](const CandidateSegment &segment) {
                auto is_big_component = !IsTinyComponent(segment);
                auto not_nearest =
                    has_nearest && segment.fixed_projected_coordinate != nearest_coord;
@ -194,8 +159,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                return use_candidate;
            },
            [this, &has_big_component, &max_distance, input_coordinate, &big_component_distance](
-                const std::size_t /*num_results*/, const CandidateSegment &segment)
-            {
+                const std::size_t /*num_results*/, const CandidateSegment &segment) {
                auto distance = GetSegmentDistance(input_coordinate, segment);
                auto further_than_big_component = distance > big_component_distance;
                auto no_more_candidates = has_big_component && further_than_big_component;
@ -226,17 +190,13 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
        PhantomNodeCandidates nearest_phantoms;
        PhantomNodeCandidates big_component_phantoms;

-        const auto add_to_candidates =
-            [this, &input_coordinate](PhantomNodeCandidates &candidates, const EdgeData data)
-        {
+        const auto add_to_candidates = [this, &input_coordinate](PhantomNodeCandidates &candidates,
+                                                                 const EdgeData data) {
            auto candidate_it =
-                std::find_if(candidates.begin(),
-                             candidates.end(),
-                             [&](const PhantomNode &node)
-                             {
-                                 return data.forward_segment_id.id == node.forward_segment_id.id &&
-                                        data.reverse_segment_id.id == node.reverse_segment_id.id;
-                             });
+                std::find_if(candidates.begin(), candidates.end(), [&](const PhantomNode &node) {
+                    return data.forward_segment_id.id == node.forward_segment_id.id &&
+                           data.reverse_segment_id.id == node.reverse_segment_id.id;
+                });
            if (candidate_it == candidates.end())
            {
                // First candidate from this segment
@ -299,20 +259,17 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
            }
        };

-        std::for_each(results.begin(),
-                      results.end(),
-                      [&](const CandidateSegment &segment)
-                      {
-                          if (segment.fixed_projected_coordinate == nearest_coord)
-                          {
-                              add_to_candidates(nearest_phantoms, segment.data);
-                          }
-                          else
-                          {
-                              // Can only be from a big component for the alternative candidates
-                              add_to_candidates(big_component_phantoms, segment.data);
-                          }
-                      });
+        std::for_each(results.begin(), results.end(), [&](const CandidateSegment &segment) {
+            if (segment.fixed_projected_coordinate == nearest_coord)
+            {
+                add_to_candidates(nearest_phantoms, segment.data);
+            }
+            else
+            {
+                // Can only be from a big component for the alternative candidates
+                add_to_candidates(big_component_phantoms, segment.data);
+            }
+        });
        return std::make_pair(std::move(nearest_phantoms), std::move(big_component_phantoms));
    }

@ -324,8 +281,9 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
        std::transform(results.begin(),
                       results.end(),
                       distance_and_phantoms.begin(),
-                       [this, &input_coordinate](const CandidateSegment &segment)
-                       { return MakePhantomNode(input_coordinate, segment.data); });
+                       [this, &input_coordinate](const CandidateSegment &segment) {
+                           return MakePhantomNode(input_coordinate, segment.data);
+                       });
        return distance_and_phantoms;
    }

@ -442,8 +400,9 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
        }

        // check phantom node segments validity
-        auto areSegmentsValid = [](auto first, auto last) -> bool
-        { return std::find(first, last, INVALID_SEGMENT_WEIGHT) == last; };
+        auto areSegmentsValid = [](auto first, auto last) -> bool {
+            return std::find(first, last, INVALID_SEGMENT_WEIGHT) == last;
+        };
        bool is_forward_valid_source =
            areSegmentsValid(forward_weights.begin(), forward_weights.end());
        bool is_forward_valid_target = areSegmentsValid(
@ -599,7 +558,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
    {
        bool isOnewaySegment =
            !(segment.data.forward_segment_id.enabled && segment.data.reverse_segment_id.enabled);
-        if (!isOnewaySegment && (approach == Approach::CURB || approach == Approach::OPPOSITE))
+        if (!isOnewaySegment && approach == Approach::CURB)
        {
            // Check the counter clockwise
            //
@ -614,9 +573,6 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
            if (datafacade.IsLeftHandDriving(segment.data.forward_segment_id.id))
                input_coordinate_is_at_right = !input_coordinate_is_at_right;

-            if (approach == Approach::OPPOSITE)
-                input_coordinate_is_at_right = !input_coordinate_is_at_right;
-
            return std::make_pair(input_coordinate_is_at_right, (!input_coordinate_is_at_right));
        }
        return std::make_pair(true, true);
--- a/include/engine/guidance/assemble_geometry.hpp
+++ b/include/engine/guidance/assemble_geometry.hpp
@ -37,14 +37,6 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
 {
    LegGeometry geometry;

-    // each container will at most have `leg_data.size()` + 1/2 elements in it
-    // these additional 1/2 elements come from processing of very first and very last segment
-    geometry.locations.reserve(leg_data.size() + 2);
-    geometry.segment_distances.reserve(leg_data.size() + 1);
-    geometry.segment_offsets.reserve(leg_data.size() + 1);
-    geometry.annotations.reserve(leg_data.size() + 1);
-    geometry.node_ids.reserve(leg_data.size() + 2);
-
    // segment 0 first and last
    geometry.segment_offsets.push_back(0);
    geometry.locations.push_back(source_node.location);
--- a/include/engine/guidance/assemble_leg.hpp
+++ b/include/engine/guidance/assemble_leg.hpp
@ -43,8 +43,7 @@ std::array<std::uint32_t, SegmentNumber> summarizeRoute(const datafacade::BaseDa
                                                        const bool target_traversed_in_reverse)
 {
    // merges segments with same name id
-    const auto collapse_segments = [](std::vector<NamedSegment> &segments)
-    {
+    const auto collapse_segments = [](std::vector<NamedSegment> &segments) {
        auto out = segments.begin();
        auto end = segments.end();

@ -76,8 +75,7 @@ std::array<std::uint32_t, SegmentNumber> summarizeRoute(const datafacade::BaseDa
    std::transform(route_data.begin(),
                   route_data.end(),
                   segments.begin(),
-                   [&index, &facade](const PathData &point)
-                   {
+                   [&index, &facade](const PathData &point) {
                       return NamedSegment{point.duration_until_turn,
                                           index++,
                                           facade.GetNameIndex(point.from_edge_based_node)};
@ -89,37 +87,33 @@ std::array<std::uint32_t, SegmentNumber> summarizeRoute(const datafacade::BaseDa
    if (target_duration > EdgeDuration{1})
        segments.push_back({target_duration, index++, facade.GetNameIndex(target_node_id)});
    // this makes sure that the segment with the lowest position comes first
-    std::sort(segments.begin(),
-              segments.end(),
-              [](const NamedSegment &lhs, const NamedSegment &rhs)
-              {
-                  return lhs.name_id < rhs.name_id ||
-                         (lhs.name_id == rhs.name_id && lhs.position < rhs.position);
-              });
+    std::sort(
+        segments.begin(), segments.end(), [](const NamedSegment &lhs, const NamedSegment &rhs) {
+            return lhs.name_id < rhs.name_id ||
+                   (lhs.name_id == rhs.name_id && lhs.position < rhs.position);
+        });
    auto new_end = collapse_segments(segments);
    segments.resize(new_end - segments.begin());

    // Filter out segments with an empty name (name_id == 0)
-    new_end = std::remove_if(segments.begin(),
-                             segments.end(),
-                             [](const NamedSegment &segment) { return segment.name_id == 0; });
+    new_end = std::remove_if(segments.begin(), segments.end(), [](const NamedSegment &segment) {
+        return segment.name_id == 0;
+    });
    segments.resize(new_end - segments.begin());

    // sort descending
-    std::sort(segments.begin(),
-              segments.end(),
-              [](const NamedSegment &lhs, const NamedSegment &rhs)
-              {
-                  return lhs.duration > rhs.duration ||
-                         (lhs.duration == rhs.duration && lhs.position < rhs.position);
-              });
+    std::sort(
+        segments.begin(), segments.end(), [](const NamedSegment &lhs, const NamedSegment &rhs) {
+            return lhs.duration > rhs.duration ||
+                   (lhs.duration == rhs.duration && lhs.position < rhs.position);
+        });

    // make sure the segments are sorted by position
    segments.resize(std::min(segments.size(), SegmentNumber));
-    std::sort(segments.begin(),
-              segments.end(),
-              [](const NamedSegment &lhs, const NamedSegment &rhs)
-              { return lhs.position < rhs.position; });
+    std::sort(
+        segments.begin(), segments.end(), [](const NamedSegment &lhs, const NamedSegment &rhs) {
+            return lhs.position < rhs.position;
+        });

    std::array<std::uint32_t, SegmentNumber> summary;
    std::fill(summary.begin(), summary.end(), EMPTY_NAMEID);
@ -144,8 +138,7 @@ inline std::string assembleSummary(const datafacade::BaseDataFacade &facade,

    // transform a name_id into a string containing either the name, or -if the name is empty-
    // the reference.
-    const auto name_id_to_string = [&](const NameID name_id)
-    {
+    const auto name_id_to_string = [&](const NameID name_id) {
        const auto name = facade.GetNameForID(name_id);
        if (!name.empty())
            return std::string(name);
@ -185,16 +178,14 @@ inline RouteLeg assembleLeg(const datafacade::BaseDataFacade &facade,
    const auto target_weight =
        (target_traversed_in_reverse ? target_node.reverse_weight : target_node.forward_weight);

-    auto duration = std::accumulate(route_data.begin(),
-                                    route_data.end(),
-                                    0,
-                                    [](const double sum, const PathData &data)
-                                    { return sum + from_alias<double>(data.duration_until_turn); });
-    auto weight = std::accumulate(route_data.begin(),
-                                  route_data.end(),
-                                  0,
-                                  [](const double sum, const PathData &data)
-                                  { return sum + from_alias<double>(data.weight_until_turn); });
+    auto duration = std::accumulate(
+        route_data.begin(), route_data.end(), 0, [](const double sum, const PathData &data) {
+            return sum + from_alias<double>(data.duration_until_turn);
+        });
+    auto weight = std::accumulate(
+        route_data.begin(), route_data.end(), 0, [](const double sum, const PathData &data) {
+            return sum + from_alias<double>(data.weight_until_turn);
+        });

    //                 s
    //                 |
--- a/include/engine/guidance/assemble_steps.hpp
+++ b/include/engine/guidance/assemble_steps.hpp
@ -17,9 +17,9 @@
 #include "util/guidance/turn_lanes.hpp"
 #include "util/typedefs.hpp"

+#include <boost/optional.hpp>
 #include <cstddef>
 #include <guidance/turn_bearing.hpp>
-#include <optional>
 #include <vector>

 namespace osrm::engine::guidance
--- a/include/engine/guidance/collapse_scenario_detection.hpp
+++ b/include/engine/guidance/collapse_scenario_detection.hpp
@ -16,7 +16,7 @@ bool basicCollapsePreconditions(const RouteStepIterator first,

 // Staggered intersection are very short zig-zags of a few meters.
 // We do not want to announce these short left-rights or right-lefts:
-//  
+// 
 //      * -> b      a -> *
 //      |       or       |       becomes  a   ->   b
 // a -> *                * -> b
@ -26,7 +26,7 @@ bool isStaggeredIntersection(const RouteStepIterator step_prior_to_intersection,

 // Two two turns following close after another, we can announce them as a U-Turn if both end up
 // involving the same (segregated) road.
-//  
+// 
 // b < - y
 //       |      will be represented by at x, turn around instead of turn left at x, turn left at y
 // a - > x
@ -42,11 +42,11 @@ bool isNameOszillation(const RouteStepIterator step_prior_to_intersection,

 // Sometimes, segments names don't match the perceived turns. We try to detect these additional
 // name changes and issue a combined turn.
-//  
+// 
 //  |  e  |
 // a - b - c
 //         d
-//  
+// 
 // can have `a-b` as one name, `b-c-d` as a second. At `b` we would issue a new name, even though
 // the road turns right after. The offset would only be there due to the broad road at `e`
 bool maneuverPreceededByNameChange(const RouteStepIterator step_prior_to_intersection,
@ -73,11 +73,11 @@ bool doubleChoiceless(const RouteStepIterator step_entering_intersection,

 // Due to obvious detection, sometimes we can have straight turns followed by a different turn right
 // next to each other. We combine both turns into one, if the second turn is without choice
-//  
-//          e
+// 
+//         e
 // a - b - c
 //       ' d
-//  
+// 
 // with a main road `abd`, the turn `continue straight` at `b` and `turn left at `c` will become a
 // `turn left` at `b`
 bool straightTurnFollowedByChoiceless(const RouteStepIterator step_entering_intersection,
--- a/include/engine/guidance/collapse_turns.hpp
+++ b/include/engine/guidance/collapse_turns.hpp
@ -1,6 +1,7 @@
 #ifndef OSRM_ENGINE_GUIDANCE_COLLAPSE_HPP

 #include "engine/guidance/route_step.hpp"
+#include "util/attributes.hpp"

 #include <type_traits>
 #include <vector>
@ -11,15 +12,16 @@ namespace osrm::engine::guidance
 // Multiple possible reasons can result in unnecessary/confusing instructions
 // Collapsing such turns into a single turn instruction, we give a clearer
 // set of instructions that is not cluttered by unnecessary turns/name changes.
-[[nodiscard]] std::vector<RouteStep> collapseTurnInstructions(std::vector<RouteStep> steps);
+OSRM_ATTR_WARN_UNUSED
+std::vector<RouteStep> collapseTurnInstructions(std::vector<RouteStep> steps);

 // Multiple possible reasons can result in unnecessary/confusing instructions
 // A prime example would be a segregated intersection. Turning around at this
 // intersection would result in two instructions to turn left.
 // Collapsing such turns into a single turn instruction, we give a clearer
 // set of instructions that is not cluttered by unnecessary turns/name changes.
-[[nodiscard]] std::vector<RouteStep>
-collapseSegregatedTurnInstructions(std::vector<RouteStep> steps);
+OSRM_ATTR_WARN_UNUSED
+std::vector<RouteStep> collapseSegregatedTurnInstructions(std::vector<RouteStep> steps);

 // A combined turn is a set of two instructions that actually form a single turn, as far as we
 // perceive it. A u-turn consisting of two left turns is one such example. But there are also lots
--- a/include/engine/guidance/collapsing_utility.hpp
+++ b/include/engine/guidance/collapsing_utility.hpp
@ -3,6 +3,7 @@

 #include "guidance/turn_instruction.hpp"
 #include "engine/guidance/route_step.hpp"
+#include "util/attributes.hpp"
 #include "util/bearing.hpp"
 #include "util/guidance/name_announcements.hpp"

@ -121,8 +122,9 @@ inline bool haveSameMode(const RouteStep &first, const RouteStep &second, const
 // alias for readability
 inline bool haveSameName(const RouteStep &lhs, const RouteStep &rhs)
 {
-    const auto has_name_or_ref = [](auto const &step)
-    { return !step.name.empty() || !step.ref.empty(); };
+    const auto has_name_or_ref = [](auto const &step) {
+        return !step.name.empty() || !step.ref.empty();
+    };

    // make sure empty is not involved
    if (!has_name_or_ref(lhs) || !has_name_or_ref(rhs))
@ -149,14 +151,12 @@ inline bool haveSameName(const RouteStep &lhs, const RouteStep &rhs)
 // alias for readability, both turn right | left
 inline bool areSameSide(const RouteStep &lhs, const RouteStep &rhs)
 {
-    const auto is_left = [](const RouteStep &step)
-    {
+    const auto is_left = [](const RouteStep &step) {
        return hasModifier(step, osrm::guidance::DirectionModifier::Straight) ||
               hasLeftModifier(step.maneuver.instruction);
    };

-    const auto is_right = [](const RouteStep &step)
-    {
+    const auto is_right = [](const RouteStep &step) {
        return hasModifier(step, osrm::guidance::DirectionModifier::Straight) ||
               hasRightModifier(step.maneuver.instruction);
    };
@ -165,7 +165,8 @@ inline bool areSameSide(const RouteStep &lhs, const RouteStep &rhs)
 }

 // do this after invalidating any steps to compress the step array again
-[[nodiscard]] inline std::vector<RouteStep> removeNoTurnInstructions(std::vector<RouteStep> steps)
+OSRM_ATTR_WARN_UNUSED
+inline std::vector<RouteStep> removeNoTurnInstructions(std::vector<RouteStep> steps)
 {
    // finally clean up the post-processed instructions.
    // Remove all invalid instructions from the set of instructions.
@ -173,8 +174,7 @@ inline bool areSameSide(const RouteStep &lhs, const RouteStep &rhs)
    // Two valid NO_TURNs exist in each leg in the form of Depart/Arrive

    // keep valid instructions
-    const auto not_is_valid = [](const RouteStep &step)
-    {
+    const auto not_is_valid = [](const RouteStep &step) {
        return step.maneuver.instruction == osrm::guidance::TurnInstruction::NO_TURN() &&
               step.maneuver.waypoint_type == WaypointType::None;
    };
@ -202,8 +202,8 @@ inline double totalTurnAngle(const RouteStep &entry_step, const RouteStep &exit_
    if (entry_step.geometry_begin > exit_step.geometry_begin)
        return totalTurnAngle(exit_step, entry_step);

-    const auto &exit_intersection = exit_step.intersections.front();
-    const auto &entry_intersection = entry_step.intersections.front();
+    const auto exit_intersection = exit_step.intersections.front();
+    const auto entry_intersection = entry_step.intersections.front();
    if ((exit_intersection.out >= exit_intersection.bearings.size()) ||
        (entry_intersection.in >= entry_intersection.bearings.size()))
        return entry_intersection.bearings[entry_intersection.out];
@ -225,8 +225,7 @@ inline double totalTurnAngle(const RouteStep &entry_step, const RouteStep &exit_
 inline bool bearingsAreReversed(const double bearing_in, const double bearing_out)
 {
    // Nearly perfectly reversed angles have a difference close to 180 degrees (straight)
-    const double left_turn_angle = [&]()
-    {
+    const double left_turn_angle = [&]() {
        if (0 <= bearing_out && bearing_out <= bearing_in)
            return bearing_in - bearing_out;
        return bearing_in + 360 - bearing_out;
--- a/include/engine/guidance/lane_processing.hpp
+++ b/include/engine/guidance/lane_processing.hpp
@ -1,10 +1,11 @@
 #ifndef OSRM_ENGINE_GUIDANCE_LANE_PROCESSING_HPP_
 #define OSRM_ENGINE_GUIDANCE_LANE_PROCESSING_HPP_

-#include "engine/guidance/route_step.hpp"
-
 #include <vector>

+#include "engine/guidance/route_step.hpp"
+#include "util/attributes.hpp"
+
 namespace osrm::engine::guidance
 {

@ -13,9 +14,9 @@ namespace osrm::engine::guidance
 // we anticipate lane changes emitting only matching lanes early on.
 // the second parameter describes the duration that we feel two segments need to be apart to count
 // as separate maneuvers.
-[[nodiscard]] std::vector<RouteStep>
-anticipateLaneChange(std::vector<RouteStep> steps,
-                     const double min_distance_needed_for_lane_change = 200);
+OSRM_ATTR_WARN_UNUSED
+std::vector<RouteStep> anticipateLaneChange(std::vector<RouteStep> steps,
+                                            const double min_distance_needed_for_lane_change = 200);

 } // namespace osrm::engine::guidance

--- a/include/engine/guidance/post_processing.hpp
+++ b/include/engine/guidance/post_processing.hpp
@ -5,6 +5,7 @@
 #include "engine/guidance/leg_geometry.hpp"
 #include "engine/guidance/route_step.hpp"
 #include "engine/phantom_node.hpp"
+#include "util/attributes.hpp"

 #include <vector>

@ -12,7 +13,8 @@ namespace osrm::engine::guidance
 {

 // passed as none-reference to modify in-place and move out again
-[[nodiscard]] std::vector<RouteStep> handleRoundabouts(std::vector<RouteStep> steps);
+OSRM_ATTR_WARN_UNUSED
+std::vector<RouteStep> handleRoundabouts(std::vector<RouteStep> steps);

 // trim initial/final segment of very short length.
 // This function uses in/out parameter passing to modify both steps and geometry in place.
@ -22,21 +24,23 @@ namespace osrm::engine::guidance
 void trimShortSegments(std::vector<RouteStep> &steps, LegGeometry &geometry);

 // assign relative locations to depart/arrive instructions
-[[nodiscard]] std::vector<RouteStep> assignRelativeLocations(std::vector<RouteStep> steps,
-                                                             const LegGeometry &geometry,
-                                                             const PhantomNode &source_node,
-                                                             const PhantomNode &target_node);
+OSRM_ATTR_WARN_UNUSED
+std::vector<RouteStep> assignRelativeLocations(std::vector<RouteStep> steps,
+                                               const LegGeometry &geometry,
+                                               const PhantomNode &source_node,
+                                               const PhantomNode &target_node);

 // collapse suppressed instructions remaining into intersections array
-[[nodiscard]] std::vector<RouteStep> buildIntersections(std::vector<RouteStep> steps);
+OSRM_ATTR_WARN_UNUSED
+std::vector<RouteStep> buildIntersections(std::vector<RouteStep> steps);

 // postProcess will break the connection between the leg geometry
 // for which a segment is supposed to represent exactly the coordinates
 // between routing maneuvers and the route steps itself.
 // If required, we can get both in sync again using this function.
 // Move in LegGeometry for modification in place.
-[[nodiscard]] LegGeometry resyncGeometry(LegGeometry leg_geometry,
-                                         const std::vector<RouteStep> &steps);
+OSRM_ATTR_WARN_UNUSED
+LegGeometry resyncGeometry(LegGeometry leg_geometry, const std::vector<RouteStep> &steps);

 /**
 * Apply maneuver override relations to the selected route.
--- a/include/engine/guidance/postprocessing_toolkit.hpp
+++ b/include/engine/guidance/postprocessing_toolkit.hpp
@ -20,16 +20,14 @@ template <typename Iter, typename Fn> inline Fn forEachRoundabout(Iter first, It
 {
    while (first != last)
    {
-        const auto enter = std::find_if(first,
-                                        last,
-                                        [](const RouteStep &step)
-                                        { return entersRoundabout(step.maneuver.instruction); });
+        const auto enter = std::find_if(first, last, [](const RouteStep &step) {
+            return entersRoundabout(step.maneuver.instruction);
+        });

        // enter has to come before leave, otherwise: faulty data / partial roundabout, skip those
-        const auto leave = std::find_if(enter,
-                                        last,
-                                        [](const RouteStep &step)
-                                        { return leavesRoundabout(step.maneuver.instruction); });
+        const auto leave = std::find_if(enter, last, [](const RouteStep &step) {
+            return leavesRoundabout(step.maneuver.instruction);
+        });

        // No roundabouts, or partial one (like start / end inside a roundabout)
        if (enter == last || leave == last)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Siarhei Fedartsou	3e68237e03	Fix CI	2023-08-22 20:29:21 +02:00
Siarhei Fedartsou	2016d468bb	Merge branch 'master' into sf-osrm-routed	2023-08-22 17:55:10 +02:00
Siarhei Fedartsou	38e4b0b9d6	Implement NodeJS based server fully replicating osrm-routed	2022-10-29 13:26:40 +02:00
Siarhei Fedartsou	ddde7e1ea6	Implement NodeJS based server fully replicating osrm-routed	2022-10-29 13:24:48 +02:00
Siarhei Fedartsou	4dfae26be7	add cluster	2022-10-26 19:30:27 +02:00
Siarhei Fedartsou	40805f7058	Implement NodeJS based server fully replicating osrm-routed	2022-10-25 20:26:20 +02:00
Siarhei Fedartsou	8e3fa70eb0	Implement NodeJS based server fully replicating osrm-routed	2022-10-25 15:54:59 +02:00
Siarhei Fedartsou	41ff79aa1d	Implement NodeJS based server fully replicating osrm-routed	2022-10-23 17:00:36 +02:00
Siarhei Fedartsou	6dfb7d4ede	Implement NodeJS based server fully replicating osrm-routed	2022-10-23 16:57:01 +02:00
Siarhei Fedartsou	71a638a14f	Implement NodeJS based server fully replicating osrm-routed	2022-10-23 16:42:47 +02:00
Siarhei Fedartsou	4fd4c3b563	Implement NodeJS based server fully replicating osrm-routed	2022-10-23 16:24:07 +02:00
Siarhei Fedartsou	242c07443a	Implement NodeJS based server fully replicating osrm-routed	2022-10-23 16:07:34 +02:00
Siarhei Fedartsou	1047cc1bfd	Implement NodeJS based server fully replicating osrm-routed	2022-10-23 16:06:13 +02:00
Siarhei Fedartsou	9c7d75d7d4	Implement NodeJS based server fully replicating osrm-routed	2022-10-23 16:01:57 +02:00
Siarhei Fedartsou	3f0ded653d	Implement NodeJS based server fully replicating osrm-routed	2022-10-23 16:01:13 +02:00
Siarhei Fedartsou	61810b9205	Implement NodeJS based server fully replicating osrm-routed	2022-10-23 15:59:51 +02:00
Siarhei Fedartsou	8273e8b0e2	Implement NodeJS based server fully replicating osrm-routed	2022-10-23 15:13:42 +02:00
Siarhei Fedartsou	dd04760982	Implement NodeJS based server fully replicating osrm-routed	2022-10-23 14:38:42 +02:00
Siarhei Fedartsou	768c33127a	Implement NodeJS based server fully replicating osrm-routed	2022-10-23 14:26:10 +02:00
Siarhei Fedartsou	251ffe4a50	Implement NodeJS based server fully replicating osrm-routed	2022-10-23 14:18:52 +02:00
Siarhei Fedartsou	53f2da5d5e	Implement NodeJS based server fully replicating osrm-routed	2022-10-23 13:56:21 +02:00