feat(osrm): initial develop osrm self-manage v1.0

docs/altinstall-osrm.md

-🔥 Siap, berikut ini rencana **final changelog untuk `install-osrm-ngpm.sh v4.6`**, biar kamu tahu persis apa yang akan saya implementasikan sebelum saya keluarkan skrip lengkapnya:
+
+
+# 🧩 OSRM NGPM Installer — Specification (Final Draft v1.0)
+
+## 1. Tujuan
+
+Menyediakan **satu bash script tunggal (`install-osrm-ngpm.sh`)** untuk mengelola *lifecycle* OSRM (Open Source Routing Machine) environment berbasis Docker pada sistem **Rocky Linux 10**.
+
+Skrip ini bersifat:
+
+* **Idempotent** → aman dijalankan berulang kali.
+* **Modular** → bisa install, update, dan remove secara terpisah untuk backend, frontend, profil, dan map.
+* **Self-contained** → tidak memerlukan konfigurasi eksternal manual selain argumen CLI.
+* **Interactive** → menggunakan prompt CLI konfirmasi (bukan `dialog`).
+* **Auto dependency check** → instalasi otomatis bila memungkinkan.
+
+---
+
+## 2. Struktur Direktori Default
+
+| Komponen              | Path                                         | Keterangan              |
+| --------------------- | -------------------------------------------- | ----------------------- |
+| Working directory     | `~/data/docker-data/osrm`                    | Root semua komponen     |
+| Dataset               | `~/data/docker-data/osrm/dataset`            | File `.osm.pbf`         |
+| Profiles              | `~/data/docker-data/osrm/profiles`           | File `.lua` profil      |
+| Logs                  | `~/data/docker-data/osrm/logs`               | Semua log proses        |
+| Docker Compose Config | `~/data/docker-data/osrm/docker-compose.yml` | Konfigurasi absolut     |
+| Backup                | `~/data/docker-data/osrm/backup/`            | Backup konfigurasi lama |
 
 ---
 
-## 🧩 **install-osrm-ngpm.sh v4.6 — Production Ready Edition**
+## 3. Dependency Management
 
-### ⚙️ Core Enhancements
+### 3.1. Package wajib
 
-✅ **Auto Lua Patch**
+* `docker`
+* `docker-compose`
+* `curl`
+* `wget`
+* `jq` *(optional tapi direkomendasikan untuk output JSON)*
+* `tar`, `gzip`
 
-* Deteksi otomatis `arg[0]` atau variabel bermasalah di file profile `.lua`.
-* Patch jadi aman (`local profile_name = "car"`).
-* Berlaku untuk semua profile (`car`, `motorcycle`, `bicycle`, `foot`, dll).
+### 3.2. Otomatisasi
 
-✅ **Sequential Routing Preparation**
+Jika dependency tidak ditemukan:
 
-* Preprocessing tetap jalan satu per satu untuk menghindari OOM/CPU spikes.
-* Setelah preprocessing sukses → otomatis buat **`osrm-routed-*` service** di `docker-compose.yml`.
-* Jika preprocess gagal → skip pembuatan service & tampilkan log merah `[FAILED]`.
+* Jika bisa diinstal tanpa konfigurasi tambahan → auto install dengan `dnf install -y`.
+* Jika butuh setup tambahan (contoh: `docker`) → tampilkan warning dan petunjuk manual.
 
-✅ **Docker Compose Update Logic**
+---
 
-* Template `docker-compose.yml` disusun modular.
-* Section `services:` akan diupdate otomatis jika profil bertambah.
-* Tambah opsi `--rebuild` untuk force-regenerate compose file (jika sudah ada lama).
+## 4. Profil Routing
 
-✅ **Improved Logging**
+### 4.1. Default Profiles
 
-* Tambah notifikasi jelas:
+| Nama       | File             | Catatan                                                            |
+| ---------- | ---------------- | ------------------------------------------------------------------ |
+| car        | `car.lua`        | bawaan OSRM                                                        |
+| bike       | `bicycle.lua`    | bawaan OSRM                                                        |
+| foot       | `foot.lua`       | bawaan OSRM                                                        |
+| motorcycle | `motorcycle.lua` | kustom: `maxspeed=100km/h`, `u-turn penalty=60s`, `avoid toll=yes` |
 
-  ```
-  [INFO] ✅ Preprocess success: car
-  [INFO] 🚀 Spawning routed service: osrm-routed-car (port: 5000)
-  ```
-* Tambah warning warna jika ada error Lua atau path permission issue.
+Semua profil disimpan di `--profile-dir` dan digunakan sesuai argumen `--profiles`.
 
 ---
 
-### 🌐 **Frontend / NGPM Integration**
+## 5. Default Konfigurasi
 
-✅ Tidak auto-modify frontend config (tetap aman untuk multi-proxy)
-✅ Menampilkan **Frontend & NGPM hints** di akhir proses:
+| Flag                  | Deskripsi                                              | Default                                                               |
+| --------------------- | ------------------------------------------------------ | --------------------------------------------------------------------- |
+| `--profiles`          | Daftar profil yang diinstall                           | `car`                                                                 |
+| `--profile-dir`       | Direktori profil Lua                                   | `~/data/docker-data/osrm/profiles`                                    |
+| `--map-dir`           | Direktori file `.osm.pbf`                              | `~/data/docker-data/osrm/dataset`                                     |
+| `--map-source`        | URL atau local path sumber peta                        | `http://download.geofabrik.de/asia/indonesia-latest.osm.pbf`          |
+| `--backend-version`   | Versi OSRM backend                                     | `latest`                                                              |
+| `--frontend-version`  | Versi OSRM frontend                                    | `latest`                                                              |
+| `--backend-registry`  | Registry backend                                       | `ghcr.io/project-osrm/osrm-backend`                                   |
+| `--frontend-registry` | Registry frontend                                      | `ghcr.io/project-osrm/osrm-frontend`                                  |
+| `--backend-port`      | Port backend                                           | `5000`                                                                |
+| `--frontend-port`     | Port frontend                                          | `9966`                                                                |
+| `--backend-domain`    | Domain backend                                         | `localhost`                                                           |
+| `--frontend-domain`   | Domain frontend                                        | `localhost`                                                           |
+| `--backend-path`      | Path API backend                                       | `/osrm`                                                               |
+| `--api-version`       | Versi API backend                                      | `v1`                                                                  |
+| `--backend-url`       | URL lengkap backend (untuk frontend)                   | `http://{backend-domain}:{backend-port}/osrm/{api-version}/{profile}` |
+| `--network`           | Docker network                                         | `ngpm-network`                                                        |
+| `--work-dir`          | Direktori kerja utama                                  | `~/data/docker-data/osrm`                                             |
+| `--domain`            | Alias untuk domain publik (opsional)                   | *kosong*                                                              |
+| `--dry-run`           | Simulasi tanpa eksekusi                                | `false`                                                               |
+| `--print-config`      | Cetak konfigurasi saja                                 | `false`                                                               |
+| `--update`            | Update backend/frontend tanpa map/profile              | `false`                                                               |
+| `--update-map`        | Update map dataset                                     | `false`                                                               |
+| `--update-profile`    | Update profil routing                                  | `false`                                                               |
+| `--update-backend`    | Pull image OSRM backend terbaru                        | `false`                                                               |
+| `--update-frontend`   | Pull image OSRM frontend terbaru                       | `false`                                                               |
+| `--update-all`        | Update semua komponen (backend, frontend, map, profil) | `false`                                                               |
+| `--remove-backend`    | Hapus container + config backend                       | `false`                                                               |
+| `--remove-frontend`   | Hapus container frontend                               | `false`                                                               |
+| `--remove-profile`    | Hapus profil routing                                   | `false`                                                               |
+| `--remove-map`        | Hapus dataset peta                                     | `false`                                                               |
+| `--remove-all`        | Hapus semua (backend, frontend, profil, peta)          | `false`                                                               |
+| `--no-frontend`       | Jangan install OSRM frontend                           | `false`                                                               |
+| `--no-backend`        | Jangan install OSRM backend                            | `false`                                                               |
 
+---
+
+## 6. Behavior Perintah
+
+### 🧱 6.1. INSTALL
+
+**Contoh command:**
+
+```bash
+./install-osrm-ngpm.sh --profiles car,bike,foot,motorcycle
 ```
-────────────────────────────────────────────
-🌐 Frontend Configuration Hints (for NGPM)
-────────────────────────────────────────────
-- Backend URL: https://route.geotency.com/osrm/v1/
-- Profiles available: car, motorcycle
-- Example endpoint: /osrm/v1/car/...
-────────────────────────────────────────────
-```
 
-✅ Mendukung argument:
+**Proses:**
+
+1. Validasi dependency.
+2. Buat direktori kerja jika belum ada.
+3. Download profil `.lua` jika belum ada di `--profile-dir`.
+4. Cek file `.osm.pbf`:
 
-* `--domain` untuk menentukan domain base URL (misal `https://route.geotency.com`)
-* `--backend-path` untuk menentukan path (misal `/osrm/v1`)
+   * Jika `--map-source` lokal dan file ada → skip download.
+   * Jika URL dan file belum ada → download otomatis.
+5. Generate docker-compose absolute config.
+6. Jalankan container backend & frontend (kecuali `--no-backend` / `--no-frontend`).
+7. Tampilkan hasil:
+
+   ```
+   Backend (car):  http://localhost:5000/osrm/v1/car
+   Frontend:       http://localhost:9966
+   ```
 
 ---
 
-### 🧠 **Argumen Baru / Diperbaiki**
-
-| Flag                  | Deskripsi                             | Default                                                      |
-| --------------------- | ------------------------------------- | ------------------------------------------------------------ |
-| `--profiles`          | Daftar profil yang diinstall          | `car`                                                        |
-| `--profile-dir`       | Direktori profil Lua                  | `~/data/docker-data/osrm/profiles`                           |
-| `--map-dir`           | Direktori file `.osm.pbf`             | `~/data/docker-data/osrm/dataset`                            |
-| `--map-source`        | URL sumber peta untuk update otomatis | `http://download.geofabrik.de/asia/indonesia-latest.osm.pbf` |
-| `--backend-version`   | Versi OSRM backend                    | `latest`                                                     |
-| `--frontend-version`  | Versi OSRM frontend                   | `latest`                                                     |
-| `--backend-registry`  | Registry backend                      | `ghcr.io/project-osrm/osrm-backend`                          |
-| `--frontend-registry` | Registry frontend                     | `ghcr.io/project-osrm/osrm-frontend`                         |
-| `--backend-port`      | Port backend utama                    | `5000`                                                       |
-| `--frontend-port`     | Port frontend (opsional)              | `8080`                                                       |
-| `--network`           | Docker network                        | `ngpm-network`                                               |
-| `--work-dir`          | Direktori kerja utama                 | `~/data/docker-data/osrm`                                    |
-| `--with-frontend`     | Ikut deploy OSRM frontend             | `false`                                                      |
-| `--domain`            | Domain base (untuk hint output)       | *kosong*                                                     |
-| `--backend-path`      | Base path API                         | `/osrm/v1`                                                   |
-| `--dry-run`           | Simulasi tanpa eksekusi               | `false`                                                      |
-| `--update`            | Update image, peta, dan profil        | `false`                                                      |
-| `--print-config`      | Menampilkan konfigurasi saja          | `false`                                                      |
+### 🔄 6.2. UPDATE
+
+#### a. Backend only
+
+```bash
+./install-osrm-ngpm.sh --update-backend
+```
+
+* Pull image backend terbaru.
+* Recreate container backend.
+* Tidak memodifikasi dataset/profil.
+
+#### b. Frontend only
+
+```bash
+./install-osrm-ngpm.sh --update-frontend
+```
+
+* Pull image frontend terbaru.
+* Recreate container frontend.
+* Keep backend as-is.
+
+#### c. Map
+
+```bash
+./install-osrm-ngpm.sh --update-map
+```
+
+* Download ulang `.osm.pbf` dari `--map-source`.
+* Jalankan ulang proses extract + partition + customize.
+* Restart backend container.
+
+#### d. Profile
+
+```bash
+./install-osrm-ngpm.sh --update-profile
+```
+
+* Download ulang profil `.lua` default OSRM.
+* Rebuild data `.osrm*` untuk tiap profil.
+* Restart backend container.
+
+#### e. All
+
+```bash
+./install-osrm-ngpm.sh --update-all
+```
+
+* Menjalankan semua proses update di atas secara berurutan.
 
 ---
 
-### 🪄 **Auto-Fix for Common Issues**
+### 🧹 6.3. REMOVE
 
-* Fix permission issue saat preprocess (pakai tmp writable volume)
-* Patch Lua `arg` nil
-* Skip rebuild jika hasil `.osrm` sudah valid
-* Auto-recreate Docker network jika belum ada
+#### a. Remove backend
+
+```bash
+./install-osrm-ngpm.sh --remove-backend
+```
+
+* Stop & remove container backend.
+* Backup config → `backup/`.
+* Hapus file compose section backend.
+
+#### b. Remove frontend
+
+```bash
+./install-osrm-ngpm.sh --remove-frontend
+```
+
+* Stop & remove container frontend.
+* Backup config frontend.
+
+#### c. Remove profile
+
+```bash
+./install-osrm-ngpm.sh --remove-profile --profiles car,bike
+```
+
+* Hapus profil `.lua` dan hasil preprocessing `.osrm*`.
+
+#### d. Remove map
+
+```bash
+./install-osrm-ngpm.sh --remove-map
+```
+
+* Hapus file `.osm.pbf` dari dataset.
+
+#### e. Remove all
+
+```bash
+./install-osrm-ngpm.sh --remove-all
+```
+
+* Jalankan semua remove di atas (backend, frontend, profil, map).
+* Bersihkan network jika kosong.
 
 ---
 
-### 🧾 **Output Akhir**
+## 7. Workflow Diagram (Mermaid)
+
+```mermaid
+flowchart TD
+    A[Start Script] --> B{Arguments Provided?}
+    B -->|--remove-*| R[Branch REMOVE Flow]
+    B -->|--update-*| U[Branch UPDATE Flow]
+    B -->|Default| I[Branch INSTALL Flow]
 
+    %% INSTALL
+    I --> I1[Check Dependencies]
+    I1 --> I2[Create directories (dataset, profiles, logs)]
+    I2 --> I3[Validate map-source]
+    I3 -->|URL| I4[Download if missing]
+    I3 -->|Local path| I5[Check file exists]
+    I4 --> I6[Extract, Partition, Customize]
+    I5 --> I6
+    I6 --> I7[Generate docker-compose.yml (absolute path)]
+    I7 --> I8{no-backend / no-frontend?}
+    I8 -->|Install Backend| I9[Deploy backend container]
+    I8 -->|Install Frontend| I10[Deploy frontend container]
+    I9 --> I11[Show backend URL]
+    I10 --> I12[Show frontend URL]
+    I11 --> Z[End]
+    I12 --> Z
+
+    %% UPDATE
+    U --> U1{Type of Update?}
+    U1 -->|Backend| UB[Pull backend image, recreate container]
+    U1 -->|Frontend| UF[Pull frontend image, recreate container]
+    U1 -->|Map| UM[Download .osm.pbf, rebuild, restart backend]
+    U1 -->|Profile| UP[Update .lua, rebuild, restart backend]
+    U1 -->|All| UA[Run all updates sequentially]
+    UA --> Z
+    UB --> Z
+    UF --> Z
+    UM --> Z
+    UP --> Z
+
+    %% REMOVE
+    R --> R1{Type of Remove?}
+    R1 -->|Backend| RB[Stop & remove backend]
+    R1 -->|Frontend| RF[Stop & remove frontend]
+    R1 -->|Profile| RP[Delete .lua & .osrm*]
+    R1 -->|Map| RM[Delete .osm.pbf]
+    R1 -->|All| RA[Run all removals sequentially]
+    RB --> Z
+    RF --> Z
+    RP --> Z
+    RM --> Z
+    RA --> Z
 ```
-2025-10-15 10:21:45 [SUCCESS] OSRM backend deployed for: car, motorcycle
-2025-10-15 10:21:45 [SUCCESS] Docker Compose file: /home/sysadmin/data/docker-data/osrm/docker-compose.yml
-
-────────────────────────────────────────────
-🌐 Frontend Configuration Hints (for NGPM)
-────────────────────────────────────────────
-Backend: https://route.geotency.com/osrm/v1/
-Profiles: car, motorcycle
-Network: ngpm-network
-────────────────────────────────────────────
-💡 Test endpoint:
-    curl "https://route.geotency.com/osrm/v1/car/106.8,-6.2;106.9,-6.3"
-────────────────────────────────────────────
+
+---
+
+## 8. Logging
+
+* Semua aktivitas disimpan di `~/data/docker-data/osrm/logs/osrm-installer-YYYYMMDD.log`.
+* Kesalahan fatal juga ditulis di file log.
+* Setiap proses major (install/update/remove) akan mencatat timestamp mulai dan selesai.
+
+---
+
+## 9. Output Akhir
+
+Setelah sukses dijalankan:
+
+```bash
+✅ OSRM installation complete!
+
+Backend URLs:
+ - car:        http://localhost:5000/osrm/v1/car
+ - bike:       http://localhost:5000/osrm/v1/bike
+ - foot:       http://localhost:5000/osrm/v1/foot
+ - motorcycle: http://localhost:5000/osrm/v1/motorcycle
+
+Frontend URL:
+ → http://localhost:9966
+
+Logs stored at: ~/data/docker-data/osrm/logs/osrm-installer-20251015.log
 ```
 
+---
+
+## 10. Konfirmasi Sebelum Implementasi
+
+Mohon konfirmasi hal berikut:
+
+1. Apakah semua flag dan behavior sudah sesuai (termasuk pemisahan `update-*` & `remove-*`)?
+2. Apakah format URL backend `http://{backend-domain}:{backend-port}/osrm/{api-version}/{profile}` sudah final?
+3. Apakah lokasi default (`~/data/docker-data/osrm`) boleh di-hardcode dalam skrip (dapat diubah via `--work-dir`)?
+4. Apakah backup otomatis (zip sebelum override) tetap diaktifkan?
+5. Apakah kamu ingin output tambahan berupa file `config-summary.json` untuk dokumentasi hasil instalasi?
+
+Setelah kamu konfirmasi, saya akan lanjut ke tahap **penulisan bashscript implementasi final** sesuai spesifikasi ini.

scripts/install-osrm-ngpm.sh

 #!/usr/bin/env bash
-# install-osrm-ngpm.sh v4.6
-# Production-grade OSRM backend + frontend installer & manager
-# - kebab-case CLI, NGPM used for Nginx Proxy Manager
-# - sequential preprocessing, patched lua profiles, safe mounts
-# - print-config, ngpm/frontend hints (no auto-edit frontend)
+#
+# install-osrm-ngpm.sh
+# OSRM + NGPM installer & manager (Rocky Linux 10)
+# Version: v1.0 (final draft based on spec v3.3)
+#
+# Features:
+# - single-file, self-contained, idempotent installer/manager
+# - absolute paths for docker-compose mounts
+# - supports install / update / remove granular modes
+# - flags use kebab-case
+# - auto-install dependencies on Rocky Linux when possible
+# - logs saved to ~/data/docker-data/osrm/logs/
+# - supports --map-source (URL or local path). default checks dataset/indonesia-latest.osm.pbf
+# - motorcycle profile patched from car.lua (maxspeed=100km/h, u-turn penalty=60s, avoid tolls)
+# - default backend port 5000 (host+container), frontend port 9966
+# - default backend URL format: http://{backend-domain}:{backend-port}/osrm/{api-version}/{profile}
+# - interactive CLI prompts (y/N), supports --yes for non-interactive
+#
 set -euo pipefail
 IFS=$'\n\t'
 
 # -------------------------
-# Defaults
+# DEFAULTS
 # -------------------------
 DEFAULT_WORK_DIR="${HOME}/data/docker-data/osrm"
 DEFAULT_MAP_DIR="${DEFAULT_WORK_DIR}/dataset"
 DEFAULT_PROFILE_DIR="${DEFAULT_WORK_DIR}/profiles"
 DEFAULT_PATCHED_DIR="${DEFAULT_WORK_DIR}/patched-profiles"
+DEFAULT_BACKUP_DIR="${DEFAULT_WORK_DIR}/backup"
+DEFAULT_LOG_DIR="${DEFAULT_WORK_DIR}/logs"
+
 DEFAULT_BACKEND_REGISTRY="ghcr.io/project-osrm/osrm-backend"
 DEFAULT_FRONTEND_REGISTRY="ghcr.io/project-osrm/osrm-frontend"
 DEFAULT_BACKEND_VERSION="latest"
@@ -22,99 +38,150 @@ DEFAULT_MAP_SOURCE="https://download.geofabrik.de/asia/indonesia-latest.osm.pbf"
 DEFAULT_NETWORK="ngpm-network"
 DEFAULT_PROFILES="car"
 DEFAULT_BACKEND_PORT=5000
-DEFAULT_FRONTEND_PORT=8080
-DEFAULT_DOMAIN=""
-DEFAULT_PATH_PREFIX="/osrm"
-
-LOGFILE="${DEFAULT_WORK_DIR}/osrm-install.log"
-NGPM_HINTS="${DEFAULT_WORK_DIR}/ngpm-config.txt"
-
-# -------------------------
-# Runtime variables (CLI overrides)
-# -------------------------
-work_dir="${DEFAULT_WORK_DIR}"
-map_dir="${DEFAULT_MAP_DIR}"
-profile_dir="${DEFAULT_PROFILE_DIR}"
-patched_dir="${DEFAULT_PATCHED_DIR}"
-backend_registry="${DEFAULT_BACKEND_REGISTRY}"
-frontend_registry="${DEFAULT_FRONTEND_REGISTRY}"
-backend_version="${DEFAULT_BACKEND_VERSION}"
-frontend_version="${DEFAULT_FRONTEND_VERSION}"
-map_source="${DEFAULT_MAP_SOURCE}"
-network_name="${DEFAULT_NETWORK}"
-profiles_csv="${DEFAULT_PROFILES}"
-backend_port="${DEFAULT_BACKEND_PORT}"
-frontend_port="${DEFAULT_FRONTEND_PORT}"
-with_frontend=false
-dry_run=false
-domain="${DEFAULT_DOMAIN}"
-path_prefix="${DEFAULT_PATH_PREFIX}"
-map_arg=""                # user-provided --map (path or url)
-print_config=false
-
-# update flags (when using 'update' command)
-update_map=false
-update_profiles=false
-update_images=false
-
-# command: install | update | remove | status | print-config
-command_name=""
+ya DEFAULT_FRONTEND_PORT=9966
+DEFAULT_BACKEND_DOMAIN="localhost"
+DEFAULT_FRONTEND_DOMAIN="localhost"
+DEFAULT_BACKEND_PATH="/osrm"
+DEFAULT_API_VERSION="v1"
+DEFAULT_NO_FRONTEND=false
+DEFAULT_NO_BACKEND=false
+
+# -------------------------
+# RUN-TIME VARIABLES (overridden by CLI)
+# -------------------------
+work-dir="${DEFAULT_WORK_DIR}"
+map-dir="${DEFAULT_MAP_DIR}"
+profile-dir="${DEFAULT_PROFILE_DIR}"
+patched-dir="${DEFAULT_PATCHED_DIR}"
+backup-dir="${DEFAULT_BACKUP_DIR}"
+log-dir="${DEFAULT_LOG_DIR}"
+
+backend-registry="${DEFAULT_BACKEND_REGISTRY}"
+frontend-registry="${DEFAULT_FRONTEND_REGISTRY}"
+backend-version="${DEFAULT_BACKEND_VERSION}"
+frontend-version="${DEFAULT_FRONTEND_VERSION}"
+map-source="${DEFAULT_MAP_SOURCE}"
+network-name="${DEFAULT_NETWORK}"
+profiles-csv="${DEFAULT_PROFILES}"
+backend-port="${DEFAULT_BACKEND_PORT}"
+frontend-port="${DEFAULT_FRONTEND_PORT}"
+backend-domain="${DEFAULT_BACKEND_DOMAIN}"
+frontend-domain="${DEFAULT_FRONTEND_DOMAIN}"
+backend-path="${DEFAULT_BACKEND_PATH}"
+api-version="${DEFAULT_API_VERSION}"
+no-frontend="${DEFAULT_NO_FRONTEND}"
+no-backend="${DEFAULT_NO_BACKEND}"
+
+dry-run=false
+print-config=false
+yes-all=false
+
+# update/remove flags (granular)
+do-update-backend=false
+do-update-frontend=false
+do-update-map=false
+do-update-profile=false
+do-update-all=false
+
+do-remove-backend=false
+do-remove-frontend=false
+do-remove-profile=false
+do-remove-map=false
+do-remove-all=false
+do-purge=false
+
+map-arg=""   # explicit --map-source given (URL or path) override var map-source
+
+# derived
+COMPOSE_FILE=""
+LOGFILE=""
+NGPM_HINTS=""
 
 # -------------------------
 # Logging helpers
 # -------------------------
-mkdir -p "$(dirname "$LOGFILE")" 2>/dev/null || true
+timestamp() { date '+%Y-%m-%d %H:%M:%S'; }
+logfile_init() {
+  mkdir -p "${log-dir}"
+  LOGFILE="${log-dir}/osrm-installer-$(date '+%Y%m%d_%H%M%S').log"
+  : > "${LOGFILE}"
+}
 _log() {
   local lvl="$1"; shift
-  local ts; ts="$(date '+%Y-%m-%d %H:%M:%S')"
-  printf "%s [%s] %s\n" "$ts" "$lvl" "$*" | tee -a "$LOGFILE"
+  local ts; ts="$(timestamp)"
+  printf "%s [%s] %s\n" "$ts" "$lvl" "$*" | tee -a "${LOGFILE}"
 }
-info() { _log INFO "$*"; }
-success() { _log SUCCESS "$*"; }
-warn() { _log WARNING "$*"; }
-err() { _log ERROR "$*" >&2; }
+info() { _log "INFO" "$*"; }
+success() { _log "SUCCESS" "$*"; }
+warn() { _log "WARN" "$*"; }
+err() { _log "ERROR" "$*" >&2; }
 
 # -------------------------
 # Usage
 # -------------------------
 usage() {
   cat <<EOF
-install-osrm-ngpm.sh v4.6
+install-osrm-ngpm.sh - OSRM + NGPM installer & manager (Rocky Linux 10)
 
 Usage:
   $0 <command> [options]
 
-Commands:
-  install            Install and run OSRM backend (+ optional frontend)
-  update             Update images / profiles / map (controlled with flags)
-  remove             Stop & remove generated containers and data
-  status             Show docker containers in the NGPM network
-  print-config       Print resolved configuration and exit
+Commands: (use one or combine with flags)
+  install                     Install and run OSRM backend + frontend (unless disabled)
+  update                      Use update flags (--update-backend, --update-frontend, --update-map, --update-profile, --update-all)
+  remove                      Use remove flags (--remove-backend, --remove-frontend, --remove-profile, --remove-map, --remove-all)
 
 Common options (kebab-case):
-  --work-dir <dir>           Working directory (default: ${DEFAULT_WORK_DIR})
-  --map <file|url>           Map file path or URL (overrides auto-detect)
-  --map-dir <dir>            Map directory (default: ${DEFAULT_MAP_DIR})
-  --map-source <url>         Map download source (default: ${DEFAULT_MAP_SOURCE})
-  --profiles <csv>           Comma-separated profiles (car,motorcycle,bicycle,foot). Default 'car'
-  --profile-dir <dir>        Profile directory for .lua (default: ${DEFAULT_PROFILE_DIR})
-  --with-frontend            Deploy OSRM frontend (UI)
-  --backend-registry <img>   Backend registry (default: ${DEFAULT_BACKEND_REGISTRY})
-  --frontend-registry <img>  Frontend registry (default: ${DEFAULT_FRONTEND_REGISTRY})
-  --backend-version <tag>    Backend image tag (default: ${DEFAULT_BACKEND_VERSION})
-  --frontend-version <tag>   Frontend image tag (default: ${DEFAULT_FRONTEND_VERSION})
-  --backend-port <port>      First host port for backend mapping (default: ${DEFAULT_BACKEND_PORT})
-  --frontend-port <port>     Host port for frontend UI (default: ${DEFAULT_FRONTEND_PORT})
-  --network <name>           Docker network name (default: ${DEFAULT_NETWORK})
-  --domain <url>             Domain used in hints only (optional)
-  --path-prefix <path>       Path prefix used in hints only (default: ${DEFAULT_PATH_PREFIX})
-  --update-map               With 'update': update/download map
-  --update-profiles          With 'update': regenerate profile wrappers (won't overwrite custom)
-  --update-images            With 'update': pull backend/frontend images
-  --update-all               With 'update': run all updates
-  --print-config             Print resolved configuration and exit
-  --dry-run                  Simulate actions (no changes)
+  --work-dir <dir>            Work dir (default: ${DEFAULT_WORK_DIR})
+  --map-source <url|path>     Map URL or local file path (default: ${DEFAULT_MAP_SOURCE})
+  --map-dir <dir>             Map directory (default: ${DEFAULT_MAP_DIR})
+  --profiles <csv>            Profiles to enable (car,motorcycle,bike,foot). Default 'car'
+  --profile-dir <dir>         Profile Lua dir (default: ${DEFAULT_PROFILE_DIR})
+  --backend-registry <img>    Backend registry (default: ${DEFAULT_BACKEND_REGISTRY})
+  --frontend-registry <img>   Frontend registry (default: ${DEFAULT_FRONTEND_REGISTRY})
+  --backend-version <tag>     Backend image tag (default: ${DEFAULT_BACKEND_VERSION})
+  --frontend-version <tag>    Frontend image tag (default: ${DEFAULT_FRONTEND_VERSION})
+  --backend-port <port>       Host start port for backend mapping (default: ${DEFAULT_BACKEND_PORT})
+  --frontend-port <port>      Host port for frontend UI (default: ${DEFAULT_FRONTEND_PORT})
+  --network <name>            Docker network name (default: ${DEFAULT_NETWORK})
+  --backend-domain <domain>   Domain for backend URLs (default: ${DEFAULT_BACKEND_DOMAIN})
+  --frontend-domain <domain>  Domain for frontend (default: ${DEFAULT_FRONTEND_DOMAIN})
+  --backend-path <path>       Base path for backend (default: ${DEFAULT_BACKEND_PATH})
+  --api-version <version>     API version (default: ${DEFAULT_API_VERSION})
+  --no-frontend               Do NOT install frontend (frontend is installed by default)
+  --no-backend                Do NOT install backend
+  --dry-run                   Simulate steps
+  --print-config              Print resolved configuration and exit
+  --yes                       Non-interactive (answer Yes to all prompts)
+
+Update flags:
+  --update-backend
+  --update-frontend
+  --update-map
+  --update-profile
+  --update-all
+
+Remove flags:
+  --remove-backend
+  --remove-frontend
+  --remove-profile
+  --remove-map
+  --remove-all
+  --purge                    Use with remove to delete data (dataset, profiles, compose)
+
+Other:
   -h, --help                 Show this help
+
+Examples:
+  Install default:
+    $0 install
+
+  Install with profiles:
+    $0 install --profiles car,motorcycle,bike,foot
+
+  Update only map (local file):
+    $0 update --update-map --map-source /data/osm/indonesia-latest.osm.pbf
+
 EOF
   exit 0
 }
@@ -123,139 +190,261 @@ EOF
 # Parse args
 # -------------------------
 if [ $# -eq 0 ]; then usage; fi
-command_name="$1"; shift
+command_name="$1"; shift || true
 
 while (( "$#" )); do
   case "$1" in
-    --work-dir) work_dir="${2/#\~/$HOME}"; shift 2 ;;
-    --map) map_arg="${2/#\~/$HOME}"; shift 2 ;;
-    --map-dir) map_dir="${2/#\~/$HOME}"; shift 2 ;;
-    --map-source) map_source="$2"; shift 2 ;;
-    --profiles) profiles_csv="$2"; shift 2 ;;
-    --profile-dir) profile_dir="${2/#\~/$HOME}"; shift 2 ;;
-    --with-frontend) with_frontend=true; shift ;;
-    --backend-registry) backend_registry="$2"; shift 2 ;;
-    --frontend-registry) frontend_registry="$2"; shift 2 ;;
-    --backend-version) backend_version="$2"; shift 2 ;;
-    --frontend-version) frontend_version="$2"; shift 2 ;;
-    --backend-port) backend_port="$2"; shift 2 ;;
-    --frontend-port) frontend_port="$2"; shift 2 ;;
-    --network) network_name="$2"; shift 2 ;;
-    --domain) domain="$2"; shift 2 ;;
-    --path-prefix) path_prefix="$2"; shift 2 ;;
-    --dry-run) dry_run=true; shift ;;
-    --update-map) update_map=true; shift ;;
-    --update-profiles) update_profiles=true; shift ;;
-    --update-images) update_images=true; shift ;;
-    --update-all) update_map=true; update_profiles=true; update_images=true; shift ;;
-    --print-config) print_config=true; shift ;;
+    --work-dir) work-dir="${2/#\~/$HOME}"; shift 2 ;;
+    --map-source) map-source="${2}"; map-arg="${2}"; shift 2 ;;
+    --map-dir) map-dir="${2/#\~/$HOME}"; shift 2 ;;
+    --profiles) profiles-csv="${2}"; shift 2 ;;
+    --profile-dir) profile-dir="${2/#\~/$HOME}"; shift 2 ;;
+    --backend-registry) backend-registry="$2"; shift 2 ;;
+    --frontend-registry) frontend-registry="$2"; shift 2 ;;
+    --backend-version) backend-version="$2"; shift 2 ;;
+    --frontend-version) frontend-version="$2"; shift 2 ;;
+    --backend-port) backend-port="$2"; shift 2 ;;
+    --frontend-port) frontend-port="$2"; shift 2 ;;
+    --network) network-name="$2"; shift 2 ;;
+    --backend-domain) backend-domain="$2"; shift 2 ;;
+    --frontend-domain) frontend-domain="$2"; shift 2 ;;
+    --backend-path) backend-path="$2"; shift 2 ;;
+    --api-version) api-version="$2"; shift 2 ;;
+    --no-frontend) no-frontend=true; shift ;;
+    --no-backend) no-backend=true; shift ;;
+    --dry-run) dry-run=true; shift ;;
+    --print-config) print-config=true; shift ;;
+    --yes) yes-all=true; shift ;;
+    --update-backend) do-update-backend=true; shift ;;
+    --update-frontend) do-update-frontend=true; shift ;;
+    --update-map) do-update-map=true; shift ;;
+    --update-profile) do-update-profile=true; shift ;;
+    --update-all) do-update-all=true; shift ;;
+    --remove-backend) do-remove-backend=true; shift ;;
+    --remove-frontend) do-remove-frontend=true; shift ;;
+    --remove-profile) do-remove-profile=true; shift ;;
+    --remove-map) do-remove-map=true; shift ;;
+    --remove-all) do-remove-all=true; shift ;;
+    --purge) do-purge=true; shift ;;
     -h|--help) usage ;;
     *) warn "Unknown option: $1"; shift ;;
   esac
 done
 
-# normalize booleans
-with_frontend=${with_frontend:-false}
-dry_run=${dry_run:-false}
-print_config=${print_config:-false}
-update_map=${update_map:-false}
-update_profiles=${update_profiles:-false}
-update_images=${update_images:-false}
-
-# normalize paths
-work_dir="${work_dir/#\~/$HOME}"
-map_dir="${map_dir/#\~/$HOME}"
-profile_dir="${profile_dir/#\~/$HOME}"
-patched_dir="${patched_dir/#\~/$HOME}"
-mkdir -p "$work_dir" "$map_dir" "$profile_dir" "$patched_dir"
-
-COMPOSE_FILE="${work_dir}/docker-compose.yml"
-LOGFILE="${work_dir}/osrm-install.log"
-NGPM_HINTS="${work_dir}/ngpm-config.txt"
+# normalize
+work-dir="${work-dir/#\~/$HOME}"
+map-dir="${map-dir/#\~/$HOME}"
+profile-dir="${profile-dir/#\~/$HOME}"
+patched-dir="${patched-dir/#\~/$HOME}"
+backup-dir="${backup-dir/#\~/$HOME}"
+log-dir="${log-dir/#\~/$HOME}"
+
+mkdir -p "${work-dir}" "${map-dir}" "${profile-dir}" "${patched-dir}" "${backup-dir}" "${log-dir}"
+COMPOSE_FILE="${work-dir}/docker-compose.yml"
+NGPM_HINTS="${work-dir}/ngpm-config.txt"
+
+logfile_init
 
 # parse profiles csv -> array
-IFS=',' read -r -a PROFILE_ARR <<< "$(echo "${profiles_csv}" | tr -d '[:space:]')"
+IFS=',' read -r -a PROFILE_ARR <<< "$(echo "${profiles-csv}" | tr -d '[:space:]')"
 if [ "${#PROFILE_ARR[@]}" -eq 0 ]; then PROFILE_ARR=(car); fi
 
-BACKEND_IMAGE="${backend_registry}:${backend_version}"
-FRONTEND_IMAGE="${frontend_registry}:${frontend_version}"
+BACKEND_IMAGE="${backend-registry}:${backend-version}"
+FRONTEND_IMAGE="${frontend-registry}:${frontend-version}"
 
 info "Command: ${command_name}"
-info "Work dir: ${work_dir}"
-info "Map dir: ${map_dir}"
-info "Profile dir: ${profile_dir}"
-info "Patched profiles dir: ${patched_dir}"
-info "Network: ${network_name}"
+info "Work dir: ${work-dir}"
+info "Map dir: ${map-dir}"
+info "Profile dir: ${profile-dir}"
+info "Patched profiles dir: ${patched-dir}"
+info "Backup dir: ${backup-dir}"
+info "Log dir: ${log-dir}"
+info "Network: ${network-name}"
 info "Backend image: ${BACKEND_IMAGE}"
 info "Frontend image: ${FRONTEND_IMAGE}"
 info "Profiles: ${PROFILE_ARR[*]}"
-info "With frontend: ${with_frontend}"
-info "Dry run: ${dry_run}"
-[ -n "$domain" ] && info "Domain (hints only): ${domain}"
-info "Path prefix (hints only): ${path_prefix}"
+info "No frontend: ${no-frontend}"
+info "No backend: ${no-backend}"
+info "Dry run: ${dry-run}"
+info "Backend domain: ${backend-domain}"
+info "Frontend domain: ${frontend-domain}"
+info "Backend path: ${backend-path}"
+info "API version: ${api-version}"
+[ -n "${map-arg}" ] && info "Map source override: ${map-arg}"
 
 # -------------------------
-# Preconditions
+# Preconditions & helpers
 # -------------------------
-command -v docker >/dev/null 2>&1 || { err "docker not found. Install Docker."; exit 1; }
-if command -v curl >/dev/null 2>&1; then downloader="curl"; else downloader="wget"; fi
+command_exists() { command -v "$1" >/dev/null 2>&1; }
 
-# -------------------------
-# Helpers
-# -------------------------
-download_file() {
-  local url="$1"; local dest="$2"
-  info "Downloading ${url} -> ${dest}"
-  if [ "$dry_run" = "true" ]; then
-    warn "[DRY RUN] Would download ${url} to ${dest}"
+ensure_package() {
+  local pkg="$1"
+  if command_exists "$pkg"; then
+    info "Dependency found: ${pkg}"
     return 0
   fi
-  mkdir -p "$(dirname "$dest")"
-  if [ "$downloader" = "curl" ]; then
-    curl -L --fail -o "${dest}.tmp" "$url" && mv "${dest}.tmp" "$dest"
+  info "Dependency missing: ${pkg}"
+  if [ "$(id -u)" -ne 0 ]; then
+    warn "Cannot auto-install ${pkg} because script not running as root. Please run: sudo dnf install -y ${pkg}"
+    return 1
+  fi
+  info "Attempting to install ${pkg} via dnf..."
+  if dnf install -y "${pkg}"; then
+    success "Installed ${pkg}"
+    return 0
   else
-    wget -O "${dest}.tmp" "$url" && mv "${dest}.tmp" "$dest"
+    warn "Failed to auto-install ${pkg}. Please install manually."
+    return 1
   fi
 }
 
-safe_copy_map() {
-  local src="$1"; local dest="$2"
-  if [ "$dry_run" = "true" ]; then
-    warn "[DRY RUN] Would copy ${src} -> ${dest} (if needed)"
+prereqs_check() {
+  local ok=0
+  # docker must be present but we can't auto-configure daemon here; just warn
+  if ! command_exists docker; then
+    warn "docker not found. Please install docker and ensure docker daemon is running."
+    ok=1
+  fi
+  # docker compose plugin
+  if ! docker compose version >/dev/null 2>&1; then
+    warn "docker compose plugin not found. Attempting to install docker-compose-plugin via dnf (requires root)."
+    if ! ensure_package docker-compose-plugin; then
+      warn "docker compose plugin not available. Please install docker compose manually."
+      ok=1
+    fi
+  fi
+  # other utils
+  for util in curl jq tar awk sed wget; do
+    if ! command_exists "$util"; then
+      info "Utility ${util} missing; attempting to install"
+      if ! ensure_package "$util"; then
+        warn "Please install ${util} manually."
+        ok=1
+      fi
+    fi
+  done
+  return ${ok}
+}
+
+# SELinux label detection for mounts
+SELINUX_LABEL=""
+if command_exists sestatus && sestatus 2>/dev/null | grep -qi enabled; then
+  SELINUX_LABEL=":z"
+  info "SELinux is enabled. Will append :z to bind mounts."
+fi
+
+# interactive prompt helper
+ask_confirm() {
+  local prompt="$1"; shift
+  if [ "${yes-all}" = true ]; then
+    info "[auto-yes] ${prompt} -> yes"
     return 0
   fi
-  mkdir -p "$(dirname "$dest")"
-  if [ -e "$dest" ]; then
-    if [ "$(realpath "$src")" = "$(realpath "$dest")" ]; then
-      info "Map already at target location; skipping copy."
+  while true; do
+    printf "%s [y/N]: " "${prompt}"
+    read -r yn
+    case "${yn}" in
+      [Yy]*) return 0 ;;
+      [Nn]*|"") return 1 ;;
+      *) echo "Please answer y or n." ;;
+    esac
+  done
+}
+
+# -------------------------
+# Map selection logic
+# - accepts URL or local path
+# - default file: ${map-dir}/indonesia-latest.osm.pbf
+# -------------------------
+select_map() {
+  info "Selecting map..."
+  # if user provided local path (map-arg) and it exists -> use it
+  if [ -n "${map-arg}" ]; then
+    if [[ "${map-arg}" =~ ^https?:// ]]; then
+      MAP_PATH="${map-dir}/$(basename "${map-arg}")"
+      download_map_if_needed "${map-arg}" "${MAP_PATH}"
       return 0
     fi
-    if [ "$(stat -c%s "$src")" = "$(stat -c%s "$dest")" ] && [ "$(sha256sum "$src" | awk '{print $1}')" = "$(sha256sum "$dest" | awk '{print $1}')" ]; then
-      info "Map identical to target (checksum); skipping copy."
+    # local path provided
+    if [ -f "${map-arg}" ]; then
+      MAP_PATH="$(realpath "${map-arg}")"
+      info "Using user-provided local map: ${MAP_PATH}"
       return 0
     fi
+    err "Provided --map-source file not found: ${map-arg}"
+    exit 1
+  fi
+
+  # check default filename in dataset dir
+  local default_file="${map-dir}/indonesia-latest.osm.pbf"
+  if [ -f "${default_file}" ]; then
+    MAP_PATH="${default_file}"
+    info "Found existing default map: ${MAP_PATH}"
+    return 0
+  fi
+
+  # otherwise, if map-source is URL -> download
+  if [[ "${map-source}" =~ ^https?:// ]]; then
+    MAP_PATH="${map-dir}/$(basename "${map-source}")"
+    download_map_if_needed "${map-source}" "${MAP_PATH}"
+    return 0
+  fi
+
+  # if map-source is local file path
+  if [ -f "${map-source}" ]; then
+    MAP_PATH="$(realpath "${map-source}")"
+    info "Using map-source path: ${MAP_PATH}"
+    return 0
   fi
-  info "Copying map ${src} -> ${dest}"
-  cp -f "$src" "$dest"
+
+  # else attempt to download from default URL
+  MAP_PATH="${map-dir}/$(basename "${DEFAULT_MAP_SOURCE}")"
+  download_map_if_needed "${DEFAULT_MAP_SOURCE}" "${MAP_PATH}"
+}
+
+download_map_if_needed() {
+  local url="$1"; local dest="$2"
+  info "Preparing map: ${url} -> ${dest}"
+  if [ -f "${dest}" ]; then
+    info "Map already exists at ${dest}. Skipping download."
+    return 0
+  fi
+  if [ "${dry-run}" = true ]; then
+    warn "[DRY RUN] Would download ${url} to ${dest}"
+    return 0
+  fi
+  mkdir -p "$(dirname "${dest}")"
+  if command_exists curl; then
+    info "Downloading with curl..."
+    curl -L --fail -o "${dest}.tmp" "${url}" && mv "${dest}.tmp" "${dest}"
+  elif command_exists wget; then
+    info "Downloading with wget..."
+    wget -O "${dest}.tmp" "${url}" && mv "${dest}.tmp" "${dest}"
+  else
+    err "No download client available (curl or wget). Cannot download map."
+    exit 1
+  fi
+  success "Map downloaded: ${dest}"
 }
 
 # -------------------------
-# Profile wrappers & patching
-# - generate default wrappers if missing (do not overwrite custom)
-# - create patched copy that ensures `arg[0]` fallback to profile name
+# Profile wrappers & patched profiles
+# - ensure default wrappers present
+# - create patched copy with arg fallback and motorcycle modifications
 # -------------------------
 generate_profile_wrappers() {
-  info "Generating profile wrappers into ${profile_dir} (only when missing)"
-  mkdir -p "$profile_dir"
+  info "Generating profile wrappers in ${profile-dir} (if missing)"
+  mkdir -p "${profile-dir}"
   for profile in "${PROFILE_ARR[@]}"; do
-    local pf="${profile_dir}/${profile}.lua"
-    if [ -f "$pf" ]; then
-      info "Custom profile exists: ${pf} (will use it)"
+    local pf="${profile-dir}/${profile}.lua"
+    if [ -f "${pf}" ]; then
+      info "Profile exists: ${pf}"
       continue
     fi
-    case "$profile" in
-      car|bicycle|foot)
-        cat > "$pf" <<'LUA'
+    case "${profile}" in
+      car|bicycle|bike|foot)
+        info "Generating wrapper for ${profile} from builtin"
+        cat > "${pf}" <<'LUA'
 -- wrapper: attempt to load builtin profile
 local function load_builtin(name)
   local cands = {"/opt/profiles/"..name..".lua", "/opt/"..name..".lua"}
@@ -265,19 +454,19 @@ local function load_builtin(name)
   end
   error("builtin profile not found: "..name)
 end
--- prefer explicit name if possible
 local base = load_builtin("car")
 if type(base) == "table" and base.setup then return base end
 if type(base) == "table" then return base end
 if type(base) == "function" then return base() end
 error("unexpected profile format")
 LUA
-        success "Generated default wrapper for ${profile}: ${pf}"
+        success "Generated wrapper: ${pf}"
         ;;
       motorcycle)
-        # custom motorcycle per spec
-        cat > "$pf" <<'LUA'
--- custom motorcycle wrapper (derived from car)
+        info "Generating motorcycle wrapper based on car"
+        # we'll create a motorcycle wrapper that loads car and patches properties
+        cat > "${pf}" <<'LUA'
+-- motorcycle wrapper derived from car profile
 local function load_builtin(name)
   local cands = {"/opt/profiles/"..name..".lua", "/opt/"..name..".lua"}
   for _,p in ipairs(cands) do
@@ -298,20 +487,13 @@ local properties = base_profile.properties or {}
 local speed_profile = base_profile.speed_profile or {}
 local turn_penalty_profile = base_profile.turn_penalty_profile or {}
 
-properties.max_speed = 100
+properties.max_speed = properties.max_speed or 100
 properties.u_turn_penalty = 60
 
-local restrictions = {
-  ['motorcycle:designated']='designated',
-  ['motorcycle:yes']='permissive',
-  ['motorcycle:no']='prohibited',
-  ['motorcar:designated']='prohibited',
-  ['motorcar:yes']='prohibited',
-  ['motorcar:no']='permissive',
-  ['highway:motorway']='prohibited',
-  ['highway:trunk']='prohibited',
-  ['toll']='prohibited'
-}
+-- add motorcycle-specific restrictions
+local restrictions = base_profile.restrictions or {}
+-- set toll to prohibited
+restrictions["toll"] = "prohibited"
 
 local profile = {
   properties = properties,
@@ -331,23 +513,22 @@ LUA
         success "Generated motorcycle wrapper: ${pf}"
         ;;
       *)
-        warn "No generator for profile '${profile}'. Please provide ${pf}"
+        warn "No generator for profile '${profile}'. Provide ${pf} manually."
         ;;
     esac
   done
 }
 
 create_patched_profiles() {
-  info "Creating patched profiles in ${patched_dir} (safe copies with arg fallback)"
-  mkdir -p "${patched_dir}"
+  info "Creating patched profiles in ${patched-dir:-${patched-dir}} (safe copies with arg fallback)"
+  mkdir -p "${patched-dir}"
   for profile in "${PROFILE_ARR[@]}"; do
-    local src="${profile_dir}/${profile}.lua"
-    local dst="${patched_dir}/${profile}.lua"
+    local src="${profile-dir}/${profile}.lua"
+    local dst="${patched-dir}/${profile}.lua"
     if [ ! -f "${src}" ]; then
-      warn "Profile source not found: ${src} (skipping patch). Ensure wrapper exists."
+      warn "Profile source not found: ${src} (skipping patch)"
       continue
     fi
-    # create patched file: ensure arg table exists with [0] = profile name
     {
       printf 'local arg = arg or {}\n'
       printf 'arg[0] = arg[0] or "%s"\n' "${profile}"
@@ -360,22 +541,25 @@ create_patched_profiles() {
 }
 
 # -------------------------
-# Compose generation
-# - both preprocess and routed services present for each profile
-# - preprocess uses profile-data (rw) so preprocess can write .osrm outputs
-# - routed uses profile-data (ro)
-# - host ports start at backend_port and increase per profile
+# Docker Compose generation (absolute paths)
+# - Create preprocess and routed service per profile
+# - Preprocess mounts patched-profiles and profile-data (rw)
+# - Routed mounts profile-data (ro)
+# - Host ports assigned starting at backend-port incremented per profile
+# - Frontend service (default installed unless --no-frontend)
 # -------------------------
 generate_docker_compose() {
   info "Generating docker-compose.yml at ${COMPOSE_FILE}"
-  mkdir -p "$(dirname "$COMPOSE_FILE")"
+  mkdir -p "$(dirname "${COMPOSE_FILE}")"
 
+  local selabel="${SELINUX_LABEL:-}"
   local services=""
   local idx=0
   for profile in "${PROFILE_ARR[@]}"; do
     idx=$((idx+1))
-    local host_port=$((backend_port + idx - 1))
-    mkdir -p "${work_dir}/${profile}-data"
+    local host_port=$((backend-port + idx - 1))
+    local pdata="${work-dir}/${profile}-data"
+    mkdir -p "${pdata}"
     services+="
   osrm-preprocess-${profile}:
     image: ${BACKEND_IMAGE}
@@ -385,10 +569,10 @@ generate_docker_compose() {
              osrm-partition /data/map.osrm &&
              osrm-customize /data/map.osrm\"
     volumes:
-      - ./patched-profiles:/opt/custom_profiles:ro
-      - ./${profile}-data:/data:rw
+      - ${patched-dir}:/opt/custom_profiles:ro${selabel}
+      - ${pdata}:/data:rw${selabel}
     networks:
-      - ${network_name}
+      - ${network-name}
 
   osrm-routed-${profile}:
     image: ${BACKEND_IMAGE}
@@ -396,372 +580,550 @@ generate_docker_compose() {
     restart: unless-stopped
     command: osrm-routed --algorithm mld --max-table-size 10000 /data/map.osrm
     volumes:
-      - ./${profile}-data:/data:ro
+      - ${pdata}:/data:ro${selabel}
     ports:
       - \"${host_port}:5000\"
     networks:
-      - ${network_name}
+      - ${network-name}
 "
   done
 
   local frontend_block=""
-  if [ "${with_frontend}" = "true" ]; then
+  if [ "${no-frontend}" != true ]; then
+    # build list of backend urls for frontend environment variable
+    local backend_urls=""
+    local idx2=0
+    for profile in "${PROFILE_ARR[@]}"; do
+      idx2=$((idx2+1))
+      local host_port=$((backend-port + idx2 - 1))
+      # backend url format: {backend-domain}:{backend-port}/osrm/{api-version}/{profile}
+      local url="http://${backend-domain}:${host_port}${backend-path}/${api-version}/${profile}"
+      if [ -z "${backend_urls}" ]; then
+        backend_urls="${url}"
+      else
+        backend_urls="${backend_urls},${url}"
+      fi
+    done
+
     frontend_block+="
   osrm-frontend:
     image: ${FRONTEND_IMAGE}
     container_name: osrm-frontend
     restart: unless-stopped
     environment:
-      - DEFAULT_BACKEND_URL=http://osrm-routed-${PROFILE_ARR[0]}:5000
+      - DEFAULT_BACKEND_URLS=${backend-urls}
     ports:
-      - \"${frontend_port}:9966\"
+      - \"${frontend-port}:9966\"
     networks:
-      - ${network_name}
+      - ${network-name}
 "
   fi
 
   cat > "${COMPOSE_FILE}" <<EOF
+version: '3.8'
 services:
 ${services}
 ${frontend_block}
 networks:
-  ${network_name}:
+  ${network-name}:
     external: true
-    name: ${network_name}
+    name: ${network-name}
 EOF
 
   success "docker-compose.yml written to ${COMPOSE_FILE}"
 }
 
 # -------------------------
-# Ensure docker network
+# Ensure docker network exists
 # -------------------------
 ensure_network() {
-  if [ "${dry_run}" = "true" ]; then
-    warn "[DRY RUN] Would ensure docker network '${network_name}' exists"
+  if [ "${dry-run}" = true ]; then
+    warn "[DRY RUN] Would ensure docker network ${network-name} exists"
     return 0
   fi
-  if docker network inspect "${network_name}" >/dev/null 2>&1; then
-    info "Docker network '${network_name}' exists"
+  if docker network inspect "${network-name}" >/dev/null 2>&1; then
+    info "Docker network ${network-name} exists"
   else
-    info "Creating docker network '${network_name}'"
-    docker network create "${network_name}"
-  fi
-}
-
-# -------------------------
-# Map selection / prep
-# -------------------------
-select_map() {
-  if [ -n "${map_arg:-}" ]; then
-    if [[ "${map_arg}" =~ ^https?:// ]]; then
-      MAP_PATH="${map_dir}/$(basename "${map_arg}")"
-      download_file "${map_arg}" "${MAP_PATH}"
-      return 0
-    fi
-    if [ -f "${map_arg}" ]; then
-      MAP_PATH="${map_arg}"
-      info "Using user-provided map: ${MAP_PATH}"
-      return 0
-    fi
-    err "Provided --map not found: ${map_arg}"
-    exit 1
+    info "Creating docker network ${network-name}"
+    docker network create "${network-name}"
   fi
-
-  local newest
-  newest="$(ls -t "${map_dir}"/*.osm.pbf 2>/dev/null | head -n1 || true)"
-  if [ -n "${newest}" ]; then
-    MAP_PATH="${newest}"
-    info "Found newest map in ${map_dir}: ${MAP_PATH}"
-    return 0
-  fi
-
-  MAP_PATH="${map_dir}/$(basename "${map_source}")"
-  info "No local map found; downloading ${map_source} -> ${MAP_PATH}"
-  download_file "${map_source}" "${MAP_PATH}"
 }
 
 # -------------------------
-# Pull images
+# Pull images (interactive)
 # -------------------------
 pull_images() {
-  if [ "${dry_run}" = "true" ]; then
+  if [ "${dry-run}" = true ]; then
     warn "[DRY RUN] Would pull images: ${BACKEND_IMAGE} ${FRONTEND_IMAGE}"
     return 0
   fi
-  info "Pulling backend image: ${BACKEND_IMAGE}"
-  docker pull "${BACKEND_IMAGE}"
-  if [ "${with_frontend}" = "true" ]; then
-    info "Pulling frontend image: ${FRONTEND_IMAGE}"
-    docker pull "${FRONTEND_IMAGE}"
+  info "Pulling images..."
+  if [ "${do-update-backend}" = true ] || [ "${do-update-all}" = true ] || [ "${command_name}" = "install" ]; then
+    info "Pull backend: ${BACKEND_IMAGE}"
+    docker pull "${BACKEND_IMAGE}" || warn "docker pull backend failed"
+  fi
+  if [ "${no-frontend}" != true ] && ( [ "${do-update-frontend}" = true ] || [ "${do-update-all}" = true ] || [ "${command_name}" = "install" ] ); then
+    info "Pull frontend: ${FRONTEND_IMAGE}"
+    docker pull "${FRONTEND_IMAGE}" || warn "docker pull frontend failed"
   fi
 }
 
 # -------------------------
-# Preprocess sequentially
+# Preprocess sequentially (per profile)
 # -------------------------
 preprocess_sequential() {
-  info "Starting sequential preprocessing for profiles: ${PROFILE_ARR[*]}"
-  mkdir -p "${work_dir}/dataset"
-  safe_copy_map "${MAP_PATH}" "${work_dir}/dataset/map.osm.pbf"
+  info "Starting sequential preprocess for profiles: ${PROFILE_ARR[*]}"
+  mkdir -p "${work-dir}/dataset"
+  # ensure map copied into each profile-data as map.osm.pbf
+  safe_copy_map "${MAP_PATH}" "${work-dir}/dataset/map.osm.pbf"
 
   local idx=0
   for profile in "${PROFILE_ARR[@]}"; do
     idx=$((idx+1))
     info "=== Preprocessing (${idx}/${#PROFILE_ARR[@]}): ${profile} ==="
-    local profile_data="${work_dir}/${profile}-data"
-    mkdir -p "${profile_data}"
-    safe_copy_map "${work_dir}/dataset/map.osm.pbf" "${profile_data}/map.osm.pbf"
-
-    # run preprocess
-    if [ "${dry_run}" = "true" ]; then
-      warn "[DRY RUN] Would run: docker compose --project-directory ${work_dir} up --build osrm-preprocess-${profile}"
-      warn "[DRY RUN] Would run: docker compose --project-directory ${work_dir} rm -fsv osrm-preprocess-${profile}"
-      success "Simulated preprocess for: ${profile}"
+    local pdata="${work-dir}/${profile}-data"
+    mkdir -p "${pdata}"
+    safe_copy_map "${work-dir}/dataset/map.osm.pbf" "${pdata}/map.osm.pbf"
+
+    if [ "${dry-run}" = true ]; then
+      warn "[DRY RUN] Would run: docker compose --project-directory ${work-dir} up --build osrm-preprocess-${profile}"
       continue
     fi
 
-    # start preprocess and capture exit
-    if docker compose --project-directory "${work_dir}" up --build osrm-preprocess-"${profile}"; then
-      success "Preprocess SUCCESS for: ${profile}"
+    # run preprocess (compose creates container)
+    if docker compose --project-directory "${work-dir}" up --build osrm-preprocess-"${profile}"; then
+      success "Preprocess container exited 0 for: ${profile}"
     else
-      err "Preprocess FAILED for: ${profile} -- skipping routed service for this profile"
-      # ensure container removed
-      docker compose --project-directory "${work_dir}" rm -fsv osrm-preprocess-"${profile}" || true
-      # mark: skip further action for this profile by removing its profile-data (or leaving as-is)
+      err "Preprocess failed for: ${profile}. Showing logs:"
+      docker compose --project-directory "${work-dir}" logs osrm-preprocess-"${profile}" --no-log-prefix | sed -n '1,200p' || true
+      docker compose --project-directory "${work-dir}" rm -fsv osrm-preprocess-"${profile}" || true
       continue
     fi
 
-    # remove preprocess container (cleanup)
-    docker compose --project-directory "${work_dir}" rm -fsv osrm-preprocess-"${profile}" || true
-    # brief pause
+    # cleanup container
+    docker compose --project-directory "${work-dir}" rm -fsv osrm-preprocess-"${profile}" || true
+
+    # Post-check: find map.osrm.properties or any map.osrm*
+    if [ -f "${pdata}/map.osrm.properties" ] || ls "${pdata}"/*.osrm* >/dev/null 2>&1; then
+      success "Preprocess SUCCESS for: ${profile}"
+    else
+      warn "Preprocess claimed success but no OSRM outputs found in ${pdata}"
+      docker compose --project-directory "${work-dir}" logs osrm-preprocess-"${profile}" --no-log-prefix | sed -n '1,200p' || true
+      continue
+    fi
     sleep 1
   done
 }
 
 # -------------------------
-# Start routed services
+# safe copy map helper (avoid unnecessary copies)
+# -------------------------
+safe_copy_map() {
+  local src="$1"; local dest="$2"
+  if [ "${dry-run}" = true ]; then
+    warn "[DRY RUN] Would cp ${src} -> ${dest}"
+    return 0
+  fi
+  mkdir -p "$(dirname "${dest}")"
+  if [ -e "${dest}" ] && [ -e "${src}" ]; then
+    if [ "$(realpath "${src}")" = "$(realpath "${dest}")" ]; then
+      info "Map already at target location; skipping copy"
+      return 0
+    fi
+    if [ "$(stat -c%s "${src}")" = "$(stat -c%s "${dest}")" ] && [ "$(sha256sum "${src}" | awk '{print $1}')" = "$(sha256sum "${dest}" | awk '{print $1}')" ]; then
+      info "Map identical to target; skipping copy"
+      return 0
+    fi
+  fi
+  cp -f "${src}" "${dest}"
+  info "Copied map to ${dest}"
+}
+
+# -------------------------
+# Start routed services (idempotent checks)
 # -------------------------
 start_routed_services() {
   info "Starting routed services for profiles: ${PROFILE_ARR[*]}"
-  if [ "${dry_run}" = "true" ]; then
+  if [ "${dry-run}" = true ]; then
     warn "[DRY RUN] Would start routed containers via docker compose"
     return 0
   fi
-  # achieve idempotent behavior: try to start only services that have .osrm present
+
   local to_start=()
   local idx=0
   for profile in "${PROFILE_ARR[@]}"; do
     idx=$((idx+1))
-    local profile_data="${work_dir}/${profile}-data"
-    if [ -f "${profile_data}/map.osrm" ] || ls "${profile_data}"/*.osrm 2>/dev/null | grep -q .; then
+    local pdata="${work-dir}/${profile}-data"
+    if [ -f "${pdata}/map.osrm.properties" ] || ls "${pdata}"/*.osrm* >/dev/null 2>&1; then
       to_start+=("osrm-routed-${profile}")
     else
-      warn "Skipping osrm-routed-${profile}: .osrm output not found in ${profile_data}"
+      warn "Skipping osrm-routed-${profile}: no OSRM outputs found in ${pdata}"
     fi
   done
 
   if [ "${#to_start[@]}" -eq 0 ]; then
-    err "No routed services to start (no successful preprocess outputs found)."
+    err "No routed services to start."
     return 1
   fi
 
-  docker compose --project-directory "${work_dir}" up -d "${to_start[@]}"
-  success "Routed services started: ${to_start[*]}"
+  # detect existing containers and ask for recreate if present
+  local will_start=()
+  for svc in "${to_start[@]}"; do
+    if docker ps -a --format '{{.Names}}' | grep -q "^${svc}$"; then
+      if ask_confirm "Container ${svc} already exists. Recreate (stop & remove & recreate)?" ; then
+        info "Recreating ${svc}"
+        docker compose --project-directory "${work-dir}" rm -fsv "${svc}" || true
+        will_start+=("${svc}")
+      else
+        info "Keeping existing ${svc}"
+      fi
+    else
+      will_start+=("${svc}")
+    fi
+  done
+
+  if [ "${#will_start[@]}" -eq 0 ]; then
+    info "No routed services selected to start."
+    return 0
+  fi
+
+  docker compose --project-directory "${work-dir}" up -d "${will_start[@]}"
+  success "Routed services started: ${will_start[*]}"
 
-  # print mapping
   local idx2=0
   for profile in "${PROFILE_ARR[@]}"; do
     idx2=$((idx2+1))
-    local host_port=$((backend_port + idx2 - 1))
+    local host_port=$((backend-port + idx2 - 1))
     info "Profile ${profile}: host port ${host_port} -> container osrm-routed-${profile}:5000"
   done
 }
 
 # -------------------------
-# Start frontend
+# Start frontend (idempotent)
 # -------------------------
 start_frontend() {
-  if [ "${with_frontend}" != "true" ]; then
-    info "Frontend not requested"
+  if [ "${no-frontend}" = true ]; then
+    info "Frontend installation skipped (--no-frontend)"
     return 0
   fi
-  if [ "${dry_run}" = "true" ]; then
+  if [ "${dry-run}" = true ]; then
     warn "[DRY RUN] Would start osrm-frontend via docker compose"
     return 0
   fi
-  docker compose --project-directory "${work_dir}" up -d osrm-frontend
-  success "Frontend started (container osrm-frontend) host port ${frontend_port}"
+  if docker ps -a --format '{{.Names}}' | grep -q "^osrm-frontend$"; then
+    if ask_confirm "osrm-frontend container exists. Recreate?" ; then
+      docker compose --project-directory "${work-dir}" rm -fsv osrm-frontend || true
+    else
+      info "Keeping existing osrm-frontend"
+      return 0
+    fi
+  fi
+  docker compose --project-directory "${work-dir}" up -d osrm-frontend
+  success "Frontend started (container osrm-frontend) host port ${frontend-port}"
 }
 
 # -------------------------
-# Generate NGPM hints (printed + saved)
+# Generate NGPM hints
 # -------------------------
 generate_ngpm_hints() {
-  info "Generating NGPM & frontend hints at ${NGPM_HINTS}"
+  info "Generating NGPM hints at ${NGPM_HINTS}"
   {
-    echo "NGPM (Nginx Proxy Manager) configuration hints"
-    echo "Domain (hints only): ${domain:-<your-domain>}"
-    echo "Path prefix (hints only): ${path_prefix}"
+    echo "NGPM (Nginx Proxy Manager) hints"
+    echo "Backend domain: ${backend-domain}"
+    echo "Frontend domain: ${frontend-domain}"
+    echo "Backend path: ${backend-path}/${api-version}/{profile}"
     echo
-    printf "%-30s %-35s %s\n" "LOCATION PATH" "FORWARD HOSTNAME / IP" "CONTAINER PORT -> HOST"
+    printf "%-30s %-35s %s\n" "LOCATION PATH" "FORWARD HOSTNAME / CONTAINER" "HOST PORT"
     local idx=0
     for profile in "${PROFILE_ARR[@]}"; do
       idx=$((idx+1))
-      local host_port=$((backend_port + idx - 1))
-      printf "%-30s %-35s %s\n" "${path_prefix}/${profile}" "osrm-routed-${profile}" "5000 -> ${host_port}"
+      local host_port=$((backend-port + idx - 1))
+      printf "%-30s %-35s %s\n" "${backend-path}/${api-version}/${profile}" "osrm-routed-${profile}:5000" "${host_port}"
     done
-    if [ "${with_frontend}" = "true" ]; then
+    if [ "${no-frontend}" != true ]; then
       echo
-      echo "Frontend UI (optional):"
-      echo "  container: osrm-frontend"
-      echo "  host port: ${frontend_port}"
-      echo "  In the UI you can add backend URLs (manual) such as:"
-      for profile in "${PROFILE_ARR[@]}"; do
-        echo "    - http://osrm-routed-${profile}:5000"
-      done
+      echo "Frontend UI (container: osrm-frontend) -> host port ${frontend-port}"
+      echo "Configure NGPM manually and attach it to docker network ${network-name}"
     fi
-    echo
-    echo "Sample curl test using domain (replace <host> if domain not set):"
-    local first_profile="${PROFILE_ARR[0]}"
-    echo "  curl \"${domain:-http://<host>}${path_prefix}/${first_profile}/route/v1/driving/106.82,-6.17;106.83,-6.18?overview=false\""
-    echo
-    echo "Notes:"
-    echo "- Ensure NGPM is attached to Docker network '${network_name}'."
-    echo "- This script does NOT modify frontend config.js automatically. Configure frontend UI manually if needed."
   } > "${NGPM_HINTS}"
   success "NGPM hints saved to ${NGPM_HINTS}"
-  info "NGPM hints (preview):"
+  info "NGPM hints preview:"
   sed -n '1,200p' "${NGPM_HINTS}" | sed -n '1,120p'
 }
 
 # -------------------------
-# print-config
+# Print resolved configuration
 # -------------------------
 print_configuration() {
   cat <<EOF
 Resolved configuration:
-  work-dir: ${work_dir}
-  map-dir: ${map_dir}
-  profile-dir: ${profile_dir}
-  patched-profiles-dir: ${patched_dir}
-  backend-image: ${BACKEND_IMAGE}
-  frontend-image: ${FRONTEND_IMAGE}
-  profiles: ${PROFILE_ARR[*]}
-  network: ${network_name}
-  backend-port(start): ${backend_port}
-  frontend-port: ${frontend_port}
-  with-frontend: ${with_frontend}
-  domain (hints only): ${domain}
-  path-prefix (hints only): ${path_prefix}
-  dry-run: ${dry_run}
+  work-dir:        ${work-dir}
+  map-dir:         ${map-dir}
+  profile-dir:     ${profile-dir}
+  patched-dir:     ${patched-dir}
+  backup-dir:      ${backup-dir}
+  log-dir:         ${log-dir}
+  docker-compose:  ${COMPOSE_FILE}
+  backend-image:   ${BACKEND_IMAGE}
+  frontend-image:  ${FRONTEND_IMAGE}
+  profiles:        ${PROFILE_ARR[*]}
+  network:         ${network-name}
+  backend-port:    ${backend-port}
+  frontend-port:   ${frontend-port}
+  backend-domain:  ${backend-domain}
+  frontend-domain: ${frontend-domain}
+  backend-path:    ${backend-path}
+  api-version:     ${api-version}
+  no-frontend:     ${no-frontend}
+  no-backend:      ${no-backend}
+  dry-run:         ${dry-run}
 EOF
 }
 
 # -------------------------
-# Update logic
+# Update functions
 # -------------------------
-perform_update() {
-  info "Performing update actions"
-  if [ "${update_map}" = "false" ] && [ "${update_profiles}" = "false" ] && [ "${update_images}" = "false" ]; then
-    update_map=true; update_profiles=true; update_images=true
-  fi
+update_backend() {
+  info "Updating backend..."
+  pull_images
+  # recreate routed services for backend profiles
+  for profile in "${PROFILE_ARR[@]}"; do
+    local svc="osrm-routed-${profile}"
+    if docker ps -a --format '{{.Names}}' | grep -q "^${svc}$"; then
+      if ask_confirm "Recreate ${svc} with new backend image?" ; then
+        docker compose --project-directory "${work-dir}" rm -fsv "${svc}" || true
+      else
+        info "Skipping ${svc}"
+        continue
+      fi
+    fi
+    docker compose --project-directory "${work-dir}" up -d "${svc}" || warn "Failed to start ${svc}"
+    success "Updated ${svc}"
+  done
+}
 
-  if [ "${update_images}" = "true" ]; then
-    pull_images
+update_frontend() {
+  info "Updating frontend..."
+  pull_images
+  if [ "${no-frontend}" = true ]; then
+    info "--no-frontend set; skipping frontend update"
+    return 0
   fi
-
-  if [ "${update_profiles}" = "true" ]; then
-    generate_profile_wrappers
-    create_patched_profiles
+  if docker ps -a --format '{{.Names}}' | grep -q "^osrm-frontend$"; then
+    if ask_confirm "Recreate osrm-frontend with new image?" ; then
+      docker compose --project-directory "${work-dir}" rm -fsv osrm-frontend || true
+    else
+      info "Keeping existing frontend"
+      return 0
+    fi
   fi
+  docker compose --project-directory "${work-dir}" up -d osrm-frontend || warn "Failed to start osrm-frontend"
+  success "Frontend updated"
+}
 
-  if [ "${update_map}" = "true" ]; then
-    local target="${map_dir}/$(basename "${map_source}")"
-    download_file "${map_source}" "${target}"
-    info "Map updated: ${target}"
+update_map() {
+  info "Updating map dataset..."
+  # if map-source is url -> download
+  if [[ "${map-source}" =~ ^https?:// ]]; then
+    local dest="${map-dir}/$(basename "${map-source}")"
+    if [ "${dry-run}" = true ]; then
+      warn "[DRY RUN] Would download ${map-source} -> ${dest}"
+    else
+      download_map_if_needed "${map-source}" "${dest}"
+      MAP_PATH="${dest}"
+    fi
+  elif [ -f "${map-source}" ]; then
+    MAP_PATH="$(realpath "${map-source}")"
+    info "Using local map: ${MAP_PATH}"
+  else
+    warn "Map source not found: ${map-source}"
+    return 1
   fi
 
-  success "Update finished"
+  # rebuild all profiles if requested
+  preprocess_sequential
+  # restart routed services
+  start_routed_services || true
+  success "Map update completed"
+}
+
+update_profile() {
+  info "Updating profiles..."
+  # re-generate wrappers and patched profiles
+  generate_profile_wrappers
+  create_patched_profiles
+  preprocess_sequential
+  start_routed_services || true
+  success "Profile update completed"
+}
+
+update_all() {
+  info "Running update-all (backend, frontend, map, profile)"
+  pull_images
+  update_map
+  update_profile
+  update_backend
+  update_frontend
+  success "All components updated"
 }
 
 # -------------------------
-# Remove (clean)
+# Remove functions
 # -------------------------
-perform_remove() {
-  info "Removing containers and generated data (profile-data)"
-  if [ "${dry_run}" = "true" ]; then
-    warn "[DRY RUN] Would docker compose down and remove ${work_dir}/*-data"
-    return 0
-  fi
-  docker compose --project-directory "${work_dir}" down --remove-orphans || true
+backup_before_remove() {
+  local bfile="${backup-dir}/backup-$(date '+%Y%m%d_%H%M%S').tar.gz"
+  info "Creating backup ${bfile}"
+  tar -czf "${bfile}" -C "${work-dir}" . || warn "Backup failed"
+  info "Backup saved: ${bfile}"
+}
+
+remove_backend() {
+  info "Removing backend containers..."
   for profile in "${PROFILE_ARR[@]}"; do
-    rm -rf "${work_dir}/${profile}-data" || true
+    local svc="osrm-routed-${profile}"
+    if docker ps -a --format '{{.Names}}' | grep -q "^${svc}$"; then
+      docker rm -f "${svc}" || warn "Failed to remove ${svc}"
+      success "Removed ${svc}"
+    else
+      info "${svc} not present"
+    fi
+    if [ "${do-purge}" = true ]; then
+      rm -rf "${work-dir}/${profile}-data" || warn "Failed to purge ${work-dir}/${profile}-data"
+      info "Purged ${work-dir}/${profile}-data"
+    fi
   done
+  # remove preprocess containers if any
+  docker compose --project-directory "${work-dir}" rm -fsv $(docker compose --project-directory "${work-dir}" ps --services --filter "status=exited" 2>/dev/null || true) || true
+  success "Backend removal completed"
+}
+
+remove_frontend() {
+  info "Removing frontend container..."
+  if docker ps -a --format '{{.Names}}' | grep -q '^osrm-frontend$'; then
+    docker rm -f osrm-frontend || warn "Failed to remove osrm-frontend"
+    success "Removed osrm-frontend"
+  else
+    info "osrm-frontend not present"
+  fi
+}
+
+remove_profile() {
+  info "Removing profiles and patched-profiles..."
+  rm -rf "${profile-dir}"/* "${patched-dir}"/* || warn "Failed to remove some profile files"
+  success "Profiles removed"
+}
+
+remove_map() {
+  info "Removing map dataset..."
+  rm -rf "${map-dir}"/* || warn "Failed to remove map files"
+  success "Map files removed"
+}
+
+remove_all() {
+  info "Removing all OSRM components..."
+  backup_before_remove
+  remove_frontend
+  remove_backend
+  remove_profile
+  remove_map
   rm -f "${COMPOSE_FILE}" "${NGPM_HINTS}" || true
-  success "Remove completed"
+  success "All components removed"
 }
 
 # -------------------------
 # Main dispatcher
 # -------------------------
 case "${command_name}" in
-  print-config)
-    print_configuration
-    exit 0
-    ;;
-  status)
-    docker ps --filter "network=${network_name}" --format 'table {{.Names}}\t{{.Status}}\t{{.Ports}}'
-    exit 0
-    ;;
-  remove)
-    perform_remove
-    exit 0
-    ;;
-  update)
-    perform_update
-    exit 0
-    ;;
   install)
-    # Prepare environment
     info "Install flow started"
-    mkdir -p "${work_dir}" "${map_dir}" "${profile_dir}" "${patched_dir}"
-    BACKEND_IMAGE="${backend_registry}:${backend_version}"
-    FRONTEND_IMAGE="${frontend_registry}:${frontend_version}"
+    # prereqs
+    prereqs_check || warn "Some dependencies missing; check above warnings"
 
-    # 1) map selection
+    # map selection
     select_map
 
-    # 2) generate wrappers if missing
+    # generate wrappers if missing
     generate_profile_wrappers
 
-    # 3) create patched profiles (patched copies with arg fallback)
+    # create patched profiles
     create_patched_profiles
 
-    # 4) pull images (if requested/desired)
+    # pull images
     pull_images
 
-    # 5) write docker-compose
+    # generate compose
     generate_docker_compose
 
-    # 6) ensure network
+    # ensure network
     ensure_network
 
-    # 7) sequential preprocess
+    # preprocess sequential
     preprocess_sequential
 
-    # 8) start routed services (only for profiles which produced .osrm)
-    start_routed_services
+    # start routed
+    start_routed_services || true
 
-    # 9) start frontend if requested
+    # start frontend
     start_frontend
 
-    # 10) generate NGPM & frontend hints
+    # ngpm hints
     generate_ngpm_hints
 
     success "Install flow completed"
     info "NGPM hints saved: ${NGPM_HINTS}"
-    info "Use --print-config to verify parsed configuration quickly"
+    print_configuration
+    exit 0
+    ;;
+  update)
+    info "Update flow started"
+    prereqs_check || warn "Dependency warnings (check logs)"
+
+    # honor granular flags if specified; if none specified, default to update-all
+    if [ "${do-update-backend}" = false ] && [ "${do-update-frontend}" = false ] && [ "${do-update-map}" = false ] && [ "${do-update-profile}" = false ] && [ "${do-update-all}" = false ]; then
+      do-update-all=true
+    fi
+
+    if [ "${do-update-all}" = true ]; then
+      update_all
+    else
+      [ "${do-update-map}" = true ] && update_map
+      [ "${do-update-profile}" = true ] && update_profile
+      [ "${do-update-backend}" = true ] && update_backend
+      [ "${do-update-frontend}" = true ] && update_frontend
+    fi
+    success "Update flow completed"
+    exit 0
+    ;;
+  remove)
+    info "Remove flow started"
+    # if no flags given, prompt overall remove-all
+    if [ "${do-remove-backend}" = false ] && [ "${do-remove-frontend}" = false ] && [ "${do-remove-profile}" = false ] && [ "${do-remove-map}" = false ] && [ "${do-remove-all}" = false ]; then
+      if ask_confirm "No remove sub-flag given. Remove all OSRM components (including data)?"; then
+        do-remove-all=true
+      else
+        info "Remove aborted"
+        exit 0
+      fi
+    fi
+
+    if [ "${do-remove-all}" = true ]; then
+      if ask_confirm "This will remove ALL OSRM components. Proceed?"; then
+        remove_all
+      else
+        info "Remove-all aborted"
+        exit 0
+      fi
+    else
+      [ "${do-remove-frontend}" = true ] && remove_frontend
+      [ "${do-remove-backend}" = true ] && remove_backend
+      [ "${do-remove-profile}" = true ] && remove_profile
+      [ "${do-remove-map}" = true ] && remove_map
+      if [ "${do-purge}" = true ]; then
+        info "--purge provided: purging dataset/profile directories"
+        rm -rf "${work-dir}/"*/-data || true
+      fi
+    fi
+    success "Remove flow completed"
     exit 0
     ;;
   *)