Added:

- `build.kind = "efi"` — UEFI PE32+ executable support. Links with `-shared -nostdlib -Wl,-dll -Wl,--subsystem,10`, output via `efi_path()` with `.efi` extension, rejected by `dcr run`.
- `build.kind = "elf"` — bare-metal ELF executable support. Uses `elf_path()` output path, rejected by `dcr run`, no extra linker flags.

Fixed:

- `dcr run` with `--target` or `build.target` now correctly finds the binary in the arch-specific target directory.
- `dcr run` checks profile-specific `build.{profile}.kind` before rejecting library builds (previously only checked `build.kind`).
- `dcr clean` now reads `build.target` from `dcr.toml` when no `--target` flag is given.
- Linux: target directory is now consistent — `target/<arch>-unknown-linux-gnu/<profile>/` (no stale `target/<profile>/`).
- `dcr.lock` is now populated with all resolved dependencies (registry, path, git) instead of being always empty.
- Git dependencies are now properly recognized and recorded in `dcr.lock`.
- `is_registry_dep` correctly identifies version-based registry dependency tables (`{ version = "..." }`) and rejects tables with unknown keys.
- `dcr test` accepts `--debug`/`--release` flags (defaults to `debug` profile instead of always `release`).
- Build fingerprint cache (`build_cache_path`) now includes `target_dir` — different targets no longer share a single cache entry.
- `object_path` no longer hardcodes the `src/` prefix — works correctly with custom `build.roots` (e.g. `roots = ["lib"]`).
- `dcr update` now generates `.exe` candidates for all Windows targets, not just `x86_64-pc-windows-msvc`.
- Compiler existence is verified before starting the build (clear error if compiler is not found in PATH).
- Consolidated duplicate `OUTPUT_MUTEX` definitions — MSVC backend now uses the shared mutex from `common.rs`.
- Registry cache root directory is created if missing (prevents cryptic errors when `~/.dcr/` does not exist).

src/core/deps/mod.rs

@@ -5,8 +5,20 @@ pub mod register;
 
 use crate::core::config::Config;
 use crate::core::deps::common::ResolvedDeps;
+use crate::core::deps::lock::{DepLock, write_lock};
 use std::path::Path;
 
+fn dep_version(path: &Path) -> String {
+    Config::open(&path.join("dcr.toml").to_string_lossy())
+        .ok()
+        .and_then(|c| {
+            c.get("package.version")
+                .and_then(|v| v.as_str())
+                .map(|s| s.to_string())
+        })
+        .unwrap_or_default()
+}
+
 pub fn resolve_deps(
     config: &Config,
     _profile: &str,
@@ -26,7 +38,7 @@ pub fn resolve_deps(
         .to_string();
 
     let deps_table = config.get("dependencies").and_then(|v| v.as_table());
-    let lock_packages = Vec::new();
+    let mut lock_packages: Vec<DepLock> = Vec::new();
 
     if let Some(deps) = deps_table {
         for (name, value) in deps {
@@ -45,6 +57,23 @@ pub fn resolve_deps(
                         .to_string(),
                 );
                 resolved.libs.push(name.clone());
+
+                lock_packages.push(DepLock {
+                    name: name.clone(),
+                    version: pkg_info
+                        .get("version")
+                        .and_then(|v| v.as_str())
+                        .unwrap_or("")
+                        .to_string(),
+                    checksum: String::new(),
+                    source: format!(
+                        "registry+{}",
+                        pkg_info
+                            .get("registry_url")
+                            .and_then(|v| v.as_str())
+                            .unwrap_or("https://dcr-registry.pages.dev")
+                    ),
+                });
             } else if let Some(path) = path_dep_path(value) {
                 let dep_root = project_root.join(path);
                 if let Some(table) = value.as_table() {
@@ -86,11 +115,25 @@ pub fn resolve_deps(
                     push_default_lib_dirs(&mut resolved.lib_dirs, &dep_root);
                     resolved.libs.push(name.clone());
                 }
+
+                lock_packages.push(DepLock {
+                    name: name.clone(),
+                    version: dep_version(&dep_root),
+                    checksum: String::new(),
+                    source: format!("path+{}", dep_root.display()),
+                });
+            } else if let Some(git_info) = git_dep(value) {
+                lock_packages.push(DepLock {
+                    name: name.clone(),
+                    version: git_info.version.unwrap_or_default(),
+                    checksum: String::new(),
+                    source: format!("git+{}", git_info.url),
+                });
             }
         }
     }
 
-    crate::core::deps::lock::write_lock(
+    write_lock(
         project_root,
         &project_name,
         &project_version,
@@ -100,6 +143,24 @@ pub fn resolve_deps(
     Ok(resolved)
 }
 
+struct GitDep<'a> {
+    url: &'a str,
+    version: Option<String>,
+}
+
+fn git_dep(value: &toml::Value) -> Option<GitDep<'_>> {
+    if let Some(table) = value.as_table()
+        && let Some(url) = table.get("git").and_then(|v| v.as_str())
+    {
+        let version = table
+            .get("version")
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string());
+        return Some(GitDep { url, version });
+    }
+    None
+}
+
 fn path_dep_path(value: &toml::Value) -> Option<&str> {
     if let Some(table) = value.as_table() {
         return table.get("path").and_then(|v| v.as_str());

src/core/deps/register.rs

@@ -51,10 +51,18 @@ pub fn get_index_path() -> PathBuf {
 }
 
 pub fn get_registry_cache_root() -> PathBuf {
-    get_index_path()
-        .parent()
-        .map(Path::to_path_buf)
-        .unwrap_or_else(|| PathBuf::from("."))
+    let index_path = get_index_path();
+    if let Some(parent) = index_path.parent() {
+        if parent.exists() {
+            return parent.to_path_buf();
+        }
+        if let Err(e) = std::fs::create_dir_all(parent) {
+            eprintln!("Warning: failed to create registry cache directory: {e}");
+        }
+        parent.to_path_buf()
+    } else {
+        PathBuf::from(".")
+    }
 }
 
 pub fn package_root_from_registry_info(pkg_info: &JsonValue) -> Result<PathBuf, String> {
@@ -124,12 +132,16 @@ pub fn is_registry_dep(value: &TomlValue) -> bool {
         return !is_path_like_string(raw) && !is_git_like_string(raw);
     }
     if let Some(table) = value.as_table() {
-        return !table.contains_key("git")
-            && !table.contains_key("path")
-            && !table.contains_key("url")
-            && !table.contains_key("version");
+        if table.contains_key("git") || table.contains_key("path") || table.contains_key("url") {
+            return false;
+        }
+        table.contains_key("version")
+            || table.contains_key("features")
+            || table.contains_key("optional")
+            || table.contains_key("registry")
+    } else {
+        false
     }
-    false
 }
 
 pub fn path_from_string_dep(value: &TomlValue) -> Option<&str> {