Merge branch 'main' into worktree-agent-aacf40607c4b686e0

# Conflicts:
#	xtask/src/main.rs

xtask/src/ico.rs

@@ -0,0 +1,104 @@
+//! `cargo xtask ico <out.ico> <in.png>…`: pack PNG images into a Windows `.ico`.
+//!
+//! Vista and later read PNG-compressed icon entries, so each PNG is stored as is. The size comes
+//! from the PNG's IHDR chunk; 256 px is written as 0, per the ICO format.
+
+use std::path::Path;
+
+/// Width and height from a PNG's IHDR chunk.
+pub fn png_size(png: &[u8]) -> Result<(u32, u32), String> {
+    const SIG: &[u8] = b"\x89PNG\r\n\x1a\n";
+    if png.len() < 24 || &png[..8] != SIG || &png[12..16] != b"IHDR" {
+        return Err("not a PNG file".into());
+    }
+    let w = u32::from_be_bytes([png[16], png[17], png[18], png[19]]);
+    let h = u32::from_be_bytes([png[20], png[21], png[22], png[23]]);
+    Ok((w, h))
+}
+
+/// An ICO file holding `pngs`, which must be square and at most 256 px.
+pub fn pack(pngs: &[Vec<u8>]) -> Result<Vec<u8>, String> {
+    if pngs.is_empty() || pngs.len() > u16::MAX as usize {
+        return Err("need at least one PNG".into());
+    }
+    let mut out = Vec::new();
+    out.extend_from_slice(&0u16.to_le_bytes()); // reserved
+    out.extend_from_slice(&1u16.to_le_bytes()); // type: icon
+    out.extend_from_slice(&(pngs.len() as u16).to_le_bytes());
+    let mut offset = 6 + 16 * pngs.len();
+    for png in pngs {
+        let (w, h) = png_size(png)?;
+        if w != h || w == 0 || w > 256 {
+            return Err(format!("icon images must be square and at most 256 px, got {w}x{h}"));
+        }
+        let dim = if w == 256 { 0 } else { w as u8 };
+        out.extend_from_slice(&[dim, dim, 0, 0]); // width, height, palette size, reserved
+        out.extend_from_slice(&1u16.to_le_bytes()); // colour planes
+        out.extend_from_slice(&32u16.to_le_bytes()); // bits per pixel
+        out.extend_from_slice(&(png.len() as u32).to_le_bytes());
+        out.extend_from_slice(&(offset as u32).to_le_bytes());
+        offset += png.len();
+    }
+    for png in pngs {
+        out.extend_from_slice(png);
+    }
+    Ok(out)
+}
+
+pub fn run(args: &[&str]) -> Result<(), String> {
+    let [out, inputs @ ..] = args else {
+        return Err("usage: cargo xtask ico <out.ico> <in.png>…".into());
+    };
+    let pngs = inputs.iter().map(|p| std::fs::read(p).map_err(|e| format!("read {p}: {e}"))).collect::<Result<Vec<_>, _>>()?;
+    let ico = pack(&pngs)?;
+    std::fs::write(Path::new(out), &ico).map_err(|e| format!("write {out}: {e}"))?;
+    println!("{out}: {} images, {} bytes", pngs.len(), ico.len());
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn fake_png(size: u32) -> Vec<u8> {
+        let mut v = b"\x89PNG\r\n\x1a\n\0\0\0\x0dIHDR".to_vec();
+        v.extend_from_slice(&size.to_be_bytes());
+        v.extend_from_slice(&size.to_be_bytes());
+        v.extend_from_slice(&[8, 6, 0, 0, 0, 1, 2, 3, 4]);
+        v
+    }
+
+    #[test]
+    fn packs_directory_and_payloads() {
+        let a = fake_png(16);
+        let b = fake_png(256);
+        let ico = pack(&[a.clone(), b.clone()]).unwrap();
+        assert_eq!(&ico[..6], &[0, 0, 1, 0, 2, 0]);
+        // Entry 0: 16 px at offset 6 + 32.
+        assert_eq!(&ico[6..8], &[16, 16]);
+        assert_eq!(u32::from_le_bytes(ico[14..18].try_into().unwrap()), a.len() as u32);
+        assert_eq!(u32::from_le_bytes(ico[18..22].try_into().unwrap()), 38);
+        // Entry 1: 256 px stored as 0, right after the first payload.
+        assert_eq!(&ico[22..24], &[0, 0]);
+        assert_eq!(u32::from_le_bytes(ico[34..38].try_into().unwrap()), 38 + a.len() as u32);
+        assert_eq!(&ico[38..38 + a.len()], &a[..]);
+        assert_eq!(&ico[38 + a.len()..], &b[..]);
+    }
+
+    #[test]
+    fn rejects_bad_input() {
+        assert!(pack(&[]).is_err());
+        assert!(pack(&[fake_png(512)]).is_err());
+        assert!(pack(&[b"GIF89a".to_vec()]).is_err());
+        assert_eq!(png_size(&fake_png(48)).unwrap(), (48, 48));
+    }
+
+    #[test]
+    fn committed_icon_is_valid() {
+        let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../assets/app-icon/filmcraft.ico");
+        let Ok(ico) = std::fs::read(&path) else { return };
+        assert_eq!(&ico[..4], &[0, 0, 1, 0]);
+        let n = u16::from_le_bytes([ico[4], ico[5]]) as usize;
+        assert!(n >= 4, "expected several sizes in {}", path.display());
+    }
+}

xtask/src/main.rs

@@ -11,8 +11,12 @@
 //! - `fixtures [crate…]`: pre-generate the ffmpeg fixture matrix of the oracle tests (runs each
 //!   crate's ignored `generate_fixtures` test, i.e. the same generators the tests use) and print
 //!   what was made, reused or skipped.
+//! - `ico <out.ico> <in.png>…`: pack PNGs into a Windows `.ico` (used by `packaging/icons.sh`).
 //! - `ci`: fmt check, clippy -D warnings, tests, layers, assets, wasm.
 
+mod ico;
+mod version;
+
 use std::process::{Command, ExitCode};
 
 use serde_json::Value;
@@ -346,6 +350,7 @@ fn serve_dir(dir: &std::path::Path, port: u16) -> Result<(), String> {
                 "js" => "text/javascript",
                 "wasm" => "application/wasm",
                 "svg" => "image/svg+xml",
+                "png" => "image/png",
                 "json" => "application/json",
                 "mp4" => "video/mp4",
                 "webm" => "video/webm",
@@ -433,6 +438,11 @@ fn bench() -> Result<(), String> {
     run(Command::new(env!("CARGO")).args(["run", "--release", "-p", "filmcraft-ui-egui", "--example", "bench", "--"]).args(&extra))
 }
 
+/// The workspace root (the parent of `xtask/`).
+fn root() -> std::path::PathBuf {
+    std::path::Path::new(env!("CARGO_MANIFEST_DIR")).parent().expect("xtask lives in the workspace").to_path_buf()
+}
+
 fn main() -> ExitCode {
     let task = std::env::args().nth(1).unwrap_or_default();
     let r = match task.as_str() {
@@ -444,7 +454,18 @@ fn main() -> ExitCode {
         "bench" => bench(),
         "bench-playback" => bench_playback(),
         "web" => web(&std::env::args().skip(2).collect::<Vec<_>>()),
-        _ => Err("usage: cargo xtask <layers|assets|wasm|web [--dev] [--serve PORT]|fixtures [crate…]|ci|bench [args]|bench-playback [args]>".into()),
+        "version" => {
+            let rest: Vec<String> = std::env::args().skip(2).collect();
+            version::run(&root(), &rest.iter().map(String::as_str).collect::<Vec<_>>())
+        }
+        "ico" => {
+            let rest: Vec<String> = std::env::args().skip(2).collect();
+            ico::run(&rest.iter().map(String::as_str).collect::<Vec<_>>())
+        }
+        _ => Err(
+            "usage: cargo xtask <layers|assets|wasm|web [--dev] [--serve PORT]|fixtures [crate…]|ico OUT IN…|version [set X.Y.Z]|ci|bench [args]|bench-playback [args]>"
+                .into(),
+        ),
     };
     match r {
         Ok(()) => ExitCode::SUCCESS,

xtask/src/version.rs

@@ -0,0 +1,149 @@
+//! `cargo xtask version [set X.Y.Z[-pre]]`: the workspace version, the single source of truth.
+//!
+//! The version lives in `[workspace.package] version` in the root `Cargo.toml`; every crate
+//! inherits it with `version.workspace = true`, and the packaging scripts read it from here.
+
+use std::path::Path;
+
+/// The `version = "…"` value inside `[workspace.package]`.
+pub fn read(manifest: &str) -> Result<String, String> {
+    let (_, line) = find_line(manifest)?;
+    let v = line.split_once('=').map(|(_, v)| v.trim().trim_matches('"').to_string()).unwrap_or_default();
+    if v.is_empty() {
+        return Err("empty [workspace.package] version".into());
+    }
+    Ok(v)
+}
+
+/// `manifest` with the workspace version replaced; everything else is byte-for-byte unchanged.
+pub fn replace(manifest: &str, new: &str) -> Result<String, String> {
+    validate(new)?;
+    let (idx, _) = find_line(manifest)?;
+    let mut out = String::with_capacity(manifest.len() + 8);
+    for (i, line) in manifest.split_inclusive('\n').enumerate() {
+        if i == idx {
+            let eol = if line.ends_with("\r\n") {
+                "\r\n"
+            } else if line.ends_with('\n') {
+                "\n"
+            } else {
+                ""
+            };
+            out.push_str(&format!("version = \"{new}\"{eol}"));
+        } else {
+            out.push_str(line);
+        }
+    }
+    Ok(out)
+}
+
+/// Semver without build metadata: `MAJOR.MINOR.PATCH` plus an optional `-pre.release` tag.
+pub fn validate(v: &str) -> Result<(), String> {
+    let bad = || Err(format!("`{v}` is not a version like 1.2.3 or 1.2.3-rc.1"));
+    let (core, pre) = match v.split_once('-') {
+        Some((c, p)) => (c, Some(p)),
+        None => (v, None),
+    };
+    let nums: Vec<&str> = core.split('.').collect();
+    if nums.len() != 3 || nums.iter().any(|n| n.is_empty() || !n.bytes().all(|b| b.is_ascii_digit()) || (n.len() > 1 && n.starts_with('0'))) {
+        return bad();
+    }
+    if let Some(p) = pre
+        && (p.is_empty() || p.split('.').any(|id| id.is_empty() || !id.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-')))
+    {
+        return bad();
+    }
+    Ok(())
+}
+
+/// Index and text of the `version` line in `[workspace.package]`.
+fn find_line(manifest: &str) -> Result<(usize, &str), String> {
+    let mut in_section = false;
+    for (i, line) in manifest.lines().enumerate() {
+        let t = line.trim();
+        if t.starts_with('[') {
+            in_section = t == "[workspace.package]";
+            continue;
+        }
+        if in_section
+            && let Some(rest) = t.strip_prefix("version")
+            && rest.trim_start().starts_with('=')
+        {
+            return Ok((i, line));
+        }
+    }
+    Err("no `version = \"…\"` in [workspace.package] of the root Cargo.toml".into())
+}
+
+pub fn run(root: &Path, args: &[&str]) -> Result<(), String> {
+    let path = root.join("Cargo.toml");
+    let text = std::fs::read_to_string(&path).map_err(|e| format!("read {}: {e}", path.display()))?;
+    match args {
+        [] => {
+            println!("{}", read(&text)?);
+            Ok(())
+        }
+        ["set", new] => {
+            let old = read(&text)?;
+            let updated = replace(&text, new)?;
+            // Write atomically: a half-written root manifest breaks every build in the workspace.
+            let tmp = root.join("target").join("Cargo.toml.xtask-version");
+            std::fs::create_dir_all(root.join("target")).map_err(|e| format!("create target/: {e}"))?;
+            std::fs::write(&tmp, updated).map_err(|e| format!("write {}: {e}", tmp.display()))?;
+            std::fs::rename(&tmp, &path).map_err(|e| format!("replace {}: {e}", path.display()))?;
+            // Refresh the workspace members' entries in Cargo.lock (no dependency upgrades).
+            let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".into());
+            if crate::run(std::process::Command::new(&cargo).args(["update", "--workspace", "--offline"])).is_err() {
+                crate::run(std::process::Command::new(&cargo).args(["update", "--workspace"]))?;
+            }
+            println!("version: {old} -> {new}");
+            Ok(())
+        }
+        _ => Err("usage: cargo xtask version [set X.Y.Z[-pre]]".into()),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const MANIFEST: &str = "[workspace]\nmembers = [\"a\"]\n\n[workspace.package]\nversion = \"0.1.0\"\nedition = \"2024\"\n\n[workspace.dependencies]\nfoo = { version = \"1\" }\n";
+
+    #[test]
+    fn reads_the_workspace_version() {
+        assert_eq!(read(MANIFEST).unwrap(), "0.1.0");
+        assert!(read("[package]\nversion = \"1.0.0\"\n").is_err());
+    }
+
+    #[test]
+    fn replaces_only_the_workspace_version() {
+        let out = replace(MANIFEST, "1.2.3-rc.1").unwrap();
+        assert_eq!(read(&out).unwrap(), "1.2.3-rc.1");
+        assert_eq!(out, MANIFEST.replace("version = \"0.1.0\"", "version = \"1.2.3-rc.1\""));
+        assert!(out.contains("foo = { version = \"1\" }"));
+    }
+
+    #[test]
+    fn keeps_crlf_line_endings() {
+        let crlf = MANIFEST.replace('\n', "\r\n");
+        let out = replace(&crlf, "2.0.0").unwrap();
+        assert_eq!(out, crlf.replace("\"0.1.0\"", "\"2.0.0\""));
+    }
+
+    #[test]
+    fn validates_versions() {
+        for ok in ["0.1.0", "1.20.300", "1.0.0-rc.1", "1.0.0-alpha", "1.0.0-x-y.2"] {
+            assert!(validate(ok).is_ok(), "{ok}");
+        }
+        for bad in ["1.0", "1.0.0.0", "v1.0.0", "01.0.0", "1.0.0-", "1.0.0-a..b", "1.0.0+meta", "1.a.0", ""] {
+            assert!(validate(bad).is_err(), "{bad}");
+        }
+        assert!(replace(MANIFEST, "nope").is_err());
+    }
+
+    #[test]
+    fn the_real_manifest_has_a_valid_version() {
+        let text = std::fs::read_to_string(crate::root().join("Cargo.toml")).unwrap();
+        validate(&read(&text).unwrap()).unwrap();
+    }
+}