Merge pull request #15 from integr-dev/develop

### Performance & Optimization
* Parallelized the plugin startup and shutdown process, significantly reducing loading times.
* Optimized the logging system to be more flexible and reduce impact on startup speed.
* Introduced a dedicated server dispatcher to ensure background tasks interact safely with the main server thread.

### Configuration & Management
* Centralized all plugin settings into a new configuration system for easier management.
* Added a new configuration option to toggle automatic update checks.
* Simplified the "wipe" command by removing unnecessary confirmation steps for faster administration.

### Diagnostics & Stability
* Added a new "probes" command to help administrators detect and manage memory leaks caused by script hot-reloading.
* Implemented an automated background checker to monitor and report potential performance leaks.
* Improved the accuracy of startup and shutdown duration logging for better performance tracking.

### Documentation
* Updated the README and example code to provide clearer instructions on configuration and resource management.

Author: integr-dev

README.md

@@ -170,7 +170,7 @@ Backbone provides a simple and powerful way to manage your plugin's data and con
 
 #### Resource Pools
 
-A `ResourcePool` is a namespaced container for your resources. It's recommended to create a separate pool for each script or feature set to avoid conflicts.
+A `ResourcePool` is a namespaced container for your resources. It's recommended to create a separate pool for each part of your server set to avoid conflicts.
 
 ```kotlin
 // Create a resource pool for your script's storage
@@ -186,18 +186,17 @@ This will create directories at `storage/mystorage/` and `config/myconfig/` in y
 
 You can manage typed configuration files. Backbone handles the serialization and deserialization of your data classes automatically.
 
-First, define a serializable data class for your configuration:
+First, define a data class for your configuration:
 
 ```kotlin
-@Serializable // Requires the kotlinx.serialization plugin
 data class MyConfig(val settingA: String = "default", val settingB: Int = 10)
 ```
 
 Then, use the `config()` function on your resource pool to get a handler for it:
 
 ```kotlin
 // Get a handler for a config file named 'settings.yml'
-val configHandler = myScriptConfig.config<MyConfig>("settings.yml")
+val configHandler = myScriptConfig.config<MyConfig>("settings.yml", MyConfig())
 
 // Load the config file synchronously
 configHandler.updateSync()

build.gradle.kts

@@ -7,7 +7,7 @@ plugins {
 }
 
 group = "net.integr"
-version = "1.7.1"
+version = "1.8.0"
 
 repositories {
     mavenCentral()

src/main/kotlin/net/integr/backbone/Backbone.kt

@@ -18,6 +18,7 @@ import net.integr.backbone.systems.entity.EntityHandler
 import net.integr.backbone.systems.event.EventBus
 import net.integr.backbone.systems.gui.GuiHandler
 import net.integr.backbone.systems.item.ItemHandler
+import net.integr.backbone.systems.logger.BackboneLogger
 import net.integr.backbone.systems.permission.PermissionNode
 import net.integr.backbone.systems.placeholder.PlaceholderGroup
 import net.integr.backbone.systems.storage.ResourcePool
@@ -61,6 +62,23 @@ object Backbone {
     @ApiStatus.Internal
     val CONFIG_POOL = ResourcePool.fromConfig("backbone")
 
+    /**
+     * Backbones main config. **Important:** Do not use this.
+     * Create a new config instead:
+     * ```kotlin
+     * val config = pool.config<MyConfig>("my-config.yaml")
+     * ```
+     *
+     * @since 1.8.0
+     */
+    @get:ApiStatus.Internal
+    val MAIN_CONFIG by lazy {
+        CONFIG_POOL.config("backbone.yaml", BackboneConfig())
+    }
+
+    val CONFIG_STATE
+        get() = MAIN_CONFIG.getState()!!
+
     /**
      * Internal script pool.
      *
@@ -78,8 +96,10 @@ object Backbone {
      *
      * @since 1.0.0
      */
-    @ApiStatus.Internal
-    val LOGGER = BackboneLogger("backbone")
+    @get:ApiStatus.Internal
+    val LOGGER by lazy {
+        BackboneLogger("backbone", MAIN_CONFIG.getState()!!.loggerCompatibilityMode, pluginInternal)
+    }
 
     /**
      * Backbones root permission. **Important:** Do not use this for your own permission checks.
@@ -116,7 +136,8 @@ object Backbone {
      *
      * @since 1.0.0
      */
-    private val pluginInternal: JavaPlugin? by lazy {
+    @get:ApiStatus.Internal
+    internal val pluginInternal: JavaPlugin? by lazy {
         Utils.tryOrNull { JavaPlugin.getPlugin(BackboneServer::class.java) } // For testing purposes we allow null here
     }
 

src/main/kotlin/net/integr/backbone/BackboneConfig.kt

@@ -0,0 +1,20 @@
+/*
+ * Copyright © 2026 Integr
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.integr.backbone
+
+
+data class BackboneConfig(
+    val checkForUpdates: Boolean = true,
+    val loggerCompatibilityMode: Boolean = false
+)

src/main/kotlin/net/integr/backbone/BackboneServer.kt

@@ -13,22 +13,27 @@
 
 package net.integr.backbone
 
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import net.integr.backbone.commands.BackboneCommand
 import net.integr.backbone.events.TickEvent
 import net.integr.backbone.systems.bstats.BStatHandler
+import net.integr.backbone.systems.diagnostic.ProbeHandler
 import net.integr.backbone.systems.entity.EntityHandler
 import net.integr.backbone.systems.event.EventBus
 import net.integr.backbone.systems.gui.GuiHandler
 import net.integr.backbone.systems.hotloader.ScriptEngine
 import net.integr.backbone.systems.hotloader.ScriptLinker
 import net.integr.backbone.systems.item.ItemHandler
+import net.integr.backbone.systems.update.UpdateChecker
 import org.bukkit.plugin.java.JavaPlugin
 import org.bukkit.scheduler.BukkitTask
 import org.jetbrains.annotations.ApiStatus
 import java.io.FileDescriptor
 import java.io.FileOutputStream
 import java.io.PrintStream
+import kotlin.time.measureTime
 
 /**
  * The main plugin class for the Backbone API.
@@ -37,6 +42,7 @@ import java.io.PrintStream
 @ApiStatus.Internal
 class BackboneServer : JavaPlugin() {
     private var tickTask: BukkitTask? = null
+    private var probeCheckerTask: BukkitTask? = null
     private var beforeOut: PrintStream? = null
     private var beforeErr: PrintStream? = null
 
@@ -45,64 +51,102 @@ class BackboneServer : JavaPlugin() {
      * @since 1.0.0
      */
     override fun onEnable() {
-        val out = PrintStream(FileOutputStream(FileDescriptor.out), true)
-        val err = PrintStream(FileOutputStream(FileDescriptor.err), true)
+        val timeTaken = measureTime {
+            val out = PrintStream(FileOutputStream(FileDescriptor.out), true)
+            val err = PrintStream(FileOutputStream(FileDescriptor.err), true)
 
-        beforeOut = System.out
-        beforeErr = System.err
+            beforeOut = System.out
+            beforeErr = System.err
 
-        // Bypass papers println intercept
-        System.setOut(out)
-        System.setErr(err)
+            // Bypass papers println intercept
+            System.setOut(out)
+            System.setErr(err)
 
-        Backbone.SCRIPT_POOL.create()
+            Backbone.SCRIPT_POOL.create()
 
-        runBlocking {
-            ScriptLinker.compileAndLink()
-        }
+            tickTask = Backbone.dispatchMainTimer(0L, 1L) {
+                EventBus.post(TickEvent())
+            }
 
-        BStatHandler.init()
+            // Start leak probe checker every 30 seconds (600 ticks)
+            probeCheckerTask = Backbone.dispatchTimer(1200L, 600L) {
+                ProbeHandler.check()
+            }
 
-        Backbone.registerListener(GuiHandler)
-        Backbone.registerListener(ItemHandler)
-        Backbone.registerListener(EntityHandler)
+            runBlocking { // Perform initialization tasks in parallel using coroutines to speed up startup time
+                launch { // Misc initialization
+                    BStatHandler.init()
 
-        Backbone.Handler.COMMAND.register(BackboneCommand)
+                    Backbone.registerListener(GuiHandler)
+                    Backbone.registerListener(ItemHandler)
+                    Backbone.registerListener(EntityHandler)
 
-        tickTask = Backbone.dispatchMainTimer(0L, 1L) {
-            EventBus.post(TickEvent())
-        }
+                    Backbone.Handler.COMMAND.register(BackboneCommand)
+                }
+
+                launch { // Compile and link scripts
+                    val scriptsTimeTaken = measureTime {
+                        ScriptLinker.compileAndLink()
+                    }
+
+                    Backbone.LOGGER.info("Compiled and linked scripts in ${scriptsTimeTaken.inWholeSeconds}s")
+                }
+
+                launch { // Set up placeholders
+                    setPlaceholders()
 
-        Backbone.dispatchMain {
-            setPlaceholders()
+                    Backbone.PLACEHOLDER_GROUP.registerPlaceholders()
+                }
 
-            Backbone.PLACEHOLDER_GROUP.registerPlaceholders()
+                launch(Dispatchers.IO) { // Check for updates
+                    if (Backbone.CONFIG_STATE.checkForUpdates) {
+                        UpdateChecker.checkUpdate()
+                    }
+                }
+
+                Backbone.LOGGER.info("Dispatched initialization tasks, waiting for completion...")
+            }
         }
+
+        Backbone.LOGGER.info("Initialization tasks completed in ${timeTaken.inWholeSeconds}s, backbone is now enabled!")
     }
 
     /**
      * Called by bukkit.
      * @since 1.0.0
      */
-    override fun onDisable() {
-        tickTask?.cancel() // Stop the tick task
+     override fun onDisable() {
+         val timeTaken = measureTime {
+             tickTask?.cancel() // Stop the tick task
+             probeCheckerTask?.cancel() // Stop the probe checker task
+
+            Backbone.PLACEHOLDER_GROUP.unregisterPlaceholders()
 
-        Backbone.PLACEHOLDER_GROUP.unregisterPlaceholders()
+            runBlocking {
+                launch {
+                    BStatHandler.shutdown()
 
-        ScriptEngine.unloadScripts() // Cleanup
+                    Backbone.unregisterListener(GuiHandler)
+                    Backbone.unregisterListener(ItemHandler)
+                    Backbone.unregisterListener(EntityHandler)
 
-        BStatHandler.shutdown()
+                    Backbone.Handler.COMMAND.unregister(BackboneCommand)
+                }
 
-        Backbone.unregisterListener(GuiHandler)
-        Backbone.unregisterListener(ItemHandler)
-        Backbone.unregisterListener(EntityHandler)
+                launch {
+                    ScriptEngine.unloadScripts()
+                }
 
-        Backbone.Handler.COMMAND.unregister(BackboneCommand)
+                Backbone.LOGGER.info("Dispatched shutdown tasks, waiting for completion...")
+            }
+
+            // Restore original System.out and System.err
+            beforeOut?.let { System.setOut(it) }
+            beforeErr?.let { System.setErr(it) }
+        }
 
+        Backbone.LOGGER.info("Shutdown tasks completed in ${timeTaken.inWholeMilliseconds}ms, backbone is now disabled!")
 
-        // Restore original System.out and System.err
-        beforeOut?.let { System.setOut(it) }
-        beforeErr?.let { System.setErr(it) }
     }
 
     /**

src/main/kotlin/net/integr/backbone/ServerDispatcher.kt

@@ -0,0 +1,51 @@
+/*
+ * Copyright © 2026 Integr
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.integr.backbone
+
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Runnable
+import kotlinx.coroutines.isActive
+import org.bukkit.Bukkit
+import kotlin.coroutines.CoroutineContext
+
+/**
+ * A [CoroutineDispatcher] that dispatches tasks to the main server thread.
+ *
+ * This dispatcher checks if the current thread is the primary server thread. If it is, it runs the task immediately.
+ * Otherwise, it schedules the task to run on the main server thread using Bukkit's scheduler.
+ *
+ * @since 1.7.2
+ */
+class ServerDispatcher : CoroutineDispatcher() {
+    override fun dispatch(context: CoroutineContext, block: Runnable) {
+        if (!context.isActive) {
+            return
+        }
+
+        if (Bukkit.isPrimaryThread()) {
+            block.run()
+        } else {
+            Backbone.SERVER.scheduler.runTask(Backbone.PLUGIN, block)
+        }
+    }
+}
+
+/**
+ * Extension function to get an instance of [ServerDispatcher].
+ *
+ * @return An instance of [ServerDispatcher] that can be used to dispatch tasks to the main server thread.
+ * @since 1.7.2
+ */
+fun Dispatchers.serverDispatcher(): CoroutineDispatcher = ServerDispatcher()