let ignore_root = workspace_path.clone();

    // TODO: multiple repositories per workspace
    let repository_path = workspace_path.clone();

    let (dot_directory_sender, mut dot_directory_receiver) = tokio::sync::mpsc::unbounded_channel();
    // TODO: better separate sync vs non-sync code
    std::thread::spawn(move || {
        let walker = ignore::WalkBuilder::new(&ignore_root)
            .current_dir(&ignore_root)
            .build_parallel();

    let std::collections::hash_map::Entry::Vacant(repository_entry) =
        repositories.entry(repository_path.clone())
    else {
        tracing::warn!(message = "Ignoring existing repository");
        return;
    };

        walker.run(move || {
            let path_sender = dot_directory_sender.clone();

    let repository_uri = match threadsafe_functions
        .uri_file(repository_path.to_string())
        .await
    {
        Ok(repository_uri) => repository_uri,
        Err(error) => {
            tracing::error!(message = "Failed to parse URI", ?repository_path, ?error);
            return;
        }
    };

            Box::new(move |entry_result| {
                // TODO: handle errors
                if let Ok(entry) = entry_result
                    && let Some(file_type) = entry.file_type()
                    && file_type.is_dir()
                {
                    // Path: {ENTRY}/.pijul/
                    let dot_directory_path = entry.path().join(libpijul::DOT_DIR);
                    if dot_directory_path.is_dir() {
                        path_sender.send(entry.into_path()).unwrap();
                        // Don't traverse repositories
                        return ignore::WalkState::Skip;
                    }
                }
                ignore::WalkState::Continue
            })
        });
    });
    // TODO: debug assertion that no discovered repositories are nested
    while let Some(os_repository_path) = dot_directory_receiver.recv().await {
        let repository_path = match Utf8PathBuf::from_path_buf(os_repository_path.to_path_buf()) {
            Ok(repository_path) => repository_path,
            Err(utf8_path_error) => {
                tracing::error!(
                    message = "Failed to convert OS path to UTF-8 path",
                    ?os_repository_path,
                    ?utf8_path_error
                );
                continue;
            }
        };
        let std::collections::hash_map::Entry::Vacant(repository_entry) =
            repositories.entry(repository_path.clone())
        else {
            tracing::warn!(message = "Ignoring existing repository");
            continue;
        };
        let repository_uri = match threadsafe_functions
            .uri_file(repository_path.to_string())
            .await
        {
            Ok(repository_uri) => repository_uri,
            Err(error) => {
                tracing::error!(message = "Failed to parse URI", ?repository_path, ?error);
                continue;
            }
        };

    let (source_control, unrecorded_changes, untracked_paths) = match threadsafe_functions
        .initialize_source_control(
            repository_uri,
            String::from("Pijul"),
            String::from("Changes"),
            String::from("Untracked"),
        )
        .await
    {
        Ok(initialized_source_control) => initialized_source_control,
        Err(error) => {
            tracing::error!(message = "Unable to create source control", ?error);
            return;
        }
    };

        let (source_control, unrecorded_changes, untracked_paths) = match threadsafe_functions
            .initialize_source_control(
                repository_uri,
                String::from("Pijul"),
                String::from("Changes"),
                String::from("Untracked"),
            )
            .await
        {
            Ok(initialized_source_control) => initialized_source_control,
            Err(error) => {
                tracing::error!(message = "Unable to create source control", ?error);
                continue;
            }
        };

    let file_system_repository = match pijul_extension::FileSystemRepository::new(&repository_path)
    {
        Ok(repository) => repository,
        Err(error) => {
            tracing::error!(message = "Failed to open repository", ?error);
            return;
        }
    };

        let file_system_repository =
            match pijul_extension::FileSystemRepository::new(&repository_path) {
                Ok(repository) => repository,
                Err(error) => {
                    tracing::error!(message = "Failed to open repository", ?error);
                    continue;
                }
            };

    repository_entry.insert(Repository {
        repository: file_system_repository,
        source_control,
        open_editors: HashMap::new(),
        unrecorded_changes,
        untracked_paths,
    });

        repository_entry.insert(Repository {
            repository: file_system_repository,
            source_control,
            open_editors: HashMap::new(),
            unrecorded_changes,
            untracked_paths,
        });

    tracing::info!(
        message = "Opened repository",
        ?repository_path,
        ?workspace_path
    );

        tracing::info!(
            message = "Opened repository",
            ?repository_path,
            ?workspace_path
        );
    }

ignore.workspace = true

ignore = "0.4.25"

version = "0.4.16"

version = "0.4.18"

checksum = "54a1028dfc5f5df5da8a56a73e6c153c9a9708ec57232470703592a3f18e49f5"

checksum = "52dfc19153a48bde0cbd630453615c8151bce3a5adfac7a0aebfbf0a1e1f57e3"

version = "0.4.23"

version = "0.4.25"

checksum = "6d89fd380afde86567dfba715db065673989d6253f42b88179abd3eae47bda4b"

checksum = "d3d782a365a015e0f5c04902246139249abf769125006fbe7649e2ee88169b4a"

 "ignore",