tetov/pijul-srv-lite - Change YTGUFVB4EIG5W6OMOMJELNFC2NM5GLIM5BPD6FXI3GDSXM6LIZPAC

refactor/fixes: server.rs and router.rs added to better test server, PristineReader based on libpijul

Created by tetov on April 21, 2026

YTGUFVB4EIG5W6OMOMJELNFC2NM5GLIM5BPD6FXI3GDSXM6LIZPAC

Dependencies

In channels

main

Change contents

Replacement in tests/support/test_server.rs at line 1 [5.54483]

B:BD[5.54483] → [5.54484:54527]

use std::process::{Child, Command, Stdio};

[5.54483]

[5.54527]

use std::net::{SocketAddr, TcpListener, TcpStream};
use std::process::Command;
use std::thread;
use std::time::{Duration, Instant};
use pijul_srv_lite::server::{ServerConfig, resolve_repo_path, serve};

Replacement in tests/support/test_server.rs at line 8 [5.54483]
B:BD[5.54528] → [5.54528:54559]
```
use anyhow::{Context, Result};
```
[5.54528]
[5.54559]
```
use anyhow::{Context, Result, bail};
```
Deletion in tests/support/test_server.rs at line 13 [5.54483]
B:BD[5.54618] → [5.54618:54638]
```
    process: Child,
```
Insertion in tests/support/test_server.rs at line 17 [5.54483]
[5.54680]
[5.54680]
```
const BIND_ADDR: &str = "127.0.0.1";
```

Replacement in tests/support/test_server.rs at line 21 [5.54483]

B:BD[5.54752] → [5.54752:54893]

        let port = std::env::var("PIJUL_SRV_PORT")
            .ok()
            .and_then(|p| p.parse().ok())
            .unwrap_or(8080);

[5.54752]

[5.54893]

        let repo_path = resolve_repo_path(repo.repo_root().to_path_buf())?;

Replacement in tests/support/test_server.rs at line 23 [5.54483]

B:BD[5.54894] → [5.54894:54947]

        let server_bin = env!("CARGO_BIN_EXE_main");

[5.54894]

[5.54947]

        // Binds to port 0, which asks OS for port
        let listener =
            TcpListener::bind("127.0.0.1:0").context("failed to bind ephemeral test listener")?;

Replacement in tests/support/test_server.rs at line 27 [5.54483]

B:BD[5.54948] → [5.54948:55261]

        let mut cmd = Command::new(server_bin);
        cmd.current_dir(repo.repo_root())
            .env("PIJUL_SRV_PORT", port.to_string())
            .env("PIJUL_SRV_REPO_DIR", repo.repo_root())
            .env("RUST_BACKTRACE", "1")
            .stdout(Stdio::piped())
            .stderr(Stdio::piped());

[5.54948]

[5.55261]

        let port = listener
            .local_addr()
            .context("failed to read ephemeral listener address")?
            .port();

Replacement in tests/support/test_server.rs at line 32 [5.54483]

B:BD[5.55262] → [5.55262:55296]

        repo.apply_env(&mut cmd);

[5.55262]

[5.55296]

        thread::spawn(move || {
            if let Err(err) = serve(listener, ServerConfig { repo_path }) {
                eprintln!("Server exited with error: {err:#}");
            }
        });

Replacement in tests/support/test_server.rs at line 38 [5.54483]

B:BD[5.55297] → [5.55297:55367]

        let process = cmd.spawn().context("failed to start server")?;

[5.55297]

[5.55367]

        wait_until_ready(port).context("server did not become ready")?;

Replacement in tests/support/test_server.rs at line 40 [5.54483]

B:BD[5.55368] → [5.55368:55461]

        Ok(Self {
            process,
            port,
            _repo: repo,
        })

[5.55368]

[5.55461]

        Ok(Self { port, _repo: repo })

Replacement in tests/support/test_server.rs at line 44 [5.54483]

B:BD[5.55507] → [5.55507:55557]

        format!("http://127.0.0.1:{}", self.port)

[5.55507]

[5.55557]

        format!("http://{BIND_ADDR}:{}", self.port)
    }
    pub fn repo_root(&self) -> &std::path::Path {
        self._repo.repo_root()
    }
    pub fn apply_repo_env(&self, cmd: &mut Command) {
        self._repo.apply_env(cmd);

Replacement in tests/support/test_server.rs at line 56 [5.54483]

B:BD[5.55566] → [5.55566:55692]

impl Drop for TestServer {
    fn drop(&mut self) {
        let _ = self.process.kill();
        let _ = self.process.wait();

[5.55566]

[5.55692]

fn wait_until_ready(port: u16) -> Result<()> {
    let addr: SocketAddr = ([127, 0, 0, 1], port).into();
    let deadline = Instant::now() + Duration::from_secs(5);
    loop {
        if TcpStream::connect_timeout(&addr, Duration::from_millis(50)).is_ok() {
            return Ok(());
        }
        if Instant::now() >= deadline {
            bail!("timed out waiting for server to listen on {addr}",);
        }
        std::thread::sleep(Duration::from_millis(20));

Insertion in tests/support/repo_fixture.rs at line 5 [5.55741]
[5.55819]
[5.55819]
```
use libpijul::MutTxnT;
```
Deletion in tests/support/repo_fixture.rs at line 44 [5.55741]
B:BD[5.56980] → [5.56980:57050]
```
    pub fn path(&self) -> &Path {
        self.temp_dir.path()
    }
```

Replacement in tests/support/repo_fixture.rs at line 114 [5.55741]

B:BD[5.59466] → [5.59466:59541]

        Repository::init(Some(self.repo_root().to_path_buf()), None, None)

[5.59466]

[5.59541]

        let repo = Repository::init(Some(self.repo_root().to_path_buf()), None, None)

Insertion in tests/support/repo_fixture.rs at line 117 [5.55741]

[5.59600]

        // `pijul init` creates a `main` channel. The lightweight `pijul_repository`
        // initializer doesn't guarantee that, so ensure one exists for protocol tests.
        let mut txn = repo
            .pristine
            .mut_txn_begin()
            .context("failed to open pristine mut txn")?;
        txn.open_or_create_channel("main")
            .context("failed to create main channel")?;
        txn.commit().context("failed to commit pristine txn")?;

File addition: pijul_env.rs (----------)

[5.54442]

use std::path::{Path, PathBuf};
use std::process::{Command, Output};
use anyhow::{Context, Result};
use tempfile::TempDir;
/// Isolated environment for running the `pijul` CLI in tests.
///
/// This prevents tests from reading/writing the developer machine's config under
/// `$HOME` / `XDG_CONFIG_HOME` / `XDG_DATA_HOME`.
pub struct PijulEnv {
    temp_dir: TempDir,
}
impl PijulEnv {
    pub fn new() -> Result<Self> {
        Ok(Self {
            temp_dir: TempDir::new().context("failed to create temp dir for PijulEnv")?,
        })
    }
    pub fn home_dir(&self) -> &Path {
        self.temp_dir.path()
    }
    pub fn xdg_config_home(&self) -> PathBuf {
        self.temp_dir.path().join(".config")
    }
    pub fn xdg_data_home(&self) -> PathBuf {
        self.temp_dir.path().join(".local").join("share")
    }
    pub fn apply_env(&self, cmd: &mut Command) {
        cmd.env("HOME", self.home_dir())
            .env("XDG_CONFIG_HOME", self.xdg_config_home())
            .env("XDG_DATA_HOME", self.xdg_data_home());
    }
}
pub fn run_pijul(mut cmd: Command) -> Result<Output> {
    let output = cmd.output().context("failed to spawn pijul")?;
    anyhow::ensure!(
        output.status.success(),
        "pijul exited with {}.\nstdout:\n{}\nstderr:\n{}",
        output.status,
        String::from_utf8_lossy(&output.stdout),
        String::from_utf8_lossy(&output.stderr)
    );
    Ok(output)
}

Insertion in tests/support/mod.rs at line 1 [5.59826]
[5.59826]
[5.59827]
```
pub mod pijul_env;
```
Insertion in tests/support/mod.rs at line 5 [5.59826]
[5.59871]
[5.59871]
```
pub use crate::support::pijul_env::PijulEnv;
```
Replacement in tests/e2e.rs at line 6 [5.60527]
B:BD[5.60616] → [5.60616:60644]
```
use reqwest::blocking::get;
```
[5.60616]
[5.60644]
```
use assert_fs::prelude::*;
```
Insertion in tests/e2e.rs at line 8 [5.60527]
[5.60675]
[5.60675]
```
use reqwest::blocking::get;
use serde_json::Value;
```
Insertion in tests/e2e.rs at line 13 [5.60527]
[5.60741]
[5.60741]
```
use crate::support::{PijulEnv, pijul_env::run_pijul};
```

Replacement in tests/e2e.rs at line 20 [5.60527]

B:BD[5.60967] → [5.60967:61030]

    let resp = get(&format!("{}/.pijul", server.base_url()))?;

[5.60967]

[5.61030]

    let resp = dbg!(get(&format!("{}/.pijul", server.base_url()))?);

Replacement in tests/e2e.rs at line 22 [5.60527]

B:BD[5.61031] → [5.61031:61123]

    assert_eq!(resp.status(), 404);
    assert_eq!(resp.text()?, "No command specified\n");

[5.61031]

[5.61123]

    assert_eq!(resp.status(), 200);
    assert!(
        resp.headers()
            .get("Content-Type")
            .is_some_and(|t| t == "application/json")
    );
    let body: Value = serde_json::from_str(&resp.text()?)?;
    let channels = body
        .get("channels")
        .and_then(|c| c.as_array())
        .expect("expected channels array");
    assert!(channels.iter().any(|c| c == "main"));
    assert!(body.get("head").is_some());

Insertion in tests/e2e.rs at line 43 [5.60527]

[5.61222]

    repo.write_file(".pijul/changes/ab/cdef123.change", "change data")?;
    repo.write_file(".pijul/changes/ab/cdef123.tag", "tag data")?;

Insertion in tests/e2e.rs at line 49 [5.60527]

[5.61399]


    // info (?log alias)
    {
        let resp = client.get(&url).query(&[("log", "")]).send()?;
        assert_eq!(resp.status(), 200);
        assert!(
            resp.headers()
                .get("Content-Type")
                .is_some_and(|t| t == "application/json")
        );
    }

Replacement in tests/e2e.rs at line 65 [5.60527]

B:BD[5.61538] → [5.61538:61671]

        assert!(resp
            .headers()
            .get("Content-Type")
            .is_some_and(|t| t == "application/json"));

[5.61538]

[5.61671]

        assert!(
            resp.headers()
                .get("Content-Type")
                .is_some_and(|t| t == "application/json")
        );

Insertion in tests/e2e.rs at line 72 [5.60527]

[5.61754]

    }
    // channel id
    {
        let resp = client
            .get(&url)
            .query(&[("channel", "main"), ("id", "")])
            .send()?;
        assert_eq!(resp.status(), 200);
        assert!(
            resp.headers()
                .get("Content-Type")
                .is_some_and(|t| t == "application/octet-stream")
        );
        let bytes = resp.bytes()?;
        assert_eq!(bytes.len(), 16);
    }
    // channel state summary (JSON)
    {
        let resp = client.get(&url).query(&[("channel", "main")]).send()?;
        assert_eq!(resp.status(), 200);
        assert!(
            resp.headers()
                .get("Content-Type")
                .is_some_and(|t| t == "application/json")
        );
        let body: Value = serde_json::from_str(&resp.text()?)?;
        assert!(body.get("position").and_then(|v| v.as_u64()).is_some());
        assert!(body.get("merkle").and_then(|v| v.as_str()).is_some());
        assert!(body.get("tag_merkle").and_then(|v| v.as_str()).is_some());
    }
    // state at position
    {
        let resp = client
            .get(&url)
            .query(&[("state", "0"), ("channel", "main")])
            .send()?;
        assert_eq!(resp.status(), 200);
        assert!(
            resp.headers()
                .get("Content-Type")
                .is_some_and(|t| t == "text/plain")
        );
        let body = resp.text()?;
        let parts: Vec<&str> = body.split_whitespace().collect();
        assert_eq!(parts.len(), 3);
        assert!(parts[0].parse::<u64>().is_ok());
    }
    // changelist from position
    {
        let resp = client
            .get(&url)
            .query(&[("changelist", "0"), ("channel", "main")])
            .send()?;
        assert_eq!(resp.status(), 200);
        assert!(
            resp.headers()
                .get("Content-Type")
                .is_some_and(|t| t == "text/plain")
        );
        assert_eq!(resp.text()?, "");
    }
    // change download
    {
        let resp = client.get(&url).query(&[("change", "abcdef123")]).send()?;
        assert_eq!(resp.status(), 200);
        assert!(
            resp.headers()
                .get("Cache-Control")
                .is_some_and(|v| v == "public, max-age=31536000, immutable")
        );
        let bytes = resp.bytes()?.to_vec();
        assert_eq!(bytes, b"change data");
    }
    // tag download
    {
        let resp = client.get(&url).query(&[("tag", "abcdef123")]).send()?;
        assert_eq!(resp.status(), 200);
        assert!(
            resp.headers()
                .get("Cache-Control")
                .is_some_and(|v| v == "public, max-age=31536000, immutable")
        );
        let bytes = resp.bytes()?.to_vec();
        assert_eq!(bytes, b"tag data");
    }
    // invalid query => 400
    {
        let resp = client.get(&url).query(&[("changelist", "0")]).send()?;
        assert_eq!(resp.status(), 400);

Insertion in tests/e2e.rs at line 172 [5.60527]

[5.61774]


#[test]
fn pijul_cli_clone_and_pull_over_http() -> Result<()> {
    // Remote repo with actual recorded changes, served over HTTP.
    let remote = RepoFixture::new()?;
    remote.write_file("hello.txt", "v1\n")?;
    {
        let mut cmd = std::process::Command::new("pijul");
        cmd.current_dir(remote.repo_root())
            .arg("add")
            .arg("hello.txt");
        remote.apply_env(&mut cmd);
        run_pijul(cmd)?;
    }
    {
        let mut cmd = std::process::Command::new("pijul");
        cmd.current_dir(remote.repo_root())
            .arg("record")
            .arg("--all")
            .arg("--message")
            .arg("init")
            .arg("--identity")
            .arg("test")
            .arg("--no-prompt");
        remote.apply_env(&mut cmd);
        run_pijul(cmd)?;
    }
    let server = TestServer::start(remote)?;
    // Clone into a separate isolated HOME.
    let env = PijulEnv::new()?;
    let clone_parent = assert_fs::TempDir::new()?;
    let clone_dir = clone_parent.child("clone");
    {
        let mut cmd = std::process::Command::new("pijul");
        cmd.current_dir(clone_parent.path())
            .arg("clone")
            .arg(server.base_url())
            .arg(clone_dir.path())
            .arg("--no-prompt");
        env.apply_env(&mut cmd);
        run_pijul(cmd)?;
    }
    clone_dir.child("hello.txt").assert("v1\n");
    // Add another change on the remote while the server is running.
    std::fs::write(server.repo_root().join("hello.txt"), "v2\n")?;
    {
        let mut cmd = std::process::Command::new("pijul");
        cmd.current_dir(server.repo_root())
            .arg("record")
            .arg("--all")
            .arg("--message")
            .arg("update")
            .arg("--identity")
            .arg("test")
            .arg("--no-prompt");
        server.apply_repo_env(&mut cmd);
        run_pijul(cmd)?;
    }
    // Pull into the clone.
    {
        let mut cmd = std::process::Command::new("pijul");
        cmd.current_dir(clone_dir.path())
            .arg("pull")
            .arg(server.base_url())
            .arg("--all")
            .arg("--no-prompt");
        env.apply_env(&mut cmd);
        run_pijul(cmd)?;
    }
    clone_dir.child("hello.txt").assert("v2\n");
    Ok(())
}

Insertion in src/url.rs at line 8 [7.31]

[6.283]

//! - empty query (`GET /.pijul`) - Repository info (channel list)
//! - `log` - Repository info (alias used by some clients/servers)

Replacement in src/url.rs at line 11 [7.31]

B:BD[6.330] → [2.1259:1333]

//! - `tag={hash}` - Download a tag file (doesn't seem to be implemented)

[6.330]

[6.371]

//! - `tag={hash}` - Download a tag file (a content-addressed tag/state snapshot)

Replacement in src/url.rs at line 26 [7.31]
B:BD[6.909] → [2.1334:1378]
```
/// 1. empty query → `NoCommandSpecified`
```
[6.909]
[6.939]
```
/// 1. empty query → `Info`
```
Insertion in src/url.rs at line 34 [7.31]
[6.1255]
[6.1284]
```
/// 9. `log` flag (alone) → `Info`
```

Insertion in src/url.rs at line 38 [7.31]

[6.1376]

[6.1447]

    /// Repository info (`GET /.pijul` or `?log`).
    Info,

Deletion in src/url.rs at line 54 [7.31]

B:BD[6.2082] → [2.1379:1449]

    /// No command specified (`GET /.pijul`).
    NoCommandSpecified,

Insertion in src/url.rs at line 60 [7.31]
[6.2264]
[6.2264]
```
        println!("{:?}", map);
```

Replacement in src/url.rs at line 62 [7.31]

B:BD[6.2292] → [2.1450:1500]

            return Operation::NoCommandSpecified;

[6.2292]

[6.2328]

            return Operation::Info;

Replacement in src/url.rs at line 73 [7.31]

B:BD[6.2637] → [6.2637:2972]

        if let Some(from) = map.get("changelist").and_then(|v| v.first()) {
            if let Some(channel) = map.get("channel").and_then(|v| v.first()) {
                return Operation::Changelist {
                    channel: channel.clone(),
                    from: from.parse().unwrap_or(0),
                };
            }

[6.2637]

[6.2972]

        if let Some(from) = map.get("changelist").and_then(|v| v.first())
            && let Some(channel) = map.get("channel").and_then(|v| v.first())
        {
            return Operation::Changelist {
                channel: channel.clone(),
                from: from.parse().unwrap_or(0),
            };

Replacement in src/url.rs at line 82 [7.31]

B:BD[6.2983] → [6.2983:3224]

        if map.contains_key("id") {
            if let Some(channel) = map.get("channel").and_then(|v| v.first()) {
                return Operation::ChannelId {
                    channel: channel.clone(),
                };
            }

[6.2983]

[6.3224]

        if map.contains_key("id")
            && let Some(channel) = map.get("channel").and_then(|v| v.first())
        {
            return Operation::ChannelId {
                channel: channel.clone(),
            };

Insertion in src/url.rs at line 112 [7.31]

[6.3996]

        if map.contains_key("log") && map.len() == 1 {
            return Operation::Info;
        }

Deletion in src/url.rs at line 164 [7.31]
∅:D[6.4478] → [7.1987:2005]
B:BD[7.1987] → [7.1987:2005]
B:BD[7.2005] → [6.4479:4517]
∅:D[6.4517] → [7.2039:2107]
B:BD[7.2039] → [7.2039:2107]
B:BD[7.2107] → [6.4518:4590]
∅:D[6.4590] → [7.2146:2150]
B:BD[7.2146] → [7.2146:2150]
B:BD[7.2372] → [7.2372:2394]
B:BD[7.2394] → [6.4591:4703]
∅:D[6.4703] → [7.2496:2528]
B:BD[7.2496] → [7.2496:2528]
B:BD[7.2528] → [6.4704:4773]
∅:D[6.4773] → [7.2647:2655]
B:BD[7.2647] → [7.2647:2655]
```
///
/// # Returns
/// Tuple of (path, Operation) where:
/// - `path`: URL path with leading `/` stripped (e.g., `".pijul"`)
/// - `Operation`: The protocol operation derived from query parameters
///
/// # Example
/// ```
/// use pijul_srv_lite::url::{parse_url, Operation};
/// let (path, op) = parse_url("/.pijul?channel=main&id");
/// assert_eq!(path, ".pijul");
/// assert_eq!(op, Operation::ChannelId { channel: "main".into() });
/// ```
```

Replacement in src/url.rs at line 168 [7.31]

B:BD[7.2843] → [6.4828:4888]

    (path.into(), Operation::from(&parse_query(query_str)))

[7.2843]

[7.2885]

    (path.to_string(), Operation::from(&parse_query(query_str)))

Replacement in src/url.rs at line 202 [7.31]

B:BD[7.3960] → [2.1501:1556]

        assert_eq!(op, Operation::NoCommandSpecified);

[7.3960]

[7.3995]

        assert_eq!(op, Operation::Info);

Replacement in src/url.rs at line 209 [7.31]

B:BD[6.5114] → [6.5114:5153]

                channel: "main".into()

[6.5114]

[6.5153]

                channel: "main".to_string()

Replacement in src/url.rs at line 225 [7.31]

B:BD[6.5235] → [2.1557:1643]

        assert_eq!(Operation::from(&parse_query("")), Operation::NoCommandSpecified);

[6.5235]

[6.5307]

        assert_eq!(Operation::from(&parse_query("")), Operation::Info);

Replacement in src/url.rs at line 234 [7.31]

B:BD[6.5498] → [6.5498:5536]

                hash: "ABCDEF".into()

[6.5498]

[6.5536]

                hash: "ABCDEF".to_string()

Replacement in src/url.rs at line 245 [7.31]

B:BD[6.5743] → [6.5743:5781]

                hash: "XYZABC".into()

[6.5743]

[6.5781]

                hash: "XYZABC".to_string()

Replacement in src/url.rs at line 256 [7.31]

B:BD[6.6010] → [6.6010:6050]

                channel: "main".into(),

[6.6010]

[6.6050]

                channel: "main".to_string(),

Replacement in src/url.rs at line 268 [7.31]

B:BD[6.6292] → [6.6292:6331]

                channel: "main".into()

[6.6292]

[6.6331]

                channel: "main".to_string()

Replacement in src/url.rs at line 279 [7.31]

B:BD[6.6554] → [6.6554:6596]

                channel: "feature".into()

[6.6554]

[6.6596]

                channel: "feature".to_string()

Replacement in src/url.rs at line 290 [7.31]

B:BD[6.6810] → [6.6810:6849]

                channel: "dev".into(),

[6.6810]

[6.6849]

                channel: "dev".to_string(),

Replacement in src/url.rs at line 302 [7.31]

B:BD[6.7075] → [6.7075:7115]

                channel: "main".into(),

[6.7075]

[6.7115]

                channel: "main".to_string(),

Insertion in src/url.rs at line 312 [7.31]

[6.7327]

    }
    #[test]
    fn test_operation_from_log() {
        let (_, op) = parse_url("/.pijul?log");
        assert_eq!(op, Operation::Info);

Replacement in src/url.rs at line 323 [7.31]

B:BD[6.7603] → [6.7603:7677]

        assert_eq!(op, Operation::DownloadChange { hash: "ABC".into() });

[6.7603]

[6.7677]

        assert_eq!(op, Operation::DownloadChange { hash: "ABC".to_string() });

File addition: server.rs (----------)

[8.15]

use crate::router;
use std::io;
use std::net::TcpListener;
use std::path::PathBuf;
use tiny_http::{Method, Server};
use crate::error::{Result, ServerError};
use crate::responses;
pub fn resolve_repo_path(repo_base: PathBuf) -> Result<PathBuf> {
    let repo_path = if repo_base.join(".pijul").exists() {
        repo_base
    } else {
        repo_base.join("default")
    };
    if !repo_path.join(".pijul").exists() {
        return Err(ServerError::RepoNotFound(repo_path));
    }
    Ok(repo_path)
}
pub struct ServerConfig {
    pub repo_path: PathBuf,
}
pub fn serve(listener: TcpListener, config: ServerConfig) -> Result<()> {
    let local_addr = listener.local_addr()?;
    let server =
        Server::from_listener(listener, None).map_err(|e| io::Error::other(e.to_string()))?;
    println!("listening on {local_addr}");
    println!("Serving repository from {:?}", config.repo_path);
    for request in server.incoming_requests() {
        let response = match request.method() {
            Method::Head => responses::empty(200),
            Method::Get | Method::Post => router::route(request.url(), &config),
            _ => responses::status_code(405),
        };
        request.respond(response)?;
    }
    Ok(())
}

File addition: router.rs (----------)

[8.15]

use std::path::Path;
use crate::handlers;
use crate::pristine::PristineReader;
use crate::responses;
use crate::server::ServerConfig;
use crate::url::{Operation, parse_url};
fn with_reader(
    repo_path: &Path,
    f: impl FnOnce(&PristineReader) -> responses::HttpResponse,
) -> responses::HttpResponse {
    let Ok(reader) = PristineReader::open(repo_path) else {
        return responses::status_code(500);
    };
    f(&reader)
}
pub(crate) fn route(url: &str, config: &ServerConfig) -> responses::HttpResponse {
    let (path, op) = parse_url(url);
    let repo_path = config.repo_path.as_path();
    if !path.starts_with(".pijul") {
        return responses::status_code(404);
    }
    match op {
        Operation::Info => with_reader(repo_path, handlers::serve_info),
        Operation::DownloadChange { hash } => handlers::serve_change(repo_path, &hash),
        Operation::DownloadTag { hash } => handlers::serve_tag(repo_path, &hash),
        Operation::Changelist { channel, from } => with_reader(repo_path, |reader| {
            handlers::serve_changelist(reader, &channel, from)
        }),
        Operation::ChannelId { channel } => with_reader(repo_path, |reader| {
            handlers::serve_channel_id(reader, &channel)
        }),
        Operation::ChannelState { channel } => with_reader(repo_path, |reader| {
            handlers::serve_channel(reader, &channel)
        }),
        Operation::State { channel, pos } => with_reader(repo_path, |reader| {
            handlers::serve_state(reader, &channel, pos)
        }),
        Operation::Identities => handlers::serve_identities(),
        Operation::Invalid => responses::status_code(400),
    }
}

Replacement in src/responses.rs at line 15 [9.37]
B:BD[9.460] → [3.0:39]
```
use tiny_http::{Response, StatusCode};
```
[9.460]
[9.507]
```
use tiny_http::{Header, Response, StatusCode};
```

Replacement in src/responses.rs at line 17 [9.37]

B:BD[9.508] → [9.508:559]

pub type HttpResponse = Response<Cursor<Vec<u8>>>;

[9.508]

[9.559]

pub(crate) type HttpResponse = Response<Cursor<Vec<u8>>>;

Insertion in src/responses.rs at line 26 [9.37]

[9.837]

[3.249]

fn immutable_header() -> Header {
    header!("Cache-Control", "public, max-age=31536000, immutable")
}

Replacement in src/responses.rs at line 31 [9.37]

B:BD[3.309] → [3.309:353]

pub fn binary(d: Vec<u8>) -> HttpResponse {

[3.309]

[3.353]

pub(crate) fn binary(d: Vec<u8>) -> HttpResponse {

Insertion in src/responses.rs at line 33 [9.37]

[3.445]

[9.1077]

}
pub(crate) fn empty<S>(code: S) -> HttpResponse
where
    S: Into<StatusCode>,
{
    Response::from_data(Vec::new()).with_status_code(code)

Replacement in src/responses.rs at line 43 [9.37]
B:BD[9.1132] → [3.446:485]
```
pub fn json(s: &str) -> HttpResponse {
```
[9.1132]
[3.485]
```
pub(crate) fn json(s: &str) -> HttpResponse {
```

Replacement in src/responses.rs at line 48 [9.37]

B:BD[3.622] → [3.622:706]

pub fn status_code(code: u16) -> HttpResponse {
    let c = StatusCode::from(code);

[3.622]

[9.1837]

pub(crate) fn status_code<S>(code: S) -> HttpResponse
where
    S: Into<StatusCode>,
{
    let code = code.into();
    Response::from_string(code.default_reason_phrase()).with_status_code(code)
}

Replacement in src/responses.rs at line 56 [9.37]

B:BD[9.1838] → [3.707:780]

    Response::from_string(c.default_reason_phrase()).with_status_code(c)

[9.1838]

[9.2009]

/// Create a 200 OK response with text/plain.
pub(crate) fn text(s: &str) -> HttpResponse {
    Response::from_string(s).with_header(header!("Content-Type", "text/plain"))

Replacement in src/responses.rs at line 66 [9.37]

B:BD[9.2210] → [3.781:844]

pub fn file(path: &Path, content_type: &str) -> HttpResponse {

[9.2210]

[9.2279]

pub(crate) fn file(path: &Path, content_type: &str) -> HttpResponse {

Replacement in src/responses.rs at line 70 [9.37]

B:BD[3.909] → [3.909:1046]

            .with_header(header!(
                "Cache-Control",
                "public, max-age=31536000, immutable"
            )),

[3.909]

[3.1046]

            .with_header(immutable_header()),

Replacement in src/responses.rs at line 114 [9.37]

B:BD[9.4218] → [3.1495:1593]

        let resp = super::file(std::path::Path::new("/nonexistent/path/file.txt"), "text/plain");

[9.4218]

[3.1593]

        let resp = super::file(
            std::path::Path::new("/nonexistent/path/file.txt"),
            "text/plain",
        );

Replacement in src/pristine.rs at line 1 [10.36]

B:BD[10.36] → [10.37:96]

//! (Stub) Reader for pijul's pristine sanakirja database.

[10.36]

[10.96]

//! Reader for pijul's pristine database (via libpijul).

Replacement in src/pristine.rs at line 3 [10.36]

B:BD[10.97] → [10.97:126]

pub struct PristineReader {}

[10.97]

[10.126]

use std::path::Path;
use libpijul::pristine::{Base32, Merkle, Pair, TxnT};
use libpijul::{ChannelTxnT, GraphTxnT};
use pijul_repository::Repository;
/// Read-only view of a repository's pristine database.
///
/// This is a small wrapper around `pijul_repository::Repository` so we don't
/// depend on Sanakirja directly in this crate.
pub(crate) struct PristineReader {
    repo: Repository,
}

Replacement in src/pristine.rs at line 24 [10.36]
B:BD[10.495] → [10.495:520]
```
pub struct ChangeEntry {
```
[10.495]
[10.520]
```
pub(crate) struct ChangeEntry {
```

Replacement in src/pristine.rs at line 29 [10.36]

B:BD[10.708] → [10.708:802]

    /// Base32-encoded merkle hash representing cumulative state up to this
    /// position.

[10.708]

[10.802]

    /// Base32-encoded merkle hash representing cumulative state up to this position.

Replacement in src/pristine.rs at line 31 [10.36]

B:BD[10.826] → [10.826:926]

    /// True if this entry is a tag (immutable state snapshot) rather than a
    /// regular change

[10.826]

[10.926]

    /// True if this entry is a tag (immutable state snapshot) rather than a regular change.

Insertion in src/pristine.rs at line 36 [10.36]

[10.973]

    pub fn open(repo_root: &Path) -> Result<Self, String> {
        Repository::find_root(Some(repo_root.to_path_buf()))
            .map(|repo| Self { repo })
            .map_err(|e| format!("failed to open repository at {}: {e}", repo_root.display()))
    }

Replacement in src/pristine.rs at line 43 [10.36]

B:BD[10.1054] → [10.1054:1099]

        dbg!(channel, from);
        todo!()

[10.1054]

[10.1099]

        let Ok(txn) = self.repo.pristine.txn_begin() else {
            return Vec::new();
        };
        let Ok(Some(chan_ref)) = txn.load_channel(channel) else {
            return Vec::new();
        };
        let chan = chan_ref.read();
        let Ok(cursor) = libpijul::pristine::changeid_log(&txn, &chan, from.into()) else {
            return Vec::new();
        };
        let mut out = Vec::new();
        for item in cursor {
            let Ok((
                pos,
                Pair {
                    a: change_id,
                    b: state,
                },
            )) = item
            else {
                continue;
            };
            let pos: u64 = (*pos).into();
            let Some(ext_hash) = txn.get_external(change_id).ok().flatten() else {
                continue;
            };
            let hash: libpijul::Hash = ext_hash.into();
            let merkle = Merkle::from(state).to_base32();
            let is_tag = txn.is_tagged(txn.tags(&chan), pos).unwrap_or(false);
            out.push(ChangeEntry {
                position: pos,
                hash: hash.to_base32(),
                merkle,
                is_tag,
            });
        }
        out

Replacement in src/pristine.rs at line 90 [10.36]

B:BD[10.1192] → [10.1192:1234]

        dbg!(channel, n);
        todo!()

[10.1192]

[10.1234]

        let txn = self.repo.pristine.txn_begin().ok()?;
        let chan_ref = txn.load_channel(channel).ok()??;
        let chan = chan_ref.read();
        // Merkle for the change history at (or before) `n`.
        let (pos, merkle) = {
            let mut cur = txn
                .rev_cursor_revchangeset(txn.rev_changes(&chan), Some(n.into()))
                .ok()?;
            if let Some(entry) = cur.next() {
                let (pos, Pair { b: m, .. }) = entry.ok()?;
                let pos: u64 = (*pos).into();
                (pos, Merkle::from(m).to_base32())
            } else {
                (0, Merkle::zero().to_base32())
            }
        };
        // Merkle for the tag history at (or before) `n`.
        let tag_merkle = {
            let mut cur = txn.rev_iter_tags(txn.tags(&chan), Some(n)).ok()?;
            if let Some(entry) = cur.next() {
                let (_pos, Pair { b: m, .. }) = entry.ok()?;
                Merkle::from(m).to_base32()
            } else {
                Merkle::zero().to_base32()
            }
        };
        Some((pos, merkle, tag_merkle))

Replacement in src/pristine.rs at line 123 [10.36]

B:BD[10.1290] → [10.1290:1306]

        todo!()

[10.1290]

[10.1306]

        let Ok(txn) = self.repo.pristine.txn_begin() else {
            return Vec::new();
        };
        let Ok(channels) = txn.channels("") else {
            return Vec::new();
        };
        channels
            .into_iter()
            .map(|c| c.read().name.as_str().to_string())
            .collect()
    }
    pub fn channel_id_bytes(&self, channel: &str) -> Option<[u8; 16]> {
        let txn = self.repo.pristine.txn_begin().ok()?;
        let chan_ref = txn.load_channel(channel).ok()??;
        let chan = chan_ref.read();
        Some(*chan.id.as_bytes())

Replacement in src/lib.rs at line 12 [11.31]
∅:D[6.8348] → [10.1315:1351]
B:BD[11.31] → [10.1315:1351]
∅:D[10.1351] → [9.4869:4888]
B:BD[11.31] → [9.4869:4888]
```
pub mod handlers;
pub mod pristine;
pub mod responses;
```
[6.8348]
[7.4715]
```
pub mod error;
pub(crate) mod handlers;
pub(crate) mod pristine;
pub(crate) mod responses;
pub(crate) mod router;
pub mod server;
```

Replacement in src/handlers.rs at line 28 [10.1388]

B:BD[10.2444] → [10.2444:2540]

pub fn serve_channel_id(_reader: &PristineReader, _channel: &str) -> HttpResponse {
    todo!()

[10.2444]

[10.2540]

pub(crate) fn serve_channel_id(reader: &PristineReader, channel: &str) -> HttpResponse {
    let Some(id) = reader.channel_id_bytes(channel) else {
        return responses::status_code(404);
    };
    responses::binary(id.to_vec())

Replacement in src/handlers.rs at line 46 [10.1388]

B:BD[10.3048] → [10.3048:3127]

pub fn serve_channel(reader: &PristineReader, channel: &str) -> HttpResponse {

[10.3048]

[10.3127]

pub(crate) fn serve_channel(reader: &PristineReader, channel: &str) -> HttpResponse {

Replacement in src/handlers.rs at line 56 [10.1388]

B:BD[10.3451] → [3.1857:1939]

        None => Response::from_string("channel not found").with_status_code(400),

[10.3451]

[10.3499]

        None => responses::status_code(404),

Replacement in src/handlers.rs at line 77 [10.1388]

B:BD[10.4533] → [10.4533:4626]

pub fn serve_changelist(reader: &PristineReader, channel: &str, from: u64) -> HttpResponse {

[10.4533]

[10.4626]

pub(crate) fn serve_changelist(reader: &PristineReader, channel: &str, from: u64) -> HttpResponse {

Replacement in src/handlers.rs at line 89 [10.1388]
B:BD[10.4943] → [3.1940:1975]
```
    Response::from_string(&output)
```
[10.4943]
[10.4963]
```
    responses::text(&output)
```

Replacement in src/handlers.rs at line 114 [10.1388]

B:BD[10.6033] → [10.6033:6101]

pub fn serve_change(repo_path: &Path, hash: &str) -> HttpResponse {

[10.6033]

[10.6101]

pub(crate) fn serve_change(repo_path: &Path, hash: &str) -> HttpResponse {

Replacement in src/handlers.rs at line 143 [10.1388]

B:BD[10.7135] → [10.7135:7297]

/// # Special Return
/// Returns "-" if the requested position doesn't exist
pub fn serve_state(reader: &PristineReader, channel: &str, n: u64) -> HttpResponse {

[10.7135]

[10.7297]

/// # Position Semantics
/// If `n` doesn't exist exactly, the server returns the latest state at or
/// before `n`. For an empty channel, this returns position `0` with the
/// zero merkle hashes.
pub(crate) fn serve_state(reader: &PristineReader, channel: &str, n: u64) -> HttpResponse {

Replacement in src/handlers.rs at line 149 [10.1388]

B:BD[10.7338] → [3.2116:2272]

        Some((pos, merkle, tag_merkle)) => Response::from_string(format!("{} {} {}", pos, merkle, tag_merkle)),
        None => responses::status_code(400)

[10.7338]

[10.7515]

        Some((pos, merkle, tag_merkle)) => responses::text(&format!("{pos} {merkle} {tag_merkle}")),
        None => responses::status_code(404),

Replacement in src/handlers.rs at line 156 [10.1388]

B:BD[10.7585] → [2.0:48]

/// Can't get this to work with nest.pijul.org.

[10.7585]

[10.8160]

/// # Pijul Client Interaction
/// - **Endpoint**: `GET /.pijul?tag={hash}`
/// - **Called by**: `Http::download_tags()` in pijul-remote/src/http.rs (when tags exist)
/// - **Response format**: Binary tag file content (`application/octet-stream`)

Replacement in src/handlers.rs at line 161 [10.1388]

B:BD[10.8164] → [2.49:122]

/// Pushing (other SSH) results in http response "No command specified".

[10.8164]

[10.8315]

/// # File Location
/// Tag files are stored alongside change files:
/// `.pijul/changes/{first-2-chars}/{rest}.tag`

Replacement in src/handlers.rs at line 165 [10.1388]

B:BD[10.8319] → [2.123:180]

∅:D[2.180] → [10.8465:8530]

B:BD[10.8465] → [10.8465:8530]

B:BD[10.8530] → [2.181:249]

/// On nest.pijul.org, the tags tab for repos are empty.
pub fn serve_tag(repo_path: &Path, hash: &str) -> HttpResponse {
    dbg!(repo_path, hash);
    todo!("No reference implementation")

[10.8319]

[10.8878]

/// # Caching
/// Response includes `Cache-Control: public, max-age=31536000, immutable`
/// because tag files are content-addressed and never change.
///
/// # Validation
/// Hash must be at least 3 characters and contain only alphanumeric chars.
/// Returns 404 for invalid hashes or missing files.
pub(crate) fn serve_tag(repo_path: &Path, hash: &str) -> HttpResponse {
    if hash.len() < 3 || !hash.chars().all(|c| c.is_ascii_alphanumeric()) {
        return Response::from_string("invalid tag hash").with_status_code(404);
    }
    let (pfx, sfx) = hash.split_at(2);
    let path = repo_path
        .join(".pijul")
        .join("changes")
        .join(pfx)
        .join(format!("{}.tag", sfx));
    responses::file(&path, "application/octet-stream")

Replacement in src/handlers.rs at line 209 [10.1388]

B:BD[10.10531] → [10.10531:10592]

pub fn serve_info(reader: &PristineReader) -> HttpResponse {

[10.10531]

[10.10592]

pub(crate) fn serve_info(reader: &PristineReader) -> HttpResponse {

Replacement in src/handlers.rs at line 304 [10.1388]

B:BD[10.13136] → [2.371:583]

    // #[test]
    // fn test_serve_tag_hash_too_short() {
    //     let dir = TempDir::new().unwrap();
    //     let resp = serve_tag(dir.path(), "ab");
    //     assert_eq!(get_status(&resp), 404);
    // }

[10.13136]

[10.13330]

    #[test]
    fn test_serve_tag_hash_too_short() {
        let dir = TempDir::new().unwrap();
        let resp = serve_tag(dir.path(), "ab");
        assert_eq!(get_status(&resp), 404);
    }

Replacement in src/handlers.rs at line 311 [10.1388]

B:BD[10.13331] → [2.584:773]

    // #[test]
    // fn test_serve_tag_valid_hash_file_exists() {
    //     let dir = TempDir::new().unwrap();
    //     let tag_dir = dir.path().join(".pijul").join("tags").join("ab");

[10.13331]

[6.8353]

    #[test]
    fn test_serve_tag_valid_hash_file_exists() {
        let dir = TempDir::new().unwrap();
        let tag_dir = dir.path().join(".pijul").join("changes").join("ab");

Replacement in src/handlers.rs at line 316 [10.1388]

B:BD[6.8354] → [2.774:1008]

    //     fs::create_dir_all(&tag_dir).unwrap();
    //     let tag_file = tag_dir.join("cdef123.tag");
    //     fs::File::create(&tag_file)
    //         .unwrap()
    //         .write_all(b"tag data")
    //         .unwrap();

[6.8354]

[10.13724]

        fs::create_dir_all(&tag_dir).unwrap();
        let tag_file = tag_dir.join("cdef123.tag");
        fs::File::create(&tag_file)
            .unwrap()
            .write_all(b"tag data")
            .unwrap();

Replacement in src/handlers.rs at line 323 [10.1388]

B:BD[10.13725] → [2.1009:1258]

    //     let resp = serve_tag(dir.path(), "abcdef123");
    //     assert_eq!(get_status(&resp), 200);
    //     assert_eq!(
    //         get_header(&resp, "Content-Type"),
    //         Some("application/octet-stream")
    //     );
    // }

[10.13725]

[10.13953]

        let resp = serve_tag(dir.path(), "abcdef123");
        assert_eq!(get_status(&resp), 200);
        assert_eq!(
            get_header(&resp, "Content-Type"),
            Some("application/octet-stream")
        );
        assert_eq!(
            get_header(&resp, "Cache-Control"),
            Some("public, max-age=31536000, immutable")
        );
    }

File addition: error.rs (----------)

[8.15]

use std::io;
use std::path::PathBuf;
use thiserror::Error;
#[derive(Debug, Error)]
pub enum ServerError {
    #[error(transparent)]
    Io(#[from] io::Error),
    #[error("repository not found at {0:?}")]
    RepoNotFound(PathBuf),
}
pub type Result<T> = std::result::Result<T, ServerError>;

Replacement in src/bin/main.rs at line 1 [11.2771]

B:BD[11.2771] → [10.14203:14411]

B:BD[10.14411] → [3.2346:2399]

∅:D[3.2399] → [6.8355:8404]

B:BD[10.14482] → [6.8355:8404]

∅:D[6.8404] → [10.14483:14484]

B:BD[7.4765] → [10.14483:14484]

∅:D[7.4765] → [11.2803:2835]

∅:D[10.14484] → [11.2803:2835]

B:BD[11.2803] → [11.2803:2835]

B:BD[11.2866] → [11.2866:2867]

B:BD[11.2867] → [9.4968:4993]

use pijul_srv_lite::handlers::{
    serve_change, serve_changelist, serve_channel, serve_channel_id, serve_identities, serve_info,
    serve_state, serve_tag,
};
use pijul_srv_lite::pristine::PristineReader;
use pijul_srv_lite::responses::{self, HttpResponse};
use pijul_srv_lite::url::{Operation, parse_url};
use std::path::{Path, PathBuf};
use tiny_http::Response;

[11.2771]

[11.2914]

use pijul_srv_lite::error::Result;
use pijul_srv_lite::server::{ServerConfig, resolve_repo_path, serve};
use std::{env, net::TcpListener, path::PathBuf};

Replacement in src/bin/main.rs at line 8 [11.2771]

B:BD[11.2978] → [11.2978:3025]

    let port = std::env::var("PIJUL_SRV_PORT")

[11.2978]

[11.3025]

    if let Err(err) = run() {
        eprintln!("{err:#}");
        std::process::exit(1);
    }
}
fn run() -> Result<()> {
    let bind_addr =
        std::env::var("PIJUL_SRV_BIND_ADDR").unwrap_or_else(|_| "127.0.0.1".to_string());
    let port: u16 = env::var("PIJUL_SRV_PORT")

Replacement in src/bin/main.rs at line 23 [11.2771]

B:BD[11.3104] → [11.3104:3160]

    let repo_base = std::env::var("PIJUL_SRV_REPO_DIR")

[11.3104]

[11.3160]

    let repo_base = env::var("PIJUL_SRV_REPO_DIR")

Replacement in src/bin/main.rs at line 27 [11.2771]

B:BD[11.3247] → [11.3247:3378]

    let repo_path = if repo_base.join(".pijul").exists() {
        repo_base
    } else {
        repo_base.join("default")
    };

[11.3247]

[11.3378]

    let repo_path = resolve_repo_path(repo_base)?;

Replacement in src/bin/main.rs at line 29 [11.2771]

B:BD[11.3379] → [11.3379:3522]

    if !repo_path.join(".pijul").exists() {
        eprintln!("Repository not found at {:?}", repo_path);
        std::process::exit(1);
    }

[11.3379]

[11.3522]

    let listener = TcpListener::bind(format!("{bind_addr}:{port}"))?;

Replacement in src/bin/main.rs at line 31 [11.2771]

B:BD[11.3523] → [11.3523:3764]

B:BD[11.3764] → [11.3764:3903]

B:BD[11.3903] → [11.3903:3913]

    let server = tiny_http::Server::http(format!("0.0.0.0:{port}")).unwrap();
    println!("{SERVER_NAME} listening on port {port}");
    println!("Serving repository from {:?}", repo_path);
    for request in server.incoming_requests() {
        if request.method() == &tiny_http::Method::Head {
            let _ = request.respond(Response::empty(200));
            continue;
        }

[11.3523]

[11.3913]

    println!("Starting {SERVER_NAME}");

Replacement in src/bin/main.rs at line 33 [11.2771]

B:BD[11.3914] → [11.3914:4023]

B:BD[11.4023] → [11.4023:4029]

        let response = handle_request(request.url(), &repo_path);
        let _ = request.respond(response);
    }

[11.3914]

[11.4029]

    serve(listener, ServerConfig { repo_path })

Deletion in src/bin/main.rs at line 35 [11.2771]

B:BD[11.4032] → [11.4032:4033]

B:BD[11.4033] → [10.14485:14550]

B:BD[10.14550] → [6.8487:8524]

∅:D[6.8524] → [11.4160:4198]

B:BD[11.4160] → [11.4160:4198]

B:BD[11.4198] → [3.2400:2444]

∅:D[3.2444] → [11.4237:4244]

B:BD[11.4237] → [11.4237:4244]

B:BD[11.4244] → [3.2445:2583]

∅:D[3.2583] → [10.14587:14588]

B:BD[10.14587] → [10.14587:14588]

B:BD[10.14588] → [6.8525:8540]

B:BD[6.8588] → [6.8588:9130]

B:BD[6.9130] → [3.2584:2755]

∅:D[3.2755] → [11.4308:4314]

∅:D[6.9175] → [11.4308:4314]

∅:D[10.14625] → [11.4308:4314]

B:BD[11.4308] → [11.4308:4314]

B:BD[11.5156] → [11.5156:5158]


fn handle_request(url: &str, repo_path: &Path) -> HttpResponse {
    let (path, op) = parse_url(url);
    if !path.starts_with(".pijul") {
        return responses::status_code(404);
    }
    let reader = match PristineReader::open(repo_path) {
        Ok(r) => r,
        Err(_) => return responses::status_code(500),
    };
    match op {
        Operation::DownloadChange { hash } => serve_change(repo_path, &hash),
        Operation::DownloadTag { hash } => serve_tag(&repo_path, &hash),
        Operation::Changelist { channel, from } => serve_changelist(&reader, &channel, from),
        Operation::ChannelId { channel } => serve_channel_id(&reader, &channel),
        Operation::ChannelState { channel } => serve_channel(&reader, &channel),
        Operation::State { channel, pos } => serve_state(&reader, &channel, pos),
        Operation::Identities => serve_identities(),
        Operation::NoCommandSpecified => Response::from_string("No command specified\n").with_status_code(404),
        Operation::Invalid => responses::status_code(500),
    }
}

Insertion in release-lib.nix at line 23 [8.268]

[8.742]


  tests = import ./nix/tests/default.nix { inherit pkgs; };

Insertion in nix/package/pijul-srv-lite.nix at line 5 [8.5758]
[4.1999]
[4.1999]
```
  dbus,
```
Insertion in nix/package/pijul-srv-lite.nix at line 43 [8.5758]
[5.64]
[5.64]
```
    dbus.dev
```

Replacement in nix/package/dev-shell.nix at line 16 [8.6260]

B:BD[8.6445] → [4.2520:2555]

    rust-bin.stable.latest.default

[8.6445]

    (rust-bin.stable.latest.default.override {
      extensions = [
        "rust-analyzer"
        "rustfmt"
        "rust-src"
      ];
    })

Replacement in Cargo.toml at line 7 [8.7127]

B:BD[8.7213] → [5.54087:54236]

data-encoding = "2.9"
sanakirja = "^1.4.0" # matching pijul 1.0.0-beta.9
sanakirja-core = "^1.4.1" # matching pijul 1.0.0-beta.9 -> sanakirja ^1.4.0

[8.7213]

[12.37]

data-encoding = "2"
libpijul = "1.0.0-beta.11"
pijul-repository = "0.0.1"
thiserror = "2"

Insertion in Cargo.toml at line 15 [8.7127]
[5.54250]
[12.57]
```
assert_fs = "1"
```
Replacement in Cargo.toml at line 17 [8.7127]
B:BD[12.75] → [5.54251:54313]
```
pijul-repository = "0.0.1" # e2e, matching pijul 1.0.0-beta.9
```
[12.75]
[9.4994]
```
predicates = "3"
```
Insertion in Cargo.toml at line 20 [8.7127]
[5.54403]
[11.9715]
```
serde_json = "1"
```

Insertion in Cargo.lock at line 79 [8.7249]

[5.1013]

name = "assert_fs"
version = "1.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a652f6cb1f516886fcfee5e7a5c078b9ade62cfcb889524efe5a64d682dd27a9"
dependencies = [
 "anstyle",
 "doc-comment",
 "globwalk",
 "predicates",
 "predicates-core",
 "predicates-tree",
 "tempfile",
]
[[package]]

Replacement in Cargo.lock at line 128 [8.7249]
∅:D[5.1801] → [9.5221:5240]
B:BD[9.5221] → [9.5221:5240]
```
version = "2.11.0"
```
[5.1801]
[9.5240]
```
version = "2.11.1"
```

Replacement in Cargo.lock at line 130 [8.7249]

B:BD[9.5305] → [9.5305:5383]

checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"

[9.5305]

[5.1802]

checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"

Replacement in Cargo.lock at line 206 [8.7249]
B:BD[11.11169] → [12.175:194]
```
version = "1.2.58"
```
[11.11169]
[11.11188]
```
version = "1.2.60"
```

Replacement in Cargo.lock at line 208 [8.7249]

B:BD[11.11253] → [12.195:273]

checksum = "e1e928d4b69e3077709075a938a05ffbedfa53a84c8f766efbf8220bb1ff60e1"

[11.11253]

[11.11331]

checksum = "43c5703da9466b66a946814e1adf53ea2c90f10063b86290cc9eb67ce3478a20"

Replacement in Cargo.lock at line 275 [8.7249]
B:BD[11.12298] → [12.274:292]
```
version = "4.6.0"
```
[11.12298]
[11.12317]
```
version = "4.6.1"
```

Replacement in Cargo.lock at line 277 [8.7249]

B:BD[11.12382] → [12.293:371]

checksum = "b193af5b67834b676abd72466a96c1024e6a6ad978a1f484bd90b85c94041351"

[11.12382]

[11.12460]

checksum = "1ddb117e43bbf7dacf0a4190fef4d345b9bad68dfc649cb349e7d17d28428e51"

Replacement in Cargo.lock at line 412 [8.7249]
B:BD[5.5046] → [5.5046:5065]
```
version = "0.11.0"
```
[5.5046]
[5.5065]
```
version = "0.11.1"
```

Replacement in Cargo.lock at line 414 [8.7249]

B:BD[5.5130] → [5.5130:5208]

checksum = "25fab6889090c8133f3deb8f73ba3c65a7f456f66436fc012a1b1e272b1e103e"

[5.5130]

[5.5208]

checksum = "b1d1a86f49236c215f271d40892d5fc950490551400b02ef360692c29815c714"

Replacement in Cargo.lock at line 431 [8.7249]
B:BD[5.5512] → [5.5512:5530]
```
version = "3.2.0"
```
[5.5512]
[5.5530]
```
version = "3.2.1"
```

Replacement in Cargo.lock at line 433 [8.7249]

B:BD[5.5595] → [5.5595:5673]

checksum = "0b9fdf9972b2bd6af2d913799d9ebc165ea4d2e65878e329d9c6b372c4491b61"

[5.5595]

[5.5673]

checksum = "90f9d052967f590a76e62eb387bd0bbb1b000182c3cefe5364db6b7211651bc0"

Insertion in Cargo.lock at line 485 [8.7249]

[5.6820]


[[package]]
name = "difflib"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"

Insertion in Cargo.lock at line 538 [8.7249]

[5.7976]


[[package]]
name = "doc-comment"
version = "0.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "780955b8b195a21ab8e4ac6b60dd1dbdcec1dc6c51c0617964b08c81785e12c9"

Replacement in Cargo.lock at line 561 [8.7249]
B:BD[5.8424] → [5.8424:8451]
```
 "curve25519-dalek 3.2.0",
```
[5.8424]
[5.8451]
```
 "curve25519-dalek 3.2.1",
```
Replacement in Cargo.lock at line 619 [8.7249]
B:BD[9.5844] → [9.5844:5862]
```
version = "2.3.0"
```
[9.5844]
[9.5862]
```
version = "2.4.1"
```

Replacement in Cargo.lock at line 621 [8.7249]

B:BD[9.5927] → [9.5927:6005]

checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"

[9.5927]

[9.6005]

checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"

Insertion in Cargo.lock at line 634 [8.7249]

[11.14860]


[[package]]
name = "float-cmp"
version = "0.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b09cf3155332e944990140d967ff5eceb70df778b34f77d8075db46e4704e6d8"
dependencies = [
 "num-traits",
]

Deletion in Cargo.lock at line 660 [8.7249]

B:BD[5.9656] → [5.9656:9882]

name = "fs2"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213"
dependencies = [
 "libc",
 "winapi",
]
[[package]]

Insertion in Cargo.lock at line 788 [8.7249]

[5.12841]

]
[[package]]
name = "globwalk"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0bf760ebf69878d9fd8f110c89703d90ce35095324d1f1edcb595c63945ee757"
dependencies = [
 "bitflags 2.11.1",
 "ignore",
 "walkdir",

Replacement in Cargo.lock at line 829 [8.7249]
B:BD[9.6721] → [9.6721:6740]
```
version = "0.16.1"
```
[9.6721]
[9.6740]
```
version = "0.17.0"
```

Replacement in Cargo.lock at line 831 [8.7249]

B:BD[9.6805] → [9.6805:6883]

checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"

[9.6805]

[9.6883]

checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51"

Replacement in Cargo.lock at line 1098 [8.7249]
∅:D[5.18689] → [9.7296:7315]
B:BD[9.7296] → [9.7296:7315]
```
version = "2.13.1"
```
[5.18689]
[9.7315]
```
version = "2.14.0"
```

Replacement in Cargo.lock at line 1100 [8.7249]

B:BD[9.7380] → [9.7380:7458]

checksum = "45a8a2b9cb3e0b0c1803dbb0758ffac5de2f425b23c28f518faabd9d805342ff"

[9.7380]

[9.7458]

checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"

Replacement in Cargo.lock at line 1103 [8.7249]
B:BD[9.7490] → [9.7490:7511]
```
 "hashbrown 0.16.1",
```
[9.7490]
[9.7511]
```
 "hashbrown 0.17.0",
```
Replacement in Cargo.lock at line 1191 [8.7249]
B:BD[11.15546] → [12.667:686]
```
version = "0.3.94"
```
[11.15546]
[11.15565]
```
version = "0.3.95"
```

Replacement in Cargo.lock at line 1193 [8.7249]

B:BD[11.15630] → [12.687:765]

checksum = "2e04e2ef80ce82e13552136fabeef8a5ed1f985a96805761cbb9a2c34e7664d9"

[11.15630]

[11.15708]

checksum = "2964e92d1d9dc3364cae4d718d93f227e3abb088e747d92e0395bfdedf1c12ca"

Replacement in Cargo.lock at line 1215 [8.7249]
B:BD[11.15785] → [12.766:786]
```
version = "0.2.184"
```
[11.15785]
[11.15805]
```
version = "0.2.185"
```

Replacement in Cargo.lock at line 1217 [8.7249]

B:BD[11.15870] → [12.787:865]

checksum = "48f5d2a454e16a5ea0f4ced81bd44e4cfc7bd3a507b61887c99fd3538b28e4af"

[11.15870]

[5.20581]

checksum = "52ff2c0fe9bc6cb6b14a0592c2ff4fa9ceb83eea9db979b0487cd054946a2b8f"

Replacement in Cargo.lock at line 1228 [8.7249]
B:BD[5.20830] → [5.20830:20850]
```
 "bitflags 2.11.0",
```
[5.20830]
[5.20850]
```
 "bitflags 2.11.1",
```
Replacement in Cargo.lock at line 1253 [8.7249]
B:BD[5.21205] → [5.21205:21220]
```
 "rand 0.9.2",
```
[5.21205]
[5.21220]
```
 "rand 0.9.4",
```
Replacement in Cargo.lock at line 1255 [8.7249]
B:BD[5.21230] → [5.21230:21255]
```
 "sanakirja 2.0.0-beta",
```
[5.21230]
[5.21255]
```
 "sanakirja",
```
Replacement in Cargo.lock at line 1269 [8.7249]
B:BD[5.21409] → [5.21409:21428]
```
version = "0.1.15"
```
[5.21409]
[5.21428]
```
version = "0.1.16"
```

Replacement in Cargo.lock at line 1271 [8.7249]

B:BD[5.21493] → [5.21493:21571]

checksum = "7ddbf48fd451246b1f8c2610bd3b4ac0cc6e149d89832867093ab69a17194f08"

[5.21493]

[5.21571]

checksum = "e02f3bb43d335493c96bf3fd3a321600bf6bd07ed34bc64118e9293bdffea46c"

Replacement in Cargo.lock at line 1273 [8.7249]
B:BD[5.21588] → [5.21588:21608]
```
 "bitflags 2.11.0",
```
[5.21588]
[5.21608]
```
 "bitflags 2.11.1",
```
Replacement in Cargo.lock at line 1276 [8.7249]
B:BD[5.21627] → [5.21627:21651]
```
 "redox_syscall 0.7.3",
```
[5.21627]
[5.21651]
```
 "redox_syscall 0.7.4",
```

Insertion in Cargo.lock at line 1368 [8.7249]

[5.23638]


[[package]]
name = "normalize-line-endings"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be"

Insertion in Cargo.lock at line 1538 [8.7249]
[5.26713]
[11.16999]
```
 "assert_fs",
```
Insertion in Cargo.lock at line 1541 [8.7249]
[5.26732]
[5.26732]
```
 "libpijul",
```
Insertion in Cargo.lock at line 1543 [8.7249]
[5.26753]
[5.26753]
```
 "predicates",
```
Replacement in Cargo.lock at line 1545 [8.7249]
B:BD[5.26765] → [5.26765:26810]
```
 "sanakirja 1.4.3",
 "sanakirja-core 1.4.1",
```
[5.26765]
[9.7945]
```
 "serde_json",
```
Insertion in Cargo.lock at line 1547 [8.7249]
[9.7958]
[13.34860]
```
 "thiserror 2.0.18",
```
Replacement in Cargo.lock at line 1559 [8.7249]
B:BD[5.27033] → [5.27033:27052]
```
version = "0.3.32"
```
[5.27033]
[5.27052]
```
version = "0.3.33"
```

Replacement in Cargo.lock at line 1561 [8.7249]

B:BD[5.27117] → [5.27117:27195]

checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"

[5.27117]

[5.27195]

checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"

Replacement in Cargo.lock at line 1605 [8.7249]
B:BD[5.27643] → [5.27643:27661]
```
version = "0.2.6"
```
[5.27643]
[5.27661]
```
version = "0.2.7"
```

Replacement in Cargo.lock at line 1607 [8.7249]

B:BD[5.27726] → [5.27726:27804]

checksum = "091397be61a01d4be58e7841595bd4bfedb15f1cd54977d79b8271e94ed799a3"

[5.27726]

[5.27804]

checksum = "c2a106d1259c23fac8e543272398ae0e3c0b8d33c88ed73d0cc71b0f1d902618"

Insertion in Cargo.lock at line 1631 [8.7249]

[5.28297]

[9.7959]

name = "predicates"
version = "3.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ada8f2932f28a27ee7b70dd6c1c39ea0675c55a36879ab92f3a715eaa1e63cfe"
dependencies = [
 "anstyle",
 "difflib",
 "float-cmp",
 "normalize-line-endings",
 "predicates-core",
 "regex",
]
[[package]]
name = "predicates-core"
version = "1.0.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cad38746f3166b4031b1a0d39ad9f954dd291e7854fcc0eed52ee41a0b50d144"
[[package]]
name = "predicates-tree"
version = "1.0.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d0de1b847b39c8131db0467e9df1ff60e6d0562ab8e9a16e568ad0fdb372e2f2"
dependencies = [
 "predicates-core",
 "termtree",
]
[[package]]

Replacement in Cargo.lock at line 1715 [8.7249]
B:BD[5.28806] → [5.28806:28824]
```
version = "0.8.5"
```
[5.28806]
[5.28824]
```
version = "0.8.6"
```

Replacement in Cargo.lock at line 1717 [8.7249]

B:BD[5.28889] → [5.28889:28967]

checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"

[5.28889]

[5.28967]

checksum = "5ca0ecfa931c29007047d1bc58e623ab12e5590e8c7cc53200d5202b69266d8a"

Replacement in Cargo.lock at line 1726 [8.7249]
B:BD[5.29064] → [5.29064:29082]
```
version = "0.9.2"
```
[5.29064]
[5.29082]
```
version = "0.9.4"
```

Replacement in Cargo.lock at line 1728 [8.7249]

B:BD[5.29147] → [5.29147:29225]

checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"

[5.29147]

[5.29225]

checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea"

Replacement in Cargo.lock at line 1802 [8.7249]
B:BD[11.18217] → [11.18217:18236]
```
version = "1.11.0"
```
[11.18217]
[11.18236]
```
version = "1.12.0"
```

Replacement in Cargo.lock at line 1804 [8.7249]

B:BD[11.18301] → [11.18301:18379]

checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"

[11.18301]

[11.18379]

checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"

Replacement in Cargo.lock at line 1835 [8.7249]
B:BD[5.31415] → [5.31415:31435]
```
 "bitflags 2.11.0",
```
[5.31415]
[11.18676]
```
 "bitflags 2.11.1",
```
Replacement in Cargo.lock at line 1840 [8.7249]
B:BD[5.31459] → [5.31459:31477]
```
version = "0.7.3"
```
[5.31459]
[5.31477]
```
version = "0.7.4"
```

Replacement in Cargo.lock at line 1842 [8.7249]

B:BD[5.31542] → [5.31542:31620]

checksum = "6ce70a74e890531977d37e532c34d45e9055d2409ed08ddba14529471ed0be16"

[5.31542]

[5.31620]

checksum = "f450ad9c3b1da563fb6948a8e0fb0fb9269711c9c73d9ea1de5058c79c8d643a"

Replacement in Cargo.lock at line 1844 [8.7249]
B:BD[5.31637] → [5.31637:31657]
```
 "bitflags 2.11.0",
```
[5.31637]
[5.31657]
```
 "bitflags 2.11.1",
```
Replacement in Cargo.lock at line 1944 [8.7249]
B:BD[5.33173] → [5.33173:33193]
```
 "bitflags 2.11.0",
```
[5.33173]
[5.33193]
```
 "bitflags 2.11.1",
```
Replacement in Cargo.lock at line 1957 [8.7249]
B:BD[9.8584] → [5.33263:33283]
```
 "bitflags 2.11.0",
```
[9.8584]
[9.8597]
```
 "bitflags 2.11.1",
```

Deletion in Cargo.lock at line 1987 [8.7249]

B:BD[5.33556] → [5.33556:33875]

version = "1.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "81aaf70d064e2122209f04d01fd91e8908e7a327b516236e1cbc0c3f34ac6d11"
dependencies = [
 "fs2",
 "log",
 "memmap2",
 "parking_lot 0.11.2",
 "sanakirja-core 1.4.1",
 "serde",
 "thiserror 1.0.69",
]
[[package]]
name = "sanakirja"

Replacement in Cargo.lock at line 1998 [8.7249]
B:BD[5.34148] → [5.34148:34178]
```
 "sanakirja-core 2.0.0-beta",
```
[5.34148]
[5.34178]
```
 "sanakirja-core",
```

Deletion in Cargo.lock at line 2002 [8.7249]

B:BD[5.34211] → [5.34211:34409]


[[package]]
name = "sanakirja-core"
version = "1.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8376db34ae3eac6e7bd91168bc638450073b708ce9fb46940de676f552238bf5"

Replacement in Cargo.lock at line 2020 [8.7249]
B:BD[9.8682] → [9.8682:8701]
```
version = "1.0.27"
```
[9.8682]
[9.8701]
```
version = "1.0.28"
```

Replacement in Cargo.lock at line 2022 [8.7249]

B:BD[9.8766] → [9.8766:8844]

checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"

[9.8766]

[9.8844]

checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"

Replacement in Cargo.lock at line 2165 [8.7249]
B:BD[5.37293] → [5.37293:37311]
```
version = "2.6.1"
```
[5.37293]
[5.37311]
```
version = "2.4.1"
```

Replacement in Cargo.lock at line 2167 [8.7249]

B:BD[5.37376] → [5.37376:37454]

checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"

[5.37376]

[5.37454]

checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601"

Insertion in Cargo.lock at line 2214 [8.7249]

[5.38028]

name = "termtree"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683"
[[package]]

Replacement in Cargo.lock at line 2302 [8.7249]
B:BD[5.39475] → [5.39475:39494]
```
version = "1.51.0"
```
[5.39475]
[5.39494]
```
version = "1.52.1"
```

Replacement in Cargo.lock at line 2304 [8.7249]

B:BD[5.39559] → [5.39559:39637]

checksum = "2bd1c4c0fc4a7ab90fc15ef6daaa3ec3b893f004f915f2392557ed23237820cd"

[5.39559]

[5.39637]

checksum = "b67dee974fe86fd92cc45b7a95fdd2f99a36a6d7b0d431a231178d3d670bbcc6"

Replacement in Cargo.lock at line 2329 [8.7249]
B:BD[5.40171] → [5.40171:40191]
```
 "indexmap 2.13.1",
```
[5.40171]
[5.40191]
```
 "indexmap 2.14.0",
```
Replacement in Cargo.lock at line 2342 [8.7249]
B:BD[5.40467] → [5.40467:40487]
```
 "indexmap 2.13.1",
```
[5.40467]
[5.40487]
```
 "indexmap 2.14.0",
```
Replacement in Cargo.lock at line 2364 [8.7249]
B:BD[5.40996] → [5.40996:41016]
```
 "indexmap 2.13.1",
```
[5.40996]
[5.41016]
```
 "indexmap 2.14.0",
```
Replacement in Cargo.lock at line 2377 [8.7249]
B:BD[5.41294] → [5.41294:41314]
```
 "indexmap 2.13.1",
```
[5.41294]
[5.41314]
```
 "indexmap 2.14.0",
```
Replacement in Cargo.lock at line 2412 [8.7249]
B:BD[5.42124] → [5.42124:42144]
```
 "bitflags 2.11.0",
```
[5.42124]
[5.42144]
```
 "bitflags 2.11.1",
```
Replacement in Cargo.lock at line 2468 [8.7249]
B:BD[5.43560] → [5.43560:43575]
```
 "rand 0.8.5",
```
[5.43560]
[5.43575]
```
 "rand 0.8.6",
```
Replacement in Cargo.lock at line 2474 [8.7249]
B:BD[5.43629] → [5.43629:43648]
```
version = "1.19.0"
```
[5.43629]
[5.43648]
```
version = "1.20.0"
```

Replacement in Cargo.lock at line 2476 [8.7249]

B:BD[5.43713] → [5.43713:43791]

checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"

[5.43713]

[5.43791]

checksum = "40ce102ab67701b8526c123c1bab5cbe42d7040ccfd0f64af1a385808d2f43de"

Replacement in Cargo.lock at line 2553 [8.7249]
B:BD[9.9366] → [9.9366:9395]
```
version = "1.0.2+wasi-0.2.9"
```
[9.9366]
[9.9395]
```
version = "1.0.3+wasi-0.2.9"
```

Replacement in Cargo.lock at line 2555 [8.7249]

B:BD[9.9460] → [9.9460:9538]

checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"

[9.9460]

[9.9538]

checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6"

Replacement in Cargo.lock at line 2557 [8.7249]
B:BD[9.9555] → [9.9555:9571]
```
 "wit-bindgen",
```
[9.9555]
[9.9571]
```
 "wit-bindgen 0.57.1",
```
Replacement in Cargo.lock at line 2566 [8.7249]
B:BD[9.9805] → [9.9805:9821]
```
 "wit-bindgen",
```
[9.9805]
[13.35139]
```
 "wit-bindgen 0.51.0",
```
Replacement in Cargo.lock at line 2577 [8.7249]
B:BD[11.21998] → [12.1064:1084]
```
version = "0.2.117"
```
[11.21998]
[11.22018]
```
version = "0.2.118"
```

Replacement in Cargo.lock at line 2579 [8.7249]

B:BD[11.22083] → [12.1085:1163]

checksum = "0551fc1bb415591e3372d0bc4780db7e587d84e2a7e79da121051c5c4b89d0b0"

[11.22083]

[11.22161]

checksum = "0bf938a0bacb0469e83c1e148908bd7d5a6010354cf4fb73279b7447422e3a89"

Replacement in Cargo.lock at line 2590 [8.7249]
B:BD[5.45540] → [5.45540:45559]
```
version = "0.4.67"
```
[5.45540]
[5.45559]
```
version = "0.4.68"
```

Replacement in Cargo.lock at line 2592 [8.7249]

B:BD[5.45624] → [5.45624:45702]

checksum = "03623de6905b7206edd0a75f69f747f134b7f0a2323392d664448bf2d3c5d87e"

[5.45624]

[5.45702]

checksum = "f371d383f2fb139252e0bfac3b81b265689bf45b6874af544ffa4c975ac1ebf8"

Replacement in Cargo.lock at line 2600 [8.7249]
B:BD[11.22309] → [12.1164:1184]
```
version = "0.2.117"
```
[11.22309]
[11.22329]
```
version = "0.2.118"
```

Replacement in Cargo.lock at line 2602 [8.7249]

B:BD[11.22394] → [12.1185:1263]

checksum = "7fbdf9a35adf44786aecd5ff89b4563a90325f9da0923236f6104e603c7e86be"

[11.22394]

[11.22472]

checksum = "eeff24f84126c0ec2db7a449f0c2ec963c6a49efe0698c4242929da037ca28ed"

Replacement in Cargo.lock at line 2610 [8.7249]
B:BD[11.22581] → [12.1264:1284]
```
version = "0.2.117"
```
[11.22581]
[11.22601]
```
version = "0.2.118"
```

Replacement in Cargo.lock at line 2612 [8.7249]

B:BD[11.22666] → [12.1285:1363]

checksum = "dca9693ef2bab6d4e6707234500350d8dad079eb508dca05530c85dc3a529ff2"

[11.22666]

[11.22744]

checksum = "9d08065faf983b2b80a79fd87d8254c409281cf7de75fc4b773019824196c904"

Replacement in Cargo.lock at line 2623 [8.7249]
B:BD[11.22875] → [12.1364:1384]
```
version = "0.2.117"
```
[11.22875]
[11.22895]
```
version = "0.2.118"
```

Replacement in Cargo.lock at line 2625 [8.7249]

B:BD[11.22960] → [12.1385:1463]

checksum = "39129a682a6d2d841b6c429d0c51e5cb0ed1a03829d8b3d1e69a011e62cb3d3b"

[11.22960]

[11.23038]

checksum = "5fd04d9e306f1907bd13c6361b5c6bfc7b3b3c095ed3f8a9246390f8dbdee129"

Replacement in Cargo.lock at line 2647 [8.7249]
B:BD[9.10282] → [5.45748:45768]
```
 "indexmap 2.13.1",
```
[9.10282]
[9.10295]
```
 "indexmap 2.14.0",
```
Replacement in Cargo.lock at line 2658 [8.7249]
B:BD[9.10542] → [5.45769:45789]
```
 "bitflags 2.11.0",
```
[9.10542]
[9.10555]
```
 "bitflags 2.11.1",
```
Replacement in Cargo.lock at line 2660 [8.7249]
B:BD[9.10576] → [5.45790:45810]
```
 "indexmap 2.13.1",
```
[9.10576]
[9.10589]
```
 "indexmap 2.14.0",
```
Replacement in Cargo.lock at line 2666 [8.7249]
B:BD[11.23105] → [12.1464:1483]
```
version = "0.3.94"
```
[11.23105]
[11.23124]
```
version = "0.3.95"
```

Replacement in Cargo.lock at line 2668 [8.7249]

B:BD[11.23189] → [12.1484:1562]

checksum = "cd70027e39b12f0849461e08ffc50b9cd7688d942c1c8e3c7b22273236b4dd0a"

[11.23189]

[11.23267]

checksum = "4f2dfbb17949fa2088e5d39408c48368947b86f7834484e87b73de55bc14d97d"

Insertion in Cargo.lock at line 2909 [8.7249]

[11.24681]

[9.10859]

name = "wit-bindgen"
version = "0.57.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
[[package]]

Replacement in Cargo.lock at line 2933 [8.7249]
B:BD[9.11339] → [5.51227:51247]
```
 "indexmap 2.13.1",
```
[9.11339]
[9.11352]
```
 "indexmap 2.14.0",
```
Replacement in Cargo.lock at line 2963 [8.7249]
B:BD[9.11993] → [5.51248:51288]
```
 "bitflags 2.11.0",
 "indexmap 2.13.1",
```
[9.11993]
[9.12019]
```
 "bitflags 2.11.1",
 "indexmap 2.14.0",
```
Replacement in Cargo.lock at line 2983 [8.7249]
B:BD[9.12373] → [5.51289:51309]
```
 "indexmap 2.13.1",
```
[9.12373]
[9.12386]
```
 "indexmap 2.14.0",
```
Replacement in Cargo.lock at line 3065 [8.7249]
B:BD[5.52612] → [5.52612:52630]
```
version = "1.8.2"
```
[5.52612]
[5.52630]
```
version = "1.3.0"
```

Replacement in Cargo.lock at line 3067 [8.7249]

B:BD[5.52695] → [5.52695:52773]

checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"

[5.52695]

[5.52773]

checksum = "4756f7db3f7b5574938c3eb1c117038b8e07f95ee6718c0efad4ac21508f1efd"

refactor/fixes: server.rs and router.rs added to better test server, PristineReader based on libpijul

Dependencies

In channels

Change contents

Replacement in tests/support/test_server.rs at line 1 [5.54483]

Replacement in tests/support/test_server.rs at line 8 [5.54483]

Deletion in tests/support/test_server.rs at line 13 [5.54483]

Insertion in tests/support/test_server.rs at line 17 [5.54483]

Replacement in tests/support/test_server.rs at line 21 [5.54483]

Replacement in tests/support/test_server.rs at line 23 [5.54483]

Replacement in tests/support/test_server.rs at line 27 [5.54483]

Replacement in tests/support/test_server.rs at line 32 [5.54483]

Replacement in tests/support/test_server.rs at line 38 [5.54483]

Replacement in tests/support/test_server.rs at line 40 [5.54483]

Replacement in tests/support/test_server.rs at line 44 [5.54483]

Replacement in tests/support/test_server.rs at line 56 [5.54483]

Insertion in tests/support/repo_fixture.rs at line 5 [5.55741]

Deletion in tests/support/repo_fixture.rs at line 44 [5.55741]

Replacement in tests/support/repo_fixture.rs at line 114 [5.55741]

Insertion in tests/support/repo_fixture.rs at line 117 [5.55741]

File addition: pijul_env.rs (----------)

Insertion in tests/support/mod.rs at line 1 [5.59826]

Insertion in tests/support/mod.rs at line 5 [5.59826]

Replacement in tests/e2e.rs at line 6 [5.60527]

Insertion in tests/e2e.rs at line 8 [5.60527]

Insertion in tests/e2e.rs at line 13 [5.60527]

Replacement in tests/e2e.rs at line 20 [5.60527]

Replacement in tests/e2e.rs at line 22 [5.60527]

Insertion in tests/e2e.rs at line 43 [5.60527]

Insertion in tests/e2e.rs at line 49 [5.60527]

Replacement in tests/e2e.rs at line 65 [5.60527]

Insertion in tests/e2e.rs at line 72 [5.60527]

Insertion in tests/e2e.rs at line 172 [5.60527]

Insertion in src/url.rs at line 8 [7.31]

Replacement in src/url.rs at line 11 [7.31]

Replacement in src/url.rs at line 26 [7.31]

Insertion in src/url.rs at line 34 [7.31]

Insertion in src/url.rs at line 38 [7.31]

Deletion in src/url.rs at line 54 [7.31]

Insertion in src/url.rs at line 60 [7.31]

Replacement in src/url.rs at line 62 [7.31]

Replacement in src/url.rs at line 73 [7.31]

Replacement in src/url.rs at line 82 [7.31]

Insertion in src/url.rs at line 112 [7.31]

Deletion in src/url.rs at line 164 [7.31]

Replacement in src/url.rs at line 168 [7.31]

Replacement in src/url.rs at line 202 [7.31]

Replacement in src/url.rs at line 209 [7.31]

Replacement in src/url.rs at line 225 [7.31]

Replacement in src/url.rs at line 234 [7.31]

Replacement in src/url.rs at line 245 [7.31]

Replacement in src/url.rs at line 256 [7.31]

Replacement in src/url.rs at line 268 [7.31]

Replacement in src/url.rs at line 279 [7.31]

Replacement in src/url.rs at line 290 [7.31]

Replacement in src/url.rs at line 302 [7.31]

Insertion in src/url.rs at line 312 [7.31]

Replacement in src/url.rs at line 323 [7.31]

File addition: server.rs (----------)

File addition: router.rs (----------)

Replacement in src/responses.rs at line 15 [9.37]

Replacement in src/responses.rs at line 17 [9.37]

Insertion in src/responses.rs at line 26 [9.37]

Replacement in src/responses.rs at line 31 [9.37]

Insertion in src/responses.rs at line 33 [9.37]

Replacement in src/responses.rs at line 43 [9.37]

Replacement in src/responses.rs at line 48 [9.37]

Replacement in src/responses.rs at line 56 [9.37]

Replacement in src/responses.rs at line 66 [9.37]

Replacement in src/responses.rs at line 70 [9.37]

Replacement in src/responses.rs at line 114 [9.37]

Replacement in src/pristine.rs at line 1 [10.36]

Replacement in src/pristine.rs at line 3 [10.36]

Replacement in src/pristine.rs at line 24 [10.36]

Replacement in src/pristine.rs at line 29 [10.36]

Replacement in src/pristine.rs at line 31 [10.36]

Insertion in src/pristine.rs at line 36 [10.36]

Replacement in src/pristine.rs at line 43 [10.36]

Replacement in src/pristine.rs at line 90 [10.36]

Replacement in src/pristine.rs at line 123 [10.36]