feat: add 10 new language adapters

Adds Dart (with optional Flutter auto-detection), Bash (bash-debug-adapter with mason bashdb_dir probing), R (vscDebugger package preflight), Elixir (mix_task), Haskell, OCaml (ocamlearlybird), Zig/Nim/Crystal (via codelldb filetype extension), and F# (via netcoredbg filetype extension). Expands built-in adapter coverage from 12 to 22 languages.

lua/turbo-debug/adapters/bash.lua

@@ -0,0 +1,39 @@
+local loader = require("turbo-debug.adapters.init")
+
+local M = {}
+
+function M.register(dap)
+  local exe = loader.find_executable({ "bash-debug-adapter" })
+  if not exe then return end
+
+  local bashdb_dir = vim.fn.stdpath("data") .. "/mason/packages/bash-debug-adapter/extension/bashdb_dir"
+  if vim.fn.isdirectory(bashdb_dir) == 0 then bashdb_dir = nil end
+
+  loader.register(dap, "bashdb", {
+    type = "executable",
+    command = exe,
+    name = "bashdb",
+  }, {
+    {
+      type = "bashdb",
+      request = "launch",
+      name = "Launch file",
+      showDebugOutput = true,
+      pathBashdb = bashdb_dir and (bashdb_dir .. "/bashdb") or "bashdb",
+      pathBashdbLib = bashdb_dir,
+      trace = true,
+      file = "${file}",
+      program = "${file}",
+      cwd = "${workspaceFolder}",
+      pathCat = "cat",
+      pathBash = "/bin/bash",
+      pathMkfifo = "mkfifo",
+      pathPkill = "pkill",
+      args = {},
+      env = {},
+      terminalKind = "integrated",
+    },
+  }, { "sh", "bash" })
+end
+
+return M

lua/turbo-debug/adapters/c.lua

@@ -62,7 +62,7 @@ function M.register(dap)
       cwd = "${workspaceFolder}",
     },
   }
-  for _, ft in ipairs({ "c", "cpp", "swift" }) do
+  for _, ft in ipairs({ "c", "cpp", "swift", "zig", "nim", "crystal" }) do
     dap.configurations[ft] = dap.configurations[ft] or prompt_config
   end
 

lua/turbo-debug/adapters/dart.lua

@@ -0,0 +1,46 @@
+local loader = require("turbo-debug.adapters.init")
+
+local M = {}
+
+function M.register(dap)
+  local dart = loader.find_executable({ "dart" })
+  if not dart then return end
+
+  local configs = {
+    {
+      type = "dart",
+      request = "launch",
+      name = "Launch Dart file",
+      program = "${file}",
+      cwd = "${workspaceFolder}",
+      toolArgs = { "--enable-vm-service" },
+    },
+  }
+
+  local flutter = loader.find_executable({ "flutter" })
+  if flutter then
+    if not dap.adapters.flutter then
+      dap.adapters.flutter = {
+        type = "executable",
+        command = flutter,
+        args = { "debug_adapter" },
+      }
+    end
+    table.insert(configs, {
+      type = "flutter",
+      request = "launch",
+      name = "Launch Flutter app",
+      program = "lib/main.dart",
+      cwd = "${workspaceFolder}",
+      flutterMode = "debug",
+    })
+  end
+
+  loader.register(dap, "dart", {
+    type = "executable",
+    command = dart,
+    args = { "debug_adapter" },
+  }, configs, { "dart" })
+end
+
+return M

lua/turbo-debug/adapters/init.lua

@@ -38,7 +38,7 @@ local function register_simple_adapters(dap)
           program = function() return vim.fn.input("Path to DLL: ", vim.fn.getcwd() .. "/bin/Debug/", "file") end,
         },
       },
-      { "cs" },
+      { "cs", "fsharp" },
     },
 
     {
@@ -119,6 +119,77 @@ local function register_simple_adapters(dap)
       },
       { "ruby" },
     },
+
+    {
+      "mix_task",
+      {
+        "elixir-ls-debugger",
+        "elixir-ls-debug-adapter",
+        vim.fn.stdpath("data") .. "/mason/packages/elixir-ls/debugger.sh",
+      },
+      {
+        type = "executable",
+      },
+      {
+        {
+          type = "mix_task",
+          request = "launch",
+          name = "mix test",
+          task = "test",
+          taskArgs = { "--trace" },
+          startApps = true,
+          projectDir = "${workspaceFolder}",
+          requireFiles = { "test/**/test_helper.exs", "test/**/*_test.exs" },
+        },
+      },
+      { "elixir" },
+    },
+
+    {
+      "haskell",
+      { "haskell-debug-adapter" },
+      {
+        type = "executable",
+      },
+      {
+        {
+          type = "haskell",
+          request = "launch",
+          name = "Launch file",
+          workspace = "${workspaceFolder}",
+          startup = "${file}",
+          stopOnEntry = true,
+          logFile = vim.fn.stdpath("data") .. "/haskell-dap.log",
+          logLevel = "WARNING",
+          ghciEnv = vim.empty_dict(),
+          ghciPrompt = "H>>= ",
+          ghciInitialPrompt = "Prelude>",
+          ghciCmd = "cabal exec -- ghci-dap --interactive -i -i${workspaceFolder}",
+        },
+      },
+      { "haskell" },
+    },
+
+    {
+      "ocamlearlybird",
+      { "ocamlearlybird" },
+      {
+        type = "executable",
+        args = { "debug" },
+      },
+      {
+        {
+          type = "ocamlearlybird",
+          request = "launch",
+          name = "Launch bytecode",
+          program = function()
+            return vim.fn.input("Path to bytecode: ", vim.fn.getcwd() .. "/_build/default/", "file")
+          end,
+          stopOnEntry = false,
+        },
+      },
+      { "ocaml" },
+    },
   }
 
   for _, s in ipairs(simple) do
@@ -153,7 +224,7 @@ function M.setup()
   local dap = require("dap")
 
   -- load adapters with non-trivial logic from separate files
-  for _, name in ipairs({ "python", "go", "c", "javascript" }) do
+  for _, name in ipairs({ "python", "go", "c", "javascript", "dart", "bash", "r" }) do
     local ok, adapter_mod = pcall(require, "turbo-debug.adapters." .. name)
     if ok and adapter_mod.register then adapter_mod.register(dap) end
   end

lua/turbo-debug/adapters/r.lua

@@ -0,0 +1,39 @@
+local loader = require("turbo-debug.adapters.init")
+
+local M = {}
+
+-- vscDebugger is an R package, not a standalone binary. It must be installed
+-- in the user's R library (install.packages("vscDebugger") or remotes::install_github).
+-- Silently skip registration if it's missing — matches the "no noise when
+-- prereqs missing" invariant used by the other adapters.
+local function has_vsc_debugger()
+  if vim.fn.executable("Rscript") ~= 1 then return false end
+  vim.fn.system({
+    "Rscript",
+    "-e",
+    "if (!requireNamespace('vscDebugger', quietly=TRUE)) quit(status=1)",
+  })
+  return vim.v.shell_error == 0
+end
+
+function M.register(dap)
+  local R = loader.find_executable({ "R" })
+  if not R then return end
+  if not has_vsc_debugger() then return end
+
+  loader.register(dap, "r", {
+    type = "executable",
+    command = R,
+    args = { "-e", "vscDebugger::.vsc.listenForDAP()" },
+  }, {
+    {
+      type = "r",
+      request = "launch",
+      name = "Launch R file",
+      program = "${file}",
+      cwd = "${workspaceFolder}",
+    },
+  }, { "r", "rmd" })
+end
+
+return M