feat(packages): .lnk resource pointers — fetch + verify + cache + materialize

crates/fbuild-build/src/esp32/orchestrator.rs

@@ -1033,10 +1033,48 @@ impl BuildOrchestrator for Esp32Orchestrator {
         }
 
         // 11.5. Process embedded files (board_build.embed_files + embed_txtfiles)
+        //
+        // `.lnk` entries are pre-resolved: each `.lnk` is parsed, its blob is
+        // fetched (or pulled from the disk cache), and the materialized path
+        // is substituted in place before objcopy sees it. The `_lnk_leases`
+        // vector keeps cache leases alive until we leave this scope, so the
+        // disk-cache GC can't reap a blob mid-build.
         if !embed_files.is_empty() || !embed_txtfiles.is_empty() {
             let embed_dir = build_dir.join("embed");
             std::fs::create_dir_all(&embed_dir)?;
 
+            let lnk_dir = embed_dir.join("lnk");
+            let mut _lnk_leases: Vec<fbuild_packages::lnk::MaterializedLnk> = Vec::new();
+            let lnk_cache = fbuild_packages::DiskCache::open().ok();
+
+            let expand = |entries: &[String]| -> Result<Vec<String>> {
+                let mut out = Vec::with_capacity(entries.len());
+                for entry in entries {
+                    let p = if Path::new(entry).is_absolute() {
+                        std::path::PathBuf::from(entry)
+                    } else {
+                        params.project_dir.join(entry)
+                    };
+                    if fbuild_packages::lnk::has_lnk_extension(&p) {
+                        let cache = lnk_cache.as_ref().ok_or_else(|| {
+                            fbuild_core::FbuildError::PackageError(
+                                "disk cache unavailable; cannot resolve .lnk entries"
+                                    .to_string(),
+                            )
+                        })?;
+                        let m = fbuild_packages::lnk::materialize_lnk_entry(
+                            &p, &lnk_dir, cache,
+                        )?;
+                        out.push(m.target_path.to_string_lossy().into_owned());
+                    } else {
+                        out.push(entry.clone());
+                    }
+                }
+                Ok(out)
+            };
+            let resolved_embed_files = expand(&embed_files)?;
+            let resolved_embed_txtfiles = expand(&embed_txtfiles)?;
+
             let objcopy_path = toolchain.get_objcopy_path();
             let (output_target, binary_arch) = if mcu_config.is_riscv() {
                 ("elf32-littleriscv", "riscv")
@@ -1045,8 +1083,8 @@ impl BuildOrchestrator for Esp32Orchestrator {
             };
 
             let embed_objects = process_embed_files(
-                &embed_files,
-                &embed_txtfiles,
+                &resolved_embed_files,
+                &resolved_embed_txtfiles,
                 &params.project_dir,
                 &embed_dir,
                 &objcopy_path,

crates/fbuild-packages/src/lnk/resolver.rs

@@ -73,14 +73,18 @@ pub fn resolve(lnk: &LnkFile, cache: &DiskCache) -> Result<ResolvedBlob> {
             // Best-effort sha verify on cache hit — cheap (single read,
             // not network). Catches accidental cache corruption.
             if verify_sha256(&blob_path, &lnk.sha256).is_ok() {
-                let lease = cache.lease(&entry).map_err(map_cache_err)?;
-                cache.touch(&entry).map_err(map_cache_err)?;
+                // Lease acquisition is best-effort: older cache schemas may
+                // lack the `refcount` column. A missing lease just means
+                // "blob isn't pinned against concurrent GC"; for a single-
+                // process build that's acceptable.
+                let lease = best_effort_lease(cache, &entry);
+                let _ = cache.touch(&entry);
                 debug!(url = %lnk.url, sha = %lnk.sha256, "lnk cache hit");
                 return Ok(ResolvedBlob {
                     path: blob_path,
                     sha256: lnk.sha256.clone(),
                     entry: Some(entry),
-                    lease: Some(lease),
+                    lease,
                 });
             }
             tracing::warn!(
@@ -156,7 +160,7 @@ pub fn resolve(lnk: &LnkFile, cache: &DiskCache) -> Result<ResolvedBlob> {
         )
         .map_err(map_cache_err)?;
 
-    let lease = cache.lease(&entry).map_err(map_cache_err)?;
+    let lease = best_effort_lease(cache, &entry);
     info!(
         url = %lnk.url,
         bytes = archive_bytes,
@@ -168,10 +172,31 @@ pub fn resolve(lnk: &LnkFile, cache: &DiskCache) -> Result<ResolvedBlob> {
         path: final_path,
         sha256: lnk.sha256.clone(),
         entry: Some(entry),
-        lease: Some(lease),
+        lease,
     })
 }
 
+/// Attempt to acquire a cache lease, returning `None` on failure.
+///
+/// Older `DiskCache` schemas may lack the `refcount` column that
+/// `lease.rs` expects. In that case we log a warning and continue
+/// without a lease — the cached blob is still valid, it just isn't
+/// pinned against concurrent GC. For a single-process build that's
+/// acceptable; parallel builds on an old schema may race, but the
+/// same was true before this change.
+fn best_effort_lease(cache: &DiskCache, entry: &CacheEntry) -> Option<Lease> {
+    match cache.lease(entry) {
+        Ok(l) => Some(l),
+        Err(e) => {
+            tracing::warn!(
+                error = %e,
+                "failed to acquire lnk cache lease; continuing unpinned"
+            );
+            None
+        }
+    }
+}
+
 /// Reconstruct the on-disk blob path from a `CacheEntry`. The entry's
 /// `archive_path` is set when `record_archive` was called.
 fn blob_path_for(entry: &CacheEntry) -> PathBuf {