) -> Option<String>;

            ) -> bindgen_prelude::Object<'function_context>;

            ) -> Option<String>;

            ) -> bindgen_prelude::Object<'function_context>;

            Option<String> = |returned_result: Option<String>| Ok(returned_result);

            bindgen_prelude::ObjectRef = |returned_result: bindgen_prelude::Object| returned_result.create_ref();

    let (deferred_promise, promise_object) = env.create_deferred()?;

    let (deferred_promise, promise_object) = env.create_deferred()?;

fn provide_text_document_content(
    env: &napi::Env,

fn provide_text_document_content<'env>(
    env: &'env napi::Env,

) -> Result<Option<String>, napi::Error> {
    let program_state = ExtensionState::get()?;

) -> Result<bindgen_prelude::Object<'env>, napi::Error> {

    let uri = uri::to_vscode(env, &decoded_uri)?;

    if let Some((workspace_path, workspace)) =
        program_state.repositories.get_open_repository(env, &uri)?
    {
        let absolute_path = Utf8PathBuf::from(uri.get_fs_path()?);
        let relative_path = absolute_path
            .strip_prefix(&workspace_path)
            .map_err(|error| {
                napi::Error::from_reason(format!(
                    "Failed to strip prefix {workspace_path} from {absolute_path}: {error}"
                ))
            })?;
        match workspace.repository.get_open_file(relative_path) {
            Some(open_file) => Ok(open_file.tracked_contents().map(str::to_string)),
            None => {
                tracing::error!(
                    message = "No tracked file state for {relative_path}",
                    ?workspace_path
                );

    let (deferred_promise, promise_object) = env.create_deferred()?;
    event_loop::send(Event::RequestTrackedContents {
        uri: decoded_uri,
        deferred_promise,
    });

                Ok(None)
            }
        }
    } else {
        tracing::debug!(message = "Ignoring URI", uri = uri.to_string()?);
        Ok(None)
    }

    Ok(promise_object)

    // TODO: only return `Some()` when the uri exists in the repository

                Event::RequestTrackedContents {
                    uri,
                    deferred_promise,
                } => {
                    event::request_tracked_contents::handle(uri, deferred_promise, &extension_state)
                        .await
                }

use iri_string::types::{UriAbsoluteStr, UriAbsoluteString};
use crate::event_loop::ExtensionState;
pub type DeferredPromise = napi::JsDeferred<
    Option<String>,
    Box<dyn FnOnce(napi::Env) -> Result<Option<String>, napi::Error>>,
>;
#[tracing::instrument(skip(deferred_promise, extension_state))]
pub async fn handle(
    uri: UriAbsoluteString,
    deferred_promise: DeferredPromise,
    extension_state: &ExtensionState,
) {
    let tracked_contents = get_tracked_contents(&uri, extension_state);
    tracing::info!(
        message = "Providing tracked contents",
        length = ?tracked_contents.as_ref().map(|contents| contents.len())
    );
    deferred_promise.resolve(Box::new(move |_env| Ok(tracked_contents)));
}
#[tracing::instrument(skip(extension_state))]
fn get_tracked_contents(uri: &UriAbsoluteStr, extension_state: &ExtensionState) -> Option<String> {
    let Some((repository_path, relative_path, repository)) = extension_state.get_repository(uri)
    else {
        tracing::info!(message = "No matching repository for path", ?uri);
        return None;
    };
    let Some(open_file) = repository.repository.get_open_file(relative_path) else {
        tracing::info!(
            message = "No open file found in repository",
            ?repository_path,
            ?relative_path
        );
        return None;
    };
    let Some(tracked_contents) = open_file.tracked_contents() else {
        tracing::info!(
            message = "No tracked contents for file",
            ?repository_path,
            ?relative_path
        );
        return None;
    };
    Some(tracked_contents.to_string())
}

    tracing::debug!(message = "Providing file decoration", ?optional_path_state);

#[tracing::instrument(skip(extension_state))]

    if uri.scheme_str() != "file" {
        return None;
    }

        tracing::info!(message = "No matching repository for path", ?uri);

        tracing::info!(message = "No matching repository for path");

pub mod request_tracked_contents;

    RequestTrackedContents {
        uri: UriAbsoluteString,
        deferred_promise: request_tracked_contents::DeferredPromise,
    },