repo::add(&mut repo, DEFAULT_IGNORE_FILE);

    repo::add(&mut repo, DEFAULT_IGNORE_FILE).unwrap();

    repo::record(&internal, "Initialized".to_string(), None, skey);

    repo::record(&internal, "Initialized".to_string(), None, skey).unwrap();

    let log = repo::get_log(&internal.repo, None, None, None);

    let log = repo::get_log(&internal.repo, None, None, None).unwrap();

    InitFailed(LoadError),

    InitFailed(String),

        state: State,

        state: anyhow::Result<State>,

        result: anyhow::Result<()>,

        result: anyhow::Result<()>,

        diffs: ChangedFiles,

        diffs: anyhow::Result<ChangedFiles>,

    LoadedEntireLog(Log),

    LoadedEntireLog(anyhow::Result<Log>),

        log: Log,

        log: anyhow::Result<Log>,

        Ok((mut internal_state, state)) => {

        Ok((mut internal_state, Ok(state))) => {

        }
        Ok((_, Err(err))) => {
            let _ = msg_out_tx.send(MsgOut::InitFailed(err.to_string()));

            let _ = msg_out_tx.send(MsgOut::InitFailed(err));

            let _ = msg_out_tx.send(MsgOut::InitFailed(err.to_string()));

pub fn load(path: &Path) -> Result<(InternalState, State), LoadError> {

pub fn load(
    path: &Path,
) -> Result<(InternalState, anyhow::Result<State>), LoadError> {

            let state: State;

            let state: anyhow::Result<State>;

            internal_state = spawn_blocking(move || {
                add(&mut internal_state, &path_clone);
                internal_state

            let result: anyhow::Result<()>;
            (internal_state, result) = spawn_blocking(move || {
                let result = add(&mut internal_state, &path_clone);
                (internal_state, result)

            let _ = msg_out_tx.send(MsgOut::AddedUntrackedFile { path });

            let _ =
                msg_out_tx.send(MsgOut::AddedUntrackedFile { result, path });

            internal_state = spawn_blocking(move || {
                rm(&mut internal_state, &path_clone);
                internal_state

            let result: anyhow::Result<()>;
            (internal_state, result) = spawn_blocking(move || {
                let result = rm(&mut internal_state, &path_clone);
                (internal_state, result)

            let _ = msg_out_tx.send(MsgOut::RmedAddedFile { path });

            let _ = msg_out_tx.send(MsgOut::RmedAddedFile { result, path });

            let state: State;

            let state: anyhow::Result<State>;

                record(&internal_state, msg, desc, sk);
                // Update state after making a record
                let state = get_state(&internal_state);

                let state = |internal_state: &InternalState| {
                    record(internal_state, msg, desc, sk)?;
                    // Update state after making a record
                    get_state(internal_state)
                };
                let state = state(&internal_state);

            let diffs: ChangedFiles;

            let diffs: anyhow::Result<ChangedFiles>;

                let change =
                    internal_state.repo.changes.get_change(&hash).unwrap();

                    changed_files(&change, &internal_state.repo.changes);

                    get_change_diffs(hash, &internal_state).context(format!(
                        "Getting change with the hash {}",
                        hash_to_string(&hash)
                    ));

            let state: State;

            let state: anyhow::Result<State>;

                switch_to_channel(&mut internal_state, name);
                let state = get_state(&internal_state);

                let state = |internal_state: &mut InternalState| {
                    switch_to_channel(internal_state, name)?;
                    get_state(internal_state)
                };
                let state = state(&mut internal_state);

            let state: State;

            let state: anyhow::Result<State>;

                fork_channel(&mut internal_state, name);
                let state = get_state(&internal_state);

                let state = |internal_state: &mut InternalState| {
                    fork_channel(internal_state, name)?;
                    get_state(internal_state)
                };
                let state = state(&mut internal_state);

            let log: Log;

            let log: anyhow::Result<Log>;

            let log: Log;

            let log: anyhow::Result<Log>;

fn get_state(state: &InternalState) -> State {

fn get_state(state: &InternalState) -> anyhow::Result<State> {

    let channel = current_channel(repo);
    let other_channels = other_channels(repo);
    let diff = diff(repo);
    let untracked_files = untracked_files(repo);
    let changed_files = changed_files(&diff, &repo.changes);

    let channel = current_channel(repo)?;
    let other_channels = other_channels(repo)?;
    let diff = diff(repo)?;
    let untracked_files = untracked_files(repo)?;
    let changed_files = changed_files(&diff, &repo.changes)?;

    let log = get_log(repo, Some(&channel), offset, limit);
    State {

    let log = get_log(repo, Some(&channel), offset, limit)?;
    Ok(State {

    }

    })

fn current_channel(repo: &pijul::Repository) -> String {
    let txn = repo.pristine.txn_begin().unwrap();
    txn.current_channel()

fn current_channel(repo: &pijul::Repository) -> anyhow::Result<String> {
    let txn = repo.pristine.txn_begin()?;
    Ok(txn
        .current_channel()

        .to_string()

        .to_string())

fn other_channels(repo: &pijul::Repository) -> Vec<String> {
    let txn = repo.pristine.txn_begin().unwrap();

fn other_channels(repo: &pijul::Repository) -> anyhow::Result<Vec<String>> {
    let txn = repo.pristine.txn_begin()?;

    txn.channels("")
        .unwrap()

    let channels = txn
        .channels("")?

        .collect()

        .collect();
    Ok(channels)

fn switch_to_channel(state: &mut InternalState, name: String) {

fn switch_to_channel(
    state: &mut InternalState,
    name: String,
) -> anyhow::Result<()> {

    let current_channel = current_channel(repo);
    let txn = repo.pristine.arc_txn_begin().unwrap();

    let current_channel = current_channel(repo)?;
    let txn = repo.pristine.arc_txn_begin()?;

        return;

        return Ok(());

            txn.load_channel(&current_channel).unwrap()

            txn.load_channel(&current_channel)?

            && has_unrecorded_changes(txn.clone(), channel.clone(), repo)

            && has_unrecorded_changes(txn.clone(), channel.clone(), repo)?

            return;

            return Ok(());

    txn.write().set_current_channel(&name).unwrap();
    txn.commit().unwrap();

    txn.write().set_current_channel(&name)?;
    txn.commit()?;
    Ok(())

fn fork_channel(state: &mut InternalState, name: String) {

fn fork_channel(state: &mut InternalState, name: String) -> anyhow::Result<()> {

    let current_channel = current_channel(repo);
    let mut txn = repo.pristine.mut_txn_begin().unwrap();
    let channel = txn.load_channel(&current_channel).unwrap().unwrap();
    let _fork = txn.fork(&channel, name.trim()).unwrap();
    txn.commit().unwrap();

    let current_channel = current_channel(repo)?;
    let mut txn = repo.pristine.mut_txn_begin()?;
    let channel = txn
        .load_channel(&current_channel)?
        .context("Loading current channel")?;
    let _fork = txn.fork(&channel, name.trim())?;
    txn.commit()?;
    Ok(())

) {

) -> anyhow::Result<()> {

    let channel = current_channel(repo);
    let txn = repo.pristine.arc_txn_begin().unwrap();

    let channel = current_channel(repo)?;
    let txn = repo.pristine.arc_txn_begin()?;

    let channel = txn.read().load_channel(&channel).unwrap().unwrap();

    let channel = txn
        .read()
        .load_channel(&channel)?
        .context("Loading current channel")?;

        let (h, c) = txn.read().hash_from_prefix(h).unwrap();

        let (h, c) = txn.read().hash_from_prefix(h)?;

            .get_changeset(txn.read().changes(&*channel.read()), &c)
            .unwrap()

            .get_changeset(txn.read().changes(&*channel.read()), &c)?

    txn.write()
        .apply_root_change_if_needed(
            &repo.changes,
            &channel,
            rand::thread_rng(),
        )
        .unwrap();

    txn.write().apply_root_change_if_needed(
        &repo.changes,
        &channel,
        rand::thread_rng(),
    )?;

    state
        .record(
            txn.clone(),
            pijul::Algorithm::default(),
            false,
            &pijul::DEFAULT_SEPARATOR,
            channel.clone(),
            &repo.working_copy,
            &repo.changes,
            "",
            1, // std::thread::available_parallelism()?.get(),
        )
        .unwrap();

    state.record(
        txn.clone(),
        pijul::Algorithm::default(),
        false,
        &pijul::DEFAULT_SEPARATOR,
        channel.clone(),
        &repo.working_copy,
        &repo.changes,
        "",
        1, // std::thread::available_parallelism()?.get(),
    )?;

            .map(|rec| rec.globalize(&*txn_).unwrap())
            .collect();
        let contents = Arc::try_unwrap(rec.contents).unwrap().into_inner();

            .map(|rec| {
                let res = rec.globalize(&*txn_)?;
                Ok(res)
            })
            .collect::<anyhow::Result<Vec<_>>>()?;
        let contents = Arc::into_inner(rec.contents)
            .context(
                "Failed to get unique strong reference on change contents",
            )?
            .into_inner();

        )
        .unwrap();

        )?;

        let hash = repo
            .changes
            .save_change(&mut change, |change, hash| {
                change.unhashed = Some(serde_json::json!({
                    "signature": sk.sign_raw(&hash.to_bytes()).unwrap(),
                }));
                Ok::<_, pijul::changestore::filesystem::Error>(())
            })
            .unwrap();

        let hash = repo.changes.save_change(&mut change, |change, hash| {
            change.unhashed = Some(serde_json::json!({
                "signature": sk.sign_raw(&hash.to_bytes()).unwrap(),
            }));
            Ok::<_, pijul::changestore::filesystem::Error>(())
        })?;

        txn_.apply_local_change(&channel, &change, &hash, &rec.updatables)
            .unwrap();

        txn_.apply_local_change(&channel, &change, &hash, &rec.updatables)?;

        std::fs::create_dir_all(&path).unwrap();

        std::fs::create_dir_all(&path)?;

            .duration_since(std::time::SystemTime::UNIX_EPOCH)
            .unwrap()

            .duration_since(std::time::SystemTime::UNIX_EPOCH)?

                .duration_since(std::time::SystemTime::UNIX_EPOCH)
                .unwrap()

                .duration_since(std::time::SystemTime::UNIX_EPOCH)?

    txn.commit().unwrap();

    txn.commit()?;
    Ok(())

fn diff(repo: &pijul::Repository) -> Diff {
    let txn = repo.pristine.arc_txn_begin().unwrap();

fn diff(repo: &pijul::Repository) -> anyhow::Result<Diff> {
    let txn = repo.pristine.arc_txn_begin()?;

    let channel = txn.write().open_or_create_channel(&cur_channel).unwrap();

    let channel = txn.write().open_or_create_channel(&cur_channel)?;

    state
        .record(
            txn.clone(),
            pijul::Algorithm::default(),
            false,
            &pijul::DEFAULT_SEPARATOR,
            channel.clone(),
            &repo.working_copy,
            &repo.changes,
            "",
            std::thread::available_parallelism().unwrap().get(),
        )
        .unwrap();

    state.record(
        txn.clone(),
        pijul::Algorithm::default(),
        false,
        &pijul::DEFAULT_SEPARATOR,
        channel.clone(),
        &repo.working_copy,
        &repo.changes,
        "",
        std::thread::available_parallelism()?.get(),
    )?;

            .map(|rec| rec.globalize(&*txn_).unwrap())
            .collect()

            .map(|rec| {
                let res = rec.globalize(&*txn_)?;
                Ok(res)
            })
            .collect::<anyhow::Result<Vec<_>>>()?

    let contents = std::sync::Arc::try_unwrap(rec.contents)
        .unwrap()

    let contents = std::sync::Arc::into_inner(rec.contents)
        .context("Failed to get unique strong reference on change contents")?

    )
    .unwrap();

    )?;

        )
        .unwrap()

        )?

    change

    Ok(change)

pub fn add(repo: &mut pijul::Repository, file_path_str: &str) {
    let txn = repo.pristine.arc_txn_begin().unwrap();
    let repo_path = CanonicalPathBuf::canonicalize(&repo.path).unwrap();

pub fn add(
    repo: &mut pijul::Repository,
    file_path_str: &str,
) -> anyhow::Result<()> {
    let txn = repo.pristine.arc_txn_begin()?;
    let repo_path = CanonicalPathBuf::canonicalize(&repo.path)?;

    let path = CanonicalPathBuf::canonicalize(full_path).unwrap();
    let meta = std::fs::metadata(&path).unwrap();

    let path = CanonicalPathBuf::canonicalize(full_path)?;
    let meta = std::fs::metadata(&path)?;

        if !txn.is_tracked(&path_str).unwrap() {

        if !txn.is_tracked(&path_str)? {

                panic!("Failed to track file with: {e}");

                bail!("Failed to track file with: {e}");

            panic!("Won't add file \"{path_str}\" as it's already tracked");

            bail!("Won't add file \"{path_str}\" as it's already tracked");

    txn.commit().unwrap();

    txn.commit()?;
    Ok(())

fn rm(repo: &mut pijul::Repository, file_path_str: &str) {

fn rm(repo: &mut pijul::Repository, file_path_str: &str) -> anyhow::Result<()> {

    let mut txn = repo.pristine.mut_txn_begin().unwrap();

    let mut txn = repo.pristine.mut_txn_begin()?;

    if txn.is_tracked(&path_str).unwrap() {
        txn.remove_file(&path_str).unwrap();

    if txn.is_tracked(&path_str)? {
        txn.remove_file(&path_str)?;

    txn.commit().unwrap();

    txn.commit()?;
    Ok(())
}
fn get_change_diffs(
    hash: ChangeHash,
    internal_state: &InternalState,
) -> anyhow::Result<ChangedFiles> {
    let change = internal_state.repo.changes.get_change(&hash)?;
    changed_files(&change, &internal_state.repo.changes)

fn changed_files(diff: &Diff, repo_changes: &FileSystem) -> ChangedFiles {

fn changed_files(
    diff: &Diff,
    repo_changes: &FileSystem,
) -> anyhow::Result<ChangedFiles> {

                    get_change_contents(repo_changes, change, &diff.contents)
                        .unwrap();

                    get_change_contents(repo_changes, change, &diff.contents)?;

                    get_change_contents(repo_changes, change, &diff.contents)
                        .unwrap();

                    get_change_contents(repo_changes, change, &diff.contents)?;

                )
                .unwrap();

                )?;

    changes

    Ok(changes)

fn untracked_files(repo: &pijul::Repository) -> BTreeSet<String> {
    let repo_path = CanonicalPathBuf::canonicalize(&repo.path).unwrap();
    let txn = repo.pristine.arc_txn_begin().unwrap();
    let threads = std::thread::available_parallelism().unwrap().get();

fn untracked_files(
    repo: &pijul::Repository,
) -> anyhow::Result<BTreeSet<String>> {
    let repo_path = CanonicalPathBuf::canonicalize(&repo.path)?;
    let txn = repo.pristine.arc_txn_begin()?;
    let threads = std::thread::available_parallelism()?.get();

        )
        .unwrap()
        .filter_map(move |path| {
            let (path, _) = path.unwrap();
            use path_slash::PathExt;
            let path_str = path.to_slash_lossy();
            if !txn_.read().is_tracked(&path_str).unwrap() {
                Some(path_str.into_owned())
            } else {
                None

        )?
        .filter_map(move |path| match path {
            Err(e) => Some(Err(anyhow::Error::from(e))),
            Ok((path, _)) => {
                use path_slash::PathExt;
                let path_str = path.to_slash_lossy();
                let is_tracked = match txn_.read().is_tracked(&path_str) {
                    Ok(is_tracked) => is_tracked,
                    Err(e) => return Some(Err(anyhow::Error::from(e))),
                };
                if !is_tracked {
                    Some(Ok(path_str.into_owned()))
                } else {
                    None
                }

) -> Vec<LogEntry> {

) -> anyhow::Result<Vec<LogEntry>> {

    let txn = repo.pristine.txn_begin().unwrap();

    let txn = repo.pristine.txn_begin()?;

    let channel = txn.load_channel(&cur_channel).unwrap().unwrap();

    let channel = txn
        .load_channel(&cur_channel)?
        .context("Loading current channel")?;

    let mut reverse_log =
        txn.reverse_log(&channel.read(), None).unwrap().peekable();

    let mut reverse_log = txn.reverse_log(&channel.read(), None)?.peekable();

        return vec![];

        return Ok(vec![]);

        let (_, (hash, _mrk)) = pr.unwrap();
        let cid = pijul::GraphTxnT::get_internal(&txn, hash).unwrap().unwrap();

        let (_, (hash, _mrk)) = pr?;
        let cid = pijul::GraphTxnT::get_internal(&txn, hash)?
            .context("Getting log change ID")?;

                )
                .unwrap()
                    == Some(cid);

                )? == Some(cid);

                let entry = mk_log_entry(repo, ChangeHash::from(hash));

                let entry = mk_log_entry(repo, ChangeHash::from(hash))?;

    entries

    Ok(entries)

fn mk_log_entry(repo: &pijul::Repository, hash: ChangeHash) -> LogEntry {
    let header = repo.changes.get_header(&hash).unwrap();
    let files = repo.changes.get_changes(&hash).unwrap();

fn mk_log_entry(
    repo: &pijul::Repository,
    hash: ChangeHash,
) -> anyhow::Result<LogEntry> {
    let header = repo.changes.get_header(&hash)?;
    let files = repo.changes.get_changes(&hash)?;

    LogEntry {

    Ok(LogEntry {

    }

    })

) -> bool {

) -> anyhow::Result<bool> {

    state
        .record(
            txn,
            libpijul::Algorithm::default(),
            false,
            &libpijul::DEFAULT_SEPARATOR,
            channel,
            &repo.working_copy,
            &repo.changes,
            "",
            std::thread::available_parallelism().unwrap().get(),
        )
        .unwrap();

    state.record(
        txn,
        libpijul::Algorithm::default(),
        false,
        &libpijul::DEFAULT_SEPARATOR,
        channel,
        &repo.working_copy,
        &repo.changes,
        "",
        std::thread::available_parallelism()?.get(),
    )?;

    !rec.actions.is_empty()

    Ok(!rec.actions.is_empty())

    } = state;

    } = state.unwrap();

    assert_eq!(repo::current_channel(&repo), libpijul::DEFAULT_CHANNEL);

    assert_eq!(
        repo::current_channel(&repo).unwrap(),
        libpijul::DEFAULT_CHANNEL
    );

    assert_eq!(repo::current_channel(&repo), new_channel_name);

    assert_eq!(repo::current_channel(&repo).unwrap(), new_channel_name);

    let log = repo::get_log(&internal.repo, None, None, None);

    let log = repo::get_log(&internal.repo, None, None, None).unwrap();

    repo::record(&internal, msg.to_string(), None, skey);

    repo::record(&internal, msg.to_string(), None, skey).unwrap();

    let log = repo::get_log(&internal.repo, None, None, None);

    let log = repo::get_log(&internal.repo, None, None, None).unwrap();

    let diff = repo::diff(&internal.repo);

    let diff = repo::diff(&internal.repo).unwrap();

    let diff = repo::diff(&internal.repo);

    let diff = repo::diff(&internal.repo).unwrap();

    let changed_files = repo::changed_files(&diff, &internal.repo.changes);

    let changed_files =
        repo::changed_files(&diff, &internal.repo.changes).unwrap();

    let untracked_files = repo::untracked_files(&internal.repo);

    let untracked_files = repo::untracked_files(&internal.repo).unwrap();

    let untracked_files = repo::untracked_files(&internal.repo);

    let untracked_files = repo::untracked_files(&internal.repo).unwrap();

    let diff = repo::diff(&internal.repo);

    let diff = repo::diff(&internal.repo).unwrap();

    repo::add(&mut internal.repo, new_file);

    repo::add(&mut internal.repo, new_file).unwrap();

    let diff = repo::diff(&internal.repo);

    let diff = repo::diff(&internal.repo).unwrap();

    repo::rm(&mut internal.repo, new_file);

    repo::rm(&mut internal.repo, new_file).unwrap();

    let adiff = repo::diff(&internal.repo);

    let adiff = repo::diff(&internal.repo).unwrap();

    let mut log = repo::get_log(&internal.repo, None, None, None);

    let mut log = repo::get_log(&internal.repo, None, None, None).unwrap();

    let mut log = repo::get_log(&internal.repo, None, None, Some(limit));

    let mut log =
        repo::get_log(&internal.repo, None, None, Some(limit)).unwrap();

    let mut log = repo::get_log(&internal.repo, None, Some(offset), None);

    let mut log =
        repo::get_log(&internal.repo, None, Some(offset), None).unwrap();

#[doc(inline)]
pub use anyhow::{bail, Context};

[dependencies.anyhow]
workspace = true

        Msg::FromRepo(repo::MsgOut::AddedUntrackedFile { path }) if path == file_to_record

        Msg::FromRepo(repo::MsgOut::AddedUntrackedFile { result:_, path }) if path == file_to_record

        Msg::FromRepo(repo::MsgOut::AddedUntrackedFile { path }) if path == file_to_record

        Msg::FromRepo(repo::MsgOut::AddedUntrackedFile {result:_, path }) if path == file_to_record

        Msg::FromRepo(repo::MsgOut::AddedUntrackedFile { path })

        Msg::FromRepo(repo::MsgOut::AddedUntrackedFile { result:_, path })

        Msg::FromRepo(repo::MsgOut::RmedAddedFile { path })

        Msg::FromRepo(repo::MsgOut::RmedAddedFile { result:_, path })

    let report_err = |state: &mut State, err: String| {
        report::show_err(&mut state.model.report, err);
        Task::none()
    };

        repo::MsgOut::InitFailed(err) => {
            report::show_err(&mut state.model.report, err.to_string());
            Task::none()
        }

        repo::MsgOut::InitFailed(err) => report_err(state, err.to_string()),

        } => repo_refreshed(state, repo_state, invalidate_logs),
        repo::MsgOut::AddedUntrackedFile { path: _ } => Task::none(),
        repo::MsgOut::RmedAddedFile { path: _ } => Task::none(),
        repo::MsgOut::GotChangeDiffs { hash, diffs } => {
            repo_got_change_diffs(state, hash, diffs)
        }
        repo::MsgOut::LoadedEntireLog(log) => got_entire_log(state, log),
        repo::MsgOut::LoadedOtherChannelLog { channel, log } => {
            loaded_other_channel_log(state, channel, log)
        }

        } => match repo_state {
            Ok(repo_state) => {
                repo_refreshed(state, repo_state, invalidate_logs)
            }
            Err(err) => report_err(state, err.to_string()),
        },
        repo::MsgOut::AddedUntrackedFile { result, path: _ } => match result {
            Ok(()) => Task::none(),
            Err(err) => report_err(state, err.to_string()),
        },
        repo::MsgOut::RmedAddedFile { result, path: _ } => match result {
            Ok(()) => Task::none(),
            Err(err) => report_err(state, err.to_string()),
        },
        repo::MsgOut::GotChangeDiffs { hash, diffs } => match diffs {
            Ok(diffs) => repo_got_change_diffs(state, hash, diffs),
            Err(err) => report_err(state, err.to_string()),
        },
        repo::MsgOut::LoadedEntireLog(log) => match log {
            Ok(log) => got_entire_log(state, log),
            Err(err) => report_err(state, err.to_string()),
        },
        repo::MsgOut::LoadedOtherChannelLog { channel, log } => match log {
            Ok(log) => loaded_other_channel_log(state, channel, log),
            Err(err) => report_err(state, err.to_string()),
        },

[workspace.dependencies.anyhow]
version = "1"

 "anyhow",