Chasesomero/pijul - Change 4USQK3IWRHVI67CTRX2WDEDEYDBB3BADVECKNAX3XNCEPTQS5MDQC

Big rename: libpijul => pijul-core, to match all other crates in the ecosystem

Created by berkus on February 16, 2026

4USQK3IWRHVI67CTRX2WDEDEYDBB3BADVECKNAX3XNCEPTQS5MDQC

Dependencies

In channels

main

Change contents

Deletion in pijul-repository/src/lib.rs at line 8 [2.21431]
∅:D[232.28] → [4.0:23]
∅:D[25.7684] → [4.0:23]
B:BD[2.21541] → [4.0:23]
```
use libpijul::DOT_DIR;
```
Insertion in pijul-repository/src/lib.rs at line 10 [2.21431]
[234.32]
[4.39]
```
use pijul_core::DOT_DIR;
```

Replacement in pijul-repository/src/lib.rs at line 13 [2.21431]

∅:D[44.921] → [2.21565:21688]

B:BD[2.21565] → [2.21565:21688]

B:BD[2.21688] → [83.0:70]

    pub pristine: libpijul::pristine::sanakirja::Pristine,
    pub changes: libpijul::changestore::filesystem::FileSystem,
    pub working_copy: libpijul::working_copy::filesystem::FileSystem,

[2.21565]

[2.21790]

    pub pristine: pijul_core::pristine::sanakirja::Pristine,
    pub changes: pijul_core::changestore::filesystem::FileSystem,
    pub working_copy: pijul_core::working_copy::filesystem::FileSystem,

Replacement in pijul-repository/src/lib.rs at line 81 [2.21431]

∅:D[232.1216] → [45.5811:5906]

B:BD[2.23883] → [45.5811:5906]

B:BD[45.5906] → [83.71:156]

            pristine: libpijul::pristine::sanakirja::Pristine::new(&pristine_dir.join("db"))?,
            working_copy: libpijul::working_copy::filesystem::FileSystem::from_root(

[232.1216]

[232.1217]

            pristine: pijul_core::pristine::sanakirja::Pristine::new(&pristine_dir.join("db"))?,
            working_copy: pijul_core::working_copy::filesystem::FileSystem::from_root(

Replacement in pijul-repository/src/lib.rs at line 85 [2.21431]

B:BD[83.172] → [93.307:386]

            changes: libpijul::changestore::filesystem::FileSystem::from_root(

[83.172]

[232.1259]

            changes: pijul_core::changestore::filesystem::FileSystem::from_root(

Replacement in pijul-repository/src/lib.rs at line 130 [2.21431]

B:BD[2.24885] → [45.5907:6006]

B:BD[45.6006] → [83.173:268]

B:BD[83.268] → [93.485:568]

                pristine: libpijul::pristine::sanakirja::Pristine::new(&pristine_dir.join("db"))?,
                working_copy: libpijul::working_copy::filesystem::FileSystem::from_root(&cur),
                changes: libpijul::changestore::filesystem::FileSystem::from_root(

[2.24885]

[93.568]

                pristine: pijul_core::pristine::sanakirja::Pristine::new(&pristine_dir.join("db"))?,
                working_copy: pijul_core::working_copy::filesystem::FileSystem::from_root(&cur),
                changes: pijul_core::changestore::filesystem::FileSystem::from_root(

Replacement in pijul-repository/Cargo.toml at line 11 [176.700]
B:BD[176.1015] → [193.0:26]
```
libpijul.workspace = true
```
[176.1015]
[193.26]
```
pijul-core.workspace = true
```
Deletion in pijul-remote/src/ssh.rs at line 11 [2.25380]
B:BD[4.156] → [23.32:66]
B:BD[23.66] → [78.0:38]
```
use libpijul::pristine::Position;
use libpijul::{Base32, Hash, Merkle};
```

Insertion in pijul-remote/src/ssh.rs at line 12 [2.25380]

[148.44]

[4.276]

use pijul_core::pristine::Position;
use pijul_core::{Base32, Hash, Merkle};

Replacement in pijul-remote/src/ssh.rs at line 345 [2.25380]

B:BD[75.589] → [75.589:681]

        sender: Option<tokio::sync::oneshot::Sender<Option<libpijul::pristine::RemoteId>>>,

[75.589]

[75.681]

        sender: Option<tokio::sync::oneshot::Sender<Option<pijul_core::pristine::RemoteId>>>,

Replacement in pijul-remote/src/ssh.rs at line 368 [2.25380]
B:BD[75.701] → [75.701:735]
```
        key: libpijul::key::SKey,
```
[75.701]
[75.735]
```
        key: pijul_core::key::SKey,
```

Replacement in pijul-remote/src/ssh.rs at line 517 [2.25380]

∅:D[78.201] → [75.1373:1468]

B:BD[75.1373] → [75.1373:1468]

                            libpijul::pristine::RemoteId::from_base32(&data[..data.len() - 1])

[78.201]

[75.1468]

                            pijul_core::pristine::RemoteId::from_base32(&data[..data.len() - 1])

Replacement in pijul-remote/src/ssh.rs at line 557 [2.25380]

B:BD[125.692] → [125.692:793]

                                    libpijul::changestore::filesystem::push_filename(final_path, h);

[125.692]

[125.793]

                                    pijul_core::changestore::filesystem::push_filename(
                                        final_path, h,
                                    );

Replacement in pijul-remote/src/ssh.rs at line 563 [2.25380]

B:BD[125.1052] → [125.1052:1149]

                                    libpijul::changestore::filesystem::pop_filename(final_path);

[125.1052]

[125.1149]

                                    pijul_core::changestore::filesystem::pop_filename(final_path);

Replacement in pijul-remote/src/ssh.rs at line 567 [2.25380]

B:BD[125.1273] → [125.1273:1363]

                                    libpijul::changestore::filesystem::push_tag_filename(

[125.1273]

[125.1363]

                                    pijul_core::changestore::filesystem::push_tag_filename(

Replacement in pijul-remote/src/ssh.rs at line 573 [2.25380]

B:BD[125.1717] → [125.1717:1814]

                                    libpijul::changestore::filesystem::pop_filename(final_path);

[125.1717]

[125.1814]

                                    pijul_core::changestore::filesystem::pop_filename(final_path);

Replacement in pijul-remote/src/ssh.rs at line 799 [2.25380]

B:BD[2.37998] → [92.0:100]

    pub async fn get_id(&mut self) -> Result<Option<libpijul::pristine::RemoteId>, anyhow::Error> {

[2.37998]

[75.4027]

    pub async fn get_id(
        &mut self,
    ) -> Result<Option<pijul_core::pristine::RemoteId>, anyhow::Error> {

Replacement in pijul-remote/src/ssh.rs at line 813 [2.25380]

B:BD[75.4355] → [75.4355:4446]

    pub async fn prove(&mut self, key: libpijul::key::SKey) -> Result<(), anyhow::Error> {

[75.4355]

[75.4446]

    pub async fn prove(&mut self, key: pijul_core::key::SKey) -> Result<(), anyhow::Error> {

Replacement in pijul-remote/src/ssh.rs at line 908 [2.25380]

B:BD[78.251] → [122.0:90]

        F: FnMut(&mut A, u64, Hash, libpijul::Merkle, bool) -> Result<(), anyhow::Error>,

[78.251]

[78.335]

        F: FnMut(&mut A, u64, Hash, pijul_core::Merkle, bool) -> Result<(), anyhow::Error>,

Replacement in pijul-remote/src/ssh.rs at line 968 [2.25380]

B:BD[125.2148] → [125.2148:2234]

                    libpijul::changestore::filesystem::push_filename(&mut local, &c);

[125.2148]

[125.2234]

                    pijul_core::changestore::filesystem::push_filename(&mut local, &c);

Replacement in pijul-remote/src/ssh.rs at line 981 [2.25380]

B:BD[125.2875] → [125.2875:2956]

                    libpijul::changestore::filesystem::pop_filename(&mut local);

[125.2875]

[125.2956]

                    pijul_core::changestore::filesystem::pop_filename(&mut local);

Replacement in pijul-remote/src/ssh.rs at line 984 [2.25380]

B:BD[125.3008] → [125.3008:3184]

                    libpijul::changestore::filesystem::push_tag_filename(&mut local, &c);
                    let mut tag_file = libpijul::tag::OpenTagFile::open(&local, &c)?;

[125.3008]

[125.3184]

                    pijul_core::changestore::filesystem::push_tag_filename(&mut local, &c);
                    let mut tag_file = pijul_core::tag::OpenTagFile::open(&local, &c)?;

Replacement in pijul-remote/src/ssh.rs at line 995 [2.25380]

B:BD[125.3575] → [125.3575:3656]

                    libpijul::changestore::filesystem::pop_filename(&mut local);

[125.3575]

[125.3656]

                    pijul_core::changestore::filesystem::pop_filename(&mut local);

Deletion in pijul-remote/src/local.rs at line 6 [2.79745]
∅:D[72.425] → [25.9780:9862]
B:BD[4.535] → [25.9780:9862]
```
use libpijul::pristine::{Hash, Merkle, MutTxnT, Position, TxnT};
use libpijul::*;
```

Insertion in pijul-remote/src/local.rs at line 7 [2.79745]

[4.552]

[125.20382]

use pijul_core::pristine::{Hash, Merkle, MutTxnT, Position, TxnT};
use pijul_core::*;

Replacement in pijul-remote/src/local.rs at line 18 [2.79745]

B:BD[2.80020] → [6.11626:11690]

    pub pristine: Arc<libpijul::pristine::sanakirja::Pristine>,

[2.80020]

[2.80079]

    pub pristine: Arc<pijul_core::pristine::sanakirja::Pristine>,

Replacement in pijul-remote/src/local.rs at line 24 [2.79745]

B:BD[3.3035] → [3.3035:3084]

    channel: &libpijul::pristine::ChannelRef<T>,

[3.3035]

[3.3084]

    channel: &pijul_core::pristine::ChannelRef<T>,

Replacement in pijul-remote/src/local.rs at line 53 [2.79745]

B:BD[2.80605] → [88.565:647]

    pub fn get_id(&self) -> Result<libpijul::pristine::RemoteId, anyhow::Error> {

[2.80605]

[75.8700]

    pub fn get_id(&self) -> Result<pijul_core::pristine::RemoteId, anyhow::Error> {

Replacement in pijul-remote/src/local.rs at line 91 [2.79745]

B:BD[191.149] → [191.149:246]

        T: libpijul::ChannelTxnT + libpijul::TxnTExt + libpijul::DepsTxnT + libpijul::GraphTxnT,

[191.149]

[191.246]

        T: pijul_core::ChannelTxnT
            + pijul_core::TxnTExt
            + pijul_core::DepsTxnT
            + pijul_core::GraphTxnT,

Replacement in pijul-remote/src/local.rs at line 105 [2.79745]

B:BD[191.556] → [191.556:634]

        let store = libpijul::changestore::filesystem::FileSystem::from_root(

[191.556]

[191.634]

        let store = pijul_core::changestore::filesystem::FileSystem::from_root(

Replacement in pijul-remote/src/local.rs at line 116 [2.79745]

B:BD[188.52] → [191.714:772]

                    libpijul::fs::iter_graph_descendants(

[188.52]

[191.772]

                    pijul_core::fs::iter_graph_descendants(

Replacement in pijul-remote/src/local.rs at line 220 [2.79745]

B:BD[2.82268] → [93.1182:1260]

        let store = libpijul::changestore::filesystem::FileSystem::from_root(

[2.82268]

[93.1260]

        let store = pijul_core::changestore::filesystem::FileSystem::from_root(

Replacement in pijul-remote/src/local.rs at line 231 [2.79745]

B:BD[125.21611] → [125.21611:21794]

                    libpijul::changestore::filesystem::push_filename(&mut local, &c);
                    libpijul::changestore::filesystem::push_filename(&mut self.changes_dir, &c);

[125.21611]

[125.21794]

                    pijul_core::changestore::filesystem::push_filename(&mut local, &c);
                    pijul_core::changestore::filesystem::push_filename(&mut self.changes_dir, &c);

Replacement in pijul-remote/src/local.rs at line 235 [2.79745]

B:BD[125.21846] → [125.21846:22037]

                    libpijul::changestore::filesystem::push_tag_filename(&mut local, &c);
                    libpijul::changestore::filesystem::push_tag_filename(&mut self.changes_dir, &c);

[125.21846]

[125.22037]

                    pijul_core::changestore::filesystem::push_tag_filename(&mut local, &c);
                    pijul_core::changestore::filesystem::push_tag_filename(
                        &mut self.changes_dir,
                        &c,
                    );

Replacement in pijul-remote/src/local.rs at line 250 [2.79745]

B:BD[125.22108] → [125.22108:22265]

            libpijul::changestore::filesystem::pop_filename(&mut local);
            libpijul::changestore::filesystem::pop_filename(&mut self.changes_dir);

[125.22108]

[2.83218]

            pijul_core::changestore::filesystem::pop_filename(&mut local);
            pijul_core::changestore::filesystem::pop_filename(&mut self.changes_dir);

Replacement in pijul-remote/src/local.rs at line 253 [2.79745]

B:BD[2.83228] → [53.1034:1124]

        let repo = libpijul::working_copy::filesystem::FileSystem::from_root(&self.root);

[2.83228]

[172.3460]

        let repo = pijul_core::working_copy::filesystem::FileSystem::from_root(&self.root);

Replacement in pijul-remote/src/local.rs at line 255 [2.79745]
∅:D[87.910] → [53.1204:1260]
∅:D[83.1424] → [53.1204:1260]
∅:D[172.3545] → [53.1204:1260]
B:BD[53.1204] → [53.1204:1260]
```
        libpijul::output::output_repository_no_pending(
```
[172.3545]
[83.1425]
```
        pijul_core::output::output_repository_no_pending(
```

Replacement in pijul-remote/src/local.rs at line 280 [2.79745]

B:BD[130.658] → [130.658:840]

                    libpijul::changestore::filesystem::push_filename(&mut self.changes_dir, &c);
                    libpijul::changestore::filesystem::push_filename(&mut path, &c);

[130.658]

[125.22880]

                    pijul_core::changestore::filesystem::push_filename(&mut self.changes_dir, &c);
                    pijul_core::changestore::filesystem::push_filename(&mut path, &c);

Replacement in pijul-remote/src/local.rs at line 284 [2.79745]

B:BD[130.875] → [130.875:1065]

                    libpijul::changestore::filesystem::push_tag_filename(&mut self.changes_dir, &c);
                    libpijul::changestore::filesystem::push_tag_filename(&mut path, &c);

[130.875]

[125.23102]

                    pijul_core::changestore::filesystem::push_tag_filename(
                        &mut self.changes_dir,
                        &c,
                    );
                    pijul_core::changestore::filesystem::push_tag_filename(&mut path, &c);

Replacement in pijul-remote/src/local.rs at line 295 [2.79745]

B:BD[130.1245] → [191.3316:3404]

∅:D[130.1245] → [6.12157:12233]

∅:D[191.3404] → [6.12157:12233]

∅:D[125.23250] → [6.12157:12233]

B:BD[6.12157] → [6.12157:12233]

                libpijul::changestore::filesystem::pop_filename(&mut self.changes_dir);
                libpijul::changestore::filesystem::pop_filename(&mut path);

[130.1245]

[191.3405]

                pijul_core::changestore::filesystem::pop_filename(&mut self.changes_dir);
                pijul_core::changestore::filesystem::pop_filename(&mut path);

Replacement in pijul-remote/src/local.rs at line 304 [2.79745]

B:BD[130.1517] → [130.1517:1673]

            libpijul::changestore::filesystem::pop_filename(&mut self.changes_dir);
            libpijul::changestore::filesystem::pop_filename(&mut path);

[6.12478]

[153.1510]

            pijul_core::changestore::filesystem::pop_filename(&mut self.changes_dir);
            pijul_core::changestore::filesystem::pop_filename(&mut path);

Replacement in pijul-remote/src/local.rs at line 347 [2.79745]

B:BD[3.3753] → [116.5007:5094]

pub fn upload_changes<T: MutTxnTExt + 'static, C: libpijul::changestore::ChangeStore>(

[3.3753]

[172.3617]

pub fn upload_changes<T: MutTxnTExt + 'static, C: pijul_core::changestore::ChangeStore>(

Replacement in pijul-remote/src/local.rs at line 351 [2.79745]
B:BD[3.3935] → [54.345:394]
```
    channel: &libpijul::pristine::ChannelRef<T>,
```
[3.3935]
[125.23251]
```
    channel: &pijul_core::pristine::ChannelRef<T>,
```

Replacement in pijul-remote/src/local.rs at line 354 [2.79745]

B:BD[3.4043] → [3.4043:4093]

    let mut ws = libpijul::ApplyWorkspace::new();

[3.4043]

[83.1486]

    let mut ws = pijul_core::ApplyWorkspace::new();

Replacement in pijul-remote/src/lib.rs at line 7 [2.52474]
B:BD[19.393] → [194.707:730]
∅:D[194.730] → [89.0:26]
B:BD[19.393] → [89.0:26]
```
use libpijul::DOT_DIR;
use libpijul::pristine::{
```
[194.706]
[196.488]
```
use log::{debug, info};
use pijul_core::DOT_DIR;
use pijul_core::pristine::{
```

Replacement in pijul-remote/src/lib.rs at line 13 [2.52474]

B:BD[2.52622] → [89.138:209]

∅:D[89.209] → [9.549:573]

B:BD[2.52659] → [9.549:573]

use libpijul::{ChannelTxnT, DepsTxnT, GraphTxnT, MutTxnTExt, TxnTExt};
use log::{debug, info};

[89.137]

[196.623]

use pijul_core::{ChannelTxnT, DepsTxnT, GraphTxnT, MutTxnTExt, TxnTExt};

Replacement in pijul-remote/src/lib.rs at line 98 [2.52474]
B:BD[233.1721] → [233.1721:1756]
```
        libpijul::DEFAULT_CHANNEL,
```
[233.1721]
[233.1756]
```
        pijul_core::DEFAULT_CHANNEL,
```

Replacement in pijul-remote/src/lib.rs at line 237 [2.52474]

B:BD[2.54479] → [108.669:751]

        match libpijul::pristine::sanakirja::Pristine::new(&dot_dir.join("db")) {

[2.54479]

[108.751]

        match pijul_core::pristine::sanakirja::Pristine::new(&dot_dir.join("db")) {

Replacement in pijul-remote/src/lib.rs at line 248 [2.52474]

B:BD[108.1143] → [108.1143:1217]

            Err(libpijul::pristine::sanakirja::SanakirjaError::Sanakirja(

[108.1143]

[108.1217]

            Err(pijul_core::pristine::sanakirja::SanakirjaError::Sanakirja(

Replacement in pijul-remote/src/lib.rs at line 280 [2.52474]

B:BD[89.739] → [106.0:96]

            libpijul::fs::iter_graph_descendants(txn, &channel.read(), p)?.map(|x| x.unwrap()),

[89.739]

[89.858]

            pijul_core::fs::iter_graph_descendants(txn, &channel.read(), p)?.map(|x| x.unwrap()),

Replacement in pijul-remote/src/lib.rs at line 520 [2.52474]

B:BD[89.8641] → [89.8641:8717]

        inodes.extend(inodes_.iter().map(|x| libpijul::pristine::Position {

[89.8641]

[89.8717]

        inodes.extend(inodes_.iter().map(|x| pijul_core::pristine::Position {

Replacement in pijul-remote/src/lib.rs at line 595 [2.52474]

B:BD[2.56131] → [39.899:977]

                if let Some(name) = libpijul::path::file_name(h.url.path()) {

[2.56131]

[39.977]

                if let Some(name) = pijul_core::path::file_name(h.url.path()) {

Replacement in pijul-remote/src/lib.rs at line 748 [2.52474]

B:BD[89.12028] → [89.12028:12099]

                    (k, libpijul::pristine::Pair { a: hash, .. }) => {

[89.12028]

[89.12099]

                    (k, pijul_core::pristine::Pair { a: hash, .. }) => {

Replacement in pijul-remote/src/lib.rs at line 792 [2.52474]
B:BD[89.13637] → [125.11788:11830]
```
            use libpijul::ChannelMutTxnT;
```
[89.13637]
[125.11830]
```
            use pijul_core::ChannelMutTxnT;
```

Replacement in pijul-remote/src/lib.rs at line 893 [2.52474]

B:BD[125.14012] → [125.14012:14062]

                    use libpijul::ChannelMutTxnT;

[125.14012]

[125.14062]

                    use pijul_core::ChannelMutTxnT;

Replacement in pijul-remote/src/lib.rs at line 942 [2.52474]

B:BD[2.57606] → [125.14394:14442]

        remote: &libpijul::pristine::Remote<T>,

[2.57606]

[2.57634]

        remote: &pijul_core::pristine::Remote<T>,

Replacement in pijul-remote/src/lib.rs at line 1005 [2.52474]
B:BD[2.59045] → [3.1861:1907]
```
    async fn get_state<T: libpijul::TxnTExt>(
```
[2.59045]
[2.59069]
```
    async fn get_state<T: pijul_core::TxnTExt>(
```

Replacement in pijul-remote/src/lib.rs at line 1028 [2.52474]

B:BD[92.1242] → [116.4478:4531]

    async fn get_id<T: libpijul::TxnTExt + 'static>(

[92.1242]

[75.6694]

    async fn get_id<T: pijul_core::TxnTExt + 'static>(

Replacement in pijul-remote/src/lib.rs at line 1031 [2.52474]

B:BD[75.6730] → [92.1243:1314]

    ) -> Result<Option<libpijul::pristine::RemoteId>, anyhow::Error> {

[75.6730]

[75.6801]

    ) -> Result<Option<pijul_core::pristine::RemoteId>, anyhow::Error> {

Replacement in pijul-remote/src/lib.rs at line 1059 [2.52474]

B:BD[2.61025] → [93.647:735]

                let changes = libpijul::changestore::filesystem::FileSystem::from_root(

[2.61025]

[93.735]

                let changes = pijul_core::changestore::filesystem::FileSystem::from_root(

Replacement in pijul-remote/src/lib.rs at line 1064 [2.52474]

∅:D[223.35] → [222.39:127]

B:BD[222.39] → [222.39:127]

∅:D[222.127] → [52.21:105]

∅:D[93.835] → [52.21:105]

B:BD[2.61122] → [52.21:105]

                    libpijul::working_copy::filesystem::FileSystem::from_root(&l.root);
                let mut tarball = libpijul::output::Tarball::new(w, prefix, umask);

[223.35]

[2.61199]

                    pijul_core::working_copy::filesystem::FileSystem::from_root(&l.root);
                let mut tarball = pijul_core::output::Tarball::new(w, prefix, umask);

Replacement in pijul-remote/src/lib.rs at line 1087 [2.52474]

B:BD[134.551] → [223.76:165]

                    txn.archive::<_, _, libpijul::working_copy::filesystem::FileSystem>(

[134.551]

[223.165]

                    txn.archive::<_, _, pijul_core::working_copy::filesystem::FileSystem>(

Replacement in pijul-remote/src/lib.rs at line 1155 [2.52474]

B:BD[3.2569] → [93.836:925]

                let store = libpijul::changestore::filesystem::FileSystem::from_changes(

[3.2569]

[93.925]

                let store = pijul_core::changestore::filesystem::FileSystem::from_changes(

Replacement in pijul-remote/src/lib.rs at line 1219 [2.52474]

B:BD[2.68736] → [158.228:319]

    pub async fn prove(&mut self, key: libpijul::key::SKey) -> Result<(), anyhow::Error> {

[2.68736]

[158.319]

    pub async fn prove(&mut self, key: pijul_core::key::SKey) -> Result<(), anyhow::Error> {

Replacement in pijul-remote/src/lib.rs at line 1276 [2.52474]

B:BD[130.57] → [130.57:149]

                    libpijul::changestore::filesystem::push_filename(&mut change_path_, h);

[130.57]

[130.149]

                    pijul_core::changestore::filesystem::push_filename(&mut change_path_, h);

Replacement in pijul-remote/src/lib.rs at line 1279 [2.52474]

B:BD[130.201] → [130.201:297]

                    libpijul::changestore::filesystem::push_tag_filename(&mut change_path_, h);

[130.201]

[125.16450]

                    pijul_core::changestore::filesystem::push_tag_filename(&mut change_path_, h);

Replacement in pijul-remote/src/lib.rs at line 1285 [2.52474]

∅:D[157.178] → [130.449:529]

B:BD[20.454] → [130.449:529]

            libpijul::changestore::filesystem::pop_filename(&mut change_path_);

[157.178]

[20.534]

            pijul_core::changestore::filesystem::pop_filename(&mut change_path_);

Replacement in pijul-remote/src/lib.rs at line 1300 [2.52474]

B:BD[2.69755] → [2.69755:69809]

        let mut ws = libpijul::ApplyWorkspace::new();

[12.1]

[166.0]

        let mut ws = pijul_core::ApplyWorkspace::new();

Replacement in pijul-remote/src/lib.rs at line 1307 [2.52474]

B:BD[23.1581] → [23.1581:1641]

                    use libpijul::changestore::ChangeStore;

[23.1581]

[155.312]

                    use pijul_core::changestore::ChangeStore;

Replacement in pijul-remote/src/lib.rs at line 1382 [2.52474]

B:BD[155.1702] → [155.1702:1766]

                        use libpijul::changestore::ChangeStore;

[155.1522]

[155.1766]

                        use pijul_core::changestore::ChangeStore;

Replacement in pijul-remote/src/lib.rs at line 1385 [2.52474]

B:BD[155.1887] → [155.1887:1956]

                            let dep: libpijul::pristine::Hash = dep;

[155.1887]

[155.1956]

                            let dep: pijul_core::pristine::Hash = dep;

Replacement in pijul-remote/src/lib.rs at line 1387 [2.52474]

B:BD[155.1957] → [155.1957:2056]

                            libpijul::changestore::filesystem::push_filename(&mut dep_path, &dep);

[155.1957]

[155.2056]

                            pijul_core::changestore::filesystem::push_filename(&mut dep_path, &dep);

Replacement in pijul-remote/src/lib.rs at line 1389 [2.52474]

B:BD[155.2136] → [155.2136:2228]

                            libpijul::changestore::filesystem::pop_filename(&mut dep_path);

[155.2136]

[2.70880]

                            pijul_core::changestore::filesystem::pop_filename(&mut dep_path);

Replacement in pijul-remote/src/lib.rs at line 1474 [2.52474]

B:BD[2.72752] → [2.72752:72806]

        let mut ws = libpijul::ApplyWorkspace::new();

[2.72116]

[54.140]

        let mut ws = pijul_core::ApplyWorkspace::new();

Replacement in pijul-remote/src/lib.rs at line 1538 [2.52474]
∅:D[48.2107] → [2.75038:75086]
B:BD[2.75038] → [2.75038:75086]
```
        use libpijul::changestore::ChangeStore;
```
[48.2107]
[49.4141]
```
        use pijul_core::changestore::ChangeStore;
```

Replacement in pijul-remote/src/lib.rs at line 1583 [2.52474]

B:BD[2.76665] → [2.76665:76714]

            let v = libpijul::pristine::Vertex {

[2.76665]

[2.76714]

            let v = pijul_core::pristine::Vertex {

Replacement in pijul-remote/src/lib.rs at line 1585 [2.52474]

B:BD[2.76738] → [45.8172:8314]

                start: libpijul::pristine::ChangePosition(0u64.into()),
                end: libpijul::pristine::ChangePosition(0u64.into()),

[2.76738]

[2.76860]

                start: pijul_core::pristine::ChangePosition(0u64.into()),
                end: pijul_core::pristine::ChangePosition(0u64.into()),

Deletion in pijul-remote/src/http.rs at line 2 [238.10]
B:BD[78.2254] → [78.2254:2274]
B:BD[78.2274] → [194.1280:1324]
```
use libpijul::Hash;
use libpijul::pristine::{Base32, Position};
```
Insertion in pijul-remote/src/http.rs at line 3 [238.10]
[82.32]
[143.1881]
```
use pijul_core::Hash;
use pijul_core::pristine::{Base32, Position};
```

Replacement in pijul-remote/src/http.rs at line 31 [238.10]

B:BD[125.24055] → [125.24055:24132]

            libpijul::changestore::filesystem::push_filename(&mut path, &c);

[125.24055]

[125.24132]

            pijul_core::changestore::filesystem::push_filename(&mut path, &c);

Replacement in pijul-remote/src/http.rs at line 35 [238.10]

B:BD[125.24206] → [125.24206:24287]

            libpijul::changestore::filesystem::push_tag_filename(&mut path, &c);

[125.24206]

[125.24287]

            pijul_core::changestore::filesystem::push_tag_filename(&mut path, &c);

Replacement in pijul-remote/src/http.rs at line 249 [238.10]

B:BD[125.24954] → [125.24954:25040]

                    libpijul::changestore::filesystem::push_filename(&mut local, &c);

[125.24954]

[125.25040]

                    pijul_core::changestore::filesystem::push_filename(&mut local, &c);

Replacement in pijul-remote/src/http.rs at line 256 [238.10]

B:BD[125.25277] → [125.25277:25453]

                    libpijul::changestore::filesystem::push_tag_filename(&mut local, &c);
                    let mut tag_file = libpijul::tag::OpenTagFile::open(&local, &c)?;

[125.25277]

[125.25453]

                    pijul_core::changestore::filesystem::push_tag_filename(&mut local, &c);
                    let mut tag_file = pijul_core::tag::OpenTagFile::open(&local, &c)?;

Replacement in pijul-remote/src/http.rs at line 265 [238.10]

B:BD[125.25698] → [125.25698:25771]

            libpijul::changestore::filesystem::pop_filename(&mut local);

[125.25698]

[10.1585]

            pijul_core::changestore::filesystem::pop_filename(&mut local);

Replacement in pijul-remote/src/http.rs at line 297 [238.10]

B:BD[78.2324] → [122.2979:3069]

        F: FnMut(&mut A, u64, Hash, libpijul::Merkle, bool) -> Result<(), anyhow::Error>,

[78.2324]

[78.2408]

        F: FnMut(&mut A, u64, Hash, pijul_core::Merkle, bool) -> Result<(), anyhow::Error>,

Replacement in pijul-remote/src/http.rs at line 332 [238.10]

B:BD[69.69] → [69.69:159]

            match serde_json::from_slice::<libpijul::RemoteError>(&*res.bytes().await?) {

[69.69]

[69.159]

            match serde_json::from_slice::<pijul_core::RemoteError>(&*res.bytes().await?) {

Replacement in pijul-remote/src/http.rs at line 368 [238.10]

B:BD[28.242] → [125.25891:25975]

    ) -> Result<Option<(u64, libpijul::Merkle, libpijul::Merkle)>, anyhow::Error> {

[28.242]

[28.308]

    ) -> Result<Option<(u64, pijul_core::Merkle, pijul_core::Merkle)>, anyhow::Error> {

Replacement in pijul-remote/src/http.rs at line 399 [238.10]

B:BD[28.1138] → [28.1138:1214]

                .and_then(|m| libpijul::Merkle::from_base32(m.as_bytes())),

[28.1138]

[125.26025]

                .and_then(|m| pijul_core::Merkle::from_base32(m.as_bytes())),

Replacement in pijul-remote/src/http.rs at line 401 [238.10]

B:BD[125.26046] → [125.26046:26122]

                .and_then(|m| libpijul::Merkle::from_base32(m.as_bytes())),

[125.26046]

[28.1214]

                .and_then(|m| pijul_core::Merkle::from_base32(m.as_bytes())),

Replacement in pijul-remote/src/http.rs at line 409 [238.10]

B:BD[28.1310] → [92.1568:1664]

    pub async fn get_id(&self) -> Result<Option<libpijul::pristine::RemoteId>, anyhow::Error> {

[28.1310]

[75.10538]

    pub async fn get_id(&self) -> Result<Option<pijul_core::pristine::RemoteId>, anyhow::Error> {

Replacement in pijul-remote/src/http.rs at line 428 [238.10]

B:BD[75.11088] → [92.1665:1725]

        Ok(libpijul::pristine::RemoteId::from_bytes(&resp))

[75.11088]

[75.11148]

        Ok(pijul_core::pristine::RemoteId::from_bytes(&resp))

Replacement in pijul-remote/src/http.rs at line 434 [238.10]

B:BD[28.1423] → [28.1423:1475]

        state: Option<(libpijul::Merkle, &[Hash])>,

[28.1423]

[28.1475]

        state: Option<(pijul_core::Merkle, &[Hash])>,

Replacement in pijul-remote/src/http.rs at line 542 [238.10]

B:BD[158.1930] → [172.4061:4152]

    pub async fn prove(&mut self, key: libpijul::key::SKey) -> Result<(), anyhow::Error> {

[158.1930]

[158.2044]

    pub async fn prove(&mut self, key: pijul_core::key::SKey) -> Result<(), anyhow::Error> {

Replacement in pijul-remote/Cargo.toml at line 15 [180.565]

B:BD[180.889] → [226.985:1043]

libpijul = { workspace = true, features = [ "tarball" ] }

[180.889]

[193.175]

pijul-core = { workspace = true, features = [ "tarball" ] }

Replacement in pijul-macros/Cargo.toml at line 3 [2.21011]
B:BD[2.21044] → [2.21044:21091]
```
description = "Macros used to write libpijul."
```
[2.21044]
[199.258]
```
description = "Macros used to write pijul-core."
```
Deletion in pijul-identity/src/repair.rs at line 3 [140.56]
∅:D[233.2654] → [140.191:234]
B:BD[140.191] → [140.191:234]
```
use libpijul::key::{PublicKey, SecretKey};
```
Insertion in pijul-identity/src/repair.rs at line 5 [140.56]
[233.2723]
[140.234]
```
use pijul_core::key::{PublicKey, SecretKey};
```
Replacement in pijul-identity/src/load.rs at line 4 [140.22387]
B:BD[140.22508] → [140.22508:22551]
```
use libpijul::key::{PublicKey, SecretKey};
```
[140.22508]
[140.22551]
```
use pijul_core::key::{PublicKey, SecretKey};
```
Replacement in pijul-identity/src/lib.rs at line 54 [140.15627]
B:BD[195.115] → [195.115:164]
```
use libpijul::key::{PublicKey, SKey, SecretKey};
```
[195.115]
[173.758]
```
use pijul_core::key::{PublicKey, SKey, SecretKey};
```
Replacement in pijul-identity/Cargo.toml at line 15 [179.159]
B:BD[179.502] → [193.1189:1215]
```
libpijul.workspace = true
```
[179.502]
[193.1215]
```
pijul-core.workspace = true
```
File move: libpijul → pijul-core
BF:BFD[103.2] → [103.3:22]
BF:BF[103.22] → [2.198139:198139]
[103.2]
[2.198139]

Replacement in pijul-core/src/working_copy/memory.rs at line 65 [2.199222]

B:BD[2.200692] → [2.200692:200759]

                        Inode::Directory { ref children, .. } => {

[2.200692]

[2.200759]

                        Inode::Directory { children, .. } => {

Replacement in pijul-core/src/working_copy/memory.rs at line 151 [2.199222]

B:BD[2.203478] → [2.203478:203561]

                Some(Inode::Directory { ref children, .. }) => t = Some(children),

[2.203478]

[2.203561]

                Some(Inode::Directory { children, .. }) => t = Some(children),

Replacement in pijul-core/src/working_copy/memory.rs at line 173 [2.199222]
B:BD[2.204289] → [2.204289:204330]
```
                    ref mut children, ..
```
[2.204289]
[2.204330]
```
                    children, ..
```
Replacement in pijul-core/src/working_copy/memory.rs at line 202 [2.199222]
B:BD[2.205254] → [2.205254:205295]
```
                    ref mut children, ..
```
[2.205254]
[2.205295]
```
                    children, ..
```

Replacement in pijul-core/src/working_copy/memory.rs at line 232 [2.199222]

B:BD[2.206547] → [2.206547:206603]

            Some(Inode::File { ref contents, .. }) => {

[2.206547]

[84.338]

            Some(Inode::File { contents, .. }) => {

Replacement in pijul-core/src/working_copy/memory.rs at line 293 [2.199222]
∅:D[53.26787] → [2.207567:207623]
B:BD[2.207567] → [2.207567:207623]
```
            Some(Inode::File { ref mut meta, .. }) => {
```
[53.26787]
[50.237]
```
            Some(Inode::File { meta, .. }) => {
```

Replacement in pijul-core/src/working_copy/memory.rs at line 296 [2.199222]

B:BD[2.207710] → [2.207710:207771]

            Some(Inode::Directory { ref mut meta, .. }) => {

[2.207710]

[50.319]

            Some(Inode::Directory { meta, .. }) => {

Replacement in pijul-core/src/working_copy/memory.rs at line 309 [2.199222]
B:BD[72.538] → [72.538:575]
```
                ref mut contents, ..
```
[72.538]
[72.575]
```
                contents, ..
```
Replacement in pijul-core/src/working_copy/memory.rs at line 338 [2.199222]
B:BD[222.1424] → [222.1424:1463]
```
                ref mut last_modified,
```
[222.1424]
[222.1463]
```
                last_modified,
```
Replacement in pijul-core/src/unrecord/mod.rs at line 776 [2.231493]
B:BD[192.1881] → [192.1881:1919]
```
            Atom::EdgeMap(ref n) => {
```
[192.1881]
[192.1919]
```
            Atom::EdgeMap(n) => {
```

Replacement in pijul-core/src/tests/text_changes.rs at line 123 [101.550]

B:BD[116.13774] → [116.13774:13845]

                if let PrintableAtom::Edges(ref mut change) = change {

[116.13774]

[116.13845]

                if let PrintableAtom::Edges(change) = change {

Replacement in pijul-core/src/tests/text_changes.rs at line 161 [101.550]
B:BD[101.8768] → [101.8768:8814]
```
                .gen(quickcheck::Gen::new(3))
```
[101.8768]
[101.8814]
```
                .r#gen(quickcheck::Gen::new(3))
```

Replacement in pijul-core/src/tests/file_conflicts.rs at line 1111 [2.305506]

B:BD[115.554] → [147.542:624]

        Conflict::ZombieFile { ref path, .. } => assert_eq!(path, "a/b/c/alice"),

[115.554]

[2.341517]

        Conflict::ZombieFile { path, .. } => assert_eq!(path, "a/b/c/alice"),

Replacement in pijul-core/src/tests/file_conflicts.rs at line 1196 [2.305506]

B:BD[115.600] → [147.625:707]

        Conflict::ZombieFile { ref path, .. } => assert_eq!(path, "a/b/c/alice"),

[115.600]

[2.344572]

        Conflict::ZombieFile { path, .. } => assert_eq!(path, "a/b/c/alice"),

Replacement in pijul-core/src/tests/file_conflicts.rs at line 1216 [2.305506]
B:BD[115.646] → [170.3185:3236]
```
        Conflict::ZombieFile { ref path, .. } => {
```
[115.646]
[170.3236]
```
        Conflict::ZombieFile { path, .. } => {
```
Replacement in pijul-core/src/tests/file_conflicts.rs at line 1238 [2.305506]
B:BD[115.692] → [170.3314:3365]
```
        Conflict::ZombieFile { ref path, .. } => {
```
[115.692]
[170.3365]
```
        Conflict::ZombieFile { path, .. } => {
```

Replacement in pijul-core/src/tests/file_conflicts.rs at line 1312 [2.305506]

B:BD[115.738] → [147.920:1001]

        Conflict::ZombieFile { ref path, .. } => assert_eq!(path, "alice/file"),

[115.738]

[2.348107]

        Conflict::ZombieFile { path, .. } => assert_eq!(path, "alice/file"),

Replacement in pijul-core/src/tests/file_conflicts.rs at line 1356 [2.305506]

B:BD[115.784] → [147.1002:1083]

        Conflict::ZombieFile { ref path, .. } => assert_eq!(path, "alice/file"),

[115.784]

[2.349382]

        Conflict::ZombieFile { path, .. } => assert_eq!(path, "alice/file"),

Replacement in pijul-core/src/tests/file_conflicts.rs at line 1547 [2.305506]

B:BD[115.830] → [147.1084:1158]

        Conflict::ZombieFile { ref path, .. } => assert_eq!(path, "dir"),

[115.830]

[2.355700]

        Conflict::ZombieFile { path, .. } => assert_eq!(path, "dir"),

Replacement in pijul-core/src/tests/file_conflicts.rs at line 1585 [2.305506]

B:BD[115.876] → [147.1159:1233]

        Conflict::ZombieFile { ref path, .. } => assert_eq!(path, "dir"),

[115.876]

[2.356769]

        Conflict::ZombieFile { path, .. } => assert_eq!(path, "dir"),

Replacement in pijul-core/src/tests/add_file.rs at line 572 [2.454125]

B:BD[115.1094] → [147.1234:1310]

            Conflict::ZombieFile { ref path, .. } => assert_eq!(path, "a"),

[115.1094]

[2.472693]

            Conflict::ZombieFile { path, .. } => assert_eq!(path, "a"),

Replacement in pijul-core/src/small_string.rs at line 177 [2.480474]
B:BD[2.483436] → [2.483436:483475]
```
    /// use libpijul::small_string::*;
```
[2.483436]
[2.483475]
```
    /// use pijul_core::small_string::*;
```
Replacement in pijul-core/src/small_string.rs at line 186 [2.480474]
B:BD[2.483670] → [2.483670:483709]
```
    /// use libpijul::small_string::*;
```
[2.483670]
[2.483709]
```
    /// use pijul_core::small_string::*;
```
Replacement in pijul-core/src/small_string.rs at line 210 [2.480474]
B:BD[2.484294] → [2.484294:484333]
```
    /// use libpijul::small_string::*;
```
[2.484294]
[2.484333]
```
    /// use pijul_core::small_string::*;
```
Replacement in pijul-core/src/small_string.rs at line 245 [2.480474]
B:BD[2.485541] → [2.485541:485580]
```
    /// use libpijul::small_string::*;
```
[2.485541]
[2.485580]
```
    /// use pijul_core::small_string::*;
```
Replacement in pijul-core/src/small_string.rs at line 256 [2.480474]
B:BD[2.485846] → [2.485846:485885]
```
    /// use libpijul::small_string::*;
```
[2.485846]
[2.485885]
```
    /// use pijul_core::small_string::*;
```
Replacement in pijul-core/src/small_string.rs at line 314 [2.480474]
B:BD[2.487787] → [229.0:49]
```
    unsafe fn write_to_page(&self, p: *mut u8) {
```
[2.487787]
[45.47596]
```
    unsafe fn write_to_page(&self, p: *mut u8) { unsafe {
```

Replacement in pijul-core/src/small_string.rs at line 320 [2.480474]

∅:D[46.6296] → [45.47741:47816]

B:BD[45.47741] → [45.47741:47816]

    }
    unsafe fn from_raw_ptr<'a, T>(_: &T, p: *const u8) -> &'a Self {

[46.6296]

[45.47816]

    }}
    unsafe fn from_raw_ptr<'a, T>(_: &T, p: *const u8) -> &'a Self { unsafe {

Replacement in pijul-core/src/small_string.rs at line 323 [2.480474]

B:BD[45.47849] → [45.47849:47906]

    }
    unsafe fn onpage_size(p: *const u8) -> usize {

[45.47849]

[45.47906]

    }}
    unsafe fn onpage_size(p: *const u8) -> usize { unsafe {

Replacement in pijul-core/src/small_string.rs at line 331 [2.480474]
B:BD[45.48036] → [45.48036:48042]
```
    }
```
[45.48036]
[2.487787]
```
    }}
```

Replacement in pijul-core/src/small_string.rs at line 346 [2.480474]

B:BD[2.488072] → [45.48303:48371]

unsafe fn smallstr_from_raw_ptr<'a>(p: *const u8) -> &'a SmallStr {

[2.488072]

[45.48371]

unsafe fn smallstr_from_raw_ptr<'a>(p: *const u8) -> &'a SmallStr { unsafe {

Replacement in pijul-core/src/small_string.rs at line 349 [2.480474]
B:BD[45.48471] → [45.48471:48473]
```
}
```
[45.48471]
[45.48473]
```
}}
```

Replacement in pijul-core/src/record.rs at line 862 [2.488880]

B:BD[53.55162] → [53.55162:55233]

            if let Ok(meta) = working_copy.file_metadata(&full_path) {

[53.55162]

[100.4494]

            match working_copy.file_metadata(&full_path) { Ok(meta) => {

Replacement in pijul-core/src/record.rs at line 875 [2.488880]

B:BD[53.55614] → [116.16923:17017]

            } else if let Some(vertex) = get_inodes::<_, C, W>(txn, &channel, child_inode)? {

[53.55614]

[53.55697]

            } _ => if let Some(vertex) = get_inodes::<_, C, W>(txn, &channel, child_inode)? {

Replacement in pijul-core/src/record.rs at line 886 [2.488880]
∅:D[71.898] → [53.55892:55906]
∅:D[72.1903] → [53.55892:55906]
B:BD[53.55892] → [53.55892:55906]
```
            }
```
[72.1903]
[53.55906]
```
            }}
```

Replacement in pijul-core/src/record.rs at line 903 [2.488880]

B:BD[53.56307] → [53.56307:56375]

    if let Ok(last_modified) = working_copy.modified_time(prefix) {

[53.56307]

[53.56375]

    match working_copy.modified_time(prefix) { Ok(last_modified) => {

Replacement in pijul-core/src/record.rs at line 924 [2.488880]
∅:D[113.285] → [53.56751:56764]
∅:D[114.853] → [53.56751:56764]
B:BD[53.56751] → [53.56751:56764]
```
    } else {
```
[114.853]
[53.56764]
```
    } _ => {
```
Replacement in pijul-core/src/record.rs at line 926 [2.488880]
B:BD[53.56781] → [53.56781:56787]
```
    }
```
[53.56781]
[53.56787]
```
    }}
```

Replacement in pijul-core/src/record.rs at line 1124 [2.488880]

∅:D[53.58887] → [2.501402:501478]

B:BD[2.501402] → [2.501402:501478]

        if let Ok(new_meta) = working_copy.file_metadata(&item.full_path) {

[2.501352]

[100.6854]

        match working_copy.file_metadata(&item.full_path) { Ok(new_meta) => {

Replacement in pijul-core/src/record.rs at line 1141 [2.488880]
∅:D[100.7229] → [2.503118:503135]
B:BD[2.503118] → [2.503118:503135]
```
        } else {
```
[100.7229]
[2.503135]
```
        } _ => {
```
Replacement in pijul-core/src/record.rs at line 1153 [2.488880]
B:BD[100.7270] → [100.7270:7280]
```
        }
```
[100.7270]
[100.7280]
```
        }}
```
Replacement in pijul-core/src/record.rs at line 1953 [2.488880]
∅:D[32.1971] → [2.523952:523985]
B:BD[2.523952] → [2.523952:523985]
```
            ref mut contents, ..
```
[32.1971]
[53.61462]
```
            contents, ..
```

Replacement in pijul-core/src/pristine/sanakirja.rs at line 78 [2.531056]

∅:D[159.1247] → [17.13003:13091]

B:BD[2.531623] → [17.13003:13091]

    pub unsafe fn new_nolock<P: AsRef<Path>>(name: P) -> Result<Self, SanakirjaError> {

[159.1247]

[2.531710]

    pub unsafe fn new_nolock<P: AsRef<Path>>(name: P) -> Result<Self, SanakirjaError> { unsafe {

Replacement in pijul-core/src/pristine/sanakirja.rs at line 80 [2.531056]
B:BD[2.531760] → [2.531760:531766]
```
    }
```
[2.531760]
[159.1248]
```
    }}
```
Replacement in pijul-core/src/pristine/sanakirja.rs at line 101 [2.531056]
B:BD[2.532052] → [17.13380:13420]
```
    ) -> Result<Self, SanakirjaError> {
```
[2.532052]
[2.532091]
```
    ) -> Result<Self, SanakirjaError> { unsafe {
```
Replacement in pijul-core/src/pristine/sanakirja.rs at line 105 [2.531056]
B:BD[2.532192] → [2.532192:532198]
```
    }
```
[2.532192]
[17.13421]
```
    }}
```
Replacement in pijul-core/src/pristine/sanakirja.rs at line 167 [2.531056]
∅:D[170.12498] → [2.533977:534017]
B:BD[2.533977] → [2.533977:534017]
```
        if let Some(txn) = begin(txn) {
```
[170.12498]
[2.534017]
```
        match begin(txn) { Some(txn) => {
```
Replacement in pijul-core/src/pristine/sanakirja.rs at line 169 [2.531056]
B:BD[2.534037] → [2.534037:534054]
```
        } else {
```
[2.534037]
[17.13616]
```
        } _ => {
```
Replacement in pijul-core/src/pristine/sanakirja.rs at line 171 [2.531056]
∅:D[17.13665] → [2.534108:534118]
B:BD[2.534108] → [2.534108:534118]
```
        }
```
[17.13665]
[2.534118]
```
        }}
```

Replacement in pijul-core/src/pristine/sanakirja.rs at line 1222 [2.531056]

B:BD[26.44151] → [26.44151:44210]

    ) -> Result<Option<Channel>, TxnErr<SanakirjaError>> {

[26.44151]

[170.20315]

    ) -> Result<Option<Channel>, TxnErr<SanakirjaError>> { unsafe {

Replacement in pijul-core/src/pristine/sanakirja.rs at line 1244 [2.531056]
∅:D[26.44879] → [25.44451:44457]
B:BD[25.44451] → [25.44451:44457]
```
    }
```
[26.44879]
[25.44457]
```
    }}
```
Replacement in pijul-core/src/pristine/sanakirja.rs at line 2523 [2.531056]
B:BD[2.579208] → [45.95434:95485]
```
    unsafe fn onpage_size(p: *const u8) -> usize {
```
[2.579208]
[45.95485]
```
    unsafe fn onpage_size(p: *const u8) -> usize { unsafe {
```
Replacement in pijul-core/src/pristine/sanakirja.rs at line 2526 [2.531056]
∅:D[45.95541] → [2.579553:579559]
B:BD[2.579553] → [2.579553:579559]
B:BD[2.579559] → [45.95542:95611]
```
    }
    unsafe fn from_raw_ptr<'a, T>(_: &T, p: *const u8) -> &'a Self {
```
[45.95541]
[45.95611]
```
    }}
    unsafe fn from_raw_ptr<'a, T>(_: &T, p: *const u8) -> &'a Self { unsafe {
```
Replacement in pijul-core/src/pristine/sanakirja.rs at line 2529 [2.531056]
∅:D[45.95643] → [2.580108:580114]
B:BD[2.580108] → [2.580108:580114]
B:BD[2.580114] → [225.0:49]
```
    }
    unsafe fn write_to_page(&self, p: *mut u8) {
```
[45.95643]
[45.95693]
```
    }}
    unsafe fn write_to_page(&self, p: *mut u8) { unsafe {
```
Replacement in pijul-core/src/pristine/sanakirja.rs at line 2533 [2.531056]
∅:D[225.96] → [2.580261:580267]
∅:D[183.228] → [2.580261:580267]
∅:D[170.34262] → [2.580261:580267]
∅:D[45.95791] → [2.580261:580267]
B:BD[2.580261] → [2.580261:580267]
```
    }
```
[225.96]
[2.580396]
```
    }}
```

Replacement in pijul-core/src/pristine/sanakirja.rs at line 2536 [2.531056]

B:BD[2.580399] → [45.95792:95857]

unsafe fn path_id_from_raw_ptr<'a>(p: *const u8) -> &'a PathId {

[2.580399]

[45.95857]

unsafe fn path_id_from_raw_ptr<'a>(p: *const u8) -> &'a PathId { unsafe {

Replacement in pijul-core/src/pristine/sanakirja.rs at line 2539 [2.531056]
∅:D[45.95966] → [2.580704:580706]
B:BD[2.580704] → [2.580704:580706]
```
}
```
[45.95966]
[45.95967]
```
}}
```
Replacement in pijul-core/src/pristine/sanakirja.rs at line 2600 [2.531056]
B:BD[2.583994] → [45.97254:97305]
```
    unsafe fn onpage_size(p: *const u8) -> usize {
```
[2.583994]
[45.97305]
```
    unsafe fn onpage_size(p: *const u8) -> usize { unsafe {
```
Replacement in pijul-core/src/pristine/sanakirja.rs at line 2605 [2.531056]
∅:D[45.97517] → [2.584693:584699]
B:BD[2.584693] → [2.584693:584699]
B:BD[2.584699] → [45.97518:97587]
```
    }
    unsafe fn from_raw_ptr<'a, T>(_: &T, p: *const u8) -> &'a Self {
```
[45.97517]
[45.97587]
```
    }}
    unsafe fn from_raw_ptr<'a, T>(_: &T, p: *const u8) -> &'a Self { unsafe {
```

Replacement in pijul-core/src/pristine/sanakirja.rs at line 2608 [2.531056]

∅:D[45.97616] → [2.584816:584822]

B:BD[2.584816] → [2.584816:584822]

B:BD[2.584822] → [183.229:320]

    }
    unsafe fn write_to_page_alloc<T: sanakirja::AllocPage>(&self, t: &mut T, p: *mut u8) {

[45.97616]

[183.320]

    }}
    unsafe fn write_to_page_alloc<T: sanakirja::AllocPage>(&self, t: &mut T, p: *mut u8) { unsafe {

Replacement in pijul-core/src/pristine/sanakirja.rs at line 2613 [2.531056]
∅:D[183.414] → [2.584945:584951]
∅:D[170.34430] → [2.584945:584951]
∅:D[45.97811] → [2.584945:584951]
B:BD[2.584945] → [2.584945:584951]
```
    }
```
[183.414]
[2.584951]
```
    }}
```
Replacement in pijul-core/src/pristine/sanakirja.rs at line 2635 [2.531056]
B:BD[75.33483] → [75.33483:33534]
```
    unsafe fn onpage_size(p: *const u8) -> usize {
```
[75.33483]
[125.43557]
```
    unsafe fn onpage_size(p: *const u8) -> usize { unsafe {
```

Replacement in pijul-core/src/pristine/sanakirja.rs at line 2637 [2.531056]

∅:D[125.43612] → [75.33569:33644]

B:BD[75.33569] → [75.33569:33644]

    }
    unsafe fn from_raw_ptr<'a, T>(_: &T, p: *const u8) -> &'a Self {

[125.43612]

[125.43613]

    }}
    unsafe fn from_raw_ptr<'a, T>(_: &T, p: *const u8) -> &'a Self { unsafe {

Replacement in pijul-core/src/pristine/sanakirja.rs at line 2643 [2.531056]

B:BD[75.33810] → [75.33810:33816]

B:BD[75.33816] → [183.415:506]

    }
    unsafe fn write_to_page_alloc<T: sanakirja::AllocPage>(&self, _: &mut T, p: *mut u8) {

[75.33810]

[75.33865]

    }}
    unsafe fn write_to_page_alloc<T: sanakirja::AllocPage>(&self, _: &mut T, p: *mut u8) { unsafe {

Replacement in pijul-core/src/pristine/sanakirja.rs at line 2654 [2.531056]
B:BD[75.34128] → [75.34128:34134]
```
    }
```
[75.34128]
[75.34134]
```
    }}
```
Replacement in pijul-core/src/pristine/mod.rs at line 102 [2.586748]
B:BD[84.100720] → [84.100720:100771]
```
        if let Ok(txn) = Arc::try_unwrap(self.0) {
```
[84.100720]
[84.100771]
```
        match Arc::try_unwrap(self.0) { Ok(txn) => {
```
Replacement in pijul-core/src/pristine/mod.rs at line 104 [2.586748]
B:BD[84.100809] → [84.100809:100826]
```
        } else {
```
[84.100809]
[135.0]
```
        } _ => {
```
Replacement in pijul-core/src/pristine/mod.rs at line 106 [2.586748]
∅:D[135.80] → [84.100853:100863]
B:BD[84.100853] → [84.100853:100863]
```
        }
```
[135.80]
[84.100863]
```
        }}
```
Replacement in pijul-core/src/pristine/mod.rs at line 853 [2.586748]
B:BD[25.62652] → [25.62652:62677]
```
    if let Some(e) = txn
```
[25.62652]
[37.2954]
```
    match txn
```
Replacement in pijul-core/src/pristine/mod.rs at line 856 [2.586748]
B:BD[7.40327] → [25.62739:62745]
```
    {
```
[7.40327]
[45.104130]
```
    { Some(e) => {
```
Replacement in pijul-core/src/pristine/mod.rs at line 858 [2.586748]
∅:D[45.104161] → [25.62789:62802]
B:BD[25.62789] → [25.62789:62802]
```
    } else {
```
[45.104161]
[25.62802]
```
    } _ => {
```
Replacement in pijul-core/src/pristine/mod.rs at line 860 [2.586748]
B:BD[25.62829] → [25.62829:62835]
```
    }
```
[25.62829]
[7.40634]
```
    }}
```

Replacement in pijul-core/src/pristine/mod.rs at line 967 [2.586748]

B:BD[25.65135] → [67.3156:3219]

        Hash::Blake3(ref s) => LittleEndian::read_u64(&s[..]),

[25.65135]

[7.43218]

        Hash::Blake3(s) => LittleEndian::read_u64(&s[..]),

Replacement in pijul-core/src/pristine/mod.rs at line 1301 [2.586748]

B:BD[2.618235] → [45.106796:106870]

        } else if let Ok(&dest) = txn.find_block_end(channel, v.dest()) {

[2.618235]

[26.54673]

        } else { match txn.find_block_end(channel, v.dest()) { Ok(&dest) => {

Replacement in pijul-core/src/pristine/mod.rs at line 1303 [2.586748]
∅:D[26.54690] → [2.618235:618252]
B:BD[2.618235] → [2.618235:618252]
```
        } else {
```
[26.54690]
[26.54691]
```
        } _ => {
```
Replacement in pijul-core/src/pristine/mod.rs at line 1305 [2.586748]
∅:D[7.49840] → [2.618309:618320]
∅:D[26.54718] → [2.618309:618320]
B:BD[2.618309] → [2.618309:618320]
```
        };
```
[26.54718]
[2.618320]
```
        }}};
```

Replacement in pijul-core/src/pristine/mod.rs at line 1329 [2.586748]

B:BD[2.618942] → [45.107022:107088]

    } else if let Ok(dest) = txn.find_block(&channel, v.dest()) {

[2.618942]

[2.619006]

    } else { match txn.find_block(&channel, v.dest()) { Ok(dest) => {

Replacement in pijul-core/src/pristine/mod.rs at line 1353 [2.586748]
B:BD[2.619628] → [2.619628:619641]
```
    } else {
```
[2.619628]
[2.619641]
```
    } _ => {
```
Replacement in pijul-core/src/pristine/mod.rs at line 1376 [2.586748]
B:BD[2.620238] → [2.620238:620244]
```
    }
```
[2.620238]
[2.620244]
```
    }}}
```
Replacement in pijul-core/src/pristine/mod.rs at line 1989 [2.586748]
∅:D[35.976] → [33.3867:3892]
∅:D[45.111692] → [33.3867:3892]
B:BD[33.3867] → [33.3867:3892]
```
    if let Some(e) = txn
```
[45.111692]
[37.3675]
```
    match txn
```
Replacement in pijul-core/src/pristine/mod.rs at line 1992 [2.586748]
B:BD[33.3968] → [33.3968:3974]
```
    {
```
[33.3968]
[46.16687]
```
    { Some(e) => {
```
Replacement in pijul-core/src/pristine/mod.rs at line 1996 [2.586748]
∅:D[45.111794] → [33.4037:4050]
B:BD[33.4037] → [33.4037:4050]
```
    } else {
```
[45.111794]
[33.4050]
```
    } _ => {
```
Replacement in pijul-core/src/pristine/mod.rs at line 1998 [2.586748]
B:BD[33.4067] → [33.4067:4073]
```
    }
```
[33.4067]
[33.4073]
```
    }}
```
Replacement in pijul-core/src/pristine/merkle.rs at line 85 [2.638683]
B:BD[2.639463] → [2.639463:639504]
```
            Merkle::Ed25519(ref h0) => {
```
[2.639463]
[123.5337]
```
            Merkle::Ed25519(h0) => {
```
Replacement in pijul-core/src/pristine/hash.rs at line 27 [2.644439]
B:BD[2.645161] → [2.645161:645204]
```
            Hasher::Blake3(ref mut h) => {
```
[2.645161]
[2.645204]
```
            Hasher::Blake3(h) => {
```
Replacement in pijul-core/src/pristine/hash.rs at line 34 [2.644439]
B:BD[2.645330] → [2.645330:645369]
```
            Hasher::Blake3(ref h) => {
```
[2.645330]
[2.645369]
```
            Hasher::Blake3(h) => {
```

Replacement in pijul-core/src/pristine/hash.rs at line 275 [2.644439]

B:BD[53.73142] → [53.73142:73199]

    pub unsafe fn size_from_ptr(b: *const u8) -> usize {

[53.73142]

[53.73199]

    pub unsafe fn size_from_ptr(b: *const u8) -> usize { unsafe {

Replacement in pijul-core/src/pristine/hash.rs at line 283 [2.644439]
B:BD[53.73422] → [53.73422:73428]
```
    }
```
[53.73422]
[53.73428]
```
    }}
```
Replacement in pijul-core/src/path.rs at line 11 [2.667547]
B:BD[2.668023] → [2.668023:668055]
```
/// use libpijul::path::parent;
```
[2.668023]
[2.668055]
```
/// use pijul_core::path::parent;
```
Replacement in pijul-core/src/path.rs at line 41 [2.667547]
B:BD[2.668895] → [2.668895:668930]
```
/// use libpijul::path::file_name;
```
[2.668895]
[2.668930]
```
/// use pijul_core::path::file_name;
```
Replacement in pijul-core/src/path.rs at line 117 [2.667547]
B:BD[2.670981] → [2.670981:671011]
```
/// use libpijul::path::push;
```
[2.670981]
[2.671011]
```
/// use pijul_core::path::push;
```
Replacement in pijul-core/src/path.rs at line 134 [2.667547]
B:BD[2.671448] → [2.671448:671477]
```
/// use libpijul::path::pop;
```
[2.671448]
[2.671477]
```
/// use pijul_core::path::pop;
```

Replacement in pijul-core/src/output/output.rs at line 62 [2.671807]

B:BD[137.2448] → [137.2448:2822]

            Conflict::Name { ref changes, .. } => changes,
            Conflict::ZombieFile { ref changes, .. } => changes,
            Conflict::MultipleNames { ref changes, .. } => changes,
            Conflict::Zombie { ref changes, .. } => changes,
            Conflict::Cyclic { ref changes, .. } => changes,
            Conflict::Order { ref changes, .. } => changes,

[137.2448]

[137.2822]

            Conflict::Name { changes, .. } => changes,
            Conflict::ZombieFile { changes, .. } => changes,
            Conflict::MultipleNames { changes, .. } => changes,
            Conflict::Zombie { changes, .. } => changes,
            Conflict::Cyclic { changes, .. } => changes,
            Conflict::Order { changes, .. } => changes,

Replacement in pijul-core/src/output/output.rs at line 73 [2.671807]

B:BD[137.2912] → [137.2912:3090]

            Conflict::Name { ref inodes, .. } => inodes,
            Conflict::ZombieFile { ref inode, .. } => inode,
            Conflict::MultipleNames { ref pos, .. } => pos,

[137.2912]

[137.3090]

            Conflict::Name { inodes, .. } => inodes,
            Conflict::ZombieFile { inode, .. } => inode,
            Conflict::MultipleNames { pos, .. } => pos,

Replacement in pijul-core/src/output/output.rs at line 77 [2.671807]
B:BD[137.3121] → [137.3121:3158]
```
                ref inode_vertex, ..
```
[137.3121]
[137.3158]
```
                inode_vertex, ..
```
Replacement in pijul-core/src/output/output.rs at line 80 [2.671807]
B:BD[137.3220] → [137.3220:3257]
```
                ref inode_vertex, ..
```
[137.3220]
[137.3257]
```
                inode_vertex, ..
```
Replacement in pijul-core/src/output/output.rs at line 83 [2.671807]
B:BD[137.3318] → [137.3318:3355]
```
                ref inode_vertex, ..
```
[137.3318]
[137.3355]
```
                inode_vertex, ..
```

Replacement in pijul-core/src/output/output.rs at line 448 [2.671807]

B:BD[100.17397] → [137.4415:4475]

        let name = if let Some(ref inode) = is_first_name {

[100.17397]

[137.4475]

        let name = if let &mut Some(ref inode) = is_first_name {

Replacement in pijul-core/src/output/output.rs at line 666 [2.671807]
∅:D[67.3961] → [57.1185:1234]
B:BD[17.21451] → [57.1185:1234]
```
                if let Some(ref mut tmp) = tmp {
```
[67.3961]
[162.1182]
```
                if let Some(tmp) = tmp {
```
Replacement in pijul-core/src/output/output.rs at line 905 [2.671807]
∅:D[150.372] → [2.685577:685630]
∅:D[86.413] → [2.685577:685630]
∅:D[17.22934] → [2.685577:685630]
∅:D[25.85107] → [2.685577:685630]
B:BD[2.685577] → [2.685577:685630]
```
    for (fileid, (inode, ref name)) in dead.iter() {
```
[150.372]
[2.685630]
```
    for (fileid, (inode, name)) in dead.iter() {
```

Replacement in pijul-core/src/output/mod.rs at line 111 [2.686190]

B:BD[116.30554] → [116.30554:30762]

            FileError::Changestore(ref c) => std::fmt::Debug::fmt(c, fmt),
            FileError::Txn(ref c) => std::fmt::Debug::fmt(c, fmt),
            FileError::Io(ref c) => std::fmt::Debug::fmt(c, fmt),

[116.30554]

[116.30762]

            FileError::Changestore(c) => std::fmt::Debug::fmt(c, fmt),
            FileError::Txn(c) => std::fmt::Debug::fmt(c, fmt),
            FileError::Io(c) => std::fmt::Debug::fmt(c, fmt),

Replacement in pijul-core/src/output/mod.rs at line 247 [2.686190]
B:BD[100.23749] → [100.23749:23801]
```
    let child = if let Some(child) = iter_adjacent(
```
[100.23749]
[100.23801]
```
    let child = match iter_adjacent(
```
Replacement in pijul-core/src/output/mod.rs at line 255 [2.686190]
B:BD[100.23965] → [100.23965:23971]
```
    {
```
[100.23965]
[100.23971]
```
    { Some(child) => {
```
Replacement in pijul-core/src/output/mod.rs at line 257 [2.686190]
B:BD[100.23986] → [100.23986:23999]
```
    } else {
```
[100.23986]
[165.4948]
```
    } _ => {
```
Replacement in pijul-core/src/output/mod.rs at line 282 [2.686190]
∅:D[165.5147] → [100.24566:24573]
B:BD[100.24566] → [100.24566:24573]
```
    };
```
[165.5147]
[100.24573]
```
    }};
```

Replacement in pijul-core/src/output/mod.rs at line 306 [2.686190]

B:BD[2.689916] → [25.87274:87390]

    if let Some(n) =
        iter_adjacent(txn, channel, pos.inode_vertex(), f, f | EdgeFlags::BLOCK)?.next()
    {

[2.689916]

[168.0]

    match iter_adjacent(txn, channel, pos.inode_vertex(), f, f | EdgeFlags::BLOCK)?.next()
    { Some(n) => {

Replacement in pijul-core/src/output/mod.rs at line 322 [2.686190]
∅:D[167.215] → [25.87419:87432]
∅:D[137.6332] → [25.87419:87432]
B:BD[25.87419] → [25.87419:87432]
```
    } else {
```
[167.215]
[137.6333]
```
    } _ => {
```
Replacement in pijul-core/src/output/mod.rs at line 324 [2.686190]
∅:D[137.6350] → [25.87450:87456]
B:BD[25.87450] → [25.87450:87456]
```
    }
```
[137.6350]
[53.82579]
```
    }}
```

Replacement in pijul-core/src/missing_context.rs at line 169 [2.696460]

B:BD[90.1716] → [90.1716:1804]

        let dest_vertex = if let Ok(&dest_vertex) = txn.find_block_end(&channel, pos) {

[90.1716]

[90.1804]

        let dest_vertex = match txn.find_block_end(&channel, pos) { Ok(&dest_vertex) => {

Replacement in pijul-core/src/missing_context.rs at line 174 [2.696460]
B:BD[90.1909] → [90.1909:1926]
```
        } else {
```
[90.1909]
[90.1926]
```
        } _ => {
```
Replacement in pijul-core/src/missing_context.rs at line 176 [2.696460]
B:BD[90.1948] → [90.1948:1959]
```
        };
```
[90.1948]
[90.1959]
```
        }};
```

Replacement in pijul-core/src/lib.rs at line 100 [2.717381]

∅:D[72.3162] → [58.110:175]

B:BD[58.110] → [58.110:175]

    let txn = if let Ok(txn) = std::sync::Arc::try_unwrap(txn) {

[72.3162]

[58.175]

    let txn = match std::sync::Arc::try_unwrap(txn) { Ok(txn) => {

Replacement in pijul-core/src/lib.rs at line 102 [2.717381]
B:BD[58.209] → [58.209:222]
```
    } else {
```
[58.209]
[58.222]
```
    } _ => {
```
Replacement in pijul-core/src/lib.rs at line 104 [2.717381]
B:BD[58.245] → [58.245:252]
```
    };
```
[58.245]
[58.252]
```
    }};
```
Replacement in pijul-core/src/lib.rs at line 385 [2.717381]
B:BD[25.97658] → [45.127369:127399]
```
        if let Some(p) = self
```
[25.97658]
[84.104061]
```
        match self
```
Replacement in pijul-core/src/lib.rs at line 388 [2.717381]
B:BD[25.97793] → [25.97793:97803]
```
        {
```
[25.97793]
[45.127541]
```
        { Some(p) => {
```
Replacement in pijul-core/src/lib.rs at line 396 [2.717381]
∅:D[45.127755] → [25.97878:97895]
B:BD[25.97878] → [25.97878:97895]
```
        } else {
```
[45.127755]
[25.97895]
```
        } _ => {
```
Replacement in pijul-core/src/lib.rs at line 398 [2.717381]
B:BD[25.97916] → [25.97916:97926]
```
        }
```
[25.97916]
[2.731143]
```
        }}
```

Replacement in pijul-core/src/lib.rs at line 440 [2.717381]

B:BD[2.732181] → [222.11320:11416]

        if let Some((a, b)) = fs::find_path(changes, self, &channel.read(), false, position)? {

[2.732181]

[222.11416]

        match fs::find_path(changes, self, &channel.read(), false, position)? { Some((a, b)) => {

Replacement in pijul-core/src/lib.rs at line 442 [2.717381]
B:BD[222.11455] → [222.11455:11472]
```
        } else {
```
[222.11455]
[222.11472]
```
        } _ => {
```
Replacement in pijul-core/src/lib.rs at line 444 [2.717381]
B:BD[222.11493] → [222.11493:11503]
```
        }
```
[222.11493]
[2.732254]
```
        }}
```

Replacement in pijul-core/src/lib.rs at line 457 [2.717381]

B:BD[2.732653] → [222.11504:11599]

        if let Some((a, b)) = fs::find_path(changes, self, &channel.read(), true, position)? {

[2.732653]

[222.11599]

        match fs::find_path(changes, self, &channel.read(), true, position)? { Some((a, b)) => {

Replacement in pijul-core/src/lib.rs at line 459 [2.717381]
B:BD[222.11638] → [222.11638:11655]
```
        } else {
```
[222.11638]
[222.11655]
```
        } _ => {
```
Replacement in pijul-core/src/lib.rs at line 461 [2.717381]
B:BD[222.11676] → [222.11676:11686]
```
        }
```
[222.11676]
[2.732725]
```
        }}
```

Replacement in pijul-core/src/key.rs at line 336 [73.5013]

B:BD[73.15100] → [73.15100:15162]

            Encryption::Aes128(Kdf::Pbkdf2 { ref salt }) => {

[73.15100]

[73.15162]

            Encryption::Aes128(Kdf::Pbkdf2 { salt }) => {

Replacement in pijul-core/src/diff/bin.rs at line 87 [77.2530]

∅:D[105.309] → [77.4768:4842]

B:BD[77.4768] → [77.4768:4842]

            if let Some(Chunk::New { ref mut len, .. }) = bb.last_mut() {

[105.309]

[77.4842]

            if let Some(Chunk::New { len, .. }) = bb.last_mut() {

Replacement in pijul-core/src/changestore/mod.rs at line 132 [2.817216]

B:BD[2.820295] → [2.820295:820355]

        if let crate::change::Atom::EdgeMap(ref n) = self {

[2.820295]

[2.820355]

        if let crate::change::Atom::EdgeMap(n) = self {

Replacement in pijul-core/src/changestore/filesystem.rs at line 153 [2.824013]

B:BD[2.828061] → [2.828061:828149]

        if let Ok(p) = crate::change::ChangeFile::open(hash, &path.to_str().unwrap()) {

[2.828061]

[2.828149]

        match crate::change::ChangeFile::open(hash, &path.to_str().unwrap()) { Ok(p) => {

Replacement in pijul-core/src/changestore/filesystem.rs at line 155 [2.824013]
B:BD[2.828178] → [2.828178:828195]
```
        } else {
```
[2.828178]
[2.828195]
```
        } _ => {
```
Replacement in pijul-core/src/changestore/filesystem.rs at line 157 [2.824013]
B:BD[2.828213] → [2.828213:828223]
```
        }
```
[2.828213]
[2.828223]
```
        }}
```

Replacement in pijul-core/src/change.rs at line 303 [2.831311]

B:BD[2.838610] → [163.142:213]

    let from = if let Ok(from) = txn.find_block_end(channel, e_from) {

[2.838610]

[163.213]

    let from = match txn.find_block_end(channel, e_from) { Ok(from) => {

Replacement in pijul-core/src/change.rs at line 305 [2.831311]
B:BD[163.226] → [163.226:239]
```
    } else {
```
[163.226]
[170.34844]
```
    } _ => {
```
Replacement in pijul-core/src/change.rs at line 307 [2.831311]
∅:D[170.34896] → [163.290:297]
B:BD[163.290] → [163.290:297]
```
    };
```
[170.34896]
[45.138571]
```
    }};
```

Replacement in pijul-core/src/change.rs at line 344 [2.831311]

B:BD[2.839506] → [163.337:404]

    let mut to = if let Ok(to) = txn.find_block(channel, to_pos) {

[2.839506]

[163.404]

    let mut to = match txn.find_block(channel, to_pos) { Ok(to) => {

Replacement in pijul-core/src/change.rs at line 346 [2.831311]
B:BD[163.415] → [163.415:428]
```
    } else {
```
[163.415]
[170.34897]
```
    } _ => {
```
Replacement in pijul-core/src/change.rs at line 348 [2.831311]
∅:D[170.34949] → [163.479:486]
B:BD[163.479] → [163.479:486]
```
    };
```
[170.34949]
[192.2704]
```
    }};
```

Replacement in pijul-core/src/change.rs at line 522 [2.831311]

B:BD[2.844883] → [2.844883:844975]

            Atom::NewVertex(ref n) => n.inode,
            Atom::EdgeMap(ref n) => n.inode,

[2.844883]

[2.844975]

            Atom::NewVertex(n) => n.inode,
            Atom::EdgeMap(n) => n.inode,

Replacement in pijul-core/src/change.rs at line 848 [2.831311]
B:BD[2.853372] → [2.853372:853421]
```
        if let Some(extra) = self.extra.take() {
```
[2.853372]
[2.853421]
```
        match self.extra.take() { Some(extra) => {
```

Replacement in pijul-core/src/change.rs at line 850 [2.831311]

B:BD[2.853445] → [2.853445:853502]

        } else if let Some(extra) = self.extra2.take() {

[2.853445]

[2.853502]

        } _ => { match self.extra2.take() { Some(extra) => {

Replacement in pijul-core/src/change.rs at line 852 [2.831311]

B:BD[2.853526] → [2.853526:853578]

        } else if let Some(rec) = self.rec.take() {

[2.853526]

[2.853578]

        } _ => { match self.rec.take() { Some(rec) => {

Replacement in pijul-core/src/change.rs at line 897 [2.831311]
B:BD[2.855099] → [2.855099:855116]
```
        } else {
```
[2.855099]
[2.855116]
```
        } _ => {
```
Replacement in pijul-core/src/change.rs at line 899 [2.831311]
B:BD[2.855133] → [2.855133:855143]
```
        }
```
[2.855133]
[2.855143]
```
        }}}}}}
```

Replacement in pijul-core/src/change.rs at line 1002 [2.831311]

B:BD[2.858201] → [2.858201:858253]

                    if let Some(ref c) = contents {

[2.858201]

[2.858253]

                    if let Some(c) = contents {

Replacement in pijul-core/src/change.rs at line 1014 [2.831311]

B:BD[2.858583] → [2.858583:858635]

                    if let Some(ref c) = contents {

[2.858583]

[2.858635]

                    if let Some(c) = contents {

Replacement in pijul-core/src/change.rs at line 1027 [2.831311]

B:BD[2.859005] → [2.859005:859057]

                    if let Some(ref c) = contents {

[2.859005]

[2.859057]

                    if let Some(c) = contents {

Replacement in pijul-core/src/change.rs at line 1168 [2.831311]

B:BD[97.1149] → [97.1149:1427]

            Hunk::Edit { ref local, .. }
            | Hunk::Replacement { ref local, .. }
            | Hunk::SolveOrderConflict { ref local, .. }
            | Hunk::UnsolveOrderConflict { ref local, .. }
            | Hunk::ResurrectZombies { ref local, .. } => Some(local),

[97.1149]

[97.1427]

            Hunk::Edit { local, .. }
            | Hunk::Replacement { local, .. }
            | Hunk::SolveOrderConflict { local, .. }
            | Hunk::UnsolveOrderConflict { local, .. }
            | Hunk::ResurrectZombies { local, .. } => Some(local),

Replacement in pijul-core/src/change.rs at line 1179 [2.831311]

B:BD[2.862747] → [32.6367:6947]

            Hunk::FileMove { ref path, .. }
            | Hunk::FileDel { ref path, .. }
            | Hunk::FileUndel { ref path, .. }
            | Hunk::SolveNameConflict { ref path, .. }
            | Hunk::UnsolveNameConflict { ref path, .. }
            | Hunk::FileAdd { ref path, .. } => path,
            Hunk::Edit { ref local, .. }
            | Hunk::Replacement { ref local, .. }
            | Hunk::SolveOrderConflict { ref local, .. }
            | Hunk::UnsolveOrderConflict { ref local, .. }
            | Hunk::ResurrectZombies { ref local, .. } => &local.path,

[2.862747]

[100.27790]

            Hunk::FileMove { path, .. }
            | Hunk::FileDel { path, .. }
            | Hunk::FileUndel { path, .. }
            | Hunk::SolveNameConflict { path, .. }
            | Hunk::UnsolveNameConflict { path, .. }
            | Hunk::FileAdd { path, .. } => path,
            Hunk::Edit { local, .. }
            | Hunk::Replacement { local, .. }
            | Hunk::SolveOrderConflict { local, .. }
            | Hunk::UnsolveOrderConflict { local, .. }
            | Hunk::ResurrectZombies { local, .. } => &local.path,

Replacement in pijul-core/src/change/text_changes.rs at line 331 [17.37976]

B:BD[101.13056] → [101.13056:13145]

        Atom::NewVertex(ref new_vertex) => PrintableAtom::NewVertex(PrintableNewVertex {

[101.13056]

[101.13145]

        Atom::NewVertex(new_vertex) => PrintableAtom::NewVertex(PrintableNewVertex {

Replacement in pijul-core/src/change/text_changes.rs at line 345 [17.37976]
B:BD[101.13581] → [101.13581:13642]
```
        Atom::EdgeMap(ref edge_map) => PrintableAtom::Edges(
```
[101.13581]
[101.13642]
```
        Atom::EdgeMap(edge_map) => PrintableAtom::Edges(
```
Replacement in pijul-core/src/change/text_changes.rs at line 398 [17.37976]
∅:D[32.8785] → [17.48927:48973]
B:BD[17.48927] → [17.48927:48973]
```
                Atom::NewVertex(ref add) => {
```
[32.8785]
[70.2678]
```
                Atom::NewVertex(add) => {
```

Replacement in pijul-core/src/change/text_changes.rs at line 428 [17.37976]

B:BD[27.269] → [101.15892:15977]

                let (contents_data, content_edges) = if let Some(ref c) = contents {

[27.269]

[101.15977]

                let (contents_data, content_edges) = if let Some(c) = contents {

Replacement in pijul-core/src/change/text_changes.rs at line 453 [17.37976]

B:BD[27.308] → [101.16604:16689]

                let (contents_data, content_edges) = if let Some(ref c) = contents {

[27.308]

[101.16689]

                let (contents_data, content_edges) = if let Some(c) = contents {

Replacement in pijul-core/src/change/text_changes.rs at line 478 [17.37976]

B:BD[17.51805] → [17.51805:51864]

                if let Atom::NewVertex(ref n) = add_name {

[17.51805]

[72.4247]

                if let Atom::NewVertex(n) = add_name {

Replacement in pijul-core/src/change/text_changes.rs at line 491 [17.37976]

B:BD[101.17336] → [101.17336:17420]

                    let contents = if let Some(Atom::NewVertex(ref n)) = contents {

[101.17336]

[101.17420]

                    let contents = if let Some(Atom::NewVertex(n)) = contents {

Replacement in pijul-core/src/change/text_changes.rs at line 600 [17.37976]

B:BD[102.1836] → [102.1836:1891]

                if let Atom::NewVertex(ref n) = name {

[102.1836]

[102.1891]

                if let Atom::NewVertex(n) = name {

Replacement in pijul-core/src/change/text_changes.rs at line 729 [17.37976]

B:BD[101.25736] → [101.25736:25823]

                    if let crate::InodeUpdate::Add { ref mut pos, .. } = e.get_mut() {

[101.25736]

[101.25823]

                    if let crate::InodeUpdate::Add { pos, .. } = e.get_mut() {

Replacement in pijul-core/src/change/text_changes.rs at line 997 [17.37976]

B:BD[102.4150] → [102.4150:4237]

                    if let crate::InodeUpdate::Add { ref mut pos, .. } = e.get_mut() {

[102.4150]

[102.4237]

                    if let crate::InodeUpdate::Add { pos, .. } = e.get_mut() {

Replacement in pijul-core/src/change/text_changes.rs at line 1128 [17.37976]

B:BD[17.85426] → [101.35153:35331]

∅:D[27.623] → [17.85693:85775]

∅:D[101.35331] → [17.85693:85775]

B:BD[17.85693] → [17.85693:85775]

        Atom::NewVertex(ref n) => Ok(change_contents[n.start.us()..n.end.us()].to_vec()),
        Atom::EdgeMap(ref n) if n.edges.is_empty() => Err(TextSerError::InvalidChange),
        Atom::EdgeMap(ref n) if n.edges[0].flag.contains(EdgeFlags::DELETED) => {

[17.85426]

[17.85775]

        Atom::NewVertex(n) => Ok(change_contents[n.start.us()..n.end.us()].to_vec()),
        Atom::EdgeMap(n) if n.edges.is_empty() => Err(TextSerError::InvalidChange),
        Atom::EdgeMap(n) if n.edges[0].flag.contains(EdgeFlags::DELETED) => {

Replacement in pijul-core/src/change/text_changes.rs at line 1158 [17.37976]
∅:D[129.32] → [17.86461:86501]
∅:D[101.35729] → [17.86461:86501]
B:BD[17.86461] → [17.86461:86501]
```
    if let Atom::EdgeMap(ref e) = del {
```
[129.32]
[101.35730]
```
    if let Atom::EdgeMap(e) = del {
```

Replacement in pijul-core/src/change/printable.rs at line 459 [101.36296]

B:BD[101.48420] → [104.0:73]

                let sign = if let PrintableAtom::Edges(ref e) = change {

[101.48420]

[145.0]

                let sign = if let PrintableAtom::Edges(e) = change {

Replacement in pijul-core/src/apply.rs at line 792 [2.944089]

B:BD[45.147009] → [45.147009:147080]

            if let Ok(&dest) = txn.find_block_end(channel, p.dest()) {

[45.147009]

[2.971765]

            match txn.find_block_end(channel, p.dest()) { Ok(&dest) => {

Replacement in pijul-core/src/apply.rs at line 794 [2.944089]
B:BD[2.971801] → [2.971801:971822]
```
            } else {
```
[2.971801]
[2.971822]
```
            } _ => {
```

Replacement in pijul-core/src/apply.rs at line 796 [2.944089]

B:BD[2.971848] → [2.971848:971862]

B:BD[2.971862] → [45.147081:147151]

            }
        } else if let Ok(&dest) = txn.find_block(channel, p.dest()) {

[2.971848]

[14.1656]

            }}
        } else { match txn.find_block(channel, p.dest()) { Ok(&dest) => {

Replacement in pijul-core/src/apply.rs at line 799 [2.944089]
∅:D[14.1688] → [2.971862:971879]
B:BD[2.971862] → [2.971862:971879]
```
        } else {
```
[14.1688]
[14.1689]
```
        } _ => {
```
Replacement in pijul-core/src/apply.rs at line 801 [2.944089]
∅:D[14.1711] → [2.972040:972051]
B:BD[2.972040] → [2.972040:972051]
```
        };
```
[14.1711]
[45.147152]
```
        }}};
```

Replacement in pijul-core/src/apply.rs at line 939 [2.944089]

B:BD[2.974716] → [24.21748:21811]

            Atom::NewVertex(ref n) if !n.flag.is_folder() => {

[2.974716]

[169.5761]

            Atom::NewVertex(n) if !n.flag.is_folder() => {

Replacement in pijul-core/src/apply.rs at line 975 [2.944089]
∅:D[24.22026] → [2.976959:976997]
B:BD[2.976959] → [2.976959:976997]
```
            Atom::EdgeMap(ref n) => {
```
[24.22026]
[192.8779]
```
            Atom::EdgeMap(n) => {
```

Replacement in pijul-core/src/apply.rs at line 1097 [2.944089]

B:BD[24.26780] → [25.133783:133840]

                let al = if let Some(e) = iter_adjacent(

[24.26780]

[24.26820]

                let al = match iter_adjacent(

Replacement in pijul-core/src/apply.rs at line 1105 [2.944089]
B:BD[24.27026] → [25.133861:133879]
```
                {
```
[24.27026]
[25.133879]
```
                { Some(e) => {
```
Replacement in pijul-core/src/apply.rs at line 1108 [2.944089]
B:BD[25.133928] → [25.133928:133953]
```
                } else {
```
[25.133928]
[25.133953]
```
                } _ => {
```
Replacement in pijul-core/src/apply.rs at line 1110 [2.944089]
B:BD[25.133979] → [25.133979:133998]
```
                };
```
[25.133979]
[45.147898]
```
                }};
```
Deletion in pijul-core/src/alive/retrieve.rs at line 2 [2.984582]
B:BD[2.984688] → [2.984688:984712]
```
use crate::pristine::*;
```
Insertion in pijul-core/src/alive/retrieve.rs at line 3 [2.984582]
[53.108718]
[2.984712]
```
use crate::pristine::*;
```

Replacement in pijul-core/src/alive/retrieve.rs at line 130 [2.984582]

B:BD[116.44152] → [116.44152:44254]

        debug!(target:"libpijul::forward", "deleting forward edge {:?} {:?} {:?}", ve.v, dest, ve.e);

[116.44152]

[116.44254]

        debug!(target:"pijul_core::forward", "deleting forward edge {:?} {:?} {:?}", ve.v, dest, ve.e);

Replacement in pijul-core/src/alive/dfs.rs at line 325 [2.1000429]

B:BD[2.1011776] → [2.1011776:1011891]

            PathElement::Scc { ref scc } => *scc == side.end,
            PathElement::Conflict { ref sides } => {

[2.1011776]

[2.1011891]

            PathElement::Scc { scc } => *scc == side.end,
            PathElement::Conflict { sides } => {

Replacement in pijul-core/Cargo.toml at line 2 [2.1020742]
B:BD[2.1020753] → [2.1020753:1020771]
```
name = "libpijul"
```
[2.1020753]
[2.1020771]
```
name = "pijul-core"
```
Replacement in pijul-core/Cargo.toml at line 6 [2.1020742]
∅:D[199.908] → [2.1020973:1021016]
B:BD[2.1020973] → [2.1020973:1021016]
```
documentation = "https://docs.rs/libpijul"
```
[199.908]
[199.909]
```
documentation = "https://docs.rs/pijul-core"
```

Replacement in pijul-config/src/local.rs at line 35 [231.2463]

B:BD[231.3167] → [234.533:602]

        let dot_directory = repository_path.join(libpijul::DOT_DIR);

[231.3167]

[234.602]

        let dot_directory = repository_path.join(pijul_core::DOT_DIR);

Replacement in pijul-config/Cargo.toml at line 11 [175.96]
B:BD[175.404] → [231.16714:16740]
```
libpijul.workspace = true
```
[175.404]
[231.16740]
```
pijul-core.workspace = true
```

Replacement in pijul/tests/common/identity.rs at line 233 [142.17837]

B:BD[142.24765] → [142.24765:24857]

        let secret_key: libpijul::key::SecretKey = serde_json::from_str(&secret_key_text)?;

[142.24765]

[142.24857]

        let secret_key: pijul_core::key::SecretKey = serde_json::from_str(&secret_key_text)?;

Deletion in pijul/src/commands/unrecord.rs at line 7 [2.95630]
∅:D[189.31] → [11.19:59]
∅:D[205.126] → [11.19:59]
∅:D[99.148] → [11.19:59]
B:BD[4.1160] → [11.19:59]
∅:D[26.427] → [25.11703:11720]
B:BD[11.59] → [25.11703:11720]
```
use libpijul::changestore::ChangeStore;
use libpijul::*;
```
Insertion in pijul/src/commands/unrecord.rs at line 8 [2.95630]
[4.1251]
[177.922]
```
use pijul_core::changestore::ChangeStore;
use pijul_core::*;
```

Replacement in pijul/src/commands/unrecord.rs at line 134 [2.95630]

B:BD[53.5580] → [53.5580:5640]

            libpijul::output::output_repository_no_pending(

[53.5580]

[83.2187]

            pijul_core::output::output_repository_no_pending(

Replacement in pijul/src/commands/tag.rs at line 11 [62.74]
∅:D[201.98] → [62.219:255]
∅:D[218.113] → [62.219:255]
∅:D[189.130] → [62.219:255]
∅:D[99.193] → [62.219:255]
∅:D[195.1180] → [62.219:255]
B:BD[62.219] → [62.219:255]
B:BD[62.255] → [201.99:196]
```
use libpijul::change::ChangeHeader;
use libpijul::{ArcTxn, Base32, ChannelMutTxnT, ChannelRef, ChannelTxnT, MutTxnT, TxnT, TxnTExt};
```
[218.113]
[177.957]
```
use pijul_core::change::ChangeHeader;
use pijul_core::{ArcTxn, Base32, ChannelMutTxnT, ChannelRef, ChannelTxnT, MutTxnT, TxnT, TxnTExt};
```
Replacement in pijul/src/commands/tag.rs at line 121 [62.74]
∅:D[236.2008] → [201.1031:1102]
∅:D[228.2048] → [201.1031:1102]
∅:D[233.9756] → [201.1031:1102]
B:BD[141.142] → [201.1031:1102]
```
                let h: libpijul::Merkle = libpijul::tag::from_channel(
```
[236.2008]
[201.1102]
```
                let h: pijul_core::Merkle = pijul_core::tag::from_channel(
```

Replacement in pijul/src/commands/tag.rs at line 127 [62.74]

∅:D[201.1263] → [120.212:301]

B:BD[120.212] → [120.212:301]

                libpijul::changestore::filesystem::push_tag_filename(&mut tag_path, &h);

[201.1263]

[62.3230]

                pijul_core::changestore::filesystem::push_tag_filename(&mut tag_path, &h);

Replacement in pijul/src/commands/tag.rs at line 143 [62.74]

B:BD[119.211] → [120.380:562]

                let h = if let Some(h) = libpijul::Merkle::from_base32(tag.as_bytes()) {
                    libpijul::changestore::filesystem::push_tag_filename(&mut tag_path, &h);

[119.211]

[62.3678]

                let h = if let Some(h) = pijul_core::Merkle::from_base32(tag.as_bytes()) {
                    pijul_core::changestore::filesystem::push_tag_filename(&mut tag_path, &h);

Replacement in pijul/src/commands/tag.rs at line 156 [62.74]

B:BD[62.4198] → [120.563:637]

∅:D[66.70] → [62.4457:4534]

∅:D[119.368] → [62.4457:4534]

∅:D[120.637] → [62.4457:4534]

B:BD[62.4457] → [62.4457:4534]

                let f = libpijul::tag::OpenTagFile::open(&tag_path, &h)?;
                libpijul::tag::restore_channel(f, &mut txn, &channel_name)?;

[62.4198]

[62.4534]

                let f = pijul_core::tag::OpenTagFile::open(&tag_path, &h)?;
                pijul_core::tag::restore_channel(f, &mut txn, &channel_name)?;

Replacement in pijul/src/commands/tag.rs at line 164 [62.74]

B:BD[119.430] → [120.638:820]

                let h = if let Some(h) = libpijul::Merkle::from_base32(tag.as_bytes()) {
                    libpijul::changestore::filesystem::push_tag_filename(&mut tag_path, &h);

[119.430]

[116.6006]

                let h = if let Some(h) = pijul_core::Merkle::from_base32(tag.as_bytes()) {
                    pijul_core::changestore::filesystem::push_tag_filename(&mut tag_path, &h);

Replacement in pijul/src/commands/tag.rs at line 171 [62.74]

B:BD[116.6132] → [119.483:558]

∅:D[117.71] → [116.6211:6267]

∅:D[119.558] → [116.6211:6267]

B:BD[116.6211] → [116.6211:6267]

                let tag = libpijul::tag::txn::TagTxn::new(&tag_path, &h)?;
                let txn = libpijul::tag::txn::WithTag {

[116.6132]

[116.6267]

                let tag = pijul_core::tag::txn::TagTxn::new(&tag_path, &h)?;
                let txn = pijul_core::tag::txn::WithTag {

Replacement in pijul/src/commands/tag.rs at line 179 [62.74]

B:BD[116.6458] → [116.6458:6523]

                libpijul::output::output_repository_no_pending_(

[116.6458]

[116.6523]

                pijul_core::output::output_repository_no_pending_(

Replacement in pijul/src/commands/tag.rs at line 198 [62.74]

B:BD[126.943] → [126.943:1125]

                let h = if let Some(h) = libpijul::Merkle::from_base32(tag.as_bytes()) {
                    libpijul::changestore::filesystem::push_tag_filename(&mut tag_path, &h);

[126.943]

[126.1125]

                let h = if let Some(h) = pijul_core::Merkle::from_base32(tag.as_bytes()) {
                    pijul_core::changestore::filesystem::push_tag_filename(&mut tag_path, &h);

Replacement in pijul/src/commands/tag.rs at line 227 [62.74]

∅:D[125.26959] → [120.936:1029]

B:BD[120.936] → [120.936:1029]

                    libpijul::changestore::filesystem::push_tag_filename(&mut tag_path, &m);

[125.26959]

[124.0]

                    pijul_core::changestore::filesystem::push_tag_filename(&mut tag_path, &m);

Replacement in pijul/src/commands/tag.rs at line 229 [62.74]

∅:D[124.55] → [120.1029:1111]

B:BD[120.1029] → [120.1029:1111]

                    let mut f = libpijul::tag::OpenTagFile::open(&tag_path, &m)?;

[124.55]

[63.1188]

                    let mut f = pijul_core::tag::OpenTagFile::open(&tag_path, &m)?;

Replacement in pijul/src/commands/tag.rs at line 235 [62.74]

B:BD[63.1582] → [80.0:84]

                    libpijul::changestore::filesystem::pop_filename(&mut tag_path);

[63.1582]

                    pijul_core::changestore::filesystem::pop_filename(&mut tag_path);

Replacement in pijul/src/commands/tag.rs at line 251 [62.74]
B:BD[73.686] → [75.13529:13563]
```
    use libpijul::change::Author;
```
[73.686]
[75.13563]
```
    use pijul_core::change::Author;
```

Replacement in pijul/src/commands/tag.rs at line 290 [62.74]

B:BD[79.931] → [79.931:983]

    let mut state = libpijul::RecordBuilder::new();

[79.821]

[79.983]

    let mut state = pijul_core::RecordBuilder::new();

Replacement in pijul/src/commands/tag.rs at line 293 [62.74]
B:BD[79.1014] → [79.1014:1054]
```
        libpijul::Algorithm::default(),
```
[79.1014]
[111.0]
```
        pijul_core::Algorithm::default(),
```
Replacement in pijul/src/commands/tag.rs at line 295 [62.74]
∅:D[111.15] → [99.246:284]
B:BD[79.1054] → [99.246:284]
```
        &libpijul::DEFAULT_SEPARATOR,
```
[111.15]
[79.1054]
```
        &pijul_core::DEFAULT_SEPARATOR,
```
Replacement in pijul/src/commands/status.rs at line 2 [197.189]
∅:D[217.18] → [198.0:20]
B:BD[197.221] → [198.0:20]
```
use libpijul::TxnT;
```
[217.18]
[198.20]
```
use pijul_core::TxnT;
```
Replacement in pijul/src/commands/reset.rs at line 11 [2.97650]
B:BD[206.79] → [226.1044:1070]
```
use libpijul::pristine::{
```
[206.79]
[226.1070]
```
use pijul_core::pristine::{
```

Replacement in pijul/src/commands/reset.rs at line 15 [2.97650]

∅:D[226.1150] → [218.195:278]

B:BD[218.195] → [218.195:278]

use libpijul::{ArcTxn, ChannelRef, ChannelTxnT, DepsTxnT, MutTxnT, TxnT, TxnTExt};

[226.1150]

[218.278]

use pijul_core::{ArcTxn, ChannelRef, ChannelTxnT, DepsTxnT, MutTxnT, TxnT, TxnTExt};

Replacement in pijul/src/commands/reset.rs at line 88 [2.97650]
B:BD[2.99409] → [53.6735:6778]
```
            libpijul::output::output_file(
```
[2.99409]
[2.99438]
```
            pijul_core::output::output_file(
```

Replacement in pijul/src/commands/reset.rs at line 93 [2.97650]

B:BD[2.99516] → [2.99516:99594]

                &mut libpijul::vertex_buffer::Writer::new(std::io::stdout()),

[2.99516]

[2.99594]

                &mut pijul_core::vertex_buffer::Writer::new(std::io::stdout()),

Replacement in pijul/src/commands/reset.rs at line 101 [2.97650]

B:BD[74.1051] → [174.379:429]

            .unwrap_or(libpijul::DEFAULT_CHANNEL)

[74.1051]

[74.1098]

            .unwrap_or(pijul_core::DEFAULT_CHANNEL)

Replacement in pijul/src/commands/reset.rs at line 141 [2.97650]
∅:D[184.472] → [53.8400:8464]
∅:D[83.4079] → [53.8400:8464]
B:BD[53.8400] → [53.8400:8464]
```
                libpijul::output::output_repository_no_pending(
```
[184.472]
[83.4080]
```
                pijul_core::output::output_repository_no_pending(
```

Replacement in pijul/src/commands/reset.rs at line 162 [2.97650]

B:BD[53.9311] → [83.4292:4424]

∅:D[83.4424] → [56.0:52]

B:BD[53.9504] → [56.0:52]

                let (a, b, s) =
                    libpijul::pristine::last_common_state(&*txn_, &*cur.read(), &*channel.read())?;
                let s: libpijul::Merkle = s.into();

[53.9311]

[53.9504]

                let (a, b, s) = pijul_core::pristine::last_common_state(
                    &*txn_,
                    &*cur.read(),
                    &*channel.read(),
                )?;
                let s: pijul_core::Merkle = s.into();

Replacement in pijul/src/commands/reset.rs at line 169 [2.97650]

B:BD[53.9557] → [56.53:117]

                let (a, b) = if s == libpijul::Merkle::zero() {

[53.9557]

[56.117]

                let (a, b) = if s == pijul_core::Merkle::zero() {

Replacement in pijul/src/commands/reset.rs at line 184 [2.97650]

B:BD[53.10047] → [83.4604:4703]

                    libpijul::fs::find_path(&repo.changes, &*txn_, &*channel.read(), false, *pos)?

[53.10047]

[53.10147]

                    pijul_core::fs::find_path(&repo.changes, &*txn_, &*channel.read(), false, *pos)?

Replacement in pijul/src/commands/reset.rs at line 205 [2.97650]

B:BD[91.75] → [91.75:143]

                    libpijul::output::output_repository_no_pending(

[91.75]

[91.143]

                    pijul_core::output::output_repository_no_pending(

Replacement in pijul/src/commands/reset.rs at line 229 [2.97650]

B:BD[91.1042] → [91.1042:1110]

                    libpijul::output::output_repository_no_pending(

[91.1042]

[91.1110]

                    pijul_core::output::output_repository_no_pending(

Replacement in pijul/src/commands/reset.rs at line 247 [2.97650]
∅:D[53.12467] → [23.6637:6691]
B:BD[2.101723] → [23.6637:6691]
```
        let locks = libpijul::TIMERS.lock().unwrap();
```
[53.12467]
[53.12468]
```
        let locks = pijul_core::TIMERS.lock().unwrap();
```

Replacement in pijul/src/commands/reset.rs at line 271 [2.97650]

B:BD[56.357] → [56.357:420]

    for x in libpijul::pristine::changeid_log(txn, chan, f)? {

[56.357]

[45.9746]

    for x in pijul_core::pristine::changeid_log(txn, chan, f)? {

Replacement in pijul/src/commands/reset.rs at line 298 [2.97650]
∅:D[185.293] → [184.662:714]
B:BD[184.662] → [184.662:714]
```
    let mut state = libpijul::RecordBuilder::new();
```
[185.293]
[184.714]
```
    let mut state = pijul_core::RecordBuilder::new();
```
Replacement in pijul/src/commands/reset.rs at line 301 [2.97650]
B:BD[184.745] → [184.745:785]
```
        libpijul::Algorithm::default(),
```
[184.745]
[184.785]
```
        pijul_core::Algorithm::default(),
```
Replacement in pijul/src/commands/reset.rs at line 303 [2.97650]
B:BD[184.800] → [184.800:838]
```
        &libpijul::DEFAULT_SEPARATOR,
```
[184.800]
[184.838]
```
        &pijul_core::DEFAULT_SEPARATOR,
```
Replacement in pijul/src/commands/record.rs at line 9 [2.101759]
B:BD[195.1374] → [218.348:348]
∅:D[207.18] → [2.101821:101876]
∅:D[218.348] → [2.101821:101876]
∅:D[99.399] → [2.101821:101876]
∅:D[189.659] → [2.101821:101876]
∅:D[195.1374] → [2.101821:101876]
∅:D[4.1503] → [2.101821:101876]
B:BD[2.101821] → [2.101821:101876]
B:BD[2.101876] → [53.12515:12531]
```
use libpijul::change::*;
use libpijul::changestore::*;
use libpijul::{
```
[195.1374]
[83.5019]
```
use log::debug;
use pijul_core::change::*;
use pijul_core::changestore::*;
use pijul_core::{
```
Replacement in pijul/src/commands/record.rs at line 15 [2.101759]
B:BD[53.12623] → [53.12623:12657]
B:BD[53.12657] → [73.1051:1067]
```
use libpijul::{HashMap, HashSet};
use log::debug;
```
[53.12623]
[2.102092]
```
use pijul_core::{HashMap, HashSet};
```

Replacement in pijul/src/commands/record.rs at line 141 [2.101759]

B:BD[43.506] → [83.5799:5883]

                Some(libpijul::working_copy::filesystem::FileSystem::from_root(w)),

[43.506]

[43.590]

                Some(pijul_core::working_copy::filesystem::FileSystem::from_root(
                    w,
                )),

Replacement in pijul/src/commands/record.rs at line 178 [2.101759]

∅:D[83.6076] → [75.14018:14084]

B:BD[55.1421] → [75.14018:14084]

                let mut path = repo.path.join(libpijul::DOT_DIR);

[83.6076]

[75.14084]

                let mut path = repo.path.join(pijul_core::DOT_DIR);

Replacement in pijul/src/commands/record.rs at line 282 [2.101759]

B:BD[53.13817] → [83.6296:6355]

        working_copy: &libpijul::working_copy::FileSystem,

[53.13817]

[2.106637]

        working_copy: &pijul_core::working_copy::FileSystem,

Replacement in pijul/src/commands/record.rs at line 286 [2.101759]
B:BD[2.106714] → [38.722:761]
```
        extra_deps: &[libpijul::Hash],
```
[2.106714]
[2.106714]
```
        extra_deps: &[pijul_core::Hash],
```

Replacement in pijul/src/commands/record.rs at line 292 [2.101759]

B:BD[68.628] → [68.628:683]

                HashMap<usize, libpijul::InodeUpdate>,

[68.628]

[68.723]

                HashMap<usize, pijul_core::InodeUpdate>,

Replacement in pijul/src/commands/record.rs at line 299 [2.101759]

B:BD[2.106908] → [2.106908:106964]

        let mut state = libpijul::RecordBuilder::new();

[2.106908]

[43.791]

        let mut state = pijul_core::RecordBuilder::new();

Replacement in pijul/src/commands/record.rs at line 307 [2.101759]
B:BD[220.277] → [220.277:319]
```
            libpijul::Algorithm::Patience
```
[220.277]
[220.319]
```
            pijul_core::Algorithm::Patience
```

Replacement in pijul/src/commands/record.rs at line 309 [2.101759]

B:BD[220.354] → [220.354:402]

            libpijul::Algorithm::ImaraHistogram

[220.354]

[220.402]

            pijul_core::Algorithm::ImaraHistogram

Replacement in pijul/src/commands/record.rs at line 311 [2.101759]
B:BD[220.419] → [220.419:462]
```
            libpijul::Algorithm::default()
```
[220.419]
[220.462]
```
            pijul_core::Algorithm::default()
```

Replacement in pijul/src/commands/record.rs at line 324 [2.101759]

∅:D[111.79] → [99.426:484]

B:BD[43.1329] → [99.426:484]

                            &libpijul::DEFAULT_SEPARATOR,

[111.79]

[53.13990]

                            &pijul_core::DEFAULT_SEPARATOR,

Replacement in pijul/src/commands/record.rs at line 338 [2.101759]
∅:D[111.107] → [99.485:535]
B:BD[43.1694] → [99.485:535]
```
                    &libpijul::DEFAULT_SEPARATOR,
```
[111.107]
[53.14196]
```
                    &pijul_core::DEFAULT_SEPARATOR,
```
Deletion in pijul/src/commands/pushpull.rs at line 14 [2.111631]
∅:D[218.569] → [2.111667:111707]
∅:D[4.1742] → [2.111667:111707]
B:BD[2.111667] → [2.111667:111707]
B:BD[89.18516] → [200.0:34]
B:BD[200.34] → [226.1357:1414]
∅:D[200.75] → [25.12857:12874]
∅:D[218.613] → [25.12857:12874]
∅:D[26.623] → [25.12857:12874]
∅:D[226.1414] → [25.12857:12874]
∅:D[89.18516] → [25.12857:12874]
B:BD[2.111707] → [25.12857:12874]
```
use libpijul::changestore::ChangeStore;
use libpijul::pristine::RemoteId;
use libpijul::pristine::sanakirja::{MutTxn, RawMutTxnT};
use libpijul::*;
```

Insertion in pijul/src/commands/pushpull.rs at line 15 [2.111631]

[233.10944]

[194.2571]

use pijul_core::changestore::ChangeStore;
use pijul_core::pristine::RemoteId;
use pijul_core::pristine::sanakirja::{MutTxn, RawMutTxnT};
use pijul_core::*;

Replacement in pijul/src/commands/pushpull.rs at line 723 [2.111631]

B:BD[202.1354] → [202.1354:1405]

            .unwrap_or(libpijul::DEFAULT_CHANNEL);

[202.1354]

[177.1400]

            .unwrap_or(pijul_core::DEFAULT_CHANNEL);

Replacement in pijul/src/commands/pushpull.rs at line 783 [2.111631]
∅:D[5.808] → [2.120336:120394]
∅:D[89.22307] → [2.120336:120394]
B:BD[2.120336] → [2.120336:120394]
```
            let mut ws = libpijul::ApplyWorkspace::new();
```
[89.22307]
[45.11732]
```
            let mut ws = pijul_core::ApplyWorkspace::new();
```

Replacement in pijul/src/commands/pushpull.rs at line 832 [2.111631]

B:BD[125.29851] → [125.29851:29920]

                            let ext = libpijul::pristine::Position {

[125.29851]

[125.29920]

                            let ext = pijul_core::pristine::Position {

Replacement in pijul/src/commands/pushpull.rs at line 854 [2.111631]

B:BD[83.10730] → [83.10730:10897]

                    if let Some((path, _)) =
                        libpijul::fs::find_path(&repo.changes, &*txn_, &*channel.read(), false, i)?
                    {

[83.10730]

[223.431]

                    if let Some((path, _)) = pijul_core::fs::find_path(
                        &repo.changes,
                        &*txn_,
                        &*channel.read(),
                        false,
                        i,
                    )? {

Replacement in pijul/src/commands/pushpull.rs at line 890 [2.111631]

B:BD[53.16573] → [53.16573:16641]

                    libpijul::output::output_repository_no_pending(

[53.16573]

[83.11076]

                    pijul_core::output::output_repository_no_pending(

Deletion in pijul/src/commands/protocol.rs at line 12 [2.123281]
B:BD[4.1961] → [25.15132:15149]
```
use libpijul::*;
```
Insertion in pijul/src/commands/protocol.rs at line 13 [2.123281]
[141.1145]
[177.1642]
```
use pijul_core::*;
```
Replacement in pijul/src/commands/protocol.rs at line 50 [2.123281]
B:BD[223.495] → [223.495:552]
```
type W = libpijul::working_copy::filesystem::FileSystem;
```
[223.495]
[2.124745]
```
type W = pijul_core::working_copy::filesystem::FileSystem;
```
Replacement in pijul/src/commands/protocol.rs at line 61 [2.123281]
∅:D[51.511] → [2.124930:124984]
∅:D[191.3565] → [2.124930:124984]
∅:D[83.11418] → [2.124930:124984]
B:BD[2.124930] → [2.124930:124984]
```
        let mut ws = libpijul::ApplyWorkspace::new();
```
[191.3565]
[2.125022]
```
        let mut ws = pijul_core::ApplyWorkspace::new();
```

Replacement in pijul/src/commands/protocol.rs at line 96 [2.123281]

B:BD[15.1272] → [45.12182:12250]

                                let m: libpijul::Merkle = m.into();

[15.1272]

[125.32519]

                                let m: pijul_core::Merkle = m.into();

Replacement in pijul/src/commands/protocol.rs at line 143 [2.123281]

B:BD[191.4055] → [191.4055:4153]

                            let h: libpijul::Hash = txn.get_external(&p.change)?.unwrap().into();

[191.4055]

[191.4153]

                            let h: pijul_core::Hash = txn.get_external(&p.change)?.unwrap().into();

Replacement in pijul/src/commands/protocol.rs at line 181 [2.123281]

B:BD[125.34351] → [125.34351:34536]

                    libpijul::changestore::filesystem::push_tag_filename(&mut tag_path, &state);
                    let mut tag = libpijul::tag::OpenTagFile::open(&tag_path, &state)?;

[125.34351]

[125.34536]

                    pijul_core::changestore::filesystem::push_tag_filename(&mut tag_path, &state);
                    let mut tag = pijul_core::tag::OpenTagFile::open(&tag_path, &state)?;

Replacement in pijul/src/commands/protocol.rs at line 192 [2.123281]

∅:D[208.502] → [121.209:305]

B:BD[121.209] → [121.209:305]

                    let m = libpijul::pristine::current_state(&*txn.read(), &*channel.read())?;

[208.502]

[121.305]

                    let m = pijul_core::pristine::current_state(&*txn.read(), &*channel.read())?;

Replacement in pijul/src/commands/protocol.rs at line 195 [2.123281]

B:BD[125.34988] → [125.34988:35085]

                        libpijul::changestore::filesystem::push_tag_filename(&mut tag_path, &m);

[125.34988]

[125.35085]

                        pijul_core::changestore::filesystem::push_tag_filename(&mut tag_path, &m);

Replacement in pijul/src/commands/protocol.rs at line 215 [2.123281]

B:BD[121.1332] → [125.35264:35365]

                        let header = libpijul::tag::read_short(std::io::Cursor::new(&buf[..]), &m)?;

[121.1332]

[125.35365]

                        let header =
                            pijul_core::tag::read_short(std::io::Cursor::new(&buf[..]), &m)?;

Replacement in pijul/src/commands/protocol.rs at line 222 [2.123281]

∅:D[125.35590] → [121.1398:1492]

B:BD[121.1398] → [121.1398:1492]

                        libpijul::tag::from_channel(&*txn.read(), &cap[2], &header, &mut w)?;

[125.35590]

[125.35591]

                        pijul_core::tag::from_channel(&*txn.read(), &cap[2], &header, &mut w)?;

Replacement in pijul/src/commands/protocol.rs at line 239 [2.123281]

B:BD[2.128478] → [2.128478:128571]

                libpijul::changestore::filesystem::push_filename(&mut repo.changes_dir, &h);

[2.128478]

[2.128571]

                pijul_core::changestore::filesystem::push_filename(&mut repo.changes_dir, &h);

Replacement in pijul/src/commands/protocol.rs at line 246 [2.123281]

B:BD[2.128902] → [2.128902:128974]

                    libpijul::change::Change::size_no_contents(&mut f)?

[2.128902]

[2.128974]

                    pijul_core::change::Change::size_no_contents(&mut f)?

Replacement in pijul/src/commands/protocol.rs at line 262 [2.123281]

B:BD[2.129500] → [2.129500:129588]

                libpijul::changestore::filesystem::pop_filename(&mut repo.changes_dir);

[2.129500]

[2.129588]

                pijul_core::changestore::filesystem::pop_filename(&mut repo.changes_dir);

Replacement in pijul/src/commands/protocol.rs at line 271 [2.123281]

B:BD[2.130015] → [2.130015:130096]

                libpijul::changestore::filesystem::push_filename(&mut path, &h);

[2.130015]

[36.0]

                pijul_core::changestore::filesystem::push_filename(&mut path, &h);

Replacement in pijul/src/commands/protocol.rs at line 277 [2.123281]

B:BD[2.130282] → [2.130282:130373]

                libpijul::change::Change::deserialize(&path.to_string_lossy(), Some(&h))?;

[2.130282]

[208.503]

                pijul_core::change::Change::deserialize(&path.to_string_lossy(), Some(&h))?;

Replacement in pijul/src/commands/protocol.rs at line 287 [2.123281]

B:BD[2.131024] → [2.131024:131090]

                let mut tarball = libpijul::output::Tarball::new(

[2.131024]

[2.131090]

                let mut tarball = pijul_core::output::Tarball::new(

Replacement in pijul/src/commands/protocol.rs at line 296 [2.123281]

B:BD[2.131473] → [7.3166:3356]

                    let state: libpijul::Merkle = hashes.next().unwrap().parse().unwrap();
                    let extra: Vec<libpijul::Hash> = hashes.map(|x| x.parse().unwrap()).collect();

[2.131473]

[2.131707]

                    let state: pijul_core::Merkle = hashes.next().unwrap().parse().unwrap();
                    let extra: Vec<pijul_core::Hash> = hashes.map(|x| x.parse().unwrap()).collect();

Replacement in pijul/src/commands/protocol.rs at line 366 [2.123281]

B:BD[53.18176] → [53.18176:18236]

            libpijul::output::output_repository_no_pending(

[53.18176]

[83.12663]

            pijul_core::output::output_repository_no_pending(

Replacement in pijul/src/commands/mod.rs at line 82 [2.133619]

B:BD[11.1687] → [53.18607:18685]

B:BD[53.18685] → [83.12749:12779]

∅:D[83.12779] → [53.18732:18771]

B:BD[53.18732] → [53.18732:18771]

fn pending<T: libpijul::MutTxnTExt + libpijul::TxnT + Send + Sync + 'static>(
    txn: libpijul::ArcTxn<T>,
    channel: &libpijul::ChannelRef<T>,

[11.1687]

[177.1677]

fn pending<T: pijul_core::MutTxnTExt + pijul_core::TxnT + Send + Sync + 'static>(
    txn: pijul_core::ArcTxn<T>,
    channel: &pijul_core::ChannelRef<T>,

Replacement in pijul/src/commands/mod.rs at line 86 [2.133619]

∅:D[177.1722] → [11.1847:1944]

B:BD[11.1847] → [11.1847:1944]

) -> Result<Option<libpijul::Hash>, anyhow::Error> {
    use libpijul::changestore::ChangeStore;

[177.1722]

[53.18772]

) -> Result<Option<pijul_core::Hash>, anyhow::Error> {
    use pijul_core::changestore::ChangeStore;

Replacement in pijul/src/commands/mod.rs at line 89 [2.133619]

B:BD[53.18773] → [53.18773:18829]

    let mut builder = libpijul::record::Builder::new();

[53.18773]

[53.18829]

    let mut builder = pijul_core::record::Builder::new();

Replacement in pijul/src/commands/mod.rs at line 92 [2.133619]
∅:D[53.18870] → [11.1979:2019]
B:BD[11.1979] → [11.1979:2019]
```
        libpijul::Algorithm::default(),
```
[53.18870]
[111.108]
```
        pijul_core::Algorithm::default(),
```
Replacement in pijul/src/commands/mod.rs at line 94 [2.133619]
∅:D[111.123] → [99.777:815]
B:BD[11.2019] → [99.777:815]
```
        &libpijul::DEFAULT_SEPARATOR,
```
[111.123]
[53.18871]
```
        &pijul_core::DEFAULT_SEPARATOR,
```
Replacement in pijul/src/commands/mod.rs at line 116 [2.133619]
∅:D[53.19245] → [11.2303:2371]
B:BD[11.2303] → [11.2303:2371]
```
    let mut pending_change = libpijul::change::Change::make_change(
```
[53.19245]
[53.19246]
```
    let mut pending_change = pijul_core::change::Change::make_change(
```
Replacement in pijul/src/commands/mod.rs at line 121 [2.133619]
∅:D[53.19280] → [11.2445:2496]
B:BD[11.2445] → [11.2445:2496]
```
        libpijul::change::ChangeHeader::default(),
```
[53.19280]
[11.2496]
```
        pijul_core::change::ChangeHeader::default(),
```

Replacement in pijul/src/commands/mod.rs at line 125 [2.133619]

B:BD[11.2561] → [83.12865:12962]

        libpijul::change::dependencies(&*txn, &*channel.read(), pending_change.changes.iter())?;

[11.2561]

[11.2646]

        pijul_core::change::dependencies(&*txn, &*channel.read(), pending_change.changes.iter())?;

Replacement in pijul/src/commands/mod.rs at line 186 [2.133619]

B:BD[22.3060] → [22.3060:3119]

fn make_changelist<S: libpijul::changestore::ChangeStore>(

[22.3060]

[22.3119]

fn make_changelist<S: pijul_core::changestore::ChangeStore>(

Replacement in pijul/src/commands/mod.rs at line 191 [2.133619]
B:BD[22.3223] → [22.3223:3249]
```
    use libpijul::Base32;
```
[22.3223]
[22.3249]
```
    use pijul_core::Base32;
```
Replacement in pijul/src/commands/mod.rs at line 262 [2.133619]
∅:D[178.354] → [22.4995:5021]
∅:D[131.455] → [22.4995:5021]
∅:D[125.36562] → [22.4995:5021]
B:BD[22.4995] → [22.4995:5021]
```
    use libpijul::Base32;
```
[178.354]
[131.456]
```
    use pijul_core::Base32;
```

Replacement in pijul/src/commands/mod.rs at line 270 [2.133619]

B:BD[125.36684] → [125.36684:36748]

                    libpijul::Merkle::from_base32(l.as_bytes())

[125.36684]

[125.36748]

                    pijul_core::Merkle::from_base32(l.as_bytes())

Replacement in pijul/src/commands/mod.rs at line 272 [2.133619]

B:BD[125.36767] → [178.355:453]

                let h_ = libpijul::Hash::from_base32(l.as_bytes()).map(pijul_remote::CS::Change);

[125.36767]

[131.630]

                let h_ = pijul_core::Hash::from_base32(l.as_bytes()).map(pijul_remote::CS::Change);

Replacement in pijul/src/commands/mod.rs at line 278 [2.133619]

B:BD[125.37043] → [178.454:548]

                libpijul::Merkle::from_base32(&l.as_bytes()[..]).map(pijul_remote::CS::State)

[125.37043]

                pijul_core::Merkle::from_base32(&l.as_bytes()[..]).map(pijul_remote::CS::State)

Replacement in pijul/src/commands/mod.rs at line 286 [2.133619]
B:BD[81.69] → [120.1179:1214]
```
fn find_hash<B: libpijul::Base32>(
```
[75.20228]
[120.1214]
```
fn find_hash<B: pijul_core::Base32>(
```
Replacement in pijul/src/commands/mod.rs at line 324 [2.133619]
B:BD[91.1593] → [216.29:73]
```
use libpijul::{ChannelRef, Conflict, TxnT};
```
[91.1593]
[91.1617]
```
use pijul_core::{ChannelRef, Conflict, TxnT};
```

Replacement in pijul/src/commands/mod.rs at line 370 [2.133619]

B:BD[216.241] → [216.241:298]

    (ch.unwrap_or(libpijul::DEFAULT_CHANNEL), ch == cur)

[216.241]

[22.5215]

    (ch.unwrap_or(pijul_core::DEFAULT_CHANNEL), ch == cur)

Replacement in pijul/src/commands/log.rs at line 17 [2.134376]
∅:D[209.104] → [2.134430:134460]
∅:D[99.834] → [2.134430:134460]
∅:D[189.1113] → [2.134430:134460]
∅:D[218.1439] → [2.134430:134460]
∅:D[195.1720] → [2.134430:134460]
∅:D[4.2104] → [2.134430:134460]
B:BD[2.134430] → [2.134430:134460]
B:BD[2.134460] → [116.7018:7044]
```
use libpijul::changestore::*;
use libpijul::pristine::{
```
[218.1439]
[194.3286]
```
use pijul_core::changestore::*;
use pijul_core::pristine::{
```
Replacement in pijul/src/commands/log.rs at line 21 [2.134376]
B:BD[116.7127] → [209.105:138]
```
use libpijul::{Base32, TxnTExt};
```
[116.7127]
[177.1723]
```
use pijul_core::{Base32, TxnTExt};
```

Replacement in pijul/src/commands/log.rs at line 74 [2.134376]

B:BD[96.1394] → [96.1394:1455]

        let mut id_path = repo.path.join(libpijul::DOT_DIR);

[96.1394]

[96.1455]

        let mut id_path = repo.path.join(pijul_core::DOT_DIR);

Replacement in pijul/src/commands/log.rs at line 96 [2.134376]

B:BD[96.1888] → [96.1888:1952]

    Txn(#[from] libpijul::pristine::sanakirja::SanakirjaError),

[96.1888]

[96.1952]

    Txn(#[from] pijul_core::pristine::sanakirja::SanakirjaError),

Replacement in pijul/src/commands/log.rs at line 98 [2.134376]

B:BD[96.1978] → [96.1978:2053]

    TxnErr(#[from] TxnErr<libpijul::pristine::sanakirja::SanakirjaError>),

[96.1978]

[96.2053]

    TxnErr(#[from] TxnErr<pijul_core::pristine::sanakirja::SanakirjaError>),

Replacement in pijul/src/commands/log.rs at line 100 [2.134376]

B:BD[96.2079] → [116.7128:7205]

    TreeErr(#[from] TreeErr<libpijul::pristine::sanakirja::SanakirjaError>),

[96.2079]

[116.7205]

    TreeErr(#[from] TreeErr<pijul_core::pristine::sanakirja::SanakirjaError>),

Replacement in pijul/src/commands/log.rs at line 102 [2.134376]

B:BD[116.7231] → [116.7231:7302]

    Fs(#[from] libpijul::FsError<libpijul::pristine::sanakirja::Txn>),

[116.7231]

[96.2161]

    Fs(#[from] pijul_core::FsError<pijul_core::pristine::sanakirja::Txn>),

Replacement in pijul/src/commands/log.rs at line 119 [2.134376]

B:BD[96.2682] → [96.2682:2748]

    Filesystem(#[from] libpijul::changestore::filesystem::Error),

[96.2682]

[96.2748]

    Filesystem(#[from] pijul_core::changestore::filesystem::Error),

Replacement in pijul/src/commands/log.rs at line 131 [2.134376]

B:BD[112.55] → [112.55:146]

        libpijul::Inode,
        Option<libpijul::pristine::Position<libpijul::ChangeId>>,

[112.55]

[112.146]

        pijul_core::Inode,
        Option<pijul_core::pristine::Position<pijul_core::ChangeId>>,

Replacement in pijul/src/commands/log.rs at line 160 [2.134376]

B:BD[112.202] → [112.202:265]

                let inode = libpijul::fs::find_inode(txn, s)?;

[112.202]

[112.265]

                let inode = pijul_core::fs::find_inode(txn, s)?;

Replacement in pijul/src/commands/log.rs at line 195 [2.134376]
B:BD[95.636] → [95.636:662]
```
    Hash(libpijul::Hash),
```
[95.636]
[94.5364]
```
    Hash(pijul_core::Hash),
```

Replacement in pijul/src/commands/log.rs at line 386 [2.134376]

∅:D[127.918] → [94.12405:12469]

B:BD[94.12405] → [94.12405:12469]

        h: libpijul::Hash,
        m: Option<libpijul::Merkle>,

[94.12405]

[96.3744]

        h: pijul_core::Hash,
        m: Option<pijul_core::Merkle>,

Replacement in pijul/src/commands/init.rs at line 4 [2.136543]
∅:D[99.1006] → [7.3397:3420]
∅:D[189.1212] → [7.3397:3420]
B:BD[4.2201] → [7.3397:3420]
```
use libpijul::MutTxnT;
```
[189.1212]
[4.2234]
```
use pijul_core::MutTxnT;
```

Replacement in pijul/src/commands/init.rs at line 33 [2.136543]

B:BD[15.1700] → [174.788:859]

            .unwrap_or_else(|| libpijul::DEFAULT_CHANNEL.to_string());

[15.1700]

[2.137015]

            .unwrap_or_else(|| pijul_core::DEFAULT_CHANNEL.to_string());

Replacement in pijul/src/commands/identity.rs at line 406 [140.40825]

B:BD[140.53205] → [140.53205:53296]

                                    libpijul::key::Encryption::Aes128(_) => "AES 128-bit",

[140.53205]

[140.53296]

                                    pijul_core::key::Encryption::Aes128(_) => "AES 128-bit",

Deletion in pijul/src/commands/git.rs at line 3 [2.137210]
∅:D[133.18] → [68.888:932]
∅:D[99.1066] → [68.888:932]
∅:D[189.1514] → [68.888:932]
B:BD[68.888] → [68.888:932]
```
use libpijul::pristine::*;
use libpijul::*;
```
Insertion in pijul/src/commands/git.rs at line 4 [2.137210]
[68.970]
[139.0]
```
use pijul_core::pristine::*;
use pijul_core::*;
```

Replacement in pijul/src/commands/git.rs at line 81 [2.137210]

B:BD[2.138447] → [2.138447:138509]

        let mut path_git = repo.path.join(libpijul::DOT_DIR);

[2.138447]

[2.138509]

        let mut path_git = repo.path.join(pijul_core::DOT_DIR);

Replacement in pijul/src/commands/git.rs at line 105 [2.137210]

B:BD[164.223] → [164.223:372]

                libpijul::output::output_repository_no_pending(
                    &libpijul::working_copy::FileSystem::from_root(&repo.repo.path),

[164.223]

[164.372]

                pijul_core::output::output_repository_no_pending(
                    &pijul_core::working_copy::FileSystem::from_root(&repo.repo.path),

Replacement in pijul/src/commands/git.rs at line 126 [2.137210]

B:BD[2.139340] → [7.3455:3509]

    root: Vec<(git2::Oid, Option<libpijul::Merkle>)>,

[2.139340]

[2.139404]

    root: Vec<(git2::Oid, Option<pijul_core::Merkle>)>,

Replacement in pijul/src/commands/git.rs at line 147 [2.137210]

B:BD[2.140110] → [181.0:94]

        let db: ::sanakirja::btree::UDb<Oid, libpijul::pristine::SerializedMerkle> = unsafe {

[2.140110]

[46.453]

        let db: ::sanakirja::btree::UDb<Oid, pijul_core::pristine::SerializedMerkle> = unsafe {

Replacement in pijul/src/commands/git.rs at line 279 [2.137210]
B:BD[2.143978] → [2.143978:144028]
```
    let mut ws = libpijul::ApplyWorkspace::new();
```
[2.143978]
[2.144028]
```
    let mut ws = pijul_core::ApplyWorkspace::new();
```

Replacement in pijul/src/commands/git.rs at line 292 [2.137210]

B:BD[29.256] → [46.1006:1065]

            let merkle_: libpijul::Merkle = (&p.b).into();

[29.256]

[2.144447]

            let merkle_: pijul_core::Merkle = (&p.b).into();

Replacement in pijul/src/commands/git.rs at line 375 [2.137210]
B:BD[2.147667] → [7.3686:3715]
```
    state: libpijul::Merkle,
```
[2.147667]
[2.147706]
```
    state: pijul_core::Merkle,
```

Replacement in pijul/src/commands/git.rs at line 379 [2.137210]

B:BD[2.147840] → [181.165:259]

    let mut db: ::sanakirja::btree::UDb<Oid, libpijul::pristine::SerializedMerkle> = unsafe {

[2.147840]

[46.1214]

    let mut db: ::sanakirja::btree::UDb<Oid, pijul_core::pristine::SerializedMerkle> = unsafe {

Replacement in pijul/src/commands/git.rs at line 398 [2.137210]

B:BD[2.148275] → [30.0:65]

) -> Result<(bool, Vec<(libpijul::Hash, u64)>), anyhow::Error> {

[2.148275]

[2.148327]

) -> Result<(bool, Vec<(pijul_core::Hash, u64)>), anyhow::Error> {

Replacement in pijul/src/commands/git.rs at line 419 [2.137210]

B:BD[29.632] → [46.1492:1542]

                let h: libpijul::Hash = h.into();

[29.632]

[46.1542]

                let h: pijul_core::Hash = h.into();

Replacement in pijul/src/commands/git.rs at line 446 [2.137210]
B:BD[2.149927] → [2.149927:149966]
```
    ws: &mut libpijul::ApplyWorkspace,
```
[2.149927]
[2.149966]
```
    ws: &mut pijul_core::ApplyWorkspace,
```

Replacement in pijul/src/commands/git.rs at line 477 [2.137210]

B:BD[2.151291] → [54.2579:2635]

B:BD[54.2635] → [138.107:152]

        libpijul::output::output_repository_no_pending(
            &libpijul::working_copy::sink(),

[2.151291]

[2.151374]

        pijul_core::output::output_repository_no_pending(
            &pijul_core::working_copy::sink(),

Replacement in pijul/src/commands/git.rs at line 561 [2.137210]

B:BD[46.1756] → [68.1095:1196]

                                if let Some(old_path) = libpijul::fs::inode_filename(&*txn, *inode)?

[46.1756]

[68.1196]

                                if let Some(old_path) =
                                    pijul_core::fs::inode_filename(&*txn, *inode)?

Replacement in pijul/src/commands/git.rs at line 642 [2.137210]

B:BD[138.778] → [138.778:844]

impl<'a> libpijul::working_copy::WorkingCopyRead for Commit<'a> {

[138.778]

[138.844]

impl<'a> pijul_core::working_copy::WorkingCopyRead for Commit<'a> {

Replacement in pijul/src/commands/git.rs at line 691 [2.137210]
B:BD[2.157761] → [7.3911:3958]
```
) -> Result<libpijul::Merkle, anyhow::Error> {
```
[2.157761]
[139.1653]
```
) -> Result<pijul_core::Merkle, anyhow::Error> {
```

Replacement in pijul/src/commands/git.rs at line 705 [2.137210]

B:BD[138.2355] → [138.2355:2428]

            let (tracked, pos) = libpijul::fs::get_vertex(&*txn_, &p_)?;

[138.2355]

[138.2428]

            let (tracked, pos) = pijul_core::fs::get_vertex(&*txn_, &p_)?;

Replacement in pijul/src/commands/git.rs at line 764 [2.137210]
∅:D[138.3147] → [2.158632:158673]
B:BD[2.158632] → [2.158632:158673]
```
        libpijul::change::ChangeHeader {
```
[138.3147]
[60.377]
```
        pijul_core::change::ChangeHeader {
```

Replacement in pijul/src/commands/git.rs at line 766 [2.137210]

B:BD[60.398] → [76.285:346]

            authors: vec![libpijul::change::Author(author)],

[60.398]

[68.1332]

            authors: vec![pijul_core::change::Author(author)],

Replacement in pijul/src/commands/git.rs at line 784 [2.137210]

B:BD[2.159258] → [17.266:343]

        Err(libpijul::LocalApplyError::ChangeAlreadyOnChannel { hash }) => {

[2.159258]

[17.343]

        Err(pijul_core::LocalApplyError::ChangeAlreadyOnChannel { hash }) => {

Replacement in pijul/src/commands/git.rs at line 807 [2.137210]

B:BD[138.3184] → [138.3184:3291]

    C: libpijul::changestore::ChangeStore + Clone,
    W: libpijul::working_copy::WorkingCopyRead + Clone,

[138.3184]

[68.1622]

    C: pijul_core::changestore::ChangeStore + Clone,
    W: pijul_core::working_copy::WorkingCopyRead + Clone,

Replacement in pijul/src/commands/git.rs at line 815 [2.137210]
∅:D[138.3355] → [2.160635:160679]
B:BD[2.160635] → [2.160635:160679]
```
    header: libpijul::change::ChangeHeader,
```
[138.3355]
[132.16]
```
    header: pijul_core::change::ChangeHeader,
```

Replacement in pijul/src/commands/git.rs at line 817 [2.137210]

B:BD[132.39] → [138.3356:3449]

) -> Result<(usize, Option<libpijul::Hash>, libpijul::Merkle), libpijul::LocalApplyError<T>>

[132.39]

[138.3449]

) -> Result<(usize, Option<pijul_core::Hash>, pijul_core::Merkle), pijul_core::LocalApplyError<T>>

Replacement in pijul/src/commands/git.rs at line 823 [2.137210]
∅:D[132.89] → [2.160829:160881]
∅:D[109.128] → [2.160829:160881]
∅:D[21.396] → [2.160829:160881]
∅:D[17.646] → [2.160829:160881]
∅:D[29.1006] → [2.160829:160881]
∅:D[7.4047] → [2.160829:160881]
B:BD[2.160829] → [2.160829:160881]
```
    let mut state = libpijul::RecordBuilder::new();
```
[132.89]
[138.3481]
```
    let mut state = pijul_core::RecordBuilder::new();
```

Replacement in pijul/src/commands/git.rs at line 834 [2.137210]

B:BD[138.3720] → [138.3720:3768]

                libpijul::Algorithm::default(),

[138.3720]

[138.3768]

                pijul_core::Algorithm::default(),

Replacement in pijul/src/commands/git.rs at line 836 [2.137210]

B:BD[138.3791] → [138.3791:3837]

                &libpijul::DEFAULT_SEPARATOR,

[138.3791]

[138.3837]

                &pijul_core::DEFAULT_SEPARATOR,

Replacement in pijul/src/commands/git.rs at line 849 [2.137210]

B:BD[138.4102] → [138.4102:4150]

                libpijul::Algorithm::default(),

[138.4102]

[138.4150]

                pijul_core::Algorithm::default(),

Replacement in pijul/src/commands/git.rs at line 851 [2.137210]

B:BD[138.4173] → [138.4173:4219]

                &libpijul::DEFAULT_SEPARATOR,

[138.4173]

[138.4219]

                &pijul_core::DEFAULT_SEPARATOR,

Replacement in pijul/src/commands/git.rs at line 871 [2.137210]

B:BD[30.1614] → [83.15495:15576]

∅:D[30.1695] → [2.161362:161427]

∅:D[54.5254] → [2.161362:161427]

∅:D[83.15576] → [2.161362:161427]

B:BD[2.161362] → [2.161362:161427]

        libpijul::change::dependencies(&*txn, &channel.read(), actions.iter())?;
    let mut change = libpijul::change::LocalChange::make_change(

[30.1614]

[54.5255]

        pijul_core::change::dependencies(&*txn, &channel.read(), actions.iter())?;
    let mut change = pijul_core::change::LocalChange::make_change(

Replacement in pijul/src/commands/git.rs at line 909 [2.137210]
B:BD[2.162231] → [7.4048:4082]
```
    hash: Option<libpijul::Hash>,
```
[2.162231]
[2.162275]
```
    hash: Option<pijul_core::Hash>,
```
Replacement in pijul/src/commands/git.rs at line 969 [2.137210]
B:BD[2.163932] → [2.163932:163977]
```
        let timers = libpijul::get_timers();
```
[2.163932]
[2.163977]
```
        let timers = pijul_core::get_timers();
```
Replacement in pijul/src/commands/git.rs at line 1003 [2.137210]
B:BD[2.165113] → [2.165113:165147]
```
        libpijul::reset_timers();
```
[2.165113]
[2.165147]
```
        pijul_core::reset_timers();
```
Replacement in pijul/src/commands/fork.rs at line 4 [2.167873]
∅:D[210.18] → [186.0:73]
∅:D[190.64] → [186.0:73]
B:BD[99.1111] → [186.0:73]
```
use libpijul::{Base32, ChannelTxnT, MutTxnT, MutTxnTExt, TxnT, TxnTExt};
```
[210.18]
[4.2367]
```
use pijul_core::{Base32, ChannelTxnT, MutTxnT, MutTxnTExt, TxnT, TxnTExt};
```

Replacement in pijul/src/commands/fork.rs at line 45 [2.167873]

B:BD[186.1184] → [186.1184:1271]

                if let Some(state) = libpijul::Merkle::from_base32(state.as_bytes()) {

[186.1184]

[186.1271]

                if let Some(state) = pijul_core::Merkle::from_base32(state.as_bytes()) {

Replacement in pijul/src/commands/file_operations.rs at line 9 [2.169058]
B:BD[203.44] → [218.1440:1486]
```
use libpijul::{MutTxnT, MutTxnTExt, TxnTExt};
```
[203.44]
[177.1845]
```
use pijul_core::{MutTxnT, MutTxnTExt, TxnTExt};
```

Replacement in pijul/src/commands/file_operations.rs at line 158 [2.169058]

B:BD[31.86] → [31.86:157]

                && !libpijul::working_copy::filesystem::filter_ignore(

[31.86]

[31.157]

                && !pijul_core::working_copy::filesystem::filter_ignore(

Replacement in pijul/src/commands/file_operations.rs at line 167 [2.169058]

B:BD[16.281] → [16.281:340]

                use libpijul::working_copy::filesystem::*;

[16.281]

[59.0]

                use pijul_core::working_copy::filesystem::*;

Replacement in pijul/src/commands/diff.rs at line 7 [2.173551]
∅:D[204.18] → [4.2570:2595]
∅:D[99.1294] → [4.2570:2595]
∅:D[189.1891] → [4.2570:2595]
B:BD[4.2570] → [4.2570:2595]
B:BD[4.2595] → [204.19:53]
```
use libpijul::change::*;
use libpijul::{MutTxnT, TxnTExt};
```
[204.18]
[4.2654]
```
use pijul_core::change::*;
use pijul_core::{MutTxnT, TxnTExt};
```

Replacement in pijul/src/commands/diff.rs at line 63 [2.173551]

B:BD[2.174399] → [2.174399:174455]

        let mut state = libpijul::RecordBuilder::new();

[2.174399]

[220.692]

        let mut state = pijul_core::RecordBuilder::new();

Replacement in pijul/src/commands/diff.rs at line 68 [2.173551]
B:BD[220.851] → [220.851:893]
```
            libpijul::Algorithm::Patience
```
[220.851]
[220.893]
```
            pijul_core::Algorithm::Patience
```

Replacement in pijul/src/commands/diff.rs at line 70 [2.173551]

B:BD[220.928] → [220.928:976]

            libpijul::Algorithm::ImaraHistogram

[220.928]

[220.976]

            pijul_core::Algorithm::ImaraHistogram

Replacement in pijul/src/commands/diff.rs at line 72 [2.173551]
B:BD[220.993] → [220.993:1036]
```
            libpijul::Algorithm::default()
```
[220.993]
[220.1036]
```
            pijul_core::Algorithm::default()
```
Replacement in pijul/src/commands/diff.rs at line 79 [2.173551]
∅:D[118.28] → [99.1321:1367]
∅:D[111.146] → [99.1321:1367]
B:BD[2.174593] → [99.1321:1367]
```
                &libpijul::DEFAULT_SEPARATOR,
```
[118.28]
[53.20139]
```
                &pijul_core::DEFAULT_SEPARATOR,
```

Replacement in pijul/src/commands/diff.rs at line 255 [2.173551]

B:BD[53.20834] → [53.20834:20893]

                Err(libpijul::change::TextSerError::Io(e))

[53.20834]

[53.20893]

                Err(pijul_core::change::TextSerError::Io(e))

Replacement in pijul/src/commands/diff.rs at line 261 [2.173551]
B:BD[128.494] → [128.494:536]
```
            use libpijul::ChannelMutTxnT;
```
[128.494]
[187.1124]
```
            use pijul_core::ChannelMutTxnT;
```

Replacement in pijul/src/commands/diff.rs at line 305 [2.173551]

B:BD[42.795] → [42.795:877]

impl<W: termcolor::WriteColor> libpijul::change::WriteChangeLine for Colored<W> {

[42.795]

[42.877]

impl<W: termcolor::WriteColor> pijul_core::change::WriteChangeLine for Colored<W> {

Replacement in pijul/src/commands/diff.rs at line 368 [2.173551]
B:BD[219.801] → [219.801:831]
```
    txn: libpijul::ArcTxn<T>,
```
[219.801]
[219.831]
```
    txn: pijul_core::ArcTxn<T>,
```
Replacement in pijul/src/commands/diff.rs at line 379 [2.173551]
B:BD[85.2241] → [187.1313:1343]
```
    txn: libpijul::ArcTxn<T>,
```
[85.2241]
[187.1343]
```
    txn: pijul_core::ArcTxn<T>,
```
Replacement in pijul/src/commands/dependents.rs at line 2 [156.243]
∅:D[211.18] → [156.306:323]
∅:D[189.1990] → [156.306:323]
B:BD[156.306] → [156.306:323]
```
use libpijul::*;
```
[211.18]
[171.1685]
```
use pijul_core::*;
```
Deletion in pijul/src/commands/debug.rs at line 4 [2.177758]
B:BD[212.103] → [212.103:126]
```
use libpijul::TxnTExt;
```
Insertion in pijul/src/commands/debug.rs at line 5 [2.177758]
[165.12]
[182.544]
```
use pijul_core::TxnTExt;
```

Replacement in pijul/src/commands/debug.rs at line 28 [2.177758]

B:BD[53.21126] → [53.21126:21178]

B:BD[53.21178] → [107.0:101]

∅:D[107.101] → [53.21178:21348]

B:BD[53.21178] → [53.21178:21348]

B:BD[53.21348] → [75.24193:24246]

            libpijul::pristine::debug_inodes(&txn);
            libpijul::pristine::debug_dep(&txn);
            libpijul::pristine::debug_revdep(&txn);
            libpijul::pristine::debug_revinodes(&txn);
            libpijul::pristine::debug_tree_print(&txn);
            libpijul::pristine::debug_revtree_print(&txn);
            libpijul::pristine::debug_remotes(&txn);

[53.21126]

[53.21348]

            pijul_core::pristine::debug_inodes(&txn);
            pijul_core::pristine::debug_dep(&txn);
            pijul_core::pristine::debug_revdep(&txn);
            pijul_core::pristine::debug_revinodes(&txn);
            pijul_core::pristine::debug_tree_print(&txn);
            pijul_core::pristine::debug_revtree_print(&txn);
            pijul_core::pristine::debug_remotes(&txn);

Replacement in pijul/src/commands/debug.rs at line 39 [2.177758]

B:BD[165.126] → [165.126:198]

                    let inode = libpijul::fs::find_inode(&txn, &root)?;

[165.126]

[165.198]

                    let inode = pijul_core::fs::find_inode(&txn, &root)?;

Replacement in pijul/src/commands/debug.rs at line 41 [2.177758]

B:BD[165.247] → [165.247:291]

                    use libpijul::TreeTxnT;

[165.247]

[165.291]

                    use pijul_core::TreeTxnT;

Replacement in pijul/src/commands/debug.rs at line 51 [2.177758]
∅:D[152.74] → [53.21530:21578]
∅:D[182.547] → [53.21530:21578]
∅:D[165.670] → [53.21530:21578]
∅:D[171.1882] → [53.21530:21578]
B:BD[53.21530] → [53.21530:21578]
```
                libpijul::pristine::debug_root(
```
[182.547]
[53.21578]
```
                pijul_core::pristine::debug_root(
```

Replacement in pijul/src/commands/debug.rs at line 60 [2.177758]

B:BD[83.16568] → [106.374:453]

                libpijul::pristine::debug(&txn, &channel, std::io::stdout())?;

[83.16568]

[53.21926]

                pijul_core::pristine::debug(&txn, &channel, std::io::stdout())?;

Replacement in pijul/src/commands/debug.rs at line 62 [2.177758]

B:BD[53.21940] → [83.16569:16663]

            libpijul::pristine::check_alive_debug(&repo.changes, &txn, &*channel.read(), 0)?;

[53.21940]

[18.177]

            pijul_core::pristine::check_alive_debug(&repo.changes, &txn, &*channel.read(), 0)?;

Replacement in pijul/src/commands/debug.rs at line 75 [2.177758]

B:BD[165.680] → [165.680:774]

fn parse_pos(s: &str) -> Option<libpijul::pristine::Position<libpijul::pristine::ChangeId>> {

[165.680]

[165.774]

fn parse_pos(s: &str) -> Option<pijul_core::pristine::Position<pijul_core::pristine::ChangeId>> {

Replacement in pijul/src/commands/debug.rs at line 78 [2.177758]

B:BD[170.1752] → [170.1752:1830]

        use libpijul::pristine::{Base32, ChangeId, ChangePosition, Position};

[170.1752]

[165.939]

        use pijul_core::pristine::{Base32, ChangeId, ChangePosition, Position};

Deletion in pijul/src/commands/credit.rs at line 6 [2.178684]
∅:D[189.2209] → [146.0:40]
B:BD[99.1431] → [146.0:40]
B:BD[146.40] → [194.5942:6003]
∅:D[146.101] → [25.18103:18120]
∅:D[194.6003] → [25.18103:18120]
B:BD[2.178851] → [25.18103:18120]
```
use libpijul::changestore::ChangeStore;
use libpijul::vertex_buffer::{VertexBuffer, change_message};
use libpijul::*;
```

Insertion in pijul/src/commands/credit.rs at line 7 [2.178684]

[4.2844]

[2.178929]

use pijul_core::changestore::ChangeStore;
use pijul_core::vertex_buffer::{VertexBuffer, change_message};
use pijul_core::*;

Replacement in pijul/src/commands/credit.rs at line 51 [2.178684]
∅:D[136.360] → [64.0:45]
∅:D[134.1111] → [64.0:45]
∅:D[83.16741] → [64.0:45]
B:BD[53.22212] → [64.0:45]
```
        match libpijul::output::output_file(
```
[136.360]
[2.180309]
```
        match pijul_core::output::output_file(
```

Replacement in pijul/src/commands/credit.rs at line 59 [2.178684]

∅:D[68.1774] → [65.0:58]

B:BD[64.83] → [65.0:58]

            Err(libpijul::output::FileError::Io(io)) => {

[68.1774]

[65.58]

            Err(pijul_core::output::FileError::Io(io)) => {

Deletion in pijul/src/commands/clone.rs at line 5 [2.182891]
∅:D[189.2355] → [110.0:41]
B:BD[99.1476] → [110.0:41]
```
use libpijul::{ChannelMutTxnT, MutTxnT};
```
Insertion in pijul/src/commands/clone.rs at line 6 [2.182891]
[4.2958]
[177.2002]
```
use pijul_core::{ChannelMutTxnT, MutTxnT};
```

Replacement in pijul/src/commands/clone.rs at line 12 [2.182891]

B:BD[8.4661] → [174.1198:1271]

    #[clap(long = "channel", default_value = libpijul::DEFAULT_CHANNEL)]

[8.4661]

[2.183267]

    #[clap(long = "channel", default_value = pijul_core::DEFAULT_CHANNEL)]

Replacement in pijul/src/commands/clone.rs at line 115 [2.182891]

B:BD[155.3802] → [155.3802:3862]

            libpijul::output::output_repository_no_pending(

[155.3802]

[155.3862]

            pijul_core::output::output_repository_no_pending(

Replacement in pijul/src/commands/clone.rs at line 128 [2.182891]

B:BD[155.4202] → [155.4202:4266]

                libpijul::output::output_repository_no_pending(

[155.4202]

[155.4266]

                pijul_core::output::output_repository_no_pending(

Replacement in pijul/src/commands/clone.rs at line 168 [2.182891]

B:BD[41.138] → [41.138:221]

            remove_dot: std::fs::metadata(&path.join(libpijul::DOT_DIR)).is_err(),

[41.138]

[40.484]

            remove_dot: std::fs::metadata(&path.join(pijul_core::DOT_DIR)).is_err(),

Replacement in pijul/src/commands/clone.rs at line 176 [2.182891]

B:BD[41.373] → [41.373:460]

            std::fs::remove_dir_all(&self.path.join(libpijul::DOT_DIR)).unwrap_or(());

[41.373]

[41.460]

            std::fs::remove_dir_all(&self.path.join(pijul_core::DOT_DIR)).unwrap_or(());

Deletion in pijul/src/commands/channel.rs at line 9 [2.186892]
∅:D[213.120] → [26.943:987]
∅:D[99.1521] → [26.943:987]
∅:D[189.2527] → [26.943:987]
B:BD[13.163] → [26.943:987]
```
use libpijul::{ChannelTxnT, MutTxnT, TxnT};
```
Insertion in pijul/src/commands/channel.rs at line 10 [2.186892]
[151.16]
[177.2028]
```
use pijul_core::{ChannelTxnT, MutTxnT, TxnT};
```

Replacement in pijul/src/commands/channel.rs at line 131 [2.186892]

B:BD[151.907] → [151.907:966]

                    use libpijul::{GraphTxnT, MutTxnTExt};

[151.907]

[151.966]

                    use pijul_core::{GraphTxnT, MutTxnTExt};

Replacement in pijul/src/commands/channel.rs at line 133 [2.186892]

B:BD[151.1020] → [151.1020:1109]

                        libpijul::pristine::changeid_log(&txn, &ch, 0u64.into())?.next()

[151.1020]

[151.1109]

                        pijul_core::pristine::changeid_log(&txn, &ch, 0u64.into())?.next()

Replacement in pijul/src/commands/change.rs at line 5 [2.189306]
∅:D[99.1592] → [2.189362:189402]
∅:D[189.2626] → [2.189362:189402]
B:BD[2.189362] → [2.189362:189402]
B:BD[2.189429] → [2.189429:189446]
```
use libpijul::changestore::ChangeStore;
use libpijul::*;
```
[4.3107]
[177.2063]
```
use pijul_core::changestore::ChangeStore;
use pijul_core::*;
```
Deletion in pijul/src/commands/archive.rs at line 3 [2.191083]
B:BD[189.2746] → [214.0:30]
```
use libpijul::{Hash, Merkle};
```
Insertion in pijul/src/commands/archive.rs at line 4 [2.191083]
[4.3268]
[235.5886]
```
use pijul_core::{Hash, Merkle};
```

Replacement in pijul/src/commands/archive.rs at line 85 [2.191083]

B:BD[2.192302] → [214.245:319]

                self.base.channel().unwrap_or(libpijul::DEFAULT_CHANNEL),

[2.192302]

[2.192475]

                self.base.channel().unwrap_or(pijul_core::DEFAULT_CHANNEL),

Replacement in pijul/src/commands/archive.rs at line 112 [2.191083]

B:BD[2.193296] → [52.761:851]

            let mut tarball = libpijul::output::Tarball::new(&mut f, self.prefix, umask);

[2.193296]

[214.501]

            let mut tarball = pijul_core::output::Tarball::new(&mut f, self.prefix, umask);

Replacement in pijul/src/commands/archive.rs at line 129 [2.191083]

B:BD[2.193815] → [223.725:798]

                type W = libpijul::working_copy::filesystem::FileSystem;

[2.193815]

[223.798]

                type W = pijul_core::working_copy::filesystem::FileSystem;

Replacement in pijul/src/commands/apply.rs at line 9 [2.194289]
∅:D[215.18] → [2.194343:194383]
∅:D[218.1628] → [2.194343:194383]
∅:D[99.1682] → [2.194343:194383]
∅:D[189.2905] → [2.194343:194383]
∅:D[4.3378] → [2.194343:194383]
B:BD[2.194343] → [2.194343:194383]
B:BD[2.194383] → [83.17448:17503]
∅:D[83.17503] → [53.23441:23475]
B:BD[34.617] → [53.23441:23475]
```
use libpijul::changestore::ChangeStore;
use libpijul::{DepsTxnT, GraphTxnT, MutTxnTExt, TxnT};
use libpijul::{HashMap, HashSet};
```
[218.1628]
[194.6004]
```
use pijul_core::changestore::ChangeStore;
use pijul_core::{DepsTxnT, GraphTxnT, MutTxnTExt, TxnT};
use pijul_core::{HashMap, HashSet};
```

Replacement in pijul/src/commands/apply.rs at line 41 [2.194289]

B:BD[161.146] → [161.146:246]

            let mut change = libpijul::change::Change::read(&mut change, &mut HashMap::default())?;

[161.146]

[161.246]

            let mut change =
                pijul_core::change::Change::read(&mut change, &mut HashMap::default())?;

Replacement in pijul/src/commands/apply.rs at line 49 [2.194289]
∅:D[161.408] → [154.0:31]
B:BD[2.195413] → [154.0:31]
```
        use libpijul::MutTxnT;
```
[161.408]
[154.31]
```
        use pijul_core::MutTxnT;
```

Replacement in pijul/src/commands/apply.rs at line 68 [2.194289]

B:BD[2.195560] → [61.0:79]

                let change = libpijul::change::Change::deserialize(&ch, None);

[2.195560]

[81.1047]

                let change = pijul_core::change::Change::deserialize(&ch, None);

Replacement in pijul/src/commands/apply.rs at line 73 [2.194289]

∅:D[98.678] → [61.165:232]

∅:D[81.1148] → [61.165:232]

B:BD[61.165] → [61.165:232]

                    Err(libpijul::change::ChangeError::Io(e)) => {

[98.678]

[61.232]

                    Err(pijul_core::change::ChangeError::Io(e)) => {

Replacement in pijul/src/commands/apply.rs at line 124 [2.194289]

B:BD[47.3098] → [160.0:95]

                    libpijul::fs::find_path(&repo.changes, &*txn_, &*forked.read(), false, i)?

[47.3098]

[47.3193]

                    pijul_core::fs::find_path(&repo.changes, &*txn_, &*forked.read(), false, i)?

Replacement in pijul/src/commands/apply.rs at line 139 [2.194289]

B:BD[149.190] → [149.190:254]

                let mut state = libpijul::RecordBuilder::new();

[149.190]

[149.254]

                let mut state = pijul_core::RecordBuilder::new();

Replacement in pijul/src/commands/apply.rs at line 143 [2.194289]

B:BD[149.371] → [149.371:427]

                        libpijul::Algorithm::default(),

[149.371]

[149.427]

                        pijul_core::Algorithm::default(),

Replacement in pijul/src/commands/apply.rs at line 145 [2.194289]

B:BD[149.458] → [149.458:512]

                        &libpijul::DEFAULT_SEPARATOR,

[149.458]

[154.363]

                        &pijul_core::DEFAULT_SEPARATOR,

Replacement in pijul/src/commands/apply.rs at line 157 [2.194289]

B:BD[149.968] → [154.404:460]

                        libpijul::Algorithm::default(),

[149.968]

[154.460]

                        pijul_core::Algorithm::default(),

Replacement in pijul/src/commands/apply.rs at line 178 [2.194289]

B:BD[91.3206] → [91.3206:3274]

                    libpijul::output::output_repository_no_pending(

[91.3206]

[91.3274]

                    pijul_core::output::output_repository_no_pending(

Replacement in pijul/src/commands/apply.rs at line 194 [2.194289]

B:BD[91.3691] → [91.3691:3759]

                    libpijul::output::output_repository_no_pending(

[91.3691]

[91.3759]

                    pijul_core::output::output_repository_no_pending(

Replacement in pijul/Cargo.toml at line 18 [2.196374]

B:BD[2.197381] → [193.2005:2061]

libpijul = { workspace = true, features = ["tarball"] }

[2.197381]

[193.2061]

pijul-core = { workspace = true, features = ["tarball"] }

Replacement in flake.nix at line 39 [2.1023754]
B:BD[230.1046] → [230.1046:1078]
```
            libpijul = attrs: {
```
[230.1046]
[230.1078]
```
            pijul-core = attrs: {
```
Replacement in Cargo.toml at line 3 [2.1030188]
B:BD[179.1112] → [179.1112:1128]
```
    "libpijul",
```
[179.1079]
[179.1153]
```
    "pijul-core",
```

Replacement in Cargo.toml at line 23 [2.1030188]

B:BD[193.5441] → [193.5441:5501]

libpijul = { path = "libpijul", version = "1.0.0-beta.10" }

[193.5441]

[199.1144]

pijul-core = { path = "pijul-core", version = "1.0.0-beta.10" }

Replacement in Cargo.nix at line 40 [239.12]

B:BD[224.1414] → [224.1414:1467]

    "libpijul" = rec {
      packageId = "libpijul";

[224.1414]

[224.1467]

    "pijul-core" = rec {
      packageId = "pijul-core";

Replacement in Cargo.nix at line 43 [239.12]
B:BD[224.1519] → [224.1519:1551]
```
        packageId = "libpijul";
```
[224.1519]
[224.1551]
```
        packageId = "pijul-core";
```

Replacement in Cargo.nix at line 5018 [239.12]

B:BD[224.158067] → [224.158067:158124]

      "libpijul" = rec {
        crateName = "libpijul";

[224.158067]

[230.6461]

      "pijul-core" = rec {
        crateName = "pijul-core";

Replacement in Cargo.nix at line 5022 [239.12]

B:BD[224.158185] → [224.158185:158266]

        src = lib.cleanSourceWith { filter = sourceFilter;  src = ./libpijul; };

[224.158185]

[224.158266]

        src = lib.cleanSourceWith { filter = sourceFilter;  src = ./pijul-core; };

Replacement in Cargo.nix at line 6939 [239.12]

B:BD[224.214360] → [237.2761:2828]

            name = "libpijul";
            packageId = "libpijul";

[224.214360]

[237.2828]

            name = "pijul-core";
            packageId = "pijul-core";

Replacement in Cargo.nix at line 7009 [239.12]

B:BD[224.216111] → [224.216111:216178]

            name = "libpijul";
            packageId = "libpijul";

[224.216111]

[224.216178]

            name = "pijul-core";
            packageId = "pijul-core";

Replacement in Cargo.nix at line 7143 [239.12]

B:BD[237.2865] → [237.2865:2932]

            name = "libpijul";
            packageId = "libpijul";

[237.2865]

[237.2932]

            name = "pijul-core";
            packageId = "pijul-core";

Replacement in Cargo.nix at line 7220 [239.12]

B:BD[224.221444] → [224.221444:221511]

            name = "libpijul";
            packageId = "libpijul";

[224.221444]

[224.221511]

            name = "pijul-core";
            packageId = "pijul-core";

Replacement in Cargo.nix at line 7383 [239.12]

B:BD[224.225700] → [224.225700:225767]

            name = "libpijul";
            packageId = "libpijul";

[224.225700]

[230.12379]

            name = "pijul-core";
            packageId = "pijul-core";

Replacement in Cargo.nix at line 7477 [239.12]

B:BD[224.228152] → [224.228152:228219]

            name = "libpijul";
            packageId = "libpijul";

[224.228152]

[224.228219]

            name = "pijul-core";
            packageId = "pijul-core";

Deletion in Cargo.lock at line 1642 [2.1030385]

B:BD[221.39742] → [221.39742:39760]

B:BD[221.39760] → [227.1355:1381]

∅:D[227.1381] → [221.39786:39953]

B:BD[221.39786] → [221.39786:39953]

B:BD[221.39953] → [227.1382:1409]

∅:D[227.1409] → [221.39974:40269]

B:BD[221.39974] → [221.39974:40269]

B:BD[221.40269] → [227.1410:1447]

∅:D[227.1447] → [221.40306:40492]

B:BD[221.40306] → [221.40306:40492]

name = "libpijul"
version = "1.0.0-beta.11"
dependencies = [
 "adler32",
 "aes",
 "anyhow",
 "bincode",
 "bitflags 2.10.0",
 "blake3",
 "bs58",
 "byteorder",
 "canonical-path",
 "chardetng",
 "crossbeam-deque",
 "curve25519-dalek 4.1.3",
 "data-encoding",
 "diffs",
 "ed25519-dalek",
 "encoding_rs",
 "env_logger 0.11.8",
 "flate2",
 "generic-array",
 "getrandom 0.2.16",
 "hmac",
 "ignore",
 "imara-diff",
 "jiff",
 "log",
 "lru-cache",
 "nom",
 "parking_lot 0.12.5",
 "path-slash",
 "pbkdf2 0.9.0",
 "pijul-macros",
 "quickcheck",
 "rand 0.9.2",
 "rand_chacha 0.9.0",
 "regex",
 "sanakirja",
 "serde",
 "serde_derive",
 "serde_json",
 "sha2 0.9.9",
 "tar",
 "tempfile",
 "thiserror 2.0.17",
 "toml 0.8.23",
 "twox-hash",
 "zstd-seekable",
]
[[package]]

Deletion in Cargo.lock at line 2206 [2.1030385]
B:BD[221.57819] → [221.57819:57832]
```
 "libpijul",
```
Insertion in Cargo.lock at line 2211 [2.1030385]
[221.57891]
[221.57891]
```
 "pijul-core",
```
Deletion in Cargo.lock at line 2241 [2.1030385]
B:BD[236.4096] → [236.4096:4109]
```
 "libpijul",
```
Insertion in Cargo.lock at line 2242 [2.1030385]
[221.58295]
[221.58295]
```
 "pijul-core",
```

Insertion in Cargo.lock at line 2247 [2.1030385]

[221.58349]

]
[[package]]
name = "pijul-core"
version = "1.0.0-beta.11"
dependencies = [
 "adler32",
 "aes",
 "anyhow",
 "bincode",
 "bitflags 2.10.0",
 "blake3",
 "bs58",
 "byteorder",
 "canonical-path",
 "chardetng",
 "crossbeam-deque",
 "curve25519-dalek 4.1.3",
 "data-encoding",
 "diffs",
 "ed25519-dalek",
 "encoding_rs",
 "env_logger 0.11.8",
 "flate2",
 "generic-array",
 "getrandom 0.2.16",
 "hmac",
 "ignore",
 "imara-diff",
 "jiff",
 "log",
 "lru-cache",
 "nom",
 "parking_lot 0.12.5",
 "path-slash",
 "pbkdf2 0.9.0",
 "pijul-macros",
 "quickcheck",
 "rand 0.9.2",
 "rand_chacha 0.9.0",
 "regex",
 "sanakirja",
 "serde",
 "serde_derive",
 "serde_json",
 "sha2 0.9.9",
 "tar",
 "tempfile",
 "thiserror 2.0.17",
 "toml 0.8.23",
 "twox-hash",
 "zstd-seekable",

Deletion in Cargo.lock at line 2309 [2.1030385]
B:BD[221.58477] → [221.58477:58490]
```
 "libpijul",
```
Insertion in Cargo.lock at line 2311 [2.1030385]
[221.58515]
[221.58515]
```
 "pijul-core",
```
Deletion in Cargo.lock at line 2355 [2.1030385]
B:BD[221.59115] → [221.59115:59128]
```
 "libpijul",
```
Insertion in Cargo.lock at line 2357 [2.1030385]
[221.59153]
[221.59153]
```
 "pijul-core",
```
Deletion in Cargo.lock at line 2379 [2.1030385]
B:BD[221.59454] → [221.59454:59467]
```
 "libpijul",
```
Insertion in Cargo.lock at line 2381 [2.1030385]
[221.59492]
[221.59492]
```
 "pijul-core",
```