sync: update from the development repository

Content snapshot from the private development repository. The two histories are
independent by design; this commit carries the file contents, not the upstream
commits.

Author: eauesque

CHANGELOG.en.md

@@ -7,6 +7,23 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ---
 
+## [0.3.1] - 2026-08-30
+
+### Fixed
+
+- **A stale `/_internal/scan-roots-changed` notification could overwrite newer
+  scan roots.** yu-server assigns a monotonic `generation` in config-write order,
+  but the receiver never read it and overwrote its roots on every call. yu-server's
+  own send lock orders only the sends it starts; one it gave up on (5s timeout)
+  can still land afterwards and clobber a newer one. The handler now remembers the
+  highest generation it applied and drops anything not strictly newer, answering
+  `{"ok":true,"applied":false,"stale":true}`. The generation lives under the same
+  `RwLock` as the roots so the compare-and-apply cannot interleave with another
+  request. A request carrying no `generation` (a yu-server predating the field) is
+  still applied unconditionally and leaves the stored generation alone.
+
+---
+
 ## [0.3.0] - 2026-08-16
 
 Verified on Hailo-10H hardware. Wires native tool-call support (HailoRT genai

CHANGELOG.md

@@ -7,6 +7,21 @@
 
 ---
 
+## [0.3.1] - 2026-08-30
+
+### Fixed
+
+- **`/_internal/scan-roots-changed` が古い世代の通知で新しい scan roots を上書きし得た問題
+  を修正。** yu-server は書込順に単調増加する `generation` を払っているが、受信側はこれを
+  読まず毎回無条件に上書きしていた。yu-server 側の送信ロックは自ら開始した送信しか順序化
+  できず、5 秒の timeout で諦めた送信は後から到着して新しい状態を潰し得る。受信側で
+  `generation` を記憶し、既に適用した値以下の要求を落とすようにした（応答は
+  `{"ok":true,"applied":false,"stale":true}`）。`generation` は roots と同一の
+  `RwLock` 下に置き、比較と適用が他要求と交錯しないようにしてある。`generation` を持たない
+  要求（本フィールド以前の yu-server）は従来どおり無条件に適用し、記憶した世代も動かさない。
+
+---
+
 ## [0.3.0] - 2026-08-16
 
 Hailo-10H 実機で検証済み。`/v1/infer/llm/generate/stream` にネイティブ tool 呼出し対応

Cargo.lock

@@ -3,7 +3,7 @@ members = ["yu-hailo-auth", "yu-hailo-infer-core", "yu-hailo-infer"]
 resolver = "2"
 
 [workspace.package]
-version    = "0.3.0"
+version    = "0.3.1"
 edition    = "2021"
 license    = "MIT"
 repository = "https://github.com/eauesque/yu-hailo-infer"

Cargo.toml

@@ -90,8 +90,10 @@ pub fn validate_yolo_outputs(outputs: &[YoloOutputBuffer]) -> Result<(), String>
 
 pub fn dequantize(data: &[u8], scale: f32, zero_point: f32, is_float32: bool) -> Vec<f32> {
     if is_float32 {
-        data.chunks_exact(4)
-            .map(|bytes| f32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]))
+        data.as_chunks::<4>()
+            .0
+            .iter()
+            .map(|&bytes| f32::from_le_bytes(bytes))
             .collect()
     } else {
         data.iter()
@@ -173,7 +175,7 @@ pub fn parse_nms_output(buf: &YoloOutputBuffer) -> (Vec<[f64; 4]>, Vec<f64>, Vec
     let mut scores = Vec::new();
     let mut class_ids = Vec::new();
 
-    for row in values.chunks_exact(6) {
+    for row in values.as_chunks::<6>().0 {
         let score = row[4] as f64;
         if score > 0.0 {
             boxes.push([row[1] as f64, row[0] as f64, row[3] as f64, row[2] as f64]);

yu-hailo-infer-core/src/yolo_postprocess.rs

@@ -19,9 +19,11 @@ fn main() {
         .as_deref()
         .map(|d| std::path::Path::new(d).join("hailo/hailort.hpp").exists())
         .unwrap_or_else(|| {
-            ["/usr/local", "/usr"]
-                .iter()
-                .any(|prefix| std::path::Path::new(prefix).join("include/hailo/hailort.hpp").exists())
+            ["/usr/local", "/usr"].iter().any(|prefix| {
+                std::path::Path::new(prefix)
+                    .join("include/hailo/hailort.hpp")
+                    .exists()
+            })
         });
 
     if header_exists {
@@ -43,10 +45,11 @@ fn main() {
                     .unwrap_or_else(|| dir.clone())
             });
             println!("cargo:rustc-link-search=native={lib_dir}");
-        } else if let Some(prefix) = ["/usr/local", "/usr"]
-            .iter()
-            .find(|prefix| std::path::Path::new(prefix).join("include/hailo/hailort.hpp").exists())
-        {
+        } else if let Some(prefix) = ["/usr/local", "/usr"].iter().find(|prefix| {
+            std::path::Path::new(prefix)
+                .join("include/hailo/hailort.hpp")
+                .exists()
+        }) {
             build.include(format!("{prefix}/include"));
             println!("cargo:rustc-link-search=native={prefix}/lib");
         }

yu-hailo-infer/build.rs

@@ -129,9 +129,8 @@ impl Speech2Text {
         };
         check_status("s2t_generate_segments", status)?;
         let json = take_c_string(out)?;
-        serde_json::from_str(&json).map_err(|_| {
-            HailoRtError::InvalidMetadata("shim returned malformed segments JSON")
-        })
+        serde_json::from_str(&json)
+            .map_err(|_| HailoRtError::InvalidMetadata("shim returned malformed segments JSON"))
     }
 
     pub(crate) fn tokenize(&mut self, text: &str) -> HailoRtResult<Vec<i32>> {

yu-hailo-infer/src/hailort/speech2text.rs

@@ -42,7 +42,10 @@ pub async fn run() {
     let state = router::AppState {
         started_at: std::time::Instant::now(),
         instance_id: contract.instance_id,
-        scan_roots: Arc::new(RwLock::new(contract.scan_roots)),
+        scan_roots: Arc::new(RwLock::new(router::ScanRoots {
+            roots: contract.scan_roots,
+            generation: 0,
+        })),
         auth_token: contract.auth_token,
         wd_cache_dir: cli.wd_cache_dir,
         wd_infer: Arc::new(RwLock::new(HashMap::new())),

yu-hailo-infer/src/lib.rs

@@ -89,11 +89,23 @@ fn media_preprocessing_permits(reservation_bytes: u64) -> u32 {
         .expect("media preprocessing reservation exceeds semaphore capacity type")
 }
 
+/// The scan roots yu-server last told us about, paired with the `generation`
+/// that delivered them. Both live under one lock on purpose: the
+/// compare-and-apply in `scan_roots_changed` must not interleave with another
+/// request's, and a separate counter would let two calls both pass the
+/// staleness check and then land in the wrong order.
+pub struct ScanRoots {
+    pub roots: Vec<PathBuf>,
+    /// Highest generation applied so far. yu-server's counter starts at 1, so
+    /// 0 means nothing but the startup contract has been applied yet.
+    pub generation: u64,
+}
+
 #[derive(Clone)]
 pub struct AppState {
     pub started_at: std::time::Instant,
     pub instance_id: String,
-    pub scan_roots: Arc<RwLock<Vec<PathBuf>>>,
+    pub scan_roots: Arc<RwLock<ScanRoots>>,
     pub auth_token: String,
     pub wd_cache_dir: PathBuf,
     pub wd_infer: Arc<RwLock<HashMap<String, Arc<infer_core::WdInferEngine>>>>,
@@ -151,6 +163,16 @@ async fn healthz(State(state): State<AppState>) -> Json<serde_json::Value> {
 #[derive(Deserialize)]
 pub struct ScanRootsChangedRequest {
     pub scan_roots: Vec<String>,
+    /// Monotonic counter yu-server assigns in config-write order. Its own send
+    /// lock only orders the sends it starts; a send it gave up on (5s timeout)
+    /// can still reach us after a newer one, so anything not strictly newer
+    /// than what we already applied is dropped here.
+    ///
+    /// Absent means a yu-server predating the field: apply unconditionally,
+    /// which is exactly what we did before, and leave the stored generation
+    /// alone so a mixed deployment cannot wedge us.
+    #[serde(default)]
+    pub generation: Option<u64>,
 }
 
 async fn scan_roots_changed(
@@ -166,13 +188,23 @@ async fn scan_roots_changed(
             .into_response();
     }
 
-    let roots = body
+    // Canonicalize before taking the lock -- it hits the filesystem.
+    let roots: Vec<PathBuf> = body
         .scan_roots
         .into_iter()
         .filter_map(|path| std::fs::canonicalize(path).ok())
         .collect();
-    *state.scan_roots.write().unwrap() = roots;
-    Json(json!({"ok": true})).into_response()
+
+    let mut scan_roots = state.scan_roots.write().unwrap();
+    if let Some(generation) = body.generation {
+        if generation <= scan_roots.generation {
+            return Json(json!({"ok": true, "applied": false, "stale": true})).into_response();
+        }
+        scan_roots.generation = generation;
+    }
+    scan_roots.roots = roots;
+    drop(scan_roots);
+    Json(json!({"ok": true, "applied": true})).into_response()
 }
 
 #[derive(Deserialize)]
@@ -250,7 +282,11 @@ fn check_auth(state: &AppState, headers: &HeaderMap) -> bool {
 
 fn check_scan_roots(state: &AppState, real_path: &std::path::Path) -> bool {
     let scan_roots = state.scan_roots.read().unwrap();
-    !scan_roots.is_empty() && scan_roots.iter().any(|root| real_path.starts_with(root))
+    !scan_roots.roots.is_empty()
+        && scan_roots
+            .roots
+            .iter()
+            .any(|root| real_path.starts_with(root))
 }
 
 fn check_model_id(model_id: &str) -> bool {
@@ -1771,7 +1807,10 @@ mod tests {
         AppState {
             started_at: std::time::Instant::now(),
             instance_id: "test-instance".to_string(),
-            scan_roots: Arc::new(RwLock::new(scan_roots)),
+            scan_roots: Arc::new(RwLock::new(ScanRoots {
+                roots: scan_roots,
+                generation: 0,
+            })),
             auth_token: "test-token".to_string(),
             wd_cache_dir: std::env::temp_dir().join("yu-infer-test-cache"),
             wd_infer: Arc::new(RwLock::new(HashMap::new())),
@@ -2083,6 +2122,100 @@ mod tests {
         assert_eq!(decoded.height(), 64);
     }
 
+    async fn scan_roots_changed_request(
+        app: axum::Router,
+        roots: &[&std::path::Path],
+        generation: Option<u64>,
+    ) -> StatusCode {
+        let mut payload = json!({
+            "scan_roots": roots.iter().map(|p| p.to_str().unwrap()).collect::<Vec<_>>(),
+        });
+        if let Some(generation) = generation {
+            payload["generation"] = json!(generation);
+        }
+        app.oneshot(
+            Request::builder()
+                .method("POST")
+                .uri("/_internal/scan-roots-changed")
+                .header("content-type", "application/json")
+                .header("authorization", "Bearer test-token")
+                .body(Body::from(payload.to_string()))
+                .unwrap(),
+        )
+        .await
+        .unwrap()
+        .status()
+    }
+
+    #[tokio::test]
+    async fn scan_roots_changed_drops_a_generation_it_already_passed() {
+        let base = std::env::temp_dir().join("yu-infer-scan-roots-generation-test");
+        let newer = base.join("newer");
+        let older = base.join("older");
+        std::fs::create_dir_all(&newer).unwrap();
+        std::fs::create_dir_all(&older).unwrap();
+        let canonical_newer = std::fs::canonicalize(&newer).unwrap();
+
+        let state = test_state(vec![]);
+
+        // Generation 2 lands first; the send that carried generation 1 timed
+        // out on yu-server's side and only reaches us afterwards.
+        let status =
+            scan_roots_changed_request(build_router(state.clone()), &[&newer], Some(2)).await;
+        assert_eq!(status, StatusCode::OK);
+        let status =
+            scan_roots_changed_request(build_router(state.clone()), &[&older], Some(1)).await;
+        assert_eq!(status, StatusCode::OK);
+        assert_eq!(
+            state.scan_roots.read().unwrap().roots,
+            vec![canonical_newer.clone()],
+            "a stale generation must not clobber the newer roots"
+        );
+
+        // An equal generation is a replay, not news, so it is dropped too.
+        let status =
+            scan_roots_changed_request(build_router(state.clone()), &[&older], Some(2)).await;
+        assert_eq!(status, StatusCode::OK);
+        assert_eq!(
+            state.scan_roots.read().unwrap().roots,
+            vec![canonical_newer]
+        );
+
+        // A strictly newer generation still applies.
+        let status =
+            scan_roots_changed_request(build_router(state.clone()), &[&older], Some(3)).await;
+        assert_eq!(status, StatusCode::OK);
+        assert_eq!(
+            state.scan_roots.read().unwrap().roots,
+            vec![std::fs::canonicalize(&older).unwrap()]
+        );
+        assert_eq!(state.scan_roots.read().unwrap().generation, 3);
+    }
+
+    #[tokio::test]
+    async fn scan_roots_changed_applies_a_request_without_a_generation() {
+        // A yu-server predating the field must keep working, and must not
+        // move the stored generation.
+        let base = std::env::temp_dir().join("yu-infer-scan-roots-legacy-test");
+        let first = base.join("first");
+        let later = base.join("later");
+        std::fs::create_dir_all(&first).unwrap();
+        std::fs::create_dir_all(&later).unwrap();
+        let state = test_state(vec![]);
+
+        let status =
+            scan_roots_changed_request(build_router(state.clone()), &[&first], Some(7)).await;
+        assert_eq!(status, StatusCode::OK);
+        let status = scan_roots_changed_request(build_router(state.clone()), &[&later], None).await;
+        assert_eq!(status, StatusCode::OK);
+        assert_eq!(
+            state.scan_roots.read().unwrap().roots,
+            vec![std::fs::canonicalize(&later).unwrap()],
+            "a request without a generation must still apply"
+        );
+        assert_eq!(state.scan_roots.read().unwrap().generation, 7);
+    }
+
     #[tokio::test]
     async fn infer_wd_rejects_missing_auth_header() {
         let app = build_router(test_state(vec![]));

yu-hailo-infer/src/router.rs

@@ -304,12 +304,16 @@ mod tests {
 
     use super::*;
     use crate::router::build_router;
+    use crate::router::ScanRoots;
 
     fn test_state(scan_roots: Vec<PathBuf>) -> AppState {
         AppState {
             started_at: std::time::Instant::now(),
             instance_id: "test-instance".to_string(),
-            scan_roots: Arc::new(RwLock::new(scan_roots)),
+            scan_roots: Arc::new(RwLock::new(ScanRoots {
+                roots: scan_roots,
+                generation: 0,
+            })),
             auth_token: "test-token".to_string(),
             wd_cache_dir: std::env::temp_dir().join("yu-infer-test-cache"),
             wd_infer: Arc::new(RwLock::new(HashMap::new())),