use libc::{MS_BIND, mount, umount};
use std::ffi::CString;
use tracing::*;
#[derive(Debug)]
pub struct Mount {
    target: Option<CString>,
}
impl Mount {
    pub fn bind(source: &str, target: &str) -> Result<Mount, std::io::Error> {
        let target = std::ffi::CString::new(target).unwrap();
        unsafe {
            let err = mount(
                std::ffi::CString::new(source).unwrap().as_ptr(),
                target.as_ptr(),
                std::ptr::null(),
                MS_BIND,
                std::ptr::null(),
            );
            error!("err {:?}", err);
            if err == 0 {
                Ok(Mount {
                    target: Some(target),
                })
            } else {
                Err(std::io::Error::last_os_error())
            }
        }
    }
}
impl Drop for Mount {
    fn drop(&mut self) {
        if let Some(target) = self.target.take() {
            unsafe {
                // Attention au Chroot!
                trace!("umount");
                let r = umount(target.as_ptr());
                trace!(
                    "umount done {:?} {:?} {:?}",
                    target,
                    r,
                    std::io::Error::last_os_error()
                );
            }
        }
    }
}

use libc::*;
use std::ffi::CString;
use std::path::Path;
use std::sync::Arc;
use tracing::*;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
use elpe::extract::*;
use elpe::mount::*;
use elpe::*;
pub mod proto {
    tonic::include_proto!("elpe");
}
pub struct Elpe {
    deb_client: Arc<elpe::Client>,
}
use proto::*;
#[tonic::async_trait]
impl proto::elpe_server::Elpe for Elpe {
    async fn derivation(
        &self,
        request: tonic::Request<DerivationRequest>,
    ) -> Result<tonic::Response<DerivationReply>, tonic::Status> {
        debug!("Got a request from {:?}", request.remote_addr());
        // let reply = hello_world::HelloReply {
        //     message: format!("Hello {}!", request.into_inner().name),
        // };
        // Ok(Response::new(reply))
        unimplemented!()
    }
    async fn ubuntu_release(
        &self,
        request: tonic::Request<UbuntuReleaseRequest>,
    ) -> Result<tonic::Response<DerivationReply>, tonic::Status> {
        debug!("ubuntu release {:?}", request);
        let r = request.into_inner();
        let h = self.deb_client.in_release(r.release).await.unwrap();
        let arch = match r.arch {
            0 => "amd64",
            1 => "aarch64",
            _ => unreachable!(),
        };
        let p = self
            .deb_client
            .packages(&h, &r.repository, arch)
            .await
            .unwrap();
        Ok(tonic::Response::new(proto::DerivationReply {
            path: vec![p.to_str().unwrap().to_string()],
            error: None,
        }))
    }
    async fn ubuntu_package(
        &self,
        request: tonic::Request<UbuntuPackageRequest>,
    ) -> Result<tonic::Response<DerivationReply>, tonic::Status> {
        debug!("request {:?}", request);
        let r = request.into_inner();
        let index: Result<Vec<_>, _> = r
            .index
            .into_iter()
            .map(|index| deb::Index::open(&index))
            .collect();
        let index = index.unwrap();
        let p = download_extract_deps(&index, &self.deb_client, &r.name)
            .await
            .unwrap();
        info!("path {:?}", p);
        Ok(tonic::Response::new(proto::DerivationReply {
            path: p
                .iter()
                .rev()
                .map(|x| x.to_str().unwrap().to_string())
                .collect(),
            error: None,
        }))
    }
}
pub fn child<P: AsRef<Path>>(path: &[P]) {
    let store = Path::new("/home/pe/Projets/frix/store/ailpe/store");
    std::fs::create_dir_all(store).unwrap();
    let vm_store = Path::new("/ailpe/store");
    let mut path_env = "PATH=".to_string();
    let mut ld_env = "LD_LIBRARY_PATH=".to_string();
    let mut mounts = Vec::new();
    for p in path {
        use std::fmt::Write;
        let host = store.join(p.as_ref().file_name().unwrap());
        let guest = vm_store.join(p.as_ref().file_name().unwrap());
        std::fs::create_dir_all(&host).unwrap();
        write!(
            &mut path_env,
            "{}/usr/bin:{}/bin:",
            guest.to_str().unwrap(),
            guest.to_str().unwrap()
        )
        .unwrap();
        write!(
            &mut ld_env,
            "{}/lib64/x86_64-linux-gnu:{}/lib/x86_64-linux-gnu:",
            guest.to_str().unwrap(),
            guest.to_str().unwrap()
        )
        .unwrap();
        mounts.push(Mount::bind(p.as_ref().to_str().unwrap(), host.to_str().unwrap()).unwrap());
    }
    println!("{:?}", mounts);
    // Fork in order to be able to unmount despite the chroot.
    let f = unsafe { fork() };
    if f == 0 {
        let c = std::ffi::CString::new("/home/pe/Projets/frix/store").unwrap();
        if unsafe { chroot(c.as_ptr()) } < 0 {
            println!("child {:?}", std::io::Error::last_os_error());
        }
        println!("{:?}\n{:?}", path_env, ld_env);
        let penv = CString::new(path_env).unwrap();
        let lenv = CString::new(ld_env).unwrap();
        unsafe {
            let c = std::ffi::CString::new(
                "/ailpe/store/tmp3/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2",
            )
            .unwrap();
            execve(
                c.as_ptr(),
                [c.as_ptr(), std::ptr::null()].as_ptr(),
                [penv.as_ptr(), lenv.as_ptr(), std::ptr::null()].as_ptr(),
            );
            println!("execve {:?}", std::io::Error::last_os_error());
        }
    } else {
        let mut status = 0;
        unsafe { waitpid(f, &mut status, 0) };
        std::mem::drop(mounts);
    }
}
/*
    let lua = mlua::Lua::new();
    let map_table = lua.create_table().unwrap();
    map_table.set(1, "one").unwrap();
    map_table.set("two", 2).unwrap();
    lua.globals().set("map_table", map_table).unwrap();
    let derivation = lua
        .create_function(|st, t: mlua::Table| {
            t.for_each(|k: String, v: mlua::Value| {
                println!("{:?} {:?}", k, v);
                Ok(())
            }).unwrap();
            Ok(1)
        })
        .unwrap();
    lua.globals().set("__derivation", derivation).unwrap();
    let ubuntu = lua
        .create_function(|st, (t, name): (mlua::Table, String)| {
            t.for_each(|k: String, v: mlua::Value| {
                println!("{:?} {:?}", k, v);
                Ok(())
            }).unwrap();
            let mut t = st.create_table().unwrap();
            t.set(1, "one").unwrap();
            Ok(t)
        })
        .unwrap();
    lua.globals().set("__ubuntu", ubuntu).unwrap();
    let ubuntu_ctx = lua
        .create_function(|st: &mlua::Lua, t: mlua::Table| -> mlua::Result<mlua::Table> {
            t.for_each(|k: String, v: mlua::Value| {
                println!("{:?} {:?}", k, v);
                Ok(())
            }).unwrap();
            let mut t = st.create_table().unwrap();
            t.set(1, "one").unwrap();
            Ok(t)
        })
        .unwrap();
    lua.globals().set("__ubuntu_ctx", ubuntu_ctx).unwrap();
    lua.load(std::fs::read_to_string(&std::env::args().nth(1).unwrap()).unwrap())
        .exec()
        .unwrap();
    return;
*/
#[tokio::main]
async fn main() {
    tracing_subscriber::registry()
        .with(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| String::new().into()),
        )
        .with(tracing_subscriber::fmt::layer())
        .init();
    let elpe = Elpe {
        deb_client: Arc::new(Client {
            c: lazy_init::Lazy::new(),
            mirror: "http://fr.archive.ubuntu.com/ubuntu".to_string(),
            store_path: Path::new("/home/pe/Projets/frix/store").to_path_buf(),
            in_release: None.into(),
        }),
    };
    let addr = "0.0.0.0:50051".parse().unwrap();
    tonic::transport::Server::builder()
        .add_service(elpe_server::ElpeServer::new(elpe))
        .serve(addr)
        .await
        .unwrap();
    /*
        let h_secu = c.in_release("noble-security").await.unwrap();
        let h = c.in_release("noble").await.unwrap();
        let p_secu = c.packages(&h_secu, "main", "amd64").await.unwrap();
        let p_main = c.packages(&h, "main", "amd64").await.unwrap();
        let p_universe = c.packages(&h, "universe", "amd64").await.unwrap();
        let index_secu = deb::Index::open(&p_secu).unwrap();
        let index_main = deb::Index::open(&p_main).unwrap();
        let index_universe = deb::Index::open(&p_universe).unwrap();
        let h = Arc::new(Mutex::new(HashMap::new()));
        let index = &[index_main, index_universe, index_secu];
        download_extract_deps(index, &c, h.clone(), "hello-traditional")
            .await
            .unwrap();
        download_extract_deps(index, &c, h.clone(), "bash-static")
            .await
            .unwrap();
        trace!("{:#?}", h);
        return;
        let pid = unsafe {
            syscall(
                SYS_clone3,
                &libc::clone_args {
                    flags: (CLONE_NEWPID | CLONE_NEWNET | CLONE_NEWNS) as u64,
                    pidfd: 0,
                    parent_tid: 0,
                    child_tid: 0,
                    stack: 0,
                    stack_size: 0,
                    tls: 0,
                    set_tid: 0,
                    set_tid_size: 0,
                    cgroup: 0,
                    exit_signal: SIGCHLD as u64,
                },
                std::mem::size_of::<libc::clone_args>(),
            )
        };
        println!("pid {:?}", pid);
        if pid == 0 {
            child(&[
                "/home/pe/Projets/frix/tmp",
                "/home/pe/Projets/frix/tmp2",
                "/home/pe/Projets/frix/tmp3",
            ]);
        } else {
            println!("{:?}", std::io::Error::last_os_error());
            let x = unsafe { waitpid(pid as i32, std::ptr::null_mut(), 0) };
            println!("x {:?}", x);
    }
        */
}

use futures::StreamExt;
use std::collections::HashMap;
use std::path::PathBuf;
use tempfile::NamedTempFile;
use thiserror::*;
use tracing::*;
use std::sync::Arc;
pub mod deb;
pub mod extract;
pub mod mount;
#[derive(Debug, Error)]
pub enum Error {
    #[error(transparent)]
    Deb(#[from] deb::Error),
    #[error(transparent)]
    IO(#[from] std::io::Error),
    #[error(transparent)]
    Persist(#[from] tempfile::PersistError),
    #[error(transparent)]
    Elf(#[from] elfedit::Error),
    #[error(transparent)]
    Reqwest(#[from] reqwest::Error),
    #[error("Signature error")]
    Signature,
    #[error("Hash: expected {expected}, got {got}.")]
    WrongHash { expected: String, got: String },
    #[error("Wrong size")]
    WrongSize,
    #[error("Wrong result symlink, expected {expected:?}, got {got:?}")]
    WrongResultSymlink { expected: PathBuf, got: PathBuf },
}
pub struct Client {
    // dest: PathBuf,
    pub c: lazy_init::Lazy<reqwest::Client>,
    pub mirror: String,
    pub store_path: PathBuf,
    pub in_release: tokio::sync::Mutex<Option<Arc<InRelease>>>,
}
#[derive(Debug)]
struct Downloaded {
    path: PathBuf,
}
use sha2::Digest;
use std::process::Stdio;
use tokio::io::{AsyncBufReadExt, AsyncWriteExt};
use tokio::process::Command;
#[derive(Debug)]
pub struct InRelease {
    hashed: HashMap<String, (usize, [u8; 32])>,
    release: std::borrow::Cow<'static, str>,
}
struct HashedWriter<W> {
    hasher: sha2::Sha256,
    w: W,
}
impl<W: std::io::Write> std::io::Write for HashedWriter<W> {
    fn write(&mut self, b: &[u8]) -> Result<usize, std::io::Error> {
        self.hasher.update(b);
        self.w.write_all(b).unwrap();
        Ok(b.len())
    }
    fn flush(&mut self) -> Result<(), std::io::Error> {
        self.w.flush()
    }
}
impl Client {
    fn client(&self) -> &reqwest::Client {
        self.c.get_or_create(|| reqwest::Client::new())
    }
    pub async fn packages(
        &self,
        in_release: &InRelease,
        component: &str,
        arch: &str,
    ) -> Result<PathBuf, Error> {
        let ref m = self.mirror;
        let ref release = in_release.release;
        let end = format!("{component}/binary-{arch}/Packages");
        let end_xz = format!("{component}/binary-{arch}/Packages.xz");
        let (size_xz, expected_hash_xz) = in_release.hashed.get(&end_xz).unwrap();
        let (size, expected_hash) = in_release.hashed.get(&end).unwrap();
        let expected_xz = data_encoding::BASE32_DNSSEC.encode(&*expected_hash_xz);
        let expected = data_encoding::BASE32_DNSSEC.encode(&*expected_hash);
        std::fs::create_dir_all(&self.store_path)?;
        let expected_path = self.store_path.join(&expected);
        if let Ok(_) = std::fs::metadata(&expected_path) {
            return Ok(expected_path);
        }
        let r = self
            .client()
            .get(&format!(
                "{m}/dists/{release}/{component}/binary-{arch}/Packages.xz"
            ))
            .send()
            .await?;
        let file_xz = NamedTempFile::new_in(&self.store_path)?;
        let file = NamedTempFile::new_in(&self.store_path)?;
        let mut xz_dec = xz2::write::XzDecoder::new(HashedWriter {
            w: std::fs::File::create(&file)?,
            hasher: sha2::Sha256::new(),
        });
        let mut f = tokio::fs::File::create(&file_xz).await?;
        let mut r = r.bytes_stream();
        let mut hasher_xz = sha2::Sha256::new();
        let mut total = 0;
        while let Some(item) = r.next().await {
            let item = item?;
            total += item.len();
            {
                // we can't use write_all here, since lzma has padding
                // at the end of the file and the xz2 crate rejects
                // the padding.
                use std::io::Write;
                let mut i = 0;
                loop {
                    let n = xz_dec.write(&item[i..])?;
                    if n == 0 {
                        break;
                    } else {
                        i += n
                    }
                }
            }
            hasher_xz.update(&item);
            f.write_all(&item).await?;
        }
        if total != *size_xz || xz_dec.total_out() != *size as u64 {
            return Err(Error::WrongSize);
        }
        let w = xz_dec.finish().unwrap();
        let got_xz = &hasher_xz.finalize()[..];
        let got = &w.hasher.finalize()[..];
        if got_xz == expected_hash_xz && got == expected_hash {
            let mut expected_path_xz = self.store_path.join(&expected_xz);
            expected_path_xz.set_extension("xz");
            file_xz.persist(&expected_path_xz)?;
            file.persist(&expected_path)?;
            Ok(expected_path)
        } else {
            Err(Error::WrongHash {
                expected: expected_xz,
                got: data_encoding::HEXLOWER.encode(&got),
            })
        }
    }
    pub async fn in_release<R: Into<std::borrow::Cow<'static, str>>>(
        &self,
        release: R,
    ) -> Result<Arc<InRelease>, Error> {
        let ref m = self.mirror;
        let release = release.into();
        let mut ubuntu = self.store_path.join("ubuntu");
        std::fs::create_dir_all(&ubuntu)?;
        ubuntu.push(&*release);
        let mut lock = self.in_release.lock().await;
        if let Some(l) = (&*lock).clone() {
            return Ok(l)
        }
        let f = tokio::fs::File::open(&ubuntu).await;
        if let Ok(f) = f {
            let release = Arc::new(self.read_in_release(release, f).await?);
            *lock = Some(release.clone());
            Ok(release)
        } else {
            let r = self
                .client()
                .get(&format!("{m}/dists/{release}/InRelease"))
                .send()
                .await?;
            eprintln!("writing to {:?}", ubuntu);
            let mut com = Command::new("sq")
                .arg("verify")
                .arg(&format!("--output={}", ubuntu.to_str().unwrap()))
                .stdin(Stdio::piped())
                .spawn()?;
            let mut i = com.stdin.take().unwrap();
            let mut r = r.bytes_stream();
            // Here we know `sq` doesn't start writing until consuming all
            // its stdin.
            while let Some(item) = r.next().await {
                i.write_all(&item?).await?;
            }
            std::mem::drop(i);
            let status = com.wait().await?;
            let result = if status.success() {
                self.read_in_release(release, tokio::fs::File::open(&ubuntu).await?)
                    .await
            } else {
                Err(Error::Signature)
            };
            let release = Arc::new(result?);
            *lock = Some(release.clone());
            Ok(release)
        }
    }
    pub async fn read_in_release<R: tokio::io::AsyncRead + Unpin>(
        &self,
        release: std::borrow::Cow<'static, str>,
        o: R,
    ) -> Result<InRelease, Error> {
        let mut b = tokio::io::BufReader::new(o).lines();
        let mut result = HashMap::new();
        let mut recording = false;
        while let Some(l) = b.next_line().await? {
            if recording && l.starts_with(" ") {
                let mut s = l.split(' ').filter(|x| !x.is_empty());
                let hash = s.next().unwrap();
                let mut hash_ = [0; 32];
                data_encoding::HEXLOWER_PERMISSIVE
                    .decode_mut(hash.as_bytes(), &mut hash_)
                    .unwrap();
                let size = s.next().unwrap();
                let name = s.next().unwrap();
                result.insert(name.to_string(), (size.parse().unwrap(), hash_));
            } else {
                recording = l == "SHA256:";
            }
        }
        Ok(InRelease {
            release,
            hashed: result,
        })
    }
    fn url(&self, package: &deb::Stanza) -> String {
        let ref m = self.mirror;
        let filename = package.file_name.unwrap();
        format!("{m}/{filename}")
    }
    async fn download_url<'a>(&self, url: &str, sha256: &str) -> Result<(Downloaded, bool), Error> {
        let base = url.split('/').last().unwrap();
        let path = self.store_path.join(&format!("{}-{}", sha256, base));
        if tokio::fs::metadata(&path).await.is_ok() {
            return Ok((Downloaded { path }, false));
        }
        info!("download url {:?} {:?}", url, sha256);
        let r = self.client().get(url).send().await?;
        let mut s = r.bytes_stream();
        tokio::fs::create_dir_all(&self.store_path).await?;
        let mut hasher = sha2::Sha256::new();
        let mut f = tokio::fs::File::create(&path).await?;
        while let Some(item) = s.next().await {
            let item = item?;
            hasher.update(&item);
            f.write_all(&item).await?;
        }
        f.flush().await?;
        let hash = data_encoding::HEXLOWER_PERMISSIVE.encode(&hasher.finalize());
        if &hash != sha256 {
            return Err(Error::WrongHash {
                expected: sha256.to_string(),
                got: hash,
            });
        }
        Ok((Downloaded { path }, true))
    }
}

use crate::{Client, Downloaded, Error};
use std::collections::{BTreeSet, HashMap};
use std::ffi::CString;
use std::io::Write;
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};
use tokio::sync::Semaphore;
use tracing::*;
use crate::deb;
pub async fn download_extract_deps(
    index: &[deb::Index],
    client: &Arc<Client>,
    package: &str,
) -> Result<Vec<PathBuf>, Error> {
    let files = Arc::new(Mutex::new(HashMap::new()));
    let mut seen = HashMap::new();
    let pkg = multi_lookup(index, &package).unwrap();
    let mut stack = vec![StackElt {
        package: pkg,
        rx: None,
        deps: Vec::new(),
        deps_h: BTreeSet::new(),
        ld_path: Vec::new(),
        ld_path_h: BTreeSet::new(),
    }];
    let tasks = Arc::new(Semaphore::new(MAX_PARALLEL_DOWNLOADS));
    let mut result = Vec::new();
    while let Some(mut elt) = stack.pop() {
        info!("{:?}", elt);
        if let Some(rx) = elt.rx.take() {
            let downloaded = rx.await.unwrap();
            info!("downloaded {:?}", elt.package);
            elt.finalize(client, &files, downloaded, &mut stack, &mut result)
                .await?;
            seen.insert(elt.package.package, (elt.ld_path, elt.deps));
        } else {
            if let Some((ld_path, deps)) = seen.get(&elt.package.package) {
                if let Some(last) = stack.iter_mut().rev().filter(|x| x.rx.is_some()).next() {
                    for ld in ld_path {
                        if last.ld_path_h.insert(ld.clone()) {
                            last.ld_path.push(ld.clone());
                        }
                    }
                    for dep in deps {
                        if last.deps_h.insert(dep.clone()) {
                            last.deps.push(dep.clone());
                        }
                    }
                }
                continue;
            }
            use std::collections::hash_map::Entry;
            if let Entry::Vacant(e) = seen.entry(elt.package.package) {
                e.insert((Vec::new(), Vec::new()));
            } else {
                unreachable!()
            }
            let client = client.clone();
            let url = client.url(&elt.package);
            let sha256 = elt.package.sha256.unwrap().to_string();
            let (tx, rx) = tokio::sync::oneshot::channel();
            let files = files.clone();
            let tasks = tasks.clone();
            tokio::spawn(async move {
                let permit = tasks.acquire_owned().await.unwrap();
                info!("downloading {:?}", url);
                let (mut task, downloaded) = client.download_url(&url, &sha256).await.unwrap();
                info!("finished downloading {:?}", url);
                if downloaded {
                    tokio::task::spawn_blocking(move || {
                        extract_task(&mut task, &mut *files.lock().unwrap()).unwrap();
                        info!("finished extracting {:?}", url);
                        tx.send(task).unwrap_or(());
                        info!("sent {:?}", url);
                    })
                    .await
                    .unwrap();
                } else {
                    task.path.set_extension("");
                    let mut files = files.lock().unwrap();
                    for f in find_files(task.path.clone()) {
                        if let Ok(p) = f.strip_prefix(&task.path) {
                            use std::collections::hash_map::Entry;
                            if let Entry::Vacant(e) = files.entry(p.to_path_buf()) {
                                debug!("cached {:?} -> {:?}", p, f);
                                e.insert(task.path.clone());
                            }
                        }
                    }
                    tx.send(task).unwrap_or(());
                }
                std::mem::drop(permit);
                Ok::<_, Error>(())
            });
            elt.rx = Some(rx);
            push_deps(index, elt, &mut stack);
        }
    }
    Ok(result)
}
async fn hash_reader(
    mut reader: impl tokio::io::AsyncReadExt + std::marker::Unpin,
    hasher: &mut blake3::Hasher,
) -> std::io::Result<u64> {
    let mut buffer = [0; 65536];
    let mut total = 0;
    loop {
        match reader.read(&mut buffer).await {
            Ok(0) => return Ok(total),
            Ok(n) => {
                hasher.update(&buffer[..n]);
                total += n as u64;
            }
            Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
            Err(e) => return Err(e),
        }
    }
}
fn extract_task(
    download: &mut Downloaded,
    files: &mut HashMap<PathBuf, PathBuf>,
) -> Result<(), Error> {
    debug!("extracting {:?}", download);
    let mut f = std::io::BufReader::new(std::fs::File::open(&download.path)?);
    let d = deb::Deb::read(&mut f)?;
    download.path.set_extension("");
    std::fs::create_dir_all(&download.path)?;
    d.decompress(&mut f, &download.path, |path| {
        use std::collections::hash_map::Entry;
        let path = if let Ok(p) = path.strip_prefix(".") {
            p.to_path_buf()
        } else {
            path.to_path_buf()
        };
        debug!("extract {:?} -> {:?}", path, download.path);
        if let Entry::Vacant(e) = files.entry(path) {
            e.insert(download.path.clone());
        }
    })?;
    Ok(())
}
const MAX_PARALLEL_DOWNLOADS: usize = 20;
fn multi_lookup<'a>(index: &'a [deb::Index], package: &str) -> Option<deb::Stanza<'a>> {
    for ind in index {
        if let Some(i) = ind.lookup(&package) {
            return Some(i);
        }
    }
    None
}
struct FindFiles {
    stack: Vec<(PathBuf, std::fs::Metadata, bool)>,
}
fn find_files(path: PathBuf) -> FindFiles {
    let meta = std::fs::metadata(&path).unwrap();
    FindFiles {
        stack: vec![(path, meta, false)],
    }
}
impl Iterator for FindFiles {
    type Item = PathBuf;
    fn next(&mut self) -> Option<Self::Item> {
        while let Some((p, meta, visited)) = self.stack.pop() {
            if visited {
                continue;
            }
            if let Ok(dir) = std::fs::read_dir(&p) {
                self.stack.push((p, meta, true));
                for e in dir {
                    if let Ok(e) = e {
                        self.stack.push((e.path(), e.metadata().unwrap(), false));
                    }
                }
            } else if meta.is_file() || meta.is_symlink() {
                return Some(p);
            } else {
                error!("could not read {:?}", p);
                continue;
            }
        }
        None
    }
}
type Files = Arc<Mutex<HashMap<PathBuf, PathBuf>>>;
impl<'a> StackElt<'a> {
    fn add_ld_paths(&mut self, path: &Path) -> Result<(), std::io::Error> {
        let mut ld_so = path.join("etc");
        ld_so.push("ld.so.conf.d");
        if let Ok(dir) = std::fs::read_dir(&ld_so) {
            for f in dir {
                let f = f?;
                if let Ok(f) = std::fs::read_to_string(&f.path()) {
                    for path in f.lines().rev().filter(|x| !x.starts_with("#")) {
                        let path = Path::new(path);
                        if self.ld_path_h.insert(Arc::new(path.to_path_buf())) {
                            self.ld_path.push(Arc::new(path.to_path_buf()))
                        }
                    }
                }
            }
        }
        if !self.ld_path.is_empty() {
            info!("ld_path: {:?}", self.ld_path)
        }
        Ok(())
    }
    fn find_libs(&mut self, path: &Path, dest: &Path) {
        for ld in self.ld_path.iter() {
            let path = path.join(ld.strip_prefix("/").unwrap());
            debug!("checking {:?}", path);
            if std::fs::metadata(&path).is_ok() {
                let path = Arc::new(dest.join(ld.strip_prefix("/").unwrap()));
                if self.deps_h.insert(path.clone()) {
                    self.deps.push(path);
                }
            }
        }
    }
    fn patch_elf(&mut self, f: &Path, dest_path: &Path, files: &Files) -> Result<bool, Error> {
        use elfedit::*;
        info!("patch_elf {:?}", f);
        let file = std::fs::OpenOptions::new()
            .read(true)
            .write(true)
            .open(&f)?;
        let Ok(mut elf) = Elf::open(&file) else {
            return Ok(false);
        };
        info!("patching {:?}", f);
        let Some(parsed) = elf.parse().unwrap() else {
            info!("No dynamic section");
            return Ok(false);
        };
        let has_needed = parsed.needed().next().is_some();
        let interp = parsed.interpreter();
        if let Some(interp) = interp.unwrap() {
            let interp = interp.to_str().unwrap();
            let files = files.lock().unwrap();
            let p = Path::new(interp).strip_prefix("/").unwrap();
            let subst = if let Some(subst) = files.get(p) {
                subst.join(p)
            } else if interp.starts_with("/usr")
                || interp.starts_with("/lib")
                || interp.starts_with("/bin")
            {
                // https://www.freedesktop.org/wiki/Software/systemd/TheCaseForTheUsrMerge/
                let p2 = "usr".to_string() + interp;
                let p2 = Path::new(&p2);
                debug!("{:?}", p2);
                if let Some(subst) = files.get(p2) {
                    subst.join(p2)
                } else {
                    error!("No subst for {:?}", p2);
                    let mut p2 = p2.to_path_buf();
                    while p2.pop() {
                        debug!("p2 = {:?} {:?}", p2, files.get(&p2));
                    }
                    return Ok(false);
                }
            } else {
                // TODO: not sure what else to do here, we
                // might want to set the interpreter to a
                // different value (equivalent to "recompiling
                // everything" on Nix).
                info!("Interpreter is {interp}. Already patched?");
                return Ok(false);
            };
            let subst = CString::new(subst.to_str().unwrap()).unwrap();
            info!("{:?}", subst);
            elf.set_interpreter(subst.to_bytes_with_nul());
        } else if !has_needed {
            // No need to patch
            return Ok(false);
        }
        let mut deps_h = BTreeSet::new();
        let mut path = String::new();
        for dep in self.deps.iter().rev() {
            debug!("dep = {:?}", dep);
            if !deps_h.insert(dep) {
                continue;
            }
            if !path.is_empty() {
                path.push(':')
            }
            path.push_str(dep.to_str().unwrap());
        }
        path.push('\0');
        info!("Setting path {:?}", path);
        if has_needed {
            elf.set_runpath(&path.as_bytes());
        }
        debug!("patching into {:?}", dest_path);
        Ok(elf.update(Some(dest_path)).unwrap()) // map_err(From::from)
    }
    async fn finalize(
        &mut self,
        client: &Client,
        files: &Files,
        downloaded: Downloaded,
        stack: &mut Vec<StackElt<'a>>,
        result: &mut Vec<PathBuf>,
    ) -> Result<(), Error> {
        let mut context_hasher = blake3::Hasher::new();
        context_hasher.update(self.package.sha256.unwrap().as_bytes());
        for d in self.deps.iter() {
            context_hasher.update(d.to_str().unwrap().as_bytes());
        }
        let dest = client
            .store_path
            .join(data_encoding::HEXLOWER.encode(context_hasher.finalize().as_bytes()));
        // Find the extra ld paths to look for.
        self.add_ld_paths(&downloaded.path).unwrap();
        let initial_deps_len = self.deps.len();
        // Find the libs in this package.
        self.find_libs(&downloaded.path, &dest);
        let base_package_name = self.package.file_name.unwrap().split('/').last().unwrap();
        let base_package_name = Path::new(&base_package_name).with_extension("");
        let base_package_name = base_package_name.to_str().unwrap();
        let final_path = if std::fs::metadata(&dest).is_err() {
            info!("patching");
            // Patch the ELFs, now that we have all the deps.
            let mut hashing = Vec::new();
            for f in find_files(downloaded.path.clone()) {
                let dest_path = dest.join(&f.strip_prefix(&downloaded.path).unwrap());
                std::fs::create_dir_all(dest_path.parent().unwrap()).unwrap();
                let patched = self.patch_elf(&f, &dest_path, &files).unwrap_or(false);
                if !patched {
                    // Hard link
                    debug!("hard link {:?} {:?}", f, dest_path);
                    std::fs::hard_link(&f, &dest_path).unwrap_or(());
                }
                hashing.push(tokio::spawn(async move {
                    // hash + write
                    info!("hashing {:?}", f);
                    if let Ok(link) = std::fs::read_link(&dest_path) {
                        Ok(Some((dest_path, link.to_str().unwrap().to_string())))
                    } else if let Ok(file) = tokio::fs::File::open(&dest_path).await {
                        let mut hasher = blake3::Hasher::new();
                        hash_reader(file, &mut hasher).await?;
                        let hex = data_encoding::HEXLOWER.encode(hasher.finalize().as_bytes());
                        Ok::<_, Error>(Some((f, hex)))
                    } else {
                        Ok(None)
                    }
                }));
            }
            info!("patched all");
            let mut hashes = Vec::with_capacity(hashing.len());
            for h in hashing.into_iter() {
                if let Some(h) = h.await.unwrap().unwrap() {
                    hashes.push(h)
                }
            }
            hashes.sort_by(|a, b| a.0.cmp(&b.0));
            info!("hashed all");
            let mut output_hasher = blake3::Hasher::new();
            let blakesums = dest.join("blake3sums");
            let mut file = std::fs::File::create(&blakesums).unwrap();
            for (path, hash) in hashes {
                debug!("strip {:?} {:?}", path, downloaded.path);
                let path = path.to_str().unwrap();
                writeln!(file, "{} {}", hash, path)?;
                writeln!(output_hasher, "{} {}", hash, path)?;
            }
            client.store_path.join(&format!(
                "{}-{}",
                data_encoding::HEXLOWER.encode(output_hasher.finalize().as_bytes()),
                base_package_name,
            ))
        } else {
            info!("found, no patching");
            let mut output_hasher = blake3::Hasher::new();
            let blakesums = dest.join("blake3sums");
            let file = tokio::fs::File::open(&blakesums).await.unwrap();
            hash_reader(file, &mut output_hasher).await?;
            client.store_path.join(&format!(
                "{}-{}",
                data_encoding::HEXLOWER.encode(output_hasher.finalize().as_bytes()),
                base_package_name,
            ))
        };
        // Replace prefix for all library deps we've just added,
        // in order to get a Merkle tree.
        for dep in &mut self.deps[initial_deps_len..] {
            let end = dep.strip_prefix(&dest).unwrap();
            *dep = Arc::new(final_path.join(&end));
        }
        info!("symlink {:?} {:?}", downloaded.path, final_path);
        match std::os::unix::fs::symlink(&dest, &final_path) {
            Ok(()) => (),
            Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {
                let got = std::fs::read_link(&final_path)?;
                if dest != got {
                    return Err(Error::WrongResultSymlink {
                        expected: dest,
                        got,
                    });
                }
            }
            Err(e) => return Err(e.into()),
        }
        result.push(final_path);
        // Maintenant, faire remonter les deps.
        if let Some(last) = stack.iter_mut().rev().filter(|x| x.rx.is_some()).next() {
            for ld in self.ld_path.iter() {
                if last.ld_path_h.insert(ld.clone()) {
                    last.ld_path.push(ld.clone());
                }
            }
            for dep in self.deps.iter() {
                if last.deps_h.insert(dep.clone()) {
                    last.deps.push(dep.clone());
                }
            }
        }
        info!("done with {:?}", self.package.package);
        Ok(())
    }
}
fn push_deps<'a>(index: &'a [deb::Index], elt: StackElt<'a>, stack: &mut Vec<StackElt<'a>>) {
    let depends = elt.package.depends.clone();
    stack.push(elt);
    for dep in depends.iter() {
        match dep {
            deb::Dep::Simple(s) => {
                debug!("dep {:?}", s);
                let dep = multi_lookup(index, &s.name).unwrap();
                stack.push(StackElt {
                    package: dep,
                    rx: None,
                    deps: Vec::new(),
                    deps_h: BTreeSet::new(),
                    ld_path: Vec::new(),
                    ld_path_h: BTreeSet::new(),
                })
            }
            deb::Dep::Alternatives { alt } => {
                debug!("alt {:?}", alt);
                for dep in alt {
                    if let Some(dep_) = multi_lookup(index, &dep.name) {
                        stack.push(StackElt {
                            package: dep_,
                            rx: None,
                            deps: Vec::new(),
                            deps_h: BTreeSet::new(),
                            ld_path: Vec::new(),
                            ld_path_h: BTreeSet::new(),
                        });
                        return;
                    }
                }
                panic!("Not found: {:?}", alt);
            }
        }
    }
}
#[derive(Debug)]
struct StackElt<'a> {
    package: deb::Stanza<'a>,
    rx: Option<tokio::sync::oneshot::Receiver<Downloaded>>,
    deps: Vec<Arc<PathBuf>>,
    deps_h: BTreeSet<Arc<PathBuf>>,
    ld_path: Vec<Arc<PathBuf>>,
    ld_path_h: BTreeSet<Arc<PathBuf>>,
}

use lazy_static::lazy_static;
use std::collections::HashMap;
use std::ffi::OsStr;
use std::io::{BufRead, BufReader, Read, Seek, SeekFrom};
use thiserror::*;
use tracing::*;
mod index;
pub use index::*;
/// A parsed .deb file.
#[derive(Debug)]
pub struct Deb {
    md5sums: HashMap<String, String>,
    control_file: String,
    global: Header,
    control: Header,
    data: Header,
    data_offset: u64,
}
/// A "stanza", i.e. a description of a Debian package.
#[derive(Debug, Default, Clone)]
pub struct Stanza<'a> {
    pub package: &'a str,
    pub version: Version<'a>,
    pub architecture: &'a str,
    pub depends: Vec<Dep<'a>>,
    pub sha256: Option<&'a str>,
    pub size: Option<usize>,
    pub file_name: Option<&'a str>,
}
/// A dependency, which is either a "simple" dependency, or a list of
/// alternatives.
#[derive(Debug, Clone)]
pub enum Dep<'a> {
    Simple(SimpleDep<'a>),
    Alternatives { alt: Vec<SimpleDep<'a>> },
}
/// A single dependency.
#[derive(Debug, Clone)]
pub struct SimpleDep<'a> {
    pub name: &'a str,
    pub any: bool,
    pub constraints: Vec<(&'a str, Version<'a>)>,
}
fn parse_control(s: &str) -> IResult<&str, Stanza> {
    let mut st = Stanza::default();
    for l in s.lines() {
        if l.is_empty() {
            let (_, b) = s.split_at(l.as_ptr() as usize - s.as_ptr() as usize);
            return Ok((b, st));
        }
        if let Some(i) = l.find(':') {
            let (key, val) = l.split_at(i);
            let (_, val) = val.split_at(1);
            debug!("key {:?} {:?}", key, val);
            match key.trim() {
                "Package" => st.package = val.trim(),
                "Version" => st.version = parse_version(val.trim()).unwrap().1,
                "Architecture" => st.architecture = val.trim(),
                "SHA256" => st.sha256 = Some(val.trim()),
                "Filename" => st.file_name = Some(val.trim()),
                "Depends" | "Pre-Depends" => {
                    let d = parse_deps(val.trim());
                    debug!("{:?}", d);
                    if let Ok(("", a)) = d {
                        st.depends = a
                    } else {
                        error!("error {:?}", val.trim());
                        return nom::IResult::Err(nom::Err::Error(nom::error::make_error(
                            s,
                            nom::error::ErrorKind::Tag,
                        )));
                    }
                }
                _ => {}
            }
        }
    }
    Ok(("", st))
}
/// A version of a package.
///
/// Debian versions have mechanisms to override upstream ones, such as
/// the "epoch" prefix to reorder versions if necessary, and the
/// "debian" suffix to add specifics.
#[derive(Debug, Clone)]
pub struct Version<'a> {
    pub epoch: u32,
    pub upstream_version: Upstream<'a>,
    pub debian: Option<&'a str>,
}
impl<'a> Default for Version<'a> {
    fn default() -> Version<'a> {
        Version {
            epoch: 0,
            upstream_version: Upstream(""),
            debian: None,
        }
    }
}
fn parse_constraint<'a>(s: &'a str) -> IResult<&'a str, (&'a str, Version<'a>)> {
    let (s, constraint) = tag("<<")
        .or(tag("<="))
        .or(tag("="))
        .or(tag(">="))
        .or(tag(">>"))
        .parse(s)?;
    debug!("parse_constraint {:?}", constraint);
    let (s, _) = space0(s)?;
    let (s, version) = parse_version(s)?;
    debug!("parse_constraint {:?} {:?}", s, (constraint, &version));
    Ok((s, (constraint, version)))
}
fn parse_dep<'a>(s0: &'a str) -> IResult<&'a str, Dep<'a>> {
    let (s, name) = parse_name(s0)?;
    let (s, any) = if s.starts_with(":any") {
        let (_, b) = s.split_at(4);
        (b, true)
    } else {
        (s, false)
    };
    let (s, _) = space0(s)?;
    let mut constraints = Vec::new();
    if let Ok((s, _)) = tag::<_, _, ()>("(").parse(s) {
        let (s, version) = if let Some(i) = s.find(')') {
            let (a, b) = s.split_at(i);
            let (_, b) = b.split_at(1);
            (b, a)
        } else {
            return nom::IResult::Err(nom::Err::Error(nom::error::make_error(
                s,
                nom::error::ErrorKind::Tag,
            )));
        };
        let mut v = version;
        while let Ok((v_, c)) = parse_constraint(v) {
            constraints.push(c);
            let (v_, _) = space0(v_)?;
            if let Ok((v_, _)) = tag::<_, _, ()>(",").parse(v_) {
                let (v_, _) = space0(v_)?;
                v = v_;
            } else {
                break;
            }
        }
        Ok((
            s,
            Dep::Simple(SimpleDep {
                name,
                any,
                constraints,
            }),
        ))
    } else {
        Ok((
            s,
            Dep::Simple(SimpleDep {
                name,
                any,
                constraints,
            }),
        ))
    }
}
fn parse_name(s: &str) -> IResult<&str, &str> {
    if let Some(i) = s.find(|c| {
        !((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '.' || c == '+' || c == '-')
    }) {
        if i > 0 {
            let (a, b) = s.split_at(i);
            return Ok((b, a));
        }
    } else {
        return Ok(("", s));
    }
    error!("ERROR {:?}", s);
    return nom::IResult::Err(nom::Err::Error(nom::error::make_error(
        s,
        nom::error::ErrorKind::Tag,
    )));
}
fn parse_deps<'a>(s: &'a str) -> IResult<&'a str, Vec<Dep<'a>>> {
    let mut d = Vec::new();
    let (mut s, _) = space0(s)?;
    while let Ok((s_, d_)) = parse_dep(s) {
        debug!("parse_dep {:?}", d_);
        let (s_, _) = space0(s_)?;
        if let Ok((s_, _)) = tag::<_, _, ()>("|").parse(s_) {
            let (s_, _) = space0(s_)?;
            s = s_;
            match d.pop() {
                Some(Dep::Alternatives { ref mut alt }) => {
                    if let Dep::Simple(d_) = d_ {
                        alt.push(d_)
                    }
                }
                _ => {
                    if let Dep::Simple(d_) = d_ {
                        d.push(Dep::Alternatives { alt: vec![d_] })
                    }
                }
            }
        } else if let Ok((s_, _)) = tag::<_, _, ()>(",").parse(s_) {
            d.push(d_);
            s = s_;
        } else {
            d.push(d_);
            s = s_;
            break;
        }
        let (s_, _) = space0(s)?;
        s = s_;
    }
    Ok((s, d))
}
/// The representation of an upstream version. Will implement `Ord`.
#[derive(Debug, Clone)]
pub struct Upstream<'a>(&'a str);
use nom::{
    IResult, Parser,
    bytes::tag,
    character::complete::{digit1, newline, space0},
    multi::separated_list1,
};
/// Parse a version in the Debian version format.
fn parse_version<'a>(s: &'a str) -> IResult<&'a str, Version<'a>> {
    fn epoch(s: &str) -> IResult<&str, u32> {
        let (s, i) = digit1(s)?;
        let (s, _) = tag(":").parse(s)?;
        Ok((s, i.parse().unwrap()))
    }
    let (s, epoch) = epoch(s).unwrap_or((s, 0));
    lazy_static! {
        static ref RE_DASH: regex::Regex =
            regex::Regex::new(r"^[a-z0-9.~+-]+-([a-z0-9.~+]+)").unwrap();
        static ref RE: regex::Regex = regex::Regex::new(r"^[a-z0-9.~+]+").unwrap();
    }
    let (s, v) = if let Some(m) = RE_DASH.find(s) {
        let (a, b) = s.split_at(m.end());
        (b, a)
    } else if let Some(m) = RE.find(s) {
        let (a, b) = s.split_at(m.end());
        (b, a)
    } else {
        return nom::IResult::Err(nom::Err::Error(nom::error::make_error(
            s,
            nom::error::ErrorKind::Tag,
        )));
    };
    let (upstream_version, debian) = if let Some(i) = v.rfind('-') {
        let (a, b) = v.split_at(i);
        (Upstream(a), Some(b.split_at(1).1))
    } else {
        (Upstream(v), None)
    };
    Ok((
        s,
        Version {
            epoch,
            upstream_version,
            debian,
        },
    ))
}
/// Structure of the "headers" in the debian file. No alignment
/// necessary, the numbers are in decimal. No heap allocation.
#[derive(Debug)]
#[repr(C)]
struct H {
    file_id: [u8; 16],
    timestamp: [u8; 12],
    owner_id: [u8; 6],
    group_id: [u8; 6],
    file_mode: [u8; 8],
    file_size: [u8; 10],
    end_char: [u8; 2],
}
/// Parsed version of `H`, still no heap allocation.
#[derive(Debug)]
struct Header {
    file_id: [u8; 16],
    timestamp: u64,
    owner_id: u32,
    group_id: u32,
    file_mode: u32,
    file_size: u64,
}
/// Possible errors for .deb files.
#[derive(Debug, Error)]
pub enum Error {
    #[error("Deb file parse error")]
    ParseError,
    #[error(transparent)]
    Utf8(#[from] std::str::Utf8Error),
    #[error(transparent)]
    Int(#[from] std::num::ParseIntError),
    #[error(transparent)]
    IO(#[from] std::io::Error),
    #[error("Unsupported compression algorithm: {file_id}")]
    UnsupportedCompression { file_id: String },
    #[error("Version parse: {version}")]
    Version { version: String },
}
impl Header {
    pub fn file_id(&self) -> &str {
        unsafe { std::str::from_utf8_unchecked(&self.file_id).trim() }
    }
}
impl H {
    fn parse(&self) -> Result<Header, Error> {
        std::str::from_utf8(&self.file_id)?;
        Ok(Header {
            file_id: self.file_id,
            timestamp: std::str::from_utf8(&self.timestamp)?.trim().parse()?,
            owner_id: std::str::from_utf8(&self.owner_id)?.trim().parse()?,
            group_id: std::str::from_utf8(&self.group_id)?.trim().parse().unwrap(),
            file_mode: u32::from_str_radix(std::str::from_utf8(&self.file_mode)?.trim(), 8)?,
            file_size: std::str::from_utf8(&self.file_size)?.trim().parse()?,
        })
    }
}
fn read_hdr<R: Read>(r: &mut R) -> Result<Header, Error> {
    unsafe {
        assert_eq!(std::mem::size_of::<H>(), HEADER_SIZE as usize);
        let mut b: H = std::mem::zeroed();
        r.read_exact(&mut std::slice::from_raw_parts_mut(
            &mut b as *mut H as *mut u8,
            std::mem::size_of::<H>(),
        ))?;
        debug!("{:?}", b);
        b.parse()
    }
}
const HEADER_SIZE: u64 = 60;
const SIGNATURE_SIZE: u64 = 8;
impl Deb {
    pub fn parse_control(&self) -> Vec<Stanza> {
        if let Ok(("", st)) = separated_list1(newline, parse_control).parse(&self.control_file) {
            st
        } else {
            Vec::new()
        }
    }
    pub fn md5sums(&self) -> &HashMap<String, String> {
        &self.md5sums
    }
    pub fn decompress<R: BufRead + Seek, P: AsRef<std::path::Path>, F: FnMut(&std::path::Path)>(
        &self,
        mut r: R,
        path: P,
        mut f: F,
    ) -> Result<(), Error> {
        r.seek(SeekFrom::Start(self.data_offset))?;
        debug!("decompress {:?}", self.data.file_id());
        if self.data.file_id().ends_with(".tar.gz") {
            unimplemented!()
        } else if self.data.file_id().ends_with(".tar.zst") {
            let mut ar = tar::Archive::new(
                zstd::stream::read::Decoder::new(r.take(self.data.file_size)).unwrap(),
            );
            for e in ar.entries()? {
                let mut e = e?;
                f(&e.path()?);
                e.unpack_in(&path)?;
            }
        } else {
            unimplemented!()
        };
        Ok(())
    }
    pub fn read<R: BufRead + Seek>(mut r: R) -> Result<Deb, Error> {
        let mut b = [0; 8];
        r.read_exact(&mut b)?;
        if &b != b"!<arch>\n" {
            return Err(Error::ParseError);
        }
        let global = read_hdr(&mut r)?;
        trace!("GLOBAL {:?}", global);
        r.seek(SeekFrom::Current(global.file_size as i64))?;
        r.skip_until(b'c')?; // 'control.…'
        r.seek(SeekFrom::Current(-1))?;
        let control = read_hdr(&mut r)?;
        trace!("CONTROL {:?}", control);
        // Control files are expected to be short, decompress.
        let mut ctrl = vec![0; control.file_size as usize];
        r.read_exact(&mut ctrl)?;
        // gzip xz zstd none
        let ctrl_tar = if control.file_id().ends_with(".tar.gz") {
            unimplemented!()
        } else if control.file_id().ends_with(".tar.zst") {
            zstd::decode_all(&ctrl[..])?
        } else if control.file_id().ends_with(".tar.xz") {
            unimplemented!()
        } else if control.file_id().ends_with(".tar") {
            ctrl
        } else {
            return Err(Error::UnsupportedCompression {
                file_id: control.file_id().to_string(),
            });
        };
        let mut ctrl_tar = tar::Archive::new(&ctrl_tar[..]);
        let mut control_file = String::new();
        let mut md5sums = HashMap::new();
        for e in ctrl_tar.entries().unwrap() {
            let mut e = e.unwrap();
            if e.path()?.file_name() == Some(OsStr::new("control")) {
                e.read_to_string(&mut control_file)?;
            } else if e.path()?.file_name() == Some(OsStr::new("md5sums")) {
                let mut e = BufReader::new(e);
                let mut s = String::new();
                while e.read_line(&mut s)? > 0 {
                    let mut it = s.split(' ').filter(|x| !x.is_empty());
                    if let (Some(hash), Some(file)) = (it.next(), it.next()) {
                        md5sums.insert(file.trim().to_string(), hash.trim().to_string());
                    }
                    s.clear();
                }
            }
        }
        r.seek(SeekFrom::Start(
            SIGNATURE_SIZE + 2 * HEADER_SIZE + control.file_size,
        ))?;
        r.skip_until(b'd')?; // 'data.…'
        r.seek(SeekFrom::Current(-1))?;
        let data = read_hdr(&mut r)?;
        Ok(Deb {
            md5sums,
            global,
            control,
            control_file,
            data,
            data_offset: r.seek(SeekFrom::Current(0))?,
        })
    }
}

use super::{Stanza, parse_control};
use tracing::*;
use std::num::NonZeroUsize;
use std::sync::{Arc, Mutex};
/// The index of a package repository.
///
/// These files are made of many stanzas sorted in lexicographical
/// order of the package name. Internally this is represented as a
/// memory-mapped file.
pub struct Index {
    map: memmap::Mmap,
    lru: Arc<Mutex<lru::LruCache<String, Option<(usize, usize)>>>>,
}
impl Index {
    pub fn open<P: AsRef<std::path::Path>>(f: P) -> Result<Self, std::io::Error> {
        let file = std::fs::File::open(f)?;
        let mmap = unsafe { memmap::MmapOptions::new().map(&file)? };
        Ok(Index {
            map: mmap,
            lru: Arc::new(Mutex::new(lru::LruCache::new(NonZeroUsize::new(256).unwrap()))),
        })
    }
    pub fn lookup(&self, package: &str) -> Option<Stanza> {
        info!("Looking up {:?}", package);
        let s = &*self.map;
        match self.lru.lock().unwrap().get(package) {
            Some(Some((m1, m2))) => {
                let line = std::str::from_utf8(&s[*m1..*m2]).unwrap().trim();
                let (_, st) = parse_control(line).unwrap();
                return Some(st)
            }
            Some(None) => {
                return None
            },
            None => {},
        }
        let mut a = 0;
        let mut b = s.len();
        // Now, dichotomy.
        loop {
            debug!(
                "a = {:?}",
                std::str::from_utf8(&s[a..s.len().min(a + 30)]).unwrap()
            );
            debug!(
                "b = {:?}",
                std::str::from_utf8(&s[b..s.len().min(b + 30)]).unwrap()
            );
            let mut m1 = (a + b) / 2;
            while m1 > a && (s[m1] != b'\n' || s[m1 + 1] != b'\n') {
                m1 -= 1;
            }
            let mut m2 = m1 + 2;
            while m2 + 1 < b && (s[m2] != b'\n' || s[m2 + 1] != b'\n') {
                m2 += 1;
            }
            if m2 < b {
                m2 += 1
            }
            let line = std::str::from_utf8(&s[m1..m2]).unwrap().trim();
            if line.is_empty() {
                // This may happen if b = a + 1.
                debug!("not found: {:?}", package);
                self.lru.lock().unwrap().put(package.to_string(), None);
                return None;
            }
            debug!("line {:?}", line);
            if let Ok((_, st)) = parse_control(line) {
                debug!("package: {:?}", st.package);
                if st.package == package {
                    debug!("found {:?}", package);
                    self.lru.lock().unwrap().put(package.to_string(), Some((m1, m2)));
                    return Some(st);
                } else if st.package < package {
                    debug!("smaller");
                    a = m2
                } else {
                    debug!("greater");
                    b = m1
                }
            } else {
                panic!("parse {:?}", line);
            }
            if a >= b {
                debug!(
                    "break a = {:?}",
                    std::str::from_utf8(&s[a..s.len().min(a + 30)]).unwrap()
                );
                debug!(
                    "break b = {:?}",
                    std::str::from_utf8(&s[b..s.len().min(b + 30)]).unwrap()
                );
                break;
            }
        }
        debug!("not found 2: {:?}", package);
        self.lru.lock().unwrap().put(package.to_string(), None);
        None
    }
}

syntax = "proto3";
package elpe;
message DerivationRequest {
  string name = 1;
  string builder = 2;
}
message DerivationReply {
  repeated string path = 1;
  optional string error = 2;
}
enum Arch {
  amd64 = 0;
  aarch64 = 1;
}
message UbuntuReleaseRequest {
  string release = 1;
  Arch arch = 2;
  string repository = 3;
}
message UbuntuPackageRequest {
  repeated string index = 1;
  string name = 2;
}
service Elpe {
  rpc Derivation (DerivationRequest) returns (DerivationReply);
  rpc UbuntuRelease (UbuntuReleaseRequest) returns (DerivationReply);
  rpc UbuntuPackage (UbuntuPackageRequest) returns (DerivationReply);
}

open Grpc_lwt
open Lwt.Syntax
exception Error of H2.Client_connection.error
let connection address port =
  (* Setup Http/2 connection *)
  let* addresses =
    Lwt_unix.getaddrinfo address (string_of_int port)
      [ Unix.(AI_FAMILY PF_INET) ]
  in
  let socket = Lwt_unix.socket Unix.PF_INET Unix.SOCK_STREAM 0 in
  let* () = Lwt_unix.connect socket (List.hd addresses).Unix.ai_addr in
  let error_handler e =
    raise (Error e)
  in
  H2_lwt_unix.Client.create_connection ~error_handler socket
let ubuntu_release connection ~release ~arch ~repository =
  let req =
    Elpegrpc.Elpe.UbuntuReleaseRequest.make ~release ~arch ~repository ()
  in
  let open Ocaml_protoc_plugin in
  let open Elpegrpc.Elpe in
  let encode, decode = Service.make_client_functions Elpe.ubuntuRelease in
  let enc = encode req |> Writer.contents in
  Client.call ~service:"elpe.Elpe" ~rpc:"UbuntuRelease"
    ~do_request:
      (H2_lwt_unix.Client.request connection ~error_handler:(fun _ ->
           failwith "Error"))
    ~handler:
      (Client.Rpc.unary enc ~f:(fun decoder ->
           let+ decoder = decoder in
           match decoder with
           | Some decoder -> (
               Reader.create decoder |> decode |> function
               | Ok v -> v
               | Error e ->
                   failwith
                     (Printf.sprintf "Could not decode request: %s"
                        (Result.show_error e)))
           | None -> Elpe.Derivation.Response.make ()))
    ()
let ubuntu_package connection ~index ~name =
  let req = Elpegrpc.Elpe.UbuntuPackageRequest.make ~index ~name () in
  let open Ocaml_protoc_plugin in
  let open Elpegrpc.Elpe in
  let encode, decode = Service.make_client_functions Elpe.ubuntuPackage in
  let enc = encode req |> Writer.contents in
  Client.call ~service:"elpe.Elpe" ~rpc:"UbuntuPackage"
    ~do_request:
      (H2_lwt_unix.Client.request connection ~error_handler:(fun _ ->
           failwith "Error"))
    ~handler:
      (Client.Rpc.unary enc ~f:(fun decoder ->
           let+ decoder = decoder in
           match decoder with
           | Some decoder -> (
               Reader.create decoder |> decode |> function
               | Ok v -> v
               | Error e ->
                   failwith
                     (Printf.sprintf "Could not decode request: %s"
                        (Result.show_error e)))
           | None -> Elpe.Derivation.Response.make ()))
    ()
class virtual derivation =
  object (self)
    method virtual name : string
    method setup : string list Lwt.t = Lwt.return []
    method build : string list Lwt.t = self#setup
  end
let backend_conn = ref None
let ubuntu name =
  object
    inherit derivation
    method name = name
    method! build =
      let c =
        match !backend_conn with None -> failwith "no conn" | Some c -> c
      in
      let* index =
        Lwt_list.map_p
          (fun repository ->
            let* res =
              ubuntu_release c ~release:"noble" ~arch:Amd64 ~repository
            in
            let res, _ = Result.get_ok res in
            Lwt.return res.path)
          [ "main"; "universe" ]
      in
      let index = List.concat index in
      let* res = ubuntu_package c ~index ~name in
      let res, _ = Result.get_ok res in
      Lwt.return res.path
  end
class virtual std_derivation =
  object (self)
    inherit derivation
    method environment : (string * string) List.t Lwt.t = Lwt.return []
    method build_inputs : derivation list Lwt.t = Lwt.return []
    method! setup =
      let* bash = (ubuntu "bash-static")#build in
      let bash = List.hd bash in
      let* b = self#build_inputs in
      let* b =
        Lwt_list.map_p
          (fun d ->
            let* p = d#build in
            Lwt.return (List.map (fun p -> p ^ "/usr/bin") p))
          b
      in
      let path =
        List.fold_left
          (List.fold_left (fun acc x -> if acc == "" then x else acc ^ ":" ^ x))
          "" b
      in
      Lwt.return [ "#!" ^ bash ^ "\n" ^ "export PATH=" ^ path ^ "\n" ]
  end
let last_built_module : std_derivation option ref = ref None
let build (spec : std_derivation) = last_built_module := Some spec
let run_shell (spec : std_derivation) cmd =
  Lwt_main.run
    (let open Lwt.Syntax in
     let port = 50051 in
     let address = "127.0.0.1" in
     let* c = connection address port in
     backend_conn := Some c;
     let* b = spec#setup in
     let* bash = (ubuntu "bash-static")#build in
     let bash = List.hd bash in
     let f = Filename.temp_dir "elpe-" "" ^ "/setup" in
     Unix.mkfifo f 0o666;
     let pid =
       Unix.create_process
         (bash ^ "/usr/bin/bash-static")
         (match cmd with
         | None -> [| "bash"; "--init-file"; f; "-i" |]
         | Some cmd -> [| "bash"; "--init-file"; f; "-i"; "-c"; cmd |])
         Unix.stdin Unix.stdout Unix.stderr
     in
     let p = Unix.openfile f [ Unix.O_WRONLY ] 0o644 in
     List.fold_left
       (fun () b ->
         let _ = Unix.write_substring p b 0 (String.length b) in
         ())
       () b;
     Unix.close p;
     match Unix.waitpid [] pid with
     | _, Unix.WEXITED e -> Lwt.return e
     | _ -> failwith "Unknown")
let run_build (spec : derivation) =
  Lwt_main.run
    (let open Lwt.Syntax in
     let port = 50051 in
     let address = "127.0.0.1" in
     let* c = connection address port in
     backend_conn := Some c;
     let* b = spec#build in
     let* bash = (ubuntu "bash-static")#build in
     let bash = List.hd bash in
     let f = Filename.temp_dir "elpe-" "" ^ "/setup" in
     Unix.mkfifo f 0o666;
     let pid =
       Unix.create_process
         (bash ^ "/usr/bin/bash-static")
         [| "bash"; "--init-file"; f; "-i" |]
         Unix.stdin Unix.stdout Unix.stderr
     in
     let p = Unix.openfile f [ Unix.O_WRONLY ] 0o644 in
     List.fold_left
       (fun () b ->
         let _ = Unix.write_substring p b 0 (String.length b) in
         ())
       () b;
     Unix.close p;
     let _ =
       match Unix.waitpid [] pid with
       | _, Unix.WEXITED e -> print_endline ("ended waitpid " ^ string_of_int e)
       | _ -> print_endline "other"
     in
     Lwt.return ())

(library
 (name elpe)
 (public_name elpe)
 (modes byte)
 (libraries grpc-lwt lwt lwt.unix h2 h2-lwt-unix pbrt ocaml-protoc-plugin))
(rule
 (targets elpegrpc.ml)
 (deps
  (:proto elpegrpc.proto))
 (action
  (run
   protoc
   -I
   .
   "--ocaml_out=annot=[@@deriving show { with_path = false }]:."
   %{proto})))

(lang dune 3.17)
(name elpegrpc)
; (generate_opam_files true)
(authors "Author Name <author@example.com>")
(maintainers "Maintainer Name <maintainer@example.com>")
(license LICENSE)
(documentation https://url/to/documentation)
(package
 (name elpe-bin)
 (depends ocaml elpe lwt)
)
(package
 (name elpe)
 (depends ocaml lwt grpc-lwt h2-lwt-unix pbrt ocaml-protoc-plugin protoc)
)
; See the complete stanza docs at https://dune.readthedocs.io/en/stable/reference/dune-project/index.html

open Elpe
let usage_msg = "elpe [-verbose] [-c <command>] <file1> [<file2>]"
let verbose = ref false
let cmd = ref ""
let input_files = ref []
let anon_fun filename = input_files := filename :: !input_files
let speclist =
  [
    ("-verbose", Arg.Set verbose, "Output debug information");
    ("-c", Arg.Set_string cmd, "Run the specified command");
  ]
let compile_and_run () =
  (* Compile *)
  let args =
    Array.of_list
      ([
         "ocamlfind";
         (if Dynlink.is_native then "ocamlopt" else "ocamlc");
         "-package";
         "elpe";
         "-c";
       ]
      @ !input_files)
  in
  let pid =
    let rd, wr = Unix.pipe () in
    let pid = Unix.create_process "ocamlfind" args rd Unix.stdout Unix.stderr in
    Unix.close wr;
    pid
  in
  let _ =
    match Unix.waitpid [] pid with
    | _, Unix.WEXITED 0 -> ()
    | _, Unix.WEXITED e -> Unix._exit e
    | _ -> print_endline "other"
  in
  (* Link *)
  let obj =
    Dynlink.adapt_filename
      (Filename.remove_extension (Array.get args (Array.length args - 1))
      ^ ".cmo")
  in
  Dynlink.loadfile obj;
  match !last_built_module with
  | None -> 0
  | Some last ->
      run_shell last (if String.length !cmd == 0 then None else Some !cmd)
let () =
  Arg.parse speclist anon_fun usage_msg;
  if !input_files != [] then
    let exit = compile_and_run () in
    Unix._exit exit
  else Printf.eprintf "\n"

(executable
 (name elpe_bin)
 (public_name elpe)
 (package elpe-bin)
 (modes byte)
 (libraries elpe grpc-lwt dynlink))

version=0.27.0
profile=default

with import <nixpkgs> {};
let luau = stdenv.mkDerivation rec {
      pname = "luau";
      version = "0.621";
      src = fetchFromGitHub {
        owner = "luau-lang";
        repo = "luau";
        rev = version;
        hash = "sha256-bkuYYGYcnMwQDK81ZH+74hA4XaQfVFMWvAKpy+ODCak=";
      };
      nativeBuildInputs = [ cmake pkg-config ];
      buildInputs = lib.optionals stdenv.cc.isClang [ llvmPackages.libunwind ];
      installPhase = ''
    runHook preInstall
    install -Dm755 -t $out/bin luau
    install -Dm755 -t $out/bin luau-analyze
    install -Dm755 -t $out/bin luau-compile
    install -Dm755 -t $out/lib lib*
    runHook postInstall
  '';
  #     doCheck = true;
  #     checkPhase = ''
  #   runHook preCheck
  #   ./Luau.UnitTest
  #   ./Luau.Conformance
  #   runHook postCheck
  # '';
      # passthru.updateScript = gitUpdater { };
      meta = with lib; {
        description = "Fast, small, safe, gradually typed embeddable scripting language derived from Lua";
        homepage = "https://luau-lang.org/";
        changelog = "https://github.com/luau-lang/luau/releases/tag/${version}";
        license = licenses.mit;
        platforms = platforms.all;
        maintainers = [ ];
        mainProgram = "luau";
      };
    };
    # grpc-async = ocamlPackages.buildDunePackage rec {
    #   pname = "gprc-async";
    #   version = "0.2.0";
    #   src = builtins.fetchurl {
    #     url = "https://github.com/emilpriver/jsoo-code-mirror/archive/refs/tags/v0.0.1.tar.gz";
    #     sha256 = "sha256:0rby6kd9973icp72fj8i07awibamwsi3afy71dhrbq771dgz16cq";
    #   };
    #   propagatedBuildInputs = with pkgs; [
    #     ocamlPackages.brr
    #     ocamlPackages.js_of_ocaml
    #   ];
    # };
    gluten-async = ocamlPackages.buildDunePackage rec {
      pname = "gluten-async";
      version = "0.5.2";
      src = pkgs.fetchurl {
        url = "https://github.com/anmonteiro/gluten/releases/download/0.5.2/gluten-0.5.2.tbz";
        sha256 = "sha256:0pq1ww3p41m6dzk2cmrr7pq03kvb5hjqvk49s95vp030kygxivmi";
      };
      propagatedBuildInputs = with pkgs; [
        ocamlPackages.gluten
        ocamlPackages.faraday-async
        ocamlPackages.async
        ocamlPackages.async_ssl
        ocamlPackages.tls-async
      ];
    };
    h2-lwt = ocamlPackages.buildDunePackage rec {
      pname = "h2-lwt";
      version = "0.12.0";
      src = pkgs.fetchurl {
        url = "https://github.com/anmonteiro/ocaml-h2/releases/download/0.12.0/h2-0.12.0.tbz";
        sha256 = "sha256-NuQLET2Q6jg2GajHvZk/hmExw8XZV2GbaEnrMq+MU8Y=";
      };
      propagatedBuildInputs = with pkgs; [
        h2
        ocamlPackages.faraday-async
        ocamlPackages.gluten-lwt
        gluten-async
      ];
    };
    h2-lwt-unix = ocamlPackages.buildDunePackage rec {
      pname = "h2-lwt-unix";
      version = "0.12.0";
      src = pkgs.fetchurl {
        url = "https://github.com/anmonteiro/ocaml-h2/releases/download/0.12.0/h2-0.12.0.tbz";
        sha256 = "sha256-NuQLET2Q6jg2GajHvZk/hmExw8XZV2GbaEnrMq+MU8Y=";
      };
      propagatedBuildInputs = with pkgs; [
        h2-lwt
        ocamlPackages.faraday-lwt-unix
        ocamlPackages.gluten-lwt-unix
      ];
    };
    h2 = ocamlPackages.buildDunePackage rec {
      pname = "h2";
      version = "0.12.0";
      src = pkgs.fetchurl {
        url = "https://github.com/anmonteiro/ocaml-h2/releases/download/0.12.0/h2-0.12.0.tbz";
        sha256 = "sha256-NuQLET2Q6jg2GajHvZk/hmExw8XZV2GbaEnrMq+MU8Y=";
      };
      propagatedBuildInputs = with pkgs; [
        ocamlPackages.base64
        ocamlPackages.angstrom
        ocamlPackages.faraday
        ocamlPackages.bigstringaf
        ocamlPackages.psq
        ocamlPackages.hpack
        ocamlPackages.httpun-types
        ocamlPackages.alcotest
        ocamlPackages.yojson
        ocamlPackages.hex
      ];
    };
    grpc = ocamlPackages.buildDunePackage rec {
      pname = "grpc";
      version = "0.2.0";
      src = pkgs.fetchurl {
        url = "https://github.com/dialohq/ocaml-grpc/archive/refs/tags/0.2.0.tar.gz";
        sha256 = "sha256-5myWWT3qziJ9m84aRXodGRZ5sGlUNBcY/6nkkzJ4in4=";
      };
      propagatedBuildInputs = with pkgs; [
        ocamlPackages.uri
        h2
        ocamlPackages.ppx_deriving
        ocamlPackages.ppxlib
      ];
    };
    grpc-lwt = ocamlPackages.buildDunePackage rec {
      pname = "grpc-lwt";
      version = "0.2.0";
      src = pkgs.fetchurl {
        url = "https://github.com/dialohq/ocaml-grpc/archive/refs/tags/0.2.0.tar.gz";
        sha256 = "sha256-5myWWT3qziJ9m84aRXodGRZ5sGlUNBcY/6nkkzJ4in4=";
      };
      propagatedBuildInputs = with pkgs; [
        ocamlPackages.stringext
        ocamlPackages.lwt
        grpc
      ];
    };
    elpe = ocamlPackages.buildDunePackage rec {
      pname = "elpe";
      version = "0.1.0";
      src = ./elpe;
      propagatedBuildInputs = with pkgs; [
        ocamlPackages.ocaml-protoc
        ocamlPackages.pbrt
        ocamlPackages.findlib
        ocamlPackages.ocaml-protoc-plugin
        grpc-lwt
        h2-lwt-unix
      ];
      nativeBuildInputs = [
        protobuf
      ];
    };
in
clangStdenv.mkDerivation {
  name = "elpe";
  buildInputs = [
    openssl nettle zstd.dev sequoia-sq
    xz.dev
    pkg-config
    # luau
    ocaml
    opam
    ocamlPackages.ocaml
    ocamlPackages.dune_3
    ocamlPackages.ocaml-protoc
    ocamlPackages.pbrt
    ocamlPackages.findlib
    ocamlPackages.ocaml-protoc-plugin
    grpc-lwt
    h2-lwt-unix
    elpe
    ocamlformat
    protobuf
    checksec
    linuxPackages_latest.perf
  ];
  nativeBuildInputs = [pkg-config b3sum];
  LIBCLANG_PATH="${llvmPackages.libclang.lib}/lib";
  PROTOC="${protobuf}/bin/protoc";
}

use std::{env, path::PathBuf};
fn main() {
    let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
    tonic_build::configure()
        .file_descriptor_set_path(out_dir.join("elpe_descriptor.bin"))
        .compile_protos(&["elpe/lib/elpegrpc.proto"], &["elpe/lib"])
        .unwrap();
}

[package]
name = "elpe"
version = "0.1.0"
edition = "2024"
# [profile.release]
# debug = 1
[workspace]
members = ["elfedit"]
[dependencies]
elfedit = { path = "elfedit" }
base32 = "0.5.1"
blake3 = "1.6.1"
data-encoding = "2.8.0"
futures = "0.3.31"
lazy_static = "1.5.0"
libc = "*"
memmap = "0.7.0"
nom = "8.0.0"
regex = "1.11.1"
reqwest = { version = "0.12.12", features = [ "stream" ] }
sha2 = "0.10.8"
tar = "0.4.44"
tempfile = "3.18.0"
thiserror = "2.0.11"
tokio = { version = "1.44.0", features = [ "macros", "rt-multi-thread", "fs", "process" ] }
tracing = "0.1.41"
tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
xz2 = { version = "0.1.6", features = [ "tokio" ] }
zstd = "0.13.3"
prost = "0.13.5"
prost-types = "0.13.5"
tonic = "0.13.0"
lazy-init = "0.5.1"
lru = "0.14.0"
[build-dependencies]
tonic-build = "0.13.0"

# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 4
[[package]]
name = "addr2line"
version = "0.24.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1"
dependencies = [
 "gimli",
]
[[package]]
name = "adler2"
version = "2.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"
[[package]]
name = "aho-corasick"
version = "1.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
dependencies = [
 "memchr",
]
[[package]]
name = "allocator-api2"
version = "0.2.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
[[package]]
name = "anyhow"
version = "1.0.98"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
[[package]]
name = "arrayref"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
[[package]]
name = "arrayvec"
version = "0.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
[[package]]
name = "async-trait"
version = "0.1.88"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e539d3fca749fcee5236ab05e93a52867dd549cc157c8cb7f99595f3cedffdb5"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "atomic-waker"
version = "1.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
[[package]]
name = "autocfg"
version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
[[package]]
name = "axum"
version = "0.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "de45108900e1f9b9242f7f2e254aa3e2c029c921c258fe9e6b4217eeebd54288"
dependencies = [
 "axum-core",
 "bytes 1.10.1",
 "futures-util",
 "http",
 "http-body",
 "http-body-util",
 "itoa",
 "matchit",
 "memchr",
 "mime",
 "percent-encoding",
 "pin-project-lite",
 "rustversion",
 "serde",
 "sync_wrapper",
 "tower",
 "tower-layer",
 "tower-service",
]
[[package]]
name = "axum-core"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "68464cd0412f486726fb3373129ef5d2993f90c34bc2bc1c1e9943b2f4fc7ca6"
dependencies = [
 "bytes 1.10.1",
 "futures-core",
 "http",
 "http-body",
 "http-body-util",
 "mime",
 "pin-project-lite",
 "rustversion",
 "sync_wrapper",
 "tower-layer",
 "tower-service",
]
[[package]]
name = "backtrace"
version = "0.3.74"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8d82cb332cdfaed17ae235a638438ac4d4839913cc2af585c3c6746e8f8bee1a"
dependencies = [
 "addr2line",
 "cfg-if",
 "libc",
 "miniz_oxide",
 "object",
 "rustc-demangle",
 "windows-targets",
]
[[package]]
name = "base32"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "022dfe9eb35f19ebbcb51e0b40a5ab759f46ad60cadf7297e0bd085afb50e076"
[[package]]
name = "base64"
version = "0.22.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
[[package]]
name = "bitflags"
version = "2.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
[[package]]
name = "blake3"
version = "1.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "675f87afced0413c9bb02843499dbbd3882a237645883f71a2b59644a6d2f753"
dependencies = [
 "arrayref",
 "arrayvec",
 "cc",
 "cfg-if",
 "constant_time_eq",
]
[[package]]
name = "block-buffer"
version = "0.10.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
dependencies = [
 "generic-array",
]
[[package]]
name = "bumpalo"
version = "3.17.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1628fb46dfa0b37568d12e5edd512553eccf6a22a78e8bde00bb4aed84d5bdbf"
[[package]]
name = "byteorder"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
[[package]]
name = "bytes"
version = "0.4.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "206fdffcfa2df7cbe15601ef46c813fce0965eb3286db6b56c583b814b51c81c"
dependencies = [
 "byteorder",
 "iovec",
]
[[package]]
name = "bytes"
version = "1.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
[[package]]
name = "cc"
version = "1.2.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "be714c154be609ec7f5dad223a33bf1482fff90472de28f7362806e6d4832b8c"
dependencies = [
 "jobserver",
 "libc",
 "shlex",
]
[[package]]
name = "cfg-if"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
[[package]]
name = "constant_time_eq"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
[[package]]
name = "core-foundation"
version = "0.9.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
dependencies = [
 "core-foundation-sys",
 "libc",
]
[[package]]
name = "core-foundation-sys"
version = "0.8.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
[[package]]
name = "cpufeatures"
version = "0.2.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
dependencies = [
 "libc",
]
[[package]]
name = "crypto-common"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
dependencies = [
 "generic-array",
 "typenum",
]
[[package]]
name = "data-encoding"
version = "2.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "575f75dfd25738df5b91b8e43e14d44bda14637a58fae779fd2b064f8bf3e010"
[[package]]
name = "digest"
version = "0.10.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
dependencies = [
 "block-buffer",
 "crypto-common",
]
[[package]]
name = "displaydoc"
version = "0.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "either"
version = "1.15.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
[[package]]
name = "elfedit"
version = "0.1.0"
dependencies = [
 "memmap",
 "tempfile",
 "thiserror",
]
[[package]]
name = "elpe"
version = "0.1.0"
dependencies = [
 "base32",
 "blake3",
 "data-encoding",
 "elfedit",
 "futures 0.3.31",
 "lazy-init",
 "lazy_static",
 "libc",
 "lru",
 "memmap",
 "nom",
 "prost",
 "prost-types",
 "regex",
 "reqwest",
 "sha2",
 "tar",
 "tempfile",
 "thiserror",
 "tokio",
 "tonic",
 "tonic-build",
 "tracing",
 "tracing-subscriber",
 "xz2",
 "zstd",
]
[[package]]
name = "encoding_rs"
version = "0.8.35"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
dependencies = [
 "cfg-if",
]
[[package]]
name = "equivalent"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
[[package]]
name = "errno"
version = "0.3.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "33d852cb9b869c2a9b3df2f71a3074817f01e1844f839a144f5fcef059a4eb5d"
dependencies = [
 "libc",
 "windows-sys 0.59.0",
]
[[package]]
name = "fastrand"
version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
[[package]]
name = "filetime"
version = "0.2.25"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "35c0522e981e68cbfa8c3f978441a5f34b30b96e146b33cd3359176b50fe8586"
dependencies = [
 "cfg-if",
 "libc",
 "libredox",
 "windows-sys 0.59.0",
]
[[package]]
name = "fixedbitset"
version = "0.5.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
[[package]]
name = "fnv"
version = "1.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
[[package]]
name = "foldhash"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
[[package]]
name = "foreign-types"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
dependencies = [
 "foreign-types-shared",
]
[[package]]
name = "foreign-types-shared"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
[[package]]
name = "form_urlencoded"
version = "1.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
dependencies = [
 "percent-encoding",
]
[[package]]
name = "futures"
version = "0.1.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3a471a38ef8ed83cd6e40aa59c1ffe17db6855c18e3604d9c4ed8c08ebc28678"
[[package]]
name = "futures"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
dependencies = [
 "futures-channel",
 "futures-core",
 "futures-executor",
 "futures-io",
 "futures-sink",
 "futures-task",
 "futures-util",
]
[[package]]
name = "futures-channel"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
dependencies = [
 "futures-core",
 "futures-sink",
]
[[package]]
name = "futures-core"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
[[package]]
name = "futures-executor"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
dependencies = [
 "futures-core",
 "futures-task",
 "futures-util",
]
[[package]]
name = "futures-io"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
[[package]]
name = "futures-macro"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "futures-sink"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
[[package]]
name = "futures-task"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
[[package]]
name = "futures-util"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
dependencies = [
 "futures-channel",
 "futures-core",
 "futures-io",
 "futures-macro",
 "futures-sink",
 "futures-task",
 "memchr",
 "pin-project-lite",
 "pin-utils",
 "slab",
]
[[package]]
name = "generic-array"
version = "0.14.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
dependencies = [
 "typenum",
 "version_check",
]
[[package]]
name = "getrandom"
version = "0.2.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
dependencies = [
 "cfg-if",
 "libc",
 "wasi 0.11.0+wasi-snapshot-preview1",
]
[[package]]
name = "getrandom"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "43a49c392881ce6d5c3b8cb70f98717b7c07aabbdff06687b9030dbfbe2725f8"
dependencies = [
 "cfg-if",
 "libc",
 "wasi 0.13.3+wasi-0.2.2",
 "windows-targets",
]
[[package]]
name = "gimli"
version = "0.31.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
[[package]]
name = "h2"
version = "0.4.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5017294ff4bb30944501348f6f8e42e6ad28f42c8bbef7a74029aff064a4e3c2"
dependencies = [
 "atomic-waker",
 "bytes 1.10.1",
 "fnv",
 "futures-core",
 "futures-sink",
 "http",
 "indexmap",
 "slab",
 "tokio",
 "tokio-util",
 "tracing",
]
[[package]]
name = "hashbrown"
version = "0.15.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289"
dependencies = [
 "allocator-api2",
 "equivalent",
 "foldhash",
]
[[package]]
name = "heck"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
[[package]]
name = "http"
version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f16ca2af56261c99fba8bac40a10251ce8188205a4c448fbb745a2e4daa76fea"
dependencies = [
 "bytes 1.10.1",
 "fnv",
 "itoa",
]
[[package]]
name = "http-body"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
dependencies = [
 "bytes 1.10.1",
 "http",
]
[[package]]
name = "http-body-util"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "793429d76616a256bcb62c2a2ec2bed781c8307e797e2598c50010f2bee2544f"
dependencies = [
 "bytes 1.10.1",
 "futures-util",
 "http",
 "http-body",
 "pin-project-lite",
]
[[package]]
name = "httparse"
version = "1.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
[[package]]
name = "httpdate"
version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
[[package]]
name = "hyper"
version = "1.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cc2b571658e38e0c01b1fdca3bbbe93c00d3d71693ff2770043f8c29bc7d6f80"
dependencies = [
 "bytes 1.10.1",
 "futures-channel",
 "futures-util",
 "h2",
 "http",
 "http-body",
 "httparse",
 "httpdate",
 "itoa",
 "pin-project-lite",
 "smallvec",
 "tokio",
 "want",
]
[[package]]
name = "hyper-rustls"
version = "0.27.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2d191583f3da1305256f22463b9bb0471acad48a4e534a5218b9963e9c1f59b2"
dependencies = [
 "futures-util",
 "http",
 "hyper",
 "hyper-util",
 "rustls",
 "rustls-pki-types",
 "tokio",
 "tokio-rustls",
 "tower-service",
]
[[package]]
name = "hyper-timeout"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b90d566bffbce6a75bd8b09a05aa8c2cb1fabb6cb348f8840c9e4c90a0d83b0"
dependencies = [
 "hyper",
 "hyper-util",
 "pin-project-lite",
 "tokio",
 "tower-service",
]
[[package]]
name = "hyper-tls"
version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
dependencies = [
 "bytes 1.10.1",
 "http-body-util",
 "hyper",
 "hyper-util",
 "native-tls",
 "tokio",
 "tokio-native-tls",
 "tower-service",
]
[[package]]
name = "hyper-util"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "df2dcfbe0677734ab2f3ffa7fa7bfd4706bfdc1ef393f2ee30184aed67e631b4"
dependencies = [
 "bytes 1.10.1",
 "futures-channel",
 "futures-util",
 "http",
 "http-body",
 "hyper",
 "pin-project-lite",
 "socket2",
 "tokio",
 "tower-service",
 "tracing",
]
[[package]]
name = "icu_collections"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "db2fa452206ebee18c4b5c2274dbf1de17008e874b4dc4f0aea9d01ca79e4526"
dependencies = [
 "displaydoc",
 "yoke",
 "zerofrom",
 "zerovec",
]
[[package]]
name = "icu_locid"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "13acbb8371917fc971be86fc8057c41a64b521c184808a698c02acc242dbf637"
dependencies = [
 "displaydoc",
 "litemap",
 "tinystr",
 "writeable",
 "zerovec",
]
[[package]]
name = "icu_locid_transform"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "01d11ac35de8e40fdeda00d9e1e9d92525f3f9d887cdd7aa81d727596788b54e"
dependencies = [
 "displaydoc",
 "icu_locid",
 "icu_locid_transform_data",
 "icu_provider",
 "tinystr",
 "zerovec",
]
[[package]]
name = "icu_locid_transform_data"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fdc8ff3388f852bede6b579ad4e978ab004f139284d7b28715f773507b946f6e"
[[package]]
name = "icu_normalizer"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "19ce3e0da2ec68599d193c93d088142efd7f9c5d6fc9b803774855747dc6a84f"
dependencies = [
 "displaydoc",
 "icu_collections",
 "icu_normalizer_data",
 "icu_properties",
 "icu_provider",
 "smallvec",
 "utf16_iter",
 "utf8_iter",
 "write16",
 "zerovec",
]
[[package]]
name = "icu_normalizer_data"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f8cafbf7aa791e9b22bec55a167906f9e1215fd475cd22adfcf660e03e989516"
[[package]]
name = "icu_properties"
version = "1.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "93d6020766cfc6302c15dbbc9c8778c37e62c14427cb7f6e601d849e092aeef5"
dependencies = [
 "displaydoc",
 "icu_collections",
 "icu_locid_transform",
 "icu_properties_data",
 "icu_provider",
 "tinystr",
 "zerovec",
]
[[package]]
name = "icu_properties_data"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "67a8effbc3dd3e4ba1afa8ad918d5684b8868b3b26500753effea8d2eed19569"
[[package]]
name = "icu_provider"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6ed421c8a8ef78d3e2dbc98a973be2f3770cb42b606e3ab18d6237c4dfde68d9"
dependencies = [
 "displaydoc",
 "icu_locid",
 "icu_provider_macros",
 "stable_deref_trait",
 "tinystr",
 "writeable",
 "yoke",
 "zerofrom",
 "zerovec",
]
[[package]]
name = "icu_provider_macros"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "idna"
version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e"
dependencies = [
 "idna_adapter",
 "smallvec",
 "utf8_iter",
]
[[package]]
name = "idna_adapter"
version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "daca1df1c957320b2cf139ac61e7bd64fed304c5040df000a745aa1de3b4ef71"
dependencies = [
 "icu_normalizer",
 "icu_properties",
]
[[package]]
name = "indexmap"
version = "2.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8c9c992b02b5b4c94ea26e32fe5bccb7aa7d9f390ab5c1221ff895bc7ea8b652"
dependencies = [
 "equivalent",
 "hashbrown",
]
[[package]]
name = "iovec"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e"
dependencies = [
 "libc",
]
[[package]]
name = "ipnet"
version = "2.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
[[package]]
name = "itertools"
version = "0.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
dependencies = [
 "either",
]
[[package]]
name = "itoa"
version = "1.0.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
[[package]]
name = "jobserver"
version = "0.1.32"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0"
dependencies = [
 "libc",
]
[[package]]
name = "js-sys"
version = "0.3.77"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
dependencies = [
 "once_cell",
 "wasm-bindgen",
]
[[package]]
name = "lazy-init"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9f40963626ac12dcaf92afc15e4c3db624858c92fd9f8ba2125eaada3ac2706f"
[[package]]
name = "lazy_static"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
[[package]]
name = "libc"
version = "0.2.171"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"
[[package]]
name = "libredox"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
dependencies = [
 "bitflags",
 "libc",
 "redox_syscall",
]
[[package]]
name = "linux-raw-sys"
version = "0.4.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
[[package]]
name = "linux-raw-sys"
version = "0.9.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6db9c683daf087dc577b7506e9695b3d556a9f3849903fa28186283afd6809e9"
[[package]]
name = "litemap"
version = "0.7.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "23fb14cb19457329c82206317a5663005a4d404783dc74f4252769b0d5f42856"
[[package]]
name = "log"
version = "0.4.26"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "30bde2b3dc3671ae49d8e2e9f044c7c005836e7a023ee57cffa25ab82764bb9e"
[[package]]
name = "lru"
version = "0.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9f8cc7106155f10bdf99a6f379688f543ad6596a415375b36a59a054ceda1198"
dependencies = [
 "hashbrown",
]
[[package]]
name = "lzma-sys"
version = "0.1.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5fda04ab3764e6cde78b9974eec4f779acaba7c4e84b36eca3cf77c581b85d27"
dependencies = [
 "cc",
 "libc",
 "pkg-config",
]
[[package]]
name = "matchers"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
dependencies = [
 "regex-automata 0.1.10",
]
[[package]]
name = "matchit"
version = "0.8.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"
[[package]]
name = "memchr"
version = "2.7.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
[[package]]
name = "memmap"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6585fd95e7bb50d6cc31e20d4cf9afb4e2ba16c5846fc76793f11218da9c475b"
dependencies = [
 "libc",
 "winapi",
]
[[package]]
name = "mime"
version = "0.3.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
[[package]]
name = "miniz_oxide"
version = "0.8.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8e3e04debbb59698c15bacbb6d93584a8c0ca9cc3213cb423d31f760d8843ce5"
dependencies = [
 "adler2",
]
[[package]]
name = "mio"
version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd"
dependencies = [
 "libc",
 "wasi 0.11.0+wasi-snapshot-preview1",
 "windows-sys 0.52.0",
]
[[package]]
name = "multimap"
version = "0.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "defc4c55412d89136f966bbb339008b474350e5e6e78d2714439c386b3137a03"
[[package]]
name = "native-tls"
version = "0.2.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "87de3442987e9dbec73158d5c715e7ad9072fda936bb03d19d7fa10e00520f0e"
dependencies = [
 "libc",
 "log",
 "openssl",
 "openssl-probe",
 "openssl-sys",
 "schannel",
 "security-framework",
 "security-framework-sys",
 "tempfile",
]
[[package]]
name = "nom"
version = "8.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405"
dependencies = [
 "memchr",
]
[[package]]
name = "nu-ansi-term"
version = "0.46.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
dependencies = [
 "overload",
 "winapi",
]
[[package]]
name = "object"
version = "0.36.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87"
dependencies = [
 "memchr",
]
[[package]]
name = "once_cell"
version = "1.21.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cde51589ab56b20a6f686b2c68f7a0bd6add753d697abf720d63f8db3ab7b1ad"
[[package]]
name = "openssl"
version = "0.10.71"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5e14130c6a98cd258fdcb0fb6d744152343ff729cbfcb28c656a9d12b999fbcd"
dependencies = [
 "bitflags",
 "cfg-if",
 "foreign-types",
 "libc",
 "once_cell",
 "openssl-macros",
 "openssl-sys",
]
[[package]]
name = "openssl-macros"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "openssl-probe"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
[[package]]
name = "openssl-sys"
version = "0.9.106"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8bb61ea9811cc39e3c2069f40b8b8e2e70d8569b361f879786cc7ed48b777cdd"
dependencies = [
 "cc",
 "libc",
 "pkg-config",
 "vcpkg",
]
[[package]]
name = "overload"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
[[package]]
name = "percent-encoding"
version = "2.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
[[package]]
name = "petgraph"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3672b37090dbd86368a4145bc067582552b29c27377cad4e0a306c97f9bd7772"
dependencies = [
 "fixedbitset",
 "indexmap",
]
[[package]]
name = "pin-project"
version = "1.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "677f1add503faace112b9f1373e43e9e054bfdd22ff1a63c1bc485eaec6a6a8a"
dependencies = [
 "pin-project-internal",
]
[[package]]
name = "pin-project-internal"
version = "1.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "pin-project-lite"
version = "0.2.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
[[package]]
name = "pin-utils"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
[[package]]
name = "pkg-config"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2"
[[package]]
name = "prettyplease"
version = "0.2.32"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "664ec5419c51e34154eec046ebcba56312d5a2fc3b09a06da188e1ad21afadf6"
dependencies = [
 "proc-macro2",
 "syn",
]
[[package]]
name = "proc-macro2"
version = "1.0.93"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "60946a68e5f9d28b0dc1c21bb8a97ee7d018a8b322fa57838ba31cc878e22d99"
dependencies = [
 "unicode-ident",
]
[[package]]
name = "prost"
version = "0.13.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5"
dependencies = [
 "bytes 1.10.1",
 "prost-derive",
]
[[package]]
name = "prost-build"
version = "0.13.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "be769465445e8c1474e9c5dac2018218498557af32d9ed057325ec9a41ae81bf"
dependencies = [
 "heck",
 "itertools",
 "log",
 "multimap",
 "once_cell",
 "petgraph",
 "prettyplease",
 "prost",
 "prost-types",
 "regex",
 "syn",
 "tempfile",
]
[[package]]
name = "prost-derive"
version = "0.13.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d"
dependencies = [
 "anyhow",
 "itertools",
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "prost-types"
version = "0.13.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "52c2c1bf36ddb1a1c396b3601a3cec27c2462e45f07c386894ec3ccf5332bd16"
dependencies = [
 "prost",
]
[[package]]
name = "quote"
version = "1.0.38"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc"
dependencies = [
 "proc-macro2",
]
[[package]]
name = "redox_syscall"
version = "0.5.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "82b568323e98e49e2a0899dcee453dd679fae22d69adf9b11dd508d1549b7e2f"
dependencies = [
 "bitflags",
]
[[package]]
name = "regex"
version = "1.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
dependencies = [
 "aho-corasick",
 "memchr",
 "regex-automata 0.4.9",
 "regex-syntax 0.8.5",
]
[[package]]
name = "regex-automata"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
dependencies = [
 "regex-syntax 0.6.29",
]
[[package]]
name = "regex-automata"
version = "0.4.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
dependencies = [
 "aho-corasick",
 "memchr",
 "regex-syntax 0.8.5",
]
[[package]]
name = "regex-syntax"
version = "0.6.29"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
[[package]]
name = "regex-syntax"
version = "0.8.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
[[package]]
name = "reqwest"
version = "0.12.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "43e734407157c3c2034e0258f5e4473ddb361b1e85f95a66690d67264d7cd1da"
dependencies = [
 "base64",
 "bytes 1.10.1",
 "encoding_rs",
 "futures-core",
 "futures-util",
 "h2",
 "http",
 "http-body",
 "http-body-util",
 "hyper",
 "hyper-rustls",
 "hyper-tls",
 "hyper-util",
 "ipnet",
 "js-sys",
 "log",
 "mime",
 "native-tls",
 "once_cell",
 "percent-encoding",
 "pin-project-lite",
 "rustls-pemfile",
 "serde",
 "serde_json",
 "serde_urlencoded",
 "sync_wrapper",
 "system-configuration",
 "tokio",
 "tokio-native-tls",
 "tokio-util",
 "tower",
 "tower-service",
 "url",
 "wasm-bindgen",
 "wasm-bindgen-futures",
 "wasm-streams",
 "web-sys",
 "windows-registry",
]
[[package]]
name = "ring"
version = "0.17.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "70ac5d832aa16abd7d1def883a8545280c20a60f523a370aa3a9617c2b8550ee"
dependencies = [
 "cc",
 "cfg-if",
 "getrandom 0.2.15",
 "libc",
 "untrusted",
 "windows-sys 0.52.0",
]
[[package]]
name = "rustc-demangle"
version = "0.1.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
[[package]]
name = "rustix"
version = "0.38.44"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
dependencies = [
 "bitflags",
 "errno",
 "libc",
 "linux-raw-sys 0.4.15",
 "windows-sys 0.59.0",
]
[[package]]
name = "rustix"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f7178faa4b75a30e269c71e61c353ce2748cf3d76f0c44c393f4e60abf49b825"
dependencies = [
 "bitflags",
 "errno",
 "libc",
 "linux-raw-sys 0.9.2",
 "windows-sys 0.59.0",
]
[[package]]
name = "rustls"
version = "0.23.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "47796c98c480fce5406ef69d1c76378375492c3b0a0de587be0c1d9feb12f395"
dependencies = [
 "once_cell",
 "rustls-pki-types",
 "rustls-webpki",
 "subtle",
 "zeroize",
]
[[package]]
name = "rustls-pemfile"
version = "2.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dce314e5fee3f39953d46bb63bb8a46d40c2f8fb7cc5a3b6cab2bde9721d6e50"
dependencies = [
 "rustls-pki-types",
]
[[package]]
name = "rustls-pki-types"
version = "1.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "917ce264624a4b4db1c364dcc35bfca9ded014d0a958cd47ad3e960e988ea51c"
[[package]]
name = "rustls-webpki"
version = "0.102.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "64ca1bc8749bd4cf37b5ce386cc146580777b4e8572c7b97baf22c83f444bee9"
dependencies = [
 "ring",
 "rustls-pki-types",
 "untrusted",
]
[[package]]
name = "rustversion"
version = "1.0.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "eded382c5f5f786b989652c49544c4877d9f015cc22e145a5ea8ea66c2921cd2"
[[package]]
name = "ryu"
version = "1.0.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
[[package]]
name = "schannel"
version = "0.1.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1f29ebaa345f945cec9fbbc532eb307f0fdad8161f281b6369539c8d84876b3d"
dependencies = [
 "windows-sys 0.59.0",
]
[[package]]
name = "security-framework"
version = "2.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
dependencies = [
 "bitflags",
 "core-foundation",
 "core-foundation-sys",
 "libc",
 "security-framework-sys",
]
[[package]]
name = "security-framework-sys"
version = "2.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "49db231d56a190491cb4aeda9527f1ad45345af50b0851622a7adb8c03b01c32"
dependencies = [
 "core-foundation-sys",
 "libc",
]
[[package]]
name = "serde"
version = "1.0.219"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
dependencies = [
 "serde_derive",
]
[[package]]
name = "serde_derive"
version = "1.0.219"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "serde_json"
version = "1.0.140"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
dependencies = [
 "itoa",
 "memchr",
 "ryu",
 "serde",
]
[[package]]
name = "serde_urlencoded"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
dependencies = [
 "form_urlencoded",
 "itoa",
 "ryu",
 "serde",
]
[[package]]
name = "sha2"
version = "0.10.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
dependencies = [
 "cfg-if",
 "cpufeatures",
 "digest",
]
[[package]]
name = "sharded-slab"
version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
dependencies = [
 "lazy_static",
]
[[package]]
name = "shlex"
version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
[[package]]
name = "signal-hook-registry"
version = "1.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1"
dependencies = [
 "libc",
]
[[package]]
name = "slab"
version = "0.4.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
dependencies = [
 "autocfg",
]
[[package]]
name = "smallvec"
version = "1.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7fcf8323ef1faaee30a44a340193b1ac6814fd9b7b4e88e9d4519a3e4abe1cfd"
[[package]]
name = "socket2"
version = "0.5.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c970269d99b64e60ec3bd6ad27270092a5394c4e309314b18ae3fe575695fbe8"
dependencies = [
 "libc",
 "windows-sys 0.52.0",
]
[[package]]
name = "stable_deref_trait"
version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
[[package]]
name = "subtle"
version = "2.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
[[package]]
name = "syn"
version = "2.0.98"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "36147f1a48ae0ec2b5b3bc5b537d267457555a10dc06f3dbc8cb11ba3006d3b1"
dependencies = [
 "proc-macro2",
 "quote",
 "unicode-ident",
]
[[package]]
name = "sync_wrapper"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
dependencies = [
 "futures-core",
]
[[package]]
name = "synstructure"
version = "0.13.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "system-configuration"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
dependencies = [
 "bitflags",
 "core-foundation",
 "system-configuration-sys",
]
[[package]]
name = "system-configuration-sys"
version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"
dependencies = [
 "core-foundation-sys",
 "libc",
]
[[package]]
name = "tar"
version = "0.4.44"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1d863878d212c87a19c1a610eb53bb01fe12951c0501cf5a0d65f724914a667a"
dependencies = [
 "filetime",
 "libc",
 "xattr",
]
[[package]]
name = "tempfile"
version = "3.19.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7437ac7763b9b123ccf33c338a5cc1bac6f69b45a136c19bdd8a65e3916435bf"
dependencies = [
 "fastrand",
 "getrandom 0.3.1",
 "once_cell",
 "rustix 1.0.2",
 "windows-sys 0.59.0",
]
[[package]]
name = "thiserror"
version = "2.0.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
dependencies = [
 "thiserror-impl",
]
[[package]]
name = "thiserror-impl"
version = "2.0.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "thread_local"
version = "1.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
dependencies = [
 "cfg-if",
 "once_cell",
]
[[package]]
name = "tinystr"
version = "0.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9117f5d4db391c1cf6927e7bea3db74b9a1c1add8f7eda9ffd5364f40f57b82f"
dependencies = [
 "displaydoc",
 "zerovec",
]
[[package]]
name = "tokio"
version = "1.44.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9975ea0f48b5aa3972bf2d888c238182458437cc2a19374b81b25cdf1023fb3a"
dependencies = [
 "backtrace",
 "bytes 1.10.1",
 "libc",
 "mio",
 "pin-project-lite",
 "signal-hook-registry",
 "socket2",
 "tokio-macros",
 "windows-sys 0.52.0",
]
[[package]]
name = "tokio-io"
version = "0.1.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "57fc868aae093479e3131e3d165c93b1c7474109d13c90ec0dda2a1bbfff0674"
dependencies = [
 "bytes 0.4.12",
 "futures 0.1.31",
 "log",
]
[[package]]
name = "tokio-macros"
version = "2.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "tokio-native-tls"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
dependencies = [
 "native-tls",
 "tokio",
]
[[package]]
name = "tokio-rustls"
version = "0.26.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8e727b36a1a0e8b74c376ac2211e40c2c8af09fb4013c60d910495810f008e9b"
dependencies = [
 "rustls",
 "tokio",
]
[[package]]
name = "tokio-stream"
version = "0.1.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "eca58d7bba4a75707817a2c44174253f9236b2d5fbd055602e9d5c07c139a047"
dependencies = [
 "futures-core",
 "pin-project-lite",
 "tokio",
]
[[package]]
name = "tokio-util"
version = "0.7.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d7fcaa8d55a2bdd6b83ace262b016eca0d79ee02818c5c1bcdf0305114081078"
dependencies = [
 "bytes 1.10.1",
 "futures-core",
 "futures-sink",
 "pin-project-lite",
 "tokio",
]
[[package]]
name = "tonic"
version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "85839f0b32fd242bb3209262371d07feda6d780d16ee9d2bc88581b89da1549b"
dependencies = [
 "async-trait",
 "axum",
 "base64",
 "bytes 1.10.1",
 "h2",
 "http",
 "http-body",
 "http-body-util",
 "hyper",
 "hyper-timeout",
 "hyper-util",
 "percent-encoding",
 "pin-project",
 "prost",
 "socket2",
 "tokio",
 "tokio-stream",
 "tower",
 "tower-layer",
 "tower-service",
 "tracing",
]
[[package]]
name = "tonic-build"
version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d85f0383fadd15609306383a90e85eaed44169f931a5d2be1b42c76ceff1825e"
dependencies = [
 "prettyplease",
 "proc-macro2",
 "prost-build",
 "prost-types",
 "quote",
 "syn",
]
[[package]]
name = "tower"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9"
dependencies = [
 "futures-core",
 "futures-util",
 "indexmap",
 "pin-project-lite",
 "slab",
 "sync_wrapper",
 "tokio",
 "tokio-util",
 "tower-layer",
 "tower-service",
 "tracing",
]
[[package]]
name = "tower-layer"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
[[package]]
name = "tower-service"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
[[package]]
name = "tracing"
version = "0.1.41"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
dependencies = [
 "pin-project-lite",
 "tracing-attributes",
 "tracing-core",
]
[[package]]
name = "tracing-attributes"
version = "0.1.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "395ae124c09f9e6918a2310af6038fba074bcf474ac352496d5910dd59a2226d"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "tracing-core"
version = "0.1.33"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c"
dependencies = [
 "once_cell",
 "valuable",
]
[[package]]
name = "tracing-log"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
dependencies = [
 "log",
 "once_cell",
 "tracing-core",
]
[[package]]
name = "tracing-subscriber"
version = "0.3.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e8189decb5ac0fa7bc8b96b7cb9b2701d60d48805aca84a238004d665fcc4008"
dependencies = [
 "matchers",
 "nu-ansi-term",
 "once_cell",
 "regex",
 "sharded-slab",
 "smallvec",
 "thread_local",
 "tracing",
 "tracing-core",
 "tracing-log",
]
[[package]]
name = "try-lock"
version = "0.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
[[package]]
name = "typenum"
version = "1.18.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1dccffe3ce07af9386bfd29e80c0ab1a8205a2fc34e4bcd40364df902cfa8f3f"
[[package]]
name = "unicode-ident"
version = "1.0.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00e2473a93778eb0bad35909dff6a10d28e63f792f16ed15e404fca9d5eeedbe"
[[package]]
name = "untrusted"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
[[package]]
name = "url"
version = "2.5.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60"
dependencies = [
 "form_urlencoded",
 "idna",
 "percent-encoding",
]
[[package]]
name = "utf16_iter"
version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246"
[[package]]
name = "utf8_iter"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
[[package]]
name = "valuable"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
[[package]]
name = "vcpkg"
version = "0.2.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
[[package]]
name = "version_check"
version = "0.9.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
[[package]]
name = "want"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
dependencies = [
 "try-lock",
]
[[package]]
name = "wasi"
version = "0.11.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
[[package]]
name = "wasi"
version = "0.13.3+wasi-0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "26816d2e1a4a36a2940b96c5296ce403917633dff8f3440e9b236ed6f6bacad2"
dependencies = [
 "wit-bindgen-rt",
]
[[package]]
name = "wasm-bindgen"
version = "0.2.100"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
dependencies = [
 "cfg-if",
 "once_cell",
 "rustversion",
 "wasm-bindgen-macro",
]
[[package]]
name = "wasm-bindgen-backend"
version = "0.2.100"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
dependencies = [
 "bumpalo",
 "log",
 "proc-macro2",
 "quote",
 "syn",
 "wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-futures"
version = "0.4.50"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "555d470ec0bc3bb57890405e5d4322cc9ea83cebb085523ced7be4144dac1e61"
dependencies = [
 "cfg-if",
 "js-sys",
 "once_cell",
 "wasm-bindgen",
 "web-sys",
]
[[package]]
name = "wasm-bindgen-macro"
version = "0.2.100"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
dependencies = [
 "quote",
 "wasm-bindgen-macro-support",
]
[[package]]
name = "wasm-bindgen-macro-support"
version = "0.2.100"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 "wasm-bindgen-backend",
 "wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-shared"
version = "0.2.100"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
dependencies = [
 "unicode-ident",
]
[[package]]
name = "wasm-streams"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65"
dependencies = [
 "futures-util",
 "js-sys",
 "wasm-bindgen",
 "wasm-bindgen-futures",
 "web-sys",
]
[[package]]
name = "web-sys"
version = "0.3.77"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "33b6dd2ef9186f1f2072e409e99cd22a975331a6b3591b12c764e0e55c60d5d2"
dependencies = [
 "js-sys",
 "wasm-bindgen",
]
[[package]]
name = "winapi"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
dependencies = [
 "winapi-i686-pc-windows-gnu",
 "winapi-x86_64-pc-windows-gnu",
]
[[package]]
name = "winapi-i686-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
[[package]]
name = "winapi-x86_64-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
[[package]]
name = "windows-registry"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e400001bb720a623c1c69032f8e3e4cf09984deec740f007dd2b03ec864804b0"
dependencies = [
 "windows-result",
 "windows-strings",
 "windows-targets",
]
[[package]]
name = "windows-result"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e"
dependencies = [
 "windows-targets",
]
[[package]]
name = "windows-strings"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10"
dependencies = [
 "windows-result",
 "windows-targets",
]
[[package]]
name = "windows-sys"
version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
dependencies = [
 "windows-targets",
]
[[package]]
name = "windows-sys"
version = "0.59.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
dependencies = [
 "windows-targets",
]
[[package]]
name = "windows-targets"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
dependencies = [
 "windows_aarch64_gnullvm",
 "windows_aarch64_msvc",
 "windows_i686_gnu",
 "windows_i686_gnullvm",
 "windows_i686_msvc",
 "windows_x86_64_gnu",
 "windows_x86_64_gnullvm",
 "windows_x86_64_msvc",
]
[[package]]
name = "windows_aarch64_gnullvm"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
[[package]]
name = "windows_aarch64_msvc"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
[[package]]
name = "windows_i686_gnu"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
[[package]]
name = "windows_i686_gnullvm"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
[[package]]
name = "windows_i686_msvc"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
[[package]]
name = "windows_x86_64_gnu"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
[[package]]
name = "windows_x86_64_gnullvm"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
[[package]]
name = "windows_x86_64_msvc"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
[[package]]
name = "wit-bindgen-rt"
version = "0.33.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3268f3d866458b787f390cf61f4bbb563b922d091359f9608842999eaee3943c"
dependencies = [
 "bitflags",
]
[[package]]
name = "write16"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936"
[[package]]
name = "writeable"
version = "0.5.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51"
[[package]]
name = "xattr"
version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e105d177a3871454f754b33bb0ee637ecaaac997446375fd3e5d43a2ed00c909"
dependencies = [
 "libc",
 "linux-raw-sys 0.4.15",
 "rustix 0.38.44",
]
[[package]]
name = "xz2"
version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "388c44dc09d76f1536602ead6d325eb532f5c122f17782bd57fb47baeeb767e2"
dependencies = [
 "futures 0.1.31",
 "lzma-sys",
 "tokio-io",
]
[[package]]
name = "yoke"
version = "0.7.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "120e6aef9aa629e3d4f52dc8cc43a015c7724194c97dfaf45180d2daf2b77f40"
dependencies = [
 "serde",
 "stable_deref_trait",
 "yoke-derive",
 "zerofrom",
]
[[package]]
name = "yoke-derive"
version = "0.7.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 "synstructure",
]
[[package]]
name = "zerofrom"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
dependencies = [
 "zerofrom-derive",
]
[[package]]
name = "zerofrom-derive"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 "synstructure",
]
[[package]]
name = "zeroize"
version = "1.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
[[package]]
name = "zerovec"
version = "0.10.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aa2b893d79df23bfb12d5461018d408ea19dfafe76c2c7ef6d4eba614f8ff079"
dependencies = [
 "yoke",
 "zerofrom",
 "zerovec-derive",
]
[[package]]
name = "zerovec-derive"
version = "0.10.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "zstd"
version = "0.13.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
dependencies = [
 "zstd-safe",
]
[[package]]
name = "zstd-safe"
version = "7.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f3051792fbdc2e1e143244dc28c60f73d8470e93f3f9cbd0ead44da5ed802722"
dependencies = [
 "zstd-sys",
]
[[package]]
name = "zstd-sys"
version = "2.0.14+zstd.1.5.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8fb060d4926e4ac3a3ad15d864e99ceb5f343c6b34f5bd6d81ae6ed417311be5"
dependencies = [
 "cc",
 "pkg-config",
]