diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index b1559268a..9c1f8908b 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -23,7 +23,7 @@ jobs:
         run: chmod +x gradlew
 
       - name: Build
-        run: ./gradlew --no-daemon :api:bootJar
+        run: ./gradlew --no-daemon :api:shadowJar
 
       - name: Upload Artifact
         uses: actions/upload-artifact@v4
diff --git a/Makefile b/Makefile
index e38c9b7fd..ac3f341cd 100644
--- a/Makefile
+++ b/Makefile
@@ -1,24 +1,18 @@
-.PHONY: api desktop bootRun build install
+.PHONY: api desktop build install
 
 ifeq ($(OS),Windows_NT)
 api:
-	gradlew.bat api:bootJar
+	gradlew.bat api:shadowJar
 
 desktop:
 	cd desktop && npm run electron:build
-
-bootRun:
-	gradlew.bat api:bootRun --args='--server.port=7000'
 else
 api:
-	./gradlew api:bootJar
+	./gradlew api:shadowJar
 
 desktop:
 	cd desktop && npm run electron:build:deb
 
-bootRun:
-	./gradlew api:bootRun --args='--server.port=7000'
-
 install:
 	sudo dpkg -i desktop/release/nebulosa_0.1.0_amd64.deb
 endif
diff --git a/api/Main.run.xml b/api/Main.run.xml
index 69d9c73ea..2d1a2e146 100644
--- a/api/Main.run.xml
+++ b/api/Main.run.xml
@@ -1,19 +1,11 @@
 <component name="ProjectRunConfigurationManager">
-    <configuration default="false"
-                   name="Main"
-                   type="JetRunConfigurationType">
-        <option name="MAIN_CLASS_NAME"
-                value="nebulosa.api.MainKt"/>
+    <configuration default="false" name="Main" type="JetRunConfigurationType">
+        <option name="MAIN_CLASS_NAME" value="nebulosa.api.MainKt"/>
         <module name="nebulosa.api.main"/>
-        <option name="PROGRAM_PARAMETERS"
-                value="--server.port=7000 --spring.jpa.show-sql=true --logging.level.nebulosa=DEBUG"/>
+        <option name="PROGRAM_PARAMETERS" value="--port=7000 --debug"/>
         <shortenClasspath name="NONE"/>
         <method v="2">
-            <option name="Gradle.BeforeRunTask"
-                    enabled="true"
-                    tasks="build"
-                    externalProjectPath="$PROJECT_DIR$/api"
-                    vmOptions=""
+            <option name="Gradle.BeforeRunTask" enabled="true" tasks="build" externalProjectPath="$PROJECT_DIR$/api" vmOptions=""
                     scriptParameters="-x test"/>
         </method>
     </configuration>
diff --git a/api/build.gradle.kts b/api/build.gradle.kts
index f6907a480..eab48ae25 100644
--- a/api/build.gradle.kts
+++ b/api/build.gradle.kts
@@ -1,12 +1,10 @@
-import org.springframework.boot.gradle.tasks.bundling.BootJar
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 
 plugins {
     kotlin("jvm")
-    id("org.springframework.boot") version "3.3.2"
-    id("io.spring.dependency-management") version "1.1.6"
-    kotlin("plugin.spring")
     kotlin("kapt")
     id("io.objectbox")
+    id("com.gradleup.shadow")
 }
 
 dependencies {
@@ -14,13 +12,14 @@ dependencies {
     implementation(project(":nebulosa-astap"))
     implementation(project(":nebulosa-astrometrynet"))
     implementation(project(":nebulosa-alpaca-indi"))
-    implementation(project(":nebulosa-common"))
+    implementation(project(":nebulosa-autofocus"))
     implementation(project(":nebulosa-curve-fitting"))
     implementation(project(":nebulosa-guiding-phd2"))
     implementation(project(":nebulosa-hips2fits"))
     implementation(project(":nebulosa-horizons"))
     implementation(project(":nebulosa-image"))
     implementation(project(":nebulosa-indi-client"))
+    implementation(project(":nebulosa-job-manager"))
     implementation(project(":nebulosa-log"))
     implementation(project(":nebulosa-lx200-protocol"))
     implementation(project(":nebulosa-nova"))
@@ -29,6 +28,7 @@ dependencies {
     implementation(project(":nebulosa-simbad"))
     implementation(project(":nebulosa-siril"))
     implementation(project(":nebulosa-stellarium-protocol"))
+    implementation(project(":nebulosa-util"))
     implementation(project(":nebulosa-wcs"))
     implementation(project(":nebulosa-xisf"))
     implementation(libs.rx)
@@ -37,29 +37,23 @@ dependencies {
     implementation(libs.eventbus)
     implementation(libs.okhttp)
     implementation(libs.oshi)
-    implementation("org.springframework.boot:spring-boot-starter")
-    implementation("org.springframework.boot:spring-boot-starter-web") {
-        exclude(module = "spring-boot-starter-tomcat")
-    }
-    implementation("org.springframework.boot:spring-boot-starter-validation")
-    implementation("org.springframework.boot:spring-boot-starter-websocket") {
-        exclude(module = "spring-boot-starter-tomcat")
-    }
-    implementation("org.springframework.boot:spring-boot-starter-undertow")
-    implementation("org.jetbrains.kotlin:kotlin-reflect")
-    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
-    kapt("org.springframework:spring-context-indexer:6.1.12")
+    implementation(libs.javalin)
+    implementation(libs.koin)
+    implementation(libs.airline)
+
     testImplementation(project(":nebulosa-astrobin-api"))
     testImplementation(project(":nebulosa-skycatalog-stellarium"))
     testImplementation(project(":nebulosa-test"))
 }
 
-tasks.withType<BootJar> {
-    archiveFileName = "api.jar"
-    destinationDirectory = file("$rootDir/desktop")
+tasks.withType<ShadowJar> {
+    isZip64 = true
+
+    archiveFileName.set("api.jar")
+    destinationDirectory.set(file("../desktop"))
 
     manifest {
-        attributes["Start-Class"] = "nebulosa.api.MainKt"
+        attributes["Main-Class"] = "nebulosa.api.MainKt"
     }
 }
 
diff --git a/api/src/main/kotlin/nebulosa/api/Main.kt b/api/src/main/kotlin/nebulosa/api/Main.kt
index 67929a568..96f1775d8 100644
--- a/api/src/main/kotlin/nebulosa/api/Main.kt
+++ b/api/src/main/kotlin/nebulosa/api/Main.kt
@@ -1,57 +1,34 @@
 package nebulosa.api
 
+import com.github.rvesse.airline.SingleCommand
 import com.sun.jna.Platform
-import nebulosa.time.SystemClock
-import org.springframework.boot.runApplication
 import java.nio.file.Path
-import java.time.LocalDate
-import java.time.format.DateTimeFormatter
 import java.util.*
 import javax.swing.filechooser.FileSystemView
+import kotlin.io.path.Path
 import kotlin.io.path.createDirectories
-import kotlin.io.path.deleteIfExists
-import kotlin.io.path.exists
-import kotlin.io.path.listDirectoryEntries
+
+const val APP_DIR_KEY = "app.dir"
 
 fun initAppDirectory(): Path {
     val appPath = when {
-        Platform.isLinux() -> Path.of(System.getProperty("user.home"), ".nebulosa")
-        Platform.isWindows() -> Path.of(FileSystemView.getFileSystemView().defaultDirectory.path, "Nebulosa")
+        Platform.isLinux() -> Path(System.getProperty("user.home"), ".nebulosa")
+        Platform.isWindows() -> Path(FileSystemView.getFileSystemView().defaultDirectory.path, "Nebulosa")
         else -> throw IllegalStateException("unsupported operating system")
     }
 
-    appPath.createDirectories()
-    System.setProperty("app.dir", "$appPath")
     return appPath
-}
-
-private fun Path.clearLogIfPastDays(days: Long = 7L) {
-    if (exists()) {
-        val pastDays = LocalDate.now(SystemClock).minusDays(days)
-
-        for (entry in listDirectoryEntries("nebulosa-*.log")) {
-            val logDate = entry.fileName.toString()
-                .replace("nebulosa-", "")
-                .replace(".log", "")
-                .let { runCatching { LocalDate.parse(it, DateTimeFormatter.ISO_LOCAL_DATE) }.getOrNull() }
-                ?: continue
-
-            if (pastDays.isAfter(logDate)) {
-                entry.deleteIfExists()
-            }
-        }
-    }
+        .createDirectories()
+        .also { System.setProperty(APP_DIR_KEY, "$it") }
 }
 
 fun main(args: Array<String>) {
-    with(initAppDirectory()) {
-        Path.of("$this", "logs").createDirectories().clearLogIfPastDays()
-        Path.of("$this", "data").createDirectories().also { System.setProperty("DATA_PATH", "$it") }
-    }
+    initAppDirectory()
 
     // Sets default locale to en_US.
     Locale.setDefault(Locale.ENGLISH)
 
-    // Run the Spring Boot application.
-    runApplication<Nebulosa>(*args)
+    val parser = SingleCommand.singleCommand(Nebulosa::class.java)
+    val nebulosa = parser.parse(*args)
+    nebulosa.run()
 }
diff --git a/api/src/main/kotlin/nebulosa/api/Nebulosa.kt b/api/src/main/kotlin/nebulosa/api/Nebulosa.kt
index f3337ed44..167795a46 100644
--- a/api/src/main/kotlin/nebulosa/api/Nebulosa.kt
+++ b/api/src/main/kotlin/nebulosa/api/Nebulosa.kt
@@ -1,20 +1,82 @@
 package nebulosa.api
 
+import ch.qos.logback.classic.Level
+import com.fasterxml.jackson.databind.DeserializationFeature
+import com.fasterxml.jackson.databind.SerializationFeature
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule
+import com.fasterxml.jackson.module.kotlin.jsonMapper
+import com.github.rvesse.airline.annotations.Command
+import com.github.rvesse.airline.annotations.Option
+import io.javalin.Javalin
+import io.javalin.json.JavalinJackson
+import nebulosa.api.atlas.Location
+import nebulosa.api.beans.modules.DeviceModule
+import nebulosa.api.inject.*
+import nebulosa.json.PathModule
 import nebulosa.log.loggerFor
-import org.springframework.boot.autoconfigure.SpringBootApplication
-import org.springframework.boot.web.servlet.context.ServletWebServerInitializedEvent
-import org.springframework.context.event.EventListener
+import org.koin.core.context.startKoin
+import org.slf4j.LoggerFactory
+import java.util.concurrent.ConcurrentHashMap
 
-@SpringBootApplication
-class Nebulosa {
+@Command(name = "nebulosa")
+class Nebulosa : Runnable, AutoCloseable {
 
-    @EventListener
-    private fun onServletWebServerInitializedEvent(event: ServletWebServerInitializedEvent) {
-        LOG.info("server is started at port: ${event.webServer.port}")
+    @Option(name = ["-h", "--host"])
+    private var host = "0.0.0.0"
+
+    @Option(name = ["-p", "--port"])
+    private var port = 0
+
+    @Option(name = ["-d", "--debug"])
+    private var debug = false
+
+    private lateinit var app: Javalin
+
+    override fun run() {
+        if (debug) {
+            with(LoggerFactory.getLogger("nebulosa") as ch.qos.logback.classic.Logger) {
+                level = Level.DEBUG
+            }
+        }
+
+        // Run the server.
+        app = Javalin.create { config ->
+            config.showJavalinBanner = false
+            // JACKSON
+            config.jsonMapper(JavalinJackson(OBJECT_MAPPER))
+            // CORS
+            config.bundledPlugins.enableCors { cors ->
+                cors.addRule {
+                    it.anyHost()
+                    it.exposeHeader("X-Image-Info")
+                }
+            }
+        }.start(host, port)
+
+        koinApp.modules(appModule(app))
+        koinApp.modules(objectMapperModule(OBJECT_MAPPER))
+        koinApp.modules(servicesModule())
+        koinApp.modules(controllersModule())
+        startKoin(koinApp)
+
+        LOG.info("server is started at port: {}", app.port())
+    }
+
+    override fun close() {
+        app.stop()
     }
 
     companion object {
 
         @JvmStatic private val LOG = loggerFor<Nebulosa>()
+
+        @JvmStatic private val OBJECT_MAPPER = jsonMapper {
+            addModule(JavaTimeModule())
+            addModule(PathModule())
+            addModule(DeviceModule())
+            disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
+            enable(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)
+            disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
+        }
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/alignment/polar/PolarAlignmentController.kt b/api/src/main/kotlin/nebulosa/api/alignment/polar/PolarAlignmentController.kt
index 0b16df7d0..9c519c437 100644
--- a/api/src/main/kotlin/nebulosa/api/alignment/polar/PolarAlignmentController.kt
+++ b/api/src/main/kotlin/nebulosa/api/alignment/polar/PolarAlignmentController.kt
@@ -1,59 +1,72 @@
 package nebulosa.api.alignment.polar
 
-import nebulosa.api.alignment.polar.darv.DARVEvent
+import io.javalin.Javalin
+import io.javalin.http.Context
+import io.javalin.http.bodyAsClass
 import nebulosa.api.alignment.polar.darv.DARVStartRequest
-import nebulosa.api.alignment.polar.tppa.TPPAEvent
 import nebulosa.api.alignment.polar.tppa.TPPAStartRequest
-import nebulosa.indi.device.camera.Camera
-import nebulosa.indi.device.guider.GuideOutput
-import nebulosa.indi.device.mount.Mount
-import org.springframework.web.bind.annotation.*
+import nebulosa.api.connection.ConnectionService
+import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.valid
 
-@RestController
-@RequestMapping("polar-alignment")
 class PolarAlignmentController(
+    app: Javalin,
     private val polarAlignmentService: PolarAlignmentService,
+    private val connectionService: ConnectionService,
 ) {
 
-    @PutMapping("darv/{camera}/{guideOutput}/start")
-    fun darvStart(
-        camera: Camera, guideOutput: GuideOutput,
-        @RequestBody body: DARVStartRequest,
-    ) = polarAlignmentService.darvStart(camera, guideOutput, body)
+    init {
+        app.put("polar-alignment/darv/{camera}/{guideOutput}/start", ::darvStart)
+        app.put("polar-alignment/darv/{camera}/stop", ::darvStop)
+        app.get("polar-alignment/darv/{camera}/status", ::darvStatus)
+        app.put("polar-alignment/tppa/{camera}/{mount}/start", ::tppaStart)
+        app.put("polar-alignment/tppa/{camera}/stop", ::tppaStop)
+        app.put("polar-alignment/tppa/{camera}/pause", ::tppaPause)
+        app.put("polar-alignment/tppa/{camera}/unpause", ::tppaUnpause)
+        app.get("polar-alignment/tppa/{camera}/status", ::tppaStatus)
+    }
+
+    private fun darvStart(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")).notNull()
+        val guideOutput = connectionService.guideOutput(ctx.pathParam("guideOutput")).notNull()
+        val body = ctx.bodyAsClass<DARVStartRequest>().valid()
+        polarAlignmentService.darvStart(camera, guideOutput, body)
+    }
 
-    @PutMapping("darv/{camera}/stop")
-    fun darvStop(camera: Camera) {
+    private fun darvStop(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")) ?: return
         polarAlignmentService.darvStop(camera)
     }
 
-    @GetMapping("darv/{camera}/status")
-    fun darvStatus(camera: Camera): DARVEvent? {
-        return polarAlignmentService.darvStatus(camera)
+    private fun darvStatus(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")).notNull()
+        polarAlignmentService.darvStatus(camera)?.also(ctx::json)
     }
 
-    @PutMapping("tppa/{camera}/{mount}/start")
-    fun tppaStart(
-        camera: Camera, mount: Mount,
-        @RequestBody body: TPPAStartRequest,
-    ) = polarAlignmentService.tppaStart(camera, mount, body)
+    private fun tppaStart(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")).notNull()
+        val mount = connectionService.mount(ctx.pathParam("mount")).notNull()
+        val body = ctx.bodyAsClass<TPPAStartRequest>().valid()
+        polarAlignmentService.tppaStart(camera, mount, body)
+    }
 
-    @PutMapping("tppa/{camera}/stop")
-    fun tppaStop(camera: Camera) {
+    private fun tppaStop(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")) ?: return
         polarAlignmentService.tppaStop(camera)
     }
 
-    @PutMapping("tppa/{camera}/pause")
-    fun tppaPause(camera: Camera) {
+    private fun tppaPause(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")) ?: return
         polarAlignmentService.tppaPause(camera)
     }
 
-    @PutMapping("tppa/{camera}/unpause")
-    fun tppaUnpause(camera: Camera) {
+    private fun tppaUnpause(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")) ?: return
         polarAlignmentService.tppaUnpause(camera)
     }
 
-    @GetMapping("tppa/{camera}/status")
-    fun tppaStatus(camera: Camera): TPPAEvent? {
-        return polarAlignmentService.tppaStatus(camera)
+    private fun tppaStatus(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")).notNull()
+        polarAlignmentService.tppaStatus(camera)?.also(ctx::json)
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/alignment/polar/PolarAlignmentService.kt b/api/src/main/kotlin/nebulosa/api/alignment/polar/PolarAlignmentService.kt
index 04e9c232e..e5c72cc7d 100644
--- a/api/src/main/kotlin/nebulosa/api/alignment/polar/PolarAlignmentService.kt
+++ b/api/src/main/kotlin/nebulosa/api/alignment/polar/PolarAlignmentService.kt
@@ -9,9 +9,7 @@ import nebulosa.api.alignment.polar.tppa.TPPAStartRequest
 import nebulosa.indi.device.camera.Camera
 import nebulosa.indi.device.guider.GuideOutput
 import nebulosa.indi.device.mount.Mount
-import org.springframework.stereotype.Service
 
-@Service
 class PolarAlignmentService(
     private val darvExecutor: DARVExecutor,
     private val tppaExecutor: TPPAExecutor,
diff --git a/api/src/main/kotlin/nebulosa/api/alignment/polar/darv/DARVEvent.kt b/api/src/main/kotlin/nebulosa/api/alignment/polar/darv/DARVEvent.kt
index b4cad781b..160f6ef63 100644
--- a/api/src/main/kotlin/nebulosa/api/alignment/polar/darv/DARVEvent.kt
+++ b/api/src/main/kotlin/nebulosa/api/alignment/polar/darv/DARVEvent.kt
@@ -1,5 +1,6 @@
 package nebulosa.api.alignment.polar.darv
 
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
 import nebulosa.api.cameras.CameraCaptureEvent
 import nebulosa.api.message.MessageEvent
 import nebulosa.guiding.GuideDirection
@@ -7,9 +8,9 @@ import nebulosa.indi.device.camera.Camera
 
 data class DARVEvent(
     @JvmField val camera: Camera,
-    @JvmField val state: DARVState = DARVState.IDLE,
-    @JvmField val direction: GuideDirection? = null,
-    @JvmField val capture: CameraCaptureEvent? = null,
+    @JvmField var state: DARVState = DARVState.IDLE,
+    @JvmField var direction: GuideDirection? = null,
+    @JvmField @field:JsonIgnoreProperties("camera") val capture: CameraCaptureEvent = CameraCaptureEvent(camera),
 ) : MessageEvent {
 
     override val eventName = "DARV.ELAPSED"
diff --git a/api/src/main/kotlin/nebulosa/api/alignment/polar/darv/DARVExecutor.kt b/api/src/main/kotlin/nebulosa/api/alignment/polar/darv/DARVExecutor.kt
index 53b85c769..c9c67dd29 100644
--- a/api/src/main/kotlin/nebulosa/api/alignment/polar/darv/DARVExecutor.kt
+++ b/api/src/main/kotlin/nebulosa/api/alignment/polar/darv/DARVExecutor.kt
@@ -1,62 +1,62 @@
 package nebulosa.api.alignment.polar.darv
 
-import io.reactivex.rxjava3.functions.Consumer
-import nebulosa.api.beans.annotations.Subscriber
 import nebulosa.api.cameras.CameraEventAware
 import nebulosa.api.message.MessageEvent
 import nebulosa.api.message.MessageService
 import nebulosa.indi.device.camera.Camera
 import nebulosa.indi.device.camera.CameraEvent
 import nebulosa.indi.device.guider.GuideOutput
+import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode
-import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor
-import org.springframework.stereotype.Component
 import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.Executor
+import java.util.concurrent.ExecutorService
+import java.util.function.Consumer
 
 /**
  * @see <a href="https://www.cloudynights.com/articles/cat/articles/darv-drift-alignment-by-robert-vice-r2760">Reference</a>
  */
-@Component
-@Subscriber
 class DARVExecutor(
     private val messageService: MessageService,
-    private val threadPoolTaskExecutor: ThreadPoolTaskExecutor,
-) : Consumer<MessageEvent>, CameraEventAware {
+    private val executorService: ExecutorService,
+    eventBus: EventBus,
+) : Consumer<MessageEvent>, CameraEventAware, Executor by executorService {
 
     private val jobs = ConcurrentHashMap.newKeySet<DARVJob>(1)
 
+    init {
+        eventBus.register(this)
+    }
+
     override fun accept(event: MessageEvent) {
         messageService.sendMessage(event)
     }
 
     @Subscribe(threadMode = ThreadMode.ASYNC)
     override fun handleCameraEvent(event: CameraEvent) {
-        jobs.find { it.task.camera === event.device }?.handleCameraEvent(event)
+        jobs.find { it.camera === event.device }?.handleCameraEvent(event)
     }
 
     @Synchronized
     fun execute(camera: Camera, guideOutput: GuideOutput, request: DARVStartRequest) {
         check(camera.connected) { "${camera.name} Camera is not connected" }
         check(guideOutput.connected) { "${guideOutput.name} Guide Output is not connected" }
-        check(jobs.none { it.task.camera === camera }) { "${camera.name} DARV Job is already in progress" }
-        check(jobs.none { it.task.guideOutput === guideOutput }) { "${camera.name} DARV Job is already in progress" }
-
-        val task = DARVTask(camera, guideOutput, request, threadPoolTaskExecutor)
-        task.subscribe(this)
+        check(jobs.none { it.camera === camera }) { "${camera.name} DARV Job is already in progress" }
+        check(jobs.none { it.guideOutput === guideOutput }) { "${camera.name} DARV Job is already in progress" }
 
-        with(DARVJob(task)) {
+        with(DARVJob(this, camera, guideOutput, request)) {
+            val completable = runAsync(executorService)
             jobs.add(this)
-            whenComplete { _, _ -> jobs.remove(this) }
-            start()
+            completable.whenComplete { _, _ -> jobs.remove(this) }
         }
     }
 
     fun stop(camera: Camera) {
-        jobs.find { it.task.camera === camera }?.stop()
+        jobs.find { it.camera === camera }?.stop()
     }
 
     fun status(camera: Camera): DARVEvent? {
-        return jobs.find { it.task.camera === camera }?.task?.get() as? DARVEvent
+        return jobs.find { it.camera === camera }?.status
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/alignment/polar/darv/DARVJob.kt b/api/src/main/kotlin/nebulosa/api/alignment/polar/darv/DARVJob.kt
index 97d290089..5b7f75e55 100644
--- a/api/src/main/kotlin/nebulosa/api/alignment/polar/darv/DARVJob.kt
+++ b/api/src/main/kotlin/nebulosa/api/alignment/polar/darv/DARVJob.kt
@@ -1,14 +1,117 @@
 package nebulosa.api.alignment.polar.darv
 
-import nebulosa.api.cameras.CameraEventAware
-import nebulosa.api.tasks.Job
+import nebulosa.api.cameras.*
+import nebulosa.api.guiding.GuidePulseRequest
+import nebulosa.api.guiding.GuidePulseTask
+import nebulosa.api.message.MessageEvent
+import nebulosa.indi.device.camera.Camera
 import nebulosa.indi.device.camera.CameraEvent
+import nebulosa.indi.device.camera.FrameType
+import nebulosa.indi.device.guider.GuideOutput
+import nebulosa.job.manager.AbstractJob
+import nebulosa.job.manager.SplitTask
+import nebulosa.job.manager.Task
+import nebulosa.job.manager.delay.DelayEvent
+import nebulosa.job.manager.delay.DelayTask
+import nebulosa.log.loggerFor
+import java.nio.file.Files
+import java.time.Duration
 
-data class DARVJob(override val task: DARVTask) : Job(), CameraEventAware {
+data class DARVJob(
+    @JvmField val darvExecutor: DARVExecutor,
+    @JvmField val camera: Camera,
+    @JvmField val guideOutput: GuideOutput,
+    @JvmField val request: DARVStartRequest,
+) : AbstractJob(), CameraEventAware {
 
-    override val name = "${task.camera.name} DARV Job"
+    @JvmField val cameraRequest = request.capture.copy(
+        exposureAmount = 1,
+        exposureTime = request.capture.exposureTime + request.capture.exposureDelay,
+        savePath = CAPTURE_SAVE_PATH, exposureDelay = Duration.ZERO,
+        frameType = FrameType.LIGHT, autoSave = false,
+        autoSubFolderMode = AutoSubFolderMode.OFF
+    )
+
+    private val direction = if (request.reversed) request.direction.reversed else request.direction
+    private val guidePulseDuration = request.capture.exposureTime.dividedBy(2L)
+
+    private val cameraExposureTask = CameraExposureTask(this, camera, cameraRequest)
+    private val delayTask = DelayTask(this, request.capture.exposureDelay)
+    private val forwardGuidePulseTask = GuidePulseTask(this, guideOutput, GuidePulseRequest(direction, guidePulseDuration))
+    private val backwardGuidePulseTask = GuidePulseTask(this, guideOutput, GuidePulseRequest(direction.reversed, guidePulseDuration))
+    private val delayAndGuidePulseTask = DelayAndGuidePulseTask()
+    private val task = SplitTask(listOf(cameraExposureTask, delayAndGuidePulseTask), darvExecutor)
+
+    @JvmField val status = DARVEvent(camera)
+
+    inline val savedPath
+        get() = status.capture.savedPath
+
+    init {
+        status.capture.exposureAmount = 1
+
+        add(task)
+    }
 
     override fun handleCameraEvent(event: CameraEvent) {
-        task.handleCameraEvent(event)
+        cameraExposureTask.handleCameraEvent(event)
+    }
+
+    override fun accept(event: Any) {
+        when (event) {
+            is DelayEvent -> {
+                status.state = if (event.task === delayTask) DARVState.INITIAL_PAUSE
+                else if (event.task === forwardGuidePulseTask.delayTask) DARVState.FORWARD
+                else DARVState.BACKWARD
+            }
+            is CameraExposureEvent -> {
+                status.capture.handleCameraExposureEvent(event)
+
+                if (event is CameraExposureFinished) {
+                    status.capture.send()
+                }
+            }
+            else -> return
+        }
+
+        status.send()
+    }
+
+    override fun beforeStart() {
+        LOG.debug("DARV started. camera={}, guideOutput={}, request={}", camera, guideOutput, request)
+
+        status.capture.handleCameraCaptureStarted(cameraExposureTask.exposureTimeInMicroseconds)
+    }
+
+    override fun afterFinish() {
+        status.capture.handleCameraCaptureFinished()
+        status.state = DARVState.IDLE
+        status.send()
+
+        LOG.debug("DARV finished. camera={}, guideOutput={}, request={}", camera, guideOutput, request)
+    }
+
+    @Suppress("NOTHING_TO_INLINE")
+    private inline fun MessageEvent.send() {
+        darvExecutor.accept(this)
+    }
+
+    private inner class DelayAndGuidePulseTask : Task {
+
+        override fun run() {
+            delayTask.run()
+
+            status.direction = forwardGuidePulseTask.request.direction
+            forwardGuidePulseTask.run()
+
+            status.direction = backwardGuidePulseTask.request.direction
+            backwardGuidePulseTask.run()
+        }
+    }
+
+    companion object {
+
+        @JvmStatic private val LOG = loggerFor<DARVJob>()
+        @JvmStatic private val CAPTURE_SAVE_PATH = Files.createTempDirectory("darv-")
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/alignment/polar/darv/DARVStartRequest.kt b/api/src/main/kotlin/nebulosa/api/alignment/polar/darv/DARVStartRequest.kt
index 209792636..4a4d02ab1 100644
--- a/api/src/main/kotlin/nebulosa/api/alignment/polar/darv/DARVStartRequest.kt
+++ b/api/src/main/kotlin/nebulosa/api/alignment/polar/darv/DARVStartRequest.kt
@@ -1,10 +1,16 @@
 package nebulosa.api.alignment.polar.darv
 
 import nebulosa.api.cameras.CameraStartCaptureRequest
+import nebulosa.api.javalin.Validatable
 import nebulosa.guiding.GuideDirection
 
 data class DARVStartRequest(
     @JvmField val capture: CameraStartCaptureRequest = CameraStartCaptureRequest.EMPTY,
     @JvmField val direction: GuideDirection = GuideDirection.NORTH,
     @JvmField val reversed: Boolean = false,
-)
+) : Validatable {
+
+    override fun validate() {
+        capture.validate()
+    }
+}
diff --git a/api/src/main/kotlin/nebulosa/api/alignment/polar/darv/DARVTask.kt b/api/src/main/kotlin/nebulosa/api/alignment/polar/darv/DARVTask.kt
deleted file mode 100644
index 3fa64a6be..000000000
--- a/api/src/main/kotlin/nebulosa/api/alignment/polar/darv/DARVTask.kt
+++ /dev/null
@@ -1,129 +0,0 @@
-package nebulosa.api.alignment.polar.darv
-
-import io.reactivex.rxjava3.functions.Consumer
-import nebulosa.api.cameras.*
-import nebulosa.api.guiding.GuidePulseEvent
-import nebulosa.api.guiding.GuidePulseRequest
-import nebulosa.api.guiding.GuidePulseTask
-import nebulosa.api.message.MessageEvent
-import nebulosa.api.tasks.AbstractTask
-import nebulosa.api.tasks.SplitTask
-import nebulosa.api.tasks.Task
-import nebulosa.api.tasks.delay.DelayEvent
-import nebulosa.api.tasks.delay.DelayTask
-import nebulosa.common.concurrency.cancel.CancellationToken
-import nebulosa.guiding.GuideDirection
-import nebulosa.indi.device.camera.Camera
-import nebulosa.indi.device.camera.CameraEvent
-import nebulosa.indi.device.camera.FrameType
-import nebulosa.indi.device.guider.GuideOutput
-import nebulosa.indi.device.mount.Mount
-import nebulosa.log.loggerFor
-import java.nio.file.Files
-import java.time.Duration
-import java.util.concurrent.Executor
-
-data class DARVTask(
-    @JvmField val camera: Camera,
-    @JvmField val guideOutput: GuideOutput,
-    @JvmField val request: DARVStartRequest,
-    private val executor: Executor,
-) : AbstractTask<MessageEvent>(), Consumer<Any>, CameraEventAware {
-
-    @JvmField val cameraRequest = request.capture.copy(
-        exposureTime = request.capture.exposureTime + request.capture.exposureDelay,
-        savePath = CAPTURE_SAVE_PATH,
-        exposureAmount = 1, exposureDelay = Duration.ZERO,
-        frameType = FrameType.LIGHT, autoSave = false, autoSubFolderMode = AutoSubFolderMode.OFF
-    )
-
-    private val cameraCaptureTask = CameraCaptureTask(camera, cameraRequest)
-    private val delayTask = DelayTask(request.capture.exposureDelay)
-    private val forwardGuidePulseTask: GuidePulseTask
-    private val backwardGuidePulseTask: GuidePulseTask
-
-    @Volatile private var state = DARVState.IDLE
-    @Volatile private var direction: GuideDirection? = null
-
-    init {
-        val direction = if (request.reversed) request.direction.reversed else request.direction
-        val guidePulseDuration = request.capture.exposureTime.dividedBy(2L)
-
-        forwardGuidePulseTask = GuidePulseTask(guideOutput, GuidePulseRequest(direction, guidePulseDuration))
-        backwardGuidePulseTask = GuidePulseTask(guideOutput, GuidePulseRequest(direction.reversed, guidePulseDuration))
-
-        cameraCaptureTask.subscribe(this)
-        delayTask.subscribe(this)
-        forwardGuidePulseTask.subscribe(this)
-        backwardGuidePulseTask.subscribe(this)
-    }
-
-    override fun handleCameraEvent(event: CameraEvent) {
-        cameraCaptureTask.handleCameraEvent(event)
-    }
-
-    override fun execute(cancellationToken: CancellationToken) {
-        LOG.info("DARV started. camera={}, guideOutput={}, request={}", camera, guideOutput, request)
-
-        if (guideOutput is Mount) camera.snoop(camera.snoopedDevices.filter { it !is Mount } + guideOutput)
-
-        val task = SplitTask(listOf(cameraCaptureTask, Task.of(delayTask, forwardGuidePulseTask, backwardGuidePulseTask)), executor)
-        task.execute(cancellationToken)
-
-        state = DARVState.IDLE
-        sendEvent()
-
-        LOG.info("DARV finished. camera={}, guideOutput={}, request={}", camera, guideOutput, request)
-    }
-
-    override fun canUseAsLastEvent(event: MessageEvent) = event is DARVEvent
-
-    override fun accept(event: Any) {
-        when (event) {
-            is DelayEvent -> {
-                state = DARVState.INITIAL_PAUSE
-            }
-            is CameraCaptureEvent -> {
-                if (event.state == CameraCaptureState.EXPOSURE_FINISHED) {
-                    onNext(event)
-                }
-
-                sendEvent(event)
-            }
-            is GuidePulseEvent -> {
-                direction = event.task.request.direction
-                state = if (direction == forwardGuidePulseTask.request.direction) DARVState.FORWARD else DARVState.BACKWARD
-            }
-            else -> return LOG.warn("unknown event: {}", event)
-        }
-    }
-
-    @Suppress("NOTHING_TO_INLINE")
-    private inline fun sendEvent(capture: CameraCaptureEvent? = null) {
-        onNext(DARVEvent(camera, state, direction, capture))
-    }
-
-    override fun reset() {
-        state = DARVState.IDLE
-        direction = null
-
-        cameraCaptureTask.reset()
-        delayTask.reset()
-        forwardGuidePulseTask.reset()
-        backwardGuidePulseTask.reset()
-    }
-
-    override fun close() {
-        cameraCaptureTask.close()
-        delayTask.close()
-        forwardGuidePulseTask.close()
-        backwardGuidePulseTask.close()
-        super.close()
-    }
-
-    companion object {
-
-        @JvmStatic private val LOG = loggerFor<DARVTask>()
-        @JvmStatic private val CAPTURE_SAVE_PATH = Files.createTempDirectory("darv-")
-    }
-}
diff --git a/api/src/main/kotlin/nebulosa/api/alignment/polar/tppa/TPPAEvent.kt b/api/src/main/kotlin/nebulosa/api/alignment/polar/tppa/TPPAEvent.kt
index 67b3d7f51..323a28a7d 100644
--- a/api/src/main/kotlin/nebulosa/api/alignment/polar/tppa/TPPAEvent.kt
+++ b/api/src/main/kotlin/nebulosa/api/alignment/polar/tppa/TPPAEvent.kt
@@ -1,5 +1,6 @@
 package nebulosa.api.alignment.polar.tppa
 
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
 import com.fasterxml.jackson.databind.annotation.JsonSerialize
 import nebulosa.api.beans.converters.angle.DeclinationSerializer
 import nebulosa.api.beans.converters.angle.RightAscensionSerializer
@@ -10,15 +11,15 @@ import nebulosa.math.Angle
 
 data class TPPAEvent(
     @JvmField val camera: Camera,
-    @JvmField val state: TPPAState = TPPAState.IDLE,
-    @JvmField @field:JsonSerialize(using = RightAscensionSerializer::class) val rightAscension: Angle = 0.0,
-    @JvmField @field:JsonSerialize(using = DeclinationSerializer::class) val declination: Angle = 0.0,
-    @JvmField @field:JsonSerialize(using = DeclinationSerializer::class) val azimuthError: Angle = 0.0,
-    @JvmField @field:JsonSerialize(using = DeclinationSerializer::class) val altitudeError: Angle = 0.0,
-    @JvmField @JsonSerialize(using = DeclinationSerializer::class) val totalError: Angle = 0.0,
-    @JvmField val azimuthErrorDirection: String = "",
-    @JvmField val altitudeErrorDirection: String = "",
-    @JvmField val capture: CameraCaptureEvent? = null,
+    @JvmField var state: TPPAState = TPPAState.IDLE,
+    @JvmField @field:JsonSerialize(using = RightAscensionSerializer::class) var rightAscension: Angle = 0.0,
+    @JvmField @field:JsonSerialize(using = DeclinationSerializer::class) var declination: Angle = 0.0,
+    @JvmField @field:JsonSerialize(using = DeclinationSerializer::class) var azimuthError: Angle = 0.0,
+    @JvmField @field:JsonSerialize(using = DeclinationSerializer::class) var altitudeError: Angle = 0.0,
+    @JvmField @field:JsonSerialize(using = DeclinationSerializer::class) var totalError: Angle = 0.0,
+    @JvmField var azimuthErrorDirection: String = "",
+    @JvmField var altitudeErrorDirection: String = "",
+    @JvmField @field:JsonIgnoreProperties("camera") val capture: CameraCaptureEvent = CameraCaptureEvent(camera),
 ) : MessageEvent {
 
     override val eventName = "TPPA.ELAPSED"
diff --git a/api/src/main/kotlin/nebulosa/api/alignment/polar/tppa/TPPAExecutor.kt b/api/src/main/kotlin/nebulosa/api/alignment/polar/tppa/TPPAExecutor.kt
index 1b7d947f6..9c35b8038 100644
--- a/api/src/main/kotlin/nebulosa/api/alignment/polar/tppa/TPPAExecutor.kt
+++ b/api/src/main/kotlin/nebulosa/api/alignment/polar/tppa/TPPAExecutor.kt
@@ -1,68 +1,75 @@
 package nebulosa.api.alignment.polar.tppa
 
-import io.reactivex.rxjava3.functions.Consumer
-import nebulosa.api.beans.annotations.Subscriber
 import nebulosa.api.cameras.CameraEventAware
 import nebulosa.api.message.MessageEvent
 import nebulosa.api.message.MessageService
+import nebulosa.api.mounts.MountEventAware
 import nebulosa.indi.device.camera.Camera
 import nebulosa.indi.device.camera.CameraEvent
 import nebulosa.indi.device.mount.Mount
-import okhttp3.OkHttpClient
+import nebulosa.indi.device.mount.MountEvent
+import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode
-import org.springframework.stereotype.Component
 import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.ExecutorService
+import java.util.function.Consumer
 
-@Component
-@Subscriber
 class TPPAExecutor(
     private val messageService: MessageService,
-    private val httpClient: OkHttpClient,
-) : Consumer<MessageEvent>, CameraEventAware {
+    private val executorService: ExecutorService,
+    eventBus: EventBus,
+) : Consumer<MessageEvent>, CameraEventAware, MountEventAware {
 
     private val jobs = ConcurrentHashMap.newKeySet<TPPAJob>(1)
 
+    init {
+        eventBus.register(this)
+    }
+
     override fun accept(event: MessageEvent) {
         messageService.sendMessage(event)
     }
 
     @Subscribe(threadMode = ThreadMode.ASYNC)
     override fun handleCameraEvent(event: CameraEvent) {
-        jobs.find { it.task.camera === event.device }?.handleCameraEvent(event)
+        jobs.find { it.camera === event.device }?.handleCameraEvent(event)
+    }
+
+    @Subscribe(threadMode = ThreadMode.ASYNC)
+    override fun handleMountEvent(event: MountEvent) {
+        jobs.find { it.mount === event.device }?.handleMountEvent(event)
     }
 
     @Synchronized
     fun execute(camera: Camera, mount: Mount, request: TPPAStartRequest) {
         check(camera.connected) { "${camera.name} Camera is not connected" }
         check(mount.connected) { "${mount.name} Mount is not connected" }
-        check(jobs.none { it.task.camera === camera }) { "${camera.name} TPPA Job is already in progress" }
-        check(jobs.none { it.task.mount === mount }) { "${camera.name} TPPA Job is already in progress" }
+        check(jobs.none { it.camera === camera }) { "${camera.name} TPPA Job is already in progress" }
+        check(jobs.none { it.mount === mount }) { "${camera.name} TPPA Job is already in progress" }
 
-        val solver = request.plateSolver.get(httpClient)
-        val task = TPPATask(camera, solver, request, mount)
-        task.subscribe(this)
+        val solver = request.plateSolver.get()
 
-        with(TPPAJob(task)) {
+        with(TPPAJob(this, camera, solver, request, mount)) {
+            val completable = runAsync(executorService)
             jobs.add(this)
-            whenComplete { _, _ -> jobs.remove(this) }
-            start()
+            completable.whenComplete { _, _ -> jobs.remove(this) }
         }
     }
 
     fun stop(camera: Camera) {
-        jobs.find { it.task.camera === camera }?.stop()
+        jobs.find { it.camera === camera }?.stop()
     }
 
     fun pause(camera: Camera) {
-        jobs.find { it.task.camera === camera }?.pause()
+        jobs.find { it.camera === camera }?.pause()
     }
 
     fun unpause(camera: Camera) {
-        jobs.find { it.task.camera === camera }?.unpause()
+        jobs.find { it.camera === camera }?.unpause()
     }
 
     fun status(camera: Camera): TPPAEvent? {
-        return jobs.find { it.task.camera === camera }?.task?.get() as? TPPAEvent
+        return jobs.find { it.camera === camera }?.status
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/alignment/polar/tppa/TPPAJob.kt b/api/src/main/kotlin/nebulosa/api/alignment/polar/tppa/TPPAJob.kt
index e71b4e21b..a5c117bd3 100644
--- a/api/src/main/kotlin/nebulosa/api/alignment/polar/tppa/TPPAJob.kt
+++ b/api/src/main/kotlin/nebulosa/api/alignment/polar/tppa/TPPAJob.kt
@@ -1,14 +1,255 @@
 package nebulosa.api.alignment.polar.tppa
 
-import nebulosa.api.cameras.CameraEventAware
-import nebulosa.api.tasks.Job
+import nebulosa.alignment.polar.point.three.ThreePointPolarAlignment
+import nebulosa.alignment.polar.point.three.ThreePointPolarAlignmentResult
+import nebulosa.api.cameras.*
+import nebulosa.api.message.MessageEvent
+import nebulosa.api.mounts.MountEventAware
+import nebulosa.api.mounts.MountMoveRequest
+import nebulosa.api.mounts.MountMoveTask
+import nebulosa.api.mounts.MountTrackTask
+import nebulosa.indi.device.camera.Camera
 import nebulosa.indi.device.camera.CameraEvent
+import nebulosa.indi.device.camera.FrameType
+import nebulosa.indi.device.mount.Mount
+import nebulosa.indi.device.mount.MountEvent
+import nebulosa.job.manager.AbstractJob
+import nebulosa.job.manager.Task
+import nebulosa.job.manager.delay.DelayEvent
+import nebulosa.job.manager.delay.DelayStarted
+import nebulosa.job.manager.delay.DelayTask
+import nebulosa.log.loggerFor
+import nebulosa.math.Angle
+import nebulosa.math.formatSignedDMS
+import nebulosa.platesolver.PlateSolver
+import nebulosa.util.time.Stopwatch
+import java.nio.file.Files
+import java.time.Duration
+import kotlin.math.hypot
 
-data class TPPAJob(override val task: TPPATask) : Job(), CameraEventAware {
+data class TPPAJob(
+    @JvmField val tppaExecutor: TPPAExecutor,
+    @JvmField val camera: Camera,
+    @JvmField val solver: PlateSolver,
+    @JvmField val request: TPPAStartRequest,
+    @JvmField val mount: Mount,
+    @JvmField val longitude: Angle = mount.longitude,
+    @JvmField val latitude: Angle = mount.latitude,
+) : AbstractJob(), CameraEventAware, MountEventAware {
 
-    override val name = "${task.camera.name} TPPA Job"
+    @JvmField val mountMoveRequest = MountMoveRequest(request.stepDirection, request.stepDuration, request.stepSpeed)
+
+    @JvmField val cameraRequest = request.capture.copy(
+        savePath = CAPTURE_SAVE_PATH,
+        exposureAmount = 0, exposureDelay = Duration.ZERO,
+        exposureTime = maxOf(request.capture.exposureTime, MIN_EXPOSURE_TIME),
+        frameType = FrameType.LIGHT, autoSave = false, autoSubFolderMode = AutoSubFolderMode.OFF
+    )
+
+    @JvmField val status = TPPAEvent(camera)
+
+    @Volatile @JvmField internal var noSolutionAttempts = 0
+
+    private val alignment = ThreePointPolarAlignment(solver, longitude, latitude)
+    private val cameraExposureTask = CameraExposureTask(this, camera, cameraRequest)
+    private val settleDelayTask = DelayTask(this, SETTLE_TIME)
+    private val tppaTask = TPPATask(this, alignment)
+    private val mountTrackTask = MountTrackTask(this, mount, true)
+    private val mountMoveTask = MountMoveTask(this, mount, mountMoveRequest)
+    private val mountMoveState = BooleanArray(3)
+    private val stopwatch = Stopwatch()
+
+    inline val savedPath
+        get() = status.capture.savedPath
+
+    init {
+        add(mountTrackTask)
+        add(mountMoveTask)
+        add(settleDelayTask)
+        add(cameraExposureTask)
+        add(tppaTask)
+    }
 
     override fun handleCameraEvent(event: CameraEvent) {
-        task.handleCameraEvent(event)
+        cameraExposureTask.handleCameraEvent(event)
+    }
+
+    override fun handleMountEvent(event: MountEvent) {
+        mountTrackTask.handleMountEvent(event)
+    }
+
+    override fun isLoop(): Boolean {
+        return true
+    }
+
+    override fun canRun(prev: Task?, current: Task): Boolean {
+        if (current === settleDelayTask) {
+            return prev === mountMoveTask
+        } else if (current === mountMoveTask) {
+            return alignment.state.ordinal in 1..2 && !mountMoveState[alignment.state.ordinal]
+        }
+
+        return super.canRun(prev, current)
+    }
+
+    override fun beforeTask(task: Task) {
+        if (task === mountMoveTask) {
+            status.state = TPPAState.SLEWING
+            status.send()
+        } else if (task === cameraExposureTask) {
+            status.capture.savedPath = null
+            status.state = TPPAState.EXPOSURING
+            status.send()
+        } else if (task === tppaTask) {
+            status.state = TPPAState.SOLVING
+            status.send()
+        }
+    }
+
+    override fun afterTask(task: Task, exception: Throwable?): Boolean {
+        if (exception == null) {
+            if (task === mountMoveTask) {
+                status.rightAscension = task.mount.rightAscension
+                status.declination = task.mount.declination
+                status.state = TPPAState.SLEWED
+                status.send()
+            } else if (task === cameraExposureTask) {
+                return status.capture.savedPath != null
+            }
+        }
+
+        return super.afterTask(task, exception)
+    }
+
+    override fun onPause(paused: Boolean) {
+        if (paused) {
+            status.state = TPPAState.PAUSING
+            status.send()
+        }
+
+        super.onPause(paused)
+    }
+
+    override fun beforePause(task: Task) {
+        status.state = TPPAState.PAUSED
+        status.send()
+    }
+
+    override fun accept(event: Any) {
+        when (event) {
+            is CameraExposureEvent -> {
+                if (event is CameraExposureStarted) {
+                    status.capture.captureElapsedTime = stopwatch.elapsedMicroseconds
+                }
+
+                status.capture.handleCameraExposureEvent(event)
+
+                if (event is CameraExposureFinished) {
+                    status.capture.send()
+                }
+
+                status.send()
+            }
+            is DelayEvent -> {
+                if (event is DelayStarted) {
+                    status.capture.captureElapsedTime = stopwatch.elapsedMicroseconds
+                }
+
+                status.capture.handleCameraDelayEvent(event)
+
+                if (event.task === settleDelayTask) {
+                    status.state = TPPAState.SETTLING
+                } else if (event.task === mountMoveTask.delayTask) {
+                    status.state = TPPAState.SLEWING
+                }
+
+                status.send()
+            }
+            is ThreePointPolarAlignmentResult.NeedMoreMeasurement -> {
+                noSolutionAttempts = 0
+                status.rightAscension = event.rightAscension
+                status.declination = event.declination
+                status.state = TPPAState.SOLVED
+                status.send()
+            }
+            is ThreePointPolarAlignmentResult.NoPlateSolution -> {
+                noSolutionAttempts++
+                status.state = TPPAState.FAILED
+
+                status.send()
+
+                if (noSolutionAttempts >= MAX_ATTEMPTS) {
+                    LOG.error("exhausted all attempts to plate solve")
+                    stop()
+                }
+            }
+            is ThreePointPolarAlignmentResult.Measured -> {
+                noSolutionAttempts = 0
+
+                status.rightAscension = event.rightAscension
+                status.declination = event.declination
+                status.azimuthError = event.azimuth
+                status.altitudeError = event.altitude
+                status.totalError = hypot(status.azimuthError, status.altitudeError)
+
+                status.azimuthErrorDirection = when {
+                    status.azimuthError > 0 -> if (latitude > 0) "🠔 Move LEFT/WEST" else "🠔 Move LEFT/EAST"
+                    status.azimuthError < 0 -> if (latitude > 0) "Move RIGHT/EAST 🠖" else "Move RIGHT/WEST 🠖"
+                    else -> ""
+                }
+
+                status.altitudeErrorDirection = when {
+                    status.altitudeError > 0 -> if (latitude > 0) "🠗 Move DOWN" else "Move UP 🠕"
+                    status.altitudeError < 0 -> if (latitude > 0) "Move UP 🠕" else "🠗 Move DOWN"
+                    else -> ""
+                }
+
+                LOG.debug(
+                    "TPPA aligned. azimuthError={}, altitudeError={}",
+                    status.azimuthError.formatSignedDMS(), status.altitudeError.formatSignedDMS()
+                )
+
+                status.state = TPPAState.COMPUTED
+                status.send()
+            }
+        }
+    }
+
+    override fun beforeStart() {
+        LOG.debug("TPPA started. longitude={}, latitude={}, camera={}, mount={}, request={}", longitude, latitude, camera, mount, request)
+
+        status.rightAscension = mount.rightAscension
+        status.declination = mount.declination
+
+        stopwatch.start()
+    }
+
+    override fun afterFinish() {
+        LOG.debug("TPPA finished. camera={}, mount={}, request={}", camera, mount, request)
+
+        stopwatch.stop()
+
+        if (request.stopTrackingWhenDone) {
+            mount.tracking(false)
+        }
+
+        status.capture.handleCameraCaptureFinished()
+        status.state = TPPAState.FINISHED
+        status.send()
+    }
+
+    @Suppress("NOTHING_TO_INLINE")
+    private inline fun MessageEvent.send() {
+        tppaExecutor.accept(this)
+    }
+
+    companion object {
+
+        const val MAX_ATTEMPTS = 30
+
+        @JvmStatic private val MIN_EXPOSURE_TIME = Duration.ofSeconds(1L)
+        @JvmStatic private val SETTLE_TIME = Duration.ofSeconds(5)
+        @JvmStatic private val CAPTURE_SAVE_PATH = Files.createTempDirectory("tppa-")
+        @JvmStatic private val LOG = loggerFor<TPPAJob>()
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/alignment/polar/tppa/TPPAStartRequest.kt b/api/src/main/kotlin/nebulosa/api/alignment/polar/tppa/TPPAStartRequest.kt
index 0377eb526..30041fc37 100644
--- a/api/src/main/kotlin/nebulosa/api/alignment/polar/tppa/TPPAStartRequest.kt
+++ b/api/src/main/kotlin/nebulosa/api/alignment/polar/tppa/TPPAStartRequest.kt
@@ -1,23 +1,29 @@
 package nebulosa.api.alignment.polar.tppa
 
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties
-import jakarta.validation.Valid
-import jakarta.validation.constraints.NotNull
+import nebulosa.api.beans.converters.time.DurationUnit
 import nebulosa.api.cameras.CameraStartCaptureRequest
+import nebulosa.api.javalin.Validatable
+import nebulosa.api.javalin.min
 import nebulosa.api.platesolver.PlateSolverRequest
 import nebulosa.guiding.GuideDirection
-import org.hibernate.validator.constraints.time.DurationMin
-import org.springframework.boot.convert.DurationUnit
 import java.time.Duration
 import java.time.temporal.ChronoUnit
+import java.util.concurrent.TimeUnit
 
 data class TPPAStartRequest(
     @JsonIgnoreProperties("camera", "focuser", "wheel") @JvmField val capture: CameraStartCaptureRequest = CameraStartCaptureRequest.EMPTY,
-    @field:NotNull @Valid @JvmField val plateSolver: PlateSolverRequest = PlateSolverRequest.EMPTY,
+    @JvmField val plateSolver: PlateSolverRequest = PlateSolverRequest.EMPTY,
     @JvmField val startFromCurrentPosition: Boolean = true,
     @JvmField val compensateRefraction: Boolean = false,
     @JvmField val stopTrackingWhenDone: Boolean = true,
-    @field:DurationMin(seconds = 1L) @JvmField val stepDirection: GuideDirection = GuideDirection.EAST,
-    @field:DurationUnit(ChronoUnit.SECONDS) @field:DurationMin(seconds = 1L) @JvmField val stepDuration: Duration = Duration.ZERO,
+    @JvmField val stepDirection: GuideDirection = GuideDirection.EAST,
+    @field:DurationUnit(ChronoUnit.SECONDS) @JvmField val stepDuration: Duration = Duration.ZERO,
     @JvmField val stepSpeed: String? = null,
-)
+) : Validatable {
+
+    override fun validate() {
+        plateSolver.validate()
+        stepDuration.min(1L, TimeUnit.SECONDS)
+    }
+}
diff --git a/api/src/main/kotlin/nebulosa/api/alignment/polar/tppa/TPPATask.kt b/api/src/main/kotlin/nebulosa/api/alignment/polar/tppa/TPPATask.kt
index bd0180fe0..a10fa3aed 100644
--- a/api/src/main/kotlin/nebulosa/api/alignment/polar/tppa/TPPATask.kt
+++ b/api/src/main/kotlin/nebulosa/api/alignment/polar/tppa/TPPATask.kt
@@ -1,321 +1,29 @@
 package nebulosa.api.alignment.polar.tppa
 
-import io.reactivex.rxjava3.functions.Consumer
 import nebulosa.alignment.polar.point.three.ThreePointPolarAlignment
-import nebulosa.alignment.polar.point.three.ThreePointPolarAlignmentResult
-import nebulosa.api.cameras.*
-import nebulosa.api.message.MessageEvent
-import nebulosa.api.mounts.MountMoveRequest
-import nebulosa.api.mounts.MountMoveTask
-import nebulosa.api.tasks.AbstractTask
-import nebulosa.api.tasks.delay.DelayEvent
-import nebulosa.api.tasks.delay.DelayTask
-import nebulosa.common.concurrency.cancel.CancellationToken
-import nebulosa.common.concurrency.latch.PauseListener
-import nebulosa.common.time.Stopwatch
-import nebulosa.indi.device.camera.Camera
-import nebulosa.indi.device.camera.CameraEvent
-import nebulosa.indi.device.camera.FrameType
-import nebulosa.indi.device.mount.Mount
-import nebulosa.log.loggerFor
-import nebulosa.math.Angle
-import nebulosa.math.formatHMS
-import nebulosa.math.formatSignedDMS
-import nebulosa.platesolver.PlateSolver
-import java.nio.file.Files
-import java.nio.file.Path
-import java.time.Duration
-import java.util.concurrent.atomic.AtomicBoolean
-import kotlin.math.hypot
+import nebulosa.job.manager.Task
 
 data class TPPATask(
-    @JvmField val camera: Camera,
-    @JvmField val solver: PlateSolver,
-    @JvmField val request: TPPAStartRequest,
-    @JvmField val mount: Mount? = null,
-    @JvmField val longitude: Angle = mount!!.longitude,
-    @JvmField val latitude: Angle = mount!!.latitude,
-) : AbstractTask<MessageEvent>(), Consumer<Any>, PauseListener, CameraEventAware {
+    @JvmField val job: TPPAJob,
+    @JvmField val alignment: ThreePointPolarAlignment,
+) : Task {
 
-    @JvmField val mountMoveRequest = MountMoveRequest(request.stepDirection, request.stepDuration, request.stepSpeed)
+    private val mount = job.mount
+    private val request = job.request
 
-    @JvmField val cameraRequest = request.capture.copy(
-        savePath = CAPTURE_SAVE_PATH,
-        exposureAmount = 0, exposureDelay = Duration.ZERO,
-        exposureTime = maxOf(request.capture.exposureTime, MIN_EXPOSURE_TIME),
-        frameType = FrameType.LIGHT, autoSave = false, autoSubFolderMode = AutoSubFolderMode.OFF
-    )
+    override fun run() {
+        val radius = ATTEMPT_RADIUS * (job.noSolutionAttempts + 1)
 
-    private val alignment = ThreePointPolarAlignment(solver, longitude, latitude)
-    private val cameraCaptureTask = CameraCaptureTask(camera, cameraRequest, mount = mount)
-    private val settleDelayTask = DelayTask(SETTLE_TIME)
-    private val mountMoveState = BooleanArray(3)
-    private val elapsedTime = Stopwatch()
-    private val pausing = AtomicBoolean()
-    private val finished = AtomicBoolean()
-
-    @Volatile private var rightAscension: Angle = 0.0
-    @Volatile private var declination: Angle = 0.0
-    @Volatile private var azimuthError: Angle = 0.0
-    @Volatile private var altitudeError: Angle = 0.0
-    @Volatile private var totalError: Angle = 0.0
-    @Volatile private var azimuthErrorDirection = ""
-    @Volatile private var altitudeErrorDirection = ""
-    @Volatile private var savedImage: Path? = null
-    @Volatile private var noSolutionAttempts = 0
-    @Volatile private var captureEvent: CameraCaptureEvent? = null
-
-    init {
-        cameraCaptureTask.subscribe(this)
-        settleDelayTask.subscribe(this)
-    }
-
-    override fun handleCameraEvent(event: CameraEvent) {
-        if (camera === event.device) {
-            cameraCaptureTask.handleCameraEvent(event)
-        }
-    }
-
-    override fun canUseAsLastEvent(event: MessageEvent) = event is TPPAEvent
-
-    override fun accept(event: Any) {
-        when (event) {
-            is CameraCaptureEvent -> {
-                captureEvent = event
-
-                if (event.state == CameraCaptureState.EXPOSURE_FINISHED) {
-                    savedImage = event.savedPath!!
-                }
-
-                if (!finished.get()) {
-                    sendEvent(TPPAState.EXPOSURING, event)
-                }
-            }
-            is DelayEvent -> {
-                sendEvent(TPPAState.SETTLING)
-            }
-        }
-    }
-
-    override fun execute(cancellationToken: CancellationToken) {
-        LOG.info(
-            "TPPA started. longitude={}, latitude={}, rightAscension={}, declination={}, camera={}, mount={}, request={}",
-            longitude.formatSignedDMS(), latitude.formatSignedDMS(), mount?.rightAscension?.formatHMS(), mount?.declination?.formatSignedDMS(),
-            camera, mount, request
-        )
-
-        finished.set(false)
-        elapsedTime.start()
-
-        rightAscension = mount?.rightAscension ?: 0.0
-        declination = mount?.declination ?: 0.0
-
-        cancellationToken.listenToPause(this)
-
-        cameraCaptureTask.initialize(cancellationToken)
-
-        while (!cancellationToken.isCancelled) {
-            if (cancellationToken.isPaused) {
-                pausing.set(false)
-                sendEvent(TPPAState.PAUSED)
-                cancellationToken.waitForPause()
-            }
-
-            if (cancellationToken.isCancelled) break
-
-            mount?.tracking(true)
-
-            // SLEWING.
-            if (mount != null) {
-                if (alignment.state.ordinal in 1..2 && !mountMoveState[alignment.state.ordinal]) {
-                    MountMoveTask(mount, mountMoveRequest).use {
-                        sendEvent(TPPAState.SLEWING)
-                        it.execute(cancellationToken)
-                        mountMoveState[alignment.state.ordinal] = true
-                    }
-
-                    if (cancellationToken.isCancelled) break
-
-                    rightAscension = mount.rightAscension
-                    declination = mount.declination
-                    sendEvent(TPPAState.SLEWED)
-
-                    LOG.info("TPPA slewed. rightAscension={}, declination={}", mount.rightAscension.formatHMS(), mount.declination.formatSignedDMS())
-
-                    settleDelayTask.execute(cancellationToken)
-                }
-            }
-
-            if (cancellationToken.isCancelled) break
-
-            sendEvent(TPPAState.EXPOSURING)
-
-            // CAPTURE.
-            cameraCaptureTask.executeOnce(cancellationToken)
-
-            if (cancellationToken.isCancelled || savedImage == null) {
-                break
-            }
-
-            sendEvent(TPPAState.SOLVING)
-
-            // ALIGNMENT.
-            val radius = if (mount == null) 0.0 else ATTEMPT_RADIUS * (noSolutionAttempts + 1)
-
-            val result = try {
-                alignment.align(
-                    savedImage!!, mount?.rightAscension ?: 0.0, mount?.declination ?: 0.0, radius,
-                    request.compensateRefraction, cancellationToken
-                )
-            } catch (e: Throwable) {
-                sendEvent(TPPAState.FAILED)
-                LOG.error("failed to align", e)
-                break
-            }
-
-            savedImage = null
-
-            LOG.info("TPPA alignment completed. result=$result")
-
-            if (cancellationToken.isCancelled) break
-
-            when (result) {
-                is ThreePointPolarAlignmentResult.NeedMoreMeasurement -> {
-                    noSolutionAttempts = 0
-                    rightAscension = result.rightAscension
-                    declination = result.declination
-                    sendEvent(TPPAState.SOLVED)
-                    continue
-                }
-                is ThreePointPolarAlignmentResult.NoPlateSolution -> {
-                    noSolutionAttempts++
-
-                    sendEvent(TPPAState.FAILED)
-
-                    if (noSolutionAttempts < MAX_ATTEMPTS) {
-                        continue
-                    } else {
-                        LOG.error("exhausted all attempts to plate solve")
-                        break
-                    }
-                }
-                is ThreePointPolarAlignmentResult.Measured -> {
-                    noSolutionAttempts = 0
-
-                    rightAscension = result.rightAscension
-                    declination = result.declination
-                    azimuthError = result.azimuth
-                    altitudeError = result.altitude
-                    totalError = hypot(azimuthError, altitudeError)
-
-                    azimuthErrorDirection = when {
-                        azimuthError > 0 -> if (latitude > 0) "🠔 Move LEFT/WEST" else "🠔 Move LEFT/EAST"
-                        azimuthError < 0 -> if (latitude > 0) "Move RIGHT/EAST 🠖" else "Move RIGHT/WEST 🠖"
-                        else -> ""
-                    }
-
-                    altitudeErrorDirection = when {
-                        altitudeError > 0 -> if (latitude > 0) "🠗 Move DOWN" else "Move UP 🠕"
-                        altitudeError < 0 -> if (latitude > 0) "Move UP 🠕" else "🠗 Move DOWN"
-                        else -> ""
-                    }
-
-                    LOG.info(
-                        "TPPA alignment computed. rightAscension={}, declination={}, azimuthError={}, altitudeError={}",
-                        result.rightAscension.formatHMS(), result.declination.formatSignedDMS(),
-                        azimuthError.formatSignedDMS(), altitudeError.formatSignedDMS(),
-                    )
-
-                    sendEvent(TPPAState.COMPUTED)
-
-                    continue
-                }
-                is ThreePointPolarAlignmentResult.Cancelled -> {
-                    break
-                }
-            }
-        }
-
-        cameraCaptureTask.finalize(cancellationToken)
-
-        pausing.set(false)
-        cancellationToken.unlistenToPause(this)
-
-        finished.set(true)
-        elapsedTime.stop()
-
-        if (request.stopTrackingWhenDone) {
-            mount?.tracking(false)
-        }
-
-        sendEvent(TPPAState.FINISHED)
-
-        LOG.info("TPPA finished. camera={}, mount={}, request={}", camera, mount, request)
-    }
-
-    @Suppress("NOTHING_TO_INLINE")
-    private inline fun processCameraCaptureEvent(event: CameraCaptureEvent?): CameraCaptureEvent? {
-        return event?.copy(captureElapsedTime = elapsedTime.elapsed)
-    }
-
-    private fun sendEvent(state: TPPAState, capture: CameraCaptureEvent? = captureEvent) {
-        val event = TPPAEvent(
-            camera, if (pausing.get()) TPPAState.PAUSING else state, rightAscension, declination,
-            azimuthError, altitudeError, totalError,
-            azimuthErrorDirection, altitudeErrorDirection,
-            processCameraCaptureEvent(capture),
+        val result = alignment.align(
+            job.savedPath!!, mount.rightAscension, mount.declination, radius,
+            request.compensateRefraction // TODO: CANCELLATION TOKEN?
         )
 
-        onNext(event)
-
-        if (capture?.state == CameraCaptureState.EXPOSURE_FINISHED) {
-            onNext(capture)
-        }
-    }
-
-    override fun reset() {
-        mountMoveState.fill(false)
-        azimuthError = 0.0
-        altitudeError = 0.0
-        totalError = 0.0
-        azimuthErrorDirection = ""
-        altitudeErrorDirection = ""
-        savedImage = null
-        noSolutionAttempts = 0
-
-        pausing.set(false)
-        finished.set(false)
-        elapsedTime.reset()
-
-        cameraCaptureTask.reset()
-        settleDelayTask.reset()
-
-        alignment.reset()
-
-        super.reset()
-    }
-
-    override fun onPause(paused: Boolean) {
-        pausing.set(paused)
-
-        if (paused) {
-            sendEvent(TPPAState.PAUSING)
-        }
-    }
-
-    override fun close() {
-        cameraCaptureTask.close()
-        super.close()
+        job.accept(result)
     }
 
     companion object {
 
-        @JvmStatic private val MIN_EXPOSURE_TIME = Duration.ofSeconds(1L)
-        @JvmStatic private val SETTLE_TIME = Duration.ofSeconds(5)
-        @JvmStatic private val CAPTURE_SAVE_PATH = Files.createTempDirectory("tppa-")
-        @JvmStatic private val LOG = loggerFor<TPPATask>()
-
-        const val MAX_ATTEMPTS = 30
-        const val ATTEMPT_RADIUS = ThreePointPolarAlignment.DEFAULT_RADIUS / 2.0
+        private const val ATTEMPT_RADIUS = ThreePointPolarAlignment.DEFAULT_RADIUS / 2.0
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/atlas/IERSUpdateTask.kt b/api/src/main/kotlin/nebulosa/api/atlas/IERSUpdateTask.kt
index 197784fc1..69a993b25 100644
--- a/api/src/main/kotlin/nebulosa/api/atlas/IERSUpdateTask.kt
+++ b/api/src/main/kotlin/nebulosa/api/atlas/IERSUpdateTask.kt
@@ -1,5 +1,6 @@
 package nebulosa.api.atlas
 
+import io.javalin.http.Header
 import nebulosa.api.preference.PreferenceService
 import nebulosa.io.transferAndClose
 import nebulosa.log.loggerFor
@@ -9,22 +10,23 @@ import nebulosa.time.IERSAB
 import nebulosa.time.IERSB
 import okhttp3.OkHttpClient
 import okhttp3.Request
-import org.springframework.http.HttpHeaders
-import org.springframework.scheduling.annotation.Scheduled
-import org.springframework.stereotype.Component
 import java.nio.file.Path
+import java.util.concurrent.ScheduledExecutorService
 import java.util.concurrent.TimeUnit
 import kotlin.io.path.inputStream
 import kotlin.io.path.outputStream
 
-@Component
 class IERSUpdateTask(
     private val dataPath: Path,
-    private val preferenceService: PreferenceService,
     private val httpClient: OkHttpClient,
+    private val preferenceService: PreferenceService,
+    scheduledExecutorService: ScheduledExecutorService,
 ) : Runnable {
 
-    @Scheduled(fixedDelay = Long.MAX_VALUE, timeUnit = TimeUnit.SECONDS)
+    init {
+        scheduledExecutorService.schedule(this, 0L, TimeUnit.SECONDS)
+    }
+
     override fun run() {
         val iersa = IERSA()
         val iersb = IERSB()
@@ -47,22 +49,22 @@ class IERSUpdateTask(
             var request = Request.Builder().head().url(url).build()
 
             var modifiedAt = httpClient.newCall(request).execute()
-                .use { it.headers.getDate(HttpHeaders.LAST_MODIFIED) }
+                .use { it.headers.getDate(Header.LAST_MODIFIED) }
 
             if (modifiedAt != null && "$modifiedAt" == preferenceService.getText(key)) {
-                LOG.info("$url is up to date. modifiedAt={}", modifiedAt)
+                LOG.info("{} is up to date. modifiedAt={}", url, modifiedAt)
                 return
             }
 
             request = request.newBuilder().get().build()
 
-            LOG.info("downloading $url")
+            LOG.debug("downloading {}", url)
 
             httpClient.newCall(request).execute().use {
                 it.body!!.byteStream().transferAndClose(outputStream())
-                modifiedAt = it.headers.getDate(HttpHeaders.LAST_MODIFIED)
+                modifiedAt = it.headers.getDate(Header.LAST_MODIFIED)
                 preferenceService.putText(key, "$modifiedAt")
-                LOG.info("$url downloaded. modifiedAt={}", modifiedAt)
+                LOG.debug("{} downloaded. modifiedAt={}", url, modifiedAt)
             }
         } catch (e: Throwable) {
             LOG.error("failed to download finals2000A.all", e)
diff --git a/api/src/main/kotlin/nebulosa/api/atlas/LibWCSDownloadTask.kt b/api/src/main/kotlin/nebulosa/api/atlas/LibWCSDownloadTask.kt
index 2beac0599..e25ee1e3b 100644
--- a/api/src/main/kotlin/nebulosa/api/atlas/LibWCSDownloadTask.kt
+++ b/api/src/main/kotlin/nebulosa/api/atlas/LibWCSDownloadTask.kt
@@ -7,21 +7,23 @@ import nebulosa.log.loggerFor
 import nebulosa.wcs.LibWCS
 import okhttp3.OkHttpClient
 import okhttp3.Request
-import org.springframework.scheduling.annotation.Scheduled
-import org.springframework.stereotype.Component
 import java.nio.file.Path
+import java.util.concurrent.ScheduledExecutorService
 import java.util.concurrent.TimeUnit
 import kotlin.io.path.exists
 import kotlin.io.path.outputStream
 
-@Component
 class LibWCSDownloadTask(
+    private val libsPath: Path,
     private val httpClient: OkHttpClient,
     private val preferenceService: PreferenceService,
-    private val libsPath: Path,
+    scheduledExecutorService: ScheduledExecutorService,
 ) : Runnable {
 
-    @Scheduled(fixedDelay = Long.MAX_VALUE, timeUnit = TimeUnit.SECONDS)
+    init {
+        scheduledExecutorService.schedule(this, 5L, TimeUnit.SECONDS)
+    }
+
     override fun run() {
         var request = Request.Builder().get().url(VERSION_URL).build()
 
diff --git a/api/src/main/kotlin/nebulosa/api/atlas/Location.kt b/api/src/main/kotlin/nebulosa/api/atlas/Location.kt
index 8bd3b0ca3..f840efa50 100644
--- a/api/src/main/kotlin/nebulosa/api/atlas/Location.kt
+++ b/api/src/main/kotlin/nebulosa/api/atlas/Location.kt
@@ -1,5 +1,6 @@
 package nebulosa.api.atlas
 
+import com.fasterxml.jackson.annotation.JsonIgnore
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize
 import com.fasterxml.jackson.databind.annotation.JsonSerialize
 import nebulosa.api.beans.converters.angle.DegreesDeserializer
@@ -18,5 +19,6 @@ data class Location(
     @JvmField val offsetInMinutes: Int = 0,
 ) : GeographicCoordinate, TimeZonedInSeconds {
 
-    override val offsetInSeconds = offsetInMinutes * 60
+    override val offsetInSeconds
+        @JsonIgnore get() = offsetInMinutes * 60
 }
diff --git a/api/src/main/kotlin/nebulosa/api/atlas/MoonPhaseFinder.kt b/api/src/main/kotlin/nebulosa/api/atlas/MoonPhaseFinder.kt
index a1d1e7e1c..85c781920 100644
--- a/api/src/main/kotlin/nebulosa/api/atlas/MoonPhaseFinder.kt
+++ b/api/src/main/kotlin/nebulosa/api/atlas/MoonPhaseFinder.kt
@@ -9,14 +9,12 @@ import nebulosa.math.Angle
 import nebulosa.math.Distance
 import nebulosa.math.deg
 import nebulosa.nova.almanac.computeDiffAndReduceToIndices
-import org.springframework.stereotype.Component
 import java.time.LocalDate
 import java.time.LocalDateTime
 import java.time.LocalTime
 import java.time.temporal.TemporalAdjusters
 import kotlin.math.floor
 
-@Component
 class MoonPhaseFinder(private val horizonsService: HorizonsService) {
 
     fun find(
diff --git a/api/src/main/kotlin/nebulosa/api/atlas/SatelliteRepository.kt b/api/src/main/kotlin/nebulosa/api/atlas/SatelliteRepository.kt
index 43e7fbff3..26caa0270 100644
--- a/api/src/main/kotlin/nebulosa/api/atlas/SatelliteRepository.kt
+++ b/api/src/main/kotlin/nebulosa/api/atlas/SatelliteRepository.kt
@@ -3,11 +3,8 @@ package nebulosa.api.atlas
 import io.objectbox.Box
 import io.objectbox.query.QueryBuilder.StringOrder.CASE_SENSITIVE
 import nebulosa.api.repositories.BoxRepository
-import org.springframework.beans.factory.annotation.Qualifier
-import org.springframework.stereotype.Component
 
-@Component
-class SatelliteRepository(@Qualifier("satelliteBox") override val box: Box<SatelliteEntity>) : BoxRepository<SatelliteEntity>() {
+class SatelliteRepository(override val box: Box<SatelliteEntity>) : BoxRepository<SatelliteEntity>() {
 
     fun search(text: String? = null, groups: Iterable<SatelliteGroupType> = emptyList(), id: Long = 0L): List<SatelliteEntity> {
         val condition = and(
diff --git a/api/src/main/kotlin/nebulosa/api/atlas/SatelliteUpdateTask.kt b/api/src/main/kotlin/nebulosa/api/atlas/SatelliteUpdateTask.kt
index b1ca26384..91b0553b1 100644
--- a/api/src/main/kotlin/nebulosa/api/atlas/SatelliteUpdateTask.kt
+++ b/api/src/main/kotlin/nebulosa/api/atlas/SatelliteUpdateTask.kt
@@ -5,20 +5,22 @@ import nebulosa.api.preference.PreferenceService
 import nebulosa.log.loggerFor
 import okhttp3.OkHttpClient
 import okhttp3.Request
-import org.springframework.scheduling.annotation.Scheduled
-import org.springframework.stereotype.Component
 import java.util.concurrent.CompletableFuture
+import java.util.concurrent.ScheduledExecutorService
 import java.util.concurrent.TimeUnit
 
-@Component
 class SatelliteUpdateTask(
     private val httpClient: OkHttpClient,
-    private val preferenceService: PreferenceService,
     private val satelliteRepository: SatelliteRepository,
+    private val preferenceService: PreferenceService,
     private val messageService: MessageService,
+    scheduledExecutorService: ScheduledExecutorService,
 ) : Runnable {
 
-    @Scheduled(fixedDelay = UPDATE_INTERVAL, timeUnit = TimeUnit.MILLISECONDS)
+    init {
+        scheduledExecutorService.schedule(this, 10L, TimeUnit.SECONDS)
+    }
+
     override fun run() {
         checkIsOutOfDateAndUpdate()
     }
diff --git a/api/src/main/kotlin/nebulosa/api/atlas/SimbadEntityRepository.kt b/api/src/main/kotlin/nebulosa/api/atlas/SimbadEntityRepository.kt
index d3753ec69..c00beede5 100644
--- a/api/src/main/kotlin/nebulosa/api/atlas/SimbadEntityRepository.kt
+++ b/api/src/main/kotlin/nebulosa/api/atlas/SimbadEntityRepository.kt
@@ -8,11 +8,8 @@ import nebulosa.math.toDegrees
 import nebulosa.nova.astrometry.Constellation
 import nebulosa.skycatalog.SkyObject
 import nebulosa.skycatalog.SkyObjectType
-import org.springframework.beans.factory.annotation.Qualifier
-import org.springframework.stereotype.Component
 
-@Component
-class SimbadEntityRepository(@Qualifier("simbadBox") override val box: Box<SimbadEntity>) : BoxRepository<SimbadEntity>() {
+class SimbadEntityRepository(override val box: Box<SimbadEntity>) : BoxRepository<SimbadEntity>() {
 
     fun search(
         name: String? = null, constellation: Constellation? = null,
diff --git a/api/src/main/kotlin/nebulosa/api/atlas/SkyAtlasController.kt b/api/src/main/kotlin/nebulosa/api/atlas/SkyAtlasController.kt
index 2fd6608b5..321568d96 100644
--- a/api/src/main/kotlin/nebulosa/api/atlas/SkyAtlasController.kt
+++ b/api/src/main/kotlin/nebulosa/api/atlas/SkyAtlasController.kt
@@ -1,156 +1,176 @@
 package nebulosa.api.atlas
 
-import jakarta.servlet.http.HttpServletResponse
-import jakarta.validation.Valid
-import jakarta.validation.constraints.Min
-import jakarta.validation.constraints.NotBlank
-import jakarta.validation.constraints.Positive
-import nebulosa.api.beans.converters.location.LocationParam
-import nebulosa.api.beans.converters.time.DateAndTimeParam
+import io.javalin.Javalin
+import io.javalin.http.Context
+import io.javalin.http.queryParamsAsClass
+import nebulosa.api.javalin.*
 import nebulosa.math.deg
 import nebulosa.math.hours
 import nebulosa.nova.astrometry.Constellation
+import nebulosa.skycatalog.SkyObject
 import nebulosa.skycatalog.SkyObjectType
-import org.springframework.validation.annotation.Validated
-import org.springframework.web.bind.annotation.*
-import java.time.LocalDate
 import java.time.LocalDateTime
 
-@Validated
-@RestController
-@RequestMapping("sky-atlas")
 class SkyAtlasController(
+    app: Javalin,
     private val skyAtlasService: SkyAtlasService,
+    private val satelliteRepository: SatelliteRepository,
 ) {
 
-    @GetMapping("sun/image")
-    fun imageOfSun(response: HttpServletResponse) {
-        skyAtlasService.imageOfSun(response)
-    }
-
-    @GetMapping("sun/position")
-    fun positionOfSun(
-        @LocationParam location: Location,
-        @DateAndTimeParam dateTime: LocalDateTime,
-        @RequestParam(required = false, defaultValue = "false") fast: Boolean,
-    ) = skyAtlasService.positionOfSun(location, dateTime, fast)
-
-    @GetMapping("sun/altitude-points")
-    fun altitudePointsOfSun(
-        @LocationParam location: Location,
-        @DateAndTimeParam dateTime: LocalDateTime,
-        @RequestParam(required = false, defaultValue = "1") @Valid @Min(1) stepSize: Int,
-        @RequestParam(required = false, defaultValue = "false") fast: Boolean,
-    ) = skyAtlasService.altitudePointsOfSun(location, dateTime, stepSize, fast)
-
-    @GetMapping("moon/position")
-    fun positionOfMoon(
-        @LocationParam location: Location,
-        @DateAndTimeParam dateTime: LocalDateTime,
-        @RequestParam(required = false, defaultValue = "false") fast: Boolean,
-    ) = skyAtlasService.positionOfMoon(location, dateTime, fast)
-
-    @GetMapping("moon/altitude-points")
-    fun altitudePointsOfMoon(
-        @LocationParam location: Location,
-        @DateAndTimeParam dateTime: LocalDateTime,
-        @RequestParam(required = false, defaultValue = "1") @Valid @Min(1) stepSize: Int,
-        @RequestParam(required = false, defaultValue = "false") fast: Boolean,
-    ) = skyAtlasService.altitudePointsOfMoon(location, dateTime, stepSize, fast)
-
-    @GetMapping("planets/{code}/position")
-    fun positionOfPlanet(
-        @PathVariable code: String,
-        @LocationParam location: Location,
-        @DateAndTimeParam dateTime: LocalDateTime,
-        @RequestParam(required = false, defaultValue = "false") fast: Boolean,
-    ) = skyAtlasService.positionOfPlanet(location, code, dateTime, fast)
-
-    @GetMapping("planets/{code}/altitude-points")
-    fun altitudePointsOfPlanet(
-        @PathVariable code: String,
-        @LocationParam location: Location,
-        @DateAndTimeParam dateTime: LocalDateTime,
-        @RequestParam(required = false, defaultValue = "1") @Valid @Min(1) stepSize: Int,
-        @RequestParam(required = false, defaultValue = "false") fast: Boolean,
-    ) = skyAtlasService.altitudePointsOfPlanet(location, code, dateTime, stepSize, fast)
-
-    @GetMapping("minor-planets")
-    fun searchMinorPlanet(@RequestParam @Valid @NotBlank text: String) = skyAtlasService.searchMinorPlanet(text)
-
-    @GetMapping("minor-planets/close-approaches")
-    fun closeApproachesForMinorPlanets(
-        @RequestParam(required = false, defaultValue = "7") @Valid @Positive days: Long,
-        @RequestParam(required = false, defaultValue = "10") @Valid @Positive distance: Double,
-        @DateAndTimeParam(nullable = true) dateTime: LocalDate?,
-    ) = skyAtlasService.closeApproachesForMinorPlanets(days, distance, dateTime)
-
-    @GetMapping("sky-objects/{id}/position")
-    fun positionOfSkyObject(
-        @PathVariable id: Long,
-        @LocationParam location: Location,
-        @DateAndTimeParam dateTime: LocalDateTime,
-    ) = skyAtlasService.positionOfSkyObject(location, id, dateTime)
-
-    @GetMapping("sky-objects/{id}/altitude-points")
-    fun altitudePointsOfSkyObject(
-        @PathVariable id: Long,
-        @LocationParam location: Location,
-        @DateAndTimeParam dateTime: LocalDateTime,
-        @RequestParam(required = false, defaultValue = "1") @Valid @Min(1) stepSize: Int,
-    ) = skyAtlasService.altitudePointsOfSkyObject(location, id, dateTime, stepSize)
-
-    @GetMapping("sky-objects")
-    fun searchSkyObject(
-        @RequestParam(required = false, defaultValue = "") text: String,
-        @RequestParam(required = false, defaultValue = "") rightAscension: String,
-        @RequestParam(required = false, defaultValue = "") declination: String,
-        @RequestParam(required = false, defaultValue = "0.0") radius: Double,
-        @RequestParam(required = false) constellation: Constellation?,
-        @RequestParam(required = false, defaultValue = "-99.0") magnitudeMin: Double,
-        @RequestParam(required = false, defaultValue = "99.0") magnitudeMax: Double,
-        @RequestParam(required = false) type: SkyObjectType?,
-        @RequestParam(required = false, defaultValue = "0") id: Long,
-    ) = skyAtlasService.searchSkyObject(
-        text, rightAscension.hours, declination.deg, radius.deg,
-        constellation, magnitudeMin, magnitudeMax, type, id,
-    )
-
-    @GetMapping("sky-objects/types")
-    fun skyObjectTypes() = skyAtlasService.objectTypes
-
-    @GetMapping("satellites/{satellite}/position")
-    fun positionOfSatellite(
-        satellite: SatelliteEntity,
-        @LocationParam location: Location,
-        @DateAndTimeParam dateTime: LocalDateTime,
-    ) = skyAtlasService.positionOfSatellite(location, satellite, dateTime)
-
-    @GetMapping("satellites/{satellite}/altitude-points")
-    fun altitudePointsOfSatellite(
-        satellite: SatelliteEntity,
-        @LocationParam location: Location,
-        @DateAndTimeParam dateTime: LocalDateTime,
-        @RequestParam(required = false, defaultValue = "1") @Valid @Min(1) stepSize: Int,
-    ) = skyAtlasService.altitudePointsOfSatellite(location, satellite, dateTime, stepSize)
-
-    @GetMapping("satellites")
-    fun searchSatellites(
-        @RequestParam(required = false, defaultValue = "") text: String,
-        @RequestParam(name = "group", required = false) groups: List<SatelliteGroupType>?,
-        @RequestParam(required = false, defaultValue = "0") id: Long,
-    ) = skyAtlasService.searchSatellites(text, groups ?: emptyList(), id)
-
-    @GetMapping("twilight")
-    fun twilight(
-        @LocationParam location: Location,
-        @DateAndTimeParam dateTime: LocalDateTime,
-        @RequestParam(required = false, defaultValue = "false") fast: Boolean,
-    ) = skyAtlasService.twilight(location, dateTime, fast)
-
-    @GetMapping("moon/phase")
-    fun moonPhase(
-        @LocationParam location: Location,
-        @DateAndTimeParam dateTime: LocalDateTime,
-    ) = skyAtlasService.moonPhase(location, dateTime)
+    init {
+        app.get("sky-atlas/sun/image", ::imageOfSun)
+        app.get("sky-atlas/sun/position", ::positionOfSun)
+        app.get("sky-atlas/sun/altitude-points", ::altitudePointsOfSun)
+        app.get("sky-atlas/moon/position", ::positionOfMoon)
+        app.get("sky-atlas/moon/altitude-points", ::altitudePointsOfMoon)
+        app.get("sky-atlas/moon/phase", ::moonPhase)
+        app.get("sky-atlas/twilight", ::twilight)
+        app.get("sky-atlas/planets/{code}/position", ::positionOfPlanet)
+        app.get("sky-atlas/planets/{code}/altitude-points", ::altitudePointsOfPlanet)
+        app.get("sky-atlas/minor-planets", ::searchMinorPlanet)
+        app.get("sky-atlas/minor-planets/close-approaches", ::closeApproachesForMinorPlanets)
+        app.get("sky-atlas/sky-objects", ::searchSkyObject)
+        app.get("sky-atlas/sky-objects/types", ::skyObjectTypes)
+        app.get("sky-atlas/sky-objects/{id}/position", ::positionOfSkyObject)
+        app.get("sky-atlas/sky-objects/{id}/altitude-points", ::altitudePointsOfSkyObject)
+        app.get("sky-atlas/satellites/", ::searchSatellites)
+        app.get("sky-atlas/satellites/{id}/position", ::positionOfSatellite)
+        app.get("sky-atlas/satellites/{id}/altitude-points", ::altitudePointsOfSatellite)
+    }
+
+    private fun imageOfSun(ctx: Context) {
+        skyAtlasService.imageOfSun(ctx.res())
+    }
+
+    private fun positionOfSun(ctx: Context) {
+        val location = ctx.location().notNull()
+        val dateTime = LocalDateTime.of(ctx.localDate(), ctx.localTime())
+        val fast = ctx.queryParam("fast")?.toBoolean() ?: false
+        ctx.json(skyAtlasService.positionOfSun(location, dateTime, fast))
+    }
+
+    private fun altitudePointsOfSun(ctx: Context) {
+        val location = ctx.location().notNull()
+        val dateTime = LocalDateTime.of(ctx.localDate(), ctx.localTime())
+        val stepSize = ctx.queryParam("stepSize")?.toInt()?.min(1) ?: 1
+        val fast = ctx.queryParam("fast")?.toBoolean() ?: false
+        ctx.json(skyAtlasService.altitudePointsOfSun(location, dateTime, stepSize, fast))
+    }
+
+    private fun positionOfMoon(ctx: Context) {
+        val location = ctx.location().notNull()
+        val dateTime = LocalDateTime.of(ctx.localDate(), ctx.localTime())
+        val fast = ctx.queryParam("fast")?.toBoolean() ?: false
+        ctx.json(skyAtlasService.positionOfMoon(location, dateTime, fast))
+    }
+
+    private fun altitudePointsOfMoon(ctx: Context) {
+        val location = ctx.location().notNull()
+        val dateTime = LocalDateTime.of(ctx.localDate(), ctx.localTime())
+        val stepSize = ctx.queryParam("stepSize")?.toInt()?.min(1) ?: 1
+        val fast = ctx.queryParam("fast")?.toBoolean() ?: false
+        ctx.json(skyAtlasService.altitudePointsOfMoon(location, dateTime, stepSize, fast))
+    }
+
+    private fun positionOfPlanet(ctx: Context) {
+        val code = ctx.pathParam("code")
+        val location = ctx.location().notNull()
+        val dateTime = LocalDateTime.of(ctx.localDate(), ctx.localTime())
+        val fast = ctx.queryParam("fast")?.toBoolean() ?: false
+        ctx.json(skyAtlasService.positionOfPlanet(location, code, dateTime, fast))
+    }
+
+    private fun altitudePointsOfPlanet(ctx: Context) {
+        val code = ctx.pathParam("code")
+        val location = ctx.location().notNull()
+        val dateTime = LocalDateTime.of(ctx.localDate(), ctx.localTime())
+        val stepSize = ctx.queryParam("stepSize")?.toInt()?.min(1) ?: 1
+        val fast = ctx.queryParam("fast")?.toBoolean() ?: false
+        ctx.json(skyAtlasService.altitudePointsOfPlanet(location, code, dateTime, stepSize, fast))
+    }
+
+    private fun searchMinorPlanet(ctx: Context) {
+        val text = ctx.queryParam("text").notNull().notBlank()
+        ctx.json(skyAtlasService.searchMinorPlanet(text))
+    }
+
+    private fun closeApproachesForMinorPlanets(ctx: Context) {
+        val days = ctx.queryParam("days")?.toLong()?.positive() ?: 7L
+        val distance = ctx.queryParam("distance")?.toDouble()?.positive() ?: 10.0
+        val date = ctx.localDateOrNull()
+        ctx.json(skyAtlasService.closeApproachesForMinorPlanets(days, distance, date))
+    }
+
+    private fun positionOfSkyObject(ctx: Context) {
+        val id = ctx.pathParam("id").toLong().positive()
+        val location = ctx.location().notNull()
+        val dateTime = LocalDateTime.of(ctx.localDate(), ctx.localTime())
+        ctx.json(skyAtlasService.positionOfSkyObject(location, id, dateTime))
+    }
+
+    private fun altitudePointsOfSkyObject(ctx: Context) {
+        val id = ctx.pathParam("id").toLong().positive()
+        val location = ctx.location().notNull()
+        val dateTime = LocalDateTime.of(ctx.localDate(), ctx.localTime())
+        val stepSize = ctx.queryParam("stepSize")?.toInt()?.min(1) ?: 1
+        ctx.json(skyAtlasService.altitudePointsOfSkyObject(location, id, dateTime, stepSize))
+    }
+
+    private fun searchSkyObject(ctx: Context) {
+        val text = ctx.queryParam("text") ?: ""
+        val rightAscension = ctx.queryParam("rightAscension") ?: ""
+        val declination = ctx.queryParam("declination") ?: ""
+        val radius = ctx.queryParam("radius")?.toDouble() ?: 0.0
+        val constellation = ctx.queryParam("constellation")?.let(Constellation::valueOf)
+        val magnitudeMin = ctx.queryParam("magnitudeMin")?.toDouble() ?: SkyObject.MAGNITUDE_MIN
+        val magnitudeMax = ctx.queryParam("magnitudeMax")?.toDouble() ?: SkyObject.MAGNITUDE_MAX
+        val type = ctx.queryParam("type")?.let(SkyObjectType::valueOf)
+        val id = ctx.queryParam("id")?.toLong() ?: 0L
+
+        val result = skyAtlasService.searchSkyObject(
+            text, rightAscension.hours, declination.deg, radius.deg,
+            constellation, magnitudeMin, magnitudeMax, type, id,
+        )
+
+        ctx.json(result)
+    }
+
+    private fun skyObjectTypes(ctx: Context) {
+        ctx.json(skyAtlasService.objectTypes)
+    }
+
+    private fun positionOfSatellite(ctx: Context) {
+        val satellite = satelliteRepository.find(ctx.pathParam("id").toLong().positive()) ?: return
+        val location = ctx.location().notNull()
+        val dateTime = LocalDateTime.of(ctx.localDate(), ctx.localTime())
+        ctx.json(skyAtlasService.positionOfSatellite(location, satellite, dateTime))
+    }
+
+    private fun altitudePointsOfSatellite(ctx: Context) {
+        val satellite = satelliteRepository.find(ctx.pathParam("id").toLong().positive()) ?: return
+        val location = ctx.location().notNull()
+        val dateTime = LocalDateTime.of(ctx.localDate(), ctx.localTime())
+        val stepSize = ctx.queryParam("stepSize")?.toInt()?.min(1) ?: 1
+        ctx.json(skyAtlasService.altitudePointsOfSatellite(location, satellite, dateTime, stepSize))
+    }
+
+    private fun searchSatellites(ctx: Context) {
+        val text = ctx.queryParam("text") ?: ""
+        val id = ctx.queryParam("id")?.toLong() ?: 0L
+        val groups = ctx.queryParamsAsClass<String>("groups").allowNullable().get()?.map(SatelliteGroupType::valueOf)
+        ctx.json(skyAtlasService.searchSatellites(text, groups ?: emptyList(), id))
+    }
+
+    private fun twilight(ctx: Context) {
+        val location = ctx.location().notNull()
+        val dateTime = LocalDateTime.of(ctx.localDate(), ctx.localTime())
+        val fast = ctx.queryParam("fast")?.toBoolean() ?: false
+        ctx.json(skyAtlasService.twilight(location, dateTime, fast))
+    }
+
+    private fun moonPhase(ctx: Context) {
+        val location = ctx.location().notNull()
+        val dateTime = LocalDateTime.of(ctx.localDate(), ctx.localTime())
+        skyAtlasService.moonPhase(location, dateTime)?.also(ctx::json)
+    }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/atlas/SkyAtlasService.kt b/api/src/main/kotlin/nebulosa/api/atlas/SkyAtlasService.kt
index cd8ca5e5e..6ece3acce 100644
--- a/api/src/main/kotlin/nebulosa/api/atlas/SkyAtlasService.kt
+++ b/api/src/main/kotlin/nebulosa/api/atlas/SkyAtlasService.kt
@@ -1,6 +1,7 @@
 package nebulosa.api.atlas
 
 import com.fasterxml.jackson.databind.ObjectMapper
+import io.javalin.http.NotFoundResponse
 import jakarta.servlet.http.HttpServletResponse
 import nebulosa.api.atlas.ephemeris.BodyEphemerisProvider
 import nebulosa.api.atlas.ephemeris.HorizonsEphemerisProvider
@@ -26,24 +27,18 @@ import nebulosa.time.TimeYMDHMS
 import nebulosa.time.TimeZonedInSeconds
 import okhttp3.OkHttpClient
 import okhttp3.Request
-import org.springframework.http.HttpStatus
-import org.springframework.scheduling.annotation.EnableScheduling
-import org.springframework.scheduling.annotation.Scheduled
-import org.springframework.stereotype.Service
-import org.springframework.web.server.ResponseStatusException
 import java.awt.image.BufferedImage
 import java.io.ByteArrayOutputStream
 import java.time.LocalDate
 import java.time.LocalDateTime
 import java.time.format.DateTimeFormatter
 import java.time.temporal.ChronoUnit
+import java.util.concurrent.ScheduledExecutorService
 import java.util.concurrent.TimeUnit
 import javax.imageio.ImageIO
 import kotlin.math.abs
 import kotlin.math.hypot
 
-@Service
-@EnableScheduling
 class SkyAtlasService(
     private val horizonsEphemerisProvider: HorizonsEphemerisProvider,
     private val bodyEphemerisProvider: BodyEphemerisProvider,
@@ -53,6 +48,7 @@ class SkyAtlasService(
     private val httpClient: OkHttpClient,
     private val objectMapper: ObjectMapper,
     private val moonPhaseFinder: MoonPhaseFinder,
+    scheduledExecutorService: ScheduledExecutorService,
 ) {
 
     private val positions = HashMap<GeographicCoordinate, GeographicPosition>()
@@ -63,6 +59,10 @@ class SkyAtlasService(
     @Volatile private var sunImage = ByteArray(0)
     @Volatile private var moonPhase: Pair<LocalDateTime, MoonPhase>? = null
 
+    init {
+        scheduledExecutorService.scheduleAtFixedRate(::refreshImageOfSun, 0L, 15L, TimeUnit.MINUTES)
+    }
+
     val objectTypes: Collection<SkyObjectType> by lazy { simbadEntityRepository.findAll().map { it.type }.toSortedSet() }
 
     fun imageOfSun(output: HttpServletResponse) {
@@ -84,8 +84,7 @@ class SkyAtlasService(
     }
 
     fun positionOfSkyObject(location: GeographicCoordinate, id: Long, dateTime: LocalDateTime): BodyPosition {
-        val target = cachedSimbadEntities[id] ?: simbadEntityRepository.find(id)
-        ?: throw ResponseStatusException(HttpStatus.NOT_FOUND, "Cannot found sky object: [$id]")
+        val target = cachedSimbadEntities[id] ?: simbadEntityRepository.find(id) ?: throw NotFoundResponse("Cannot found sky object: [$id]")
         cachedSimbadEntities[id] = target
         val distance = SkyObject.distanceFor(target.parallax.toMas)
         return positionOfBody(target, location, dateTime)!!
@@ -178,14 +177,18 @@ class SkyAtlasService(
     }
 
     fun altitudePointsOfSkyObject(location: GeographicCoordinate, id: Long, dateTime: LocalDateTime, stepSize: Int): List<DoubleArray> {
-        val target = cachedSimbadEntities[id] ?: simbadEntityRepository.find(id)
-        ?: throw ResponseStatusException(HttpStatus.NOT_FOUND, "Cannot found sky object: [$id]")
+        val target = cachedSimbadEntities[id] ?: simbadEntityRepository.find(id) ?: throw NotFoundResponse("Cannot found sky object: [$id]")
         cachedSimbadEntities[id] = target
         val ephemeris = bodyEphemeris(target, location, dateTime, true)
         return altitudePointsOfBody(ephemeris, stepSize)
     }
 
-    fun altitudePointsOfSatellite(location: GeographicCoordinate, satellite: SatelliteEntity, dateTime: LocalDateTime, stepSize: Int): List<DoubleArray> {
+    fun altitudePointsOfSatellite(
+        location: GeographicCoordinate,
+        satellite: SatelliteEntity,
+        dateTime: LocalDateTime,
+        stepSize: Int
+    ): List<DoubleArray> {
         val ephemeris = bodyEphemeris("TLE@${satellite.tle}", location, dateTime, true)
         return altitudePointsOfBody(ephemeris, stepSize)
     }
@@ -219,7 +222,6 @@ class SkyAtlasService(
         type: SkyObjectType? = null, id: Long = 0L,
     ) = simbadEntityRepository.search(text, constellation, rightAscension, declination, radius, magnitudeMin, magnitudeMax, type, id)
 
-    @Scheduled(fixedDelay = 15, timeUnit = TimeUnit.MINUTES)
     fun refreshImageOfSun() {
         val request = Request.Builder()
             .url(SUN_IMAGE_URL)
diff --git a/api/src/main/kotlin/nebulosa/api/atlas/SkyAtlasUpdateTask.kt b/api/src/main/kotlin/nebulosa/api/atlas/SkyAtlasUpdateTask.kt
index e4a2ed6a8..9dd036a32 100644
--- a/api/src/main/kotlin/nebulosa/api/atlas/SkyAtlasUpdateTask.kt
+++ b/api/src/main/kotlin/nebulosa/api/atlas/SkyAtlasUpdateTask.kt
@@ -6,19 +6,21 @@ import nebulosa.log.loggerFor
 import okhttp3.OkHttpClient
 import okhttp3.Request
 import okio.source
-import org.springframework.scheduling.annotation.Scheduled
-import org.springframework.stereotype.Component
+import java.util.concurrent.ScheduledExecutorService
 import java.util.concurrent.TimeUnit
 
-@Component
 class SkyAtlasUpdateTask(
     private val httpClient: OkHttpClient,
     private val simbadEntityRepository: SimbadEntityRepository,
     private val preferenceService: PreferenceService,
     private val messageService: MessageService,
+    scheduledExecutorService: ScheduledExecutorService,
 ) : Runnable {
 
-    @Scheduled(fixedDelay = Long.MAX_VALUE, timeUnit = TimeUnit.SECONDS)
+    init {
+        scheduledExecutorService.schedule(this, 0L, TimeUnit.SECONDS)
+    }
+
     override fun run() {
         var request = Request.Builder().get().url(VERSION_URL).build()
 
diff --git a/api/src/main/kotlin/nebulosa/api/atlas/ephemeris/BodyEphemerisProvider.kt b/api/src/main/kotlin/nebulosa/api/atlas/ephemeris/BodyEphemerisProvider.kt
index 615730ffe..89466e4d1 100644
--- a/api/src/main/kotlin/nebulosa/api/atlas/ephemeris/BodyEphemerisProvider.kt
+++ b/api/src/main/kotlin/nebulosa/api/atlas/ephemeris/BodyEphemerisProvider.kt
@@ -13,16 +13,14 @@ import nebulosa.nova.position.Barycentric
 import nebulosa.nova.position.GeographicPosition
 import nebulosa.time.TimeYMDHMS
 import nebulosa.time.UTC
-import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor
-import org.springframework.stereotype.Service
 import java.time.LocalDateTime
 import java.time.temporal.ChronoUnit
 import java.util.*
 import java.util.concurrent.CompletableFuture
+import java.util.concurrent.ExecutorService
 import kotlin.system.measureTimeMillis
 
-@Service
-class BodyEphemerisProvider(private val threadPoolTaskExecutor: ThreadPoolTaskExecutor) : CachedEphemerisProvider<Body>() {
+class BodyEphemerisProvider(private val executor: ExecutorService) : CachedEphemerisProvider<Body>() {
 
     private val timeBucket = HashMap<LocalDateTime, UTC>()
     private val cachedBodies = HashMap<GeographicPosition, Body>()
@@ -48,7 +46,7 @@ class BodyEphemerisProvider(private val threadPoolTaskExecutor: ThreadPoolTaskEx
         val tasks = ArrayList<CompletableFuture<*>>(numberOfTasks)
 
         repeat(numberOfTasks) {
-            threadPoolTaskExecutor.submitCompletable {
+            CompletableFuture.runAsync({
                 while (true) {
                     val element = synchronized(elementQueue) {
                         elementQueue.removeFirstOrNull()
@@ -78,7 +76,7 @@ class BodyEphemerisProvider(private val threadPoolTaskExecutor: ThreadPoolTaskEx
                     val (elongation, east) = if (target === VSOP87E.SUN) SUN_ELONGATION else barycentric.elongation(target, VSOP87E.SUN)
                     element[HorizonsQuantity.SUN_OBSERVER_TARGET_ELONGATION_ANGLE] = "${elongation.toDegrees},/${if (east) 'L' else 'T'}"
                 }
-            }.also(tasks::add)
+            }, executor).also(tasks::add)
         }
 
         val elapsedTime = measureTimeMillis { tasks.forEach { it.get() } }
diff --git a/api/src/main/kotlin/nebulosa/api/atlas/ephemeris/HorizonsEphemerisProvider.kt b/api/src/main/kotlin/nebulosa/api/atlas/ephemeris/HorizonsEphemerisProvider.kt
index ee560b6d2..af6a2bd49 100644
--- a/api/src/main/kotlin/nebulosa/api/atlas/ephemeris/HorizonsEphemerisProvider.kt
+++ b/api/src/main/kotlin/nebulosa/api/atlas/ephemeris/HorizonsEphemerisProvider.kt
@@ -1,17 +1,11 @@
 package nebulosa.api.atlas.ephemeris
 
-import nebulosa.horizons.HorizonsElement
-import nebulosa.horizons.HorizonsQuantity
-import nebulosa.horizons.HorizonsService
-import nebulosa.horizons.NonUniqueObjectException
-import nebulosa.horizons.ObservingSite
+import nebulosa.horizons.*
 import nebulosa.log.loggerFor
 import nebulosa.nova.position.GeographicPosition
 import nebulosa.sbd.SmallBody
-import org.springframework.stereotype.Service
 import java.time.LocalDateTime
 
-@Service
 class HorizonsEphemerisProvider(private val horizonsService: HorizonsService) : CachedEphemerisProvider<Any>() {
 
     override fun compute(
diff --git a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusController.kt b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusController.kt
index 1b2534adf..399f15dc5 100644
--- a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusController.kt
+++ b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusController.kt
@@ -1,22 +1,38 @@
 package nebulosa.api.autofocus
 
-import nebulosa.indi.device.camera.Camera
-import nebulosa.indi.device.focuser.Focuser
-import org.springframework.web.bind.annotation.*
+import io.javalin.Javalin
+import io.javalin.http.Context
+import io.javalin.http.bodyAsClass
+import nebulosa.api.connection.ConnectionService
+import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.valid
 
-@RestController
-@RequestMapping("auto-focus")
-class AutoFocusController(private val autoFocusService: AutoFocusService) {
+class AutoFocusController(
+    app: Javalin,
+    private val autoFocusService: AutoFocusService,
+    private val connectionService: ConnectionService,
+) {
 
-    @PutMapping("{camera}/{focuser}/start")
-    fun start(
-        camera: Camera, focuser: Focuser,
-        @RequestBody body: AutoFocusRequest,
-    ) = autoFocusService.start(camera, focuser, body)
+    init {
+        app.put("auto-focus/{camera}/{focuser}/start", ::start)
+        app.put("auto-focus/{camera}/stop", ::stop)
+        app.get("auto-focus/{camera}/status", ::status)
+    }
 
-    @PutMapping("{camera}/stop")
-    fun stop(camera: Camera) = autoFocusService.stop(camera)
+    private fun start(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")).notNull()
+        val focuser = connectionService.focuser(ctx.pathParam("focuser")).notNull()
+        val body = ctx.bodyAsClass<AutoFocusRequest>().valid()
+        autoFocusService.start(camera, focuser, body)
+    }
 
-    @GetMapping("{camera}/status")
-    fun status(camera: Camera) = autoFocusService.status(camera)
+    private fun stop(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")).notNull()
+        autoFocusService.stop(camera)
+    }
+
+    private fun status(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")).notNull()
+        autoFocusService.status(camera)?.also(ctx::json)
+    }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusEvent.kt b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusEvent.kt
index 09c4bffc3..16b73960d 100644
--- a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusEvent.kt
+++ b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusEvent.kt
@@ -1,20 +1,23 @@
 package nebulosa.api.autofocus
 
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
 import nebulosa.api.cameras.CameraCaptureEvent
 import nebulosa.api.message.MessageEvent
 import nebulosa.curve.fitting.CurvePoint
 import nebulosa.curve.fitting.HyperbolicFitting
 import nebulosa.curve.fitting.QuadraticFitting
 import nebulosa.curve.fitting.TrendLineFitting
+import nebulosa.indi.device.camera.Camera
 
 data class AutoFocusEvent(
-    @JvmField val state: AutoFocusState = AutoFocusState.IDLE,
-    @JvmField val focusPoint: CurvePoint? = null,
-    @JvmField val determinedFocusPoint: CurvePoint? = null,
-    @JvmField val starCount: Int = 0,
-    @JvmField val starHFD: Double = 0.0,
-    @JvmField val chart: Chart? = null,
-    @JvmField val capture: CameraCaptureEvent? = null,
+    @JvmField val camera: Camera,
+    @JvmField var state: AutoFocusState = AutoFocusState.IDLE,
+    @JvmField var focusPoint: CurvePoint? = null,
+    @JvmField var determinedFocusPoint: CurvePoint? = null,
+    @JvmField var starCount: Int = 0,
+    @JvmField var starHFD: Double = 0.0,
+    @JvmField var chart: Chart? = null,
+    @JvmField @field:JsonIgnoreProperties("camera") val capture: CameraCaptureEvent = CameraCaptureEvent(camera),
 ) : MessageEvent {
 
     data class Chart(
diff --git a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusEventChartSerializer.kt b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusEventChartSerializer.kt
index c4f24d7a7..514d25630 100644
--- a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusEventChartSerializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusEventChartSerializer.kt
@@ -5,12 +5,10 @@ import com.fasterxml.jackson.databind.SerializerProvider
 import com.fasterxml.jackson.databind.ser.std.StdSerializer
 import nebulosa.curve.fitting.*
 import nebulosa.math.evenlySpacedNumbers
-import org.springframework.stereotype.Component
 import kotlin.math.max
 import kotlin.math.min
 import kotlin.math.roundToInt
 
-@Component
 class AutoFocusEventChartSerializer : StdSerializer<AutoFocusEvent.Chart>(AutoFocusEvent.Chart::class.java) {
 
     override fun serialize(chart: AutoFocusEvent.Chart?, gen: JsonGenerator, provider: SerializerProvider) {
diff --git a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusExecutor.kt b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusExecutor.kt
index 688d89246..4774b3a72 100644
--- a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusExecutor.kt
+++ b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusExecutor.kt
@@ -1,7 +1,5 @@
 package nebulosa.api.autofocus
 
-import io.reactivex.rxjava3.functions.Consumer
-import nebulosa.api.beans.annotations.Subscriber
 import nebulosa.api.cameras.CameraEventAware
 import nebulosa.api.focusers.FocuserEventAware
 import nebulosa.api.message.MessageEvent
@@ -10,27 +8,33 @@ import nebulosa.indi.device.camera.Camera
 import nebulosa.indi.device.camera.CameraEvent
 import nebulosa.indi.device.focuser.Focuser
 import nebulosa.indi.device.focuser.FocuserEvent
+import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode
-import org.springframework.stereotype.Component
 import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.ExecutorService
+import java.util.function.Consumer
 
-@Component
-@Subscriber
 class AutoFocusExecutor(
     private val messageService: MessageService,
+    private val executorService: ExecutorService,
+    eventBus: EventBus,
 ) : Consumer<MessageEvent>, CameraEventAware, FocuserEventAware {
 
     private val jobs = ConcurrentHashMap.newKeySet<AutoFocusJob>(2)
 
+    init {
+        eventBus.register(this)
+    }
+
     @Subscribe(threadMode = ThreadMode.ASYNC)
     override fun handleCameraEvent(event: CameraEvent) {
-        jobs.find { it.task.camera === event.device }?.handleCameraEvent(event)
+        jobs.find { it.camera === event.device }?.handleCameraEvent(event)
     }
 
     @Subscribe(threadMode = ThreadMode.ASYNC)
     override fun handleFocuserEvent(event: FocuserEvent) {
-        jobs.find { it.task.focuser === event.device }?.handleFocuserEvent(event)
+        jobs.find { it.focuser === event.device }?.handleFocuserEvent(event)
     }
 
     override fun accept(event: MessageEvent) {
@@ -41,25 +45,23 @@ class AutoFocusExecutor(
     fun execute(camera: Camera, focuser: Focuser, request: AutoFocusRequest) {
         check(camera.connected) { "${camera.name} Camera is not connected" }
         check(focuser.connected) { "${focuser.name} Camera is not connected" }
-        check(jobs.none { it.task.camera === camera }) { "${camera.name} Auto Focus is already in progress" }
-        check(jobs.none { it.task.focuser === focuser }) { "${camera.name} Auto Focus is already in progress" }
+        check(jobs.none { it.camera === camera }) { "${camera.name} Auto Focus is already in progress" }
+        check(jobs.none { it.focuser === focuser }) { "${camera.name} Auto Focus is already in progress" }
 
         val starDetector = request.starDetector.get()
-        val task = AutoFocusTask(camera, focuser, request, starDetector)
-        task.subscribe(this)
 
-        with(AutoFocusJob(task)) {
+        with(AutoFocusJob(this, camera, focuser, request, starDetector)) {
+            val completable = runAsync(executorService)
             jobs.add(this)
-            whenComplete { _, _ -> jobs.remove(this) }
-            start()
+            completable.whenComplete { _, _ -> jobs.remove(this) }
         }
     }
 
     fun stop(camera: Camera) {
-        jobs.find { it.task.camera === camera }?.stop()
+        jobs.find { it.camera === camera }?.stop()
     }
 
     fun status(camera: Camera): AutoFocusEvent? {
-        return jobs.find { it.task.camera === camera }?.task?.get() as? AutoFocusEvent
+        return jobs.find { it.camera === camera }?.status
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusJob.kt b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusJob.kt
index f1e807513..cd22137ba 100644
--- a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusJob.kt
+++ b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusJob.kt
@@ -1,20 +1,242 @@
 package nebulosa.api.autofocus
 
-import nebulosa.api.cameras.CameraEventAware
+import nebulosa.api.cameras.*
+import nebulosa.api.focusers.BacklashCompensationFocuserMoveTask
+import nebulosa.api.focusers.BacklashCompensationMode
 import nebulosa.api.focusers.FocuserEventAware
-import nebulosa.api.tasks.Job
+import nebulosa.api.message.MessageEvent
+import nebulosa.autofocus.AutoFocus
+import nebulosa.autofocus.AutoFocusListener
+import nebulosa.autofocus.AutoFocusResult
+import nebulosa.curve.fitting.CurvePoint
+import nebulosa.curve.fitting.HyperbolicFitting
+import nebulosa.curve.fitting.QuadraticFitting
+import nebulosa.curve.fitting.TrendLineFitting
+import nebulosa.indi.device.camera.Camera
 import nebulosa.indi.device.camera.CameraEvent
+import nebulosa.indi.device.camera.FrameType
+import nebulosa.indi.device.focuser.Focuser
 import nebulosa.indi.device.focuser.FocuserEvent
+import nebulosa.job.manager.AbstractJob
+import nebulosa.job.manager.Task
+import nebulosa.log.loggerFor
+import nebulosa.stardetector.StarDetector
+import java.nio.file.Files
+import java.nio.file.Path
+import java.time.Duration
+import java.util.concurrent.atomic.AtomicBoolean
+import kotlin.math.roundToInt
 
-data class AutoFocusJob(override val task: AutoFocusTask) : Job(), CameraEventAware, FocuserEventAware {
+data class AutoFocusJob(
+    @JvmField val autoFocusExecutor: AutoFocusExecutor,
+    @JvmField val camera: Camera,
+    @JvmField val focuser: Focuser,
+    @JvmField val request: AutoFocusRequest,
+    @JvmField val starDetector: StarDetector<Path>,
+) : AbstractJob(), CameraEventAware, FocuserEventAware, AutoFocusListener {
 
-    override val name = "${task.camera.name} Auto Focus Job"
+    @JvmField val cameraRequest = request.capture.copy(
+        savePath = CAPTURE_SAVE_PATH,
+        exposureTime = maxOf(request.capture.exposureTime, MIN_EXPOSURE_TIME),
+        frameType = FrameType.LIGHT,
+        autoSave = false,
+        autoSubFolderMode = AutoSubFolderMode.OFF,
+    )
+
+    private val cameraExposureTask = CameraExposureTask(this, camera, cameraRequest)
+    private val backlashCompensationFocuserMoveTask = BacklashCompensationFocuserMoveTask(this, focuser, 0, request.backlashCompensation)
+    private val reverse = request.backlashCompensation.mode == BacklashCompensationMode.OVERSHOOT && request.backlashCompensation.backlashIn > 0
+    private val finished = AtomicBoolean()
+
+    private val autoFocus = AutoFocus(
+        starDetector, request.capture.exposureAmount,
+        request.initialOffsetSteps, request.stepSize, request.fittingMode,
+        request.rSquaredThreshold, reverse, focuser.maxPosition,
+    )
+
+    @Volatile private var initialFocusPosition = 0
+
+    @JvmField val status = AutoFocusEvent(camera)
+
+    init {
+        initialFocusPosition = focuser.position
+
+        val result = autoFocus.determinate(focuser.position)
+        result.handle()
+    }
+
+    private fun AutoFocusResult.handle() {
+        when (this) {
+            AutoFocusResult.Determinate -> return
+            AutoFocusResult.TakeExposure -> {
+                add(cameraExposureTask)
+            }
+            is AutoFocusResult.MoveFocuser -> {
+                backlashCompensationFocuserMoveTask.position = if (relative) focuser.position + position else position
+                add(backlashCompensationFocuserMoveTask)
+            }
+            is AutoFocusResult.Completed -> {
+                status.determinedFocusPoint = determinedFocusPoint
+                status.starHFD = determinedFocusPoint.y
+                status.state = AutoFocusState.FINISHED
+                status.send()
+
+                movingFocuserToDeterminedFocusPosition(determinedFocusPoint)
+            }
+            is AutoFocusResult.Failed -> {
+                status.determinedFocusPoint = null
+                status.starCount = 0
+                status.starHFD = 0.0
+                status.state = AutoFocusState.FAILED
+                status.send()
+
+                restoringFocuserToInitialPosition()
+            }
+        }
+    }
 
     override fun handleCameraEvent(event: CameraEvent) {
-        task.handleCameraEvent(event)
+        cameraExposureTask.handleCameraEvent(event)
     }
 
     override fun handleFocuserEvent(event: FocuserEvent) {
-        task.handleFocuserEvent(event)
+        backlashCompensationFocuserMoveTask.handleFocuserEvent(event)
+    }
+
+    override fun beforeStart() {
+        LOG.debug("Auto Focus started. reverse={}, request={}, camera={}, focuser={}", reverse, request, camera, focuser)
+
+        autoFocus.registerAutoFocusListener(this)
+        finished.set(false)
+
+        camera.snoop(camera.snoopedDevices.filter { it !is Focuser } + focuser)
+    }
+
+    override fun beforeTask(task: Task) {
+        if (task === backlashCompensationFocuserMoveTask) {
+            status.state = AutoFocusState.MOVING
+            status.send()
+        } else if (task === cameraExposureTask) {
+            status.state = AutoFocusState.EXPOSURING
+            status.send()
+        }
+    }
+
+    override fun afterTask(task: Task, exception: Throwable?): Boolean {
+        if (exception == null && !finished.get()) {
+            status.state = AutoFocusState.ANALYSING
+            status.send()
+
+            while (true) {
+                val result = try {
+                    autoFocus
+                        .determinate(focuser.position)
+                        .also { it.handle() }
+                } catch (e: Throwable) {
+                    LOG.error("auto focus determination failed", e)
+
+                    status.state = AutoFocusState.FAILED
+                    status.send()
+
+                    restoringFocuserToInitialPosition()
+
+                    return false
+                }
+
+                if (result !is AutoFocusResult.Determinate) break
+            }
+
+            if (!finished.get()) {
+                status.state = AutoFocusState.ANALYSED
+                status.send()
+            }
+        } else {
+            status.state = AutoFocusState.FAILED
+            status.send()
+
+            restoringFocuserToInitialPosition()
+        }
+
+        return super.afterTask(task, exception)
+    }
+
+    override fun afterFinish() {
+        autoFocus.unregisterAutoFocusListener(this)
+
+        if (!finished.get()) {
+            status.state = AutoFocusState.IDLE
+            status.capture.state = CameraCaptureState.IDLE
+            status.send()
+        }
+
+        LOG.debug("Auto Focus finished. camera={}, focuser={}", camera, focuser)
+    }
+
+    override fun accept(event: Any) {
+        when (event) {
+            is CameraExposureEvent -> {
+                status.capture.handleCameraExposureEvent(event)
+
+                if (!finished.get()) {
+                    if (!isCancelled) {
+                        status.state = if (event is CameraExposureFinished) {
+                            autoFocus.add(event.savedPath)
+
+                            status.capture.send()
+                            AutoFocusState.EXPOSURED
+                        } else {
+                            AutoFocusState.EXPOSURING
+                        }
+
+                        status.send()
+                    }
+                } else if (event is CameraExposureFinished) {
+                    status.capture.send()
+                }
+            }
+        }
+    }
+
+    private fun restoringFocuserToInitialPosition() {
+        finished.set(true)
+        backlashCompensationFocuserMoveTask.position = initialFocusPosition
+        backlashCompensationFocuserMoveTask.run()
+        cameraExposureTask.run()
+    }
+
+    private fun movingFocuserToDeterminedFocusPosition(position: CurvePoint) {
+        finished.set(true)
+        backlashCompensationFocuserMoveTask.position = position.x.roundToInt()
+        backlashCompensationFocuserMoveTask.run()
+        cameraExposureTask.run()
+    }
+
+    override fun onStarDetected(count: Int, hfd: Double, stdDev: Double, afterExposures: Boolean) {
+        status.starCount = count
+        status.starHFD = hfd
+    }
+
+    override fun onCurveFitted(
+        predictedFocusPoint: CurvePoint?,
+        minX: Double, minY: Double,
+        maxX: Double, maxY: Double,
+        trendLine: TrendLineFitting.Curve?, parabolic: QuadraticFitting.Curve?, hyperbolic: HyperbolicFitting.Curve?
+    ) {
+        status.state = AutoFocusState.CURVE_FITTED
+        status.chart = AutoFocusEvent.Chart(predictedFocusPoint, minX, minY, maxX, maxY, trendLine, parabolic, hyperbolic)
+        status.send()
+        status.chart = null
+    }
+
+    @Suppress("NOTHING_TO_INLINE")
+    private inline fun MessageEvent.send() {
+        autoFocusExecutor.accept(this)
+    }
+
+    companion object {
+
+        @JvmStatic private val MIN_EXPOSURE_TIME = Duration.ofSeconds(1L)
+        @JvmStatic private val CAPTURE_SAVE_PATH = Files.createTempDirectory("af-")
+        @JvmStatic private val LOG = loggerFor<AutoFocusJob>()
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusRequest.kt b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusRequest.kt
index 1ba8511da..6d421bbc4 100644
--- a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusRequest.kt
+++ b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusRequest.kt
@@ -2,7 +2,12 @@ package nebulosa.api.autofocus
 
 import nebulosa.api.cameras.CameraStartCaptureRequest
 import nebulosa.api.focusers.BacklashCompensation
+import nebulosa.api.javalin.Validatable
+import nebulosa.api.javalin.max
+import nebulosa.api.javalin.positive
+import nebulosa.api.javalin.range
 import nebulosa.api.stardetector.StarDetectionRequest
+import nebulosa.autofocus.AutoFocusFittingMode
 
 data class AutoFocusRequest(
     @JvmField val fittingMode: AutoFocusFittingMode = AutoFocusFittingMode.HYPERBOLIC,
@@ -11,6 +16,14 @@ data class AutoFocusRequest(
     @JvmField val backlashCompensation: BacklashCompensation = BacklashCompensation.EMPTY,
     @JvmField val initialOffsetSteps: Int = 4,
     @JvmField val stepSize: Int = 50,
-    @JvmField val totalNumberOfAttempts: Int = 1,
     @JvmField val starDetector: StarDetectionRequest = StarDetectionRequest.EMPTY,
-)
+) : Validatable {
+
+    override fun validate() {
+        initialOffsetSteps.positive().max(1000)
+        rSquaredThreshold.range(0.0, 1.0)
+        stepSize.positive()
+        capture.validate()
+        starDetector.validate()
+    }
+}
diff --git a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusService.kt b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusService.kt
index fc70aaef5..2848b0636 100644
--- a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusService.kt
+++ b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusService.kt
@@ -2,9 +2,7 @@ package nebulosa.api.autofocus
 
 import nebulosa.indi.device.camera.Camera
 import nebulosa.indi.device.focuser.Focuser
-import org.springframework.stereotype.Service
 
-@Service
 class AutoFocusService(
     private val autoFocusExecutor: AutoFocusExecutor,
 ) {
diff --git a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusTask.kt b/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusTask.kt
deleted file mode 100644
index c79e60271..000000000
--- a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusTask.kt
+++ /dev/null
@@ -1,419 +0,0 @@
-package nebulosa.api.autofocus
-
-import io.reactivex.rxjava3.functions.Consumer
-import nebulosa.api.cameras.*
-import nebulosa.api.focusers.BacklashCompensationFocuserMoveTask
-import nebulosa.api.focusers.BacklashCompensationMode
-import nebulosa.api.focusers.FocuserEventAware
-import nebulosa.api.message.MessageEvent
-import nebulosa.api.tasks.AbstractTask
-import nebulosa.common.concurrency.cancel.CancellationToken
-import nebulosa.curve.fitting.CurvePoint
-import nebulosa.curve.fitting.CurvePoint.Companion.midPoint
-import nebulosa.curve.fitting.HyperbolicFitting
-import nebulosa.curve.fitting.QuadraticFitting
-import nebulosa.curve.fitting.TrendLineFitting
-import nebulosa.indi.device.camera.Camera
-import nebulosa.indi.device.camera.CameraEvent
-import nebulosa.indi.device.camera.FrameType
-import nebulosa.indi.device.focuser.Focuser
-import nebulosa.indi.device.focuser.FocuserEvent
-import nebulosa.log.loggerFor
-import nebulosa.stardetector.StarDetector
-import nebulosa.stardetector.StarPoint
-import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics
-import java.nio.file.Files
-import java.nio.file.Path
-import java.time.Duration
-import kotlin.math.max
-import kotlin.math.roundToInt
-
-data class AutoFocusTask(
-    @JvmField val camera: Camera,
-    @JvmField val focuser: Focuser,
-    @JvmField val request: AutoFocusRequest,
-    @JvmField val starDetection: StarDetector<Path>,
-) : AbstractTask<MessageEvent>(), Consumer<CameraCaptureEvent>, CameraEventAware, FocuserEventAware {
-
-    data class MeasuredStars(@JvmField val hfd: Double, @JvmField val stdDev: Double) {
-
-        companion object {
-
-            @JvmStatic val EMPTY = MeasuredStars(0.0, 0.0)
-        }
-    }
-
-    @JvmField val cameraRequest = request.capture.copy(
-        exposureAmount = 0, exposureDelay = Duration.ZERO,
-        savePath = CAPTURE_SAVE_PATH,
-        exposureTime = maxOf(request.capture.exposureTime, MIN_EXPOSURE_TIME),
-        frameType = FrameType.LIGHT, autoSave = false, autoSubFolderMode = AutoSubFolderMode.OFF
-    )
-
-    private val focusPoints = ArrayList<CurvePoint>()
-    private val measurements = ArrayList<MeasuredStars>(request.capture.exposureAmount)
-    private val cameraCaptureTask = CameraCaptureTask(camera, cameraRequest, focuser = focuser)
-    private val focuserMoveTask = BacklashCompensationFocuserMoveTask(focuser, 0, request.backlashCompensation)
-
-    @Volatile private var trendLineCurve: TrendLineFitting.Curve? = null
-    @Volatile private var parabolicCurve: QuadraticFitting.Curve? = null
-    @Volatile private var hyperbolicCurve: HyperbolicFitting.Curve? = null
-
-    @Volatile private var focusPoint: CurvePoint? = null
-    @Volatile private var starCount = 0
-    @Volatile private var starHFD = 0.0
-    @Volatile private var determinedFocusPoint: CurvePoint? = null
-
-    init {
-        cameraCaptureTask.subscribe(this)
-    }
-
-    override fun handleCameraEvent(event: CameraEvent) {
-        cameraCaptureTask.handleCameraEvent(event)
-    }
-
-    override fun handleFocuserEvent(event: FocuserEvent) {
-        focuserMoveTask.handleFocuserEvent(event)
-    }
-
-    override fun canUseAsLastEvent(event: MessageEvent) = event is AutoFocusEvent
-
-    override fun execute(cancellationToken: CancellationToken) {
-        reset()
-
-        val initialFocusPosition = focuser.position
-
-        cameraCaptureTask.initialize(cancellationToken)
-
-        // Get initial position information, as average of multiple exposures, if configured this way.
-        val initialHFD = if (request.rSquaredThreshold <= 0.0) takeExposure(cancellationToken) else MeasuredStars.EMPTY
-        val reverse = request.backlashCompensation.mode == BacklashCompensationMode.OVERSHOOT && request.backlashCompensation.backlashIn > 0
-
-        LOG.info("Auto Focus started. initialHFD={}, reverse={}, request={}, camera={}, focuser={}", initialHFD, reverse, request, camera, focuser)
-
-        var exited = false
-        var numberOfAttempts = 0
-        val maximumFocusPoints = request.capture.exposureAmount * request.initialOffsetSteps * 10
-
-        while (!exited && !cancellationToken.isCancelled) {
-            numberOfAttempts++
-
-            val offsetSteps = request.initialOffsetSteps
-            val numberOfSteps = offsetSteps + 1
-
-            LOG.info("attempt #{}. offsetSteps={}, numberOfSteps={}", numberOfAttempts, offsetSteps, numberOfSteps)
-
-            obtainFocusPoints(numberOfSteps, offsetSteps, reverse, cancellationToken)
-
-            if (cancellationToken.isCancelled) break
-
-            var leftCount = trendLineCurve?.left?.points?.size ?: 0
-            var rightCount = trendLineCurve?.right?.points?.size ?: 0
-
-            LOG.info("trend line computed. left=$leftCount, right=$rightCount")
-
-            // When data points are not sufficient analyze and take more.
-            do {
-                if (leftCount == 0 && rightCount == 0) {
-                    LOG.warn("Not enought spreaded points")
-                    exited = true
-                    break
-                }
-
-                LOG.info("data points are not sufficient. attempt={}, numberOfSteps={}", numberOfAttempts, numberOfSteps)
-
-                // Let's keep moving in, one step at a time, until we have enough left trend points.
-                // Then we can think about moving out to fill in the right trend points.
-                if (trendLineCurve!!.left.points.size < offsetSteps
-                    && focusPoints.count { it.x < trendLineCurve!!.minimum.x && it.y == 0.0 } < offsetSteps
-                ) {
-                    LOG.info("more data points needed to the left of the minimum")
-
-                    // Move to the leftmost point - this should never be necessary since we're already there, but just in case
-                    if (focuser.position != focusPoints.first().x.roundToInt()) {
-                        moveFocuser(focusPoints.first().x.roundToInt(), cancellationToken, false)
-                    }
-
-                    // More points needed to the left.
-                    obtainFocusPoints(1, -1, false, cancellationToken)
-                } else if (trendLineCurve!!.right.points.size < offsetSteps
-                    && focusPoints.count { it.x > trendLineCurve!!.minimum.x && it.y == 0.0 } < offsetSteps
-                ) {
-                    // Now we can go to the right, if necessary.
-                    LOG.info("more data points needed to the right of the minimum")
-
-                    // More points needed to the right. Let's get to the rightmost point, and keep going right one point at a time.
-                    if (focuser.position != focusPoints.last().x.roundToInt()) {
-                        moveFocuser(focusPoints.last().x.roundToInt(), cancellationToken, false)
-                    }
-
-                    // More points needed to the right.
-                    obtainFocusPoints(1, 1, false, cancellationToken)
-                }
-
-                if (cancellationToken.isCancelled) break
-
-                leftCount = trendLineCurve!!.left.points.size
-                rightCount = trendLineCurve!!.right.points.size
-
-                LOG.info("trend line computed. left=$leftCount, right=$rightCount")
-
-                if (maximumFocusPoints < focusPoints.size) {
-                    // Break out when the maximum limit of focus points is reached
-                    LOG.error("failed to complete. Maximum number of focus points exceeded ($maximumFocusPoints).")
-                    break
-                }
-
-                if (focuser.position <= 0 || focuser.position >= focuser.maxPosition) {
-                    // Break out when the focuser hits the min/max position. It can't continue from there.
-                    LOG.error("failed to complete. position reached ${focuser.position}")
-                    break
-                }
-            } while (!cancellationToken.isCancelled && (rightCount + focusPoints.count { it.x > trendLineCurve!!.minimum.x && it.y == 0.0 } < offsetSteps || leftCount + focusPoints.count { it.x < trendLineCurve!!.minimum.x && it.y == 0.0 } < offsetSteps))
-
-            if (exited || cancellationToken.isCancelled) break
-
-            val finalFocusPoint = determineFinalFocusPoint()
-
-            if (finalFocusPoint == null || !validateCalculatedFocusPosition(finalFocusPoint, initialHFD.hfd, cancellationToken)) {
-                if (cancellationToken.isCancelled) {
-                    break
-                } else if (numberOfAttempts < request.totalNumberOfAttempts) {
-                    moveFocuser(initialFocusPosition, cancellationToken, false)
-                    LOG.warn("potentially bad auto-focus. Reattempting")
-                    reset()
-                    continue
-                } else {
-                    LOG.warn("potentially bad auto-focus. Restoring original focus position")
-                    exited = true
-                }
-            } else {
-                determinedFocusPoint = finalFocusPoint
-                LOG.info("Auto Focus completed. x={}, y={}", finalFocusPoint.x, finalFocusPoint.y)
-                break
-            }
-        }
-
-        cameraCaptureTask.finalize(cancellationToken)
-
-        if (exited || cancellationToken.isCancelled) {
-            LOG.warn("Auto Focus did not complete successfully, so restoring the focuser position to $initialFocusPosition")
-            sendEvent(if (exited) AutoFocusState.FAILED else AutoFocusState.FINISHED)
-
-            if (exited) {
-                moveFocuser(initialFocusPosition, CancellationToken.NONE, false)
-            }
-        } else {
-            sendEvent(AutoFocusState.FINISHED)
-        }
-
-        reset()
-
-        LOG.info("Auto Focus finished. camera={}, focuser={}", camera, focuser)
-    }
-
-    private fun determineFinalFocusPoint(): CurvePoint? {
-        return when (request.fittingMode) {
-            AutoFocusFittingMode.TRENDLINES -> trendLineCurve!!.intersection
-            AutoFocusFittingMode.PARABOLIC -> parabolicCurve?.minimum
-            AutoFocusFittingMode.TREND_PARABOLIC -> parabolicCurve?.minimum?.midPoint(trendLineCurve!!.intersection)
-            AutoFocusFittingMode.HYPERBOLIC -> hyperbolicCurve?.minimum
-            AutoFocusFittingMode.TREND_HYPERBOLIC -> hyperbolicCurve?.minimum?.midPoint(trendLineCurve!!.intersection)
-        }
-    }
-
-    private fun evaluateAllMeasurements(): MeasuredStars {
-        if (measurements.isEmpty()) MeasuredStars.EMPTY
-        if (measurements.size == 1) return measurements[0]
-        val descriptiveStatistics = DescriptiveStatistics(measurements.size)
-        measurements.forEach { descriptiveStatistics.addValue(it.hfd) }
-        return MeasuredStars(descriptiveStatistics.mean, descriptiveStatistics.standardDeviation)
-    }
-
-    override fun accept(event: CameraCaptureEvent) {
-        if (event.state == CameraCaptureState.EXPOSURE_FINISHED) {
-            sendEvent(AutoFocusState.EXPOSURED, event)
-            sendEvent(AutoFocusState.ANALYSING)
-            val detectedStars = starDetection.detect(event.savedPath!!)
-            starCount = detectedStars.size
-            LOG.info("detected $starCount stars")
-            val measurement = detectedStars.measureDetectedStars()
-            LOG.info("HFD measurement: hfd={}, stdDev={}", measurement.hfd, measurement.stdDev)
-            measurements.add(measurement)
-            sendEvent(AutoFocusState.ANALYSED)
-            onNext(event)
-        } else {
-            sendEvent(AutoFocusState.EXPOSURING, event)
-        }
-    }
-
-    private fun takeExposure(cancellationToken: CancellationToken): MeasuredStars {
-        return if (!cancellationToken.isCancelled) {
-            measurements.clear()
-            sendEvent(AutoFocusState.EXPOSURING)
-            cameraCaptureTask.executeUntil(cancellationToken, max(1, request.capture.exposureAmount))
-            evaluateAllMeasurements()
-        } else {
-            MeasuredStars.EMPTY
-        }
-    }
-
-    private fun obtainFocusPoints(numberOfSteps: Int, offset: Int, reverse: Boolean, cancellationToken: CancellationToken) {
-        val stepSize = request.stepSize
-        val direction = if (reverse) -1 else 1
-
-        LOG.info("retrieving focus points. numberOfSteps={}, offset={}, reverse={}", numberOfSteps, offset, reverse)
-
-        var focusPosition = 0
-
-        if (offset != 0) {
-            focusPosition = moveFocuser(direction * offset * stepSize, cancellationToken, true)
-        }
-
-        var remainingSteps = numberOfSteps
-
-        while (!cancellationToken.isCancelled && remainingSteps > 0) {
-            val currentFocusPosition = focusPosition
-
-            val measurement = takeExposure(cancellationToken)
-
-            if (cancellationToken.isCancelled) break
-
-            LOG.info("HFD measured after exposures. mean={}", measurement)
-
-            if (remainingSteps-- > 1) {
-                focusPosition = moveFocuser(direction * -stepSize, cancellationToken, true)
-            }
-
-            if (cancellationToken.isCancelled) break
-
-            // If star measurement is 0, we didn't detect any stars or shapes,
-            // and want this point to be ignored by the fitting as much as possible.
-            if (measurement.hfd == 0.0) {
-                LOG.warn("No stars detected in step")
-            } else {
-                focusPoint = CurvePoint(currentFocusPosition.toDouble(), measurement.hfd, measurement.stdDev)
-                focusPoints.add(focusPoint!!)
-                focusPoints.sortBy { it.x }
-
-                LOG.info("focus point added. remainingSteps={}, point={}", remainingSteps, focusPoint)
-
-                computeCurveFittings()
-            }
-        }
-    }
-
-    private fun computeCurveFittings() {
-        with(focusPoints) {
-            trendLineCurve = TrendLineFitting.calculate(this)
-
-            if (size >= 3) {
-                if (request.fittingMode == AutoFocusFittingMode.PARABOLIC || request.fittingMode == AutoFocusFittingMode.TREND_PARABOLIC) {
-                    parabolicCurve = QuadraticFitting.calculate(this)
-                } else if (request.fittingMode == AutoFocusFittingMode.HYPERBOLIC || request.fittingMode == AutoFocusFittingMode.TREND_HYPERBOLIC) {
-                    hyperbolicCurve = HyperbolicFitting.calculate(this)
-                }
-            }
-
-            sendEvent(AutoFocusState.CURVE_FITTED)
-        }
-    }
-
-    private fun validateCalculatedFocusPosition(focusPoint: CurvePoint, initialHFD: Double, cancellationToken: CancellationToken): Boolean {
-        val threshold = request.rSquaredThreshold
-
-        LOG.info("validating calculated focus position. threshold={}", threshold)
-
-        if (threshold > 0.0) {
-            fun isTrendLineBad() = trendLineCurve?.let { it.left.rSquared < threshold || it.right.rSquared < threshold } != false
-            fun isParabolicBad() = parabolicCurve?.let { it.rSquared < threshold } != false
-            fun isHyperbolicBad() = hyperbolicCurve?.let { it.rSquared < threshold } != false
-
-            val isBad = when (request.fittingMode) {
-                AutoFocusFittingMode.TRENDLINES -> isTrendLineBad()
-                AutoFocusFittingMode.PARABOLIC -> isParabolicBad()
-                AutoFocusFittingMode.TREND_PARABOLIC -> isParabolicBad() || isTrendLineBad()
-                AutoFocusFittingMode.HYPERBOLIC -> isHyperbolicBad()
-                AutoFocusFittingMode.TREND_HYPERBOLIC -> isHyperbolicBad() || isTrendLineBad()
-            }
-
-            if (isBad) {
-                LOG.error("coefficient of determination is below threshold")
-                return false
-            }
-        }
-
-        val min = focusPoints.first().x
-        val max = focusPoints.last().x
-
-        if (focusPoint.x < min || focusPoint.x > max) {
-            LOG.error("determined focus point position is outside of the overall measurement points of the curve")
-            return false
-        }
-
-        if (cancellationToken.isCancelled) return false
-
-        moveFocuser(focusPoint.x.roundToInt(), cancellationToken, false)
-        val (hfd) = takeExposure(cancellationToken)
-
-        if (threshold <= 0) {
-            if (initialHFD != 0.0 && hfd > initialHFD * 1.15) {
-                LOG.warn("New focus point HFR $hfd is significantly worse than original HFR $initialHFD")
-                return false
-            }
-        }
-
-        return true
-    }
-
-    private fun moveFocuser(position: Int, cancellationToken: CancellationToken, relative: Boolean): Int {
-        sendEvent(AutoFocusState.MOVING)
-        focuserMoveTask.position = if (relative) focuser.position + position else position
-        focuserMoveTask.execute(cancellationToken)
-        return focuser.position
-    }
-
-    private fun sendEvent(state: AutoFocusState, capture: CameraCaptureEvent? = null) {
-        val chart = when (state) {
-            AutoFocusState.FINISHED,
-            AutoFocusState.CURVE_FITTED -> {
-                val predictedFocusPoint = determinedFocusPoint ?: determineFinalFocusPoint()
-                val (minX, minY) = if (focusPoints.isEmpty()) CurvePoint.ZERO else focusPoints[0]
-                val (maxX, maxY) = if (focusPoints.isEmpty()) CurvePoint.ZERO else focusPoints[focusPoints.lastIndex]
-                AutoFocusEvent.Chart(predictedFocusPoint, minX, minY, maxX, maxY, trendLineCurve, parabolicCurve, hyperbolicCurve)
-            }
-            else -> null
-        }
-
-        onNext(AutoFocusEvent(state, focusPoint, determinedFocusPoint, starCount, starHFD, chart, capture))
-    }
-
-    override fun reset() {
-        cameraCaptureTask.reset()
-        focusPoints.clear()
-
-        trendLineCurve = null
-        parabolicCurve = null
-        hyperbolicCurve = null
-    }
-
-    override fun close() {
-        super.close()
-        cameraCaptureTask.close()
-    }
-
-    companion object {
-
-        @JvmStatic private val MIN_EXPOSURE_TIME = Duration.ofSeconds(1L)
-        @JvmStatic private val CAPTURE_SAVE_PATH = Files.createTempDirectory("af-")
-        @JvmStatic private val LOG = loggerFor<AutoFocusTask>()
-
-        @JvmStatic
-        private fun List<StarPoint>.measureDetectedStars(): MeasuredStars {
-            if (isEmpty()) return MeasuredStars.EMPTY
-            val descriptiveStatistics = DescriptiveStatistics(size)
-            forEach { descriptiveStatistics.addValue(it.hfd) }
-            return MeasuredStars(descriptiveStatistics.mean, descriptiveStatistics.standardDeviation)
-        }
-    }
-}
diff --git a/api/src/main/kotlin/nebulosa/api/autofocus/CurvePointSerializer.kt b/api/src/main/kotlin/nebulosa/api/autofocus/CurvePointSerializer.kt
index 3d5db1549..8f71d2a15 100644
--- a/api/src/main/kotlin/nebulosa/api/autofocus/CurvePointSerializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/autofocus/CurvePointSerializer.kt
@@ -4,9 +4,7 @@ import com.fasterxml.jackson.core.JsonGenerator
 import com.fasterxml.jackson.databind.SerializerProvider
 import com.fasterxml.jackson.databind.ser.std.StdSerializer
 import nebulosa.curve.fitting.CurvePoint
-import org.springframework.stereotype.Component
 
-@Component
 class CurvePointSerializer : StdSerializer<CurvePoint>(CurvePoint::class.java) {
 
     override fun serialize(point: CurvePoint?, gen: JsonGenerator, provider: SerializerProvider) {
diff --git a/api/src/main/kotlin/nebulosa/api/beans/annotations/Subscriber.kt b/api/src/main/kotlin/nebulosa/api/beans/annotations/Subscriber.kt
index d9bfee611..3cc166f89 100644
--- a/api/src/main/kotlin/nebulosa/api/beans/annotations/Subscriber.kt
+++ b/api/src/main/kotlin/nebulosa/api/beans/annotations/Subscriber.kt
@@ -1,7 +1,4 @@
 package nebulosa.api.beans.annotations
 
-import org.springframework.context.annotation.Lazy
-
-@Lazy(false)
 @Target(AnnotationTarget.CLASS)
 annotation class Subscriber
diff --git a/api/src/main/kotlin/nebulosa/api/beans/configurations/BeanConfiguration.kt b/api/src/main/kotlin/nebulosa/api/beans/configurations/BeanConfiguration.kt
deleted file mode 100644
index 698ad108a..000000000
--- a/api/src/main/kotlin/nebulosa/api/beans/configurations/BeanConfiguration.kt
+++ /dev/null
@@ -1,222 +0,0 @@
-package nebulosa.api.beans.configurations
-
-import com.fasterxml.jackson.databind.DeserializationFeature
-import com.fasterxml.jackson.databind.deser.std.StdDeserializer
-import com.fasterxml.jackson.databind.module.SimpleModule
-import com.fasterxml.jackson.databind.ser.std.StdSerializer
-import com.fasterxml.jackson.module.kotlin.kotlinModule
-import io.objectbox.BoxStore
-import io.objectbox.kotlin.boxFor
-import nebulosa.api.atlas.SatelliteEntity
-import nebulosa.api.atlas.SimbadEntity
-import nebulosa.api.calibration.CalibrationFrameEntity
-import nebulosa.api.database.MyObjectBox
-import nebulosa.api.preference.PreferenceEntity
-import nebulosa.common.concurrency.DaemonThreadFactory
-import nebulosa.guiding.Guider
-import nebulosa.guiding.phd2.PHD2Guider
-import nebulosa.hips2fits.Hips2FitsService
-import nebulosa.horizons.HorizonsService
-import nebulosa.json.PathDeserializer
-import nebulosa.json.PathSerializer
-import nebulosa.log.loggerFor
-import nebulosa.phd2.client.PHD2Client
-import nebulosa.sbd.SmallBodyDatabaseService
-import nebulosa.simbad.SimbadService
-import okhttp3.Cache
-import okhttp3.ConnectionPool
-import okhttp3.OkHttpClient
-import okhttp3.logging.HttpLoggingInterceptor
-import org.greenrobot.eventbus.EventBus
-import org.springframework.beans.factory.annotation.Qualifier
-import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer
-import org.springframework.context.annotation.Bean
-import org.springframework.context.annotation.Configuration
-import org.springframework.context.annotation.Primary
-import org.springframework.http.converter.HttpMessageConverter
-import org.springframework.http.converter.StringHttpMessageConverter
-import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor
-import org.springframework.web.method.support.HandlerMethodArgumentResolver
-import org.springframework.web.servlet.config.annotation.CorsRegistry
-import org.springframework.web.servlet.config.annotation.WebMvcConfigurer
-import java.nio.file.Path
-import java.util.concurrent.ExecutorService
-import java.util.concurrent.Executors
-import java.util.concurrent.TimeUnit
-import kotlin.io.path.createDirectories
-
-@Configuration
-class BeanConfiguration {
-
-    @Bean
-    fun appPath(): Path = Path.of(System.getProperty("app.dir"))
-
-    @Bean
-    fun dataPath(appPath: Path): Path = Path.of("$appPath", "data").createDirectories()
-
-    @Bean
-    fun logsPath(appPath: Path): Path = Path.of("$appPath", "logs").createDirectories()
-
-    @Bean
-    fun capturesPath(appPath: Path): Path = Path.of("$appPath", "captures").createDirectories()
-
-    @Bean
-    fun sequencesPath(appPath: Path): Path = Path.of("$appPath", "sequences").createDirectories()
-
-    @Bean
-    fun cachePath(appPath: Path): Path = Path.of("$appPath", "cache").createDirectories()
-
-    @Bean
-    fun libsPath(appPath: Path): Path = Path.of("$appPath", "libs").createDirectories()
-
-    @Bean
-    @Suppress("UNCHECKED_CAST")
-    fun kotlinModule(
-        serializers: List<StdSerializer<*>>,
-        deserializers: List<StdDeserializer<*>>,
-    ): SimpleModule = kotlinModule()
-        .apply { serializers.forEach { addSerializer(it) } }
-        .apply { deserializers.forEach { addDeserializer(it.handledType() as Class<Any>, it) } }
-        .addSerializer(PathSerializer())
-        .addDeserializer(Path::class.java, PathDeserializer())
-
-    @Bean
-    fun jackson2ObjectMapperBuilderCustomizer() = Jackson2ObjectMapperBuilderCustomizer {
-        it.featuresToDisable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
-        it.featuresToEnable(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)
-    }
-
-    @Bean
-    fun connectionPool() = ConnectionPool(32, 5L, TimeUnit.MINUTES)
-
-    @Bean
-    fun cache(cachePath: Path) = Cache(cachePath.toFile(), MAX_CACHE_SIZE)
-
-    @Bean
-    fun httpLogger() = HttpLoggingInterceptor.Logger { OKHTTP_LOG.info(it) }
-
-    @Bean
-    fun httpClient(connectionPool: ConnectionPool, cache: Cache, httpLogger: HttpLoggingInterceptor.Logger) = OkHttpClient.Builder()
-        .connectionPool(connectionPool)
-        .cache(cache)
-        .addInterceptor(HttpLoggingInterceptor(httpLogger).setLevel(HttpLoggingInterceptor.Level.BASIC))
-        .readTimeout(60L, TimeUnit.SECONDS)
-        .writeTimeout(60L, TimeUnit.SECONDS)
-        .connectTimeout(60L, TimeUnit.SECONDS)
-        .callTimeout(60L, TimeUnit.SECONDS)
-        .build()
-
-    @Bean
-    fun alpacaHttpClient(connectionPool: ConnectionPool) = OkHttpClient.Builder()
-        .connectionPool(connectionPool)
-        .readTimeout(60L, TimeUnit.SECONDS)
-        .writeTimeout(60L, TimeUnit.SECONDS)
-        .connectTimeout(60L, TimeUnit.SECONDS)
-        .callTimeout(60L, TimeUnit.SECONDS)
-        .build()
-
-    @Bean
-    fun horizonsService(httpClient: OkHttpClient) = HorizonsService(httpClient = httpClient)
-
-    @Bean
-    fun simbadService(httpClient: OkHttpClient) = SimbadService(httpClient = httpClient)
-
-    @Bean
-    fun smallBodyDatabaseService(httpClient: OkHttpClient) = SmallBodyDatabaseService(httpClient = httpClient)
-
-    @Bean
-    fun hips2FitsService(httpClient: OkHttpClient) = Hips2FitsService(httpClient = httpClient)
-
-    @Bean
-    @Primary
-    fun threadPoolTaskExecutor(): ThreadPoolTaskExecutor {
-        val taskExecutor = ThreadPoolTaskExecutor()
-        taskExecutor.corePoolSize = 32
-        taskExecutor.keepAliveSeconds = 30
-        taskExecutor.isDaemon = true
-        taskExecutor.initialize()
-        return taskExecutor
-    }
-
-    @Bean
-    fun eventBusExecutorService(): ExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors(), DaemonThreadFactory)
-
-    @Bean
-    fun eventBus(eventBusExecutorService: ExecutorService) = EventBus.builder()
-        .sendNoSubscriberEvent(false)
-        .sendSubscriberExceptionEvent(false)
-        .throwSubscriberException(false)
-        .logNoSubscriberMessages(false)
-        .logSubscriberExceptions(false)
-        .executorService(eventBusExecutorService)
-        .installDefaultEventBus()!!
-
-    @Bean
-    fun phd2Client() = PHD2Client()
-
-    @Bean
-    fun phd2Guider(phd2Client: PHD2Client): Guider = PHD2Guider(phd2Client)
-
-    @Bean
-    @Primary
-    fun boxStore(dataPath: Path) = MyObjectBox.builder()
-        .baseDirectory(dataPath.toFile())
-        .name("main")
-        .build()!!
-
-    @Bean
-    fun simbadBoxStore(dataPath: Path) = MyObjectBox.builder()
-        .baseDirectory(dataPath.toFile())
-        .name("simbad")
-        .build()!!
-
-    @Bean
-    fun calibrationFrameBox(boxStore: BoxStore) = boxStore.boxFor<CalibrationFrameEntity>()
-
-    @Bean
-    fun preferenceBox(boxStore: BoxStore) = boxStore.boxFor<PreferenceEntity>()
-
-    @Bean
-    fun satelliteBox(boxStore: BoxStore) = boxStore.boxFor<SatelliteEntity>()
-
-    @Bean
-    fun simbadBox(@Qualifier("simbadBoxStore") boxStore: BoxStore) = boxStore.boxFor<SimbadEntity>()
-
-    @Bean
-    fun webMvcConfigurer(
-        deviceOrEntityParamMethodArgumentResolver: HandlerMethodArgumentResolver,
-        dateAndTimeParamMethodArgumentResolver: HandlerMethodArgumentResolver,
-        angleParamMethodArgumentResolver: HandlerMethodArgumentResolver,
-        durationUnitMethodArgumentResolver: HandlerMethodArgumentResolver,
-        locationParamMethodArgumentResolver: HandlerMethodArgumentResolver,
-    ) = object : WebMvcConfigurer {
-
-        override fun extendMessageConverters(converters: MutableList<HttpMessageConverter<*>>) {
-            converters.removeIf { it is StringHttpMessageConverter }
-        }
-
-        override fun addCorsMappings(registry: CorsRegistry) {
-            registry
-                .addMapping("/**")
-                .allowedOrigins("*")
-                .allowedMethods("*")
-                .allowedHeaders("*")
-                .exposedHeaders("X-Image-Info")
-        }
-
-        override fun addArgumentResolvers(resolvers: MutableList<HandlerMethodArgumentResolver>) {
-            resolvers.add(deviceOrEntityParamMethodArgumentResolver)
-            resolvers.add(dateAndTimeParamMethodArgumentResolver)
-            resolvers.add(angleParamMethodArgumentResolver)
-            resolvers.add(durationUnitMethodArgumentResolver)
-            resolvers.add(locationParamMethodArgumentResolver)
-        }
-    }
-
-    companion object {
-
-        private const val MAX_CACHE_SIZE = 1024L * 1024L * 32L // 32MB
-
-        @JvmStatic private val OKHTTP_LOG = loggerFor<OkHttpClient>()
-    }
-}
diff --git a/api/src/main/kotlin/nebulosa/api/beans/configurations/WebSocketConfiguration.kt b/api/src/main/kotlin/nebulosa/api/beans/configurations/WebSocketConfiguration.kt
deleted file mode 100644
index bf0be0f81..000000000
--- a/api/src/main/kotlin/nebulosa/api/beans/configurations/WebSocketConfiguration.kt
+++ /dev/null
@@ -1,15 +0,0 @@
-package nebulosa.api.beans.configurations
-
-import org.springframework.context.annotation.Configuration
-import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker
-import org.springframework.web.socket.config.annotation.StompEndpointRegistry
-import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer
-
-@Configuration
-@EnableWebSocketMessageBroker
-class WebSocketConfiguration : WebSocketMessageBrokerConfigurer {
-
-    override fun registerStompEndpoints(registry: StompEndpointRegistry) {
-        registry.addEndpoint("/ws")
-    }
-}
diff --git a/api/src/main/kotlin/nebulosa/api/beans/converters/ConverterHelper.kt b/api/src/main/kotlin/nebulosa/api/beans/converters/ConverterHelper.kt
deleted file mode 100644
index 870f7c4ab..000000000
--- a/api/src/main/kotlin/nebulosa/api/beans/converters/ConverterHelper.kt
+++ /dev/null
@@ -1,24 +0,0 @@
-package nebulosa.api.beans.converters
-
-import jakarta.servlet.http.HttpServletRequest
-import org.springframework.core.MethodParameter
-import org.springframework.web.context.request.NativeWebRequest
-import org.springframework.web.servlet.HandlerMapping
-
-@Suppress("UNCHECKED_CAST")
-val NativeWebRequest.pathVariables
-    get() = getNativeRequest(HttpServletRequest::class.java)!!
-        .getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE) as Map<String, String>
-
-fun NativeWebRequest.parameter(name: String) =
-    pathVariables[name]?.ifBlank { null }
-        ?: getParameter(name)?.ifBlank { null }
-        ?: getNativeRequest(HttpServletRequest::class.java)!!.getParameter(name)?.ifBlank { null }
-
-inline fun <reified T : Annotation> MethodParameter.hasAnnotation(): Boolean {
-    return hasParameterAnnotation(T::class.java)
-}
-
-inline fun <reified T : Annotation> MethodParameter.annotation(): T? {
-    return getParameterAnnotation(T::class.java)
-}
diff --git a/api/src/main/kotlin/nebulosa/api/beans/converters/angle/AngleParam.kt b/api/src/main/kotlin/nebulosa/api/beans/converters/angle/AngleParam.kt
deleted file mode 100644
index f89ae63fd..000000000
--- a/api/src/main/kotlin/nebulosa/api/beans/converters/angle/AngleParam.kt
+++ /dev/null
@@ -1,9 +0,0 @@
-package nebulosa.api.beans.converters.angle
-
-@Target(AnnotationTarget.VALUE_PARAMETER)
-annotation class AngleParam(
-    val name: String = "",
-    val required: Boolean = true,
-    val isHours: Boolean = false,
-    val defaultValue: String = "",
-)
diff --git a/api/src/main/kotlin/nebulosa/api/beans/converters/angle/AngleParamMethodArgumentResolver.kt b/api/src/main/kotlin/nebulosa/api/beans/converters/angle/AngleParamMethodArgumentResolver.kt
deleted file mode 100644
index 931d11eed..000000000
--- a/api/src/main/kotlin/nebulosa/api/beans/converters/angle/AngleParamMethodArgumentResolver.kt
+++ /dev/null
@@ -1,32 +0,0 @@
-package nebulosa.api.beans.converters.angle
-
-import nebulosa.api.beans.converters.annotation
-import nebulosa.api.beans.converters.hasAnnotation
-import nebulosa.api.beans.converters.parameter
-import nebulosa.math.Angle
-import org.springframework.core.MethodParameter
-import org.springframework.stereotype.Component
-import org.springframework.web.bind.support.WebDataBinderFactory
-import org.springframework.web.context.request.NativeWebRequest
-import org.springframework.web.method.support.HandlerMethodArgumentResolver
-import org.springframework.web.method.support.ModelAndViewContainer
-
-@Component
-class AngleParamMethodArgumentResolver : HandlerMethodArgumentResolver {
-
-    override fun supportsParameter(parameter: MethodParameter): Boolean {
-        return parameter.hasAnnotation<AngleParam>()
-    }
-
-    override fun resolveArgument(
-        parameter: MethodParameter,
-        mavContainer: ModelAndViewContainer?,
-        webRequest: NativeWebRequest,
-        binderFactory: WebDataBinderFactory?,
-    ): Angle {
-        val param = parameter.annotation<AngleParam>()!!
-        val parameterName = param.name.ifBlank { null } ?: parameter.parameterName!!
-        val parameterValue = webRequest.parameter(parameterName) ?: param.defaultValue
-        return Angle(parameterValue, param.isHours)
-    }
-}
diff --git a/api/src/main/kotlin/nebulosa/api/beans/converters/device/DeviceOrEntityParam.kt b/api/src/main/kotlin/nebulosa/api/beans/converters/device/DeviceOrEntityParam.kt
deleted file mode 100644
index e02e8eebf..000000000
--- a/api/src/main/kotlin/nebulosa/api/beans/converters/device/DeviceOrEntityParam.kt
+++ /dev/null
@@ -1,7 +0,0 @@
-package nebulosa.api.beans.converters.device
-
-@Target(AnnotationTarget.VALUE_PARAMETER)
-annotation class DeviceOrEntityParam(
-    val name: String = "",
-    val defaultValue: String = ""
-)
diff --git a/api/src/main/kotlin/nebulosa/api/beans/converters/device/DeviceOrEntityParamMethodArgumentResolver.kt b/api/src/main/kotlin/nebulosa/api/beans/converters/device/DeviceOrEntityParamMethodArgumentResolver.kt
deleted file mode 100644
index e89bdd05f..000000000
--- a/api/src/main/kotlin/nebulosa/api/beans/converters/device/DeviceOrEntityParamMethodArgumentResolver.kt
+++ /dev/null
@@ -1,71 +0,0 @@
-package nebulosa.api.beans.converters.device
-
-import nebulosa.api.atlas.SatelliteEntity
-import nebulosa.api.atlas.SatelliteRepository
-import nebulosa.api.beans.converters.annotation
-import nebulosa.api.beans.converters.parameter
-import nebulosa.api.calibration.CalibrationFrameEntity
-import nebulosa.api.calibration.CalibrationFrameRepository
-import nebulosa.api.connection.ConnectionService
-import nebulosa.indi.device.Device
-import nebulosa.indi.device.camera.Camera
-import nebulosa.indi.device.dustcap.DustCap
-import nebulosa.indi.device.filterwheel.FilterWheel
-import nebulosa.indi.device.focuser.Focuser
-import nebulosa.indi.device.gps.GPS
-import nebulosa.indi.device.guider.GuideOutput
-import nebulosa.indi.device.lightbox.LightBox
-import nebulosa.indi.device.mount.Mount
-import nebulosa.indi.device.rotator.Rotator
-import nebulosa.indi.device.thermometer.Thermometer
-import org.springframework.core.MethodParameter
-import org.springframework.stereotype.Component
-import org.springframework.web.bind.support.WebDataBinderFactory
-import org.springframework.web.context.request.NativeWebRequest
-import org.springframework.web.method.support.HandlerMethodArgumentResolver
-import org.springframework.web.method.support.ModelAndViewContainer
-
-@Component
-class DeviceOrEntityParamMethodArgumentResolver(
-    private val satelliteRepository: SatelliteRepository,
-    private val calibrationFrameRepository: CalibrationFrameRepository,
-    private val connectionService: ConnectionService,
-) : HandlerMethodArgumentResolver {
-
-    private val entityResolvers = mapOf<Class<*>, (String) -> Any?>(
-        SatelliteEntity::class.java to { satelliteRepository.find(it.toLong()) },
-        CalibrationFrameEntity::class.java to { calibrationFrameRepository.find(it.toLong()) },
-        Device::class.java to { connectionService.device(it) },
-        Camera::class.java to { connectionService.camera(it) },
-        Mount::class.java to { connectionService.mount(it) },
-        Focuser::class.java to { connectionService.focuser(it) },
-        FilterWheel::class.java to { connectionService.wheel(it) },
-        Rotator::class.java to { connectionService.rotator(it) },
-        GPS::class.java to { connectionService.gps(it) },
-        GuideOutput::class.java to { connectionService.guideOutput(it) },
-        LightBox::class.java to { connectionService.lightBox(it) },
-        DustCap::class.java to { connectionService.dustCap(it) },
-        Thermometer::class.java to { connectionService.thermometer(it) },
-    )
-
-    override fun supportsParameter(parameter: MethodParameter): Boolean {
-        return parameter.parameterType in entityResolvers
-    }
-
-    override fun resolveArgument(
-        parameter: MethodParameter,
-        mavContainer: ModelAndViewContainer?,
-        webRequest: NativeWebRequest,
-        binderFactory: WebDataBinderFactory?,
-    ): Any? {
-        val requestParam = parameter.annotation<DeviceOrEntityParam>()
-        val parameterName = requestParam?.name?.ifBlank { null } ?: parameter.parameterName ?: "id"
-        val parameterValue = webRequest.parameter(parameterName) ?: requestParam?.defaultValue?.ifBlank { null }
-        return entityByParameterValue(parameter.parameterType, parameterValue)
-    }
-
-    private fun entityByParameterValue(parameterType: Class<*>, parameterValue: String?): Any? {
-        if (parameterValue.isNullOrBlank()) return null
-        return entityResolvers[parameterType]?.invoke(parameterValue)
-    }
-}
diff --git a/api/src/main/kotlin/nebulosa/api/beans/converters/location/LocationParam.kt b/api/src/main/kotlin/nebulosa/api/beans/converters/location/LocationParam.kt
deleted file mode 100644
index 311e3db3e..000000000
--- a/api/src/main/kotlin/nebulosa/api/beans/converters/location/LocationParam.kt
+++ /dev/null
@@ -1,4 +0,0 @@
-package nebulosa.api.beans.converters.location
-
-@Target(AnnotationTarget.VALUE_PARAMETER)
-annotation class LocationParam
diff --git a/api/src/main/kotlin/nebulosa/api/beans/converters/location/LocationParamMethodArgumentResolver.kt b/api/src/main/kotlin/nebulosa/api/beans/converters/location/LocationParamMethodArgumentResolver.kt
deleted file mode 100644
index 0605fca66..000000000
--- a/api/src/main/kotlin/nebulosa/api/beans/converters/location/LocationParamMethodArgumentResolver.kt
+++ /dev/null
@@ -1,37 +0,0 @@
-package nebulosa.api.beans.converters.location
-
-import com.fasterxml.jackson.databind.ObjectMapper
-import nebulosa.api.atlas.Location
-import nebulosa.api.beans.converters.hasAnnotation
-import org.springframework.core.MethodParameter
-import org.springframework.stereotype.Component
-import org.springframework.web.bind.support.WebDataBinderFactory
-import org.springframework.web.context.request.NativeWebRequest
-import org.springframework.web.method.support.HandlerMethodArgumentResolver
-import org.springframework.web.method.support.ModelAndViewContainer
-
-@Component
-class LocationParamMethodArgumentResolver(
-    private val objectMapper: ObjectMapper
-) : HandlerMethodArgumentResolver {
-
-    override fun supportsParameter(parameter: MethodParameter): Boolean {
-        return parameter.hasAnnotation<LocationParam>()
-    }
-
-    override fun resolveArgument(
-        parameter: MethodParameter,
-        mavContainer: ModelAndViewContainer?,
-        webRequest: NativeWebRequest,
-        binderFactory: WebDataBinderFactory?,
-    ): Location? {
-        // val param = parameter.annotation<LocationParam>()!!
-        val headerValue = webRequest.getHeader("X-Location")?.ifBlank { null } ?: return null
-        return CACHED_LOCATIONS.getOrPut(headerValue) { objectMapper.readValue(headerValue, Location::class.java) }
-    }
-
-    companion object {
-
-        @JvmStatic private val CACHED_LOCATIONS = HashMap<String, Location>(8)
-    }
-}
diff --git a/api/src/main/kotlin/nebulosa/api/beans/converters/time/DateAndTimeParam.kt b/api/src/main/kotlin/nebulosa/api/beans/converters/time/DateAndTimeParam.kt
deleted file mode 100644
index e41fad45d..000000000
--- a/api/src/main/kotlin/nebulosa/api/beans/converters/time/DateAndTimeParam.kt
+++ /dev/null
@@ -1,9 +0,0 @@
-package nebulosa.api.beans.converters.time
-
-@Target(AnnotationTarget.VALUE_PARAMETER)
-annotation class DateAndTimeParam(
-    val datePattern: String = "yyyy-MM-dd",
-    val timePattern: String = "HH:mm:ss",
-    val noSeconds: Boolean = true,
-    val nullable: Boolean = false,
-)
diff --git a/api/src/main/kotlin/nebulosa/api/beans/converters/time/DateAndTimeParamMethodArgumentResolver.kt b/api/src/main/kotlin/nebulosa/api/beans/converters/time/DateAndTimeParamMethodArgumentResolver.kt
deleted file mode 100644
index 9574c4e70..000000000
--- a/api/src/main/kotlin/nebulosa/api/beans/converters/time/DateAndTimeParamMethodArgumentResolver.kt
+++ /dev/null
@@ -1,53 +0,0 @@
-package nebulosa.api.beans.converters.time
-
-import nebulosa.api.beans.converters.annotation
-import nebulosa.api.beans.converters.hasAnnotation
-import nebulosa.api.beans.converters.parameter
-import nebulosa.time.SystemClock
-import org.springframework.core.MethodParameter
-import org.springframework.stereotype.Component
-import org.springframework.web.bind.support.WebDataBinderFactory
-import org.springframework.web.context.request.NativeWebRequest
-import org.springframework.web.method.support.HandlerMethodArgumentResolver
-import org.springframework.web.method.support.ModelAndViewContainer
-import java.time.LocalDate
-import java.time.LocalDateTime
-import java.time.LocalTime
-import java.time.format.DateTimeFormatter
-import java.time.temporal.Temporal
-
-@Component
-class DateAndTimeParamMethodArgumentResolver : HandlerMethodArgumentResolver {
-
-    override fun supportsParameter(parameter: MethodParameter): Boolean {
-        return parameter.hasAnnotation<DateAndTimeParam>()
-    }
-
-    override fun resolveArgument(
-        parameter: MethodParameter,
-        mavContainer: ModelAndViewContainer?,
-        webRequest: NativeWebRequest,
-        binderFactory: WebDataBinderFactory?,
-    ): Temporal? {
-        val dateAndTimeParam = parameter.annotation<DateAndTimeParam>()!!
-        val type = parameter.parameterType
-
-        val dateValue = webRequest.parameter("date")?.ifBlank { null }
-        val timeValue = webRequest.parameter("time")?.ifBlank { null }
-
-        val date = dateValue
-            ?.let { LocalDate.parse(it, DateTimeFormatter.ofPattern(dateAndTimeParam.datePattern)) }
-            ?: if (dateAndTimeParam.nullable) null else LocalDate.now(SystemClock)
-
-        if (type === LocalDate::class.java) return date
-
-        val time = timeValue
-            ?.let { LocalTime.parse(it, DateTimeFormatter.ofPattern(dateAndTimeParam.timePattern)) }
-            ?: if (dateAndTimeParam.nullable) null else LocalTime.now(SystemClock)
-
-        if (type === LocalTime::class.java) return time
-
-        return LocalDateTime.of(date ?: LocalDate.now(SystemClock), time ?: LocalTime.now(SystemClock))
-            .let { if (dateAndTimeParam.noSeconds) it.withSecond(0).withNano(0) else it }
-    }
-}
diff --git a/api/src/main/kotlin/nebulosa/api/beans/converters/time/DurationDeserializer.kt b/api/src/main/kotlin/nebulosa/api/beans/converters/time/DurationDeserializer.kt
index c0fd8b858..acfa72b50 100644
--- a/api/src/main/kotlin/nebulosa/api/beans/converters/time/DurationDeserializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/beans/converters/time/DurationDeserializer.kt
@@ -7,27 +7,21 @@ import com.fasterxml.jackson.databind.JsonDeserializer
 import com.fasterxml.jackson.databind.deser.ContextualDeserializer
 import com.fasterxml.jackson.databind.deser.std.NumberDeserializers
 import com.fasterxml.jackson.databind.deser.std.StdDeserializer
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.boot.convert.DurationUnit
-import org.springframework.stereotype.Component
 import java.time.Duration
 import java.time.temporal.ChronoUnit
 
-@Component
-class DurationDeserializer(private val unit: ChronoUnit?) : StdDeserializer<Duration>(Duration::class.java), ContextualDeserializer {
+class DurationDeserializer(private val unit: ChronoUnit? = null) : StdDeserializer<Duration>(Duration::class.java), ContextualDeserializer {
 
     private val numberDeserializer by lazy { NumberDeserializers.LongDeserializer(Long::class.java, 0L) }
 
-    @Autowired
-    constructor() : this(null)
-
     override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Duration? {
-        return if (unit == null) StringToDurationConverter.convert(p.text)
+        return if (unit == null) p.text?.ifBlank { null }?.toLongOrNull()
+            ?.let { Duration.of(it, ChronoUnit.MICROS) }
         else Duration.of(numberDeserializer.deserialize(p, ctxt), unit)
     }
 
     override fun createContextual(ctxt: DeserializationContext, property: BeanProperty): JsonDeserializer<*> {
-        val unit = property.getAnnotation(DurationUnit::class.java)?.value ?: return this
+        val unit = property.getAnnotation(DurationUnit::class.java)?.unit ?: return this
         return DESERIALIZERS.getOrPut(unit) { DurationDeserializer(unit) }
     }
 
diff --git a/api/src/main/kotlin/nebulosa/api/beans/converters/time/DurationSerializer.kt b/api/src/main/kotlin/nebulosa/api/beans/converters/time/DurationSerializer.kt
index de45953de..46c30a965 100644
--- a/api/src/main/kotlin/nebulosa/api/beans/converters/time/DurationSerializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/beans/converters/time/DurationSerializer.kt
@@ -6,17 +6,10 @@ import com.fasterxml.jackson.databind.JsonSerializer
 import com.fasterxml.jackson.databind.SerializerProvider
 import com.fasterxml.jackson.databind.ser.ContextualSerializer
 import com.fasterxml.jackson.databind.ser.std.StdSerializer
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.boot.convert.DurationUnit
-import org.springframework.stereotype.Component
 import java.time.Duration
 import java.time.temporal.ChronoUnit
 
-@Component
-class DurationSerializer(private val unit: ChronoUnit?) : StdSerializer<Duration>(Duration::class.java), ContextualSerializer {
-
-    @Autowired
-    constructor() : this(null)
+class DurationSerializer(private val unit: ChronoUnit? = null) : StdSerializer<Duration>(Duration::class.java), ContextualSerializer {
 
     override fun serialize(duration: Duration?, gen: JsonGenerator, provider: SerializerProvider) {
         if (duration == null) gen.writeNull()
@@ -25,7 +18,7 @@ class DurationSerializer(private val unit: ChronoUnit?) : StdSerializer<Duration
     }
 
     override fun createContextual(provider: SerializerProvider, property: BeanProperty): JsonSerializer<*> {
-        val unit = property.getAnnotation(DurationUnit::class.java)?.value ?: return this
+        val unit = property.getAnnotation(DurationUnit::class.java)?.unit ?: return this
         return SERIALIZERS.getOrPut(unit) { DurationSerializer(unit) }
 
     }
diff --git a/api/src/main/kotlin/nebulosa/api/beans/converters/time/DurationUnit.kt b/api/src/main/kotlin/nebulosa/api/beans/converters/time/DurationUnit.kt
new file mode 100644
index 000000000..2233acc01
--- /dev/null
+++ b/api/src/main/kotlin/nebulosa/api/beans/converters/time/DurationUnit.kt
@@ -0,0 +1,5 @@
+package nebulosa.api.beans.converters.time
+
+import java.time.temporal.ChronoUnit
+
+annotation class DurationUnit(val unit: ChronoUnit)
diff --git a/api/src/main/kotlin/nebulosa/api/beans/converters/time/DurationUnitMethodArgumentResolver.kt b/api/src/main/kotlin/nebulosa/api/beans/converters/time/DurationUnitMethodArgumentResolver.kt
deleted file mode 100644
index aaaa845dc..000000000
--- a/api/src/main/kotlin/nebulosa/api/beans/converters/time/DurationUnitMethodArgumentResolver.kt
+++ /dev/null
@@ -1,32 +0,0 @@
-package nebulosa.api.beans.converters.time
-
-import nebulosa.api.beans.converters.annotation
-import nebulosa.api.beans.converters.hasAnnotation
-import nebulosa.api.beans.converters.parameter
-import org.springframework.boot.convert.DurationUnit
-import org.springframework.core.MethodParameter
-import org.springframework.stereotype.Component
-import org.springframework.web.bind.support.WebDataBinderFactory
-import org.springframework.web.context.request.NativeWebRequest
-import org.springframework.web.method.support.HandlerMethodArgumentResolver
-import org.springframework.web.method.support.ModelAndViewContainer
-import java.time.Duration
-
-@Component
-class DurationUnitMethodArgumentResolver : HandlerMethodArgumentResolver {
-
-    override fun supportsParameter(parameter: MethodParameter): Boolean {
-        return parameter.hasAnnotation<DurationUnit>()
-    }
-
-    override fun resolveArgument(
-        parameter: MethodParameter,
-        mavContainer: ModelAndViewContainer?,
-        webRequest: NativeWebRequest,
-        binderFactory: WebDataBinderFactory?,
-    ): Any? {
-        val unit = parameter.annotation<DurationUnit>()!!.value
-        val value = webRequest.parameter(parameter.parameterName!!) ?: return null
-        return Duration.of(value.toLong(), unit)
-    }
-}
diff --git a/api/src/main/kotlin/nebulosa/api/beans/converters/time/StringToDurationConverter.kt b/api/src/main/kotlin/nebulosa/api/beans/converters/time/StringToDurationConverter.kt
deleted file mode 100644
index f080f1f40..000000000
--- a/api/src/main/kotlin/nebulosa/api/beans/converters/time/StringToDurationConverter.kt
+++ /dev/null
@@ -1,37 +0,0 @@
-package nebulosa.api.beans.converters.time
-
-import org.springframework.boot.convert.DurationStyle
-import org.springframework.boot.convert.DurationUnit
-import org.springframework.core.convert.TypeDescriptor
-import org.springframework.core.convert.converter.GenericConverter
-import org.springframework.core.convert.converter.GenericConverter.ConvertiblePair
-import org.springframework.stereotype.Component
-import java.time.Duration
-import java.time.temporal.ChronoUnit
-
-@Component
-class StringToDurationConverter : GenericConverter {
-
-    override fun getConvertibleTypes() = SUPPORTED_TYPES
-
-    override fun convert(source: Any?, sourceType: TypeDescriptor, targetType: TypeDescriptor): Any? {
-        val text = (source as? String)?.ifBlank { null } ?: return null
-        val unit = targetType.getAnnotation(DurationUnit::class.java)?.value ?: ChronoUnit.MICROS
-        return convert(text, unit)
-    }
-
-    companion object {
-
-        @JvmStatic
-        private val SUPPORTED_TYPES = setOf(ConvertiblePair(String::class.java, Duration::class.java))
-
-        @JvmStatic
-        fun convert(source: String?, unit: ChronoUnit = ChronoUnit.MICROS): Duration? {
-            val text = source?.ifBlank { null } ?: return null
-
-            return text.toLongOrNull()
-                ?.let { Duration.of(it, unit) }
-                ?: DurationStyle.SIMPLE.parse(text, unit)
-        }
-    }
-}
diff --git a/api/src/main/kotlin/nebulosa/api/beans/modules/DeviceModule.kt b/api/src/main/kotlin/nebulosa/api/beans/modules/DeviceModule.kt
new file mode 100644
index 000000000..9b595f40f
--- /dev/null
+++ b/api/src/main/kotlin/nebulosa/api/beans/modules/DeviceModule.kt
@@ -0,0 +1,73 @@
+package nebulosa.api.beans.modules
+
+import com.fasterxml.jackson.databind.module.SimpleDeserializers
+import com.fasterxml.jackson.databind.module.SimpleModule
+import com.fasterxml.jackson.databind.module.SimpleSerializers
+import nebulosa.api.autofocus.AutoFocusEventChartSerializer
+import nebulosa.api.autofocus.CurvePointSerializer
+import nebulosa.api.beans.converters.time.DurationDeserializer
+import nebulosa.api.beans.converters.time.DurationSerializer
+import nebulosa.api.cameras.CameraDeserializer
+import nebulosa.api.cameras.CameraSerializer
+import nebulosa.api.dustcap.DustCapDeserializer
+import nebulosa.api.dustcap.DustCapSerializer
+import nebulosa.api.focusers.FocuserDeserializer
+import nebulosa.api.focusers.FocuserSerializer
+import nebulosa.api.guiding.GuideOutputDeserializer
+import nebulosa.api.guiding.GuideOutputSerializer
+import nebulosa.api.indi.INDIPropertySerializer
+import nebulosa.api.indi.INDIPropertyVectorSerializer
+import nebulosa.api.lightboxes.LightBoxDeserializer
+import nebulosa.api.lightboxes.LightBoxSerializer
+import nebulosa.api.mounts.MountDeserializer
+import nebulosa.api.mounts.MountSerializer
+import nebulosa.api.rotators.RotatorDeserializer
+import nebulosa.api.rotators.RotatorSerializer
+import nebulosa.api.stardetector.StarPointSerializer
+import nebulosa.api.wheels.WheelDeserializer
+import nebulosa.api.wheels.WheelSerializer
+import nebulosa.indi.device.camera.Camera
+import nebulosa.indi.device.dustcap.DustCap
+import nebulosa.indi.device.filterwheel.FilterWheel
+import nebulosa.indi.device.focuser.Focuser
+import nebulosa.indi.device.guider.GuideOutput
+import nebulosa.indi.device.lightbox.LightBox
+import nebulosa.indi.device.mount.Mount
+import nebulosa.indi.device.rotator.Rotator
+import java.time.Duration
+
+class DeviceModule : SimpleModule() {
+
+    override fun setupModule(context: SetupContext) {
+        super.setupModule(context)
+
+        val serializers = SimpleSerializers()
+        serializers.addSerializer(CameraSerializer())
+        serializers.addSerializer(MountSerializer())
+        serializers.addSerializer(RotatorSerializer())
+        serializers.addSerializer(FocuserSerializer())
+        serializers.addSerializer(WheelSerializer())
+        serializers.addSerializer(GuideOutputSerializer())
+        serializers.addSerializer(LightBoxSerializer())
+        serializers.addSerializer(DustCapSerializer())
+        serializers.addSerializer(INDIPropertyVectorSerializer())
+        serializers.addSerializer(INDIPropertySerializer())
+        serializers.addSerializer(StarPointSerializer())
+        serializers.addSerializer(AutoFocusEventChartSerializer())
+        serializers.addSerializer(CurvePointSerializer())
+        serializers.addSerializer(DurationSerializer())
+        context.addSerializers(serializers)
+
+        val deserializers = SimpleDeserializers()
+        deserializers.addDeserializer(Camera::class.java, CameraDeserializer())
+        deserializers.addDeserializer(Mount::class.java, MountDeserializer())
+        deserializers.addDeserializer(Rotator::class.java, RotatorDeserializer())
+        deserializers.addDeserializer(Focuser::class.java, FocuserDeserializer())
+        deserializers.addDeserializer(FilterWheel::class.java, WheelDeserializer())
+        deserializers.addDeserializer(GuideOutput::class.java, GuideOutputDeserializer())
+        deserializers.addDeserializer(LightBox::class.java, LightBoxDeserializer())
+        deserializers.addDeserializer(DustCap::class.java, DustCapDeserializer())
+        deserializers.addDeserializer(Duration::class.java, DurationDeserializer())
+        context.addDeserializers(deserializers)
+    }
+}
diff --git a/api/src/main/kotlin/nebulosa/api/beans/processors/EventBusBeanPostProcessor.kt b/api/src/main/kotlin/nebulosa/api/beans/processors/EventBusBeanPostProcessor.kt
deleted file mode 100644
index b76db98d6..000000000
--- a/api/src/main/kotlin/nebulosa/api/beans/processors/EventBusBeanPostProcessor.kt
+++ /dev/null
@@ -1,24 +0,0 @@
-package nebulosa.api.beans.processors
-
-import nebulosa.api.beans.annotations.Subscriber
-import org.greenrobot.eventbus.EventBus
-import org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor
-import org.springframework.stereotype.Component
-
-@Component
-class EventBusBeanPostProcessor(private val eventBus: EventBus) : DestructionAwareBeanPostProcessor {
-
-    override fun postProcessAfterInitialization(bean: Any, beanName: String): Any {
-        if (bean::class.java.isAnnotationPresent(Subscriber::class.java)) {
-            eventBus.register(bean)
-        }
-
-        return bean
-    }
-
-    override fun postProcessBeforeDestruction(bean: Any, beanName: String) {
-        if (bean::class.java.isAnnotationPresent(Subscriber::class.java)) {
-            eventBus.unregister(bean)
-        }
-    }
-}
diff --git a/api/src/main/kotlin/nebulosa/api/calibration/CalibrationFrameController.kt b/api/src/main/kotlin/nebulosa/api/calibration/CalibrationFrameController.kt
index d69ec5960..e99338ba3 100644
--- a/api/src/main/kotlin/nebulosa/api/calibration/CalibrationFrameController.kt
+++ b/api/src/main/kotlin/nebulosa/api/calibration/CalibrationFrameController.kt
@@ -1,38 +1,48 @@
 package nebulosa.api.calibration
 
-import jakarta.validation.Valid
-import org.springframework.validation.annotation.Validated
-import org.springframework.web.bind.annotation.*
-import java.nio.file.Path
-
-@Validated
-@RestController
-@RequestMapping("calibration-frames")
+import io.javalin.Javalin
+import io.javalin.http.Context
+import io.javalin.http.bodyAsClass
+import nebulosa.api.javalin.exists
+import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.path
+import nebulosa.api.javalin.valid
+
 class CalibrationFrameController(
+    app: Javalin,
     private val calibrationFrameService: CalibrationFrameService,
 ) {
 
-    @GetMapping
-    fun groups() = calibrationFrameService.groups()
+    init {
+        app.get("calibration-frames", ::groups)
+        app.get("calibration-frames/{group}", ::frames)
+        app.put("calibration-frames/{group}", ::upload)
+        app.post("calibration-frames", ::update)
+        app.delete("calibration-frames/{id}", ::delete)
+    }
+
+    private fun groups(ctx: Context) {
+        ctx.json(calibrationFrameService.groups())
+    }
 
-    @GetMapping("{group}")
-    fun frames(@PathVariable group: String): List<CalibrationFrameEntity> {
-        return calibrationFrameService.frames(group).sorted()
+    private fun frames(ctx: Context) {
+        val group = ctx.pathParam("group")
+        ctx.json(calibrationFrameService.frames(group).sorted())
     }
 
-    @PutMapping("{group}")
-    fun upload(@PathVariable group: String, @RequestParam path: Path): List<CalibrationFrameEntity> {
-        return calibrationFrameService.upload(group, path)
+    private fun upload(ctx: Context) {
+        val group = ctx.pathParam("group")
+        val path = ctx.queryParam("path").notNull().path().exists()
+        ctx.json(calibrationFrameService.upload(group, path))
     }
 
-    @PostMapping
-    fun update(@RequestBody @Valid body: CalibrationFrameEntity): CalibrationFrameEntity {
-        require(body.id > 0L) { "invalid frame id" }
-        return calibrationFrameService.edit(body)
+    private fun update(ctx: Context) {
+        val body = ctx.bodyAsClass<CalibrationFrameEntity>().valid()
+        ctx.json(calibrationFrameService.edit(body))
     }
 
-    @DeleteMapping("{id}")
-    fun delete(@PathVariable id: Long) {
+    private fun delete(ctx: Context) {
+        val id = ctx.pathParam("id").notNull().toLong()
         calibrationFrameService.delete(id)
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/calibration/CalibrationFrameEntity.kt b/api/src/main/kotlin/nebulosa/api/calibration/CalibrationFrameEntity.kt
index 4e684e1b4..36ecf19e6 100644
--- a/api/src/main/kotlin/nebulosa/api/calibration/CalibrationFrameEntity.kt
+++ b/api/src/main/kotlin/nebulosa/api/calibration/CalibrationFrameEntity.kt
@@ -7,6 +7,9 @@ import io.objectbox.annotation.Index
 import nebulosa.api.beans.converters.database.FrameTypePropertyConverter
 import nebulosa.api.beans.converters.database.PathPropertyConverter
 import nebulosa.api.database.BoxEntity
+import nebulosa.api.javalin.Validatable
+import nebulosa.api.javalin.positive
+import nebulosa.api.javalin.positiveOrZero
 import nebulosa.fits.INVALID_TEMPERATURE
 import nebulosa.indi.device.camera.FrameType
 import java.nio.file.Path
@@ -26,7 +29,17 @@ data class CalibrationFrameEntity(
     @JvmField var gain: Double = 0.0,
     @JvmField @Convert(converter = PathPropertyConverter::class, dbType = String::class) var path: Path? = null,
     @JvmField var enabled: Boolean = true,
-) : BoxEntity, Comparable<CalibrationFrameEntity> {
+) : BoxEntity, Comparable<CalibrationFrameEntity>, Validatable {
+
+    override fun validate() {
+        id.positive()
+        exposureTime.positive()
+        width.positive()
+        height.positive()
+        binX.positive()
+        binY.positive()
+        gain.positiveOrZero()
+    }
 
     override fun compareTo(other: CalibrationFrameEntity): Int {
         return if (type.ordinal > other.type.ordinal) 1
@@ -47,7 +60,6 @@ data class CalibrationFrameEntity(
         else if (temperature < other.temperature) -1
         else if (filter != null && other.filter != null) filter!!.compareTo(other.filter!!)
         else if (filter == null) -1
-        else if (other.filter == null) 1
-        else 0
+        else 1
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/calibration/CalibrationFrameRepository.kt b/api/src/main/kotlin/nebulosa/api/calibration/CalibrationFrameRepository.kt
index e91a4c454..bd40d34f9 100644
--- a/api/src/main/kotlin/nebulosa/api/calibration/CalibrationFrameRepository.kt
+++ b/api/src/main/kotlin/nebulosa/api/calibration/CalibrationFrameRepository.kt
@@ -4,11 +4,8 @@ import io.objectbox.Box
 import io.objectbox.kotlin.equal
 import nebulosa.api.repositories.BoxRepository
 import nebulosa.indi.device.camera.FrameType
-import org.springframework.beans.factory.annotation.Qualifier
-import org.springframework.stereotype.Component
 
-@Component
-class CalibrationFrameRepository(@Qualifier("calibrationFrameBox") override val box: Box<CalibrationFrameEntity>) :
+class CalibrationFrameRepository(override val box: Box<CalibrationFrameEntity>) :
     BoxRepository<CalibrationFrameEntity>() {
 
     fun groups() = box.all.map { it.group }.distinct()
diff --git a/api/src/main/kotlin/nebulosa/api/calibration/CalibrationFrameService.kt b/api/src/main/kotlin/nebulosa/api/calibration/CalibrationFrameService.kt
index c5e25be84..240d94b4a 100644
--- a/api/src/main/kotlin/nebulosa/api/calibration/CalibrationFrameService.kt
+++ b/api/src/main/kotlin/nebulosa/api/calibration/CalibrationFrameService.kt
@@ -11,7 +11,6 @@ import nebulosa.indi.device.camera.FrameType.Companion.frameType
 import nebulosa.log.loggerFor
 import nebulosa.xisf.isXisf
 import nebulosa.xisf.xisf
-import org.springframework.stereotype.Service
 import java.nio.file.Path
 import java.util.*
 import kotlin.io.path.isDirectory
@@ -23,10 +22,7 @@ import kotlin.math.roundToInt
 // https://cdn.diffractionlimited.com/help/maximdl/Understanding_Calibration_Groups.htm
 // https://www.astropy.org/ccd-reduction-and-photometry-guide/v/dev/notebooks/00-00-Preface.html
 
-@Service
-class CalibrationFrameService(
-    private val calibrationFrameRepository: CalibrationFrameRepository,
-) : CalibrationFrameProvider {
+class CalibrationFrameService(private val calibrationFrameRepository: CalibrationFrameRepository) : CalibrationFrameProvider {
 
     fun calibrate(group: String, image: Image, createNew: Boolean = false): Image {
         return synchronized(image) {
diff --git a/api/src/main/kotlin/nebulosa/api/cameras/CameraCaptureEvent.kt b/api/src/main/kotlin/nebulosa/api/cameras/CameraCaptureEvent.kt
index 4d158ed95..9cb091ee7 100644
--- a/api/src/main/kotlin/nebulosa/api/cameras/CameraCaptureEvent.kt
+++ b/api/src/main/kotlin/nebulosa/api/cameras/CameraCaptureEvent.kt
@@ -3,25 +3,97 @@ package nebulosa.api.cameras
 import com.fasterxml.jackson.annotation.JsonIgnore
 import nebulosa.api.message.MessageEvent
 import nebulosa.indi.device.camera.Camera
+import nebulosa.job.manager.TimedTaskEvent
+import nebulosa.job.manager.delay.DelayEvent
 import java.nio.file.Path
-import java.time.Duration
 
 data class CameraCaptureEvent(
-    @JvmField @field:JsonIgnore val task: CameraCaptureTask,
-    @JvmField val camera: Camera = task.camera,
-    @JvmField val state: CameraCaptureState = CameraCaptureState.IDLE,
-    @JvmField val exposureAmount: Int = 0,
-    @JvmField val exposureCount: Int = 0,
-    @JvmField val captureRemainingTime: Duration = Duration.ZERO,
-    @JvmField val captureElapsedTime: Duration = Duration.ZERO,
-    @JvmField val captureProgress: Double = 0.0,
-    @JvmField val stepRemainingTime: Duration = Duration.ZERO,
-    @JvmField val stepElapsedTime: Duration = Duration.ZERO,
-    @JvmField val stepProgress: Double = 0.0,
-    @JvmField val savedPath: Path? = null,
-    @JvmField val liveStackedPath: Path? = null,
-    @JvmField val capture: CameraStartCaptureRequest? = null,
+    @JvmField val camera: Camera,
+    @JvmField var state: CameraCaptureState = CameraCaptureState.IDLE,
+    @JvmField var exposureAmount: Int = 0,
+    @JvmField var exposureCount: Int = 0,
+    @JvmField var captureRemainingTime: Long = 0L,
+    @JvmField var captureElapsedTime: Long = 0L,
+    @JvmField var captureProgress: Double = 0.0,
+    @JvmField var stepRemainingTime: Long = 0L,
+    @JvmField var stepElapsedTime: Long = 0L,
+    @JvmField var stepProgress: Double = 0.0,
+    @JvmField var savedPath: Path? = null,
+    @JvmField var liveStackedPath: Path? = null,
 ) : MessageEvent {
 
     override val eventName = "CAMERA.CAPTURE_ELAPSED"
+
+    @Volatile @field:JsonIgnore private var captureStartElapsedTime = 0L
+    @Volatile @field:JsonIgnore private var captureStartRemainingTime = 0L
+
+    @Suppress("NOTHING_TO_INLINE")
+    private inline fun handleTimedTaskEvent(event: TimedTaskEvent) {
+        stepRemainingTime = event.remainingTime
+        stepElapsedTime = event.elapsedTime
+        stepProgress = event.progress
+    }
+
+    fun handleCameraExposureStarted(event: CameraExposureStarted) {
+        handleTimedTaskEvent(event)
+        state = CameraCaptureState.EXPOSURE_STARTED
+        captureStartElapsedTime = captureElapsedTime
+        captureStartRemainingTime = captureRemainingTime
+        exposureCount++
+    }
+
+    fun handleCameraExposureFinished(event: CameraExposureFinished) {
+        handleTimedTaskEvent(event)
+        state = CameraCaptureState.EXPOSURE_FINISHED
+        captureElapsedTime = captureStartElapsedTime + event.elapsedTime
+        captureRemainingTime = captureStartRemainingTime - event.elapsedTime
+        computeCaptureProgress()
+        savedPath = event.savedPath
+    }
+
+    fun handleCameraExposureElapsed(event: CameraExposureElapsed) {
+        handleTimedTaskEvent(event)
+        state = CameraCaptureState.EXPOSURING
+        captureElapsedTime = captureStartElapsedTime + event.elapsedTime
+        captureRemainingTime = captureStartRemainingTime - event.elapsedTime
+    }
+
+    fun handleCameraCaptureStarted(estimatedCaptureTime: Long = 0L) {
+        state = CameraCaptureState.CAPTURE_STARTED
+        captureRemainingTime = estimatedCaptureTime
+        captureElapsedTime = 0L
+        captureProgress = 0.0
+    }
+
+    fun handleCameraCaptureFinished() {
+        state = CameraCaptureState.CAPTURE_FINISHED
+        captureRemainingTime = 0L
+        captureProgress = 1.0
+    }
+
+    @Suppress("NOTHING_TO_INLINE")
+    private inline fun computeCaptureProgress() {
+        if (captureElapsedTime > 0L && captureRemainingTime >= 0L) {
+            captureProgress = captureElapsedTime.toDouble() / (captureElapsedTime + captureRemainingTime)
+        }
+    }
+
+    fun handleCameraDelayEvent(event: DelayEvent, newState: CameraCaptureState = CameraCaptureState.WAITING) {
+        handleTimedTaskEvent(event)
+        captureElapsedTime += event.waitTime
+        captureRemainingTime -= event.waitTime
+        state = newState
+        computeCaptureProgress()
+    }
+
+    fun handleCameraExposureEvent(event: CameraExposureEvent) {
+        when (event) {
+            is CameraExposureElapsed -> handleCameraExposureElapsed(event)
+            is CameraExposureFinished -> handleCameraExposureFinished(event)
+            is CameraExposureStarted -> handleCameraExposureStarted(event)
+            is CameraExposureFailed -> handleTimedTaskEvent(event)
+        }
+
+        computeCaptureProgress()
+    }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/cameras/CameraCaptureExecutor.kt b/api/src/main/kotlin/nebulosa/api/cameras/CameraCaptureExecutor.kt
index d3958a4e2..d52ca6ff0 100644
--- a/api/src/main/kotlin/nebulosa/api/cameras/CameraCaptureExecutor.kt
+++ b/api/src/main/kotlin/nebulosa/api/cameras/CameraCaptureExecutor.kt
@@ -1,7 +1,5 @@
 package nebulosa.api.cameras
 
-import io.reactivex.rxjava3.functions.Consumer
-import nebulosa.api.beans.annotations.Subscriber
 import nebulosa.api.calibration.CalibrationFrameService
 import nebulosa.api.message.MessageService
 import nebulosa.api.wheels.WheelEventAware
@@ -13,31 +11,36 @@ import nebulosa.indi.device.filterwheel.FilterWheelEvent
 import nebulosa.indi.device.focuser.Focuser
 import nebulosa.indi.device.mount.Mount
 import nebulosa.indi.device.rotator.Rotator
+import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode
-import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor
-import org.springframework.stereotype.Component
 import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.Executor
+import java.util.concurrent.ExecutorService
+import java.util.function.Consumer
 
-@Component
-@Subscriber
 class CameraCaptureExecutor(
     private val messageService: MessageService,
-    private val guider: Guider,
-    private val threadPoolTaskExecutor: ThreadPoolTaskExecutor,
     private val calibrationFrameService: CalibrationFrameService,
-) : Consumer<CameraCaptureEvent>, CameraEventAware, WheelEventAware {
+    private val guider: Guider,
+    private val executorService: ExecutorService,
+    eventBus: EventBus,
+) : Consumer<CameraCaptureEvent>, CameraEventAware, WheelEventAware, Executor by executorService {
 
     private val jobs = ConcurrentHashMap.newKeySet<CameraCaptureJob>(2)
 
+    init {
+        eventBus.register(this)
+    }
+
     @Subscribe(threadMode = ThreadMode.ASYNC)
     override fun handleCameraEvent(event: CameraEvent) {
-        jobs.find { it.task.camera === event.device }?.handleCameraEvent(event)
+        jobs.find { it.camera === event.device }?.handleCameraEvent(event)
     }
 
     @Subscribe(threadMode = ThreadMode.ASYNC)
     override fun handleFilterWheelEvent(event: FilterWheelEvent) {
-        jobs.find { it.task.wheel === event.device }?.handleFilterWheelEvent(event)
+        jobs.find { it.wheel === event.device }?.handleFilterWheelEvent(event)
     }
 
     override fun accept(event: CameraCaptureEvent) {
@@ -50,36 +53,30 @@ class CameraCaptureExecutor(
         mount: Mount? = null, wheel: FilterWheel? = null, focuser: Focuser? = null, rotator: Rotator? = null
     ) {
         check(camera.connected) { "${camera.name} Camera is not connected" }
-        check(jobs.none { it.task.camera === camera }) { "${camera.name} Camera Capture is already in progress" }
+        check(jobs.none { it.camera === camera }) { "${camera.name} Camera Capture is already in progress" }
 
         val liveStackingManager = CameraLiveStackingManager(calibrationFrameService)
-        val task = CameraCaptureTask(
-            camera, request, guider, false, threadPoolTaskExecutor,
-            liveStackingManager, mount, wheel, focuser, rotator
-        )
-
-        task.subscribe(this)
 
-        with(CameraCaptureJob(task)) {
+        with(CameraCaptureJob(this, camera, request, guider, liveStackingManager, mount, wheel, focuser, rotator)) {
+            val completable = runAsync(executorService)
             jobs.add(this)
-            whenComplete { _, _ -> jobs.remove(this); liveStackingManager.close() }
-            start()
+            completable.whenComplete { _, _ -> jobs.remove(this); liveStackingManager.close() }
         }
     }
 
     fun pause(camera: Camera) {
-        jobs.find { it.task.camera === camera }?.pause()
+        jobs.find { it.camera === camera }?.pause()
     }
 
     fun unpause(camera: Camera) {
-        jobs.find { it.task.camera === camera }?.unpause()
+        jobs.find { it.camera === camera }?.unpause()
     }
 
     fun stop(camera: Camera) {
-        jobs.find { it.task.camera === camera }?.stop()
+        jobs.find { it.camera === camera }?.stop()
     }
 
     fun status(camera: Camera): CameraCaptureEvent? {
-        return jobs.find { it.task.camera === camera }?.task?.get()
+        return jobs.find { it.camera === camera }?.status
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/cameras/CameraCaptureJob.kt b/api/src/main/kotlin/nebulosa/api/cameras/CameraCaptureJob.kt
index 6a310180e..087d4f982 100644
--- a/api/src/main/kotlin/nebulosa/api/cameras/CameraCaptureJob.kt
+++ b/api/src/main/kotlin/nebulosa/api/cameras/CameraCaptureJob.kt
@@ -1,19 +1,176 @@
 package nebulosa.api.cameras
 
-import nebulosa.api.tasks.Job
+import nebulosa.api.guiding.DitherAfterExposureEvent
+import nebulosa.api.guiding.DitherAfterExposureTask
+import nebulosa.api.guiding.WaitForSettleTask
 import nebulosa.api.wheels.WheelEventAware
+import nebulosa.api.wheels.WheelMoveTask
+import nebulosa.guiding.Guider
+import nebulosa.indi.device.camera.Camera
 import nebulosa.indi.device.camera.CameraEvent
+import nebulosa.indi.device.camera.FrameType
+import nebulosa.indi.device.filterwheel.FilterWheel
 import nebulosa.indi.device.filterwheel.FilterWheelEvent
+import nebulosa.indi.device.focuser.Focuser
+import nebulosa.indi.device.mount.Mount
+import nebulosa.indi.device.rotator.Rotator
+import nebulosa.job.manager.AbstractJob
+import nebulosa.job.manager.SplitTask
+import nebulosa.job.manager.Task
+import nebulosa.job.manager.delay.DelayEvent
+import nebulosa.job.manager.delay.DelayTask
+import nebulosa.log.debug
+import nebulosa.log.loggerFor
+import java.nio.file.Path
 
-data class CameraCaptureJob(override val task: CameraCaptureTask) : Job(), CameraEventAware, WheelEventAware {
+data class CameraCaptureJob(
+    @JvmField val cameraCaptureExecutor: CameraCaptureExecutor,
+    @JvmField val camera: Camera,
+    @JvmField val request: CameraStartCaptureRequest,
+    @JvmField val guider: Guider? = null,
+    @JvmField val liveStackerManager: CameraLiveStackingManager? = null,
+    @JvmField val mount: Mount? = null,
+    @JvmField val wheel: FilterWheel? = null,
+    @JvmField val focuser: Focuser? = null,
+    @JvmField val rotator: Rotator? = null,
+) : AbstractJob(), CameraEventAware, WheelEventAware {
 
-    override val name = "${task.camera.name} Camera Capture Job"
+    private val delayTask = DelayTask(this, request.exposureDelay)
+    private val waitForSettleTask = WaitForSettleTask(this, guider)
+    private val delayAndWaitForSettleSplitTask = SplitTask(listOf(delayTask, waitForSettleTask), cameraCaptureExecutor)
+    private val cameraExposureTask = CameraExposureTask(this, camera, request)
+    private val ditherAfterExposureTask = DitherAfterExposureTask(this, guider, request.dither)
+    private val shutterWheelMoveTask = if (wheel != null && request.shutterPosition > 0) WheelMoveTask(this, wheel, request.shutterPosition) else null
+
+    @JvmField val status = CameraCaptureEvent(camera, exposureAmount = request.exposureAmount)
+
+    init {
+        shutterWheelMoveTask?.also(::add)
+        add(delayAndWaitForSettleSplitTask)
+        add(cameraExposureTask)
+        add(ditherAfterExposureTask)
+    }
 
     override fun handleCameraEvent(event: CameraEvent) {
-        task.handleCameraEvent(event)
+        cameraExposureTask.handleCameraEvent(event)
     }
 
     override fun handleFilterWheelEvent(event: FilterWheelEvent) {
-        task.handleFilterWheelEvent(event)
+        shutterWheelMoveTask?.handleFilterWheelEvent(event)
+    }
+
+    override fun onPause(paused: Boolean) {
+        if (paused) {
+            status.state = CameraCaptureState.PAUSING
+            status.send()
+        }
+
+        super.onPause(paused)
+    }
+
+    override fun beforePause(task: Task) {
+        status.state = CameraCaptureState.PAUSED
+        status.send()
+    }
+
+    override fun beforeStart() {
+        LOG.debug { "Camera Capture started. request=$request, camera=$camera, mount=$mount, wheel=$wheel, focuser=$focuser" }
+
+        camera.snoop(listOf(mount, wheel, focuser, rotator))
+
+        val estimatedCaptureTime =
+            (request.exposureTime.toNanos() * request.exposureAmount + request.exposureDelay.toNanos() * (request.exposureAmount - 1)) / 1000L
+
+        status.handleCameraCaptureStarted(estimatedCaptureTime)
+        status.send()
+    }
+
+    override fun afterFinish() {
+        status.handleCameraCaptureFinished()
+        status.send()
+
+        liveStackerManager?.stop(request)
+
+        LOG.debug { "Camera Capture finished. request=$request, status=$status, mount=$mount, wheel=$wheel, focuser=$focuser" }
+    }
+
+    override fun isLoop(): Boolean {
+        return request.isLoop || status.exposureCount < request.exposureAmount
+    }
+
+    override fun canRun(prev: Task?, current: Task): Boolean {
+        if (current === ditherAfterExposureTask) {
+            return !isCancelled && guider != null
+                    && status.exposureCount >= 1 && request.dither.afterExposures > 0
+                    && status.exposureCount % request.dither.afterExposures == 0
+        } else if (current === delayAndWaitForSettleSplitTask) {
+            return status.exposureCount > 0
+        } else if (current === shutterWheelMoveTask) {
+            return request.frameType == FrameType.DARK
+        }
+
+        return super.canRun(prev, current)
+    }
+
+    override fun accept(event: Any) {
+        val pausing = status.state == CameraCaptureState.PAUSING
+
+        when (event) {
+            is DelayEvent -> {
+                if (event.task === delayTask) {
+                    status.handleCameraDelayEvent(event)
+                    if (pausing) status.state = CameraCaptureState.PAUSING
+                    status.send()
+                }
+            }
+            is CameraExposureEvent -> {
+                status.handleCameraExposureEvent(event)
+
+                if (event is CameraExposureFinished) {
+                    status.liveStackedPath = addFrameToLiveStacker(status.savedPath)
+
+                    if (pausing) {
+                        status.send()
+                    }
+                }
+
+                if (pausing) {
+                    status.state = CameraCaptureState.PAUSING
+                }
+
+                status.send()
+            }
+            is DitherAfterExposureEvent -> {
+                status.state = CameraCaptureState.DITHERING
+                status.send()
+            }
+        }
+    }
+
+    private fun addFrameToLiveStacker(path: Path?): Path? {
+        return if (path != null && liveStackerManager?.start(request, path) == true) {
+            try {
+                val state = status.state
+                status.state = CameraCaptureState.STACKING
+                status.send()
+                status.state = state
+
+                liveStackerManager.stack(request, path)
+            } catch (_: Throwable) {
+                null
+            }
+        } else {
+            null
+        }
+    }
+
+    @Suppress("NOTHING_TO_INLINE")
+    private inline fun CameraCaptureEvent.send() {
+        cameraCaptureExecutor.accept(this)
+    }
+
+    companion object {
+
+        @JvmStatic private val LOG = loggerFor<CameraCaptureJob>()
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/cameras/CameraCaptureNamingFormatter.kt b/api/src/main/kotlin/nebulosa/api/cameras/CameraCaptureNamingFormatter.kt
index ab590b6f0..0cf1fb8bd 100644
--- a/api/src/main/kotlin/nebulosa/api/cameras/CameraCaptureNamingFormatter.kt
+++ b/api/src/main/kotlin/nebulosa/api/cameras/CameraCaptureNamingFormatter.kt
@@ -1,6 +1,5 @@
 package nebulosa.api.cameras
 
-import nebulosa.common.concurrency.atomic.Incrementer
 import nebulosa.fits.*
 import nebulosa.image.format.ReadableHeader
 import nebulosa.indi.device.camera.Camera
@@ -12,6 +11,7 @@ import nebulosa.indi.device.mount.Mount
 import nebulosa.indi.device.rotator.Rotator
 import nebulosa.math.AngleFormatter
 import nebulosa.math.format
+import nebulosa.util.concurrency.atomic.Incrementer
 import java.time.Clock
 import java.time.LocalDate
 import java.time.LocalTime
diff --git a/api/src/main/kotlin/nebulosa/api/cameras/CameraCaptureTask.kt b/api/src/main/kotlin/nebulosa/api/cameras/CameraCaptureTask.kt
deleted file mode 100644
index a3e2c6d72..000000000
--- a/api/src/main/kotlin/nebulosa/api/cameras/CameraCaptureTask.kt
+++ /dev/null
@@ -1,319 +0,0 @@
-package nebulosa.api.cameras
-
-import com.fasterxml.jackson.annotation.JsonIgnore
-import io.reactivex.rxjava3.functions.Consumer
-import nebulosa.api.guiding.DitherAfterExposureEvent
-import nebulosa.api.guiding.DitherAfterExposureTask
-import nebulosa.api.guiding.WaitForSettleTask
-import nebulosa.api.tasks.AbstractTask
-import nebulosa.api.tasks.SplitTask
-import nebulosa.api.tasks.delay.DelayEvent
-import nebulosa.api.tasks.delay.DelayTask
-import nebulosa.api.wheels.WheelEventAware
-import nebulosa.api.wheels.WheelMoveTask
-import nebulosa.common.concurrency.cancel.CancellationToken
-import nebulosa.common.concurrency.latch.PauseListener
-import nebulosa.guiding.Guider
-import nebulosa.indi.device.camera.Camera
-import nebulosa.indi.device.camera.CameraEvent
-import nebulosa.indi.device.camera.FrameType
-import nebulosa.indi.device.filterwheel.FilterWheel
-import nebulosa.indi.device.filterwheel.FilterWheelEvent
-import nebulosa.indi.device.focuser.Focuser
-import nebulosa.indi.device.mount.Mount
-import nebulosa.indi.device.rotator.Rotator
-import nebulosa.log.loggerFor
-import java.nio.file.Path
-import java.time.Duration
-import java.util.concurrent.Executor
-import java.util.concurrent.atomic.AtomicBoolean
-
-data class CameraCaptureTask(
-    @JvmField val camera: Camera,
-    @JvmField val request: CameraStartCaptureRequest,
-    @JvmField val guider: Guider? = null,
-    private val useFirstExposure: Boolean = false,
-    private val executor: Executor? = null,
-    private val liveStackerManager: CameraLiveStackingManager? = null,
-    @JvmField val mount: Mount? = null,
-    @JvmField val wheel: FilterWheel? = null,
-    @JvmField val focuser: Focuser? = null,
-    @JvmField val rotator: Rotator? = null,
-) : AbstractTask<CameraCaptureEvent>(), Consumer<Any>, PauseListener, CameraEventAware, WheelEventAware {
-
-    private val delayTask = DelayTask(request.exposureDelay)
-    private val waitForSettleTask = WaitForSettleTask(guider)
-    private val delayAndWaitForSettleSplitTask = SplitTask(listOf(delayTask, waitForSettleTask), executor)
-    private val cameraExposureTask = CameraExposureTask(camera, request)
-    private val ditherAfterExposureTask = DitherAfterExposureTask(guider, request.dither)
-    private val shutterWheelMoveTask = if (wheel != null && request.shutterPosition > 0) WheelMoveTask(wheel, request.shutterPosition) else null
-
-    @Volatile private var exposureCount = 0
-    @Volatile private var captureRemainingTime = Duration.ZERO
-    @Volatile private var prevCaptureElapsedTime = Duration.ZERO
-    @Volatile private var captureElapsedTime = Duration.ZERO
-    @Volatile private var captureProgress = 0.0
-    @Volatile private var stepRemainingTime = Duration.ZERO
-    @Volatile private var stepElapsedTime = Duration.ZERO
-    @Volatile private var stepProgress = 0.0
-    @Volatile private var savedPath: Path? = null
-    @Volatile private var liveStackedPath: Path? = null
-
-    @JvmField @JsonIgnore val estimatedCaptureTime: Duration = if (request.isLoop) Duration.ZERO
-    else Duration.ofNanos(request.exposureTime.toNanos() * request.exposureAmount + request.exposureDelay.toNanos() * (request.exposureAmount - if (useFirstExposure) 0 else 1))
-
-    @Volatile private var exposureRepeatCount = 0
-
-    private val pausing = AtomicBoolean()
-
-    init {
-        delayTask.subscribe(this)
-        cameraExposureTask.subscribe(this)
-
-        if (guider != null) {
-            // waitForSettleTask.subscribe(this)
-            ditherAfterExposureTask.subscribe(this)
-        }
-    }
-
-    override fun handleCameraEvent(event: CameraEvent) {
-        cameraExposureTask.handleCameraEvent(event)
-    }
-
-    override fun handleFilterWheelEvent(event: FilterWheelEvent) {
-        shutterWheelMoveTask?.handleFilterWheelEvent(event)
-    }
-
-    override fun onPause(paused: Boolean) {
-        pausing.set(paused)
-
-        if (paused) {
-            sendEvent(CameraCaptureState.PAUSING)
-        }
-    }
-
-    fun initialize(
-        cancellationToken: CancellationToken,
-        hasShutter: Boolean = false, snoopDevices: Boolean = true,
-    ) {
-        LOG.info(
-            "Camera Capture started. request={}, exposureCount={}, camera={}, mount={}, wheel={}, focuser={}", request, exposureCount,
-            camera, mount, wheel, focuser
-        )
-
-        cameraExposureTask.reset()
-
-        pausing.set(false)
-        cancellationToken.listenToPause(this)
-
-        if (snoopDevices) {
-            camera.snoop(listOf(mount, wheel, focuser, rotator))
-        }
-
-        if (hasShutter && shutterWheelMoveTask != null && request.frameType == FrameType.DARK) {
-            shutterWheelMoveTask.execute(cancellationToken)
-        }
-    }
-
-    fun finalize(cancellationToken: CancellationToken) {
-        pausing.set(false)
-        cancellationToken.unlistenToPause(this)
-
-        sendEvent(CameraCaptureState.CAPTURE_FINISHED)
-
-        liveStackerManager?.stop(request)
-
-        LOG.info("Camera Capture finished. camera={}, request={}, exposureCount={}", camera, request, exposureCount)
-    }
-
-    override fun execute(cancellationToken: CancellationToken) {
-        try {
-            initialize(cancellationToken, hasShutter = true)
-            executeInLoop(cancellationToken)
-        } finally {
-            finalize(cancellationToken)
-        }
-    }
-
-    fun executeUntil(cancellationToken: CancellationToken, count: Int) {
-        exposureRepeatCount = 0
-
-        while (!cancellationToken.isCancelled && !cameraExposureTask.isAborted && exposureRepeatCount < count) {
-            executeOnce(cancellationToken)
-        }
-    }
-
-    fun executeInLoop(cancellationToken: CancellationToken) {
-        exposureCount = 0
-
-        while (!cancellationToken.isCancelled && !cameraExposureTask.isAborted && (request.isLoop || exposureCount < request.exposureAmount)) {
-            executeOnce(cancellationToken)
-        }
-    }
-
-    fun executeOnce(cancellationToken: CancellationToken) {
-        if (cancellationToken.isPaused) {
-            pausing.set(false)
-            sendEvent(CameraCaptureState.PAUSED)
-            cancellationToken.waitForPause()
-        }
-
-        if (exposureCount == 0) {
-            sendEvent(CameraCaptureState.CAPTURE_STARTED)
-
-            if (guider != null) {
-                if (useFirstExposure) {
-                    // DELAY & WAIT FOR SETTLE.
-                    delayAndWaitForSettleSplitTask.execute(cancellationToken)
-                } else {
-                    // WAIT FOR SETTLE.
-                    waitForSettleTask.execute(cancellationToken)
-                }
-            } else if (useFirstExposure) {
-                // DELAY.
-                delayTask.execute(cancellationToken)
-            }
-        } else if (guider != null) {
-            // DELAY & WAIT FOR SETTLE.
-            delayAndWaitForSettleSplitTask.execute(cancellationToken)
-        } else {
-            // DELAY.
-            delayTask.execute(cancellationToken)
-        }
-
-        // CAPTURE.
-        cameraExposureTask.execute(cancellationToken)
-
-        // DITHER.
-        if (!cancellationToken.isCancelled && !cameraExposureTask.isAborted && guider != null
-            && exposureCount >= 1 && request.dither.afterExposures > 0 && exposureCount % request.dither.afterExposures == 0
-        ) {
-            ditherAfterExposureTask.execute(cancellationToken)
-        }
-
-        if (cancellationToken.isPaused) {
-            pausing.set(false)
-            sendEvent(CameraCaptureState.PAUSED)
-        }
-    }
-
-    @Synchronized
-    override fun accept(event: Any) {
-        val state = when (event) {
-            is DelayEvent -> {
-                captureElapsedTime += event.waitTime
-                stepElapsedTime = event.task.duration - event.remainingTime
-                stepRemainingTime = event.remainingTime
-                stepProgress = event.progress
-                CameraCaptureState.WAITING
-            }
-            is CameraExposureEvent -> {
-                when (event.state) {
-                    CameraExposureState.STARTED -> {
-                        prevCaptureElapsedTime = captureElapsedTime
-                        exposureCount++
-                        exposureRepeatCount++
-                        CameraCaptureState.EXPOSURE_STARTED
-                    }
-                    CameraExposureState.ELAPSED -> {
-                        captureElapsedTime = prevCaptureElapsedTime + event.elapsedTime
-                        stepElapsedTime = event.elapsedTime
-                        stepRemainingTime = event.remainingTime
-                        stepProgress = event.progress
-                        CameraCaptureState.EXPOSURING
-                    }
-                    CameraExposureState.FINISHED -> {
-                        captureElapsedTime = prevCaptureElapsedTime + request.exposureTime
-                        savedPath = event.savedPath
-                        liveStackedPath = addFrameToLiveStacker(savedPath)
-                        CameraCaptureState.EXPOSURE_FINISHED
-                    }
-                    CameraExposureState.IDLE -> {
-                        CameraCaptureState.CAPTURE_FINISHED
-                    }
-                }
-            }
-            is DitherAfterExposureEvent -> {
-                CameraCaptureState.DITHERING
-            }
-            else -> {
-                return LOG.warn("unknown event: {}", event)
-            }
-        }
-
-        sendEvent(state)
-    }
-
-    private fun sendEvent(state: CameraCaptureState) {
-        if (state != CameraCaptureState.IDLE && !request.isLoop) {
-            captureRemainingTime = if (estimatedCaptureTime > captureElapsedTime) estimatedCaptureTime - captureElapsedTime else Duration.ZERO
-            captureProgress = (estimatedCaptureTime - captureRemainingTime).toNanos().toDouble() / estimatedCaptureTime.toNanos()
-        }
-
-        val isExposureFinished = state == CameraCaptureState.EXPOSURE_FINISHED
-
-        val event = CameraCaptureEvent(
-            this, camera, if (pausing.get() && !isExposureFinished) CameraCaptureState.PAUSING else state,
-            request.exposureAmount, exposureCount,
-            captureRemainingTime, captureElapsedTime, captureProgress,
-            stepRemainingTime, stepElapsedTime, stepProgress,
-            savedPath, liveStackedPath,
-            if (isExposureFinished) request else null
-        )
-
-        onNext(event)
-    }
-
-    private fun addFrameToLiveStacker(path: Path?): Path? {
-        if (liveStackerManager == null) return null
-
-        return if (path != null && liveStackerManager.start(request, path)) {
-            sendEvent(CameraCaptureState.STACKING)
-
-            try {
-                liveStackerManager.stack(request, path)
-            } catch (_: Throwable) {
-                null
-            } finally {
-                sendEvent(CameraCaptureState.WAITING)
-            }
-        } else {
-            null
-        }
-    }
-
-    override fun close() {
-        delayTask.close()
-        waitForSettleTask.close()
-        delayAndWaitForSettleSplitTask.close()
-        cameraExposureTask.close()
-        ditherAfterExposureTask.close()
-        liveStackerManager?.stop(request)
-        super.close()
-    }
-
-    override fun reset() {
-        exposureCount = 0
-        captureRemainingTime = Duration.ZERO
-        prevCaptureElapsedTime = Duration.ZERO
-        captureElapsedTime = Duration.ZERO
-        captureProgress = 0.0
-        stepRemainingTime = Duration.ZERO
-        stepElapsedTime = Duration.ZERO
-        stepProgress = 0.0
-        savedPath = null
-        liveStackedPath = null
-
-        delayTask.reset()
-        cameraExposureTask.reset()
-        ditherAfterExposureTask.reset()
-
-        pausing.set(false)
-        exposureRepeatCount = 0
-    }
-
-    companion object {
-
-        @JvmStatic private val LOG = loggerFor<CameraCaptureTask>()
-    }
-}
diff --git a/api/src/main/kotlin/nebulosa/api/cameras/CameraController.kt b/api/src/main/kotlin/nebulosa/api/cameras/CameraController.kt
index 9c7f78aa5..4e034bd2f 100644
--- a/api/src/main/kotlin/nebulosa/api/cameras/CameraController.kt
+++ b/api/src/main/kotlin/nebulosa/api/cameras/CameraController.kt
@@ -1,89 +1,119 @@
 package nebulosa.api.cameras
 
-import jakarta.validation.Valid
+import io.javalin.Javalin
+import io.javalin.http.Context
+import io.javalin.http.bodyAsClass
 import nebulosa.api.connection.ConnectionService
-import nebulosa.indi.device.camera.Camera
-import nebulosa.indi.device.filterwheel.FilterWheel
-import nebulosa.indi.device.focuser.Focuser
-import nebulosa.indi.device.mount.Mount
-import nebulosa.indi.device.rotator.Rotator
-import org.hibernate.validator.constraints.Range
-import org.springframework.web.bind.annotation.*
-
-@RestController
-@RequestMapping("cameras")
+import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.range
+import nebulosa.api.javalin.valid
+
 class CameraController(
+    app: Javalin,
     private val connectionService: ConnectionService,
     private val cameraService: CameraService,
 ) {
 
-    @GetMapping
-    fun cameras(): List<Camera> {
-        return connectionService.cameras().sorted()
+    init {
+        app.get("cameras", ::cameras)
+        app.get("cameras/{id}", ::camera)
+        app.put("cameras/{id}/connect", ::connect)
+        app.put("cameras/{id}/disconnect", ::disconnect)
+        app.put("cameras/{id}/snoop", ::snoop)
+        app.put("cameras/{id}/cooler", ::cooler)
+        app.put("cameras/{id}/temperature/setpoint", ::setpointTemperature)
+        app.put("cameras/{id}/capture/start", ::startCapture)
+        app.put("cameras/{id}/capture/pause", ::pauseCapture)
+        app.put("cameras/{id}/capture/unpause", ::unpauseCapture)
+        app.put("cameras/{id}/capture/abort", ::abortCapture)
+        app.get("cameras/{id}/capture/status", ::captureStatus)
+        app.put("cameras/{id}/listen", ::listen)
+    }
+
+    private fun cameras(ctx: Context) {
+        ctx.json(connectionService.cameras().sorted())
     }
 
-    @GetMapping("{camera}")
-    fun camera(camera: Camera): Camera {
-        return camera
+    private fun camera(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val camera = connectionService.camera(id).notNull()
+        ctx.json(camera)
     }
 
-    @PutMapping("{camera}/connect")
-    fun connect(camera: Camera) {
+    private fun connect(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val camera = connectionService.camera(id) ?: return
         cameraService.connect(camera)
     }
 
-    @PutMapping("{camera}/disconnect")
-    fun disconnect(camera: Camera) {
+    private fun disconnect(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val camera = connectionService.camera(id) ?: return
         cameraService.disconnect(camera)
     }
 
-    @PutMapping("{camera}/snoop")
-    fun snoop(
-        camera: Camera,
-        mount: Mount?, wheel: FilterWheel?, focuser: Focuser?, rotator: Rotator?
-    ) = cameraService.snoop(camera, mount, wheel, focuser, rotator)
-
-    @PutMapping("{camera}/cooler")
-    fun cooler(
-        camera: Camera,
-        @RequestParam enabled: Boolean,
-    ) = cameraService.cooler(camera, enabled)
-
-    @PutMapping("{camera}/temperature/setpoint")
-    fun setpointTemperature(
-        camera: Camera,
-        @RequestParam @Valid @Range(min = -50, max = 50) temperature: Double,
-    ) = cameraService.setpointTemperature(camera, temperature)
-
-    @PutMapping("{camera}/capture/start")
-    fun startCapture(
-        camera: Camera,
-        mount: Mount?, wheel: FilterWheel?, focuser: Focuser?, rotator: Rotator?,
-        @RequestBody body: CameraStartCaptureRequest,
-    ) = cameraService.startCapture(camera, body, mount, wheel, focuser, rotator)
-
-    @PutMapping("{camera}/capture/pause")
-    fun pauseCapture(camera: Camera) {
+    private fun snoop(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val camera = connectionService.camera(id) ?: return
+        val mount = ctx.queryParam("mount")?.let(connectionService::mount)
+        val wheel = ctx.queryParam("wheel")?.let(connectionService::wheel)
+        val focuser = ctx.queryParam("focuser")?.let(connectionService::focuser)
+        val rotator = ctx.queryParam("rotator")?.let(connectionService::rotator)
+        cameraService.snoop(camera, mount, wheel, focuser, rotator)
+    }
+
+    private fun cooler(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val camera = connectionService.camera(id) ?: return
+        val enabled = ctx.queryParam("enabled").notNull().toBoolean()
+        cameraService.cooler(camera, enabled)
+    }
+
+    private fun setpointTemperature(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val camera = connectionService.camera(id) ?: return
+        val temperature = ctx.queryParam("temperature").notNull().toDouble().range(-50.0, 50.0)
+        cameraService.setpointTemperature(camera, temperature)
+    }
+
+    private fun startCapture(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val camera = connectionService.camera(id) ?: return
+        val mount = ctx.queryParam("mount")?.let(connectionService::mount)
+        val wheel = ctx.queryParam("wheel")?.let(connectionService::wheel)
+        val focuser = ctx.queryParam("focuser")?.let(connectionService::focuser)
+        val rotator = ctx.queryParam("rotator")?.let(connectionService::rotator)
+        val body = ctx.bodyAsClass<CameraStartCaptureRequest>().valid()
+        cameraService.startCapture(camera, body, mount, wheel, focuser, rotator)
+    }
+
+    private fun pauseCapture(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val camera = connectionService.camera(id) ?: return
         cameraService.pauseCapture(camera)
     }
 
-    @PutMapping("{camera}/capture/unpause")
-    fun unpauseCapture(camera: Camera) {
+    private fun unpauseCapture(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val camera = connectionService.camera(id) ?: return
         cameraService.unpauseCapture(camera)
     }
 
-    @PutMapping("{camera}/capture/abort")
-    fun abortCapture(camera: Camera) {
+    private fun abortCapture(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val camera = connectionService.camera(id) ?: return
         cameraService.abortCapture(camera)
     }
 
-    @GetMapping("{camera}/capture/status")
-    fun captureStatus(camera: Camera): CameraCaptureEvent? {
-        return cameraService.captureStatus(camera)
+    private fun captureStatus(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val camera = connectionService.camera(id) ?: return
+        cameraService.captureStatus(camera)?.also(ctx::json)
     }
 
-    @PutMapping("{camera}/listen")
-    fun listen(camera: Camera) {
+    private fun listen(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val camera = connectionService.camera(id) ?: return
         cameraService.listen(camera)
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/cameras/CameraDeserializer.kt b/api/src/main/kotlin/nebulosa/api/cameras/CameraDeserializer.kt
index 66c5b16b4..ac40edf7d 100644
--- a/api/src/main/kotlin/nebulosa/api/cameras/CameraDeserializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/cameras/CameraDeserializer.kt
@@ -1,16 +1,12 @@
 package nebulosa.api.cameras
 
-import nebulosa.api.devices.DeviceDeserializer
 import nebulosa.api.connection.ConnectionService
+import nebulosa.api.devices.DeviceDeserializer
 import nebulosa.indi.device.camera.Camera
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.context.annotation.Lazy
-import org.springframework.stereotype.Component
-
-@Component
-class CameraDeserializer : DeviceDeserializer<Camera>(Camera::class.java) {
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.get
 
-    @Autowired @Lazy private lateinit var connectionService: ConnectionService
+class CameraDeserializer : DeviceDeserializer<Camera>(Camera::class.java), KoinComponent {
 
-    override fun deviceFor(name: String) = connectionService.camera(name)
+    override fun deviceFor(name: String) = get<ConnectionService>().camera(name)
 }
diff --git a/api/src/main/kotlin/nebulosa/api/cameras/CameraEventHub.kt b/api/src/main/kotlin/nebulosa/api/cameras/CameraEventHub.kt
index 9498793fd..c6cdd4703 100644
--- a/api/src/main/kotlin/nebulosa/api/cameras/CameraEventHub.kt
+++ b/api/src/main/kotlin/nebulosa/api/cameras/CameraEventHub.kt
@@ -1,6 +1,5 @@
 package nebulosa.api.cameras
 
-import nebulosa.api.beans.annotations.Subscriber
 import nebulosa.api.devices.DeviceEventHub
 import nebulosa.api.message.MessageService
 import nebulosa.indi.device.DeviceType
@@ -9,23 +8,26 @@ import nebulosa.indi.device.camera.Camera
 import nebulosa.indi.device.camera.CameraAttached
 import nebulosa.indi.device.camera.CameraDetached
 import nebulosa.indi.device.camera.CameraEvent
+import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode
-import org.springframework.stereotype.Component
 
-@Component
-@Subscriber
 class CameraEventHub(
     private val messageService: MessageService,
+    eventBus: EventBus,
 ) : DeviceEventHub<Camera, CameraEvent>(DeviceType.CAMERA), CameraEventAware {
 
+    init {
+        eventBus.register(this)
+    }
+
     @Subscribe(threadMode = ThreadMode.ASYNC)
     override fun handleCameraEvent(event: CameraEvent) {
         if (event.device.type == DeviceType.CAMERA) {
             when (event) {
-            is PropertyChangedEvent -> onNext(event)
-            is CameraAttached -> onAttached(event.device)
-            is CameraDetached -> onDetached(event.device)
+                is PropertyChangedEvent -> onNext(event)
+                is CameraAttached -> onAttached(event.device)
+                is CameraDetached -> onDetached(event.device)
             }
         }
     }
diff --git a/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureElapsed.kt b/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureElapsed.kt
new file mode 100644
index 000000000..0eaef0149
--- /dev/null
+++ b/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureElapsed.kt
@@ -0,0 +1,14 @@
+package nebulosa.api.cameras
+
+import nebulosa.job.manager.Job
+
+data class CameraExposureElapsed(
+    override val job: Job,
+    override val task: CameraExposureTask,
+    override val elapsedTime: Long,
+    override val remainingTime: Long,
+    override val progress: Double,
+) : CameraExposureEvent {
+
+    override val savedPath = null
+}
diff --git a/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureEvent.kt b/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureEvent.kt
index 8d721dafb..b7f9a264c 100644
--- a/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureEvent.kt
+++ b/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureEvent.kt
@@ -1,13 +1,9 @@
 package nebulosa.api.cameras
 
+import nebulosa.job.manager.TimedTaskEvent
 import java.nio.file.Path
-import java.time.Duration
 
-data class CameraExposureEvent(
-    @JvmField val task: CameraExposureTask,
-    @JvmField val state: CameraExposureState = CameraExposureState.IDLE,
-    @JvmField val elapsedTime: Duration = Duration.ZERO,
-    @JvmField val remainingTime: Duration = Duration.ZERO,
-    @JvmField val progress: Double = 0.0,
-    @JvmField val savedPath: Path? = null,
-)
+sealed interface CameraExposureEvent : TimedTaskEvent {
+
+    val savedPath: Path?
+}
diff --git a/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureFailed.kt b/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureFailed.kt
new file mode 100644
index 000000000..b9b9e1459
--- /dev/null
+++ b/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureFailed.kt
@@ -0,0 +1,14 @@
+package nebulosa.api.cameras
+
+import nebulosa.job.manager.Job
+
+data class CameraExposureFailed(
+    override val job: Job,
+    override val task: CameraExposureTask,
+) : CameraExposureEvent {
+
+    override val elapsedTime = task.exposureTimeInMicroseconds
+    override val remainingTime = 0L
+    override val progress = 1.0
+    override val savedPath = null
+}
diff --git a/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureFinished.kt b/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureFinished.kt
new file mode 100644
index 000000000..3232f6039
--- /dev/null
+++ b/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureFinished.kt
@@ -0,0 +1,15 @@
+package nebulosa.api.cameras
+
+import nebulosa.job.manager.Job
+import java.nio.file.Path
+
+data class CameraExposureFinished(
+    override val job: Job,
+    override val task: CameraExposureTask,
+    override val savedPath: Path,
+) : CameraExposureEvent {
+
+    override val elapsedTime = task.exposureTimeInMicroseconds
+    override val remainingTime = 0L
+    override val progress = 1.0
+}
diff --git a/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureStarted.kt b/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureStarted.kt
new file mode 100644
index 000000000..093393b24
--- /dev/null
+++ b/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureStarted.kt
@@ -0,0 +1,11 @@
+package nebulosa.api.cameras
+
+import nebulosa.job.manager.Job
+
+data class CameraExposureStarted(override val job: Job, override val task: CameraExposureTask) : CameraExposureEvent {
+
+    override val elapsedTime = 0L
+    override val remainingTime = task.exposureTimeInMicroseconds
+    override val progress = 0.0
+    override val savedPath = null
+}
diff --git a/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureState.kt b/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureState.kt
deleted file mode 100644
index 3c71ba3ea..000000000
--- a/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureState.kt
+++ /dev/null
@@ -1,8 +0,0 @@
-package nebulosa.api.cameras
-
-enum class CameraExposureState {
-    IDLE,
-    STARTED,
-    ELAPSED,
-    FINISHED,
-}
diff --git a/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureTask.kt b/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureTask.kt
index c592f3e53..a73e27807 100644
--- a/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureTask.kt
+++ b/api/src/main/kotlin/nebulosa/api/cameras/CameraExposureTask.kt
@@ -1,44 +1,35 @@
 package nebulosa.api.cameras
 
-import nebulosa.api.tasks.AbstractTask
-import nebulosa.common.concurrency.cancel.CancellationListener
-import nebulosa.common.concurrency.cancel.CancellationSource
-import nebulosa.common.concurrency.cancel.CancellationToken
-import nebulosa.common.concurrency.latch.CountUpDownLatch
 import nebulosa.fits.fits
 import nebulosa.image.format.ReadableHeader
 import nebulosa.indi.device.camera.*
 import nebulosa.io.transferAndClose
+import nebulosa.job.manager.Job
+import nebulosa.job.manager.Task
 import nebulosa.log.loggerFor
+import nebulosa.util.concurrency.cancellation.CancellationSource
+import nebulosa.util.concurrency.latch.CountUpDownLatch
 import okio.sink
 import java.nio.file.Files
 import java.nio.file.Path
-import java.time.Duration
 import java.time.LocalDateTime
-import java.util.concurrent.atomic.AtomicBoolean
 import kotlin.io.path.createParentDirectories
 import kotlin.io.path.deleteIfExists
 import kotlin.io.path.moveTo
 import kotlin.io.path.outputStream
+import kotlin.math.min
 
 data class CameraExposureTask(
+    @JvmField val job: Job,
     @JvmField val camera: Camera,
     @JvmField val request: CameraStartCaptureRequest,
-) : AbstractTask<CameraExposureEvent>(), CancellationListener, CameraEventAware {
+) : Task, CameraEventAware {
 
     private val latch = CountUpDownLatch()
-    private val aborted = AtomicBoolean()
-
-    @Volatile private var elapsedTime = Duration.ZERO
-    @Volatile private var remainingTime = Duration.ZERO
-    @Volatile private var progress = 0.0
-    @Volatile private var savedPath: Path? = null
-
     private val outputPath = Files.createTempFile(camera.name, ".fits")
     private val formatter = CameraCaptureNamingFormatter(camera)
 
-    val isAborted
-        get() = aborted.get()
+    @JvmField val exposureTimeInMicroseconds = request.exposureTime.toNanos() / 1000L
 
     override fun handleCameraEvent(event: CameraEvent) {
         if (event.device === camera) {
@@ -47,32 +38,29 @@ data class CameraExposureTask(
                     save(event)
                 }
                 is CameraExposureAborted,
-                is CameraExposureFailed,
+                is nebulosa.indi.device.camera.CameraExposureFailed,
                 is CameraDetached -> {
-                    aborted.set(true)
                     latch.reset()
+                    job.accept(CameraExposureFailed(job, this))
                 }
                 is CameraExposureProgressChanged -> {
-                    val exposureTime = request.exposureTime
-                    // minOf fix possible bug on SVBony exposure time?
-                    remainingTime = minOf(event.device.exposureTime, request.exposureTime)
-                    elapsedTime = exposureTime - remainingTime
-                    progress = elapsedTime.toNanos().toDouble() / exposureTime.toNanos()
-                    sendEvent(CameraExposureState.ELAPSED)
+                    // "min" fix possible bug on SVBony exposure time?
+                    val remainingTime = min(event.device.exposureTime, request.exposureTime.toNanos() / 1000L)
+                    val elapsedTime = exposureTimeInMicroseconds - remainingTime
+                    val progress = elapsedTime.toDouble() / exposureTimeInMicroseconds
+                    job.accept(CameraExposureElapsed(job, this@CameraExposureTask, elapsedTime, remainingTime, progress))
                 }
             }
         }
     }
 
-    override fun execute(cancellationToken: CancellationToken) {
-        if (camera.connected && !aborted.get()) {
-            LOG.info("Camera Exposure started. camera={}, request={}", camera, request)
-
-            cancellationToken.waitForPause()
+    override fun run() {
+        if (camera.connected) {
+            LOG.debug("Camera Exposure started. camera={}, request={}", camera, request)
 
             latch.countUp()
 
-            sendEvent(CameraExposureState.STARTED)
+            job.accept(CameraExposureStarted(job, this))
 
             with(camera) {
                 enableBlob()
@@ -86,37 +74,23 @@ data class CameraExposureTask(
                 bin(request.binX, request.binY)
                 gain(request.gain)
                 offset(request.offset)
-                startCapture(request.exposureTime)
+                startCapture(request.exposureTime.toNanos() / 1000L)
             }
 
-            try {
-                cancellationToken.listen(this)
-                latch.await()
-            } finally {
-                cancellationToken.unlisten(this)
-            }
+            latch.await()
 
-            LOG.info("Camera Exposure finished. aborted={}, camera={}, request={}", aborted.get(), camera, request)
+            LOG.debug("Camera Exposure finished. camera={}, request={}", camera, request)
         } else {
-            LOG.warn("camera not connected or aborted. aborted={}, camera={}, request={}", aborted.get(), camera, request)
+            LOG.warn("camera not connected. camera={}, request={}", camera, request)
         }
+
+        outputPath.deleteIfExists()
     }
 
     override fun onCancel(source: CancellationSource) {
         camera.abortCapture()
     }
 
-    override fun reset() {
-        aborted.set(false)
-        latch.reset()
-    }
-
-    override fun close() {
-        onCancel(CancellationSource.Close)
-        outputPath.deleteIfExists()
-        super.close()
-    }
-
     private fun save(event: CameraFrameCaptured) {
         try {
             val header = if (event.stream != null) {
@@ -131,25 +105,18 @@ data class CameraExposureTask(
             }
 
             with(request.makeSavePath(header = header)) {
-                LOG.info("saving FITS image at {}", this)
+                LOG.debug("saving FITS image at {}", this)
                 createParentDirectories()
                 outputPath.moveTo(this, true)
-                savedPath = this
+                job.accept(CameraExposureFinished(job, this@CameraExposureTask, this))
             }
-
-            sendEvent(CameraExposureState.FINISHED)
         } catch (e: Throwable) {
             LOG.error("failed to save FITS image", e)
-            aborted.set(true)
         } finally {
             latch.countDown()
         }
     }
 
-    private fun sendEvent(state: CameraExposureState) {
-        onNext(CameraExposureEvent(this, state, elapsedTime, remainingTime, progress, savedPath))
-    }
-
     private fun CameraStartCaptureRequest.makeSavePath(
         autoSave: Boolean = this.autoSave,
         header: ReadableHeader? = null,
diff --git a/api/src/main/kotlin/nebulosa/api/cameras/CameraLiveStackingManager.kt b/api/src/main/kotlin/nebulosa/api/cameras/CameraLiveStackingManager.kt
index 697fc3d12..73e22019a 100644
--- a/api/src/main/kotlin/nebulosa/api/cameras/CameraLiveStackingManager.kt
+++ b/api/src/main/kotlin/nebulosa/api/cameras/CameraLiveStackingManager.kt
@@ -3,16 +3,7 @@ package nebulosa.api.cameras
 import nebulosa.api.calibration.CalibrationFrameProvider
 import nebulosa.api.livestacker.LiveStackingRequest
 import nebulosa.api.stacker.StackerGroupType
-import nebulosa.fits.binX
-import nebulosa.fits.binY
-import nebulosa.fits.exposureTimeInMicroseconds
-import nebulosa.fits.filter
-import nebulosa.fits.fits
-import nebulosa.fits.gain
-import nebulosa.fits.height
-import nebulosa.fits.isFits
-import nebulosa.fits.temperature
-import nebulosa.fits.width
+import nebulosa.fits.*
 import nebulosa.image.format.ImageHdu
 import nebulosa.livestacker.LiveStacker
 import nebulosa.log.loggerFor
@@ -20,13 +11,8 @@ import nebulosa.xisf.isXisf
 import nebulosa.xisf.xisf
 import java.nio.file.Files
 import java.nio.file.Path
-import java.util.EnumMap
-import kotlin.io.path.copyTo
-import kotlin.io.path.deleteIfExists
-import kotlin.io.path.deleteRecursively
-import kotlin.io.path.exists
-import kotlin.io.path.extension
-import kotlin.io.path.isRegularFile
+import java.util.*
+import kotlin.io.path.*
 
 data class CameraLiveStackingManager(
     private val calibrationFrameProvider: CalibrationFrameProvider? = null,
@@ -121,7 +107,7 @@ data class CameraLiveStackingManager(
             else if (path.isXisf()) path.xisf()
             else return this
 
-            val hdu = image.use { it.firstOrNull { it is ImageHdu } } ?: return this
+            val hdu = image.use { it.firstOrNull { h -> h is ImageHdu } } ?: return this
             val header = hdu.header
             val temperature = header.temperature
             val binX = header.binX
diff --git a/api/src/main/kotlin/nebulosa/api/cameras/CameraSerializer.kt b/api/src/main/kotlin/nebulosa/api/cameras/CameraSerializer.kt
index f7aa10c9a..4205c0749 100644
--- a/api/src/main/kotlin/nebulosa/api/cameras/CameraSerializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/cameras/CameraSerializer.kt
@@ -2,13 +2,16 @@ package nebulosa.api.cameras
 
 import com.fasterxml.jackson.core.JsonGenerator
 import nebulosa.api.devices.DeviceSerializer
+import nebulosa.api.inject.Named
 import nebulosa.indi.device.camera.Camera
 import nebulosa.indi.device.camera.GuideHead
-import org.springframework.stereotype.Component
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.inject
 import java.nio.file.Path
 
-@Component
-class CameraSerializer(private val capturesPath: Path) : DeviceSerializer<Camera>(Camera::class.java) {
+class CameraSerializer : DeviceSerializer<Camera>(Camera::class.java), KoinComponent {
+
+    private val capturesDir by inject<Path>(Named.capturesDir)
 
     override fun JsonGenerator.serialize(value: Camera) {
         writeBooleanField("exposuring", value.exposuring)
@@ -22,10 +25,10 @@ class CameraSerializer(private val capturesPath: Path) : DeviceSerializer<Camera
         writeNumberField("cfaOffsetX", value.cfaOffsetX)
         writeNumberField("cfaOffsetY", value.cfaOffsetY)
         writeStringField("cfaType", value.cfaType.name)
-        writeNumberField("exposureMin", value.exposureMin.toNanos() / 1000L)
-        writeNumberField("exposureMax", value.exposureMax.toNanos() / 1000L)
+        writeNumberField("exposureMin", value.exposureMin)
+        writeNumberField("exposureMax", value.exposureMax)
         writeStringField("exposureState", value.exposureState.name)
-        writeNumberField("exposureTime", value.exposureTime.toNanos() / 1000L)
+        writeNumberField("exposureTime", value.exposureTime)
         writeBooleanField("hasCooler", value.hasCooler)
         writeBooleanField("canSetTemperature", value.canSetTemperature)
         writeBooleanField("canSubFrame", value.canSubFrame)
@@ -59,7 +62,7 @@ class CameraSerializer(private val capturesPath: Path) : DeviceSerializer<Camera
         writeBooleanField("pulseGuiding", value.pulseGuiding)
         writeBooleanField("hasThermometer", value.hasThermometer)
         writeNumberField("temperature", value.temperature)
-        writeObjectField("capturesPath", Path.of("$capturesPath", value.name))
+        writeObjectField("capturesPath", Path.of("$capturesDir", value.name))
 
         if (value is GuideHead) {
             writeMainOrGuideHead(value.main, "main")
diff --git a/api/src/main/kotlin/nebulosa/api/cameras/CameraService.kt b/api/src/main/kotlin/nebulosa/api/cameras/CameraService.kt
index 7f9936cc3..34f407efb 100644
--- a/api/src/main/kotlin/nebulosa/api/cameras/CameraService.kt
+++ b/api/src/main/kotlin/nebulosa/api/cameras/CameraService.kt
@@ -6,12 +6,10 @@ import nebulosa.indi.device.filterwheel.FilterWheel
 import nebulosa.indi.device.focuser.Focuser
 import nebulosa.indi.device.mount.Mount
 import nebulosa.indi.device.rotator.Rotator
-import org.springframework.stereotype.Service
 import java.nio.file.Path
 import kotlin.io.path.exists
 import kotlin.io.path.isDirectory
 
-@Service
 class CameraService(
     private val capturesPath: Path,
     private val cameraCaptureExecutor: CameraCaptureExecutor,
diff --git a/api/src/main/kotlin/nebulosa/api/cameras/CameraStartCaptureRequest.kt b/api/src/main/kotlin/nebulosa/api/cameras/CameraStartCaptureRequest.kt
index 484fa9ef5..ee5acacc6 100644
--- a/api/src/main/kotlin/nebulosa/api/cameras/CameraStartCaptureRequest.kt
+++ b/api/src/main/kotlin/nebulosa/api/cameras/CameraStartCaptureRequest.kt
@@ -1,43 +1,38 @@
 package nebulosa.api.cameras
 
-import jakarta.validation.Valid
-import jakarta.validation.constraints.Positive
-import jakarta.validation.constraints.PositiveOrZero
+import nebulosa.api.beans.converters.time.DurationUnit
 import nebulosa.api.guiding.DitherAfterExposureRequest
+import nebulosa.api.javalin.*
 import nebulosa.api.livestacker.LiveStackingRequest
 import nebulosa.api.stacker.StackerGroupType
 import nebulosa.indi.device.camera.FrameType
-import org.hibernate.validator.constraints.Range
-import org.hibernate.validator.constraints.time.DurationMax
-import org.hibernate.validator.constraints.time.DurationMin
-import org.springframework.boot.convert.DurationUnit
 import java.nio.file.Path
 import java.time.Duration
 import java.time.temporal.ChronoUnit
+import java.util.concurrent.TimeUnit
 
 data class CameraStartCaptureRequest(
     @JvmField val enabled: Boolean = true,
     // Capture.
-    @field:DurationMin(nanos = 1000L) @field:DurationMax(minutes = 60L) @JvmField val exposureTime: Duration = Duration.ZERO,
-    @field:Range(min = 0L, max = 1000L) @JvmField val exposureAmount: Int = 1, // 0 = looping
-    @field:DurationUnit(ChronoUnit.SECONDS) @field:DurationMin(nanos = 0L) @field:DurationMax(seconds = 60L)
-    @JvmField val exposureDelay: Duration = Duration.ZERO,
-    @field:PositiveOrZero @JvmField val x: Int = 0,
-    @field:PositiveOrZero @JvmField val y: Int = 0,
-    @field:PositiveOrZero @JvmField val width: Int = 0,
-    @field:PositiveOrZero @JvmField val height: Int = 0,
+    @JvmField val exposureTime: Duration = Duration.ZERO,
+    @JvmField val exposureAmount: Int = 1, // 0 = looping
+    @field:DurationUnit(ChronoUnit.SECONDS) @JvmField val exposureDelay: Duration = Duration.ZERO,
+    @JvmField val x: Int = 0,
+    @JvmField val y: Int = 0,
+    @JvmField val width: Int = 0,
+    @JvmField val height: Int = 0,
     @JvmField val frameFormat: String? = null,
     @JvmField val frameType: FrameType = FrameType.LIGHT,
-    @field:Positive @JvmField val binX: Int = 1,
-    @field:Positive @JvmField val binY: Int = 1,
-    @field:PositiveOrZero @JvmField val gain: Int = 0,
-    @field:PositiveOrZero @JvmField val offset: Int = 0,
+    @JvmField val binX: Int = 1,
+    @JvmField val binY: Int = 1,
+    @JvmField val gain: Int = 0,
+    @JvmField val offset: Int = 0,
     @JvmField val autoSave: Boolean = false,
     @JvmField val savePath: Path? = null,
     @JvmField val autoSubFolderMode: AutoSubFolderMode = AutoSubFolderMode.OFF,
     @JvmField val calibrationGroup: String? = null,
     // Dithering.
-    @field:Valid @JvmField val dither: DitherAfterExposureRequest = DitherAfterExposureRequest.DISABLED,
+    @JvmField val dither: DitherAfterExposureRequest = DitherAfterExposureRequest.DISABLED,
     // Stacking.
     @JvmField val liveStacking: LiveStackingRequest = LiveStackingRequest.DISABLED,
     @JvmField val stackerGroupType: StackerGroupType = StackerGroupType.MONO,
@@ -48,13 +43,30 @@ data class CameraStartCaptureRequest(
     @JvmField val focusOffset: Int = 0,
     // Others.
     @JvmField val namingFormat: CameraCaptureNamingFormat = CameraCaptureNamingFormat.DEFAULT,
-) {
+) : Validatable {
 
     inline val isLoop
         get() = exposureAmount <= 0
 
+    override fun validate() {
+        exposureTime.min(1L, TimeUnit.MICROSECONDS).max(1L, TimeUnit.HOURS)
+        exposureAmount.range(0, MAX_EXPOSURE_AMOUNT)
+        exposureDelay.positiveOrZero().max(1L, TimeUnit.MINUTES)
+        x.positiveOrZero()
+        y.positiveOrZero()
+        width.positiveOrZero()
+        height.positiveOrZero()
+        binX.positive()
+        binY.positive()
+        gain.positiveOrZero()
+        offset.positiveOrZero()
+        dither.validate()
+    }
+
     companion object {
 
+        const val MAX_EXPOSURE_AMOUNT = 10000
+
         @JvmStatic val EMPTY = CameraStartCaptureRequest()
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/confirmation/ConfirmationController.kt b/api/src/main/kotlin/nebulosa/api/confirmation/ConfirmationController.kt
index 8a27118a2..2c7d55389 100644
--- a/api/src/main/kotlin/nebulosa/api/confirmation/ConfirmationController.kt
+++ b/api/src/main/kotlin/nebulosa/api/confirmation/ConfirmationController.kt
@@ -1,13 +1,22 @@
 package nebulosa.api.confirmation
 
-import org.springframework.web.bind.annotation.*
+import io.javalin.Javalin
+import io.javalin.http.Context
+import io.javalin.http.pathParamAsClass
+import nebulosa.api.javalin.notNull
 
-@RestController
-@RequestMapping("confirmation")
-class ConfirmationController(private val confirmationService: ConfirmationService) {
+class ConfirmationController(
+    app: Javalin,
+    private val confirmationService: ConfirmationService
+) {
 
-    @PutMapping("{idempotencyKey}")
-    fun confirm(@PathVariable idempotencyKey: String, @RequestParam accepted: Boolean) {
+    init {
+        app.put("confirmation/{idempotencyKey}", ::confirm)
+    }
+
+    private fun confirm(ctx: Context) {
+        val idempotencyKey = ctx.pathParamAsClass<String>("idempotencyKey").get()
+        val accepted = ctx.queryParam("accepted").notNull().toBoolean()
         confirmationService.confirm(idempotencyKey, accepted)
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/confirmation/ConfirmationService.kt b/api/src/main/kotlin/nebulosa/api/confirmation/ConfirmationService.kt
index 14d395e60..47708dfde 100644
--- a/api/src/main/kotlin/nebulosa/api/confirmation/ConfirmationService.kt
+++ b/api/src/main/kotlin/nebulosa/api/confirmation/ConfirmationService.kt
@@ -2,9 +2,7 @@ package nebulosa.api.confirmation
 
 import nebulosa.api.message.MessageService
 import nebulosa.log.loggerFor
-import org.springframework.stereotype.Service
 
-@Service
 class ConfirmationService(private val messageService: MessageService) {
 
     private val confirmations = HashMap<String, ConfirmationLatch>()
diff --git a/api/src/main/kotlin/nebulosa/api/connection/ConnectionController.kt b/api/src/main/kotlin/nebulosa/api/connection/ConnectionController.kt
index 0bd82df5a..94c81725b 100644
--- a/api/src/main/kotlin/nebulosa/api/connection/ConnectionController.kt
+++ b/api/src/main/kotlin/nebulosa/api/connection/ConnectionController.kt
@@ -1,37 +1,42 @@
 package nebulosa.api.connection
 
-import jakarta.validation.Valid
-import jakarta.validation.constraints.NotBlank
-import org.hibernate.validator.constraints.Range
-import org.springframework.validation.annotation.Validated
-import org.springframework.web.bind.annotation.*
-
-@Validated
-@RestController
-@RequestMapping("connection")
+import io.javalin.Javalin
+import io.javalin.http.Context
+import nebulosa.api.javalin.notBlank
+import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.range
+
 class ConnectionController(
+    app: Javalin,
     private val connectionService: ConnectionService,
 ) {
 
-    @PutMapping
-    fun connect(
-        @RequestParam @Valid @NotBlank host: String,
-        @RequestParam @Valid @Range(min = 1, max = 65535) port: Int,
-        @RequestParam(required = false, defaultValue = "INDI") type: ConnectionType,
-    ) = connectionService.connect(host, port, type)
+    init {
+        app.get("connection", ::statuses)
+        app.get("connection/{id}", ::status)
+        app.put("connection", ::connect)
+        app.delete("connection/{id}", ::disconnect)
+    }
+
+    private fun connect(ctx: Context) {
+        val host = ctx.queryParam("host").notNull().notBlank()
+        val port = ctx.queryParam("port").notNull().toInt().range(1, 65535)
+        val type = ctx.queryParam("type").notNull().let(ConnectionType::valueOf)
+
+        connectionService.connect(host, port, type)
+    }
 
-    @DeleteMapping("{id}")
-    fun disconnect(@PathVariable id: String) {
+    private fun disconnect(ctx: Context) {
+        val id = ctx.pathParam("id")
         connectionService.disconnect(id)
     }
 
-    @GetMapping
-    fun connectionStatuses(): List<ConnectionStatus> {
-        return connectionService.connectionStatuses()
+    private fun statuses(ctx: Context) {
+        ctx.json(connectionService.connectionStatuses())
     }
 
-    @GetMapping("{id}")
-    fun connectionStatus(@PathVariable id: String): ConnectionStatus? {
-        return connectionService.connectionStatus(id)
+    private fun status(ctx: Context) {
+        val id = ctx.pathParam("id")
+        connectionService.connectionStatus(id)?.also(ctx::json)
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/connection/ConnectionEventHub.kt b/api/src/main/kotlin/nebulosa/api/connection/ConnectionEventHub.kt
index 238f10b78..a15f0c2ec 100644
--- a/api/src/main/kotlin/nebulosa/api/connection/ConnectionEventHub.kt
+++ b/api/src/main/kotlin/nebulosa/api/connection/ConnectionEventHub.kt
@@ -19,9 +19,7 @@ import nebulosa.indi.device.guider.GuideOutput
 import nebulosa.indi.device.lightbox.LightBox
 import nebulosa.indi.device.mount.Mount
 import nebulosa.indi.device.rotator.Rotator
-import org.springframework.stereotype.Component
 
-@Component
 class ConnectionEventHub(
     private val cameraEventHub: CameraEventHub,
     private val mountEventHub: MountEventHub,
diff --git a/api/src/main/kotlin/nebulosa/api/connection/ConnectionService.kt b/api/src/main/kotlin/nebulosa/api/connection/ConnectionService.kt
index 7087e93aa..b5f9e0afc 100644
--- a/api/src/main/kotlin/nebulosa/api/connection/ConnectionService.kt
+++ b/api/src/main/kotlin/nebulosa/api/connection/ConnectionService.kt
@@ -1,10 +1,10 @@
 package nebulosa.api.connection
 
+import io.javalin.http.InternalServerErrorResponse
 import nebulosa.alpaca.indi.client.AlpacaClient
 import nebulosa.api.message.MessageService
 import nebulosa.indi.client.INDIClient
 import nebulosa.indi.client.connection.INDISocketConnection
-import nebulosa.indi.device.Device
 import nebulosa.indi.device.DeviceEventHandler
 import nebulosa.indi.device.INDIDeviceProvider
 import nebulosa.indi.device.camera.Camera
@@ -21,14 +21,12 @@ import nebulosa.log.error
 import nebulosa.log.loggerFor
 import okhttp3.OkHttpClient
 import org.greenrobot.eventbus.EventBus
-import org.springframework.stereotype.Service
-import org.springframework.web.server.ServerErrorException
+import kotlin.collections.set
 
-@Service
 class ConnectionService(
     private val eventBus: EventBus,
-    private val connectionEventHub: ConnectionEventHub,
     private val alpacaHttpClient: OkHttpClient,
+    private val connectionEventHub: ConnectionEventHub,
     private val messageService: MessageService,
 ) : AutoCloseable {
 
@@ -82,8 +80,7 @@ class ConnectionService(
             return provider.id
         } catch (e: Throwable) {
             LOG.error(e)
-
-            throw ServerErrorException("Connection Failed", e)
+            throw InternalServerErrorResponse("Connection Failed")
         }
     }
 
@@ -268,18 +265,16 @@ class ConnectionService(
         return providers.firstNotNullOfOrNull { it.value.thermometer(name) }
     }
 
-    fun device(name: String): Device? {
-        return camera(name)
-            ?: mount(name)
-            ?: focuser(name)
-            ?: wheel(name)
-            ?: rotator(name)
-            ?: guideOutput(name)
-            ?: lightBox(name)
-            ?: dustCap(name)
-            ?: gps(name)
-            ?: thermometer(name)
-    }
+    fun device(name: String) = camera(name)
+        ?: mount(name)
+        ?: focuser(name)
+        ?: wheel(name)
+        ?: rotator(name)
+        ?: guideOutput(name)
+        ?: lightBox(name)
+        ?: dustCap(name)
+        ?: gps(name)
+        ?: thermometer(name)
 
     companion object {
 
diff --git a/api/src/main/kotlin/nebulosa/api/dustcap/DustCapController.kt b/api/src/main/kotlin/nebulosa/api/dustcap/DustCapController.kt
index 67f4f40a0..80656d77d 100644
--- a/api/src/main/kotlin/nebulosa/api/dustcap/DustCapController.kt
+++ b/api/src/main/kotlin/nebulosa/api/dustcap/DustCapController.kt
@@ -1,51 +1,61 @@
 package nebulosa.api.dustcap
 
+import io.javalin.Javalin
+import io.javalin.http.Context
 import nebulosa.api.connection.ConnectionService
-import nebulosa.indi.device.dustcap.DustCap
-import org.springframework.web.bind.annotation.GetMapping
-import org.springframework.web.bind.annotation.PutMapping
-import org.springframework.web.bind.annotation.RequestMapping
-import org.springframework.web.bind.annotation.RestController
-
-@RestController
-@RequestMapping("dust-caps")
+
 class DustCapController(
+    app: Javalin,
     private val connectionService: ConnectionService,
     private val dustCapService: DustCapService,
 ) {
 
-    @GetMapping
-    fun dustCaps(): List<DustCap> {
-        return connectionService.dustCaps().sorted()
+    init {
+        app.get("dust-caps", ::dustCaps)
+        app.get("dust-caps/{id}", ::dustCap)
+        app.put("dust-caps/{id}/connect", ::connect)
+        app.put("dust-caps/{id}/disconnect", ::disconnect)
+        app.put("dust-caps/{id}/park", ::park)
+        app.put("dust-caps/{id}/unpark", ::unpark)
+        app.put("dust-caps/{id}/listen", ::listen)
+    }
+
+    private fun dustCaps(ctx: Context) {
+        ctx.json(connectionService.dustCaps().sorted())
     }
 
-    @GetMapping("{dustCap}")
-    fun dustCap(dustCap: DustCap): DustCap {
-        return dustCap
+    private fun dustCap(ctx: Context) {
+        val id = ctx.pathParam("id")
+        connectionService.dustCap(id)?.also(ctx::json)
     }
 
-    @PutMapping("{dustCap}/connect")
-    fun connect(dustCap: DustCap) {
+    private fun connect(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val dustCap = connectionService.dustCap(id) ?: return
         dustCapService.connect(dustCap)
     }
 
-    @PutMapping("{dustCap}/disconnect")
-    fun disconnect(dustCap: DustCap) {
+    private fun disconnect(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val dustCap = connectionService.dustCap(id) ?: return
         dustCapService.disconnect(dustCap)
     }
 
-    @PutMapping("{dustCap}/park")
-    fun park(dustCap: DustCap) {
+    private fun park(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val dustCap = connectionService.dustCap(id) ?: return
         dustCapService.park(dustCap)
     }
 
-    @PutMapping("{dustCap}/unpark")
-    fun unpark(dustCap: DustCap) {
+    private fun unpark(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val dustCap = connectionService.dustCap(id) ?: return
         dustCapService.unpark(dustCap)
     }
 
-    @PutMapping("{dustCap}/listen")
-    fun listen(dustCap: DustCap) {
+    private fun listen(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val dustCap = connectionService.dustCap(id) ?: return
         dustCapService.listen(dustCap)
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/dustcap/DustCapDeserializer.kt b/api/src/main/kotlin/nebulosa/api/dustcap/DustCapDeserializer.kt
index c6f2a0016..6854acd50 100644
--- a/api/src/main/kotlin/nebulosa/api/dustcap/DustCapDeserializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/dustcap/DustCapDeserializer.kt
@@ -3,14 +3,10 @@ package nebulosa.api.dustcap
 import nebulosa.api.connection.ConnectionService
 import nebulosa.api.devices.DeviceDeserializer
 import nebulosa.indi.device.dustcap.DustCap
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.context.annotation.Lazy
-import org.springframework.stereotype.Component
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.get
 
-@Component
-class DustCapDeserializer : DeviceDeserializer<DustCap>(DustCap::class.java) {
+class DustCapDeserializer : DeviceDeserializer<DustCap>(DustCap::class.java), KoinComponent {
 
-    @Autowired @Lazy private lateinit var connectionService: ConnectionService
-
-    override fun deviceFor(name: String) = connectionService.dustCap(name)
+    override fun deviceFor(name: String) = get<ConnectionService>().dustCap(name)
 }
diff --git a/api/src/main/kotlin/nebulosa/api/dustcap/DustCapEventHub.kt b/api/src/main/kotlin/nebulosa/api/dustcap/DustCapEventHub.kt
index 53328e7ac..da8ee452e 100644
--- a/api/src/main/kotlin/nebulosa/api/dustcap/DustCapEventHub.kt
+++ b/api/src/main/kotlin/nebulosa/api/dustcap/DustCapEventHub.kt
@@ -1,6 +1,5 @@
 package nebulosa.api.dustcap
 
-import nebulosa.api.beans.annotations.Subscriber
 import nebulosa.api.devices.DeviceEventHub
 import nebulosa.api.message.MessageService
 import nebulosa.indi.device.DeviceType
@@ -9,16 +8,19 @@ import nebulosa.indi.device.dustcap.DustCap
 import nebulosa.indi.device.dustcap.DustCapAttached
 import nebulosa.indi.device.dustcap.DustCapDetached
 import nebulosa.indi.device.dustcap.DustCapEvent
+import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode
-import org.springframework.stereotype.Component
 
-@Component
-@Subscriber
 class DustCapEventHub(
     private val messageService: MessageService,
+    eventBus: EventBus,
 ) : DeviceEventHub<DustCap, DustCapEvent>(DeviceType.DUST_CAP), DustCapEventAware {
 
+    init {
+        eventBus.register(this)
+    }
+
     @Subscribe(threadMode = ThreadMode.ASYNC)
     override fun handleDustCapEvent(event: DustCapEvent) {
         if (event.device.type == DeviceType.DUST_CAP) {
diff --git a/api/src/main/kotlin/nebulosa/api/dustcap/DustCapSerializer.kt b/api/src/main/kotlin/nebulosa/api/dustcap/DustCapSerializer.kt
index 82b834592..e65f35ebd 100644
--- a/api/src/main/kotlin/nebulosa/api/dustcap/DustCapSerializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/dustcap/DustCapSerializer.kt
@@ -3,9 +3,7 @@ package nebulosa.api.dustcap
 import com.fasterxml.jackson.core.JsonGenerator
 import nebulosa.api.devices.DeviceSerializer
 import nebulosa.indi.device.dustcap.DustCap
-import org.springframework.stereotype.Component
 
-@Component
 class DustCapSerializer : DeviceSerializer<DustCap>(DustCap::class.java) {
 
     override fun JsonGenerator.serialize(value: DustCap) {
diff --git a/api/src/main/kotlin/nebulosa/api/dustcap/DustCapService.kt b/api/src/main/kotlin/nebulosa/api/dustcap/DustCapService.kt
index 3883fca12..b014baa78 100644
--- a/api/src/main/kotlin/nebulosa/api/dustcap/DustCapService.kt
+++ b/api/src/main/kotlin/nebulosa/api/dustcap/DustCapService.kt
@@ -1,9 +1,7 @@
 package nebulosa.api.dustcap
 
 import nebulosa.indi.device.dustcap.DustCap
-import org.springframework.stereotype.Service
 
-@Service
 class DustCapService(private val dustCapEventHub: DustCapEventHub) {
 
     fun connect(dustCap: DustCap) {
diff --git a/api/src/main/kotlin/nebulosa/api/focusers/AbstractFocuserMoveTask.kt b/api/src/main/kotlin/nebulosa/api/focusers/AbstractFocuserMoveTask.kt
index e130bb6c6..b4277778e 100644
--- a/api/src/main/kotlin/nebulosa/api/focusers/AbstractFocuserMoveTask.kt
+++ b/api/src/main/kotlin/nebulosa/api/focusers/AbstractFocuserMoveTask.kt
@@ -1,16 +1,18 @@
 package nebulosa.api.focusers
 
-import nebulosa.common.concurrency.cancel.CancellationListener
-import nebulosa.common.concurrency.cancel.CancellationSource
-import nebulosa.common.concurrency.cancel.CancellationToken
-import nebulosa.common.concurrency.latch.CountUpDownLatch
 import nebulosa.indi.device.focuser.FocuserEvent
 import nebulosa.indi.device.focuser.FocuserMoveFailed
 import nebulosa.indi.device.focuser.FocuserMovingChanged
 import nebulosa.indi.device.focuser.FocuserPositionChanged
+import nebulosa.job.manager.Job
 import nebulosa.log.loggerFor
+import nebulosa.util.concurrency.cancellation.CancellationListener
+import nebulosa.util.concurrency.cancellation.CancellationSource
+import nebulosa.util.concurrency.latch.CountUpDownLatch
 
-abstract class AbstractFocuserMoveTask : FocuserMoveTask, CancellationListener {
+sealed class AbstractFocuserMoveTask : FocuserTask, CancellationListener {
+
+    abstract val job: Job
 
     @JvmField protected val latch = CountUpDownLatch()
 
@@ -19,8 +21,8 @@ abstract class AbstractFocuserMoveTask : FocuserMoveTask, CancellationListener {
     override fun handleFocuserEvent(event: FocuserEvent) {
         if (event.device === focuser) {
             when (event) {
-                is FocuserMovingChanged -> if (event.device.moving) moving = true else latch.reset()
-                is FocuserPositionChanged -> if (moving && !event.device.moving) latch.reset()
+                is FocuserMovingChanged -> if (event.device.moving) moving = true else if (moving) latch.reset()
+                // is FocuserPositionChanged -> if (moving && !event.device.moving) latch.reset()
                 is FocuserMoveFailed -> latch.reset()
             }
         }
@@ -30,19 +32,14 @@ abstract class AbstractFocuserMoveTask : FocuserMoveTask, CancellationListener {
 
     protected abstract fun move()
 
-    override fun execute(cancellationToken: CancellationToken) {
-        if (!cancellationToken.isCancelled && focuser.connected && !focuser.moving && canMove()) {
-            try {
-                cancellationToken.listen(this)
-                LOG.info("Focuser move started. focuser={}", focuser)
-                latch.countUp()
-                move()
-                latch.await()
-            } finally {
-                moving = false
-                cancellationToken.unlisten(this)
-                LOG.info("Focuser move finished. focuser={}", focuser)
-            }
+    override fun run() {
+        if (!job.isCancelled && focuser.connected && !focuser.moving && canMove()) {
+            LOG.debug("Focuser move started. focuser={}", focuser)
+            latch.countUp()
+            move()
+            latch.await()
+            moving = false
+            LOG.debug("Focuser move finished. focuser={}", focuser)
         }
     }
 
diff --git a/api/src/main/kotlin/nebulosa/api/focusers/BacklashCompensationFocuserMoveTask.kt b/api/src/main/kotlin/nebulosa/api/focusers/BacklashCompensationFocuserMoveTask.kt
index 1131b1bd7..95458f042 100644
--- a/api/src/main/kotlin/nebulosa/api/focusers/BacklashCompensationFocuserMoveTask.kt
+++ b/api/src/main/kotlin/nebulosa/api/focusers/BacklashCompensationFocuserMoveTask.kt
@@ -1,20 +1,22 @@
 package nebulosa.api.focusers
 
-import nebulosa.common.concurrency.cancel.CancellationToken
 import nebulosa.indi.device.focuser.Focuser
 import nebulosa.indi.device.focuser.FocuserEvent
+import nebulosa.job.manager.Job
 import nebulosa.log.loggerFor
+import nebulosa.util.concurrency.cancellation.CancellationSource
 
 /**
- * This decorator will wrap an absolute backlash [compensation] model around the [focuser].
+ * This task will wrap an absolute backlash [compensation] model around the [focuser].
  * On each move an absolute backlash compensation value will be applied, if the focuser changes its moving direction
  * The returned position will then accommodate for this backlash and simulating the position without backlash.
  */
 data class BacklashCompensationFocuserMoveTask(
+    @JvmField val job: Job,
     override val focuser: Focuser,
-    @JvmField @Volatile var position: Int,
+    @JvmField var position: Int,
     @JvmField val compensation: BacklashCompensation,
-) : FocuserMoveTask {
+) : FocuserTask {
 
     enum class OvershootDirection {
         NONE,
@@ -25,7 +27,7 @@ data class BacklashCompensationFocuserMoveTask(
     @Volatile private var offset = 0
     @Volatile private var lastDirection = OvershootDirection.NONE
 
-    private val task = FocuserMoveAbsoluteTask(focuser, 0)
+    private val task = FocuserMoveAbsoluteTask(job, focuser, 0)
 
     /**
      * Returns the adjusted position based on the amount of backlash compensation.
@@ -37,8 +39,16 @@ data class BacklashCompensationFocuserMoveTask(
         task.handleFocuserEvent(event)
     }
 
-    override fun execute(cancellationToken: CancellationToken) {
-        if (!cancellationToken.isCancelled && focuser.connected && !focuser.moving) {
+    override fun onCancel(source: CancellationSource) {
+        task.onCancel(source)
+    }
+
+    override fun onPause(paused: Boolean) {
+        task.onPause(paused)
+    }
+
+    override fun run() {
+        if (!job.isCancelled && focuser.connected && !focuser.moving) {
             val startPosition = focuser.position
 
             val newPosition = when (compensation.mode) {
@@ -68,9 +78,12 @@ data class BacklashCompensationFocuserMoveTask(
                         } else if (overshoot > focuser.maxPosition) {
                             LOG.warn("overshooting position is above maximum ${focuser.maxPosition}, skipping overshoot")
                         } else {
-                            LOG.info("overshooting from $startPosition to overshoot position $overshoot using a compensation of $backlashCompensation")
-                            moveFocuser(overshoot, cancellationToken)
-                            LOG.info("moving back to position $position")
+                            LOG.debug(
+                                "overshooting from {} to overshoot position {} using a compensation of {}. Moving back to position {}",
+                                startPosition, overshoot, backlashCompensation, position
+                            )
+
+                            moveFocuser(overshoot)
                         }
                     }
 
@@ -81,31 +94,20 @@ data class BacklashCompensationFocuserMoveTask(
                 }
             }
 
-            LOG.info("moving to position {} using {} backlash compensation", newPosition, compensation.mode)
+            LOG.debug("moving to position {} using {} backlash compensation", newPosition, compensation.mode)
 
-            moveFocuser(newPosition, cancellationToken)
+            moveFocuser(newPosition)
         }
     }
 
-    private fun moveFocuser(position: Int, cancellationToken: CancellationToken) {
+    private fun moveFocuser(position: Int) {
         if (position > 0 && position <= focuser.maxPosition) {
             lastDirection = determineMovingDirection(focuser.position, position)
             task.position = position
-            task.execute(cancellationToken)
+            task.run()
         }
     }
 
-    override fun reset() {
-        task.reset()
-
-        offset = 0
-        lastDirection = OvershootDirection.NONE
-    }
-
-    override fun close() {
-        task.close()
-    }
-
     private fun determineMovingDirection(prevPosition: Int, newPosition: Int): OvershootDirection {
         return if (newPosition > prevPosition) OvershootDirection.OUT
         else if (newPosition < prevPosition) OvershootDirection.IN
@@ -116,10 +118,10 @@ data class BacklashCompensationFocuserMoveTask(
         val direction = determineMovingDirection(lastPosition, newPosition)
 
         return if (direction == OvershootDirection.IN && lastDirection == OvershootDirection.OUT) {
-            LOG.info("Focuser is reversing direction from outwards to inwards")
+            LOG.debug("Focuser is reversing direction from outwards to inwards")
             -compensation.backlashIn
         } else if (direction == OvershootDirection.OUT && lastDirection === OvershootDirection.IN) {
-            LOG.info("Focuser is reversing direction from inwards to outwards")
+            LOG.debug("Focuser is reversing direction from inwards to outwards")
             compensation.backlashOut
         } else {
             0
diff --git a/api/src/main/kotlin/nebulosa/api/focusers/FocuserController.kt b/api/src/main/kotlin/nebulosa/api/focusers/FocuserController.kt
index ee0347d2a..37c5314ff 100644
--- a/api/src/main/kotlin/nebulosa/api/focusers/FocuserController.kt
+++ b/api/src/main/kotlin/nebulosa/api/focusers/FocuserController.kt
@@ -1,77 +1,89 @@
 package nebulosa.api.focusers
 
-import jakarta.validation.Valid
-import jakarta.validation.constraints.PositiveOrZero
+import io.javalin.Javalin
+import io.javalin.http.Context
 import nebulosa.api.connection.ConnectionService
-import nebulosa.indi.device.focuser.Focuser
-import org.springframework.web.bind.annotation.*
+import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.positiveOrZero
 
-@RestController
-@RequestMapping("focusers")
 class FocuserController(
+    app: Javalin,
     private val connectionService: ConnectionService,
     private val focuserService: FocuserService,
 ) {
 
-    @GetMapping
-    fun focusers(): List<Focuser> {
-        return connectionService.focusers().sorted()
+    init {
+        app.get("focusers", ::focusers)
+        app.get("focusers/{id}", ::focuser)
+        app.put("focusers/{id}/connect", ::connect)
+        app.put("focusers/{id}/disconnect", ::disconnect)
+        app.put("focusers/{id}/move-in", ::moveIn)
+        app.put("focusers/{id}/move-out", ::moveOut)
+        app.put("focusers/{id}/move-to", ::moveTo)
+        app.put("focusers/{id}/abort", ::abort)
+        app.put("focusers/{id}/sync", ::sync)
+        app.put("focusers/{id}/listen", ::listen)
     }
 
-    @GetMapping("{focuser}")
-    fun focuser(focuser: Focuser): Focuser {
-        return focuser
+    private fun focusers(ctx: Context) {
+        ctx.json(connectionService.focusers().sorted())
     }
 
-    @PutMapping("{focuser}/connect")
-    fun connect(focuser: Focuser) {
+    private fun focuser(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val focuser = connectionService.focuser(id) ?: return
+        ctx.json(focuser)
+    }
+
+    private fun connect(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val focuser = connectionService.focuser(id) ?: return
         focuserService.connect(focuser)
     }
 
-    @PutMapping("{focuser}/disconnect")
-    fun disconnect(focuser: Focuser) {
+    private fun disconnect(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val focuser = connectionService.focuser(id) ?: return
         focuserService.disconnect(focuser)
     }
 
-    @PutMapping("{focuser}/move-in")
-    fun moveIn(
-        focuser: Focuser,
-        @RequestParam @Valid @PositiveOrZero steps: Int,
-    ) {
+    private fun moveIn(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val focuser = connectionService.focuser(id) ?: return
+        val steps = ctx.queryParam("steps").notNull().toInt().positiveOrZero()
         focuserService.moveIn(focuser, steps)
     }
 
-    @PutMapping("{focuser}/move-out")
-    fun moveOut(
-        focuser: Focuser,
-        @RequestParam @Valid @PositiveOrZero steps: Int,
-    ) {
+    private fun moveOut(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val focuser = connectionService.focuser(id) ?: return
+        val steps = ctx.queryParam("steps").notNull().toInt().positiveOrZero()
         focuserService.moveOut(focuser, steps)
     }
 
-    @PutMapping("{focuser}/move-to")
-    fun moveTo(
-        focuser: Focuser,
-        @RequestParam @Valid @PositiveOrZero steps: Int,
-    ) {
+    private fun moveTo(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val focuser = connectionService.focuser(id) ?: return
+        val steps = ctx.queryParam("steps").notNull().toInt().positiveOrZero()
         focuserService.moveTo(focuser, steps)
     }
 
-    @PutMapping("{focuser}/abort")
-    fun abort(focuser: Focuser) {
+    private fun abort(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val focuser = connectionService.focuser(id) ?: return
         focuserService.abort(focuser)
     }
 
-    @PutMapping("{focuser}/sync")
-    fun sync(
-        focuser: Focuser,
-        @RequestParam @Valid @PositiveOrZero steps: Int,
-    ) {
+    private fun sync(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val focuser = connectionService.focuser(id) ?: return
+        val steps = ctx.queryParam("steps").notNull().toInt().positiveOrZero()
         focuserService.sync(focuser, steps)
     }
 
-    @PutMapping("{focuser}/listen")
-    fun listen(focuser: Focuser) {
+    private fun listen(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val focuser = connectionService.focuser(id) ?: return
         focuserService.listen(focuser)
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/focusers/FocuserDeserializer.kt b/api/src/main/kotlin/nebulosa/api/focusers/FocuserDeserializer.kt
index f73e57f0b..b6bf667fe 100644
--- a/api/src/main/kotlin/nebulosa/api/focusers/FocuserDeserializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/focusers/FocuserDeserializer.kt
@@ -1,16 +1,12 @@
 package nebulosa.api.focusers
 
-import nebulosa.api.devices.DeviceDeserializer
 import nebulosa.api.connection.ConnectionService
+import nebulosa.api.devices.DeviceDeserializer
 import nebulosa.indi.device.focuser.Focuser
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.context.annotation.Lazy
-import org.springframework.stereotype.Component
-
-@Component
-class FocuserDeserializer : DeviceDeserializer<Focuser>(Focuser::class.java) {
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.get
 
-    @Autowired @Lazy private lateinit var connectionService: ConnectionService
+class FocuserDeserializer : DeviceDeserializer<Focuser>(Focuser::class.java), KoinComponent {
 
-    override fun deviceFor(name: String) = connectionService.focuser(name)
+    override fun deviceFor(name: String) = get<ConnectionService>().focuser(name)
 }
diff --git a/api/src/main/kotlin/nebulosa/api/focusers/FocuserEventHub.kt b/api/src/main/kotlin/nebulosa/api/focusers/FocuserEventHub.kt
index 970746b0e..61511c952 100644
--- a/api/src/main/kotlin/nebulosa/api/focusers/FocuserEventHub.kt
+++ b/api/src/main/kotlin/nebulosa/api/focusers/FocuserEventHub.kt
@@ -1,6 +1,5 @@
 package nebulosa.api.focusers
 
-import nebulosa.api.beans.annotations.Subscriber
 import nebulosa.api.devices.DeviceEventHub
 import nebulosa.api.message.MessageService
 import nebulosa.indi.device.DeviceType
@@ -9,23 +8,26 @@ import nebulosa.indi.device.focuser.Focuser
 import nebulosa.indi.device.focuser.FocuserAttached
 import nebulosa.indi.device.focuser.FocuserDetached
 import nebulosa.indi.device.focuser.FocuserEvent
+import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode
-import org.springframework.stereotype.Component
 
-@Component
-@Subscriber
 class FocuserEventHub(
     private val messageService: MessageService,
+    eventBus: EventBus,
 ) : DeviceEventHub<Focuser, FocuserEvent>(DeviceType.FOCUSER), FocuserEventAware {
 
+    init {
+        eventBus.register(this)
+    }
+
     @Subscribe(threadMode = ThreadMode.ASYNC)
     override fun handleFocuserEvent(event: FocuserEvent) {
         if (event.device.type == DeviceType.FOCUSER) {
             when (event) {
-            is PropertyChangedEvent -> onNext(event)
-            is FocuserAttached -> onAttached(event.device)
-            is FocuserDetached -> onDetached(event.device)
+                is PropertyChangedEvent -> onNext(event)
+                is FocuserAttached -> onAttached(event.device)
+                is FocuserDetached -> onDetached(event.device)
             }
         }
     }
diff --git a/api/src/main/kotlin/nebulosa/api/focusers/FocuserMoveAbsoluteTask.kt b/api/src/main/kotlin/nebulosa/api/focusers/FocuserMoveAbsoluteTask.kt
index 85379b053..91692bf03 100644
--- a/api/src/main/kotlin/nebulosa/api/focusers/FocuserMoveAbsoluteTask.kt
+++ b/api/src/main/kotlin/nebulosa/api/focusers/FocuserMoveAbsoluteTask.kt
@@ -1,9 +1,11 @@
 package nebulosa.api.focusers
 
 import nebulosa.indi.device.focuser.Focuser
+import nebulosa.job.manager.Job
 import kotlin.math.abs
 
 data class FocuserMoveAbsoluteTask(
+    override val job: Job,
     override val focuser: Focuser,
     @JvmField @Volatile var position: Int,
 ) : AbstractFocuserMoveTask() {
diff --git a/api/src/main/kotlin/nebulosa/api/focusers/FocuserMoveRelativeTask.kt b/api/src/main/kotlin/nebulosa/api/focusers/FocuserMoveRelativeTask.kt
index ec4671b3a..9d550f1f1 100644
--- a/api/src/main/kotlin/nebulosa/api/focusers/FocuserMoveRelativeTask.kt
+++ b/api/src/main/kotlin/nebulosa/api/focusers/FocuserMoveRelativeTask.kt
@@ -1,9 +1,11 @@
 package nebulosa.api.focusers
 
 import nebulosa.indi.device.focuser.Focuser
+import nebulosa.job.manager.Job
 import kotlin.math.abs
 
 data class FocuserMoveRelativeTask(
+    override val job: Job,
     override val focuser: Focuser,
     @JvmField val offset: Int,
 ) : AbstractFocuserMoveTask() {
diff --git a/api/src/main/kotlin/nebulosa/api/focusers/FocuserSerializer.kt b/api/src/main/kotlin/nebulosa/api/focusers/FocuserSerializer.kt
index 8c3be834b..09ee422d7 100644
--- a/api/src/main/kotlin/nebulosa/api/focusers/FocuserSerializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/focusers/FocuserSerializer.kt
@@ -3,9 +3,7 @@ package nebulosa.api.focusers
 import com.fasterxml.jackson.core.JsonGenerator
 import nebulosa.api.devices.DeviceSerializer
 import nebulosa.indi.device.focuser.Focuser
-import org.springframework.stereotype.Component
 
-@Component
 class FocuserSerializer : DeviceSerializer<Focuser>(Focuser::class.java) {
 
     override fun JsonGenerator.serialize(value: Focuser) {
diff --git a/api/src/main/kotlin/nebulosa/api/focusers/FocuserService.kt b/api/src/main/kotlin/nebulosa/api/focusers/FocuserService.kt
index f0084dfdb..ae440b002 100644
--- a/api/src/main/kotlin/nebulosa/api/focusers/FocuserService.kt
+++ b/api/src/main/kotlin/nebulosa/api/focusers/FocuserService.kt
@@ -1,9 +1,7 @@
 package nebulosa.api.focusers
 
 import nebulosa.indi.device.focuser.Focuser
-import org.springframework.stereotype.Service
 
-@Service
 class FocuserService(private val focuserEventHub: FocuserEventHub) {
 
     fun connect(focuser: Focuser) {
diff --git a/api/src/main/kotlin/nebulosa/api/focusers/FocuserMoveTask.kt b/api/src/main/kotlin/nebulosa/api/focusers/FocuserTask.kt
similarity index 53%
rename from api/src/main/kotlin/nebulosa/api/focusers/FocuserMoveTask.kt
rename to api/src/main/kotlin/nebulosa/api/focusers/FocuserTask.kt
index 729ca77af..d5fcd7804 100644
--- a/api/src/main/kotlin/nebulosa/api/focusers/FocuserMoveTask.kt
+++ b/api/src/main/kotlin/nebulosa/api/focusers/FocuserTask.kt
@@ -1,9 +1,9 @@
 package nebulosa.api.focusers
 
-import nebulosa.api.tasks.Task
 import nebulosa.indi.device.focuser.Focuser
+import nebulosa.job.manager.Task
 
-interface FocuserMoveTask : Task, FocuserEventAware {
+sealed interface FocuserTask : Task, FocuserEventAware {
 
     val focuser: Focuser
 }
diff --git a/api/src/main/kotlin/nebulosa/api/framing/FramingController.kt b/api/src/main/kotlin/nebulosa/api/framing/FramingController.kt
index b9dd4ac30..b203d1c41 100644
--- a/api/src/main/kotlin/nebulosa/api/framing/FramingController.kt
+++ b/api/src/main/kotlin/nebulosa/api/framing/FramingController.kt
@@ -1,33 +1,40 @@
 package nebulosa.api.framing
 
-import jakarta.validation.Valid
-import jakarta.validation.constraints.Max
-import jakarta.validation.constraints.NotBlank
-import jakarta.validation.constraints.Positive
+import io.javalin.Javalin
+import io.javalin.http.Context
 import nebulosa.api.image.ImageService
+import nebulosa.api.javalin.notBlank
+import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.range
 import nebulosa.math.deg
 import nebulosa.math.hours
-import org.hibernate.validator.constraints.Range
-import org.springframework.web.bind.annotation.*
 
-@RestController
-@RequestMapping("framing")
 class FramingController(
+    app: Javalin,
     private val imageService: ImageService,
     private val framingService: FramingService,
 ) {
 
-    @GetMapping("hips-surveys")
-    fun hipsSurveys() = framingService.availableHipsSurveys
+    init {
+        app.get("framing/hips-surveys", ::hipsSurveys)
+        app.put("framing", ::frame)
+    }
 
-    @PutMapping
-    fun frame(
-        @RequestParam @Valid @NotBlank rightAscension: String,
-        @RequestParam @Valid @NotBlank declination: String,
-        @RequestParam(required = false, defaultValue = "1280") @Valid @Range(min = 1, max = 7680) width: Int,
-        @RequestParam(required = false, defaultValue = "720") @Valid @Range(min = 1, max = 4320) height: Int,
-        @RequestParam(required = false, defaultValue = "1.0") @Valid @Positive @Max(90) fov: Double,
-        @RequestParam(required = false, defaultValue = "0.0") rotation: Double,
-        @RequestParam(required = false, defaultValue = "CDS/P/DSS2/COLOR") hipsSurvey: String,
-    ) = imageService.frame(rightAscension.hours, declination.deg, width, height, fov.deg, rotation.deg, hipsSurvey)
+    private fun hipsSurveys(ctx: Context) {
+        ctx.json(framingService.availableHipsSurveys)
+    }
+
+    private fun frame(ctx: Context) {
+        val rightAscension = ctx.queryParam("rightAscension").notNull().notBlank()
+        val declination = ctx.queryParam("declination").notNull().notBlank()
+        val width = ctx.queryParam("width")?.toInt()?.range(1, 7680) ?: 1280
+        val height = ctx.queryParam("height")?.toInt()?.range(1, 4320) ?: 720
+        val fov = ctx.queryParam("fov")?.toDouble()?.range(0.0, 90.0) ?: 1.0
+        val rotation = ctx.queryParam("rotation")?.toDouble() ?: 0.0
+        val hipsSurvey = ctx.queryParam("hipsSurvey") ?: "CDS/P/DSS2/COLOR"
+
+        imageService
+            .frame(rightAscension.hours, declination.deg, width, height, fov.deg, rotation.deg, hipsSurvey)
+            .also(ctx::json)
+    }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/framing/FramingService.kt b/api/src/main/kotlin/nebulosa/api/framing/FramingService.kt
index 0c2b9eb10..56547dff0 100644
--- a/api/src/main/kotlin/nebulosa/api/framing/FramingService.kt
+++ b/api/src/main/kotlin/nebulosa/api/framing/FramingService.kt
@@ -6,27 +6,25 @@ import nebulosa.hips2fits.FormatOutputType
 import nebulosa.hips2fits.Hips2FitsService
 import nebulosa.hips2fits.HipsSurvey
 import nebulosa.image.Image
+import nebulosa.io.resource
 import nebulosa.io.transferAndCloseOutput
 import nebulosa.log.loggerFor
 import nebulosa.math.Angle
 import nebulosa.platesolver.PlateSolution
-import org.springframework.beans.factory.annotation.Value
-import org.springframework.core.io.Resource
-import org.springframework.stereotype.Service
 import java.nio.file.Files
 import java.nio.file.Path
 import kotlin.io.path.outputStream
 
-@Service
 class FramingService(
     private val hips2FitsService: Hips2FitsService,
     private val objectMapper: ObjectMapper,
 ) {
 
-    @Value("classpath:HIPS_SURVEYS.json")
-    private lateinit var hipsSurveysResource: Resource
-
-    val availableHipsSurveys by lazy { hipsSurveysResource.inputStream.use { objectMapper.readValue(it, Array<HipsSurvey>::class.java) }.sorted() }
+    val availableHipsSurveys by lazy {
+        resource("HIPS_SURVEYS.json")!!
+            .use { objectMapper.readValue(it, Array<HipsSurvey>::class.java) }
+            .sorted()
+    }
 
     @Synchronized
     fun frame(
diff --git a/api/src/main/kotlin/nebulosa/api/guiding/DitherAfterExposureDithered.kt b/api/src/main/kotlin/nebulosa/api/guiding/DitherAfterExposureDithered.kt
new file mode 100644
index 000000000..a50318272
--- /dev/null
+++ b/api/src/main/kotlin/nebulosa/api/guiding/DitherAfterExposureDithered.kt
@@ -0,0 +1,10 @@
+package nebulosa.api.guiding
+
+import nebulosa.job.manager.Job
+
+data class DitherAfterExposureDithered(
+    override val job: Job,
+    override val task: DitherAfterExposureTask,
+    override val dx: Double,
+    override val dy: Double,
+) : DitherAfterExposureEvent
diff --git a/api/src/main/kotlin/nebulosa/api/guiding/DitherAfterExposureEvent.kt b/api/src/main/kotlin/nebulosa/api/guiding/DitherAfterExposureEvent.kt
index 34fbd6056..7633362e3 100644
--- a/api/src/main/kotlin/nebulosa/api/guiding/DitherAfterExposureEvent.kt
+++ b/api/src/main/kotlin/nebulosa/api/guiding/DitherAfterExposureEvent.kt
@@ -1,10 +1,12 @@
 package nebulosa.api.guiding
 
-import java.time.Duration
-
-data class DitherAfterExposureEvent(
-    @JvmField val task: DitherAfterExposureTask,
-    @JvmField val state: DitherAfterExposureState = DitherAfterExposureState.IDLE,
-    @JvmField val dx: Double = 0.0, @JvmField val dy: Double = 0.0,
-    @JvmField val elapsedTime: Duration = Duration.ZERO,
-)
+import nebulosa.job.manager.TaskEvent
+
+sealed interface DitherAfterExposureEvent : TaskEvent {
+
+    override val task: DitherAfterExposureTask
+
+    val dx: Double
+
+    val dy: Double
+}
diff --git a/api/src/main/kotlin/nebulosa/api/guiding/DitherAfterExposureRequest.kt b/api/src/main/kotlin/nebulosa/api/guiding/DitherAfterExposureRequest.kt
index c5a0b4dfe..8193feb77 100644
--- a/api/src/main/kotlin/nebulosa/api/guiding/DitherAfterExposureRequest.kt
+++ b/api/src/main/kotlin/nebulosa/api/guiding/DitherAfterExposureRequest.kt
@@ -1,13 +1,19 @@
 package nebulosa.api.guiding
 
-import jakarta.validation.constraints.Positive
+import nebulosa.api.javalin.Validatable
+import nebulosa.api.javalin.positive
 
 data class DitherAfterExposureRequest(
-    val enabled: Boolean = true,
-    @field:Positive val amount: Double = 1.5,
-    val raOnly: Boolean = false,
-    @field:Positive val afterExposures: Int = 1,
-) {
+    @JvmField val enabled: Boolean = true,
+    @JvmField val amount: Double = 1.5,
+    @JvmField val raOnly: Boolean = false,
+    @JvmField val afterExposures: Int = 1,
+) : Validatable {
+
+    override fun validate() {
+        amount.positive()
+        afterExposures.positive()
+    }
 
     companion object {
 
diff --git a/api/src/main/kotlin/nebulosa/api/guiding/DitherAfterExposureState.kt b/api/src/main/kotlin/nebulosa/api/guiding/DitherAfterExposureState.kt
deleted file mode 100644
index 8c2eebe21..000000000
--- a/api/src/main/kotlin/nebulosa/api/guiding/DitherAfterExposureState.kt
+++ /dev/null
@@ -1,8 +0,0 @@
-package nebulosa.api.guiding
-
-enum class DitherAfterExposureState {
-    IDLE,
-    STARTED,
-    DITHERED,
-    FINISHED,
-}
diff --git a/api/src/main/kotlin/nebulosa/api/guiding/DitherAfterExposureTask.kt b/api/src/main/kotlin/nebulosa/api/guiding/DitherAfterExposureTask.kt
index 74e58df06..5b30f58f1 100644
--- a/api/src/main/kotlin/nebulosa/api/guiding/DitherAfterExposureTask.kt
+++ b/api/src/main/kotlin/nebulosa/api/guiding/DitherAfterExposureTask.kt
@@ -1,63 +1,44 @@
 package nebulosa.api.guiding
 
-import nebulosa.api.tasks.AbstractTask
-import nebulosa.common.concurrency.cancel.CancellationListener
-import nebulosa.common.concurrency.cancel.CancellationSource
-import nebulosa.common.concurrency.cancel.CancellationToken
-import nebulosa.common.concurrency.latch.CountUpDownLatch
 import nebulosa.guiding.GuideState
 import nebulosa.guiding.Guider
 import nebulosa.guiding.GuiderListener
+import nebulosa.job.manager.Job
+import nebulosa.job.manager.Task
+import nebulosa.log.debug
 import nebulosa.log.loggerFor
-import java.time.Duration
-import kotlin.system.measureTimeMillis
+import nebulosa.util.Resettable
+import nebulosa.util.concurrency.cancellation.CancellationSource
+import nebulosa.util.concurrency.latch.CountUpDownLatch
 
 data class DitherAfterExposureTask(
+    @JvmField val job: Job,
     @JvmField val guider: Guider?,
     @JvmField val request: DitherAfterExposureRequest,
-) : AbstractTask<DitherAfterExposureEvent>(), GuiderListener, CancellationListener {
+) : Task, GuiderListener, Resettable {
 
     private val ditherLatch = CountUpDownLatch()
 
-    @Volatile private var dx = 0.0
-    @Volatile private var dy = 0.0
-    @Volatile private var elapsedTime = Duration.ZERO
-
-    override fun execute(cancellationToken: CancellationToken) {
+    override fun run() {
         if (guider != null && guider.canDither && request.enabled
             && guider.state == GuideState.GUIDING
-            && !cancellationToken.isCancelled
+            && !job.isCancelled
         ) {
-            LOG.info("Dither started. request={}", request)
-
-            try {
-                cancellationToken.listen(this)
-                guider.registerGuiderListener(this)
-                ditherLatch.countUp()
-
-                sendEvent(DitherAfterExposureState.STARTED)
-
-                elapsedTime = Duration.ofMillis(measureTimeMillis {
-                    guider.dither(request.amount, request.raOnly)
-                    ditherLatch.await()
-                })
-            } finally {
-                sendEvent(DitherAfterExposureState.FINISHED)
+            LOG.debug { "Dither started. request=$request" }
 
-                guider.unregisterGuiderListener(this)
-                cancellationToken.unlisten(this)
+            guider.registerGuiderListener(this)
+            ditherLatch.countUp()
+            guider.dither(request.amount, request.raOnly)
+            ditherLatch.await()
+            guider.unregisterGuiderListener(this)
 
-                LOG.info("Dither finished. elapsedTime={}, request={}", elapsedTime, request)
-            }
+            LOG.debug { "Dither finished. request=$request" }
         }
     }
 
     override fun onDithered(dx: Double, dy: Double) {
-        this.dx = dx
-        this.dy = dy
-
-        sendEvent(DitherAfterExposureState.DITHERED)
-        LOG.info("dithered. dx={}, dy={}", dx, dy)
+        job.accept(DitherAfterExposureDithered(job, this, dx, dy))
+        LOG.debug { "dithered. dx=$dx, dy=$dy" }
         ditherLatch.reset()
     }
 
@@ -66,13 +47,7 @@ data class DitherAfterExposureTask(
     }
 
     override fun reset() {
-        dx = 0.0
-        dy = 0.0
-        elapsedTime = Duration.ZERO
-    }
-
-    private fun sendEvent(state: DitherAfterExposureState) {
-        onNext(DitherAfterExposureEvent(this, state, dx, dy, elapsedTime))
+        ditherLatch.reset()
     }
 
     companion object {
diff --git a/api/src/main/kotlin/nebulosa/api/guiding/GuideOutputController.kt b/api/src/main/kotlin/nebulosa/api/guiding/GuideOutputController.kt
index 7e2cc0ca3..5a77bc877 100644
--- a/api/src/main/kotlin/nebulosa/api/guiding/GuideOutputController.kt
+++ b/api/src/main/kotlin/nebulosa/api/guiding/GuideOutputController.kt
@@ -1,51 +1,66 @@
 package nebulosa.api.guiding
 
+import io.javalin.Javalin
+import io.javalin.http.Context
 import nebulosa.api.connection.ConnectionService
+import nebulosa.api.javalin.notBlank
+import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.range
 import nebulosa.guiding.GuideDirection
-import nebulosa.indi.device.guider.GuideOutput
-import org.hibernate.validator.constraints.time.DurationMax
-import org.hibernate.validator.constraints.time.DurationMin
-import org.springframework.web.bind.annotation.*
 import java.time.Duration
 
-@RestController
-@RequestMapping("guide-outputs")
 class GuideOutputController(
+    app: Javalin,
     private val connectionService: ConnectionService,
     private val guideOutputService: GuideOutputService,
 ) {
 
-    @GetMapping
-    fun guideOutputs(): List<GuideOutput> {
-        return connectionService.guideOutputs().sorted()
+    init {
+        app.get("guide-outputs", ::guideOutputs)
+        app.get("guide-outputs/{id}", ::guideOutput)
+        app.put("guide-outputs/{id}/connect", ::connect)
+        app.put("guide-outputs/{id}/disconnect", ::disconnect)
+        app.put("guide-outputs/{id}/pulse", ::pulse)
+        app.put("guide-outputs/{id}/listen", ::listen)
     }
 
-    @GetMapping("{guideOutput}")
-    fun guideOutput(guideOutput: GuideOutput): GuideOutput {
-        return guideOutput
+    private fun guideOutputs(ctx: Context) {
+        ctx.json(connectionService.guideOutputs().sorted())
     }
 
-    @PutMapping("{guideOutput}/connect")
-    fun connect(guideOutput: GuideOutput) {
+    private fun guideOutput(ctx: Context) {
+        val id = ctx.pathParam("id")
+        connectionService.guideOutput(id)?.also(ctx::json)
+    }
+
+    private fun connect(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val guideOutput = connectionService.guideOutput(id) ?: return
         guideOutputService.connect(guideOutput)
     }
 
-    @PutMapping("{guideOutput}/disconnect")
-    fun disconnect(guideOutput: GuideOutput) {
+    private fun disconnect(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val guideOutput = connectionService.guideOutput(id) ?: return
         guideOutputService.disconnect(guideOutput)
     }
 
-    @PutMapping("{guideOutput}/pulse")
-    fun pulse(
-        guideOutput: GuideOutput,
-        @RequestParam direction: GuideDirection,
-        @RequestParam @DurationMin(nanos = 0L) @DurationMax(minutes = 30L) duration: Duration,
-    ) {
+    private fun pulse(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val guideOutput = connectionService.guideOutput(id) ?: return
+        val direction = ctx.queryParam("direction").notNull().notBlank().let(GuideDirection::valueOf)
+        val duration = ctx.queryParam("duration").notNull().toLong().range(0L, 1800000000L).times(1000L).let(Duration::ofNanos)
         guideOutputService.pulse(guideOutput, direction, duration)
     }
 
-    @PutMapping("{guideOutput}/listen")
-    fun listen(guideOutput: GuideOutput) {
+    private fun listen(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val guideOutput = connectionService.guideOutput(id) ?: return
         guideOutputService.listen(guideOutput)
     }
+
+    companion object {
+
+        private val PULSE_DURATION_RANGE = 0L..1800000000L
+    }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/guiding/GuideOutputDeserializer.kt b/api/src/main/kotlin/nebulosa/api/guiding/GuideOutputDeserializer.kt
index fd7e7de62..f38fceb90 100644
--- a/api/src/main/kotlin/nebulosa/api/guiding/GuideOutputDeserializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/guiding/GuideOutputDeserializer.kt
@@ -1,16 +1,12 @@
 package nebulosa.api.guiding
 
-import nebulosa.api.devices.DeviceDeserializer
 import nebulosa.api.connection.ConnectionService
+import nebulosa.api.devices.DeviceDeserializer
 import nebulosa.indi.device.guider.GuideOutput
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.context.annotation.Lazy
-import org.springframework.stereotype.Component
-
-@Component
-class GuideOutputDeserializer : DeviceDeserializer<GuideOutput>(GuideOutput::class.java) {
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.get
 
-    @Autowired @Lazy private lateinit var connectionService: ConnectionService
+class GuideOutputDeserializer : DeviceDeserializer<GuideOutput>(GuideOutput::class.java), KoinComponent {
 
-    override fun deviceFor(name: String) = connectionService.guideOutput(name)
+    override fun deviceFor(name: String) = get<ConnectionService>().guideOutput(name)
 }
diff --git a/api/src/main/kotlin/nebulosa/api/guiding/GuideOutputEventHub.kt b/api/src/main/kotlin/nebulosa/api/guiding/GuideOutputEventHub.kt
index 471c23828..6e636d2fb 100644
--- a/api/src/main/kotlin/nebulosa/api/guiding/GuideOutputEventHub.kt
+++ b/api/src/main/kotlin/nebulosa/api/guiding/GuideOutputEventHub.kt
@@ -1,6 +1,5 @@
 package nebulosa.api.guiding
 
-import nebulosa.api.beans.annotations.Subscriber
 import nebulosa.api.devices.DeviceEventHub
 import nebulosa.api.message.MessageService
 import nebulosa.indi.device.DeviceType
@@ -9,16 +8,19 @@ import nebulosa.indi.device.guider.GuideOutput
 import nebulosa.indi.device.guider.GuideOutputAttached
 import nebulosa.indi.device.guider.GuideOutputDetached
 import nebulosa.indi.device.guider.GuideOutputEvent
+import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode
-import org.springframework.stereotype.Component
 
-@Component
-@Subscriber
 class GuideOutputEventHub(
     private val messageService: MessageService,
+    eventBus: EventBus,
 ) : DeviceEventHub<GuideOutput, GuideOutputEvent>(DeviceType.GUIDE_OUTPUT), GuideOutputEventAware {
 
+    init {
+        eventBus.register(this)
+    }
+
     @Subscribe(threadMode = ThreadMode.ASYNC)
     override fun handleGuideOutputEvent(event: GuideOutputEvent) {
         if (event.device.type == DeviceType.GUIDE_OUTPUT) {
diff --git a/api/src/main/kotlin/nebulosa/api/guiding/GuideOutputSerializer.kt b/api/src/main/kotlin/nebulosa/api/guiding/GuideOutputSerializer.kt
index 7088afd87..b16aeaf14 100644
--- a/api/src/main/kotlin/nebulosa/api/guiding/GuideOutputSerializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/guiding/GuideOutputSerializer.kt
@@ -3,9 +3,7 @@ package nebulosa.api.guiding
 import com.fasterxml.jackson.core.JsonGenerator
 import nebulosa.api.devices.DeviceSerializer
 import nebulosa.indi.device.guider.GuideOutput
-import org.springframework.stereotype.Component
 
-@Component
 class GuideOutputSerializer : DeviceSerializer<GuideOutput>(GuideOutput::class.java) {
 
     override fun JsonGenerator.serialize(value: GuideOutput) {
diff --git a/api/src/main/kotlin/nebulosa/api/guiding/GuideOutputService.kt b/api/src/main/kotlin/nebulosa/api/guiding/GuideOutputService.kt
index b5880d092..ec0f1940e 100644
--- a/api/src/main/kotlin/nebulosa/api/guiding/GuideOutputService.kt
+++ b/api/src/main/kotlin/nebulosa/api/guiding/GuideOutputService.kt
@@ -2,10 +2,8 @@ package nebulosa.api.guiding
 
 import nebulosa.guiding.GuideDirection
 import nebulosa.indi.device.guider.GuideOutput
-import org.springframework.stereotype.Service
 import java.time.Duration
 
-@Service
 class GuideOutputService(private val guideOutputEventHub: GuideOutputEventHub) {
 
     fun connect(guideOutput: GuideOutput) {
diff --git a/api/src/main/kotlin/nebulosa/api/guiding/GuidePulseEvent.kt b/api/src/main/kotlin/nebulosa/api/guiding/GuidePulseEvent.kt
deleted file mode 100644
index c15be48dc..000000000
--- a/api/src/main/kotlin/nebulosa/api/guiding/GuidePulseEvent.kt
+++ /dev/null
@@ -1,9 +0,0 @@
-package nebulosa.api.guiding
-
-import java.time.Duration
-
-data class GuidePulseEvent(
-    @JvmField val task: GuidePulseTask,
-    @JvmField val remainingTime: Duration = Duration.ZERO,
-    @JvmField val progress: Double = 0.0,
-)
diff --git a/api/src/main/kotlin/nebulosa/api/guiding/GuidePulseTask.kt b/api/src/main/kotlin/nebulosa/api/guiding/GuidePulseTask.kt
index a7ad08b1e..d119fbac7 100644
--- a/api/src/main/kotlin/nebulosa/api/guiding/GuidePulseTask.kt
+++ b/api/src/main/kotlin/nebulosa/api/guiding/GuidePulseTask.kt
@@ -1,54 +1,41 @@
 package nebulosa.api.guiding
 
-import io.reactivex.rxjava3.functions.Consumer
-import nebulosa.api.tasks.AbstractTask
-import nebulosa.api.tasks.delay.DelayEvent
-import nebulosa.api.tasks.delay.DelayTask
-import nebulosa.common.concurrency.cancel.CancellationListener
-import nebulosa.common.concurrency.cancel.CancellationSource
-import nebulosa.common.concurrency.cancel.CancellationToken
 import nebulosa.guiding.GuideDirection
 import nebulosa.indi.device.guider.GuideOutput
+import nebulosa.job.manager.Job
+import nebulosa.job.manager.Task
+import nebulosa.job.manager.delay.DelayTask
+import nebulosa.log.debug
 import nebulosa.log.loggerFor
+import nebulosa.util.concurrency.cancellation.CancellationSource
 import java.time.Duration
 
 data class GuidePulseTask(
+    @JvmField val job: Job,
     @JvmField val guideOutput: GuideOutput,
     @JvmField val request: GuidePulseRequest,
-) : AbstractTask<GuidePulseEvent>(), CancellationListener, Consumer<DelayEvent> {
+) : Task {
 
-    private val delayTask = DelayTask(request.duration)
+    private val direction = request.direction
+    private val duration = request.duration.toMillis()
 
-    init {
-        delayTask.subscribe(this)
-    }
-
-    override fun execute(cancellationToken: CancellationToken) {
-        if (!cancellationToken.isCancelled && guideOutput.pulseGuide(request.duration, request.direction)) {
-            LOG.info("Guide Pulse started. guideOutput={}, duration={}, direction={}", guideOutput, request.duration.toMillis(), request.direction)
-
-            try {
-                cancellationToken.listen(this)
-                delayTask.execute(cancellationToken)
-            } finally {
-                cancellationToken.unlisten(this)
-            }
+    @JvmField val delayTask = DelayTask(job, duration)
 
-            LOG.info("Guide Pulse finished. guideOutput={}, duration={}, direction={}", guideOutput, request.duration.toMillis(), request.direction)
+    override fun run() {
+        if (!job.isCancelled && guideOutput.pulseGuide(request.duration, request.direction)) {
+            LOG.debug { "Guide Pulse started. guideOutput=$guideOutput, duration=$duration ms, direction=$direction" }
+            delayTask.run()
+            LOG.debug { "Guide Pulse finished. guideOutput=$guideOutput, duration=$duration ms, direction=$direction" }
         }
     }
 
     override fun onCancel(source: CancellationSource) {
+        delayTask.onCancel(source)
         guideOutput.pulseGuide(Duration.ZERO, request.direction)
     }
 
-    override fun accept(event: DelayEvent) {
-        onNext(GuidePulseEvent(this, event.remainingTime, event.progress))
-    }
-
-    override fun close() {
-        delayTask.close()
-        super.close()
+    override fun onPause(paused: Boolean) {
+        delayTask.onPause(paused)
     }
 
     companion object {
diff --git a/api/src/main/kotlin/nebulosa/api/guiding/GuideStepHistory.kt b/api/src/main/kotlin/nebulosa/api/guiding/GuideStepHistory.kt
index e85b1732f..3ed886adf 100644
--- a/api/src/main/kotlin/nebulosa/api/guiding/GuideStepHistory.kt
+++ b/api/src/main/kotlin/nebulosa/api/guiding/GuideStepHistory.kt
@@ -1,7 +1,7 @@
 package nebulosa.api.guiding
 
-import nebulosa.common.concurrency.atomic.Incrementer
 import nebulosa.guiding.GuideStep
+import nebulosa.util.concurrency.atomic.Incrementer
 import java.util.*
 
 class GuideStepHistory private constructor(private val data: LinkedList<HistoryStep>) : List<HistoryStep> by data {
diff --git a/api/src/main/kotlin/nebulosa/api/guiding/GuidingController.kt b/api/src/main/kotlin/nebulosa/api/guiding/GuidingController.kt
index f0a54f1d4..241199930 100644
--- a/api/src/main/kotlin/nebulosa/api/guiding/GuidingController.kt
+++ b/api/src/main/kotlin/nebulosa/api/guiding/GuidingController.kt
@@ -1,71 +1,84 @@
 package nebulosa.api.guiding
 
-import jakarta.validation.Valid
-import org.springframework.web.bind.annotation.*
+import io.javalin.Javalin
+import io.javalin.http.Context
+import io.javalin.http.bodyAsClass
+import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.valid
+import kotlin.math.min
 
-@RestController
-@RequestMapping("guiding")
-class GuidingController(private val guidingService: GuidingService) {
+class GuidingController(
+    app: Javalin,
+    private val guidingService: GuidingService,
+) {
 
-    @PutMapping("connect")
-    fun connect(
-        @RequestParam(required = false, defaultValue = "localhost") host: String,
-        @RequestParam(required = false, defaultValue = "4400") port: Int,
-    ) {
+    init {
+        app.put("guiding/connect", ::connect)
+        app.put("guiding/disconnect", ::disconnect)
+        app.get("guiding/history", ::history)
+        app.get("guiding/history/latest", ::latestHistory)
+        app.put("guiding/history/clear", ::clearHistory)
+        app.put("guiding/loop", ::loop)
+        app.put("guiding/start", ::start)
+        app.get("guiding/status", ::status)
+        app.put("guiding/settle", ::settle)
+        app.put("guiding/dither", ::dither)
+        app.put("guiding/stop", ::stop)
+    }
+
+    private fun connect(ctx: Context) {
+        val host = ctx.queryParam("host")?.ifBlank { null } ?: "localhost"
+        val port = ctx.queryParam("port")?.toInt() ?: 4400
         guidingService.connect(host, port)
     }
 
-    @DeleteMapping("disconnect")
-    fun disconnect() {
+    @Suppress("UNUSED_PARAMETER")
+    private fun disconnect(ctx: Context) {
         guidingService.disconnect()
     }
 
-    @GetMapping("status")
-    fun status(): GuiderInfo {
-        return guidingService.status()
+    private fun status(ctx: Context) {
+        ctx.json(guidingService.status())
     }
 
-    @GetMapping("history")
-    fun history(@RequestParam(required = false, defaultValue = "100") maxLength: Int): List<HistoryStep> {
-        return guidingService.history(maxLength)
+    private fun history(ctx: Context) {
+        val maxLength = min(100, ctx.queryParam("maxLength")?.toInt() ?: 100)
+        ctx.json(guidingService.history(maxLength))
     }
 
-    @GetMapping("history/latest")
-    fun latestHistory(): HistoryStep? {
-        return guidingService.latestHistory()
+    private fun latestHistory(ctx: Context) {
+        guidingService.latestHistory()?.also(ctx::json)
     }
 
 
-    @PutMapping("history/clear")
-    fun clearHistory() {
+    @Suppress("UNUSED_PARAMETER")
+    private fun clearHistory(ctx: Context) {
         return guidingService.clearHistory()
     }
 
-    @PutMapping("loop")
-    fun loop(@RequestParam(required = false, defaultValue = "true") autoSelectGuideStar: Boolean) {
+    private fun loop(ctx: Context) {
+        val autoSelectGuideStar = ctx.queryParam("autoSelectGuideStar")?.toBoolean() ?: true
         guidingService.loop(autoSelectGuideStar)
     }
 
-    @PutMapping("start")
-    fun start(@RequestParam(required = false, defaultValue = "false") forceCalibration: Boolean) {
+    private fun start(ctx: Context) {
+        val forceCalibration = ctx.queryParam("forceCalibration")?.toBoolean() ?: false
         guidingService.start(forceCalibration)
     }
 
-    @PutMapping("settle")
-    fun settle(@RequestBody @Valid body: SettleInfo) {
+    private fun settle(ctx: Context) {
+        val body = ctx.bodyAsClass<SettleInfo>().valid()
         guidingService.settle(body)
     }
 
-    @PutMapping("dither")
-    fun dither(
-        @RequestParam amount: Double,
-        @RequestParam(required = false, defaultValue = "false") raOnly: Boolean,
-    ) {
+    private fun dither(ctx: Context) {
+        val amount = ctx.queryParam("amount").notNull().toDouble()
+        val raOnly = ctx.queryParam("raOnly")?.toBoolean() ?: false
         return guidingService.dither(amount, raOnly)
     }
 
-    @PutMapping("stop")
-    fun stop() {
+    @Suppress("UNUSED_PARAMETER")
+    private fun stop(ctx: Context) {
         guidingService.stop()
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/guiding/GuidingService.kt b/api/src/main/kotlin/nebulosa/api/guiding/GuidingService.kt
index 422f31d64..80809a987 100644
--- a/api/src/main/kotlin/nebulosa/api/guiding/GuidingService.kt
+++ b/api/src/main/kotlin/nebulosa/api/guiding/GuidingService.kt
@@ -1,6 +1,5 @@
 package nebulosa.api.guiding
 
-import jakarta.annotation.PreDestroy
 import nebulosa.api.message.MessageService
 import nebulosa.api.preference.PreferenceService
 import nebulosa.guiding.GuideStar
@@ -8,12 +7,10 @@ import nebulosa.guiding.GuideState
 import nebulosa.guiding.Guider
 import nebulosa.guiding.GuiderListener
 import nebulosa.phd2.client.PHD2Client
-import org.springframework.stereotype.Service
 import java.time.Duration
 import kotlin.math.max
 import kotlin.math.min
 
-@Service
 class GuidingService(
     private val preferenceService: PreferenceService,
     private val messageService: MessageService,
@@ -42,7 +39,6 @@ class GuidingService(
         messageService.sendMessage(GuiderMessageEvent(GUIDER_CONNECTED))
     }
 
-    @PreDestroy
     @Synchronized
     fun disconnect() {
         runCatching { guider.close() }
diff --git a/api/src/main/kotlin/nebulosa/api/guiding/SettleInfo.kt b/api/src/main/kotlin/nebulosa/api/guiding/SettleInfo.kt
index e899eaf11..f6a082512 100644
--- a/api/src/main/kotlin/nebulosa/api/guiding/SettleInfo.kt
+++ b/api/src/main/kotlin/nebulosa/api/guiding/SettleInfo.kt
@@ -1,12 +1,19 @@
 package nebulosa.api.guiding
 
-import org.hibernate.validator.constraints.Range
+import nebulosa.api.javalin.Validatable
+import nebulosa.api.javalin.range
 
 data class SettleInfo(
-    @Range(min = 1, max = 25) @JvmField val amount: Double = 1.5,
-    @Range(min = 1, max = 60) @JvmField val time: Long = 10,
-    @Range(min = 1, max = 60) @JvmField val timeout: Long = 30,
-) {
+    @JvmField val amount: Double = 1.5,
+    @JvmField val time: Long = 10,
+    @JvmField val timeout: Long = 30,
+) : Validatable {
+
+    override fun validate() {
+        amount.range(1.0, 25.0)
+        time.range(1L, 60L)
+        timeout.range(1L, 60L)
+    }
 
     companion object {
 
diff --git a/api/src/main/kotlin/nebulosa/api/guiding/WaitForSettleEvent.kt b/api/src/main/kotlin/nebulosa/api/guiding/WaitForSettleEvent.kt
new file mode 100644
index 000000000..ec161a99b
--- /dev/null
+++ b/api/src/main/kotlin/nebulosa/api/guiding/WaitForSettleEvent.kt
@@ -0,0 +1,5 @@
+package nebulosa.api.guiding
+
+import nebulosa.job.manager.TaskEvent
+
+sealed interface WaitForSettleEvent : TaskEvent
diff --git a/api/src/main/kotlin/nebulosa/api/guiding/WaitForSettleFinished.kt b/api/src/main/kotlin/nebulosa/api/guiding/WaitForSettleFinished.kt
new file mode 100644
index 000000000..7f4a958f4
--- /dev/null
+++ b/api/src/main/kotlin/nebulosa/api/guiding/WaitForSettleFinished.kt
@@ -0,0 +1,5 @@
+package nebulosa.api.guiding
+
+import nebulosa.job.manager.Job
+
+data class WaitForSettleFinished(override val job: Job, override val task: WaitForSettleTask) : WaitForSettleEvent
diff --git a/api/src/main/kotlin/nebulosa/api/guiding/WaitForSettleStarted.kt b/api/src/main/kotlin/nebulosa/api/guiding/WaitForSettleStarted.kt
new file mode 100644
index 000000000..cdd3a1e57
--- /dev/null
+++ b/api/src/main/kotlin/nebulosa/api/guiding/WaitForSettleStarted.kt
@@ -0,0 +1,5 @@
+package nebulosa.api.guiding
+
+import nebulosa.job.manager.Job
+
+data class WaitForSettleStarted(override val job: Job, override val task: WaitForSettleTask) : WaitForSettleEvent
diff --git a/api/src/main/kotlin/nebulosa/api/guiding/WaitForSettleTask.kt b/api/src/main/kotlin/nebulosa/api/guiding/WaitForSettleTask.kt
index 87006cb6e..b149fc457 100644
--- a/api/src/main/kotlin/nebulosa/api/guiding/WaitForSettleTask.kt
+++ b/api/src/main/kotlin/nebulosa/api/guiding/WaitForSettleTask.kt
@@ -1,19 +1,23 @@
 package nebulosa.api.guiding
 
-import nebulosa.api.tasks.Task
-import nebulosa.common.concurrency.cancel.CancellationToken
 import nebulosa.guiding.Guider
+import nebulosa.job.manager.Job
+import nebulosa.job.manager.Task
+import nebulosa.log.debug
 import nebulosa.log.loggerFor
 
 data class WaitForSettleTask(
+    @JvmField val job: Job,
     @JvmField val guider: Guider?,
 ) : Task {
 
-    override fun execute(cancellationToken: CancellationToken) {
-        if (guider != null && guider.isSettling && !cancellationToken.isCancelled) {
-            LOG.info("Wait For Settle started")
-            guider.waitForSettle(cancellationToken)
-            LOG.info("Wait For Settle finished")
+    override fun run() {
+        if (guider != null && guider.isSettling && !job.isCancelled) {
+            LOG.debug { "Wait For Settle started" }
+            job.accept(WaitForSettleStarted(job, this))
+            guider.waitForSettle()
+            job.accept(WaitForSettleFinished(job, this))
+            LOG.debug { "Wait For Settle finished" }
         }
     }
 
diff --git a/api/src/main/kotlin/nebulosa/api/image/ImageBucket.kt b/api/src/main/kotlin/nebulosa/api/image/ImageBucket.kt
index de461a572..964e4ee22 100644
--- a/api/src/main/kotlin/nebulosa/api/image/ImageBucket.kt
+++ b/api/src/main/kotlin/nebulosa/api/image/ImageBucket.kt
@@ -5,15 +5,13 @@ import nebulosa.image.Image
 import nebulosa.log.loggerFor
 import nebulosa.platesolver.PlateSolution
 import nebulosa.xisf.xisf
-import org.springframework.stereotype.Component
 import java.nio.file.Path
-import java.util.*
 import java.util.concurrent.ConcurrentHashMap
-import kotlin.concurrent.timer
+import java.util.concurrent.ScheduledExecutorService
+import java.util.concurrent.TimeUnit
 import kotlin.io.path.extension
 
-@Component
-class ImageBucket : AutoCloseable {
+class ImageBucket(scheduledExecutorService: ScheduledExecutorService) {
 
     data class OpenedImage(
         @JvmField var image: Image? = null,
@@ -23,7 +21,10 @@ class ImageBucket : AutoCloseable {
     )
 
     private val bucket = ConcurrentHashMap<Path, OpenedImage>(8)
-    private val timer = timer("Image Bucket Timer", true, IMAGES_MAX_TIME, IMAGES_MAX_TIME, ::deleteUnusedImages)
+
+    init {
+        scheduledExecutorService.scheduleAtFixedRate(::deleteUnusedImages, IMAGE_TIMEOUT, IMAGE_TIMEOUT, TimeUnit.MILLISECONDS)
+    }
 
     @Synchronized
     fun put(path: Path, image: Image, solution: PlateSolution? = null, debayer: Boolean = true): OpenedImage {
@@ -82,17 +83,12 @@ class ImageBucket : AutoCloseable {
         return bucket.any { it.value.solution === solution }
     }
 
-    override fun close() {
-        timer.cancel()
-    }
-
-    @Suppress("UNUSED_PARAMETER")
-    private fun deleteUnusedImages(task: TimerTask) {
+    private fun deleteUnusedImages() {
         val currentTime = System.currentTimeMillis()
 
         synchronized(this) {
             for ((path, image) in bucket) {
-                if (image.image != null && currentTime - image.openedAt >= IMAGES_MAX_TIME) {
+                if (image.image != null && currentTime - image.openedAt >= IMAGE_TIMEOUT) {
                     image.image = null
                     LOG.info("image at {} has been disposed", path)
                 }
@@ -102,7 +98,7 @@ class ImageBucket : AutoCloseable {
 
     companion object {
 
-        private const val IMAGES_MAX_TIME = 1000 * 60 * 5L // 5 min
+        private const val IMAGE_TIMEOUT = 1000 * 60 * 5L // 5 min
 
         @JvmStatic private val LOG = loggerFor<ImageBucket>()
     }
diff --git a/api/src/main/kotlin/nebulosa/api/image/ImageController.kt b/api/src/main/kotlin/nebulosa/api/image/ImageController.kt
index 33d886df0..efb0154de 100644
--- a/api/src/main/kotlin/nebulosa/api/image/ImageController.kt
+++ b/api/src/main/kotlin/nebulosa/api/image/ImageController.kt
@@ -1,70 +1,72 @@
 package nebulosa.api.image
 
-import jakarta.servlet.http.HttpServletResponse
-import jakarta.validation.Valid
-import nebulosa.api.atlas.Location
-import nebulosa.api.beans.converters.location.LocationParam
-import nebulosa.indi.device.camera.Camera
-import org.hibernate.validator.constraints.Range
-import org.springframework.http.HttpHeaders
-import org.springframework.web.bind.annotation.*
-import java.nio.file.Path
+import io.javalin.Javalin
+import io.javalin.http.Context
+import io.javalin.http.bodyAsClass
+import nebulosa.api.connection.ConnectionService
+import nebulosa.api.javalin.*
+import java.io.ByteArrayInputStream
 
-@RestController
-@RequestMapping("image")
 class ImageController(
+    app: Javalin,
     private val imageService: ImageService,
+    private val connectionService: ConnectionService,
 ) {
 
-    @PostMapping
-    fun openImage(
-        @RequestParam path: Path,
-        camera: Camera?,
-        @RequestBody transformation: ImageTransformation,
-        output: HttpServletResponse,
-    ) = imageService.openImage(path, camera, transformation, output)
+    init {
+        app.post("image", ::openImage)
+        app.delete("image", ::closeImage)
+        app.put("image/save-as", ::saveImageAs)
+        app.put("image/annotations", ::annotations)
+        app.get("image/coordinate-interpolation", ::coordinateInterpolation)
+        app.get("image/histogram", ::histogram)
+        app.get("image/fov-cameras", ::fovCameras)
+        app.get("image/fov-telescopes", ::fovTelescopes)
+    }
+
+    private fun openImage(ctx: Context) {
+        val path = ctx.queryParam("path").notNull().path().exists()
+        val camera = ctx.queryParam("camera")?.ifBlank { null }?.let(connectionService::camera)
+        val transformation = ctx.bodyAsClass<ImageTransformation>()
+        imageService.openImage(path, camera, transformation, ctx.res())
+    }
 
-    @DeleteMapping
-    fun closeImage(@RequestParam path: Path) {
+    private fun closeImage(ctx: Context) {
+        val path = ctx.queryParam("path").notNull().path()
         return imageService.closeImage(path)
     }
 
-    @PutMapping("save-as")
-    fun saveImageAs(
-        @RequestParam path: Path,
-        camera: Camera?,
-        @RequestBody save: SaveImage
-    ) {
-        imageService.saveImageAs(path, save, camera)
+    private fun saveImageAs(ctx: Context) {
+        val path = ctx.queryParam("path").notNull().path()
+        val save = ctx.bodyAsClass<SaveImage>()
+        imageService.saveImageAs(path, save)
     }
 
-    @PutMapping("annotations")
-    fun annotationsOfImage(
-        @RequestParam path: Path,
-        @RequestBody request: AnnotateImageRequest,
-        @LocationParam location: Location? = null,
-    ) = imageService.annotations(path, request, location)
+    private fun annotations(ctx: Context) {
+        val path = ctx.queryParam("path").notNull().path().exists()
+        val request = ctx.bodyAsClass<AnnotateImageRequest>()
+        val location = ctx.location()
+        ctx.json(imageService.annotations(path, request, location))
+    }
 
-    @GetMapping("coordinate-interpolation")
-    fun coordinateInterpolation(@RequestParam path: Path): CoordinateInterpolation? {
-        return imageService.coordinateInterpolation(path)
+    private fun coordinateInterpolation(ctx: Context) {
+        val path = ctx.queryParam("path").notNull().path().exists()
+        imageService.coordinateInterpolation(path)?.also(ctx::json)
     }
 
-    @GetMapping("histogram")
-    fun histogram(
-        @RequestParam path: Path,
-        @RequestParam(required = false, defaultValue = "16") @Valid @Range(min = 8, max = 16) bitLength: Int,
-    ) = imageService.histogram(path, bitLength)
+    private fun histogram(ctx: Context) {
+        val path = ctx.queryParam("path").notNull().path().exists()
+        val bitLength = ctx.queryParam("bitLength")?.toInt()?.range(8, 16) ?: 16
+        ctx.json(imageService.histogram(path, bitLength))
+    }
 
-    @GetMapping("fov-cameras")
-    fun fovCameras(response: HttpServletResponse) {
-        response.addHeader(HttpHeaders.CONTENT_TYPE, "application/json")
-        return response.outputStream.write(imageService.fovCameras)
+    private fun fovCameras(ctx: Context) {
+        val bytes = imageService.fovCameras
+        ctx.writeSeekableStream(ByteArrayInputStream(bytes), "application/json", bytes.size.toLong())
     }
 
-    @GetMapping("fov-telescopes")
-    fun fovTelescopes(response: HttpServletResponse) {
-        response.addHeader(HttpHeaders.CONTENT_TYPE, "application/json")
-        return response.outputStream.write(imageService.fovTelescopes)
+    private fun fovTelescopes(ctx: Context) {
+        val bytes = imageService.fovTelescopes
+        ctx.writeSeekableStream(ByteArrayInputStream(bytes), "application/json", bytes.size.toLong())
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/image/ImageService.kt b/api/src/main/kotlin/nebulosa/api/image/ImageService.kt
index 4e3e53cda..f37b5f051 100644
--- a/api/src/main/kotlin/nebulosa/api/image/ImageService.kt
+++ b/api/src/main/kotlin/nebulosa/api/image/ImageService.kt
@@ -1,6 +1,7 @@
 package nebulosa.api.image
 
 import com.fasterxml.jackson.databind.ObjectMapper
+import io.javalin.http.NotFoundResponse
 import jakarta.servlet.http.HttpServletResponse
 import nebulosa.api.atlas.Location
 import nebulosa.api.atlas.SimbadEntityRepository
@@ -33,20 +34,16 @@ import nebulosa.wcs.WCS
 import nebulosa.wcs.WCSException
 import nebulosa.xisf.XisfFormat
 import okio.sink
-import org.springframework.http.HttpStatus
-import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor
-import org.springframework.stereotype.Service
-import org.springframework.web.server.ResponseStatusException
 import java.net.URI
 import java.nio.file.Path
 import java.time.LocalDateTime
 import java.util.*
 import java.util.concurrent.CompletableFuture
+import java.util.concurrent.ExecutorService
 import javax.imageio.ImageIO
 import kotlin.io.path.outputStream
 import kotlin.math.roundToInt
 
-@Service
 class ImageService(
     private val objectMapper: ObjectMapper,
     private val framingService: FramingService,
@@ -55,7 +52,7 @@ class ImageService(
     private val simbadEntityRepository: SimbadEntityRepository,
     private val simbadService: SimbadService,
     private val imageBucket: ImageBucket,
-    private val threadPoolTaskExecutor: ThreadPoolTaskExecutor,
+    private val executorService: ExecutorService,
     private val connectionService: ConnectionService,
 ) {
 
@@ -196,7 +193,7 @@ class ImageService(
         val dateTime = image.header.observationDate ?: LocalDateTime.now(SystemClock)
 
         if (request.minorPlanets) {
-            threadPoolTaskExecutor.submitCompletable {
+            CompletableFuture.runAsync({
                 val latitude = image.header.latitude ?: location?.latitude?.deg ?: 0.0
                 val longitude = image.header.longitude ?: location?.longitude?.deg ?: 0.0
 
@@ -209,7 +206,7 @@ class ImageService(
                     dateTime, latitude, longitude, 0.0,
                     calibration.rightAscension, calibration.declination, calibration.radius,
                     request.minorPlanetMagLimit, !request.includeMinorPlanetsWithoutMagnitude,
-                ).execute().body() ?: return@submitCompletable
+                ).execute().body() ?: return@runAsync
 
                 val radiusInSeconds = calibration.radius.toArcsec
                 var count = 0
@@ -221,21 +218,25 @@ class ImageService(
                         val rightAscension = it[1].hours.takeIf(Angle::isFinite) ?: return@forEach
                         val declination = it[2].deg.takeIf(Angle::isFinite) ?: return@forEach
                         val (x, y) = wcs.skyToPix(rightAscension, declination)
-                        val magnitude = it[6].replace(INVALID_MAG_CHARS, "").toDoubleOrNull() ?: SkyObject.UNKNOWN_MAGNITUDE
-                        val minorPlanet = ImageAnnotation.MinorPlanet(0L, it[0], rightAscension, declination, magnitude)
-                        val annotation = ImageAnnotation(x, y, minorPlanet = minorPlanet)
-                        annotations.add(annotation)
-                        count++
+
+                        if (x >= 0 && y >= 0 && x < image.width && y < image.height) {
+                            val magnitude = it[6].replace(INVALID_MAG_CHARS, "").toDoubleOrNull() ?: SkyObject.UNKNOWN_MAGNITUDE
+                            val minorPlanet = ImageAnnotation.MinorPlanet(0L, it[0], rightAscension, declination, magnitude)
+                            val annotation = ImageAnnotation(x, y, minorPlanet = minorPlanet)
+                            annotations.add(annotation)
+                            count++
+                        }
                     }
                 }
 
                 LOG.info("found {} minor planets", count)
-            }.whenComplete { _, e -> e?.printStackTrace() }
+            }, executorService)
+                .whenComplete { _, e -> e?.printStackTrace() }
                 .also(tasks::add)
         }
 
         if (request.starsAndDSOs) {
-            threadPoolTaskExecutor.submitCompletable {
+            CompletableFuture.runAsync({
                 LOG.info("finding star/DSO annotations. dateTime={}, useSimbad={}, calibration={}", dateTime, request.useSimbad, calibration)
 
                 val rightAscension = calibration.rightAscension
@@ -257,14 +258,18 @@ class ImageService(
                     val astrometric = barycentric.observe(entry).equatorial()
 
                     val (x, y) = wcs.skyToPix(astrometric.longitude.normalized, astrometric.latitude)
-                    val annotation = if (entry.type.classification == ClassificationType.STAR) ImageAnnotation(x, y, star = StarDSO(entry))
-                    else ImageAnnotation(x, y, dso = StarDSO(entry))
-                    annotations.add(annotation)
-                    count++
+
+                    if (x >= 0 && y >= 0 && x < image.width && y < image.height) {
+                        val annotation = if (entry.type.classification == ClassificationType.STAR) ImageAnnotation(x, y, star = StarDSO(entry))
+                        else ImageAnnotation(x, y, dso = StarDSO(entry))
+                        annotations.add(annotation)
+                        count++
+                    }
                 }
 
                 LOG.info("found {} stars/DSOs", count)
-            }.whenComplete { _, e -> e?.printStackTrace() }
+            }, executorService)
+                .whenComplete { _, e -> e?.printStackTrace() }
                 .also(tasks::add)
         }
 
@@ -275,13 +280,13 @@ class ImageService(
         return annotations
     }
 
-    fun saveImageAs(path: Path, save: SaveImage, camera: Camera?) {
+    fun saveImageAs(path: Path, save: SaveImage) {
         require(save.path != null)
 
         var (image) = imageBucket.open(path).image?.transform(save.shouldBeTransformed, save.transformation, ImageOperation.SAVE)
-            ?: throw ResponseStatusException(HttpStatus.NOT_FOUND, "Image not found")
+            ?: throw NotFoundResponse("Image not found")
 
-        var (x, y, width, height) = save.subFrame.constrained(image.width, image.height)
+        val (x, y, width, height) = save.subFrame.constrained(image.width, image.height)
 
         if (width > 0 && height > 0 && (x > 0 || y > 0 || width != image.width || height != image.height)) {
             LOG.debug { "image subframed. x=$x, y=$y, width=$width, height=$height" }
diff --git a/api/src/main/kotlin/nebulosa/api/indi/INDIController.kt b/api/src/main/kotlin/nebulosa/api/indi/INDIController.kt
index ca889fd60..598eca5d9 100644
--- a/api/src/main/kotlin/nebulosa/api/indi/INDIController.kt
+++ b/api/src/main/kotlin/nebulosa/api/indi/INDIController.kt
@@ -1,63 +1,74 @@
 package nebulosa.api.indi
 
-import jakarta.validation.Valid
-import nebulosa.indi.device.Device
-import nebulosa.indi.device.PropertyVector
-import org.springframework.web.bind.annotation.*
+import io.javalin.Javalin
+import io.javalin.http.Context
+import io.javalin.http.bodyAsClass
+import nebulosa.api.connection.ConnectionService
+import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.valid
 
-@RestController
-@RequestMapping("indi")
 class INDIController(
+    app: Javalin,
     private val indiService: INDIService,
+    private val connectionService: ConnectionService,
 ) {
 
-    @GetMapping("{device}")
-    fun device(device: Device): Device {
-        return device
+    init {
+        app.get("indi/{device}", ::device)
+        app.put("indi/{device}/connect", ::connect)
+        app.put("indi/{device}/disconnect", ::disconnect)
+        app.get("indi/{device}/properties", ::properties)
+        app.put("indi/{device}/send", ::sendProperty)
+        app.get("indi/{device}/log", ::deviceLog)
+        app.put("indi/{device}/listen", ::listen)
+        app.put("indi/{device}/unlisten", ::unlisten)
+        app.get("indi/log", ::log)
     }
 
-    @PutMapping("{device}/connect")
-    fun connect(device: Device) {
+    private fun device(ctx: Context) {
+        val device = connectionService.device(ctx.pathParam("device")).notNull()
+        ctx.json(device)
+    }
+
+    private fun connect(ctx: Context) {
+        val device = connectionService.device(ctx.pathParam("device")) ?: return
         indiService.connect(device)
     }
 
-    @PutMapping("{device}/disconnect")
-    fun disconnect(device: Device) {
+    private fun disconnect(ctx: Context) {
+        val device = connectionService.device(ctx.pathParam("device")) ?: return
         indiService.disconnect(device)
     }
 
-    @GetMapping("{device}/properties")
-    fun properties(device: Device): Collection<PropertyVector<*, *>> {
-        return indiService.properties(device)
+    private fun properties(ctx: Context) {
+        val device = connectionService.device(ctx.pathParam("device")).notNull()
+        ctx.json(indiService.properties(device))
     }
 
-    @PutMapping("{device}/send")
-    fun sendProperty(
-        device: Device,
-        @RequestBody @Valid body: INDISendProperty,
-    ) {
-        return indiService.sendProperty(device, body)
+    private fun sendProperty(ctx: Context) {
+        val device = connectionService.device(ctx.pathParam("device")) ?: return
+        val body = ctx.bodyAsClass<INDISendProperty>().valid()
+        indiService.sendProperty(device, body)
     }
 
-    @GetMapping("{device}/log")
-    fun log(device: Device): List<String> {
-        return synchronized(device.messages) { device.messages }
+    private fun deviceLog(ctx: Context) {
+        val device = connectionService.device(ctx.pathParam("device")).notNull()
+        ctx.json(synchronized(device.messages) { device.messages })
     }
 
-    @GetMapping("log")
-    fun log(): List<String> {
-        return indiService.messages()
+    private fun log(ctx: Context) {
+        ctx.json(indiService.messages())
     }
 
     @Synchronized
-    @PutMapping("{device}/listen")
-    fun listen(device: Device) {
+    private fun listen(ctx: Context) {
+        val device = connectionService.device(ctx.pathParam("device")) ?: return
         indiService.registerDeviceToSendMessage(device)
     }
 
     @Synchronized
-    @PutMapping("{device}/unlisten")
-    fun unlisten(device: Device) {
+    private fun unlisten(ctx: Context) {
+        val device = connectionService.device(ctx.pathParam("device")) ?: return
         indiService.unregisterDeviceToSendMessage(device)
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/indi/INDIEventHandler.kt b/api/src/main/kotlin/nebulosa/api/indi/INDIEventHandler.kt
index 70d95ce32..affbcd171 100644
--- a/api/src/main/kotlin/nebulosa/api/indi/INDIEventHandler.kt
+++ b/api/src/main/kotlin/nebulosa/api/indi/INDIEventHandler.kt
@@ -1,22 +1,24 @@
 package nebulosa.api.indi
 
-import nebulosa.api.beans.annotations.Subscriber
 import nebulosa.api.message.MessageService
 import nebulosa.indi.device.*
+import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode
-import org.springframework.stereotype.Component
 import java.util.*
 
-@Component
-@Subscriber
 class INDIEventHandler(
     private val messageService: MessageService,
+    eventBus: EventBus,
 ) {
 
     private val canSendEvents = HashSet<Device>(8)
     private val messages = LinkedList<String>()
 
+    init {
+        eventBus.register(this)
+    }
+
     @Subscribe(threadMode = ThreadMode.ASYNC)
     fun onDeviceEvent(event: DeviceEvent<*>) {
         when (event) {
diff --git a/api/src/main/kotlin/nebulosa/api/indi/INDIPropertySerializer.kt b/api/src/main/kotlin/nebulosa/api/indi/INDIPropertySerializer.kt
index 9115b7b85..9fa3fd1be 100644
--- a/api/src/main/kotlin/nebulosa/api/indi/INDIPropertySerializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/indi/INDIPropertySerializer.kt
@@ -4,9 +4,7 @@ import com.fasterxml.jackson.core.JsonGenerator
 import com.fasterxml.jackson.databind.SerializerProvider
 import com.fasterxml.jackson.databind.ser.std.StdSerializer
 import nebulosa.indi.device.Property
-import org.springframework.stereotype.Component
 
-@Component
 class INDIPropertySerializer : StdSerializer<Property<*>>(Property::class.java) {
 
     override fun serialize(value: Property<*>, gen: JsonGenerator, provider: SerializerProvider) {
diff --git a/api/src/main/kotlin/nebulosa/api/indi/INDIPropertyVectorSerializer.kt b/api/src/main/kotlin/nebulosa/api/indi/INDIPropertyVectorSerializer.kt
index 069753059..167ee31c1 100644
--- a/api/src/main/kotlin/nebulosa/api/indi/INDIPropertyVectorSerializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/indi/INDIPropertyVectorSerializer.kt
@@ -5,9 +5,7 @@ import com.fasterxml.jackson.databind.SerializerProvider
 import com.fasterxml.jackson.databind.ser.std.StdSerializer
 import nebulosa.indi.device.PropertyVector
 import nebulosa.indi.device.SwitchPropertyVector
-import org.springframework.stereotype.Component
 
-@Component
 class INDIPropertyVectorSerializer : StdSerializer<PropertyVector<*, *>>(PropertyVector::class.java) {
 
     override fun serialize(value: PropertyVector<*, *>, gen: JsonGenerator, provider: SerializerProvider) {
diff --git a/api/src/main/kotlin/nebulosa/api/indi/INDISendProperty.kt b/api/src/main/kotlin/nebulosa/api/indi/INDISendProperty.kt
index 3bd06d872..a4a1cc913 100644
--- a/api/src/main/kotlin/nebulosa/api/indi/INDISendProperty.kt
+++ b/api/src/main/kotlin/nebulosa/api/indi/INDISendProperty.kt
@@ -1,13 +1,19 @@
 package nebulosa.api.indi
 
-import jakarta.validation.Valid
-import jakarta.validation.constraints.NotBlank
-import jakarta.validation.constraints.NotEmpty
-import jakarta.validation.constraints.NotNull
+import nebulosa.api.javalin.Validatable
+import nebulosa.api.javalin.notBlank
+import nebulosa.api.javalin.notEmpty
 import nebulosa.indi.protocol.PropertyType
 
 data class INDISendProperty(
-    @field:NotBlank @JvmField val name: String = "",
-    @field:NotNull @JvmField val type: PropertyType = PropertyType.SWITCH,
-    @field:NotEmpty @field:Valid @JvmField val items: List<INDISendPropertyItem> = emptyList(),
-)
+    @JvmField val name: String = "",
+    @JvmField val type: PropertyType = PropertyType.SWITCH,
+    @JvmField val items: List<INDISendPropertyItem> = emptyList(),
+) : Validatable {
+
+
+    override fun validate() {
+        name.notBlank()
+        items.notEmpty().onEach { it.validate() }
+    }
+}
diff --git a/api/src/main/kotlin/nebulosa/api/indi/INDISendPropertyItem.kt b/api/src/main/kotlin/nebulosa/api/indi/INDISendPropertyItem.kt
index c6d382497..ed182edc4 100644
--- a/api/src/main/kotlin/nebulosa/api/indi/INDISendPropertyItem.kt
+++ b/api/src/main/kotlin/nebulosa/api/indi/INDISendPropertyItem.kt
@@ -1,9 +1,14 @@
 package nebulosa.api.indi
 
-import jakarta.validation.constraints.NotBlank
-import jakarta.validation.constraints.NotNull
+import nebulosa.api.javalin.Validatable
+import nebulosa.api.javalin.notBlank
 
 data class INDISendPropertyItem(
-    @field:NotBlank @JvmField val name: String = "",
-    @field:NotNull @JvmField val value: Any = "",
-)
+    @JvmField val name: String = "",
+    @JvmField val value: Any = "",
+) : Validatable {
+
+    override fun validate() {
+        name.notBlank()
+    }
+}
diff --git a/api/src/main/kotlin/nebulosa/api/indi/INDIService.kt b/api/src/main/kotlin/nebulosa/api/indi/INDIService.kt
index 91f4c5d92..b34b135a9 100644
--- a/api/src/main/kotlin/nebulosa/api/indi/INDIService.kt
+++ b/api/src/main/kotlin/nebulosa/api/indi/INDIService.kt
@@ -3,12 +3,8 @@ package nebulosa.api.indi
 import nebulosa.indi.device.Device
 import nebulosa.indi.device.PropertyVector
 import nebulosa.indi.protocol.PropertyType
-import org.springframework.stereotype.Service
 
-@Service("indiService")
-class INDIService(
-    private val indiEventHandler: INDIEventHandler,
-) {
+class INDIService(private val indiEventHandler: INDIEventHandler) {
 
     fun registerDeviceToSendMessage(device: Device) {
         indiEventHandler.registerDevice(device)
diff --git a/api/src/main/kotlin/nebulosa/api/inject/Inject.kt b/api/src/main/kotlin/nebulosa/api/inject/Inject.kt
new file mode 100644
index 000000000..fff13043d
--- /dev/null
+++ b/api/src/main/kotlin/nebulosa/api/inject/Inject.kt
@@ -0,0 +1,359 @@
+package nebulosa.api.inject
+
+import com.fasterxml.jackson.databind.ObjectMapper
+import io.javalin.Javalin
+import io.objectbox.BoxStore
+import io.objectbox.kotlin.boxFor
+import nebulosa.api.APP_DIR_KEY
+import nebulosa.api.alignment.polar.PolarAlignmentController
+import nebulosa.api.alignment.polar.PolarAlignmentService
+import nebulosa.api.alignment.polar.darv.DARVExecutor
+import nebulosa.api.alignment.polar.tppa.TPPAExecutor
+import nebulosa.api.atlas.*
+import nebulosa.api.atlas.ephemeris.BodyEphemerisProvider
+import nebulosa.api.atlas.ephemeris.HorizonsEphemerisProvider
+import nebulosa.api.autofocus.AutoFocusController
+import nebulosa.api.autofocus.AutoFocusExecutor
+import nebulosa.api.autofocus.AutoFocusService
+import nebulosa.api.calibration.CalibrationFrameController
+import nebulosa.api.calibration.CalibrationFrameEntity
+import nebulosa.api.calibration.CalibrationFrameRepository
+import nebulosa.api.calibration.CalibrationFrameService
+import nebulosa.api.cameras.CameraCaptureExecutor
+import nebulosa.api.cameras.CameraController
+import nebulosa.api.cameras.CameraEventHub
+import nebulosa.api.cameras.CameraService
+import nebulosa.api.confirmation.ConfirmationController
+import nebulosa.api.confirmation.ConfirmationService
+import nebulosa.api.connection.ConnectionController
+import nebulosa.api.connection.ConnectionEventHub
+import nebulosa.api.connection.ConnectionService
+import nebulosa.api.database.MyObjectBox
+import nebulosa.api.dustcap.DustCapController
+import nebulosa.api.dustcap.DustCapEventHub
+import nebulosa.api.dustcap.DustCapService
+import nebulosa.api.focusers.FocuserController
+import nebulosa.api.focusers.FocuserEventHub
+import nebulosa.api.focusers.FocuserService
+import nebulosa.api.framing.FramingController
+import nebulosa.api.framing.FramingService
+import nebulosa.api.guiding.*
+import nebulosa.api.image.ImageBucket
+import nebulosa.api.image.ImageController
+import nebulosa.api.image.ImageService
+import nebulosa.api.indi.INDIController
+import nebulosa.api.indi.INDIEventHandler
+import nebulosa.api.indi.INDIService
+import nebulosa.api.lightboxes.LightBoxController
+import nebulosa.api.lightboxes.LightBoxEventHub
+import nebulosa.api.lightboxes.LightBoxService
+import nebulosa.api.livestacker.LiveStackingController
+import nebulosa.api.livestacker.LiveStackingService
+import nebulosa.api.message.MessageService
+import nebulosa.api.mounts.MountController
+import nebulosa.api.mounts.MountEventHub
+import nebulosa.api.mounts.MountService
+import nebulosa.api.platesolver.PlateSolverController
+import nebulosa.api.platesolver.PlateSolverService
+import nebulosa.api.preference.PreferenceEntity
+import nebulosa.api.preference.PreferenceRepository
+import nebulosa.api.preference.PreferenceService
+import nebulosa.api.rotators.RotatorController
+import nebulosa.api.rotators.RotatorEventHub
+import nebulosa.api.rotators.RotatorService
+import nebulosa.api.sequencer.SequencerController
+import nebulosa.api.sequencer.SequencerExecutor
+import nebulosa.api.sequencer.SequencerService
+import nebulosa.api.stacker.StackerController
+import nebulosa.api.stacker.StackerService
+import nebulosa.api.stardetector.StarDetectionController
+import nebulosa.api.stardetector.StarDetectionService
+import nebulosa.api.wheels.WheelController
+import nebulosa.api.wheels.WheelEventHub
+import nebulosa.api.wheels.WheelService
+import nebulosa.api.wizard.flat.FlatWizardController
+import nebulosa.api.wizard.flat.FlatWizardExecutor
+import nebulosa.api.wizard.flat.FlatWizardService
+import nebulosa.guiding.Guider
+import nebulosa.guiding.phd2.PHD2Guider
+import nebulosa.hips2fits.Hips2FitsService
+import nebulosa.horizons.HorizonsService
+import nebulosa.log.loggerFor
+import nebulosa.phd2.client.PHD2Client
+import nebulosa.sbd.SmallBodyDatabaseService
+import nebulosa.simbad.SimbadService
+import nebulosa.time.SystemClock
+import nebulosa.util.concurrency.DaemonThreadFactory
+import okhttp3.Cache
+import okhttp3.ConnectionPool
+import okhttp3.OkHttpClient
+import okhttp3.logging.HttpLoggingInterceptor
+import org.greenrobot.eventbus.EventBus
+import org.koin.core.qualifier.named
+import org.koin.dsl.koinApplication
+import org.koin.dsl.module
+import java.nio.file.Path
+import java.time.LocalDate
+import java.time.format.DateTimeFormatter
+import java.util.concurrent.*
+import kotlin.io.path.*
+
+val koinApp = koinApplication {
+    modules(pathModule())
+    modules(coreModule())
+    modules(httpModule())
+    modules(eventBusModule())
+    modules(boxStoreModule())
+    modules(repositoriesModule())
+    modules(phd2Module())
+}
+
+object Named {
+
+    val appDir = named("appDir")
+    val logsDir = named("logsDir")
+    val dataDir = named("dataDir")
+    val capturesDir = named("capturesDir")
+    val sequencesDir = named("sequencesDir")
+    val cacheDir = named("cacheDir")
+    val libsDir = named("libsDir")
+    val defaultHttpClient = named("defaultHttpClient")
+    val alpacaHttpClient = named("alpacaHttpClient")
+    val mainBoxStore = named("mainBoxStore")
+    val simbadBoxStore = named("simbadBoxStore")
+    val calibrationFrameBox = named("calibrationFrameBox")
+    val preferenceBox = named("preferenceBox")
+    val satelliteBox = named("satelliteBox")
+    val simbadBox = named("simbadBox")
+}
+
+// PATH
+
+private fun Path.clearLogIfPastDays(days: Long = 7L) {
+    if (exists()) {
+        val pastDays = LocalDate.now(SystemClock).minusDays(days)
+
+        for (entry in listDirectoryEntries("nebulosa-*.log")) {
+            val logDate = entry.fileName.toString()
+                .replace("nebulosa-", "")
+                .replace(".log", "")
+                .let { runCatching { LocalDate.parse(it, DateTimeFormatter.ISO_LOCAL_DATE) }.getOrNull() }
+                ?: continue
+
+            if (pastDays.isAfter(logDate)) {
+                entry.deleteIfExists()
+            }
+        }
+    }
+}
+
+fun pathModule(root: Path = Path(requireNotNull(System.getProperty(APP_DIR_KEY)))) = module(true) {
+    single(Named.appDir) { root }
+    single(Named.logsDir) { Path("$root", "logs").createDirectories().clearLogIfPastDays() }
+    single(Named.dataDir) { Path("$root", "data").createDirectories() }
+    single(Named.capturesDir) { Path("$root", "captures").createDirectories() }
+    single(Named.sequencesDir) { Path("$root", "sequences").createDirectories() }
+    single(Named.cacheDir) { Path("$root", "cache").createDirectories() }
+    single(Named.libsDir) { Path("$root", "libs").createDirectories() }
+}
+
+// CORE
+
+fun coreModule() = module {
+    val numberOfCores = Runtime.getRuntime().availableProcessors()
+
+    single<ExecutorService> { ThreadPoolExecutor(numberOfCores, 32, 60L, TimeUnit.SECONDS, SynchronousQueue(), DaemonThreadFactory) }
+    single<ScheduledExecutorService> { Executors.newScheduledThreadPool(numberOfCores, DaemonThreadFactory) }
+}
+
+// HTTP
+
+private const val MAX_CACHE_SIZE = 1024L * 1024L * 32L // 32MB
+private val OKHTTP_LOG = loggerFor<OkHttpClient>()
+
+fun httpModule() = module {
+    single { ConnectionPool(32, 5L, TimeUnit.MINUTES) }
+    single { Cache(get<Path>(Named.cacheDir).toFile(), MAX_CACHE_SIZE) }
+    single { HttpLoggingInterceptor.Logger { OKHTTP_LOG.info(it) } }
+    single(Named.defaultHttpClient) {
+        OkHttpClient.Builder()
+            .connectionPool(get())
+            .cache(get())
+            .addInterceptor(HttpLoggingInterceptor(get()).setLevel(HttpLoggingInterceptor.Level.BASIC))
+            .readTimeout(60L, TimeUnit.SECONDS)
+            .writeTimeout(60L, TimeUnit.SECONDS)
+            .connectTimeout(60L, TimeUnit.SECONDS)
+            .callTimeout(60L, TimeUnit.SECONDS)
+            .build()
+    }
+    single(Named.alpacaHttpClient) {
+        OkHttpClient.Builder()
+            .connectionPool(get())
+            .readTimeout(90L, TimeUnit.SECONDS)
+            .writeTimeout(90L, TimeUnit.SECONDS)
+            .connectTimeout(90L, TimeUnit.SECONDS)
+            .callTimeout(90L, TimeUnit.SECONDS)
+            .build()
+    }
+}
+
+// EVENT BUS
+
+fun eventBusModule() = module {
+    single {
+        EventBus.builder()
+            .sendNoSubscriberEvent(false)
+            .sendSubscriberExceptionEvent(false)
+            .throwSubscriberException(false)
+            .logNoSubscriberMessages(false)
+            .logSubscriberExceptions(false)
+            .executorService(get())
+            .build()
+    }
+}
+
+// BOX STORE
+
+fun boxStoreModule() = module {
+    single(Named.mainBoxStore) {
+        MyObjectBox.builder()
+            .baseDirectory(get<Path>(Named.dataDir).toFile())
+            .name("main")
+            .build()!!
+    }
+    single(Named.simbadBoxStore) {
+        MyObjectBox.builder()
+            .baseDirectory(get<Path>(Named.dataDir).toFile())
+            .name("simbad")
+            .build()!!
+    }
+    single(Named.calibrationFrameBox) { get<BoxStore>(Named.mainBoxStore).boxFor<CalibrationFrameEntity>() }
+    single(Named.preferenceBox) { get<BoxStore>(Named.mainBoxStore).boxFor<PreferenceEntity>() }
+    single(Named.satelliteBox) { get<BoxStore>(Named.mainBoxStore).boxFor<SatelliteEntity>() }
+    single(Named.simbadBox) { get<BoxStore>(Named.simbadBoxStore).boxFor<SimbadEntity>() }
+}
+
+// OBJECT MAPPER
+
+fun objectMapperModule(mapper: ObjectMapper) = module {
+    single<ObjectMapper> { mapper }
+}
+
+// PHD2
+
+fun phd2Module() = module {
+    single { PHD2Client() }
+    single<Guider> { PHD2Guider(get()) }
+}
+
+// REPOSITORIES
+
+fun repositoriesModule() = module {
+    single { CalibrationFrameRepository(get(Named.calibrationFrameBox)) }
+    single { PreferenceRepository(get(Named.preferenceBox)) }
+    single { SatelliteRepository(get(Named.satelliteBox)) }
+    single { SimbadEntityRepository(get(Named.simbadBox)) }
+}
+
+// SERVICES
+
+fun eventHandlerModule() = module(true) {
+    single { CameraEventHub(get(), get()) }
+    single { MountEventHub(get(), get()) }
+    single { FocuserEventHub(get(), get()) }
+    single { WheelEventHub(get(), get()) }
+    single { GuideOutputEventHub(get(), get()) }
+    single { RotatorEventHub(get(), get()) }
+    single { LightBoxEventHub(get(), get()) }
+    single { DustCapEventHub(get(), get()) }
+    single { ConnectionEventHub(get(), get(), get(), get(), get(), get(), get(), get()) }
+    single { INDIEventHandler(get(), get()) }
+}
+
+fun tasksModule() = module(true) {
+    single { IERSUpdateTask(get(Named.dataDir), get(Named.defaultHttpClient), get(), get()) }
+    single { SkyAtlasUpdateTask(get(Named.defaultHttpClient), get(), get(), get(), get()) }
+    single { SatelliteUpdateTask(get(Named.defaultHttpClient), get(), get(), get(), get()) }
+    single { LibWCSDownloadTask(get(Named.libsDir), get(Named.defaultHttpClient), get(), get()) }
+}
+
+fun servicesModule() = module {
+    single { HorizonsService(httpClient = get(Named.defaultHttpClient)) }
+    single { SimbadService(httpClient = get(Named.defaultHttpClient)) }
+    single { SmallBodyDatabaseService(httpClient = get(Named.defaultHttpClient)) }
+    single { Hips2FitsService(httpClient = get(Named.defaultHttpClient)) }
+    single(createdAtStart = true) { MessageService(get()) }
+    includes(eventHandlerModule())
+    single(createdAtStart = true) { ConnectionService(get(), get(Named.alpacaHttpClient), get(), get()) }
+    single { ConfirmationService(get()) }
+    single { RotatorService(get()) }
+    single { FocuserService(get()) }
+    single { WheelService(get()) }
+    single { GuideOutputService(get()) }
+    single { LightBoxService(get()) }
+    single { DustCapService(get()) }
+    single { ImageBucket(get()) }
+    single { CalibrationFrameService(get()) }
+    single { FramingService(get(), get()) }
+    single { ImageService(get(), get(), get(), get(), get(), get(), get(), get(), get()) }
+    single { PlateSolverService(get()) }
+    single { FlatWizardExecutor(get(), get(), get()) }
+    single { FlatWizardService(get(Named.capturesDir), get()) }
+    single { StarDetectionService() }
+    single { AutoFocusExecutor(get(), get(), get()) }
+    single { AutoFocusService(get()) }
+    single { LiveStackingService() }
+    single { StackerService(get()) }
+    single { FramingService(get(), get()) }
+    single { INDIService(get()) }
+    single { DARVExecutor(get(), get(), get()) }
+    single { TPPAExecutor(get(), get(), get()) }
+    single { PolarAlignmentService(get(), get()) }
+    single { PreferenceService(get(), get()) }
+    single { GuidingService(get(), get(), get(), get()) }
+    single { SequencerExecutor(get(), get(), get(), get(), get()) }
+    single { SequencerService(get(Named.sequencesDir), get()) }
+    single { MoonPhaseFinder(get()) }
+    single { HorizonsEphemerisProvider(get()) }
+    single { BodyEphemerisProvider(get()) }
+    single { SkyAtlasService(get(), get(), get(), get(), get(), get(Named.defaultHttpClient), get(), get(), get()) }
+    single { MountService(get(), get(), get(), get(), get()) }
+    single { CameraCaptureExecutor(get(), get(), get(), get(), get()) }
+    single { CameraService(get(Named.capturesDir), get(), get()) }
+    includes(tasksModule())
+}
+
+// CONTROLLERS
+
+fun controllersModule() = module(true) {
+    single { ConnectionController(get(), get()) }
+    single { ConfirmationController(get(), get()) }
+    single { RotatorController(get(), get(), get()) }
+    single { FocuserController(get(), get(), get()) }
+    single { WheelController(get(), get(), get()) }
+    single { GuideOutputController(get(), get(), get()) }
+    single { LightBoxController(get(), get(), get()) }
+    single { DustCapController(get(), get(), get()) }
+    single { CalibrationFrameController(get(), get()) }
+    single { ImageController(get(), get(), get()) }
+    single { PlateSolverController(get(), get()) }
+    single { FlatWizardController(get(), get(), get()) }
+    single { StarDetectionController(get(), get()) }
+    single { AutoFocusController(get(), get(), get()) }
+    single { LiveStackingController(get(), get(), get()) }
+    single { StackerController(get(), get()) }
+    single { FramingController(get(), get(), get()) }
+    single { INDIController(get(), get(), get()) }
+    single { PolarAlignmentController(get(), get(), get()) }
+    single { GuidingController(get(), get()) }
+    single { SequencerController(get(), get(), get()) }
+    single { SkyAtlasController(get(), get(), get()) }
+    single { MountController(get(), get(), get()) }
+    single { CameraController(get(), get(), get()) }
+}
+
+// APP
+
+fun appModule(app: Javalin) = module(true) {
+    single { app }
+}
diff --git a/api/src/main/kotlin/nebulosa/api/javalin/Headers.kt b/api/src/main/kotlin/nebulosa/api/javalin/Headers.kt
new file mode 100644
index 000000000..1b91e2d98
--- /dev/null
+++ b/api/src/main/kotlin/nebulosa/api/javalin/Headers.kt
@@ -0,0 +1,17 @@
+@file:Suppress("NOTHING_TO_INLINE")
+
+package nebulosa.api.javalin
+
+import io.javalin.http.Context
+import io.javalin.json.fromJsonString
+import nebulosa.api.atlas.Location
+import java.util.concurrent.ConcurrentHashMap
+
+const val X_LOCATION_HEADER_KEY = "X-Location"
+const val X_IDEMPOTENCY_HEADER_KEY = "X-Idempotency-Key"
+
+@PublishedApi internal val CACHED_LOCATION = ConcurrentHashMap<String, Location>(4)
+
+inline fun Context.location() =
+    header(X_LOCATION_HEADER_KEY)?.let { value -> CACHED_LOCATION.computeIfAbsent(value) { jsonMapper().fromJsonString<Location>(it) } }
+inline fun Context.idempotencyKey() = header(X_IDEMPOTENCY_HEADER_KEY)
diff --git a/api/src/main/kotlin/nebulosa/api/javalin/Queries.kt b/api/src/main/kotlin/nebulosa/api/javalin/Queries.kt
new file mode 100644
index 000000000..d7dbfb2df
--- /dev/null
+++ b/api/src/main/kotlin/nebulosa/api/javalin/Queries.kt
@@ -0,0 +1,13 @@
+@file:Suppress("NOTHING_TO_INLINE")
+
+package nebulosa.api.javalin
+
+import io.javalin.http.Context
+import nebulosa.time.SystemClock
+import java.time.LocalDate
+import java.time.LocalTime
+
+inline fun Context.localDate(): LocalDate = localDateOrNull() ?: LocalDate.now(SystemClock)
+inline fun Context.localDateOrNull() = queryParam("date")?.let(LocalDate::parse)
+inline fun Context.localTime(): LocalTime = localTimeOrNull() ?: LocalTime.now(SystemClock)
+inline fun Context.localTimeOrNull() = queryParam("time")?.let(LocalTime::parse)
diff --git a/api/src/main/kotlin/nebulosa/api/javalin/Validatable.kt b/api/src/main/kotlin/nebulosa/api/javalin/Validatable.kt
new file mode 100644
index 000000000..d72be300c
--- /dev/null
+++ b/api/src/main/kotlin/nebulosa/api/javalin/Validatable.kt
@@ -0,0 +1,6 @@
+package nebulosa.api.javalin
+
+fun interface Validatable {
+
+    fun validate()
+}
diff --git a/api/src/main/kotlin/nebulosa/api/javalin/Validators.kt b/api/src/main/kotlin/nebulosa/api/javalin/Validators.kt
new file mode 100644
index 000000000..27d493191
--- /dev/null
+++ b/api/src/main/kotlin/nebulosa/api/javalin/Validators.kt
@@ -0,0 +1,74 @@
+@file:Suppress("NOTHING_TO_INLINE")
+
+package nebulosa.api.javalin
+
+import java.nio.file.Path
+import java.time.Duration
+import java.util.concurrent.TimeUnit
+import kotlin.io.path.Path
+import kotlin.io.path.exists
+
+// https://github.com/hibernate/hibernate-validator/blob/main/engine/src/main/resources/org/hibernate/validator/ValidationMessages.properties
+
+inline fun <T> T.validate(value: Boolean, lazyMessage: () -> String) = apply { require(value, lazyMessage) }
+
+// ANY
+
+inline fun <T> T?.notNull() = requireNotNull(this) { "must not be null" }
+
+// TEXT
+
+inline fun String.notEmpty() = validate(isNotEmpty()) { "must not be empty" }
+inline fun String.notBlank() = validate(isNotBlank()) { "must not be blank" }
+inline fun String.minLength(min: Int) = validate(length >= min) { "length must be greater than or equal to $min" }
+inline fun String.maxLength(max: Int) = validate(length <= max) { "length must be greater than or equal to $max" }
+inline fun String.regex(pattern: Regex) = validate(pattern.matches(this)) { "must match \"$pattern\"" }
+
+// INT
+
+inline fun Int.min(min: Int) = validate(this >= min) { "must be greater than or equal to $min" }
+inline fun Int.max(max: Int) = validate(this <= max) { "must be less than or equal to $max" }
+inline fun Int.range(min: Int, max: Int) = validate(this in min..max) { " must be between $min and $max" }
+inline fun Int.positive() = validate(this > 0) { "must be greater than 0" }
+inline fun Int.positiveOrZero() = validate(this >= 0) { "must be greater than or equal to 0" }
+
+// LONG
+
+inline fun Long.min(min: Long) = validate(this >= min) { "must be greater than or equal to $min" }
+inline fun Long.max(max: Long) = validate(this <= max) { "must be less than or equal to $max" }
+inline fun Long.range(min: Long, max: Long) = validate(this in min..max) { " must be between $min and $max" }
+inline fun Long.positive() = validate(this > 0) { "must be greater than 0" }
+inline fun Long.positiveOrZero() = validate(this >= 0) { "must be greater than or equal to 0" }
+
+// DOUBLE
+
+inline fun Double.min(min: Double) = validate(this >= min) { "must be greater than or equal to $min" }
+inline fun Double.max(max: Double) = validate(this <= max) { "must be less than or equal to $max" }
+inline fun Double.range(min: Double, max: Double) = validate(this in min..max) { " must be between $min and $max" }
+inline fun Double.positive() = validate(this > 0) { "must be greater than 0" }
+inline fun Double.positiveOrZero() = validate(this >= 0) { "must be greater than or equal to 0" }
+
+// PATH
+
+inline fun String.path() = Path(this)
+inline fun Path.exists() = validate(exists()) { "must exist" }
+
+// DURATION
+
+inline fun Duration.positive() = validate(!isNegative && !isZero) { "must be greater than 0" }
+inline fun Duration.positiveOrZero() = validate(!isNegative) { "must be greater than or equal to 0" }
+
+inline fun Duration.min(duration: Long, unit: TimeUnit) =
+    validate(toNanos() >= unit.toNanos(duration)) { "must be greater than or equal to $duration $unit" }
+
+inline fun Duration.max(duration: Long, unit: TimeUnit) =
+    validate(toNanos() <= unit.toNanos(duration)) { "must be less than or equal to $duration $unit" }
+
+// COLLECTION
+
+inline fun <T> Collection<T>.notEmpty() = validate(isNotEmpty()) { "must not be empty" }
+inline fun <T> Collection<T>.minSize(min: Int) = validate(size >= min) { "size must be greater than or equal to $min" }
+
+// BODY
+
+inline fun <T : Validatable> T.valid() = apply(Validatable::validate)
diff --git a/api/src/main/kotlin/nebulosa/api/lightboxes/LightBoxController.kt b/api/src/main/kotlin/nebulosa/api/lightboxes/LightBoxController.kt
index 2a0c06962..5ced8c4c3 100644
--- a/api/src/main/kotlin/nebulosa/api/lightboxes/LightBoxController.kt
+++ b/api/src/main/kotlin/nebulosa/api/lightboxes/LightBoxController.kt
@@ -1,61 +1,71 @@
 package nebulosa.api.lightboxes
 
-import jakarta.validation.Valid
-import jakarta.validation.constraints.PositiveOrZero
+import io.javalin.Javalin
+import io.javalin.http.Context
 import nebulosa.api.connection.ConnectionService
-import nebulosa.indi.device.lightbox.LightBox
-import org.springframework.validation.annotation.Validated
-import org.springframework.web.bind.annotation.GetMapping
-import org.springframework.web.bind.annotation.PutMapping
-import org.springframework.web.bind.annotation.RequestMapping
-import org.springframework.web.bind.annotation.RequestParam
-import org.springframework.web.bind.annotation.RestController
-
-@Validated
-@RestController
-@RequestMapping("light-boxes")
+import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.positiveOrZero
+
 class LightBoxController(
+    app: Javalin,
     private val connectionService: ConnectionService,
     private val lightBoxService: LightBoxService,
 ) {
 
-    @GetMapping
-    fun lightBoxes(): List<LightBox> {
-        return connectionService.lightBoxes().sorted()
+    init {
+        app.get("light-boxes", ::lightBoxes)
+        app.get("light-boxes/{id}", ::lightBox)
+        app.put("light-boxes/{id}/connect", ::connect)
+        app.put("light-boxes/{id}/disconnect", ::disconnect)
+        app.put("light-boxes/{id}/enable", ::enable)
+        app.put("light-boxes/{id}/disable", ::disable)
+        app.put("light-boxes/{id}/brightness", ::brightness)
+        app.put("light-boxes/{id}/listen", ::listen)
+    }
+
+    private fun lightBoxes(ctx: Context) {
+        ctx.json(connectionService.lightBoxes().sorted())
     }
 
-    @GetMapping("{lightBox}")
-    fun lightBox(lightBox: LightBox): LightBox {
-        return lightBox
+    private fun lightBox(ctx: Context) {
+        val id = ctx.pathParam("id")
+        connectionService.lightBox(id)?.also(ctx::json)
     }
 
-    @PutMapping("{lightBox}/connect")
-    fun connect(lightBox: LightBox) {
+    private fun connect(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val lightBox = connectionService.lightBox(id) ?: return
         lightBoxService.connect(lightBox)
     }
 
-    @PutMapping("{lightBox}/disconnect")
-    fun disconnect(lightBox: LightBox) {
+    private fun disconnect(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val lightBox = connectionService.lightBox(id) ?: return
         lightBoxService.disconnect(lightBox)
     }
 
-    @PutMapping("{lightBox}/enable")
-    fun enable(lightBox: LightBox) {
+    private fun enable(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val lightBox = connectionService.lightBox(id) ?: return
         lightBoxService.enable(lightBox)
     }
 
-    @PutMapping("{lightBox}/disable")
-    fun disable(lightBox: LightBox) {
+    private fun disable(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val lightBox = connectionService.lightBox(id) ?: return
         lightBoxService.disable(lightBox)
     }
 
-    @PutMapping("{lightBox}/brightness")
-    fun brightness(lightBox: LightBox, @RequestParam @Valid @PositiveOrZero intensity: Double) {
+    private fun brightness(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val lightBox = connectionService.lightBox(id) ?: return
+        val intensity = ctx.queryParam("intensity").notNull().toDouble().positiveOrZero()
         lightBoxService.brightness(lightBox, intensity)
     }
 
-    @PutMapping("{lightBox}/listen")
-    fun listen(lightBox: LightBox) {
+    private fun listen(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val lightBox = connectionService.lightBox(id) ?: return
         lightBoxService.listen(lightBox)
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/lightboxes/LightBoxDeserializer.kt b/api/src/main/kotlin/nebulosa/api/lightboxes/LightBoxDeserializer.kt
index b5fd818c5..acf0590bd 100644
--- a/api/src/main/kotlin/nebulosa/api/lightboxes/LightBoxDeserializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/lightboxes/LightBoxDeserializer.kt
@@ -3,14 +3,10 @@ package nebulosa.api.lightboxes
 import nebulosa.api.connection.ConnectionService
 import nebulosa.api.devices.DeviceDeserializer
 import nebulosa.indi.device.lightbox.LightBox
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.context.annotation.Lazy
-import org.springframework.stereotype.Component
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.get
 
-@Component
-class LightBoxDeserializer : DeviceDeserializer<LightBox>(LightBox::class.java) {
+class LightBoxDeserializer : DeviceDeserializer<LightBox>(LightBox::class.java), KoinComponent {
 
-    @Autowired @Lazy private lateinit var connectionService: ConnectionService
-
-    override fun deviceFor(name: String) = connectionService.lightBox(name)
+    override fun deviceFor(name: String) = get<ConnectionService>().lightBox(name)
 }
diff --git a/api/src/main/kotlin/nebulosa/api/lightboxes/LightBoxEventHub.kt b/api/src/main/kotlin/nebulosa/api/lightboxes/LightBoxEventHub.kt
index 85d85fc1a..479e9b31f 100644
--- a/api/src/main/kotlin/nebulosa/api/lightboxes/LightBoxEventHub.kt
+++ b/api/src/main/kotlin/nebulosa/api/lightboxes/LightBoxEventHub.kt
@@ -1,6 +1,5 @@
 package nebulosa.api.lightboxes
 
-import nebulosa.api.beans.annotations.Subscriber
 import nebulosa.api.devices.DeviceEventHub
 import nebulosa.api.message.MessageService
 import nebulosa.indi.device.DeviceType
@@ -9,16 +8,19 @@ import nebulosa.indi.device.lightbox.LightBox
 import nebulosa.indi.device.lightbox.LightBoxAttached
 import nebulosa.indi.device.lightbox.LightBoxDetached
 import nebulosa.indi.device.lightbox.LightBoxEvent
+import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode
-import org.springframework.stereotype.Component
 
-@Component
-@Subscriber
 class LightBoxEventHub(
     private val messageService: MessageService,
+    eventBus: EventBus,
 ) : DeviceEventHub<LightBox, LightBoxEvent>(DeviceType.LIGHT_BOX), LightBoxEventAware {
 
+    init {
+        eventBus.register(this)
+    }
+
     @Subscribe(threadMode = ThreadMode.ASYNC)
     override fun handleLightBoxEvent(event: LightBoxEvent) {
         if (event.device.type == DeviceType.LIGHT_BOX) {
diff --git a/api/src/main/kotlin/nebulosa/api/lightboxes/LightBoxSerializer.kt b/api/src/main/kotlin/nebulosa/api/lightboxes/LightBoxSerializer.kt
index 3b9658707..ce2e45617 100644
--- a/api/src/main/kotlin/nebulosa/api/lightboxes/LightBoxSerializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/lightboxes/LightBoxSerializer.kt
@@ -3,9 +3,7 @@ package nebulosa.api.lightboxes
 import com.fasterxml.jackson.core.JsonGenerator
 import nebulosa.api.devices.DeviceSerializer
 import nebulosa.indi.device.lightbox.LightBox
-import org.springframework.stereotype.Component
 
-@Component
 class LightBoxSerializer : DeviceSerializer<LightBox>(LightBox::class.java) {
 
     override fun JsonGenerator.serialize(value: LightBox) {
diff --git a/api/src/main/kotlin/nebulosa/api/lightboxes/LightBoxService.kt b/api/src/main/kotlin/nebulosa/api/lightboxes/LightBoxService.kt
index ee861e4f2..64ed6bc50 100644
--- a/api/src/main/kotlin/nebulosa/api/lightboxes/LightBoxService.kt
+++ b/api/src/main/kotlin/nebulosa/api/lightboxes/LightBoxService.kt
@@ -1,9 +1,7 @@
 package nebulosa.api.lightboxes
 
 import nebulosa.indi.device.lightbox.LightBox
-import org.springframework.stereotype.Service
 
-@Service
 class LightBoxService(private val lightBoxEventHub: LightBoxEventHub) {
 
     fun connect(lightBox: LightBox) {
diff --git a/api/src/main/kotlin/nebulosa/api/livestacker/LiveStackingController.kt b/api/src/main/kotlin/nebulosa/api/livestacker/LiveStackingController.kt
index 03acb8096..ff2428325 100644
--- a/api/src/main/kotlin/nebulosa/api/livestacker/LiveStackingController.kt
+++ b/api/src/main/kotlin/nebulosa/api/livestacker/LiveStackingController.kt
@@ -1,27 +1,40 @@
 package nebulosa.api.livestacker
 
-import jakarta.validation.Valid
-import jakarta.validation.constraints.NotBlank
-import nebulosa.indi.device.camera.Camera
-import org.springframework.web.bind.annotation.*
-import java.nio.file.Path
+import io.javalin.Javalin
+import io.javalin.http.Context
+import io.javalin.http.bodyAsClass
+import nebulosa.api.connection.ConnectionService
+import nebulosa.api.javalin.exists
+import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.path
+import nebulosa.api.javalin.valid
 
-@RestController
-@RequestMapping("live-stacking")
-class LiveStackingController(private val liveStackingService: LiveStackingService) {
+class LiveStackingController(
+    app: Javalin,
+    private val liveStackingService: LiveStackingService,
+    private val connectionService: ConnectionService,
+) {
 
-    @PutMapping("{camera}/start")
-    fun start(camera: Camera, @RequestBody body: LiveStackingRequest) {
+    init {
+        app.put("live-stacking/{camera}/start", ::start)
+        app.put("live-stacking/{camera}/add", ::add)
+        app.put("live-stacking/{camera}/stop", ::stop)
+    }
+
+    private fun start(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")).notNull()
+        val body = ctx.bodyAsClass<LiveStackingRequest>().valid()
         liveStackingService.start(camera, body)
     }
 
-    @PutMapping("{camera}/add")
-    fun add(camera: Camera, @RequestParam @Valid @NotBlank path: Path): Path? {
-        return liveStackingService.add(camera, path)
+    private fun add(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")).notNull()
+        val path = ctx.queryParam("path").notNull().path().exists()
+        liveStackingService.add(camera, path)?.also(ctx::json)
     }
 
-    @PutMapping("{camera}/stop")
-    fun stop(camera: Camera) {
+    private fun stop(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")).notNull()
         liveStackingService.stop(camera)
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/livestacker/LiveStackingRequest.kt b/api/src/main/kotlin/nebulosa/api/livestacker/LiveStackingRequest.kt
index 0a11ff617..29b04b1be 100644
--- a/api/src/main/kotlin/nebulosa/api/livestacker/LiveStackingRequest.kt
+++ b/api/src/main/kotlin/nebulosa/api/livestacker/LiveStackingRequest.kt
@@ -1,6 +1,8 @@
 package nebulosa.api.livestacker
 
-import jakarta.validation.constraints.NotNull
+import nebulosa.api.javalin.Validatable
+import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.positiveOrZero
 import nebulosa.livestacker.LiveStacker
 import nebulosa.pixinsight.livestacker.PixInsightLiveStacker
 import nebulosa.pixinsight.script.startPixInsight
@@ -10,14 +12,19 @@ import java.nio.file.Path
 data class LiveStackingRequest(
     @JvmField val enabled: Boolean = false,
     @JvmField val type: LiveStackerType = LiveStackerType.SIRIL,
-    @JvmField @field:NotNull val executablePath: Path? = null,
+    @JvmField val executablePath: Path? = null,
     @JvmField val darkPath: Path? = null,
     @JvmField val flatPath: Path? = null,
     @JvmField val biasPath: Path? = null,
     @JvmField val use32Bits: Boolean = false,
     @JvmField val slot: Int = 1,
     @JvmField val useCalibrationGroup: Boolean = false,
-) {
+) : Validatable {
+
+    override fun validate() {
+        executablePath.notNull()
+        slot.positiveOrZero()
+    }
 
     fun get(workingDirectory: Path): LiveStacker {
         return when (type) {
diff --git a/api/src/main/kotlin/nebulosa/api/livestacker/LiveStackingService.kt b/api/src/main/kotlin/nebulosa/api/livestacker/LiveStackingService.kt
index eab12d85f..a481ae07a 100644
--- a/api/src/main/kotlin/nebulosa/api/livestacker/LiveStackingService.kt
+++ b/api/src/main/kotlin/nebulosa/api/livestacker/LiveStackingService.kt
@@ -2,13 +2,11 @@ package nebulosa.api.livestacker
 
 import nebulosa.indi.device.camera.Camera
 import nebulosa.livestacker.LiveStacker
-import org.springframework.stereotype.Service
 import java.nio.file.Files
 import java.nio.file.Path
 import java.util.concurrent.ConcurrentHashMap
 import kotlin.io.path.deleteRecursively
 
-@Service
 class LiveStackingService {
 
     private val liveStackers = ConcurrentHashMap<Camera, Pair<LiveStacker, Path>>(2)
diff --git a/api/src/main/kotlin/nebulosa/api/message/MessageService.kt b/api/src/main/kotlin/nebulosa/api/message/MessageService.kt
index 2d3761a2e..97ed8f011 100644
--- a/api/src/main/kotlin/nebulosa/api/message/MessageService.kt
+++ b/api/src/main/kotlin/nebulosa/api/message/MessageService.kt
@@ -1,53 +1,66 @@
 package nebulosa.api.message
 
-import nebulosa.log.debug
+import io.javalin.Javalin
+import io.javalin.websocket.WsConfig
+import io.javalin.websocket.WsContext
 import nebulosa.log.loggerFor
-import org.springframework.context.event.EventListener
-import org.springframework.messaging.simp.SimpMessageHeaderAccessor
-import org.springframework.messaging.simp.SimpMessagingTemplate
-import org.springframework.stereotype.Service
-import org.springframework.web.socket.messaging.SessionDisconnectEvent
-import org.springframework.web.socket.messaging.SessionSubscribeEvent
+import org.eclipse.jetty.websocket.api.Session
 import java.util.concurrent.LinkedBlockingQueue
-import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicReference
+import java.util.function.Consumer
 
-@Service
-class MessageService(
-    private val simpleMessageTemplate: SimpMessagingTemplate,
-) {
+class MessageService(app: Javalin) : Consumer<WsConfig> {
 
-    private val connected = AtomicBoolean()
+    private val connected = AtomicReference<Session>()
+    private val context = AtomicReference<WsContext>()
     private val messageQueue = LinkedBlockingQueue<MessageEvent>()
 
-    @EventListener
-    private fun handleSessionSubscribe(event: SessionSubscribeEvent) {
-        val destination = SimpMessageHeaderAccessor.wrap(event.message).destination ?: return
+    init {
+        app.ws("/ws", this)
+    }
+
+    override fun accept(ws: WsConfig) {
+        ws.onConnect {
+            if (connected.compareAndSet(null, it.session)) {
+                LOG.info("web socket session accepted. address={}", it.session.remoteAddress)
+
+                context.set(it)
+                it.enableAutomaticPings()
 
-        if (destination == DESTINATION && connected.compareAndSet(false, true)) {
-            while (messageQueue.isNotEmpty()) {
-                sendMessage(messageQueue.take())
+                while (messageQueue.isNotEmpty()) {
+                    sendMessage(messageQueue.take())
+                }
+            } else {
+                LOG.warn("web socket session rejected. address={}", it.session.remoteAddress)
+
+                // Accepts only one connection.
+                it.closeSession()
             }
         }
-    }
 
-    @EventListener
-    private fun handleSessionDisconnect(event: SessionDisconnectEvent) {
-        connected.set(false)
+        ws.onClose {
+            if (connected.compareAndSet(it.session, null)) {
+                it.disableAutomaticPings()
+                context.set(null)
+                LOG.info("web socket session closed. address={}, status={}, reason={}", it.session.remoteAddress, it.status(), it.reason())
+            }
+        }
     }
 
     fun sendMessage(event: MessageEvent) {
-        if (connected.get()) {
-            simpleMessageTemplate.convertAndSend(DESTINATION, event)
+        val context = context.get()
+
+        if (context != null) {
+            LOG.debug("sending message. event={}", event)
+            context.send(event)
         } else if (event is QueueableEvent) {
-            LOG.debug { "queueing message. event=$event" }
+            LOG.debug("queueing message. event={}", event)
             messageQueue.offer(event)
         }
     }
 
     companion object {
 
-        const val DESTINATION = "NEBULOSA.EVENT"
-
         @JvmStatic private val LOG = loggerFor<MessageService>()
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/mounts/MountController.kt b/api/src/main/kotlin/nebulosa/api/mounts/MountController.kt
index 3a6edf283..f43f34824 100644
--- a/api/src/main/kotlin/nebulosa/api/mounts/MountController.kt
+++ b/api/src/main/kotlin/nebulosa/api/mounts/MountController.kt
@@ -1,160 +1,177 @@
 package nebulosa.api.mounts
 
-import jakarta.validation.Valid
-import jakarta.validation.constraints.NotBlank
-import jakarta.validation.constraints.Positive
-import jakarta.validation.constraints.PositiveOrZero
-import nebulosa.api.beans.converters.angle.AngleParam
-import nebulosa.api.beans.converters.time.DateAndTimeParam
+import io.javalin.Javalin
+import io.javalin.http.Context
 import nebulosa.api.connection.ConnectionService
+import nebulosa.api.javalin.*
 import nebulosa.guiding.GuideDirection
-import nebulosa.indi.device.mount.Mount
 import nebulosa.indi.device.mount.TrackMode
-import nebulosa.math.Angle
 import nebulosa.math.deg
 import nebulosa.math.hours
 import nebulosa.math.m
-import org.hibernate.validator.constraints.Range
-import org.springframework.web.bind.annotation.*
-import java.nio.file.Path
 import java.time.LocalDateTime
 import java.time.OffsetDateTime
 import java.time.ZoneOffset
 
-@RestController
-@RequestMapping("mounts")
 class MountController(
+    app: Javalin,
     private val connectionService: ConnectionService,
     private val mountService: MountService,
 ) {
 
-    @GetMapping
-    fun mounts(): List<Mount> {
-        return connectionService.mounts().sorted()
-    }
-
-    @GetMapping("{mount}")
-    fun mount(mount: Mount): Mount {
-        return mount
-    }
-
-    @PutMapping("{mount}/connect")
-    fun connect(mount: Mount) {
+    init {
+        app.get("mounts", ::mounts)
+        app.get("mounts/{id}", ::mount)
+        app.put("mounts/{id}/connect", ::connect)
+        app.put("mounts/{id}/disconnect", ::disconnect)
+        app.put("mounts/{id}/tracking", ::tracking)
+        app.put("mounts/{id}/sync", ::sync)
+        app.put("mounts/{id}/slew", ::slew)
+        app.put("mounts/{id}/goto", ::goTo)
+        app.put("mounts/{id}/home", ::home)
+        app.put("mounts/{id}/abort", ::abort)
+        app.put("mounts/{id}/track-mode", ::trackMode)
+        app.put("mounts/{id}/slew-rate", ::slewRate)
+        app.put("mounts/{id}/move", ::move)
+        app.put("mounts/{id}/park", ::park)
+        app.put("mounts/{id}/unpark", ::unpark)
+        app.put("mounts/{id}/coordinates", ::coordinates)
+        app.put("mounts/{id}/datetime", ::dateTime)
+        app.get("mounts/{id}/location", ::location)
+        app.get("mounts/{id}/location/{type}", ::celestialLocation)
+        app.put("mounts/{id}/point-here", ::pointMountHere)
+        app.get("mounts/{id}/remote-control", ::remoteControlList)
+        app.put("mounts/{id}/remote-control/start", ::remoteControlStart)
+        app.put("mounts/{id}/remote-control/stop", ::remoteControlStop)
+        app.put("mounts/{id}/listen", ::listen)
+    }
+
+    private fun mounts(ctx: Context) {
+        ctx.json(connectionService.mounts().sorted())
+    }
+
+    private fun mount(ctx: Context) {
+        val id = ctx.pathParam("id")
+        connectionService.mount(id)?.also(ctx::json)
+    }
+
+    private fun connect(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
         mountService.connect(mount)
     }
 
-    @PutMapping("{mount}/disconnect")
-    fun disconnect(mount: Mount) {
+    private fun disconnect(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
         mountService.disconnect(mount)
     }
 
-    @PutMapping("{mount}/tracking")
-    fun tracking(
-        mount: Mount,
-        @RequestParam enabled: Boolean,
-    ) {
+    private fun tracking(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
+        val enabled = ctx.queryParam("enabled").notNull().toBoolean()
         mountService.tracking(mount, enabled)
     }
 
-    @PutMapping("{mount}/sync")
-    fun sync(
-        mount: Mount,
-        @RequestParam @Valid @NotBlank rightAscension: String,
-        @RequestParam @Valid @NotBlank declination: String,
-        @RequestParam(required = false, defaultValue = "false") j2000: Boolean,
-    ) {
+    private fun sync(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
+        val rightAscension = ctx.queryParam("rightAscension").notNull().notBlank()
+        val declination = ctx.queryParam("declination").notNull().notBlank()
+        val j2000 = ctx.queryParam("j2000")?.toBoolean() ?: false
         mountService.sync(mount, rightAscension.hours, declination.deg, j2000)
     }
 
-    @PutMapping("{mount}/slew")
-    fun slew(
-        mount: Mount,
-        @RequestParam @Valid @NotBlank rightAscension: String,
-        @RequestParam @Valid @NotBlank declination: String,
-        @RequestParam(required = false, defaultValue = "false") j2000: Boolean,
-        @RequestHeader("X-Idempotency-Key") idempotencyKey: String?,
-    ) {
+    private fun slew(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
+        val rightAscension = ctx.queryParam("rightAscension").notNull().notBlank()
+        val declination = ctx.queryParam("declination").notNull().notBlank()
+        val j2000 = ctx.queryParam("j2000")?.toBoolean() ?: false
+        val idempotencyKey = ctx.idempotencyKey()
         mountService.slewTo(mount, rightAscension.hours, declination.deg, j2000, idempotencyKey)
     }
 
-    @PutMapping("{mount}/goto")
-    fun goTo(
-        mount: Mount,
-        @RequestParam @Valid @NotBlank rightAscension: String,
-        @RequestParam @Valid @NotBlank declination: String,
-        @RequestParam(required = false, defaultValue = "false") j2000: Boolean,
-        @RequestHeader("X-Idempotency-Key") idempotencyKey: String?,
-    ) {
+    private fun goTo(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
+        val rightAscension = ctx.queryParam("rightAscension").notNull().notBlank()
+        val declination = ctx.queryParam("declination").notNull().notBlank()
+        val j2000 = ctx.queryParam("j2000")?.toBoolean() ?: false
+        val idempotencyKey = ctx.idempotencyKey()
         mountService.goTo(mount, rightAscension.hours, declination.deg, j2000, idempotencyKey)
     }
 
-    @PutMapping("{mount}/home")
-    fun home(mount: Mount) {
+    private fun home(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
         mountService.home(mount)
     }
 
-    @PutMapping("{mount}/abort")
-    fun abort(mount: Mount) {
+    private fun abort(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
         mountService.abort(mount)
     }
 
-    @PutMapping("{mount}/track-mode")
-    fun trackMode(
-        mount: Mount,
-        @RequestParam mode: TrackMode,
-    ) {
+    private fun trackMode(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
+        val mode = ctx.queryParam("mode").notNull().notBlank().let(TrackMode::valueOf)
         mountService.trackMode(mount, mode)
     }
 
-    @PutMapping("{mount}/slew-rate")
-    fun slewRate(
-        mount: Mount,
-        @RequestParam @Valid @NotBlank rate: String,
-    ) {
+    private fun slewRate(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
+        val rate = ctx.queryParam("rate").notNull().notBlank()
         mountService.slewRate(mount, mount.slewRates.first { it.name == rate })
     }
 
-    @PutMapping("{mount}/move")
-    fun move(
-        mount: Mount,
-        @RequestParam direction: GuideDirection,
-        @RequestParam enabled: Boolean,
-    ) {
+    private fun move(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
+        val direction = ctx.queryParam("direction").notNull().notBlank().let(GuideDirection::valueOf)
+        val enabled = ctx.queryParam("enabled").notNull().toBoolean()
         mountService.move(mount, direction, enabled)
     }
 
-    @PutMapping("{mount}/park")
-    fun park(mount: Mount) {
+    private fun park(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
         mountService.park(mount)
     }
 
-    @PutMapping("{mount}/unpark")
-    fun unpark(mount: Mount) {
+    private fun unpark(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
         mountService.unpark(mount)
     }
 
-    @PutMapping("{mount}/coordinates")
-    fun coordinates(
-        mount: Mount,
-        @RequestParam @Valid @NotBlank longitude: String,
-        @RequestParam @Valid @NotBlank latitude: String,
-        @RequestParam(required = false, defaultValue = "0.0") elevation: Double,
-    ) {
+    private fun coordinates(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
+        val longitude = ctx.queryParam("longitude").notNull().notBlank()
+        val latitude = ctx.queryParam("latitude").notNull().notBlank()
+        val elevation = ctx.queryParam("elevation")?.toDouble() ?: 0.0
         mountService.coordinates(mount, longitude.deg, latitude.deg, elevation.m)
     }
 
-    @PutMapping("{mount}/datetime")
-    fun dateTime(
-        mount: Mount,
-        @DateAndTimeParam dateTime: LocalDateTime,
-        @RequestParam @Valid @Range(min = -720, max = 720) offsetInMinutes: Int,
-    ) {
+    private fun dateTime(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
+        val dateTime = LocalDateTime.of(ctx.localDate(), ctx.localTime())
+        val offsetInMinutes = ctx.queryParam("offsetInMinutes").notNull().toInt().range(-720, 720)
         mountService.dateTime(mount, OffsetDateTime.of(dateTime, ZoneOffset.ofTotalSeconds(offsetInMinutes * 60)))
     }
 
-    @GetMapping("{mount}/location/{type}")
-    fun celestialLocation(mount: Mount, @PathVariable type: CelestialLocationType): ComputedLocation {
-        return when (type) {
+    private fun celestialLocation(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
+        val type = ctx.pathParam("type").notNull().notBlank().let(CelestialLocationType::valueOf)
+
+        val location = when (type) {
             CelestialLocationType.ZENITH -> mountService.computeZenithLocation(mount)
             CelestialLocationType.NORTH_POLE -> mountService.computeNorthCelestialPoleLocation(mount)
             CelestialLocationType.SOUTH_POLE -> mountService.computeSouthCelestialPoleLocation(mount)
@@ -163,51 +180,56 @@ class MountController(
             CelestialLocationType.MERIDIAN_ECLIPTIC -> mountService.computeMeridianEclipticLocation(mount)
             CelestialLocationType.EQUATOR_ECLIPTIC -> mountService.computeEquatorEclipticLocation(mount)
         }
+
+        ctx.json(location)
+    }
+
+    private fun location(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
+        val rightAscension = ctx.queryParam("rightAscension").notNull().notBlank()
+        val declination = ctx.queryParam("declination").notNull().notBlank()
+        val j2000 = ctx.queryParam("j2000")?.toBoolean() ?: false
+        val equatorial = ctx.queryParam("equatorial")?.toBoolean() ?: true
+        val horizontal = ctx.queryParam("horizontal")?.toBoolean() ?: true
+        val meridianAt = ctx.queryParam("meridianAt")?.toBoolean() ?: true
+        ctx.json(mountService.computeLocation(mount, rightAscension.hours, declination.deg, j2000, equatorial, horizontal, meridianAt))
     }
 
-    @GetMapping("{mount}/location")
-    fun location(
-        mount: Mount,
-        @AngleParam(isHours = true) rightAscension: Angle,
-        @AngleParam declination: Angle,
-        @RequestParam(required = false, defaultValue = "false") j2000: Boolean,
-        @RequestParam(required = false, defaultValue = "true") equatorial: Boolean,
-        @RequestParam(required = false, defaultValue = "true") horizontal: Boolean,
-        @RequestParam(required = false, defaultValue = "true") meridianAt: Boolean,
-    ) = mountService.computeLocation(mount, rightAscension, declination, j2000, equatorial, horizontal, meridianAt)
-
-    @PutMapping("{mount}/point-here")
-    fun pointMountHere(
-        mount: Mount,
-        @RequestParam path: Path,
-        @RequestParam @Valid @PositiveOrZero x: Double,
-        @RequestParam @Valid @PositiveOrZero y: Double,
-    ) {
+    private fun pointMountHere(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
+        val path = ctx.queryParam("path").notNull().path().exists()
+        val x = ctx.queryParam("x").notNull().toDouble().positiveOrZero()
+        val y = ctx.queryParam("y").notNull().toDouble().positiveOrZero()
         mountService.pointMountHere(mount, path, x, y)
     }
 
-    @PutMapping("{mount}/remote-control/start")
-    fun remoteControlStart(
-        mount: Mount,
-        @RequestParam protocol: MountRemoteControlProtocol,
-        @RequestParam(required = false, defaultValue = "0.0.0.0") host: String,
-        @RequestParam(required = false, defaultValue = "10001") @Valid @Positive port: Int,
-    ) {
+    private fun remoteControlStart(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
+        val protocol = ctx.queryParam("protocol").notNull().notBlank().let(MountRemoteControlProtocol::valueOf)
+        val host = ctx.queryParam("host")?.ifBlank { null } ?: "0.0.0.0"
+        val port = ctx.queryParam("port")?.toInt()?.positive() ?: 10001
         mountService.remoteControlStart(mount, protocol, host, port)
     }
 
-    @PutMapping("{mount}/remote-control/stop")
-    fun remoteControlStart(mount: Mount, @RequestParam protocol: MountRemoteControlProtocol) {
+    private fun remoteControlStop(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
+        val protocol = ctx.queryParam("protocol").notNull().notBlank().let(MountRemoteControlProtocol::valueOf)
         mountService.remoteControlStop(mount, protocol)
     }
 
-    @GetMapping("{mount}/remote-control")
-    fun remoteControlList(mount: Mount): List<MountRemoteControl> {
-        return mountService.remoteControlList(mount)
+    private fun remoteControlList(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
+        ctx.json(mountService.remoteControlList(mount))
     }
 
-    @PutMapping("{mount}/listen")
-    fun listen(mount: Mount) {
+    private fun listen(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val mount = connectionService.mount(id) ?: return
         mountService.listen(mount)
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/mounts/MountDeserializer.kt b/api/src/main/kotlin/nebulosa/api/mounts/MountDeserializer.kt
index f924d7708..db364a4af 100644
--- a/api/src/main/kotlin/nebulosa/api/mounts/MountDeserializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/mounts/MountDeserializer.kt
@@ -1,16 +1,12 @@
 package nebulosa.api.mounts
 
-import nebulosa.api.devices.DeviceDeserializer
 import nebulosa.api.connection.ConnectionService
+import nebulosa.api.devices.DeviceDeserializer
 import nebulosa.indi.device.mount.Mount
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.context.annotation.Lazy
-import org.springframework.stereotype.Component
-
-@Component
-class MountDeserializer : DeviceDeserializer<Mount>(Mount::class.java) {
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.get
 
-    @Autowired @Lazy private lateinit var connectionService: ConnectionService
+class MountDeserializer : DeviceDeserializer<Mount>(Mount::class.java), KoinComponent {
 
-    override fun deviceFor(name: String) = connectionService.mount(name)
+    override fun deviceFor(name: String) = get<ConnectionService>().mount(name)
 }
diff --git a/api/src/main/kotlin/nebulosa/api/mounts/MountEventHub.kt b/api/src/main/kotlin/nebulosa/api/mounts/MountEventHub.kt
index 94d9de3b5..9e3df15a6 100644
--- a/api/src/main/kotlin/nebulosa/api/mounts/MountEventHub.kt
+++ b/api/src/main/kotlin/nebulosa/api/mounts/MountEventHub.kt
@@ -1,6 +1,5 @@
 package nebulosa.api.mounts
 
-import nebulosa.api.beans.annotations.Subscriber
 import nebulosa.api.devices.DeviceEventHub
 import nebulosa.api.message.MessageService
 import nebulosa.indi.device.DeviceType
@@ -9,23 +8,26 @@ import nebulosa.indi.device.mount.Mount
 import nebulosa.indi.device.mount.MountAttached
 import nebulosa.indi.device.mount.MountDetached
 import nebulosa.indi.device.mount.MountEvent
+import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode
-import org.springframework.stereotype.Component
 
-@Component
-@Subscriber
 class MountEventHub(
     private val messageService: MessageService,
+    eventBus: EventBus,
 ) : DeviceEventHub<Mount, MountEvent>(DeviceType.MOUNT), MountEventAware {
 
+    init {
+        eventBus.register(this)
+    }
+
     @Subscribe(threadMode = ThreadMode.ASYNC)
     override fun handleMountEvent(event: MountEvent) {
         if (event.device.type == DeviceType.MOUNT) {
             when (event) {
-            is PropertyChangedEvent -> onNext(event)
-            is MountAttached -> onAttached(event.device)
-            is MountDetached -> onDetached(event.device)
+                is PropertyChangedEvent -> onNext(event)
+                is MountAttached -> onAttached(event.device)
+                is MountDetached -> onDetached(event.device)
             }
         }
     }
diff --git a/api/src/main/kotlin/nebulosa/api/mounts/MountMoveTask.kt b/api/src/main/kotlin/nebulosa/api/mounts/MountMoveTask.kt
index db1546b52..a9665d183 100644
--- a/api/src/main/kotlin/nebulosa/api/mounts/MountMoveTask.kt
+++ b/api/src/main/kotlin/nebulosa/api/mounts/MountMoveTask.kt
@@ -1,64 +1,51 @@
 package nebulosa.api.mounts
 
-import io.reactivex.rxjava3.functions.Consumer
-import nebulosa.api.tasks.AbstractTask
-import nebulosa.api.tasks.delay.DelayEvent
-import nebulosa.api.tasks.delay.DelayTask
-import nebulosa.common.concurrency.cancel.CancellationListener
-import nebulosa.common.concurrency.cancel.CancellationSource
-import nebulosa.common.concurrency.cancel.CancellationToken
 import nebulosa.guiding.GuideDirection
 import nebulosa.indi.device.mount.Mount
+import nebulosa.job.manager.Job
+import nebulosa.job.manager.Task
+import nebulosa.job.manager.delay.DelayTask
+import nebulosa.log.debug
 import nebulosa.log.loggerFor
+import nebulosa.util.Startable
+import nebulosa.util.Stoppable
+import nebulosa.util.concurrency.cancellation.CancellationSource
 
 data class MountMoveTask(
+    @JvmField val job: Job,
     @JvmField val mount: Mount,
     @JvmField val request: MountMoveRequest,
-) : AbstractTask<MountMoveEvent>(), CancellationListener, Consumer<DelayEvent> {
+) : Task, Startable, Stoppable {
 
-    private val delayTask = DelayTask(request.duration)
+    @JvmField val delayTask = DelayTask(job, request.duration)
 
-    init {
-        delayTask.subscribe(this)
-    }
+    override fun run() {
+        if (!job.isCancelled && delayTask.duration > 0) {
+            LOG.debug { "Mount Move started. mount=$mount, request=$request" }
 
-    override fun execute(cancellationToken: CancellationToken) {
-        if (!cancellationToken.isCancelled && request.duration.toMillis() > 0) {
             mount.slewRates.takeIf { !request.speed.isNullOrBlank() }
                 ?.find { it.name == request.speed }
                 ?.also { mount.slewRate(it) }
 
-            mount.move(request.direction, true)
-
-            LOG.info("Mount Move started. mount={}, request={}", mount, request)
-
-            try {
-                cancellationToken.listen(this)
-                delayTask.execute(cancellationToken)
-            } finally {
-                stop()
-                cancellationToken.unlisten(this)
-            }
+            start()
+            delayTask.run()
+            stop()
 
-            LOG.info("Mount Move finished. mount={}, request={}", mount, request)
+            LOG.debug { "Mount Move finished. mount=$mount, request=$request" }
         }
     }
 
     override fun onCancel(source: CancellationSource) {
+        delayTask.onCancel(source)
         stop()
     }
 
-    fun stop() {
-        mount.move(request.direction, false)
-    }
-
-    override fun accept(event: DelayEvent) {
-        onNext(MountMoveEvent(this, event.remainingTime, event.progress))
+    override fun start() {
+        mount.move(request.direction, true)
     }
 
-    override fun close() {
-        delayTask.close()
-        super.close()
+    override fun stop() {
+        mount.move(request.direction, false)
     }
 
     companion object {
diff --git a/api/src/main/kotlin/nebulosa/api/mounts/MountSerializer.kt b/api/src/main/kotlin/nebulosa/api/mounts/MountSerializer.kt
index 454546e44..7d495912e 100644
--- a/api/src/main/kotlin/nebulosa/api/mounts/MountSerializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/mounts/MountSerializer.kt
@@ -7,10 +7,8 @@ import nebulosa.math.formatHMS
 import nebulosa.math.formatSignedDMS
 import nebulosa.math.toDegrees
 import nebulosa.math.toMeters
-import org.springframework.stereotype.Component
 import java.time.ZoneOffset
 
-@Component
 class MountSerializer : DeviceSerializer<Mount>(Mount::class.java) {
 
     override fun JsonGenerator.serialize(value: Mount) {
diff --git a/api/src/main/kotlin/nebulosa/api/mounts/MountService.kt b/api/src/main/kotlin/nebulosa/api/mounts/MountService.kt
index b9d1235aa..dd3d64517 100644
--- a/api/src/main/kotlin/nebulosa/api/mounts/MountService.kt
+++ b/api/src/main/kotlin/nebulosa/api/mounts/MountService.kt
@@ -1,7 +1,6 @@
 package nebulosa.api.mounts
 
 import nebulosa.api.atlas.SkyAtlasService
-import nebulosa.api.beans.annotations.Subscriber
 import nebulosa.api.confirmation.ConfirmationService
 import nebulosa.api.image.ImageBucket
 import nebulosa.constants.PI
@@ -22,27 +21,30 @@ import nebulosa.stellarium.protocol.StellariumProtocolServer
 import nebulosa.time.CurrentTime
 import nebulosa.time.SystemClock
 import nebulosa.wcs.WCS
+import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode
-import org.springframework.stereotype.Service
 import java.nio.file.Path
 import java.time.LocalDateTime
 import java.time.OffsetDateTime
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.TimeUnit
 
-@Service
-@Subscriber
 class MountService(
     private val imageBucket: ImageBucket,
     private val mountEventHub: MountEventHub,
     private val skyAtlasService: SkyAtlasService,
     private val confirmationService: ConfirmationService,
+    eventBus: EventBus,
 ) {
 
     private val sites = ConcurrentHashMap<Mount, GeographicPosition>(2)
     private val remoteControls = ArrayList<MountRemoteControl>(2)
 
+    init {
+        eventBus.register(this)
+    }
+
     @Subscribe(threadMode = ThreadMode.ASYNC)
     fun onMountGeographicCoordinateChanged(event: MountGeographicCoordinateChanged) {
         sites[event.device] = Geoid.IERS2010.lonLat(event.device)
diff --git a/api/src/main/kotlin/nebulosa/api/mounts/MountSlewTask.kt b/api/src/main/kotlin/nebulosa/api/mounts/MountSlewTask.kt
index 9c057a224..52a60b25e 100644
--- a/api/src/main/kotlin/nebulosa/api/mounts/MountSlewTask.kt
+++ b/api/src/main/kotlin/nebulosa/api/mounts/MountSlewTask.kt
@@ -1,28 +1,31 @@
 package nebulosa.api.mounts
 
-import nebulosa.api.tasks.Task
-import nebulosa.api.tasks.delay.DelayTask
-import nebulosa.common.concurrency.cancel.CancellationListener
-import nebulosa.common.concurrency.cancel.CancellationSource
-import nebulosa.common.concurrency.cancel.CancellationToken
-import nebulosa.common.concurrency.latch.CountUpDownLatch
 import nebulosa.indi.device.mount.Mount
 import nebulosa.indi.device.mount.MountEvent
 import nebulosa.indi.device.mount.MountSlewFailed
 import nebulosa.indi.device.mount.MountSlewingChanged
+import nebulosa.job.manager.Job
+import nebulosa.job.manager.Task
+import nebulosa.job.manager.delay.DelayTask
+import nebulosa.log.debug
 import nebulosa.log.loggerFor
 import nebulosa.math.Angle
 import nebulosa.math.formatHMS
 import nebulosa.math.formatSignedDMS
+import nebulosa.util.Resettable
+import nebulosa.util.Stoppable
+import nebulosa.util.concurrency.cancellation.CancellationSource
+import nebulosa.util.concurrency.latch.CountUpDownLatch
 import java.time.Duration
 
 data class MountSlewTask(
+    @JvmField val job: Job,
     @JvmField val mount: Mount,
     @JvmField val rightAscension: Angle, @JvmField val declination: Angle,
     @JvmField val j2000: Boolean = false, @JvmField val goTo: Boolean = true,
-) : Task, CancellationListener, MountEventAware {
+) : Task, Stoppable, Resettable, MountEventAware {
 
-    private val delayTask = DelayTask(SETTLE_DURATION)
+    private val delayTask = DelayTask(job, SETTLE_DURATION)
     private val latch = CountUpDownLatch()
 
     @Volatile private var initialRA = mount.rightAscension
@@ -41,55 +44,48 @@ data class MountSlewTask(
         }
     }
 
-    override fun execute(cancellationToken: CancellationToken) {
-        if (!cancellationToken.isCancelled &&
+    override fun run() {
+        if (!job.isCancelled &&
             mount.connected && !mount.parked && !mount.parking && !mount.slewing &&
             rightAscension.isFinite() && declination.isFinite() &&
             (mount.rightAscension != rightAscension || mount.declination != declination)
         ) {
-            latch.countUp()
+            LOG.debug { "Mount Slew started. mount=$mount, ra=${rightAscension.formatHMS()}, dec=${declination.formatSignedDMS()}" }
 
-            LOG.info("Mount Slew started. mount={}, ra={}, dec={}", mount, rightAscension.formatHMS(), declination.formatSignedDMS())
+            latch.countUp()
 
             initialRA = mount.rightAscension
             initialDEC = mount.declination
 
-            try {
-                cancellationToken.listen(this)
-
-                if (j2000) {
-                    if (goTo) mount.goToJ2000(rightAscension, declination)
-                    else mount.slewToJ2000(rightAscension, declination)
-                } else {
-                    if (goTo) mount.goTo(rightAscension, declination)
-                    else mount.slewTo(rightAscension, declination)
-                }
-
-                latch.await()
-            } finally {
-                cancellationToken.unlisten(this)
+            if (j2000) {
+                if (goTo) mount.goToJ2000(rightAscension, declination)
+                else mount.slewToJ2000(rightAscension, declination)
+            } else {
+                if (goTo) mount.goTo(rightAscension, declination)
+                else mount.slewTo(rightAscension, declination)
             }
 
-            LOG.info("Mount Slew finished. mount={}, ra={}, dec={}", mount, rightAscension.formatHMS(), declination.formatSignedDMS())
+            latch.await()
+
+            LOG.debug { "Mount Slew finished. mount=$mount, ra=${rightAscension.formatHMS()}, dec=${declination.formatSignedDMS()}" }
 
-            delayTask.execute(cancellationToken)
+            delayTask.run()
         } else {
             LOG.warn("cannot slew mount. mount={}, ra={}, dec={}", mount, rightAscension.formatHMS(), declination.formatSignedDMS())
         }
     }
 
-    fun stop() {
+    override fun stop() {
         mount.abortMotion()
         latch.reset()
     }
 
-    override fun onCancel(source: CancellationSource) {
-        stop()
+    override fun reset() {
+        latch.reset()
     }
 
-    override fun close() {
-        delayTask.close()
-        super.close()
+    override fun onCancel(source: CancellationSource) {
+        stop()
     }
 
     companion object {
diff --git a/api/src/main/kotlin/nebulosa/api/mounts/MountTrackTask.kt b/api/src/main/kotlin/nebulosa/api/mounts/MountTrackTask.kt
new file mode 100644
index 000000000..9ee25942a
--- /dev/null
+++ b/api/src/main/kotlin/nebulosa/api/mounts/MountTrackTask.kt
@@ -0,0 +1,39 @@
+package nebulosa.api.mounts
+
+import nebulosa.indi.device.mount.Mount
+import nebulosa.indi.device.mount.MountEvent
+import nebulosa.indi.device.mount.MountTrackingChanged
+import nebulosa.job.manager.Job
+import nebulosa.job.manager.Task
+import nebulosa.log.loggerFor
+import nebulosa.util.concurrency.latch.CountUpDownLatch
+
+data class MountTrackTask(
+    @JvmField val job: Job,
+    @JvmField val mount: Mount,
+    @JvmField val enabled: Boolean,
+) : Task, MountEventAware {
+
+    private val trackingLatch = CountUpDownLatch()
+
+    override fun handleMountEvent(event: MountEvent) {
+        if (event.device === mount && event is MountTrackingChanged && mount.tracking == enabled) {
+            trackingLatch.reset()
+        }
+    }
+
+    override fun run() {
+        if (mount.connected && mount.tracking != enabled) {
+            LOG.debug("Mount Track started. mount={}, enabled={}", mount, enabled)
+            trackingLatch.countUp()
+            mount.tracking(enabled)
+            trackingLatch.await()
+            LOG.debug("Mount Track finished. mount={}, enabled={}", mount, enabled)
+        }
+    }
+
+    companion object {
+
+        @JvmStatic private val LOG = loggerFor<MountTrackTask>()
+    }
+}
diff --git a/api/src/main/kotlin/nebulosa/api/platesolver/PlateSolverController.kt b/api/src/main/kotlin/nebulosa/api/platesolver/PlateSolverController.kt
index 5e44131bf..ab0764aff 100644
--- a/api/src/main/kotlin/nebulosa/api/platesolver/PlateSolverController.kt
+++ b/api/src/main/kotlin/nebulosa/api/platesolver/PlateSolverController.kt
@@ -1,23 +1,31 @@
 package nebulosa.api.platesolver
 
-import jakarta.validation.Valid
-import org.springframework.web.bind.annotation.*
-import java.nio.file.Path
+import io.javalin.Javalin
+import io.javalin.http.Context
+import io.javalin.http.bodyAsClass
+import nebulosa.api.javalin.exists
+import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.path
+import nebulosa.api.javalin.valid
 
-@RestController
-@RequestMapping("plate-solver")
 class PlateSolverController(
+    app: Javalin,
     private val plateSolverService: PlateSolverService,
 ) {
 
-    @PutMapping("start")
-    fun start(
-        @RequestParam path: Path,
-        @RequestBody @Valid solver: PlateSolverRequest,
-    ) = plateSolverService.solveImage(solver, path)
+    init {
+        app.put("plate-solver/start", ::start)
+        app.put("plate-solver/stop", ::stop)
+    }
+
+    private fun start(ctx: Context) {
+        val path = ctx.queryParam("path")?.path().notNull().exists()
+        val solver = ctx.bodyAsClass<PlateSolverRequest>().valid()
+        ctx.json(plateSolverService.solveImage(solver, path))
+    }
 
-    @PutMapping("stop")
-    fun stop() {
+    @Suppress("UNUSED_PARAMETER")
+    private fun stop(ctx: Context) {
         plateSolverService.stopSolver()
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/platesolver/PlateSolverRequest.kt b/api/src/main/kotlin/nebulosa/api/platesolver/PlateSolverRequest.kt
index af3219921..9f37a51a1 100644
--- a/api/src/main/kotlin/nebulosa/api/platesolver/PlateSolverRequest.kt
+++ b/api/src/main/kotlin/nebulosa/api/platesolver/PlateSolverRequest.kt
@@ -4,6 +4,11 @@ import com.fasterxml.jackson.databind.annotation.JsonDeserialize
 import nebulosa.api.beans.converters.angle.DeclinationDeserializer
 import nebulosa.api.beans.converters.angle.DegreesDeserializer
 import nebulosa.api.beans.converters.angle.RightAscensionDeserializer
+import nebulosa.api.beans.converters.time.DurationUnit
+import nebulosa.api.inject.Named
+import nebulosa.api.javalin.Validatable
+import nebulosa.api.javalin.max
+import nebulosa.api.javalin.positiveOrZero
 import nebulosa.astap.platesolver.AstapPlateSolver
 import nebulosa.astrometrynet.nova.NovaAstrometryNetService
 import nebulosa.astrometrynet.platesolver.LocalAstrometryNetPlateSolver
@@ -11,14 +16,16 @@ import nebulosa.astrometrynet.platesolver.NovaAstrometryNetPlateSolver
 import nebulosa.math.Angle
 import nebulosa.pixinsight.platesolver.PixInsightPlateSolver
 import nebulosa.pixinsight.script.startPixInsight
+import nebulosa.platesolver.PlateSolver
 import nebulosa.siril.platesolver.SirilPlateSolver
 import okhttp3.OkHttpClient
-import org.hibernate.validator.constraints.time.DurationMax
-import org.hibernate.validator.constraints.time.DurationMin
-import org.springframework.boot.convert.DurationUnit
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.get
 import java.nio.file.Path
 import java.time.Duration
 import java.time.temporal.ChronoUnit
+import java.util.concurrent.TimeUnit
+import java.util.function.Supplier
 
 data class PlateSolverRequest(
     @JvmField val type: PlateSolverType = PlateSolverType.ASTROMETRY_NET_ONLINE,
@@ -28,20 +35,28 @@ data class PlateSolverRequest(
     @JvmField val pixelSize: Double = 0.0,
     @JvmField val apiUrl: String = "",
     @JvmField val apiKey: String = "",
-    @field:DurationMin(seconds = 0) @field:DurationMax(minutes = 5) @field:DurationUnit(ChronoUnit.SECONDS)
-    @JvmField val timeout: Duration = Duration.ZERO,
+    @field:DurationUnit(ChronoUnit.SECONDS) @JvmField val timeout: Duration = Duration.ZERO,
     @JvmField val slot: Int = 1,
     @JvmField val blind: Boolean = true,
-    @JsonDeserialize(using = RightAscensionDeserializer::class) @JvmField val centerRA: Angle = 0.0,
-    @JsonDeserialize(using = DeclinationDeserializer::class) @JvmField val centerDEC: Angle = 0.0,
-    @JsonDeserialize(using = DegreesDeserializer::class) @JvmField val radius: Angle = if (blind) 0.0 else 4.0,
-) {
+    @field:JsonDeserialize(using = RightAscensionDeserializer::class) @JvmField val centerRA: Angle = 0.0,
+    @field:JsonDeserialize(using = DeclinationDeserializer::class) @JvmField val centerDEC: Angle = 0.0,
+    @field:JsonDeserialize(using = DegreesDeserializer::class) @JvmField val radius: Angle = if (blind) 0.0 else 4.0,
+) : Validatable, KoinComponent, Supplier<PlateSolver> {
 
-    fun get(httpClient: OkHttpClient? = null) = with(this) {
+    override fun validate() {
+        timeout.positiveOrZero().max(5, TimeUnit.MINUTES)
+        downsampleFactor.positiveOrZero()
+        focalLength.positiveOrZero()
+        pixelSize.positiveOrZero()
+        slot.positiveOrZero()
+    }
+
+    override fun get() = with(this) {
         when (type) {
             PlateSolverType.ASTAP -> AstapPlateSolver(executablePath!!)
             PlateSolverType.ASTROMETRY_NET -> LocalAstrometryNetPlateSolver(executablePath!!)
             PlateSolverType.ASTROMETRY_NET_ONLINE -> {
+                val httpClient = get<OkHttpClient>(Named.defaultHttpClient)
                 val service = NOVA_ASTROMETRY_NET_CACHE.getOrPut(apiUrl) { NovaAstrometryNetService(apiUrl, httpClient) }
                 NovaAstrometryNetPlateSolver(service, apiKey)
             }
diff --git a/api/src/main/kotlin/nebulosa/api/platesolver/PlateSolverService.kt b/api/src/main/kotlin/nebulosa/api/platesolver/PlateSolverService.kt
index dfbe20d30..e5fa0191a 100644
--- a/api/src/main/kotlin/nebulosa/api/platesolver/PlateSolverService.kt
+++ b/api/src/main/kotlin/nebulosa/api/platesolver/PlateSolverService.kt
@@ -2,16 +2,12 @@ package nebulosa.api.platesolver
 
 import nebulosa.api.image.ImageBucket
 import nebulosa.api.image.ImageSolved
-import nebulosa.common.concurrency.cancel.CancellationToken
-import okhttp3.OkHttpClient
-import org.springframework.stereotype.Service
+import nebulosa.util.concurrency.cancellation.CancellationToken
 import java.nio.file.Path
 import java.util.concurrent.atomic.AtomicReference
 
-@Service
 class PlateSolverService(
     private val imageBucket: ImageBucket,
-    private val httpClient: OkHttpClient,
 ) {
 
     private val cancellationToken = AtomicReference<CancellationToken>()
@@ -25,7 +21,7 @@ class PlateSolverService(
     @Synchronized
     fun solve(request: PlateSolverRequest, path: Path) = CancellationToken().use {
         cancellationToken.set(it)
-        val solver = request.get(httpClient)
+        val solver = request.get()
         val radius = if (request.blind) 0.0 else request.radius
         solver.solve(path, null, request.centerRA, request.centerDEC, radius, request.downsampleFactor, request.timeout, it)
     }
diff --git a/api/src/main/kotlin/nebulosa/api/preference/PreferenceRepository.kt b/api/src/main/kotlin/nebulosa/api/preference/PreferenceRepository.kt
index 1b1ac12c5..2222b52b9 100644
--- a/api/src/main/kotlin/nebulosa/api/preference/PreferenceRepository.kt
+++ b/api/src/main/kotlin/nebulosa/api/preference/PreferenceRepository.kt
@@ -3,11 +3,8 @@ package nebulosa.api.preference
 import io.objectbox.Box
 import io.objectbox.kotlin.equal
 import nebulosa.api.repositories.BoxRepository
-import org.springframework.beans.factory.annotation.Qualifier
-import org.springframework.stereotype.Component
 
-@Component
-class PreferenceRepository(@Qualifier("preferenceBox") override val box: Box<PreferenceEntity>) : BoxRepository<PreferenceEntity>() {
+class PreferenceRepository(override val box: Box<PreferenceEntity>) : BoxRepository<PreferenceEntity>() {
 
     fun existsByKey(key: String): Boolean {
         return box.query(PreferenceEntity_.key equal key)
diff --git a/api/src/main/kotlin/nebulosa/api/preference/PreferenceService.kt b/api/src/main/kotlin/nebulosa/api/preference/PreferenceService.kt
index d018d0cf4..c69ac4074 100644
--- a/api/src/main/kotlin/nebulosa/api/preference/PreferenceService.kt
+++ b/api/src/main/kotlin/nebulosa/api/preference/PreferenceService.kt
@@ -1,9 +1,7 @@
 package nebulosa.api.preference
 
 import com.fasterxml.jackson.databind.ObjectMapper
-import org.springframework.stereotype.Service
 
-@Service
 class PreferenceService(
     private val preferenceRepository: PreferenceRepository,
     private val objectMapper: ObjectMapper,
@@ -17,13 +15,13 @@ class PreferenceService(
 
     fun <T> getJSON(key: String, type: Class<out T>): T? = this[key]?.value?.let { objectMapper.readValue(it, type) }
 
-    final inline fun <reified T> getJSON(key: String) = getJSON(key, T::class.java)
+    inline fun <reified T> getJSON(key: String) = getJSON(key, T::class.java)
 
     fun getBoolean(key: String) = getJSON(key, Boolean::class.java)
 
     fun getText(key: String) = getJSON(key, String::class.java)
 
-    final inline fun <reified T : Enum<T>> getEnum(key: String) = getText(key)?.takeIf { it.isNotBlank() }?.let { enumValueOf<T>(it) }
+    inline fun <reified T : Enum<T>> getEnum(key: String) = getText(key)?.takeIf { it.isNotBlank() }?.let { enumValueOf<T>(it) }
 
     fun getInt(key: String) = getJSON(key, Int::class.java)
 
diff --git a/api/src/main/kotlin/nebulosa/api/rotators/RotatorController.kt b/api/src/main/kotlin/nebulosa/api/rotators/RotatorController.kt
index 01af185f0..45464bb71 100644
--- a/api/src/main/kotlin/nebulosa/api/rotators/RotatorController.kt
+++ b/api/src/main/kotlin/nebulosa/api/rotators/RotatorController.kt
@@ -1,74 +1,87 @@
 package nebulosa.api.rotators
 
-import jakarta.validation.Valid
+import io.javalin.Javalin
+import io.javalin.http.Context
 import nebulosa.api.connection.ConnectionService
-import nebulosa.indi.device.rotator.Rotator
-import org.hibernate.validator.constraints.Range
-import org.springframework.web.bind.annotation.*
+import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.range
 
-@RestController
-@RequestMapping("rotators")
 class RotatorController(
+    app: Javalin,
     private val connectionService: ConnectionService,
     private val rotatorService: RotatorService,
 ) {
 
-    @GetMapping
-    fun rotators(): List<Rotator> {
-        return connectionService.rotators().sorted()
+    init {
+        app.get("rotators", ::rotators)
+        app.get("rotators/{id}", ::rotator)
+        app.put("rotators/{id}/connect", ::connect)
+        app.put("rotators/{id}/disconnect", ::disconnect)
+        app.put("rotators/{id}/reverse", ::reverse)
+        app.put("rotators/{id}/move", ::move)
+        app.put("rotators/{id}/abort", ::abort)
+        app.put("rotators/{id}/home", ::home)
+        app.put("rotators/{id}/sync", ::sync)
+        app.put("rotators/{id}/listen", ::listen)
     }
 
-    @GetMapping("{rotator}")
-    fun rotator(rotator: Rotator): Rotator {
-        return rotator
+    private fun rotators(ctx: Context) {
+        ctx.json(connectionService.rotators().sorted())
     }
 
-    @PutMapping("{rotator}/connect")
-    fun connect(rotator: Rotator) {
+    private fun rotator(ctx: Context) {
+        val id = ctx.pathParam("id")
+        connectionService.rotator(id)?.also(ctx::json)
+    }
+
+    private fun connect(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val rotator = connectionService.rotator(id) ?: return
         rotatorService.connect(rotator)
     }
 
-    @PutMapping("{rotator}/disconnect")
-    fun disconnect(rotator: Rotator) {
+    private fun disconnect(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val rotator = connectionService.rotator(id) ?: return
         rotatorService.disconnect(rotator)
     }
 
-    @PutMapping("{rotator}/reverse")
-    fun reverse(
-        rotator: Rotator,
-        @RequestParam enabled: Boolean,
-    ) {
+    private fun reverse(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val rotator = connectionService.rotator(id) ?: return
+        val enabled = ctx.queryParam("enabled").notNull().toBoolean()
         rotatorService.reverse(rotator, enabled)
     }
 
-    @PutMapping("{rotator}/move")
-    fun move(
-        rotator: Rotator,
-        @RequestParam @Valid @Range(min = 0, max = 360) angle: Double,
-    ) {
+    private fun move(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val rotator = connectionService.rotator(id) ?: return
+        val angle = ctx.queryParam("angle").notNull().toDouble().range(0.0, 360.0)
         rotatorService.move(rotator, angle)
     }
 
-    @PutMapping("{rotator}/abort")
-    fun abort(rotator: Rotator) {
+    private fun abort(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val rotator = connectionService.rotator(id) ?: return
         rotatorService.abort(rotator)
     }
 
-    @PutMapping("{rotator}/home")
-    fun home(rotator: Rotator) {
+    private fun home(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val rotator = connectionService.rotator(id) ?: return
         rotatorService.home(rotator)
     }
 
-    @PutMapping("{rotator}/sync")
-    fun sync(
-        rotator: Rotator,
-        @RequestParam @Valid @Range(min = 0, max = 360) angle: Double,
-    ) {
+    private fun sync(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val rotator = connectionService.rotator(id) ?: return
+        val angle = ctx.queryParam("angle").notNull().toDouble().range(0.0, 360.0)
         rotatorService.sync(rotator, angle)
     }
 
-    @PutMapping("{rotator}/listen")
-    fun listen(rotator: Rotator) {
+    private fun listen(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val rotator = connectionService.rotator(id) ?: return
         rotatorService.listen(rotator)
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/rotators/RotatorDeserializer.kt b/api/src/main/kotlin/nebulosa/api/rotators/RotatorDeserializer.kt
index 046395b8a..a8b42b296 100644
--- a/api/src/main/kotlin/nebulosa/api/rotators/RotatorDeserializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/rotators/RotatorDeserializer.kt
@@ -1,16 +1,12 @@
 package nebulosa.api.rotators
 
-import nebulosa.api.devices.DeviceDeserializer
 import nebulosa.api.connection.ConnectionService
+import nebulosa.api.devices.DeviceDeserializer
 import nebulosa.indi.device.rotator.Rotator
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.context.annotation.Lazy
-import org.springframework.stereotype.Component
-
-@Component
-class RotatorDeserializer : DeviceDeserializer<Rotator>(Rotator::class.java) {
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.get
 
-    @Autowired @Lazy private lateinit var connectionService: ConnectionService
+class RotatorDeserializer : DeviceDeserializer<Rotator>(Rotator::class.java), KoinComponent {
 
-    override fun deviceFor(name: String) = connectionService.rotator(name)
+    override fun deviceFor(name: String) = get<ConnectionService>().rotator(name)
 }
diff --git a/api/src/main/kotlin/nebulosa/api/rotators/RotatorEventHub.kt b/api/src/main/kotlin/nebulosa/api/rotators/RotatorEventHub.kt
index 46a94bc93..c10f1ea77 100644
--- a/api/src/main/kotlin/nebulosa/api/rotators/RotatorEventHub.kt
+++ b/api/src/main/kotlin/nebulosa/api/rotators/RotatorEventHub.kt
@@ -1,6 +1,5 @@
 package nebulosa.api.rotators
 
-import nebulosa.api.beans.annotations.Subscriber
 import nebulosa.api.devices.DeviceEventHub
 import nebulosa.api.message.MessageService
 import nebulosa.indi.device.DeviceType
@@ -9,23 +8,26 @@ import nebulosa.indi.device.rotator.Rotator
 import nebulosa.indi.device.rotator.RotatorAttached
 import nebulosa.indi.device.rotator.RotatorDetached
 import nebulosa.indi.device.rotator.RotatorEvent
+import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode
-import org.springframework.stereotype.Component
 
-@Component
-@Subscriber
 class RotatorEventHub(
     private val messageService: MessageService,
+    eventBus: EventBus,
 ) : DeviceEventHub<Rotator, RotatorEvent>(DeviceType.ROTATOR), RotatorEventAware {
 
+    init {
+        eventBus.register(this)
+    }
+
     @Subscribe(threadMode = ThreadMode.ASYNC)
     override fun handleRotatorEvent(event: RotatorEvent) {
         if (event.device.type == DeviceType.ROTATOR) {
             when (event) {
-            is PropertyChangedEvent -> onNext(event)
-            is RotatorAttached -> onAttached(event.device)
-            is RotatorDetached -> onDetached(event.device)
+                is PropertyChangedEvent -> onNext(event)
+                is RotatorAttached -> onAttached(event.device)
+                is RotatorDetached -> onDetached(event.device)
             }
         }
     }
diff --git a/api/src/main/kotlin/nebulosa/api/rotators/RotatorSerializer.kt b/api/src/main/kotlin/nebulosa/api/rotators/RotatorSerializer.kt
index d41473df7..c1b18016c 100644
--- a/api/src/main/kotlin/nebulosa/api/rotators/RotatorSerializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/rotators/RotatorSerializer.kt
@@ -3,9 +3,7 @@ package nebulosa.api.rotators
 import com.fasterxml.jackson.core.JsonGenerator
 import nebulosa.api.devices.DeviceSerializer
 import nebulosa.indi.device.rotator.Rotator
-import org.springframework.stereotype.Component
 
-@Component
 class RotatorSerializer : DeviceSerializer<Rotator>(Rotator::class.java) {
 
     override fun JsonGenerator.serialize(value: Rotator) {
diff --git a/api/src/main/kotlin/nebulosa/api/rotators/RotatorService.kt b/api/src/main/kotlin/nebulosa/api/rotators/RotatorService.kt
index a1831a9e1..641045883 100644
--- a/api/src/main/kotlin/nebulosa/api/rotators/RotatorService.kt
+++ b/api/src/main/kotlin/nebulosa/api/rotators/RotatorService.kt
@@ -1,9 +1,7 @@
 package nebulosa.api.rotators
 
 import nebulosa.indi.device.rotator.Rotator
-import org.springframework.stereotype.Service
 
-@Service
 class RotatorService(private val rotatorEventHub: RotatorEventHub) {
 
     fun connect(rotator: Rotator) {
diff --git a/api/src/main/kotlin/nebulosa/api/sequencer/AutoFocusAfterConditions.kt b/api/src/main/kotlin/nebulosa/api/sequencer/AutoFocusAfterConditions.kt
index 9fc874590..1f75a7463 100644
--- a/api/src/main/kotlin/nebulosa/api/sequencer/AutoFocusAfterConditions.kt
+++ b/api/src/main/kotlin/nebulosa/api/sequencer/AutoFocusAfterConditions.kt
@@ -1,26 +1,33 @@
 package nebulosa.api.sequencer
 
-import jakarta.validation.constraints.PositiveOrZero
-import org.hibernate.validator.constraints.time.DurationMax
-import org.hibernate.validator.constraints.time.DurationMin
-import org.springframework.boot.convert.DurationUnit
+import nebulosa.api.beans.converters.time.DurationUnit
+import nebulosa.api.javalin.Validatable
+import nebulosa.api.javalin.max
+import nebulosa.api.javalin.positiveOrZero
 import java.time.Duration
 import java.time.temporal.ChronoUnit
+import java.util.concurrent.TimeUnit
 
 data class AutoFocusAfterConditions(
     @JvmField val enabled: Boolean = false,
     @JvmField val onStart: Boolean = false,
     @JvmField val onFilterChange: Boolean = false,
-    @field:DurationMin(seconds = 0) @field:DurationMax(hours = 8) @field:DurationUnit(ChronoUnit.SECONDS)
-    @JvmField val afterElapsedTime: Duration = Duration.ZERO,
-    @field:PositiveOrZero @JvmField val afterExposures: Int = 0,
-    @field:PositiveOrZero @JvmField val afterTemperatureChange: Double = 0.0,
-    @field:PositiveOrZero @JvmField val afterHFDIncrease: Double = 0.0,
+    @field:DurationUnit(ChronoUnit.SECONDS) @JvmField val afterElapsedTime: Duration = Duration.ZERO,
+    @JvmField val afterExposures: Int = 0,
+    @JvmField val afterTemperatureChange: Double = 0.0,
+    @JvmField val afterHFDIncrease: Double = 0.0,
     @JvmField val afterElapsedTimeEnabled: Boolean = false,
     @JvmField val afterExposuresEnabled: Boolean = false,
     @JvmField val afterTemperatureChangeEnabled: Boolean = false,
     @JvmField val afterHFDIncreaseEnabled: Boolean = false,
-) {
+) : Validatable {
+
+    override fun validate() {
+        afterElapsedTime.positiveOrZero().max(24L, TimeUnit.HOURS)
+        afterExposures.positiveOrZero()
+        afterTemperatureChange.positiveOrZero()
+        afterHFDIncrease.positiveOrZero()
+    }
 
     companion object {
 
diff --git a/api/src/main/kotlin/nebulosa/api/sequencer/SequencerController.kt b/api/src/main/kotlin/nebulosa/api/sequencer/SequencerController.kt
index d8d0478dd..2660e1ee5 100644
--- a/api/src/main/kotlin/nebulosa/api/sequencer/SequencerController.kt
+++ b/api/src/main/kotlin/nebulosa/api/sequencer/SequencerController.kt
@@ -1,43 +1,53 @@
 package nebulosa.api.sequencer
 
-import jakarta.validation.Valid
-import nebulosa.indi.device.camera.Camera
-import nebulosa.indi.device.filterwheel.FilterWheel
-import nebulosa.indi.device.focuser.Focuser
-import nebulosa.indi.device.mount.Mount
-import nebulosa.indi.device.rotator.Rotator
-import org.springframework.web.bind.annotation.*
-
-@RestController
-@RequestMapping("sequencer")
+import io.javalin.Javalin
+import io.javalin.http.Context
+import io.javalin.http.bodyAsClass
+import nebulosa.api.connection.ConnectionService
+import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.valid
+
 class SequencerController(
+    app: Javalin,
     private val sequencerService: SequencerService,
+    private val connectionService: ConnectionService,
 ) {
 
-    @PutMapping("{camera}/start")
-    fun start(
-        camera: Camera,
-        mount: Mount?, wheel: FilterWheel?, focuser: Focuser?, rotator: Rotator?,
-        @RequestBody @Valid body: SequencerPlanRequest,
-    ) = sequencerService.start(camera, body, mount, wheel, focuser, rotator)
+    init {
+        app.put("sequencer/{camera}/start", ::start)
+        app.put("sequencer/{camera}/stop", ::stop)
+        app.put("sequencer/{camera}/pause", ::pause)
+        app.put("sequencer/{camera}/unpause", ::unpause)
+        app.get("sequencer/{camera}/status", ::status)
+    }
+
+    private fun start(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")).notNull()
+        val mount = ctx.queryParam("mount")?.let(connectionService::mount)
+        val wheel = ctx.queryParam("wheel")?.let(connectionService::wheel)
+        val focuser = ctx.queryParam("focuser")?.let(connectionService::focuser)
+        val rotator = ctx.queryParam("rotator")?.let(connectionService::rotator)
+        val body = ctx.bodyAsClass<SequencerPlanRequest>().valid()
+        sequencerService.start(camera, body, mount, wheel, focuser, rotator)
+    }
 
-    @PutMapping("{camera}/stop")
-    fun stop(camera: Camera) {
+    fun stop(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")) ?: return
         sequencerService.stop(camera)
     }
 
-    @PutMapping("{camera}/pause")
-    fun pause(camera: Camera) {
+    fun pause(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")) ?: return
         sequencerService.pause(camera)
     }
 
-    @PutMapping("{camera}/unpause")
-    fun unpause(camera: Camera) {
+    fun unpause(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")) ?: return
         sequencerService.unpause(camera)
     }
 
-    @GetMapping("{camera}/status")
-    fun status(camera: Camera): SequencerEvent? {
-        return sequencerService.status(camera)
+    fun status(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")).notNull()
+        sequencerService.status(camera)?.also(ctx::json)
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/sequencer/SequencerEvent.kt b/api/src/main/kotlin/nebulosa/api/sequencer/SequencerEvent.kt
index f072ab4b8..e34a7a36b 100644
--- a/api/src/main/kotlin/nebulosa/api/sequencer/SequencerEvent.kt
+++ b/api/src/main/kotlin/nebulosa/api/sequencer/SequencerEvent.kt
@@ -1,16 +1,18 @@
 package nebulosa.api.sequencer
 
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
 import nebulosa.api.cameras.CameraCaptureEvent
 import nebulosa.api.message.MessageEvent
-import java.time.Duration
+import nebulosa.indi.device.camera.Camera
 
 data class SequencerEvent(
-    @JvmField val id: Int = 0,
-    @JvmField val elapsedTime: Duration = Duration.ZERO,
-    @JvmField val remainingTime: Duration = Duration.ZERO,
-    @JvmField val progress: Double = 0.0,
-    @JvmField val capture: CameraCaptureEvent? = null,
-    @JvmField val state: SequencerState = SequencerState.IDLE,
+    @JvmField val camera: Camera,
+    @JvmField var id: Int = 0,
+    @JvmField var elapsedTime: Long = 0L,
+    @JvmField var remainingTime: Long = 0L,
+    @JvmField var progress: Double = 0.0,
+    @JvmField var state: SequencerState = SequencerState.IDLE,
+    @JvmField @field:JsonIgnoreProperties("camera") var capture: CameraCaptureEvent = CameraCaptureEvent(camera),
 ) : MessageEvent {
 
     override val eventName = "SEQUENCER.ELAPSED"
diff --git a/api/src/main/kotlin/nebulosa/api/sequencer/SequencerExecutor.kt b/api/src/main/kotlin/nebulosa/api/sequencer/SequencerExecutor.kt
index efd19c02c..c9ab39033 100644
--- a/api/src/main/kotlin/nebulosa/api/sequencer/SequencerExecutor.kt
+++ b/api/src/main/kotlin/nebulosa/api/sequencer/SequencerExecutor.kt
@@ -1,12 +1,11 @@
 package nebulosa.api.sequencer
 
-import io.reactivex.rxjava3.functions.Consumer
-import nebulosa.api.beans.annotations.Subscriber
 import nebulosa.api.calibration.CalibrationFrameService
 import nebulosa.api.cameras.CameraEventAware
 import nebulosa.api.focusers.FocuserEventAware
 import nebulosa.api.message.MessageEvent
 import nebulosa.api.message.MessageService
+import nebulosa.api.rotators.RotatorEventAware
 import nebulosa.api.wheels.WheelEventAware
 import nebulosa.guiding.Guider
 import nebulosa.indi.device.camera.Camera
@@ -17,36 +16,47 @@ import nebulosa.indi.device.focuser.Focuser
 import nebulosa.indi.device.focuser.FocuserEvent
 import nebulosa.indi.device.mount.Mount
 import nebulosa.indi.device.rotator.Rotator
+import nebulosa.indi.device.rotator.RotatorEvent
+import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode
-import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor
-import org.springframework.stereotype.Component
 import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.Executor
+import java.util.concurrent.ExecutorService
+import java.util.function.Consumer
 
-@Component
-@Subscriber
 class SequencerExecutor(
     private val messageService: MessageService,
     private val guider: Guider,
-    private val threadPoolTaskExecutor: ThreadPoolTaskExecutor,
+    private val executorService: ExecutorService,
     private val calibrationFrameService: CalibrationFrameService,
-) : Consumer<MessageEvent>, CameraEventAware, WheelEventAware, FocuserEventAware {
+    eventBus: EventBus,
+) : Consumer<MessageEvent>, CameraEventAware, WheelEventAware, FocuserEventAware, RotatorEventAware, Executor by executorService {
 
     private val jobs = ConcurrentHashMap.newKeySet<SequencerJob>(1)
 
+    init {
+        eventBus.register(this)
+    }
+
     @Subscribe(threadMode = ThreadMode.ASYNC)
     override fun handleCameraEvent(event: CameraEvent) {
-        jobs.find { it.task.camera === event.device }?.handleCameraEvent(event)
+        jobs.find { it.camera === event.device }?.handleCameraEvent(event)
     }
 
     @Subscribe(threadMode = ThreadMode.ASYNC)
     override fun handleFilterWheelEvent(event: FilterWheelEvent) {
-        jobs.find { it.task.wheel === event.device }?.handleFilterWheelEvent(event)
+        jobs.find { it.wheel === event.device }?.handleFilterWheelEvent(event)
     }
 
     @Subscribe(threadMode = ThreadMode.ASYNC)
     override fun handleFocuserEvent(event: FocuserEvent) {
-        // jobs.find { it.task.focuser === event.device }?.handleFocuserEvent(event)
+        jobs.find { it.focuser === event.device }?.handleFocuserEvent(event)
+    }
+
+    @Subscribe(threadMode = ThreadMode.ASYNC)
+    override fun handleRotatorEvent(event: RotatorEvent) {
+        jobs.find { it.rotator === event.device }?.handleRotatorEvent(event)
     }
 
     override fun accept(event: MessageEvent) {
@@ -58,43 +68,40 @@ class SequencerExecutor(
         mount: Mount? = null, wheel: FilterWheel? = null, focuser: Focuser? = null, rotator: Rotator? = null,
     ) {
         check(camera.connected) { "${camera.name} Camera is not connected" }
-        check(jobs.none { it.task.camera === camera }) { "${camera.name} Sequencer Job is already in progress" }
+        check(jobs.none { it.camera === camera }) { "${camera.name} Sequencer Job is already in progress" }
 
         if (wheel != null && wheel.connected) {
-            check(jobs.none { it.task.wheel === wheel }) { "${camera.name} Sequencer Job is already in progress" }
+            check(jobs.none { it.wheel === wheel }) { "${camera.name} Sequencer Job is already in progress" }
         }
 
         if (focuser != null && focuser.connected) {
-            check(jobs.none { it.task.focuser === focuser }) { "${camera.name} Sequencer Job is already in progress" }
+            check(jobs.none { it.focuser === focuser }) { "${camera.name} Sequencer Job is already in progress" }
         }
 
         if (rotator != null && rotator.connected) {
-            check(jobs.none { it.task.rotator === rotator }) { "${camera.name} Sequencer Job is already in progress" }
+            check(jobs.none { it.rotator === rotator }) { "${camera.name} Sequencer Job is already in progress" }
         }
 
-        val task = SequencerTask(camera, request, guider, mount, wheel, focuser, rotator, threadPoolTaskExecutor, calibrationFrameService)
-        task.subscribe(this)
-
-        with(SequencerJob(task)) {
+        with(SequencerJob(this, camera, request, guider, mount, wheel, focuser, rotator, calibrationFrameService)) {
+            val completable = runAsync(executorService)
             jobs.add(this)
-            whenComplete { _, _ -> jobs.remove(this) }
-            start()
+            completable.whenComplete { _, _ -> jobs.remove(this) }
         }
     }
 
     fun pause(camera: Camera) {
-        jobs.find { it.task.camera === camera }?.pause()
+        jobs.find { it.camera === camera }?.pause()
     }
 
     fun unpause(camera: Camera) {
-        jobs.find { it.task.camera === camera }?.unpause()
+        jobs.find { it.camera === camera }?.unpause()
     }
 
     fun stop(camera: Camera) {
-        jobs.find { it.task.camera === camera }?.stop()
+        jobs.find { it.camera === camera }?.stop()
     }
 
     fun status(camera: Camera): SequencerEvent? {
-        return jobs.find { it.task.camera === camera }?.task?.get() as? SequencerEvent
+        return jobs.find { it.camera === camera }?.status
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/sequencer/SequencerJob.kt b/api/src/main/kotlin/nebulosa/api/sequencer/SequencerJob.kt
index 55b2e7d70..1e8fd6109 100644
--- a/api/src/main/kotlin/nebulosa/api/sequencer/SequencerJob.kt
+++ b/api/src/main/kotlin/nebulosa/api/sequencer/SequencerJob.kt
@@ -1,20 +1,316 @@
 package nebulosa.api.sequencer
 
-import nebulosa.api.cameras.CameraEventAware
-import nebulosa.api.tasks.Job
+import nebulosa.api.calibration.CalibrationFrameProvider
+import nebulosa.api.cameras.*
+import nebulosa.api.focusers.FocuserEventAware
+import nebulosa.api.guiding.DitherAfterExposureEvent
+import nebulosa.api.guiding.DitherAfterExposureTask
+import nebulosa.api.guiding.WaitForSettleTask
+import nebulosa.api.message.MessageEvent
+import nebulosa.api.rotators.RotatorEventAware
 import nebulosa.api.wheels.WheelEventAware
+import nebulosa.api.wheels.WheelMoveTask
+import nebulosa.guiding.Guider
+import nebulosa.indi.device.camera.Camera
 import nebulosa.indi.device.camera.CameraEvent
+import nebulosa.indi.device.camera.FrameType
+import nebulosa.indi.device.filterwheel.FilterWheel
 import nebulosa.indi.device.filterwheel.FilterWheelEvent
+import nebulosa.indi.device.focuser.Focuser
+import nebulosa.indi.device.focuser.FocuserEvent
+import nebulosa.indi.device.mount.Mount
+import nebulosa.indi.device.rotator.Rotator
+import nebulosa.indi.device.rotator.RotatorEvent
+import nebulosa.job.manager.AbstractJob
+import nebulosa.job.manager.SplitTask
+import nebulosa.job.manager.Task
+import nebulosa.job.manager.delay.DelayEvent
+import nebulosa.job.manager.delay.DelayTask
+import nebulosa.log.debug
+import nebulosa.log.loggerFor
+import java.nio.file.Path
 
-data class SequencerJob(override val task: SequencerTask) : Job(), CameraEventAware, WheelEventAware {
+data class SequencerJob(
+    @JvmField val sequencerExecutor: SequencerExecutor,
+    @JvmField val camera: Camera,
+    @JvmField val plan: SequencerPlanRequest,
+    @JvmField val guider: Guider? = null,
+    @JvmField val mount: Mount? = null,
+    @JvmField val wheel: FilterWheel? = null,
+    @JvmField val focuser: Focuser? = null,
+    @JvmField val rotator: Rotator? = null,
+    private val calibrationFrameProvider: CalibrationFrameProvider? = null,
+) : AbstractJob(), CameraEventAware, WheelEventAware, FocuserEventAware, RotatorEventAware {
 
-    override val name = "${task.camera.name} Sequencer Job"
+    private val sequences = plan.sequences.filter { it.enabled }
+    private val initialDelayTask = DelayTask(this, plan.initialDelay)
+    private val waitForSettleTask = WaitForSettleTask(this, guider)
+    private val liveStackingManager = CameraLiveStackingManager(calibrationFrameProvider)
+    private val cameraCaptureEvents =
+        Array(plan.sequences.size + 1) { CameraCaptureEvent(camera, exposureAmount = plan.sequences.getOrNull(it - 1)?.exposureAmount ?: 0) }
+
+    @Volatile private var estimatedCaptureTime = initialDelayTask.duration * 1000L
+    @Volatile private var captureStartElapsedTime = 0L
+
+    @JvmField val status = SequencerEvent(camera)
+
+    init {
+        require(sequences.isNotEmpty()) { "no entries found" }
+
+        add(initialDelayTask)
+
+        if (plan.captureMode == SequencerCaptureMode.FULLY || sequences.size == 1) {
+            var first = true
+
+            for (i in sequences.indices) {
+                val request = sequences[i].map()
+
+                val id = plan.sequences.indexOfFirst { it === sequences[i] } + 1
+
+                // SEQUENCE ID.
+                add(SequencerIdTask(id))
+
+                // FILTER WHEEL.
+                request.wheelMoveTask()?.also(::add)
+
+                // DELAY.
+                val delayTask = DelayTask(this, request.exposureDelay)
+
+                // CAPTURE.
+                val cameraCaptureTask = CameraExposureTask(this, camera, request)
+
+                repeat(request.exposureAmount) {
+                    if (!first) {
+                        add(SplitTask(listOf(delayTask, waitForSettleTask), sequencerExecutor))
+                        cameraCaptureEvents[id].captureRemainingTime += delayTask.duration * 1000L
+                    }
+
+                    add(cameraCaptureTask)
+                    first = false
+
+                    cameraCaptureEvents[id].captureRemainingTime += cameraCaptureTask.exposureTimeInMicroseconds
+                }
+
+                // DITHER.
+                add(DitherAfterExposureTask(this, guider, request.dither))
+            }
+        } else {
+            val requests = sequences.map { it.map() }
+            val sequenceIdTasks = sequences.map { req -> SequencerIdTask(plan.sequences.indexOfFirst { it === req } + 1) }
+            val wheelMoveTasks = requests.map { it.wheelMoveTask() }
+            val cameraExposureTasks = requests.map { CameraExposureTask(this, camera, it) }
+            val delayTasks = requests.map { DelayTask(this, it.exposureDelay) }
+            val ditherAfterExposureTask = requests.map { DitherAfterExposureTask(this, guider, it.dither) }
+            val delayAndWaitForSettleSplitTasks = delayTasks.map { SplitTask(listOf(it, waitForSettleTask), sequencerExecutor) }
+            val count = IntArray(requests.size) { requests[it].exposureAmount }
+            var first = true
+
+            while (count.sum() > 0) {
+                for (i in count.indices) {
+                    if (count[i] > 0) {
+                        val id = sequenceIdTasks[i].id
+
+                        // SEQUENCE ID.
+                        add(sequenceIdTasks[i])
+
+                        // FILTER WHEEL.
+                        wheelMoveTasks[i]?.also(::add)
+
+                        // DELAY.
+                        if (!first) {
+                            add(delayAndWaitForSettleSplitTasks[i])
+                            cameraCaptureEvents[id].captureRemainingTime += delayTasks[i].duration * 1000L
+                        }
+
+                        // CAPTURE.
+                        add(cameraExposureTasks[i])
+                        cameraCaptureEvents[id].captureRemainingTime += cameraExposureTasks[i].exposureTimeInMicroseconds
+
+                        // DITHER.
+                        add(ditherAfterExposureTask[i])
+
+                        count[i]--
+                        first = false
+                    }
+                }
+            }
+        }
+
+        estimatedCaptureTime += cameraCaptureEvents.sumOf { it.captureRemainingTime }
+    }
 
     override fun handleCameraEvent(event: CameraEvent) {
-        task.handleCameraEvent(event)
+        (currentTask as? CameraEventAware)?.handleCameraEvent(event)
     }
 
     override fun handleFilterWheelEvent(event: FilterWheelEvent) {
-        task.handleFilterWheelEvent(event)
+        (currentTask as? WheelEventAware)?.handleFilterWheelEvent(event)
+    }
+
+    override fun handleFocuserEvent(event: FocuserEvent) = Unit
+
+    override fun handleRotatorEvent(event: RotatorEvent) = Unit
+
+    private fun CameraStartCaptureRequest.map() = copy(
+        savePath = plan.savePath,
+        autoSave = true,
+        autoSubFolderMode = plan.autoSubFolderMode,
+        dither = plan.dither,
+        liveStacking = plan.liveStacking,
+        namingFormat = plan.namingFormat,
+    )
+
+    private fun CameraStartCaptureRequest.wheelMoveTask(): WheelMoveTask? {
+        if (wheel != null) {
+            val filterPosition = if (frameType == FrameType.DARK) shutterPosition else filterPosition
+
+            if (filterPosition in 1..wheel.count) {
+                return WheelMoveTask(this@SequencerJob, wheel, filterPosition)
+            }
+        }
+
+        return null
+    }
+
+    private fun addFrameToLiveStacker(request: CameraStartCaptureRequest, path: Path?): Path? {
+        return if (path != null && liveStackingManager.start(request, path)) {
+            try {
+                status.capture.state = CameraCaptureState.STACKING
+                status.send()
+
+                liveStackingManager.stack(request, path)
+            } catch (_: Throwable) {
+                null
+            }
+        } else {
+            null
+        }
+    }
+
+    override fun onPause(paused: Boolean) {
+        if (paused) {
+            status.state = SequencerState.PAUSING
+            status.send()
+        }
+
+        super.onPause(paused)
+    }
+
+    override fun beforePause(task: Task) {
+        status.state = SequencerState.PAUSED
+        status.send()
+    }
+
+    override fun afterPause(task: Task) {
+        status.state = SequencerState.RUNNING
+        status.send()
+    }
+
+    override fun canRun(prev: Task?, current: Task): Boolean {
+        if (current is DitherAfterExposureTask) {
+            return !isCancelled && guider != null
+                    && status.capture.exposureCount >= 1 && current.request.afterExposures > 0
+                    && status.capture.exposureCount % current.request.afterExposures == 0
+        }
+
+        return super.canRun(prev, current)
+    }
+
+    override fun accept(event: Any) {
+        when (event) {
+            is DelayEvent -> {
+                status.capture.handleCameraDelayEvent(event)
+                status.elapsedTime += event.waitTime
+                status.computeRemainingTimeAndProgress()
+                status.send()
+            }
+            is CameraExposureEvent -> {
+                status.capture.handleCameraExposureEvent(event)
+
+                if (event is CameraExposureFailed) {
+                    return stop()
+                }
+
+                if (event is CameraExposureStarted) {
+                    captureStartElapsedTime = status.elapsedTime
+                } else {
+                    status.elapsedTime = captureStartElapsedTime + event.elapsedTime
+
+                    if (event is CameraExposureFinished) {
+                        if (status.capture.captureRemainingTime <= 0L) {
+                            status.capture.state = CameraCaptureState.IDLE
+                        }
+
+                        status.capture.liveStackedPath = addFrameToLiveStacker(event.task.request, status.capture.savedPath)
+                        status.capture.send()
+                    }
+                }
+
+                status.computeRemainingTimeAndProgress()
+                status.send()
+            }
+            is DitherAfterExposureEvent -> {
+                status.capture.state = CameraCaptureState.DITHERING
+                status.send()
+            }
+        }
+    }
+
+    override fun beforeStart() {
+        LOG.debug("Sequencer started. camera={}, mount={}, wheel={}, focuser={}, rotator={}, plan={}", camera, mount, wheel, focuser, rotator, plan)
+
+        status.state = SequencerState.RUNNING
+        status.send()
+    }
+
+    override fun beforeTask(task: Task) {
+        if (task === initialDelayTask && initialDelayTask.duration > 0L) {
+            status.state = SequencerState.WAITING
+        }
+    }
+
+    override fun afterTask(task: Task, exception: Throwable?): Boolean {
+        if (exception == null) {
+            if (task is SequencerIdTask) {
+                status.capture = cameraCaptureEvents[task.id]
+            } else if (task === initialDelayTask) {
+                status.state = SequencerState.RUNNING
+            }
+        }
+
+        return super.afterTask(task, exception)
+    }
+
+    override fun afterFinish() {
+        liveStackingManager.close()
+
+        status.state = SequencerState.IDLE
+        status.send()
+
+        LOG.debug("Sequencer finished. camera={}, mount={}, wheel={}, focuser={}, rotator={}, plan={}", camera, mount, wheel, focuser, rotator, plan)
+    }
+
+    @Suppress("NOTHING_TO_INLINE")
+    private inline fun SequencerEvent.computeRemainingTimeAndProgress() {
+        remainingTime = if (estimatedCaptureTime > elapsedTime) estimatedCaptureTime - elapsedTime else 0L
+        progress = elapsedTime.toDouble() / estimatedCaptureTime
+    }
+
+    @Suppress("NOTHING_TO_INLINE")
+    private inline fun MessageEvent.send() {
+        sequencerExecutor.accept(this)
+    }
+
+    private inner class SequencerIdTask(@JvmField val id: Int) : Task {
+
+        override fun run() {
+            LOG.debug { "Sequence in execution. id=$id" }
+            status.id = id
+        }
+    }
+
+    companion object {
+
+        @JvmStatic private val LOG = loggerFor<SequencerJob>()
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/sequencer/SequencerPlanRequest.kt b/api/src/main/kotlin/nebulosa/api/sequencer/SequencerPlanRequest.kt
index 58b067760..67f5ab787 100644
--- a/api/src/main/kotlin/nebulosa/api/sequencer/SequencerPlanRequest.kt
+++ b/api/src/main/kotlin/nebulosa/api/sequencer/SequencerPlanRequest.kt
@@ -1,27 +1,37 @@
 package nebulosa.api.sequencer
 
-import jakarta.validation.Valid
-import jakarta.validation.constraints.NotEmpty
+import nebulosa.api.beans.converters.time.DurationUnit
 import nebulosa.api.cameras.AutoSubFolderMode
 import nebulosa.api.cameras.CameraCaptureNamingFormat
 import nebulosa.api.cameras.CameraStartCaptureRequest
 import nebulosa.api.guiding.DitherAfterExposureRequest
+import nebulosa.api.javalin.Validatable
+import nebulosa.api.javalin.max
+import nebulosa.api.javalin.notEmpty
+import nebulosa.api.javalin.positiveOrZero
 import nebulosa.api.livestacker.LiveStackingRequest
-import org.hibernate.validator.constraints.time.DurationMax
-import org.hibernate.validator.constraints.time.DurationMin
-import org.springframework.boot.convert.DurationUnit
 import java.nio.file.Path
 import java.time.Duration
 import java.time.temporal.ChronoUnit
+import java.util.concurrent.TimeUnit
 
 data class SequencerPlanRequest(
-    @JvmField @field:DurationUnit(ChronoUnit.SECONDS) @field:DurationMin(seconds = 0) @field:DurationMax(minutes = 60) val initialDelay: Duration = Duration.ZERO,
+    @JvmField @field:DurationUnit(ChronoUnit.SECONDS) val initialDelay: Duration = Duration.ZERO,
     @JvmField val captureMode: SequencerCaptureMode = SequencerCaptureMode.INTERLEAVED,
     @JvmField val autoSubFolderMode: AutoSubFolderMode = AutoSubFolderMode.OFF,
     @JvmField val savePath: Path? = null,
-    @JvmField @field:NotEmpty val sequences: List<CameraStartCaptureRequest> = emptyList(),
-    @JvmField @field:Valid val dither: DitherAfterExposureRequest = DitherAfterExposureRequest.DISABLED,
-    @JvmField @field:Valid val autoFocus: AutoFocusAfterConditions = AutoFocusAfterConditions.DISABLED,
-    @JvmField @field:Valid val liveStacking: LiveStackingRequest = LiveStackingRequest.DISABLED,
-    @JvmField @field:Valid val namingFormat: CameraCaptureNamingFormat = CameraCaptureNamingFormat.DEFAULT,
-)
+    @JvmField val sequences: List<CameraStartCaptureRequest> = emptyList(),
+    @JvmField val dither: DitherAfterExposureRequest = DitherAfterExposureRequest.DISABLED,
+    @JvmField val autoFocus: AutoFocusAfterConditions = AutoFocusAfterConditions.DISABLED,
+    @JvmField val liveStacking: LiveStackingRequest = LiveStackingRequest.DISABLED,
+    @JvmField val namingFormat: CameraCaptureNamingFormat = CameraCaptureNamingFormat.DEFAULT,
+) : Validatable {
+
+    override fun validate() {
+        initialDelay.positiveOrZero().max(60L, TimeUnit.MINUTES)
+        sequences.notEmpty()
+        dither.validate()
+        autoFocus.validate()
+        liveStacking.validate()
+    }
+}
diff --git a/api/src/main/kotlin/nebulosa/api/sequencer/SequencerService.kt b/api/src/main/kotlin/nebulosa/api/sequencer/SequencerService.kt
index 1672a18d7..12f603383 100644
--- a/api/src/main/kotlin/nebulosa/api/sequencer/SequencerService.kt
+++ b/api/src/main/kotlin/nebulosa/api/sequencer/SequencerService.kt
@@ -5,12 +5,10 @@ import nebulosa.indi.device.filterwheel.FilterWheel
 import nebulosa.indi.device.focuser.Focuser
 import nebulosa.indi.device.mount.Mount
 import nebulosa.indi.device.rotator.Rotator
-import org.springframework.stereotype.Service
 import java.nio.file.Path
 import kotlin.io.path.exists
 import kotlin.io.path.isDirectory
 
-@Service
 class SequencerService(
     private val sequencesPath: Path,
     private val sequencerExecutor: SequencerExecutor,
diff --git a/api/src/main/kotlin/nebulosa/api/sequencer/SequencerState.kt b/api/src/main/kotlin/nebulosa/api/sequencer/SequencerState.kt
index 4fc5ecca9..8b318bd79 100644
--- a/api/src/main/kotlin/nebulosa/api/sequencer/SequencerState.kt
+++ b/api/src/main/kotlin/nebulosa/api/sequencer/SequencerState.kt
@@ -2,6 +2,7 @@ package nebulosa.api.sequencer
 
 enum class SequencerState {
     IDLE,
+    WAITING,
     RUNNING,
     PAUSING,
     PAUSED,
diff --git a/api/src/main/kotlin/nebulosa/api/sequencer/SequencerTask.kt b/api/src/main/kotlin/nebulosa/api/sequencer/SequencerTask.kt
deleted file mode 100644
index c552cd941..000000000
--- a/api/src/main/kotlin/nebulosa/api/sequencer/SequencerTask.kt
+++ /dev/null
@@ -1,301 +0,0 @@
-package nebulosa.api.sequencer
-
-import io.reactivex.rxjava3.functions.Consumer
-import nebulosa.api.calibration.CalibrationFrameProvider
-import nebulosa.api.cameras.*
-import nebulosa.api.message.MessageEvent
-import nebulosa.api.tasks.AbstractTask
-import nebulosa.api.tasks.Task
-import nebulosa.api.tasks.delay.DelayEvent
-import nebulosa.api.tasks.delay.DelayTask
-import nebulosa.api.wheels.WheelEventAware
-import nebulosa.api.wheels.WheelMoveTask
-import nebulosa.common.concurrency.cancel.CancellationToken
-import nebulosa.common.concurrency.latch.PauseListener
-import nebulosa.guiding.Guider
-import nebulosa.indi.device.camera.Camera
-import nebulosa.indi.device.camera.CameraEvent
-import nebulosa.indi.device.camera.FrameType
-import nebulosa.indi.device.filterwheel.FilterWheel
-import nebulosa.indi.device.filterwheel.FilterWheelEvent
-import nebulosa.indi.device.focuser.Focuser
-import nebulosa.indi.device.mount.Mount
-import nebulosa.indi.device.rotator.Rotator
-import nebulosa.log.loggerFor
-import java.time.Duration
-import java.util.*
-import java.util.concurrent.Executor
-import java.util.concurrent.atomic.AtomicBoolean
-import java.util.concurrent.atomic.AtomicInteger
-import java.util.concurrent.atomic.AtomicReference
-
-// https://cdn.diffractionlimited.com/help/maximdl/Autosave_Sequence.htm
-// https://nighttime-imaging.eu/docs/master/site/tabs/sequence/
-// https://nighttime-imaging.eu/docs/master/site/sequencer/advanced/advanced/
-
-data class SequencerTask(
-    @JvmField val camera: Camera,
-    @JvmField val plan: SequencerPlanRequest,
-    @JvmField val guider: Guider? = null,
-    @JvmField val mount: Mount? = null,
-    @JvmField val wheel: FilterWheel? = null,
-    @JvmField val focuser: Focuser? = null,
-    @JvmField val rotator: Rotator? = null,
-    private val executor: Executor? = null,
-    private val calibrationFrameProvider: CalibrationFrameProvider? = null,
-) : AbstractTask<MessageEvent>(), Consumer<Any>, CameraEventAware, WheelEventAware, PauseListener {
-
-    private val sequences = plan.sequences.filter { it.enabled }
-    private val initialDelayTask = DelayTask(plan.initialDelay)
-    private val sequencerId = AtomicInteger()
-    private val tasks = LinkedList<Task>()
-    private val currentTask = AtomicReference<Task>()
-    private val pausing = AtomicBoolean()
-    private val paused = AtomicBoolean()
-    private val liveStackingManager = CameraLiveStackingManager(calibrationFrameProvider)
-
-    @Volatile private var estimatedCaptureTime = initialDelayTask.duration
-    @Volatile private var elapsedTime = Duration.ZERO
-    @Volatile private var prevElapsedTime = Duration.ZERO
-    @Volatile private var remainingTime = Duration.ZERO
-    @Volatile private var progress = 0.0
-
-    init {
-        require(sequences.isNotEmpty()) { "no entries found" }
-
-        initialDelayTask.subscribe(this)
-        tasks.add(initialDelayTask)
-
-        fun mapRequest(request: CameraStartCaptureRequest) = request.copy(
-            savePath = plan.savePath, autoSave = true,
-            autoSubFolderMode = plan.autoSubFolderMode,
-            dither = plan.dither,
-            liveStacking = plan.liveStacking,
-            namingFormat = plan.namingFormat,
-        )
-
-        if (plan.captureMode == SequencerCaptureMode.FULLY || sequences.size == 1) {
-            for (i in sequences.indices) {
-                val request = mapRequest(sequences[i])
-
-                // ID.
-                tasks.add(SequencerIdTask(plan.sequences.indexOfFirst { it === sequences[i] } + 1))
-
-                // FILTER WHEEL.
-                request.wheelMoveTask()?.also(tasks::add)
-
-                // CAPTURE.
-                val cameraCaptureTask = CameraCaptureTask(
-                    camera, request, guider, false, executor,
-                    liveStackingManager,
-                    mount, wheel, focuser, rotator
-                )
-
-                cameraCaptureTask.subscribe(this)
-                estimatedCaptureTime += cameraCaptureTask.estimatedCaptureTime
-                tasks.add(SequenceCaptureModeCameraCaptureTask(cameraCaptureTask, SequencerCaptureMode.FULLY, i))
-            }
-        } else {
-            val sequenceIdTasks = sequences.map { req -> SequencerIdTask(plan.sequences.indexOfFirst { it === req } + 1) }
-            val requests = sequences.map { mapRequest(it) }
-            val cameraCaptureTasks = requests.mapIndexed { i, req ->
-                val task = CameraCaptureTask(
-                    camera, req, guider,
-                    i > 0, executor, liveStackingManager,
-                    mount, wheel, focuser, rotator
-                )
-
-                SequenceCaptureModeCameraCaptureTask(task, SequencerCaptureMode.INTERLEAVED, i)
-            }
-            val wheelMoveTasks = requests.map { it.wheelMoveTask() }
-            val count = IntArray(requests.size) { sequences[it].exposureAmount }
-
-            for ((cameraCaptureTask) in cameraCaptureTasks) {
-                cameraCaptureTask.subscribe(this)
-                estimatedCaptureTime += cameraCaptureTask.estimatedCaptureTime
-            }
-
-            while (count.sum() > 0) {
-                for (i in sequences.indices) {
-                    if (count[i] > 0) {
-                        tasks.add(sequenceIdTasks[i])
-                        wheelMoveTasks[i]?.also(tasks::add)
-
-                        val task = cameraCaptureTasks[i]
-
-                        if (count[i] == sequences[i].exposureAmount) {
-                            tasks.add(InitializeCameraCaptureTask(task.task))
-                        }
-
-                        tasks.add(task)
-
-                        count[i]--
-
-                        if (count[i] == 0) {
-                            tasks.add(FininalizeCameraCaptureTask(task.task))
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    override fun handleCameraEvent(event: CameraEvent) {
-        when (val task = currentTask.get()) {
-            is CameraCaptureTask -> task.handleCameraEvent(event)
-            is SequenceCaptureModeCameraCaptureTask -> task.task.handleCameraEvent(event)
-        }
-    }
-
-    override fun handleFilterWheelEvent(event: FilterWheelEvent) {
-        when (val task = currentTask.get()) {
-            is WheelMoveTask -> task.handleFilterWheelEvent(event)
-            is CameraCaptureTask -> task.handleFilterWheelEvent(event)
-            is SequenceCaptureModeCameraCaptureTask -> task.task.handleFilterWheelEvent(event)
-        }
-    }
-
-    override fun onPause(paused: Boolean) {
-        pausing.set(paused)
-
-        if (paused) {
-            sendEvent(SequencerState.PAUSING)
-        }
-    }
-
-    override fun execute(cancellationToken: CancellationToken) {
-        LOG.info("Sequencer started. camera={}, mount={}, wheel={}, focuser={}, plan={}", camera, mount, wheel, focuser, plan)
-
-        cancellationToken.listenToPause(this)
-
-        for (task in tasks) {
-            if (cancellationToken.isCancelled) break
-
-            currentTask.set(task)
-            task.execute(cancellationToken)
-            currentTask.set(null)
-        }
-
-        if (remainingTime.toMillis() > 0L) {
-            remainingTime = Duration.ZERO
-            progress = 1.0
-            sendEvent(SequencerState.IDLE)
-        }
-
-        cancellationToken.unlistenToPause(this)
-
-        LOG.info("Sequencer finished. camera={}, mount={}, wheel={}, focuser={}, plan={}", camera, mount, wheel, focuser, plan)
-    }
-
-    private fun CameraStartCaptureRequest.wheelMoveTask(): WheelMoveTask? {
-        if (wheel != null) {
-            val filterPosition = if (frameType == FrameType.DARK) shutterPosition else filterPosition
-
-            if (filterPosition in 1..wheel.count) {
-                return WheelMoveTask(wheel, filterPosition)
-            }
-        }
-
-        return null
-    }
-
-    override fun canUseAsLastEvent(event: MessageEvent) = event is SequencerEvent
-
-    override fun accept(event: Any) {
-        when (event) {
-            is DelayEvent -> {
-                if (event.task === initialDelayTask) {
-                    elapsedTime += event.waitTime
-                    computeRemainingTimeAndProgress()
-                    sendEvent(SequencerState.RUNNING)
-                }
-            }
-            is CameraCaptureEvent -> {
-                pausing.set(event.state == CameraCaptureState.PAUSING)
-                paused.set(event.state == CameraCaptureState.PAUSED)
-
-                when (event.state) {
-                    CameraCaptureState.CAPTURE_STARTED -> {
-                        prevElapsedTime = elapsedTime
-                    }
-                    CameraCaptureState.EXPOSURING,
-                    CameraCaptureState.WAITING -> {
-                        elapsedTime = prevElapsedTime + event.captureElapsedTime
-                        computeRemainingTimeAndProgress()
-                    }
-                    CameraCaptureState.EXPOSURE_FINISHED -> {
-                        onNext(event)
-                    }
-                    else -> Unit
-                }
-
-                sendEvent(SequencerState.RUNNING, event)
-            }
-        }
-    }
-
-    @Suppress("NOTHING_TO_INLINE")
-    private inline fun computeRemainingTimeAndProgress() {
-        remainingTime = if (estimatedCaptureTime > elapsedTime) estimatedCaptureTime - elapsedTime else Duration.ZERO
-        progress = (estimatedCaptureTime - remainingTime).toNanos().toDouble() / estimatedCaptureTime.toNanos()
-    }
-
-    @Suppress("NOTHING_TO_INLINE")
-    private inline fun sendEvent(state: SequencerState, capture: CameraCaptureEvent? = null) {
-        onNext(
-            SequencerEvent(
-                sequencerId.get(), elapsedTime, remainingTime, progress, capture,
-                if (pausing.get()) SequencerState.PAUSING else if (paused.get()) SequencerState.PAUSED else state
-            )
-        )
-    }
-
-    override fun close() {
-        tasks.forEach { it.close() }
-        liveStackingManager.close()
-    }
-
-    private inner class SequencerIdTask(private val id: Int) : Task {
-
-        override fun execute(cancellationToken: CancellationToken) {
-            LOG.info("Sequence in execution. id={}", id)
-            sequencerId.set(id)
-        }
-    }
-
-    private data class InitializeCameraCaptureTask(@JvmField val task: CameraCaptureTask) : Task {
-
-        override fun execute(cancellationToken: CancellationToken) {
-            task.initialize(cancellationToken)
-        }
-    }
-
-    private data class SequenceCaptureModeCameraCaptureTask(
-        @JvmField val task: CameraCaptureTask,
-        @JvmField val mode: SequencerCaptureMode,
-        @JvmField val index: Int,
-    ) : Task {
-
-        override fun execute(cancellationToken: CancellationToken) {
-            if (mode == SequencerCaptureMode.FULLY) {
-                task.initialize(cancellationToken)
-                task.executeInLoop(cancellationToken)
-                task.finalize(cancellationToken)
-            } else {
-                task.executeOnce(cancellationToken)
-            }
-        }
-    }
-
-    private data class FininalizeCameraCaptureTask(@JvmField val task: CameraCaptureTask) : Task {
-
-        override fun execute(cancellationToken: CancellationToken) {
-            task.finalize(cancellationToken)
-        }
-    }
-
-    companion object {
-
-        @JvmStatic private val LOG = loggerFor<SequencerTask>()
-    }
-}
diff --git a/api/src/main/kotlin/nebulosa/api/stacker/StackerController.kt b/api/src/main/kotlin/nebulosa/api/stacker/StackerController.kt
index 66a95ff33..9f37bd4e8 100644
--- a/api/src/main/kotlin/nebulosa/api/stacker/StackerController.kt
+++ b/api/src/main/kotlin/nebulosa/api/stacker/StackerController.kt
@@ -1,46 +1,52 @@
 package nebulosa.api.stacker
 
-import jakarta.validation.Valid
-import nebulosa.common.concurrency.cancel.CancellationToken
-import org.springframework.validation.annotation.Validated
-import org.springframework.web.bind.annotation.*
-import java.nio.file.Path
+import io.javalin.Javalin
+import io.javalin.http.Context
+import io.javalin.http.bodyAsClass
+import nebulosa.api.javalin.exists
+import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.path
+import nebulosa.api.javalin.valid
+import nebulosa.util.concurrency.cancellation.CancellationToken
 import java.util.concurrent.atomic.AtomicReference
 
-@Validated
-@RestController
-@RequestMapping("stacker")
 class StackerController(
+    app: Javalin,
     private val stackerService: StackerService,
 ) {
 
     private val cancellationToken = AtomicReference<CancellationToken>()
 
-    @PutMapping("start")
-    fun start(@RequestBody @Valid body: StackingRequest): Path? {
-        return if (cancellationToken.compareAndSet(null, CancellationToken())) {
+    init {
+        app.put("stacker/start", ::start)
+        app.get("stacker/running", ::isRunning)
+        app.put("stacker/stop", ::stop)
+        app.put("stacker/analyze", ::analyze)
+    }
+
+    private fun start(ctx: Context) {
+        val body = ctx.bodyAsClass<StackingRequest>().valid()
+
+        if (cancellationToken.compareAndSet(null, CancellationToken())) {
             try {
-                stackerService.stack(body, cancellationToken.get())
+                stackerService.stack(body, cancellationToken.get())?.also(ctx::json)
             } finally {
                 cancellationToken.getAndSet(null)?.unlistenAll()
             }
-        } else {
-            null
         }
     }
 
-    @GetMapping("running")
-    fun isRunning(): Boolean {
-        return cancellationToken.get() != null
+    private fun isRunning(ctx: Context) {
+        ctx.json(cancellationToken.get() != null)
     }
 
-    @PutMapping("stop")
-    fun stop() {
+    @Suppress("UNUSED_PARAMETER")
+    private fun stop(ctx: Context) {
         cancellationToken.get()?.cancel()
     }
 
-    @PutMapping("analyze")
-    fun analyze(@RequestParam path: Path): AnalyzedTarget? {
-        return stackerService.analyze(path)
+    private fun analyze(ctx: Context) {
+        val path = ctx.queryParam("path").notNull().path().exists()
+        stackerService.analyze(path)?.also(ctx::json)
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/stacker/StackerService.kt b/api/src/main/kotlin/nebulosa/api/stacker/StackerService.kt
index c1b35d5cf..ee6279215 100644
--- a/api/src/main/kotlin/nebulosa/api/stacker/StackerService.kt
+++ b/api/src/main/kotlin/nebulosa/api/stacker/StackerService.kt
@@ -1,21 +1,19 @@
 package nebulosa.api.stacker
 
 import nebulosa.api.message.MessageService
-import nebulosa.common.concurrency.cancel.CancellationToken
 import nebulosa.fits.fits
 import nebulosa.fits.isFits
 import nebulosa.image.format.ImageHdu
 import nebulosa.stacker.AutoStacker
 import nebulosa.stacker.AutoStackerListener
+import nebulosa.util.concurrency.cancellation.CancellationToken
 import nebulosa.xisf.isXisf
 import nebulosa.xisf.xisf
-import org.springframework.stereotype.Service
 import java.nio.file.Path
 import kotlin.io.path.exists
 import kotlin.io.path.isDirectory
 import kotlin.io.path.isRegularFile
 
-@Service
 class StackerService(private val messageService: MessageService?) {
 
     @Synchronized
@@ -134,7 +132,7 @@ class StackerService(private val messageService: MessageService?) {
         else if (path.isXisf()) path.xisf()
         else return null
 
-        return image.use { it.firstOrNull { it is ImageHdu }?.header }?.let(::AnalyzedTarget)
+        return image.use { it.firstOrNull { hdu -> hdu is ImageHdu }?.header }?.let(::AnalyzedTarget)
     }
 
     private inner class AutoStackerMessageHandler(
diff --git a/api/src/main/kotlin/nebulosa/api/stacker/StackingRequest.kt b/api/src/main/kotlin/nebulosa/api/stacker/StackingRequest.kt
index 66b00312a..51f6e557c 100644
--- a/api/src/main/kotlin/nebulosa/api/stacker/StackingRequest.kt
+++ b/api/src/main/kotlin/nebulosa/api/stacker/StackingRequest.kt
@@ -1,8 +1,8 @@
 package nebulosa.api.stacker
 
-import jakarta.validation.Valid
-import jakarta.validation.constraints.NotNull
-import jakarta.validation.constraints.Size
+import nebulosa.api.javalin.Validatable
+import nebulosa.api.javalin.minSize
+import nebulosa.api.javalin.notNull
 import nebulosa.pixinsight.script.startPixInsight
 import nebulosa.pixinsight.stacker.PixInsightAutoStacker
 import nebulosa.stacker.AutoStacker
@@ -13,9 +13,9 @@ import kotlin.io.path.exists
 import kotlin.io.path.isRegularFile
 
 data class StackingRequest(
-    @JvmField @field:NotNull val outputDirectory: Path? = null,
+    @JvmField val outputDirectory: Path? = null,
     @JvmField val type: StackerType = StackerType.PIXINSIGHT,
-    @JvmField @field:NotNull val executablePath: Path? = null,
+    @JvmField val executablePath: Path? = null,
     @JvmField val darkPath: Path? = null,
     @JvmField val darkEnabled: Boolean = false,
     @JvmField val flatPath: Path? = null,
@@ -24,9 +24,16 @@ data class StackingRequest(
     @JvmField val biasEnabled: Boolean = false,
     @JvmField val use32Bits: Boolean = false,
     @JvmField val slot: Int = 1,
-    @JvmField @field:NotNull val referencePath: Path? = null,
-    @JvmField @field:Size(min = 2) @field:Valid val targets: List<StackingTarget> = emptyList(),
-) : Supplier<AutoStacker> {
+    @JvmField val referencePath: Path? = null,
+    @JvmField val targets: List<StackingTarget> = emptyList(),
+) : Supplier<AutoStacker>, Validatable {
+
+    override fun validate() {
+        outputDirectory.notNull().exists()
+        executablePath.notNull()
+        referencePath.notNull().exists()
+        targets.minSize(2).onEach { it.validate() }
+    }
 
     override fun get(): AutoStacker {
         val workingDirectory = Files.createTempDirectory("as-")
diff --git a/api/src/main/kotlin/nebulosa/api/stacker/StackingTarget.kt b/api/src/main/kotlin/nebulosa/api/stacker/StackingTarget.kt
index a544f999f..3a4253fae 100644
--- a/api/src/main/kotlin/nebulosa/api/stacker/StackingTarget.kt
+++ b/api/src/main/kotlin/nebulosa/api/stacker/StackingTarget.kt
@@ -1,11 +1,18 @@
 package nebulosa.api.stacker
 
-import jakarta.validation.constraints.NotNull
+import nebulosa.api.javalin.Validatable
+import nebulosa.api.javalin.exists
+import nebulosa.api.javalin.notNull
 import java.nio.file.Path
 
 data class StackingTarget(
     @JvmField val enabled: Boolean = true,
-    @JvmField @field:NotNull val path: Path? = null,
+    @JvmField val path: Path? = null,
     @JvmField val group: StackerGroupType = StackerGroupType.MONO,
     @JvmField val debayer: Boolean = true,
-)
+) : Validatable {
+
+    override fun validate() {
+        path.notNull().exists()
+    }
+}
diff --git a/api/src/main/kotlin/nebulosa/api/stardetector/StarDetectionController.kt b/api/src/main/kotlin/nebulosa/api/stardetector/StarDetectionController.kt
index 64eaf5c5a..13f8d4a7d 100644
--- a/api/src/main/kotlin/nebulosa/api/stardetector/StarDetectionController.kt
+++ b/api/src/main/kotlin/nebulosa/api/stardetector/StarDetectionController.kt
@@ -1,18 +1,25 @@
 package nebulosa.api.stardetector
 
-import jakarta.validation.Valid
-import org.springframework.validation.annotation.Validated
-import org.springframework.web.bind.annotation.*
-import java.nio.file.Path
+import io.javalin.Javalin
+import io.javalin.http.Context
+import io.javalin.http.bodyAsClass
+import nebulosa.api.javalin.exists
+import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.path
+import nebulosa.api.javalin.valid
 
-@Validated
-@RestController
-@RequestMapping("star-detection")
-class StarDetectionController(private val starDetectionService: StarDetectionService) {
+class StarDetectionController(
+    app: Javalin,
+    private val starDetectionService: StarDetectionService,
+) {
 
-    @PutMapping
-    fun detectStars(
-        @RequestParam path: Path,
-        @RequestBody @Valid body: StarDetectionRequest
-    ) = starDetectionService.detectStars(path, body)
+    init {
+        app.put("star-detection", ::detectStars)
+    }
+
+    private fun detectStars(ctx: Context) {
+        val path = ctx.queryParam("path").notNull().path().exists()
+        val body = ctx.bodyAsClass<StarDetectionRequest>().valid()
+        ctx.json(starDetectionService.detectStars(path, body))
+    }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/stardetector/StarDetectionRequest.kt b/api/src/main/kotlin/nebulosa/api/stardetector/StarDetectionRequest.kt
index 982f000a9..437164f9e 100644
--- a/api/src/main/kotlin/nebulosa/api/stardetector/StarDetectionRequest.kt
+++ b/api/src/main/kotlin/nebulosa/api/stardetector/StarDetectionRequest.kt
@@ -1,5 +1,7 @@
 package nebulosa.api.stardetector
 
+import nebulosa.api.javalin.Validatable
+import nebulosa.api.javalin.positiveOrZero
 import nebulosa.astap.stardetector.AstapStarDetector
 import nebulosa.pixinsight.script.startPixInsight
 import nebulosa.pixinsight.stardetector.PixInsightStarDetector
@@ -16,7 +18,14 @@ data class StarDetectionRequest(
     @JvmField val minSNR: Double = 0.0,
     @JvmField val maxStars: Int = 0,
     @JvmField val slot: Int = 1,
-) : Supplier<StarDetector<Path>> {
+) : Supplier<StarDetector<Path>>, Validatable {
+
+    override fun validate() {
+        timeout.positiveOrZero()
+        minSNR.positiveOrZero()
+        maxStars.positiveOrZero()
+        slot.positiveOrZero()
+    }
 
     override fun get() = when (type) {
         StarDetectorType.ASTAP -> AstapStarDetector(executablePath!!, minSNR)
diff --git a/api/src/main/kotlin/nebulosa/api/stardetector/StarDetectionService.kt b/api/src/main/kotlin/nebulosa/api/stardetector/StarDetectionService.kt
index 576bf184a..e9297fb2a 100644
--- a/api/src/main/kotlin/nebulosa/api/stardetector/StarDetectionService.kt
+++ b/api/src/main/kotlin/nebulosa/api/stardetector/StarDetectionService.kt
@@ -1,10 +1,8 @@
 package nebulosa.api.stardetector
 
 import nebulosa.stardetector.StarPoint
-import org.springframework.stereotype.Service
 import java.nio.file.Path
 
-@Service
 class StarDetectionService {
 
     fun detectStars(path: Path, options: StarDetectionRequest): List<StarPoint> {
diff --git a/api/src/main/kotlin/nebulosa/api/stardetector/StarPointSerializer.kt b/api/src/main/kotlin/nebulosa/api/stardetector/StarPointSerializer.kt
index 907df78b3..98f030dcf 100644
--- a/api/src/main/kotlin/nebulosa/api/stardetector/StarPointSerializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/stardetector/StarPointSerializer.kt
@@ -4,9 +4,7 @@ import com.fasterxml.jackson.core.JsonGenerator
 import com.fasterxml.jackson.databind.SerializerProvider
 import com.fasterxml.jackson.databind.ser.std.StdSerializer
 import nebulosa.stardetector.StarPoint
-import org.springframework.stereotype.Component
 
-@Component
 class StarPointSerializer : StdSerializer<StarPoint>(StarPoint::class.java) {
 
     override fun serialize(star: StarPoint?, gen: JsonGenerator, provider: SerializerProvider) {
diff --git a/api/src/main/kotlin/nebulosa/api/tasks/AbstractTask.kt b/api/src/main/kotlin/nebulosa/api/tasks/AbstractTask.kt
deleted file mode 100644
index 676439b12..000000000
--- a/api/src/main/kotlin/nebulosa/api/tasks/AbstractTask.kt
+++ /dev/null
@@ -1,31 +0,0 @@
-package nebulosa.api.tasks
-
-import io.reactivex.rxjava3.core.Observable
-import io.reactivex.rxjava3.core.Observer
-import java.util.concurrent.atomic.AtomicReference
-
-abstract class AbstractTask<T : Any> : Observable<T>(), ObservableTask<T> {
-
-    private val observers = LinkedHashSet<Observer<in T>>(1)
-    private val lastEvent = AtomicReference<T>()
-
-    protected open fun canUseAsLastEvent(event: T) = true
-
-    final override fun get(): T? = lastEvent.get()
-
-    final override fun subscribeActual(observer: Observer<in T>) {
-        observers.add(observer)
-    }
-
-    protected fun onNext(event: T) {
-        if (canUseAsLastEvent(event)) {
-            lastEvent.set(event)
-        }
-
-        observers.forEach { it.onNext(event) }
-    }
-
-    override fun close() {
-        observers.forEach { it.onComplete() }
-    }
-}
diff --git a/api/src/main/kotlin/nebulosa/api/tasks/Job.kt b/api/src/main/kotlin/nebulosa/api/tasks/Job.kt
deleted file mode 100644
index d733d654f..000000000
--- a/api/src/main/kotlin/nebulosa/api/tasks/Job.kt
+++ /dev/null
@@ -1,66 +0,0 @@
-package nebulosa.api.tasks
-
-import nebulosa.common.concurrency.cancel.CancellationToken
-import java.util.concurrent.CompletableFuture
-import java.util.concurrent.atomic.AtomicBoolean
-
-abstract class Job : CompletableFuture<Unit>(), Runnable {
-
-    abstract val task: Task
-
-    abstract val name: String
-
-    private val cancellationToken = CancellationToken()
-    private val running = AtomicBoolean()
-
-    @Volatile private var thread: Thread? = null
-
-    val isRunning
-        get() = running.get()
-
-    final override fun run() {
-        try {
-            running.set(true)
-            task.execute(cancellationToken)
-        } finally {
-            running.set(false)
-            thread = null
-            cancellationToken.close()
-            complete(Unit)
-            task.close()
-        }
-    }
-
-    /**
-     * Runs this Job in a new thread.
-     */
-    @Synchronized
-    fun start() {
-        if (thread == null && !running.get()) {
-            thread = Thread(this, name)
-            thread!!.isDaemon = true
-            thread!!.start()
-        }
-    }
-
-    /**
-     * Stops gracefully this Job.
-     */
-    fun stop() {
-        cancellationToken.cancel()
-    }
-
-    /**
-     * Pauses this Job.
-     */
-    fun pause() {
-        cancellationToken.pause()
-    }
-
-    /**
-     * Unpauses this Job.
-     */
-    fun unpause() {
-        cancellationToken.unpause()
-    }
-}
diff --git a/api/src/main/kotlin/nebulosa/api/tasks/ObservableTask.kt b/api/src/main/kotlin/nebulosa/api/tasks/ObservableTask.kt
deleted file mode 100644
index e04a941c4..000000000
--- a/api/src/main/kotlin/nebulosa/api/tasks/ObservableTask.kt
+++ /dev/null
@@ -1,6 +0,0 @@
-package nebulosa.api.tasks
-
-import io.reactivex.rxjava3.core.ObservableSource
-import java.util.function.Supplier
-
-interface ObservableTask<T : Any> : Task, ObservableSource<T>, Supplier<T?>
diff --git a/api/src/main/kotlin/nebulosa/api/tasks/SplitTask.kt b/api/src/main/kotlin/nebulosa/api/tasks/SplitTask.kt
deleted file mode 100644
index 9de7e082c..000000000
--- a/api/src/main/kotlin/nebulosa/api/tasks/SplitTask.kt
+++ /dev/null
@@ -1,32 +0,0 @@
-package nebulosa.api.tasks
-
-import nebulosa.common.concurrency.cancel.CancellationToken
-import java.util.concurrent.CompletableFuture
-import java.util.concurrent.Executor
-import java.util.concurrent.ForkJoinPool
-
-data class SplitTask(
-    private val tasks: Collection<Task>,
-    private val executor: Executor? = null,
-) : Task {
-
-    override fun execute(cancellationToken: CancellationToken) {
-        if (tasks.isEmpty()) {
-            return
-        } else if (tasks.size == 1) {
-            tasks.first().execute(cancellationToken)
-        } else {
-            val completables = tasks.map { CompletableFuture.runAsync({ it.execute(cancellationToken) }, executor ?: EXECUTOR) }
-            completables.forEach(CompletableFuture<*>::join)
-        }
-    }
-
-    override fun reset() {
-        tasks.forEach { it.reset() }
-    }
-
-    companion object {
-
-        @JvmStatic private val EXECUTOR = ForkJoinPool.commonPool()
-    }
-}
diff --git a/api/src/main/kotlin/nebulosa/api/tasks/Task.kt b/api/src/main/kotlin/nebulosa/api/tasks/Task.kt
deleted file mode 100644
index 9626e3eaa..000000000
--- a/api/src/main/kotlin/nebulosa/api/tasks/Task.kt
+++ /dev/null
@@ -1,26 +0,0 @@
-package nebulosa.api.tasks
-
-import nebulosa.common.Resettable
-import nebulosa.common.concurrency.cancel.CancellationToken
-
-interface Task : Resettable, AutoCloseable {
-
-    fun execute(cancellationToken: CancellationToken = CancellationToken.NONE)
-
-    override fun reset() = Unit
-
-    override fun close() = Unit
-
-    companion object {
-
-        @JvmStatic
-        fun of(vararg tasks: Task) = object : Task {
-
-            override fun execute(cancellationToken: CancellationToken) = tasks.forEach { it.execute(cancellationToken) }
-
-            override fun reset() = tasks.forEach { it.reset() }
-
-            override fun close() = tasks.forEach { it.close() }
-        }
-    }
-}
diff --git a/api/src/main/kotlin/nebulosa/api/tasks/delay/DelayEvent.kt b/api/src/main/kotlin/nebulosa/api/tasks/delay/DelayEvent.kt
deleted file mode 100644
index f68e8119c..000000000
--- a/api/src/main/kotlin/nebulosa/api/tasks/delay/DelayEvent.kt
+++ /dev/null
@@ -1,10 +0,0 @@
-package nebulosa.api.tasks.delay
-
-import java.time.Duration
-
-data class DelayEvent(
-    @JvmField val task: DelayTask,
-    @JvmField val remainingTime: Duration = Duration.ZERO,
-    @JvmField val waitTime: Duration = Duration.ZERO,
-    @JvmField val progress: Double = 0.0,
-)
diff --git a/api/src/main/kotlin/nebulosa/api/tasks/delay/DelayTask.kt b/api/src/main/kotlin/nebulosa/api/tasks/delay/DelayTask.kt
deleted file mode 100644
index 6d3dbe5e4..000000000
--- a/api/src/main/kotlin/nebulosa/api/tasks/delay/DelayTask.kt
+++ /dev/null
@@ -1,61 +0,0 @@
-package nebulosa.api.tasks.delay
-
-import nebulosa.api.tasks.AbstractTask
-import nebulosa.common.concurrency.cancel.CancellationToken
-import nebulosa.log.loggerFor
-import java.time.Duration
-
-data class DelayTask(
-    @JvmField val duration: Duration,
-) : AbstractTask<DelayEvent>() {
-
-    @Volatile private var remainingTime = Duration.ZERO
-    @Volatile private var waitTime = Duration.ZERO
-    @Volatile private var progress = 0.0
-
-    override fun execute(cancellationToken: CancellationToken) {
-        val durationTime = duration.toMillis()
-        var remainingTime = durationTime
-
-        if (!cancellationToken.isCancelled && remainingTime > 0L) {
-            LOG.info("Delay started. duration={}", remainingTime)
-
-            while (!cancellationToken.isCancelled && remainingTime > 0L) {
-                val waitTime = minOf(remainingTime, DELAY_INTERVAL)
-
-                if (waitTime > 0L) {
-                    progress = (durationTime - remainingTime) / durationTime.toDouble()
-                    this.remainingTime = Duration.ofMillis(remainingTime)
-                    this.waitTime = Duration.ofMillis(waitTime)
-                    sendEvent()
-
-                    Thread.sleep(waitTime)
-
-                    remainingTime -= waitTime
-                }
-            }
-
-            this.remainingTime = Duration.ZERO
-            this.waitTime = Duration.ZERO
-            progress = 1.0
-
-            sendEvent()
-        }
-    }
-
-    override fun reset() {
-        remainingTime = Duration.ZERO
-        waitTime = Duration.ZERO
-        progress = 0.0
-    }
-
-    private fun sendEvent() {
-        onNext(DelayEvent(this, remainingTime, waitTime, progress))
-    }
-
-    companion object {
-
-        const val DELAY_INTERVAL = 500L
-        @JvmStatic private val LOG = loggerFor<DelayTask>()
-    }
-}
diff --git a/api/src/main/kotlin/nebulosa/api/wheels/WheelController.kt b/api/src/main/kotlin/nebulosa/api/wheels/WheelController.kt
index 2c7c9acd9..d31ff9a24 100644
--- a/api/src/main/kotlin/nebulosa/api/wheels/WheelController.kt
+++ b/api/src/main/kotlin/nebulosa/api/wheels/WheelController.kt
@@ -1,57 +1,66 @@
 package nebulosa.api.wheels
 
-import jakarta.validation.Valid
-import jakarta.validation.constraints.NotEmpty
-import jakarta.validation.constraints.PositiveOrZero
+import io.javalin.Javalin
+import io.javalin.http.Context
 import nebulosa.api.connection.ConnectionService
-import nebulosa.indi.device.filterwheel.FilterWheel
-import org.springframework.web.bind.annotation.*
+import nebulosa.api.javalin.notBlank
+import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.positiveOrZero
 
-@RestController
-@RequestMapping("wheels")
 class WheelController(
+    app: Javalin,
     private val connectionService: ConnectionService,
     private val wheelService: WheelService,
 ) {
 
-    @GetMapping
-    fun wheels(): List<FilterWheel> {
-        return connectionService.wheels().sorted()
+    init {
+        app.get("wheels", ::wheels)
+        app.get("wheels/{id}", ::wheel)
+        app.put("wheels/{id}/connect", ::connect)
+        app.put("wheels/{id}/disconnect", ::disconnect)
+        app.put("wheels/{id}/move-to", ::moveTo)
+        app.put("wheels/{id}/sync", ::sync)
+        app.put("wheels/{id}/listen", ::listen)
     }
 
-    @GetMapping("{wheel}")
-    fun wheel(wheel: FilterWheel): FilterWheel {
-        return wheel
+    private fun wheels(ctx: Context) {
+        ctx.json(connectionService.wheels().sorted())
     }
 
-    @PutMapping("{wheel}/connect")
-    fun connect(wheel: FilterWheel) {
+    private fun wheel(ctx: Context) {
+        val id = ctx.pathParam("id")
+        connectionService.wheel(id)?.also(ctx::json)
+    }
+
+    private fun connect(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val wheel = connectionService.wheel(id) ?: return
         wheelService.connect(wheel)
     }
 
-    @PutMapping("{wheel}/disconnect")
-    fun disconnect(wheel: FilterWheel) {
+    private fun disconnect(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val wheel = connectionService.wheel(id) ?: return
         wheelService.disconnect(wheel)
     }
 
-    @PutMapping("{wheel}/move-to")
-    fun moveTo(
-        wheel: FilterWheel,
-        @RequestParam @Valid @PositiveOrZero position: Int,
-    ) {
+    private fun moveTo(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val wheel = connectionService.wheel(id) ?: return
+        val position = ctx.queryParam("position").notNull().toInt().positiveOrZero()
         wheelService.moveTo(wheel, position)
     }
 
-    @PutMapping("{wheel}/sync")
-    fun sync(
-        wheel: FilterWheel,
-        @RequestParam @Valid @NotEmpty names: String,
-    ) {
+    private fun sync(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val wheel = connectionService.wheel(id) ?: return
+        val names = ctx.queryParam("names").notNull().notBlank()
         wheelService.sync(wheel, names.split(","))
     }
 
-    @PutMapping("{wheel}/listen")
-    fun listen(wheel: FilterWheel) {
+    private fun listen(ctx: Context) {
+        val id = ctx.pathParam("id")
+        val wheel = connectionService.wheel(id) ?: return
         wheelService.listen(wheel)
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/wheels/WheelDeserializer.kt b/api/src/main/kotlin/nebulosa/api/wheels/WheelDeserializer.kt
index cfa61af92..e4d913e46 100644
--- a/api/src/main/kotlin/nebulosa/api/wheels/WheelDeserializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/wheels/WheelDeserializer.kt
@@ -1,16 +1,12 @@
 package nebulosa.api.wheels
 
-import nebulosa.api.devices.DeviceDeserializer
 import nebulosa.api.connection.ConnectionService
+import nebulosa.api.devices.DeviceDeserializer
 import nebulosa.indi.device.filterwheel.FilterWheel
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.context.annotation.Lazy
-import org.springframework.stereotype.Component
-
-@Component
-class WheelDeserializer : DeviceDeserializer<FilterWheel>(FilterWheel::class.java) {
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.get
 
-    @Autowired @Lazy private lateinit var connectionService: ConnectionService
+class WheelDeserializer : DeviceDeserializer<FilterWheel>(FilterWheel::class.java), KoinComponent {
 
-    override fun deviceFor(name: String) = connectionService.wheel(name)
+    override fun deviceFor(name: String) = get<ConnectionService>().wheel(name)
 }
diff --git a/api/src/main/kotlin/nebulosa/api/wheels/WheelEventHub.kt b/api/src/main/kotlin/nebulosa/api/wheels/WheelEventHub.kt
index 6d97c2593..2b19511b2 100644
--- a/api/src/main/kotlin/nebulosa/api/wheels/WheelEventHub.kt
+++ b/api/src/main/kotlin/nebulosa/api/wheels/WheelEventHub.kt
@@ -1,6 +1,5 @@
 package nebulosa.api.wheels
 
-import nebulosa.api.beans.annotations.Subscriber
 import nebulosa.api.devices.DeviceEventHub
 import nebulosa.api.message.MessageService
 import nebulosa.indi.device.DeviceType
@@ -9,16 +8,19 @@ import nebulosa.indi.device.filterwheel.FilterWheel
 import nebulosa.indi.device.filterwheel.FilterWheelAttached
 import nebulosa.indi.device.filterwheel.FilterWheelDetached
 import nebulosa.indi.device.filterwheel.FilterWheelEvent
+import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode
-import org.springframework.stereotype.Component
 
-@Component
-@Subscriber
 class WheelEventHub(
     private val messageService: MessageService,
+    eventBus: EventBus,
 ) : DeviceEventHub<FilterWheel, FilterWheelEvent>(DeviceType.WHEEL), WheelEventAware {
 
+    init {
+        eventBus.register(this)
+    }
+
     @Subscribe(threadMode = ThreadMode.ASYNC)
     override fun handleFilterWheelEvent(event: FilterWheelEvent) {
         if (event.device.type == DeviceType.WHEEL) {
diff --git a/api/src/main/kotlin/nebulosa/api/wheels/WheelMoveTask.kt b/api/src/main/kotlin/nebulosa/api/wheels/WheelMoveTask.kt
index cc9235d2f..3e7dd539a 100644
--- a/api/src/main/kotlin/nebulosa/api/wheels/WheelMoveTask.kt
+++ b/api/src/main/kotlin/nebulosa/api/wheels/WheelMoveTask.kt
@@ -1,15 +1,18 @@
 package nebulosa.api.wheels
 
-import nebulosa.api.tasks.Task
-import nebulosa.common.concurrency.cancel.CancellationToken
-import nebulosa.common.concurrency.latch.CountUpDownLatch
 import nebulosa.indi.device.filterwheel.FilterWheel
 import nebulosa.indi.device.filterwheel.FilterWheelEvent
 import nebulosa.indi.device.filterwheel.FilterWheelMoveFailed
 import nebulosa.indi.device.filterwheel.FilterWheelPositionChanged
+import nebulosa.job.manager.Job
+import nebulosa.job.manager.Task
+import nebulosa.log.debug
 import nebulosa.log.loggerFor
+import nebulosa.util.concurrency.cancellation.CancellationSource
+import nebulosa.util.concurrency.latch.CountUpDownLatch
 
 data class WheelMoveTask(
+    @JvmField val job: Job,
     @JvmField val wheel: FilterWheel,
     @JvmField val position: Int,
 ) : Task, WheelEventAware {
@@ -29,26 +32,26 @@ data class WheelMoveTask(
         }
     }
 
-    override fun execute(cancellationToken: CancellationToken) {
+    override fun run() {
         if (wheel.connected && position in 1..wheel.count && wheel.position != position) {
+            LOG.debug { "Wheel Move started. wheel=$wheel, position=$position" }
+
             initialPosition = wheel.position
 
-            LOG.info("Filter Wheel Move started. wheel={}, position={}", wheel, position)
+            latch.countUp()
+            wheel.moveTo(position)
+            latch.await()
 
-            try {
-                cancellationToken.listen(latch)
-                latch.countUp()
-                wheel.moveTo(position)
-                latch.await()
-            } finally {
-                cancellationToken.unlisten(latch)
-                LOG.info("Filter Wheel Move finished. wheel={}, position={}", wheel, position)
-            }
+            LOG.debug { "Wheel Move finished. wheel=$wheel, position=$position" }
         } else {
             LOG.warn("filter wheel not connected or invalid position. position={}, wheel={}", position, wheel)
         }
     }
 
+    override fun onCancel(source: CancellationSource) {
+        latch.onCancel(source)
+    }
+
     companion object {
 
         @JvmStatic private val LOG = loggerFor<WheelMoveTask>()
diff --git a/api/src/main/kotlin/nebulosa/api/wheels/WheelSerializer.kt b/api/src/main/kotlin/nebulosa/api/wheels/WheelSerializer.kt
index f7d7f237a..cd244a559 100644
--- a/api/src/main/kotlin/nebulosa/api/wheels/WheelSerializer.kt
+++ b/api/src/main/kotlin/nebulosa/api/wheels/WheelSerializer.kt
@@ -3,9 +3,7 @@ package nebulosa.api.wheels
 import com.fasterxml.jackson.core.JsonGenerator
 import nebulosa.api.devices.DeviceSerializer
 import nebulosa.indi.device.filterwheel.FilterWheel
-import org.springframework.stereotype.Component
 
-@Component
 class WheelSerializer : DeviceSerializer<FilterWheel>(FilterWheel::class.java) {
 
     override fun JsonGenerator.serialize(value: FilterWheel) {
diff --git a/api/src/main/kotlin/nebulosa/api/wheels/WheelService.kt b/api/src/main/kotlin/nebulosa/api/wheels/WheelService.kt
index bae534f6b..ffa61859f 100644
--- a/api/src/main/kotlin/nebulosa/api/wheels/WheelService.kt
+++ b/api/src/main/kotlin/nebulosa/api/wheels/WheelService.kt
@@ -1,9 +1,7 @@
 package nebulosa.api.wheels
 
 import nebulosa.indi.device.filterwheel.FilterWheel
-import org.springframework.stereotype.Service
 
-@Service
 class WheelService(private val wheelEventHub: WheelEventHub) {
 
     fun connect(wheel: FilterWheel) {
diff --git a/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardController.kt b/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardController.kt
index cb782e2c3..47f064c83 100644
--- a/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardController.kt
+++ b/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardController.kt
@@ -1,27 +1,37 @@
 package nebulosa.api.wizard.flat
 
-import jakarta.validation.Valid
-import nebulosa.indi.device.camera.Camera
-import org.springframework.web.bind.annotation.*
+import io.javalin.Javalin
+import io.javalin.http.Context
+import io.javalin.http.bodyAsClass
+import nebulosa.api.connection.ConnectionService
+import nebulosa.api.javalin.notNull
+import nebulosa.api.javalin.valid
 
-@RestController
-@RequestMapping("flat-wizard")
 class FlatWizardController(
+    app: Javalin,
     private val flatWizardService: FlatWizardService,
+    private val connectionService: ConnectionService,
 ) {
 
-    @PutMapping("{camera}/start")
-    fun start(camera: Camera, @RequestBody @Valid body: FlatWizardRequest) {
+    init {
+        app.put("flat-wizard/{camera}/start", ::start)
+        app.put("flat-wizard/{camera}/stop", ::stop)
+        app.get("flat-wizard/{camera}/status", ::status)
+    }
+
+    private fun start(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")).notNull()
+        val body = ctx.bodyAsClass<FlatWizardRequest>().valid()
         flatWizardService.start(camera, body)
     }
 
-    @PutMapping("{camera}/stop")
-    fun stop(camera: Camera) {
+    private fun stop(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")).notNull()
         flatWizardService.stop(camera)
     }
 
-    @GetMapping("{camera}/status")
-    fun status(camera: Camera): FlatWizardEvent? {
-        return flatWizardService.status(camera)
+    private fun status(ctx: Context) {
+        val camera = connectionService.camera(ctx.pathParam("camera")).notNull()
+        flatWizardService.status(camera)?.also(ctx::json)
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardEvent.kt b/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardEvent.kt
index a8d13c5a2..44266d4cb 100644
--- a/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardEvent.kt
+++ b/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardEvent.kt
@@ -1,15 +1,15 @@
 package nebulosa.api.wizard.flat
 
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
 import nebulosa.api.cameras.CameraCaptureEvent
 import nebulosa.api.message.MessageEvent
-import java.nio.file.Path
-import java.time.Duration
+import nebulosa.indi.device.camera.Camera
 
 data class FlatWizardEvent(
-    @JvmField val state: FlatWizardState = FlatWizardState.IDLE,
-    @JvmField val exposureTime: Duration = Duration.ZERO,
-    @JvmField val capture: CameraCaptureEvent? = null,
-    @JvmField val savedPath: Path? = null,
+    @JvmField val camera: Camera,
+    @JvmField var state: FlatWizardState = FlatWizardState.IDLE,
+    @JvmField var exposureTime: Long = 0L,
+    @JvmField @field:JsonIgnoreProperties("camera") val capture: CameraCaptureEvent = CameraCaptureEvent(camera),
 ) : MessageEvent {
 
     override val eventName = "FLAT_WIZARD.ELAPSED"
diff --git a/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardExecutor.kt b/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardExecutor.kt
index cce2facbc..9c2b3c64b 100644
--- a/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardExecutor.kt
+++ b/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardExecutor.kt
@@ -1,28 +1,32 @@
 package nebulosa.api.wizard.flat
 
-import io.reactivex.rxjava3.functions.Consumer
-import nebulosa.api.beans.annotations.Subscriber
 import nebulosa.api.cameras.CameraEventAware
 import nebulosa.api.message.MessageEvent
 import nebulosa.api.message.MessageService
 import nebulosa.indi.device.camera.Camera
 import nebulosa.indi.device.camera.CameraEvent
+import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode
-import org.springframework.stereotype.Component
 import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.ExecutorService
+import java.util.function.Consumer
 
-@Component
-@Subscriber
 class FlatWizardExecutor(
     private val messageService: MessageService,
+    private val executorService: ExecutorService,
+    eventBus: EventBus,
 ) : Consumer<MessageEvent>, CameraEventAware {
 
     private val jobs = ConcurrentHashMap.newKeySet<FlatWizardJob>(1)
 
+    init {
+        eventBus.register(this)
+    }
+
     @Subscribe(threadMode = ThreadMode.ASYNC)
     override fun handleCameraEvent(event: CameraEvent) {
-        jobs.find { it.task.camera === event.device }?.handleCameraEvent(event)
+        jobs.find { it.camera === event.device }?.handleCameraEvent(event)
     }
 
     override fun accept(event: MessageEvent) {
@@ -31,23 +35,20 @@ class FlatWizardExecutor(
 
     fun execute(camera: Camera, request: FlatWizardRequest) {
         check(camera.connected) { "camera is not connected" }
-        check(jobs.none { it.task.camera === camera }) { "${camera.name} Flat Wizard is already in progress" }
-
-        val task = FlatWizardTask(camera, request)
-        task.subscribe(this)
+        check(jobs.none { it.camera === camera }) { "${camera.name} Flat Wizard is already in progress" }
 
-        with(FlatWizardJob(task)) {
+        with(FlatWizardJob(this, camera, request)) {
+            val completable = runAsync(executorService)
             jobs.add(this)
-            whenComplete { _, _ -> jobs.remove(this) }
-            start()
+            completable.whenComplete { _, _ -> jobs.remove(this) }
         }
     }
 
     fun stop(camera: Camera) {
-        jobs.find { it.task.camera === camera }?.stop()
+        jobs.find { it.camera === camera }?.stop()
     }
 
     fun status(camera: Camera): FlatWizardEvent? {
-        return jobs.find { it.task.camera === camera }?.task?.get() as? FlatWizardEvent
+        return jobs.find { it.camera === camera }?.status
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardJob.kt b/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardJob.kt
index 4dfcb7a3a..cbd78bffa 100644
--- a/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardJob.kt
+++ b/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardJob.kt
@@ -1,14 +1,156 @@
 package nebulosa.api.wizard.flat
 
-import nebulosa.api.cameras.CameraEventAware
-import nebulosa.api.tasks.Job
+import nebulosa.api.cameras.*
+import nebulosa.api.message.MessageEvent
+import nebulosa.fits.fits
+import nebulosa.image.Image
+import nebulosa.image.algorithms.computation.Statistics
+import nebulosa.indi.device.camera.Camera
 import nebulosa.indi.device.camera.CameraEvent
+import nebulosa.indi.device.camera.FrameType
+import nebulosa.job.manager.AbstractJob
+import nebulosa.job.manager.Task
+import nebulosa.log.loggerFor
+import nebulosa.util.concurrency.cancellation.CancellationSource
+import nebulosa.util.concurrency.latch.CountUpDownLatch
+import java.nio.file.Path
+import java.time.Duration
 
-data class FlatWizardJob(override val task: FlatWizardTask) : Job(), CameraEventAware {
+data class FlatWizardJob(
+    @JvmField val flatWizardExecutor: FlatWizardExecutor,
+    @JvmField val camera: Camera,
+    @JvmField val request: FlatWizardRequest,
+) : AbstractJob(), CameraEventAware {
 
-    override val name = "${task.camera.name} Flat Wizard Job"
+    @JvmField val meanTarget = request.meanTarget / 65535f
+    @JvmField val meanRange = (meanTarget * request.meanTolerance / 100f).let { (meanTarget - it)..(meanTarget + it) }
+
+    @Volatile private var exposureMin = request.exposureMin.toNanos()
+    @Volatile private var exposureMax = request.exposureMax.toNanos()
+
+    @JvmField val status = FlatWizardEvent(camera)
+
+    @Volatile private var cameraExposureTask = CameraExposureTask(
+        this, camera, request.capture.copy(
+            exposureTime = Duration.ofNanos((exposureMin + exposureMax) / 2),
+            frameType = FrameType.FLAT,
+            autoSave = false, autoSubFolderMode = AutoSubFolderMode.OFF,
+        )
+    )
+
+    private val waitToComputeOptimalExposureTime = CountUpDownLatch()
+
+    inline val savedPath
+        get() = status.capture.savedPath
+
+    init {
+        add(cameraExposureTask)
+        status.exposureTime = cameraExposureTask.request.exposureTime.toNanos() / 1000L
+    }
 
     override fun handleCameraEvent(event: CameraEvent) {
-        task.handleCameraEvent(event)
+        cameraExposureTask.handleCameraEvent(event)
+    }
+
+    override fun onCancel(source: CancellationSource) {
+        waitToComputeOptimalExposureTime.reset()
+        super.onCancel(source)
+    }
+
+    override fun accept(event: Any) {
+        when (event) {
+            is CameraExposureEvent -> {
+                status.capture.handleCameraExposureEvent(event)
+
+                if (event is CameraExposureFinished) {
+                    status.capture.send()
+
+                    if (!computeOptimalExposureTime(event.savedPath)) {
+                        val exposureTimeInNanos = (exposureMax + exposureMin) / 2L
+                        val request = cameraExposureTask.request.copy(exposureTime = Duration.ofNanos(exposureTimeInNanos))
+                        status.exposureTime = exposureTimeInNanos / 1000L
+                        add(CameraExposureTask(this, camera, request).also { cameraExposureTask = it })
+                    }
+
+                    waitToComputeOptimalExposureTime.reset()
+                }
+
+                status.send()
+            }
+        }
+    }
+
+    private fun computeOptimalExposureTime(savedPath: Path): Boolean {
+        val image = savedPath.fits().use { Image.open(it, false) }
+        val statistics = STATISTICS.compute(image)
+
+        LOG.debug("flat frame computed. statistics={}", statistics)
+
+        if (statistics.mean in meanRange) {
+            LOG.debug("found an optimal exposure time. exposureTime={}, path={}", status.exposureTime, savedPath)
+            status.state = FlatWizardState.CAPTURED
+            status.capture.state = CameraCaptureState.IDLE
+            return true
+        } else if (statistics.mean < meanRange.start) {
+            exposureMin = cameraExposureTask.request.exposureTime.toNanos()
+            LOG.debug("captured frame is below mean range. exposureTime={}, path={}", exposureMin, savedPath)
+        } else {
+            exposureMax = cameraExposureTask.request.exposureTime.toNanos()
+            LOG.debug("captured frame is above mean range. exposureTime={}, path={}", exposureMax, savedPath)
+        }
+
+        val delta = exposureMax - exposureMin
+
+        // 10ms
+        if (delta < MIN_DELTA_TIME) {
+            LOG.warn("Failed to find an optimal exposure time. exposureMin={}, exposureMax={}", exposureMin, exposureMax)
+            status.state = FlatWizardState.FAILED
+            status.capture.state = CameraCaptureState.IDLE
+            return true
+        }
+
+        return false
+    }
+
+    override fun beforeStart() {
+        LOG.debug("Flat Wizard started. camera={}, request={}", camera, request)
+
+        status.state = FlatWizardState.EXPOSURING
+        status.send()
+    }
+
+    override fun beforeTask(task: Task) {
+        waitToComputeOptimalExposureTime.countUp()
+    }
+
+    override fun afterTask(task: Task, exception: Throwable?): Boolean {
+        if (exception == null) {
+            waitToComputeOptimalExposureTime.await()
+        }
+
+        return super.afterTask(task, exception)
+    }
+
+    override fun afterFinish() {
+        if (status.state == FlatWizardState.EXPOSURING) {
+            status.state = FlatWizardState.IDLE
+            status.capture.state = CameraCaptureState.IDLE
+            status.send()
+        }
+
+        LOG.debug("Flat Wizard finished. camera={}, request={}, exposureTime={} µs", camera, request, status.exposureTime)
+    }
+
+    @Suppress("NOTHING_TO_INLINE")
+    private inline fun MessageEvent.send() {
+        flatWizardExecutor.accept(this)
+    }
+
+    companion object {
+
+        private const val MIN_DELTA_TIME = 10000000 // 10ms
+
+        @JvmStatic private val LOG = loggerFor<FlatWizardJob>()
+        @JvmStatic private val STATISTICS = Statistics(noMedian = true, noDeviation = true)
     }
 }
diff --git a/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardRequest.kt b/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardRequest.kt
index 92a214d3c..6165225d4 100644
--- a/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardRequest.kt
+++ b/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardRequest.kt
@@ -1,21 +1,31 @@
 package nebulosa.api.wizard.flat
 
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+import nebulosa.api.beans.converters.time.DurationUnit
 import nebulosa.api.cameras.CameraStartCaptureRequest
-import org.hibernate.validator.constraints.Range
-import org.hibernate.validator.constraints.time.DurationMax
-import org.hibernate.validator.constraints.time.DurationMin
-import org.springframework.boot.convert.DurationUnit
+import nebulosa.api.javalin.Validatable
+import nebulosa.api.javalin.max
+import nebulosa.api.javalin.min
+import nebulosa.api.javalin.range
 import java.time.Duration
 import java.time.temporal.ChronoUnit
+import java.util.concurrent.TimeUnit
 
 data class FlatWizardRequest(
-    @JsonIgnoreProperties("camera", "focuser", "dither") @JvmField val capture: CameraStartCaptureRequest,
-    @field:DurationMin(millis = 1) @field:DurationMax(minutes = 1) @field:DurationUnit(ChronoUnit.MILLIS) @JvmField val exposureMin: Duration = MIN_EXPOSURE,
-    @field:DurationMin(millis = 1) @field:DurationMax(minutes = 1) @field:DurationUnit(ChronoUnit.MILLIS) @JvmField val exposureMax: Duration = MAX_EXPOSURE,
-    @field:Range(min = 0, max = 65535) @JvmField val meanTarget: Int = 32768, // 50% = 32768 (16-bit)
-    @field:Range(min = 0, max = 100) @JvmField val meanTolerance: Int = 10, // 10%
-) {
+    @JsonIgnoreProperties("camera", "focuser", "dither") @JvmField val capture: CameraStartCaptureRequest = CameraStartCaptureRequest.EMPTY,
+    @field:DurationUnit(ChronoUnit.MILLIS) @JvmField val exposureMin: Duration = MIN_EXPOSURE,
+    @field:DurationUnit(ChronoUnit.MILLIS) @JvmField val exposureMax: Duration = MAX_EXPOSURE,
+    @JvmField val meanTarget: Int = 32768, // 50% = 32768 (16-bit)
+    @JvmField val meanTolerance: Int = 10, // 10%
+) : Validatable {
+
+    override fun validate() {
+        capture.validate()
+        exposureMin.min(1L, TimeUnit.MILLISECONDS).max(10L, TimeUnit.MINUTES)
+        exposureMax.min(1L, TimeUnit.MILLISECONDS).max(10L, TimeUnit.MINUTES)
+        meanTarget.range(0, 65535)
+        meanTolerance.range(0, 100)
+    }
 
     companion object {
 
diff --git a/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardService.kt b/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardService.kt
index 4ac313b61..5e67bdad9 100644
--- a/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardService.kt
+++ b/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardService.kt
@@ -1,12 +1,10 @@
 package nebulosa.api.wizard.flat
 
 import nebulosa.indi.device.camera.Camera
-import org.springframework.stereotype.Service
 import java.nio.file.Path
 import kotlin.io.path.exists
 import kotlin.io.path.isDirectory
 
-@Service
 class FlatWizardService(
     private val capturesPath: Path,
     private val flatWizardExecutor: FlatWizardExecutor,
diff --git a/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardTask.kt b/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardTask.kt
deleted file mode 100644
index 49859b098..000000000
--- a/api/src/main/kotlin/nebulosa/api/wizard/flat/FlatWizardTask.kt
+++ /dev/null
@@ -1,125 +0,0 @@
-package nebulosa.api.wizard.flat
-
-import nebulosa.api.cameras.*
-import nebulosa.api.message.MessageEvent
-import nebulosa.api.tasks.AbstractTask
-import nebulosa.common.concurrency.cancel.CancellationToken
-import nebulosa.fits.fits
-import nebulosa.image.Image
-import nebulosa.image.algorithms.computation.Statistics
-import nebulosa.indi.device.camera.Camera
-import nebulosa.indi.device.camera.CameraEvent
-import nebulosa.indi.device.camera.FrameType
-import nebulosa.log.loggerFor
-import java.nio.file.Path
-import java.time.Duration
-
-data class FlatWizardTask(
-    @JvmField val camera: Camera,
-    @JvmField val request: FlatWizardRequest,
-) : AbstractTask<MessageEvent>(), CameraEventAware {
-
-    private val meanTarget = request.meanTarget / 65535f
-    private val meanRange = (meanTarget * request.meanTolerance / 100f).let { (meanTarget - it)..(meanTarget + it) }
-
-    @Volatile private var cameraCaptureTask: CameraCaptureTask? = null
-    @Volatile private var exposureMin = request.exposureMin
-    @Volatile private var exposureMax = request.exposureMax
-    @Volatile private var exposureTime = Duration.ZERO
-
-    @Volatile private var state = FlatWizardState.IDLE
-    @Volatile private var capture: CameraCaptureEvent? = null
-    @Volatile private var savedPath: Path? = null
-
-    override fun handleCameraEvent(event: CameraEvent) {
-        cameraCaptureTask?.handleCameraEvent(event)
-    }
-
-    override fun canUseAsLastEvent(event: MessageEvent) = event is FlatWizardEvent
-
-    override fun execute(cancellationToken: CancellationToken) {
-        while (!cancellationToken.isCancelled) {
-            val delta = exposureMax.toMillis() - exposureMin.toMillis()
-
-            if (delta < 10) {
-                LOG.warn("Failed to find an optimal exposure time. exposureMin={}, exposureMax={}", exposureMin, exposureMax)
-                state = FlatWizardState.FAILED
-                break
-            }
-
-            exposureTime = (exposureMax + exposureMin).dividedBy(2L)
-
-            LOG.info("Flat Wizard started. camera={}, request={}, exposureTime={}", camera, request, exposureTime)
-
-            val cameraRequest = request.capture.copy(
-                exposureTime = exposureTime, frameType = FrameType.FLAT,
-                autoSave = false, autoSubFolderMode = AutoSubFolderMode.OFF,
-            )
-
-            state = FlatWizardState.EXPOSURING
-
-            CameraCaptureTask(camera, cameraRequest).use {
-                cameraCaptureTask = it
-
-                it.subscribe { event ->
-                    capture = event
-
-                    if (event.state == CameraCaptureState.EXPOSURE_FINISHED) {
-                        savedPath = event.savedPath!!
-                        onNext(event)
-                    }
-
-                    sendEvent()
-                }
-
-                it.execute(cancellationToken)
-            }
-
-            if (cancellationToken.isCancelled) {
-                state = FlatWizardState.IDLE
-                break
-            } else if (savedPath == null) {
-                state = FlatWizardState.FAILED
-                break
-            }
-
-            val image = savedPath!!.fits().use { Image.open(it, false) }
-
-            val statistics = STATISTICS.compute(image)
-            LOG.info("flat frame captured. exposureTime={}, statistics={}", exposureTime, statistics)
-
-            if (statistics.mean in meanRange) {
-                state = FlatWizardState.CAPTURED
-                LOG.info("found an optimal exposure time. exposureTime={}, path={}", exposureTime, savedPath)
-                break
-            } else if (statistics.mean < meanRange.start) {
-                savedPath = null
-                exposureMin = exposureTime
-                LOG.info("captured frame is below mean range. exposureTime={}, path={}", exposureTime, savedPath)
-            } else {
-                savedPath = null
-                exposureMax = exposureTime
-                LOG.info("captured frame is above mean range. exposureTime={}, path={}", exposureTime, savedPath)
-            }
-        }
-
-        if (state != FlatWizardState.FAILED && cancellationToken.isCancelled) {
-            state = FlatWizardState.IDLE
-        }
-
-        sendEvent()
-
-        LOG.info("Flat Wizard finished. camera={}, request={}, exposureTime={}", camera, request, exposureTime)
-    }
-
-    @Suppress("NOTHING_TO_INLINE")
-    private inline fun sendEvent() {
-        onNext(FlatWizardEvent(state, exposureTime, capture, savedPath))
-    }
-
-    companion object {
-
-        @JvmStatic private val LOG = loggerFor<FlatWizardTask>()
-        @JvmStatic private val STATISTICS = Statistics(noMedian = true, noDeviation = true)
-    }
-}
diff --git a/api/src/test/kotlin/CameraCaptureNamingFormatterTest.kt b/api/src/test/kotlin/CameraCaptureNamingFormatterTest.kt
index ba9b8e1c6..edb8365b8 100644
--- a/api/src/test/kotlin/CameraCaptureNamingFormatterTest.kt
+++ b/api/src/test/kotlin/CameraCaptureNamingFormatterTest.kt
@@ -263,10 +263,10 @@ class CameraCaptureNamingFormatterTest {
         override val cfaOffsetX = 0
         override val cfaOffsetY = 0
         override val cfaType = CfaPattern.RGGB
-        override val exposureMin: Duration = Duration.ofNanos(1000)
-        override val exposureMax: Duration = Duration.ofMinutes(10)
+        override val exposureMin = 1L
+        override val exposureMax = 1000000L * 60 * 10
         override val exposureState = PropertyState.IDLE
-        override val exposureTime: Duration = Duration.ofSeconds(1)
+        override val exposureTime = 1000000L
         override val hasCooler = true
         override val canSetTemperature = true
         override val canSubFrame = true
@@ -319,7 +319,7 @@ class CameraCaptureNamingFormatterTest {
 
         override fun offset(value: Int) = Unit
 
-        override fun startCapture(exposureTime: Duration) = Unit
+        override fun startCapture(exposureTime: Long) = Unit
 
         override fun abortCapture() = Unit
 
diff --git a/api/src/test/kotlin/SkyAtlasServiceTest.kt b/api/src/test/kotlin/SkyAtlasServiceTest.kt
index 83b467fd5..5be0c2ac8 100644
--- a/api/src/test/kotlin/SkyAtlasServiceTest.kt
+++ b/api/src/test/kotlin/SkyAtlasServiceTest.kt
@@ -23,10 +23,10 @@ import nebulosa.skycatalog.SkyObjectType
 import nebulosa.test.HTTP_CLIENT
 import org.junit.jupiter.api.AfterAll
 import org.junit.jupiter.api.Test
-import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor
 import java.time.LocalDate
 import java.time.LocalDateTime
 import java.util.*
+import java.util.concurrent.Executors
 
 class SkyAtlasServiceTest {
 
@@ -239,7 +239,7 @@ class SkyAtlasServiceTest {
             BOX_STORE.close()
         }
 
-        @JvmStatic private val THREAD_POOL_TASK_EXECUTOR = ThreadPoolTaskExecutor().also { it.initialize() }
+        @JvmStatic private val THREAD_POOL_TASK_EXECUTOR = Executors.newSingleThreadExecutor()
         @JvmStatic private val HORIZONS_SERVICE = HorizonsService(httpClient = HTTP_CLIENT)
         @JvmStatic private val HORIZONS_EPHEMERIS_PROVIDER = HorizonsEphemerisProvider(HORIZONS_SERVICE)
         @JvmStatic private val BODY_EPHEMERIS_PROVIDER = BodyEphemerisProvider(THREAD_POOL_TASK_EXECUTOR)
@@ -265,6 +265,7 @@ class SkyAtlasServiceTest {
         @JvmStatic private val SERVICE = SkyAtlasService(
             HORIZONS_EPHEMERIS_PROVIDER, BODY_EPHEMERIS_PROVIDER, SMALL_BODY_DATABASE_SERVICE,
             SATELLITE_REPOSITORY, SIMBAD_ENTITY_REPOSITORY, HTTP_CLIENT, OBJECT_MAPPER, MOON_PHASE_FINDER,
+            Executors.newSingleThreadScheduledExecutor(),
         )
 
         @JvmStatic private val LOCATION = Location("-19.846616".deg, "-43.96872".deg, 852.0.m, -180)
diff --git a/build.gradle.kts b/build.gradle.kts
index c7c06a0b5..c59c150de 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -4,9 +4,9 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 buildscript {
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:2.0.10")
-        classpath("org.jetbrains.kotlin:kotlin-allopen:2.0.10")
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:2.0.20")
         classpath("io.objectbox:objectbox-gradle-plugin:4.0.2")
+        classpath("com.gradleup.shadow:shadow-gradle-plugin:8.3.3")
     }
 
     repositories {
diff --git a/desktop/app/main.ts b/desktop/app/main.ts
index 4f3c7b2ad..f5bd81ae2 100644
--- a/desktop/app/main.ts
+++ b/desktop/app/main.ts
@@ -3,13 +3,10 @@ import * as fs from 'fs'
 import type { ChildProcessWithoutNullStreams } from 'node:child_process'
 import { spawn } from 'node:child_process'
 import { join } from 'path'
-import { WebSocket } from 'ws'
 import type { InternalEventType, JsonFile } from '../src/shared/types/app.types'
 import { ArgumentParser } from './argument.parser'
 import { WindowManager } from './window.manager'
 
-Object.assign(global, { WebSocket })
-
 const argParser = new ArgumentParser()
 const parsedArgs = argParser.parse(process.argv.slice(1))
 
@@ -34,10 +31,10 @@ process.on('beforeExit', () => {
 
 function createApiProcess(port: number = parsedArgs.port) {
 	const apiJar = join(process.resourcesPath, 'api.jar')
-	const apiProcess = spawn('java', ['-jar', apiJar, `--server.port=${port}`])
+	const apiProcess = spawn('java', ['-jar', apiJar, `--port=${port}`])
 
 	apiProcess.on('close', (code) => {
-		console.warn(`server process exited with code: ${code}`)
+		console.warn(`api process exited with code: ${code}`)
 		process.exit(code ?? 0)
 	})
 
diff --git a/desktop/app/package-lock.json b/desktop/app/package-lock.json
index 11a11b8bf..fd94f2fce 100644
--- a/desktop/app/package-lock.json
+++ b/desktop/app/package-lock.json
@@ -9,16 +9,10 @@
 			"version": "0.1.0",
 			"license": "MIT",
 			"dependencies": {
-				"@stomp/stompjs": "7.0.0",
 				"electron-store": "8.2.0",
 				"ws": "8.18.0"
 			}
 		},
-		"node_modules/@stomp/stompjs": {
-			"version": "7.0.0",
-			"resolved": "https://registry.npmjs.org/@stomp/stompjs/-/stompjs-7.0.0.tgz",
-			"integrity": "sha512-fGdq4wPDnSV/KyOsjq4P+zLc8MFWC3lMmP5FBgLWKPJTYcuCbAIrnRGjB7q2jHZdYCOD5vxLuFoKIYLy5/u8Pw=="
-		},
 		"node_modules/ajv": {
 			"version": "8.17.1",
 			"resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
diff --git a/desktop/app/package.json b/desktop/app/package.json
index dae08a583..19752d065 100644
--- a/desktop/app/package.json
+++ b/desktop/app/package.json
@@ -11,7 +11,6 @@
 	"main": "main.js",
 	"private": true,
 	"dependencies": {
-		"@stomp/stompjs": "7.0.0",
 		"electron-store": "8.2.0",
 		"ws": "8.18.0"
 	}
diff --git a/desktop/app/window.manager.ts b/desktop/app/window.manager.ts
index 777fa5e98..ea7863aad 100644
--- a/desktop/app/window.manager.ts
+++ b/desktop/app/window.manager.ts
@@ -1,9 +1,9 @@
-import { Client } from '@stomp/stompjs'
 import type { Rectangle } from 'electron'
 import { BrowserWindow, Notification, dialog, screen, shell } from 'electron'
 import Store from 'electron-store'
 import type { ChildProcessWithoutNullStreams } from 'node:child_process'
 import { join } from 'path'
+import { WebSocket } from 'ws'
 import type { MessageEvent } from '../src/shared/types/api.types'
 import type { CloseWindow, ConfirmationEvent, FullscreenWindow, NotificationEvent, OpenDirectory, OpenFile, OpenWindow, ResizeWindow, WindowCommand } from '../src/shared/types/app.types'
 import type { Nullable } from '../src/shared/utils/types'
@@ -21,7 +21,7 @@ export class ApplicationWindow {
 		public readonly browserWindow: BrowserWindow,
 		public readonly data: OpenWindow,
 		public readonly parentWindow?: BrowserWindow,
-		public webSocket?: Client,
+		public webSocket?: WebSocket,
 		public apiProcess?: ChildProcessWithoutNullStreams,
 		public resolver?: (data: unknown) => void,
 	) {}
@@ -209,6 +209,44 @@ export class WindowManager {
 		}
 	}
 
+	private createWebSocket(host: string, port: number, connected: (webSocket: WebSocket) => void) {
+		const webSocket = new WebSocket(`ws://${host}:${port}/ws`)
+
+		const reconnect = () => {
+			setTimeout(() => this.createWebSocket(host, port, connected), 2000)
+		}
+
+		webSocket.on('open', () => {
+			console.info('Web Socket connected')
+			connected(webSocket)
+		})
+
+		webSocket.on('message', (data: Buffer) => {
+			const event = JSON.parse(data.toString()) as MessageEvent
+
+			if (isNotificationEvent(event)) {
+				this.showNotification(event)
+			} else if (isConfirmationEvent(event)) {
+				this.showConfirmation(event)
+			} else if (event.eventName) {
+				this.dispatchEvent(event)
+			} else {
+				console.warn('invalid message event', event)
+			}
+		})
+
+		webSocket.on('close', (code, reason) => {
+			console.warn('Web Socket closed', code, reason.toString())
+			reconnect()
+		})
+
+		webSocket.on('error', () => {
+			console.error('Web Socket error')
+		})
+
+		return webSocket
+	}
+
 	async createMainWindow(apiProcess?: ChildProcessWithoutNullStreams, port: number = this.port, host: string = this.host) {
 		this.port = port
 		this.host = host
@@ -216,39 +254,8 @@ export class WindowManager {
 		const open: OpenWindow = { id: 'home', path: 'home', preference: {} }
 		const appWindow = await this.createWindow(open)
 
-		const webSocket = new Client({
-			brokerURL: `ws://${host}:${port}/ws`,
-			onConnect: () => {
-				webSocket.subscribe('NEBULOSA.EVENT', (message) => {
-					const event = JSON.parse(message.body) as MessageEvent
-
-					if (isNotificationEvent(event)) {
-						this.showNotification(event)
-					} else if (isConfirmationEvent(event)) {
-						this.showConfirmation(event)
-					} else if (event.eventName) {
-						this.dispatchEvent(event)
-					} else {
-						console.warn('invalid message event', event)
-					}
-				})
-
-				console.info('Web Socket connected')
-			},
-			onDisconnect: () => {
-				console.warn('Web Socket disconnected')
-			},
-			onWebSocketClose: () => {
-				console.warn('Web Socket closed')
-			},
-			onWebSocketError: () => {
-				console.error('Web Socket error')
-			},
-		})
-
-		webSocket.activate()
+		this.createWebSocket(host, port, (webSocket) => (appWindow.webSocket = webSocket))
 
-		appWindow.webSocket = webSocket
 		appWindow.apiProcess = apiProcess
 	}
 
diff --git a/desktop/package-lock.json b/desktop/package-lock.json
index fb231703c..9932ac082 100644
--- a/desktop/package-lock.json
+++ b/desktop/package-lock.json
@@ -10,15 +10,15 @@
 			"hasInstallScript": true,
 			"license": "MIT",
 			"dependencies": {
-				"@angular/animations": "18.2.0",
-				"@angular/cdk": "18.2.0",
-				"@angular/common": "18.2.0",
-				"@angular/compiler": "18.2.0",
-				"@angular/core": "18.2.0",
-				"@angular/forms": "18.2.0",
-				"@angular/platform-browser": "18.2.0",
-				"@angular/platform-browser-dynamic": "18.2.0",
-				"@angular/router": "18.2.0",
+				"@angular/animations": "18.2.6",
+				"@angular/cdk": "18.2.6",
+				"@angular/common": "18.2.6",
+				"@angular/compiler": "18.2.6",
+				"@angular/core": "18.2.6",
+				"@angular/forms": "18.2.6",
+				"@angular/platform-browser": "18.2.6",
+				"@angular/platform-browser-dynamic": "18.2.6",
+				"@angular/router": "18.2.6",
 				"@mdi/font": "7.4.47",
 				"chart.js": "4.4.4",
 				"chartjs-plugin-zoom": "2.0.1",
@@ -29,32 +29,32 @@
 				"panzoom": "9.4.3",
 				"primeflex": "3.3.1",
 				"primeicons": "7.0.0",
-				"primeng": "17.18.9",
+				"primeng": "17.18.11",
 				"primeng-sass-theme": "github:primefaces/primeng-sass-theme#17.18.3",
 				"rxjs": "7.8.1",
-				"tslib": "2.6.3",
+				"tslib": "2.7.0",
 				"zone.js": "0.14.10"
 			},
 			"devDependencies": {
 				"@angular-builders/custom-webpack": "18.0.0",
 				"@angular-devkit/build-angular": "18.2.6",
-				"@angular/cli": "18.2.1",
-				"@angular/compiler-cli": "18.2.0",
-				"@angular/language-service": "18.2.0",
-				"@eslint/js": "9.9.0",
+				"@angular/cli": "18.2.6",
+				"@angular/compiler-cli": "18.2.6",
+				"@angular/language-service": "18.2.6",
+				"@eslint/js": "9.11.1",
 				"@types/eslint__js": "8.42.3",
 				"@types/leaflet": "1.9.12",
-				"@types/node": "22.5.0",
-				"electron": "32.0.1",
-				"electron-builder": "24.13.3",
-				"eslint": "9.9.0",
+				"@types/node": "22.7.4",
+				"electron": "32.1.2",
+				"electron-builder": "25.0.5",
+				"eslint": "9.11.1",
 				"node-polyfill-webpack-plugin": "4.0.0",
 				"npm-run-all": "4.1.5",
 				"prettier": "3.3.3",
 				"ts-node": "10.9.2",
 				"typescript": "5.5.4",
-				"typescript-eslint": "8.2.0",
-				"wait-on": "8.0.0"
+				"typescript-eslint": "8.8.0",
+				"wait-on": "8.0.1"
 			},
 			"engines": {
 				"node": ">= 20.11.1"
@@ -111,13 +111,13 @@
 			}
 		},
 		"node_modules/@angular-devkit/architect": {
-			"version": "0.1802.1",
-			"resolved": "https://registry.npmjs.org/@angular-devkit/architect/-/architect-0.1802.1.tgz",
-			"integrity": "sha512-XTnJfCBMDQl3xF4w/eNrq821gbj2Ig1cqbzpRflhz4pqrANTAfHfPoIC7piWEZ60FNlHapzb6fvh6tJUGXG9og==",
+			"version": "0.1802.6",
+			"resolved": "https://registry.npmjs.org/@angular-devkit/architect/-/architect-0.1802.6.tgz",
+			"integrity": "sha512-oF7cPFdTLxeuvXkK/opSdIxZ1E4LrBbmuytQ/nCoAGOaKBWdqvwagRZ6jVhaI0Gwu48rkcV7Zhesg/ESNnROdw==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@angular-devkit/core": "18.2.1",
+				"@angular-devkit/core": "18.2.6",
 				"rxjs": "7.8.1"
 			},
 			"engines": {
@@ -131,6 +131,7 @@
 			"resolved": "https://registry.npmjs.org/@angular-devkit/build-angular/-/build-angular-18.2.6.tgz",
 			"integrity": "sha512-u12cJZttgs5j7gICHWSmcaTCu0EFXEzKqI8nkYCwq2MtuJlAXiMQSXYuEP9OU3Go4vMAPtQh2kShyOWCX5b4EQ==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@ampproject/remapping": "2.3.0",
 				"@angular-devkit/architect": "0.1802.6",
@@ -254,26 +255,185 @@
 				}
 			}
 		},
-		"node_modules/@angular-devkit/build-angular/node_modules/@angular-devkit/architect": {
+		"node_modules/@angular-devkit/build-angular/node_modules/ajv": {
+			"version": "6.12.6",
+			"resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
+			"integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"fast-deep-equal": "^3.1.1",
+				"fast-json-stable-stringify": "^2.0.0",
+				"json-schema-traverse": "^0.4.1",
+				"uri-js": "^4.2.2"
+			},
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/epoberezkin"
+			}
+		},
+		"node_modules/@angular-devkit/build-angular/node_modules/ajv-keywords": {
+			"version": "3.5.2",
+			"resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
+			"integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==",
+			"dev": true,
+			"license": "MIT",
+			"peerDependencies": {
+				"ajv": "^6.9.1"
+			}
+		},
+		"node_modules/@angular-devkit/build-angular/node_modules/eslint-scope": {
+			"version": "5.1.1",
+			"resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz",
+			"integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==",
+			"dev": true,
+			"license": "BSD-2-Clause",
+			"dependencies": {
+				"esrecurse": "^4.3.0",
+				"estraverse": "^4.1.1"
+			},
+			"engines": {
+				"node": ">=8.0.0"
+			}
+		},
+		"node_modules/@angular-devkit/build-angular/node_modules/estraverse": {
+			"version": "4.3.0",
+			"resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz",
+			"integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==",
+			"dev": true,
+			"license": "BSD-2-Clause",
+			"engines": {
+				"node": ">=4.0"
+			}
+		},
+		"node_modules/@angular-devkit/build-angular/node_modules/json-parse-even-better-errors": {
+			"version": "2.3.1",
+			"resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
+			"integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==",
+			"dev": true,
+			"license": "MIT"
+		},
+		"node_modules/@angular-devkit/build-angular/node_modules/json-schema-traverse": {
+			"version": "0.4.1",
+			"resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+			"integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+			"dev": true,
+			"license": "MIT"
+		},
+		"node_modules/@angular-devkit/build-angular/node_modules/schema-utils": {
+			"version": "3.3.0",
+			"resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.3.0.tgz",
+			"integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@types/json-schema": "^7.0.8",
+				"ajv": "^6.12.5",
+				"ajv-keywords": "^3.5.2"
+			},
+			"engines": {
+				"node": ">= 10.13.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/webpack"
+			}
+		},
+		"node_modules/@angular-devkit/build-angular/node_modules/tslib": {
+			"version": "2.6.3",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.3.tgz",
+			"integrity": "sha512-xNvxJEOUiWPGhUuUdQgAJPKOOJfGnIyKySOc09XkKsgdUV/3E2zvwZYdejjmRgPCgcym1juLH3226yA7sEFJKQ==",
+			"dev": true,
+			"license": "0BSD"
+		},
+		"node_modules/@angular-devkit/build-angular/node_modules/webpack": {
+			"version": "5.94.0",
+			"resolved": "https://registry.npmjs.org/webpack/-/webpack-5.94.0.tgz",
+			"integrity": "sha512-KcsGn50VT+06JH/iunZJedYGUJS5FGjow8wb9c0v5n1Om8O1g4L6LjtfxwlXIATopoQu+vOXXa7gYisWxCoPyg==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@types/estree": "^1.0.5",
+				"@webassemblyjs/ast": "^1.12.1",
+				"@webassemblyjs/wasm-edit": "^1.12.1",
+				"@webassemblyjs/wasm-parser": "^1.12.1",
+				"acorn": "^8.7.1",
+				"acorn-import-attributes": "^1.9.5",
+				"browserslist": "^4.21.10",
+				"chrome-trace-event": "^1.0.2",
+				"enhanced-resolve": "^5.17.1",
+				"es-module-lexer": "^1.2.1",
+				"eslint-scope": "5.1.1",
+				"events": "^3.2.0",
+				"glob-to-regexp": "^0.4.1",
+				"graceful-fs": "^4.2.11",
+				"json-parse-even-better-errors": "^2.3.1",
+				"loader-runner": "^4.2.0",
+				"mime-types": "^2.1.27",
+				"neo-async": "^2.6.2",
+				"schema-utils": "^3.2.0",
+				"tapable": "^2.1.1",
+				"terser-webpack-plugin": "^5.3.10",
+				"watchpack": "^2.4.1",
+				"webpack-sources": "^3.2.3"
+			},
+			"bin": {
+				"webpack": "bin/webpack.js"
+			},
+			"engines": {
+				"node": ">=10.13.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/webpack"
+			},
+			"peerDependenciesMeta": {
+				"webpack-cli": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/@angular-devkit/build-angular/node_modules/webpack-merge": {
+			"version": "6.0.1",
+			"resolved": "https://registry.npmjs.org/webpack-merge/-/webpack-merge-6.0.1.tgz",
+			"integrity": "sha512-hXXvrjtx2PLYx4qruKl+kyRSLc52V+cCvMxRjmKwoA+CBbbF5GfIBtR6kCvl0fYGqTUPKB+1ktVmTHqMOzgCBg==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"clone-deep": "^4.0.1",
+				"flat": "^5.0.2",
+				"wildcard": "^2.0.1"
+			},
+			"engines": {
+				"node": ">=18.0.0"
+			}
+		},
+		"node_modules/@angular-devkit/build-webpack": {
 			"version": "0.1802.6",
-			"resolved": "https://registry.npmjs.org/@angular-devkit/architect/-/architect-0.1802.6.tgz",
-			"integrity": "sha512-oF7cPFdTLxeuvXkK/opSdIxZ1E4LrBbmuytQ/nCoAGOaKBWdqvwagRZ6jVhaI0Gwu48rkcV7Zhesg/ESNnROdw==",
+			"resolved": "https://registry.npmjs.org/@angular-devkit/build-webpack/-/build-webpack-0.1802.6.tgz",
+			"integrity": "sha512-JMLcXFaitJplwZMKkqhbYirINCRD6eOPZuIGaIOVynXYGWgvJkLT9t5C2wm9HqSLtp1K7NcYG2Y7PtTVR4krnQ==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
-				"@angular-devkit/core": "18.2.6",
+				"@angular-devkit/architect": "0.1802.6",
 				"rxjs": "7.8.1"
 			},
 			"engines": {
 				"node": "^18.19.1 || ^20.11.1 || >=22.0.0",
 				"npm": "^6.11.0 || ^7.5.6 || >=8.0.0",
 				"yarn": ">= 1.13.0"
+			},
+			"peerDependencies": {
+				"webpack": "^5.30.0",
+				"webpack-dev-server": "^5.0.2"
 			}
 		},
-		"node_modules/@angular-devkit/build-angular/node_modules/@angular-devkit/core": {
+		"node_modules/@angular-devkit/core": {
 			"version": "18.2.6",
 			"resolved": "https://registry.npmjs.org/@angular-devkit/core/-/core-18.2.6.tgz",
 			"integrity": "sha512-la4CFvs5PcRWSkQ/H7TB5cPZirFVA9GoWk5LzIk8si6VjWBJRm8b3keKJoC9LlNeABRUIR5z0ocYkyQQUhdMfg==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"ajv": "8.17.1",
 				"ajv-formats": "3.0.1",
@@ -296,11 +456,46 @@
 				}
 			}
 		},
-		"node_modules/@angular-devkit/build-angular/node_modules/@angular/build": {
+		"node_modules/@angular-devkit/schematics": {
+			"version": "18.2.6",
+			"resolved": "https://registry.npmjs.org/@angular-devkit/schematics/-/schematics-18.2.6.tgz",
+			"integrity": "sha512-uIttrQ2cQ2PWAFFVPeCoNR8xvs7tPJ2i8gzqsIwYdge107xDC6u9CqfgmBqPDSFpWj+IiC2Jwcm8Z4HYKU4+7A==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@angular-devkit/core": "18.2.6",
+				"jsonc-parser": "3.3.1",
+				"magic-string": "0.30.11",
+				"ora": "5.4.1",
+				"rxjs": "7.8.1"
+			},
+			"engines": {
+				"node": "^18.19.1 || ^20.11.1 || >=22.0.0",
+				"npm": "^6.11.0 || ^7.5.6 || >=8.0.0",
+				"yarn": ">= 1.13.0"
+			}
+		},
+		"node_modules/@angular/animations": {
+			"version": "18.2.6",
+			"resolved": "https://registry.npmjs.org/@angular/animations/-/animations-18.2.6.tgz",
+			"integrity": "sha512-vy9wy+Q9beiRxkEO8wNxFQ63AqAujGvk8AUHepxxIT7QNNc512TNKz8uH+feWDPO38Dm2obwYQHMGzs3WO7pUA==",
+			"license": "MIT",
+			"dependencies": {
+				"tslib": "^2.3.0"
+			},
+			"engines": {
+				"node": "^18.19.1 || ^20.11.1 || >=22.0.0"
+			},
+			"peerDependencies": {
+				"@angular/core": "18.2.6"
+			}
+		},
+		"node_modules/@angular/build": {
 			"version": "18.2.6",
 			"resolved": "https://registry.npmjs.org/@angular/build/-/build-18.2.6.tgz",
 			"integrity": "sha512-TQzX6Mi7uXFvmz7+OVl4Za7WawYPcx+B5Ewm6IY/DdMyB9P/Z4tbKb1LO+ynWUXYwm7avXo6XQQ4m5ArDY5F/A==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@ampproject/remapping": "2.3.0",
 				"@angular-devkit/architect": "0.1802.6",
@@ -364,423 +559,36 @@
 				}
 			}
 		},
-		"node_modules/@angular-devkit/build-angular/node_modules/@rollup/rollup-android-arm-eabi": {
-			"version": "4.22.4",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.22.4.tgz",
-			"integrity": "sha512-Fxamp4aEZnfPOcGA8KSNEohV8hX7zVHOemC8jVBoBUHu5zpJK/Eu3uJwt6BMgy9fkvzxDaurgj96F/NiLukF2w==",
-			"cpu": [
-				"arm"
-			],
-			"dev": true,
-			"optional": true,
-			"os": [
-				"android"
-			]
-		},
-		"node_modules/@angular-devkit/build-angular/node_modules/@rollup/rollup-android-arm64": {
-			"version": "4.22.4",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.22.4.tgz",
-			"integrity": "sha512-VXoK5UMrgECLYaMuGuVTOx5kcuap1Jm8g/M83RnCHBKOqvPPmROFJGQaZhGccnsFtfXQ3XYa4/jMCJvZnbJBdA==",
-			"cpu": [
-				"arm64"
-			],
-			"dev": true,
-			"optional": true,
-			"os": [
-				"android"
-			]
-		},
-		"node_modules/@angular-devkit/build-angular/node_modules/@rollup/rollup-darwin-arm64": {
-			"version": "4.22.4",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.22.4.tgz",
-			"integrity": "sha512-xMM9ORBqu81jyMKCDP+SZDhnX2QEVQzTcC6G18KlTQEzWK8r/oNZtKuZaCcHhnsa6fEeOBionoyl5JsAbE/36Q==",
-			"cpu": [
-				"arm64"
-			],
-			"dev": true,
-			"optional": true,
-			"os": [
-				"darwin"
-			]
+		"node_modules/@angular/cdk": {
+			"version": "18.2.6",
+			"resolved": "https://registry.npmjs.org/@angular/cdk/-/cdk-18.2.6.tgz",
+			"integrity": "sha512-Gfq/iv4zhlKYpdQkDaBRwxI71NHNUHM1Cs1XhnZ0/oFct5HXvSv1RHRGTKqBJLLACaAPzZKXJ/UglLoyO5CNiQ==",
+			"license": "MIT",
+			"dependencies": {
+				"tslib": "^2.3.0"
+			},
+			"optionalDependencies": {
+				"parse5": "^7.1.2"
+			},
+			"peerDependencies": {
+				"@angular/common": "^18.0.0 || ^19.0.0",
+				"@angular/core": "^18.0.0 || ^19.0.0",
+				"rxjs": "^6.5.3 || ^7.4.0"
+			}
 		},
-		"node_modules/@angular-devkit/build-angular/node_modules/@rollup/rollup-darwin-x64": {
-			"version": "4.22.4",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.22.4.tgz",
-			"integrity": "sha512-aJJyYKQwbHuhTUrjWjxEvGnNNBCnmpHDvrb8JFDbeSH3m2XdHcxDd3jthAzvmoI8w/kSjd2y0udT+4okADsZIw==",
-			"cpu": [
-				"x64"
-			],
-			"dev": true,
-			"optional": true,
-			"os": [
-				"darwin"
-			]
-		},
-		"node_modules/@angular-devkit/build-angular/node_modules/@rollup/rollup-linux-arm-gnueabihf": {
-			"version": "4.22.4",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.22.4.tgz",
-			"integrity": "sha512-j63YtCIRAzbO+gC2L9dWXRh5BFetsv0j0va0Wi9epXDgU/XUi5dJKo4USTttVyK7fGw2nPWK0PbAvyliz50SCQ==",
-			"cpu": [
-				"arm"
-			],
-			"dev": true,
-			"optional": true,
-			"os": [
-				"linux"
-			]
-		},
-		"node_modules/@angular-devkit/build-angular/node_modules/@rollup/rollup-linux-arm-musleabihf": {
-			"version": "4.22.4",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.22.4.tgz",
-			"integrity": "sha512-dJnWUgwWBX1YBRsuKKMOlXCzh2Wu1mlHzv20TpqEsfdZLb3WoJW2kIEsGwLkroYf24IrPAvOT/ZQ2OYMV6vlrg==",
-			"cpu": [
-				"arm"
-			],
-			"dev": true,
-			"optional": true,
-			"os": [
-				"linux"
-			]
-		},
-		"node_modules/@angular-devkit/build-angular/node_modules/@rollup/rollup-linux-arm64-gnu": {
-			"version": "4.22.4",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.22.4.tgz",
-			"integrity": "sha512-AdPRoNi3NKVLolCN/Sp4F4N1d98c4SBnHMKoLuiG6RXgoZ4sllseuGioszumnPGmPM2O7qaAX/IJdeDU8f26Aw==",
-			"cpu": [
-				"arm64"
-			],
-			"dev": true,
-			"optional": true,
-			"os": [
-				"linux"
-			]
-		},
-		"node_modules/@angular-devkit/build-angular/node_modules/@rollup/rollup-linux-arm64-musl": {
-			"version": "4.22.4",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.22.4.tgz",
-			"integrity": "sha512-Gl0AxBtDg8uoAn5CCqQDMqAx22Wx22pjDOjBdmG0VIWX3qUBHzYmOKh8KXHL4UpogfJ14G4wk16EQogF+v8hmA==",
-			"cpu": [
-				"arm64"
-			],
-			"dev": true,
-			"optional": true,
-			"os": [
-				"linux"
-			]
-		},
-		"node_modules/@angular-devkit/build-angular/node_modules/@rollup/rollup-linux-powerpc64le-gnu": {
-			"version": "4.22.4",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.22.4.tgz",
-			"integrity": "sha512-3aVCK9xfWW1oGQpTsYJJPF6bfpWfhbRnhdlyhak2ZiyFLDaayz0EP5j9V1RVLAAxlmWKTDfS9wyRyY3hvhPoOg==",
-			"cpu": [
-				"ppc64"
-			],
-			"dev": true,
-			"optional": true,
-			"os": [
-				"linux"
-			]
-		},
-		"node_modules/@angular-devkit/build-angular/node_modules/@rollup/rollup-linux-riscv64-gnu": {
-			"version": "4.22.4",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.22.4.tgz",
-			"integrity": "sha512-ePYIir6VYnhgv2C5Xe9u+ico4t8sZWXschR6fMgoPUK31yQu7hTEJb7bCqivHECwIClJfKgE7zYsh1qTP3WHUA==",
-			"cpu": [
-				"riscv64"
-			],
-			"dev": true,
-			"optional": true,
-			"os": [
-				"linux"
-			]
-		},
-		"node_modules/@angular-devkit/build-angular/node_modules/@rollup/rollup-linux-s390x-gnu": {
-			"version": "4.22.4",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.22.4.tgz",
-			"integrity": "sha512-GqFJ9wLlbB9daxhVlrTe61vJtEY99/xB3C8e4ULVsVfflcpmR6c8UZXjtkMA6FhNONhj2eA5Tk9uAVw5orEs4Q==",
-			"cpu": [
-				"s390x"
-			],
-			"dev": true,
-			"optional": true,
-			"os": [
-				"linux"
-			]
-		},
-		"node_modules/@angular-devkit/build-angular/node_modules/@rollup/rollup-linux-x64-gnu": {
-			"version": "4.22.4",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.22.4.tgz",
-			"integrity": "sha512-87v0ol2sH9GE3cLQLNEy0K/R0pz1nvg76o8M5nhMR0+Q+BBGLnb35P0fVz4CQxHYXaAOhE8HhlkaZfsdUOlHwg==",
-			"cpu": [
-				"x64"
-			],
-			"dev": true,
-			"optional": true,
-			"os": [
-				"linux"
-			]
-		},
-		"node_modules/@angular-devkit/build-angular/node_modules/@rollup/rollup-linux-x64-musl": {
-			"version": "4.22.4",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.22.4.tgz",
-			"integrity": "sha512-UV6FZMUgePDZrFjrNGIWzDo/vABebuXBhJEqrHxrGiU6HikPy0Z3LfdtciIttEUQfuDdCn8fqh7wiFJjCNwO+g==",
-			"cpu": [
-				"x64"
-			],
-			"dev": true,
-			"optional": true,
-			"os": [
-				"linux"
-			]
-		},
-		"node_modules/@angular-devkit/build-angular/node_modules/@rollup/rollup-win32-arm64-msvc": {
-			"version": "4.22.4",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.22.4.tgz",
-			"integrity": "sha512-BjI+NVVEGAXjGWYHz/vv0pBqfGoUH0IGZ0cICTn7kB9PyjrATSkX+8WkguNjWoj2qSr1im/+tTGRaY+4/PdcQw==",
-			"cpu": [
-				"arm64"
-			],
-			"dev": true,
-			"optional": true,
-			"os": [
-				"win32"
-			]
-		},
-		"node_modules/@angular-devkit/build-angular/node_modules/@rollup/rollup-win32-ia32-msvc": {
-			"version": "4.22.4",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.22.4.tgz",
-			"integrity": "sha512-SiWG/1TuUdPvYmzmYnmd3IEifzR61Tragkbx9D3+R8mzQqDBz8v+BvZNDlkiTtI9T15KYZhP0ehn3Dld4n9J5g==",
-			"cpu": [
-				"ia32"
-			],
-			"dev": true,
-			"optional": true,
-			"os": [
-				"win32"
-			]
-		},
-		"node_modules/@angular-devkit/build-angular/node_modules/@rollup/rollup-win32-x64-msvc": {
-			"version": "4.22.4",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.22.4.tgz",
-			"integrity": "sha512-j8pPKp53/lq9lMXN57S8cFz0MynJk8OWNuUnXct/9KCpKU7DgU3bYMJhwWmcqC0UU29p8Lr0/7KEVcaM6bf47Q==",
-			"cpu": [
-				"x64"
-			],
-			"dev": true,
-			"optional": true,
-			"os": [
-				"win32"
-			]
-		},
-		"node_modules/@angular-devkit/build-angular/node_modules/@types/estree": {
-			"version": "1.0.5",
-			"resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.5.tgz",
-			"integrity": "sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==",
-			"dev": true
-		},
-		"node_modules/@angular-devkit/build-angular/node_modules/rollup": {
-			"version": "4.22.4",
-			"resolved": "https://registry.npmjs.org/rollup/-/rollup-4.22.4.tgz",
-			"integrity": "sha512-vD8HJ5raRcWOyymsR6Z3o6+RzfEPCnVLMFJ6vRslO1jt4LO6dUo5Qnpg7y4RkZFM2DMe3WUirkI5c16onjrc6A==",
-			"dev": true,
-			"dependencies": {
-				"@types/estree": "1.0.5"
-			},
-			"bin": {
-				"rollup": "dist/bin/rollup"
-			},
-			"engines": {
-				"node": ">=18.0.0",
-				"npm": ">=8.0.0"
-			},
-			"optionalDependencies": {
-				"@rollup/rollup-android-arm-eabi": "4.22.4",
-				"@rollup/rollup-android-arm64": "4.22.4",
-				"@rollup/rollup-darwin-arm64": "4.22.4",
-				"@rollup/rollup-darwin-x64": "4.22.4",
-				"@rollup/rollup-linux-arm-gnueabihf": "4.22.4",
-				"@rollup/rollup-linux-arm-musleabihf": "4.22.4",
-				"@rollup/rollup-linux-arm64-gnu": "4.22.4",
-				"@rollup/rollup-linux-arm64-musl": "4.22.4",
-				"@rollup/rollup-linux-powerpc64le-gnu": "4.22.4",
-				"@rollup/rollup-linux-riscv64-gnu": "4.22.4",
-				"@rollup/rollup-linux-s390x-gnu": "4.22.4",
-				"@rollup/rollup-linux-x64-gnu": "4.22.4",
-				"@rollup/rollup-linux-x64-musl": "4.22.4",
-				"@rollup/rollup-win32-arm64-msvc": "4.22.4",
-				"@rollup/rollup-win32-ia32-msvc": "4.22.4",
-				"@rollup/rollup-win32-x64-msvc": "4.22.4",
-				"fsevents": "~2.3.2"
-			}
-		},
-		"node_modules/@angular-devkit/build-angular/node_modules/webpack-merge": {
-			"version": "6.0.1",
-			"resolved": "https://registry.npmjs.org/webpack-merge/-/webpack-merge-6.0.1.tgz",
-			"integrity": "sha512-hXXvrjtx2PLYx4qruKl+kyRSLc52V+cCvMxRjmKwoA+CBbbF5GfIBtR6kCvl0fYGqTUPKB+1ktVmTHqMOzgCBg==",
+		"node_modules/@angular/cli": {
+			"version": "18.2.6",
+			"resolved": "https://registry.npmjs.org/@angular/cli/-/cli-18.2.6.tgz",
+			"integrity": "sha512-tdXsnV/w+Rgu8q0zFsLU5L9ImTVqrTol1vppHaQkJ/vuoHy+s8ZEbBqhVrO/ffosNb2xseUybGYvqMS4zkNQjg==",
 			"dev": true,
 			"license": "MIT",
-			"dependencies": {
-				"clone-deep": "^4.0.1",
-				"flat": "^5.0.2",
-				"wildcard": "^2.0.1"
-			},
-			"engines": {
-				"node": ">=18.0.0"
-			}
-		},
-		"node_modules/@angular-devkit/build-webpack": {
-			"version": "0.1802.6",
-			"resolved": "https://registry.npmjs.org/@angular-devkit/build-webpack/-/build-webpack-0.1802.6.tgz",
-			"integrity": "sha512-JMLcXFaitJplwZMKkqhbYirINCRD6eOPZuIGaIOVynXYGWgvJkLT9t5C2wm9HqSLtp1K7NcYG2Y7PtTVR4krnQ==",
-			"dev": true,
 			"dependencies": {
 				"@angular-devkit/architect": "0.1802.6",
-				"rxjs": "7.8.1"
-			},
-			"engines": {
-				"node": "^18.19.1 || ^20.11.1 || >=22.0.0",
-				"npm": "^6.11.0 || ^7.5.6 || >=8.0.0",
-				"yarn": ">= 1.13.0"
-			},
-			"peerDependencies": {
-				"webpack": "^5.30.0",
-				"webpack-dev-server": "^5.0.2"
-			}
-		},
-		"node_modules/@angular-devkit/build-webpack/node_modules/@angular-devkit/architect": {
-			"version": "0.1802.6",
-			"resolved": "https://registry.npmjs.org/@angular-devkit/architect/-/architect-0.1802.6.tgz",
-			"integrity": "sha512-oF7cPFdTLxeuvXkK/opSdIxZ1E4LrBbmuytQ/nCoAGOaKBWdqvwagRZ6jVhaI0Gwu48rkcV7Zhesg/ESNnROdw==",
-			"dev": true,
-			"dependencies": {
 				"@angular-devkit/core": "18.2.6",
-				"rxjs": "7.8.1"
-			},
-			"engines": {
-				"node": "^18.19.1 || ^20.11.1 || >=22.0.0",
-				"npm": "^6.11.0 || ^7.5.6 || >=8.0.0",
-				"yarn": ">= 1.13.0"
-			}
-		},
-		"node_modules/@angular-devkit/build-webpack/node_modules/@angular-devkit/core": {
-			"version": "18.2.6",
-			"resolved": "https://registry.npmjs.org/@angular-devkit/core/-/core-18.2.6.tgz",
-			"integrity": "sha512-la4CFvs5PcRWSkQ/H7TB5cPZirFVA9GoWk5LzIk8si6VjWBJRm8b3keKJoC9LlNeABRUIR5z0ocYkyQQUhdMfg==",
-			"dev": true,
-			"dependencies": {
-				"ajv": "8.17.1",
-				"ajv-formats": "3.0.1",
-				"jsonc-parser": "3.3.1",
-				"picomatch": "4.0.2",
-				"rxjs": "7.8.1",
-				"source-map": "0.7.4"
-			},
-			"engines": {
-				"node": "^18.19.1 || ^20.11.1 || >=22.0.0",
-				"npm": "^6.11.0 || ^7.5.6 || >=8.0.0",
-				"yarn": ">= 1.13.0"
-			},
-			"peerDependencies": {
-				"chokidar": "^3.5.2"
-			},
-			"peerDependenciesMeta": {
-				"chokidar": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@angular-devkit/core": {
-			"version": "18.2.1",
-			"resolved": "https://registry.npmjs.org/@angular-devkit/core/-/core-18.2.1.tgz",
-			"integrity": "sha512-fSuGj6CxiTFR+yjuVcaWqaVb5Wts39CSBYRO1BlsOlbuWFZ2NKC/BAb5bdxpB31heCBJi7e3XbPvcMMJIcnKlA==",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"ajv": "8.17.1",
-				"ajv-formats": "3.0.1",
-				"jsonc-parser": "3.3.1",
-				"picomatch": "4.0.2",
-				"rxjs": "7.8.1",
-				"source-map": "0.7.4"
-			},
-			"engines": {
-				"node": "^18.19.1 || ^20.11.1 || >=22.0.0",
-				"npm": "^6.11.0 || ^7.5.6 || >=8.0.0",
-				"yarn": ">= 1.13.0"
-			},
-			"peerDependencies": {
-				"chokidar": "^3.5.2"
-			},
-			"peerDependenciesMeta": {
-				"chokidar": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@angular-devkit/schematics": {
-			"version": "18.2.1",
-			"resolved": "https://registry.npmjs.org/@angular-devkit/schematics/-/schematics-18.2.1.tgz",
-			"integrity": "sha512-2t/q0Jcv7yqhAzEdNgsxoGSCmPgD4qfnVOJ7EJw3LNIA+kX1CmtN4FESUS0i49kN4AyNJFAI5O2pV8iJiliKaw==",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@angular-devkit/core": "18.2.1",
-				"jsonc-parser": "3.3.1",
-				"magic-string": "0.30.11",
-				"ora": "5.4.1",
-				"rxjs": "7.8.1"
-			},
-			"engines": {
-				"node": "^18.19.1 || ^20.11.1 || >=22.0.0",
-				"npm": "^6.11.0 || ^7.5.6 || >=8.0.0",
-				"yarn": ">= 1.13.0"
-			}
-		},
-		"node_modules/@angular/animations": {
-			"version": "18.2.0",
-			"resolved": "https://registry.npmjs.org/@angular/animations/-/animations-18.2.0.tgz",
-			"integrity": "sha512-BFAfqDDjsa0Q91F4s33pFcBG+ydFDurEmwYGG1gmO7UXZJI6ZbRVdULaZHz75M+Bf3hJkzVB05pesvfbK+Fg/g==",
-			"license": "MIT",
-			"dependencies": {
-				"tslib": "^2.3.0"
-			},
-			"engines": {
-				"node": "^18.19.1 || ^20.11.1 || >=22.0.0"
-			},
-			"peerDependencies": {
-				"@angular/core": "18.2.0"
-			}
-		},
-		"node_modules/@angular/cdk": {
-			"version": "18.2.0",
-			"resolved": "https://registry.npmjs.org/@angular/cdk/-/cdk-18.2.0.tgz",
-			"integrity": "sha512-hjuUWNhxU48WB2i1j4NLwnPTaCnucRElfp7DBX5Io0rY5Lwl3HXafvyi7/A1D0Ah+YsJpktKOWPDGv8r7vxymg==",
-			"license": "MIT",
-			"dependencies": {
-				"tslib": "^2.3.0"
-			},
-			"optionalDependencies": {
-				"parse5": "^7.1.2"
-			},
-			"peerDependencies": {
-				"@angular/common": "^18.0.0 || ^19.0.0",
-				"@angular/core": "^18.0.0 || ^19.0.0",
-				"rxjs": "^6.5.3 || ^7.4.0"
-			}
-		},
-		"node_modules/@angular/cli": {
-			"version": "18.2.1",
-			"resolved": "https://registry.npmjs.org/@angular/cli/-/cli-18.2.1.tgz",
-			"integrity": "sha512-SomUFDHanY4o7k3XBGf1eFt4z1h05IGJHfcbl2vxoc0lY59VN13m/pZsD2AtpqtJTzLQT02XQOUP4rmBbGoQ+Q==",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@angular-devkit/architect": "0.1802.1",
-				"@angular-devkit/core": "18.2.1",
-				"@angular-devkit/schematics": "18.2.1",
+				"@angular-devkit/schematics": "18.2.6",
 				"@inquirer/prompts": "5.3.8",
 				"@listr2/prompt-adapter-inquirer": "2.0.15",
-				"@schematics/angular": "18.2.1",
+				"@schematics/angular": "18.2.6",
 				"@yarnpkg/lockfile": "1.1.0",
 				"ini": "4.1.3",
 				"jsonc-parser": "3.3.1",
@@ -803,9 +611,9 @@
 			}
 		},
 		"node_modules/@angular/common": {
-			"version": "18.2.0",
-			"resolved": "https://registry.npmjs.org/@angular/common/-/common-18.2.0.tgz",
-			"integrity": "sha512-DELx/QYNqqjmiM+kE5PoVmyG4gPw5WB1bDDeg3hEuBCK3eS2KosgQH0/MQo3OSBZHOcAMFjfHMGqKgxndmYixQ==",
+			"version": "18.2.6",
+			"resolved": "https://registry.npmjs.org/@angular/common/-/common-18.2.6.tgz",
+			"integrity": "sha512-89793ow+wrI1c7C6kyMbnweLNIZHzXthosxAEjipRZGBrqBYjvTtkE45Fl+5yBa3JO7bAhyGkUnEoyvWtZIAEA==",
 			"license": "MIT",
 			"dependencies": {
 				"tslib": "^2.3.0"
@@ -814,14 +622,14 @@
 				"node": "^18.19.1 || ^20.11.1 || >=22.0.0"
 			},
 			"peerDependencies": {
-				"@angular/core": "18.2.0",
+				"@angular/core": "18.2.6",
 				"rxjs": "^6.5.3 || ^7.4.0"
 			}
 		},
 		"node_modules/@angular/compiler": {
-			"version": "18.2.0",
-			"resolved": "https://registry.npmjs.org/@angular/compiler/-/compiler-18.2.0.tgz",
-			"integrity": "sha512-RmGwQ7jRzotUKKMk0CwxTcIXFr5mRxSbJf9o5S3ujuIOo1lYop8SQZvjq67a5BuoYyD+1pX6iMmxZqlbKoihBQ==",
+			"version": "18.2.6",
+			"resolved": "https://registry.npmjs.org/@angular/compiler/-/compiler-18.2.6.tgz",
+			"integrity": "sha512-3tX2/Qw+bZ8XzKitviH8jzNGyY0uohhehhBB57OJOCc+yr4ojy/7SYFnun1lSsRnDztdCE461641X4iQLCQ94w==",
 			"license": "MIT",
 			"dependencies": {
 				"tslib": "^2.3.0"
@@ -830,7 +638,7 @@
 				"node": "^18.19.1 || ^20.11.1 || >=22.0.0"
 			},
 			"peerDependencies": {
-				"@angular/core": "18.2.0"
+				"@angular/core": "18.2.6"
 			},
 			"peerDependenciesMeta": {
 				"@angular/core": {
@@ -839,9 +647,9 @@
 			}
 		},
 		"node_modules/@angular/compiler-cli": {
-			"version": "18.2.0",
-			"resolved": "https://registry.npmjs.org/@angular/compiler-cli/-/compiler-cli-18.2.0.tgz",
-			"integrity": "sha512-pPBFjMqNTNettrleLtEc6a/ysOZjG3F0Z5lyKYePcyNQmn2rpa9XmD2y6PhmzTmIhxeXrogWA84Xgg/vK5wBNw==",
+			"version": "18.2.6",
+			"resolved": "https://registry.npmjs.org/@angular/compiler-cli/-/compiler-cli-18.2.6.tgz",
+			"integrity": "sha512-b5x9STfjNiNM/S0D+CnqRP9UOxPtSz1+RlCH5WdOMiW/p8j5p6dBix8YYgTe6Wg3OD7eItD2pnFQKgF/dWiopA==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
@@ -863,14 +671,14 @@
 				"node": "^18.19.1 || ^20.11.1 || >=22.0.0"
 			},
 			"peerDependencies": {
-				"@angular/compiler": "18.2.0",
+				"@angular/compiler": "18.2.6",
 				"typescript": ">=5.4 <5.6"
 			}
 		},
 		"node_modules/@angular/core": {
-			"version": "18.2.0",
-			"resolved": "https://registry.npmjs.org/@angular/core/-/core-18.2.0.tgz",
-			"integrity": "sha512-7+4wXfeAk1TnG3MGho2gpBI5XHxeSRWzLK2rC5qyyRbmMV+GrIgf1HqFjQ4S02rydkQvGpjqQHtO1PYJnyn4bg==",
+			"version": "18.2.6",
+			"resolved": "https://registry.npmjs.org/@angular/core/-/core-18.2.6.tgz",
+			"integrity": "sha512-PjFad2j4YBwLVTw+0Te8CJCa/tV0W8caTHG8aOjj3ObdL6ihGI+FKnwerLc9RVzDFd14BOO4C6/+LbOQAh3Ltw==",
 			"license": "MIT",
 			"dependencies": {
 				"tslib": "^2.3.0"
@@ -884,9 +692,9 @@
 			}
 		},
 		"node_modules/@angular/forms": {
-			"version": "18.2.0",
-			"resolved": "https://registry.npmjs.org/@angular/forms/-/forms-18.2.0.tgz",
-			"integrity": "sha512-G+4BjNCUo4cRwg9NwisGLbtG/1AbIJNOO3RUejPJJbCcAkYMSzmDWSQ+LQEGW4vC/1xaDKO8AT71DI/I09bOxA==",
+			"version": "18.2.6",
+			"resolved": "https://registry.npmjs.org/@angular/forms/-/forms-18.2.6.tgz",
+			"integrity": "sha512-quGkUqTxlBaLB8C/RnpfFG57fdmNF5RQ+368N89Ma++2lpIsVAHaGZZn4yOyo3wNYaM2jBxNqaYxOzZNUl5Tig==",
 			"license": "MIT",
 			"dependencies": {
 				"tslib": "^2.3.0"
@@ -895,16 +703,16 @@
 				"node": "^18.19.1 || ^20.11.1 || >=22.0.0"
 			},
 			"peerDependencies": {
-				"@angular/common": "18.2.0",
-				"@angular/core": "18.2.0",
-				"@angular/platform-browser": "18.2.0",
+				"@angular/common": "18.2.6",
+				"@angular/core": "18.2.6",
+				"@angular/platform-browser": "18.2.6",
 				"rxjs": "^6.5.3 || ^7.4.0"
 			}
 		},
 		"node_modules/@angular/language-service": {
-			"version": "18.2.0",
-			"resolved": "https://registry.npmjs.org/@angular/language-service/-/language-service-18.2.0.tgz",
-			"integrity": "sha512-brl5061YqfNnT7yZNMWmsgv6ve6p9+kfhX6mZWOGICcY2SYVtCNVHdqzwWTTwY7MvTVfycHxiAf9PEmc5lD4/g==",
+			"version": "18.2.6",
+			"resolved": "https://registry.npmjs.org/@angular/language-service/-/language-service-18.2.6.tgz",
+			"integrity": "sha512-GBvBvS2llh+/l2YhO7UO5o3GftlvQQoXnw3v0hcNoHKwcnvqXV4CCi+T2WOaZyK0iB8Is4QRbMrpJUC66HokZg==",
 			"dev": true,
 			"license": "MIT",
 			"engines": {
@@ -912,9 +720,9 @@
 			}
 		},
 		"node_modules/@angular/platform-browser": {
-			"version": "18.2.0",
-			"resolved": "https://registry.npmjs.org/@angular/platform-browser/-/platform-browser-18.2.0.tgz",
-			"integrity": "sha512-yhj281TuPz5a8CehwucwIVl29Oqte9KS4X/VQkMV++GpYQE2KKKcoff4FXSdF5RUcUYkK2li4IvawIqPmUSagg==",
+			"version": "18.2.6",
+			"resolved": "https://registry.npmjs.org/@angular/platform-browser/-/platform-browser-18.2.6.tgz",
+			"integrity": "sha512-RA8UMiYNLga+QMwpKcDw1357gYPfPyY/rmLeezMak//BbsENFYQOJ4Z6DBOBNiPlHxmBsUJMGaKdlpQhfCROyQ==",
 			"license": "MIT",
 			"dependencies": {
 				"tslib": "^2.3.0"
@@ -923,9 +731,9 @@
 				"node": "^18.19.1 || ^20.11.1 || >=22.0.0"
 			},
 			"peerDependencies": {
-				"@angular/animations": "18.2.0",
-				"@angular/common": "18.2.0",
-				"@angular/core": "18.2.0"
+				"@angular/animations": "18.2.6",
+				"@angular/common": "18.2.6",
+				"@angular/core": "18.2.6"
 			},
 			"peerDependenciesMeta": {
 				"@angular/animations": {
@@ -934,9 +742,9 @@
 			}
 		},
 		"node_modules/@angular/platform-browser-dynamic": {
-			"version": "18.2.0",
-			"resolved": "https://registry.npmjs.org/@angular/platform-browser-dynamic/-/platform-browser-dynamic-18.2.0.tgz",
-			"integrity": "sha512-izfaXKNC/kqOEzJG8eTnFu39VLI3vv3dTKoYOdEKRB7MTI0t0x66oZmABnHcihtkTSvXs/is+7lA5HmH2ZuIEQ==",
+			"version": "18.2.6",
+			"resolved": "https://registry.npmjs.org/@angular/platform-browser-dynamic/-/platform-browser-dynamic-18.2.6.tgz",
+			"integrity": "sha512-kGBU3FNc+DF9r33hwHZqiWoZgQbCDdEIucU0NCLCIg0Hw6/Q9Hr2ndjxQI+WynCPg0JeBn34jpouvpeJer3YDQ==",
 			"license": "MIT",
 			"dependencies": {
 				"tslib": "^2.3.0"
@@ -945,16 +753,16 @@
 				"node": "^18.19.1 || ^20.11.1 || >=22.0.0"
 			},
 			"peerDependencies": {
-				"@angular/common": "18.2.0",
-				"@angular/compiler": "18.2.0",
-				"@angular/core": "18.2.0",
-				"@angular/platform-browser": "18.2.0"
+				"@angular/common": "18.2.6",
+				"@angular/compiler": "18.2.6",
+				"@angular/core": "18.2.6",
+				"@angular/platform-browser": "18.2.6"
 			}
 		},
 		"node_modules/@angular/router": {
-			"version": "18.2.0",
-			"resolved": "https://registry.npmjs.org/@angular/router/-/router-18.2.0.tgz",
-			"integrity": "sha512-6/462hvC3HSwbps8VItECHpkdkiFqRmTKdn1Trik+FjnvdupYrKB6kBsveM3eP+gZD4zyMBMKzBWB9N/xA1clw==",
+			"version": "18.2.6",
+			"resolved": "https://registry.npmjs.org/@angular/router/-/router-18.2.6.tgz",
+			"integrity": "sha512-t57Sqja8unHhZlPr+4CWnQacuox2M4p2pMHps+31wt337qH6mKf4jqDmK0dE/MFdRyKjT2a2E/2NwtxXxcWNuw==",
 			"license": "MIT",
 			"dependencies": {
 				"tslib": "^2.3.0"
@@ -963,9 +771,9 @@
 				"node": "^18.19.1 || ^20.11.1 || >=22.0.0"
 			},
 			"peerDependencies": {
-				"@angular/common": "18.2.0",
-				"@angular/core": "18.2.0",
-				"@angular/platform-browser": "18.2.0",
+				"@angular/common": "18.2.6",
+				"@angular/core": "18.2.6",
+				"@angular/platform-browser": "18.2.6",
 				"rxjs": "^6.5.3 || ^7.4.0"
 			}
 		},
@@ -984,9 +792,9 @@
 			}
 		},
 		"node_modules/@babel/compat-data": {
-			"version": "7.25.2",
-			"resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.25.2.tgz",
-			"integrity": "sha512-bYcppcpKBvX4znYaPEeFau03bp89ShqNMLs+rmdptMw+heSZh9+z84d2YG+K7cYLbWwzdjtDoW/uqZmPjulClQ==",
+			"version": "7.25.4",
+			"resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.25.4.tgz",
+			"integrity": "sha512-+LGRog6RAsCJrrrg/IO6LGmpphNe5DiK30dGjCoxxeGv49B10/3XYGxPsAwrDlMFcFEvdAUavDT8r9k/hSyQqQ==",
 			"dev": true,
 			"license": "MIT",
 			"engines": {
@@ -1112,9 +920,9 @@
 			}
 		},
 		"node_modules/@babel/helper-create-class-features-plugin": {
-			"version": "7.25.0",
-			"resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.25.0.tgz",
-			"integrity": "sha512-GYM6BxeQsETc9mnct+nIIpf63SAyzvyYN7UB/IlTyd+MBg06afFGp0mIeUqGyWgS2mxad6vqbMrHVlaL3m70sQ==",
+			"version": "7.25.4",
+			"resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.25.4.tgz",
+			"integrity": "sha512-ro/bFs3/84MDgDmMwbcHgDa8/E6J3QKNTk4xJJnVeFtGE+tL0K26E3pNxhYz2b67fJpt7Aphw5XcploKXuCvCQ==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
@@ -1123,7 +931,7 @@
 				"@babel/helper-optimise-call-expression": "^7.24.7",
 				"@babel/helper-replace-supers": "^7.25.0",
 				"@babel/helper-skip-transparent-expression-wrappers": "^7.24.7",
-				"@babel/traverse": "^7.25.0",
+				"@babel/traverse": "^7.25.4",
 				"semver": "^6.3.1"
 			},
 			"engines": {
@@ -1327,6 +1135,7 @@
 			"resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.24.7.tgz",
 			"integrity": "sha512-oy5V7pD+UvfkEATUKvIjvIAH/xCzfsFVw7ygW2SI6NClZzquT+mwdTfgfdbUiceh6iQO0CHtCPsyze/MZ2YbAA==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@babel/types": "^7.24.7"
 			},
@@ -1380,14 +1189,14 @@
 			}
 		},
 		"node_modules/@babel/helpers": {
-			"version": "7.25.0",
-			"resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.25.0.tgz",
-			"integrity": "sha512-MjgLZ42aCm0oGjJj8CtSM3DB8NOOf8h2l7DCTePJs29u+v7yO/RBX9nShlKMgFnRks/Q4tBAe7Hxnov9VkGwLw==",
+			"version": "7.25.6",
+			"resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.25.6.tgz",
+			"integrity": "sha512-Xg0tn4HcfTijTwfDwYlvVCl43V6h4KyVVX2aEm4qdO/PC6L2YvzLHFdmxhoeSA3eslcE6+ZVXHgWwopXYLNq4Q==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"@babel/template": "^7.25.0",
-				"@babel/types": "^7.25.0"
+				"@babel/types": "^7.25.6"
 			},
 			"engines": {
 				"node": ">=6.9.0"
@@ -1410,13 +1219,13 @@
 			}
 		},
 		"node_modules/@babel/parser": {
-			"version": "7.25.3",
-			"resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.25.3.tgz",
-			"integrity": "sha512-iLTJKDbJ4hMvFPgQwwsVoxtHyWpKKPBrxkANrSYewDPaPpT5py5yeVkgPIJ7XYXhndxJpaA3PyALSXQ7u8e/Dw==",
+			"version": "7.25.6",
+			"resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.25.6.tgz",
+			"integrity": "sha512-trGdfBdbD0l1ZPmcJ83eNxB9rbEax4ALFTF7fN386TMYbeCQbyme5cOEXQhbGXKebwGaB/J52w1mrklMcbgy6Q==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@babel/types": "^7.25.2"
+				"@babel/types": "^7.25.6"
 			},
 			"bin": {
 				"parser": "bin/babel-parser.js"
@@ -1591,13 +1400,13 @@
 			}
 		},
 		"node_modules/@babel/plugin-syntax-import-assertions": {
-			"version": "7.24.7",
-			"resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.24.7.tgz",
-			"integrity": "sha512-Ec3NRUMoi8gskrkBe3fNmEQfxDvY8bgfQpz6jlk/41kX9eUjvpyqWU7PBP/pLAvMaSQjbMNKJmvX57jP+M6bPg==",
+			"version": "7.25.6",
+			"resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.25.6.tgz",
+			"integrity": "sha512-aABl0jHw9bZ2karQ/uUD6XP4u0SG22SJrOHFoL6XB1R7dTovOP4TzTlsxOYC5yQ1pdscVK2JTUnF6QL3ARoAiQ==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@babel/helper-plugin-utils": "^7.24.7"
+				"@babel/helper-plugin-utils": "^7.24.8"
 			},
 			"engines": {
 				"node": ">=6.9.0"
@@ -1861,14 +1670,14 @@
 			}
 		},
 		"node_modules/@babel/plugin-transform-class-properties": {
-			"version": "7.24.7",
-			"resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.24.7.tgz",
-			"integrity": "sha512-vKbfawVYayKcSeSR5YYzzyXvsDFWU2mD8U5TFeXtbCPLFUqe7GyCgvO6XDHzje862ODrOwy6WCPmKeWHbCFJ4w==",
+			"version": "7.25.4",
+			"resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.25.4.tgz",
+			"integrity": "sha512-nZeZHyCWPfjkdU5pA/uHiTaDAFUEqkpzf1YoQT2NeSynCGYq9rxfyI3XpQbfx/a0hSnFH6TGlEXvae5Vi7GD8g==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@babel/helper-create-class-features-plugin": "^7.24.7",
-				"@babel/helper-plugin-utils": "^7.24.7"
+				"@babel/helper-create-class-features-plugin": "^7.25.4",
+				"@babel/helper-plugin-utils": "^7.24.8"
 			},
 			"engines": {
 				"node": ">=6.9.0"
@@ -1896,17 +1705,17 @@
 			}
 		},
 		"node_modules/@babel/plugin-transform-classes": {
-			"version": "7.25.0",
-			"resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.25.0.tgz",
-			"integrity": "sha512-xyi6qjr/fYU304fiRwFbekzkqVJZ6A7hOjWZd+89FVcBqPV3S9Wuozz82xdpLspckeaafntbzglaW4pqpzvtSw==",
+			"version": "7.25.4",
+			"resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.25.4.tgz",
+			"integrity": "sha512-oexUfaQle2pF/b6E0dwsxQtAol9TLSO88kQvym6HHBWFliV2lGdrPieX+WgMRLSJDVzdYywk7jXbLPuO2KLTLg==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"@babel/helper-annotate-as-pure": "^7.24.7",
-				"@babel/helper-compilation-targets": "^7.24.8",
+				"@babel/helper-compilation-targets": "^7.25.2",
 				"@babel/helper-plugin-utils": "^7.24.8",
 				"@babel/helper-replace-supers": "^7.25.0",
-				"@babel/traverse": "^7.25.0",
+				"@babel/traverse": "^7.25.4",
 				"globals": "^11.1.0"
 			},
 			"engines": {
@@ -2377,14 +2186,14 @@
 			}
 		},
 		"node_modules/@babel/plugin-transform-private-methods": {
-			"version": "7.24.7",
-			"resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.24.7.tgz",
-			"integrity": "sha512-COTCOkG2hn4JKGEKBADkA8WNb35TGkkRbI5iT845dB+NyqgO8Hn+ajPbSnIQznneJTa3d30scb6iz/DhH8GsJQ==",
+			"version": "7.25.4",
+			"resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.25.4.tgz",
+			"integrity": "sha512-ao8BG7E2b/URaUQGqN3Tlsg+M3KlHY6rJ1O1gXAEUnZoyNQnvKyH87Kfg+FoxSeyWUB8ISZZsC91C44ZuBFytw==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@babel/helper-create-class-features-plugin": "^7.24.7",
-				"@babel/helper-plugin-utils": "^7.24.7"
+				"@babel/helper-create-class-features-plugin": "^7.25.4",
+				"@babel/helper-plugin-utils": "^7.24.8"
 			},
 			"engines": {
 				"node": ">=6.9.0"
@@ -2624,14 +2433,14 @@
 			}
 		},
 		"node_modules/@babel/plugin-transform-unicode-sets-regex": {
-			"version": "7.24.7",
-			"resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.24.7.tgz",
-			"integrity": "sha512-2G8aAvF4wy1w/AGZkemprdGMRg5o6zPNhbHVImRz3lss55TYCBd6xStN19rt8XJHq20sqV0JbyWjOWwQRwV/wg==",
+			"version": "7.25.4",
+			"resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.25.4.tgz",
+			"integrity": "sha512-qesBxiWkgN1Q+31xUE9RcMk79eOXXDCv6tfyGMRSs4RGlioSg2WVyQAm07k726cSE56pa+Kb0y9epX2qaXzTvA==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@babel/helper-create-regexp-features-plugin": "^7.24.7",
-				"@babel/helper-plugin-utils": "^7.24.7"
+				"@babel/helper-create-regexp-features-plugin": "^7.25.2",
+				"@babel/helper-plugin-utils": "^7.24.8"
 			},
 			"engines": {
 				"node": ">=6.9.0"
@@ -2799,17 +2608,17 @@
 			}
 		},
 		"node_modules/@babel/traverse": {
-			"version": "7.25.3",
-			"resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.25.3.tgz",
-			"integrity": "sha512-HefgyP1x754oGCsKmV5reSmtV7IXj/kpaE1XYY+D9G5PvKKoFfSbiS4M77MdjuwlZKDIKFCffq9rPU+H/s3ZdQ==",
+			"version": "7.25.6",
+			"resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.25.6.tgz",
+			"integrity": "sha512-9Vrcx5ZW6UwK5tvqsj0nGpp/XzqthkT0dqIc9g1AdtygFToNtTF67XzYS//dm+SAK9cp3B9R4ZO/46p63SCjlQ==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"@babel/code-frame": "^7.24.7",
-				"@babel/generator": "^7.25.0",
-				"@babel/parser": "^7.25.3",
+				"@babel/generator": "^7.25.6",
+				"@babel/parser": "^7.25.6",
 				"@babel/template": "^7.25.0",
-				"@babel/types": "^7.25.2",
+				"@babel/types": "^7.25.6",
 				"debug": "^4.3.1",
 				"globals": "^11.1.0"
 			},
@@ -2817,10 +2626,26 @@
 				"node": ">=6.9.0"
 			}
 		},
+		"node_modules/@babel/traverse/node_modules/@babel/generator": {
+			"version": "7.25.6",
+			"resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.25.6.tgz",
+			"integrity": "sha512-VPC82gr1seXOpkjAAKoLhP50vx4vGNlF4msF64dSFq1P8RfB+QAuJWGHPXXPc8QyfVWwwB/TNNU4+ayZmHNbZw==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@babel/types": "^7.25.6",
+				"@jridgewell/gen-mapping": "^0.3.5",
+				"@jridgewell/trace-mapping": "^0.3.25",
+				"jsesc": "^2.5.1"
+			},
+			"engines": {
+				"node": ">=6.9.0"
+			}
+		},
 		"node_modules/@babel/types": {
-			"version": "7.25.2",
-			"resolved": "https://registry.npmjs.org/@babel/types/-/types-7.25.2.tgz",
-			"integrity": "sha512-YTnYtra7W9e6/oAZEHj0bJehPRUlLH9/fbpT5LfB0NhQXyALCRkRs3zH9v07IYhkgpqX6Z78FnuccZr/l4Fs4Q==",
+			"version": "7.25.6",
+			"resolved": "https://registry.npmjs.org/@babel/types/-/types-7.25.6.tgz",
+			"integrity": "sha512-/l42B1qxpG6RdfYf343Uw1vmDjeNhneUXtzhojE7pDgfpEypmRhI6j1kr17XCVv4Cgl9HdAiQY2x0GwKm7rWCw==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
@@ -2934,9 +2759,9 @@
 			}
 		},
 		"node_modules/@egjs/agent": {
-			"version": "2.4.3",
-			"resolved": "https://registry.npmjs.org/@egjs/agent/-/agent-2.4.3.tgz",
-			"integrity": "sha512-XvksSENe8wPeFlEVouvrOhKdx8HMniJ3by7sro2uPF3M6QqWwjzVcmvwoPtdjiX8O1lfRoLhQMp1a7NGlVTdIA==",
+			"version": "2.4.4",
+			"resolved": "https://registry.npmjs.org/@egjs/agent/-/agent-2.4.4.tgz",
+			"integrity": "sha512-cvAPSlUILhBBOakn2krdPnOGv5hAZq92f1YHxYcfu0p7uarix2C6Ia3AVizpS1SGRZGiEkIS5E+IVTLg1I2Iog==",
 			"license": "MIT"
 		},
 		"node_modules/@egjs/children-differ": {
@@ -2961,12 +2786,13 @@
 			"license": "MIT"
 		},
 		"node_modules/@electron/asar": {
-			"version": "3.2.10",
-			"resolved": "https://registry.npmjs.org/@electron/asar/-/asar-3.2.10.tgz",
-			"integrity": "sha512-mvBSwIBUeiRscrCeJE1LwctAriBj65eUDm0Pc11iE5gRwzkmsdbS7FnZ1XUWjpSeQWL1L5g12Fc/SchPM9DUOw==",
+			"version": "3.2.13",
+			"resolved": "https://registry.npmjs.org/@electron/asar/-/asar-3.2.13.tgz",
+			"integrity": "sha512-pY5z2qQSwbFzJsBdgfJIzXf5ElHTVMutC2dxh0FD60njknMu3n1NnTABOcQwbb5/v5soqE79m9UjaJryBf3epg==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
+				"@types/glob": "^7.1.0",
 				"commander": "^5.0.0",
 				"glob": "^7.1.6",
 				"minimatch": "^3.0.4"
@@ -3035,9 +2861,9 @@
 			}
 		},
 		"node_modules/@electron/notarize": {
-			"version": "2.2.1",
-			"resolved": "https://registry.npmjs.org/@electron/notarize/-/notarize-2.2.1.tgz",
-			"integrity": "sha512-aL+bFMIkpR0cmmj5Zgy0LMKEpgy43/hw5zadEArgmAMWWlKc5buwFvFT9G/o/YJkvXAJm5q3iuTuLaiaXW39sg==",
+			"version": "2.3.2",
+			"resolved": "https://registry.npmjs.org/@electron/notarize/-/notarize-2.3.2.tgz",
+			"integrity": "sha512-zfayxCe19euNwRycCty1C7lF7snk9YwfRpB5M8GLr1a4ICH63znxaPNAubrMvj0yDvVozqfgsdYpXVUnpWBDpg==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
@@ -3062,10 +2888,83 @@
 				"universalify": "^2.0.0"
 			},
 			"engines": {
-				"node": ">=10"
+				"node": ">=10"
+			}
+		},
+		"node_modules/@electron/notarize/node_modules/jsonfile": {
+			"version": "6.1.0",
+			"resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
+			"integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"universalify": "^2.0.0"
+			},
+			"optionalDependencies": {
+				"graceful-fs": "^4.1.6"
+			}
+		},
+		"node_modules/@electron/notarize/node_modules/universalify": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+			"integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+			"dev": true,
+			"license": "MIT",
+			"engines": {
+				"node": ">= 10.0.0"
+			}
+		},
+		"node_modules/@electron/osx-sign": {
+			"version": "1.3.1",
+			"resolved": "https://registry.npmjs.org/@electron/osx-sign/-/osx-sign-1.3.1.tgz",
+			"integrity": "sha512-BAfviURMHpmb1Yb50YbCxnOY0wfwaLXH5KJ4+80zS0gUkzDX3ec23naTlEqKsN+PwYn+a1cCzM7BJ4Wcd3sGzw==",
+			"dev": true,
+			"license": "BSD-2-Clause",
+			"dependencies": {
+				"compare-version": "^0.1.2",
+				"debug": "^4.3.4",
+				"fs-extra": "^10.0.0",
+				"isbinaryfile": "^4.0.8",
+				"minimist": "^1.2.6",
+				"plist": "^3.0.5"
+			},
+			"bin": {
+				"electron-osx-flat": "bin/electron-osx-flat.js",
+				"electron-osx-sign": "bin/electron-osx-sign.js"
+			},
+			"engines": {
+				"node": ">=12.0.0"
+			}
+		},
+		"node_modules/@electron/osx-sign/node_modules/fs-extra": {
+			"version": "10.1.0",
+			"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+			"integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"graceful-fs": "^4.2.0",
+				"jsonfile": "^6.0.1",
+				"universalify": "^2.0.0"
+			},
+			"engines": {
+				"node": ">=12"
+			}
+		},
+		"node_modules/@electron/osx-sign/node_modules/isbinaryfile": {
+			"version": "4.0.10",
+			"resolved": "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-4.0.10.tgz",
+			"integrity": "sha512-iHrqe5shvBUcFbmZq9zOQHBoeOhZJu6RQGrDpBgenUm/Am+F3JM2MgQj+rK3Z601fzrL5gLZWtAPH2OBaSVcyw==",
+			"dev": true,
+			"license": "MIT",
+			"engines": {
+				"node": ">= 8.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/gjtorikian/"
 			}
 		},
-		"node_modules/@electron/notarize/node_modules/jsonfile": {
+		"node_modules/@electron/osx-sign/node_modules/jsonfile": {
 			"version": "6.1.0",
 			"resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
 			"integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
@@ -3078,7 +2977,7 @@
 				"graceful-fs": "^4.1.6"
 			}
 		},
-		"node_modules/@electron/notarize/node_modules/universalify": {
+		"node_modules/@electron/osx-sign/node_modules/universalify": {
 			"version": "2.0.1",
 			"resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
 			"integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
@@ -3088,29 +2987,89 @@
 				"node": ">= 10.0.0"
 			}
 		},
-		"node_modules/@electron/osx-sign": {
-			"version": "1.0.5",
-			"resolved": "https://registry.npmjs.org/@electron/osx-sign/-/osx-sign-1.0.5.tgz",
-			"integrity": "sha512-k9ZzUQtamSoweGQDV2jILiRIHUu7lYlJ3c6IEmjv1hC17rclE+eb9U+f6UFlOOETo0JzY1HNlXy4YOlCvl+Lww==",
+		"node_modules/@electron/rebuild": {
+			"version": "3.6.0",
+			"resolved": "https://registry.npmjs.org/@electron/rebuild/-/rebuild-3.6.0.tgz",
+			"integrity": "sha512-zF4x3QupRU3uNGaP5X1wjpmcjfw1H87kyqZ00Tc3HvriV+4gmOGuvQjGNkrJuXdsApssdNyVwLsy+TaeTGGcVw==",
 			"dev": true,
-			"license": "BSD-2-Clause",
+			"license": "MIT",
 			"dependencies": {
-				"compare-version": "^0.1.2",
-				"debug": "^4.3.4",
+				"@malept/cross-spawn-promise": "^2.0.0",
+				"chalk": "^4.0.0",
+				"debug": "^4.1.1",
+				"detect-libc": "^2.0.1",
 				"fs-extra": "^10.0.0",
-				"isbinaryfile": "^4.0.8",
-				"minimist": "^1.2.6",
-				"plist": "^3.0.5"
+				"got": "^11.7.0",
+				"node-abi": "^3.45.0",
+				"node-api-version": "^0.2.0",
+				"node-gyp": "^9.0.0",
+				"ora": "^5.1.0",
+				"read-binary-file-arch": "^1.0.6",
+				"semver": "^7.3.5",
+				"tar": "^6.0.5",
+				"yargs": "^17.0.1"
 			},
 			"bin": {
-				"electron-osx-flat": "bin/electron-osx-flat.js",
-				"electron-osx-sign": "bin/electron-osx-sign.js"
+				"electron-rebuild": "lib/cli.js"
 			},
 			"engines": {
-				"node": ">=12.0.0"
+				"node": ">=12.13.0"
 			}
 		},
-		"node_modules/@electron/osx-sign/node_modules/fs-extra": {
+		"node_modules/@electron/rebuild/node_modules/ansi-styles": {
+			"version": "4.3.0",
+			"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+			"integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"color-convert": "^2.0.1"
+			},
+			"engines": {
+				"node": ">=8"
+			},
+			"funding": {
+				"url": "https://github.com/chalk/ansi-styles?sponsor=1"
+			}
+		},
+		"node_modules/@electron/rebuild/node_modules/chalk": {
+			"version": "4.1.2",
+			"resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+			"integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"ansi-styles": "^4.1.0",
+				"supports-color": "^7.1.0"
+			},
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/chalk/chalk?sponsor=1"
+			}
+		},
+		"node_modules/@electron/rebuild/node_modules/color-convert": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+			"integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"color-name": "~1.1.4"
+			},
+			"engines": {
+				"node": ">=7.0.0"
+			}
+		},
+		"node_modules/@electron/rebuild/node_modules/color-name": {
+			"version": "1.1.4",
+			"resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+			"integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+			"dev": true,
+			"license": "MIT"
+		},
+		"node_modules/@electron/rebuild/node_modules/fs-extra": {
 			"version": "10.1.0",
 			"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
 			"integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
@@ -3125,20 +3084,17 @@
 				"node": ">=12"
 			}
 		},
-		"node_modules/@electron/osx-sign/node_modules/isbinaryfile": {
-			"version": "4.0.10",
-			"resolved": "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-4.0.10.tgz",
-			"integrity": "sha512-iHrqe5shvBUcFbmZq9zOQHBoeOhZJu6RQGrDpBgenUm/Am+F3JM2MgQj+rK3Z601fzrL5gLZWtAPH2OBaSVcyw==",
+		"node_modules/@electron/rebuild/node_modules/has-flag": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+			"integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
 			"dev": true,
 			"license": "MIT",
 			"engines": {
-				"node": ">= 8.0.0"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/gjtorikian/"
+				"node": ">=8"
 			}
 		},
-		"node_modules/@electron/osx-sign/node_modules/jsonfile": {
+		"node_modules/@electron/rebuild/node_modules/jsonfile": {
 			"version": "6.1.0",
 			"resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
 			"integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
@@ -3151,7 +3107,20 @@
 				"graceful-fs": "^4.1.6"
 			}
 		},
-		"node_modules/@electron/osx-sign/node_modules/universalify": {
+		"node_modules/@electron/rebuild/node_modules/supports-color": {
+			"version": "7.2.0",
+			"resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+			"integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"has-flag": "^4.0.0"
+			},
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/@electron/rebuild/node_modules/universalify": {
 			"version": "2.0.1",
 			"resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
 			"integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
@@ -3162,49 +3131,37 @@
 			}
 		},
 		"node_modules/@electron/universal": {
-			"version": "1.5.1",
-			"resolved": "https://registry.npmjs.org/@electron/universal/-/universal-1.5.1.tgz",
-			"integrity": "sha512-kbgXxyEauPJiQQUNG2VgUeyfQNFk6hBF11ISN2PNI6agUgPl55pv4eQmaqHzTAzchBvqZ2tQuRVaPStGf0mxGw==",
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/@electron/universal/-/universal-2.0.1.tgz",
+			"integrity": "sha512-fKpv9kg4SPmt+hY7SVBnIYULE9QJl8L3sCfcBsnqbJwwBwAeTLokJ9TRt9y7bK0JAzIW2y78TVVjvnQEms/yyA==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@electron/asar": "^3.2.1",
-				"@malept/cross-spawn-promise": "^1.1.0",
+				"@electron/asar": "^3.2.7",
+				"@malept/cross-spawn-promise": "^2.0.0",
 				"debug": "^4.3.1",
-				"dir-compare": "^3.0.0",
-				"fs-extra": "^9.0.1",
-				"minimatch": "^3.0.4",
-				"plist": "^3.0.4"
+				"dir-compare": "^4.2.0",
+				"fs-extra": "^11.1.1",
+				"minimatch": "^9.0.3",
+				"plist": "^3.1.0"
 			},
 			"engines": {
-				"node": ">=8.6"
-			}
-		},
-		"node_modules/@electron/universal/node_modules/brace-expansion": {
-			"version": "1.1.11",
-			"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-			"integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"balanced-match": "^1.0.0",
-				"concat-map": "0.0.1"
+				"node": ">=16.4"
 			}
 		},
 		"node_modules/@electron/universal/node_modules/fs-extra": {
-			"version": "9.1.0",
-			"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",
-			"integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==",
+			"version": "11.2.0",
+			"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.2.0.tgz",
+			"integrity": "sha512-PmDi3uwK5nFuXh7XDTlVnS17xJS7vW36is2+w3xcv8SVxiB4NyATf4ctkVY5bkSjX0Y4nbvZCq1/EjtEyr9ktw==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"at-least-node": "^1.0.0",
 				"graceful-fs": "^4.2.0",
 				"jsonfile": "^6.0.1",
 				"universalify": "^2.0.0"
 			},
 			"engines": {
-				"node": ">=10"
+				"node": ">=14.14"
 			}
 		},
 		"node_modules/@electron/universal/node_modules/jsonfile": {
@@ -3221,16 +3178,19 @@
 			}
 		},
 		"node_modules/@electron/universal/node_modules/minimatch": {
-			"version": "3.1.2",
-			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-			"integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+			"version": "9.0.5",
+			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
+			"integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
 			"dev": true,
 			"license": "ISC",
 			"dependencies": {
-				"brace-expansion": "^1.1.7"
+				"brace-expansion": "^2.0.1"
 			},
 			"engines": {
-				"node": "*"
+				"node": ">=16 || 14 >=14.17"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/isaacs"
 			}
 		},
 		"node_modules/@electron/universal/node_modules/universalify": {
@@ -3251,6 +3211,7 @@
 				"ppc64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"aix"
@@ -3267,6 +3228,7 @@
 				"arm"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"android"
@@ -3283,6 +3245,7 @@
 				"arm64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"android"
@@ -3299,6 +3262,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"android"
@@ -3315,6 +3279,7 @@
 				"arm64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"darwin"
@@ -3331,6 +3296,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"darwin"
@@ -3347,6 +3313,7 @@
 				"arm64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"freebsd"
@@ -3363,6 +3330,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"freebsd"
@@ -3379,6 +3347,7 @@
 				"arm"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -3395,6 +3364,7 @@
 				"arm64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -3411,6 +3381,7 @@
 				"ia32"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -3427,6 +3398,7 @@
 				"loong64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -3443,6 +3415,7 @@
 				"mips64el"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -3459,6 +3432,7 @@
 				"ppc64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -3475,6 +3449,7 @@
 				"riscv64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -3491,6 +3466,7 @@
 				"s390x"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -3507,6 +3483,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -3523,6 +3500,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"netbsd"
@@ -3539,6 +3517,7 @@
 				"arm64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"openbsd"
@@ -3555,6 +3534,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"openbsd"
@@ -3571,6 +3551,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"sunos"
@@ -3587,6 +3568,7 @@
 				"arm64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"win32"
@@ -3603,6 +3585,7 @@
 				"ia32"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"win32"
@@ -3619,6 +3602,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"win32"
@@ -3657,9 +3641,9 @@
 			}
 		},
 		"node_modules/@eslint-community/regexpp": {
-			"version": "4.11.0",
-			"resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.11.0.tgz",
-			"integrity": "sha512-G/M/tIiMrTAxEWRfLfQJMmGNX28IxBg4PBz8XqQhqUHLFI6TL2htpIB1iQCj144V5ee/JaKyT9/WZ0MGZWfA7A==",
+			"version": "4.11.1",
+			"resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.11.1.tgz",
+			"integrity": "sha512-m4DVN9ZqskZoLU5GlWZadwDnYo3vAEydiUayB9widCl9ffWx2IvPnp6n3on5rJmziJSw9Bv+Z3ChDVdMwXCY8Q==",
 			"dev": true,
 			"license": "MIT",
 			"engines": {
@@ -3667,9 +3651,9 @@
 			}
 		},
 		"node_modules/@eslint/config-array": {
-			"version": "0.17.1",
-			"resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.17.1.tgz",
-			"integrity": "sha512-BlYOpej8AQ8Ev9xVqroV7a02JK3SkBAaN9GfMMH9W6Ch8FlQlkjGw4Ir7+FgYwfirivAf4t+GtzuAxqfukmISA==",
+			"version": "0.18.0",
+			"resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.18.0.tgz",
+			"integrity": "sha512-fTxvnS1sRMu3+JjXwJG0j/i4RT9u4qJ+lqS/yCGap4lH4zZGzQ7tu+xZqQmcMZq5OBZDL4QRxQzRjkWcGt8IVw==",
 			"dev": true,
 			"license": "Apache-2.0",
 			"dependencies": {
@@ -3705,6 +3689,16 @@
 				"node": "*"
 			}
 		},
+		"node_modules/@eslint/core": {
+			"version": "0.6.0",
+			"resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.6.0.tgz",
+			"integrity": "sha512-8I2Q8ykA4J0x0o7cg67FPVnehcqWTBehu/lmY+bolPFHGjh49YzGBMXTvpqVgEbBdvNCSxj6iFgiIyHzf03lzg==",
+			"dev": true,
+			"license": "Apache-2.0",
+			"engines": {
+				"node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+			}
+		},
 		"node_modules/@eslint/eslintrc": {
 			"version": "3.1.0",
 			"resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.1.0.tgz",
@@ -3791,9 +3785,9 @@
 			}
 		},
 		"node_modules/@eslint/js": {
-			"version": "9.9.0",
-			"resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.9.0.tgz",
-			"integrity": "sha512-hhetes6ZHP3BlXLxmd8K2SNgkhNSi+UcecbnwWKwpP7kyi/uC75DJ1lOOBO3xrC4jyojtGE3YxKZPHfk4yrgug==",
+			"version": "9.11.1",
+			"resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.11.1.tgz",
+			"integrity": "sha512-/qu+TWz8WwPWc7/HcIJKi+c+MOm46GdVaSlTTQcaqaL53+GsoA6MxWp5PtTx48qbSP7ylM1Kn7nhvkugfJvRSA==",
 			"dev": true,
 			"license": "MIT",
 			"engines": {
@@ -3810,6 +3804,26 @@
 				"node": "^18.18.0 || ^20.9.0 || >=21.1.0"
 			}
 		},
+		"node_modules/@eslint/plugin-kit": {
+			"version": "0.2.0",
+			"resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.2.0.tgz",
+			"integrity": "sha512-vH9PiIMMwvhCx31Af3HiGzsVNULDbyVkHXwlemn/B0TFj/00ho3y55efXrUZTfQipxoHC5u4xq6zblww1zm1Ig==",
+			"dev": true,
+			"license": "Apache-2.0",
+			"dependencies": {
+				"levn": "^0.4.1"
+			},
+			"engines": {
+				"node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+			}
+		},
+		"node_modules/@gar/promisify": {
+			"version": "1.1.3",
+			"resolved": "https://registry.npmjs.org/@gar/promisify/-/promisify-1.1.3.tgz",
+			"integrity": "sha512-k2Ty1JcVojjJFwrg/ThKi2ujJ7XNLYaFGNB/bWT9wGR+oSMJHMa5w+CUq6p/pVrKeNNgA7pCqEcjSnHVoqJQFw==",
+			"dev": true,
+			"license": "MIT"
+		},
 		"node_modules/@hapi/hoek": {
 			"version": "9.3.0",
 			"resolved": "https://registry.npmjs.org/@hapi/hoek/-/hoek-9.3.0.tgz",
@@ -3856,15 +3870,15 @@
 			}
 		},
 		"node_modules/@inquirer/checkbox": {
-			"version": "2.4.7",
-			"resolved": "https://registry.npmjs.org/@inquirer/checkbox/-/checkbox-2.4.7.tgz",
-			"integrity": "sha512-5YwCySyV1UEgqzz34gNsC38eKxRBtlRDpJLlKcRtTjlYA/yDKuc1rfw+hjw+2WJxbAZtaDPsRl5Zk7J14SBoBw==",
+			"version": "2.5.0",
+			"resolved": "https://registry.npmjs.org/@inquirer/checkbox/-/checkbox-2.5.0.tgz",
+			"integrity": "sha512-sMgdETOfi2dUHT8r7TT1BTKOwNvdDGFDXYWtQ2J69SvlYNntk9I/gJe7r5yvMwwsuKnYbuRs3pNhx4tgNck5aA==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@inquirer/core": "^9.0.10",
+				"@inquirer/core": "^9.1.0",
 				"@inquirer/figures": "^1.0.5",
-				"@inquirer/type": "^1.5.2",
+				"@inquirer/type": "^1.5.3",
 				"ansi-escapes": "^4.3.2",
 				"yoctocolors-cjs": "^2.1.2"
 			},
@@ -3887,19 +3901,18 @@
 			}
 		},
 		"node_modules/@inquirer/core": {
-			"version": "9.0.10",
-			"resolved": "https://registry.npmjs.org/@inquirer/core/-/core-9.0.10.tgz",
-			"integrity": "sha512-TdESOKSVwf6+YWDz8GhS6nKscwzkIyakEzCLJ5Vh6O3Co2ClhCJ0A4MG909MUWfaWdpJm7DE45ii51/2Kat9tA==",
+			"version": "9.2.1",
+			"resolved": "https://registry.npmjs.org/@inquirer/core/-/core-9.2.1.tgz",
+			"integrity": "sha512-F2VBt7W/mwqEU4bL0RnHNZmC/OxzNx9cOYxHqnXX3MP6ruYvZUZAW9imgN9+h/uBT/oP8Gh888J2OZSbjSeWcg==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@inquirer/figures": "^1.0.5",
-				"@inquirer/type": "^1.5.2",
+				"@inquirer/figures": "^1.0.6",
+				"@inquirer/type": "^2.0.0",
 				"@types/mute-stream": "^0.0.4",
-				"@types/node": "^22.1.0",
+				"@types/node": "^22.5.5",
 				"@types/wrap-ansi": "^3.0.0",
 				"ansi-escapes": "^4.3.2",
-				"cli-spinners": "^2.9.2",
 				"cli-width": "^4.1.0",
 				"mute-stream": "^1.0.0",
 				"signal-exit": "^4.1.0",
@@ -3911,15 +3924,28 @@
 				"node": ">=18"
 			}
 		},
+		"node_modules/@inquirer/core/node_modules/@inquirer/type": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/@inquirer/type/-/type-2.0.0.tgz",
+			"integrity": "sha512-XvJRx+2KR3YXyYtPUUy+qd9i7p+GO9Ko6VIIpWlBrpWwXDv8WLFeHTxz35CfQFUiBMLXlGHhGzys7lqit9gWag==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"mute-stream": "^1.0.0"
+			},
+			"engines": {
+				"node": ">=18"
+			}
+		},
 		"node_modules/@inquirer/editor": {
-			"version": "2.1.22",
-			"resolved": "https://registry.npmjs.org/@inquirer/editor/-/editor-2.1.22.tgz",
-			"integrity": "sha512-K1QwTu7GCK+nKOVRBp5HY9jt3DXOfPGPr6WRDrPImkcJRelG9UTx2cAtK1liXmibRrzJlTWOwqgWT3k2XnS62w==",
+			"version": "2.2.0",
+			"resolved": "https://registry.npmjs.org/@inquirer/editor/-/editor-2.2.0.tgz",
+			"integrity": "sha512-9KHOpJ+dIL5SZli8lJ6xdaYLPPzB8xB9GZItg39MBybzhxA16vxmszmQFrRwbOA918WA2rvu8xhDEg/p6LXKbw==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@inquirer/core": "^9.0.10",
-				"@inquirer/type": "^1.5.2",
+				"@inquirer/core": "^9.1.0",
+				"@inquirer/type": "^1.5.3",
 				"external-editor": "^3.1.0"
 			},
 			"engines": {
@@ -3927,14 +3953,14 @@
 			}
 		},
 		"node_modules/@inquirer/expand": {
-			"version": "2.1.22",
-			"resolved": "https://registry.npmjs.org/@inquirer/expand/-/expand-2.1.22.tgz",
-			"integrity": "sha512-wTZOBkzH+ItPuZ3ZPa9lynBsdMp6kQ9zbjVPYEtSBG7UulGjg2kQiAnUjgyG4SlntpTce5bOmXAPvE4sguXjpA==",
+			"version": "2.3.0",
+			"resolved": "https://registry.npmjs.org/@inquirer/expand/-/expand-2.3.0.tgz",
+			"integrity": "sha512-qnJsUcOGCSG1e5DTOErmv2BPQqrtT6uzqn1vI/aYGiPKq+FgslGZmtdnXbhuI7IlT7OByDoEEqdnhUnVR2hhLw==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@inquirer/core": "^9.0.10",
-				"@inquirer/type": "^1.5.2",
+				"@inquirer/core": "^9.1.0",
+				"@inquirer/type": "^1.5.3",
 				"yoctocolors-cjs": "^2.1.2"
 			},
 			"engines": {
@@ -3942,9 +3968,9 @@
 			}
 		},
 		"node_modules/@inquirer/figures": {
-			"version": "1.0.5",
-			"resolved": "https://registry.npmjs.org/@inquirer/figures/-/figures-1.0.5.tgz",
-			"integrity": "sha512-79hP/VWdZ2UVc9bFGJnoQ/lQMpL74mGgzSYX1xUqCVk7/v73vJCMw1VuyWN1jGkZ9B3z7THAbySqGbCNefcjfA==",
+			"version": "1.0.6",
+			"resolved": "https://registry.npmjs.org/@inquirer/figures/-/figures-1.0.6.tgz",
+			"integrity": "sha512-yfZzps3Cso2UbM7WlxKwZQh2Hs6plrbjs1QnzQDZhK2DgyCo6D8AaHps9olkNcUFlcYERMqU3uJSp1gmy3s/qQ==",
 			"dev": true,
 			"license": "MIT",
 			"engines": {
@@ -3952,42 +3978,42 @@
 			}
 		},
 		"node_modules/@inquirer/input": {
-			"version": "2.2.9",
-			"resolved": "https://registry.npmjs.org/@inquirer/input/-/input-2.2.9.tgz",
-			"integrity": "sha512-7Z6N+uzkWM7+xsE+3rJdhdG/+mQgejOVqspoW+w0AbSZnL6nq5tGMEVASaYVWbkoSzecABWwmludO2evU3d31g==",
+			"version": "2.3.0",
+			"resolved": "https://registry.npmjs.org/@inquirer/input/-/input-2.3.0.tgz",
+			"integrity": "sha512-XfnpCStx2xgh1LIRqPXrTNEEByqQWoxsWYzNRSEUxJ5c6EQlhMogJ3vHKu8aXuTacebtaZzMAHwEL0kAflKOBw==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@inquirer/core": "^9.0.10",
-				"@inquirer/type": "^1.5.2"
+				"@inquirer/core": "^9.1.0",
+				"@inquirer/type": "^1.5.3"
 			},
 			"engines": {
 				"node": ">=18"
 			}
 		},
 		"node_modules/@inquirer/number": {
-			"version": "1.0.10",
-			"resolved": "https://registry.npmjs.org/@inquirer/number/-/number-1.0.10.tgz",
-			"integrity": "sha512-kWTxRF8zHjQOn2TJs+XttLioBih6bdc5CcosXIzZsrTY383PXI35DuhIllZKu7CdXFi2rz2BWPN9l0dPsvrQOA==",
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/@inquirer/number/-/number-1.1.0.tgz",
+			"integrity": "sha512-ilUnia/GZUtfSZy3YEErXLJ2Sljo/mf9fiKc08n18DdwdmDbOzRcTv65H1jjDvlsAuvdFXf4Sa/aL7iw/NanVA==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@inquirer/core": "^9.0.10",
-				"@inquirer/type": "^1.5.2"
+				"@inquirer/core": "^9.1.0",
+				"@inquirer/type": "^1.5.3"
 			},
 			"engines": {
 				"node": ">=18"
 			}
 		},
 		"node_modules/@inquirer/password": {
-			"version": "2.1.22",
-			"resolved": "https://registry.npmjs.org/@inquirer/password/-/password-2.1.22.tgz",
-			"integrity": "sha512-5Fxt1L9vh3rAKqjYwqsjU4DZsEvY/2Gll+QkqR4yEpy6wvzLxdSgFhUcxfDAOtO4BEoTreWoznC0phagwLU5Kw==",
+			"version": "2.2.0",
+			"resolved": "https://registry.npmjs.org/@inquirer/password/-/password-2.2.0.tgz",
+			"integrity": "sha512-5otqIpgsPYIshqhgtEwSspBQE40etouR8VIxzpJkv9i0dVHIpyhiivbkH9/dGiMLdyamT54YRdGJLfl8TFnLHg==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@inquirer/core": "^9.0.10",
-				"@inquirer/type": "^1.5.2",
+				"@inquirer/core": "^9.1.0",
+				"@inquirer/type": "^1.5.3",
 				"ansi-escapes": "^4.3.2"
 			},
 			"engines": {
@@ -4017,14 +4043,14 @@
 			}
 		},
 		"node_modules/@inquirer/rawlist": {
-			"version": "2.2.4",
-			"resolved": "https://registry.npmjs.org/@inquirer/rawlist/-/rawlist-2.2.4.tgz",
-			"integrity": "sha512-pb6w9pWrm7EfnYDgQObOurh2d2YH07+eDo3xQBsNAM2GRhliz6wFXGi1thKQ4bN6B0xDd6C3tBsjdr3obsCl3Q==",
+			"version": "2.3.0",
+			"resolved": "https://registry.npmjs.org/@inquirer/rawlist/-/rawlist-2.3.0.tgz",
+			"integrity": "sha512-zzfNuINhFF7OLAtGHfhwOW2TlYJyli7lOUoJUXw/uyklcwalV6WRXBXtFIicN8rTRK1XTiPWB4UY+YuW8dsnLQ==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@inquirer/core": "^9.0.10",
-				"@inquirer/type": "^1.5.2",
+				"@inquirer/core": "^9.1.0",
+				"@inquirer/type": "^1.5.3",
 				"yoctocolors-cjs": "^2.1.2"
 			},
 			"engines": {
@@ -4032,15 +4058,15 @@
 			}
 		},
 		"node_modules/@inquirer/search": {
-			"version": "1.0.7",
-			"resolved": "https://registry.npmjs.org/@inquirer/search/-/search-1.0.7.tgz",
-			"integrity": "sha512-p1wpV+3gd1eST/o5N3yQpYEdFNCzSP0Klrl+5bfD3cTTz8BGG6nf4Z07aBW0xjlKIj1Rp0y3x/X4cZYi6TfcLw==",
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/@inquirer/search/-/search-1.1.0.tgz",
+			"integrity": "sha512-h+/5LSj51dx7hp5xOn4QFnUaKeARwUCLs6mIhtkJ0JYPBLmEYjdHSYh7I6GrLg9LwpJ3xeX0FZgAG1q0QdCpVQ==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@inquirer/core": "^9.0.10",
+				"@inquirer/core": "^9.1.0",
 				"@inquirer/figures": "^1.0.5",
-				"@inquirer/type": "^1.5.2",
+				"@inquirer/type": "^1.5.3",
 				"yoctocolors-cjs": "^2.1.2"
 			},
 			"engines": {
@@ -4048,15 +4074,15 @@
 			}
 		},
 		"node_modules/@inquirer/select": {
-			"version": "2.4.7",
-			"resolved": "https://registry.npmjs.org/@inquirer/select/-/select-2.4.7.tgz",
-			"integrity": "sha512-JH7XqPEkBpNWp3gPCqWqY8ECbyMoFcCZANlL6pV9hf59qK6dGmkOlx1ydyhY+KZ0c5X74+W6Mtp+nm2QX0/MAQ==",
+			"version": "2.5.0",
+			"resolved": "https://registry.npmjs.org/@inquirer/select/-/select-2.5.0.tgz",
+			"integrity": "sha512-YmDobTItPP3WcEI86GvPo+T2sRHkxxOq/kXmsBjHS5BVXUgvgZ5AfJjkvQvZr03T81NnI3KrrRuMzeuYUQRFOA==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@inquirer/core": "^9.0.10",
+				"@inquirer/core": "^9.1.0",
 				"@inquirer/figures": "^1.0.5",
-				"@inquirer/type": "^1.5.2",
+				"@inquirer/type": "^1.5.3",
 				"ansi-escapes": "^4.3.2",
 				"yoctocolors-cjs": "^2.1.2"
 			},
@@ -4065,9 +4091,9 @@
 			}
 		},
 		"node_modules/@inquirer/type": {
-			"version": "1.5.2",
-			"resolved": "https://registry.npmjs.org/@inquirer/type/-/type-1.5.2.tgz",
-			"integrity": "sha512-w9qFkumYDCNyDZmNQjf/n6qQuvQ4dMC3BJesY4oF+yr0CxR5vxujflAVeIcS6U336uzi9GM0kAfZlLrZ9UTkpA==",
+			"version": "1.5.5",
+			"resolved": "https://registry.npmjs.org/@inquirer/type/-/type-1.5.5.tgz",
+			"integrity": "sha512-MzICLu4yS7V8AA61sANROZ9vT1H3ooca5dSmI1FjZkzq7o/koMsRfQSzRtFo+F3Ao4Sf1C0bpLKejpKB/+j6MA==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
@@ -4096,9 +4122,9 @@
 			}
 		},
 		"node_modules/@isaacs/cliui/node_modules/ansi-regex": {
-			"version": "6.0.1",
-			"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.1.tgz",
-			"integrity": "sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==",
+			"version": "6.1.0",
+			"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
+			"integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
 			"dev": true,
 			"license": "MIT",
 			"engines": {
@@ -4259,6 +4285,7 @@
 			"resolved": "https://registry.npmjs.org/@jsonjoy.com/base64/-/base64-1.1.2.tgz",
 			"integrity": "sha512-q6XAnWQDIMA3+FTiOYajoYqySkO+JSat0ytXGSuRdq9uXE7o92gzuQwQM14xaCRlBLGq3v5miDGC4vkVTn54xA==",
 			"dev": true,
+			"license": "Apache-2.0",
 			"engines": {
 				"node": ">=10.0"
 			},
@@ -4275,6 +4302,7 @@
 			"resolved": "https://registry.npmjs.org/@jsonjoy.com/json-pack/-/json-pack-1.1.0.tgz",
 			"integrity": "sha512-zlQONA+msXPPwHWZMKFVS78ewFczIll5lXiVPwFPCZUsrOKdxc2AvxU1HoNBmMRhqDZUR9HkC3UOm+6pME6Xsg==",
 			"dev": true,
+			"license": "Apache-2.0",
 			"dependencies": {
 				"@jsonjoy.com/base64": "^1.1.1",
 				"@jsonjoy.com/util": "^1.1.2",
@@ -4297,6 +4325,7 @@
 			"resolved": "https://registry.npmjs.org/@jsonjoy.com/util/-/util-1.3.0.tgz",
 			"integrity": "sha512-Cebt4Vk7k1xHy87kHY7KSPLT77A7Ev7IfOblyLZhtYEhrdQ6fX4EoLq3xOQ3O/DRMEh2ok5nyC180E+ABS8Wmw==",
 			"dev": true,
+			"license": "Apache-2.0",
 			"engines": {
 				"node": ">=10.0"
 			},
@@ -4318,7 +4347,8 @@
 			"version": "2.0.5",
 			"resolved": "https://registry.npmjs.org/@leichtgewicht/ip-codec/-/ip-codec-2.0.5.tgz",
 			"integrity": "sha512-Vo+PSpZG2/fmgmiNzYK9qWRh8h/CHrwD0mo1h1DzL4yzHNSfWYujGTYsWGreD000gcgmZ7K4Ys6Tx9TxtsKdDw==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/@listr2/prompt-adapter-inquirer": {
 			"version": "2.0.15",
@@ -4344,6 +4374,7 @@
 				"arm64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"darwin"
@@ -4357,6 +4388,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"darwin"
@@ -4370,6 +4402,7 @@
 				"arm"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -4383,6 +4416,7 @@
 				"arm64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -4396,6 +4430,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -4409,15 +4444,16 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"win32"
 			]
 		},
 		"node_modules/@malept/cross-spawn-promise": {
-			"version": "1.1.1",
-			"resolved": "https://registry.npmjs.org/@malept/cross-spawn-promise/-/cross-spawn-promise-1.1.1.tgz",
-			"integrity": "sha512-RTBGWL5FWQcg9orDOCcp4LvItNzUPcyEU9bwaeJX0rJ1IQxzucC48Y0/sQLp/g6t99IQgAlGIaesJS+gTn7tVQ==",
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/@malept/cross-spawn-promise/-/cross-spawn-promise-2.0.0.tgz",
+			"integrity": "sha512-1DpKU0Z5ThltBwjNySMC14g0CkbyhCaz9FkhxqNsZI6uAPJXFS8cMXlBKo26FJ8ZuW6S9GCMcR9IO5k2X5/9Fg==",
 			"dev": true,
 			"funding": [
 				{
@@ -4434,7 +4470,7 @@
 				"cross-spawn": "^7.0.1"
 			},
 			"engines": {
-				"node": ">= 10"
+				"node": ">= 12.13.0"
 			}
 		},
 		"node_modules/@malept/flatpak-bundler": {
@@ -4506,6 +4542,7 @@
 				"arm64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"darwin"
@@ -4519,6 +4556,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"darwin"
@@ -4532,6 +4570,7 @@
 				"arm"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -4545,6 +4584,7 @@
 				"arm64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -4558,6 +4598,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -4571,6 +4612,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"win32"
@@ -4581,6 +4623,7 @@
 			"resolved": "https://registry.npmjs.org/@ngtools/webpack/-/webpack-18.2.6.tgz",
 			"integrity": "sha512-7HwOPE1EOgcHnpt4brSiT8G2CcXB50G0+CbCBaKGy4LYCG3Y3mrlzF5Fup9HvMJ6Tzqd62RqzpKKYBiGUT7hxg==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": "^18.19.1 || ^20.11.1 || >=22.0.0",
 				"npm": "^6.11.0 || ^7.5.6 || >=8.0.0",
@@ -4681,17 +4724,33 @@
 			"dev": true,
 			"license": "ISC"
 		},
+		"node_modules/@npmcli/agent/node_modules/socks-proxy-agent": {
+			"version": "8.0.4",
+			"resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.4.tgz",
+			"integrity": "sha512-GNAq/eg8Udq2x0eNiFkr9gRg5bA7PXEWagQdeRX4cPSG+X/8V38v637gim9bjFptMk1QWsCTr0ttrJEiXbNnRw==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"agent-base": "^7.1.1",
+				"debug": "^4.3.4",
+				"socks": "^2.8.3"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
 		"node_modules/@npmcli/fs": {
-			"version": "3.1.1",
-			"resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-3.1.1.tgz",
-			"integrity": "sha512-q9CRWjpHCMIh5sVyefoD1cA7PkvILqCZsnSOEUUivORLjxCO/Irmue2DprETiNgEqktDBZaM1Bi+jrarx1XdCg==",
+			"version": "2.1.2",
+			"resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-2.1.2.tgz",
+			"integrity": "sha512-yOJKRvohFOaLqipNtwYB9WugyZKhC/DZC4VYPmpaCzDBrA8YpK3qHZ8/HGscMnE4GqbkLNuVcCnxkeQEdGt6LQ==",
 			"dev": true,
 			"license": "ISC",
 			"dependencies": {
+				"@gar/promisify": "^1.1.3",
 				"semver": "^7.3.5"
 			},
 			"engines": {
-				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+				"node": "^12.13.0 || ^14.15.0 || >=16.0.0"
 			}
 		},
 		"node_modules/@npmcli/git": {
@@ -4765,6 +4824,21 @@
 				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
 			}
 		},
+		"node_modules/@npmcli/move-file": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/@npmcli/move-file/-/move-file-2.0.1.tgz",
+			"integrity": "sha512-mJd2Z5TjYWq/ttPLLGqArdtnC74J6bOzg4rMDnN+p1xTacZ2yPRCk2y0oSWQtygLR9YVQXgOcONrwtnk3JupxQ==",
+			"deprecated": "This functionality has been moved to @npmcli/fs",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"mkdirp": "^1.0.4",
+				"rimraf": "^3.0.2"
+			},
+			"engines": {
+				"node": "^12.13.0 || ^14.15.0 || >=16.0.0"
+			}
+		},
 		"node_modules/@npmcli/node-gyp": {
 			"version": "3.0.0",
 			"resolved": "https://registry.npmjs.org/@npmcli/node-gyp/-/node-gyp-3.0.0.tgz",
@@ -4776,9 +4850,9 @@
 			}
 		},
 		"node_modules/@npmcli/package-json": {
-			"version": "5.2.0",
-			"resolved": "https://registry.npmjs.org/@npmcli/package-json/-/package-json-5.2.0.tgz",
-			"integrity": "sha512-qe/kiqqkW0AGtvBjL8TJKZk/eBBSpnJkUWvHdQ9jM2lKHXRYYJuyNpJPlJw3c8QjC2ow6NZYiLExhUaeJelbxQ==",
+			"version": "5.2.1",
+			"resolved": "https://registry.npmjs.org/@npmcli/package-json/-/package-json-5.2.1.tgz",
+			"integrity": "sha512-f7zYC6kQautXHvNbLEWgD/uGu1+xCn9izgqBfgItWSx22U0ZDekxN08A1vM8cTxj/cRVe0Q94Ode+tdoYmIOOQ==",
 			"dev": true,
 			"license": "ISC",
 			"dependencies": {
@@ -4851,6 +4925,16 @@
 				"url": "https://github.com/sponsors/isaacs"
 			}
 		},
+		"node_modules/@npmcli/package-json/node_modules/minipass": {
+			"version": "7.1.2",
+			"resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
+			"integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
+			"dev": true,
+			"license": "ISC",
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
+			}
+		},
 		"node_modules/@npmcli/promise-spawn": {
 			"version": "7.0.2",
 			"resolved": "https://registry.npmjs.org/@npmcli/promise-spawn/-/promise-spawn-7.0.2.tgz",
@@ -4915,17 +4999,266 @@
 				"which": "^4.0.0"
 			},
 			"engines": {
-				"node": "^16.14.0 || >=18.0.0"
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/@npmcli/run-script/node_modules/@npmcli/fs": {
+			"version": "3.1.1",
+			"resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-3.1.1.tgz",
+			"integrity": "sha512-q9CRWjpHCMIh5sVyefoD1cA7PkvILqCZsnSOEUUivORLjxCO/Irmue2DprETiNgEqktDBZaM1Bi+jrarx1XdCg==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"semver": "^7.3.5"
+			},
+			"engines": {
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+			}
+		},
+		"node_modules/@npmcli/run-script/node_modules/abbrev": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/abbrev/-/abbrev-2.0.0.tgz",
+			"integrity": "sha512-6/mh1E2u2YgEsCHdY0Yx5oW+61gZU+1vXaoiHHrpKeuRNNgFvS+/jrwHiQhB5apAf5oB7UB7E19ol2R2LKH8hQ==",
+			"dev": true,
+			"license": "ISC",
+			"engines": {
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+			}
+		},
+		"node_modules/@npmcli/run-script/node_modules/cacache": {
+			"version": "18.0.4",
+			"resolved": "https://registry.npmjs.org/cacache/-/cacache-18.0.4.tgz",
+			"integrity": "sha512-B+L5iIa9mgcjLbliir2th36yEwPftrzteHYujzsx3dFP/31GCHcIeS8f5MGd80odLOjaOvSpU3EEAmRQptkxLQ==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"@npmcli/fs": "^3.1.0",
+				"fs-minipass": "^3.0.0",
+				"glob": "^10.2.2",
+				"lru-cache": "^10.0.1",
+				"minipass": "^7.0.3",
+				"minipass-collect": "^2.0.1",
+				"minipass-flush": "^1.0.5",
+				"minipass-pipeline": "^1.2.4",
+				"p-map": "^4.0.0",
+				"ssri": "^10.0.0",
+				"tar": "^6.1.11",
+				"unique-filename": "^3.0.0"
+			},
+			"engines": {
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/@npmcli/run-script/node_modules/fs-minipass": {
+			"version": "3.0.3",
+			"resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-3.0.3.tgz",
+			"integrity": "sha512-XUBA9XClHbnJWSfBzjkm6RvPsyg3sryZt06BEQoXcF7EK/xpGaQYJgQKDJSUH5SGZ76Y7pFx1QBnXz09rU5Fbw==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"minipass": "^7.0.3"
+			},
+			"engines": {
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+			}
+		},
+		"node_modules/@npmcli/run-script/node_modules/glob": {
+			"version": "10.4.5",
+			"resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
+			"integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"foreground-child": "^3.1.0",
+				"jackspeak": "^3.1.2",
+				"minimatch": "^9.0.4",
+				"minipass": "^7.1.2",
+				"package-json-from-dist": "^1.0.0",
+				"path-scurry": "^1.11.1"
+			},
+			"bin": {
+				"glob": "dist/esm/bin.mjs"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/isaacs"
+			}
+		},
+		"node_modules/@npmcli/run-script/node_modules/isexe": {
+			"version": "3.1.1",
+			"resolved": "https://registry.npmjs.org/isexe/-/isexe-3.1.1.tgz",
+			"integrity": "sha512-LpB/54B+/2J5hqQ7imZHfdU31OlgQqx7ZicVlkm9kzg9/w8GKLEcFfJl/t7DCEDueOyBAD6zCCwTO6Fzs0NoEQ==",
+			"dev": true,
+			"license": "ISC",
+			"engines": {
+				"node": ">=16"
+			}
+		},
+		"node_modules/@npmcli/run-script/node_modules/lru-cache": {
+			"version": "10.4.3",
+			"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+			"integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+			"dev": true,
+			"license": "ISC"
+		},
+		"node_modules/@npmcli/run-script/node_modules/make-fetch-happen": {
+			"version": "13.0.1",
+			"resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-13.0.1.tgz",
+			"integrity": "sha512-cKTUFc/rbKUd/9meOvgrpJ2WrNzymt6jfRDdwg5UCnVzv9dTpEj9JS5m3wtziXVCjluIXyL8pcaukYqezIzZQA==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"@npmcli/agent": "^2.0.0",
+				"cacache": "^18.0.0",
+				"http-cache-semantics": "^4.1.1",
+				"is-lambda": "^1.0.1",
+				"minipass": "^7.0.2",
+				"minipass-fetch": "^3.0.0",
+				"minipass-flush": "^1.0.5",
+				"minipass-pipeline": "^1.2.4",
+				"negotiator": "^0.6.3",
+				"proc-log": "^4.2.0",
+				"promise-retry": "^2.0.1",
+				"ssri": "^10.0.0"
+			},
+			"engines": {
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/@npmcli/run-script/node_modules/minimatch": {
+			"version": "9.0.5",
+			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
+			"integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"brace-expansion": "^2.0.1"
+			},
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/isaacs"
+			}
+		},
+		"node_modules/@npmcli/run-script/node_modules/minipass": {
+			"version": "7.1.2",
+			"resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
+			"integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
+			"dev": true,
+			"license": "ISC",
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
+			}
+		},
+		"node_modules/@npmcli/run-script/node_modules/minipass-collect": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/minipass-collect/-/minipass-collect-2.0.1.tgz",
+			"integrity": "sha512-D7V8PO9oaz7PWGLbCACuI1qEOsq7UKfLotx/C0Aet43fCUB/wfQ7DYeq2oR/svFJGYDHPr38SHATeaj/ZoKHKw==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"minipass": "^7.0.3"
+			},
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
+			}
+		},
+		"node_modules/@npmcli/run-script/node_modules/minipass-fetch": {
+			"version": "3.0.5",
+			"resolved": "https://registry.npmjs.org/minipass-fetch/-/minipass-fetch-3.0.5.tgz",
+			"integrity": "sha512-2N8elDQAtSnFV0Dk7gt15KHsS0Fyz6CbYZ360h0WTYV1Ty46li3rAXVOQj1THMNLdmrD9Vt5pBPtWtVkpwGBqg==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"minipass": "^7.0.3",
+				"minipass-sized": "^1.0.3",
+				"minizlib": "^2.1.2"
+			},
+			"engines": {
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+			},
+			"optionalDependencies": {
+				"encoding": "^0.1.13"
+			}
+		},
+		"node_modules/@npmcli/run-script/node_modules/node-gyp": {
+			"version": "10.2.0",
+			"resolved": "https://registry.npmjs.org/node-gyp/-/node-gyp-10.2.0.tgz",
+			"integrity": "sha512-sp3FonBAaFe4aYTcFdZUn2NYkbP7xroPGYvQmP4Nl5PxamznItBnNCgjrVTKrEfQynInMsJvZrdmqUnysCJ8rw==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"env-paths": "^2.2.0",
+				"exponential-backoff": "^3.1.1",
+				"glob": "^10.3.10",
+				"graceful-fs": "^4.2.6",
+				"make-fetch-happen": "^13.0.0",
+				"nopt": "^7.0.0",
+				"proc-log": "^4.1.0",
+				"semver": "^7.3.5",
+				"tar": "^6.2.1",
+				"which": "^4.0.0"
+			},
+			"bin": {
+				"node-gyp": "bin/node-gyp.js"
+			},
+			"engines": {
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/@npmcli/run-script/node_modules/nopt": {
+			"version": "7.2.1",
+			"resolved": "https://registry.npmjs.org/nopt/-/nopt-7.2.1.tgz",
+			"integrity": "sha512-taM24ViiimT/XntxbPyJQzCG+p4EKOpgD3mxFwW38mGjVUrfERQOeY4EDHjdnptttfHuHQXFx+lTP08Q+mLa/w==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"abbrev": "^2.0.0"
+			},
+			"bin": {
+				"nopt": "bin/nopt.js"
+			},
+			"engines": {
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+			}
+		},
+		"node_modules/@npmcli/run-script/node_modules/ssri": {
+			"version": "10.0.6",
+			"resolved": "https://registry.npmjs.org/ssri/-/ssri-10.0.6.tgz",
+			"integrity": "sha512-MGrFH9Z4NP9Iyhqn16sDtBpRRNJ0Y2hNa6D65h736fVSaPCHr4DM4sWUNvVaSuC+0OBGhwsrydQwmgfg5LncqQ==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"minipass": "^7.0.3"
+			},
+			"engines": {
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+			}
+		},
+		"node_modules/@npmcli/run-script/node_modules/unique-filename": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-3.0.0.tgz",
+			"integrity": "sha512-afXhuC55wkAmZ0P18QsVE6kp8JaxrEokN2HGIoIVv2ijHQd419H0+6EigAFcIzXeMIkcIkNBpB3L/DXB3cTS/g==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"unique-slug": "^4.0.0"
+			},
+			"engines": {
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
 			}
 		},
-		"node_modules/@npmcli/run-script/node_modules/isexe": {
-			"version": "3.1.1",
-			"resolved": "https://registry.npmjs.org/isexe/-/isexe-3.1.1.tgz",
-			"integrity": "sha512-LpB/54B+/2J5hqQ7imZHfdU31OlgQqx7ZicVlkm9kzg9/w8GKLEcFfJl/t7DCEDueOyBAD6zCCwTO6Fzs0NoEQ==",
+		"node_modules/@npmcli/run-script/node_modules/unique-slug": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-4.0.0.tgz",
+			"integrity": "sha512-WrcA6AyEfqDX5bWige/4NQfPZMtASNVxdmWR76WESYQVAACSgWcR6e9i0mofqqBxYFtL4oAxPIptY73/0YE1DQ==",
 			"dev": true,
 			"license": "ISC",
+			"dependencies": {
+				"imurmurhash": "^0.1.4"
+			},
 			"engines": {
-				"node": ">=16"
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
 			}
 		},
 		"node_modules/@npmcli/run-script/node_modules/which": {
@@ -4956,208 +5289,224 @@
 			}
 		},
 		"node_modules/@rollup/rollup-android-arm-eabi": {
-			"version": "4.23.0",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.23.0.tgz",
-			"integrity": "sha512-8OR+Ok3SGEMsAZispLx8jruuXw0HVF16k+ub2eNXKHDmdxL4cf9NlNpAzhlOhNyXzKDEJuFeq0nZm+XlNb1IFw==",
+			"version": "4.22.4",
+			"resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.22.4.tgz",
+			"integrity": "sha512-Fxamp4aEZnfPOcGA8KSNEohV8hX7zVHOemC8jVBoBUHu5zpJK/Eu3uJwt6BMgy9fkvzxDaurgj96F/NiLukF2w==",
 			"cpu": [
 				"arm"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"android"
 			]
 		},
 		"node_modules/@rollup/rollup-android-arm64": {
-			"version": "4.23.0",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.23.0.tgz",
-			"integrity": "sha512-rEFtX1nP8gqmLmPZsXRMoLVNB5JBwOzIAk/XAcEPuKrPa2nPJ+DuGGpfQUR0XjRm8KjHfTZLpWbKXkA5BoFL3w==",
+			"version": "4.22.4",
+			"resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.22.4.tgz",
+			"integrity": "sha512-VXoK5UMrgECLYaMuGuVTOx5kcuap1Jm8g/M83RnCHBKOqvPPmROFJGQaZhGccnsFtfXQ3XYa4/jMCJvZnbJBdA==",
 			"cpu": [
 				"arm64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"android"
 			]
 		},
 		"node_modules/@rollup/rollup-darwin-arm64": {
-			"version": "4.23.0",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.23.0.tgz",
-			"integrity": "sha512-ZbqlMkJRMMPeapfaU4drYHns7Q5MIxjM/QeOO62qQZGPh9XWziap+NF9fsqPHT0KzEL6HaPspC7sOwpgyA3J9g==",
+			"version": "4.22.4",
+			"resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.22.4.tgz",
+			"integrity": "sha512-xMM9ORBqu81jyMKCDP+SZDhnX2QEVQzTcC6G18KlTQEzWK8r/oNZtKuZaCcHhnsa6fEeOBionoyl5JsAbE/36Q==",
 			"cpu": [
 				"arm64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"darwin"
 			]
 		},
 		"node_modules/@rollup/rollup-darwin-x64": {
-			"version": "4.23.0",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.23.0.tgz",
-			"integrity": "sha512-PfmgQp78xx5rBCgn2oYPQ1rQTtOaQCna0kRaBlc5w7RlA3TDGGo7m3XaptgitUZ54US9915i7KeVPHoy3/W8tA==",
+			"version": "4.22.4",
+			"resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.22.4.tgz",
+			"integrity": "sha512-aJJyYKQwbHuhTUrjWjxEvGnNNBCnmpHDvrb8JFDbeSH3m2XdHcxDd3jthAzvmoI8w/kSjd2y0udT+4okADsZIw==",
 			"cpu": [
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"darwin"
 			]
 		},
 		"node_modules/@rollup/rollup-linux-arm-gnueabihf": {
-			"version": "4.23.0",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.23.0.tgz",
-			"integrity": "sha512-WAeZfAAPus56eQgBioezXRRzArAjWJGjNo/M+BHZygUcs9EePIuGI1Wfc6U/Ki+tMW17FFGvhCfYnfcKPh18SA==",
+			"version": "4.22.4",
+			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.22.4.tgz",
+			"integrity": "sha512-j63YtCIRAzbO+gC2L9dWXRh5BFetsv0j0va0Wi9epXDgU/XUi5dJKo4USTttVyK7fGw2nPWK0PbAvyliz50SCQ==",
 			"cpu": [
 				"arm"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
 			]
 		},
 		"node_modules/@rollup/rollup-linux-arm-musleabihf": {
-			"version": "4.23.0",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.23.0.tgz",
-			"integrity": "sha512-v7PGcp1O5XKZxKX8phTXtmJDVpE20Ub1eF6w9iMmI3qrrPak6yR9/5eeq7ziLMrMTjppkkskXyxnmm00HdtXjA==",
+			"version": "4.22.4",
+			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.22.4.tgz",
+			"integrity": "sha512-dJnWUgwWBX1YBRsuKKMOlXCzh2Wu1mlHzv20TpqEsfdZLb3WoJW2kIEsGwLkroYf24IrPAvOT/ZQ2OYMV6vlrg==",
 			"cpu": [
 				"arm"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
 			]
 		},
 		"node_modules/@rollup/rollup-linux-arm64-gnu": {
-			"version": "4.23.0",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.23.0.tgz",
-			"integrity": "sha512-nAbWsDZ9UkU6xQiXEyXBNHAKbzSAi95H3gTStJq9UGiS1v+YVXwRHcQOQEF/3CHuhX5BVhShKoeOf6Q/1M+Zhg==",
+			"version": "4.22.4",
+			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.22.4.tgz",
+			"integrity": "sha512-AdPRoNi3NKVLolCN/Sp4F4N1d98c4SBnHMKoLuiG6RXgoZ4sllseuGioszumnPGmPM2O7qaAX/IJdeDU8f26Aw==",
 			"cpu": [
 				"arm64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
 			]
 		},
 		"node_modules/@rollup/rollup-linux-arm64-musl": {
-			"version": "4.23.0",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.23.0.tgz",
-			"integrity": "sha512-5QT/Di5FbGNPaVw8hHO1wETunwkPuZBIu6W+5GNArlKHD9fkMHy7vS8zGHJk38oObXfWdsuLMogD4sBySLJ54g==",
+			"version": "4.22.4",
+			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.22.4.tgz",
+			"integrity": "sha512-Gl0AxBtDg8uoAn5CCqQDMqAx22Wx22pjDOjBdmG0VIWX3qUBHzYmOKh8KXHL4UpogfJ14G4wk16EQogF+v8hmA==",
 			"cpu": [
 				"arm64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
 			]
 		},
 		"node_modules/@rollup/rollup-linux-powerpc64le-gnu": {
-			"version": "4.23.0",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.23.0.tgz",
-			"integrity": "sha512-Sefl6vPyn5axzCsO13r1sHLcmPuiSOrKIImnq34CBurntcJ+lkQgAaTt/9JkgGmaZJ+OkaHmAJl4Bfd0DmdtOQ==",
+			"version": "4.22.4",
+			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.22.4.tgz",
+			"integrity": "sha512-3aVCK9xfWW1oGQpTsYJJPF6bfpWfhbRnhdlyhak2ZiyFLDaayz0EP5j9V1RVLAAxlmWKTDfS9wyRyY3hvhPoOg==",
 			"cpu": [
 				"ppc64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
 			]
 		},
 		"node_modules/@rollup/rollup-linux-riscv64-gnu": {
-			"version": "4.23.0",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.23.0.tgz",
-			"integrity": "sha512-o4QI2KU/QbP7ZExMse6ULotdV3oJUYMrdx3rBZCgUF3ur3gJPfe8Fuasn6tia16c5kZBBw0aTmaUygad6VB/hQ==",
+			"version": "4.22.4",
+			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.22.4.tgz",
+			"integrity": "sha512-ePYIir6VYnhgv2C5Xe9u+ico4t8sZWXschR6fMgoPUK31yQu7hTEJb7bCqivHECwIClJfKgE7zYsh1qTP3WHUA==",
 			"cpu": [
 				"riscv64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
 			]
 		},
 		"node_modules/@rollup/rollup-linux-s390x-gnu": {
-			"version": "4.23.0",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.23.0.tgz",
-			"integrity": "sha512-+bxqx+V/D4FGrpXzPGKp/SEZIZ8cIW3K7wOtcJAoCrmXvzRtmdUhYNbgd+RztLzfDEfA2WtKj5F4tcbNPuqgeg==",
+			"version": "4.22.4",
+			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.22.4.tgz",
+			"integrity": "sha512-GqFJ9wLlbB9daxhVlrTe61vJtEY99/xB3C8e4ULVsVfflcpmR6c8UZXjtkMA6FhNONhj2eA5Tk9uAVw5orEs4Q==",
 			"cpu": [
 				"s390x"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
 			]
 		},
 		"node_modules/@rollup/rollup-linux-x64-gnu": {
-			"version": "4.23.0",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.23.0.tgz",
-			"integrity": "sha512-I/eXsdVoCKtSgK9OwyQKPAfricWKUMNCwJKtatRYMmDo5N859tbO3UsBw5kT3dU1n6ZcM1JDzPRSGhAUkxfLxw==",
+			"version": "4.22.4",
+			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.22.4.tgz",
+			"integrity": "sha512-87v0ol2sH9GE3cLQLNEy0K/R0pz1nvg76o8M5nhMR0+Q+BBGLnb35P0fVz4CQxHYXaAOhE8HhlkaZfsdUOlHwg==",
 			"cpu": [
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
 			]
 		},
 		"node_modules/@rollup/rollup-linux-x64-musl": {
-			"version": "4.23.0",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.23.0.tgz",
-			"integrity": "sha512-4ZoDZy5ShLbbe1KPSafbFh1vbl0asTVfkABC7eWqIs01+66ncM82YJxV2VtV3YVJTqq2P8HMx3DCoRSWB/N3rw==",
+			"version": "4.22.4",
+			"resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.22.4.tgz",
+			"integrity": "sha512-UV6FZMUgePDZrFjrNGIWzDo/vABebuXBhJEqrHxrGiU6HikPy0Z3LfdtciIttEUQfuDdCn8fqh7wiFJjCNwO+g==",
 			"cpu": [
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
 			]
 		},
 		"node_modules/@rollup/rollup-win32-arm64-msvc": {
-			"version": "4.23.0",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.23.0.tgz",
-			"integrity": "sha512-+5Ky8dhft4STaOEbZu3/NU4QIyYssKO+r1cD3FzuusA0vO5gso15on7qGzKdNXnc1gOrsgCqZjRw1w+zL4y4hQ==",
+			"version": "4.22.4",
+			"resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.22.4.tgz",
+			"integrity": "sha512-BjI+NVVEGAXjGWYHz/vv0pBqfGoUH0IGZ0cICTn7kB9PyjrATSkX+8WkguNjWoj2qSr1im/+tTGRaY+4/PdcQw==",
 			"cpu": [
 				"arm64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"win32"
 			]
 		},
 		"node_modules/@rollup/rollup-win32-ia32-msvc": {
-			"version": "4.23.0",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.23.0.tgz",
-			"integrity": "sha512-0SPJk4cPZQhq9qA1UhIRumSE3+JJIBBjtlGl5PNC///BoaByckNZd53rOYD0glpTkYFBQSt7AkMeLVPfx65+BQ==",
+			"version": "4.22.4",
+			"resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.22.4.tgz",
+			"integrity": "sha512-SiWG/1TuUdPvYmzmYnmd3IEifzR61Tragkbx9D3+R8mzQqDBz8v+BvZNDlkiTtI9T15KYZhP0ehn3Dld4n9J5g==",
 			"cpu": [
 				"ia32"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"win32"
 			]
 		},
 		"node_modules/@rollup/rollup-win32-x64-msvc": {
-			"version": "4.23.0",
-			"resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.23.0.tgz",
-			"integrity": "sha512-lqCK5GQC8fNo0+JvTSxcG7YB1UKYp8yrNLhsArlvPWN+16ovSZgoehlVHg6X0sSWPUkpjRBR5TuR12ZugowZ4g==",
+			"version": "4.22.4",
+			"resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.22.4.tgz",
+			"integrity": "sha512-j8pPKp53/lq9lMXN57S8cFz0MynJk8OWNuUnXct/9KCpKU7DgU3bYMJhwWmcqC0UU29p8Lr0/7KEVcaM6bf47Q==",
 			"cpu": [
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"win32"
@@ -5191,96 +5540,294 @@
 				"@daybrush/utils": "^1.4.0"
 			}
 		},
-		"node_modules/@schematics/angular": {
-			"version": "18.2.1",
-			"resolved": "https://registry.npmjs.org/@schematics/angular/-/angular-18.2.1.tgz",
-			"integrity": "sha512-bBV7I+MCbdQmBPUFF4ECg37VReM0+AdQsxgwkjBBSYExmkErkDoDgKquwL/tH7stDCc5IfTd0g9BMeosRgDMug==",
+		"node_modules/@schematics/angular": {
+			"version": "18.2.6",
+			"resolved": "https://registry.npmjs.org/@schematics/angular/-/angular-18.2.6.tgz",
+			"integrity": "sha512-Y988EoOEQDLEyHu3414T6AeVUyx21AexBHQNbUNQkK8cxlxyB6m1eH1cx6vFgLRFUTsLVv+C6Ln/ICNTfLcG4A==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@angular-devkit/core": "18.2.6",
+				"@angular-devkit/schematics": "18.2.6",
+				"jsonc-parser": "3.3.1"
+			},
+			"engines": {
+				"node": "^18.19.1 || ^20.11.1 || >=22.0.0",
+				"npm": "^6.11.0 || ^7.5.6 || >=8.0.0",
+				"yarn": ">= 1.13.0"
+			}
+		},
+		"node_modules/@sideway/address": {
+			"version": "4.1.5",
+			"resolved": "https://registry.npmjs.org/@sideway/address/-/address-4.1.5.tgz",
+			"integrity": "sha512-IqO/DUQHUkPeixNQ8n0JA6102hT9CmaljNTPmQ1u8MEhBo/R4Q8eKLN/vGZxuebwOroDB4cbpjheD4+/sKFK4Q==",
+			"dev": true,
+			"license": "BSD-3-Clause",
+			"dependencies": {
+				"@hapi/hoek": "^9.0.0"
+			}
+		},
+		"node_modules/@sideway/formula": {
+			"version": "3.0.1",
+			"resolved": "https://registry.npmjs.org/@sideway/formula/-/formula-3.0.1.tgz",
+			"integrity": "sha512-/poHZJJVjx3L+zVD6g9KgHfYnb443oi7wLu/XKojDviHy6HOEOA6z1Trk5aR1dGcmPenJEgb2sK2I80LeS3MIg==",
+			"dev": true,
+			"license": "BSD-3-Clause"
+		},
+		"node_modules/@sideway/pinpoint": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/@sideway/pinpoint/-/pinpoint-2.0.0.tgz",
+			"integrity": "sha512-RNiOoTPkptFtSVzQevY/yWtZwf/RxyVnPy/OcA9HBM3MlGDnBEYL5B41H0MTn0Uec8Hi+2qUtTfG2WWZBmMejQ==",
+			"dev": true,
+			"license": "BSD-3-Clause"
+		},
+		"node_modules/@sigstore/bundle": {
+			"version": "2.3.2",
+			"resolved": "https://registry.npmjs.org/@sigstore/bundle/-/bundle-2.3.2.tgz",
+			"integrity": "sha512-wueKWDk70QixNLB363yHc2D2ItTgYiMTdPwK8D9dKQMR3ZQ0c35IxP5xnwQ8cNLoCgCRcHf14kE+CLIvNX1zmA==",
+			"dev": true,
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@sigstore/protobuf-specs": "^0.3.2"
+			},
+			"engines": {
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/@sigstore/core": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/@sigstore/core/-/core-1.1.0.tgz",
+			"integrity": "sha512-JzBqdVIyqm2FRQCulY6nbQzMpJJpSiJ8XXWMhtOX9eKgaXXpfNOF53lzQEjIydlStnd/eFtuC1dW4VYdD93oRg==",
+			"dev": true,
+			"license": "Apache-2.0",
+			"engines": {
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/@sigstore/protobuf-specs": {
+			"version": "0.3.2",
+			"resolved": "https://registry.npmjs.org/@sigstore/protobuf-specs/-/protobuf-specs-0.3.2.tgz",
+			"integrity": "sha512-c6B0ehIWxMI8wiS/bj6rHMPqeFvngFV7cDU/MY+B16P9Z3Mp9k8L93eYZ7BYzSickzuqAQqAq0V956b3Ju6mLw==",
+			"dev": true,
+			"license": "Apache-2.0",
+			"engines": {
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/@sigstore/sign": {
+			"version": "2.3.2",
+			"resolved": "https://registry.npmjs.org/@sigstore/sign/-/sign-2.3.2.tgz",
+			"integrity": "sha512-5Vz5dPVuunIIvC5vBb0APwo7qKA4G9yM48kPWJT+OEERs40md5GoUR1yedwpekWZ4m0Hhw44m6zU+ObsON+iDA==",
+			"dev": true,
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@sigstore/bundle": "^2.3.2",
+				"@sigstore/core": "^1.0.0",
+				"@sigstore/protobuf-specs": "^0.3.2",
+				"make-fetch-happen": "^13.0.1",
+				"proc-log": "^4.2.0",
+				"promise-retry": "^2.0.1"
+			},
+			"engines": {
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/@sigstore/sign/node_modules/@npmcli/fs": {
+			"version": "3.1.1",
+			"resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-3.1.1.tgz",
+			"integrity": "sha512-q9CRWjpHCMIh5sVyefoD1cA7PkvILqCZsnSOEUUivORLjxCO/Irmue2DprETiNgEqktDBZaM1Bi+jrarx1XdCg==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"semver": "^7.3.5"
+			},
+			"engines": {
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+			}
+		},
+		"node_modules/@sigstore/sign/node_modules/cacache": {
+			"version": "18.0.4",
+			"resolved": "https://registry.npmjs.org/cacache/-/cacache-18.0.4.tgz",
+			"integrity": "sha512-B+L5iIa9mgcjLbliir2th36yEwPftrzteHYujzsx3dFP/31GCHcIeS8f5MGd80odLOjaOvSpU3EEAmRQptkxLQ==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"@npmcli/fs": "^3.1.0",
+				"fs-minipass": "^3.0.0",
+				"glob": "^10.2.2",
+				"lru-cache": "^10.0.1",
+				"minipass": "^7.0.3",
+				"minipass-collect": "^2.0.1",
+				"minipass-flush": "^1.0.5",
+				"minipass-pipeline": "^1.2.4",
+				"p-map": "^4.0.0",
+				"ssri": "^10.0.0",
+				"tar": "^6.1.11",
+				"unique-filename": "^3.0.0"
+			},
+			"engines": {
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/@sigstore/sign/node_modules/fs-minipass": {
+			"version": "3.0.3",
+			"resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-3.0.3.tgz",
+			"integrity": "sha512-XUBA9XClHbnJWSfBzjkm6RvPsyg3sryZt06BEQoXcF7EK/xpGaQYJgQKDJSUH5SGZ76Y7pFx1QBnXz09rU5Fbw==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"minipass": "^7.0.3"
+			},
+			"engines": {
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+			}
+		},
+		"node_modules/@sigstore/sign/node_modules/glob": {
+			"version": "10.4.5",
+			"resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
+			"integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"foreground-child": "^3.1.0",
+				"jackspeak": "^3.1.2",
+				"minimatch": "^9.0.4",
+				"minipass": "^7.1.2",
+				"package-json-from-dist": "^1.0.0",
+				"path-scurry": "^1.11.1"
+			},
+			"bin": {
+				"glob": "dist/esm/bin.mjs"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/isaacs"
+			}
+		},
+		"node_modules/@sigstore/sign/node_modules/lru-cache": {
+			"version": "10.4.3",
+			"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+			"integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+			"dev": true,
+			"license": "ISC"
+		},
+		"node_modules/@sigstore/sign/node_modules/make-fetch-happen": {
+			"version": "13.0.1",
+			"resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-13.0.1.tgz",
+			"integrity": "sha512-cKTUFc/rbKUd/9meOvgrpJ2WrNzymt6jfRDdwg5UCnVzv9dTpEj9JS5m3wtziXVCjluIXyL8pcaukYqezIzZQA==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"@npmcli/agent": "^2.0.0",
+				"cacache": "^18.0.0",
+				"http-cache-semantics": "^4.1.1",
+				"is-lambda": "^1.0.1",
+				"minipass": "^7.0.2",
+				"minipass-fetch": "^3.0.0",
+				"minipass-flush": "^1.0.5",
+				"minipass-pipeline": "^1.2.4",
+				"negotiator": "^0.6.3",
+				"proc-log": "^4.2.0",
+				"promise-retry": "^2.0.1",
+				"ssri": "^10.0.0"
+			},
+			"engines": {
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/@sigstore/sign/node_modules/minimatch": {
+			"version": "9.0.5",
+			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
+			"integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
 			"dev": true,
-			"license": "MIT",
+			"license": "ISC",
 			"dependencies": {
-				"@angular-devkit/core": "18.2.1",
-				"@angular-devkit/schematics": "18.2.1",
-				"jsonc-parser": "3.3.1"
+				"brace-expansion": "^2.0.1"
 			},
 			"engines": {
-				"node": "^18.19.1 || ^20.11.1 || >=22.0.0",
-				"npm": "^6.11.0 || ^7.5.6 || >=8.0.0",
-				"yarn": ">= 1.13.0"
+				"node": ">=16 || 14 >=14.17"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/isaacs"
 			}
 		},
-		"node_modules/@sideway/address": {
-			"version": "4.1.5",
-			"resolved": "https://registry.npmjs.org/@sideway/address/-/address-4.1.5.tgz",
-			"integrity": "sha512-IqO/DUQHUkPeixNQ8n0JA6102hT9CmaljNTPmQ1u8MEhBo/R4Q8eKLN/vGZxuebwOroDB4cbpjheD4+/sKFK4Q==",
+		"node_modules/@sigstore/sign/node_modules/minipass": {
+			"version": "7.1.2",
+			"resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
+			"integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
 			"dev": true,
-			"license": "BSD-3-Clause",
-			"dependencies": {
-				"@hapi/hoek": "^9.0.0"
+			"license": "ISC",
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
 			}
 		},
-		"node_modules/@sideway/formula": {
-			"version": "3.0.1",
-			"resolved": "https://registry.npmjs.org/@sideway/formula/-/formula-3.0.1.tgz",
-			"integrity": "sha512-/poHZJJVjx3L+zVD6g9KgHfYnb443oi7wLu/XKojDviHy6HOEOA6z1Trk5aR1dGcmPenJEgb2sK2I80LeS3MIg==",
-			"dev": true,
-			"license": "BSD-3-Clause"
-		},
-		"node_modules/@sideway/pinpoint": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/@sideway/pinpoint/-/pinpoint-2.0.0.tgz",
-			"integrity": "sha512-RNiOoTPkptFtSVzQevY/yWtZwf/RxyVnPy/OcA9HBM3MlGDnBEYL5B41H0MTn0Uec8Hi+2qUtTfG2WWZBmMejQ==",
+		"node_modules/@sigstore/sign/node_modules/minipass-collect": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/minipass-collect/-/minipass-collect-2.0.1.tgz",
+			"integrity": "sha512-D7V8PO9oaz7PWGLbCACuI1qEOsq7UKfLotx/C0Aet43fCUB/wfQ7DYeq2oR/svFJGYDHPr38SHATeaj/ZoKHKw==",
 			"dev": true,
-			"license": "BSD-3-Clause"
+			"license": "ISC",
+			"dependencies": {
+				"minipass": "^7.0.3"
+			},
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
+			}
 		},
-		"node_modules/@sigstore/bundle": {
-			"version": "2.3.2",
-			"resolved": "https://registry.npmjs.org/@sigstore/bundle/-/bundle-2.3.2.tgz",
-			"integrity": "sha512-wueKWDk70QixNLB363yHc2D2ItTgYiMTdPwK8D9dKQMR3ZQ0c35IxP5xnwQ8cNLoCgCRcHf14kE+CLIvNX1zmA==",
+		"node_modules/@sigstore/sign/node_modules/minipass-fetch": {
+			"version": "3.0.5",
+			"resolved": "https://registry.npmjs.org/minipass-fetch/-/minipass-fetch-3.0.5.tgz",
+			"integrity": "sha512-2N8elDQAtSnFV0Dk7gt15KHsS0Fyz6CbYZ360h0WTYV1Ty46li3rAXVOQj1THMNLdmrD9Vt5pBPtWtVkpwGBqg==",
 			"dev": true,
-			"license": "Apache-2.0",
+			"license": "MIT",
 			"dependencies": {
-				"@sigstore/protobuf-specs": "^0.3.2"
+				"minipass": "^7.0.3",
+				"minipass-sized": "^1.0.3",
+				"minizlib": "^2.1.2"
 			},
 			"engines": {
-				"node": "^16.14.0 || >=18.0.0"
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+			},
+			"optionalDependencies": {
+				"encoding": "^0.1.13"
 			}
 		},
-		"node_modules/@sigstore/core": {
-			"version": "1.1.0",
-			"resolved": "https://registry.npmjs.org/@sigstore/core/-/core-1.1.0.tgz",
-			"integrity": "sha512-JzBqdVIyqm2FRQCulY6nbQzMpJJpSiJ8XXWMhtOX9eKgaXXpfNOF53lzQEjIydlStnd/eFtuC1dW4VYdD93oRg==",
+		"node_modules/@sigstore/sign/node_modules/ssri": {
+			"version": "10.0.6",
+			"resolved": "https://registry.npmjs.org/ssri/-/ssri-10.0.6.tgz",
+			"integrity": "sha512-MGrFH9Z4NP9Iyhqn16sDtBpRRNJ0Y2hNa6D65h736fVSaPCHr4DM4sWUNvVaSuC+0OBGhwsrydQwmgfg5LncqQ==",
 			"dev": true,
-			"license": "Apache-2.0",
+			"license": "ISC",
+			"dependencies": {
+				"minipass": "^7.0.3"
+			},
 			"engines": {
-				"node": "^16.14.0 || >=18.0.0"
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
 			}
 		},
-		"node_modules/@sigstore/protobuf-specs": {
-			"version": "0.3.2",
-			"resolved": "https://registry.npmjs.org/@sigstore/protobuf-specs/-/protobuf-specs-0.3.2.tgz",
-			"integrity": "sha512-c6B0ehIWxMI8wiS/bj6rHMPqeFvngFV7cDU/MY+B16P9Z3Mp9k8L93eYZ7BYzSickzuqAQqAq0V956b3Ju6mLw==",
+		"node_modules/@sigstore/sign/node_modules/unique-filename": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-3.0.0.tgz",
+			"integrity": "sha512-afXhuC55wkAmZ0P18QsVE6kp8JaxrEokN2HGIoIVv2ijHQd419H0+6EigAFcIzXeMIkcIkNBpB3L/DXB3cTS/g==",
 			"dev": true,
-			"license": "Apache-2.0",
+			"license": "ISC",
+			"dependencies": {
+				"unique-slug": "^4.0.0"
+			},
 			"engines": {
-				"node": "^16.14.0 || >=18.0.0"
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
 			}
 		},
-		"node_modules/@sigstore/sign": {
-			"version": "2.3.2",
-			"resolved": "https://registry.npmjs.org/@sigstore/sign/-/sign-2.3.2.tgz",
-			"integrity": "sha512-5Vz5dPVuunIIvC5vBb0APwo7qKA4G9yM48kPWJT+OEERs40md5GoUR1yedwpekWZ4m0Hhw44m6zU+ObsON+iDA==",
+		"node_modules/@sigstore/sign/node_modules/unique-slug": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-4.0.0.tgz",
+			"integrity": "sha512-WrcA6AyEfqDX5bWige/4NQfPZMtASNVxdmWR76WESYQVAACSgWcR6e9i0mofqqBxYFtL4oAxPIptY73/0YE1DQ==",
 			"dev": true,
-			"license": "Apache-2.0",
+			"license": "ISC",
 			"dependencies": {
-				"@sigstore/bundle": "^2.3.2",
-				"@sigstore/core": "^1.0.0",
-				"@sigstore/protobuf-specs": "^0.3.2",
-				"make-fetch-happen": "^13.0.1",
-				"proc-log": "^4.2.0",
-				"promise-retry": "^2.0.1"
+				"imurmurhash": "^0.1.4"
 			},
 			"engines": {
-				"node": "^16.14.0 || >=18.0.0"
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
 			}
 		},
 		"node_modules/@sigstore/tuf": {
@@ -5434,6 +5981,7 @@
 			"resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.5.tgz",
 			"integrity": "sha512-fB3Zu92ucau0iQ0JMCFQE7b/dv8Ot07NI3KaZIkIUNXq82k4eBAqUaneXfleGY9JWskeS9y+u0nXMyspcuQrCg==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@types/connect": "*",
 				"@types/node": "*"
@@ -5444,6 +5992,7 @@
 			"resolved": "https://registry.npmjs.org/@types/bonjour/-/bonjour-3.5.13.tgz",
 			"integrity": "sha512-z9fJ5Im06zvUL548KvYNecEVlA7cVDkGUi6kZusb04mpyEFKCIZJvloCcmpmLaIahDpOQGHaHmG6imtPMmPXGQ==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@types/node": "*"
 			}
@@ -5466,6 +6015,7 @@
 			"resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz",
 			"integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@types/node": "*"
 			}
@@ -5475,6 +6025,7 @@
 			"resolved": "https://registry.npmjs.org/@types/connect-history-api-fallback/-/connect-history-api-fallback-1.5.4.tgz",
 			"integrity": "sha512-n6Cr2xS1h4uAulPRdlw6Jl6s1oG8KrVilPN2yUITEs+K48EzMJJ3W1xy8K5eWuFvjp3R74AOIGSmp2UfBJ8HFw==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@types/express-serve-static-core": "*",
 				"@types/node": "*"
@@ -5491,9 +6042,9 @@
 			}
 		},
 		"node_modules/@types/eslint": {
-			"version": "9.6.0",
-			"resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-9.6.0.tgz",
-			"integrity": "sha512-gi6WQJ7cHRgZxtkQEoyHMppPjq9Kxo5Tjn2prSKDSmZrCz8TZ3jSRCeTJm+WoM+oB0WG37bRqLzaaU3q7JypGg==",
+			"version": "9.6.1",
+			"resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-9.6.1.tgz",
+			"integrity": "sha512-FXx2pKgId/WyYo2jXw63kk7/+TY7u7AziEJxJAnSFzHlqTAS3Ync6SvgYAN/k4/PQpnnVuzoMuVnByKK2qp0ag==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
@@ -5515,13 +6066,15 @@
 			"version": "1.0.6",
 			"resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.6.tgz",
 			"integrity": "sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/@types/express": {
 			"version": "4.17.21",
 			"resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.21.tgz",
 			"integrity": "sha512-ejlPM315qwLpaQlQDTjPdsUFSc6ZsP4AN6AlWnogPjQ7CVi7PYF3YVz+CY3jE2pwYf7E/7HlDAN0rV2GxTG0HQ==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@types/body-parser": "*",
 				"@types/express-serve-static-core": "^4.17.33",
@@ -5534,6 +6087,7 @@
 			"resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-5.0.0.tgz",
 			"integrity": "sha512-AbXMTZGt40T+KON9/Fdxx0B2WK5hsgxcfXJLr5bFpZ7b4JCex2WyQPTEKdXqfHiY5nKKBScZ7yCoO6Pvgxfvnw==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@types/node": "*",
 				"@types/qs": "*",
@@ -5546,6 +6100,7 @@
 			"resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.19.6.tgz",
 			"integrity": "sha512-N4LZ2xG7DatVqhCZzOGb1Yi5lMbXSZcmdLDe9EzSndPV2HpWYWzRbaerl2n27irrm94EPpprqa8KpskPT085+A==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@types/node": "*",
 				"@types/qs": "*",
@@ -5570,6 +6125,17 @@
 			"dev": true,
 			"license": "MIT"
 		},
+		"node_modules/@types/glob": {
+			"version": "7.2.0",
+			"resolved": "https://registry.npmjs.org/@types/glob/-/glob-7.2.0.tgz",
+			"integrity": "sha512-ZUxbzKl0IfJILTS6t7ip5fQQM/J3TJYubDm3nMbgubNNYS62eXeUpoLUC8/7fJNiFYHTrGPQn7hspDUzIHX3UA==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@types/minimatch": "*",
+				"@types/node": "*"
+			}
+		},
 		"node_modules/@types/http-cache-semantics": {
 			"version": "4.0.4",
 			"resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.0.4.tgz",
@@ -5581,7 +6147,8 @@
 			"version": "2.0.4",
 			"resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.4.tgz",
 			"integrity": "sha512-D0CFMMtydbJAegzOyHjtiKPLlvnm3iTZyZRSZoLq2mRhDdmLfIWOCYPfQJ4cu2erKghU++QvjcUjp/5h7hESpA==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/@types/http-proxy": {
 			"version": "1.17.15",
@@ -5624,7 +6191,15 @@
 			"version": "1.3.5",
 			"resolved": "https://registry.npmjs.org/@types/mime/-/mime-1.3.5.tgz",
 			"integrity": "sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
+		},
+		"node_modules/@types/minimatch": {
+			"version": "5.1.2",
+			"resolved": "https://registry.npmjs.org/@types/minimatch/-/minimatch-5.1.2.tgz",
+			"integrity": "sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA==",
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/@types/ms": {
 			"version": "0.7.34",
@@ -5644,9 +6219,9 @@
 			}
 		},
 		"node_modules/@types/node": {
-			"version": "22.5.0",
-			"resolved": "https://registry.npmjs.org/@types/node/-/node-22.5.0.tgz",
-			"integrity": "sha512-DkFrJOe+rfdHTqqMg0bSNlGlQ85hSoh2TPzZyhHsXnMtligRWpxUySiyw8FY14ITt24HVCiQPWxS3KO/QlGmWg==",
+			"version": "22.7.4",
+			"resolved": "https://registry.npmjs.org/@types/node/-/node-22.7.4.tgz",
+			"integrity": "sha512-y+NPi1rFzDs1NdQHHToqeiX2TIS79SWEAw9GYhkkx8bD0ChpfqC+n2j5OXOCpzfojBEBt6DnEnnG9MY0zk1XLg==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
@@ -5658,6 +6233,7 @@
 			"resolved": "https://registry.npmjs.org/@types/node-forge/-/node-forge-1.3.11.tgz",
 			"integrity": "sha512-FQx220y22OKNTqaByeBGqHWYz4cl94tpcxeFdvBo3wjG6XPBuZ0BNgNZRV5J5TFmmcsJ4IzsLkmGRiQbnYsBEQ==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@types/node": "*"
 			}
@@ -5678,13 +6254,15 @@
 			"version": "6.9.16",
 			"resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.9.16.tgz",
 			"integrity": "sha512-7i+zxXdPD0T4cKDuxCUXJ4wHcsJLwENa6Z3dCu8cfCK743OGy5Nu1RmAGqDPsoTDINVEcdXKRvR/zre+P2Ku1A==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/@types/range-parser": {
 			"version": "1.2.7",
 			"resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.7.tgz",
 			"integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/@types/responselike": {
 			"version": "1.0.3",
@@ -5700,13 +6278,15 @@
 			"version": "0.12.2",
 			"resolved": "https://registry.npmjs.org/@types/retry/-/retry-0.12.2.tgz",
 			"integrity": "sha512-XISRgDJ2Tc5q4TRqvgJtzsRkFYNJzZrhTdtMoGVBttwzzQJkPnS3WWTFc7kuDRoPtPakl+T+OfdEUjYJj7Jbow==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/@types/send": {
 			"version": "0.17.4",
 			"resolved": "https://registry.npmjs.org/@types/send/-/send-0.17.4.tgz",
 			"integrity": "sha512-x2EM6TJOybec7c52BX0ZspPodMsQUd5L6PRwOunVyVUhXiBSKf3AezDL8Dgvgt5o0UfKNfuA0eMLr2wLT4AiBA==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@types/mime": "^1",
 				"@types/node": "*"
@@ -5717,6 +6297,7 @@
 			"resolved": "https://registry.npmjs.org/@types/serve-index/-/serve-index-1.9.4.tgz",
 			"integrity": "sha512-qLpGZ/c2fhSs5gnYsQxtDEq3Oy8SXPClIXkW5ghvAvsNuVSA8k+gCONcUCS/UjLEYvYps+e8uBtfgXgvhwfNug==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@types/express": "*"
 			}
@@ -5726,6 +6307,7 @@
 			"resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.7.tgz",
 			"integrity": "sha512-W8Ym+h8nhuRwaKPaDw34QUkwsGi6Rc4yYqvKFo5rm2FUEhCFbzVWrxXUxuKK8TASjWsysJY0nsmNCGhCOIsrOw==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@types/http-errors": "*",
 				"@types/node": "*",
@@ -5737,6 +6319,7 @@
 			"resolved": "https://registry.npmjs.org/@types/sockjs/-/sockjs-0.3.36.tgz",
 			"integrity": "sha512-MK9V6NzAS1+Ud7JV9lJLFqW85VbC9dq3LmwZCuBe4wBDgKC0Kj/jd8Xl+nSviU+Qc3+m7umHHyHg//2KSa0a0Q==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@types/node": "*"
 			}
@@ -5761,6 +6344,7 @@
 			"resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.5.12.tgz",
 			"integrity": "sha512-3tPRkv1EtkDpzlgyKyI8pGsGZAGPEaXeu0DOj5DI25Ja91bdAYddYHbADRYVrZMRbfW+1l5YwXVDKohDJNQxkQ==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@types/node": "*"
 			}
@@ -5777,17 +6361,17 @@
 			}
 		},
 		"node_modules/@typescript-eslint/eslint-plugin": {
-			"version": "8.2.0",
-			"resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.2.0.tgz",
-			"integrity": "sha512-02tJIs655em7fvt9gps/+4k4OsKULYGtLBPJfOsmOq1+3cdClYiF0+d6mHu6qDnTcg88wJBkcPLpQhq7FyDz0A==",
+			"version": "8.8.0",
+			"resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.8.0.tgz",
+			"integrity": "sha512-wORFWjU30B2WJ/aXBfOm1LX9v9nyt9D3jsSOxC3cCaTQGCW5k4jNpmjFv3U7p/7s4yvdjHzwtv2Sd2dOyhjS0A==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"@eslint-community/regexpp": "^4.10.0",
-				"@typescript-eslint/scope-manager": "8.2.0",
-				"@typescript-eslint/type-utils": "8.2.0",
-				"@typescript-eslint/utils": "8.2.0",
-				"@typescript-eslint/visitor-keys": "8.2.0",
+				"@typescript-eslint/scope-manager": "8.8.0",
+				"@typescript-eslint/type-utils": "8.8.0",
+				"@typescript-eslint/utils": "8.8.0",
+				"@typescript-eslint/visitor-keys": "8.8.0",
 				"graphemer": "^1.4.0",
 				"ignore": "^5.3.1",
 				"natural-compare": "^1.4.0",
@@ -5811,16 +6395,16 @@
 			}
 		},
 		"node_modules/@typescript-eslint/parser": {
-			"version": "8.2.0",
-			"resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.2.0.tgz",
-			"integrity": "sha512-j3Di+o0lHgPrb7FxL3fdEy6LJ/j2NE8u+AP/5cQ9SKb+JLH6V6UHDqJ+e0hXBkHP1wn1YDFjYCS9LBQsZDlDEg==",
+			"version": "8.8.0",
+			"resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.8.0.tgz",
+			"integrity": "sha512-uEFUsgR+tl8GmzmLjRqz+VrDv4eoaMqMXW7ruXfgThaAShO9JTciKpEsB+TvnfFfbg5IpujgMXVV36gOJRLtZg==",
 			"dev": true,
 			"license": "BSD-2-Clause",
 			"dependencies": {
-				"@typescript-eslint/scope-manager": "8.2.0",
-				"@typescript-eslint/types": "8.2.0",
-				"@typescript-eslint/typescript-estree": "8.2.0",
-				"@typescript-eslint/visitor-keys": "8.2.0",
+				"@typescript-eslint/scope-manager": "8.8.0",
+				"@typescript-eslint/types": "8.8.0",
+				"@typescript-eslint/typescript-estree": "8.8.0",
+				"@typescript-eslint/visitor-keys": "8.8.0",
 				"debug": "^4.3.4"
 			},
 			"engines": {
@@ -5840,14 +6424,14 @@
 			}
 		},
 		"node_modules/@typescript-eslint/scope-manager": {
-			"version": "8.2.0",
-			"resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.2.0.tgz",
-			"integrity": "sha512-OFn80B38yD6WwpoHU2Tz/fTz7CgFqInllBoC3WP+/jLbTb4gGPTy9HBSTsbDWkMdN55XlVU0mMDYAtgvlUspGw==",
+			"version": "8.8.0",
+			"resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.8.0.tgz",
+			"integrity": "sha512-EL8eaGC6gx3jDd8GwEFEV091210U97J0jeEHrAYvIYosmEGet4wJ+g0SYmLu+oRiAwbSA5AVrt6DxLHfdd+bUg==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@typescript-eslint/types": "8.2.0",
-				"@typescript-eslint/visitor-keys": "8.2.0"
+				"@typescript-eslint/types": "8.8.0",
+				"@typescript-eslint/visitor-keys": "8.8.0"
 			},
 			"engines": {
 				"node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -5858,14 +6442,14 @@
 			}
 		},
 		"node_modules/@typescript-eslint/type-utils": {
-			"version": "8.2.0",
-			"resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.2.0.tgz",
-			"integrity": "sha512-g1CfXGFMQdT5S+0PSO0fvGXUaiSkl73U1n9LTK5aRAFnPlJ8dLKkXr4AaLFvPedW8lVDoMgLLE3JN98ZZfsj0w==",
+			"version": "8.8.0",
+			"resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.8.0.tgz",
+			"integrity": "sha512-IKwJSS7bCqyCeG4NVGxnOP6lLT9Okc3Zj8hLO96bpMkJab+10HIfJbMouLrlpyOr3yrQ1cA413YPFiGd1mW9/Q==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@typescript-eslint/typescript-estree": "8.2.0",
-				"@typescript-eslint/utils": "8.2.0",
+				"@typescript-eslint/typescript-estree": "8.8.0",
+				"@typescript-eslint/utils": "8.8.0",
 				"debug": "^4.3.4",
 				"ts-api-utils": "^1.3.0"
 			},
@@ -5883,9 +6467,9 @@
 			}
 		},
 		"node_modules/@typescript-eslint/types": {
-			"version": "8.2.0",
-			"resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.2.0.tgz",
-			"integrity": "sha512-6a9QSK396YqmiBKPkJtxsgZZZVjYQ6wQ/TlI0C65z7vInaETuC6HAHD98AGLC8DyIPqHytvNuS8bBVvNLKyqvQ==",
+			"version": "8.8.0",
+			"resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.8.0.tgz",
+			"integrity": "sha512-QJwc50hRCgBd/k12sTykOJbESe1RrzmX6COk8Y525C9l7oweZ+1lw9JiU56im7Amm8swlz00DRIlxMYLizr2Vw==",
 			"dev": true,
 			"license": "MIT",
 			"engines": {
@@ -5897,16 +6481,16 @@
 			}
 		},
 		"node_modules/@typescript-eslint/typescript-estree": {
-			"version": "8.2.0",
-			"resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.2.0.tgz",
-			"integrity": "sha512-kiG4EDUT4dImplOsbh47B1QnNmXSoUqOjWDvCJw/o8LgfD0yr7k2uy54D5Wm0j4t71Ge1NkynGhpWdS0dEIAUA==",
+			"version": "8.8.0",
+			"resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.8.0.tgz",
+			"integrity": "sha512-ZaMJwc/0ckLz5DaAZ+pNLmHv8AMVGtfWxZe/x2JVEkD5LnmhWiQMMcYT7IY7gkdJuzJ9P14fRy28lUrlDSWYdw==",
 			"dev": true,
 			"license": "BSD-2-Clause",
 			"dependencies": {
-				"@typescript-eslint/types": "8.2.0",
-				"@typescript-eslint/visitor-keys": "8.2.0",
+				"@typescript-eslint/types": "8.8.0",
+				"@typescript-eslint/visitor-keys": "8.8.0",
 				"debug": "^4.3.4",
-				"globby": "^11.1.0",
+				"fast-glob": "^3.3.2",
 				"is-glob": "^4.0.3",
 				"minimatch": "^9.0.4",
 				"semver": "^7.6.0",
@@ -5925,27 +6509,6 @@
 				}
 			}
 		},
-		"node_modules/@typescript-eslint/typescript-estree/node_modules/globby": {
-			"version": "11.1.0",
-			"resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz",
-			"integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"array-union": "^2.1.0",
-				"dir-glob": "^3.0.1",
-				"fast-glob": "^3.2.9",
-				"ignore": "^5.2.0",
-				"merge2": "^1.4.1",
-				"slash": "^3.0.0"
-			},
-			"engines": {
-				"node": ">=10"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/sindresorhus"
-			}
-		},
 		"node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch": {
 			"version": "9.0.5",
 			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
@@ -5962,27 +6525,17 @@
 				"url": "https://github.com/sponsors/isaacs"
 			}
 		},
-		"node_modules/@typescript-eslint/typescript-estree/node_modules/slash": {
-			"version": "3.0.0",
-			"resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz",
-			"integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=8"
-			}
-		},
 		"node_modules/@typescript-eslint/utils": {
-			"version": "8.2.0",
-			"resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.2.0.tgz",
-			"integrity": "sha512-O46eaYKDlV3TvAVDNcoDzd5N550ckSe8G4phko++OCSC1dYIb9LTc3HDGYdWqWIAT5qDUKphO6sd9RrpIJJPfg==",
+			"version": "8.8.0",
+			"resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.8.0.tgz",
+			"integrity": "sha512-QE2MgfOTem00qrlPgyByaCHay9yb1+9BjnMFnSFkUKQfu7adBXDTnCAivURnuPPAG/qiB+kzKkZKmKfaMT0zVg==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"@eslint-community/eslint-utils": "^4.4.0",
-				"@typescript-eslint/scope-manager": "8.2.0",
-				"@typescript-eslint/types": "8.2.0",
-				"@typescript-eslint/typescript-estree": "8.2.0"
+				"@typescript-eslint/scope-manager": "8.8.0",
+				"@typescript-eslint/types": "8.8.0",
+				"@typescript-eslint/typescript-estree": "8.8.0"
 			},
 			"engines": {
 				"node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -5996,13 +6549,13 @@
 			}
 		},
 		"node_modules/@typescript-eslint/visitor-keys": {
-			"version": "8.2.0",
-			"resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.2.0.tgz",
-			"integrity": "sha512-sbgsPMW9yLvS7IhCi8IpuK1oBmtbWUNP+hBdwl/I9nzqVsszGnNGti5r9dUtF5RLivHUFFIdRvLiTsPhzSyJ3Q==",
+			"version": "8.8.0",
+			"resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.8.0.tgz",
+			"integrity": "sha512-8mq51Lx6Hpmd7HnA2fcHQo3YgfX1qbccxQOgZcb4tvasu//zXRaA1j5ZRFeCw/VRAdFi4mRM9DnZw0Nu0Q2d1g==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@typescript-eslint/types": "8.2.0",
+				"@typescript-eslint/types": "8.8.0",
 				"eslint-visitor-keys": "^3.4.3"
 			},
 			"engines": {
@@ -6031,6 +6584,7 @@
 			"resolved": "https://registry.npmjs.org/@vitejs/plugin-basic-ssl/-/plugin-basic-ssl-1.1.0.tgz",
 			"integrity": "sha512-wO4Dk/rm8u7RNhOf95ZzcEmC9rYOncYgvq4z3duaJrCgjN8BxAnDVyndanfcJZ0O6XZzHz6Q0hTimxTg8Y9g/A==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">=14.6.0"
 			},
@@ -6238,14 +6792,11 @@
 			"license": "MIT"
 		},
 		"node_modules/abbrev": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/abbrev/-/abbrev-2.0.0.tgz",
-			"integrity": "sha512-6/mh1E2u2YgEsCHdY0Yx5oW+61gZU+1vXaoiHHrpKeuRNNgFvS+/jrwHiQhB5apAf5oB7UB7E19ol2R2LKH8hQ==",
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz",
+			"integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==",
 			"dev": true,
-			"license": "ISC",
-			"engines": {
-				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
-			}
+			"license": "ISC"
 		},
 		"node_modules/abort-controller": {
 			"version": "3.0.0",
@@ -6265,6 +6816,7 @@
 			"resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
 			"integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"mime-types": "~2.1.34",
 				"negotiator": "0.6.3"
@@ -6307,9 +6859,9 @@
 			}
 		},
 		"node_modules/acorn-walk": {
-			"version": "8.3.3",
-			"resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.3.tgz",
-			"integrity": "sha512-MxXdReSRhGO7VlFe1bRG/oI7/mdLV9B9JJT0N8vZOhF7gFRR5l3M8W9G8JxmKV+JC5mGqJ0QvqfSOLsCPa4nUw==",
+			"version": "8.3.4",
+			"resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.4.tgz",
+			"integrity": "sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
@@ -6361,6 +6913,19 @@
 				"node": ">= 6.0.0"
 			}
 		},
+		"node_modules/agentkeepalive": {
+			"version": "4.5.0",
+			"resolved": "https://registry.npmjs.org/agentkeepalive/-/agentkeepalive-4.5.0.tgz",
+			"integrity": "sha512-5GG/5IbQQpC9FpkRGsSvZI5QYeSCzlJHdpBQntCsuTOxhKD8lqKhrleg2Yi7yvMIf82Ycmmqln9U8V9qwEiJew==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"humanize-ms": "^1.2.1"
+			},
+			"engines": {
+				"node": ">= 8.0.0"
+			}
+		},
 		"node_modules/aggregate-error": {
 			"version": "3.1.0",
 			"resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.1.0.tgz",
@@ -6466,6 +7031,7 @@
 			"engines": [
 				"node >= 0.8.0"
 			],
+			"license": "Apache-2.0",
 			"bin": {
 				"ansi-html": "bin/ansi-html"
 			}
@@ -6521,33 +7087,34 @@
 			}
 		},
 		"node_modules/app-builder-bin": {
-			"version": "4.0.0",
-			"resolved": "https://registry.npmjs.org/app-builder-bin/-/app-builder-bin-4.0.0.tgz",
-			"integrity": "sha512-xwdG0FJPQMe0M0UA4Tz0zEB8rBJTRA5a476ZawAqiBkMv16GRK5xpXThOjMaEOFnZ6zabejjG4J3da0SXG63KA==",
+			"version": "5.0.0-alpha.7",
+			"resolved": "https://registry.npmjs.org/app-builder-bin/-/app-builder-bin-5.0.0-alpha.7.tgz",
+			"integrity": "sha512-ww2mK4ITUvqisnqOuUWAeHzokpPidyZ7a0ZkwW+V7sF5/Pdi2OldkRjAWqEzn6Xtmj3SLVT84as4wB59A6jJ4g==",
 			"dev": true,
 			"license": "MIT"
 		},
 		"node_modules/app-builder-lib": {
-			"version": "24.13.3",
-			"resolved": "https://registry.npmjs.org/app-builder-lib/-/app-builder-lib-24.13.3.tgz",
-			"integrity": "sha512-FAzX6IBit2POXYGnTCT8YHFO/lr5AapAII6zzhQO3Rw4cEDOgK+t1xhLc5tNcKlicTHlo9zxIwnYCX9X2DLkig==",
+			"version": "25.0.5",
+			"resolved": "https://registry.npmjs.org/app-builder-lib/-/app-builder-lib-25.0.5.tgz",
+			"integrity": "sha512-rxgxMx1f7I4ZAP0jA5+5iB7X6x6MJvGF7GauRzQBnIVihwXX2HOiAE7yenyY9Ry5YAiH47MnCxdq413Wq6XOcQ==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"@develar/schema-utils": "~2.6.5",
-				"@electron/notarize": "2.2.1",
-				"@electron/osx-sign": "1.0.5",
-				"@electron/universal": "1.5.1",
+				"@electron/notarize": "2.3.2",
+				"@electron/osx-sign": "1.3.1",
+				"@electron/rebuild": "3.6.0",
+				"@electron/universal": "2.0.1",
 				"@malept/flatpak-bundler": "^0.4.0",
 				"@types/fs-extra": "9.0.13",
 				"async-exit-hook": "^2.0.1",
 				"bluebird-lst": "^1.0.9",
-				"builder-util": "24.13.1",
-				"builder-util-runtime": "9.2.4",
+				"builder-util": "25.0.3",
+				"builder-util-runtime": "9.2.5",
 				"chromium-pickle-js": "^0.2.0",
 				"debug": "^4.3.4",
 				"ejs": "^3.1.8",
-				"electron-publish": "24.13.1",
+				"electron-publish": "25.0.3",
 				"form-data": "^4.0.0",
 				"fs-extra": "^10.1.0",
 				"hosted-git-info": "^4.1.0",
@@ -6555,8 +7122,9 @@
 				"isbinaryfile": "^5.0.0",
 				"js-yaml": "^4.1.0",
 				"lazy-val": "^1.0.5",
-				"minimatch": "^5.1.1",
-				"read-config-file": "6.3.2",
+				"minimatch": "^10.0.0",
+				"read-config-file": "6.4.0",
+				"resedit": "^1.7.0",
 				"sanitize-filename": "^1.6.3",
 				"semver": "^7.3.8",
 				"tar": "^6.1.12",
@@ -6566,8 +7134,8 @@
 				"node": ">=14.0.0"
 			},
 			"peerDependencies": {
-				"dmg-builder": "24.13.3",
-				"electron-builder-squirrel-windows": "24.13.3"
+				"dmg-builder": "25.0.5",
+				"electron-builder-squirrel-windows": "25.0.5"
 			}
 		},
 		"node_modules/app-builder-lib/node_modules/fs-extra": {
@@ -6608,6 +7176,13 @@
 				"node": ">= 10.0.0"
 			}
 		},
+		"node_modules/aproba": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/aproba/-/aproba-2.0.0.tgz",
+			"integrity": "sha512-lYe4Gx7QT+MKGbDsA+Z+he/Wtef0BiwDOlK/XkBrdfsh9J/jPPXbX0tE9x9cl27Tmu5gg3QUbUrQYa/y+KOHPQ==",
+			"dev": true,
+			"license": "ISC"
+		},
 		"node_modules/archiver": {
 			"version": "5.3.2",
 			"resolved": "https://registry.npmjs.org/archiver/-/archiver-5.3.2.tgz",
@@ -6695,6 +7270,21 @@
 				"safe-buffer": "~5.1.0"
 			}
 		},
+		"node_modules/are-we-there-yet": {
+			"version": "3.0.1",
+			"resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-3.0.1.tgz",
+			"integrity": "sha512-QZW4EDmGwlYur0Yyf/b2uGucHQMa8aFUP7eu9ddR73vvhFyt4V0Vl3QHPcTNJ8l6qYOBdxgXdnBXQrHilfRQBg==",
+			"deprecated": "This package is no longer supported.",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"delegates": "^1.0.0",
+				"readable-stream": "^3.6.0"
+			},
+			"engines": {
+				"node": "^12.13.0 || ^14.15.0 || >=16.0.0"
+			}
+		},
 		"node_modules/arg": {
 			"version": "4.1.3",
 			"resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz",
@@ -6730,17 +7320,8 @@
 			"version": "1.1.1",
 			"resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
 			"integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==",
-			"dev": true
-		},
-		"node_modules/array-union": {
-			"version": "2.1.0",
-			"resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz",
-			"integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==",
 			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=8"
-			}
+			"license": "MIT"
 		},
 		"node_modules/arraybuffer.prototype.slice": {
 			"version": "1.0.3",
@@ -6909,9 +7490,9 @@
 			}
 		},
 		"node_modules/axios": {
-			"version": "1.7.4",
-			"resolved": "https://registry.npmjs.org/axios/-/axios-1.7.4.tgz",
-			"integrity": "sha512-DukmaFRnY6AzAALSH4J2M3k6PkaC+MfaAGdEERRWcC9q3/TWQwLpHR8ZRLKTdQ3aBDL64EdluRDjJqKw+BPZEw==",
+			"version": "1.7.7",
+			"resolved": "https://registry.npmjs.org/axios/-/axios-1.7.7.tgz",
+			"integrity": "sha512-S4kL7XrjgBmvdGut0sN3yJxqYzrDOnivkBiN0OFs6hLiUam3UPvswUo0kqGyhqUZGEOytHyumEdXsAkgCOUf3Q==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
@@ -7022,7 +7603,8 @@
 			"version": "0.6.1",
 			"resolved": "https://registry.npmjs.org/batch/-/batch-0.6.1.tgz",
 			"integrity": "sha512-x+VAiMRL6UPkx+kudNvxTl6hB2XNNCG2r+7wixVfIYwu/2HKRXimwQyaumLjMveWvT2Hkd/cAJw+QBMfJ/EKVw==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/bezier-easing": {
 			"version": "2.1.0",
@@ -7094,6 +7676,7 @@
 			"resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz",
 			"integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"bytes": "3.1.2",
 				"content-type": "~1.0.5",
@@ -7118,6 +7701,7 @@
 			"resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
 			"integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.8"
 			}
@@ -7127,6 +7711,7 @@
 			"resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
 			"integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"ms": "2.0.0"
 			}
@@ -7136,6 +7721,7 @@
 			"resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
 			"integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"safer-buffer": ">= 2.1.2 < 3"
 			},
@@ -7147,13 +7733,15 @@
 			"version": "2.0.0",
 			"resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
 			"integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/bonjour-service": {
 			"version": "1.2.1",
 			"resolved": "https://registry.npmjs.org/bonjour-service/-/bonjour-service-1.2.1.tgz",
 			"integrity": "sha512-oSzCS2zV14bh2kji6vNe7vrpJYCHGvcZnlffFQ1MEoX/WOeQ/teD8SYWKR942OI3INjq8OMNJlbPK5LLLUxFDw==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"fast-deep-equal": "^3.1.3",
 				"multicast-dns": "^7.2.5"
@@ -7163,7 +7751,8 @@
 			"version": "1.0.0",
 			"resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz",
 			"integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==",
-			"dev": true
+			"dev": true,
+			"license": "ISC"
 		},
 		"node_modules/boolean": {
 			"version": "3.2.0",
@@ -7244,14 +7833,18 @@
 			}
 		},
 		"node_modules/browserify-rsa": {
-			"version": "4.1.0",
-			"resolved": "https://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.1.0.tgz",
-			"integrity": "sha512-AdEER0Hkspgno2aR97SAf6vi0y0k8NuOpGnVH3O99rcA5Q6sh8QxcngtHuJ6uXwnfAXNM4Gn1Gb7/MV1+Ymbog==",
+			"version": "4.1.1",
+			"resolved": "https://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.1.1.tgz",
+			"integrity": "sha512-YBjSAiTqM04ZVei6sXighu679a3SqWORA3qZTEqZImnlkDIFtKc6pNutpjyZ8RJTjQtuYfeetkxM11GwoYXMIQ==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"bn.js": "^5.0.0",
-				"randombytes": "^2.0.1"
+				"bn.js": "^5.2.1",
+				"randombytes": "^2.1.0",
+				"safe-buffer": "^5.2.1"
+			},
+			"engines": {
+				"node": ">= 0.10"
 			}
 		},
 		"node_modules/browserify-sign": {
@@ -7334,9 +7927,9 @@
 			}
 		},
 		"node_modules/browserslist": {
-			"version": "4.23.3",
-			"resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.23.3.tgz",
-			"integrity": "sha512-btwCFJVjI4YWDNfau8RhZ+B1Q/VLoUITrm3RlP6y1tYGWIOa+InuYiRGXUBXo8nA1qKmHMyLB/iVQg5TT4eFoA==",
+			"version": "4.24.0",
+			"resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.0.tgz",
+			"integrity": "sha512-Rmb62sR1Zpjql25eSanFGEhAxcFwfA1K0GuQcLoaJBAcENegrQut3hYdhXFF1obQfiDyqIW/cLM5HSJ/9k884A==",
 			"dev": true,
 			"funding": [
 				{
@@ -7354,8 +7947,8 @@
 			],
 			"license": "MIT",
 			"dependencies": {
-				"caniuse-lite": "^1.0.30001646",
-				"electron-to-chromium": "^1.5.4",
+				"caniuse-lite": "^1.0.30001663",
+				"electron-to-chromium": "^1.5.28",
 				"node-releases": "^2.0.18",
 				"update-browserslist-db": "^1.1.0"
 			},
@@ -7398,20 +7991,7 @@
 			"dev": true,
 			"license": "MIT",
 			"engines": {
-				"node": "*"
-			}
-		},
-		"node_modules/buffer-equal": {
-			"version": "1.0.1",
-			"resolved": "https://registry.npmjs.org/buffer-equal/-/buffer-equal-1.0.1.tgz",
-			"integrity": "sha512-QoV3ptgEaQpvVwbXdSO39iqPQTCxSF7A5U99AxbHYqUdCizL/lH2Z0A2y6nbZucxMEOtNyZfG2s6gsVugGpKkg==",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=0.4"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/ljharb"
+				"node": "*"
 			}
 		},
 		"node_modules/buffer-from": {
@@ -7429,17 +8009,17 @@
 			"license": "MIT"
 		},
 		"node_modules/builder-util": {
-			"version": "24.13.1",
-			"resolved": "https://registry.npmjs.org/builder-util/-/builder-util-24.13.1.tgz",
-			"integrity": "sha512-NhbCSIntruNDTOVI9fdXz0dihaqX2YuE1D6zZMrwiErzH4ELZHE6mdiB40wEgZNprDia+FghRFgKoAqMZRRjSA==",
+			"version": "25.0.3",
+			"resolved": "https://registry.npmjs.org/builder-util/-/builder-util-25.0.3.tgz",
+			"integrity": "sha512-eH5c1ukdY2xjtFQWQ6jlzEuXuqcuAVc3UQ6V6fdYu9Kg3CkDbCR82Mox42uaJDmee9WXSbP/88cOworFdOHPhw==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"@types/debug": "^4.1.6",
 				"7zip-bin": "~5.2.0",
-				"app-builder-bin": "4.0.0",
+				"app-builder-bin": "5.0.0-alpha.7",
 				"bluebird-lst": "^1.0.9",
-				"builder-util-runtime": "9.2.4",
+				"builder-util-runtime": "9.2.5",
 				"chalk": "^4.1.2",
 				"cross-spawn": "^7.0.3",
 				"debug": "^4.3.4",
@@ -7454,9 +8034,9 @@
 			}
 		},
 		"node_modules/builder-util-runtime": {
-			"version": "9.2.4",
-			"resolved": "https://registry.npmjs.org/builder-util-runtime/-/builder-util-runtime-9.2.4.tgz",
-			"integrity": "sha512-upp+biKpN/XZMLim7aguUyW8s0FUpDvOtK6sbanMFDAMBzpHDqdhgVYm6zc9HJ6nWo7u2Lxk60i2M6Jd3aiNrA==",
+			"version": "9.2.5",
+			"resolved": "https://registry.npmjs.org/builder-util-runtime/-/builder-util-runtime-9.2.5.tgz",
+			"integrity": "sha512-HjIDfhvqx/8B3TDN4GbABQcgpewTU4LMRTQPkVpKYV3lsuxEJoIfvg09GyWTNmfVNSUAYf+fbTN//JX4TH20pg==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
@@ -7607,6 +8187,7 @@
 			"resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.0.tgz",
 			"integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"run-applescript": "^7.0.0"
 			},
@@ -7622,76 +8203,83 @@
 			"resolved": "https://registry.npmjs.org/bytes/-/bytes-3.0.0.tgz",
 			"integrity": "sha512-pMhOfFDPiv9t5jjIXkHosWmkSyQbvsgEVNkz0ERHbuLh2T/7j4Mqqpz523Fe8MVY89KC6Sh/QfS2sM+SjgFDcw==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.8"
 			}
 		},
 		"node_modules/cacache": {
-			"version": "18.0.4",
-			"resolved": "https://registry.npmjs.org/cacache/-/cacache-18.0.4.tgz",
-			"integrity": "sha512-B+L5iIa9mgcjLbliir2th36yEwPftrzteHYujzsx3dFP/31GCHcIeS8f5MGd80odLOjaOvSpU3EEAmRQptkxLQ==",
+			"version": "16.1.3",
+			"resolved": "https://registry.npmjs.org/cacache/-/cacache-16.1.3.tgz",
+			"integrity": "sha512-/+Emcj9DAXxX4cwlLmRI9c166RuL3w30zp4R7Joiv2cQTtTtA+jeuCAjH3ZlGnYS3tKENSrKhAzVVP9GVyzeYQ==",
 			"dev": true,
 			"license": "ISC",
 			"dependencies": {
-				"@npmcli/fs": "^3.1.0",
-				"fs-minipass": "^3.0.0",
-				"glob": "^10.2.2",
-				"lru-cache": "^10.0.1",
-				"minipass": "^7.0.3",
-				"minipass-collect": "^2.0.1",
+				"@npmcli/fs": "^2.1.0",
+				"@npmcli/move-file": "^2.0.0",
+				"chownr": "^2.0.0",
+				"fs-minipass": "^2.1.0",
+				"glob": "^8.0.1",
+				"infer-owner": "^1.0.4",
+				"lru-cache": "^7.7.1",
+				"minipass": "^3.1.6",
+				"minipass-collect": "^1.0.2",
 				"minipass-flush": "^1.0.5",
 				"minipass-pipeline": "^1.2.4",
+				"mkdirp": "^1.0.4",
 				"p-map": "^4.0.0",
-				"ssri": "^10.0.0",
+				"promise-inflight": "^1.0.1",
+				"rimraf": "^3.0.2",
+				"ssri": "^9.0.0",
 				"tar": "^6.1.11",
-				"unique-filename": "^3.0.0"
+				"unique-filename": "^2.0.0"
 			},
 			"engines": {
-				"node": "^16.14.0 || >=18.0.0"
+				"node": "^12.13.0 || ^14.15.0 || >=16.0.0"
 			}
 		},
 		"node_modules/cacache/node_modules/glob": {
-			"version": "10.4.5",
-			"resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
-			"integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==",
+			"version": "8.1.0",
+			"resolved": "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz",
+			"integrity": "sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==",
+			"deprecated": "Glob versions prior to v9 are no longer supported",
 			"dev": true,
 			"license": "ISC",
 			"dependencies": {
-				"foreground-child": "^3.1.0",
-				"jackspeak": "^3.1.2",
-				"minimatch": "^9.0.4",
-				"minipass": "^7.1.2",
-				"package-json-from-dist": "^1.0.0",
-				"path-scurry": "^1.11.1"
+				"fs.realpath": "^1.0.0",
+				"inflight": "^1.0.4",
+				"inherits": "2",
+				"minimatch": "^5.0.1",
+				"once": "^1.3.0"
 			},
-			"bin": {
-				"glob": "dist/esm/bin.mjs"
+			"engines": {
+				"node": ">=12"
 			},
 			"funding": {
 				"url": "https://github.com/sponsors/isaacs"
 			}
 		},
 		"node_modules/cacache/node_modules/lru-cache": {
-			"version": "10.4.3",
-			"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
-			"integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+			"version": "7.18.3",
+			"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz",
+			"integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==",
 			"dev": true,
-			"license": "ISC"
+			"license": "ISC",
+			"engines": {
+				"node": ">=12"
+			}
 		},
 		"node_modules/cacache/node_modules/minimatch": {
-			"version": "9.0.5",
-			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
-			"integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+			"version": "5.1.6",
+			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
+			"integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
 			"dev": true,
 			"license": "ISC",
 			"dependencies": {
 				"brace-expansion": "^2.0.1"
 			},
 			"engines": {
-				"node": ">=16 || 14 >=14.17"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/isaacs"
+				"node": ">=10"
 			}
 		},
 		"node_modules/cacheable-lookup": {
@@ -7754,9 +8342,9 @@
 			}
 		},
 		"node_modules/caniuse-lite": {
-			"version": "1.0.30001651",
-			"resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001651.tgz",
-			"integrity": "sha512-9Cf+Xv1jJNe1xPZLGuUXLNkE1BoDkqRqYyFJ9TDYSqhduqA4hu4oR9HluGoWYQC/aj8WHjsGVV+bwkh0+tegRg==",
+			"version": "1.0.30001664",
+			"resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001664.tgz",
+			"integrity": "sha512-AmE7k4dXiNKQipgn7a2xg558IRqPN3jMQY/rOsbxDhrd0tyChwbITBfiwtnqz8bi2M5mIWbxAYBvk7W7QBUS2g==",
 			"dev": true,
 			"funding": [
 				{
@@ -8090,6 +8678,16 @@
 			"dev": true,
 			"license": "MIT"
 		},
+		"node_modules/color-support": {
+			"version": "1.1.3",
+			"resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz",
+			"integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==",
+			"dev": true,
+			"license": "ISC",
+			"bin": {
+				"color-support": "bin.js"
+			}
+		},
 		"node_modules/colorette": {
 			"version": "2.0.20",
 			"resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz",
@@ -8159,6 +8757,7 @@
 			"resolved": "https://registry.npmjs.org/compressible/-/compressible-2.0.18.tgz",
 			"integrity": "sha512-AF3r7P5dWxL8MxyITRMlORQNaOA2IkAFaTr4k7BUumjPtRpGDTZpl0Pb1XCO6JeDCBdp126Cgs9sMxqSjgYyRg==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"mime-db": ">= 1.43.0 < 2"
 			},
@@ -8171,6 +8770,7 @@
 			"resolved": "https://registry.npmjs.org/compression/-/compression-1.7.4.tgz",
 			"integrity": "sha512-jaSIDzP9pZVS4ZfQ+TzvtiWhdpFhE2RDHz8QJkpX9SIpLq88VueF5jJw6t+6CUQcAoA6t+x89MLrWAqpfDE8iQ==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"accepts": "~1.3.5",
 				"bytes": "3.0.0",
@@ -8189,6 +8789,7 @@
 			"resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
 			"integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"ms": "2.0.0"
 			}
@@ -8197,13 +8798,15 @@
 			"version": "2.0.0",
 			"resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
 			"integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/compression/node_modules/safe-buffer": {
 			"version": "5.1.2",
 			"resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
 			"integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/concat-map": {
 			"version": "0.0.1",
@@ -8213,14 +8816,14 @@
 			"license": "MIT"
 		},
 		"node_modules/config-file-ts": {
-			"version": "0.2.6",
-			"resolved": "https://registry.npmjs.org/config-file-ts/-/config-file-ts-0.2.6.tgz",
-			"integrity": "sha512-6boGVaglwblBgJqGyxm4+xCmEGcWgnWHSWHY5jad58awQhB6gftq0G8HbzU39YqCIYHMLAiL1yjwiZ36m/CL8w==",
+			"version": "0.2.8-rc1",
+			"resolved": "https://registry.npmjs.org/config-file-ts/-/config-file-ts-0.2.8-rc1.tgz",
+			"integrity": "sha512-GtNECbVI82bT4RiDIzBSVuTKoSHufnU7Ce7/42bkWZJZFLjmDF2WBpVsvRkhKCfKBnTBb3qZrBwPpFBU/Myvhg==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"glob": "^10.3.10",
-				"typescript": "^5.3.3"
+				"glob": "^10.3.12",
+				"typescript": "^5.4.3"
 			}
 		},
 		"node_modules/config-file-ts/node_modules/glob": {
@@ -8260,11 +8863,22 @@
 				"url": "https://github.com/sponsors/isaacs"
 			}
 		},
+		"node_modules/config-file-ts/node_modules/minipass": {
+			"version": "7.1.2",
+			"resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
+			"integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
+			"dev": true,
+			"license": "ISC",
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
+			}
+		},
 		"node_modules/connect-history-api-fallback": {
 			"version": "2.0.0",
 			"resolved": "https://registry.npmjs.org/connect-history-api-fallback/-/connect-history-api-fallback-2.0.0.tgz",
 			"integrity": "sha512-U73+6lQFmfiNPrYbXqr6kZ1i1wiRqXnp2nhMsINseWXO8lDau0LGEffJ8kQi4EjLZympVgRdvqjAgiZ1tgzDDA==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">=0.8"
 			}
@@ -8275,6 +8889,13 @@
 			"integrity": "sha512-ZMkYO/LkF17QvCPqM0gxw8yUzigAOZOSWSHg91FH6orS7vcEj5dVZTidN2fQ14yBSdg97RqhSNwLUXInd52OTA==",
 			"dev": true
 		},
+		"node_modules/console-control-strings": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz",
+			"integrity": "sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==",
+			"dev": true,
+			"license": "ISC"
+		},
 		"node_modules/constants-browserify": {
 			"version": "1.0.0",
 			"resolved": "https://registry.npmjs.org/constants-browserify/-/constants-browserify-1.0.0.tgz",
@@ -8287,6 +8908,7 @@
 			"resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
 			"integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"safe-buffer": "5.2.1"
 			},
@@ -8299,6 +8921,7 @@
 			"resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
 			"integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.6"
 			}
@@ -8315,6 +8938,7 @@
 			"resolved": "https://registry.npmjs.org/cookie/-/cookie-0.6.0.tgz",
 			"integrity": "sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.6"
 			}
@@ -8323,7 +8947,8 @@
 			"version": "1.0.6",
 			"resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz",
 			"integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/copy-anything": {
 			"version": "2.0.6",
@@ -8523,6 +9148,7 @@
 			"resolved": "https://registry.npmjs.org/critters/-/critters-0.0.24.tgz",
 			"integrity": "sha512-Oyqew0FGM0wYUSNqR0L6AteO5MpMoUU0rhKRieXeiKs+PmRTxiJMyaunYB2KF6fQ3dzChXKCpbFOEJx3OQ1v/Q==",
 			"dev": true,
+			"license": "Apache-2.0",
 			"dependencies": {
 				"chalk": "^4.1.0",
 				"css-select": "^5.1.0",
@@ -8538,6 +9164,7 @@
 			"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
 			"integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"color-convert": "^2.0.1"
 			},
@@ -8553,6 +9180,7 @@
 			"resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
 			"integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"ansi-styles": "^4.1.0",
 				"supports-color": "^7.1.0"
@@ -8569,6 +9197,7 @@
 			"resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
 			"integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"color-name": "~1.1.4"
 			},
@@ -8580,13 +9209,15 @@
 			"version": "1.1.4",
 			"resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
 			"integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/critters/node_modules/has-flag": {
 			"version": "4.0.0",
 			"resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
 			"integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">=8"
 			}
@@ -8596,6 +9227,7 @@
 			"resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
 			"integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"has-flag": "^4.0.0"
 			},
@@ -8728,6 +9360,7 @@
 			"resolved": "https://registry.npmjs.org/css-select/-/css-select-5.1.0.tgz",
 			"integrity": "sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==",
 			"dev": true,
+			"license": "BSD-2-Clause",
 			"dependencies": {
 				"boolbase": "^1.0.0",
 				"css-what": "^6.1.0",
@@ -8763,6 +9396,7 @@
 			"resolved": "https://registry.npmjs.org/css-what/-/css-what-6.1.0.tgz",
 			"integrity": "sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==",
 			"dev": true,
+			"license": "BSD-2-Clause",
 			"engines": {
 				"node": ">= 6"
 			},
@@ -8838,13 +9472,13 @@
 			}
 		},
 		"node_modules/debug": {
-			"version": "4.3.6",
-			"resolved": "https://registry.npmjs.org/debug/-/debug-4.3.6.tgz",
-			"integrity": "sha512-O/09Bd4Z1fBrU4VzkhFqVgpPzaGbw6Sm9FEkBT1A/YBXQFGuuSxa1dN2nxgxS34JmKXqYx8CZAwEVoJFImUXIg==",
+			"version": "4.3.7",
+			"resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
+			"integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"ms": "2.1.2"
+				"ms": "^2.1.3"
 			},
 			"engines": {
 				"node": ">=6.0"
@@ -8896,6 +9530,7 @@
 			"resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.2.1.tgz",
 			"integrity": "sha512-WY/3TUME0x3KPYdRRxEJJvXRHV4PyPoUsxtZa78lwItwRQRHhd2U9xOscaT/YTf8uCXIAjeJOFBVEh/7FtD8Xg==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"bundle-name": "^4.1.0",
 				"default-browser-id": "^5.0.0"
@@ -8912,6 +9547,7 @@
 			"resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.0.tgz",
 			"integrity": "sha512-A6p/pu/6fyBcA1TRz/GqWYPViplrftcW2gZC9q79ngNCKAeR/X3gcEdXQHl4KNXV+3wgIJ1CPkJQ3IHM6lcsyA==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">=18"
 			},
@@ -8924,6 +9560,7 @@
 			"resolved": "https://registry.npmjs.org/default-gateway/-/default-gateway-6.0.3.tgz",
 			"integrity": "sha512-fwSOJsbbNzZ/CUFpqFBqYfYNLj1NbMPm8MMCIzHjC83iSJRBEGmDUxU+WP661BaBQImeC2yHwXtz+P/O9o+XEg==",
 			"dev": true,
+			"license": "BSD-2-Clause",
 			"dependencies": {
 				"execa": "^5.0.0"
 			},
@@ -8977,6 +9614,7 @@
 			"resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz",
 			"integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">=12"
 			},
@@ -9012,11 +9650,19 @@
 				"node": ">=0.4.0"
 			}
 		},
+		"node_modules/delegates": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz",
+			"integrity": "sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==",
+			"dev": true,
+			"license": "MIT"
+		},
 		"node_modules/depd": {
 			"version": "2.0.0",
 			"resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
 			"integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.8"
 			}
@@ -9037,6 +9683,7 @@
 			"resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
 			"integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.8",
 				"npm": "1.2.8000 || >= 1.4.16"
@@ -9047,6 +9694,7 @@
 			"resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.0.3.tgz",
 			"integrity": "sha512-bwy0MGW55bG41VqxxypOsdSdGqLwXPI/focwgTYCFMbdUiBAxLg9CFzG08sz2aqzknwiX7Hkl0bQENjg8iLByw==",
 			"dev": true,
+			"license": "Apache-2.0",
 			"engines": {
 				"node": ">=8"
 			}
@@ -9088,14 +9736,14 @@
 			"license": "MIT"
 		},
 		"node_modules/dir-compare": {
-			"version": "3.3.0",
-			"resolved": "https://registry.npmjs.org/dir-compare/-/dir-compare-3.3.0.tgz",
-			"integrity": "sha512-J7/et3WlGUCxjdnD3HAAzQ6nsnc0WL6DD7WcwJb7c39iH1+AWfg+9OqzJNaI6PkBwBvm1mhZNL9iY/nRiZXlPg==",
+			"version": "4.2.0",
+			"resolved": "https://registry.npmjs.org/dir-compare/-/dir-compare-4.2.0.tgz",
+			"integrity": "sha512-2xMCmOoMrdQIPHdsTawECdNPwlVFB9zGcz3kuhmBO6U3oU+UQjsue0i8ayLKpgBcm+hcXPMVSGUN9d+pvJ6+VQ==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"buffer-equal": "^1.0.0",
-				"minimatch": "^3.0.4"
+				"minimatch": "^3.0.5",
+				"p-limit": "^3.1.0 "
 			}
 		},
 		"node_modules/dir-compare/node_modules/brace-expansion": {
@@ -9122,39 +9770,16 @@
 				"node": "*"
 			}
 		},
-		"node_modules/dir-glob": {
-			"version": "3.0.1",
-			"resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz",
-			"integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"path-type": "^4.0.0"
-			},
-			"engines": {
-				"node": ">=8"
-			}
-		},
-		"node_modules/dir-glob/node_modules/path-type": {
-			"version": "4.0.0",
-			"resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz",
-			"integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=8"
-			}
-		},
 		"node_modules/dmg-builder": {
-			"version": "24.13.3",
-			"resolved": "https://registry.npmjs.org/dmg-builder/-/dmg-builder-24.13.3.tgz",
-			"integrity": "sha512-rcJUkMfnJpfCboZoOOPf4L29TRtEieHNOeAbYPWPxlaBw/Z1RKrRA86dOI9rwaI4tQSc/RD82zTNHprfUHXsoQ==",
+			"version": "25.0.5",
+			"resolved": "https://registry.npmjs.org/dmg-builder/-/dmg-builder-25.0.5.tgz",
+			"integrity": "sha512-ocnZV44ZqInoSFaY54fF7BlCtw+WtbrjyPrkBhaB+Ztn7GPKjmFgRbIKytifJ8h9Cib8jdFRMgjCUtkU45Y6DA==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"app-builder-lib": "24.13.3",
-				"builder-util": "24.13.1",
-				"builder-util-runtime": "9.2.4",
+				"app-builder-lib": "25.0.5",
+				"builder-util": "25.0.3",
+				"builder-util-runtime": "9.2.5",
 				"fs-extra": "^10.1.0",
 				"iconv-lite": "^0.6.2",
 				"js-yaml": "^4.1.0"
@@ -9259,6 +9884,7 @@
 			"resolved": "https://registry.npmjs.org/dns-packet/-/dns-packet-5.6.1.tgz",
 			"integrity": "sha512-l4gcSouhcgIKRvyy99RNVOgxXiicE+2jZoNmaNmZ6JXiGajBOJAesk1OBlJuM5k2c+eudGdLxDqXuPCKIj6kpw==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@leichtgewicht/ip-codec": "^2.0.1"
 			},
@@ -9271,6 +9897,7 @@
 			"resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz",
 			"integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"domelementtype": "^2.3.0",
 				"domhandler": "^5.0.2",
@@ -9303,13 +9930,15 @@
 					"type": "github",
 					"url": "https://github.com/sponsors/fb55"
 				}
-			]
+			],
+			"license": "BSD-2-Clause"
 		},
 		"node_modules/domhandler": {
 			"version": "5.0.3",
 			"resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz",
 			"integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==",
 			"dev": true,
+			"license": "BSD-2-Clause",
 			"dependencies": {
 				"domelementtype": "^2.3.0"
 			},
@@ -9325,6 +9954,7 @@
 			"resolved": "https://registry.npmjs.org/domutils/-/domutils-3.1.0.tgz",
 			"integrity": "sha512-H78uMmQtI2AhgDJjWeQmHwJJ2bLPD3GMmO7Zja/ZZh84wkm+4ut+IUnUdRa8uCGX88DiVx1j6FRe1XfxEgjEZA==",
 			"dev": true,
+			"license": "BSD-2-Clause",
 			"dependencies": {
 				"dom-serializer": "^2.0.0",
 				"domelementtype": "^2.3.0",
@@ -9335,21 +9965,33 @@
 			}
 		},
 		"node_modules/dotenv": {
-			"version": "9.0.2",
-			"resolved": "https://registry.npmjs.org/dotenv/-/dotenv-9.0.2.tgz",
-			"integrity": "sha512-I9OvvrHp4pIARv4+x9iuewrWycX6CcZtoAu1XrzPxc5UygMJXJZYmBsynku8IkrJwgypE5DGNjDPmPRhDCptUg==",
+			"version": "16.4.5",
+			"resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.4.5.tgz",
+			"integrity": "sha512-ZmdL2rui+eB2YwhsWzjInR8LldtZHGDoQ1ugH85ppHKwpUHL7j7rN0Ti9NCnGiQbhaZ11FpR+7ao1dNsmduNUg==",
 			"dev": true,
 			"license": "BSD-2-Clause",
 			"engines": {
-				"node": ">=10"
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://dotenvx.com"
 			}
 		},
 		"node_modules/dotenv-expand": {
-			"version": "5.1.0",
-			"resolved": "https://registry.npmjs.org/dotenv-expand/-/dotenv-expand-5.1.0.tgz",
-			"integrity": "sha512-YXQl1DSa4/PQyRfgrv6aoNjhasp/p4qs9FjJ4q4cQk+8m4r6k4ZSiEyytKG8f8W9gi8WsQtIObNmKd+tMzNTmA==",
+			"version": "11.0.6",
+			"resolved": "https://registry.npmjs.org/dotenv-expand/-/dotenv-expand-11.0.6.tgz",
+			"integrity": "sha512-8NHi73otpWsZGBSZwwknTXS5pqMOrk9+Ssrna8xCaxkzEpU9OTf9R5ArQGVw03//Zmk9MOwLPng9WwndvpAJ5g==",
 			"dev": true,
-			"license": "BSD-2-Clause"
+			"license": "BSD-2-Clause",
+			"dependencies": {
+				"dotenv": "^16.4.4"
+			},
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://dotenvx.com"
+			}
 		},
 		"node_modules/eastasianwidth": {
 			"version": "0.2.0",
@@ -9362,7 +10004,8 @@
 			"version": "1.1.1",
 			"resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
 			"integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/ejs": {
 			"version": "3.1.10",
@@ -9381,9 +10024,9 @@
 			}
 		},
 		"node_modules/electron": {
-			"version": "32.0.1",
-			"resolved": "https://registry.npmjs.org/electron/-/electron-32.0.1.tgz",
-			"integrity": "sha512-5Hd5Jaf9niYVR2hZxoRd3gOrcxPOxQV1XPV5WaoSfT9jLJHFadhlKtuSDIk3U6rQZke+aC7GqPPAv55nWFCMsA==",
+			"version": "32.1.2",
+			"resolved": "https://registry.npmjs.org/electron/-/electron-32.1.2.tgz",
+			"integrity": "sha512-CXe6doFzhmh1U7daOvUzmF6Cj8hssdYWMeEPRnRO6rB9/bbwMlWctcQ7P8NJXhLQ88/vYUJQrJvlJPh8qM0BRQ==",
 			"dev": true,
 			"hasInstallScript": true,
 			"license": "MIT",
@@ -9400,21 +10043,21 @@
 			}
 		},
 		"node_modules/electron-builder": {
-			"version": "24.13.3",
-			"resolved": "https://registry.npmjs.org/electron-builder/-/electron-builder-24.13.3.tgz",
-			"integrity": "sha512-yZSgVHft5dNVlo31qmJAe4BVKQfFdwpRw7sFp1iQglDRCDD6r22zfRJuZlhtB5gp9FHUxCMEoWGq10SkCnMAIg==",
+			"version": "25.0.5",
+			"resolved": "https://registry.npmjs.org/electron-builder/-/electron-builder-25.0.5.tgz",
+			"integrity": "sha512-Uj5LFRbUqNiVajsgqcwlKe+CHtwubK3hcoJsW5C2YiWodej2mmxM+LrTqga0rrWWHVMNmrcmGcS/WHpKwy6KEw==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"app-builder-lib": "24.13.3",
-				"builder-util": "24.13.1",
-				"builder-util-runtime": "9.2.4",
+				"app-builder-lib": "25.0.5",
+				"builder-util": "25.0.3",
+				"builder-util-runtime": "9.2.5",
 				"chalk": "^4.1.2",
-				"dmg-builder": "24.13.3",
+				"dmg-builder": "25.0.5",
 				"fs-extra": "^10.1.0",
 				"is-ci": "^3.0.0",
 				"lazy-val": "^1.0.5",
-				"read-config-file": "6.3.2",
+				"read-config-file": "6.4.0",
 				"simple-update-notifier": "2.0.0",
 				"yargs": "^17.6.2"
 			},
@@ -9427,16 +10070,16 @@
 			}
 		},
 		"node_modules/electron-builder-squirrel-windows": {
-			"version": "24.13.3",
-			"resolved": "https://registry.npmjs.org/electron-builder-squirrel-windows/-/electron-builder-squirrel-windows-24.13.3.tgz",
-			"integrity": "sha512-oHkV0iogWfyK+ah9ZIvMDpei1m9ZRpdXcvde1wTpra2U8AFDNNpqJdnin5z+PM1GbQ5BoaKCWas2HSjtR0HwMg==",
+			"version": "25.0.5",
+			"resolved": "https://registry.npmjs.org/electron-builder-squirrel-windows/-/electron-builder-squirrel-windows-25.0.5.tgz",
+			"integrity": "sha512-N2U7LGSdt4hmEhjEeIV2XJbjj2YIrTL6enfsGKfOhGTpL6GEejUmT3gjdKUqKBS5+NBx0GWhnEwD3MpO2P6Nfg==",
 			"dev": true,
 			"license": "MIT",
 			"peer": true,
 			"dependencies": {
-				"app-builder-lib": "24.13.3",
+				"app-builder-lib": "25.0.5",
 				"archiver": "^5.3.1",
-				"builder-util": "24.13.1",
+				"builder-util": "25.0.3",
 				"fs-extra": "^10.1.0"
 			}
 		},
@@ -9596,15 +10239,15 @@
 			}
 		},
 		"node_modules/electron-publish": {
-			"version": "24.13.1",
-			"resolved": "https://registry.npmjs.org/electron-publish/-/electron-publish-24.13.1.tgz",
-			"integrity": "sha512-2ZgdEqJ8e9D17Hwp5LEq5mLQPjqU3lv/IALvgp+4W8VeNhryfGhYEQC/PgDPMrnWUp+l60Ou5SJLsu+k4mhQ8A==",
+			"version": "25.0.3",
+			"resolved": "https://registry.npmjs.org/electron-publish/-/electron-publish-25.0.3.tgz",
+			"integrity": "sha512-wSGm+TFK2lArswIFBPLuIRHbo945s3MCvG5y1xVC57zL/PsrElUkaGH2ERtRrcKNpaDNq77rDA9JnMJhAFJjUg==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"@types/fs-extra": "^9.0.11",
-				"builder-util": "24.13.1",
-				"builder-util-runtime": "9.2.4",
+				"builder-util": "25.0.3",
+				"builder-util-runtime": "9.2.5",
 				"chalk": "^4.1.2",
 				"fs-extra": "^10.1.0",
 				"lazy-val": "^1.0.5",
@@ -9726,16 +10369,16 @@
 			}
 		},
 		"node_modules/electron-to-chromium": {
-			"version": "1.5.13",
-			"resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.13.tgz",
-			"integrity": "sha512-lbBcvtIJ4J6sS4tb5TLp1b4LyfCdMkwStzXPyAgVgTRAsep4bvrAGaBOP7ZJtQMNJpSQ9SqG4brWOroNaQtm7Q==",
+			"version": "1.5.30",
+			"resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.30.tgz",
+			"integrity": "sha512-sXI35EBN4lYxzc/pIGorlymYNzDBOqkSlVRe6MkgBsW/hW1tpC/HDJ2fjG7XnjakzfLEuvdmux0Mjs6jHq4UOA==",
 			"dev": true,
 			"license": "ISC"
 		},
 		"node_modules/electron/node_modules/@types/node": {
-			"version": "20.16.1",
-			"resolved": "https://registry.npmjs.org/@types/node/-/node-20.16.1.tgz",
-			"integrity": "sha512-zJDo7wEadFtSyNz5QITDfRcrhqDvQI1xQNQ0VoizPjM/dVAODqqIUWbJPkvsxmTI0MYRGRikcdjMPhOssnPejQ==",
+			"version": "20.16.10",
+			"resolved": "https://registry.npmjs.org/@types/node/-/node-20.16.10.tgz",
+			"integrity": "sha512-vQUKgWTjEIRFCvK6CyriPH3MZYiYlNy0fKiEYHWbcoWLEgs4opurGGKlebrTLqdSMIbXImH6XExNiIyNUv3WpA==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
@@ -9787,6 +10430,7 @@
 			"resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
 			"integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.8"
 			}
@@ -10044,6 +10688,7 @@
 			"integrity": "sha512-1lvV17H2bMYda/WaFb2jLPeHU3zml2k4/yagNMG8Q/YtfMjCwEUZa2eXXMgZTVSL5q1n4H7sQ0X6CdJDqqeCFA==",
 			"dev": true,
 			"hasInstallScript": true,
+			"license": "MIT",
 			"bin": {
 				"esbuild": "bin/esbuild"
 			},
@@ -10091,9 +10736,9 @@
 			}
 		},
 		"node_modules/escalade": {
-			"version": "3.1.2",
-			"resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.2.tgz",
-			"integrity": "sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA==",
+			"version": "3.2.0",
+			"resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+			"integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
 			"dev": true,
 			"license": "MIT",
 			"engines": {
@@ -10104,7 +10749,8 @@
 			"version": "1.0.3",
 			"resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
 			"integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/escape-string-regexp": {
 			"version": "1.0.5",
@@ -10117,20 +10763,24 @@
 			}
 		},
 		"node_modules/eslint": {
-			"version": "9.9.0",
-			"resolved": "https://registry.npmjs.org/eslint/-/eslint-9.9.0.tgz",
-			"integrity": "sha512-JfiKJrbx0506OEerjK2Y1QlldtBxkAlLxT5OEcRF8uaQ86noDe2k31Vw9rnSWv+MXZHj7OOUV/dA0AhdLFcyvA==",
+			"version": "9.11.1",
+			"resolved": "https://registry.npmjs.org/eslint/-/eslint-9.11.1.tgz",
+			"integrity": "sha512-MobhYKIoAO1s1e4VUrgx1l1Sk2JBR/Gqjjgw8+mfgoLE2xwsHur4gdfTxyTgShrhvdVFTaJSgMiQBl1jv/AWxg==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"@eslint-community/eslint-utils": "^4.2.0",
 				"@eslint-community/regexpp": "^4.11.0",
-				"@eslint/config-array": "^0.17.1",
+				"@eslint/config-array": "^0.18.0",
+				"@eslint/core": "^0.6.0",
 				"@eslint/eslintrc": "^3.1.0",
-				"@eslint/js": "9.9.0",
+				"@eslint/js": "9.11.1",
+				"@eslint/plugin-kit": "^0.2.0",
 				"@humanwhocodes/module-importer": "^1.0.1",
 				"@humanwhocodes/retry": "^0.3.0",
 				"@nodelib/fs.walk": "^1.2.8",
+				"@types/estree": "^1.0.6",
+				"@types/json-schema": "^7.0.15",
 				"ajv": "^6.12.4",
 				"chalk": "^4.0.0",
 				"cross-spawn": "^7.0.2",
@@ -10150,7 +10800,6 @@
 				"is-glob": "^4.0.0",
 				"is-path-inside": "^3.0.3",
 				"json-stable-stringify-without-jsonify": "^1.0.1",
-				"levn": "^0.4.1",
 				"lodash.merge": "^4.6.2",
 				"minimatch": "^3.1.2",
 				"natural-compare": "^1.4.0",
@@ -10177,9 +10826,9 @@
 			}
 		},
 		"node_modules/eslint-scope": {
-			"version": "8.0.2",
-			"resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.0.2.tgz",
-			"integrity": "sha512-6E4xmrTw5wtxnLA5wYL3WDfhZ/1bUBGOXV0zQvVRDOtrR8D0p6W7fs3JweNYhwRYeGvd/1CKX2se0/2s7Q/nJA==",
+			"version": "8.1.0",
+			"resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.1.0.tgz",
+			"integrity": "sha512-14dSvlhaVhKKsa9Fx1l8A17s7ah7Ef7wCakJ10LYk6+GYmP9yDti2oq2SEwcyndt6knfcZyhyxwY3i9yL78EQw==",
 			"dev": true,
 			"license": "BSD-2-Clause",
 			"dependencies": {
@@ -10194,9 +10843,9 @@
 			}
 		},
 		"node_modules/eslint-visitor-keys": {
-			"version": "4.0.0",
-			"resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.0.0.tgz",
-			"integrity": "sha512-OtIRv/2GyiF6o/d8K7MYKKbXrOUBIK6SfkIRM4Z0dY3w+LiQ0vy3F57m0Z71bjbyeiWFiHJ8brqnmE6H6/jEuw==",
+			"version": "4.1.0",
+			"resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.1.0.tgz",
+			"integrity": "sha512-Q7lok0mqMUSf5a/AdAZkA5a/gHcO6snwQClVNNvFKCAVlxXucdU8pKydU5ZVZjBx5xr37vGbFFWtLQYreLzrZg==",
 			"dev": true,
 			"license": "Apache-2.0",
 			"engines": {
@@ -10357,15 +11006,15 @@
 			}
 		},
 		"node_modules/espree": {
-			"version": "10.1.0",
-			"resolved": "https://registry.npmjs.org/espree/-/espree-10.1.0.tgz",
-			"integrity": "sha512-M1M6CpiE6ffoigIOWYO9UDP8TMUw9kqb21tf+08IgDYjCsOvCuDt4jQcZmoYxx+w7zlKw9/N0KXfto+I8/FrXA==",
+			"version": "10.2.0",
+			"resolved": "https://registry.npmjs.org/espree/-/espree-10.2.0.tgz",
+			"integrity": "sha512-upbkBJbckcCNBDBDXEbuhjbP68n+scUd3k/U2EkyM9nw+I/jPiL4cLF/Al06CF96wRltFda16sxDFrxsI1v0/g==",
 			"dev": true,
 			"license": "BSD-2-Clause",
 			"dependencies": {
 				"acorn": "^8.12.0",
 				"acorn-jsx": "^5.3.2",
-				"eslint-visitor-keys": "^4.0.0"
+				"eslint-visitor-keys": "^4.1.0"
 			},
 			"engines": {
 				"node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -10425,6 +11074,7 @@
 			"resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
 			"integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.6"
 			}
@@ -10472,6 +11122,7 @@
 			"resolved": "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz",
 			"integrity": "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"cross-spawn": "^7.0.3",
 				"get-stream": "^6.0.0",
@@ -10495,6 +11146,7 @@
 			"resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz",
 			"integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">=10"
 			},
@@ -10507,6 +11159,7 @@
 			"resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz",
 			"integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"mimic-fn": "^2.1.0"
 			},
@@ -10521,7 +11174,8 @@
 			"version": "3.0.7",
 			"resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
 			"integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
-			"dev": true
+			"dev": true,
+			"license": "ISC"
 		},
 		"node_modules/exponential-backoff": {
 			"version": "3.1.1",
@@ -10535,6 +11189,7 @@
 			"resolved": "https://registry.npmjs.org/express/-/express-4.21.0.tgz",
 			"integrity": "sha512-VqcNGcj/Id5ZT1LZ/cfihi3ttTn+NJmkli2eZADigjq29qTlWi/hAQ43t/VLPq8+UX06FCEx3ByOYet6ZFblng==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"accepts": "~1.3.8",
 				"array-flatten": "1.1.1",
@@ -10577,6 +11232,7 @@
 			"resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
 			"integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"ms": "2.0.0"
 			}
@@ -10585,7 +11241,8 @@
 			"version": "2.0.0",
 			"resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
 			"integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/external-editor": {
 			"version": "3.1.0",
@@ -10686,9 +11343,9 @@
 			"license": "MIT"
 		},
 		"node_modules/fast-uri": {
-			"version": "3.0.1",
-			"resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.0.1.tgz",
-			"integrity": "sha512-MWipKbbYiYI0UC7cl8m/i/IWTqfC8YXsqjzybjddLsFjStroQzsHXkc73JutMvBiXmOvapk+axIl79ig5t55Bw==",
+			"version": "3.0.2",
+			"resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.0.2.tgz",
+			"integrity": "sha512-GR6f0hD7XXyNJa25Tb9BuIdN0tdr+0BMi6/CJPH3wJO1JjNG3n/VsSw38AwRdKZABm8lGbPfakLRkYzx2V9row==",
 			"dev": true,
 			"license": "MIT"
 		},
@@ -10707,6 +11364,7 @@
 			"resolved": "https://registry.npmjs.org/faye-websocket/-/faye-websocket-0.11.4.tgz",
 			"integrity": "sha512-CzbClwlXAuiRQAlUyfqPgvPoNKTckTPGfwZV4ZdAhVcP2lh9KUxJg2b5GkE7XbjKQ3YJnQ9z6D9ntLAlB+tP8g==",
 			"dev": true,
+			"license": "Apache-2.0",
 			"dependencies": {
 				"websocket-driver": ">=0.5.1"
 			},
@@ -10747,6 +11405,19 @@
 				"minimatch": "^5.0.1"
 			}
 		},
+		"node_modules/filelist/node_modules/minimatch": {
+			"version": "5.1.6",
+			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
+			"integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"brace-expansion": "^2.0.1"
+			},
+			"engines": {
+				"node": ">=10"
+			}
+		},
 		"node_modules/fill-range": {
 			"version": "7.1.1",
 			"resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
@@ -10765,6 +11436,7 @@
 			"resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.1.tgz",
 			"integrity": "sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"debug": "2.6.9",
 				"encodeurl": "~2.0.0",
@@ -10783,6 +11455,7 @@
 			"resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
 			"integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"ms": "2.0.0"
 			}
@@ -10791,7 +11464,8 @@
 			"version": "2.0.0",
 			"resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
 			"integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/find-cache-dir": {
 			"version": "4.0.0",
@@ -10859,9 +11533,9 @@
 			"license": "ISC"
 		},
 		"node_modules/follow-redirects": {
-			"version": "1.15.6",
-			"resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.6.tgz",
-			"integrity": "sha512-wWN62YITEaOpSK584EZXJafH1AGpO8RVgElfkuXbTOrPX4fIfOyEpW/CsiNd8JdYrAoOvafRTOEnvsO++qCqFA==",
+			"version": "1.15.9",
+			"resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz",
+			"integrity": "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==",
 			"dev": true,
 			"funding": [
 				{
@@ -10926,6 +11600,7 @@
 			"resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
 			"integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.6"
 			}
@@ -10955,6 +11630,7 @@
 			"resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
 			"integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.6"
 			}
@@ -10983,16 +11659,16 @@
 			}
 		},
 		"node_modules/fs-minipass": {
-			"version": "3.0.3",
-			"resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-3.0.3.tgz",
-			"integrity": "sha512-XUBA9XClHbnJWSfBzjkm6RvPsyg3sryZt06BEQoXcF7EK/xpGaQYJgQKDJSUH5SGZ76Y7pFx1QBnXz09rU5Fbw==",
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz",
+			"integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==",
 			"dev": true,
 			"license": "ISC",
 			"dependencies": {
-				"minipass": "^7.0.3"
+				"minipass": "^3.0.0"
 			},
 			"engines": {
-				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+				"node": ">= 8"
 			}
 		},
 		"node_modules/fs.realpath": {
@@ -11056,6 +11732,34 @@
 				"url": "https://github.com/sponsors/ljharb"
 			}
 		},
+		"node_modules/gauge": {
+			"version": "4.0.4",
+			"resolved": "https://registry.npmjs.org/gauge/-/gauge-4.0.4.tgz",
+			"integrity": "sha512-f9m+BEN5jkg6a0fZjleidjN51VE1X+mPFQ2DJ0uv1V39oCLCbsGe6yjbBnp7eK7z/+GAon99a3nHuqbuuthyPg==",
+			"deprecated": "This package is no longer supported.",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"aproba": "^1.0.3 || ^2.0.0",
+				"color-support": "^1.1.3",
+				"console-control-strings": "^1.1.0",
+				"has-unicode": "^2.0.1",
+				"signal-exit": "^3.0.7",
+				"string-width": "^4.2.3",
+				"strip-ansi": "^6.0.1",
+				"wide-align": "^1.1.5"
+			},
+			"engines": {
+				"node": "^12.13.0 || ^14.15.0 || >=16.0.0"
+			}
+		},
+		"node_modules/gauge/node_modules/signal-exit": {
+			"version": "3.0.7",
+			"resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+			"integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
+			"dev": true,
+			"license": "ISC"
+		},
 		"node_modules/gensync": {
 			"version": "1.0.0-beta.2",
 			"resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
@@ -11352,7 +12056,8 @@
 			"version": "2.0.1",
 			"resolved": "https://registry.npmjs.org/handle-thing/-/handle-thing-2.0.1.tgz",
 			"integrity": "sha512-9Qn4yBxelxoh2Ow62nP+Ka/kMnOXRi8BXnRaUwezLNhqelnN49xKz4F/dPP8OYLxLxq6JDtZb2i9XznUQbNPTg==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/has-bigints": {
 			"version": "1.0.2",
@@ -11429,6 +12134,13 @@
 				"url": "https://github.com/sponsors/ljharb"
 			}
 		},
+		"node_modules/has-unicode": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz",
+			"integrity": "sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==",
+			"dev": true,
+			"license": "ISC"
+		},
 		"node_modules/hash-base": {
 			"version": "3.0.4",
 			"resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.0.4.tgz",
@@ -11526,6 +12238,7 @@
 			"resolved": "https://registry.npmjs.org/hpack.js/-/hpack.js-2.1.6.tgz",
 			"integrity": "sha512-zJxVehUdMGIKsRaNt7apO2Gqp0BdqW5yaiGHXXmbpvxgBYVZnAql+BJb4RO5ad2MgpbZKn5G6nMnegrH1FcNYQ==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"inherits": "^2.0.1",
 				"obuf": "^1.0.0",
@@ -11537,13 +12250,15 @@
 			"version": "1.0.0",
 			"resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
 			"integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/hpack.js/node_modules/readable-stream": {
 			"version": "2.3.8",
 			"resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
 			"integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"core-util-is": "~1.0.0",
 				"inherits": "~2.0.3",
@@ -11558,13 +12273,15 @@
 			"version": "5.1.2",
 			"resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
 			"integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/hpack.js/node_modules/string_decoder": {
 			"version": "1.1.1",
 			"resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
 			"integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"safe-buffer": "~5.1.0"
 			}
@@ -11583,7 +12300,8 @@
 					"type": "patreon",
 					"url": "https://patreon.com/mdevils"
 				}
-			]
+			],
+			"license": "MIT"
 		},
 		"node_modules/htmlparser2": {
 			"version": "8.0.2",
@@ -11597,6 +12315,7 @@
 					"url": "https://github.com/sponsors/fb55"
 				}
 			],
+			"license": "MIT",
 			"dependencies": {
 				"domelementtype": "^2.3.0",
 				"domhandler": "^5.0.3",
@@ -11615,13 +12334,15 @@
 			"version": "1.2.7",
 			"resolved": "https://registry.npmjs.org/http-deceiver/-/http-deceiver-1.2.7.tgz",
 			"integrity": "sha512-LmpOGxTfbpgtGVxJrj5k7asXHCgNZp5nLfp+hWc8QQRqtb7fUy6kRY3BO1h9ddF6yIPYUARgxGOwB42DnxIaNw==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/http-errors": {
 			"version": "2.0.0",
 			"resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
 			"integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"depd": "2.0.0",
 				"inherits": "2.0.4",
@@ -11637,7 +12358,8 @@
 			"version": "0.5.8",
 			"resolved": "https://registry.npmjs.org/http-parser-js/-/http-parser-js-0.5.8.tgz",
 			"integrity": "sha512-SGeBX54F94Wgu5RH3X5jsDtf4eHyRogWX1XGT3b4HuW3tQPM4AaBzoUji/4AAJNXCEOWZ5O0DgZmJw1947gD5Q==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/http-proxy": {
 			"version": "1.18.1",
@@ -11740,15 +12462,27 @@
 			"resolved": "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz",
 			"integrity": "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==",
 			"dev": true,
+			"license": "Apache-2.0",
 			"engines": {
 				"node": ">=10.17.0"
 			}
 		},
+		"node_modules/humanize-ms": {
+			"version": "1.2.1",
+			"resolved": "https://registry.npmjs.org/humanize-ms/-/humanize-ms-1.2.1.tgz",
+			"integrity": "sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"ms": "^2.0.0"
+			}
+		},
 		"node_modules/hyperdyperid": {
 			"version": "1.2.0",
 			"resolved": "https://registry.npmjs.org/hyperdyperid/-/hyperdyperid-1.2.0.tgz",
 			"integrity": "sha512-Y93lCzHYgGWdrJ66yIktxiaGULYc6oGiABxhcO5AufBeOyoIdZF7bIfLaOrbM0iGIOXQQgxxRrFEnb+Y6w1n4A==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">=10.18"
 			}
@@ -11915,6 +12649,13 @@
 				"node": ">=8"
 			}
 		},
+		"node_modules/infer-owner": {
+			"version": "1.0.4",
+			"resolved": "https://registry.npmjs.org/infer-owner/-/infer-owner-1.0.4.tgz",
+			"integrity": "sha512-IClj+Xz94+d7irH5qRyfJonOdfTzuDaifE6ZPWfx0N0+/ATZCbuTPq2prFl526urkQd90WyUKIh1DfBQ2hMz9A==",
+			"dev": true,
+			"license": "ISC"
+		},
 		"node_modules/inflight": {
 			"version": "1.0.6",
 			"resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
@@ -11978,6 +12719,7 @@
 			"resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-2.2.0.tgz",
 			"integrity": "sha512-Ag3wB2o37wslZS19hZqorUnrnzSkpOVy+IiiDEiTqNubEYpYuHWIf6K4psgN2ZWKExS4xhVCrRVfb/wfW8fWJA==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 10"
 			}
@@ -12093,9 +12835,9 @@
 			}
 		},
 		"node_modules/is-core-module": {
-			"version": "2.15.0",
-			"resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.15.0.tgz",
-			"integrity": "sha512-Dd+Lb2/zvk9SKy1TGCt1wFJFo/MWBPMX5x7KcvLajWTGuomczdQX61PvY5yK6SVACwpoexWo81IfFyoKY2QnTA==",
+			"version": "2.15.1",
+			"resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.15.1.tgz",
+			"integrity": "sha512-z0vtXSwucUJtANQWldhbtbt7BnL0vxiFjIdDLAatwhDYty2bad6s+rijD6Ri4YuYJubLzIJLUidCh09e1djEVQ==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
@@ -12145,6 +12887,7 @@
 			"resolved": "https://registry.npmjs.org/is-docker/-/is-docker-3.0.0.tgz",
 			"integrity": "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ==",
 			"dev": true,
+			"license": "MIT",
 			"bin": {
 				"is-docker": "cli.js"
 			},
@@ -12209,6 +12952,7 @@
 			"resolved": "https://registry.npmjs.org/is-inside-container/-/is-inside-container-1.0.0.tgz",
 			"integrity": "sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"is-docker": "^3.0.0"
 			},
@@ -12274,6 +13018,7 @@
 			"resolved": "https://registry.npmjs.org/is-network-error/-/is-network-error-1.1.0.tgz",
 			"integrity": "sha512-tUdRRAnhT+OtCZR/LxZelH/C7QtjtFrTu5tXCA8pl55eTUElUHT+GPYV8MBMBvea/j+NxQqVt3LbWMRir7Gx9g==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">=16"
 			},
@@ -12381,6 +13126,7 @@
 			"resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz",
 			"integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">=8"
 			},
@@ -12474,6 +13220,7 @@
 			"resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-3.1.0.tgz",
 			"integrity": "sha512-UcVfVfaK4Sc4m7X3dUSoHoozQGBEFeDC+zVo06t98xe8CzHSZZBekNXH+tu0NalHolcJ/QAGqS46Hef7QXBIMw==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"is-inside-container": "^1.0.0"
 			},
@@ -12927,6 +13674,7 @@
 			"resolved": "https://registry.npmjs.org/launch-editor/-/launch-editor-2.9.1.tgz",
 			"integrity": "sha512-Gcnl4Bd+hRO9P9icCP/RVVT2o8SFlPXofuCxvA2SaZuH45whSvf5p8x5oih5ftLiVhEI4sp5xDY+R+b3zJBh5w==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"picocolors": "^1.0.0",
 				"shell-quote": "^1.8.1"
@@ -13140,9 +13888,9 @@
 			}
 		},
 		"node_modules/listr2/node_modules/ansi-regex": {
-			"version": "6.0.1",
-			"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.1.tgz",
-			"integrity": "sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==",
+			"version": "6.1.0",
+			"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
+			"integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
 			"dev": true,
 			"license": "MIT",
 			"engines": {
@@ -13183,9 +13931,9 @@
 			}
 		},
 		"node_modules/listr2/node_modules/emoji-regex": {
-			"version": "10.3.0",
-			"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.3.0.tgz",
-			"integrity": "sha512-QpLs9D9v9kArv4lfDEgg1X/gN5XLnf/A6l9cs8SPZLRZR3ZkY9+kwIQTxm+fsSej5UMYGE8fdoaZVIBlqG0XTw==",
+			"version": "10.4.0",
+			"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.4.0.tgz",
+			"integrity": "sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw==",
 			"dev": true,
 			"license": "MIT"
 		},
@@ -13284,6 +14032,7 @@
 			"integrity": "sha512-UGe+BbaSUQtAMZobTb4nHvFMrmvuAQKSeaqAX2meTEQjfsbpl5sxdHD8T72OnwD4GU9uwNhYXIVe4QGs8N9Zyw==",
 			"dev": true,
 			"hasInstallScript": true,
+			"license": "MIT",
 			"dependencies": {
 				"msgpackr": "^1.10.2",
 				"node-addon-api": "^6.1.0",
@@ -13307,7 +14056,8 @@
 			"version": "6.1.0",
 			"resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-6.1.0.tgz",
 			"integrity": "sha512-+eawOlIgy680F0kBzPUNFhMZGtJ1YmqM6l4+Crf4IkImjYrO/mqPwRMh352g23uIaQKFItcQ64I7KMaJxHgAVA==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/load-json-file": {
 			"version": "4.0.0",
@@ -13576,9 +14326,9 @@
 			}
 		},
 		"node_modules/log-update/node_modules/ansi-regex": {
-			"version": "6.0.1",
-			"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.1.tgz",
-			"integrity": "sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==",
+			"version": "6.1.0",
+			"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
+			"integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
 			"dev": true,
 			"license": "MIT",
 			"engines": {
@@ -13602,9 +14352,9 @@
 			}
 		},
 		"node_modules/log-update/node_modules/emoji-regex": {
-			"version": "10.3.0",
-			"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.3.0.tgz",
-			"integrity": "sha512-QpLs9D9v9kArv4lfDEgg1X/gN5XLnf/A6l9cs8SPZLRZR3ZkY9+kwIQTxm+fsSej5UMYGE8fdoaZVIBlqG0XTw==",
+			"version": "10.4.0",
+			"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.4.0.tgz",
+			"integrity": "sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw==",
 			"dev": true,
 			"license": "MIT"
 		},
@@ -13757,27 +14507,55 @@
 			"license": "ISC"
 		},
 		"node_modules/make-fetch-happen": {
-			"version": "13.0.1",
-			"resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-13.0.1.tgz",
-			"integrity": "sha512-cKTUFc/rbKUd/9meOvgrpJ2WrNzymt6jfRDdwg5UCnVzv9dTpEj9JS5m3wtziXVCjluIXyL8pcaukYqezIzZQA==",
+			"version": "10.2.1",
+			"resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-10.2.1.tgz",
+			"integrity": "sha512-NgOPbRiaQM10DYXvN3/hhGVI2M5MtITFryzBGxHM5p4wnFxsVCbxkrBrDsk+EZ5OB4jEOT7AjDxtdF+KVEFT7w==",
 			"dev": true,
 			"license": "ISC",
 			"dependencies": {
-				"@npmcli/agent": "^2.0.0",
-				"cacache": "^18.0.0",
-				"http-cache-semantics": "^4.1.1",
+				"agentkeepalive": "^4.2.1",
+				"cacache": "^16.1.0",
+				"http-cache-semantics": "^4.1.0",
+				"http-proxy-agent": "^5.0.0",
+				"https-proxy-agent": "^5.0.0",
 				"is-lambda": "^1.0.1",
-				"minipass": "^7.0.2",
-				"minipass-fetch": "^3.0.0",
+				"lru-cache": "^7.7.1",
+				"minipass": "^3.1.6",
+				"minipass-collect": "^1.0.2",
+				"minipass-fetch": "^2.0.3",
 				"minipass-flush": "^1.0.5",
 				"minipass-pipeline": "^1.2.4",
 				"negotiator": "^0.6.3",
-				"proc-log": "^4.2.0",
 				"promise-retry": "^2.0.1",
-				"ssri": "^10.0.0"
+				"socks-proxy-agent": "^7.0.0",
+				"ssri": "^9.0.0"
 			},
 			"engines": {
-				"node": "^16.14.0 || >=18.0.0"
+				"node": "^12.13.0 || ^14.15.0 || >=16.0.0"
+			}
+		},
+		"node_modules/make-fetch-happen/node_modules/https-proxy-agent": {
+			"version": "5.0.1",
+			"resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz",
+			"integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"agent-base": "6",
+				"debug": "4"
+			},
+			"engines": {
+				"node": ">= 6"
+			}
+		},
+		"node_modules/make-fetch-happen/node_modules/lru-cache": {
+			"version": "7.18.3",
+			"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz",
+			"integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==",
+			"dev": true,
+			"license": "ISC",
+			"engines": {
+				"node": ">=12"
 			}
 		},
 		"node_modules/matcher": {
@@ -13825,6 +14603,7 @@
 			"resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
 			"integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.6"
 			}
@@ -13834,6 +14613,7 @@
 			"resolved": "https://registry.npmjs.org/memfs/-/memfs-4.12.0.tgz",
 			"integrity": "sha512-74wDsex5tQDSClVkeK1vtxqYCAgCoXxx+K4NSHzgU/muYVYByFqa+0RnrPO9NM6naWm1+G9JmZ0p6QHhXmeYfA==",
 			"dev": true,
+			"license": "Apache-2.0",
 			"dependencies": {
 				"@jsonjoy.com/json-pack": "^1.0.3",
 				"@jsonjoy.com/util": "^1.3.0",
@@ -13862,6 +14642,7 @@
 			"resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
 			"integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==",
 			"dev": true,
+			"license": "MIT",
 			"funding": {
 				"url": "https://github.com/sponsors/sindresorhus"
 			}
@@ -13888,14 +14669,15 @@
 			"resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
 			"integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.6"
 			}
 		},
 		"node_modules/micromatch": {
-			"version": "4.0.7",
-			"resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.7.tgz",
-			"integrity": "sha512-LPP/3KorzCwBxfeUuZmaR6bG2kdeHSbe0P2tY3FLRU4vYrjYz5hI4QZwV0njUx3jeuKe67YukQ1LSPZBKDqO/Q==",
+			"version": "4.0.8",
+			"resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
+			"integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
@@ -14045,16 +14827,19 @@
 			"license": "MIT"
 		},
 		"node_modules/minimatch": {
-			"version": "5.1.6",
-			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
-			"integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
+			"version": "10.0.1",
+			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.0.1.tgz",
+			"integrity": "sha512-ethXTt3SGGR+95gudmqJ1eNhRO7eGEGIgYA9vnPatK4/etz2MEVDno5GMCibdMTuBMyElzIlgxMna3K94XDIDQ==",
 			"dev": true,
 			"license": "ISC",
 			"dependencies": {
 				"brace-expansion": "^2.0.1"
 			},
 			"engines": {
-				"node": ">=10"
+				"node": "20 || >=22"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/isaacs"
 			}
 		},
 		"node_modules/minimist": {
@@ -14068,41 +14853,44 @@
 			}
 		},
 		"node_modules/minipass": {
-			"version": "7.1.2",
-			"resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
-			"integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
+			"version": "3.3.6",
+			"resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+			"integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
 			"dev": true,
 			"license": "ISC",
+			"dependencies": {
+				"yallist": "^4.0.0"
+			},
 			"engines": {
-				"node": ">=16 || 14 >=14.17"
+				"node": ">=8"
 			}
 		},
 		"node_modules/minipass-collect": {
-			"version": "2.0.1",
-			"resolved": "https://registry.npmjs.org/minipass-collect/-/minipass-collect-2.0.1.tgz",
-			"integrity": "sha512-D7V8PO9oaz7PWGLbCACuI1qEOsq7UKfLotx/C0Aet43fCUB/wfQ7DYeq2oR/svFJGYDHPr38SHATeaj/ZoKHKw==",
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/minipass-collect/-/minipass-collect-1.0.2.tgz",
+			"integrity": "sha512-6T6lH0H8OG9kITm/Jm6tdooIbogG9e0tLgpY6mphXSm/A9u8Nq1ryBG+Qspiub9LjWlBPsPS3tWQ/Botq4FdxA==",
 			"dev": true,
 			"license": "ISC",
 			"dependencies": {
-				"minipass": "^7.0.3"
+				"minipass": "^3.0.0"
 			},
 			"engines": {
-				"node": ">=16 || 14 >=14.17"
+				"node": ">= 8"
 			}
 		},
 		"node_modules/minipass-fetch": {
-			"version": "3.0.5",
-			"resolved": "https://registry.npmjs.org/minipass-fetch/-/minipass-fetch-3.0.5.tgz",
-			"integrity": "sha512-2N8elDQAtSnFV0Dk7gt15KHsS0Fyz6CbYZ360h0WTYV1Ty46li3rAXVOQj1THMNLdmrD9Vt5pBPtWtVkpwGBqg==",
+			"version": "2.1.2",
+			"resolved": "https://registry.npmjs.org/minipass-fetch/-/minipass-fetch-2.1.2.tgz",
+			"integrity": "sha512-LT49Zi2/WMROHYoqGgdlQIZh8mLPZmOrN2NdJjMXxYe4nkN6FUyuPuOAOedNJDrx0IRGg9+4guZewtp8hE6TxA==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"minipass": "^7.0.3",
+				"minipass": "^3.1.6",
 				"minipass-sized": "^1.0.3",
 				"minizlib": "^2.1.2"
 			},
 			"engines": {
-				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+				"node": "^12.13.0 || ^14.15.0 || >=16.0.0"
 			},
 			"optionalDependencies": {
 				"encoding": "^0.1.13"
@@ -14121,26 +14909,6 @@
 				"node": ">= 8"
 			}
 		},
-		"node_modules/minipass-flush/node_modules/minipass": {
-			"version": "3.3.6",
-			"resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
-			"integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
-			"dev": true,
-			"license": "ISC",
-			"dependencies": {
-				"yallist": "^4.0.0"
-			},
-			"engines": {
-				"node": ">=8"
-			}
-		},
-		"node_modules/minipass-flush/node_modules/yallist": {
-			"version": "4.0.0",
-			"resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
-			"integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
-			"dev": true,
-			"license": "ISC"
-		},
 		"node_modules/minipass-pipeline": {
 			"version": "1.2.4",
 			"resolved": "https://registry.npmjs.org/minipass-pipeline/-/minipass-pipeline-1.2.4.tgz",
@@ -14154,26 +14922,6 @@
 				"node": ">=8"
 			}
 		},
-		"node_modules/minipass-pipeline/node_modules/minipass": {
-			"version": "3.3.6",
-			"resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
-			"integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
-			"dev": true,
-			"license": "ISC",
-			"dependencies": {
-				"yallist": "^4.0.0"
-			},
-			"engines": {
-				"node": ">=8"
-			}
-		},
-		"node_modules/minipass-pipeline/node_modules/yallist": {
-			"version": "4.0.0",
-			"resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
-			"integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
-			"dev": true,
-			"license": "ISC"
-		},
 		"node_modules/minipass-sized": {
 			"version": "1.0.3",
 			"resolved": "https://registry.npmjs.org/minipass-sized/-/minipass-sized-1.0.3.tgz",
@@ -14187,20 +14935,7 @@
 				"node": ">=8"
 			}
 		},
-		"node_modules/minipass-sized/node_modules/minipass": {
-			"version": "3.3.6",
-			"resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
-			"integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
-			"dev": true,
-			"license": "ISC",
-			"dependencies": {
-				"yallist": "^4.0.0"
-			},
-			"engines": {
-				"node": ">=8"
-			}
-		},
-		"node_modules/minipass-sized/node_modules/yallist": {
+		"node_modules/minipass/node_modules/yallist": {
 			"version": "4.0.0",
 			"resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
 			"integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
@@ -14221,19 +14956,6 @@
 				"node": ">= 8"
 			}
 		},
-		"node_modules/minizlib/node_modules/minipass": {
-			"version": "3.3.6",
-			"resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
-			"integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
-			"dev": true,
-			"license": "ISC",
-			"dependencies": {
-				"yallist": "^4.0.0"
-			},
-			"engines": {
-				"node": ">=8"
-			}
-		},
 		"node_modules/minizlib/node_modules/yallist": {
 			"version": "4.0.0",
 			"resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
@@ -14272,14 +14994,15 @@
 			"resolved": "https://registry.npmjs.org/mrmime/-/mrmime-2.0.0.tgz",
 			"integrity": "sha512-eu38+hdgojoyq63s+yTpN4XMBdt5l8HhMhc4VKLO9KM5caLIBvUm4thi7fFaxyTmCKeNnXZ5pAlBwCUnhA09uw==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">=10"
 			}
 		},
 		"node_modules/ms": {
-			"version": "2.1.2",
-			"resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
-			"integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
+			"version": "2.1.3",
+			"resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+			"integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
 			"dev": true,
 			"license": "MIT"
 		},
@@ -14288,6 +15011,7 @@
 			"resolved": "https://registry.npmjs.org/msgpackr/-/msgpackr-1.11.0.tgz",
 			"integrity": "sha512-I8qXuuALqJe5laEBYoFykChhSXLikZmUhccjGsPuSJ/7uPip2TJ7lwdIQwWSAi0jGZDXv4WOP8Qg65QZRuXxXw==",
 			"dev": true,
+			"license": "MIT",
 			"optionalDependencies": {
 				"msgpackr-extract": "^3.0.2"
 			}
@@ -14298,6 +15022,7 @@
 			"integrity": "sha512-P0efT1C9jIdVRefqjzOQ9Xml57zpOXnIuS+csaB4MdZbTdmGDLo8XhzBG1N7aO11gKDDkJvBLULeFTo46wwreA==",
 			"dev": true,
 			"hasInstallScript": true,
+			"license": "MIT",
 			"optional": true,
 			"dependencies": {
 				"node-gyp-build-optional-packages": "5.2.2"
@@ -14319,6 +15044,7 @@
 			"resolved": "https://registry.npmjs.org/multicast-dns/-/multicast-dns-7.2.5.tgz",
 			"integrity": "sha512-2eznPJP8z2BFLX50tf0LuODrpINqP1RVIm/CObbTcBRITQgmC/TjcREF1NeTBzIcR5XO/ukWo+YHOjBbFwIupg==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"dns-packet": "^5.2.2",
 				"thunky": "^1.0.2"
@@ -14425,6 +15151,7 @@
 			"integrity": "sha512-px/KnJAJZf5RuBGcfD+Sp2pAKq0ytz8j+1NehvgIGFkvtvFrDM3T8E4x/JJODXK9WZow8RRGrbA9QQ3hs+pDhA==",
 			"dev": true,
 			"hasInstallScript": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"!win32"
@@ -14439,6 +15166,7 @@
 			"resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-3.2.1.tgz",
 			"integrity": "sha512-mmcei9JghVNDYydghQmeDX8KoAm0FAiYyIcUt/N4nhyAipB17pllZQDOJD2fotxABnt4Mdz+dKTO7eftLg4d0A==",
 			"dev": true,
+			"license": "MIT",
 			"optional": true
 		},
 		"node_modules/nice-try": {
@@ -14448,6 +15176,19 @@
 			"dev": true,
 			"license": "MIT"
 		},
+		"node_modules/node-abi": {
+			"version": "3.68.0",
+			"resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.68.0.tgz",
+			"integrity": "sha512-7vbj10trelExNjFSBm5kTvZXXa7pZyKWx9RCKIyqe6I9Ev3IzGpQoqBP3a+cOdxY+pWj6VkP28n/2wWysBHD/A==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"semver": "^7.3.5"
+			},
+			"engines": {
+				"node": ">=10"
+			}
+		},
 		"node_modules/node-addon-api": {
 			"version": "1.7.2",
 			"resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-1.7.2.tgz",
@@ -14456,127 +15197,78 @@
 			"license": "MIT",
 			"optional": true
 		},
+		"node_modules/node-api-version": {
+			"version": "0.2.0",
+			"resolved": "https://registry.npmjs.org/node-api-version/-/node-api-version-0.2.0.tgz",
+			"integrity": "sha512-fthTTsi8CxaBXMaBAD7ST2uylwvsnYxh2PfaScwpMhos6KlSFajXQPcM4ogNE1q2s3Lbz9GCGqeIHC+C6OZnKg==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"semver": "^7.3.5"
+			}
+		},
 		"node_modules/node-forge": {
 			"version": "1.3.1",
 			"resolved": "https://registry.npmjs.org/node-forge/-/node-forge-1.3.1.tgz",
 			"integrity": "sha512-dPEtOeMvF9VMcYV/1Wb8CPoVAXtp6MKMlcbAt4ddqmGqUJ6fQZFXkNZNkNlfevtNkGtaSoXf/vNNNSvgrdXwtA==",
 			"dev": true,
+			"license": "(BSD-3-Clause OR GPL-2.0)",
 			"engines": {
 				"node": ">= 6.13.0"
 			}
 		},
 		"node_modules/node-gyp": {
-			"version": "10.2.0",
-			"resolved": "https://registry.npmjs.org/node-gyp/-/node-gyp-10.2.0.tgz",
-			"integrity": "sha512-sp3FonBAaFe4aYTcFdZUn2NYkbP7xroPGYvQmP4Nl5PxamznItBnNCgjrVTKrEfQynInMsJvZrdmqUnysCJ8rw==",
+			"version": "9.4.1",
+			"resolved": "https://registry.npmjs.org/node-gyp/-/node-gyp-9.4.1.tgz",
+			"integrity": "sha512-OQkWKbjQKbGkMf/xqI1jjy3oCTgMKJac58G2+bjZb3fza6gW2YrCSdMQYaoTb70crvE//Gngr4f0AgVHmqHvBQ==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"env-paths": "^2.2.0",
 				"exponential-backoff": "^3.1.1",
-				"glob": "^10.3.10",
+				"glob": "^7.1.4",
 				"graceful-fs": "^4.2.6",
-				"make-fetch-happen": "^13.0.0",
-				"nopt": "^7.0.0",
-				"proc-log": "^4.1.0",
+				"make-fetch-happen": "^10.0.3",
+				"nopt": "^6.0.0",
+				"npmlog": "^6.0.0",
+				"rimraf": "^3.0.2",
 				"semver": "^7.3.5",
-				"tar": "^6.2.1",
-				"which": "^4.0.0"
-			},
-			"bin": {
-				"node-gyp": "bin/node-gyp.js"
-			},
-			"engines": {
-				"node": "^16.14.0 || >=18.0.0"
-			}
-		},
-		"node_modules/node-gyp-build": {
-			"version": "4.8.2",
-			"resolved": "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.8.2.tgz",
-			"integrity": "sha512-IRUxE4BVsHWXkV/SFOut4qTlagw2aM8T5/vnTsmrHJvVoKueJHRc/JaFND7QDDc61kLYUJ6qlZM3sqTSyx2dTw==",
-			"dev": true,
-			"optional": true,
-			"bin": {
-				"node-gyp-build": "bin.js",
-				"node-gyp-build-optional": "optional.js",
-				"node-gyp-build-test": "build-test.js"
-			}
-		},
-		"node_modules/node-gyp-build-optional-packages": {
-			"version": "5.2.2",
-			"resolved": "https://registry.npmjs.org/node-gyp-build-optional-packages/-/node-gyp-build-optional-packages-5.2.2.tgz",
-			"integrity": "sha512-s+w+rBWnpTMwSFbaE0UXsRlg7hU4FjekKU4eyAih5T8nJuNZT1nNsskXpxmeqSK9UzkBl6UgRlnKc8hz8IEqOw==",
-			"dev": true,
-			"dependencies": {
-				"detect-libc": "^2.0.1"
-			},
-			"bin": {
-				"node-gyp-build-optional-packages": "bin.js",
-				"node-gyp-build-optional-packages-optional": "optional.js",
-				"node-gyp-build-optional-packages-test": "build-test.js"
-			}
-		},
-		"node_modules/node-gyp/node_modules/glob": {
-			"version": "10.4.5",
-			"resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
-			"integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==",
-			"dev": true,
-			"license": "ISC",
-			"dependencies": {
-				"foreground-child": "^3.1.0",
-				"jackspeak": "^3.1.2",
-				"minimatch": "^9.0.4",
-				"minipass": "^7.1.2",
-				"package-json-from-dist": "^1.0.0",
-				"path-scurry": "^1.11.1"
-			},
-			"bin": {
-				"glob": "dist/esm/bin.mjs"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/isaacs"
-			}
-		},
-		"node_modules/node-gyp/node_modules/isexe": {
-			"version": "3.1.1",
-			"resolved": "https://registry.npmjs.org/isexe/-/isexe-3.1.1.tgz",
-			"integrity": "sha512-LpB/54B+/2J5hqQ7imZHfdU31OlgQqx7ZicVlkm9kzg9/w8GKLEcFfJl/t7DCEDueOyBAD6zCCwTO6Fzs0NoEQ==",
-			"dev": true,
-			"license": "ISC",
+				"tar": "^6.1.2",
+				"which": "^2.0.2"
+			},
+			"bin": {
+				"node-gyp": "bin/node-gyp.js"
+			},
 			"engines": {
-				"node": ">=16"
+				"node": "^12.13 || ^14.13 || >=16"
 			}
 		},
-		"node_modules/node-gyp/node_modules/minimatch": {
-			"version": "9.0.5",
-			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
-			"integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+		"node_modules/node-gyp-build": {
+			"version": "4.8.2",
+			"resolved": "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.8.2.tgz",
+			"integrity": "sha512-IRUxE4BVsHWXkV/SFOut4qTlagw2aM8T5/vnTsmrHJvVoKueJHRc/JaFND7QDDc61kLYUJ6qlZM3sqTSyx2dTw==",
 			"dev": true,
-			"license": "ISC",
-			"dependencies": {
-				"brace-expansion": "^2.0.1"
-			},
-			"engines": {
-				"node": ">=16 || 14 >=14.17"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/isaacs"
+			"license": "MIT",
+			"optional": true,
+			"bin": {
+				"node-gyp-build": "bin.js",
+				"node-gyp-build-optional": "optional.js",
+				"node-gyp-build-test": "build-test.js"
 			}
 		},
-		"node_modules/node-gyp/node_modules/which": {
-			"version": "4.0.0",
-			"resolved": "https://registry.npmjs.org/which/-/which-4.0.0.tgz",
-			"integrity": "sha512-GlaYyEb07DPxYCKhKzplCWBJtvxZcZMrL+4UkrTSJHHPyZU4mYYTv3qaOe77H7EODLSSopAUFAc6W8U4yqvscg==",
+		"node_modules/node-gyp-build-optional-packages": {
+			"version": "5.2.2",
+			"resolved": "https://registry.npmjs.org/node-gyp-build-optional-packages/-/node-gyp-build-optional-packages-5.2.2.tgz",
+			"integrity": "sha512-s+w+rBWnpTMwSFbaE0UXsRlg7hU4FjekKU4eyAih5T8nJuNZT1nNsskXpxmeqSK9UzkBl6UgRlnKc8hz8IEqOw==",
 			"dev": true,
-			"license": "ISC",
+			"license": "MIT",
 			"dependencies": {
-				"isexe": "^3.1.1"
+				"detect-libc": "^2.0.1"
 			},
 			"bin": {
-				"node-which": "bin/which.js"
-			},
-			"engines": {
-				"node": "^16.13.0 || >=18.0.0"
+				"node-gyp-build-optional-packages": "bin.js",
+				"node-gyp-build-optional-packages-optional": "optional.js",
+				"node-gyp-build-optional-packages-test": "build-test.js"
 			}
 		},
 		"node_modules/node-polyfill-webpack-plugin": {
@@ -14661,9 +15353,9 @@
 			}
 		},
 		"node_modules/node-polyfill-webpack-plugin/node_modules/type-fest": {
-			"version": "4.25.0",
-			"resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.25.0.tgz",
-			"integrity": "sha512-bRkIGlXsnGBRBQRAY56UXBm//9qH4bmJfFvq83gSz41N282df+fjy8ofcEgc1sM8geNt5cl6mC2g9Fht1cs8Aw==",
+			"version": "4.26.1",
+			"resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.26.1.tgz",
+			"integrity": "sha512-yOGpmOAL7CkKe/91I5O3gPICmJNLJ1G4zFYVAsRHg7M64biSnPtRj0WNQt++bRkjYOqjWXrhnUw1utzmVErAdg==",
 			"dev": true,
 			"license": "(MIT OR CC0-1.0)",
 			"engines": {
@@ -14681,19 +15373,19 @@
 			"license": "MIT"
 		},
 		"node_modules/nopt": {
-			"version": "7.2.1",
-			"resolved": "https://registry.npmjs.org/nopt/-/nopt-7.2.1.tgz",
-			"integrity": "sha512-taM24ViiimT/XntxbPyJQzCG+p4EKOpgD3mxFwW38mGjVUrfERQOeY4EDHjdnptttfHuHQXFx+lTP08Q+mLa/w==",
+			"version": "6.0.0",
+			"resolved": "https://registry.npmjs.org/nopt/-/nopt-6.0.0.tgz",
+			"integrity": "sha512-ZwLpbTgdhuZUnZzjd7nb1ZV+4DoiC6/sfiVKok72ym/4Tlf+DFdlHYmT2JPmcNNWV6Pi3SDf1kT+A4r9RTuT9g==",
 			"dev": true,
 			"license": "ISC",
 			"dependencies": {
-				"abbrev": "^2.0.0"
+				"abbrev": "^1.0.0"
 			},
 			"bin": {
 				"nopt": "bin/nopt.js"
 			},
 			"engines": {
-				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+				"node": "^12.13.0 || ^14.15.0 || >=16.0.0"
 			}
 		},
 		"node_modules/normalize-package-data": {
@@ -14800,89 +15492,287 @@
 				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
 			}
 		},
-		"node_modules/npm-package-arg": {
-			"version": "11.0.3",
-			"resolved": "https://registry.npmjs.org/npm-package-arg/-/npm-package-arg-11.0.3.tgz",
-			"integrity": "sha512-sHGJy8sOC1YraBywpzQlIKBE4pBbGbiF95U6Auspzyem956E0+FtDtsx1ZxlOJkQCZ1AFXAY/yuvtFYrOxF+Bw==",
+		"node_modules/npm-package-arg": {
+			"version": "11.0.3",
+			"resolved": "https://registry.npmjs.org/npm-package-arg/-/npm-package-arg-11.0.3.tgz",
+			"integrity": "sha512-sHGJy8sOC1YraBywpzQlIKBE4pBbGbiF95U6Auspzyem956E0+FtDtsx1ZxlOJkQCZ1AFXAY/yuvtFYrOxF+Bw==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"hosted-git-info": "^7.0.0",
+				"proc-log": "^4.0.0",
+				"semver": "^7.3.5",
+				"validate-npm-package-name": "^5.0.0"
+			},
+			"engines": {
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/npm-package-arg/node_modules/hosted-git-info": {
+			"version": "7.0.2",
+			"resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-7.0.2.tgz",
+			"integrity": "sha512-puUZAUKT5m8Zzvs72XWy3HtvVbTWljRE66cP60bxJzAqf2DgICo7lYTY2IHUmLnNpjYvw5bvmoHvPc0QO2a62w==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"lru-cache": "^10.0.1"
+			},
+			"engines": {
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/npm-package-arg/node_modules/lru-cache": {
+			"version": "10.4.3",
+			"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+			"integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+			"dev": true,
+			"license": "ISC"
+		},
+		"node_modules/npm-packlist": {
+			"version": "8.0.2",
+			"resolved": "https://registry.npmjs.org/npm-packlist/-/npm-packlist-8.0.2.tgz",
+			"integrity": "sha512-shYrPFIS/JLP4oQmAwDyk5HcyysKW8/JLTEA32S0Z5TzvpaeeX2yMFfoK1fjEBnCBvVyIB/Jj/GBFdm0wsgzbA==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"ignore-walk": "^6.0.4"
+			},
+			"engines": {
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+			}
+		},
+		"node_modules/npm-pick-manifest": {
+			"version": "9.1.0",
+			"resolved": "https://registry.npmjs.org/npm-pick-manifest/-/npm-pick-manifest-9.1.0.tgz",
+			"integrity": "sha512-nkc+3pIIhqHVQr085X9d2JzPzLyjzQS96zbruppqC9aZRm/x8xx6xhI98gHtsfELP2bE+loHq8ZaHFHhe+NauA==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"npm-install-checks": "^6.0.0",
+				"npm-normalize-package-bin": "^3.0.0",
+				"npm-package-arg": "^11.0.0",
+				"semver": "^7.3.5"
+			},
+			"engines": {
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/npm-registry-fetch": {
+			"version": "17.1.0",
+			"resolved": "https://registry.npmjs.org/npm-registry-fetch/-/npm-registry-fetch-17.1.0.tgz",
+			"integrity": "sha512-5+bKQRH0J1xG1uZ1zMNvxW0VEyoNWgJpY9UDuluPFLKDfJ9u2JmmjmTJV1srBGQOROfdBMiVvnH2Zvpbm+xkVA==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"@npmcli/redact": "^2.0.0",
+				"jsonparse": "^1.3.1",
+				"make-fetch-happen": "^13.0.0",
+				"minipass": "^7.0.2",
+				"minipass-fetch": "^3.0.0",
+				"minizlib": "^2.1.2",
+				"npm-package-arg": "^11.0.0",
+				"proc-log": "^4.0.0"
+			},
+			"engines": {
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/npm-registry-fetch/node_modules/@npmcli/fs": {
+			"version": "3.1.1",
+			"resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-3.1.1.tgz",
+			"integrity": "sha512-q9CRWjpHCMIh5sVyefoD1cA7PkvILqCZsnSOEUUivORLjxCO/Irmue2DprETiNgEqktDBZaM1Bi+jrarx1XdCg==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"semver": "^7.3.5"
+			},
+			"engines": {
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+			}
+		},
+		"node_modules/npm-registry-fetch/node_modules/cacache": {
+			"version": "18.0.4",
+			"resolved": "https://registry.npmjs.org/cacache/-/cacache-18.0.4.tgz",
+			"integrity": "sha512-B+L5iIa9mgcjLbliir2th36yEwPftrzteHYujzsx3dFP/31GCHcIeS8f5MGd80odLOjaOvSpU3EEAmRQptkxLQ==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"@npmcli/fs": "^3.1.0",
+				"fs-minipass": "^3.0.0",
+				"glob": "^10.2.2",
+				"lru-cache": "^10.0.1",
+				"minipass": "^7.0.3",
+				"minipass-collect": "^2.0.1",
+				"minipass-flush": "^1.0.5",
+				"minipass-pipeline": "^1.2.4",
+				"p-map": "^4.0.0",
+				"ssri": "^10.0.0",
+				"tar": "^6.1.11",
+				"unique-filename": "^3.0.0"
+			},
+			"engines": {
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/npm-registry-fetch/node_modules/fs-minipass": {
+			"version": "3.0.3",
+			"resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-3.0.3.tgz",
+			"integrity": "sha512-XUBA9XClHbnJWSfBzjkm6RvPsyg3sryZt06BEQoXcF7EK/xpGaQYJgQKDJSUH5SGZ76Y7pFx1QBnXz09rU5Fbw==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"minipass": "^7.0.3"
+			},
+			"engines": {
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+			}
+		},
+		"node_modules/npm-registry-fetch/node_modules/glob": {
+			"version": "10.4.5",
+			"resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
+			"integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"foreground-child": "^3.1.0",
+				"jackspeak": "^3.1.2",
+				"minimatch": "^9.0.4",
+				"minipass": "^7.1.2",
+				"package-json-from-dist": "^1.0.0",
+				"path-scurry": "^1.11.1"
+			},
+			"bin": {
+				"glob": "dist/esm/bin.mjs"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/isaacs"
+			}
+		},
+		"node_modules/npm-registry-fetch/node_modules/lru-cache": {
+			"version": "10.4.3",
+			"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+			"integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+			"dev": true,
+			"license": "ISC"
+		},
+		"node_modules/npm-registry-fetch/node_modules/make-fetch-happen": {
+			"version": "13.0.1",
+			"resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-13.0.1.tgz",
+			"integrity": "sha512-cKTUFc/rbKUd/9meOvgrpJ2WrNzymt6jfRDdwg5UCnVzv9dTpEj9JS5m3wtziXVCjluIXyL8pcaukYqezIzZQA==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"@npmcli/agent": "^2.0.0",
+				"cacache": "^18.0.0",
+				"http-cache-semantics": "^4.1.1",
+				"is-lambda": "^1.0.1",
+				"minipass": "^7.0.2",
+				"minipass-fetch": "^3.0.0",
+				"minipass-flush": "^1.0.5",
+				"minipass-pipeline": "^1.2.4",
+				"negotiator": "^0.6.3",
+				"proc-log": "^4.2.0",
+				"promise-retry": "^2.0.1",
+				"ssri": "^10.0.0"
+			},
+			"engines": {
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/npm-registry-fetch/node_modules/minimatch": {
+			"version": "9.0.5",
+			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
+			"integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"brace-expansion": "^2.0.1"
+			},
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/isaacs"
+			}
+		},
+		"node_modules/npm-registry-fetch/node_modules/minipass": {
+			"version": "7.1.2",
+			"resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
+			"integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
+			"dev": true,
+			"license": "ISC",
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
+			}
+		},
+		"node_modules/npm-registry-fetch/node_modules/minipass-collect": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/minipass-collect/-/minipass-collect-2.0.1.tgz",
+			"integrity": "sha512-D7V8PO9oaz7PWGLbCACuI1qEOsq7UKfLotx/C0Aet43fCUB/wfQ7DYeq2oR/svFJGYDHPr38SHATeaj/ZoKHKw==",
 			"dev": true,
 			"license": "ISC",
 			"dependencies": {
-				"hosted-git-info": "^7.0.0",
-				"proc-log": "^4.0.0",
-				"semver": "^7.3.5",
-				"validate-npm-package-name": "^5.0.0"
+				"minipass": "^7.0.3"
 			},
 			"engines": {
-				"node": "^16.14.0 || >=18.0.0"
+				"node": ">=16 || 14 >=14.17"
 			}
 		},
-		"node_modules/npm-package-arg/node_modules/hosted-git-info": {
-			"version": "7.0.2",
-			"resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-7.0.2.tgz",
-			"integrity": "sha512-puUZAUKT5m8Zzvs72XWy3HtvVbTWljRE66cP60bxJzAqf2DgICo7lYTY2IHUmLnNpjYvw5bvmoHvPc0QO2a62w==",
+		"node_modules/npm-registry-fetch/node_modules/minipass-fetch": {
+			"version": "3.0.5",
+			"resolved": "https://registry.npmjs.org/minipass-fetch/-/minipass-fetch-3.0.5.tgz",
+			"integrity": "sha512-2N8elDQAtSnFV0Dk7gt15KHsS0Fyz6CbYZ360h0WTYV1Ty46li3rAXVOQj1THMNLdmrD9Vt5pBPtWtVkpwGBqg==",
 			"dev": true,
-			"license": "ISC",
+			"license": "MIT",
 			"dependencies": {
-				"lru-cache": "^10.0.1"
+				"minipass": "^7.0.3",
+				"minipass-sized": "^1.0.3",
+				"minizlib": "^2.1.2"
 			},
 			"engines": {
-				"node": "^16.14.0 || >=18.0.0"
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+			},
+			"optionalDependencies": {
+				"encoding": "^0.1.13"
 			}
 		},
-		"node_modules/npm-package-arg/node_modules/lru-cache": {
-			"version": "10.4.3",
-			"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
-			"integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
-			"dev": true,
-			"license": "ISC"
-		},
-		"node_modules/npm-packlist": {
-			"version": "8.0.2",
-			"resolved": "https://registry.npmjs.org/npm-packlist/-/npm-packlist-8.0.2.tgz",
-			"integrity": "sha512-shYrPFIS/JLP4oQmAwDyk5HcyysKW8/JLTEA32S0Z5TzvpaeeX2yMFfoK1fjEBnCBvVyIB/Jj/GBFdm0wsgzbA==",
+		"node_modules/npm-registry-fetch/node_modules/ssri": {
+			"version": "10.0.6",
+			"resolved": "https://registry.npmjs.org/ssri/-/ssri-10.0.6.tgz",
+			"integrity": "sha512-MGrFH9Z4NP9Iyhqn16sDtBpRRNJ0Y2hNa6D65h736fVSaPCHr4DM4sWUNvVaSuC+0OBGhwsrydQwmgfg5LncqQ==",
 			"dev": true,
 			"license": "ISC",
 			"dependencies": {
-				"ignore-walk": "^6.0.4"
+				"minipass": "^7.0.3"
 			},
 			"engines": {
 				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
 			}
 		},
-		"node_modules/npm-pick-manifest": {
-			"version": "9.1.0",
-			"resolved": "https://registry.npmjs.org/npm-pick-manifest/-/npm-pick-manifest-9.1.0.tgz",
-			"integrity": "sha512-nkc+3pIIhqHVQr085X9d2JzPzLyjzQS96zbruppqC9aZRm/x8xx6xhI98gHtsfELP2bE+loHq8ZaHFHhe+NauA==",
+		"node_modules/npm-registry-fetch/node_modules/unique-filename": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-3.0.0.tgz",
+			"integrity": "sha512-afXhuC55wkAmZ0P18QsVE6kp8JaxrEokN2HGIoIVv2ijHQd419H0+6EigAFcIzXeMIkcIkNBpB3L/DXB3cTS/g==",
 			"dev": true,
 			"license": "ISC",
 			"dependencies": {
-				"npm-install-checks": "^6.0.0",
-				"npm-normalize-package-bin": "^3.0.0",
-				"npm-package-arg": "^11.0.0",
-				"semver": "^7.3.5"
+				"unique-slug": "^4.0.0"
 			},
 			"engines": {
-				"node": "^16.14.0 || >=18.0.0"
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
 			}
 		},
-		"node_modules/npm-registry-fetch": {
-			"version": "17.1.0",
-			"resolved": "https://registry.npmjs.org/npm-registry-fetch/-/npm-registry-fetch-17.1.0.tgz",
-			"integrity": "sha512-5+bKQRH0J1xG1uZ1zMNvxW0VEyoNWgJpY9UDuluPFLKDfJ9u2JmmjmTJV1srBGQOROfdBMiVvnH2Zvpbm+xkVA==",
+		"node_modules/npm-registry-fetch/node_modules/unique-slug": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-4.0.0.tgz",
+			"integrity": "sha512-WrcA6AyEfqDX5bWige/4NQfPZMtASNVxdmWR76WESYQVAACSgWcR6e9i0mofqqBxYFtL4oAxPIptY73/0YE1DQ==",
 			"dev": true,
 			"license": "ISC",
 			"dependencies": {
-				"@npmcli/redact": "^2.0.0",
-				"jsonparse": "^1.3.1",
-				"make-fetch-happen": "^13.0.0",
-				"minipass": "^7.0.2",
-				"minipass-fetch": "^3.0.0",
-				"minizlib": "^2.1.2",
-				"npm-package-arg": "^11.0.0",
-				"proc-log": "^4.0.0"
+				"imurmurhash": "^0.1.4"
 			},
 			"engines": {
-				"node": "^16.14.0 || >=18.0.0"
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
 			}
 		},
 		"node_modules/npm-run-all": {
@@ -15013,6 +15903,7 @@
 			"resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz",
 			"integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"path-key": "^3.0.0"
 			},
@@ -15020,11 +15911,29 @@
 				"node": ">=8"
 			}
 		},
+		"node_modules/npmlog": {
+			"version": "6.0.2",
+			"resolved": "https://registry.npmjs.org/npmlog/-/npmlog-6.0.2.tgz",
+			"integrity": "sha512-/vBvz5Jfr9dT/aFWd0FIRf+T/Q2WBsLENygUaFUqstqsycmZAP/t5BvFJTK0viFmSUxiUKTUplWy5vt+rvKIxg==",
+			"deprecated": "This package is no longer supported.",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"are-we-there-yet": "^3.0.0",
+				"console-control-strings": "^1.1.0",
+				"gauge": "^4.0.3",
+				"set-blocking": "^2.0.0"
+			},
+			"engines": {
+				"node": "^12.13.0 || ^14.15.0 || >=16.0.0"
+			}
+		},
 		"node_modules/nth-check": {
 			"version": "2.1.1",
 			"resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz",
 			"integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==",
 			"dev": true,
+			"license": "BSD-2-Clause",
 			"dependencies": {
 				"boolbase": "^1.0.0"
 			},
@@ -15104,13 +16013,15 @@
 			"version": "1.1.2",
 			"resolved": "https://registry.npmjs.org/obuf/-/obuf-1.1.2.tgz",
 			"integrity": "sha512-PX1wu0AmAdPqOL1mWhqmlOd8kOIZQwGZw6rh7uby9fTc5lhaOWFLX3I6R1hrF9k3zUY40e6igsLGkDXK92LJNg==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/on-finished": {
 			"version": "2.4.1",
 			"resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
 			"integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"ee-first": "1.1.1"
 			},
@@ -15123,6 +16034,7 @@
 			"resolved": "https://registry.npmjs.org/on-headers/-/on-headers-1.0.2.tgz",
 			"integrity": "sha512-pZAE+FJLoyITytdqK0U5s+FIpjN0JP3OzFi/u8Rx+EV5/W+JTWGXG8xFzevE7AjBfDqHv/8vL8qQsIhHnqRkrA==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.8"
 			}
@@ -15158,6 +16070,7 @@
 			"resolved": "https://registry.npmjs.org/open/-/open-10.1.0.tgz",
 			"integrity": "sha512-mnkeQ1qP5Ue2wd+aivTD3NHd/lZ96Lu0jgf0pwktLPtx6cTZiH7tyeGRRHs0zX0rbrahXPnXlUnbeXyaBBuIaw==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"default-browser": "^5.2.1",
 				"define-lazy-prop": "^3.0.0",
@@ -15343,7 +16256,8 @@
 			"version": "1.5.2",
 			"resolved": "https://registry.npmjs.org/ordered-binary/-/ordered-binary-1.5.2.tgz",
 			"integrity": "sha512-JTo+4+4Fw7FreyAvlSLjb1BBVaxEQAacmjD3jjuyPZclpbEghTvQZbXBb2qPd2LeIMxiHwXBZUcpmG2Gl/mDEA==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/os-browserify": {
 			"version": "0.3.0",
@@ -15434,6 +16348,7 @@
 			"resolved": "https://registry.npmjs.org/p-retry/-/p-retry-6.2.0.tgz",
 			"integrity": "sha512-JA6nkq6hKyWLLasXQXUrO4z8BUZGUt/LjlJxx8Gb2+2ntodU/SS63YZ8b0LUTbQ8ZB9iwOfhEPhg4ykKnn2KsA==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@types/retry": "0.12.2",
 				"is-network-error": "^1.0.0",
@@ -15446,52 +16361,209 @@
 				"url": "https://github.com/sponsors/sindresorhus"
 			}
 		},
-		"node_modules/p-retry/node_modules/retry": {
-			"version": "0.13.1",
-			"resolved": "https://registry.npmjs.org/retry/-/retry-0.13.1.tgz",
-			"integrity": "sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==",
+		"node_modules/p-retry/node_modules/retry": {
+			"version": "0.13.1",
+			"resolved": "https://registry.npmjs.org/retry/-/retry-0.13.1.tgz",
+			"integrity": "sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==",
+			"dev": true,
+			"license": "MIT",
+			"engines": {
+				"node": ">= 4"
+			}
+		},
+		"node_modules/package-json-from-dist": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
+			"integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==",
+			"dev": true,
+			"license": "BlueOak-1.0.0"
+		},
+		"node_modules/pacote": {
+			"version": "18.0.6",
+			"resolved": "https://registry.npmjs.org/pacote/-/pacote-18.0.6.tgz",
+			"integrity": "sha512-+eK3G27SMwsB8kLIuj4h1FUhHtwiEUo21Tw8wNjmvdlpOEr613edv+8FUsTj/4F/VN5ywGE19X18N7CC2EJk6A==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"@npmcli/git": "^5.0.0",
+				"@npmcli/installed-package-contents": "^2.0.1",
+				"@npmcli/package-json": "^5.1.0",
+				"@npmcli/promise-spawn": "^7.0.0",
+				"@npmcli/run-script": "^8.0.0",
+				"cacache": "^18.0.0",
+				"fs-minipass": "^3.0.0",
+				"minipass": "^7.0.2",
+				"npm-package-arg": "^11.0.0",
+				"npm-packlist": "^8.0.0",
+				"npm-pick-manifest": "^9.0.0",
+				"npm-registry-fetch": "^17.0.0",
+				"proc-log": "^4.0.0",
+				"promise-retry": "^2.0.1",
+				"sigstore": "^2.2.0",
+				"ssri": "^10.0.0",
+				"tar": "^6.1.11"
+			},
+			"bin": {
+				"pacote": "bin/index.js"
+			},
+			"engines": {
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/pacote/node_modules/@npmcli/fs": {
+			"version": "3.1.1",
+			"resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-3.1.1.tgz",
+			"integrity": "sha512-q9CRWjpHCMIh5sVyefoD1cA7PkvILqCZsnSOEUUivORLjxCO/Irmue2DprETiNgEqktDBZaM1Bi+jrarx1XdCg==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"semver": "^7.3.5"
+			},
+			"engines": {
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+			}
+		},
+		"node_modules/pacote/node_modules/cacache": {
+			"version": "18.0.4",
+			"resolved": "https://registry.npmjs.org/cacache/-/cacache-18.0.4.tgz",
+			"integrity": "sha512-B+L5iIa9mgcjLbliir2th36yEwPftrzteHYujzsx3dFP/31GCHcIeS8f5MGd80odLOjaOvSpU3EEAmRQptkxLQ==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"@npmcli/fs": "^3.1.0",
+				"fs-minipass": "^3.0.0",
+				"glob": "^10.2.2",
+				"lru-cache": "^10.0.1",
+				"minipass": "^7.0.3",
+				"minipass-collect": "^2.0.1",
+				"minipass-flush": "^1.0.5",
+				"minipass-pipeline": "^1.2.4",
+				"p-map": "^4.0.0",
+				"ssri": "^10.0.0",
+				"tar": "^6.1.11",
+				"unique-filename": "^3.0.0"
+			},
+			"engines": {
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/pacote/node_modules/fs-minipass": {
+			"version": "3.0.3",
+			"resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-3.0.3.tgz",
+			"integrity": "sha512-XUBA9XClHbnJWSfBzjkm6RvPsyg3sryZt06BEQoXcF7EK/xpGaQYJgQKDJSUH5SGZ76Y7pFx1QBnXz09rU5Fbw==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"minipass": "^7.0.3"
+			},
+			"engines": {
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+			}
+		},
+		"node_modules/pacote/node_modules/glob": {
+			"version": "10.4.5",
+			"resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
+			"integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"foreground-child": "^3.1.0",
+				"jackspeak": "^3.1.2",
+				"minimatch": "^9.0.4",
+				"minipass": "^7.1.2",
+				"package-json-from-dist": "^1.0.0",
+				"path-scurry": "^1.11.1"
+			},
+			"bin": {
+				"glob": "dist/esm/bin.mjs"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/isaacs"
+			}
+		},
+		"node_modules/pacote/node_modules/lru-cache": {
+			"version": "10.4.3",
+			"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+			"integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+			"dev": true,
+			"license": "ISC"
+		},
+		"node_modules/pacote/node_modules/minimatch": {
+			"version": "9.0.5",
+			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
+			"integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"brace-expansion": "^2.0.1"
+			},
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/isaacs"
+			}
+		},
+		"node_modules/pacote/node_modules/minipass": {
+			"version": "7.1.2",
+			"resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
+			"integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
+			"dev": true,
+			"license": "ISC",
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
+			}
+		},
+		"node_modules/pacote/node_modules/minipass-collect": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/minipass-collect/-/minipass-collect-2.0.1.tgz",
+			"integrity": "sha512-D7V8PO9oaz7PWGLbCACuI1qEOsq7UKfLotx/C0Aet43fCUB/wfQ7DYeq2oR/svFJGYDHPr38SHATeaj/ZoKHKw==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"minipass": "^7.0.3"
+			},
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
+			}
+		},
+		"node_modules/pacote/node_modules/ssri": {
+			"version": "10.0.6",
+			"resolved": "https://registry.npmjs.org/ssri/-/ssri-10.0.6.tgz",
+			"integrity": "sha512-MGrFH9Z4NP9Iyhqn16sDtBpRRNJ0Y2hNa6D65h736fVSaPCHr4DM4sWUNvVaSuC+0OBGhwsrydQwmgfg5LncqQ==",
 			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"minipass": "^7.0.3"
+			},
 			"engines": {
-				"node": ">= 4"
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
 			}
 		},
-		"node_modules/package-json-from-dist": {
-			"version": "1.0.0",
-			"resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.0.tgz",
-			"integrity": "sha512-dATvCeZN/8wQsGywez1mzHtTlP22H8OEfPrVMLNr4/eGa+ijtLn/6M5f0dY8UKNrC2O9UCU6SSoG3qRKnt7STw==",
+		"node_modules/pacote/node_modules/unique-filename": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-3.0.0.tgz",
+			"integrity": "sha512-afXhuC55wkAmZ0P18QsVE6kp8JaxrEokN2HGIoIVv2ijHQd419H0+6EigAFcIzXeMIkcIkNBpB3L/DXB3cTS/g==",
 			"dev": true,
-			"license": "BlueOak-1.0.0"
+			"license": "ISC",
+			"dependencies": {
+				"unique-slug": "^4.0.0"
+			},
+			"engines": {
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+			}
 		},
-		"node_modules/pacote": {
-			"version": "18.0.6",
-			"resolved": "https://registry.npmjs.org/pacote/-/pacote-18.0.6.tgz",
-			"integrity": "sha512-+eK3G27SMwsB8kLIuj4h1FUhHtwiEUo21Tw8wNjmvdlpOEr613edv+8FUsTj/4F/VN5ywGE19X18N7CC2EJk6A==",
+		"node_modules/pacote/node_modules/unique-slug": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-4.0.0.tgz",
+			"integrity": "sha512-WrcA6AyEfqDX5bWige/4NQfPZMtASNVxdmWR76WESYQVAACSgWcR6e9i0mofqqBxYFtL4oAxPIptY73/0YE1DQ==",
 			"dev": true,
 			"license": "ISC",
 			"dependencies": {
-				"@npmcli/git": "^5.0.0",
-				"@npmcli/installed-package-contents": "^2.0.1",
-				"@npmcli/package-json": "^5.1.0",
-				"@npmcli/promise-spawn": "^7.0.0",
-				"@npmcli/run-script": "^8.0.0",
-				"cacache": "^18.0.0",
-				"fs-minipass": "^3.0.0",
-				"minipass": "^7.0.2",
-				"npm-package-arg": "^11.0.0",
-				"npm-packlist": "^8.0.0",
-				"npm-pick-manifest": "^9.0.0",
-				"npm-registry-fetch": "^17.0.0",
-				"proc-log": "^4.0.0",
-				"promise-retry": "^2.0.1",
-				"sigstore": "^2.2.0",
-				"ssri": "^10.0.0",
-				"tar": "^6.1.11"
-			},
-			"bin": {
-				"pacote": "bin/index.js"
+				"imurmurhash": "^0.1.4"
 			},
 			"engines": {
-				"node": "^16.14.0 || >=18.0.0"
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
 			}
 		},
 		"node_modules/pako": {
@@ -15597,6 +16669,7 @@
 			"resolved": "https://registry.npmjs.org/parse5-html-rewriting-stream/-/parse5-html-rewriting-stream-7.0.0.tgz",
 			"integrity": "sha512-mazCyGWkmCRWDI15Zp+UiCqMp/0dgEmkZRvhlsqqKYr4SsVm/TvnSpD9fCvqCA2zoWJcfRym846ejWBBHRiYEg==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"entities": "^4.3.0",
 				"parse5": "^7.0.0",
@@ -15611,6 +16684,7 @@
 			"resolved": "https://registry.npmjs.org/parse5-sax-parser/-/parse5-sax-parser-7.0.0.tgz",
 			"integrity": "sha512-5A+v2SNsq8T6/mG3ahcz8ZtQ0OUFTatxPbeidoMB7tkJSGDY3tdfl4MHovtLQHkEn5CGxijNWRQHhRQ6IRpXKg==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"parse5": "^7.0.0"
 			},
@@ -15623,6 +16697,7 @@
 			"resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
 			"integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.8"
 			}
@@ -15695,11 +16770,22 @@
 			"dev": true,
 			"license": "ISC"
 		},
+		"node_modules/path-scurry/node_modules/minipass": {
+			"version": "7.1.2",
+			"resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
+			"integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
+			"dev": true,
+			"license": "ISC",
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
+			}
+		},
 		"node_modules/path-to-regexp": {
 			"version": "0.1.10",
 			"resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.10.tgz",
 			"integrity": "sha512-7lf7qcQidTku0Gu3YDPc8DJ1q7OOucfa/BSsIwjuh56VU7katFvuM8hULfkwB3Fns/rsVF7PwPKVw1sl5KQS9w==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/path-type": {
 			"version": "5.0.0",
@@ -15731,6 +16817,21 @@
 				"node": ">=0.12"
 			}
 		},
+		"node_modules/pe-library": {
+			"version": "0.4.1",
+			"resolved": "https://registry.npmjs.org/pe-library/-/pe-library-0.4.1.tgz",
+			"integrity": "sha512-eRWB5LBz7PpDu4PUlwT0PhnQfTQJlDDdPa35urV4Osrm0t0AqQFGn+UIkU3klZvwJ8KPO3VbBFsXquA6p6kqZw==",
+			"dev": true,
+			"license": "MIT",
+			"engines": {
+				"node": ">=12",
+				"npm": ">=6"
+			},
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/jet2jet"
+			}
+		},
 		"node_modules/pend": {
 			"version": "1.2.0",
 			"resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
@@ -15742,7 +16843,8 @@
 			"version": "1.1.0",
 			"resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.0.tgz",
 			"integrity": "sha512-TQ92mBOW0l3LeMeyLV6mzy/kWr8lkd/hp3mTg7wYK7zJhuBStmGMBG0BdeDZS/dZx1IukaX6Bk11zcln25o1Aw==",
-			"dev": true
+			"dev": true,
+			"license": "ISC"
 		},
 		"node_modules/picomatch": {
 			"version": "4.0.2",
@@ -15786,6 +16888,7 @@
 			"resolved": "https://registry.npmjs.org/piscina/-/piscina-4.6.1.tgz",
 			"integrity": "sha512-z30AwWGtQE+Apr+2WBZensP2lIvwoaMcOPkQlIEmSGMJNUvaYACylPYrQM6wSdUNJlnDVMSpLv7xTMJqlVshOA==",
 			"dev": true,
+			"license": "MIT",
 			"optionalDependencies": {
 				"nice-napi": "^1.0.2"
 			}
@@ -15984,7 +17087,8 @@
 			"version": "0.2.3",
 			"resolved": "https://registry.npmjs.org/postcss-media-query-parser/-/postcss-media-query-parser-0.2.3.tgz",
 			"integrity": "sha512-3sOlxmbKcSHMjlUXQZKQ06jOswE7oVkXPxmZdoB1r5l0q6gTFTQSHxNxOrCccElbW7dxNytifNEo8qidX2Vsig==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/postcss-modules-extract-imports": {
 			"version": "3.1.0",
@@ -16109,9 +17213,9 @@
 			"license": "MIT"
 		},
 		"node_modules/primeng": {
-			"version": "17.18.9",
-			"resolved": "https://registry.npmjs.org/primeng/-/primeng-17.18.9.tgz",
-			"integrity": "sha512-1FT0B8wtgvs/joduB1DDOLe2IsP1pegOiEfSPAHSbc6otgNx/6iLR0k2M/xr2c9Ur1aC7tAikkVfH3FGpWof3w==",
+			"version": "17.18.11",
+			"resolved": "https://registry.npmjs.org/primeng/-/primeng-17.18.11.tgz",
+			"integrity": "sha512-LzV0fFZmb3GdnaRqi1+GP+RPtW0a+jztL5pH1zRWY7+7pyQ0n1YNyTXzmqVcdks/CmoyjNhutWEmexwi6vFVeA==",
 			"license": "MIT",
 			"dependencies": {
 				"tslib": "^2.3.0"
@@ -16192,6 +17296,7 @@
 			"resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
 			"integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"forwarded": "0.2.0",
 				"ipaddr.js": "1.9.1"
@@ -16205,6 +17310,7 @@
 			"resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
 			"integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.10"
 			}
@@ -16247,9 +17353,9 @@
 			"license": "MIT"
 		},
 		"node_modules/pump": {
-			"version": "3.0.0",
-			"resolved": "https://registry.npmjs.org/pump/-/pump-3.0.0.tgz",
-			"integrity": "sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==",
+			"version": "3.0.2",
+			"resolved": "https://registry.npmjs.org/pump/-/pump-3.0.2.tgz",
+			"integrity": "sha512-tUPXtzlGM8FE3P0ZL6DVs/3P58k9nk8/jZeQCurTJylQA8qFYzHFfhBJkuqyE0FifOsQ0uKWekiZ5g8wtr28cw==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
@@ -16352,6 +17458,7 @@
 			"resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
 			"integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.6"
 			}
@@ -16361,6 +17468,7 @@
 			"resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz",
 			"integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"bytes": "3.1.2",
 				"http-errors": "2.0.0",
@@ -16376,6 +17484,7 @@
 			"resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
 			"integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.8"
 			}
@@ -16385,6 +17494,7 @@
 			"resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
 			"integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"safer-buffer": ">= 2.1.2 < 3"
 			},
@@ -16432,19 +17542,32 @@
 				"selecto": "~1.26.3"
 			}
 		},
+		"node_modules/read-binary-file-arch": {
+			"version": "1.0.6",
+			"resolved": "https://registry.npmjs.org/read-binary-file-arch/-/read-binary-file-arch-1.0.6.tgz",
+			"integrity": "sha512-BNg9EN3DD3GsDXX7Aa8O4p92sryjkmzYYgmgTAc6CA4uGLEDzFfxOxugu21akOxpcXHiEgsYkC6nPsQvLLLmEg==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"debug": "^4.3.4"
+			},
+			"bin": {
+				"read-binary-file-arch": "cli.js"
+			}
+		},
 		"node_modules/read-config-file": {
-			"version": "6.3.2",
-			"resolved": "https://registry.npmjs.org/read-config-file/-/read-config-file-6.3.2.tgz",
-			"integrity": "sha512-M80lpCjnE6Wt6zb98DoW8WHR09nzMSpu8XHtPkiTHrJ5Az9CybfeQhTJ8D7saeBHpGhLPIVyA8lcL6ZmdKwY6Q==",
+			"version": "6.4.0",
+			"resolved": "https://registry.npmjs.org/read-config-file/-/read-config-file-6.4.0.tgz",
+			"integrity": "sha512-uB5QOBeF84PT61GlV11OTV4jUGHAO3iDEOP6v9ygxhG6Bs9PLg7WsjNT6mtIX2G+x8lJTr4ZWNeG6LDTKkNf2Q==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"config-file-ts": "^0.2.4",
-				"dotenv": "^9.0.2",
-				"dotenv-expand": "^5.1.0",
+				"config-file-ts": "0.2.8-rc1",
+				"dotenv": "^16.4.5",
+				"dotenv-expand": "^11.0.6",
 				"js-yaml": "^4.1.0",
-				"json5": "^2.2.0",
-				"lazy-val": "^1.0.4"
+				"json5": "^2.2.3",
+				"lazy-val": "^1.0.5"
 			},
 			"engines": {
 				"node": ">=12.0.0"
@@ -16544,6 +17667,20 @@
 				"minimatch": "^5.1.0"
 			}
 		},
+		"node_modules/readdir-glob/node_modules/minimatch": {
+			"version": "5.1.6",
+			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
+			"integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
+			"dev": true,
+			"license": "ISC",
+			"peer": true,
+			"dependencies": {
+				"brace-expansion": "^2.0.1"
+			},
+			"engines": {
+				"node": ">=10"
+			}
+		},
 		"node_modules/readdirp": {
 			"version": "3.6.0",
 			"resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
@@ -16585,9 +17722,9 @@
 			"license": "MIT"
 		},
 		"node_modules/regenerate-unicode-properties": {
-			"version": "10.1.1",
-			"resolved": "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-10.1.1.tgz",
-			"integrity": "sha512-X007RyZLsCJVVrjgEFVpLUTZwyOZk3oiL75ZcuYjlIWd6rNJtOjkBwQc5AsRrpbKVkxN6sklw/k/9m2jJYOf8Q==",
+			"version": "10.2.0",
+			"resolved": "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-10.2.0.tgz",
+			"integrity": "sha512-DqHn3DwbmmPVzeKj9woBadqmXxLvQoQIwu7nopMc72ztvxVmVk2SBhSnx67zuye5TP+lJsb/TBQsjLKhnDf3MA==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
@@ -16707,6 +17844,24 @@
 			"dev": true,
 			"license": "MIT"
 		},
+		"node_modules/resedit": {
+			"version": "1.7.1",
+			"resolved": "https://registry.npmjs.org/resedit/-/resedit-1.7.1.tgz",
+			"integrity": "sha512-/FJ6/gKAXbcHtivannhecWsa43kGVFK3aHHv9Jm3x0eFiM31MoGihkAOWbm3UsvjYLRVw0zTkfARy2dI96JL1Q==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"pe-library": "^0.4.1"
+			},
+			"engines": {
+				"node": ">=12",
+				"npm": ">=6"
+			},
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/jet2jet"
+			}
+		},
 		"node_modules/resolve": {
 			"version": "1.22.8",
 			"resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.8.tgz",
@@ -16843,50 +17998,17 @@
 			"license": "MIT"
 		},
 		"node_modules/rimraf": {
-			"version": "5.0.10",
-			"resolved": "https://registry.npmjs.org/rimraf/-/rimraf-5.0.10.tgz",
-			"integrity": "sha512-l0OE8wL34P4nJH/H2ffoaniAokM2qSmrtXHmlpvYr5AVVX8msAyW0l8NVJFDxlSK4u3Uh/f41cQheDVdnYijwQ==",
-			"dev": true,
-			"dependencies": {
-				"glob": "^10.3.7"
-			},
-			"bin": {
-				"rimraf": "dist/esm/bin.mjs"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/isaacs"
-			}
-		},
-		"node_modules/rimraf/node_modules/glob": {
-			"version": "10.4.5",
-			"resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
-			"integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==",
+			"version": "3.0.2",
+			"resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
+			"integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
+			"deprecated": "Rimraf versions prior to v4 are no longer supported",
 			"dev": true,
+			"license": "ISC",
 			"dependencies": {
-				"foreground-child": "^3.1.0",
-				"jackspeak": "^3.1.2",
-				"minimatch": "^9.0.4",
-				"minipass": "^7.1.2",
-				"package-json-from-dist": "^1.0.0",
-				"path-scurry": "^1.11.1"
+				"glob": "^7.1.3"
 			},
 			"bin": {
-				"glob": "dist/esm/bin.mjs"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/isaacs"
-			}
-		},
-		"node_modules/rimraf/node_modules/minimatch": {
-			"version": "9.0.5",
-			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
-			"integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
-			"dev": true,
-			"dependencies": {
-				"brace-expansion": "^2.0.1"
-			},
-			"engines": {
-				"node": ">=16 || 14 >=14.17"
+				"rimraf": "bin.js"
 			},
 			"funding": {
 				"url": "https://github.com/sponsors/isaacs"
@@ -16923,12 +18045,13 @@
 			}
 		},
 		"node_modules/rollup": {
-			"version": "4.23.0",
-			"resolved": "https://registry.npmjs.org/rollup/-/rollup-4.23.0.tgz",
-			"integrity": "sha512-vXB4IT9/KLDrS2WRXmY22sVB2wTsTwkpxjB8Q3mnakTENcYw3FRmfdYDy/acNmls+lHmDazgrRjK/yQ6hQAtwA==",
+			"version": "4.22.4",
+			"resolved": "https://registry.npmjs.org/rollup/-/rollup-4.22.4.tgz",
+			"integrity": "sha512-vD8HJ5raRcWOyymsR6Z3o6+RzfEPCnVLMFJ6vRslO1jt4LO6dUo5Qnpg7y4RkZFM2DMe3WUirkI5c16onjrc6A==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
-				"@types/estree": "1.0.6"
+				"@types/estree": "1.0.5"
 			},
 			"bin": {
 				"rollup": "dist/bin/rollup"
@@ -16938,30 +18061,38 @@
 				"npm": ">=8.0.0"
 			},
 			"optionalDependencies": {
-				"@rollup/rollup-android-arm-eabi": "4.23.0",
-				"@rollup/rollup-android-arm64": "4.23.0",
-				"@rollup/rollup-darwin-arm64": "4.23.0",
-				"@rollup/rollup-darwin-x64": "4.23.0",
-				"@rollup/rollup-linux-arm-gnueabihf": "4.23.0",
-				"@rollup/rollup-linux-arm-musleabihf": "4.23.0",
-				"@rollup/rollup-linux-arm64-gnu": "4.23.0",
-				"@rollup/rollup-linux-arm64-musl": "4.23.0",
-				"@rollup/rollup-linux-powerpc64le-gnu": "4.23.0",
-				"@rollup/rollup-linux-riscv64-gnu": "4.23.0",
-				"@rollup/rollup-linux-s390x-gnu": "4.23.0",
-				"@rollup/rollup-linux-x64-gnu": "4.23.0",
-				"@rollup/rollup-linux-x64-musl": "4.23.0",
-				"@rollup/rollup-win32-arm64-msvc": "4.23.0",
-				"@rollup/rollup-win32-ia32-msvc": "4.23.0",
-				"@rollup/rollup-win32-x64-msvc": "4.23.0",
+				"@rollup/rollup-android-arm-eabi": "4.22.4",
+				"@rollup/rollup-android-arm64": "4.22.4",
+				"@rollup/rollup-darwin-arm64": "4.22.4",
+				"@rollup/rollup-darwin-x64": "4.22.4",
+				"@rollup/rollup-linux-arm-gnueabihf": "4.22.4",
+				"@rollup/rollup-linux-arm-musleabihf": "4.22.4",
+				"@rollup/rollup-linux-arm64-gnu": "4.22.4",
+				"@rollup/rollup-linux-arm64-musl": "4.22.4",
+				"@rollup/rollup-linux-powerpc64le-gnu": "4.22.4",
+				"@rollup/rollup-linux-riscv64-gnu": "4.22.4",
+				"@rollup/rollup-linux-s390x-gnu": "4.22.4",
+				"@rollup/rollup-linux-x64-gnu": "4.22.4",
+				"@rollup/rollup-linux-x64-musl": "4.22.4",
+				"@rollup/rollup-win32-arm64-msvc": "4.22.4",
+				"@rollup/rollup-win32-ia32-msvc": "4.22.4",
+				"@rollup/rollup-win32-x64-msvc": "4.22.4",
 				"fsevents": "~2.3.2"
 			}
 		},
+		"node_modules/rollup/node_modules/@types/estree": {
+			"version": "1.0.5",
+			"resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.5.tgz",
+			"integrity": "sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==",
+			"dev": true,
+			"license": "MIT"
+		},
 		"node_modules/run-applescript": {
 			"version": "7.0.0",
 			"resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.0.0.tgz",
 			"integrity": "sha512-9by4Ij99JUr/MCFBUkDKLWK3G9HVXmabKz9U5MlIAIuvuzkiOicRYs8XJLxX+xahD+mLiiCYDqF9dKAgtzKP1A==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">=18"
 			},
@@ -17185,7 +18316,8 @@
 			"version": "2.0.0",
 			"resolved": "https://registry.npmjs.org/select-hose/-/select-hose-2.0.0.tgz",
 			"integrity": "sha512-mEugaLK+YfkijB4fx0e6kImuJdCIt2LxCRcbEYPqRGCs4F2ogyfZU5IAZRdjCP8JPq2AtdNoC/Dux63d9Kiryg==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/selecto": {
 			"version": "1.26.3",
@@ -17210,6 +18342,7 @@
 			"resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-2.4.1.tgz",
 			"integrity": "sha512-th5B4L2U+eGLq1TVh7zNRGBapioSORUeymIydxgFpwww9d2qyKvtuPU2jJuHvYAwwqi2Y596QBL3eEqcPEYL8Q==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@types/node-forge": "^1.3.0",
 				"node-forge": "^1"
@@ -17244,6 +18377,7 @@
 			"resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz",
 			"integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"debug": "2.6.9",
 				"depd": "2.0.0",
@@ -17268,6 +18402,7 @@
 			"resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
 			"integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"ms": "2.0.0"
 			}
@@ -17276,13 +18411,15 @@
 			"version": "2.0.0",
 			"resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
 			"integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/send/node_modules/encodeurl": {
 			"version": "1.0.2",
 			"resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
 			"integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.8"
 			}
@@ -17292,6 +18429,7 @@
 			"resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
 			"integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
 			"dev": true,
+			"license": "MIT",
 			"bin": {
 				"mime": "cli.js"
 			},
@@ -17299,12 +18437,6 @@
 				"node": ">=4"
 			}
 		},
-		"node_modules/send/node_modules/ms": {
-			"version": "2.1.3",
-			"resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-			"integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-			"dev": true
-		},
 		"node_modules/serialize-error": {
 			"version": "7.0.1",
 			"resolved": "https://registry.npmjs.org/serialize-error/-/serialize-error-7.0.1.tgz",
@@ -17351,6 +18483,7 @@
 			"resolved": "https://registry.npmjs.org/serve-index/-/serve-index-1.9.1.tgz",
 			"integrity": "sha512-pXHfKNP4qujrtteMrSBb0rc8HJ9Ms/GrXwcUtUtD5s4ewDJI8bT3Cz2zTVRMKtri49pLx2e0Ya8ziP5Ya2pZZw==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"accepts": "~1.3.4",
 				"batch": "0.6.1",
@@ -17369,6 +18502,7 @@
 			"resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
 			"integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"ms": "2.0.0"
 			}
@@ -17378,6 +18512,7 @@
 			"resolved": "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz",
 			"integrity": "sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.6"
 			}
@@ -17387,6 +18522,7 @@
 			"resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.6.3.tgz",
 			"integrity": "sha512-lks+lVC8dgGyh97jxvxeYTWQFvh4uw4yC12gVl63Cg30sjPX4wuGcdkICVXDAESr6OJGjqGA8Iz5mkeN6zlD7A==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"depd": "~1.1.2",
 				"inherits": "2.0.3",
@@ -17401,25 +18537,29 @@
 			"version": "2.0.3",
 			"resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
 			"integrity": "sha512-x00IRNXNy63jwGkJmzPigoySHbaqpNuzKbBOmzK+g2OdZpQ9w+sxCN+VSB3ja7IAge2OP2qpfxTjeNcyjmW1uw==",
-			"dev": true
+			"dev": true,
+			"license": "ISC"
 		},
 		"node_modules/serve-index/node_modules/ms": {
 			"version": "2.0.0",
 			"resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
 			"integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/serve-index/node_modules/setprototypeof": {
 			"version": "1.1.0",
 			"resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.1.0.tgz",
 			"integrity": "sha512-BvE/TwpZX4FXExxOxZyRGQQv651MSwmWKZGqvmPcRIjDqWub67kTKuIMx43cZZrS/cBBzwBcNDWoFxt2XEFIpQ==",
-			"dev": true
+			"dev": true,
+			"license": "ISC"
 		},
 		"node_modules/serve-index/node_modules/statuses": {
 			"version": "1.5.0",
 			"resolved": "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz",
 			"integrity": "sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.6"
 			}
@@ -17429,6 +18569,7 @@
 			"resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.2.tgz",
 			"integrity": "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"encodeurl": "~2.0.0",
 				"escape-html": "~1.0.3",
@@ -17439,6 +18580,13 @@
 				"node": ">= 0.8.0"
 			}
 		},
+		"node_modules/set-blocking": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
+			"integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==",
+			"dev": true,
+			"license": "ISC"
+		},
 		"node_modules/set-function-length": {
 			"version": "1.2.2",
 			"resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
@@ -17484,7 +18632,8 @@
 			"version": "1.2.0",
 			"resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
 			"integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
-			"dev": true
+			"dev": true,
+			"license": "ISC"
 		},
 		"node_modules/sha.js": {
 			"version": "2.4.11",
@@ -17693,6 +18842,7 @@
 			"resolved": "https://registry.npmjs.org/sockjs/-/sockjs-0.3.24.tgz",
 			"integrity": "sha512-GJgLTZ7vYb/JtPSSZ10hsOYIvEYsjbNU+zPdIHcUaWVNUEPivzxku31865sSSud0Da0W4lEeOPlmw93zLQchuQ==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"faye-websocket": "^0.11.3",
 				"uuid": "^8.3.2",
@@ -17715,31 +18865,18 @@
 			}
 		},
 		"node_modules/socks-proxy-agent": {
-			"version": "8.0.4",
-			"resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.4.tgz",
-			"integrity": "sha512-GNAq/eg8Udq2x0eNiFkr9gRg5bA7PXEWagQdeRX4cPSG+X/8V38v637gim9bjFptMk1QWsCTr0ttrJEiXbNnRw==",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"agent-base": "^7.1.1",
-				"debug": "^4.3.4",
-				"socks": "^2.8.3"
-			},
-			"engines": {
-				"node": ">= 14"
-			}
-		},
-		"node_modules/socks-proxy-agent/node_modules/agent-base": {
-			"version": "7.1.1",
-			"resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.1.tgz",
-			"integrity": "sha512-H0TSyFNDMomMNJQBn8wFV5YC/2eJ+VXECwOadZJT554xP6cODZHPX3H9QMQECxvrgiSOP1pHjy1sMWQVYJOUOA==",
+			"version": "7.0.0",
+			"resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-7.0.0.tgz",
+			"integrity": "sha512-Fgl0YPZ902wEsAyiQ+idGd1A7rSFx/ayC1CQVMw5P+EQx2V0SgpGtf6OKFhVjPflPUl9YMmEOnmfjCdMUsygww==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"debug": "^4.3.4"
+				"agent-base": "^6.0.2",
+				"debug": "^4.3.3",
+				"socks": "^2.6.2"
 			},
 			"engines": {
-				"node": ">= 14"
+				"node": ">= 10"
 			}
 		},
 		"node_modules/source-map": {
@@ -17757,6 +18894,7 @@
 			"resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
 			"integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
 			"dev": true,
+			"license": "BSD-3-Clause",
 			"engines": {
 				"node": ">=0.10.0"
 			}
@@ -17844,6 +18982,7 @@
 			"resolved": "https://registry.npmjs.org/spdy/-/spdy-4.0.2.tgz",
 			"integrity": "sha512-r46gZQZQV+Kl9oItvl1JZZqJKGr+oEkB08A6BzkiR7593/7IbtuncXHd2YoYeTsG4157ZssMu9KYvUHLcjcDoA==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"debug": "^4.1.0",
 				"handle-thing": "^2.0.0",
@@ -17860,6 +18999,7 @@
 			"resolved": "https://registry.npmjs.org/spdy-transport/-/spdy-transport-3.0.0.tgz",
 			"integrity": "sha512-hsLVFE5SjA6TCisWeJXFKniGGOpBgMLmerfO2aCyCU5s7nJ/rpAepqmFifv/GCbSbueEeAJJnmSQ2rKC/g8Fcw==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"debug": "^4.1.0",
 				"detect-node": "^2.0.4",
@@ -17877,16 +19017,16 @@
 			"license": "BSD-3-Clause"
 		},
 		"node_modules/ssri": {
-			"version": "10.0.6",
-			"resolved": "https://registry.npmjs.org/ssri/-/ssri-10.0.6.tgz",
-			"integrity": "sha512-MGrFH9Z4NP9Iyhqn16sDtBpRRNJ0Y2hNa6D65h736fVSaPCHr4DM4sWUNvVaSuC+0OBGhwsrydQwmgfg5LncqQ==",
+			"version": "9.0.1",
+			"resolved": "https://registry.npmjs.org/ssri/-/ssri-9.0.1.tgz",
+			"integrity": "sha512-o57Wcn66jMQvfHG1FlYbWeZWW/dHZhJXjpIcTfXldXEk5nz5lStPo3mK0OJQfGR3RbZUlbISexbljkJzuEj/8Q==",
 			"dev": true,
 			"license": "ISC",
 			"dependencies": {
-				"minipass": "^7.0.3"
+				"minipass": "^3.1.1"
 			},
 			"engines": {
-				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+				"node": "^12.13.0 || ^14.15.0 || >=16.0.0"
 			}
 		},
 		"node_modules/stat-mode": {
@@ -17904,6 +19044,7 @@
 			"resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
 			"integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.8"
 			}
@@ -18086,6 +19227,7 @@
 			"resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz",
 			"integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">=6"
 			}
@@ -18198,32 +19340,6 @@
 				"node": ">=6"
 			}
 		},
-		"node_modules/tar/node_modules/fs-minipass": {
-			"version": "2.1.0",
-			"resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz",
-			"integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==",
-			"dev": true,
-			"license": "ISC",
-			"dependencies": {
-				"minipass": "^3.0.0"
-			},
-			"engines": {
-				"node": ">= 8"
-			}
-		},
-		"node_modules/tar/node_modules/fs-minipass/node_modules/minipass": {
-			"version": "3.3.6",
-			"resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
-			"integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
-			"dev": true,
-			"license": "ISC",
-			"dependencies": {
-				"yallist": "^4.0.0"
-			},
-			"engines": {
-				"node": ">=8"
-			}
-		},
 		"node_modules/tar/node_modules/minipass": {
 			"version": "5.0.0",
 			"resolved": "https://registry.npmjs.org/minipass/-/minipass-5.0.0.tgz",
@@ -18416,6 +19532,7 @@
 			"resolved": "https://registry.npmjs.org/thingies/-/thingies-1.21.0.tgz",
 			"integrity": "sha512-hsqsJsFMsV+aD4s3CWKk85ep/3I9XzYV/IXaSouJMYIoDlgyi11cBhsqYe9/geRfB0YIikBQg6raRaM+nIMP9g==",
 			"dev": true,
+			"license": "Unlicense",
 			"engines": {
 				"node": ">=10.18"
 			},
@@ -18427,7 +19544,8 @@
 			"version": "1.1.0",
 			"resolved": "https://registry.npmjs.org/thunky/-/thunky-1.1.0.tgz",
 			"integrity": "sha512-eHY7nBftgThBqOyHGVN+l8gF0BucP09fMo0oO/Lb0w1OF80dJv+lDVpXG60WMQvkcxAkNybKsrEIE3ZtKGmPrA==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/timers-browserify": {
 			"version": "2.0.12",
@@ -18503,6 +19621,7 @@
 			"resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
 			"integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">=0.6"
 			}
@@ -18512,6 +19631,7 @@
 			"resolved": "https://registry.npmjs.org/tree-dump/-/tree-dump-1.0.2.tgz",
 			"integrity": "sha512-dpev9ABuLWdEubk+cIaI9cHwRNNDjkBBLXTwI4UCUFdQ5xXKqNXoK4FEciw/vxf+NQ7Cb7sGUyeUtORvHIdRXQ==",
 			"dev": true,
+			"license": "Apache-2.0",
 			"engines": {
 				"node": ">=10.0"
 			},
@@ -18543,104 +19663,302 @@
 				"utf8-byte-length": "^1.0.1"
 			}
 		},
-		"node_modules/ts-api-utils": {
-			"version": "1.3.0",
-			"resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-1.3.0.tgz",
-			"integrity": "sha512-UQMIo7pb8WRomKR1/+MFVLTroIvDVtMX3K6OUir8ynLyzB8Jeriont2bTAtmNPa1ekAgN7YPDyf6V+ygrdU+eQ==",
+		"node_modules/ts-api-utils": {
+			"version": "1.3.0",
+			"resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-1.3.0.tgz",
+			"integrity": "sha512-UQMIo7pb8WRomKR1/+MFVLTroIvDVtMX3K6OUir8ynLyzB8Jeriont2bTAtmNPa1ekAgN7YPDyf6V+ygrdU+eQ==",
+			"dev": true,
+			"license": "MIT",
+			"engines": {
+				"node": ">=16"
+			},
+			"peerDependencies": {
+				"typescript": ">=4.2.0"
+			}
+		},
+		"node_modules/ts-node": {
+			"version": "10.9.2",
+			"resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.2.tgz",
+			"integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@cspotcode/source-map-support": "^0.8.0",
+				"@tsconfig/node10": "^1.0.7",
+				"@tsconfig/node12": "^1.0.7",
+				"@tsconfig/node14": "^1.0.0",
+				"@tsconfig/node16": "^1.0.2",
+				"acorn": "^8.4.1",
+				"acorn-walk": "^8.1.1",
+				"arg": "^4.1.0",
+				"create-require": "^1.1.0",
+				"diff": "^4.0.1",
+				"make-error": "^1.1.1",
+				"v8-compile-cache-lib": "^3.0.1",
+				"yn": "3.1.1"
+			},
+			"bin": {
+				"ts-node": "dist/bin.js",
+				"ts-node-cwd": "dist/bin-cwd.js",
+				"ts-node-esm": "dist/bin-esm.js",
+				"ts-node-script": "dist/bin-script.js",
+				"ts-node-transpile-only": "dist/bin-transpile.js",
+				"ts-script": "dist/bin-script-deprecated.js"
+			},
+			"peerDependencies": {
+				"@swc/core": ">=1.2.50",
+				"@swc/wasm": ">=1.2.50",
+				"@types/node": "*",
+				"typescript": ">=2.7"
+			},
+			"peerDependenciesMeta": {
+				"@swc/core": {
+					"optional": true
+				},
+				"@swc/wasm": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/tsconfig-paths": {
+			"version": "4.2.0",
+			"resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz",
+			"integrity": "sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"json5": "^2.2.2",
+				"minimist": "^1.2.6",
+				"strip-bom": "^3.0.0"
+			},
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/tslib": {
+			"version": "2.7.0",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.7.0.tgz",
+			"integrity": "sha512-gLXCKdN1/j47AiHiOkJN69hJmcbGTHI0ImLmbYLHykhgeN0jVGola9yVjFgzCUklsZQMW55o+dW7IXv3RCXDzA==",
+			"license": "0BSD"
+		},
+		"node_modules/tty-browserify": {
+			"version": "0.0.1",
+			"resolved": "https://registry.npmjs.org/tty-browserify/-/tty-browserify-0.0.1.tgz",
+			"integrity": "sha512-C3TaO7K81YvjCgQH9Q1S3R3P3BtN3RIM8n+OvX4il1K1zgE8ZhI0op7kClgkxtutIE8hQrcrHBXvIheqKUUCxw==",
+			"dev": true,
+			"license": "MIT"
+		},
+		"node_modules/tuf-js": {
+			"version": "2.2.1",
+			"resolved": "https://registry.npmjs.org/tuf-js/-/tuf-js-2.2.1.tgz",
+			"integrity": "sha512-GwIJau9XaA8nLVbUXsN3IlFi7WmQ48gBUrl3FTkkL/XLu/POhBzfmX9hd33FNMX1qAsfl6ozO1iMmW9NC8YniA==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@tufjs/models": "2.0.1",
+				"debug": "^4.3.4",
+				"make-fetch-happen": "^13.0.1"
+			},
+			"engines": {
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/tuf-js/node_modules/@npmcli/fs": {
+			"version": "3.1.1",
+			"resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-3.1.1.tgz",
+			"integrity": "sha512-q9CRWjpHCMIh5sVyefoD1cA7PkvILqCZsnSOEUUivORLjxCO/Irmue2DprETiNgEqktDBZaM1Bi+jrarx1XdCg==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"semver": "^7.3.5"
+			},
+			"engines": {
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+			}
+		},
+		"node_modules/tuf-js/node_modules/cacache": {
+			"version": "18.0.4",
+			"resolved": "https://registry.npmjs.org/cacache/-/cacache-18.0.4.tgz",
+			"integrity": "sha512-B+L5iIa9mgcjLbliir2th36yEwPftrzteHYujzsx3dFP/31GCHcIeS8f5MGd80odLOjaOvSpU3EEAmRQptkxLQ==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"@npmcli/fs": "^3.1.0",
+				"fs-minipass": "^3.0.0",
+				"glob": "^10.2.2",
+				"lru-cache": "^10.0.1",
+				"minipass": "^7.0.3",
+				"minipass-collect": "^2.0.1",
+				"minipass-flush": "^1.0.5",
+				"minipass-pipeline": "^1.2.4",
+				"p-map": "^4.0.0",
+				"ssri": "^10.0.0",
+				"tar": "^6.1.11",
+				"unique-filename": "^3.0.0"
+			},
+			"engines": {
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/tuf-js/node_modules/fs-minipass": {
+			"version": "3.0.3",
+			"resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-3.0.3.tgz",
+			"integrity": "sha512-XUBA9XClHbnJWSfBzjkm6RvPsyg3sryZt06BEQoXcF7EK/xpGaQYJgQKDJSUH5SGZ76Y7pFx1QBnXz09rU5Fbw==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"minipass": "^7.0.3"
+			},
+			"engines": {
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+			}
+		},
+		"node_modules/tuf-js/node_modules/glob": {
+			"version": "10.4.5",
+			"resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
+			"integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"foreground-child": "^3.1.0",
+				"jackspeak": "^3.1.2",
+				"minimatch": "^9.0.4",
+				"minipass": "^7.1.2",
+				"package-json-from-dist": "^1.0.0",
+				"path-scurry": "^1.11.1"
+			},
+			"bin": {
+				"glob": "dist/esm/bin.mjs"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/isaacs"
+			}
+		},
+		"node_modules/tuf-js/node_modules/lru-cache": {
+			"version": "10.4.3",
+			"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+			"integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+			"dev": true,
+			"license": "ISC"
+		},
+		"node_modules/tuf-js/node_modules/make-fetch-happen": {
+			"version": "13.0.1",
+			"resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-13.0.1.tgz",
+			"integrity": "sha512-cKTUFc/rbKUd/9meOvgrpJ2WrNzymt6jfRDdwg5UCnVzv9dTpEj9JS5m3wtziXVCjluIXyL8pcaukYqezIzZQA==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"@npmcli/agent": "^2.0.0",
+				"cacache": "^18.0.0",
+				"http-cache-semantics": "^4.1.1",
+				"is-lambda": "^1.0.1",
+				"minipass": "^7.0.2",
+				"minipass-fetch": "^3.0.0",
+				"minipass-flush": "^1.0.5",
+				"minipass-pipeline": "^1.2.4",
+				"negotiator": "^0.6.3",
+				"proc-log": "^4.2.0",
+				"promise-retry": "^2.0.1",
+				"ssri": "^10.0.0"
+			},
+			"engines": {
+				"node": "^16.14.0 || >=18.0.0"
+			}
+		},
+		"node_modules/tuf-js/node_modules/minimatch": {
+			"version": "9.0.5",
+			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
+			"integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"brace-expansion": "^2.0.1"
+			},
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/isaacs"
+			}
+		},
+		"node_modules/tuf-js/node_modules/minipass": {
+			"version": "7.1.2",
+			"resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
+			"integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
+			"dev": true,
+			"license": "ISC",
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
+			}
+		},
+		"node_modules/tuf-js/node_modules/minipass-collect": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/minipass-collect/-/minipass-collect-2.0.1.tgz",
+			"integrity": "sha512-D7V8PO9oaz7PWGLbCACuI1qEOsq7UKfLotx/C0Aet43fCUB/wfQ7DYeq2oR/svFJGYDHPr38SHATeaj/ZoKHKw==",
 			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=16"
+			"license": "ISC",
+			"dependencies": {
+				"minipass": "^7.0.3"
 			},
-			"peerDependencies": {
-				"typescript": ">=4.2.0"
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
 			}
 		},
-		"node_modules/ts-node": {
-			"version": "10.9.2",
-			"resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.2.tgz",
-			"integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
+		"node_modules/tuf-js/node_modules/minipass-fetch": {
+			"version": "3.0.5",
+			"resolved": "https://registry.npmjs.org/minipass-fetch/-/minipass-fetch-3.0.5.tgz",
+			"integrity": "sha512-2N8elDQAtSnFV0Dk7gt15KHsS0Fyz6CbYZ360h0WTYV1Ty46li3rAXVOQj1THMNLdmrD9Vt5pBPtWtVkpwGBqg==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@cspotcode/source-map-support": "^0.8.0",
-				"@tsconfig/node10": "^1.0.7",
-				"@tsconfig/node12": "^1.0.7",
-				"@tsconfig/node14": "^1.0.0",
-				"@tsconfig/node16": "^1.0.2",
-				"acorn": "^8.4.1",
-				"acorn-walk": "^8.1.1",
-				"arg": "^4.1.0",
-				"create-require": "^1.1.0",
-				"diff": "^4.0.1",
-				"make-error": "^1.1.1",
-				"v8-compile-cache-lib": "^3.0.1",
-				"yn": "3.1.1"
-			},
-			"bin": {
-				"ts-node": "dist/bin.js",
-				"ts-node-cwd": "dist/bin-cwd.js",
-				"ts-node-esm": "dist/bin-esm.js",
-				"ts-node-script": "dist/bin-script.js",
-				"ts-node-transpile-only": "dist/bin-transpile.js",
-				"ts-script": "dist/bin-script-deprecated.js"
+				"minipass": "^7.0.3",
+				"minipass-sized": "^1.0.3",
+				"minizlib": "^2.1.2"
 			},
-			"peerDependencies": {
-				"@swc/core": ">=1.2.50",
-				"@swc/wasm": ">=1.2.50",
-				"@types/node": "*",
-				"typescript": ">=2.7"
+			"engines": {
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
 			},
-			"peerDependenciesMeta": {
-				"@swc/core": {
-					"optional": true
-				},
-				"@swc/wasm": {
-					"optional": true
-				}
+			"optionalDependencies": {
+				"encoding": "^0.1.13"
 			}
 		},
-		"node_modules/tsconfig-paths": {
-			"version": "4.2.0",
-			"resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz",
-			"integrity": "sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==",
+		"node_modules/tuf-js/node_modules/ssri": {
+			"version": "10.0.6",
+			"resolved": "https://registry.npmjs.org/ssri/-/ssri-10.0.6.tgz",
+			"integrity": "sha512-MGrFH9Z4NP9Iyhqn16sDtBpRRNJ0Y2hNa6D65h736fVSaPCHr4DM4sWUNvVaSuC+0OBGhwsrydQwmgfg5LncqQ==",
 			"dev": true,
-			"license": "MIT",
+			"license": "ISC",
 			"dependencies": {
-				"json5": "^2.2.2",
-				"minimist": "^1.2.6",
-				"strip-bom": "^3.0.0"
+				"minipass": "^7.0.3"
 			},
 			"engines": {
-				"node": ">=6"
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
 			}
 		},
-		"node_modules/tslib": {
-			"version": "2.6.3",
-			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.3.tgz",
-			"integrity": "sha512-xNvxJEOUiWPGhUuUdQgAJPKOOJfGnIyKySOc09XkKsgdUV/3E2zvwZYdejjmRgPCgcym1juLH3226yA7sEFJKQ==",
-			"license": "0BSD"
-		},
-		"node_modules/tty-browserify": {
-			"version": "0.0.1",
-			"resolved": "https://registry.npmjs.org/tty-browserify/-/tty-browserify-0.0.1.tgz",
-			"integrity": "sha512-C3TaO7K81YvjCgQH9Q1S3R3P3BtN3RIM8n+OvX4il1K1zgE8ZhI0op7kClgkxtutIE8hQrcrHBXvIheqKUUCxw==",
+		"node_modules/tuf-js/node_modules/unique-filename": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-3.0.0.tgz",
+			"integrity": "sha512-afXhuC55wkAmZ0P18QsVE6kp8JaxrEokN2HGIoIVv2ijHQd419H0+6EigAFcIzXeMIkcIkNBpB3L/DXB3cTS/g==",
 			"dev": true,
-			"license": "MIT"
+			"license": "ISC",
+			"dependencies": {
+				"unique-slug": "^4.0.0"
+			},
+			"engines": {
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+			}
 		},
-		"node_modules/tuf-js": {
-			"version": "2.2.1",
-			"resolved": "https://registry.npmjs.org/tuf-js/-/tuf-js-2.2.1.tgz",
-			"integrity": "sha512-GwIJau9XaA8nLVbUXsN3IlFi7WmQ48gBUrl3FTkkL/XLu/POhBzfmX9hd33FNMX1qAsfl6ozO1iMmW9NC8YniA==",
+		"node_modules/tuf-js/node_modules/unique-slug": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-4.0.0.tgz",
+			"integrity": "sha512-WrcA6AyEfqDX5bWige/4NQfPZMtASNVxdmWR76WESYQVAACSgWcR6e9i0mofqqBxYFtL4oAxPIptY73/0YE1DQ==",
 			"dev": true,
-			"license": "MIT",
+			"license": "ISC",
 			"dependencies": {
-				"@tufjs/models": "2.0.1",
-				"debug": "^4.3.4",
-				"make-fetch-happen": "^13.0.1"
+				"imurmurhash": "^0.1.4"
 			},
 			"engines": {
-				"node": "^16.14.0 || >=18.0.0"
+				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
 			}
 		},
 		"node_modules/type-check": {
@@ -18674,6 +19992,7 @@
 			"resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
 			"integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"media-typer": "0.3.0",
 				"mime-types": "~2.1.24"
@@ -18781,15 +20100,15 @@
 			}
 		},
 		"node_modules/typescript-eslint": {
-			"version": "8.2.0",
-			"resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.2.0.tgz",
-			"integrity": "sha512-DmnqaPcML0xYwUzgNbM1XaKXpEb7BShYf2P1tkUmmcl8hyeG7Pj08Er7R9bNy6AufabywzJcOybQAtnD/c9DGw==",
+			"version": "8.8.0",
+			"resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.8.0.tgz",
+			"integrity": "sha512-BjIT/VwJ8+0rVO01ZQ2ZVnjE1svFBiRczcpr1t1Yxt7sT25VSbPfrJtDsQ8uQTy2pilX5nI9gwxhUyLULNentw==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@typescript-eslint/eslint-plugin": "8.2.0",
-				"@typescript-eslint/parser": "8.2.0",
-				"@typescript-eslint/utils": "8.2.0"
+				"@typescript-eslint/eslint-plugin": "8.8.0",
+				"@typescript-eslint/parser": "8.8.0",
+				"@typescript-eslint/utils": "8.8.0"
 			},
 			"engines": {
 				"node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -18828,9 +20147,9 @@
 			"license": "MIT"
 		},
 		"node_modules/unicode-canonical-property-names-ecmascript": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.0.tgz",
-			"integrity": "sha512-yY5PpDlfVIU5+y/BSCxAJRBIS1Zc2dDG3Ujq+sR0U+JjUevW2JhocOF+soROYDSaAezOzOKuyyixhD6mBknSmQ==",
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.1.tgz",
+			"integrity": "sha512-dA8WbNeb2a6oQzAQ55YlT5vQAWGV9WXOsi3SskE3bcCdM0P4SDd+24zS/OCacdRq5BkdsRj9q3Pg6YyQoxIGqg==",
 			"dev": true,
 			"license": "MIT",
 			"engines": {
@@ -18852,9 +20171,9 @@
 			}
 		},
 		"node_modules/unicode-match-property-value-ecmascript": {
-			"version": "2.1.0",
-			"resolved": "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.1.0.tgz",
-			"integrity": "sha512-qxkjQt6qjg/mYscYMC0XKRn3Rh0wFPlfxB0xkt9CfyTvpX1Ra0+rAmdX2QyAobptSEvuy4RtpPRui6XkV+8wjA==",
+			"version": "2.2.0",
+			"resolved": "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.2.0.tgz",
+			"integrity": "sha512-4IehN3V/+kkr5YeSSDDQG8QLqO26XpL2XP3GQtqwlT/QYSECAwFztxVHjlbh0+gjJ3XmNLS0zDsbgs9jWKExLg==",
 			"dev": true,
 			"license": "MIT",
 			"engines": {
@@ -18885,29 +20204,29 @@
 			}
 		},
 		"node_modules/unique-filename": {
-			"version": "3.0.0",
-			"resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-3.0.0.tgz",
-			"integrity": "sha512-afXhuC55wkAmZ0P18QsVE6kp8JaxrEokN2HGIoIVv2ijHQd419H0+6EigAFcIzXeMIkcIkNBpB3L/DXB3cTS/g==",
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-2.0.1.tgz",
+			"integrity": "sha512-ODWHtkkdx3IAR+veKxFV+VBkUMcN+FaqzUUd7IZzt+0zhDZFPFxhlqwPF3YQvMHx1TD0tdgYl+kuPnJ8E6ql7A==",
 			"dev": true,
 			"license": "ISC",
 			"dependencies": {
-				"unique-slug": "^4.0.0"
+				"unique-slug": "^3.0.0"
 			},
 			"engines": {
-				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+				"node": "^12.13.0 || ^14.15.0 || >=16.0.0"
 			}
 		},
 		"node_modules/unique-slug": {
-			"version": "4.0.0",
-			"resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-4.0.0.tgz",
-			"integrity": "sha512-WrcA6AyEfqDX5bWige/4NQfPZMtASNVxdmWR76WESYQVAACSgWcR6e9i0mofqqBxYFtL4oAxPIptY73/0YE1DQ==",
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-3.0.0.tgz",
+			"integrity": "sha512-8EyMynh679x/0gqE9fT9oilG+qEt+ibFyqjuVTsZn1+CMxH+XLlpvr2UZx4nVcCwTpx81nICr2JQFkM+HPLq4w==",
 			"dev": true,
 			"license": "ISC",
 			"dependencies": {
 				"imurmurhash": "^0.1.4"
 			},
 			"engines": {
-				"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+				"node": "^12.13.0 || ^14.15.0 || >=16.0.0"
 			}
 		},
 		"node_modules/universalify": {
@@ -18925,14 +20244,15 @@
 			"resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
 			"integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.8"
 			}
 		},
 		"node_modules/update-browserslist-db": {
-			"version": "1.1.0",
-			"resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.0.tgz",
-			"integrity": "sha512-EdRAaAyk2cUE1wOf2DkEhzxqOQvFOoRJFNS6NeyJ01Gp2beMRpBAINjM2iDXE3KCuKhwnvHIQCJm6ThL2Z+HzQ==",
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.1.tgz",
+			"integrity": "sha512-R8UzCaa9Az+38REPiJ1tXlImTJXlVfgHZsglwBD/k6nj76ctsH1E3q4doGrukiLQd3sGQYu56r5+lo5r94l29A==",
 			"dev": true,
 			"funding": [
 				{
@@ -18950,8 +20270,8 @@
 			],
 			"license": "MIT",
 			"dependencies": {
-				"escalade": "^3.1.2",
-				"picocolors": "^1.0.1"
+				"escalade": "^3.2.0",
+				"picocolors": "^1.1.0"
 			},
 			"bin": {
 				"update-browserslist-db": "cli.js"
@@ -19024,6 +20344,7 @@
 			"resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
 			"integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.4.0"
 			}
@@ -19033,6 +20354,7 @@
 			"resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
 			"integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
 			"dev": true,
+			"license": "MIT",
 			"bin": {
 				"uuid": "dist/bin/uuid"
 			}
@@ -19070,6 +20392,7 @@
 			"resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
 			"integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.8"
 			}
@@ -19095,6 +20418,7 @@
 			"resolved": "https://registry.npmjs.org/vite/-/vite-5.4.6.tgz",
 			"integrity": "sha512-IeL5f8OO5nylsgzd9tq4qD2QqI0k2CQLGrWD0rCN0EQJZpBK5vJAx0I+GDkMOXxQX/OfFHMuLIx6ddAxGX/k+Q==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"esbuild": "^0.21.3",
 				"postcss": "^8.4.43",
@@ -19157,6 +20481,7 @@
 				"ppc64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"aix"
@@ -19173,6 +20498,7 @@
 				"arm"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"android"
@@ -19189,6 +20515,7 @@
 				"arm64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"android"
@@ -19205,6 +20532,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"android"
@@ -19221,6 +20549,7 @@
 				"arm64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"darwin"
@@ -19237,6 +20566,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"darwin"
@@ -19253,6 +20583,7 @@
 				"arm64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"freebsd"
@@ -19269,6 +20600,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"freebsd"
@@ -19285,6 +20617,7 @@
 				"arm"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -19301,6 +20634,7 @@
 				"arm64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -19317,6 +20651,7 @@
 				"ia32"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -19333,6 +20668,7 @@
 				"loong64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -19349,6 +20685,7 @@
 				"mips64el"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -19365,6 +20702,7 @@
 				"ppc64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -19381,6 +20719,7 @@
 				"riscv64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -19397,6 +20736,7 @@
 				"s390x"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -19413,6 +20753,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"linux"
@@ -19429,6 +20770,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"netbsd"
@@ -19445,6 +20787,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"openbsd"
@@ -19461,6 +20804,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"sunos"
@@ -19477,6 +20821,7 @@
 				"arm64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"win32"
@@ -19493,6 +20838,7 @@
 				"ia32"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"win32"
@@ -19509,6 +20855,7 @@
 				"x64"
 			],
 			"dev": true,
+			"license": "MIT",
 			"optional": true,
 			"os": [
 				"win32"
@@ -19523,6 +20870,7 @@
 			"integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
 			"dev": true,
 			"hasInstallScript": true,
+			"license": "MIT",
 			"bin": {
 				"esbuild": "bin/esbuild"
 			},
@@ -19574,6 +20922,7 @@
 					"url": "https://github.com/sponsors/ai"
 				}
 			],
+			"license": "MIT",
 			"dependencies": {
 				"nanoid": "^3.3.7",
 				"picocolors": "^1.1.0",
@@ -19591,13 +20940,13 @@
 			"license": "MIT"
 		},
 		"node_modules/wait-on": {
-			"version": "8.0.0",
-			"resolved": "https://registry.npmjs.org/wait-on/-/wait-on-8.0.0.tgz",
-			"integrity": "sha512-fNE5SXinLr2Bt7cJvjvLg2PcXfqznlqRvtE3f8AqYdRZ9BhE+XpsCp1mwQbRoO7s1q7uhAuCw0Ro3mG/KdZjEw==",
+			"version": "8.0.1",
+			"resolved": "https://registry.npmjs.org/wait-on/-/wait-on-8.0.1.tgz",
+			"integrity": "sha512-1wWQOyR2LVVtaqrcIL2+OM+x7bkpmzVROa0Nf6FryXkS+er5Sa1kzFGjzZRqLnHa3n1rACFLeTwUqE1ETL9Mig==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"axios": "^1.7.4",
+				"axios": "^1.7.7",
 				"joi": "^17.13.3",
 				"lodash": "^4.17.21",
 				"minimist": "^1.2.8",
@@ -19629,6 +20978,7 @@
 			"resolved": "https://registry.npmjs.org/wbuf/-/wbuf-1.7.3.tgz",
 			"integrity": "sha512-O84QOnr0icsbFGLS0O3bI5FswxzRr8/gHwWkDlQFskhSPryQXvrTMxjxGP4+iWYoauLoBvfDpkrOauZ+0iZpDA==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"minimalistic-assert": "^1.0.0"
 			}
@@ -19647,13 +20997,16 @@
 			"version": "1.2.2",
 			"resolved": "https://registry.npmjs.org/weak-lru-cache/-/weak-lru-cache-1.2.2.tgz",
 			"integrity": "sha512-DEAoo25RfSYMuTGc9vPJzZcZullwIqRDSI9LOy+fkCJPi6hykCnfKaXTuPBDuXAUcqHXyOgFtHNp/kB2FjYHbw==",
-			"dev": true
+			"dev": true,
+			"license": "MIT"
 		},
 		"node_modules/webpack": {
-			"version": "5.94.0",
-			"resolved": "https://registry.npmjs.org/webpack/-/webpack-5.94.0.tgz",
-			"integrity": "sha512-KcsGn50VT+06JH/iunZJedYGUJS5FGjow8wb9c0v5n1Om8O1g4L6LjtfxwlXIATopoQu+vOXXa7gYisWxCoPyg==",
+			"version": "5.95.0",
+			"resolved": "https://registry.npmjs.org/webpack/-/webpack-5.95.0.tgz",
+			"integrity": "sha512-2t3XstrKULz41MNMBF+cJ97TyHdyQ8HCt//pqErqDvNjU9YQBnZxIHa11VXsi7F3mb5/aO2tuDxdeTPdU7xu9Q==",
 			"dev": true,
+			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@types/estree": "^1.0.5",
 				"@webassemblyjs/ast": "^1.12.1",
@@ -19700,6 +21053,7 @@
 			"resolved": "https://registry.npmjs.org/webpack-dev-middleware/-/webpack-dev-middleware-7.4.2.tgz",
 			"integrity": "sha512-xOO8n6eggxnwYpy1NlzUKpvrjfJTvae5/D6WOK0S2LSo7vjmo5gCM1DbLUmFqrMTJP+W/0YZNctm7jasWvLuBA==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"colorette": "^2.0.10",
 				"memfs": "^4.6.0",
@@ -19729,6 +21083,7 @@
 			"resolved": "https://registry.npmjs.org/webpack-dev-server/-/webpack-dev-server-5.0.4.tgz",
 			"integrity": "sha512-dljXhUgx3HqKP2d8J/fUMvhxGhzjeNVarDLcbO/EWMSgRizDkxHQDZQaLFL5VJY9tRBj2Gz+rvCEYYvhbqPHNA==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@types/bonjour": "^3.5.13",
 				"@types/connect-history-api-fallback": "^1.5.4",
@@ -19783,11 +21138,33 @@
 				}
 			}
 		},
+		"node_modules/webpack-dev-server/node_modules/glob": {
+			"version": "10.4.5",
+			"resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
+			"integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"foreground-child": "^3.1.0",
+				"jackspeak": "^3.1.2",
+				"minimatch": "^9.0.4",
+				"minipass": "^7.1.2",
+				"package-json-from-dist": "^1.0.0",
+				"path-scurry": "^1.11.1"
+			},
+			"bin": {
+				"glob": "dist/esm/bin.mjs"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/isaacs"
+			}
+		},
 		"node_modules/webpack-dev-server/node_modules/http-proxy-middleware": {
 			"version": "2.0.6",
 			"resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.6.tgz",
 			"integrity": "sha512-ya/UeJ6HVBYxrgYotAZo1KvPWlgB48kUJLDePFeneHsVujFaW5WNj2NgWCAE//B1Dl02BIfYlpNgBy8Kf8Rjmw==",
 			"dev": true,
+			"license": "MIT",
 			"dependencies": {
 				"@types/http-proxy": "^1.17.8",
 				"http-proxy": "^1.18.1",
@@ -19807,6 +21184,48 @@
 				}
 			}
 		},
+		"node_modules/webpack-dev-server/node_modules/minimatch": {
+			"version": "9.0.5",
+			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
+			"integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"brace-expansion": "^2.0.1"
+			},
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/isaacs"
+			}
+		},
+		"node_modules/webpack-dev-server/node_modules/minipass": {
+			"version": "7.1.2",
+			"resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
+			"integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
+			"dev": true,
+			"license": "ISC",
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
+			}
+		},
+		"node_modules/webpack-dev-server/node_modules/rimraf": {
+			"version": "5.0.10",
+			"resolved": "https://registry.npmjs.org/rimraf/-/rimraf-5.0.10.tgz",
+			"integrity": "sha512-l0OE8wL34P4nJH/H2ffoaniAokM2qSmrtXHmlpvYr5AVVX8msAyW0l8NVJFDxlSK4u3Uh/f41cQheDVdnYijwQ==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"glob": "^10.3.7"
+			},
+			"bin": {
+				"rimraf": "dist/esm/bin.mjs"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/isaacs"
+			}
+		},
 		"node_modules/webpack-merge": {
 			"version": "5.10.0",
 			"resolved": "https://registry.npmjs.org/webpack-merge/-/webpack-merge-5.10.0.tgz",
@@ -19860,6 +21279,7 @@
 			"integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
 			"dev": true,
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"fast-deep-equal": "^3.1.1",
 				"fast-json-stable-stringify": "^2.0.0",
@@ -19877,6 +21297,7 @@
 			"integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==",
 			"dev": true,
 			"license": "MIT",
+			"peer": true,
 			"peerDependencies": {
 				"ajv": "^6.9.1"
 			}
@@ -19887,6 +21308,7 @@
 			"integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==",
 			"dev": true,
 			"license": "BSD-2-Clause",
+			"peer": true,
 			"dependencies": {
 				"esrecurse": "^4.3.0",
 				"estraverse": "^4.1.1"
@@ -19901,6 +21323,7 @@
 			"integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==",
 			"dev": true,
 			"license": "BSD-2-Clause",
+			"peer": true,
 			"engines": {
 				"node": ">=4.0"
 			}
@@ -19910,14 +21333,16 @@
 			"resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
 			"integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==",
 			"dev": true,
-			"license": "MIT"
+			"license": "MIT",
+			"peer": true
 		},
 		"node_modules/webpack/node_modules/json-schema-traverse": {
 			"version": "0.4.1",
 			"resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
 			"integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
 			"dev": true,
-			"license": "MIT"
+			"license": "MIT",
+			"peer": true
 		},
 		"node_modules/webpack/node_modules/schema-utils": {
 			"version": "3.3.0",
@@ -19925,6 +21350,7 @@
 			"integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==",
 			"dev": true,
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@types/json-schema": "^7.0.8",
 				"ajv": "^6.12.5",
@@ -19943,6 +21369,7 @@
 			"resolved": "https://registry.npmjs.org/websocket-driver/-/websocket-driver-0.7.4.tgz",
 			"integrity": "sha512-b17KeDIQVjvb0ssuSDF2cYXSg2iztliJ4B9WdsuB6J952qCPKmnVq4DyW5motImXHDC1cBT/1UezrJVsKw5zjg==",
 			"dev": true,
+			"license": "Apache-2.0",
 			"dependencies": {
 				"http-parser-js": ">=0.5.1",
 				"safe-buffer": ">=5.1.0",
@@ -19957,6 +21384,7 @@
 			"resolved": "https://registry.npmjs.org/websocket-extensions/-/websocket-extensions-0.1.4.tgz",
 			"integrity": "sha512-OqedPIGOfsDlo31UNwYbCFMSaO9m9G/0faIHj5/dZFDMFqPTcx6UwqyOy3COEaEOg/9VsGIpdqn62W5KhoKSpg==",
 			"dev": true,
+			"license": "Apache-2.0",
 			"engines": {
 				"node": ">=0.8.0"
 			}
@@ -20020,6 +21448,16 @@
 				"url": "https://github.com/sponsors/ljharb"
 			}
 		},
+		"node_modules/wide-align": {
+			"version": "1.1.5",
+			"resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.5.tgz",
+			"integrity": "sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==",
+			"dev": true,
+			"license": "ISC",
+			"dependencies": {
+				"string-width": "^1.0.2 || 2 || 3 || 4"
+			}
+		},
 		"node_modules/wildcard": {
 			"version": "2.0.1",
 			"resolved": "https://registry.npmjs.org/wildcard/-/wildcard-2.0.1.tgz",
@@ -20155,6 +21593,7 @@
 			"resolved": "https://registry.npmjs.org/ws/-/ws-8.18.0.tgz",
 			"integrity": "sha512-8VbfWfHLbbwu3+N6OKsOMpBdT4kXPDDB9cJk2bJ6mh9ucxdlnNvH1e+roYkKmN9Nxw2yjz7VzeO9oOz2zJ04Pw==",
 			"dev": true,
+			"license": "MIT",
 			"engines": {
 				"node": ">=10.0.0"
 			},
diff --git a/desktop/package.json b/desktop/package.json
index 90fbc809c..dbc0839ba 100644
--- a/desktop/package.json
+++ b/desktop/package.json
@@ -35,15 +35,15 @@
 		"prettier:scss": "npx prettier '**/*.scss' --write"
 	},
 	"dependencies": {
-		"@angular/animations": "18.2.0",
-		"@angular/cdk": "18.2.0",
-		"@angular/common": "18.2.0",
-		"@angular/compiler": "18.2.0",
-		"@angular/core": "18.2.0",
-		"@angular/forms": "18.2.0",
-		"@angular/platform-browser": "18.2.0",
-		"@angular/platform-browser-dynamic": "18.2.0",
-		"@angular/router": "18.2.0",
+		"@angular/animations": "18.2.6",
+		"@angular/cdk": "18.2.6",
+		"@angular/common": "18.2.6",
+		"@angular/compiler": "18.2.6",
+		"@angular/core": "18.2.6",
+		"@angular/forms": "18.2.6",
+		"@angular/platform-browser": "18.2.6",
+		"@angular/platform-browser-dynamic": "18.2.6",
+		"@angular/router": "18.2.6",
 		"@mdi/font": "7.4.47",
 		"chart.js": "4.4.4",
 		"chartjs-plugin-zoom": "2.0.1",
@@ -54,32 +54,32 @@
 		"panzoom": "9.4.3",
 		"primeflex": "3.3.1",
 		"primeicons": "7.0.0",
-		"primeng": "17.18.9",
+		"primeng": "17.18.11",
 		"primeng-sass-theme": "github:primefaces/primeng-sass-theme#17.18.3",
 		"rxjs": "7.8.1",
-		"tslib": "2.6.3",
+		"tslib": "2.7.0",
 		"zone.js": "0.14.10"
 	},
 	"devDependencies": {
 		"@angular-builders/custom-webpack": "18.0.0",
 		"@angular-devkit/build-angular": "18.2.6",
-		"@angular/cli": "18.2.1",
-		"@angular/compiler-cli": "18.2.0",
-		"@angular/language-service": "18.2.0",
-		"@eslint/js": "9.9.0",
+		"@angular/cli": "18.2.6",
+		"@angular/compiler-cli": "18.2.6",
+		"@angular/language-service": "18.2.6",
+		"@eslint/js": "9.11.1",
 		"@types/eslint__js": "8.42.3",
 		"@types/leaflet": "1.9.12",
-		"@types/node": "22.5.0",
-		"electron": "32.0.1",
-		"electron-builder": "24.13.3",
-		"eslint": "9.9.0",
+		"@types/node": "22.7.4",
+		"electron": "32.1.2",
+		"electron-builder": "25.0.5",
+		"eslint": "9.11.1",
 		"node-polyfill-webpack-plugin": "4.0.0",
 		"npm-run-all": "4.1.5",
 		"prettier": "3.3.3",
 		"ts-node": "10.9.2",
 		"typescript": "5.5.4",
-		"typescript-eslint": "8.2.0",
-		"wait-on": "8.0.0"
+		"typescript-eslint": "8.8.0",
+		"wait-on": "8.0.1"
 	},
 	"engines": {
 		"node": ">= 20.11.1"
diff --git a/desktop/src/app/alignment/alignment.component.html b/desktop/src/app/alignment/alignment.component.html
index 57dd89ef2..051e404f8 100644
--- a/desktop/src/app/alignment/alignment.component.html
+++ b/desktop/src/app/alignment/alignment.component.html
@@ -56,7 +56,7 @@
 			</div>
 		</div>
 	</div>
-	<div class="grid">
+	<div class="grid relative">
 		<div class="col-12">
 			<p-tabView [(activeIndex)]="tab">
 				<p-tabPanel header="TPPA">
@@ -262,19 +262,46 @@
 								[text]="true" />
 						</div>
 					</div>
-					<div class="grid mt-1">
-						<div class="col-12 flex-column justify-content-center text-sm overflow-y-auto max-h-8rem p-0">
-							<span>1. Locate a star near the south meridian and close to declination 0.</span>
-							<span>2. Start DARV and wait for routine to complete.</span>
-							<span>3. If you see V shaped track, adjust the Azimuth and repeat the step 2 till you get a line.</span>
-							<span>4. Locate a star in the eastern or western horizon and close to declination 0.</span>
-							<span>5. Start DARV and wait for routine to complete.</span>
-							<span>6. If you see V shaped track, adjust the Altitude and repeat the step 5 till you get a line.</span>
-							<span>7. Increase the drift time and repeat the step 1 to refine the alignment.</span>
-						</div>
-					</div>
 				</p-tabPanel>
 			</p-tabView>
 		</div>
+		<p-button
+			[text]="true"
+			severity="info"
+			icon="mdi mdi-information"
+			styleClass="absolute"
+			[style]="{ right: '8px', top: '5px' }"
+			(onClick)="tab === 0 ? tppaInfo.toggle($event) : darvInfo.toggle($event)" />
+
+		<p-overlayPanel
+			#tppaInfo
+			[focusOnShow]="false"
+			appendTo="body"
+			[style]="{ maxWidth: '91vw' }">
+			<div class="grid text-sm">
+				<div class="col-12 flex-column justify-content-center px-0">
+					<span>1. Choose step duration and speed so that the step size is at least 30 arcmin.</span>
+					<span>2. Start TPPA and wait for the azimuth/altitude errors to be displayed.</span>
+					<span>3. Repeatedly adjust the Azimuth/Altitude until their values get close to 0.</span>
+				</div>
+			</div>
+		</p-overlayPanel>
+		<p-overlayPanel
+			#darvInfo
+			[focusOnShow]="false"
+			appendTo="body"
+			[style]="{ maxWidth: '91vw' }">
+			<div class="grid text-sm">
+				<div class="col-12 flex-column justify-content-center px-0">
+					<span>1. Locate a star near the south meridian and close to declination 0.</span>
+					<span>2. Start DARV and wait for routine to complete.</span>
+					<span>3. If you see V shaped track, adjust the Azimuth and repeat the step 2 till you get a line.</span>
+					<span>4. Locate a star in the eastern or western horizon and close to declination 0.</span>
+					<span>5. Start DARV and wait for routine to complete.</span>
+					<span>6. If you see V shaped track, adjust the Altitude and repeat the step 5 till you get a line.</span>
+					<span>7. Increase the drift time and repeat the step 1 to refine the alignment.</span>
+				</div>
+			</div>
+		</p-overlayPanel>
 	</div>
 </div>
diff --git a/desktop/src/app/alignment/alignment.component.ts b/desktop/src/app/alignment/alignment.component.ts
index e6f45d791..780632253 100644
--- a/desktop/src/app/alignment/alignment.component.ts
+++ b/desktop/src/app/alignment/alignment.component.ts
@@ -178,7 +178,7 @@ export class AlignmentComponent implements AfterViewInit, OnDestroy, Tickable {
 						this.tppaResult.failed = true
 					}
 
-					if (event.capture && event.capture.state !== 'CAPTURE_FINISHED') {
+					if (event.capture.state !== 'CAPTURE_FINISHED') {
 						this.cameraExposure.handleCameraCaptureEvent(event.capture, true)
 					}
 				})
@@ -274,7 +274,6 @@ export class AlignmentComponent implements AfterViewInit, OnDestroy, Tickable {
 			this.method = 'DARV'
 			this.darvRequest.direction = direction
 			this.darvRequest.reversed = this.preference.darvHemisphere === 'SOUTHERN'
-			Object.assign(this.tppaRequest.plateSolver, this.preferenceService.settings.get().plateSolver[this.tppaRequest.plateSolver.type])
 
 			await this.openCameraImage()
 			await this.api.darvStart(this.camera, this.guideOutput, this.darvRequest)
@@ -290,6 +289,7 @@ export class AlignmentComponent implements AfterViewInit, OnDestroy, Tickable {
 	protected async tppaStart() {
 		if (this.camera?.id && this.mount?.id) {
 			this.method = 'TPPA'
+			Object.assign(this.tppaRequest.plateSolver, this.preferenceService.settings.get().plateSolver[this.tppaRequest.plateSolver.type])
 
 			await this.openCameraImage()
 			await this.api.tppaStart(this.camera, this.mount, this.tppaRequest)
diff --git a/desktop/src/app/autofocus/autofocus.component.html b/desktop/src/app/autofocus/autofocus.component.html
index 38c9fa60c..d4b95892c 100644
--- a/desktop/src/app/autofocus/autofocus.component.html
+++ b/desktop/src/app/autofocus/autofocus.component.html
@@ -99,19 +99,6 @@
 							<label>Initial Offset Steps ({{ request.initialOffsetSteps * request.stepSize }})</label>
 						</p-floatLabel>
 					</div>
-					<div class="col-3 align-items-center">
-						<p-floatLabel>
-							<p-inputNumber
-								styleClass="p-inputtext-sm border-0 max-w-full"
-								[(ngModel)]="request.totalNumberOfAttempts"
-								[showButtons]="true"
-								[min]="1"
-								[max]="10"
-								(ngModelChange)="savePreference()"
-								spinnableNumber />
-							<label>Attempts</label>
-						</p-floatLabel>
-					</div>
 					<div class="col-5 align-items-center">
 						<p-floatLabel class="w-full">
 							<p-dropdown
@@ -144,7 +131,7 @@
 								styleClass="p-inputtext-sm border-0 max-w-full"
 								[(ngModel)]="request.rSquaredThreshold"
 								[showButtons]="true"
-								[min]="0.1"
+								[min]="0"
 								[max]="1"
 								[step]="0.1"
 								(ngModelChange)="savePreference()"
diff --git a/desktop/src/app/autofocus/autofocus.component.ts b/desktop/src/app/autofocus/autofocus.component.ts
index de9c1d9c6..ed0668d68 100644
--- a/desktop/src/app/autofocus/autofocus.component.ts
+++ b/desktop/src/app/autofocus/autofocus.component.ts
@@ -305,22 +305,24 @@ export class AutoFocusComponent implements AfterViewInit, OnDestroy, Tickable {
 
 		electronService.on('AUTO_FOCUS.ELAPSED', (event) => {
 			ngZone.run(() => {
-				this.status = event.state
-				this.running = event.state !== 'FAILED' && event.state !== 'FINISHED'
+				const { state } = event
+
+				this.status = state
+				this.running = state !== 'FAILED' && state !== 'FINISHED' && state !== 'IDLE'
+				this.starCount = event.starCount
+				this.starHFD = event.starHFD
 
 				if (event.capture) {
 					this.cameraExposure.handleCameraCaptureEvent(event.capture, true)
 				}
 
-				if (event.state === 'CURVE_FITTED' && event.focusPoint) {
-					this.focusPoints.push(event.focusPoint)
-				} else if (event.state === 'ANALYSED') {
-					this.starCount = event.starCount
-					this.starHFD = event.starHFD
-				}
-
-				if (event.chart) {
-					this.updateChart(event.chart)
+				if (state === 'CURVE_FITTED') {
+					if (event.focusPoint) {
+						this.focusPoints.push(event.focusPoint)
+					}
+					if (event.chart) {
+						this.updateChart(event.chart)
+					}
 				}
 			})
 		})
@@ -362,6 +364,7 @@ export class AutoFocusComponent implements AfterViewInit, OnDestroy, Tickable {
 
 			const focuser = await this.api.focuser(this.focuser.id)
 			Object.assign(this.focuser, focuser)
+			this.loadPreference()
 		}
 	}
 
@@ -450,8 +453,8 @@ export class AutoFocusComponent implements AfterViewInit, OnDestroy, Tickable {
 	}
 
 	private loadPreference() {
-		if (this.camera?.id) {
-			Object.assign(this.preference, this.preferenceService.autoFocus(this.camera).get())
+		if (this.camera?.id && this.focuser?.id) {
+			Object.assign(this.preference, this.preferenceService.autoFocus(this.camera, this.focuser).get())
 			this.request = this.preference.request
 
 			if (this.camera.connected) {
@@ -461,8 +464,8 @@ export class AutoFocusComponent implements AfterViewInit, OnDestroy, Tickable {
 	}
 
 	protected savePreference() {
-		if (this.camera?.id) {
-			this.preferenceService.autoFocus(this.camera).set(this.preference)
+		if (this.camera?.id && this.focuser?.id) {
+			this.preferenceService.autoFocus(this.camera, this.focuser).set(this.preference)
 		}
 	}
 }
diff --git a/desktop/src/app/filterwheel/filterwheel.component.ts b/desktop/src/app/filterwheel/filterwheel.component.ts
index 1cc4c9bbf..c5866a8d1 100644
--- a/desktop/src/app/filterwheel/filterwheel.component.ts
+++ b/desktop/src/app/filterwheel/filterwheel.component.ts
@@ -247,7 +247,7 @@ export class FilterWheelComponent implements AfterContentInit, OnDestroy, Tickab
 
 				const offset = nextFocusOffset - currentFocusOffset
 
-				if (this.focuser && offset !== 0) {
+				if (this.focuser?.connected && offset !== 0) {
 					if (offset < 0) await this.api.focuserMoveIn(this.focuser, -offset)
 					else await this.api.focuserMoveOut(this.focuser, offset)
 				}
diff --git a/desktop/src/app/flat-wizard/flat-wizard.component.ts b/desktop/src/app/flat-wizard/flat-wizard.component.ts
index 9be7b2260..bc32f121e 100644
--- a/desktop/src/app/flat-wizard/flat-wizard.component.ts
+++ b/desktop/src/app/flat-wizard/flat-wizard.component.ts
@@ -57,15 +57,18 @@ export class FlatWizardComponent implements AfterViewInit, OnDestroy, Tickable {
 
 		electronService.on('FLAT_WIZARD.ELAPSED', (event) => {
 			ngZone.run(() => {
-				if (event.state === 'EXPOSURING' && event.capture && event.capture.camera.id === this.camera?.id) {
+				if (event.state === 'EXPOSURING' && event.capture && event.camera.id === this.camera?.id) {
 					this.running = true
 					this.cameraExposure.handleCameraCaptureEvent(event.capture, true)
-				} else if (event.state === 'CAPTURED') {
+				} else {
 					this.running = false
-					this.angularService.message('Flat frame captured')
-				} else if (event.state === 'FAILED') {
-					this.running = false
-					this.angularService.message('Failed to find an optimal exposure time from given parameters', 'error')
+					this.cameraExposure.reset()
+
+					if (event.state === 'CAPTURED') {
+						this.angularService.message('Flat frame captured')
+					} else if (event.state === 'FAILED') {
+						this.angularService.message('Failed to find an optimal exposure time from given parameters', 'error')
+					}
 				}
 			})
 		})
diff --git a/desktop/src/app/image/image.component.ts b/desktop/src/app/image/image.component.ts
index 9542ca963..74b37d3b9 100644
--- a/desktop/src/app/image/image.component.ts
+++ b/desktop/src/app/image/image.component.ts
@@ -449,7 +449,6 @@ export class ImageComponent implements AfterViewInit, OnDestroy {
 					await this.closeImage()
 
 					this.imageData.path = event.savedPath
-					this.imageData.capture = event.capture
 					this.imageData.exposureCount = event.exposureCount
 					this.liveStacking.path = event.liveStackedPath
 
diff --git a/desktop/src/app/mount/mount.component.html b/desktop/src/app/mount/mount.component.html
index 69e96a25d..7f8cf302a 100644
--- a/desktop/src/app/mount/mount.component.html
+++ b/desktop/src/app/mount/mount.component.html
@@ -476,7 +476,7 @@
 								severity="danger"
 								pTooltip="Stop"
 								tooltipPosition="bottom"
-								(onClick)="stopRemoteControl(item.type)" />
+								(onClick)="stopRemoteControl(item.protocol)" />
 						</div>
 					</div>
 				</ng-template>
diff --git a/desktop/src/app/sequencer/sequencer.component.ts b/desktop/src/app/sequencer/sequencer.component.ts
index 805b2b4e7..d783390b3 100644
--- a/desktop/src/app/sequencer/sequencer.component.ts
+++ b/desktop/src/app/sequencer/sequencer.component.ts
@@ -262,12 +262,12 @@ export class SequencerComponent implements AfterContentInit, OnDestroy, Tickable
 
 		electronService.on('SEQUENCER.ELAPSED', (event) => {
 			ngZone.run(() => {
-				if (this.running !== event.remainingTime > 0) {
-					this.enableOrDisableTopbarMenu(event.remainingTime <= 0)
+				if (this.running !== (event.state !== 'IDLE')) {
+					this.enableOrDisableTopbarMenu(this.running)
 				}
 
 				this.event = event
-				this.running = event.remainingTime > 0
+				this.running = event.state !== 'IDLE'
 
 				const captureEvent = event.capture
 
diff --git a/desktop/src/app/stacker/stacker.component.html b/desktop/src/app/stacker/stacker.component.html
index d44c2ccdc..fc21b4a44 100644
--- a/desktop/src/app/stacker/stacker.component.html
+++ b/desktop/src/app/stacker/stacker.component.html
@@ -92,8 +92,12 @@
 										<span *ngIf="item.analyzed.gain">GAIN: {{ item.analyzed.gain }}</span>
 									</div>
 								}
-								<div class="flex align-items-center justify-content-center gap-2 w-full">
-									<span class="text-xs text-gray-200">{{ item.path }}</span>
+								<div class="flex align-items-center justify-content-center w-full">
+									<span
+										class="text-xs text-gray-200"
+										style="word-break: break-all">
+										{{ item.path }}
+									</span>
 								</div>
 							</div>
 							<div class="flex flex-column justify-content-center align-items-center gap-2">
diff --git a/desktop/src/shared/components/camera-exposure/camera-exposure.component.ts b/desktop/src/shared/components/camera-exposure/camera-exposure.component.ts
index 1c51b1a50..31ee71c2c 100644
--- a/desktop/src/shared/components/camera-exposure/camera-exposure.component.ts
+++ b/desktop/src/shared/components/camera-exposure/camera-exposure.component.ts
@@ -25,11 +25,12 @@ export class CameraExposureComponent {
 		return this.state
 	}
 
-	handleCameraCaptureEvent(event: CameraCaptureEvent, looping: boolean = false) {
+	handleCameraCaptureEvent(event: Omit<CameraCaptureEvent, 'camera'>, looping: boolean = false) {
 		this.capture.elapsedTime = event.captureElapsedTime
 		this.capture.remainingTime = event.captureRemainingTime
 		this.capture.progress = event.captureProgress
 		this.capture.count = event.exposureCount
+		this.capture.amount = event.exposureAmount
 		if (looping) this.capture.looping = looping
 		this.step.elapsedTime = event.stepElapsedTime
 		this.step.remainingTime = event.stepRemainingTime
diff --git a/desktop/src/shared/interceptors/confirmation.interceptor.ts b/desktop/src/shared/interceptors/confirmation.interceptor.ts
index ec5be3093..3fe7e2bae 100644
--- a/desktop/src/shared/interceptors/confirmation.interceptor.ts
+++ b/desktop/src/shared/interceptors/confirmation.interceptor.ts
@@ -1,6 +1,6 @@
 import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http'
 import { Injectable } from '@angular/core'
-import { Observable, finalize } from 'rxjs'
+import { Observable } from 'rxjs'
 import { ConfirmationService } from '../services/confirmation.service'
 import { IdempotencyKeyInterceptor } from './idempotency-key.interceptor'
 
@@ -17,20 +17,8 @@ export class ConfirmationInterceptor implements HttpInterceptor {
 			if (idempotencyKey) {
 				this.confirmationService.register(idempotencyKey)
 			}
-
-			const res = next.handle(req)
-
-			if (idempotencyKey) {
-				return res.pipe(
-					finalize(() => {
-						this.confirmationService.unregister(idempotencyKey)
-					}),
-				)
-			}
-
-			return res
-		} else {
-			return next.handle(req)
 		}
+
+		return next.handle(req)
 	}
 }
diff --git a/desktop/src/shared/services/api.service.ts b/desktop/src/shared/services/api.service.ts
index 44ebede84..3f3ab681e 100644
--- a/desktop/src/shared/services/api.service.ts
+++ b/desktop/src/shared/services/api.service.ts
@@ -413,7 +413,7 @@ export class ApiService {
 	}
 
 	guidingDisconnect() {
-		return this.http.delete<never>(`guiding/disconnect`)
+		return this.http.put<never>(`guiding/disconnect`)
 	}
 
 	guidingStatus() {
diff --git a/desktop/src/shared/services/confirmation.service.ts b/desktop/src/shared/services/confirmation.service.ts
index 55b4c0b12..509c5a14b 100644
--- a/desktop/src/shared/services/confirmation.service.ts
+++ b/desktop/src/shared/services/confirmation.service.ts
@@ -6,7 +6,7 @@ import { ApiService } from './api.service'
 
 @Injectable({ providedIn: 'root' })
 export class ConfirmationService {
-	private readonly keys = new Map<string, string>()
+	private readonly keys = new Set<string>()
 
 	constructor(
 		private readonly angularService: AngularService,
@@ -14,11 +14,7 @@ export class ConfirmationService {
 	) {}
 
 	register(key: string) {
-		this.keys.set(key, '')
-	}
-
-	unregister(key: string) {
-		this.keys.delete(key)
+		this.keys.add(key)
 	}
 
 	has(key: string) {
@@ -28,6 +24,5 @@ export class ConfirmationService {
 	async processConfirmationEvent(event: ConfirmationEvent) {
 		const response = await this.angularService.confirm(event.message)
 		await this.api.confirm(event.idempotencyKey, response === ConfirmEventType.ACCEPT)
-		this.unregister(event.idempotencyKey)
 	}
 }
diff --git a/desktop/src/shared/services/preference.service.ts b/desktop/src/shared/services/preference.service.ts
index ea9586ef5..92397db96 100644
--- a/desktop/src/shared/services/preference.service.ts
+++ b/desktop/src/shared/services/preference.service.ts
@@ -103,8 +103,8 @@ export class PreferenceService {
 		return this.create<FlatWizardPreference>(`flatWizard.${camera.name}`, () => structuredClone(DEFAULT_FLAT_WIZARD_PREFERENCE), flatWizardPreferenceWithDefault)
 	}
 
-	autoFocus(camera: Camera) {
-		return this.create<AutoFocusPreference>(`autoFocus.${camera.name}`, () => structuredClone(DEFAULT_AUTO_FOCUS_PREFERENCE), autoFocusPreferenceWithDefault)
+	autoFocus(camera: Camera, focuser: Focuser) {
+		return this.create<AutoFocusPreference>(`autoFocus.${camera.name}.${focuser.name}`, () => structuredClone(DEFAULT_AUTO_FOCUS_PREFERENCE), autoFocusPreferenceWithDefault)
 	}
 
 	sequencer(camera: Camera) {
diff --git a/desktop/src/shared/types/alignment.types.ts b/desktop/src/shared/types/alignment.types.ts
index 9bb245529..e8af9ab96 100644
--- a/desktop/src/shared/types/alignment.types.ts
+++ b/desktop/src/shared/types/alignment.types.ts
@@ -27,7 +27,7 @@ export interface DARVEvent extends MessageEvent {
 	camera: Camera
 	state: DARVState
 	direction?: GuideDirection
-	capture: CameraCaptureEvent
+	capture: Omit<CameraCaptureEvent, 'camera'>
 }
 
 export interface TPPAStart {
@@ -62,7 +62,7 @@ export interface TPPAEvent extends MessageEvent {
 	totalError: Angle
 	azimuthErrorDirection: string
 	altitudeErrorDirection: string
-	capture?: CameraCaptureEvent
+	capture: Omit<CameraCaptureEvent, 'camera'>
 }
 
 export interface DARVResult {
diff --git a/desktop/src/shared/types/autofocus.type.ts b/desktop/src/shared/types/autofocus.type.ts
index 874f452e5..b1e14d9e7 100644
--- a/desktop/src/shared/types/autofocus.type.ts
+++ b/desktop/src/shared/types/autofocus.type.ts
@@ -22,7 +22,6 @@ export interface AutoFocusRequest {
 	backlashCompensation: BacklashCompensation
 	initialOffsetSteps: number
 	stepSize: number
-	totalNumberOfAttempts: number
 	starDetector: StarDetectionRequest
 }
 
@@ -96,7 +95,6 @@ export const DEFAULT_AUTO_FOCUS_REQUEST: AutoFocusRequest = {
 	rSquaredThreshold: 0.5,
 	initialOffsetSteps: 4,
 	stepSize: 100,
-	totalNumberOfAttempts: 1,
 	backlashCompensation: DEFAULT_BACKLASH_COMPENSATION,
 	starDetector: DEFAULT_STAR_DETECTION_REQUEST,
 }
@@ -120,7 +118,6 @@ export function autoFocusRequestWithDefault(request?: Partial<AutoFocusRequest>,
 	request.rSquaredThreshold ??= source.rSquaredThreshold
 	request.initialOffsetSteps ??= source.initialOffsetSteps
 	request.stepSize ??= source.stepSize
-	request.totalNumberOfAttempts ??= source.totalNumberOfAttempts
 	request.backlashCompensation = backlashCompensationWithDefault(request.backlashCompensation, source.backlashCompensation)
 	request.starDetector = starDetectionRequestWithDefault(request.starDetector, source.starDetector)
 	return request as AutoFocusRequest
diff --git a/desktop/src/shared/types/camera.types.ts b/desktop/src/shared/types/camera.types.ts
index cb8eb75bd..95c1ccb72 100644
--- a/desktop/src/shared/types/camera.types.ts
+++ b/desktop/src/shared/types/camera.types.ts
@@ -131,7 +131,6 @@ export interface CameraCaptureEvent extends MessageEvent {
 	savedPath?: string
 	liveStackedPath?: string
 	state: CameraCaptureState
-	capture?: CameraStartCapture
 }
 
 export interface CameraDialogInput {
diff --git a/desktop/src/shared/types/flat-wizard.types.ts b/desktop/src/shared/types/flat-wizard.types.ts
index d7565dfe5..dbb0dd14b 100644
--- a/desktop/src/shared/types/flat-wizard.types.ts
+++ b/desktop/src/shared/types/flat-wizard.types.ts
@@ -1,4 +1,4 @@
-import { cameraStartCaptureWithDefault, DEFAULT_CAMERA_START_CAPTURE, type CameraCaptureEvent, type CameraStartCapture } from './camera.types'
+import { cameraStartCaptureWithDefault, DEFAULT_CAMERA_START_CAPTURE, type Camera, type CameraCaptureEvent, type CameraStartCapture } from './camera.types'
 
 export type FlatWizardState = 'EXPOSURING' | 'CAPTURED' | 'FAILED'
 
@@ -15,9 +15,10 @@ export interface FlatWizardRequest {
 }
 
 export interface FlatWizardEvent {
+	camera: Camera
 	state: FlatWizardState
 	exposureTime: number
-	capture?: CameraCaptureEvent
+	capture?: Omit<CameraCaptureEvent, 'camera'>
 	savedPath?: string
 }
 
diff --git a/desktop/src/shared/types/sequencer.types.ts b/desktop/src/shared/types/sequencer.types.ts
index e1b1118ee..207ff3f81 100644
--- a/desktop/src/shared/types/sequencer.types.ts
+++ b/desktop/src/shared/types/sequencer.types.ts
@@ -23,7 +23,7 @@ export type Sequence = CameraStartCapture
 
 export type SequencerCaptureMode = 'FULLY' | 'INTERLEAVED'
 
-export type SequencerState = 'IDLE' | 'PAUSING' | 'PAUSED' | 'RUNNING'
+export type SequencerState = 'IDLE' | 'WAITING' | 'PAUSING' | 'PAUSED' | 'RUNNING'
 
 export type SequenceProperty = 'EXPOSURE_TIME' | 'EXPOSURE_AMOUNT' | 'EXPOSURE_DELAY' | 'FRAME_TYPE' | 'X' | 'Y' | 'WIDTH' | 'HEIGHT' | 'BIN' | 'FRAME_FORMAT' | 'GAIN' | 'OFFSET' | 'STACKING_GROUP' | 'CALIBRATION_GROUP'
 
@@ -61,11 +61,12 @@ export interface SequencerPlan {
 }
 
 export interface SequencerEvent extends MessageEvent {
+	camera: Camera
 	id: number
 	elapsedTime: number
 	remainingTime: number
 	progress: number
-	capture?: CameraCaptureEvent
+	capture?: Omit<CameraCaptureEvent, 'camera'>
 	state: SequencerState
 }
 
diff --git a/docs/package-lock.json b/docs/package-lock.json
index 92b0fac52..42544941d 100644
--- a/docs/package-lock.json
+++ b/docs/package-lock.json
@@ -9,10 +9,10 @@
             "version": "0.0.1",
             "dependencies": {
                 "@astrojs/check": "0.9.3",
-                "@astrojs/starlight": "0.26.1",
-                "astro": "4.14.3",
+                "@astrojs/starlight": "0.28.2",
+                "astro": "4.15.9",
                 "sharp": "0.33.5",
-                "typescript": "5.5.4"
+                "typescript": "5.6.2"
             }
         },
         "node_modules/@ampproject/remapping": {
@@ -60,9 +60,9 @@
             "license": "MIT"
         },
         "node_modules/@astrojs/language-server": {
-            "version": "2.14.1",
-            "resolved": "https://registry.npmjs.org/@astrojs/language-server/-/language-server-2.14.1.tgz",
-            "integrity": "sha512-mkKtCTPRD4dyKdAqIP0zmmPyO/ZABOqFESnaVca47Dg/sAagJnDSEsDUDzNbHFh1+9Dj1o5y4iwNsxJboGdaNg==",
+            "version": "2.14.2",
+            "resolved": "https://registry.npmjs.org/@astrojs/language-server/-/language-server-2.14.2.tgz",
+            "integrity": "sha512-daUJ/+/2pPF3eGG4tVdXKyw0tabUDrJKwLzU8VTuNhEHIn3VZAIES6VT3+mX0lmKcMiKM8/bjZdfY+fPfmnsMA==",
             "license": "MIT",
             "dependencies": {
                 "@astrojs/compiler": "^2.10.3",
@@ -128,9 +128,9 @@
             }
         },
         "node_modules/@astrojs/mdx": {
-            "version": "3.1.4",
-            "resolved": "https://registry.npmjs.org/@astrojs/mdx/-/mdx-3.1.4.tgz",
-            "integrity": "sha512-AcdcAlDpzTM5LHpur7A3NWoIqyfhH1gZNbTvvjiUlDEo7eJjIxl4gdWrb/kZZRfLBEuM8cptCB+Qk11ncQL4IA==",
+            "version": "3.1.7",
+            "resolved": "https://registry.npmjs.org/@astrojs/mdx/-/mdx-3.1.7.tgz",
+            "integrity": "sha512-8lGdCt+S0TrZgQpbcP3fQJc4cTeacAirtz9TpAMtHCWrQGW8slKt3WG4/0N+bhZgYRC4h5AT5drzFz+y3wvmsg==",
             "license": "MIT",
             "dependencies": {
                 "@astrojs/markdown-remark": "5.2.0",
@@ -139,14 +139,14 @@
                 "es-module-lexer": "^1.5.4",
                 "estree-util-visit": "^2.0.0",
                 "gray-matter": "^4.0.3",
-                "hast-util-to-html": "^9.0.1",
+                "hast-util-to-html": "^9.0.2",
                 "kleur": "^4.1.5",
                 "rehype-raw": "^7.0.0",
                 "remark-gfm": "^4.0.0",
                 "remark-smartypants": "^3.0.2",
                 "source-map": "^0.7.4",
                 "unist-util-visit": "^5.0.0",
-                "vfile": "^6.0.2"
+                "vfile": "^6.0.3"
             },
             "engines": {
                 "node": "^18.17.1 || ^20.3.0 || >=21.0.0"
@@ -179,9 +179,9 @@
             }
         },
         "node_modules/@astrojs/starlight": {
-            "version": "0.26.1",
-            "resolved": "https://registry.npmjs.org/@astrojs/starlight/-/starlight-0.26.1.tgz",
-            "integrity": "sha512-0qNYWZJ+ZOdSfM7du6fGuwUhyTHtAeRIl0zYe+dF0TxDvcakplO1SYLbGGX6lEVYE3PdBne7dcJww85bXZJIIQ==",
+            "version": "0.28.2",
+            "resolved": "https://registry.npmjs.org/@astrojs/starlight/-/starlight-0.28.2.tgz",
+            "integrity": "sha512-Q1/Ujl2EzWX71qwqdt/0KP3wOyX6Rvyzcep/zD3hRCtw/Vi2TReh4Q2wLwz7mnbuYU9H7YvBKYknbkmjC+K/0w==",
             "license": "MIT",
             "dependencies": {
                 "@astrojs/mdx": "^3.1.3",
@@ -195,6 +195,7 @@
                 "hast-util-select": "^6.0.2",
                 "hast-util-to-string": "^3.0.0",
                 "hastscript": "^9.0.0",
+                "i18next": "^23.11.5",
                 "mdast-util-directive": "^3.0.0",
                 "mdast-util-to-markdown": "^2.1.0",
                 "mdast-util-to-string": "^4.0.0",
@@ -207,7 +208,7 @@
                 "vfile": "^6.0.2"
             },
             "peerDependencies": {
-                "astro": "^4.8.6"
+                "astro": "^4.14.0"
             }
         },
         "node_modules/@astrojs/telemetry": {
@@ -251,9 +252,9 @@
             }
         },
         "node_modules/@babel/compat-data": {
-            "version": "7.25.2",
-            "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.25.2.tgz",
-            "integrity": "sha512-bYcppcpKBvX4znYaPEeFau03bp89ShqNMLs+rmdptMw+heSZh9+z84d2YG+K7cYLbWwzdjtDoW/uqZmPjulClQ==",
+            "version": "7.25.4",
+            "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.25.4.tgz",
+            "integrity": "sha512-+LGRog6RAsCJrrrg/IO6LGmpphNe5DiK30dGjCoxxeGv49B10/3XYGxPsAwrDlMFcFEvdAUavDT8r9k/hSyQqQ==",
             "license": "MIT",
             "engines": {
                 "node": ">=6.9.0"
@@ -299,12 +300,12 @@
             }
         },
         "node_modules/@babel/generator": {
-            "version": "7.25.0",
-            "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.25.0.tgz",
-            "integrity": "sha512-3LEEcj3PVW8pW2R1SR1M89g/qrYk/m/mB/tLqn7dn4sbBUQyTqnlod+II2U4dqiGtUmkcnAmkMDralTFZttRiw==",
+            "version": "7.25.6",
+            "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.25.6.tgz",
+            "integrity": "sha512-VPC82gr1seXOpkjAAKoLhP50vx4vGNlF4msF64dSFq1P8RfB+QAuJWGHPXXPc8QyfVWwwB/TNNU4+ayZmHNbZw==",
             "license": "MIT",
             "dependencies": {
-                "@babel/types": "^7.25.0",
+                "@babel/types": "^7.25.6",
                 "@jridgewell/gen-mapping": "^0.3.5",
                 "@jridgewell/trace-mapping": "^0.3.25",
                 "jsesc": "^2.5.1"
@@ -431,13 +432,13 @@
             }
         },
         "node_modules/@babel/helpers": {
-            "version": "7.25.0",
-            "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.25.0.tgz",
-            "integrity": "sha512-MjgLZ42aCm0oGjJj8CtSM3DB8NOOf8h2l7DCTePJs29u+v7yO/RBX9nShlKMgFnRks/Q4tBAe7Hxnov9VkGwLw==",
+            "version": "7.25.6",
+            "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.25.6.tgz",
+            "integrity": "sha512-Xg0tn4HcfTijTwfDwYlvVCl43V6h4KyVVX2aEm4qdO/PC6L2YvzLHFdmxhoeSA3eslcE6+ZVXHgWwopXYLNq4Q==",
             "license": "MIT",
             "dependencies": {
                 "@babel/template": "^7.25.0",
-                "@babel/types": "^7.25.0"
+                "@babel/types": "^7.25.6"
             },
             "engines": {
                 "node": ">=6.9.0"
@@ -459,12 +460,12 @@
             }
         },
         "node_modules/@babel/parser": {
-            "version": "7.25.3",
-            "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.25.3.tgz",
-            "integrity": "sha512-iLTJKDbJ4hMvFPgQwwsVoxtHyWpKKPBrxkANrSYewDPaPpT5py5yeVkgPIJ7XYXhndxJpaA3PyALSXQ7u8e/Dw==",
+            "version": "7.25.6",
+            "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.25.6.tgz",
+            "integrity": "sha512-trGdfBdbD0l1ZPmcJ83eNxB9rbEax4ALFTF7fN386TMYbeCQbyme5cOEXQhbGXKebwGaB/J52w1mrklMcbgy6Q==",
             "license": "MIT",
             "dependencies": {
-                "@babel/types": "^7.25.2"
+                "@babel/types": "^7.25.6"
             },
             "bin": {
                 "parser": "bin/babel-parser.js"
@@ -507,6 +508,18 @@
                 "@babel/core": "^7.0.0-0"
             }
         },
+        "node_modules/@babel/runtime": {
+            "version": "7.25.6",
+            "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.25.6.tgz",
+            "integrity": "sha512-VBj9MYyDb9tuLq7yzqjgzt6Q+IBQLrGZfdjOekyEirZPHxXWoTSGUTMrpsfi58Up73d13NfYLv8HT9vmznjzhQ==",
+            "license": "MIT",
+            "dependencies": {
+                "regenerator-runtime": "^0.14.0"
+            },
+            "engines": {
+                "node": ">=6.9.0"
+            }
+        },
         "node_modules/@babel/template": {
             "version": "7.25.0",
             "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.25.0.tgz",
@@ -522,16 +535,16 @@
             }
         },
         "node_modules/@babel/traverse": {
-            "version": "7.25.3",
-            "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.25.3.tgz",
-            "integrity": "sha512-HefgyP1x754oGCsKmV5reSmtV7IXj/kpaE1XYY+D9G5PvKKoFfSbiS4M77MdjuwlZKDIKFCffq9rPU+H/s3ZdQ==",
+            "version": "7.25.6",
+            "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.25.6.tgz",
+            "integrity": "sha512-9Vrcx5ZW6UwK5tvqsj0nGpp/XzqthkT0dqIc9g1AdtygFToNtTF67XzYS//dm+SAK9cp3B9R4ZO/46p63SCjlQ==",
             "license": "MIT",
             "dependencies": {
                 "@babel/code-frame": "^7.24.7",
-                "@babel/generator": "^7.25.0",
-                "@babel/parser": "^7.25.3",
+                "@babel/generator": "^7.25.6",
+                "@babel/parser": "^7.25.6",
                 "@babel/template": "^7.25.0",
-                "@babel/types": "^7.25.2",
+                "@babel/types": "^7.25.6",
                 "debug": "^4.3.1",
                 "globals": "^11.1.0"
             },
@@ -540,9 +553,9 @@
             }
         },
         "node_modules/@babel/types": {
-            "version": "7.25.2",
-            "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.25.2.tgz",
-            "integrity": "sha512-YTnYtra7W9e6/oAZEHj0bJehPRUlLH9/fbpT5LfB0NhQXyALCRkRs3zH9v07IYhkgpqX6Z78FnuccZr/l4Fs4Q==",
+            "version": "7.25.6",
+            "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.25.6.tgz",
+            "integrity": "sha512-/l42B1qxpG6RdfYf343Uw1vmDjeNhneUXtzhojE7pDgfpEypmRhI6j1kr17XCVv4Cgl9HdAiQY2x0GwKm7rWCw==",
             "license": "MIT",
             "dependencies": {
                 "@babel/helper-string-parser": "^7.24.8",
@@ -1520,9 +1533,9 @@
             }
         },
         "node_modules/@oslojs/encoding": {
-            "version": "0.4.1",
-            "resolved": "https://registry.npmjs.org/@oslojs/encoding/-/encoding-0.4.1.tgz",
-            "integrity": "sha512-hkjo6MuIK/kQR5CrGNdAPZhS01ZCXuWDRJ187zh6qqF2+yMHZpD9fAYpX8q2bOO6Ryhl3XpCT6kUX76N8hhm4Q==",
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/@oslojs/encoding/-/encoding-1.1.0.tgz",
+            "integrity": "sha512-70wQhgYmndg4GCPxPPxPGevRKqTIJ2Nh4OkiMWmDAVYsTQ+Ta7Sq+rPevXyXGdzr30/qZBnyOalCszoMxlyldQ==",
             "license": "MIT"
         },
         "node_modules/@pagefind/darwin-arm64": {
@@ -1532,6 +1545,7 @@
             "cpu": [
                 "arm64"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "darwin"
@@ -1544,6 +1558,7 @@
             "cpu": [
                 "x64"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "darwin"
@@ -1552,7 +1567,8 @@
         "node_modules/@pagefind/default-ui": {
             "version": "1.1.1",
             "resolved": "https://registry.npmjs.org/@pagefind/default-ui/-/default-ui-1.1.1.tgz",
-            "integrity": "sha512-ZM0zDatWDnac/VGHhQCiM7UgA4ca8jpjA+VfuTJyHJBaxGqZMQnm4WoTz9E0KFcue1Bh9kxpu7uWFZfwpZZk0A=="
+            "integrity": "sha512-ZM0zDatWDnac/VGHhQCiM7UgA4ca8jpjA+VfuTJyHJBaxGqZMQnm4WoTz9E0KFcue1Bh9kxpu7uWFZfwpZZk0A==",
+            "license": "MIT"
         },
         "node_modules/@pagefind/linux-arm64": {
             "version": "1.1.1",
@@ -1561,6 +1577,7 @@
             "cpu": [
                 "arm64"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "linux"
@@ -1573,6 +1590,7 @@
             "cpu": [
                 "x64"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "linux"
@@ -1585,15 +1603,16 @@
             "cpu": [
                 "x64"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "win32"
             ]
         },
         "node_modules/@rollup/pluginutils": {
-            "version": "5.1.0",
-            "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.1.0.tgz",
-            "integrity": "sha512-XTIWOPPcpvyKI6L1NHo0lFlCyznUEyPmPY1mc3KpPVDYulHSTvyeLNVW00QTLIAFNhR3kYnJTQHeGqU4M3n09g==",
+            "version": "5.1.2",
+            "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.1.2.tgz",
+            "integrity": "sha512-/FIdS3PyZ39bjZlwqFnWqCOVnW7o963LtKMwQOD0NhQqw22gSr2YY1afu3FxRip4ZCZNsD5jq6Aaz6QV3D/Njw==",
             "license": "MIT",
             "dependencies": {
                 "@types/estree": "^1.0.0",
@@ -1619,206 +1638,264 @@
             "license": "MIT"
         },
         "node_modules/@rollup/rollup-android-arm-eabi": {
-            "version": "4.22.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.22.4.tgz",
-            "integrity": "sha512-Fxamp4aEZnfPOcGA8KSNEohV8hX7zVHOemC8jVBoBUHu5zpJK/Eu3uJwt6BMgy9fkvzxDaurgj96F/NiLukF2w==",
+            "version": "4.23.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.23.0.tgz",
+            "integrity": "sha512-8OR+Ok3SGEMsAZispLx8jruuXw0HVF16k+ub2eNXKHDmdxL4cf9NlNpAzhlOhNyXzKDEJuFeq0nZm+XlNb1IFw==",
             "cpu": [
                 "arm"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "android"
             ]
         },
         "node_modules/@rollup/rollup-android-arm64": {
-            "version": "4.22.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.22.4.tgz",
-            "integrity": "sha512-VXoK5UMrgECLYaMuGuVTOx5kcuap1Jm8g/M83RnCHBKOqvPPmROFJGQaZhGccnsFtfXQ3XYa4/jMCJvZnbJBdA==",
+            "version": "4.23.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.23.0.tgz",
+            "integrity": "sha512-rEFtX1nP8gqmLmPZsXRMoLVNB5JBwOzIAk/XAcEPuKrPa2nPJ+DuGGpfQUR0XjRm8KjHfTZLpWbKXkA5BoFL3w==",
             "cpu": [
                 "arm64"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "android"
             ]
         },
         "node_modules/@rollup/rollup-darwin-arm64": {
-            "version": "4.22.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.22.4.tgz",
-            "integrity": "sha512-xMM9ORBqu81jyMKCDP+SZDhnX2QEVQzTcC6G18KlTQEzWK8r/oNZtKuZaCcHhnsa6fEeOBionoyl5JsAbE/36Q==",
+            "version": "4.23.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.23.0.tgz",
+            "integrity": "sha512-ZbqlMkJRMMPeapfaU4drYHns7Q5MIxjM/QeOO62qQZGPh9XWziap+NF9fsqPHT0KzEL6HaPspC7sOwpgyA3J9g==",
             "cpu": [
                 "arm64"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "darwin"
             ]
         },
         "node_modules/@rollup/rollup-darwin-x64": {
-            "version": "4.22.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.22.4.tgz",
-            "integrity": "sha512-aJJyYKQwbHuhTUrjWjxEvGnNNBCnmpHDvrb8JFDbeSH3m2XdHcxDd3jthAzvmoI8w/kSjd2y0udT+4okADsZIw==",
+            "version": "4.23.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.23.0.tgz",
+            "integrity": "sha512-PfmgQp78xx5rBCgn2oYPQ1rQTtOaQCna0kRaBlc5w7RlA3TDGGo7m3XaptgitUZ54US9915i7KeVPHoy3/W8tA==",
             "cpu": [
                 "x64"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "darwin"
             ]
         },
         "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
-            "version": "4.22.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.22.4.tgz",
-            "integrity": "sha512-j63YtCIRAzbO+gC2L9dWXRh5BFetsv0j0va0Wi9epXDgU/XUi5dJKo4USTttVyK7fGw2nPWK0PbAvyliz50SCQ==",
+            "version": "4.23.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.23.0.tgz",
+            "integrity": "sha512-WAeZfAAPus56eQgBioezXRRzArAjWJGjNo/M+BHZygUcs9EePIuGI1Wfc6U/Ki+tMW17FFGvhCfYnfcKPh18SA==",
             "cpu": [
                 "arm"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "linux"
             ]
         },
         "node_modules/@rollup/rollup-linux-arm-musleabihf": {
-            "version": "4.22.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.22.4.tgz",
-            "integrity": "sha512-dJnWUgwWBX1YBRsuKKMOlXCzh2Wu1mlHzv20TpqEsfdZLb3WoJW2kIEsGwLkroYf24IrPAvOT/ZQ2OYMV6vlrg==",
+            "version": "4.23.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.23.0.tgz",
+            "integrity": "sha512-v7PGcp1O5XKZxKX8phTXtmJDVpE20Ub1eF6w9iMmI3qrrPak6yR9/5eeq7ziLMrMTjppkkskXyxnmm00HdtXjA==",
             "cpu": [
                 "arm"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "linux"
             ]
         },
         "node_modules/@rollup/rollup-linux-arm64-gnu": {
-            "version": "4.22.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.22.4.tgz",
-            "integrity": "sha512-AdPRoNi3NKVLolCN/Sp4F4N1d98c4SBnHMKoLuiG6RXgoZ4sllseuGioszumnPGmPM2O7qaAX/IJdeDU8f26Aw==",
+            "version": "4.23.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.23.0.tgz",
+            "integrity": "sha512-nAbWsDZ9UkU6xQiXEyXBNHAKbzSAi95H3gTStJq9UGiS1v+YVXwRHcQOQEF/3CHuhX5BVhShKoeOf6Q/1M+Zhg==",
             "cpu": [
                 "arm64"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "linux"
             ]
         },
         "node_modules/@rollup/rollup-linux-arm64-musl": {
-            "version": "4.22.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.22.4.tgz",
-            "integrity": "sha512-Gl0AxBtDg8uoAn5CCqQDMqAx22Wx22pjDOjBdmG0VIWX3qUBHzYmOKh8KXHL4UpogfJ14G4wk16EQogF+v8hmA==",
+            "version": "4.23.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.23.0.tgz",
+            "integrity": "sha512-5QT/Di5FbGNPaVw8hHO1wETunwkPuZBIu6W+5GNArlKHD9fkMHy7vS8zGHJk38oObXfWdsuLMogD4sBySLJ54g==",
             "cpu": [
                 "arm64"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "linux"
             ]
         },
         "node_modules/@rollup/rollup-linux-powerpc64le-gnu": {
-            "version": "4.22.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.22.4.tgz",
-            "integrity": "sha512-3aVCK9xfWW1oGQpTsYJJPF6bfpWfhbRnhdlyhak2ZiyFLDaayz0EP5j9V1RVLAAxlmWKTDfS9wyRyY3hvhPoOg==",
+            "version": "4.23.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.23.0.tgz",
+            "integrity": "sha512-Sefl6vPyn5axzCsO13r1sHLcmPuiSOrKIImnq34CBurntcJ+lkQgAaTt/9JkgGmaZJ+OkaHmAJl4Bfd0DmdtOQ==",
             "cpu": [
                 "ppc64"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "linux"
             ]
         },
         "node_modules/@rollup/rollup-linux-riscv64-gnu": {
-            "version": "4.22.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.22.4.tgz",
-            "integrity": "sha512-ePYIir6VYnhgv2C5Xe9u+ico4t8sZWXschR6fMgoPUK31yQu7hTEJb7bCqivHECwIClJfKgE7zYsh1qTP3WHUA==",
+            "version": "4.23.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.23.0.tgz",
+            "integrity": "sha512-o4QI2KU/QbP7ZExMse6ULotdV3oJUYMrdx3rBZCgUF3ur3gJPfe8Fuasn6tia16c5kZBBw0aTmaUygad6VB/hQ==",
             "cpu": [
                 "riscv64"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "linux"
             ]
         },
         "node_modules/@rollup/rollup-linux-s390x-gnu": {
-            "version": "4.22.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.22.4.tgz",
-            "integrity": "sha512-GqFJ9wLlbB9daxhVlrTe61vJtEY99/xB3C8e4ULVsVfflcpmR6c8UZXjtkMA6FhNONhj2eA5Tk9uAVw5orEs4Q==",
+            "version": "4.23.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.23.0.tgz",
+            "integrity": "sha512-+bxqx+V/D4FGrpXzPGKp/SEZIZ8cIW3K7wOtcJAoCrmXvzRtmdUhYNbgd+RztLzfDEfA2WtKj5F4tcbNPuqgeg==",
             "cpu": [
                 "s390x"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "linux"
             ]
         },
         "node_modules/@rollup/rollup-linux-x64-gnu": {
-            "version": "4.22.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.22.4.tgz",
-            "integrity": "sha512-87v0ol2sH9GE3cLQLNEy0K/R0pz1nvg76o8M5nhMR0+Q+BBGLnb35P0fVz4CQxHYXaAOhE8HhlkaZfsdUOlHwg==",
+            "version": "4.23.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.23.0.tgz",
+            "integrity": "sha512-I/eXsdVoCKtSgK9OwyQKPAfricWKUMNCwJKtatRYMmDo5N859tbO3UsBw5kT3dU1n6ZcM1JDzPRSGhAUkxfLxw==",
             "cpu": [
                 "x64"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "linux"
             ]
         },
         "node_modules/@rollup/rollup-linux-x64-musl": {
-            "version": "4.22.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.22.4.tgz",
-            "integrity": "sha512-UV6FZMUgePDZrFjrNGIWzDo/vABebuXBhJEqrHxrGiU6HikPy0Z3LfdtciIttEUQfuDdCn8fqh7wiFJjCNwO+g==",
+            "version": "4.23.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.23.0.tgz",
+            "integrity": "sha512-4ZoDZy5ShLbbe1KPSafbFh1vbl0asTVfkABC7eWqIs01+66ncM82YJxV2VtV3YVJTqq2P8HMx3DCoRSWB/N3rw==",
             "cpu": [
                 "x64"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "linux"
             ]
         },
         "node_modules/@rollup/rollup-win32-arm64-msvc": {
-            "version": "4.22.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.22.4.tgz",
-            "integrity": "sha512-BjI+NVVEGAXjGWYHz/vv0pBqfGoUH0IGZ0cICTn7kB9PyjrATSkX+8WkguNjWoj2qSr1im/+tTGRaY+4/PdcQw==",
+            "version": "4.23.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.23.0.tgz",
+            "integrity": "sha512-+5Ky8dhft4STaOEbZu3/NU4QIyYssKO+r1cD3FzuusA0vO5gso15on7qGzKdNXnc1gOrsgCqZjRw1w+zL4y4hQ==",
             "cpu": [
                 "arm64"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "win32"
             ]
         },
         "node_modules/@rollup/rollup-win32-ia32-msvc": {
-            "version": "4.22.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.22.4.tgz",
-            "integrity": "sha512-SiWG/1TuUdPvYmzmYnmd3IEifzR61Tragkbx9D3+R8mzQqDBz8v+BvZNDlkiTtI9T15KYZhP0ehn3Dld4n9J5g==",
+            "version": "4.23.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.23.0.tgz",
+            "integrity": "sha512-0SPJk4cPZQhq9qA1UhIRumSE3+JJIBBjtlGl5PNC///BoaByckNZd53rOYD0glpTkYFBQSt7AkMeLVPfx65+BQ==",
             "cpu": [
                 "ia32"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "win32"
             ]
         },
         "node_modules/@rollup/rollup-win32-x64-msvc": {
-            "version": "4.22.4",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.22.4.tgz",
-            "integrity": "sha512-j8pPKp53/lq9lMXN57S8cFz0MynJk8OWNuUnXct/9KCpKU7DgU3bYMJhwWmcqC0UU29p8Lr0/7KEVcaM6bf47Q==",
+            "version": "4.23.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.23.0.tgz",
+            "integrity": "sha512-lqCK5GQC8fNo0+JvTSxcG7YB1UKYp8yrNLhsArlvPWN+16ovSZgoehlVHg6X0sSWPUkpjRBR5TuR12ZugowZ4g==",
             "cpu": [
                 "x64"
             ],
+            "license": "MIT",
             "optional": true,
             "os": [
                 "win32"
             ]
         },
         "node_modules/@shikijs/core": {
-            "version": "1.14.1",
-            "resolved": "https://registry.npmjs.org/@shikijs/core/-/core-1.14.1.tgz",
-            "integrity": "sha512-KyHIIpKNaT20FtFPFjCQB5WVSTpLR/n+jQXhWHWVUMm9MaOaG9BGOG0MSyt7yA4+Lm+4c9rTc03tt3nYzeYSfw==",
+            "version": "1.21.0",
+            "resolved": "https://registry.npmjs.org/@shikijs/core/-/core-1.21.0.tgz",
+            "integrity": "sha512-zAPMJdiGuqXpZQ+pWNezQAk5xhzRXBNiECFPcJLtUdsFM3f//G95Z15EHTnHchYycU8kIIysqGgxp8OVSj1SPQ==",
+            "license": "MIT",
+            "dependencies": {
+                "@shikijs/engine-javascript": "1.21.0",
+                "@shikijs/engine-oniguruma": "1.21.0",
+                "@shikijs/types": "1.21.0",
+                "@shikijs/vscode-textmate": "^9.2.2",
+                "@types/hast": "^3.0.4",
+                "hast-util-to-html": "^9.0.3"
+            }
+        },
+        "node_modules/@shikijs/engine-javascript": {
+            "version": "1.21.0",
+            "resolved": "https://registry.npmjs.org/@shikijs/engine-javascript/-/engine-javascript-1.21.0.tgz",
+            "integrity": "sha512-jxQHNtVP17edFW4/0vICqAVLDAxmyV31MQJL4U/Kg+heQALeKYVOWo0sMmEZ18FqBt+9UCdyqGKYE7bLRtk9mg==",
+            "license": "MIT",
+            "dependencies": {
+                "@shikijs/types": "1.21.0",
+                "@shikijs/vscode-textmate": "^9.2.2",
+                "oniguruma-to-js": "0.4.3"
+            }
+        },
+        "node_modules/@shikijs/engine-oniguruma": {
+            "version": "1.21.0",
+            "resolved": "https://registry.npmjs.org/@shikijs/engine-oniguruma/-/engine-oniguruma-1.21.0.tgz",
+            "integrity": "sha512-AIZ76XocENCrtYzVU7S4GY/HL+tgHGbVU+qhiDyNw1qgCA5OSi4B4+HY4BtAoJSMGuD/L5hfTzoRVbzEm2WTvg==",
+            "license": "MIT",
+            "dependencies": {
+                "@shikijs/types": "1.21.0",
+                "@shikijs/vscode-textmate": "^9.2.2"
+            }
+        },
+        "node_modules/@shikijs/types": {
+            "version": "1.21.0",
+            "resolved": "https://registry.npmjs.org/@shikijs/types/-/types-1.21.0.tgz",
+            "integrity": "sha512-tzndANDhi5DUndBtpojEq/42+dpUF2wS7wdCDQaFtIXm3Rd1QkrcVgSSRLOvEwexekihOXfbYJINW37g96tJRw==",
             "license": "MIT",
             "dependencies": {
+                "@shikijs/vscode-textmate": "^9.2.2",
                 "@types/hast": "^3.0.4"
             }
         },
+        "node_modules/@shikijs/vscode-textmate": {
+            "version": "9.2.2",
+            "resolved": "https://registry.npmjs.org/@shikijs/vscode-textmate/-/vscode-textmate-9.2.2.tgz",
+            "integrity": "sha512-TMp15K+GGYrWlZM8+Lnj9EaHEFmOen0WJBrfa17hF7taDOYthuPPV0GWzfd/9iMij0akS/8Yw2ikquH7uVi/fg==",
+            "license": "MIT"
+        },
         "node_modules/@types/acorn": {
             "version": "4.0.6",
             "resolved": "https://registry.npmjs.org/@types/acorn/-/acorn-4.0.6.tgz",
@@ -1885,9 +1962,9 @@
             }
         },
         "node_modules/@types/estree": {
-            "version": "1.0.5",
-            "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.5.tgz",
-            "integrity": "sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==",
+            "version": "1.0.6",
+            "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.6.tgz",
+            "integrity": "sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==",
             "license": "MIT"
         },
         "node_modules/@types/estree-jsx": {
@@ -1939,9 +2016,9 @@
             }
         },
         "node_modules/@types/node": {
-            "version": "22.5.0",
-            "resolved": "https://registry.npmjs.org/@types/node/-/node-22.5.0.tgz",
-            "integrity": "sha512-DkFrJOe+rfdHTqqMg0bSNlGlQ85hSoh2TPzZyhHsXnMtligRWpxUySiyw8FY14ITt24HVCiQPWxS3KO/QlGmWg==",
+            "version": "22.7.4",
+            "resolved": "https://registry.npmjs.org/@types/node/-/node-22.7.4.tgz",
+            "integrity": "sha512-y+NPi1rFzDs1NdQHHToqeiX2TIS79SWEAw9GYhkkx8bD0ChpfqC+n2j5OXOCpzfojBEBt6DnEnnG9MY0zk1XLg==",
             "license": "MIT",
             "dependencies": {
                 "undici-types": "~6.19.2"
@@ -1969,13 +2046,13 @@
             "license": "ISC"
         },
         "node_modules/@volar/kit": {
-            "version": "2.4.0",
-            "resolved": "https://registry.npmjs.org/@volar/kit/-/kit-2.4.0.tgz",
-            "integrity": "sha512-uqwtPKhrbnP+3f8hs+ltDYXLZ6Wdbs54IzkaPocasI4aBhqWLht5qXctE1MqpZU52wbH359E0u9nhxEFmyon+w==",
+            "version": "2.4.5",
+            "resolved": "https://registry.npmjs.org/@volar/kit/-/kit-2.4.5.tgz",
+            "integrity": "sha512-ZzyErW5UiDfiIuJ/lpqc2Kx5PHDGDZ/bPlPJYpRcxlrn8Z8aDhRlsLHkNKcNiH65TmNahk2kbLaiejiqu6BD3A==",
             "license": "MIT",
             "dependencies": {
-                "@volar/language-service": "2.4.0",
-                "@volar/typescript": "2.4.0",
+                "@volar/language-service": "2.4.5",
+                "@volar/typescript": "2.4.5",
                 "typesafe-path": "^0.2.2",
                 "vscode-languageserver-textdocument": "^1.0.11",
                 "vscode-uri": "^3.0.8"
@@ -1985,23 +2062,23 @@
             }
         },
         "node_modules/@volar/language-core": {
-            "version": "2.4.0",
-            "resolved": "https://registry.npmjs.org/@volar/language-core/-/language-core-2.4.0.tgz",
-            "integrity": "sha512-FTla+khE+sYK0qJP+6hwPAAUwiNHVMph4RUXpxf/FIPKUP61NFrVZorml4mjFShnueR2y9/j8/vnh09YwVdH7A==",
+            "version": "2.4.5",
+            "resolved": "https://registry.npmjs.org/@volar/language-core/-/language-core-2.4.5.tgz",
+            "integrity": "sha512-F4tA0DCO5Q1F5mScHmca0umsi2ufKULAnMOVBfMsZdT4myhVl4WdKRwCaKcfOkIEuyrAVvtq1ESBdZ+rSyLVww==",
             "license": "MIT",
             "dependencies": {
-                "@volar/source-map": "2.4.0"
+                "@volar/source-map": "2.4.5"
             }
         },
         "node_modules/@volar/language-server": {
-            "version": "2.4.0",
-            "resolved": "https://registry.npmjs.org/@volar/language-server/-/language-server-2.4.0.tgz",
-            "integrity": "sha512-rmGIjAxWekWQiGH97Mosb4juiD/hfFYNQKV5Py9r7vDOLSkbIwRhITbwHm88NJKs8P6TNc6w/PfBXN6yjKadJg==",
+            "version": "2.4.5",
+            "resolved": "https://registry.npmjs.org/@volar/language-server/-/language-server-2.4.5.tgz",
+            "integrity": "sha512-l5PswE0JzCtstTlwBUpikeSa3lNUBJhTuWtj9KclZTGi2Uex4RcqGOhTiDsUUtvdv/hEuYCxGq1EdJJPlQsD/g==",
             "license": "MIT",
             "dependencies": {
-                "@volar/language-core": "2.4.0",
-                "@volar/language-service": "2.4.0",
-                "@volar/typescript": "2.4.0",
+                "@volar/language-core": "2.4.5",
+                "@volar/language-service": "2.4.5",
+                "@volar/typescript": "2.4.5",
                 "path-browserify": "^1.0.1",
                 "request-light": "^0.7.0",
                 "vscode-languageserver": "^9.0.1",
@@ -2011,30 +2088,30 @@
             }
         },
         "node_modules/@volar/language-service": {
-            "version": "2.4.0",
-            "resolved": "https://registry.npmjs.org/@volar/language-service/-/language-service-2.4.0.tgz",
-            "integrity": "sha512-4P3yeQXIL68mLfS3n6P3m02IRg3GnLHUU9k/1PCHEfm5FG9bySkDOc72dbBn2vAa2BxOqm18bmmZXrsWuQ5AOw==",
+            "version": "2.4.5",
+            "resolved": "https://registry.npmjs.org/@volar/language-service/-/language-service-2.4.5.tgz",
+            "integrity": "sha512-xiFlL0aViGg6JhwAXyohPrdlID13uom8WQg6DWYaV8ob8RRy+zoLlBUI8SpQctwlWEO9poyrYK01revijAwkcw==",
             "license": "MIT",
             "dependencies": {
-                "@volar/language-core": "2.4.0",
+                "@volar/language-core": "2.4.5",
                 "vscode-languageserver-protocol": "^3.17.5",
                 "vscode-languageserver-textdocument": "^1.0.11",
                 "vscode-uri": "^3.0.8"
             }
         },
         "node_modules/@volar/source-map": {
-            "version": "2.4.0",
-            "resolved": "https://registry.npmjs.org/@volar/source-map/-/source-map-2.4.0.tgz",
-            "integrity": "sha512-2ceY8/NEZvN6F44TXw2qRP6AQsvCYhV2bxaBPWxV9HqIfkbRydSksTFObCF1DBDNBfKiZTS8G/4vqV6cvjdOIQ==",
+            "version": "2.4.5",
+            "resolved": "https://registry.npmjs.org/@volar/source-map/-/source-map-2.4.5.tgz",
+            "integrity": "sha512-varwD7RaKE2J/Z+Zu6j3mNNJbNT394qIxXwdvz/4ao/vxOfyClZpSDtLKkwWmecinkOVos5+PWkWraelfMLfpw==",
             "license": "MIT"
         },
         "node_modules/@volar/typescript": {
-            "version": "2.4.0",
-            "resolved": "https://registry.npmjs.org/@volar/typescript/-/typescript-2.4.0.tgz",
-            "integrity": "sha512-9zx3lQWgHmVd+JRRAHUSRiEhe4TlzL7U7e6ulWXOxHH/WNYxzKwCvZD7WYWEZFdw4dHfTD9vUR0yPQO6GilCaQ==",
+            "version": "2.4.5",
+            "resolved": "https://registry.npmjs.org/@volar/typescript/-/typescript-2.4.5.tgz",
+            "integrity": "sha512-mcT1mHvLljAEtHviVcBuOyAwwMKz1ibXTi5uYtP/pf4XxoAzpdkQ+Br2IC0NPCvLCbjPZmbf3I0udndkfB1CDg==",
             "license": "MIT",
             "dependencies": {
-                "@volar/language-core": "2.4.0",
+                "@volar/language-core": "2.4.5",
                 "path-browserify": "^1.0.1",
                 "vscode-uri": "^3.0.8"
             }
@@ -2152,9 +2229,9 @@
             }
         },
         "node_modules/ansi-regex": {
-            "version": "6.0.1",
-            "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.1.tgz",
-            "integrity": "sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==",
+            "version": "6.1.0",
+            "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
+            "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
             "license": "MIT",
             "engines": {
                 "node": ">=12"
@@ -2201,12 +2278,12 @@
             "license": "Python-2.0"
         },
         "node_modules/aria-query": {
-            "version": "5.3.0",
-            "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.0.tgz",
-            "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==",
+            "version": "5.3.2",
+            "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.2.tgz",
+            "integrity": "sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw==",
             "license": "Apache-2.0",
-            "dependencies": {
-                "dequal": "^2.0.3"
+            "engines": {
+                "node": ">= 0.4"
             }
         },
         "node_modules/array-iterate": {
@@ -2220,18 +2297,18 @@
             }
         },
         "node_modules/astring": {
-            "version": "1.8.6",
-            "resolved": "https://registry.npmjs.org/astring/-/astring-1.8.6.tgz",
-            "integrity": "sha512-ISvCdHdlTDlH5IpxQJIex7BWBywFWgjJSVdwst+/iQCoEYnyOaQ95+X1JGshuBjGp6nxKUy1jMgE3zPqN7fQdg==",
+            "version": "1.9.0",
+            "resolved": "https://registry.npmjs.org/astring/-/astring-1.9.0.tgz",
+            "integrity": "sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg==",
             "license": "MIT",
             "bin": {
                 "astring": "bin/astring"
             }
         },
         "node_modules/astro": {
-            "version": "4.14.3",
-            "resolved": "https://registry.npmjs.org/astro/-/astro-4.14.3.tgz",
-            "integrity": "sha512-+Hox1EhiS5iHy4pfZaLidpD9x7WVAcgGgjTo1JOYSQ0+a2ZA9mbLtGVEXbUeeYweviNc0ZNHMnI4r9S2e8xnXg==",
+            "version": "4.15.9",
+            "resolved": "https://registry.npmjs.org/astro/-/astro-4.15.9.tgz",
+            "integrity": "sha512-51oXq9qrZ5OPWYmEXt1kGrvWmVeWsx28SgBTzi2XW6iwcnW/wC5ONm6ol6qBGSCF93tQvZplXvuzpaw1injECA==",
             "license": "MIT",
             "dependencies": {
                 "@astrojs/compiler": "^2.10.3",
@@ -2239,12 +2316,9 @@
                 "@astrojs/markdown-remark": "5.2.0",
                 "@astrojs/telemetry": "3.1.0",
                 "@babel/core": "^7.25.2",
-                "@babel/generator": "^7.25.0",
-                "@babel/parser": "^7.25.3",
                 "@babel/plugin-transform-react-jsx": "^7.25.2",
-                "@babel/traverse": "^7.25.3",
-                "@babel/types": "^7.25.2",
-                "@oslojs/encoding": "^0.4.1",
+                "@babel/types": "^7.25.6",
+                "@oslojs/encoding": "^1.0.0",
                 "@rollup/pluginutils": "^5.1.0",
                 "@types/babel__core": "^7.20.5",
                 "@types/cookie": "^0.6.0",
@@ -2257,7 +2331,7 @@
                 "common-ancestor-path": "^1.0.1",
                 "cookie": "^0.6.0",
                 "cssesc": "^3.0.0",
-                "debug": "^4.3.6",
+                "debug": "^4.3.7",
                 "deterministic-object-hash": "^2.0.2",
                 "devalue": "^5.0.0",
                 "diff": "^5.2.0",
@@ -2266,8 +2340,8 @@
                 "es-module-lexer": "^1.5.4",
                 "esbuild": "^0.21.5",
                 "estree-walker": "^3.0.3",
-                "execa": "^8.0.1",
                 "fast-glob": "^3.3.2",
+                "fastq": "^1.17.1",
                 "flattie": "^1.1.1",
                 "github-slugger": "^2.0.0",
                 "gray-matter": "^4.0.3",
@@ -2276,25 +2350,26 @@
                 "js-yaml": "^4.1.0",
                 "kleur": "^4.1.5",
                 "magic-string": "^0.30.11",
-                "micromatch": "^4.0.7",
+                "magicast": "^0.3.5",
+                "micromatch": "^4.0.8",
                 "mrmime": "^2.0.0",
                 "neotraverse": "^0.6.18",
-                "ora": "^8.0.1",
+                "ora": "^8.1.0",
                 "p-limit": "^6.1.0",
                 "p-queue": "^8.0.1",
-                "path-to-regexp": "^6.2.2",
                 "preferred-pm": "^4.0.0",
                 "prompts": "^2.4.2",
                 "rehype": "^13.0.1",
                 "semver": "^7.6.3",
-                "shiki": "^1.14.1",
+                "shiki": "^1.16.2",
                 "string-width": "^7.2.0",
                 "strip-ansi": "^7.1.0",
-                "tsconfck": "^3.1.1",
+                "tinyexec": "^0.3.0",
+                "tsconfck": "^3.1.3",
                 "unist-util-visit": "^5.0.0",
-                "vfile": "^6.0.2",
-                "vite": "^5.4.1",
-                "vitefu": "^0.2.5",
+                "vfile": "^6.0.3",
+                "vite": "^5.4.3",
+                "vitefu": "^1.0.2",
                 "which-pm": "^3.0.0",
                 "xxhash-wasm": "^1.0.2",
                 "yargs-parser": "^21.1.1",
@@ -2464,9 +2539,9 @@
             }
         },
         "node_modules/browserslist": {
-            "version": "4.23.3",
-            "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.23.3.tgz",
-            "integrity": "sha512-btwCFJVjI4YWDNfau8RhZ+B1Q/VLoUITrm3RlP6y1tYGWIOa+InuYiRGXUBXo8nA1qKmHMyLB/iVQg5TT4eFoA==",
+            "version": "4.24.0",
+            "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.0.tgz",
+            "integrity": "sha512-Rmb62sR1Zpjql25eSanFGEhAxcFwfA1K0GuQcLoaJBAcENegrQut3hYdhXFF1obQfiDyqIW/cLM5HSJ/9k884A==",
             "funding": [
                 {
                     "type": "opencollective",
@@ -2483,8 +2558,8 @@
             ],
             "license": "MIT",
             "dependencies": {
-                "caniuse-lite": "^1.0.30001646",
-                "electron-to-chromium": "^1.5.4",
+                "caniuse-lite": "^1.0.30001663",
+                "electron-to-chromium": "^1.5.28",
                 "node-releases": "^2.0.18",
                 "update-browserslist-db": "^1.1.0"
             },
@@ -2508,9 +2583,9 @@
             }
         },
         "node_modules/caniuse-lite": {
-            "version": "1.0.30001651",
-            "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001651.tgz",
-            "integrity": "sha512-9Cf+Xv1jJNe1xPZLGuUXLNkE1BoDkqRqYyFJ9TDYSqhduqA4hu4oR9HluGoWYQC/aj8WHjsGVV+bwkh0+tegRg==",
+            "version": "1.0.30001664",
+            "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001664.tgz",
+            "integrity": "sha512-AmE7k4dXiNKQipgn7a2xg558IRqPN3jMQY/rOsbxDhrd0tyChwbITBfiwtnqz8bi2M5mIWbxAYBvk7W7QBUS2g==",
             "funding": [
                 {
                     "type": "opencollective",
@@ -2643,15 +2718,15 @@
             }
         },
         "node_modules/cli-cursor": {
-            "version": "4.0.0",
-            "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-4.0.0.tgz",
-            "integrity": "sha512-VGtlMu3x/4DOtIUwEkRezxUZ2lBacNJCHash0N0WeZDBS+7Ux1dm3XWAgWYxLJFMMdOeXMHXorshEFhbMSGelg==",
+            "version": "5.0.0",
+            "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-5.0.0.tgz",
+            "integrity": "sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw==",
             "license": "MIT",
             "dependencies": {
-                "restore-cursor": "^4.0.0"
+                "restore-cursor": "^5.0.0"
             },
             "engines": {
-                "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+                "node": ">=18"
             },
             "funding": {
                 "url": "https://github.com/sponsors/sindresorhus"
@@ -2880,20 +2955,6 @@
                 "node": ">= 0.6"
             }
         },
-        "node_modules/cross-spawn": {
-            "version": "7.0.3",
-            "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz",
-            "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==",
-            "license": "MIT",
-            "dependencies": {
-                "path-key": "^3.1.0",
-                "shebang-command": "^2.0.0",
-                "which": "^2.0.1"
-            },
-            "engines": {
-                "node": ">= 8"
-            }
-        },
         "node_modules/css-selector-parser": {
             "version": "3.0.5",
             "resolved": "https://registry.npmjs.org/css-selector-parser/-/css-selector-parser-3.0.5.tgz",
@@ -2923,12 +2984,12 @@
             }
         },
         "node_modules/debug": {
-            "version": "4.3.6",
-            "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.6.tgz",
-            "integrity": "sha512-O/09Bd4Z1fBrU4VzkhFqVgpPzaGbw6Sm9FEkBT1A/YBXQFGuuSxa1dN2nxgxS34JmKXqYx8CZAwEVoJFImUXIg==",
+            "version": "4.3.7",
+            "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
+            "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
             "license": "MIT",
             "dependencies": {
-                "ms": "2.1.2"
+                "ms": "^2.1.3"
             },
             "engines": {
                 "node": ">=6.0"
@@ -2983,9 +3044,9 @@
             }
         },
         "node_modules/devalue": {
-            "version": "5.0.0",
-            "resolved": "https://registry.npmjs.org/devalue/-/devalue-5.0.0.tgz",
-            "integrity": "sha512-gO+/OMXF7488D+u3ue+G7Y4AA3ZmUnB3eHJXmBTgNHvr4ZNzl36A0ZtG+XCRNYCkYx/bFmw4qtkoFLa+wSrwAA==",
+            "version": "5.1.1",
+            "resolved": "https://registry.npmjs.org/devalue/-/devalue-5.1.1.tgz",
+            "integrity": "sha512-maua5KUiapvEwiEAe+XnlZ3Rh0GD+qI1J/nb9vrJc3muPXvcF/8gXYTWF76+5DAqHyDUtOIImEuo0YKE9mshVw==",
             "license": "MIT"
         },
         "node_modules/devlop": {
@@ -3033,6 +3094,7 @@
             "version": "3.1.4",
             "resolved": "https://registry.npmjs.org/dset/-/dset-3.1.4.tgz",
             "integrity": "sha512-2QF/g9/zTaPDc3BjNcVTGoBbXBgYfMTTceLaYcFJ/W9kggFUkhxD/hMEeuLKbugyef9SqAx8cpgwlIP/jinUTA==",
+            "license": "MIT",
             "engines": {
                 "node": ">=4"
             }
@@ -3044,15 +3106,15 @@
             "license": "MIT"
         },
         "node_modules/electron-to-chromium": {
-            "version": "1.5.13",
-            "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.13.tgz",
-            "integrity": "sha512-lbBcvtIJ4J6sS4tb5TLp1b4LyfCdMkwStzXPyAgVgTRAsep4bvrAGaBOP7ZJtQMNJpSQ9SqG4brWOroNaQtm7Q==",
+            "version": "1.5.30",
+            "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.30.tgz",
+            "integrity": "sha512-sXI35EBN4lYxzc/pIGorlymYNzDBOqkSlVRe6MkgBsW/hW1tpC/HDJ2fjG7XnjakzfLEuvdmux0Mjs6jHq4UOA==",
             "license": "ISC"
         },
         "node_modules/emmet": {
-            "version": "2.4.7",
-            "resolved": "https://registry.npmjs.org/emmet/-/emmet-2.4.7.tgz",
-            "integrity": "sha512-O5O5QNqtdlnQM2bmKHtJgyChcrFMgQuulI+WdiOw2NArzprUqqxUW6bgYtKvzKgrsYpuLWalOkdhNP+1jluhCA==",
+            "version": "2.4.11",
+            "resolved": "https://registry.npmjs.org/emmet/-/emmet-2.4.11.tgz",
+            "integrity": "sha512-23QPJB3moh/U9sT4rQzGgeyyGIrcM+GH5uVYg2C6wZIxAIJq7Ng3QLT79tl8FUwDXhyq9SusfknOrofAKqvgyQ==",
             "license": "MIT",
             "workspaces": [
                 "./packages/scanner",
@@ -3066,9 +3128,9 @@
             }
         },
         "node_modules/emoji-regex": {
-            "version": "10.3.0",
-            "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.3.0.tgz",
-            "integrity": "sha512-QpLs9D9v9kArv4lfDEgg1X/gN5XLnf/A6l9cs8SPZLRZR3ZkY9+kwIQTxm+fsSej5UMYGE8fdoaZVIBlqG0XTw==",
+            "version": "10.4.0",
+            "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.4.0.tgz",
+            "integrity": "sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw==",
             "license": "MIT"
         },
         "node_modules/entities": {
@@ -3128,9 +3190,9 @@
             }
         },
         "node_modules/escalade": {
-            "version": "3.1.2",
-            "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.2.tgz",
-            "integrity": "sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA==",
+            "version": "3.2.0",
+            "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+            "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
             "license": "MIT",
             "engines": {
                 "node": ">=6"
@@ -3241,29 +3303,6 @@
             "integrity": "sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==",
             "license": "MIT"
         },
-        "node_modules/execa": {
-            "version": "8.0.1",
-            "resolved": "https://registry.npmjs.org/execa/-/execa-8.0.1.tgz",
-            "integrity": "sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==",
-            "license": "MIT",
-            "dependencies": {
-                "cross-spawn": "^7.0.3",
-                "get-stream": "^8.0.1",
-                "human-signals": "^5.0.0",
-                "is-stream": "^3.0.0",
-                "merge-stream": "^2.0.0",
-                "npm-run-path": "^5.1.0",
-                "onetime": "^6.0.0",
-                "signal-exit": "^4.1.0",
-                "strip-final-newline": "^3.0.0"
-            },
-            "engines": {
-                "node": ">=16.17"
-            },
-            "funding": {
-                "url": "https://github.com/sindresorhus/execa?sponsor=1"
-            }
-        },
         "node_modules/expressive-code": {
             "version": "0.35.6",
             "resolved": "https://registry.npmjs.org/expressive-code/-/expressive-code-0.35.6.tgz",
@@ -3317,9 +3356,9 @@
             }
         },
         "node_modules/fast-uri": {
-            "version": "3.0.1",
-            "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.0.1.tgz",
-            "integrity": "sha512-MWipKbbYiYI0UC7cl8m/i/IWTqfC8YXsqjzybjddLsFjStroQzsHXkc73JutMvBiXmOvapk+axIl79ig5t55Bw==",
+            "version": "3.0.2",
+            "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.0.2.tgz",
+            "integrity": "sha512-GR6f0hD7XXyNJa25Tb9BuIdN0tdr+0BMi6/CJPH3wJO1JjNG3n/VsSw38AwRdKZABm8lGbPfakLRkYzx2V9row==",
             "license": "MIT"
         },
         "node_modules/fastq": {
@@ -3431,18 +3470,6 @@
                 "url": "https://github.com/sponsors/sindresorhus"
             }
         },
-        "node_modules/get-stream": {
-            "version": "8.0.1",
-            "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-8.0.1.tgz",
-            "integrity": "sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA==",
-            "license": "MIT",
-            "engines": {
-                "node": ">=16"
-            },
-            "funding": {
-                "url": "https://github.com/sponsors/sindresorhus"
-            }
-        },
         "node_modules/github-slugger": {
             "version": "2.0.0",
             "resolved": "https://registry.npmjs.org/github-slugger/-/github-slugger-2.0.0.tgz",
@@ -3536,10 +3563,29 @@
                 "url": "https://opencollective.com/unified"
             }
         },
+        "node_modules/hast-util-format": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/hast-util-format/-/hast-util-format-1.1.0.tgz",
+            "integrity": "sha512-yY1UDz6bC9rDvCWHpx12aIBGRG7krurX0p0Fm6pT547LwDIZZiNr8a+IHDogorAdreULSEzP82Nlv5SZkHZcjA==",
+            "license": "MIT",
+            "dependencies": {
+                "@types/hast": "^3.0.0",
+                "hast-util-embedded": "^3.0.0",
+                "hast-util-minify-whitespace": "^1.0.0",
+                "hast-util-phrasing": "^3.0.0",
+                "hast-util-whitespace": "^3.0.0",
+                "html-whitespace-sensitive-tag-names": "^3.0.0",
+                "unist-util-visit-parents": "^6.0.0"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/unified"
+            }
+        },
         "node_modules/hast-util-from-html": {
-            "version": "2.0.1",
-            "resolved": "https://registry.npmjs.org/hast-util-from-html/-/hast-util-from-html-2.0.1.tgz",
-            "integrity": "sha512-RXQBLMl9kjKVNkJTIO6bZyb2n+cUH8LFaSSzo82jiLT6Tfc+Pt7VQCS+/h3YwG4jaNE2TA2sdJisGWR+aJrp0g==",
+            "version": "2.0.3",
+            "resolved": "https://registry.npmjs.org/hast-util-from-html/-/hast-util-from-html-2.0.3.tgz",
+            "integrity": "sha512-CUSRHXyKjzHov8yKsQjGOElXy/3EKpyX56ELnkHH34vDVw1N1XSQ1ZcAvTyAPtGqLTuKP/uxM+aLkSPqF/EtMw==",
             "license": "MIT",
             "dependencies": {
                 "@types/hast": "^3.0.0",
@@ -3605,9 +3651,9 @@
             }
         },
         "node_modules/hast-util-is-body-ok-link": {
-            "version": "3.0.0",
-            "resolved": "https://registry.npmjs.org/hast-util-is-body-ok-link/-/hast-util-is-body-ok-link-3.0.0.tgz",
-            "integrity": "sha512-VFHY5bo2nY8HiV6nir2ynmEB1XkxzuUffhEGeVx7orbu/B1KaGyeGgMZldvMVx5xWrDlLLG/kQ6YkJAMkBEx0w==",
+            "version": "3.0.1",
+            "resolved": "https://registry.npmjs.org/hast-util-is-body-ok-link/-/hast-util-is-body-ok-link-3.0.1.tgz",
+            "integrity": "sha512-0qpnzOBLztXHbHQenVB8uNuxTnm/QBFUOmdOSsEn7GnBtyY07+ENTWVFBAnXd/zEgd9/SUG3lRY7hSIBWRgGpQ==",
             "license": "MIT",
             "dependencies": {
                 "@types/hast": "^3.0.0"
@@ -3630,6 +3676,23 @@
                 "url": "https://opencollective.com/unified"
             }
         },
+        "node_modules/hast-util-minify-whitespace": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/hast-util-minify-whitespace/-/hast-util-minify-whitespace-1.0.1.tgz",
+            "integrity": "sha512-L96fPOVpnclQE0xzdWb/D12VT5FabA7SnZOUMtL1DbXmYiHJMXZvFkIZfiMmTCNJHUeO2K9UYNXoVyfz+QHuOw==",
+            "license": "MIT",
+            "dependencies": {
+                "@types/hast": "^3.0.0",
+                "hast-util-embedded": "^3.0.0",
+                "hast-util-is-element": "^3.0.0",
+                "hast-util-whitespace": "^3.0.0",
+                "unist-util-is": "^6.0.0"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/unified"
+            }
+        },
         "node_modules/hast-util-parse-selector": {
             "version": "4.0.0",
             "resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-4.0.0.tgz",
@@ -3742,16 +3805,15 @@
             }
         },
         "node_modules/hast-util-to-html": {
-            "version": "9.0.1",
-            "resolved": "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-9.0.1.tgz",
-            "integrity": "sha512-hZOofyZANbyWo+9RP75xIDV/gq+OUKx+T46IlwERnKmfpwp81XBFbT9mi26ws+SJchA4RVUQwIBJpqEOBhMzEQ==",
+            "version": "9.0.3",
+            "resolved": "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-9.0.3.tgz",
+            "integrity": "sha512-M17uBDzMJ9RPCqLMO92gNNUDuBSq10a25SDBI08iCCxmorf4Yy6sYHK57n9WAbRAAaU+DuR4W6GN9K4DFZesYg==",
             "license": "MIT",
             "dependencies": {
                 "@types/hast": "^3.0.0",
                 "@types/unist": "^3.0.0",
                 "ccount": "^2.0.0",
                 "comma-separated-tokens": "^2.0.0",
-                "hast-util-raw": "^9.0.0",
                 "hast-util-whitespace": "^3.0.0",
                 "html-void-elements": "^3.0.0",
                 "mdast-util-to-hast": "^13.0.0",
@@ -3793,18 +3855,18 @@
             }
         },
         "node_modules/hast-util-to-jsx-runtime/node_modules/inline-style-parser": {
-            "version": "0.2.3",
-            "resolved": "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.2.3.tgz",
-            "integrity": "sha512-qlD8YNDqyTKTyuITrDOffsl6Tdhv+UC4hcdAVuQsK4IMQ99nSgd1MIA/Q+jQYoh9r3hVUXhYh7urSRmXPkW04g==",
+            "version": "0.2.4",
+            "resolved": "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.2.4.tgz",
+            "integrity": "sha512-0aO8FkhNZlj/ZIbNi7Lxxr12obT7cL1moPfE4tg1LkX7LlLfC6DeX4l2ZEud1ukP9jNQyNnfzQVqwbwmAATY4Q==",
             "license": "MIT"
         },
         "node_modules/hast-util-to-jsx-runtime/node_modules/style-to-object": {
-            "version": "1.0.6",
-            "resolved": "https://registry.npmjs.org/style-to-object/-/style-to-object-1.0.6.tgz",
-            "integrity": "sha512-khxq+Qm3xEyZfKd/y9L3oIWQimxuc4STrQKtQn8aSDRHb8mFgpukgX1hdzfrMEW6JCjyJ8p89x+IUMVnCBI1PA==",
+            "version": "1.0.8",
+            "resolved": "https://registry.npmjs.org/style-to-object/-/style-to-object-1.0.8.tgz",
+            "integrity": "sha512-xT47I/Eo0rwJmaXC4oilDGDWLohVhR6o/xAQcPQN8q6QBuZVL8qMYL85kLmST5cPjAorwvqIA4qXTRQoYHaL6g==",
             "license": "MIT",
             "dependencies": {
-                "inline-style-parser": "0.2.3"
+                "inline-style-parser": "0.2.4"
             }
         },
         "node_modules/hast-util-to-parse5": {
@@ -3827,9 +3889,9 @@
             }
         },
         "node_modules/hast-util-to-string": {
-            "version": "3.0.0",
-            "resolved": "https://registry.npmjs.org/hast-util-to-string/-/hast-util-to-string-3.0.0.tgz",
-            "integrity": "sha512-OGkAxX1Ua3cbcW6EJ5pT/tslVb90uViVkcJ4ZZIMW/R33DX/AkcJcRrPebPwJkHYwlDHXz4aIwvAAaAdtrACFA==",
+            "version": "3.0.1",
+            "resolved": "https://registry.npmjs.org/hast-util-to-string/-/hast-util-to-string-3.0.1.tgz",
+            "integrity": "sha512-XelQVTDWvqcl3axRfI0xSeoVKzyIFPwsAGSLIsKdJKQMXDYJS4WYrBNF/8J7RdhIcFI2BOHgAifggsvsxp/3+A==",
             "license": "MIT",
             "dependencies": {
                 "@types/hast": "^3.0.0"
@@ -3902,9 +3964,9 @@
             }
         },
         "node_modules/html-whitespace-sensitive-tag-names": {
-            "version": "3.0.0",
-            "resolved": "https://registry.npmjs.org/html-whitespace-sensitive-tag-names/-/html-whitespace-sensitive-tag-names-3.0.0.tgz",
-            "integrity": "sha512-KlClZ3/Qy5UgvpvVvDomGhnQhNWH5INE8GwvSIQ9CWt1K0zbbXrl7eN5bWaafOZgtmO3jMPwUqmrmEwinhPq1w==",
+            "version": "3.0.1",
+            "resolved": "https://registry.npmjs.org/html-whitespace-sensitive-tag-names/-/html-whitespace-sensitive-tag-names-3.0.1.tgz",
+            "integrity": "sha512-q+310vW8zmymYHALr1da4HyXUQ0zgiIwIicEfotYPWGN0OJVEN/58IJ3A4GBYcEq3LGAZqKb+ugvP0GNB9CEAA==",
             "license": "MIT",
             "funding": {
                 "type": "opencollective",
@@ -3917,13 +3979,27 @@
             "integrity": "sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ==",
             "license": "BSD-2-Clause"
         },
-        "node_modules/human-signals": {
-            "version": "5.0.0",
-            "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-5.0.0.tgz",
-            "integrity": "sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ==",
-            "license": "Apache-2.0",
-            "engines": {
-                "node": ">=16.17.0"
+        "node_modules/i18next": {
+            "version": "23.15.1",
+            "resolved": "https://registry.npmjs.org/i18next/-/i18next-23.15.1.tgz",
+            "integrity": "sha512-wB4abZ3uK7EWodYisHl/asf8UYEhrI/vj/8aoSsrj/ZDxj4/UXPOa1KvFt1Fq5hkUHquNqwFlDprmjZ8iySgYA==",
+            "funding": [
+                {
+                    "type": "individual",
+                    "url": "https://locize.com"
+                },
+                {
+                    "type": "individual",
+                    "url": "https://locize.com/i18next.html"
+                },
+                {
+                    "type": "individual",
+                    "url": "https://www.i18next.com/how-to/faq#i18next-is-awesome.-how-can-i-support-the-project"
+                }
+            ],
+            "license": "MIT",
+            "dependencies": {
+                "@babel/runtime": "^7.23.2"
             }
         },
         "node_modules/import-meta-resolve": {
@@ -4118,22 +4194,10 @@
                 "@types/estree": "*"
             }
         },
-        "node_modules/is-stream": {
-            "version": "3.0.0",
-            "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-3.0.0.tgz",
-            "integrity": "sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==",
-            "license": "MIT",
-            "engines": {
-                "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-            },
-            "funding": {
-                "url": "https://github.com/sponsors/sindresorhus"
-            }
-        },
         "node_modules/is-unicode-supported": {
-            "version": "2.0.0",
-            "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-2.0.0.tgz",
-            "integrity": "sha512-FRdAyx5lusK1iHG0TWpVtk9+1i+GjrzRffhDg4ovQ7mcidMQ6mj+MhKPmvh7Xwyv5gIS06ns49CA7Sqg7lC22Q==",
+            "version": "2.1.0",
+            "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-2.1.0.tgz",
+            "integrity": "sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==",
             "license": "MIT",
             "engines": {
                 "node": ">=18"
@@ -4157,12 +4221,6 @@
                 "url": "https://github.com/sponsors/sindresorhus"
             }
         },
-        "node_modules/isexe": {
-            "version": "2.0.0",
-            "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
-            "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
-            "license": "ISC"
-        },
         "node_modules/js-tokens": {
             "version": "4.0.0",
             "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
@@ -4358,6 +4416,17 @@
                 "@jridgewell/sourcemap-codec": "^1.5.0"
             }
         },
+        "node_modules/magicast": {
+            "version": "0.3.5",
+            "resolved": "https://registry.npmjs.org/magicast/-/magicast-0.3.5.tgz",
+            "integrity": "sha512-L0WhttDl+2BOsybvEOLK7fW3UA0OQ0IQ2d6Zl2x/a6vVRs3bAY0ECOSHHeL5jD+SbOpOCUEi0y1DgHEn9Qn1AQ==",
+            "license": "MIT",
+            "dependencies": {
+                "@babel/parser": "^7.25.4",
+                "@babel/types": "^7.25.4",
+                "source-map-js": "^1.2.0"
+            }
+        },
         "node_modules/markdown-extensions": {
             "version": "2.0.0",
             "resolved": "https://registry.npmjs.org/markdown-extensions/-/markdown-extensions-2.0.0.tgz",
@@ -4586,9 +4655,9 @@
             }
         },
         "node_modules/mdast-util-mdx-expression": {
-            "version": "2.0.0",
-            "resolved": "https://registry.npmjs.org/mdast-util-mdx-expression/-/mdast-util-mdx-expression-2.0.0.tgz",
-            "integrity": "sha512-fGCu8eWdKUKNu5mohVGkhBXCXGnOTLuFqOvGMvdikr+J1w7lDJgxThOKpwRWzzbyXAU2hhSwsmssOY4yTokluw==",
+            "version": "2.0.1",
+            "resolved": "https://registry.npmjs.org/mdast-util-mdx-expression/-/mdast-util-mdx-expression-2.0.1.tgz",
+            "integrity": "sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ==",
             "license": "MIT",
             "dependencies": {
                 "@types/estree-jsx": "^1.0.0",
@@ -4604,9 +4673,9 @@
             }
         },
         "node_modules/mdast-util-mdx-jsx": {
-            "version": "3.1.2",
-            "resolved": "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.1.2.tgz",
-            "integrity": "sha512-eKMQDeywY2wlHc97k5eD8VC+9ASMjN8ItEZQNGwJ6E0XWKiW/Z0V5/H8pvoXUf+y+Mj0VIgeRRbujBmFn4FTyA==",
+            "version": "3.1.3",
+            "resolved": "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.1.3.tgz",
+            "integrity": "sha512-bfOjvNt+1AcbPLTFMFWY149nJz0OjmewJs3LQQ5pIyVGxP4CdOqNVJL6kTaM5c68p8q82Xv3nCyFfUnuEcH3UQ==",
             "license": "MIT",
             "dependencies": {
                 "@types/estree-jsx": "^1.0.0",
@@ -4619,7 +4688,6 @@
                 "mdast-util-to-markdown": "^2.0.0",
                 "parse-entities": "^4.0.0",
                 "stringify-entities": "^4.0.0",
-                "unist-util-remove-position": "^5.0.0",
                 "unist-util-stringify-position": "^4.0.0",
                 "vfile-message": "^4.0.0"
             },
@@ -4714,12 +4782,6 @@
                 "url": "https://opencollective.com/unified"
             }
         },
-        "node_modules/merge-stream": {
-            "version": "2.0.0",
-            "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz",
-            "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==",
-            "license": "MIT"
-        },
         "node_modules/merge2": {
             "version": "1.4.1",
             "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
@@ -4799,9 +4861,9 @@
             }
         },
         "node_modules/micromark-extension-directive": {
-            "version": "3.0.1",
-            "resolved": "https://registry.npmjs.org/micromark-extension-directive/-/micromark-extension-directive-3.0.1.tgz",
-            "integrity": "sha512-VGV2uxUzhEZmaP7NSFo2vtq7M2nUD+WfmYQD+d8i/1nHbzE+rMy9uzTvUybBbNiVbrhOZibg3gbyoARGqgDWyg==",
+            "version": "3.0.2",
+            "resolved": "https://registry.npmjs.org/micromark-extension-directive/-/micromark-extension-directive-3.0.2.tgz",
+            "integrity": "sha512-wjcXHgk+PPdmvR58Le9d7zQYWy+vKEU9Se44p2CrCDPiLr2FMyiT4Fyb5UFKFC66wGB3kPlgD7q3TnoqPS7SZA==",
             "license": "MIT",
             "dependencies": {
                 "devlop": "^1.0.0",
@@ -4965,9 +5027,9 @@
             }
         },
         "node_modules/micromark-extension-mdx-jsx": {
-            "version": "3.0.0",
-            "resolved": "https://registry.npmjs.org/micromark-extension-mdx-jsx/-/micromark-extension-mdx-jsx-3.0.0.tgz",
-            "integrity": "sha512-uvhhss8OGuzR4/N17L1JwvmJIpPhAd8oByMawEKx6NVdBCbesjH4t+vjEp3ZXft9DwvlKSD07fCeI44/N0Vf2w==",
+            "version": "3.0.1",
+            "resolved": "https://registry.npmjs.org/micromark-extension-mdx-jsx/-/micromark-extension-mdx-jsx-3.0.1.tgz",
+            "integrity": "sha512-vNuFb9czP8QCtAQcEJn0UJQJZA8Dk6DXKBqx+bg/w0WGuSxDxNr7hErW89tHUY31dUW4NqEOWwmEUNhjTFmHkg==",
             "license": "MIT",
             "dependencies": {
                 "@types/acorn": "^4.0.0",
@@ -4977,6 +5039,7 @@
                 "micromark-factory-mdx-expression": "^2.0.0",
                 "micromark-factory-space": "^2.0.0",
                 "micromark-util-character": "^2.0.0",
+                "micromark-util-events-to-acorn": "^2.0.0",
                 "micromark-util-symbol": "^2.0.0",
                 "micromark-util-types": "^2.0.0",
                 "vfile-message": "^4.0.0"
@@ -5084,9 +5147,9 @@
             }
         },
         "node_modules/micromark-factory-mdx-expression": {
-            "version": "2.0.1",
-            "resolved": "https://registry.npmjs.org/micromark-factory-mdx-expression/-/micromark-factory-mdx-expression-2.0.1.tgz",
-            "integrity": "sha512-F0ccWIUHRLRrYp5TC9ZYXmZo+p2AM13ggbsW4T0b5CRKP8KHVRB8t4pwtBgTxtjRmwrK0Irwm7vs2JOZabHZfg==",
+            "version": "2.0.2",
+            "resolved": "https://registry.npmjs.org/micromark-factory-mdx-expression/-/micromark-factory-mdx-expression-2.0.2.tgz",
+            "integrity": "sha512-5E5I2pFzJyg2CtemqAbcyCktpHXuJbABnsb32wX2U8IQKhhVFBqkcZR5LRm1WVoFqa4kTueZK4abep7wdo9nrw==",
             "funding": [
                 {
                     "type": "GitHub Sponsors",
@@ -5101,6 +5164,7 @@
             "dependencies": {
                 "@types/estree": "^1.0.0",
                 "devlop": "^1.0.0",
+                "micromark-factory-space": "^2.0.0",
                 "micromark-util-character": "^2.0.0",
                 "micromark-util-events-to-acorn": "^2.0.0",
                 "micromark-util-symbol": "^2.0.0",
@@ -5469,6 +5533,7 @@
             "version": "4.0.8",
             "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
             "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
+            "license": "MIT",
             "dependencies": {
                 "braces": "^3.0.3",
                 "picomatch": "^2.3.1"
@@ -5477,13 +5542,13 @@
                 "node": ">=8.6"
             }
         },
-        "node_modules/mimic-fn": {
-            "version": "4.0.0",
-            "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-4.0.0.tgz",
-            "integrity": "sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==",
+        "node_modules/mimic-function": {
+            "version": "5.0.1",
+            "resolved": "https://registry.npmjs.org/mimic-function/-/mimic-function-5.0.1.tgz",
+            "integrity": "sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==",
             "license": "MIT",
             "engines": {
-                "node": ">=12"
+                "node": ">=18"
             },
             "funding": {
                 "url": "https://github.com/sponsors/sindresorhus"
@@ -5499,9 +5564,9 @@
             }
         },
         "node_modules/ms": {
-            "version": "2.1.2",
-            "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
-            "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
+            "version": "2.1.3",
+            "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+            "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
             "license": "MIT"
         },
         "node_modules/muggle-string": {
@@ -5570,33 +5635,6 @@
             "resolved": "https://registry.npmjs.org/not/-/not-0.1.0.tgz",
             "integrity": "sha512-5PDmaAsVfnWUgTUbJ3ERwn7u79Z0dYxN9ErxCpVJJqe2RK0PJ3z+iFUxuqjwtlDDegXvtWoxD/3Fzxox7tFGWA=="
         },
-        "node_modules/npm-run-path": {
-            "version": "5.3.0",
-            "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-5.3.0.tgz",
-            "integrity": "sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ==",
-            "license": "MIT",
-            "dependencies": {
-                "path-key": "^4.0.0"
-            },
-            "engines": {
-                "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-            },
-            "funding": {
-                "url": "https://github.com/sponsors/sindresorhus"
-            }
-        },
-        "node_modules/npm-run-path/node_modules/path-key": {
-            "version": "4.0.0",
-            "resolved": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz",
-            "integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==",
-            "license": "MIT",
-            "engines": {
-                "node": ">=12"
-            },
-            "funding": {
-                "url": "https://github.com/sponsors/sindresorhus"
-            }
-        },
         "node_modules/nth-check": {
             "version": "2.1.1",
             "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz",
@@ -5610,34 +5648,46 @@
             }
         },
         "node_modules/onetime": {
-            "version": "6.0.0",
-            "resolved": "https://registry.npmjs.org/onetime/-/onetime-6.0.0.tgz",
-            "integrity": "sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==",
+            "version": "7.0.0",
+            "resolved": "https://registry.npmjs.org/onetime/-/onetime-7.0.0.tgz",
+            "integrity": "sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==",
             "license": "MIT",
             "dependencies": {
-                "mimic-fn": "^4.0.0"
+                "mimic-function": "^5.0.0"
             },
             "engines": {
-                "node": ">=12"
+                "node": ">=18"
             },
             "funding": {
                 "url": "https://github.com/sponsors/sindresorhus"
             }
         },
+        "node_modules/oniguruma-to-js": {
+            "version": "0.4.3",
+            "resolved": "https://registry.npmjs.org/oniguruma-to-js/-/oniguruma-to-js-0.4.3.tgz",
+            "integrity": "sha512-X0jWUcAlxORhOqqBREgPMgnshB7ZGYszBNspP+tS9hPD3l13CdaXcHbgImoHUHlrvGx/7AvFEkTRhAGYh+jzjQ==",
+            "license": "MIT",
+            "dependencies": {
+                "regex": "^4.3.2"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/antfu"
+            }
+        },
         "node_modules/ora": {
-            "version": "8.0.1",
-            "resolved": "https://registry.npmjs.org/ora/-/ora-8.0.1.tgz",
-            "integrity": "sha512-ANIvzobt1rls2BDny5fWZ3ZVKyD6nscLvfFRpQgfWsythlcsVUC9kL0zq6j2Z5z9wwp1kd7wpsD/T9qNPVLCaQ==",
+            "version": "8.1.0",
+            "resolved": "https://registry.npmjs.org/ora/-/ora-8.1.0.tgz",
+            "integrity": "sha512-GQEkNkH/GHOhPFXcqZs3IDahXEQcQxsSjEkK4KvEEST4t7eNzoMjxTzef+EZ+JluDEV+Raoi3WQ2CflnRdSVnQ==",
             "license": "MIT",
             "dependencies": {
                 "chalk": "^5.3.0",
-                "cli-cursor": "^4.0.0",
+                "cli-cursor": "^5.0.0",
                 "cli-spinners": "^2.9.2",
                 "is-interactive": "^2.0.0",
                 "is-unicode-supported": "^2.0.0",
                 "log-symbols": "^6.0.0",
-                "stdin-discarder": "^0.2.1",
-                "string-width": "^7.0.0",
+                "stdin-discarder": "^0.2.2",
+                "string-width": "^7.2.0",
                 "strip-ansi": "^7.1.0"
             },
             "engines": {
@@ -5742,6 +5792,7 @@
             "version": "1.1.1",
             "resolved": "https://registry.npmjs.org/pagefind/-/pagefind-1.1.1.tgz",
             "integrity": "sha512-U2YR0dQN5B2fbIXrLtt/UXNS0yWSSYfePaad1KcBPTi0p+zRtsVjwmoPaMQgTks5DnHNbmDxyJUL5TGaLljK3A==",
+            "license": "MIT",
             "bin": {
                 "pagefind": "lib/runner/bin.cjs"
             },
@@ -5824,20 +5875,6 @@
                 "node": ">=8"
             }
         },
-        "node_modules/path-key": {
-            "version": "3.1.1",
-            "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
-            "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
-            "license": "MIT",
-            "engines": {
-                "node": ">=8"
-            }
-        },
-        "node_modules/path-to-regexp": {
-            "version": "6.3.0",
-            "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-6.3.0.tgz",
-            "integrity": "sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ=="
-        },
         "node_modules/periscopic": {
             "version": "3.1.0",
             "resolved": "https://registry.npmjs.org/periscopic/-/periscopic-3.1.0.tgz",
@@ -5852,7 +5889,8 @@
         "node_modules/picocolors": {
             "version": "1.1.0",
             "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.0.tgz",
-            "integrity": "sha512-TQ92mBOW0l3LeMeyLV6mzy/kWr8lkd/hp3mTg7wYK7zJhuBStmGMBG0BdeDZS/dZx1IukaX6Bk11zcln25o1Aw=="
+            "integrity": "sha512-TQ92mBOW0l3LeMeyLV6mzy/kWr8lkd/hp3mTg7wYK7zJhuBStmGMBG0BdeDZS/dZx1IukaX6Bk11zcln25o1Aw==",
+            "license": "ISC"
         },
         "node_modules/picomatch": {
             "version": "2.3.1",
@@ -5905,6 +5943,7 @@
                     "url": "https://github.com/sponsors/ai"
                 }
             ],
+            "license": "MIT",
             "dependencies": {
                 "nanoid": "^3.3.7",
                 "picocolors": "^1.1.0",
@@ -5967,16 +6006,16 @@
             }
         },
         "node_modules/prettier": {
-            "version": "3.3.3",
-            "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.3.3.tgz",
-            "integrity": "sha512-i2tDNA0O5IrMO757lfrdQZCc2jPNDVntV0m/+4whiDfWaTKfMNgR7Qz0NAeGz/nRqF4m5/6CLzbP4/liHt12Ew==",
+            "version": "2.8.7",
+            "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.7.tgz",
+            "integrity": "sha512-yPngTo3aXUUmyuTjeTUT75txrf+aMh9FiD7q9ZE/i6r0bPb22g4FsE6Y338PQX1bmfy08i9QQCB7/rcUAVntfw==",
+            "license": "MIT",
             "optional": true,
-            "peer": true,
             "bin": {
-                "prettier": "bin/prettier.cjs"
+                "prettier": "bin-prettier.js"
             },
             "engines": {
-                "node": ">=14"
+                "node": ">=10.13.0"
             },
             "funding": {
                 "url": "https://github.com/prettier/prettier?sponsor=1"
@@ -6055,10 +6094,22 @@
                 "node": ">=8.10.0"
             }
         },
+        "node_modules/regenerator-runtime": {
+            "version": "0.14.1",
+            "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.14.1.tgz",
+            "integrity": "sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==",
+            "license": "MIT"
+        },
+        "node_modules/regex": {
+            "version": "4.3.2",
+            "resolved": "https://registry.npmjs.org/regex/-/regex-4.3.2.tgz",
+            "integrity": "sha512-kK/AA3A9K6q2js89+VMymcboLOlF5lZRCYJv3gzszXFHBr6kO6qLGzbm+UIugBEV8SMMKCTR59txoY6ctRHYVw==",
+            "license": "MIT"
+        },
         "node_modules/rehype": {
-            "version": "13.0.1",
-            "resolved": "https://registry.npmjs.org/rehype/-/rehype-13.0.1.tgz",
-            "integrity": "sha512-AcSLS2mItY+0fYu9xKxOu1LhUZeBZZBx8//5HKzF+0XP+eP8+6a5MXn2+DW2kfXR6Dtp1FEXMVrjyKAcvcU8vg==",
+            "version": "13.0.2",
+            "resolved": "https://registry.npmjs.org/rehype/-/rehype-13.0.2.tgz",
+            "integrity": "sha512-j31mdaRFrwFRUIlxGeuPXXKWQxet52RBQRvCmzl5eCefn/KGbomK5GMHNMsOJf55fgo3qw5tST5neDuarDYR2A==",
             "license": "MIT",
             "dependencies": {
                 "@types/hast": "^3.0.0",
@@ -6081,36 +6132,13 @@
             }
         },
         "node_modules/rehype-format": {
-            "version": "5.0.0",
-            "resolved": "https://registry.npmjs.org/rehype-format/-/rehype-format-5.0.0.tgz",
-            "integrity": "sha512-kM4II8krCHmUhxrlvzFSptvaWh280Fr7UGNJU5DCMuvmAwGCNmGfi9CvFAQK6JDjsNoRMWQStglK3zKJH685Wg==",
-            "license": "MIT",
-            "dependencies": {
-                "@types/hast": "^3.0.0",
-                "hast-util-embedded": "^3.0.0",
-                "hast-util-is-element": "^3.0.0",
-                "hast-util-phrasing": "^3.0.0",
-                "hast-util-whitespace": "^3.0.0",
-                "html-whitespace-sensitive-tag-names": "^3.0.0",
-                "rehype-minify-whitespace": "^6.0.0",
-                "unist-util-visit-parents": "^6.0.0"
-            },
-            "funding": {
-                "type": "opencollective",
-                "url": "https://opencollective.com/unified"
-            }
-        },
-        "node_modules/rehype-minify-whitespace": {
-            "version": "6.0.0",
-            "resolved": "https://registry.npmjs.org/rehype-minify-whitespace/-/rehype-minify-whitespace-6.0.0.tgz",
-            "integrity": "sha512-i9It4YHR0Sf3GsnlR5jFUKXRr9oayvEk9GKQUkwZv6hs70OH9q3OCZrq9PpLvIGKt3W+JxBOxCidNVpH/6rWdA==",
+            "version": "5.0.1",
+            "resolved": "https://registry.npmjs.org/rehype-format/-/rehype-format-5.0.1.tgz",
+            "integrity": "sha512-zvmVru9uB0josBVpr946OR8ui7nJEdzZobwLOOqHb/OOD88W0Vk2SqLwoVOj0fM6IPCCO6TaV9CvQvJMWwukFQ==",
             "license": "MIT",
             "dependencies": {
                 "@types/hast": "^3.0.0",
-                "hast-util-embedded": "^3.0.0",
-                "hast-util-is-element": "^3.0.0",
-                "hast-util-whitespace": "^3.0.0",
-                "unist-util-is": "^6.0.0"
+                "hast-util-format": "^1.0.0"
             },
             "funding": {
                 "type": "opencollective",
@@ -6118,9 +6146,9 @@
             }
         },
         "node_modules/rehype-parse": {
-            "version": "9.0.0",
-            "resolved": "https://registry.npmjs.org/rehype-parse/-/rehype-parse-9.0.0.tgz",
-            "integrity": "sha512-WG7nfvmWWkCR++KEkZevZb/uw41E8TsH4DsY9UxsTbIXCVGbAs4S+r8FrQ+OtH5EEQAs+5UxKC42VinkmpA1Yw==",
+            "version": "9.0.1",
+            "resolved": "https://registry.npmjs.org/rehype-parse/-/rehype-parse-9.0.1.tgz",
+            "integrity": "sha512-ksCzCD0Fgfh7trPDxr2rSylbwq9iYDkSn8TCDmEJ49ljEUBxDVCzCHv7QNzZOfODanX4+bWQ4WZqLCRWYLfhag==",
             "license": "MIT",
             "dependencies": {
                 "@types/hast": "^3.0.0",
@@ -6148,9 +6176,9 @@
             }
         },
         "node_modules/rehype-stringify": {
-            "version": "10.0.0",
-            "resolved": "https://registry.npmjs.org/rehype-stringify/-/rehype-stringify-10.0.0.tgz",
-            "integrity": "sha512-1TX1i048LooI9QoecrXy7nGFFbFSufxVRAfc6Y9YMRAi56l+oB0zP51mLSV312uRuvVLPV1opSlJmslozR1XHQ==",
+            "version": "10.0.1",
+            "resolved": "https://registry.npmjs.org/rehype-stringify/-/rehype-stringify-10.0.1.tgz",
+            "integrity": "sha512-k9ecfXHmIPuFVI61B9DeLPN0qFHfawM6RsuX48hoqlaKSF61RskNjSm1lI8PhBEM0MRdLxVVm4WmTqJQccH9mA==",
             "license": "MIT",
             "dependencies": {
                 "@types/hast": "^3.0.0",
@@ -6227,9 +6255,9 @@
             }
         },
         "node_modules/remark-rehype": {
-            "version": "11.1.0",
-            "resolved": "https://registry.npmjs.org/remark-rehype/-/remark-rehype-11.1.0.tgz",
-            "integrity": "sha512-z3tJrAs2kIs1AqIIy6pzHmAHlF1hWQ+OdY4/hv+Wxe35EhyLKcajL33iUEn3ScxtFox9nUvRufR/Zre8Q08H/g==",
+            "version": "11.1.1",
+            "resolved": "https://registry.npmjs.org/remark-rehype/-/remark-rehype-11.1.1.tgz",
+            "integrity": "sha512-g/osARvjkBXb6Wo0XvAeXQohVta8i84ACbenPpoSsxTOQH/Ae0/RGP4WZgnMH5pMLpsj4FG7OHmcIcXxpza8eQ==",
             "license": "MIT",
             "dependencies": {
                 "@types/hast": "^3.0.0",
@@ -6298,51 +6326,21 @@
             }
         },
         "node_modules/restore-cursor": {
-            "version": "4.0.0",
-            "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-4.0.0.tgz",
-            "integrity": "sha512-I9fPXU9geO9bHOt9pHHOhOkYerIMsmVaWB0rA2AI9ERh/+x/i7MV5HKBNrg+ljO5eoPVgCcnFuRjJ9uH6I/3eg==",
-            "license": "MIT",
-            "dependencies": {
-                "onetime": "^5.1.0",
-                "signal-exit": "^3.0.2"
-            },
-            "engines": {
-                "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-            },
-            "funding": {
-                "url": "https://github.com/sponsors/sindresorhus"
-            }
-        },
-        "node_modules/restore-cursor/node_modules/mimic-fn": {
-            "version": "2.1.0",
-            "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz",
-            "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==",
-            "license": "MIT",
-            "engines": {
-                "node": ">=6"
-            }
-        },
-        "node_modules/restore-cursor/node_modules/onetime": {
-            "version": "5.1.2",
-            "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz",
-            "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==",
+            "version": "5.1.0",
+            "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-5.1.0.tgz",
+            "integrity": "sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA==",
             "license": "MIT",
             "dependencies": {
-                "mimic-fn": "^2.1.0"
+                "onetime": "^7.0.0",
+                "signal-exit": "^4.1.0"
             },
             "engines": {
-                "node": ">=6"
+                "node": ">=18"
             },
             "funding": {
                 "url": "https://github.com/sponsors/sindresorhus"
             }
         },
-        "node_modules/restore-cursor/node_modules/signal-exit": {
-            "version": "3.0.7",
-            "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
-            "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
-            "license": "ISC"
-        },
         "node_modules/retext": {
             "version": "9.0.0",
             "resolved": "https://registry.npmjs.org/retext/-/retext-9.0.0.tgz",
@@ -6375,9 +6373,9 @@
             }
         },
         "node_modules/retext-smartypants": {
-            "version": "6.1.0",
-            "resolved": "https://registry.npmjs.org/retext-smartypants/-/retext-smartypants-6.1.0.tgz",
-            "integrity": "sha512-LDPXg95346bqFZnDMHo0S7Rq5p64+B+N8Vz733+wPMDtwb9rCOs9LIdIEhrUOU+TAywX9St+ocQWJt8wrzivcQ==",
+            "version": "6.1.1",
+            "resolved": "https://registry.npmjs.org/retext-smartypants/-/retext-smartypants-6.1.1.tgz",
+            "integrity": "sha512-onsHf34i/GzgElJgtT1K2V+31yEhWs7NJboKNxXJcmVMMPxLpgxZ9iADoMdydd6j/bHic5F/aNq0CGqElEtu2g==",
             "license": "MIT",
             "dependencies": {
                 "@types/nlcst": "^2.0.0",
@@ -6415,11 +6413,12 @@
             }
         },
         "node_modules/rollup": {
-            "version": "4.22.4",
-            "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.22.4.tgz",
-            "integrity": "sha512-vD8HJ5raRcWOyymsR6Z3o6+RzfEPCnVLMFJ6vRslO1jt4LO6dUo5Qnpg7y4RkZFM2DMe3WUirkI5c16onjrc6A==",
+            "version": "4.23.0",
+            "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.23.0.tgz",
+            "integrity": "sha512-vXB4IT9/KLDrS2WRXmY22sVB2wTsTwkpxjB8Q3mnakTENcYw3FRmfdYDy/acNmls+lHmDazgrRjK/yQ6hQAtwA==",
+            "license": "MIT",
             "dependencies": {
-                "@types/estree": "1.0.5"
+                "@types/estree": "1.0.6"
             },
             "bin": {
                 "rollup": "dist/bin/rollup"
@@ -6429,22 +6428,22 @@
                 "npm": ">=8.0.0"
             },
             "optionalDependencies": {
-                "@rollup/rollup-android-arm-eabi": "4.22.4",
-                "@rollup/rollup-android-arm64": "4.22.4",
-                "@rollup/rollup-darwin-arm64": "4.22.4",
-                "@rollup/rollup-darwin-x64": "4.22.4",
-                "@rollup/rollup-linux-arm-gnueabihf": "4.22.4",
-                "@rollup/rollup-linux-arm-musleabihf": "4.22.4",
-                "@rollup/rollup-linux-arm64-gnu": "4.22.4",
-                "@rollup/rollup-linux-arm64-musl": "4.22.4",
-                "@rollup/rollup-linux-powerpc64le-gnu": "4.22.4",
-                "@rollup/rollup-linux-riscv64-gnu": "4.22.4",
-                "@rollup/rollup-linux-s390x-gnu": "4.22.4",
-                "@rollup/rollup-linux-x64-gnu": "4.22.4",
-                "@rollup/rollup-linux-x64-musl": "4.22.4",
-                "@rollup/rollup-win32-arm64-msvc": "4.22.4",
-                "@rollup/rollup-win32-ia32-msvc": "4.22.4",
-                "@rollup/rollup-win32-x64-msvc": "4.22.4",
+                "@rollup/rollup-android-arm-eabi": "4.23.0",
+                "@rollup/rollup-android-arm64": "4.23.0",
+                "@rollup/rollup-darwin-arm64": "4.23.0",
+                "@rollup/rollup-darwin-x64": "4.23.0",
+                "@rollup/rollup-linux-arm-gnueabihf": "4.23.0",
+                "@rollup/rollup-linux-arm-musleabihf": "4.23.0",
+                "@rollup/rollup-linux-arm64-gnu": "4.23.0",
+                "@rollup/rollup-linux-arm64-musl": "4.23.0",
+                "@rollup/rollup-linux-powerpc64le-gnu": "4.23.0",
+                "@rollup/rollup-linux-riscv64-gnu": "4.23.0",
+                "@rollup/rollup-linux-s390x-gnu": "4.23.0",
+                "@rollup/rollup-linux-x64-gnu": "4.23.0",
+                "@rollup/rollup-linux-x64-musl": "4.23.0",
+                "@rollup/rollup-win32-arm64-msvc": "4.23.0",
+                "@rollup/rollup-win32-ia32-msvc": "4.23.0",
+                "@rollup/rollup-win32-x64-msvc": "4.23.0",
                 "fsevents": "~2.3.2"
             }
         },
@@ -6541,34 +6540,17 @@
                 "@img/sharp-win32-x64": "0.33.5"
             }
         },
-        "node_modules/shebang-command": {
-            "version": "2.0.0",
-            "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
-            "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
-            "license": "MIT",
-            "dependencies": {
-                "shebang-regex": "^3.0.0"
-            },
-            "engines": {
-                "node": ">=8"
-            }
-        },
-        "node_modules/shebang-regex": {
-            "version": "3.0.0",
-            "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
-            "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
-            "license": "MIT",
-            "engines": {
-                "node": ">=8"
-            }
-        },
         "node_modules/shiki": {
-            "version": "1.14.1",
-            "resolved": "https://registry.npmjs.org/shiki/-/shiki-1.14.1.tgz",
-            "integrity": "sha512-FujAN40NEejeXdzPt+3sZ3F2dx1U24BY2XTY01+MG8mbxCiA2XukXdcbyMyLAHJ/1AUUnQd1tZlvIjefWWEJeA==",
+            "version": "1.21.0",
+            "resolved": "https://registry.npmjs.org/shiki/-/shiki-1.21.0.tgz",
+            "integrity": "sha512-apCH5BoWTrmHDPGgg3RF8+HAAbEL/CdbYr8rMw7eIrdhCkZHdVGat5mMNlRtd1erNG01VPMIKHNQ0Pj2HMAiog==",
             "license": "MIT",
             "dependencies": {
-                "@shikijs/core": "1.14.1",
+                "@shikijs/core": "1.21.0",
+                "@shikijs/engine-javascript": "1.21.0",
+                "@shikijs/engine-oniguruma": "1.21.0",
+                "@shikijs/types": "1.21.0",
+                "@shikijs/vscode-textmate": "^9.2.2",
                 "@types/hast": "^3.0.4"
             }
         },
@@ -6637,6 +6619,7 @@
             "version": "1.2.1",
             "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
             "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+            "license": "BSD-3-Clause",
             "engines": {
                 "node": ">=0.10.0"
             }
@@ -6739,18 +6722,6 @@
                 "node": ">=0.10.0"
             }
         },
-        "node_modules/strip-final-newline": {
-            "version": "3.0.0",
-            "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-3.0.0.tgz",
-            "integrity": "sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==",
-            "license": "MIT",
-            "engines": {
-                "node": ">=12"
-            },
-            "funding": {
-                "url": "https://github.com/sponsors/sindresorhus"
-            }
-        },
         "node_modules/style-to-object": {
             "version": "0.4.4",
             "resolved": "https://registry.npmjs.org/style-to-object/-/style-to-object-0.4.4.tgz",
@@ -6772,6 +6743,12 @@
                 "node": ">=4"
             }
         },
+        "node_modules/tinyexec": {
+            "version": "0.3.0",
+            "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.0.tgz",
+            "integrity": "sha512-tVGE0mVJPGb0chKhqmsoosjsS+qUnJVGJpZgsHYQcGoPlG3B51R3PouqTgEGH2Dc9jjFyOqOpix6ZHNMXp1FZg==",
+            "license": "MIT"
+        },
         "node_modules/to-fast-properties": {
             "version": "2.0.0",
             "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz",
@@ -6814,9 +6791,9 @@
             }
         },
         "node_modules/tsconfck": {
-            "version": "3.1.1",
-            "resolved": "https://registry.npmjs.org/tsconfck/-/tsconfck-3.1.1.tgz",
-            "integrity": "sha512-00eoI6WY57SvZEVjm13stEVE90VkEdJAFGgpFLTsZbJyW/LwFQ7uQxJHWpZ2hzSWgCPKc9AnBnNP+0X7o3hAmQ==",
+            "version": "3.1.3",
+            "resolved": "https://registry.npmjs.org/tsconfck/-/tsconfck-3.1.3.tgz",
+            "integrity": "sha512-ulNZP1SVpRDesxeMLON/LtWM8HIgAJEIVpVVhBM6gsmvQ8+Rh+ZG7FWGvHh7Ah3pRABwVJWklWCr/BTZSv0xnQ==",
             "license": "MIT",
             "bin": {
                 "tsconfck": "bin/tsconfck.js"
@@ -6834,9 +6811,9 @@
             }
         },
         "node_modules/tslib": {
-            "version": "2.6.3",
-            "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.3.tgz",
-            "integrity": "sha512-xNvxJEOUiWPGhUuUdQgAJPKOOJfGnIyKySOc09XkKsgdUV/3E2zvwZYdejjmRgPCgcym1juLH3226yA7sEFJKQ==",
+            "version": "2.7.0",
+            "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.7.0.tgz",
+            "integrity": "sha512-gLXCKdN1/j47AiHiOkJN69hJmcbGTHI0ImLmbYLHykhgeN0jVGola9yVjFgzCUklsZQMW55o+dW7IXv3RCXDzA==",
             "license": "0BSD",
             "optional": true
         },
@@ -6859,9 +6836,9 @@
             "license": "MIT"
         },
         "node_modules/typescript": {
-            "version": "5.5.4",
-            "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.5.4.tgz",
-            "integrity": "sha512-Mtq29sKDAEYP7aljRgtPOpTvOfbwRWlS6dPRzwjdE+C0R4brX/GUyhHSecbHMFLNBLcJIPt9nl9yG5TZ1weH+Q==",
+            "version": "5.6.2",
+            "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.6.2.tgz",
+            "integrity": "sha512-NW8ByodCSNCwZeghjN3o+JX5OFH0Ojg6sadjEKY4huZ52TqbJTJnDo5+Tw98lSy63NZvi4n+ez5m2u5d4PkZyw==",
             "license": "Apache-2.0",
             "bin": {
                 "tsc": "bin/tsc",
@@ -7042,9 +7019,9 @@
             }
         },
         "node_modules/update-browserslist-db": {
-            "version": "1.1.0",
-            "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.0.tgz",
-            "integrity": "sha512-EdRAaAyk2cUE1wOf2DkEhzxqOQvFOoRJFNS6NeyJ01Gp2beMRpBAINjM2iDXE3KCuKhwnvHIQCJm6ThL2Z+HzQ==",
+            "version": "1.1.1",
+            "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.1.tgz",
+            "integrity": "sha512-R8UzCaa9Az+38REPiJ1tXlImTJXlVfgHZsglwBD/k6nj76ctsH1E3q4doGrukiLQd3sGQYu56r5+lo5r94l29A==",
             "funding": [
                 {
                     "type": "opencollective",
@@ -7061,8 +7038,8 @@
             ],
             "license": "MIT",
             "dependencies": {
-                "escalade": "^3.1.2",
-                "picocolors": "^1.0.1"
+                "escalade": "^3.2.0",
+                "picocolors": "^1.1.0"
             },
             "bin": {
                 "update-browserslist-db": "cli.js"
@@ -7078,13 +7055,12 @@
             "license": "MIT"
         },
         "node_modules/vfile": {
-            "version": "6.0.2",
-            "resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.2.tgz",
-            "integrity": "sha512-zND7NlS8rJYb/sPqkb13ZvbbUoExdbi4w3SfRrMq6R3FvnLQmmfpajJNITuuYm6AZ5uao9vy4BAos3EXBPf2rg==",
+            "version": "6.0.3",
+            "resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz",
+            "integrity": "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==",
             "license": "MIT",
             "dependencies": {
                 "@types/unist": "^3.0.0",
-                "unist-util-stringify-position": "^4.0.0",
                 "vfile-message": "^4.0.0"
             },
             "funding": {
@@ -7121,9 +7097,10 @@
             }
         },
         "node_modules/vite": {
-            "version": "5.4.6",
-            "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.6.tgz",
-            "integrity": "sha512-IeL5f8OO5nylsgzd9tq4qD2QqI0k2CQLGrWD0rCN0EQJZpBK5vJAx0I+GDkMOXxQX/OfFHMuLIx6ddAxGX/k+Q==",
+            "version": "5.4.8",
+            "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.8.tgz",
+            "integrity": "sha512-FqrItQ4DT1NC4zCUqMB4c4AZORMKIa0m8/URVCZ77OZ/QSNeJ54bU1vrFADbDsuwfIPcgknRkmqakQcgnL4GiQ==",
+            "license": "MIT",
             "dependencies": {
                 "esbuild": "^0.21.3",
                 "postcss": "^8.4.43",
@@ -7179,10 +7156,14 @@
             }
         },
         "node_modules/vitefu": {
-            "version": "0.2.5",
-            "resolved": "https://registry.npmjs.org/vitefu/-/vitefu-0.2.5.tgz",
-            "integrity": "sha512-SgHtMLoqaeeGnd2evZ849ZbACbnwQCIwRH57t18FxcXoZop0uQu0uzlIhJBlF/eWVzuce0sHeqPcDo+evVcg8Q==",
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/vitefu/-/vitefu-1.0.2.tgz",
+            "integrity": "sha512-0/iAvbXyM3RiPPJ4lyD4w6Mjgtf4ejTK6TPvTNG3H32PLwuT0N/ZjJLiXug7ETE/LWtTeHw9WRv7uX/tIKYyKg==",
             "license": "MIT",
+            "workspaces": [
+                "tests/deps/*",
+                "tests/projects/*"
+            ],
             "peerDependencies": {
                 "vite": "^3.0.0 || ^4.0.0 || ^5.0.0"
             },
@@ -7329,25 +7310,25 @@
             }
         },
         "node_modules/vscode-css-languageservice": {
-            "version": "6.3.0",
-            "resolved": "https://registry.npmjs.org/vscode-css-languageservice/-/vscode-css-languageservice-6.3.0.tgz",
-            "integrity": "sha512-nU92imtkgzpCL0xikrIb8WvedV553F2BENzgz23wFuok/HLN5BeQmroMy26pUwFxV2eV8oNRmYCUv8iO7kSMhw==",
+            "version": "6.3.1",
+            "resolved": "https://registry.npmjs.org/vscode-css-languageservice/-/vscode-css-languageservice-6.3.1.tgz",
+            "integrity": "sha512-1BzTBuJfwMc3A0uX4JBdJgoxp74cjj4q2mDJdp49yD/GuAq4X0k5WtK6fNcMYr+FfJ9nqgR6lpfCSZDkARJ5qQ==",
             "license": "MIT",
             "dependencies": {
                 "@vscode/l10n": "^0.0.18",
-                "vscode-languageserver-textdocument": "^1.0.11",
+                "vscode-languageserver-textdocument": "^1.0.12",
                 "vscode-languageserver-types": "3.17.5",
                 "vscode-uri": "^3.0.8"
             }
         },
         "node_modules/vscode-html-languageservice": {
-            "version": "5.3.0",
-            "resolved": "https://registry.npmjs.org/vscode-html-languageservice/-/vscode-html-languageservice-5.3.0.tgz",
-            "integrity": "sha512-C4Z3KsP5Ih+fjHpiBc5jxmvCl+4iEwvXegIrzu2F5pktbWvQaBT3YkVPk8N+QlSSMk8oCG6PKtZ/Sq2YHb5e8g==",
+            "version": "5.3.1",
+            "resolved": "https://registry.npmjs.org/vscode-html-languageservice/-/vscode-html-languageservice-5.3.1.tgz",
+            "integrity": "sha512-ysUh4hFeW/WOWz/TO9gm08xigiSsV/FOAZ+DolgJfeLftna54YdmZ4A+lIn46RbdO3/Qv5QHTn1ZGqmrXQhZyA==",
             "license": "MIT",
             "dependencies": {
                 "@vscode/l10n": "^0.0.18",
-                "vscode-languageserver-textdocument": "^1.0.11",
+                "vscode-languageserver-textdocument": "^1.0.12",
                 "vscode-languageserver-types": "^3.17.5",
                 "vscode-uri": "^3.0.8"
             }
@@ -7439,21 +7420,6 @@
                 "url": "https://github.com/sponsors/wooorm"
             }
         },
-        "node_modules/which": {
-            "version": "2.0.2",
-            "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
-            "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
-            "license": "ISC",
-            "dependencies": {
-                "isexe": "^2.0.0"
-            },
-            "bin": {
-                "node-which": "bin/node-which"
-            },
-            "engines": {
-                "node": ">= 8"
-            }
-        },
         "node_modules/which-pm": {
             "version": "3.0.0",
             "resolved": "https://registry.npmjs.org/which-pm/-/which-pm-3.0.0.tgz",
@@ -7587,9 +7553,9 @@
             "license": "ISC"
         },
         "node_modules/yaml": {
-            "version": "2.5.0",
-            "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.5.0.tgz",
-            "integrity": "sha512-2wWLbGbYDiSqqIKoPjar3MPgB94ErzCtrNE1FdqGuaO0pi2JGjmE8aW8TDZwzU7vuxcGRdL/4gPQwQ7hD5AMSw==",
+            "version": "2.5.1",
+            "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.5.1.tgz",
+            "integrity": "sha512-bLQOjaX/ADgQ20isPJRvF0iRUHIxVhYvr53Of7wGcWlO2jvtUlH5m87DsmulFVxRpNLOnI4tB6p/oh8D7kpn9Q==",
             "license": "ISC",
             "bin": {
                 "yaml": "bin.mjs"
@@ -7622,21 +7588,6 @@
                 "prettier": "2.8.7"
             }
         },
-        "node_modules/yaml-language-server/node_modules/prettier": {
-            "version": "2.8.7",
-            "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.7.tgz",
-            "integrity": "sha512-yPngTo3aXUUmyuTjeTUT75txrf+aMh9FiD7q9ZE/i6r0bPb22g4FsE6Y338PQX1bmfy08i9QQCB7/rcUAVntfw==",
-            "optional": true,
-            "bin": {
-                "prettier": "bin-prettier.js"
-            },
-            "engines": {
-                "node": ">=10.13.0"
-            },
-            "funding": {
-                "url": "https://github.com/prettier/prettier?sponsor=1"
-            }
-        },
         "node_modules/yaml-language-server/node_modules/request-light": {
             "version": "0.5.8",
             "resolved": "https://registry.npmjs.org/request-light/-/request-light-0.5.8.tgz",
@@ -7779,9 +7730,9 @@
             }
         },
         "node_modules/zod-to-json-schema": {
-            "version": "3.23.2",
-            "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.23.2.tgz",
-            "integrity": "sha512-uSt90Gzc/tUfyNqxnjlfBs8W6WSGpNBv0rVsNxP/BVSMHMKGdthPYff4xtCHYloJGM0CFxFsb3NbC0eqPhfImw==",
+            "version": "3.23.3",
+            "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.23.3.tgz",
+            "integrity": "sha512-TYWChTxKQbRJp5ST22o/Irt9KC5nj7CdBKYB/AosCRdj/wxEMvv4NNaj9XVUHDOIp53ZxArGhnw5HMZziPFjog==",
             "license": "ISC",
             "peerDependencies": {
                 "zod": "^3.23.3"
diff --git a/docs/package.json b/docs/package.json
index 4868b75d6..647c94701 100644
--- a/docs/package.json
+++ b/docs/package.json
@@ -11,9 +11,9 @@
     },
     "dependencies": {
         "@astrojs/check": "0.9.3",
-        "@astrojs/starlight": "0.26.1",
-        "astro": "4.14.3",
+        "@astrojs/starlight": "0.28.2",
+        "astro": "4.15.9",
         "sharp": "0.33.5",
-        "typescript": "5.5.4"
+        "typescript": "5.6.2"
     }
 }
\ No newline at end of file
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index 2c3521197..a4b76b953 100644
Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 66cd5a0e4..79eb9d003 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-all.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/And.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/And.kt
index df6dbce6c..ceed8e670 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/And.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/And.kt
@@ -3,7 +3,7 @@ package nebulosa.adql
 import adql.query.constraint.ADQLConstraint
 import adql.query.constraint.NotConstraint
 
-data class And internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class And(override val constraint: ADQLConstraint) : WhereConstraint {
 
     constructor(vararg contraints: WhereConstraint) : this(LogicalConstraintsGroup("AND")) {
         val logicalConstraint = constraint as LogicalConstraintsGroup
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Area.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Area.kt
index 80f29a592..60a065119 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Area.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Area.kt
@@ -3,7 +3,7 @@ package nebulosa.adql
 import adql.query.operand.function.geometry.AreaFunction
 import adql.query.operand.function.geometry.GeometryFunction
 
-data class Area internal constructor(override val operand: GeometryFunction) : Operand<GeometryFunction> {
+data class Area(override val operand: GeometryFunction) : Operand<GeometryFunction> {
 
     constructor(region: Region) : this(AreaFunction(GeometryFunction.GeometryValue(region.operand)))
 }
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Between.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Between.kt
index 793a2f5cd..76cb419e3 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Between.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Between.kt
@@ -3,7 +3,7 @@ package nebulosa.adql
 import adql.query.constraint.ADQLConstraint
 import adql.query.constraint.Between as ADQLBetween
 
-data class Between internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class Between(override val constraint: ADQLConstraint) : WhereConstraint {
 
     constructor(operand: Operand<*>, min: Operand<*>, max: Operand<*>) : this(ADQLBetween(operand.operand, min.operand, max.operand))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Box.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Box.kt
index f1bc9913a..826b2414c 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Box.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Box.kt
@@ -5,7 +5,7 @@ import adql.query.operand.function.geometry.BoxFunction
 import nebulosa.math.Angle
 import nebulosa.math.toDegrees
 
-data class Box internal constructor(override val operand: BoxFunction) : Region {
+data class Box(override val operand: BoxFunction) : Region {
 
     constructor(x: Operand<*>, y: Operand<*>, width: Operand<*>, height: Operand<*>)
             : this(BoxFunction(StringConstant("ICRS"), x.operand, y.operand, width.operand, height.operand))
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Circle.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Circle.kt
index 37fd52468..a9fea9c5b 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Circle.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Circle.kt
@@ -5,7 +5,7 @@ import adql.query.operand.function.geometry.CircleFunction
 import nebulosa.math.Angle
 import nebulosa.math.toDegrees
 
-data class Circle internal constructor(override val operand: CircleFunction) : Region {
+data class Circle(override val operand: CircleFunction) : Region {
 
     constructor(x: Operand<*>, y: Operand<*>, radius: Operand<*>) : this(CircleFunction(StringConstant("ICRS"), x.operand, y.operand, radius.operand))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Column.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Column.kt
index 07391d8aa..223ae06d3 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Column.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Column.kt
@@ -2,7 +2,7 @@ package nebulosa.adql
 
 import adql.query.operand.ADQLColumn
 
-data class Column internal constructor(override val operand: ADQLColumn) : Operand<ADQLColumn> {
+data class Column(override val operand: ADQLColumn) : Operand<ADQLColumn> {
 
     constructor(columnRef: String) : this(ADQLColumn(columnRef))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Contains.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Contains.kt
index 6ff47a3d2..604019ead 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Contains.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Contains.kt
@@ -7,7 +7,7 @@ import adql.query.operand.NumericConstant
 import adql.query.operand.function.geometry.ContainsFunction
 import adql.query.operand.function.geometry.GeometryFunction
 
-data class Contains internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class Contains(override val constraint: ADQLConstraint) : WhereConstraint {
 
     private constructor(left: GeometryFunction.GeometryValue<GeometryFunction>, right: GeometryFunction.GeometryValue<GeometryFunction>) : this(
         Comparison(ContainsFunction(left, right), ComparisonOperator.EQUAL, NumericConstant(1L))
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/CrossJoin.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/CrossJoin.kt
index 3a0eed106..a95cfd63e 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/CrossJoin.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/CrossJoin.kt
@@ -3,7 +3,7 @@ package nebulosa.adql
 import adql.query.from.ADQLJoin
 import adql.query.from.CrossJoin as ADQLCrossJoin
 
-data class CrossJoin internal constructor(override val table: ADQLJoin) : Table {
+data class CrossJoin(override val table: ADQLJoin) : Table {
 
     constructor(left: Table, right: Table) : this(ADQLCrossJoin(left.table, right.table))
 }
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Distance.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Distance.kt
index 9940d1174..76fffddb5 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Distance.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Distance.kt
@@ -3,7 +3,7 @@ package nebulosa.adql
 import adql.query.operand.function.geometry.DistanceFunction
 import adql.query.operand.function.geometry.GeometryFunction
 
-data class Distance internal constructor(override val operand: GeometryFunction) : Operand<GeometryFunction> {
+data class Distance(override val operand: GeometryFunction) : Operand<GeometryFunction> {
 
     constructor(a: SkyPoint, b: SkyPoint) : this(
         DistanceFunction(
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Equal.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Equal.kt
index db4e12a2a..3deec3a22 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Equal.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Equal.kt
@@ -4,7 +4,7 @@ import adql.query.constraint.ADQLConstraint
 import adql.query.constraint.Comparison
 import adql.query.constraint.ComparisonOperator
 
-data class Equal internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class Equal(override val constraint: ADQLConstraint) : WhereConstraint {
 
     constructor(left: Operand<*>, right: Operand<*>) : this(Comparison(left.operand, ComparisonOperator.EQUAL, right.operand))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Exists.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Exists.kt
index 2dd827da5..ce632ffd7 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Exists.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Exists.kt
@@ -4,7 +4,7 @@ import adql.query.constraint.ADQLConstraint
 import adql.query.constraint.Exists
 import adql.query.constraint.NotConstraint
 
-data class Exists internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class Exists(override val constraint: ADQLConstraint) : WhereConstraint {
 
     constructor(query: Query) : this(Exists(query.query))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/From.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/From.kt
index 0421f945c..68a45919f 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/From.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/From.kt
@@ -2,7 +2,7 @@ package nebulosa.adql
 
 import adql.query.from.ADQLTable
 
-data class From internal constructor(override val table: ADQLTable) : Table {
+data class From(override val table: ADQLTable) : Table {
 
     constructor(table: String) : this(ADQLTable(table))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/FullJoin.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/FullJoin.kt
index b394b7cac..1b3201de0 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/FullJoin.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/FullJoin.kt
@@ -5,7 +5,7 @@ import adql.query.from.ADQLJoin
 import adql.query.from.OuterJoin
 import adql.query.from.OuterJoin as ADQLOuterJoin
 
-data class FullJoin internal constructor(override val table: ADQLJoin) : Table {
+data class FullJoin(override val table: ADQLJoin) : Table {
 
     constructor(left: Table, right: Table) : this(ADQLOuterJoin(left.table, right.table, OuterJoin.OuterType.FULL))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/GreaterOrEqual.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/GreaterOrEqual.kt
index 29b8ab046..29df2bdf4 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/GreaterOrEqual.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/GreaterOrEqual.kt
@@ -4,7 +4,7 @@ import adql.query.constraint.ADQLConstraint
 import adql.query.constraint.Comparison
 import adql.query.constraint.ComparisonOperator
 
-data class GreaterOrEqual internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class GreaterOrEqual(override val constraint: ADQLConstraint) : WhereConstraint {
 
     constructor(left: Operand<*>, right: Operand<*>) : this(Comparison(left.operand, ComparisonOperator.GREATER_OR_EQUAL, right.operand))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/GreaterThan.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/GreaterThan.kt
index 3478550b0..d6097fd4e 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/GreaterThan.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/GreaterThan.kt
@@ -4,7 +4,7 @@ import adql.query.constraint.ADQLConstraint
 import adql.query.constraint.Comparison
 import adql.query.constraint.ComparisonOperator
 
-data class GreaterThan internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class GreaterThan(override val constraint: ADQLConstraint) : WhereConstraint {
 
     constructor(left: Operand<*>, right: Operand<*>) : this(Comparison(left.operand, ComparisonOperator.GREATER_THAN, right.operand))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/In.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/In.kt
index 8a5e26368..069aadd53 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/In.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/In.kt
@@ -5,7 +5,7 @@ import adql.query.constraint.ADQLConstraint
 import adql.query.operand.ADQLOperand
 import adql.query.constraint.In as ADQLIn
 
-data class In internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class In(override val constraint: ADQLConstraint) : WhereConstraint {
 
     constructor(operand: Operand<*>, values: Array<out Operand<*>>) : this(ADQLIn(operand.operand, values.list()))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/InnerJoin.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/InnerJoin.kt
index ada4021df..d95ad5e86 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/InnerJoin.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/InnerJoin.kt
@@ -4,7 +4,7 @@ import adql.query.ClauseConstraints
 import adql.query.from.ADQLJoin
 import adql.query.from.InnerJoin as ADQLInnerJoin
 
-data class InnerJoin internal constructor(override val table: ADQLJoin) : Table {
+data class InnerJoin(override val table: ADQLJoin) : Table {
 
     constructor(left: Table, right: Table) : this(ADQLInnerJoin(left.table, right.table))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/IsNotNull.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/IsNotNull.kt
index 2300ac598..90f9fc40a 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/IsNotNull.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/IsNotNull.kt
@@ -4,7 +4,7 @@ import adql.query.constraint.ADQLConstraint
 import adql.query.operand.ADQLColumn
 import adql.query.constraint.IsNull as ADQLIsNull
 
-data class IsNotNull internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class IsNotNull(override val constraint: ADQLConstraint) : WhereConstraint {
 
     constructor(operand: Operand<ADQLColumn>) : this(ADQLIsNull(operand.operand, true))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/IsNull.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/IsNull.kt
index 69e937000..c2af9678f 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/IsNull.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/IsNull.kt
@@ -4,7 +4,7 @@ import adql.query.constraint.ADQLConstraint
 import adql.query.operand.ADQLColumn
 import adql.query.constraint.IsNull as ADQLIsNull
 
-data class IsNull internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class IsNull(override val constraint: ADQLConstraint) : WhereConstraint {
 
     constructor(operand: Operand<ADQLColumn>) : this(ADQLIsNull(operand.operand))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/LeftJoin.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/LeftJoin.kt
index f36fbcea7..124af6c6d 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/LeftJoin.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/LeftJoin.kt
@@ -5,7 +5,7 @@ import adql.query.from.ADQLJoin
 import adql.query.from.OuterJoin
 import adql.query.from.OuterJoin as ADQLOuterJoin
 
-data class LeftJoin internal constructor(override val table: ADQLJoin) : Table {
+data class LeftJoin(override val table: ADQLJoin) : Table {
 
     constructor(left: Table, right: Table) : this(ADQLOuterJoin(left.table, right.table, OuterJoin.OuterType.LEFT))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/LessOrEqual.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/LessOrEqual.kt
index fa0eeeff0..6452d4f11 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/LessOrEqual.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/LessOrEqual.kt
@@ -4,7 +4,7 @@ import adql.query.constraint.ADQLConstraint
 import adql.query.constraint.Comparison
 import adql.query.constraint.ComparisonOperator
 
-data class LessOrEqual internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class LessOrEqual(override val constraint: ADQLConstraint) : WhereConstraint {
 
     constructor(left: Operand<*>, right: Operand<*>) : this(Comparison(left.operand, ComparisonOperator.LESS_OR_EQUAL, right.operand))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/LessThan.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/LessThan.kt
index 46d5c3d34..fbfff2bcf 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/LessThan.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/LessThan.kt
@@ -4,7 +4,7 @@ import adql.query.constraint.ADQLConstraint
 import adql.query.constraint.Comparison
 import adql.query.constraint.ComparisonOperator
 
-data class LessThan internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class LessThan(override val constraint: ADQLConstraint) : WhereConstraint {
 
     constructor(left: Operand<*>, right: Operand<*>) : this(Comparison(left.operand, ComparisonOperator.LESS_THAN, right.operand))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Like.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Like.kt
index 6eeb76501..1a21c5d3e 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Like.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Like.kt
@@ -4,7 +4,7 @@ import adql.query.constraint.ADQLConstraint
 import adql.query.constraint.Comparison
 import adql.query.constraint.ComparisonOperator
 
-data class Like internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class Like(override val constraint: ADQLConstraint) : WhereConstraint {
 
     constructor(left: Operand<*>, right: Operand<*>) : this(Comparison(left.operand, ComparisonOperator.LIKE, right.operand))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Literal.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Literal.kt
index 5d6626f0f..600679418 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Literal.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Literal.kt
@@ -5,7 +5,7 @@ import adql.query.operand.NegativeOperand
 import adql.query.operand.NumericConstant
 import adql.query.operand.StringConstant
 
-data class Literal internal constructor(override val operand: ADQLOperand) : Operand<ADQLOperand> {
+data class Literal(override val operand: ADQLOperand) : Operand<ADQLOperand> {
 
     constructor(value: String) : this(StringConstant(value))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotAnd.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotAnd.kt
index 540e28f51..8493c9b36 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotAnd.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotAnd.kt
@@ -3,7 +3,7 @@ package nebulosa.adql
 import adql.query.constraint.ADQLConstraint
 import adql.query.constraint.NotConstraint
 
-data class NotAnd internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class NotAnd(override val constraint: ADQLConstraint) : WhereConstraint {
 
     constructor(vararg contraints: WhereConstraint) : this(NotConstraint(LogicalConstraintsGroup("AND"))) {
         val logicalConstraint = constraint as LogicalConstraintsGroup
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotBetween.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotBetween.kt
index 94637fdf5..9aa123e9e 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotBetween.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotBetween.kt
@@ -3,7 +3,7 @@ package nebulosa.adql
 import adql.query.constraint.ADQLConstraint
 import adql.query.constraint.Between as ADQLBetween
 
-data class NotBetween internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class NotBetween(override val constraint: ADQLConstraint) : WhereConstraint {
 
     constructor(operand: Operand<*>, min: Operand<*>, max: Operand<*>) : this(ADQLBetween(operand.operand, min.operand, max.operand, true))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotContains.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotContains.kt
index 19a8ec188..e28b82e56 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotContains.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotContains.kt
@@ -7,7 +7,7 @@ import adql.query.operand.NumericConstant
 import adql.query.operand.function.geometry.ContainsFunction
 import adql.query.operand.function.geometry.GeometryFunction
 
-data class NotContains internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class NotContains(override val constraint: ADQLConstraint) : WhereConstraint {
 
     private constructor(left: GeometryFunction.GeometryValue<GeometryFunction>, right: GeometryFunction.GeometryValue<GeometryFunction>) : this(
         Comparison(ContainsFunction(left, right), ComparisonOperator.EQUAL, NumericConstant(0L))
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotEqual.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotEqual.kt
index 47aed92f5..cf235855a 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotEqual.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotEqual.kt
@@ -4,7 +4,7 @@ import adql.query.constraint.ADQLConstraint
 import adql.query.constraint.Comparison
 import adql.query.constraint.ComparisonOperator
 
-data class NotEqual internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class NotEqual(override val constraint: ADQLConstraint) : WhereConstraint {
 
     constructor(left: Operand<*>, right: Operand<*>) : this(Comparison(left.operand, ComparisonOperator.NOT_EQUAL, right.operand))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotExists.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotExists.kt
index d2ef96890..5389aa6d1 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotExists.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotExists.kt
@@ -4,7 +4,7 @@ import adql.query.constraint.ADQLConstraint
 import adql.query.constraint.NotConstraint
 import adql.query.constraint.Exists as ADQLExists
 
-data class NotExists internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class NotExists(override val constraint: ADQLConstraint) : WhereConstraint {
 
     constructor(query: Query) : this(NotConstraint(ADQLExists(query.query)))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotIn.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotIn.kt
index 85e536ddf..59b0da06c 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotIn.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotIn.kt
@@ -5,7 +5,7 @@ import adql.query.constraint.ADQLConstraint
 import adql.query.operand.ADQLOperand
 import adql.query.constraint.In as ADQLIn
 
-data class NotIn internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class NotIn(override val constraint: ADQLConstraint) : WhereConstraint {
 
     constructor(operand: Operand<*>, values: Array<out Operand<*>>) : this(ADQLIn(operand.operand, values.list(), true))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotLike.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotLike.kt
index 2adb29559..aecb3b2ee 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotLike.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotLike.kt
@@ -4,7 +4,7 @@ import adql.query.constraint.ADQLConstraint
 import adql.query.constraint.Comparison
 import adql.query.constraint.ComparisonOperator
 
-data class NotLike internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class NotLike(override val constraint: ADQLConstraint) : WhereConstraint {
 
     constructor(left: Operand<*>, right: Operand<*>) : this(Comparison(left.operand, ComparisonOperator.NOTLIKE, right.operand))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotOr.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotOr.kt
index f03957d70..637b7ad3b 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotOr.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/NotOr.kt
@@ -3,7 +3,7 @@ package nebulosa.adql
 import adql.query.constraint.ADQLConstraint
 import adql.query.constraint.NotConstraint
 
-data class NotOr internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class NotOr(override val constraint: ADQLConstraint) : WhereConstraint {
 
     constructor(vararg contraints: WhereConstraint) : this(NotConstraint(LogicalConstraintsGroup("OR"))) {
         val logicalConstraint = constraint as LogicalConstraintsGroup
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Or.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Or.kt
index bdf974e8e..b77fe1e9c 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Or.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Or.kt
@@ -3,7 +3,7 @@ package nebulosa.adql
 import adql.query.constraint.ADQLConstraint
 import adql.query.constraint.NotConstraint
 
-data class Or internal constructor(override val constraint: ADQLConstraint) : WhereConstraint {
+data class Or(override val constraint: ADQLConstraint) : WhereConstraint {
 
     constructor(vararg contraints: WhereConstraint) : this(LogicalConstraintsGroup("OR")) {
         val logicalConstraint = constraint as LogicalConstraintsGroup
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Polygon.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Polygon.kt
index 58aa163cf..bf03d6f4e 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Polygon.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Polygon.kt
@@ -4,7 +4,7 @@ import adql.query.operand.NumericConstant
 import adql.query.operand.function.geometry.PolygonFunction
 import nebulosa.math.toDegrees
 
-data class Polygon internal constructor(override val operand: PolygonFunction) : Region {
+data class Polygon(override val operand: PolygonFunction) : Region {
 
     constructor(points: DoubleArray) : this(PolygonFunction(Region.ICRS, points.map { NumericConstant(it.toDegrees) }))
 }
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Query.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Query.kt
index 7504c91d5..69f871429 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/Query.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/Query.kt
@@ -2,7 +2,7 @@ package nebulosa.adql
 
 import adql.query.ADQLQuery
 
-data class Query internal constructor(@JvmField internal val query: ADQLQuery) : CharSequence {
+data class Query(@JvmField internal val query: ADQLQuery) : CharSequence {
 
     private val queryText: String by lazy(query::toADQL)
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/RightJoin.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/RightJoin.kt
index f4f39c6e1..788adce96 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/RightJoin.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/RightJoin.kt
@@ -5,7 +5,7 @@ import adql.query.from.ADQLJoin
 import adql.query.from.OuterJoin
 import adql.query.from.OuterJoin as ADQLOuterJoin
 
-data class RightJoin internal constructor(override val table: ADQLJoin) : Table {
+data class RightJoin(override val table: ADQLJoin) : Table {
 
     constructor(left: Table, right: Table) : this(ADQLOuterJoin(left.table, right.table, OuterJoin.OuterType.RIGHT))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/SkyPoint.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/SkyPoint.kt
index b8e9b554d..18f0eebe9 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/SkyPoint.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/SkyPoint.kt
@@ -5,7 +5,7 @@ import adql.query.operand.function.geometry.PointFunction
 import nebulosa.math.Angle
 import nebulosa.math.toDegrees
 
-data class SkyPoint internal constructor(override val operand: PointFunction) : Region {
+data class SkyPoint(override val operand: PointFunction) : Region {
 
     constructor(x: Operand<*>, y: Operand<*>) : this(PointFunction(StringConstant("ICRS"), x.operand, y.operand))
 
diff --git a/nebulosa-adql/src/main/kotlin/nebulosa/adql/SortBy.kt b/nebulosa-adql/src/main/kotlin/nebulosa/adql/SortBy.kt
index ec9b1a424..3c1bd1929 100644
--- a/nebulosa-adql/src/main/kotlin/nebulosa/adql/SortBy.kt
+++ b/nebulosa-adql/src/main/kotlin/nebulosa/adql/SortBy.kt
@@ -2,7 +2,7 @@ package nebulosa.adql
 
 import adql.query.ADQLOrder
 
-data class SortBy internal constructor(val order: ADQLOrder) : QueryClause {
+data class SortBy(val order: ADQLOrder) : QueryClause {
 
     constructor(column: Column, direction: SortDirection = SortDirection.ASCENDING)
             : this(ADQLOrder(column.operand.columnName, direction == SortDirection.DESCENDING))
diff --git a/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/ThreePointPolarAlignment.kt b/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/ThreePointPolarAlignment.kt
index d5c548811..8ecd32ee2 100644
--- a/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/ThreePointPolarAlignment.kt
+++ b/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/ThreePointPolarAlignment.kt
@@ -1,14 +1,14 @@
 package nebulosa.alignment.polar.point.three
 
 import nebulosa.alignment.polar.point.three.ThreePointPolarAlignmentResult.*
-import nebulosa.common.Resettable
-import nebulosa.common.concurrency.cancel.CancellationToken
 import nebulosa.constants.DEG2RAD
 import nebulosa.math.Angle
 import nebulosa.platesolver.PlateSolution
 import nebulosa.platesolver.PlateSolver
 import nebulosa.platesolver.PlateSolverException
 import nebulosa.time.UTC
+import nebulosa.util.Resettable
+import nebulosa.util.concurrency.cancellation.CancellationToken
 import java.nio.file.Path
 
 /**
@@ -56,19 +56,13 @@ data class ThreePointPolarAlignment(
         compensateRefraction: Boolean = false,
         cancellationToken: CancellationToken = CancellationToken.NONE,
     ): ThreePointPolarAlignmentResult {
-        if (cancellationToken.isCancelled) {
-            return Cancelled
-        }
-
         val solution = try {
             solver.solve(path, null, rightAscension, declination, radius, cancellationToken = cancellationToken)
         } catch (e: PlateSolverException) {
             return NoPlateSolution(e)
         }
 
-        if (cancellationToken.isCancelled) {
-            return Cancelled
-        } else if (!solution.solved) {
+        if (!solution.solved) {
             return NoPlateSolution(null)
         } else {
             val time = UTC.now()
diff --git a/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/ThreePointPolarAlignmentResult.kt b/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/ThreePointPolarAlignmentResult.kt
index bfa8cfc28..a3c28152c 100644
--- a/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/ThreePointPolarAlignmentResult.kt
+++ b/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/ThreePointPolarAlignmentResult.kt
@@ -13,6 +13,4 @@ sealed interface ThreePointPolarAlignmentResult {
     ) : ThreePointPolarAlignmentResult
 
     data class NoPlateSolution(@JvmField val exception: PlateSolverException?) : ThreePointPolarAlignmentResult
-
-    data object Cancelled : ThreePointPolarAlignmentResult
 }
diff --git a/nebulosa-alpaca-api/src/main/kotlin/nebulosa/alpaca/api/DateTimeResponse.kt b/nebulosa-alpaca-api/src/main/kotlin/nebulosa/alpaca/api/DateTimeResponse.kt
index 168e49293..b29639569 100644
--- a/nebulosa-alpaca-api/src/main/kotlin/nebulosa/alpaca/api/DateTimeResponse.kt
+++ b/nebulosa-alpaca-api/src/main/kotlin/nebulosa/alpaca/api/DateTimeResponse.kt
@@ -2,13 +2,13 @@ package nebulosa.alpaca.api
 
 import com.fasterxml.jackson.annotation.JsonFormat
 import com.fasterxml.jackson.annotation.JsonProperty
-import java.time.LocalDateTime
+import java.time.OffsetDateTime
 
 data class DateTimeResponse(
     @field:JsonProperty("ClientTransactionID") override val clientTransactionID: Int = 0,
     @field:JsonProperty("ServerTransactionID") override val serverTransactionID: Int = 0,
     @field:JsonProperty("ErrorNumber") override val errorNumber: Int = 0,
     @field:JsonProperty("ErrorMessage") override val errorMessage: String = "",
-    @field:JsonProperty("Value") @field:JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd'T'HH:mm:ss[.SSS]")
-    override val value: LocalDateTime = LocalDateTime.now(),
-) : AlpacaResponse<LocalDateTime>
+    @field:JsonProperty("Value") @field:JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd'T'HH:mm:ss[.SSS][XXX]")
+    override val value: OffsetDateTime = OffsetDateTime.MIN,
+) : AlpacaResponse<OffsetDateTime>
diff --git a/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/ASCOMDevice.kt b/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/ASCOMDevice.kt
index 6a044aff5..7ee0d2750 100644
--- a/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/ASCOMDevice.kt
+++ b/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/ASCOMDevice.kt
@@ -4,11 +4,11 @@ import nebulosa.alpaca.api.AlpacaDeviceService
 import nebulosa.alpaca.api.AlpacaResponse
 import nebulosa.alpaca.api.ConfiguredDevice
 import nebulosa.alpaca.indi.client.AlpacaClient
-import nebulosa.common.Resettable
-import nebulosa.common.time.Stopwatch
 import nebulosa.indi.device.*
-import nebulosa.log.debug
 import nebulosa.log.loggerFor
+import nebulosa.time.SystemClock
+import nebulosa.util.Resettable
+import nebulosa.util.time.Stopwatch
 import retrofit2.Call
 import retrofit2.HttpException
 import java.time.LocalDateTime
@@ -90,30 +90,29 @@ abstract class ASCOMDevice : Device, Resettable {
             val body = response.body()
 
             return if (body == null) {
-                LOG.debug { "response has no body. device=%s, request=%s %s, response=%s".format(name, request.method, request.url, response) }
+                LOG.debug("response has no body. device={}, request={} {}, response={}", name, request.method, request.url, response)
                 null
             } else if (body.errorNumber != 0) {
                 val message = body.errorMessage
 
                 if (message.isNotEmpty()) {
-                    addMessageAndFireEvent("[%s]: %s".format(LocalDateTime.now(), message))
+                    addMessageAndFireEvent("[%s]: %s".format(LocalDateTime.now(SystemClock), message))
                 }
 
-                LOG.debug {
-                    "unsuccessful response. device=%s, request=%s %s, errorNumber=%s, message=%s".format(
-                        name, request.method, request.url, body.errorNumber, body.errorMessage
-                    )
-                }
+                LOG.debug(
+                    "unsuccessful response. device={}, request={} {}, errorNumber={}, message={}",
+                    name, request.method, request.url, body.errorNumber, body.errorMessage
+                )
 
                 null
             } else {
                 body
             }
         } catch (e: HttpException) {
-            LOG.error("unexpected response. device=$name", e)
+            LOG.error("unexpected response. device={}", name, e)
         } catch (e: Throwable) {
             sender.fireOnConnectionClosed()
-            LOG.error("unexpected error. device=$name", e)
+            LOG.error("unexpected error. device={}", name, e)
         }
 
         return null
diff --git a/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/cameras/ASCOMCamera.kt b/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/cameras/ASCOMCamera.kt
index 682070e77..25a2a0f04 100644
--- a/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/cameras/ASCOMCamera.kt
+++ b/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/cameras/ASCOMCamera.kt
@@ -3,7 +3,6 @@ package nebulosa.alpaca.indi.device.cameras
 import nebulosa.alpaca.api.*
 import nebulosa.alpaca.indi.client.AlpacaClient
 import nebulosa.alpaca.indi.device.ASCOMDevice
-import nebulosa.common.concurrency.latch.CountUpDownLatch
 import nebulosa.fits.Bitpix
 import nebulosa.fits.Fits
 import nebulosa.fits.FitsHeader
@@ -14,7 +13,6 @@ import nebulosa.image.format.FloatImageData
 import nebulosa.image.format.HeaderCard
 import nebulosa.indi.device.Device
 import nebulosa.indi.device.camera.*
-import nebulosa.indi.device.camera.Camera.Companion.NANO_TO_SECONDS
 import nebulosa.indi.device.filterwheel.FilterWheel
 import nebulosa.indi.device.focuser.Focuser
 import nebulosa.indi.device.guider.GuideOutputPulsingChanged
@@ -28,6 +26,7 @@ import nebulosa.math.normalized
 import nebulosa.nova.position.Geoid
 import nebulosa.nova.position.ICRF
 import nebulosa.time.CurrentTime
+import nebulosa.util.concurrency.latch.CountUpDownLatch
 import okio.buffer
 import okio.source
 import java.nio.ByteBuffer
@@ -58,10 +57,10 @@ data class ASCOMCamera(
     @Volatile final override var cfaOffsetX = 0
     @Volatile final override var cfaOffsetY = 0
     @Volatile final override var cfaType = CfaPattern.RGGB
-    @Volatile final override var exposureMin: Duration = Duration.ZERO
-    @Volatile final override var exposureMax: Duration = Duration.ZERO
+    @Volatile final override var exposureMin = 0L
+    @Volatile final override var exposureMax = 0L
     @Volatile final override var exposureState = PropertyState.IDLE
-    @Volatile final override var exposureTime: Duration = Duration.ZERO
+    @Volatile final override var exposureTime = 0L
     @Volatile final override var hasCooler = false
     @Volatile final override var canSetTemperature = false
     @Volatile final override var canSubFrame = true
@@ -157,11 +156,11 @@ data class ASCOMCamera(
         service.offset(device.number, value).doRequest()
     }
 
-    override fun startCapture(exposureTime: Duration) {
+    override fun startCapture(exposureTime: Long) {
         if (!exposuring) {
             this.exposureTime = exposureTime
 
-            service.startExposure(device.number, exposureTime.toNanos() / NANO_TO_SECONDS, frameType == FrameType.LIGHT).doRequest {
+            service.startExposure(device.number, exposureTime.toDouble() / MICROS_TO_SECONDS, frameType == FrameType.LIGHT).doRequest {
                 imageReadyWaiter.captureStarted(exposureTime)
             }
         }
@@ -242,10 +241,10 @@ data class ASCOMCamera(
         cfaOffsetX = 0
         cfaOffsetY = 0
         cfaType = CfaPattern.RGGB
-        exposureMin = Duration.ZERO
-        exposureMax = Duration.ZERO
+        exposureMin = 0L
+        exposureMax = 0L
         exposureState = PropertyState.IDLE
-        exposureTime = Duration.ZERO
+        exposureTime = 0L
         hasCooler = false
         canSetTemperature = false
         canSubFrame = true
@@ -356,9 +355,8 @@ data class ASCOMCamera(
 
             if (exposuring) {
                 service.percentCompleted(device.number).doRequest {
-                    val exposureTimeInNanoseconds = imageReadyWaiter.exposureTime.toNanos()
-                    val progressedExposureTime = (exposureTimeInNanoseconds * it.value) / 100
-                    exposureTime = Duration.ofNanos(exposureTimeInNanoseconds - progressedExposureTime)
+                    val progressedExposureTime = (imageReadyWaiter.exposureTime * it.value) / 100
+                    this.exposureTime = imageReadyWaiter.exposureTime - progressedExposureTime
 
                     sender.fireOnEventReceived(CameraExposureProgressChanged(this))
                 }
@@ -536,8 +534,8 @@ data class ASCOMCamera(
     private fun processExposureMinMax() {
         service.exposureMin(device.number).doRequest { min ->
             service.exposureMax(device.number).doRequest { max ->
-                exposureMin = Duration.ofNanos((min.value * NANO_TO_SECONDS).toLong())
-                exposureMax = Duration.ofNanos((max.value * NANO_TO_SECONDS).toLong())
+                exposureMin = (min.value * MICROS_TO_SECONDS).toLong()
+                exposureMax = (max.value * MICROS_TO_SECONDS).toLong()
 
                 sender.fireOnEventReceived(CameraExposureMinMaxChanged(this))
             }
@@ -601,7 +599,7 @@ data class ASCOMCamera(
         }
     }
 
-    private fun readImage(exposureTime: Duration) {
+    private fun readImage(exposureTime: Long) {
         service.imageArray(device.number).execute().body()?.use { body ->
             val stream = body.byteStream()
             val metadata = ImageMetadata.from(stream.readNBytes(44))
@@ -610,7 +608,7 @@ data class ASCOMCamera(
                 LOG.error("failed to read image. device={}, error={}", name, metadata.errorNumber)
                 return
             } else {
-                LOG.info("image read. metadata={}", metadata)
+                LOG.debug("image read. metadata={}", metadata)
             }
 
             val width = metadata.dimension1
@@ -646,7 +644,7 @@ data class ASCOMCamera(
             if (numberOfChannels == 3) header.add(FitsKeyword.NAXIS3, numberOfChannels)
             header.add(FitsKeyword.EXTEND, true)
             header.add(FitsKeyword.INSTRUME, name)
-            val exposureTimeInSeconds = exposureTime.toNanos() / NANO_TO_SECONDS
+            val exposureTimeInSeconds = exposureTime.toDouble() / MICROS_TO_SECONDS
             header.add(FitsKeyword.EXPTIME, exposureTimeInSeconds)
             header.add(FitsKeyword.EXPOSURE, exposureTimeInSeconds)
             if (hasThermometer) header.add(FitsKeyword.CCD_TEMP, temperature)
@@ -753,13 +751,13 @@ data class ASCOMCamera(
         private val latch = CountUpDownLatch(1)
         private val aborted = AtomicBoolean()
 
-        @Volatile @JvmField var exposureTime: Duration = Duration.ZERO
+        @Volatile @JvmField var exposureTime = 0L
 
         init {
             isDaemon = true
         }
 
-        fun captureStarted(exposureTime: Duration) {
+        fun captureStarted(exposureTime: Long) {
             this.exposureTime = exposureTime
             aborted.set(false)
             latch.reset()
@@ -816,6 +814,8 @@ data class ASCOMCamera(
 
     companion object {
 
+        private const val MICROS_TO_SECONDS = 1_000_000L
+
         @JvmStatic private val LOG = loggerFor<ASCOMCamera>()
         @JvmStatic private val DATE_OBS_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSS")
         @JvmStatic private val RA_FORMAT = AngleFormatter.HMS.newBuilder().secondsDecimalPlaces(3).separators(" ").build()
diff --git a/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/mounts/ASCOMMount.kt b/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/mounts/ASCOMMount.kt
index 9a14a6d6e..06e93015d 100644
--- a/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/mounts/ASCOMMount.kt
+++ b/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/mounts/ASCOMMount.kt
@@ -270,7 +270,7 @@ data class ASCOMMount(
         longitude = 0.0
         latitude = 0.0
         elevation = 0.0
-        dateTime = OffsetDateTime.now(SystemClock)!!
+        dateTime = OffsetDateTime.now(SystemClock)
 
         axisRates.clear()
     }
@@ -425,7 +425,7 @@ data class ASCOMMount(
 
     private fun processDateTime() {
         service.utcDate(device.number).doRequest {
-            dateTime = it.value.atOffset(ZoneOffset.UTC)
+            dateTime = it.value
             sender.fireOnEventReceived(MountTimeChanged(this))
         }
     }
diff --git a/nebulosa-astap/build.gradle.kts b/nebulosa-astap/build.gradle.kts
index c3b85905d..aea4754a3 100644
--- a/nebulosa-astap/build.gradle.kts
+++ b/nebulosa-astap/build.gradle.kts
@@ -4,9 +4,9 @@ plugins {
 }
 
 dependencies {
-    api(project(":nebulosa-common"))
     api(project(":nebulosa-platesolver"))
     api(project(":nebulosa-stardetector"))
+    api(project(":nebulosa-util"))
     api(libs.csv)
     api(libs.oshi)
     implementation(project(":nebulosa-log"))
diff --git a/nebulosa-astap/src/main/kotlin/nebulosa/astap/platesolver/AstapPlateSolver.kt b/nebulosa-astap/src/main/kotlin/nebulosa/astap/platesolver/AstapPlateSolver.kt
index 65781b721..880be7af4 100644
--- a/nebulosa-astap/src/main/kotlin/nebulosa/astap/platesolver/AstapPlateSolver.kt
+++ b/nebulosa-astap/src/main/kotlin/nebulosa/astap/platesolver/AstapPlateSolver.kt
@@ -1,7 +1,5 @@
 package nebulosa.astap.platesolver
 
-import nebulosa.common.concurrency.cancel.CancellationToken
-import nebulosa.common.exec.commandLine
 import nebulosa.fits.FitsHeader
 import nebulosa.fits.FitsKeyword
 import nebulosa.image.Image
@@ -13,6 +11,8 @@ import nebulosa.math.toHours
 import nebulosa.platesolver.PlateSolution
 import nebulosa.platesolver.PlateSolver
 import nebulosa.platesolver.PlateSolverException
+import nebulosa.util.concurrency.cancellation.CancellationToken
+import nebulosa.util.exec.commandLine
 import java.nio.file.Files
 import java.nio.file.Path
 import java.nio.file.Paths
diff --git a/nebulosa-astap/src/main/kotlin/nebulosa/astap/stardetector/AstapStarDetector.kt b/nebulosa-astap/src/main/kotlin/nebulosa/astap/stardetector/AstapStarDetector.kt
index aab444e58..4a276e89c 100644
--- a/nebulosa-astap/src/main/kotlin/nebulosa/astap/stardetector/AstapStarDetector.kt
+++ b/nebulosa-astap/src/main/kotlin/nebulosa/astap/stardetector/AstapStarDetector.kt
@@ -2,10 +2,10 @@ package nebulosa.astap.stardetector
 
 import de.siegmar.fastcsv.reader.CommentStrategy
 import de.siegmar.fastcsv.reader.CsvReader
-import nebulosa.common.exec.commandLine
 import nebulosa.log.loggerFor
 import nebulosa.stardetector.StarDetector
 import nebulosa.stardetector.StarPoint
+import nebulosa.util.exec.commandLine
 import java.io.InputStreamReader
 import java.nio.file.Path
 import kotlin.io.path.deleteIfExists
@@ -38,7 +38,7 @@ data class AstapStarDetector(
 
         try {
             cmd.start()
-            LOG.info("astap exited. code={}", cmd.get())
+            LOG.debug("astap exited. code={}", cmd.get())
         } catch (e: Throwable) {
             LOG.error("astap failed", e)
             return emptyList()
diff --git a/nebulosa-astrometrynet-jna/src/main/kotlin/nebulosa/astrometrynet/platesolver/LibAstrometryNetPlateSolver.kt b/nebulosa-astrometrynet-jna/src/main/kotlin/nebulosa/astrometrynet/platesolver/LibAstrometryNetPlateSolver.kt
index 37919f1cc..7db19d419 100644
--- a/nebulosa-astrometrynet-jna/src/main/kotlin/nebulosa/astrometrynet/platesolver/LibAstrometryNetPlateSolver.kt
+++ b/nebulosa-astrometrynet-jna/src/main/kotlin/nebulosa/astrometrynet/platesolver/LibAstrometryNetPlateSolver.kt
@@ -1,10 +1,10 @@
 package nebulosa.astrometrynet.platesolver
 
-import nebulosa.common.concurrency.cancel.CancellationToken
 import nebulosa.image.Image
 import nebulosa.math.Angle
 import nebulosa.platesolver.PlateSolution
 import nebulosa.platesolver.PlateSolver
+import nebulosa.util.concurrency.cancellation.CancellationToken
 import java.nio.file.Path
 import java.time.Duration
 
diff --git a/nebulosa-astrometrynet/build.gradle.kts b/nebulosa-astrometrynet/build.gradle.kts
index ea387d9c4..61aa6e3b8 100644
--- a/nebulosa-astrometrynet/build.gradle.kts
+++ b/nebulosa-astrometrynet/build.gradle.kts
@@ -5,9 +5,9 @@ plugins {
 
 dependencies {
     api(project(":nebulosa-math"))
-    api(project(":nebulosa-common"))
     api(project(":nebulosa-platesolver"))
     api(project(":nebulosa-retrofit"))
+    api(project(":nebulosa-util"))
     implementation(project(":nebulosa-log"))
     testImplementation(project(":nebulosa-test"))
 }
diff --git a/nebulosa-astrometrynet/src/main/kotlin/nebulosa/astrometrynet/nova/NovaAstrometryNetService.kt b/nebulosa-astrometrynet/src/main/kotlin/nebulosa/astrometrynet/nova/NovaAstrometryNetService.kt
index b3cf6590e..9162d0ff7 100644
--- a/nebulosa-astrometrynet/src/main/kotlin/nebulosa/astrometrynet/nova/NovaAstrometryNetService.kt
+++ b/nebulosa-astrometrynet/src/main/kotlin/nebulosa/astrometrynet/nova/NovaAstrometryNetService.kt
@@ -26,20 +26,20 @@ class NovaAstrometryNetService(
 
     fun login(apiKey: String): Call<Session> {
         return FormBody.Builder()
-            .add("request-json", jsonMapper.writeValueAsString(mapOf("apikey" to apiKey)))
+            .add("request-json", objectMapper.writeValueAsString(mapOf("apikey" to apiKey)))
             .build()
             .let(service::login)
     }
 
     fun uploadFromUrl(upload: Upload): Call<Submission> {
         return FormBody.Builder()
-            .add("request-json", jsonMapper.writeValueAsString(upload))
+            .add("request-json", objectMapper.writeValueAsString(upload))
             .build()
             .let(service::uploadFromUrl)
     }
 
     fun uploadFromFile(path: Path, upload: Upload): Call<Submission> {
-        val requestJsonBody = jsonMapper.writeValueAsBytes(upload).toRequestBody(TEXT_PLAIN_MEDIA_TYPE)
+        val requestJsonBody = objectMapper.writeValueAsBytes(upload).toRequestBody(TEXT_PLAIN_MEDIA_TYPE)
 
         val fileName = "%s.%s".format(UUID.randomUUID(), path.extension)
         val fileBody = path.toFile().asRequestBody(OCTET_STREAM_MEDIA_TYPE)
@@ -54,7 +54,7 @@ class NovaAstrometryNetService(
     }
 
     fun uploadFromImage(image: Image, upload: Upload): Call<Submission> {
-        val requestJsonBody = jsonMapper.writeValueAsBytes(upload).toRequestBody(TEXT_PLAIN_MEDIA_TYPE)
+        val requestJsonBody = objectMapper.writeValueAsBytes(upload).toRequestBody(TEXT_PLAIN_MEDIA_TYPE)
 
         val fileName = "%s.fits".format(UUID.randomUUID())
         val fileBody = object : RequestBody() {
diff --git a/nebulosa-astrometrynet/src/main/kotlin/nebulosa/astrometrynet/platesolver/LocalAstrometryNetPlateSolver.kt b/nebulosa-astrometrynet/src/main/kotlin/nebulosa/astrometrynet/platesolver/LocalAstrometryNetPlateSolver.kt
index 03b14705e..f0da0f98b 100644
--- a/nebulosa-astrometrynet/src/main/kotlin/nebulosa/astrometrynet/platesolver/LocalAstrometryNetPlateSolver.kt
+++ b/nebulosa-astrometrynet/src/main/kotlin/nebulosa/astrometrynet/platesolver/LocalAstrometryNetPlateSolver.kt
@@ -1,13 +1,13 @@
 package nebulosa.astrometrynet.platesolver
 
-import nebulosa.common.concurrency.cancel.CancellationToken
-import nebulosa.common.exec.CommandLineListener
-import nebulosa.common.exec.commandLine
 import nebulosa.image.Image
 import nebulosa.log.loggerFor
 import nebulosa.math.*
 import nebulosa.platesolver.PlateSolution
 import nebulosa.platesolver.PlateSolver
+import nebulosa.util.concurrency.cancellation.CancellationToken
+import nebulosa.util.exec.CommandLineListener
+import nebulosa.util.exec.commandLine
 import java.nio.file.Files
 import java.nio.file.Path
 import java.time.Duration
diff --git a/nebulosa-astrometrynet/src/main/kotlin/nebulosa/astrometrynet/platesolver/NovaAstrometryNetPlateSolver.kt b/nebulosa-astrometrynet/src/main/kotlin/nebulosa/astrometrynet/platesolver/NovaAstrometryNetPlateSolver.kt
index ace5f2ad4..2b2b77293 100644
--- a/nebulosa-astrometrynet/src/main/kotlin/nebulosa/astrometrynet/platesolver/NovaAstrometryNetPlateSolver.kt
+++ b/nebulosa-astrometrynet/src/main/kotlin/nebulosa/astrometrynet/platesolver/NovaAstrometryNetPlateSolver.kt
@@ -4,7 +4,6 @@ import nebulosa.astrometrynet.nova.NovaAstrometryNetService
 import nebulosa.astrometrynet.nova.NovaAstrometryNetService.Companion.ANONYMOUS_API_KEY
 import nebulosa.astrometrynet.nova.Session
 import nebulosa.astrometrynet.nova.Upload
-import nebulosa.common.concurrency.cancel.CancellationToken
 import nebulosa.fits.FitsHeader
 import nebulosa.image.Image
 import nebulosa.log.loggerFor
@@ -13,6 +12,7 @@ import nebulosa.math.toDegrees
 import nebulosa.platesolver.PlateSolution
 import nebulosa.platesolver.PlateSolver
 import nebulosa.platesolver.PlateSolverException
+import nebulosa.util.concurrency.cancellation.CancellationToken
 import java.nio.file.Path
 import java.time.Duration
 
diff --git a/nebulosa-autofocus/build.gradle.kts b/nebulosa-autofocus/build.gradle.kts
new file mode 100644
index 000000000..6703ef12f
--- /dev/null
+++ b/nebulosa-autofocus/build.gradle.kts
@@ -0,0 +1,20 @@
+plugins {
+    kotlin("jvm")
+    id("maven-publish")
+}
+
+dependencies {
+    api(project(":nebulosa-curve-fitting"))
+    api(project(":nebulosa-image"))
+    api(project(":nebulosa-stardetector"))
+    implementation(project(":nebulosa-log"))
+    testImplementation(project(":nebulosa-test"))
+}
+
+publishing {
+    publications {
+        create<MavenPublication>("pluginMaven") {
+            from(components["java"])
+        }
+    }
+}
diff --git a/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocus.kt b/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocus.kt
new file mode 100644
index 000000000..a97294767
--- /dev/null
+++ b/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocus.kt
@@ -0,0 +1,432 @@
+package nebulosa.autofocus
+
+import nebulosa.curve.fitting.CurvePoint
+import nebulosa.curve.fitting.CurvePoint.Companion.midPoint
+import nebulosa.curve.fitting.HyperbolicFitting
+import nebulosa.curve.fitting.QuadraticFitting
+import nebulosa.curve.fitting.TrendLineFitting
+import nebulosa.log.loggerFor
+import nebulosa.stardetector.StarDetector
+import nebulosa.stardetector.StarPoint
+import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics
+import java.nio.file.Path
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.math.roundToInt
+
+data class AutoFocus(
+    private val starDetector: StarDetector<Path>,
+    private val exposureAmount: Int = 5,
+    private val initialOffsetSteps: Int = 4,
+    private val stepSize: Int = 50,
+    private val fittingMode: AutoFocusFittingMode = AutoFocusFittingMode.TREND_HYPERBOLIC,
+    private val rSquaredThreshold: Double = 0.0,
+    private val reverse: Boolean = false,
+    private val focusMaxPosition: Int = Int.MAX_VALUE,
+) {
+
+    // TODO: Usar sealed class e remover substate e algumas variáveis como moveFocuserToLeftmostOrRightmost.
+    private enum class State {
+        IDLE,
+        FOCUS_POINTS,
+        EVALUATE_TREND_LINE_POINTS,
+        MORE_POINTS_TO_THE_LEFT,
+        MORE_POINTS_TO_THE_RIGHT,
+        VERIFY_DATA_IS_ENOUGTH,
+        DETERMINATE_FINAL_FOCUS_POINT,
+    }
+
+    private enum class SubState {
+        IDLE,
+        MOVE_FOCUSER,
+        TAKE_EXPOSURE,
+    }
+
+    private val direction = if (reverse) -1 else 1
+    private val numberOfSteps = initialOffsetSteps + 1
+    private val measurements = ArrayList<MeasuredStars>(exposureAmount)
+    private val maximumFocusPoints = exposureAmount * initialOffsetSteps * 10
+    private val focusPoints = ArrayList<CurvePoint>(maximumFocusPoints)
+    private val listeners = ConcurrentHashMap.newKeySet<AutoFocusListener>(1)
+
+    @Volatile private var subState = SubState.IDLE
+    @Volatile private var prevState = State.IDLE
+    @Volatile private var state = State.IDLE
+        private set(value) {
+            prevState = field
+            field = value
+        }
+
+    @Volatile private var measurement = MeasuredStars.EMPTY
+    @Volatile private var exposureCount = 0
+    @Volatile private var remainingSteps = 0
+    @Volatile private var initialFocusPosition = 0
+    @Volatile private var currentFocusPosition = 0
+    @Volatile private var moveFocuserToLeftmostOrRightmost = false
+
+    @Volatile private var trendLineCurve: TrendLineFitting.Curve? = null
+    @Volatile private var parabolicCurve: QuadraticFitting.Curve? = null
+    @Volatile private var hyperbolicCurve: HyperbolicFitting.Curve? = null
+    @Volatile private var leftCount = 0
+    @Volatile private var rightCount = 0
+
+    @Volatile var determinedFocusPoint: CurvePoint? = null
+        private set
+
+    private val isDataPointsEnough
+        get() = trendLineCurve != null && (rightCount + focusPoints.count { it.x > trendLineCurve!!.minimum.x && it.y == 0.0 } >= initialOffsetSteps && leftCount + focusPoints.count { it.x < trendLineCurve!!.minimum.x && it.y == 0.0 } >= initialOffsetSteps)
+
+    fun registerAutoFocusListener(listener: AutoFocusListener) {
+        listeners.add(listener)
+    }
+
+    fun unregisterAutoFocusListener(listener: AutoFocusListener) {
+        listeners.remove(listener)
+    }
+
+    fun add(path: Path) {
+        if (exposureCount > 0) {
+            exposureCount--
+            LOG.debug("added. path={}, exposureCount={}", path, exposureCount)
+            measurement = measureStars(path)
+
+            if (exposureCount == 0) {
+                measurement = evaluateAllMeasurements()
+            }
+        }
+    }
+
+    fun reset() {
+        subState = SubState.IDLE
+        state = State.IDLE
+        prevState = State.IDLE
+
+        measurement = MeasuredStars.EMPTY
+        exposureCount = 0
+        remainingSteps = 0
+        initialFocusPosition = 0
+        currentFocusPosition = 0
+        moveFocuserToLeftmostOrRightmost = false
+
+        trendLineCurve = null
+        parabolicCurve = null
+        hyperbolicCurve = null
+        leftCount = 0
+        rightCount = 0
+    }
+
+    fun determinate(focusPosition: Int): AutoFocusResult {
+        LOG.debug("determinate. position={}, state={}, subState={}, prevState={}", focusPosition, state, subState, prevState)
+
+        when (state) {
+            // Estado inicial.
+            State.IDLE -> {
+                // Salva a posição inicial do focalizador, para que possa voltar caso algo dê errado.
+                initialFocusPosition = focusPosition
+
+                // Iniciar a coleta dos pontos de foco.
+                state = State.FOCUS_POINTS
+                remainingSteps = numberOfSteps
+                // Próxima passo é mover o focalizador para a posição mais distante.
+                return moveFocuser(direction * initialOffsetSteps * stepSize, true)
+            }
+            // Estado para obter os pontos de foco e calcular a curva.
+            State.FOCUS_POINTS -> {
+                // Ainda não terminou de capturar todos os pontos de foco necessário.
+                if (remainingSteps > 0) {
+                    // Terminou de mover o focalizador.
+                    if (subState == SubState.MOVE_FOCUSER) {
+                        currentFocusPosition = focusPosition
+                        return takeExposure()
+                    }
+                    // Ainda não terminou a captura.
+                    else if (exposureCount > 0) {
+                        return takeExposure()
+                    }
+                    // Fim da captura.
+                    else if (exposureCount == 0) {
+                        LOG.debug("HFD measured after exposures. hfd={}, stdDev={}", measurement.hfd, measurement.stdDev)
+
+                        computeCurvePoint()
+
+                        // Continua a mover o focalizador.
+                        if (remainingSteps-- > 1) {
+                            return moveFocuser(direction * -stepSize, true)
+                        }
+
+                        state = State.EVALUATE_TREND_LINE_POINTS
+                        subState = SubState.IDLE
+
+                        return AutoFocusResult.Determinate
+                    }
+                }
+            }
+            State.EVALUATE_TREND_LINE_POINTS -> {
+                leftCount = trendLineCurve?.left?.points?.size ?: 0
+                rightCount = trendLineCurve?.right?.points?.size ?: 0
+
+                LOG.debug("trend line evaluated. left={}, right={}", leftCount, rightCount)
+
+                if (leftCount == 0 && rightCount == 0) {
+                    LOG.warn("Not enought spreaded points")
+                    return AutoFocusResult.Failed(initialFocusPosition)
+                }
+
+                // Let's keep moving in, one step at a time, until we have enough left trend points.
+                // Then we can think about moving out to fill in the right trend points.
+                if (trendLineCurve!!.left.points.size < initialOffsetSteps
+                    && focusPoints.count { it.x < trendLineCurve!!.minimum.x && it.y == 0.0 } < initialOffsetSteps
+                ) {
+                    LOG.debug("more data points needed to the left of the minimum")
+
+                    state = State.MORE_POINTS_TO_THE_LEFT
+
+                    val firstX = focusPoints.first().x.roundToInt()
+
+                    // Move to the leftmost point - this should never be necessary since we're already there, but just in case
+                    if (focusPosition != firstX) {
+                        moveFocuserToLeftmostOrRightmost = true
+                        return moveFocuser(firstX, false)
+                    }
+
+                    // More points needed to the left.
+                    return moveFocuser(direction * -stepSize, true)
+                } else if (trendLineCurve!!.right.points.size < initialOffsetSteps
+                    && focusPoints.count { it.x > trendLineCurve!!.minimum.x && it.y == 0.0 } < initialOffsetSteps
+                ) {
+                    // Now we can go to the right, if necessary.
+                    LOG.debug("more data points needed to the right of the minimum")
+
+                    state = State.MORE_POINTS_TO_THE_RIGHT
+
+                    val lastX = focusPoints.last().x.roundToInt()
+
+                    // More points needed to the right. Let's get to the rightmost point, and keep going right one point at a time.
+                    if (focusPosition != lastX) {
+                        moveFocuserToLeftmostOrRightmost = true
+                        return moveFocuser(lastX, false)
+                    }
+
+                    // More points needed to the right.
+                    return moveFocuser(direction * stepSize, true)
+                }
+
+                state = State.DETERMINATE_FINAL_FOCUS_POINT
+                return AutoFocusResult.Determinate
+            }
+            State.MORE_POINTS_TO_THE_LEFT -> {
+                // Terminou de mover o focalizador.
+                if (moveFocuserToLeftmostOrRightmost) {
+                    moveFocuserToLeftmostOrRightmost = false
+                    // More points needed to the left.
+                    return moveFocuser(direction * -stepSize, true)
+                } else if (subState == SubState.MOVE_FOCUSER) {
+                    currentFocusPosition = focusPosition
+                    return takeExposure()
+                }
+                // Ainda não terminou a captura.
+                else if (exposureCount > 0) {
+                    return takeExposure()
+                }
+                // Fim da captura.
+                else if (exposureCount == 0) {
+                    state = State.VERIFY_DATA_IS_ENOUGTH
+                    return AutoFocusResult.Determinate
+                }
+            }
+            State.MORE_POINTS_TO_THE_RIGHT -> {
+                // Terminou de mover o focalizador.
+                if (moveFocuserToLeftmostOrRightmost) {
+                    moveFocuserToLeftmostOrRightmost = false
+                    // More points needed to the right.
+                    return moveFocuser(direction * stepSize, true)
+                } else if (subState == SubState.MOVE_FOCUSER) {
+                    currentFocusPosition = focusPosition
+                    return takeExposure()
+                }
+                // Ainda não terminou a captura.
+                else if (exposureCount > 0) {
+                    return takeExposure()
+                }
+                // Fim da captura.
+                else if (exposureCount == 0) {
+                    state = State.VERIFY_DATA_IS_ENOUGTH
+                    return AutoFocusResult.Determinate
+                }
+            }
+            State.VERIFY_DATA_IS_ENOUGTH -> {
+                LOG.debug("HFD measured after exposures. hfd={}, stdDev={}", measurement.hfd, measurement.stdDev)
+
+                computeCurvePoint()
+
+                if (maximumFocusPoints < focusPoints.size) {
+                    // Break out when the maximum limit of focus points is reached
+                    LOG.error("failed to complete. Maximum number of focus points exceeded ({}).", maximumFocusPoints)
+                    return AutoFocusResult.Failed(initialFocusPosition)
+                }
+
+                if (focusPosition <= 0 || focusPosition >= focusMaxPosition) {
+                    // Break out when the focuser hits the min/max position. It can't continue from there.
+                    LOG.error("failed to complete. position reached to min/max")
+                    return AutoFocusResult.Failed(initialFocusPosition)
+                }
+
+                state = if (isDataPointsEnough) {
+                    State.DETERMINATE_FINAL_FOCUS_POINT
+                } else {
+                    subState = SubState.IDLE
+                    State.EVALUATE_TREND_LINE_POINTS
+                }
+
+                return AutoFocusResult.Determinate
+            }
+            State.DETERMINATE_FINAL_FOCUS_POINT -> {
+                val finalFocusPoint = determineFinalFocusPoint()
+
+                return if (finalFocusPoint == null || !validateCalculatedFocusPosition(finalFocusPoint)) {
+                    LOG.warn("potentially bad auto-focus. Restoring original focus position")
+                    AutoFocusResult.Failed(initialFocusPosition)
+                } else {
+                    determinedFocusPoint = finalFocusPoint
+                    LOG.info("Auto Focus completed. x={}, y={}", finalFocusPoint.x, finalFocusPoint.y)
+                    AutoFocusResult.Completed(finalFocusPoint)
+                }
+            }
+        }
+
+        LOG.warn("invalid state. state={}, subState={}, exposureCount={}", state, subState, exposureCount)
+
+        throw IllegalStateException("auto focus has reached an invalid state")
+    }
+
+    private fun moveFocuser(position: Int, relative: Boolean): AutoFocusResult {
+        subState = SubState.MOVE_FOCUSER
+        LOG.debug("moving focuser. position={}, relative={}", position, relative)
+        return AutoFocusResult.MoveFocuser(position, relative)
+    }
+
+    private fun takeExposure(): AutoFocusResult {
+        // Inicia-se a sequência de capturas.
+        if (exposureCount <= 0) {
+            measurements.clear()
+            exposureCount = exposureAmount
+        }
+
+        subState = SubState.TAKE_EXPOSURE
+        LOG.debug("taking exposure. exposureCount={}", exposureCount)
+        return AutoFocusResult.TakeExposure
+    }
+
+    private fun measureStars(path: Path): MeasuredStars {
+        val detectedStars = starDetector.detect(path)
+        LOG.debug("detected {} stars", detectedStars.size)
+        val measurement = detectedStars.measureDetectedStars()
+        LOG.debug("HFD measured. hfd={}, stdDev={}", measurement.hfd, measurement.stdDev)
+        measurements.add(measurement)
+        listeners.forEach { it.onStarDetected(detectedStars.size, measurement.hfd, measurement.stdDev, false) }
+        return measurement
+    }
+
+    private fun evaluateAllMeasurements(): MeasuredStars {
+        if (measurements.isEmpty()) MeasuredStars.EMPTY
+        if (measurements.size == 1) return measurements[0]
+        val descriptiveStatistics = DescriptiveStatistics(measurements.size)
+        measurements.forEach { descriptiveStatistics.addValue(it.hfd) }
+        val stdDev = descriptiveStatistics.standardDeviation
+        val starCount = measurements.sumOf { it.count } / measurements.size
+        listeners.forEach { it.onStarDetected(starCount, descriptiveStatistics.mean, stdDev, true) }
+        return MeasuredStars(starCount, descriptiveStatistics.mean, if (stdDev > 0.0) stdDev else 1.0)
+    }
+
+    private fun computeCurvePoint(): CurvePoint? {
+        return if (measurement.hfd == 0.0) {
+            LOG.warn("no stars detected in step")
+            null
+        } else {
+            val focusPoint = CurvePoint(currentFocusPosition.toDouble(), measurement.hfd, measurement.stdDev)
+            focusPoints.add(focusPoint)
+            focusPoints.sortBy { it.x }
+
+            LOG.debug("focus point added. remainingSteps={}, point={}", remainingSteps, focusPoint)
+
+            computeCurveFittings()
+
+            focusPoint
+        }
+    }
+
+    private fun computeCurveFittings() {
+        with(focusPoints) {
+            trendLineCurve = TrendLineFitting.calculate(this)
+
+            if (size >= 3) {
+                if (fittingMode == AutoFocusFittingMode.PARABOLIC || fittingMode == AutoFocusFittingMode.TREND_PARABOLIC) {
+                    parabolicCurve = QuadraticFitting.calculate(this)
+                } else if (fittingMode == AutoFocusFittingMode.HYPERBOLIC || fittingMode == AutoFocusFittingMode.TREND_HYPERBOLIC) {
+                    hyperbolicCurve = HyperbolicFitting.calculate(this)
+                }
+            }
+
+            val predictedFocusPoint = determinedFocusPoint ?: determineFinalFocusPoint()
+            val (minX, minY) = if (isEmpty()) CurvePoint.ZERO else first()
+            val (maxX, maxY) = if (isEmpty()) CurvePoint.ZERO else last()
+
+            listeners.forEach { it.onCurveFitted(predictedFocusPoint, minX, minY, maxX, maxY, trendLineCurve, parabolicCurve, hyperbolicCurve) }
+        }
+    }
+
+    private fun determineFinalFocusPoint(): CurvePoint? {
+        return when (fittingMode) {
+            AutoFocusFittingMode.TRENDLINES -> trendLineCurve?.intersection
+            AutoFocusFittingMode.PARABOLIC -> parabolicCurve?.minimum
+            AutoFocusFittingMode.TREND_PARABOLIC -> parabolicCurve?.minimum?.midPoint(trendLineCurve!!.intersection)
+            AutoFocusFittingMode.HYPERBOLIC -> hyperbolicCurve?.minimum
+            AutoFocusFittingMode.TREND_HYPERBOLIC -> hyperbolicCurve?.minimum?.midPoint(trendLineCurve!!.intersection)
+        }
+    }
+
+    private fun validateCalculatedFocusPosition(focusPoint: CurvePoint): Boolean {
+        LOG.debug("validating calculated focus position. threshold={}, x={}, y={}", rSquaredThreshold, focusPoint.x, focusPoint.y)
+
+        if (rSquaredThreshold > 0.0) {
+            fun isTrendLineBad() = trendLineCurve?.let { it.left.rSquared < rSquaredThreshold || it.right.rSquared < rSquaredThreshold } != false
+            fun isParabolicBad() = parabolicCurve?.let { it.rSquared < rSquaredThreshold } != false
+            fun isHyperbolicBad() = hyperbolicCurve?.let { it.rSquared < rSquaredThreshold } != false
+
+            val isBad = when (fittingMode) {
+                AutoFocusFittingMode.TRENDLINES -> isTrendLineBad()
+                AutoFocusFittingMode.PARABOLIC -> isParabolicBad()
+                AutoFocusFittingMode.TREND_PARABOLIC -> isParabolicBad() || isTrendLineBad()
+                AutoFocusFittingMode.HYPERBOLIC -> isHyperbolicBad()
+                AutoFocusFittingMode.TREND_HYPERBOLIC -> isHyperbolicBad() || isTrendLineBad()
+            }
+
+            if (isBad) {
+                LOG.error("coefficient of determination is below threshold")
+                return false
+            }
+        }
+
+        val min = focusPoints.first().x
+        val max = focusPoints.last().x
+
+        if (focusPoint.x < min || focusPoint.x > max) {
+            LOG.error("determined focus point position is outside of the overall measurement points of the curve")
+            return false
+        }
+
+        return true
+    }
+
+    companion object {
+
+        @JvmStatic private val LOG = loggerFor<AutoFocus>()
+
+        private fun List<StarPoint>.measureDetectedStars(): MeasuredStars {
+            if (isEmpty()) return MeasuredStars.EMPTY
+            val descriptiveStatistics = DescriptiveStatistics(size)
+            forEach { descriptiveStatistics.addValue(it.hfd) }
+            val stdDev = descriptiveStatistics.standardDeviation
+            return MeasuredStars(size, descriptiveStatistics.mean, if (stdDev > 0.0) stdDev else 1.0)
+        }
+    }
+}
diff --git a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusFittingMode.kt b/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocusFittingMode.kt
similarity index 80%
rename from api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusFittingMode.kt
rename to nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocusFittingMode.kt
index ea43d243a..9eeb12f53 100644
--- a/api/src/main/kotlin/nebulosa/api/autofocus/AutoFocusFittingMode.kt
+++ b/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocusFittingMode.kt
@@ -1,4 +1,4 @@
-package nebulosa.api.autofocus
+package nebulosa.autofocus
 
 enum class AutoFocusFittingMode {
     TRENDLINES,
diff --git a/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocusListener.kt b/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocusListener.kt
new file mode 100644
index 000000000..0dc419304
--- /dev/null
+++ b/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocusListener.kt
@@ -0,0 +1,16 @@
+package nebulosa.autofocus
+
+import nebulosa.curve.fitting.CurvePoint
+import nebulosa.curve.fitting.HyperbolicFitting
+import nebulosa.curve.fitting.QuadraticFitting
+import nebulosa.curve.fitting.TrendLineFitting
+
+interface AutoFocusListener {
+
+    fun onStarDetected(count: Int, hfd: Double, stdDev: Double, afterExposures: Boolean)
+
+    fun onCurveFitted(
+        predictedFocusPoint: CurvePoint?, minX: Double, minY: Double, maxX: Double, maxY: Double,
+        trendLine: TrendLineFitting.Curve?, parabolic: QuadraticFitting.Curve?, hyperbolic: HyperbolicFitting.Curve?
+    )
+}
diff --git a/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocusResult.kt b/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocusResult.kt
new file mode 100644
index 000000000..b722d4791
--- /dev/null
+++ b/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/AutoFocusResult.kt
@@ -0,0 +1,31 @@
+package nebulosa.autofocus
+
+import nebulosa.curve.fitting.CurvePoint
+
+sealed interface AutoFocusResult {
+
+    /**
+     * Should take a exposure.
+     */
+    data object TakeExposure : AutoFocusResult
+
+    /**
+     * Should move the focuser to [position], [relative] or not.
+     */
+    data class MoveFocuser(@JvmField val position: Int, @JvmField val relative: Boolean) : AutoFocusResult
+
+    /**
+     * Should call [AutoFocus.determinate] method again.
+     */
+    data object Determinate : AutoFocusResult
+
+    /**
+     * Auto Focus can not be determinated because it failed.
+     */
+    data class Failed(@JvmField val initialFocusPosition: Int) : AutoFocusResult
+
+    /**
+     * Auto Focus finished with success.
+     */
+    data class Completed(@JvmField val determinedFocusPoint: CurvePoint) : AutoFocusResult
+}
diff --git a/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/MeasuredStars.kt b/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/MeasuredStars.kt
new file mode 100644
index 000000000..f0f2bfcb3
--- /dev/null
+++ b/nebulosa-autofocus/src/main/kotlin/nebulosa/autofocus/MeasuredStars.kt
@@ -0,0 +1,13 @@
+package nebulosa.autofocus
+
+data class MeasuredStars(
+    @JvmField val count: Int,
+    @JvmField val hfd: Double,
+    @JvmField val stdDev: Double,
+) {
+
+    companion object {
+
+        @JvmStatic val EMPTY = MeasuredStars(0, 0.0, 0.0)
+    }
+}
diff --git a/nebulosa-autofocus/src/test/kotlin/AutoFocusTest.kt b/nebulosa-autofocus/src/test/kotlin/AutoFocusTest.kt
new file mode 100644
index 000000000..399bb8c5c
--- /dev/null
+++ b/nebulosa-autofocus/src/test/kotlin/AutoFocusTest.kt
@@ -0,0 +1,115 @@
+import io.kotest.matchers.ints.shouldBeExactly
+import io.kotest.matchers.nulls.shouldNotBeNull
+import nebulosa.autofocus.AutoFocus
+import nebulosa.autofocus.AutoFocusFittingMode
+import nebulosa.autofocus.AutoFocusFittingMode.*
+import nebulosa.autofocus.AutoFocusResult
+import nebulosa.curve.fitting.CurvePoint
+import nebulosa.stardetector.StarDetector
+import nebulosa.stardetector.StarPoint
+import nebulosa.test.*
+import org.junit.jupiter.api.Test
+import java.nio.file.Path
+import kotlin.math.cosh
+import kotlin.math.ln
+import kotlin.math.max
+import kotlin.math.roundToInt
+
+class AutoFocusTest : AbstractTest() {
+
+    @Test
+    fun trendHyperbolic() {
+        executeAutoFocus().shouldNotBeNull().x.roundToInt() shouldBeExactly 798
+        executeAutoFocus(700).shouldNotBeNull().x.roundToInt() shouldBeExactly 800
+        executeAutoFocus(1200).shouldNotBeNull().x.roundToInt() shouldBeExactly 798
+        executeAutoFocus(exposureAmount = 3).shouldNotBeNull().x.roundToInt() shouldBeExactly 798
+    }
+
+    @Test
+    fun trendParabolic() {
+        executeAutoFocus(fittingMode = TREND_PARABOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 807
+        executeAutoFocus(700, fittingMode = TREND_PARABOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 800
+        executeAutoFocus(1200, fittingMode = TREND_PARABOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 805
+        executeAutoFocus(exposureAmount = 3, fittingMode = TREND_PARABOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 807
+    }
+
+    @Test
+    fun trendlines() {
+        executeAutoFocus(fittingMode = TRENDLINES).shouldNotBeNull().x.roundToInt() shouldBeExactly 800
+        executeAutoFocus(700, fittingMode = TRENDLINES).shouldNotBeNull().x.roundToInt() shouldBeExactly 800
+        executeAutoFocus(1200, fittingMode = TRENDLINES).shouldNotBeNull().x.roundToInt() shouldBeExactly 800
+        executeAutoFocus(exposureAmount = 3, fittingMode = TRENDLINES).shouldNotBeNull().x.roundToInt() shouldBeExactly 800
+    }
+
+    @Test
+    fun hyperbolic() {
+        executeAutoFocus(fittingMode = HYPERBOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 796
+        executeAutoFocus(700, fittingMode = HYPERBOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 800
+        executeAutoFocus(1200, fittingMode = HYPERBOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 795
+        executeAutoFocus(exposureAmount = 3, fittingMode = HYPERBOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 796
+    }
+
+    @Test
+    fun parabolic() {
+        executeAutoFocus(fittingMode = PARABOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 814
+        executeAutoFocus(700, fittingMode = PARABOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 800
+        executeAutoFocus(1200, fittingMode = PARABOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 809
+        executeAutoFocus(exposureAmount = 3, fittingMode = PARABOLIC).shouldNotBeNull().x.roundToInt() shouldBeExactly 814
+    }
+
+    private data class DetectedStar(
+        override val hfd: Double,
+        override val x: Double = 0.0, override val y: Double = 0.0,
+        override val snr: Double = 0.0, override val flux: Double = 0.0,
+    ) : StarPoint
+
+    private data class HyperbolicStarDetector(private val offset: Int = 8) : StarDetector<Path> {
+
+        override fun detect(input: Path): List<StarPoint> {
+            val index = STAR_FOCUS_LIST.indexOf(input)
+            val hfd = max(1.0, ln(cosh(((index - offset) * 2).toDouble())))
+            return listOf(DetectedStar(hfd))
+        }
+    }
+
+    companion object {
+
+        @JvmStatic val STAR_FOCUS_LIST = listOf(
+            STAR_FOCUS_1, STAR_FOCUS_2, STAR_FOCUS_3, STAR_FOCUS_4, STAR_FOCUS_5,
+            STAR_FOCUS_6, STAR_FOCUS_7, STAR_FOCUS_8, STAR_FOCUS_9, STAR_FOCUS_10,
+            STAR_FOCUS_11, STAR_FOCUS_12, STAR_FOCUS_13, STAR_FOCUS_14, STAR_FOCUS_15,
+            STAR_FOCUS_16, STAR_FOCUS_17,
+        )
+
+        @JvmStatic
+        private fun executeAutoFocus(
+            initialFocusPosition: Int = 1000,
+            exposureAmount: Int = 1,
+            initialOffsetSteps: Int = 4,
+            stepSize: Int = 100,
+            fittingMode: AutoFocusFittingMode = TREND_HYPERBOLIC,
+            rSquaredThreshold: Double = 0.0,
+            reverse: Boolean = false,
+        ): CurvePoint? {
+            val autoFocus =
+                AutoFocus(HyperbolicStarDetector(), exposureAmount, initialOffsetSteps, stepSize, fittingMode, rSquaredThreshold, reverse, 16000)
+
+            var focusPosition = initialFocusPosition
+            var focusPoint: CurvePoint? = null
+
+            while (focusPoint == null) {
+                when (val result = autoFocus.determinate(focusPosition)) {
+                    AutoFocusResult.Determinate -> continue
+                    is AutoFocusResult.MoveFocuser -> focusPosition = if (result.relative) focusPosition + result.position else result.position
+                    AutoFocusResult.TakeExposure -> autoFocus.add(STAR_FOCUS_LIST[focusPosition / 100])
+                    is AutoFocusResult.Completed -> focusPoint = result.determinedFocusPoint
+                    is AutoFocusResult.Failed -> break
+                }
+
+                // Thread.sleep(100)
+            }
+
+            return focusPoint
+        }
+    }
+}
diff --git a/nebulosa-fits/src/main/kotlin/nebulosa/fits/FitsHeader.kt b/nebulosa-fits/src/main/kotlin/nebulosa/fits/FitsHeader.kt
index 6be7004d0..464488576 100644
--- a/nebulosa-fits/src/main/kotlin/nebulosa/fits/FitsHeader.kt
+++ b/nebulosa-fits/src/main/kotlin/nebulosa/fits/FitsHeader.kt
@@ -145,7 +145,7 @@ open class FitsHeader : AbstractHeader {
                     return true
                 }
 
-                LOG.warn("[${key.key}] with unexpected value type. Expected ${key.valueType}, got $type")
+                LOG.debug("[{}] with unexpected value type. Expected {}, got {}", key.key, key.valueType, type)
 
                 return false
             }
diff --git a/nebulosa-guiding-internal/build.gradle.kts b/nebulosa-guiding-internal/build.gradle.kts
index e2464b95d..765190908 100644
--- a/nebulosa-guiding-internal/build.gradle.kts
+++ b/nebulosa-guiding-internal/build.gradle.kts
@@ -4,10 +4,10 @@ plugins {
 }
 
 dependencies {
-    api(project(":nebulosa-common"))
     api(project(":nebulosa-math"))
     api(project(":nebulosa-image"))
     api(project(":nebulosa-guiding"))
+    api(project(":nebulosa-util"))
     implementation(project(":nebulosa-log"))
     testImplementation(project(":nebulosa-test"))
 }
diff --git a/nebulosa-guiding-internal/src/main/kotlin/nebulosa/guiding/internal/AxisStats.kt b/nebulosa-guiding-internal/src/main/kotlin/nebulosa/guiding/internal/AxisStats.kt
index 516b64d9a..e0a9f4173 100644
--- a/nebulosa-guiding-internal/src/main/kotlin/nebulosa/guiding/internal/AxisStats.kt
+++ b/nebulosa-guiding-internal/src/main/kotlin/nebulosa/guiding/internal/AxisStats.kt
@@ -75,7 +75,7 @@ internal open class AxisStats {
         get() = guidingEntries.size
 
     val lastEntry
-        get() = if (count > 0) guidingEntries.last!! else StarDisplacement.ZERO
+        get() = if (count > 0) guidingEntries.last() else StarDisplacement.ZERO
 
     /**
      * Adds a guiding info element of relative time,
diff --git a/nebulosa-guiding-internal/src/main/kotlin/nebulosa/guiding/internal/GuideGraph.kt b/nebulosa-guiding-internal/src/main/kotlin/nebulosa/guiding/internal/GuideGraph.kt
index f040cf0d4..af916c4af 100644
--- a/nebulosa-guiding-internal/src/main/kotlin/nebulosa/guiding/internal/GuideGraph.kt
+++ b/nebulosa-guiding-internal/src/main/kotlin/nebulosa/guiding/internal/GuideGraph.kt
@@ -42,7 +42,7 @@ internal class GuideGraph(
 
         // Update counter for osc index.
         if (nr >= 1) {
-            if (offset.mount.x * last.ra > 0.0) {
+            if (offset.mount.x * last().ra > 0.0) {
                 raSameSides++
             }
 
diff --git a/nebulosa-guiding-internal/src/main/kotlin/nebulosa/guiding/internal/WindowedAxisStats.kt b/nebulosa-guiding-internal/src/main/kotlin/nebulosa/guiding/internal/WindowedAxisStats.kt
index 2b75c6010..7d369424f 100644
--- a/nebulosa-guiding-internal/src/main/kotlin/nebulosa/guiding/internal/WindowedAxisStats.kt
+++ b/nebulosa-guiding-internal/src/main/kotlin/nebulosa/guiding/internal/WindowedAxisStats.kt
@@ -19,7 +19,7 @@ internal class WindowedAxisStats(private val autoWindowSize: Int = 0) : AxisStat
     fun removeOldestEntry() {
         if (count <= 0) return
 
-        val target = guidingEntries.first
+        val target = guidingEntries.first()
         val value = target.starPos
         val deltaTime = target.deltaTime
 
@@ -41,7 +41,7 @@ internal class WindowedAxisStats(private val autoWindowSize: Int = 0) : AxisStat
     }
 
     private fun adjustMinMaxValues() {
-        val target = guidingEntries.first
+        val target = guidingEntries.first()
         var recalNeeded = false
         var prev = target.starPos
 
diff --git a/nebulosa-guiding-phd2/src/main/kotlin/nebulosa/guiding/phd2/PHD2Guider.kt b/nebulosa-guiding-phd2/src/main/kotlin/nebulosa/guiding/phd2/PHD2Guider.kt
index 566bffd75..c206a11ad 100644
--- a/nebulosa-guiding-phd2/src/main/kotlin/nebulosa/guiding/phd2/PHD2Guider.kt
+++ b/nebulosa-guiding-phd2/src/main/kotlin/nebulosa/guiding/phd2/PHD2Guider.kt
@@ -1,7 +1,5 @@
 package nebulosa.guiding.phd2
 
-import nebulosa.common.concurrency.cancel.CancellationToken
-import nebulosa.common.concurrency.latch.CountUpDownLatch
 import nebulosa.guiding.*
 import nebulosa.log.debug
 import nebulosa.log.loggerFor
@@ -11,6 +9,7 @@ import nebulosa.phd2.client.PHD2Client
 import nebulosa.phd2.client.PHD2EventListener
 import nebulosa.phd2.client.commands.*
 import nebulosa.phd2.client.events.*
+import nebulosa.util.concurrency.latch.CountUpDownLatch
 
 class PHD2Guider(private val client: PHD2Client) : Guider, PHD2EventListener {
 
@@ -193,7 +192,7 @@ class PHD2Guider(private val client: PHD2Client) : Guider, PHD2EventListener {
         repeat(5) {
             try {
                 return client.sendCommandSync(GetLockPosition, 5)
-            } catch (ignored: Throwable) {
+            } catch (_: Throwable) {
                 Thread.sleep(5000)
             }
         }
@@ -208,7 +207,7 @@ class PHD2Guider(private val client: PHD2Client) : Guider, PHD2EventListener {
             client.sendCommandSync(command)
             refreshShiftLockParams()
             true
-        } catch (e: Throwable) {
+        } catch (_: Throwable) {
             false
         }
     }
@@ -234,16 +233,14 @@ class PHD2Guider(private val client: PHD2Client) : Guider, PHD2EventListener {
         }
     }
 
-    override fun waitForSettle(cancellationToken: CancellationToken) {
+    override fun waitForSettle() {
         try {
-            cancellationToken.listen(settling)
             settling.await(settleTimeout)
-        } catch (e: InterruptedException) {
+        } catch (_: InterruptedException) {
             LOG.warn("PHD2 did not send SettleDone message in expected time")
         } catch (e: Throwable) {
             LOG.warn("an error occurrs while waiting for settle done", e)
         } finally {
-            cancellationToken.unlisten(settling)
             settling.reset()
         }
     }
diff --git a/nebulosa-guiding/build.gradle.kts b/nebulosa-guiding/build.gradle.kts
index f891151a0..9ad896cec 100644
--- a/nebulosa-guiding/build.gradle.kts
+++ b/nebulosa-guiding/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
 
 dependencies {
     api(project(":nebulosa-math"))
-    api(project(":nebulosa-common"))
     api(project(":nebulosa-indi-device"))
     testImplementation(project(":nebulosa-test"))
 }
diff --git a/nebulosa-guiding/src/main/kotlin/nebulosa/guiding/Guider.kt b/nebulosa-guiding/src/main/kotlin/nebulosa/guiding/Guider.kt
index 1a749704d..98ad9dcf5 100644
--- a/nebulosa-guiding/src/main/kotlin/nebulosa/guiding/Guider.kt
+++ b/nebulosa-guiding/src/main/kotlin/nebulosa/guiding/Guider.kt
@@ -1,6 +1,5 @@
 package nebulosa.guiding
 
-import nebulosa.common.concurrency.cancel.CancellationToken
 import java.time.Duration
 
 interface Guider : AutoCloseable {
@@ -35,7 +34,7 @@ interface Guider : AutoCloseable {
 
     fun dither(amount: Double, raOnly: Boolean = false)
 
-    fun waitForSettle(cancellationToken: CancellationToken = CancellationToken.NONE)
+    fun waitForSettle()
 
     companion object {
 
diff --git a/nebulosa-indi-client/src/main/kotlin/nebulosa/indi/client/device/INDIDevice.kt b/nebulosa-indi-client/src/main/kotlin/nebulosa/indi/client/device/INDIDevice.kt
index 083f7fdeb..c023a49b1 100644
--- a/nebulosa-indi-client/src/main/kotlin/nebulosa/indi/client/device/INDIDevice.kt
+++ b/nebulosa-indi-client/src/main/kotlin/nebulosa/indi/client/device/INDIDevice.kt
@@ -90,8 +90,8 @@ internal abstract class INDIDevice : Device {
                     is DefNumberVector -> {
                         val properties = LinkedHashMap<String, NumberProperty>()
 
-                        for (e in message) {
-                            val property = NumberProperty(e.name, e.label, e.value)
+                        for ((name, label, value) in message) {
+                            val property = NumberProperty(name, label, value)
                             properties[property.name] = property
                         }
 
@@ -105,8 +105,8 @@ internal abstract class INDIDevice : Device {
                     is DefSwitchVector -> {
                         val properties = LinkedHashMap<String, SwitchProperty>()
 
-                        for (e in message) {
-                            val property = SwitchProperty(e.name, e.label, e.value)
+                        for ((name, label, value) in message) {
+                            val property = SwitchProperty(name, label, value)
                             properties[property.name] = property
                         }
 
@@ -120,8 +120,8 @@ internal abstract class INDIDevice : Device {
                     is DefTextVector -> {
                         val properties = LinkedHashMap<String, TextProperty>()
 
-                        for (e in message) {
-                            val property = TextProperty(e.name, e.label, e.value)
+                        for ((name, label, value) in message) {
+                            val property = TextProperty(name, label, value)
                             properties[property.name] = property
                         }
 
@@ -147,9 +147,9 @@ internal abstract class INDIDevice : Device {
 
                         vector.state = message.state
 
-                        for (e in message) {
-                            val property = vector[e.name] ?: continue
-                            property.value = e.value
+                        for ((name, value) in message) {
+                            val property = vector[name] ?: continue
+                            property.value = value
                         }
 
                         vector
@@ -159,9 +159,9 @@ internal abstract class INDIDevice : Device {
 
                         vector.state = message.state
 
-                        for (e in message) {
-                            val property = vector[e.name] ?: continue
-                            property.value = e.value
+                        for ((name, value) in message) {
+                            val property = vector[name] ?: continue
+                            property.value = value
                         }
 
                         vector
@@ -171,9 +171,9 @@ internal abstract class INDIDevice : Device {
 
                         vector.state = message.state
 
-                        for (e in message) {
-                            val property = vector[e.name] ?: continue
-                            property.value = e.value
+                        for ((name, value) in message) {
+                            val property = vector[name] ?: continue
+                            property.value = value
                         }
 
                         vector
diff --git a/nebulosa-indi-client/src/main/kotlin/nebulosa/indi/client/device/camera/INDICamera.kt b/nebulosa-indi-client/src/main/kotlin/nebulosa/indi/client/device/camera/INDICamera.kt
index 9cc506feb..ee2073494 100644
--- a/nebulosa-indi-client/src/main/kotlin/nebulosa/indi/client/device/camera/INDICamera.kt
+++ b/nebulosa-indi-client/src/main/kotlin/nebulosa/indi/client/device/camera/INDICamera.kt
@@ -9,7 +9,6 @@ import nebulosa.indi.client.device.INDIDevice
 import nebulosa.indi.client.device.handler.INDIGuideOutputHandler
 import nebulosa.indi.device.Device
 import nebulosa.indi.device.camera.*
-import nebulosa.indi.device.camera.Camera.Companion.NANO_TO_SECONDS
 import nebulosa.indi.device.filterwheel.FilterWheel
 import nebulosa.indi.device.focuser.Focuser
 import nebulosa.indi.device.mount.Mount
@@ -38,10 +37,10 @@ internal open class INDICamera(
     @Volatile final override var cfaOffsetX = 0
     @Volatile final override var cfaOffsetY = 0
     @Volatile final override var cfaType = CfaPattern.RGGB
-    @Volatile final override var exposureMin: Duration = Duration.ZERO
-    @Volatile final override var exposureMax: Duration = Duration.ZERO
+    @Volatile final override var exposureMin = 0L
+    @Volatile final override var exposureMax = 0L
     @Volatile final override var exposureState = PropertyState.IDLE
-    @Volatile final override var exposureTime: Duration = Duration.ZERO
+    @Volatile final override var exposureTime = 0L
     @Volatile final override var hasCooler = false
     @Volatile final override var canSetTemperature = false
     @Volatile final override var canSubFrame = false
@@ -143,8 +142,9 @@ internal open class INDICamera(
                             val element = message[if (isGuider) "GUIDER_EXPOSURE_VALUE" else "CCD_EXPOSURE_VALUE"]!!
 
                             if (element is DefNumber) {
-                                exposureMin = Duration.ofNanos((element.min * NANO_TO_SECONDS).toLong())
-                                exposureMax = Duration.ofNanos((element.max * NANO_TO_SECONDS).toLong())
+                                exposureMin = (element.min * MICROS_TO_SECONDS).toLong()
+                                exposureMax = (element.max * MICROS_TO_SECONDS).toLong()
+
                                 sender.fireOnEventReceived(CameraExposureMinMaxChanged(this))
                             }
 
@@ -152,7 +152,7 @@ internal open class INDICamera(
                             exposureState = message.state
 
                             if (exposureState == PropertyState.BUSY || exposureState == PropertyState.OK) {
-                                exposureTime = Duration.ofNanos((element.value * NANO_TO_SECONDS).toLong())
+                                exposureTime = (element.value * MICROS_TO_SECONDS).toLong()
 
                                 sender.fireOnEventReceived(CameraExposureProgressChanged(this))
                             }
@@ -321,7 +321,7 @@ internal open class INDICamera(
 
     override fun offset(value: Int) = Unit
 
-    override fun startCapture(exposureTime: Duration) {
+    override fun startCapture(exposureTime: Long) {
         sendNewSwitch("CCD_TRANSFER_FORMAT", "FORMAT_FITS" to true)
 
         if (exposureState != PropertyState.IDLE) {
@@ -329,7 +329,7 @@ internal open class INDICamera(
             sender.fireOnEventReceived(CameraExposureStateChanged(this))
         }
 
-        val exposureInSeconds = exposureTime.toNanos() / NANO_TO_SECONDS
+        val exposureInSeconds = exposureTime.toDouble() / MICROS_TO_SECONDS
 
         if (this is GuideHead) {
             sendNewNumber("GUIDER_EXPOSURE", "GUIDER_EXPOSURE_VALUE" to exposureInSeconds)
@@ -495,7 +495,8 @@ internal open class INDICamera(
 
     companion object {
 
-        const val GUIDE_HEAD_SUFFIX = "(Guide Head)"
+        private const val GUIDE_HEAD_SUFFIX = "(Guide Head)"
+        private const val MICROS_TO_SECONDS = 1_000_000L
 
         @JvmStatic private val COMPRESSION_FORMATS = arrayOf(".fz", ".gz")
         @JvmStatic private val LOG = loggerFor<INDICamera>()
diff --git a/nebulosa-indi-client/src/main/kotlin/nebulosa/indi/client/device/mount/INDIMount.kt b/nebulosa-indi-client/src/main/kotlin/nebulosa/indi/client/device/mount/INDIMount.kt
index 8c12ec2e9..7f18ec324 100644
--- a/nebulosa-indi-client/src/main/kotlin/nebulosa/indi/client/device/mount/INDIMount.kt
+++ b/nebulosa-indi-client/src/main/kotlin/nebulosa/indi/client/device/mount/INDIMount.kt
@@ -13,6 +13,7 @@ import nebulosa.indi.protocol.DefVector.Companion.isNotReadOnly
 import nebulosa.indi.protocol.Vector.Companion.isBusy
 import nebulosa.math.*
 import nebulosa.nova.position.ICRF
+import nebulosa.time.SystemClock
 import java.time.Duration
 import java.time.OffsetDateTime
 import java.time.ZoneOffset
@@ -56,7 +57,7 @@ internal open class INDIMount(
     @Volatile final override var longitude = 0.0
     @Volatile final override var latitude = 0.0
     @Volatile final override var elevation = 0.0
-    @Volatile final override var dateTime = OffsetDateTime.now()!!
+    @Volatile final override var dateTime = OffsetDateTime.now(SystemClock)!!
 
     override fun handleMessage(message: INDIProtocol) {
         when (message) {
diff --git a/nebulosa-indi-device/src/main/kotlin/nebulosa/indi/device/camera/Camera.kt b/nebulosa-indi-device/src/main/kotlin/nebulosa/indi/device/camera/Camera.kt
index cbd7a7fbb..4c0baa3cc 100644
--- a/nebulosa-indi-device/src/main/kotlin/nebulosa/indi/device/camera/Camera.kt
+++ b/nebulosa-indi-device/src/main/kotlin/nebulosa/indi/device/camera/Camera.kt
@@ -6,7 +6,6 @@ import nebulosa.indi.device.DeviceType
 import nebulosa.indi.device.guider.GuideOutput
 import nebulosa.indi.device.thermometer.Thermometer
 import nebulosa.indi.protocol.PropertyState
-import java.time.Duration
 
 interface Camera : GuideOutput, Thermometer {
 
@@ -35,13 +34,13 @@ interface Camera : GuideOutput, Thermometer {
 
     val cfaType: CfaPattern
 
-    val exposureMin: Duration
+    val exposureMin: Long
 
-    val exposureMax: Duration
+    val exposureMax: Long
 
     val exposureState: PropertyState
 
-    val exposureTime: Duration
+    val exposureTime: Long
 
     val hasCooler: Boolean
 
@@ -119,14 +118,9 @@ interface Camera : GuideOutput, Thermometer {
 
     fun offset(value: Int)
 
-    fun startCapture(exposureTime: Duration)
+    fun startCapture(exposureTime: Long)
 
     fun abortCapture()
 
     fun fitsKeywords(vararg cards: HeaderCard)
-
-    companion object {
-
-        const val NANO_TO_SECONDS = 1_000_000_000.0
-    }
 }
diff --git a/nebulosa-indi-protocol/src/main/kotlin/nebulosa/indi/protocol/parser/INDIXmlInputStream.kt b/nebulosa-indi-protocol/src/main/kotlin/nebulosa/indi/protocol/parser/INDIXmlInputStream.kt
index 2536c377a..d3aa8a0af 100644
--- a/nebulosa-indi-protocol/src/main/kotlin/nebulosa/indi/protocol/parser/INDIXmlInputStream.kt
+++ b/nebulosa-indi-protocol/src/main/kotlin/nebulosa/indi/protocol/parser/INDIXmlInputStream.kt
@@ -209,7 +209,7 @@ class INDIXmlInputStream(source: InputStream) : INDIInputStream {
     private fun parseDefSwitch(): DefSwitch {
         val defSwitch = DefSwitch()
         defSwitch.parseDefElement()
-        defSwitch.value = reader.elementText.trim().equals("On", true)
+        defSwitch.value = reader.elementText.contains("On", true)
         return defSwitch
     }
 
diff --git a/nebulosa-job-manager/build.gradle.kts b/nebulosa-job-manager/build.gradle.kts
new file mode 100644
index 000000000..1ed9169cc
--- /dev/null
+++ b/nebulosa-job-manager/build.gradle.kts
@@ -0,0 +1,18 @@
+plugins {
+    kotlin("jvm")
+    id("maven-publish")
+}
+
+dependencies {
+    api(project(":nebulosa-util"))
+    implementation(project(":nebulosa-log"))
+    testImplementation(project(":nebulosa-test"))
+}
+
+publishing {
+    publications {
+        create<MavenPublication>("pluginMaven") {
+            from(components["java"])
+        }
+    }
+}
diff --git a/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/AbstractJob.kt b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/AbstractJob.kt
new file mode 100644
index 000000000..93aab4cd4
--- /dev/null
+++ b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/AbstractJob.kt
@@ -0,0 +1,237 @@
+package nebulosa.job.manager
+
+import nebulosa.log.loggerFor
+import nebulosa.util.concurrency.cancellation.CancellationListener
+import nebulosa.util.concurrency.cancellation.CancellationSource
+import nebulosa.util.concurrency.latch.CountUpDownLatch
+import nebulosa.util.concurrency.latch.PauseListener
+import java.util.*
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.Executor
+import java.util.concurrent.ForkJoinPool
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicInteger
+
+abstract class AbstractJob : JobTask, CancellationListener, PauseListener {
+
+    private val tasks = Collections.synchronizedList(ArrayList<Task>(128))
+
+    private val running = AtomicBoolean()
+    private val cancelled = AtomicBoolean()
+    private val pauseLatch = CountUpDownLatch()
+    private val current = AtomicInteger(-1)
+
+    @Volatile final override var loopCount = 0
+        private set
+
+    @Volatile final override var taskCount = 0
+        private set
+
+    override val size
+        get() = tasks.size
+
+    override val isRunning
+        get() = running.get()
+
+    override val isCancelled
+        get() = cancelled.get()
+
+    override val isPaused
+        get() = !pauseLatch.get()
+
+    override val currentTask
+        get() = tasks.getOrNull(current.get())
+
+    protected open fun beforeStart() = Unit
+
+    protected open fun beforeTask(task: Task) = Unit
+
+    protected open fun afterTask(task: Task, exception: Throwable? = null) = exception == null
+
+    protected open fun afterFinish() = Unit
+
+    protected open fun beforePause(task: Task) = Unit
+
+    protected open fun afterPause(task: Task) = Unit
+
+    protected open fun isLoop() = false
+
+    protected open fun canRun(prev: Task?, current: Task) = true
+
+    protected open fun canPause(task: Task) = true
+
+    override fun onCancel(source: CancellationSource) {
+        cancelled.set(true)
+        currentTask?.onCancel(source)
+    }
+
+    override fun onPause(paused: Boolean) {
+        if (paused) {
+            pauseLatch.countUp()
+        } else {
+            pauseLatch.reset()
+        }
+
+        currentTask?.onPause(paused)
+    }
+
+    override fun runTask(task: Task, prev: Task?): TaskExecutionState {
+        return try {
+            checkIfPaused(task)
+
+            if (isCancelled) {
+                TaskExecutionState.BREAK
+            } else if (canRun(prev, task)) {
+                beforeTask(task)
+
+                var exception: Throwable? = null
+
+                try {
+                    taskCount++
+                    task.run()
+                } catch (e: Throwable) {
+                    LOG.error("task execution failed", e)
+                    exception = e
+                }
+
+                if (!afterTask(task, exception) || isCancelled) {
+                    TaskExecutionState.BREAK
+                } else {
+                    checkIfPaused(task)
+                    TaskExecutionState.OK
+                }
+            } else {
+                TaskExecutionState.CONTINUE
+            }
+        } catch (e: Throwable) {
+            LOG.error("task execution failed", e)
+            TaskExecutionState.CONTINUE
+        }
+    }
+
+    final override fun run() {
+        if (current.compareAndSet(-1, 0)) {
+            running.set(true)
+
+            beforeStart()
+
+            var prev: Task? = null
+
+            while (isRunning && !isCancelled) {
+                val index = current.get()
+                val task = tasks.getOrNull(index) ?: break
+                val state = runTask(task, prev)
+
+                if (state == TaskExecutionState.OK) {
+                    prev = task
+                } else if (state == TaskExecutionState.BREAK) {
+                    break
+                }
+
+                val next = tasks.getOrNull(index + 1)
+
+                if (next != null) {
+                    current.set(index + 1)
+                } else if (isLoop()) {
+                    loopCount++
+                    current.set(0)
+                } else {
+                    break
+                }
+            }
+
+            afterFinish()
+            running.set(false)
+
+            current.set(-1)
+        }
+    }
+
+    fun runAsync(executor: Executor = EXECUTOR): CompletableFuture<Void> {
+        return CompletableFuture.runAsync(this, executor)
+    }
+
+    private fun checkIfPaused(task: Task) {
+        if (isPaused && canPause(task)) {
+            beforePause(task)
+            pauseLatch.await()
+            afterPause(task)
+        }
+    }
+
+    final override fun iterator() = object : MutableIterator<Task> {
+
+        @Volatile private var index = 0
+
+        override fun hasNext(): Boolean {
+            return index < size
+        }
+
+        override fun next(): Task {
+            return tasks.getOrNull(index++) ?: throw NoSuchElementException()
+        }
+
+        override fun remove() {
+            TODO("Not yet implemented")
+        }
+    }
+
+    fun addFirst(task: Task) {
+        tasks.add(0, task)
+    }
+
+    fun addLast(task: Task) {
+        tasks.add(task)
+    }
+
+    fun removeFirst(): Task? {
+        return tasks.removeFirstOrNull()
+    }
+
+    fun removeLast(): Task? {
+        return tasks.removeLastOrNull()
+    }
+
+    final override fun add(element: Task): Boolean {
+        addLast(element)
+        return true
+    }
+
+    final override fun contains(element: Task): Boolean {
+        return element in tasks
+    }
+
+    final override fun clear() {
+        tasks.clear()
+    }
+
+    final override fun removeAll(elements: Collection<Task>): Boolean {
+        return tasks.removeAll(elements)
+    }
+
+    final override fun retainAll(elements: Collection<Task>): Boolean {
+        return tasks.retainAll(elements)
+    }
+
+    final override fun isEmpty(): Boolean {
+        return size == 0
+    }
+
+    final override fun containsAll(elements: Collection<Task>): Boolean {
+        return tasks.containsAll(elements)
+    }
+
+    override fun addAll(elements: Collection<Task>): Boolean {
+        return tasks.addAll(elements)
+    }
+
+    override fun remove(element: Task): Boolean {
+        return tasks.remove(element)
+    }
+
+    companion object {
+
+        @JvmStatic private val EXECUTOR = ForkJoinPool.commonPool()
+        @JvmStatic private val LOG = loggerFor<AbstractJob>()
+    }
+}
diff --git a/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/Job.kt b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/Job.kt
new file mode 100644
index 000000000..0f54aff9f
--- /dev/null
+++ b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/Job.kt
@@ -0,0 +1,20 @@
+package nebulosa.job.manager
+
+import nebulosa.util.Stoppable
+import nebulosa.util.concurrency.latch.Pauseable
+import java.util.function.Consumer
+
+interface Job : MutableCollection<Task>, Runnable, Pauseable, Stoppable, Consumer<Any> {
+
+    val loopCount: Int
+
+    val taskCount: Int
+
+    val isRunning: Boolean
+
+    val isCancelled: Boolean
+
+    val currentTask: Task?
+
+    fun runTask(task: Task, prev: Task?): TaskExecutionState
+}
diff --git a/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/JobTask.kt b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/JobTask.kt
new file mode 100644
index 000000000..0bdec58d4
--- /dev/null
+++ b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/JobTask.kt
@@ -0,0 +1,18 @@
+package nebulosa.job.manager
+
+import nebulosa.util.concurrency.cancellation.CancellationSource
+
+interface JobTask : Job, Task {
+
+    override fun pause() {
+        onPause(true)
+    }
+
+    override fun unpause() {
+        onPause(false)
+    }
+
+    override fun stop() {
+        onCancel(CancellationSource.DEFAULT)
+    }
+}
diff --git a/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/LoopTask.kt b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/LoopTask.kt
new file mode 100644
index 000000000..5468179b1
--- /dev/null
+++ b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/LoopTask.kt
@@ -0,0 +1,44 @@
+package nebulosa.job.manager
+
+data class LoopTask(
+    private val job: Job,
+    private val tasks: List<Task>,
+    private val condition: (Task, Int) -> Boolean = INFINITY_LOOP,
+) : Task {
+
+    @Volatile private var index = 0
+    @Volatile private var count = 0
+
+    @Volatile var state = TaskExecutionState.OK
+        private set
+
+    override fun run() {
+        var prev: Task? = null
+
+        while (job.isRunning && !job.isCancelled) {
+            val task = tasks[index]
+
+            if (!condition(task, count)) {
+                break
+            }
+
+            state = job.runTask(task, prev)
+
+            if (state == TaskExecutionState.OK) {
+                prev = task
+            } else if (state == TaskExecutionState.BREAK) {
+                break
+            }
+
+            if (++index >= tasks.size) {
+                index = 0
+                count++
+            }
+        }
+    }
+
+    companion object {
+
+        @JvmField val INFINITY_LOOP: (Task, Int) -> Boolean = { _, _ -> true }
+    }
+}
diff --git a/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/SplitTask.kt b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/SplitTask.kt
new file mode 100644
index 000000000..293c2ebea
--- /dev/null
+++ b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/SplitTask.kt
@@ -0,0 +1,36 @@
+package nebulosa.job.manager
+
+import nebulosa.util.concurrency.cancellation.CancellationSource
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.Executor
+import java.util.concurrent.ForkJoinPool
+
+data class SplitTask(
+    private val tasks: List<Task>,
+    private val executor: Executor = EXECUTOR,
+) : Task {
+
+    override fun onPause(paused: Boolean) {
+        tasks.forEach { it.onPause(paused) }
+    }
+
+    override fun onCancel(source: CancellationSource) {
+        tasks.forEach { it.onCancel(source) }
+    }
+
+    override fun run() {
+        if (tasks.isEmpty()) {
+            return
+        } else if (tasks.size == 1) {
+            tasks[0].run()
+        } else {
+            val completables = Array(tasks.size) { CompletableFuture.runAsync(tasks[it], executor) }
+            CompletableFuture.allOf(*completables).join()
+        }
+    }
+
+    companion object {
+
+        @JvmStatic private val EXECUTOR = ForkJoinPool.commonPool()
+    }
+}
diff --git a/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/Task.kt b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/Task.kt
new file mode 100644
index 000000000..7015f0bc7
--- /dev/null
+++ b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/Task.kt
@@ -0,0 +1,12 @@
+package nebulosa.job.manager
+
+import nebulosa.util.concurrency.cancellation.CancellationListener
+import nebulosa.util.concurrency.cancellation.CancellationSource
+import nebulosa.util.concurrency.latch.PauseListener
+
+fun interface Task : CancellationListener, PauseListener, Runnable {
+
+    override fun onCancel(source: CancellationSource) = Unit
+
+    override fun onPause(paused: Boolean) = Unit
+}
diff --git a/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/TaskEvent.kt b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/TaskEvent.kt
new file mode 100644
index 000000000..66c88b0dc
--- /dev/null
+++ b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/TaskEvent.kt
@@ -0,0 +1,8 @@
+package nebulosa.job.manager
+
+interface TaskEvent {
+
+    val job: Job
+
+    val task: Task
+}
diff --git a/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/TaskExecutionState.kt b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/TaskExecutionState.kt
new file mode 100644
index 000000000..b7f971133
--- /dev/null
+++ b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/TaskExecutionState.kt
@@ -0,0 +1,7 @@
+package nebulosa.job.manager
+
+enum class TaskExecutionState {
+    OK,
+    CONTINUE,
+    BREAK,
+}
diff --git a/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/TimedTaskEvent.kt b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/TimedTaskEvent.kt
new file mode 100644
index 000000000..94d8388b1
--- /dev/null
+++ b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/TimedTaskEvent.kt
@@ -0,0 +1,10 @@
+package nebulosa.job.manager
+
+interface TimedTaskEvent : TaskEvent {
+
+    val elapsedTime: Long
+
+    val remainingTime: Long
+
+    val progress: Double
+}
diff --git a/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/delay/DelayElapsed.kt b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/delay/DelayElapsed.kt
new file mode 100644
index 000000000..764999fe1
--- /dev/null
+++ b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/delay/DelayElapsed.kt
@@ -0,0 +1,11 @@
+package nebulosa.job.manager.delay
+
+import nebulosa.job.manager.Job
+
+data class DelayElapsed(
+    override val job: Job, override val task: DelayTask,
+    override val remainingTime: Long,
+    override val elapsedTime: Long,
+    override val waitTime: Long,
+    override val progress: Double,
+) : DelayEvent
diff --git a/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/delay/DelayEvent.kt b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/delay/DelayEvent.kt
new file mode 100644
index 000000000..cbb34414b
--- /dev/null
+++ b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/delay/DelayEvent.kt
@@ -0,0 +1,10 @@
+package nebulosa.job.manager.delay
+
+import nebulosa.job.manager.TimedTaskEvent
+
+sealed interface DelayEvent : TimedTaskEvent {
+
+    override val task: DelayTask
+
+    val waitTime: Long
+}
diff --git a/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/delay/DelayFinished.kt b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/delay/DelayFinished.kt
new file mode 100644
index 000000000..9a76c48b0
--- /dev/null
+++ b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/delay/DelayFinished.kt
@@ -0,0 +1,11 @@
+package nebulosa.job.manager.delay
+
+import nebulosa.job.manager.Job
+
+data class DelayFinished(override val job: Job, override val task: DelayTask) : DelayEvent {
+
+    override val remainingTime = 0L
+    override val elapsedTime = task.duration * 1000L
+    override val waitTime = 0L
+    override val progress = 1.0
+}
diff --git a/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/delay/DelayStarted.kt b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/delay/DelayStarted.kt
new file mode 100644
index 000000000..f305b5782
--- /dev/null
+++ b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/delay/DelayStarted.kt
@@ -0,0 +1,11 @@
+package nebulosa.job.manager.delay
+
+import nebulosa.job.manager.Job
+
+data class DelayStarted(override val job: Job, override val task: DelayTask) : DelayEvent {
+
+    override val remainingTime = task.duration * 1000L
+    override val elapsedTime = 0L
+    override val waitTime = 0L
+    override val progress = 0.0
+}
diff --git a/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/delay/DelayTask.kt b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/delay/DelayTask.kt
new file mode 100644
index 000000000..e1d6e507a
--- /dev/null
+++ b/nebulosa-job-manager/src/main/kotlin/nebulosa/job/manager/delay/DelayTask.kt
@@ -0,0 +1,49 @@
+package nebulosa.job.manager.delay
+
+import nebulosa.job.manager.Job
+import nebulosa.job.manager.Task
+import nebulosa.log.debug
+import nebulosa.log.loggerFor
+import java.time.Duration
+
+data class DelayTask(
+    @JvmField val job: Job,
+    @JvmField val duration: Long,
+) : Task {
+
+    constructor(job: Job, duration: Duration) : this(job, duration.toMillis())
+
+    override fun run() {
+        var remainingTime = duration
+
+        if (!job.isCancelled && remainingTime > 0L) {
+            LOG.debug { "Delay started. duration=$duration ms" }
+
+            job.accept(DelayStarted(job, this))
+
+            while (!job.isCancelled && remainingTime > 0L) {
+                val waitTime = minOf(remainingTime, DELAY_INTERVAL)
+
+                if (waitTime > 0L) {
+                    val progress = (duration - remainingTime) / duration.toDouble()
+                    job.accept(DelayElapsed(job, this, remainingTime * 1000L, (duration - remainingTime) * 1000L, waitTime * 1000L, progress))
+
+                    Thread.sleep(waitTime)
+
+                    remainingTime -= waitTime
+                }
+            }
+
+            job.accept(DelayFinished(job, this))
+
+            LOG.debug { "Delay finished. duration=$duration ms" }
+        }
+    }
+
+    companion object {
+
+        const val DELAY_INTERVAL = 500L
+
+        @JvmStatic private val LOG = loggerFor<DelayTask>()
+    }
+}
diff --git a/nebulosa-json/src/main/kotlin/nebulosa/json/PathModule.kt b/nebulosa-json/src/main/kotlin/nebulosa/json/PathModule.kt
index 23e4a2d13..dbe293038 100644
--- a/nebulosa-json/src/main/kotlin/nebulosa/json/PathModule.kt
+++ b/nebulosa-json/src/main/kotlin/nebulosa/json/PathModule.kt
@@ -3,10 +3,9 @@ package nebulosa.json
 import com.fasterxml.jackson.databind.module.SimpleDeserializers
 import com.fasterxml.jackson.databind.module.SimpleModule
 import com.fasterxml.jackson.databind.module.SimpleSerializers
-import com.fasterxml.jackson.datatype.jsr310.PackageVersion
 import java.nio.file.Path
 
-class PathModule : SimpleModule(PackageVersion.VERSION) {
+class PathModule : SimpleModule() {
 
     override fun setupModule(context: SetupContext) {
         super.setupModule(context)
diff --git a/nebulosa-math/src/main/kotlin/nebulosa/math/AngleFormatter.kt b/nebulosa-math/src/main/kotlin/nebulosa/math/AngleFormatter.kt
index cc8fed929..eb05d3f08 100644
--- a/nebulosa-math/src/main/kotlin/nebulosa/math/AngleFormatter.kt
+++ b/nebulosa-math/src/main/kotlin/nebulosa/math/AngleFormatter.kt
@@ -5,7 +5,7 @@ import java.math.RoundingMode
 import java.util.*
 import kotlin.math.abs
 
-data class AngleFormatter internal constructor(
+data class AngleFormatter(
     private val isHours: Boolean = false,
     private val hasSign: Boolean = true,
     private val hoursFormat: String = "%02d",
diff --git a/nebulosa-phd2-client/build.gradle.kts b/nebulosa-phd2-client/build.gradle.kts
index 41aee57dc..3eaf8e5c7 100644
--- a/nebulosa-phd2-client/build.gradle.kts
+++ b/nebulosa-phd2-client/build.gradle.kts
@@ -4,10 +4,10 @@ plugins {
 }
 
 dependencies {
-    api(project(":nebulosa-common"))
     api(project(":nebulosa-netty"))
     api(project(":nebulosa-guiding"))
     api(project(":nebulosa-json"))
+    api(project(":nebulosa-util"))
     implementation(project(":nebulosa-log"))
     testImplementation(project(":nebulosa-test"))
 }
diff --git a/nebulosa-phd2-client/src/main/kotlin/nebulosa/phd2/client/PHD2Client.kt b/nebulosa-phd2-client/src/main/kotlin/nebulosa/phd2/client/PHD2Client.kt
index e185fe988..294235fce 100644
--- a/nebulosa-phd2-client/src/main/kotlin/nebulosa/phd2/client/PHD2Client.kt
+++ b/nebulosa-phd2-client/src/main/kotlin/nebulosa/phd2/client/PHD2Client.kt
@@ -70,9 +70,9 @@ class PHD2Client : NettyClient() {
 
         @JvmStatic private val LOG = loggerFor<PHD2Client>()
 
-        @JvmStatic private val MODULE = kotlinModule().also {
-            it.addDeserializer(GuideState::class.java, GuideStateDeserializer)
-            it.addSerializer(GuideStateSerializer)
+        @JvmStatic private val MODULE = with(kotlinModule()) {
+            addDeserializer(GuideState::class.java, GuideStateDeserializer)
+            addSerializer(GuideStateSerializer)
         }
 
         @JvmStatic private val JSON_MAPPER = jsonMapper {
diff --git a/nebulosa-phd2-client/src/main/kotlin/nebulosa/phd2/client/events/GuideStateDeserializer.kt b/nebulosa-phd2-client/src/main/kotlin/nebulosa/phd2/client/events/GuideStateDeserializer.kt
index 79c12ff57..894a781fc 100644
--- a/nebulosa-phd2-client/src/main/kotlin/nebulosa/phd2/client/events/GuideStateDeserializer.kt
+++ b/nebulosa-phd2-client/src/main/kotlin/nebulosa/phd2/client/events/GuideStateDeserializer.kt
@@ -7,6 +7,8 @@ import nebulosa.guiding.GuideState
 
 data object GuideStateDeserializer : StdDeserializer<GuideState>(GuideState::class.java) {
 
+    private fun readResolve(): Any = GuideStateDeserializer
+
     override fun deserialize(p: JsonParser, ctxt: DeserializationContext): GuideState? {
         return p.valueAsString?.let(GUIDE_STATE_NAMES::get)
     }
diff --git a/nebulosa-pixinsight/build.gradle.kts b/nebulosa-pixinsight/build.gradle.kts
index 60cae2725..57c654bb8 100644
--- a/nebulosa-pixinsight/build.gradle.kts
+++ b/nebulosa-pixinsight/build.gradle.kts
@@ -4,13 +4,13 @@ plugins {
 }
 
 dependencies {
-    api(project(":nebulosa-common"))
     api(project(":nebulosa-math"))
     api(project(":nebulosa-platesolver"))
     api(project(":nebulosa-stardetector"))
     api(project(":nebulosa-stacker"))
     api(project(":nebulosa-livestacker"))
     api(project(":nebulosa-json"))
+    api(project(":nebulosa-util"))
     api(libs.apache.codec)
     implementation(project(":nebulosa-log"))
     testImplementation(project(":nebulosa-image"))
diff --git a/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/platesolver/PixInsightPlateSolver.kt b/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/platesolver/PixInsightPlateSolver.kt
index 8625a6a65..f414230bb 100644
--- a/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/platesolver/PixInsightPlateSolver.kt
+++ b/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/platesolver/PixInsightPlateSolver.kt
@@ -1,7 +1,5 @@
 package nebulosa.pixinsight.platesolver
 
-import nebulosa.common.concurrency.cancel.CancellationListener
-import nebulosa.common.concurrency.cancel.CancellationToken
 import nebulosa.image.Image
 import nebulosa.math.Angle
 import nebulosa.math.deg
@@ -11,6 +9,8 @@ import nebulosa.pixinsight.script.PixInsightScript
 import nebulosa.pixinsight.script.PixInsightScriptRunner
 import nebulosa.platesolver.PlateSolution
 import nebulosa.platesolver.PlateSolver
+import nebulosa.util.concurrency.cancellation.CancellationListener
+import nebulosa.util.concurrency.cancellation.CancellationToken
 import java.nio.file.Path
 import java.time.Duration
 
diff --git a/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/AbstractPixInsightScript.kt b/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/AbstractPixInsightScript.kt
index b49b79349..dfadc0d7f 100644
--- a/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/AbstractPixInsightScript.kt
+++ b/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/AbstractPixInsightScript.kt
@@ -2,10 +2,10 @@ package nebulosa.pixinsight.script
 
 import com.fasterxml.jackson.databind.DeserializationFeature
 import com.fasterxml.jackson.module.kotlin.jsonMapper
-import nebulosa.common.exec.CommandLine
-import nebulosa.common.exec.CommandLineListener
 import nebulosa.json.PathModule
 import nebulosa.log.loggerFor
+import nebulosa.util.exec.CommandLine
+import nebulosa.util.exec.CommandLineListener
 import org.apache.commons.codec.binary.Hex
 import java.nio.file.Path
 import java.util.concurrent.CompletableFuture
@@ -28,13 +28,13 @@ abstract class AbstractPixInsightScript<T : PixInsightScript.Output> : PixInsigh
     final override fun startCommandLine(commandLine: CommandLine) {
         commandLine.whenComplete { exitCode, exception ->
             try {
-                LOG.info("{} script finished. done={}, exitCode={}", this::class.simpleName, isDone, exitCode, exception)
+                LOG.debug("{} script finished. done={}, exitCode={}", this::class.simpleName, isDone, exitCode, exception)
 
                 waitOnComplete()
 
                 if (isDone) return@whenComplete
                 else if (exception != null) completeExceptionally(exception)
-                else complete(processOnComplete(exitCode).also { LOG.info("{} script processed. output={}", this::class.simpleName, it) })
+                else complete(processOnComplete(exitCode).also { LOG.debug("{} script processed. output={}", this::class.simpleName, it) })
             } catch (e: Throwable) {
                 LOG.error("{} finished with fatal exception. message={}", this::class.simpleName, e.message)
                 completeExceptionally(e)
diff --git a/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/PixInsightImageSolver.kt b/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/PixInsightImageSolver.kt
index 174ca044b..0548313e7 100644
--- a/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/PixInsightImageSolver.kt
+++ b/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/PixInsightImageSolver.kt
@@ -1,11 +1,11 @@
 package nebulosa.pixinsight.script
 
 import com.sun.jna.Platform
-import nebulosa.common.concurrency.cancel.CancellationToken
 import nebulosa.io.resource
 import nebulosa.io.transferAndClose
 import nebulosa.math.Angle
 import nebulosa.math.toDegrees
+import nebulosa.util.concurrency.cancellation.CancellationToken
 import java.nio.file.Files
 import java.nio.file.Path
 import java.time.Duration
diff --git a/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/PixInsightScript.kt b/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/PixInsightScript.kt
index 601e1a85d..6e715cced 100644
--- a/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/PixInsightScript.kt
+++ b/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/PixInsightScript.kt
@@ -1,6 +1,6 @@
 package nebulosa.pixinsight.script
 
-import nebulosa.common.exec.CommandLine
+import nebulosa.util.exec.CommandLine
 import java.util.concurrent.Future
 
 sealed interface PixInsightScript<T : PixInsightScript.Output> : Future<T>, AutoCloseable {
diff --git a/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/PixInsightScriptRunner.kt b/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/PixInsightScriptRunner.kt
index d7a6e7a7a..229140b15 100644
--- a/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/PixInsightScriptRunner.kt
+++ b/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/PixInsightScriptRunner.kt
@@ -1,7 +1,7 @@
 package nebulosa.pixinsight.script
 
-import nebulosa.common.exec.commandLine
 import nebulosa.log.loggerFor
+import nebulosa.util.exec.commandLine
 import java.nio.file.Path
 
 data class PixInsightScriptRunner(private val executablePath: Path) {
@@ -13,7 +13,7 @@ data class PixInsightScriptRunner(private val executablePath: Path) {
             DEFAULT_ARGS.forEach(::putArg)
         }
 
-        LOG.info("running {} script: {}", script::class.simpleName, commandLine.command)
+        LOG.debug("running {} script: {}", script::class.simpleName, commandLine.command)
 
         script.startCommandLine(commandLine)
     }
diff --git a/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/stacker/PixInsightAutoStacker.kt b/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/stacker/PixInsightAutoStacker.kt
index c39956c98..c5e2ee52b 100644
--- a/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/stacker/PixInsightAutoStacker.kt
+++ b/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/stacker/PixInsightAutoStacker.kt
@@ -1,10 +1,10 @@
 package nebulosa.pixinsight.stacker
 
-import nebulosa.common.concurrency.cancel.CancellationToken
 import nebulosa.pixinsight.script.PixInsightScript
 import nebulosa.pixinsight.script.PixInsightScriptRunner
 import nebulosa.stacker.AutoStacker
 import nebulosa.stacker.AutoStackerListener
+import nebulosa.util.concurrency.cancellation.CancellationToken
 import java.nio.file.Path
 import java.util.concurrent.CancellationException
 import kotlin.io.path.deleteIfExists
diff --git a/nebulosa-platesolver/build.gradle.kts b/nebulosa-platesolver/build.gradle.kts
index 56296109b..a44c013cc 100644
--- a/nebulosa-platesolver/build.gradle.kts
+++ b/nebulosa-platesolver/build.gradle.kts
@@ -5,9 +5,9 @@ plugins {
 
 dependencies {
     api(project(":nebulosa-math"))
-    api(project(":nebulosa-common"))
     api(project(":nebulosa-wcs"))
     api(project(":nebulosa-image"))
+    api(project(":nebulosa-util"))
     implementation(project(":nebulosa-log"))
     testImplementation(project(":nebulosa-test"))
 }
diff --git a/nebulosa-platesolver/src/main/kotlin/nebulosa/platesolver/PlateSolver.kt b/nebulosa-platesolver/src/main/kotlin/nebulosa/platesolver/PlateSolver.kt
index b1672ca58..23b53cba3 100644
--- a/nebulosa-platesolver/src/main/kotlin/nebulosa/platesolver/PlateSolver.kt
+++ b/nebulosa-platesolver/src/main/kotlin/nebulosa/platesolver/PlateSolver.kt
@@ -1,8 +1,8 @@
 package nebulosa.platesolver
 
-import nebulosa.common.concurrency.cancel.CancellationToken
 import nebulosa.image.Image
 import nebulosa.math.Angle
+import nebulosa.util.concurrency.cancellation.CancellationToken
 import java.nio.file.Path
 import java.time.Duration
 
diff --git a/nebulosa-retrofit/src/main/kotlin/nebulosa/retrofit/RetrofitService.kt b/nebulosa-retrofit/src/main/kotlin/nebulosa/retrofit/RetrofitService.kt
index 4d0565dc3..cee9c6348 100644
--- a/nebulosa-retrofit/src/main/kotlin/nebulosa/retrofit/RetrofitService.kt
+++ b/nebulosa-retrofit/src/main/kotlin/nebulosa/retrofit/RetrofitService.kt
@@ -21,7 +21,7 @@ abstract class RetrofitService(
     mapper: ObjectMapper? = null,
 ) {
 
-    protected val jsonMapper: ObjectMapper by lazy { mapper ?: DEFAULT_MAPPER.copy() }
+    protected val objectMapper by lazy { mapper ?: DEFAULT_MAPPER }
 
     protected open val converterFactory: Iterable<Converter.Factory>
         get() = emptyList()
@@ -29,23 +29,20 @@ abstract class RetrofitService(
     protected open val callAdaptorFactory: CallAdapter.Factory?
         get() = null
 
-    protected open fun withOkHttpClientBuilder(builder: OkHttpClient.Builder) = Unit
-
-    protected open fun withObjectMapper(mapper: ObjectMapper) = Unit
+    protected open fun withOkHttpClient(builder: OkHttpClient.Builder) = Unit
 
     protected open val retrofit by lazy {
         val builder = Retrofit.Builder()
         builder.baseUrl(url.trim().let { if (it.endsWith("/")) it else "$it/" })
         builder.addConverterFactory(RawAsStringConverterFactory)
         builder.addConverterFactory(RawAsByteArrayConverterFactory)
-        builder.addConverterFactory(EnumToStringConverterFactory(jsonMapper))
+        builder.addConverterFactory(EnumToStringConverterFactory(objectMapper))
         converterFactory.forEach { builder.addConverterFactory(it) }
-        withObjectMapper(jsonMapper)
-        builder.addConverterFactory(JacksonConverterFactory.create(jsonMapper))
+        builder.addConverterFactory(JacksonConverterFactory.create(objectMapper))
         callAdaptorFactory?.also(builder::addCallAdapterFactory)
 
         with((httpClient ?: HTTP_CLIENT).newBuilder()) {
-            withOkHttpClientBuilder(this)
+            withOkHttpClient(this)
             builder.client(build())
         }
 
diff --git a/nebulosa-sbd/src/main/kotlin/nebulosa/sbd/SmallBodyDatabaseService.kt b/nebulosa-sbd/src/main/kotlin/nebulosa/sbd/SmallBodyDatabaseService.kt
index 42e9f01ad..4147bd740 100644
--- a/nebulosa-sbd/src/main/kotlin/nebulosa/sbd/SmallBodyDatabaseService.kt
+++ b/nebulosa-sbd/src/main/kotlin/nebulosa/sbd/SmallBodyDatabaseService.kt
@@ -16,7 +16,7 @@ class SmallBodyDatabaseService(
 
     private val service by lazy { retrofit.create<SmallBodyDatabase>() }
 
-    override fun withOkHttpClientBuilder(builder: OkHttpClient.Builder) {
+    override fun withOkHttpClient(builder: OkHttpClient.Builder) {
         builder.readTimeout(5L, TimeUnit.MINUTES)
             .writeTimeout(5L, TimeUnit.MINUTES)
             .connectTimeout(5L, TimeUnit.MINUTES)
diff --git a/nebulosa-siril/build.gradle.kts b/nebulosa-siril/build.gradle.kts
index eb0f4ddb0..8fd972b46 100644
--- a/nebulosa-siril/build.gradle.kts
+++ b/nebulosa-siril/build.gradle.kts
@@ -4,11 +4,11 @@ plugins {
 }
 
 dependencies {
-    api(project(":nebulosa-common"))
     api(project(":nebulosa-math"))
     api(project(":nebulosa-livestacker"))
     api(project(":nebulosa-platesolver"))
     api(project(":nebulosa-stardetector"))
+    api(project(":nebulosa-util"))
     implementation(project(":nebulosa-log"))
     testImplementation(project(":nebulosa-test"))
 }
diff --git a/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/Cd.kt b/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/Cd.kt
index f99dba012..5e9a3fc62 100644
--- a/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/Cd.kt
+++ b/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/Cd.kt
@@ -1,8 +1,8 @@
 package nebulosa.siril.command
 
-import nebulosa.common.concurrency.latch.CountUpDownLatch
-import nebulosa.common.exec.CommandLineListener
 import nebulosa.siril.command.SirilCommand.Companion.SCRIPT_EXECUTION_FAILED
+import nebulosa.util.concurrency.latch.CountUpDownLatch
+import nebulosa.util.exec.CommandLineListener
 import java.nio.file.Path
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicBoolean
diff --git a/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/DumpHeader.kt b/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/DumpHeader.kt
index a17992ba3..66143e5e9 100644
--- a/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/DumpHeader.kt
+++ b/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/DumpHeader.kt
@@ -1,12 +1,12 @@
 package nebulosa.siril.command
 
-import nebulosa.common.concurrency.latch.CountUpDownLatch
-import nebulosa.common.exec.CommandLineListener
 import nebulosa.fits.FitsHeader
 import nebulosa.fits.FitsHeaderCard
 import nebulosa.image.format.Header
 import nebulosa.log.debug
 import nebulosa.log.loggerFor
+import nebulosa.util.concurrency.latch.CountUpDownLatch
+import nebulosa.util.exec.CommandLineListener
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicBoolean
 
diff --git a/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/FindStar.kt b/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/FindStar.kt
index aae87d54f..7f1dd01f4 100644
--- a/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/FindStar.kt
+++ b/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/FindStar.kt
@@ -1,11 +1,11 @@
 package nebulosa.siril.command
 
-import nebulosa.common.concurrency.latch.CountUpDownLatch
-import nebulosa.common.exec.CommandLineListener
 import nebulosa.fits.height
 import nebulosa.log.debug
 import nebulosa.log.loggerFor
 import nebulosa.stardetector.StarPoint
+import nebulosa.util.concurrency.latch.CountUpDownLatch
+import nebulosa.util.exec.CommandLineListener
 import java.nio.file.Files
 import java.nio.file.Path
 import java.util.concurrent.TimeUnit
diff --git a/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/LiveStack.kt b/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/LiveStack.kt
index e880af8e1..b5e287d3c 100644
--- a/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/LiveStack.kt
+++ b/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/LiveStack.kt
@@ -1,7 +1,7 @@
 package nebulosa.siril.command
 
-import nebulosa.common.concurrency.latch.CountUpDownLatch
-import nebulosa.common.exec.CommandLineListener
+import nebulosa.util.concurrency.latch.CountUpDownLatch
+import nebulosa.util.exec.CommandLineListener
 import java.nio.file.Path
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicBoolean
diff --git a/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/Load.kt b/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/Load.kt
index ebcc84b36..67d48e7c3 100644
--- a/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/Load.kt
+++ b/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/Load.kt
@@ -1,8 +1,8 @@
 package nebulosa.siril.command
 
-import nebulosa.common.concurrency.latch.CountUpDownLatch
-import nebulosa.common.exec.CommandLineListener
 import nebulosa.siril.command.SirilCommand.Companion.SCRIPT_EXECUTION_FAILED
+import nebulosa.util.concurrency.latch.CountUpDownLatch
+import nebulosa.util.exec.CommandLineListener
 import java.nio.file.Path
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicBoolean
diff --git a/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/PlateSolve.kt b/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/PlateSolve.kt
index 20b39c4b5..9f05c8217 100644
--- a/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/PlateSolve.kt
+++ b/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/PlateSolve.kt
@@ -1,12 +1,12 @@
 package nebulosa.siril.command
 
-import nebulosa.common.concurrency.latch.CountUpDownLatch
-import nebulosa.common.exec.CommandLineListener
 import nebulosa.log.debug
 import nebulosa.log.loggerFor
 import nebulosa.math.*
 import nebulosa.platesolver.Parity
 import nebulosa.platesolver.PlateSolution
+import nebulosa.util.concurrency.latch.CountUpDownLatch
+import nebulosa.util.exec.CommandLineListener
 import java.nio.file.Path
 import java.time.Duration
 import java.util.concurrent.atomic.AtomicBoolean
diff --git a/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/SirilCommandLine.kt b/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/SirilCommandLine.kt
index 836cb8d82..5da2203ef 100644
--- a/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/SirilCommandLine.kt
+++ b/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/SirilCommandLine.kt
@@ -1,11 +1,11 @@
 package nebulosa.siril.command
 
-import nebulosa.common.concurrency.cancel.CancellationListener
-import nebulosa.common.concurrency.cancel.CancellationSource
-import nebulosa.common.exec.CommandLineListener
-import nebulosa.common.exec.commandLine
 import nebulosa.log.debug
 import nebulosa.log.loggerFor
+import nebulosa.util.concurrency.cancellation.CancellationListener
+import nebulosa.util.concurrency.cancellation.CancellationSource
+import nebulosa.util.exec.CommandLineListener
+import nebulosa.util.exec.commandLine
 import java.nio.file.Path
 
 data class SirilCommandLine(private val executablePath: Path) : Runnable, CancellationListener, AutoCloseable {
diff --git a/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/StartLs.kt b/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/StartLs.kt
index 85afd66af..2711b06dc 100644
--- a/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/StartLs.kt
+++ b/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/StartLs.kt
@@ -1,7 +1,7 @@
 package nebulosa.siril.command
 
-import nebulosa.common.concurrency.latch.CountUpDownLatch
-import nebulosa.common.exec.CommandLineListener
+import nebulosa.util.concurrency.latch.CountUpDownLatch
+import nebulosa.util.exec.CommandLineListener
 import java.nio.file.Path
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicBoolean
diff --git a/nebulosa-siril/src/main/kotlin/nebulosa/siril/livestacker/SirilLiveStacker.kt b/nebulosa-siril/src/main/kotlin/nebulosa/siril/livestacker/SirilLiveStacker.kt
index a140a84c9..a6630488d 100644
--- a/nebulosa-siril/src/main/kotlin/nebulosa/siril/livestacker/SirilLiveStacker.kt
+++ b/nebulosa-siril/src/main/kotlin/nebulosa/siril/livestacker/SirilLiveStacker.kt
@@ -1,11 +1,11 @@
 package nebulosa.siril.livestacker
 
-import nebulosa.common.concurrency.latch.CountUpDownLatch
-import nebulosa.common.exec.CommandLineListener
 import nebulosa.livestacker.LiveStacker
 import nebulosa.log.debug
 import nebulosa.log.loggerFor
 import nebulosa.siril.command.*
+import nebulosa.util.concurrency.latch.CountUpDownLatch
+import nebulosa.util.exec.CommandLineListener
 import java.nio.file.Path
 import kotlin.io.path.deleteIfExists
 import kotlin.io.path.listDirectoryEntries
diff --git a/nebulosa-siril/src/main/kotlin/nebulosa/siril/platesolver/SirilPlateSolver.kt b/nebulosa-siril/src/main/kotlin/nebulosa/siril/platesolver/SirilPlateSolver.kt
index 9af5bd07c..5e9877b8a 100644
--- a/nebulosa-siril/src/main/kotlin/nebulosa/siril/platesolver/SirilPlateSolver.kt
+++ b/nebulosa-siril/src/main/kotlin/nebulosa/siril/platesolver/SirilPlateSolver.kt
@@ -1,6 +1,5 @@
 package nebulosa.siril.platesolver
 
-import nebulosa.common.concurrency.cancel.CancellationToken
 import nebulosa.image.Image
 import nebulosa.math.Angle
 import nebulosa.math.toDegrees
@@ -8,6 +7,7 @@ import nebulosa.platesolver.PlateSolution
 import nebulosa.platesolver.PlateSolver
 import nebulosa.siril.command.PlateSolve
 import nebulosa.siril.command.SirilCommandLine
+import nebulosa.util.concurrency.cancellation.CancellationToken
 import java.nio.file.Path
 import java.time.Duration
 
diff --git a/nebulosa-stacker/build.gradle.kts b/nebulosa-stacker/build.gradle.kts
index 2a152853f..80f7624d3 100644
--- a/nebulosa-stacker/build.gradle.kts
+++ b/nebulosa-stacker/build.gradle.kts
@@ -4,7 +4,7 @@ plugins {
 }
 
 dependencies {
-    api(project(":nebulosa-common"))
+    api(project(":nebulosa-util"))
     implementation(project(":nebulosa-log"))
 }
 
diff --git a/nebulosa-stacker/src/main/kotlin/nebulosa/stacker/AutoStacker.kt b/nebulosa-stacker/src/main/kotlin/nebulosa/stacker/AutoStacker.kt
index 12ed1d6a9..5ba9bcedb 100644
--- a/nebulosa-stacker/src/main/kotlin/nebulosa/stacker/AutoStacker.kt
+++ b/nebulosa-stacker/src/main/kotlin/nebulosa/stacker/AutoStacker.kt
@@ -1,6 +1,6 @@
 package nebulosa.stacker
 
-import nebulosa.common.concurrency.cancel.CancellationToken
+import nebulosa.util.concurrency.cancellation.CancellationToken
 import java.nio.file.Path
 
 interface AutoStacker : Stacker {
diff --git a/nebulosa-test/src/main/kotlin/nebulosa/test/Http.kt b/nebulosa-test/src/main/kotlin/nebulosa/test/Http.kt
index bf45e0490..fc6bb6cf3 100644
--- a/nebulosa-test/src/main/kotlin/nebulosa/test/Http.kt
+++ b/nebulosa-test/src/main/kotlin/nebulosa/test/Http.kt
@@ -1,5 +1,4 @@
 @file:JvmName("Http")
-@file:Suppress("NOTHING_TO_INLINE")
 
 package nebulosa.test
 
diff --git a/nebulosa-test/src/main/kotlin/nebulosa/test/Extensions.kt b/nebulosa-test/src/main/kotlin/nebulosa/test/IO.kt
similarity index 100%
rename from nebulosa-test/src/main/kotlin/nebulosa/test/Extensions.kt
rename to nebulosa-test/src/main/kotlin/nebulosa/test/IO.kt
diff --git a/nebulosa-test/src/main/kotlin/nebulosa/test/Matchers.kt b/nebulosa-test/src/main/kotlin/nebulosa/test/Matchers.kt
deleted file mode 100644
index 0bfadb132..000000000
--- a/nebulosa-test/src/main/kotlin/nebulosa/test/Matchers.kt
+++ /dev/null
@@ -1,4 +0,0 @@
-@file:JvmName("Matchers")
-@file:Suppress("NOTHING_TO_INLINE")
-
-package nebulosa.test
diff --git a/nebulosa-time/build.gradle.kts b/nebulosa-time/build.gradle.kts
index 53c46ddfe..e72a1bac9 100644
--- a/nebulosa-time/build.gradle.kts
+++ b/nebulosa-time/build.gradle.kts
@@ -4,8 +4,8 @@ plugins {
 }
 
 dependencies {
-    api(project(":nebulosa-common"))
     api(project(":nebulosa-erfa"))
+    api(project(":nebulosa-util"))
     testImplementation(project(":nebulosa-test"))
 }
 
diff --git a/nebulosa-time/src/main/kotlin/nebulosa/time/CurrentTime.kt b/nebulosa-time/src/main/kotlin/nebulosa/time/CurrentTime.kt
index 68514ddcd..ff52676d8 100644
--- a/nebulosa-time/src/main/kotlin/nebulosa/time/CurrentTime.kt
+++ b/nebulosa-time/src/main/kotlin/nebulosa/time/CurrentTime.kt
@@ -1,6 +1,6 @@
 package nebulosa.time
 
-import nebulosa.common.time.Stopwatch
+import nebulosa.util.time.Stopwatch
 
 data object CurrentTime : InstantOfTime() {
 
diff --git a/nebulosa-time/src/main/kotlin/nebulosa/time/SystemClock.kt b/nebulosa-time/src/main/kotlin/nebulosa/time/SystemClock.kt
index 9021c3209..3521b8b1a 100644
--- a/nebulosa-time/src/main/kotlin/nebulosa/time/SystemClock.kt
+++ b/nebulosa-time/src/main/kotlin/nebulosa/time/SystemClock.kt
@@ -1,15 +1,16 @@
 package nebulosa.time
 
 import java.time.Clock
+import java.time.Instant
 import java.time.ZoneId
 
 object SystemClock : Clock() {
 
     private val clock = systemDefaultZone()
 
-    override fun getZone() = ZoneId.systemDefault()
+    override fun getZone(): ZoneId = ZoneId.systemDefault()
 
-    override fun withZone(zone: ZoneId) = clock.withZone(zone)
+    override fun withZone(zone: ZoneId): Clock = clock.withZone(zone)
 
-    override fun instant() = clock.instant()
+    override fun instant(): Instant = clock.instant()
 }
diff --git a/nebulosa-common/build.gradle.kts b/nebulosa-util/build.gradle.kts
similarity index 100%
rename from nebulosa-common/build.gradle.kts
rename to nebulosa-util/build.gradle.kts
diff --git a/nebulosa-common/src/main/kotlin/nebulosa/common/Resettable.kt b/nebulosa-util/src/main/kotlin/nebulosa/util/Resettable.kt
similarity index 66%
rename from nebulosa-common/src/main/kotlin/nebulosa/common/Resettable.kt
rename to nebulosa-util/src/main/kotlin/nebulosa/util/Resettable.kt
index 204395136..21d236409 100644
--- a/nebulosa-common/src/main/kotlin/nebulosa/common/Resettable.kt
+++ b/nebulosa-util/src/main/kotlin/nebulosa/util/Resettable.kt
@@ -1,4 +1,4 @@
-package nebulosa.common
+package nebulosa.util
 
 fun interface Resettable {
 
diff --git a/nebulosa-util/src/main/kotlin/nebulosa/util/Startable.kt b/nebulosa-util/src/main/kotlin/nebulosa/util/Startable.kt
new file mode 100644
index 000000000..41e9dc38d
--- /dev/null
+++ b/nebulosa-util/src/main/kotlin/nebulosa/util/Startable.kt
@@ -0,0 +1,6 @@
+package nebulosa.util
+
+fun interface Startable {
+
+    fun start()
+}
diff --git a/nebulosa-util/src/main/kotlin/nebulosa/util/Stoppable.kt b/nebulosa-util/src/main/kotlin/nebulosa/util/Stoppable.kt
new file mode 100644
index 000000000..d058daf4d
--- /dev/null
+++ b/nebulosa-util/src/main/kotlin/nebulosa/util/Stoppable.kt
@@ -0,0 +1,6 @@
+package nebulosa.util
+
+fun interface Stoppable {
+
+    fun stop()
+}
diff --git a/nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/DaemonThreadFactory.kt b/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/DaemonThreadFactory.kt
similarity index 87%
rename from nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/DaemonThreadFactory.kt
rename to nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/DaemonThreadFactory.kt
index d7350485d..6bbedd3ae 100644
--- a/nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/DaemonThreadFactory.kt
+++ b/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/DaemonThreadFactory.kt
@@ -1,4 +1,4 @@
-package nebulosa.common.concurrency
+package nebulosa.util.concurrency
 
 import java.util.concurrent.ThreadFactory
 
diff --git a/nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/atomic/Incrementer.kt b/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/atomic/Incrementer.kt
similarity index 90%
rename from nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/atomic/Incrementer.kt
rename to nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/atomic/Incrementer.kt
index b79f9cb25..6733ab4ba 100644
--- a/nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/atomic/Incrementer.kt
+++ b/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/atomic/Incrementer.kt
@@ -1,6 +1,6 @@
-package nebulosa.common.concurrency.atomic
+package nebulosa.util.concurrency.atomic
 
-import nebulosa.common.Resettable
+import nebulosa.util.Resettable
 import java.util.concurrent.atomic.AtomicLong
 import java.util.function.Supplier
 
diff --git a/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/cancellation/Cancellable.kt b/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/cancellation/Cancellable.kt
new file mode 100644
index 000000000..a1a8bdb0c
--- /dev/null
+++ b/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/cancellation/Cancellable.kt
@@ -0,0 +1,6 @@
+package nebulosa.util.concurrency.cancellation
+
+interface Cancellable {
+
+    fun cancel(source: CancellationSource = CancellationSource.DEFAULT): Boolean
+}
diff --git a/nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/cancel/CancellationListener.kt b/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/cancellation/CancellationListener.kt
similarity index 64%
rename from nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/cancel/CancellationListener.kt
rename to nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/cancellation/CancellationListener.kt
index c2ea9a3ae..9354c62d2 100644
--- a/nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/cancel/CancellationListener.kt
+++ b/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/cancellation/CancellationListener.kt
@@ -1,4 +1,4 @@
-package nebulosa.common.concurrency.cancel
+package nebulosa.util.concurrency.cancellation
 
 fun interface CancellationListener {
 
diff --git a/nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/cancel/CancellationSource.kt b/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/cancellation/CancellationSource.kt
similarity index 72%
rename from nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/cancel/CancellationSource.kt
rename to nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/cancellation/CancellationSource.kt
index c57bfe088..f2122252e 100644
--- a/nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/cancel/CancellationSource.kt
+++ b/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/cancellation/CancellationSource.kt
@@ -1,4 +1,4 @@
-package nebulosa.common.concurrency.cancel
+package nebulosa.util.concurrency.cancellation
 
 interface CancellationSource {
 
@@ -11,4 +11,9 @@ interface CancellationSource {
     data object Close : CancellationSource
 
     data class Exceptionally(val exception: Throwable) : CancellationSource
+
+    companion object {
+
+        @JvmStatic val DEFAULT = Cancel(true)
+    }
 }
diff --git a/nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/cancel/CancellationToken.kt b/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/cancellation/CancellationToken.kt
similarity index 87%
rename from nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/cancel/CancellationToken.kt
rename to nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/cancellation/CancellationToken.kt
index 5389e2366..29432026e 100644
--- a/nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/cancel/CancellationToken.kt
+++ b/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/cancellation/CancellationToken.kt
@@ -1,13 +1,13 @@
-package nebulosa.common.concurrency.cancel
+package nebulosa.util.concurrency.cancellation
 
-import nebulosa.common.concurrency.latch.Pauser
+import nebulosa.util.concurrency.latch.Pauser
 import java.util.concurrent.CancellationException
 import java.util.concurrent.CompletableFuture
 import java.util.concurrent.Future
 import java.util.concurrent.TimeUnit
 
 class CancellationToken private constructor(private val completable: CompletableFuture<CancellationSource>?) :
-    Pauser(), AutoCloseable, Future<CancellationSource> {
+    Pauser(), Cancellable, Future<CancellationSource>, AutoCloseable {
 
     constructor() : this(CompletableFuture<CancellationSource>())
 
@@ -48,16 +48,12 @@ class CancellationToken private constructor(private val completable: Completable
         listeners.clear()
     }
 
-    fun cancel() {
-        cancel(true)
-    }
-
     override fun cancel(mayInterruptIfRunning: Boolean): Boolean {
         return cancel(CancellationSource.Cancel(mayInterruptIfRunning))
     }
 
     @Synchronized
-    fun cancel(source: CancellationSource): Boolean {
+    override fun cancel(source: CancellationSource): Boolean {
         unpause()
         completable?.complete(source) ?: return false
         return true
@@ -80,7 +76,9 @@ class CancellationToken private constructor(private val completable: Completable
     }
 
     fun throwIfCancelled() {
-        if (isCancelled) throw CancellationException()
+        if (isCancelled) {
+            throw CancellationException()
+        }
     }
 
     override fun close() {
diff --git a/nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/latch/CountUpDownLatch.kt b/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/latch/CountUpDownLatch.kt
similarity index 93%
rename from nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/latch/CountUpDownLatch.kt
rename to nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/latch/CountUpDownLatch.kt
index 508135ae0..5824bec5b 100644
--- a/nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/latch/CountUpDownLatch.kt
+++ b/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/latch/CountUpDownLatch.kt
@@ -1,7 +1,7 @@
-package nebulosa.common.concurrency.latch
+package nebulosa.util.concurrency.latch
 
-import nebulosa.common.concurrency.cancel.CancellationListener
-import nebulosa.common.concurrency.cancel.CancellationSource
+import nebulosa.util.concurrency.cancellation.CancellationListener
+import nebulosa.util.concurrency.cancellation.CancellationSource
 import java.time.Duration
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicBoolean
diff --git a/nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/latch/PauseListener.kt b/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/latch/PauseListener.kt
similarity index 61%
rename from nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/latch/PauseListener.kt
rename to nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/latch/PauseListener.kt
index 14ac8836f..be7a29803 100644
--- a/nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/latch/PauseListener.kt
+++ b/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/latch/PauseListener.kt
@@ -1,4 +1,4 @@
-package nebulosa.common.concurrency.latch
+package nebulosa.util.concurrency.latch
 
 fun interface PauseListener {
 
diff --git a/nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/latch/Pauseable.kt b/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/latch/Pauseable.kt
similarity index 67%
rename from nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/latch/Pauseable.kt
rename to nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/latch/Pauseable.kt
index d0f0b7089..bb9c3a16e 100644
--- a/nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/latch/Pauseable.kt
+++ b/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/latch/Pauseable.kt
@@ -1,4 +1,4 @@
-package nebulosa.common.concurrency.latch
+package nebulosa.util.concurrency.latch
 
 interface Pauseable {
 
diff --git a/nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/latch/Pauser.kt b/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/latch/Pauser.kt
similarity index 96%
rename from nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/latch/Pauser.kt
rename to nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/latch/Pauser.kt
index 3a1316d76..71ab73385 100644
--- a/nebulosa-common/src/main/kotlin/nebulosa/common/concurrency/latch/Pauser.kt
+++ b/nebulosa-util/src/main/kotlin/nebulosa/util/concurrency/latch/Pauser.kt
@@ -1,4 +1,4 @@
-package nebulosa.common.concurrency.latch
+package nebulosa.util.concurrency.latch
 
 import java.time.Duration
 import java.util.concurrent.TimeUnit
diff --git a/nebulosa-common/src/main/kotlin/nebulosa/common/exec/CommandLine.kt b/nebulosa-util/src/main/kotlin/nebulosa/util/exec/CommandLine.kt
similarity index 97%
rename from nebulosa-common/src/main/kotlin/nebulosa/common/exec/CommandLine.kt
rename to nebulosa-util/src/main/kotlin/nebulosa/util/exec/CommandLine.kt
index 2f34a5c0f..61e843acd 100644
--- a/nebulosa-common/src/main/kotlin/nebulosa/common/exec/CommandLine.kt
+++ b/nebulosa-util/src/main/kotlin/nebulosa/util/exec/CommandLine.kt
@@ -1,8 +1,8 @@
-package nebulosa.common.exec
+package nebulosa.util.exec
 
-import nebulosa.common.concurrency.cancel.CancellationListener
-import nebulosa.common.concurrency.cancel.CancellationSource
 import nebulosa.log.loggerFor
+import nebulosa.util.concurrency.cancellation.CancellationListener
+import nebulosa.util.concurrency.cancellation.CancellationSource
 import java.io.InputStream
 import java.io.OutputStream
 import java.io.PrintStream
@@ -16,7 +16,7 @@ inline fun commandLine(action: CommandLine.Builder.() -> Unit): CommandLine {
     return CommandLine.Builder().also(action).get()
 }
 
-data class CommandLine internal constructor(
+class CommandLine internal constructor(
     private val builder: ProcessBuilder,
     private val listeners: LinkedHashSet<CommandLineListener>,
 ) : CompletableFuture<Int>(), CancellationListener {
diff --git a/nebulosa-common/src/main/kotlin/nebulosa/common/exec/CommandLineListener.kt b/nebulosa-util/src/main/kotlin/nebulosa/util/exec/CommandLineListener.kt
similarity index 92%
rename from nebulosa-common/src/main/kotlin/nebulosa/common/exec/CommandLineListener.kt
rename to nebulosa-util/src/main/kotlin/nebulosa/util/exec/CommandLineListener.kt
index 9b32a8827..aeccacc63 100644
--- a/nebulosa-common/src/main/kotlin/nebulosa/common/exec/CommandLineListener.kt
+++ b/nebulosa-util/src/main/kotlin/nebulosa/util/exec/CommandLineListener.kt
@@ -1,4 +1,4 @@
-package nebulosa.common.exec
+package nebulosa.util.exec
 
 interface CommandLineListener {
 
diff --git a/nebulosa-common/src/main/kotlin/nebulosa/common/time/Stopwatch.kt b/nebulosa-util/src/main/kotlin/nebulosa/util/time/Stopwatch.kt
similarity index 97%
rename from nebulosa-common/src/main/kotlin/nebulosa/common/time/Stopwatch.kt
rename to nebulosa-util/src/main/kotlin/nebulosa/util/time/Stopwatch.kt
index 11a47070c..0e7706f9d 100644
--- a/nebulosa-common/src/main/kotlin/nebulosa/common/time/Stopwatch.kt
+++ b/nebulosa-util/src/main/kotlin/nebulosa/util/time/Stopwatch.kt
@@ -1,6 +1,6 @@
-package nebulosa.common.time
+package nebulosa.util.time
 
-import nebulosa.common.Resettable
+import nebulosa.util.Resettable
 import java.time.Duration
 
 /**
diff --git a/nebulosa-common/src/test/kotlin/CancellationTokenTest.kt b/nebulosa-util/src/test/kotlin/CancellationTokenTest.kt
similarity index 89%
rename from nebulosa-common/src/test/kotlin/CancellationTokenTest.kt
rename to nebulosa-util/src/test/kotlin/CancellationTokenTest.kt
index c5faaad61..e288aa785 100644
--- a/nebulosa-common/src/test/kotlin/CancellationTokenTest.kt
+++ b/nebulosa-util/src/test/kotlin/CancellationTokenTest.kt
@@ -2,8 +2,8 @@ import io.kotest.matchers.booleans.shouldBeFalse
 import io.kotest.matchers.booleans.shouldBeTrue
 import io.kotest.matchers.nulls.shouldBeNull
 import io.kotest.matchers.shouldBe
-import nebulosa.common.concurrency.cancel.CancellationSource
-import nebulosa.common.concurrency.cancel.CancellationToken
+import nebulosa.util.concurrency.cancellation.CancellationSource
+import nebulosa.util.concurrency.cancellation.CancellationToken
 import org.junit.jupiter.api.Test
 
 class CancellationTokenTest {
@@ -27,7 +27,7 @@ class CancellationTokenTest {
         token.listen { source = it }
         token.cancel()
         token.get() shouldBe source
-        source shouldBe CancellationSource.Cancel(true)
+        source shouldBe CancellationSource.DEFAULT
         token.isCancelled.shouldBeTrue()
         token.isDone.shouldBeTrue()
     }
@@ -50,7 +50,7 @@ class CancellationTokenTest {
         val token = CancellationToken()
         token.cancel()
         token.listen { source = it }
-        token.get() shouldBe CancellationSource.Cancel(true)
+        token.get() shouldBe CancellationSource.DEFAULT
         source shouldBe CancellationSource.Listen
         token.isCancelled.shouldBeTrue()
         token.isDone.shouldBeTrue()
diff --git a/nebulosa-common/src/test/kotlin/CommandLineTest.kt b/nebulosa-util/src/test/kotlin/CommandLineTest.kt
similarity index 95%
rename from nebulosa-common/src/test/kotlin/CommandLineTest.kt
rename to nebulosa-util/src/test/kotlin/CommandLineTest.kt
index fdfcf58f3..8f79ad192 100644
--- a/nebulosa-common/src/test/kotlin/CommandLineTest.kt
+++ b/nebulosa-util/src/test/kotlin/CommandLineTest.kt
@@ -4,9 +4,9 @@ import io.kotest.matchers.ints.shouldBeExactly
 import io.kotest.matchers.ints.shouldNotBeExactly
 import io.kotest.matchers.longs.shouldBeGreaterThanOrEqual
 import io.kotest.matchers.longs.shouldBeLessThan
-import nebulosa.common.exec.CommandLineListener
-import nebulosa.common.exec.commandLine
 import nebulosa.test.LinuxOnly
+import nebulosa.util.exec.CommandLineListener
+import nebulosa.util.exec.commandLine
 import org.junit.jupiter.api.Test
 import java.nio.file.Path
 import java.time.Duration
diff --git a/nebulosa-common/src/test/kotlin/CountUpDownLatchTest.kt b/nebulosa-util/src/test/kotlin/CountUpDownLatchTest.kt
similarity index 98%
rename from nebulosa-common/src/test/kotlin/CountUpDownLatchTest.kt
rename to nebulosa-util/src/test/kotlin/CountUpDownLatchTest.kt
index ad393cbd6..727e4600c 100644
--- a/nebulosa-common/src/test/kotlin/CountUpDownLatchTest.kt
+++ b/nebulosa-util/src/test/kotlin/CountUpDownLatchTest.kt
@@ -2,7 +2,7 @@ import io.kotest.matchers.booleans.shouldBeFalse
 import io.kotest.matchers.booleans.shouldBeTrue
 import io.kotest.matchers.ints.shouldBeExactly
 import io.kotest.matchers.longs.shouldBeGreaterThanOrEqual
-import nebulosa.common.concurrency.latch.CountUpDownLatch
+import nebulosa.util.concurrency.latch.CountUpDownLatch
 import org.junit.jupiter.api.Test
 import java.util.concurrent.TimeUnit
 import kotlin.concurrent.thread
diff --git a/nebulosa-common/src/test/kotlin/PauserTest.kt b/nebulosa-util/src/test/kotlin/PauserTest.kt
similarity index 94%
rename from nebulosa-common/src/test/kotlin/PauserTest.kt
rename to nebulosa-util/src/test/kotlin/PauserTest.kt
index d4161dba6..1cf70005c 100644
--- a/nebulosa-common/src/test/kotlin/PauserTest.kt
+++ b/nebulosa-util/src/test/kotlin/PauserTest.kt
@@ -1,6 +1,6 @@
 import io.kotest.matchers.booleans.shouldBeFalse
 import io.kotest.matchers.booleans.shouldBeTrue
-import nebulosa.common.concurrency.latch.Pauser
+import nebulosa.util.concurrency.latch.Pauser
 import org.junit.jupiter.api.Test
 import java.util.concurrent.TimeUnit
 import kotlin.concurrent.thread
diff --git a/nebulosa-watney/src/main/kotlin/nebulosa/watney/platesolver/WatneyPlateSolver.kt b/nebulosa-watney/src/main/kotlin/nebulosa/watney/platesolver/WatneyPlateSolver.kt
index abac46e42..759f5b3fa 100644
--- a/nebulosa-watney/src/main/kotlin/nebulosa/watney/platesolver/WatneyPlateSolver.kt
+++ b/nebulosa-watney/src/main/kotlin/nebulosa/watney/platesolver/WatneyPlateSolver.kt
@@ -1,6 +1,5 @@
 package nebulosa.watney.platesolver
 
-import nebulosa.common.concurrency.cancel.CancellationToken
 import nebulosa.erfa.SphericalCoordinate
 import nebulosa.fits.FitsHeader
 import nebulosa.fits.FitsKeyword
@@ -17,6 +16,7 @@ import nebulosa.platesolver.PlateSolution
 import nebulosa.platesolver.PlateSolver
 import nebulosa.stardetector.StarDetector
 import nebulosa.stardetector.StarPoint
+import nebulosa.util.concurrency.cancellation.CancellationToken
 import nebulosa.watney.platesolver.math.equatorialToStandardCoordinates
 import nebulosa.watney.platesolver.math.lerp
 import nebulosa.watney.platesolver.math.solveLeastSquares
diff --git a/nebulosa-xisf/src/main/kotlin/nebulosa/xisf/XisfHeaderInputStream.kt b/nebulosa-xisf/src/main/kotlin/nebulosa/xisf/XisfHeaderInputStream.kt
index 92bf128d7..0edcc8146 100644
--- a/nebulosa-xisf/src/main/kotlin/nebulosa/xisf/XisfHeaderInputStream.kt
+++ b/nebulosa-xisf/src/main/kotlin/nebulosa/xisf/XisfHeaderInputStream.kt
@@ -127,9 +127,9 @@ class XisfHeaderInputStream(source: InputStream) : AutoCloseable {
     }
 
     private fun parseProperty(): HeaderCard? {
-        val id = reader.attribute("id")!!
+        val id = reader.attribute("id") ?: return null
         val key = AstronomicalImageProperties[id] ?: return null
-        val propertyType = XisfPropertyType.fromTypeName(reader.attribute("type")!!) ?: return null
+        val propertyType = XisfPropertyType.fromTypeName(reader.attribute("type") ?: return null) ?: return null
         val value = reader.attribute("value") ?: reader.elementText.trim()
         return XisfHeaderCard(key.key, value, key.comment, propertyType)
     }
diff --git a/settings.gradle.kts b/settings.gradle.kts
index e759e31d9..9bf125d99 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -12,31 +12,34 @@ buildCache {
 dependencyResolutionManagement {
     versionCatalogs {
         create("libs") {
-            library("okio", "com.squareup.okio:okio:3.9.0")
+            library("okio", "com.squareup.okio:okio:3.9.1")
             library("okhttp", "com.squareup.okhttp3:okhttp:4.12.0")
             library("okhttp-logging", "com.squareup.okhttp3:logging-interceptor:4.12.0")
-            library("jackson-core", "com.fasterxml.jackson.core:jackson-databind:2.17.2")
-            library("jackson-jsr310", "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.17.2")
-            library("jackson-kt", "com.fasterxml.jackson.module:jackson-module-kotlin:2.17.2")
+            library("jackson-core", "com.fasterxml.jackson.core:jackson-databind:2.18.0")
+            library("jackson-jsr310", "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.18.0")
+            library("jackson-kt", "com.fasterxml.jackson.module:jackson-module-kotlin:2.18.0")
             library("retrofit", "com.squareup.retrofit2:retrofit:2.11.0")
             library("retrofit-jackson", "com.squareup.retrofit2:converter-jackson:2.11.0")
             library("rx", "io.reactivex.rxjava3:rxjava:3.1.9")
-            library("logback", "ch.qos.logback:logback-classic:1.5.7")
+            library("logback", "ch.qos.logback:logback-classic:1.5.8")
             library("eventbus", "org.greenrobot:eventbus-java:3.3.1")
-            library("netty-transport", "io.netty:netty-transport:4.1.112.Final")
-            library("netty-codec", "io.netty:netty-codec:4.1.112.Final")
+            library("netty-transport", "io.netty:netty-transport:4.1.113.Final")
+            library("netty-codec", "io.netty:netty-codec:4.1.113.Final")
             library("xml", "com.fasterxml:aalto-xml:1.3.3")
-            library("csv", "de.siegmar:fastcsv:3.2.0")
-            library("apache-lang3", "org.apache.commons:commons-lang3:3.16.0")
+            library("csv", "de.siegmar:fastcsv:3.3.1")
+            library("apache-lang3", "org.apache.commons:commons-lang3:3.17.0")
             library("apache-codec", "commons-codec:commons-codec:1.17.1")
             library("apache-collections", "org.apache.commons:commons-collections4:4.4")
             library("apache-math", "org.apache.commons:commons-math3:3.6.1")
             library("apache-numbers-complex", "org.apache.commons:commons-numbers-complex:1.2")
-            library("oshi", "com.github.oshi:oshi-core:6.6.3")
-            library("jna", "net.java.dev.jna:jna:5.14.0")
+            library("oshi", "com.github.oshi:oshi-core:6.6.5")
+            library("jna", "net.java.dev.jna:jna:5.15.0")
+            library("javalin", "io.javalin:javalin:6.3.0")
+            library("koin", "io.insert-koin:koin-core:4.0.0")
+            library("airline", "com.github.rvesse:airline:3.0.0")
             library("kotest", "io.kotest:kotest-assertions-core:5.9.1")
-            library("junit-api", "org.junit.jupiter:junit-jupiter-api:5.11.0")
-            library("junit-engine", "org.junit.jupiter:junit-jupiter-engine:5.11.0")
+            library("junit-api", "org.junit.jupiter:junit-jupiter-api:5.11.1")
+            library("junit-engine", "org.junit.jupiter:junit-jupiter-engine:5.11.1")
             bundle("netty", listOf("netty-transport", "netty-codec"))
             bundle("jackson", listOf("jackson-core", "jackson-jsr310", "jackson-kt"))
         }
@@ -53,7 +56,7 @@ include(":nebulosa-astap")
 include(":nebulosa-astrobin-api")
 include(":nebulosa-astrometrynet")
 include(":nebulosa-astrometrynet-jna")
-include(":nebulosa-common")
+include(":nebulosa-autofocus")
 include(":nebulosa-constants")
 include(":nebulosa-curve-fitting")
 include(":nebulosa-erfa")
@@ -69,6 +72,7 @@ include(":nebulosa-indi-client")
 include(":nebulosa-indi-device")
 include(":nebulosa-indi-protocol")
 include(":nebulosa-io")
+include(":nebulosa-job-manager")
 include(":nebulosa-json")
 include(":nebulosa-livestacker")
 include(":nebulosa-log")
@@ -93,6 +97,7 @@ include(":nebulosa-stacker")
 include(":nebulosa-stellarium-protocol")
 include(":nebulosa-test")
 include(":nebulosa-time")
+include(":nebulosa-util")
 include(":nebulosa-vizier")
 include(":nebulosa-watney")
 include(":nebulosa-wcs")