//  url & doc_path passed in.
...
       let repo = gix::open(&doc_path)?;
        // fetch remote HEAD of remote origin
        let remote_name = "origin";
        let remote = repo
            .remote_at(url.clone())?
            .with_refspecs(
                Some(format!("+refs/heads/*:refs/remotes/{remote_name}/*").as_str()),
                gix::remote::Direction::Fetch,
            )
            .expect("valid static spec");
        let head_refspec = gix_refspec::parse(
            format!("HEAD:refs/remotes/{remote_name}/HEAD")
                .as_str()
                .into(),
            gix_refspec::parse::Operation::Fetch,
        )
        .expect("valid")
        .to_owned();
        let res: gix::remote::fetch::Outcome = remote
            .connect(gix::remote::Direction::Fetch)?
            .prepare_fetch(&mut gix::progress::Discard, {
                let mut opts = gix::remote::ref_map::Options::default();
                if !opts.extra_refspecs.contains(&head_refspec) {
                    opts.extra_refspecs.push(head_refspec)
                }
                opts
            })?
            .with_write_packed_refs_only(true)
            .receive(&mut gix::progress::Discard, &gix::interrupt::IS_INTERRUPTED)?;

        // check if an extra pack has been received, and so a change on the remote.
        match res.status {
            gix::remote::fetch::Status::NoPackReceived {
                update_refs: _,
                negotiate: _,
                dry_run: _,
            } => {
                println!("No Changes!");
            }
            gix::remote::fetch::Status::Change {
                update_refs: _,
                write_pack_bundle: _,
                negotiate: _,
            } => {
                println!("Got Some Changes, checking out");
                // find the remote head's object id.
                let latest = res
                    .ref_map
                    .remote_refs
                    .iter()
                    .rev()
                    .filter_map(|x| match x {
                        gix::protocol::handshake::Ref::Direct {
                            full_ref_name,
                            object,
                        } => {
                            if full_ref_name == "refs/heads/main" {
                                Some(object.to_owned())
                            } else {
                                None
                            }
                        }
                        _ => None,
                    })
                    .next()
                    .unwrap();

                // get the tree for the object id in quesiton: just like in `main_worktree`
                let latest = repo
                    .find_object(latest)
                    .ok()
                    .and_then(|c| c.peel_to_tree().ok())
                    .unwrap()
                    .id;
                let index = gix_index::State::from_tree(&latest, |oid, buf| {
                    repo.objects.find_tree_iter(oid, buf).ok()
                })?;
                let mut index = gix_index::File::from_state(index, repo.index_path());

                // again same as in `main_worktree` to checkout the commit
                // mini helper to do repo.config.checkout_options(self, gix_worktree::stack::state::attributes::Source::IdMapping)
                let opts = repo.config_checkout_options()?;
                gix_worktree_state::checkout(
                    &mut index,
                    doc_path,
                    {
                        let objects = repo.objects.clone().into_arc()?;
                        move |oid, buf| objects.find_blob(oid, buf)
                    },
                    &mut Discard,
                    &mut Discard,
                    &gix::interrupt::IS_INTERRUPTED,
                    opts,
                )?;

                index.write(Default::default())?;
                println!("Repo checked out.",);
            }
        };
...

let opts = gix_worktree_state::checkout::Options {
    fs: Default::default(),
    thread_limit: Default::default(),
    destination_is_initially_empty: false,
    overwrite_existing: true,
    keep_going: false,
    stat_options: Default::default(),
    attributes: Default::default(),
    filters: Default::default(),
    filter_process_delay: Default::default(),
};