Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

196 KB
Raw Blame
use std::collections::HashMap;

use moli_fetch::{
    BrowserRequestMetadata, Request, RequestCredentialsMode, RequestResourceType,
    ScriptFetchRequestMetadata, ScriptFetchSchedulerPriority,
};
use moli_module_script_tree as module_tree;
use url::Url;

use crate::module_script_continuation::ModuleScriptCompletionOwner;
use crate::network::ResourceRequestClient;
use crate::planning::ScriptFetchMetadata;
use crate::protocol_types::NavigationResponse;
use crate::script_vm::ScriptVm;
use crate::types::SharedNavigationResponseResult;
use crate::types::{ScriptErrorConstructorKind, ScriptKind};

use super::driver::next_inline_module_eval_id;
use super::tree_adapter;
use super::tree_job::{
    NativeModuleGraphDependencyRequest, NativeModuleTreeFetchRequest, NativeModuleTreeJob,
    NativeModuleTreeJobAdvance,
};
use super::tree_owner::{NativeModuleTreeDocumentOwner, NativeModuleTreeDocumentOwnerAdapter};
use super::{
    ModuleAttributesKey, ModuleEntryId, ModuleFetchMetadata, ModuleGraphFetchedSource,
    ModuleImportPhase, ModuleKind, ModuleLoadError, ModuleLoadStage, ModuleMapEntryState,
    ModuleMapFetchDisposition, ModuleMapKey, ModuleRequestRecord, ModuleResolvedDependency,
    ModuleScriptExecutionOutcome, ModuleSource, PendingDynamicModuleImport,
};

const NATIVE_PARSER_MODULE_GRAPH_JOB: &str = "native parser module graph job";
const NATIVE_RUNTIME_MODULE_GRAPH_JOB: &str = "native runtime module graph job";
const NATIVE_DYNAMIC_IMPORT_GRAPH_JOB: &str = "native dynamic import graph job";

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct ModuleRootInput {
    pub(crate) source_url: Url,
    pub(crate) base_url: Url,
    pub(crate) initiator_url: Url,
    pub(crate) attributes: ModuleAttributesKey,
    pub(crate) phase: ModuleImportPhase,
    pub(crate) source_override: Option<ModuleSource>,
    pub(crate) fetch_metadata: ModuleFetchMetadata,
    pub(crate) parser_owned: bool,
}

impl ModuleRootInput {
    fn with_import_map_integrity_if_absent(mut self, integrity: Option<String>) -> Self {
        self.fetch_metadata = self
            .fetch_metadata
            .with_import_map_integrity_if_absent(integrity);
        self
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct ModuleGraphHandle {
    pub(crate) root_entry: ModuleEntryId,
    pub(crate) entries: Vec<ModuleEntryId>,
}

pub(crate) struct NativeModuleGraphJob {
    tree_job: Option<NativeModuleTreeJob>,
    kind: NativeModuleGraphJobKind,
}

enum NativeModuleGraphJobKind {
    ParserOwned,
    RuntimeModuleScript,
    DynamicImport(Box<PendingDynamicModuleImport>),
}

pub(crate) enum NativeModuleGraphJobAdvance {
    NeedFetches(Vec<NativeModuleGraphFetchRequest>),
    WaitingForFetches,
    Complete(ModuleGraphHandle),
}

pub(crate) struct NativeDynamicModuleImportReady {
    pub(crate) job: NativeModuleGraphJob,
    pub(crate) graph: ModuleGraphHandle,
}

pub(crate) enum ModuleScriptGraphAdvance {
    NeedFetches(Box<ModuleScriptGraphFetchBatch>),
    Complete(ModuleGraphHandle),
}

#[derive(Clone)]
pub(crate) struct NativeModuleGraphFetchRequest {
    source_url: Url,
    initiator_url: Url,
    fetch_metadata: ModuleFetchMetadata,
    kind: ModuleKind,
    tree_client: Option<module_tree::SingleModuleClientToken>,
    tree_graph_level: Option<module_tree::ModuleGraphLevel>,
    module_key: Option<ModuleMapKey>,
    dependency: Option<NativeModuleGraphDependencyRequest>,
}

pub(crate) struct ModuleScriptGraphFetchContinuation {
    request: NativeModuleGraphFetchRequest,
}

pub(crate) struct ModuleScriptGraphFetchBatch {
    job: NativeModuleGraphJob,
    fetches: Vec<ModuleScriptGraphFetchContinuation>,
}

impl ModuleScriptGraphFetchContinuation {
    pub(crate) fn is_top_level_tree_fetch(&self) -> bool {
        self.request.is_top_level_tree_fetch()
    }

    #[cfg(test)]
    pub(crate) fn pending_fetch_key(&self) -> Option<&ModuleMapKey> {
        self.request.pending_fetch_key()
    }

    pub(crate) fn request(&self) -> &NativeModuleGraphFetchRequest {
        &self.request
    }

    pub(crate) fn finish_fetch_into_job(
        self,
        vm: &mut ScriptVm,
        job: &mut NativeModuleGraphJob,
        source: std::result::Result<ModuleGraphFetchedSource, ModuleLoadError>,
    ) -> std::result::Result<NativeModuleGraphJobAdvance, ModuleLoadError> {
        job.finish_module_script_fetch_for_request(vm, &self.request, source)
    }

    #[cfg(test)]
    pub(crate) fn finish_source_for_test(
        self,
        vm: &mut ScriptVm,
        job: &mut NativeModuleGraphJob,
        source: std::result::Result<ModuleSource, ModuleLoadError>,
    ) -> std::result::Result<NativeModuleGraphJobAdvance, ModuleLoadError> {
        let source = source.map(|source| {
            ModuleGraphFetchedSource::new(self.request.source_url.clone(), false, source)
        });
        self.finish_fetch_into_job(vm, job, source)
    }
}

impl ModuleScriptGraphFetchBatch {
    fn new(job: NativeModuleGraphJob, fetches: Vec<ModuleScriptGraphFetchContinuation>) -> Self {
        Self { job, fetches }
    }

    #[cfg(test)]
    pub(crate) fn request(&self) -> &NativeModuleGraphFetchRequest {
        assert_eq!(
            self.fetches.len(),
            1,
            "single-fetch batch helper requires exactly one fetch"
        );
        self.fetches
            .first()
            .expect("single-fetch batch should contain a fetch")
            .request()
    }

    #[cfg(test)]
    pub(crate) fn pending_fetch_key(&self) -> Option<&ModuleMapKey> {
        self.request().pending_fetch_key()
    }

    #[cfg(test)]
    pub(crate) fn finish_fetch(
        self,
        vm: &mut ScriptVm,
        source: std::result::Result<ModuleGraphFetchedSource, ModuleLoadError>,
    ) -> std::result::Result<ModuleScriptGraphAdvance, ModuleLoadError> {
        let (mut job, mut fetches) = self.into_parts();
        assert_eq!(
            fetches.len(),
            1,
            "single-fetch batch completion requires exactly one fetch"
        );
        let fetch = fetches
            .pop()
            .expect("single-fetch batch should contain a fetch");
        let advance = fetch.finish_fetch_into_job(vm, &mut job, source)?;
        Ok(module_script_graph_advance_from_native(job, advance))
    }

    #[cfg(test)]
    pub(crate) fn finish_source_for_test(
        self,
        vm: &mut ScriptVm,
        source: std::result::Result<ModuleSource, ModuleLoadError>,
    ) -> std::result::Result<ModuleScriptGraphAdvance, ModuleLoadError> {
        let source_url = self.request().source_url().clone();
        self.finish_fetch(
            vm,
            source.map(|source| ModuleGraphFetchedSource::new(source_url, false, source)),
        )
    }

    pub(crate) fn into_parts(
        self,
    ) -> (
        NativeModuleGraphJob,
        Vec<ModuleScriptGraphFetchContinuation>,
    ) {
        (self.job, self.fetches)
    }
}

impl NativeModuleGraphFetchRequest {
    pub(crate) fn new(
        source_url: Url,
        initiator_url: Url,
        fetch_metadata: ModuleFetchMetadata,
        kind: ModuleKind,
    ) -> Self {
        Self {
            source_url,
            initiator_url,
            fetch_metadata,
            kind,
            tree_client: None,
            tree_graph_level: None,
            module_key: None,
            dependency: None,
        }
    }

    pub(crate) fn source_url(&self) -> &Url {
        &self.source_url
    }

    pub(crate) fn initiator_url(&self) -> &Url {
        &self.initiator_url
    }

    #[cfg(test)]
    pub(crate) fn initiator_url_for_test(&self) -> &Url {
        self.initiator_url()
    }

    pub(crate) fn nonce(&self) -> Option<&str> {
        self.fetch_metadata.nonce()
    }

    pub(crate) fn fetch_metadata(&self) -> &ModuleFetchMetadata {
        &self.fetch_metadata
    }

    pub(crate) fn pending_fetch_key(&self) -> Option<&ModuleMapKey> {
        self.module_key.as_ref()
    }

    pub(crate) fn tree_client(&self) -> Option<module_tree::SingleModuleClientToken> {
        self.tree_client
    }

    pub(crate) fn dependency(&self) -> Option<&NativeModuleGraphDependencyRequest> {
        self.dependency.as_ref()
    }

    pub(crate) fn effective_key_for_fetched_source(
        &self,
        fetched_source: &ModuleGraphFetchedSource,
    ) -> Option<ModuleMapKey> {
        self.pending_fetch_key()
            .map(|key| fetched_source.effective_key_for_request(key))
    }

    pub(crate) fn effective_fetch_metadata_for_fetched_source(
        &self,
        fetched_source: &ModuleGraphFetchedSource,
    ) -> ModuleFetchMetadata {
        self.fetch_metadata
            .clone()
            .with_response_referrer_policy(fetched_source.response_referrer_policy())
    }

    fn with_tree_fetch(
        mut self,
        client: module_tree::SingleModuleClientToken,
        graph_level: module_tree::ModuleGraphLevel,
        key: ModuleMapKey,
        dependency: Option<NativeModuleGraphDependencyRequest>,
    ) -> Self {
        self.tree_client = Some(client);
        self.tree_graph_level = Some(graph_level);
        self.module_key = Some(key);
        self.dependency = dependency;
        self
    }

    pub(crate) fn is_top_level_tree_fetch(&self) -> bool {
        self.tree_graph_level == Some(module_tree::ModuleGraphLevel::TopLevel)
    }

    pub(crate) fn with_scheduler_priority(
        mut self,
        priority: ScriptFetchSchedulerPriority,
    ) -> Self {
        self.fetch_metadata.request_metadata.scheduler_priority = Some(priority);
        self
    }

    #[cfg(test)]
    pub(crate) fn new_for_test(
        source_url: Url,
        initiator_url: Url,
        fetch_metadata: ModuleFetchMetadata,
        kind: ModuleKind,
    ) -> Self {
        Self::new(source_url, initiator_url, fetch_metadata, kind)
    }

    #[cfg(test)]
    pub(crate) fn new_tree_dependency_for_test(
        source_url: Url,
        initiator_url: Url,
        fetch_metadata: ModuleFetchMetadata,
        kind: ModuleKind,
        client: module_tree::SingleModuleClientToken,
        key: ModuleMapKey,
        parent_key: ModuleMapKey,
        parent_entry_id: ModuleEntryId,
        specifier: String,
        phase: ModuleImportPhase,
    ) -> Self {
        let dependency =
            NativeModuleGraphDependencyRequest::new(parent_key, parent_entry_id, specifier, phase);
        Self::new(source_url, initiator_url, fetch_metadata, kind).with_tree_fetch(
            client,
            module_tree::ModuleGraphLevel::Dependent,
            key,
            Some(dependency),
        )
    }

    #[cfg(test)]
    pub(crate) fn scheduler_priority_for_test(&self) -> Option<ScriptFetchSchedulerPriority> {
        self.fetch_metadata.request_metadata.scheduler_priority
    }

    #[cfg(test)]
    pub(crate) fn integrity_for_test(&self) -> Option<&str> {
        self.fetch_metadata.request_metadata.integrity.as_deref()
    }

    fn request(&self, request_origin: &moli_url::WebOrigin) -> anyhow::Result<Request> {
        let request = Request::new("GET", self.source_url.as_str(), None, vec![])
            .expect("module graph URL should already be parsed")
            .with_page_network_policy()
            .with_initiator_url(&self.initiator_url)
            .with_request_origin(request_origin.clone())
            .with_credentials_mode(self.fetch_metadata.credentials_mode)
            .with_script_fetch_metadata(self.fetch_metadata.request_metadata.clone());
        Ok(match self.kind {
            ModuleKind::Css => request
                .with_resource_type(RequestResourceType::CssStyleSheet)
                .with_browser_request_metadata(BrowserRequestMetadata::StyleModule),
            ModuleKind::Json => {
                request.with_browser_request_metadata(BrowserRequestMetadata::JsonModule)
            }
            ModuleKind::JavaScript | ModuleKind::ModulePreloadText | ModuleKind::WebAssembly => {
                request.with_browser_request_metadata(BrowserRequestMetadata::Script)
            }
        })
    }

    pub(crate) fn fetch_source_callback_with_load<F>(
        &self,
        loader: &ResourceRequestClient,
        load: crate::network::loads::ResourceLoadLease,
        request_origin: moli_url::WebOrigin,
        callback: F,
    ) -> anyhow::Result<()>
    where
        F: FnOnce(
                std::result::Result<ModuleGraphFetchedSource, String>,
                Option<SharedNavigationResponseResult>,
            ) + Send
            + 'static,
    {
        self.fetch_source_callback_inner(loader, load, request_origin, callback)
    }

    pub(crate) fn fetch_source_for_document<F>(
        &self,
        loader: &crate::network::context::DocumentResourceLoader,
        callback: F,
    ) -> anyhow::Result<()>
    where
        F: FnOnce(
                std::result::Result<ModuleGraphFetchedSource, String>,
                Option<SharedNavigationResponseResult>,
            ) + Send
            + 'static,
    {
        let load = loader
            .register_load(
                crate::network::loads::ResourceLoadKind::Script,
                crate::network::loads::ResourceLoadDisposition::Ordinary,
                None,
            )
            .ok_or_else(|| anyhow::anyhow!("Document detached before module fetch registration"))?;
        let request_client = load.request_client();
        self.fetch_source_callback_with_load(
            &request_client,
            load,
            loader.fetch_context().request_origin(),
            callback,
        )
    }

    fn fetch_source_callback_inner<F>(
        &self,
        loader: &ResourceRequestClient,
        load: crate::network::loads::ResourceLoadLease,
        request_origin: moli_url::WebOrigin,
        callback: F,
    ) -> anyhow::Result<()>
    where
        F: FnOnce(
                std::result::Result<ModuleGraphFetchedSource, String>,
                Option<SharedNavigationResponseResult>,
            ) + Send
            + 'static,
    {
        let source_url = self.source_url.clone();
        let kind = self.kind;
        let integrity = self.fetch_metadata.request_metadata.integrity.clone();
        let request = self.request(&request_origin)?;
        let request_mode = request.request_mode;
        let credentials_mode = request.credentials_mode;
        let completion = move |response: anyhow::Result<moli_fetch::Response>| {
            let mut network_result: Option<SharedNavigationResponseResult> = None;
            let result = response
                .map_err(|error| {
                    ModuleLoadError::new(
                        ModuleLoadStage::Fetch,
                        format!("failed to fetch module `{source_url}`: {error} (FailedToLoad)"),
                    )
                    .message()
                    .to_owned()
                })
                .and_then(|response| {
                    let response = NavigationResponse::from(response);
                    network_result = Some(std::sync::Arc::new(Ok(response.clone())));
                    if !(200..=299).contains(&response.status) {
                        return Err(ModuleLoadError::new(
                            ModuleLoadStage::Fetch,
                            format!(
                                "module request `{source_url}` returned HTTP {} (FailedToLoad)",
                                response.status
                            ),
                        )
                        .message()
                        .to_owned());
                    }
                    let mime_result = match kind {
                        ModuleKind::JavaScript | ModuleKind::WebAssembly => {
                            crate::planning::validate_external_script_response_mime(
                                &source_url,
                                ScriptKind::Module,
                                &response,
                            )
                        }
                        ModuleKind::Json => {
                            super::validate_json_module_response_mime(&response.headers)
                        }
                        ModuleKind::Css => {
                            super::validate_css_module_response_mime(&response.headers)
                        }
                        ModuleKind::ModulePreloadText => Ok(()),
                    };
                    if let Err(error) = mime_result {
                        return Err(ModuleLoadError::new(ModuleLoadStage::Fetch, error)
                            .message()
                            .to_owned());
                    }
                    let response_referrer_policy =
                        crate::referrer_policy::response_referrer_policy_from_headers(
                            &response.headers,
                        );
                    let (head, body_bytes) = response.into_byte_parts();
                    crate::network_host::validate_cors_response_chain(
                        &request_origin,
                        &head,
                        credentials_mode,
                    ).map_err(|error| ModuleLoadError::new(ModuleLoadStage::Fetch, error).message().to_owned())?;
                    let response_is_eligible = crate::network_host::network_response_filter(
                        &request_origin,
                        &head,
                        request_mode,
                    ).is_none();
                    if !crate::subresource_integrity::response_matches_subresource_integrity_metadata(
                        &body_bytes,
                        integrity.as_deref(),
                        response_is_eligible,
                    ) {
                        return Err(ModuleLoadError::new(
                            ModuleLoadStage::Fetch,
                            format!(
                                "module request `{source_url}` failed its integrity check (FailedToLoad)"
                            ),
                        )
                        .message()
                        .to_owned());
                    }
                    Ok(match kind {
                        ModuleKind::WebAssembly => ModuleGraphFetchedSource::new(
                            head.final_url,
                            head.redirected,
                            ModuleSource::binary(body_bytes),
                        )
                        .with_response_referrer_policy(response_referrer_policy),
                        ModuleKind::JavaScript
                        | ModuleKind::Json
                        | ModuleKind::Css
                        | ModuleKind::ModulePreloadText => ModuleGraphFetchedSource::new(
                            head.final_url,
                            head.redirected,
                            ModuleSource::text(moli_encoding::decode_utf8(&body_bytes)),
                        )
                        .with_response_referrer_policy(response_referrer_policy),
                    })
                });
            if network_result.is_none()
                && let Err(error) = &result
            {
                network_result = Some(std::sync::Arc::new(Err(error.clone())));
            }
            callback(result, network_result);
        };
        loader.fetch_cacheable_script_text_callback_with_load(request, load, completion)
    }
}

impl NativeModuleGraphJob {
    fn module_script(root: ModuleRootInput, owner: ModuleScriptCompletionOwner) -> Self {
        let (label, chromium_tree, kind) = match owner {
            ModuleScriptCompletionOwner::Parser => (
                "parser_owned_external",
                external_chromium_tree_root_input(&root)
                    .expect("parser-owned module graph root should be valid")
                    .map(tree_adapter::parser_owned_tree_job)
                    .expect("parser-owned module graph jobs require an external tree root"),
                NativeModuleGraphJobKind::ParserOwned,
            ),
            ModuleScriptCompletionOwner::Runtime => (
                "runtime_module_script_external",
                external_chromium_tree_root_input(&root)
                    .expect("runtime module graph root should be valid")
                    .map(tree_adapter::runtime_module_script_tree_job)
                    .expect("runtime module graph jobs require an external tree root"),
                NativeModuleGraphJobKind::RuntimeModuleScript,
            ),
        };
        trace_module_graph_job_created(label, &root);
        Self {
            tree_job: Some(NativeModuleTreeJob::new(chromium_tree)),
            kind,
        }
    }

    fn parser_owned(root: ModuleRootInput) -> Self {
        Self::module_script(root, ModuleScriptCompletionOwner::Parser)
    }

    fn runtime_module_script(root: ModuleRootInput) -> Self {
        Self::module_script(root, ModuleScriptCompletionOwner::Runtime)
    }

    pub(crate) fn parser_owned_compiled_entry(
        key: ModuleMapKey,
        entry: ModuleEntryId,
        source_url: Url,
        base_url: Url,
        fetch_metadata: ModuleFetchMetadata,
    ) -> Self {
        native_module_graph_job_for_inline_entry(
            &ModuleRootInput {
                source_url,
                base_url,
                initiator_url: key.url().clone(),
                attributes: key.attributes().clone(),
                phase: ModuleImportPhase::Evaluation,
                source_override: None,
                fetch_metadata,
                parser_owned: true,
            },
            &key,
            entry,
            ModuleScriptCompletionOwner::Parser,
        )
    }

    pub(crate) fn tree_id(&self) -> Option<module_tree::ModuleTreeId> {
        self.tree_job
            .as_ref()
            .map(|tree_job| tree_job.chromium_tree().tree_id())
    }

    pub(crate) fn dynamic_import(request: PendingDynamicModuleImport) -> Self {
        Self {
            tree_job: None,
            kind: NativeModuleGraphJobKind::DynamicImport(Box::new(request)),
        }
    }

    pub(crate) fn needs_dynamic_import_graph_start(&self) -> bool {
        matches!(&self.kind, NativeModuleGraphJobKind::DynamicImport(_)) && self.tree_job.is_none()
    }

    fn kind_label(&self) -> &'static str {
        match self.kind {
            NativeModuleGraphJobKind::ParserOwned => "parser_owned",
            NativeModuleGraphJobKind::RuntimeModuleScript => "runtime_module_script",
            NativeModuleGraphJobKind::DynamicImport(_) => "dynamic_import",
        }
    }

    pub(crate) fn take_pending_joined_clients(
        &mut self,
    ) -> Vec<module_tree::SingleModuleClientToken> {
        self.tree_job
            .as_mut()
            .map(NativeModuleTreeJob::take_pending_joined_clients)
            .unwrap_or_default()
    }

    pub(crate) fn advance_module_script_owner_lane(
        &mut self,
        vm: &mut ScriptVm,
    ) -> std::result::Result<NativeModuleGraphJobAdvance, ModuleLoadError> {
        match self.kind {
            NativeModuleGraphJobKind::ParserOwned => {
                self.advance_owner_lane(vm, NATIVE_PARSER_MODULE_GRAPH_JOB)
            }
            NativeModuleGraphJobKind::RuntimeModuleScript => {
                self.advance_owner_lane(vm, NATIVE_RUNTIME_MODULE_GRAPH_JOB)
            }
            NativeModuleGraphJobKind::DynamicImport(_) => {
                self.advance_owner_lane(vm, NATIVE_DYNAMIC_IMPORT_GRAPH_JOB)
            }
        }
    }

    pub(crate) fn advance_dynamic_import_owner_lane(
        &mut self,
        vm: &mut ScriptVm,
    ) -> std::result::Result<NativeModuleGraphJobAdvance, ModuleLoadError> {
        let mut owner = NativeModuleTreeDocumentOwner::new(vm);
        self.advance_dynamic_import_owner_lane_with_owner(&mut owner)
    }

    pub(crate) fn advance_dynamic_import_owner_lane_with_owner<O>(
        &mut self,
        owner: &mut O,
    ) -> std::result::Result<NativeModuleGraphJobAdvance, ModuleLoadError>
    where
        O: NativeModuleTreeDocumentOwnerAdapter,
    {
        self.prepare_dynamic_import_loader_with_owner(owner)?;
        self.advance_chromium_tree_owner_lane_with_owner(owner)
    }

    pub(crate) fn finish_dynamic_import_fetch_for_request(
        &mut self,
        vm: &mut ScriptVm,
        request: &NativeModuleGraphFetchRequest,
        source: std::result::Result<ModuleGraphFetchedSource, ModuleLoadError>,
    ) -> std::result::Result<NativeModuleGraphJobAdvance, ModuleLoadError> {
        let mut owner = NativeModuleTreeDocumentOwner::new(vm);
        self.finish_dynamic_import_fetch_for_request_with_owner(&mut owner, request, source)
    }

    pub(crate) fn finish_dynamic_import_fetch_for_request_with_owner<O>(
        &mut self,
        owner: &mut O,
        request: &NativeModuleGraphFetchRequest,
        source: std::result::Result<ModuleGraphFetchedSource, ModuleLoadError>,
    ) -> std::result::Result<NativeModuleGraphJobAdvance, ModuleLoadError>
    where
        O: NativeModuleTreeDocumentOwnerAdapter,
    {
        self.finish_pending_chromium_tree_fetch_for_request_with_owner(owner, request, source)
    }

    pub(crate) fn finish_module_tree_fetch_for_request_with_owner<O>(
        &mut self,
        owner: &mut O,
        request: &NativeModuleGraphFetchRequest,
        source: std::result::Result<ModuleGraphFetchedSource, ModuleLoadError>,
    ) -> std::result::Result<NativeModuleGraphJobAdvance, ModuleLoadError>
    where
        O: NativeModuleTreeDocumentOwnerAdapter,
    {
        self.finish_pending_chromium_tree_fetch_for_request_with_owner(owner, request, source)
    }

    pub(crate) fn finish_joined_module_map_fetch(
        &mut self,
        vm: &mut ScriptVm,
        key: module_tree::ModuleMapKey,
        client: module_tree::SingleModuleClientToken,
    ) -> std::result::Result<NativeModuleGraphJobAdvance, ModuleLoadError> {
        let mut owner = NativeModuleTreeDocumentOwner::new(vm);
        self.finish_joined_module_map_fetch_with_owner(&mut owner, key, client)
    }

    pub(crate) fn finish_joined_module_map_fetch_with_owner<O>(
        &mut self,
        owner: &mut O,
        key: module_tree::ModuleMapKey,
        client: module_tree::SingleModuleClientToken,
    ) -> std::result::Result<NativeModuleGraphJobAdvance, ModuleLoadError>
    where
        O: NativeModuleTreeDocumentOwnerAdapter,
    {
        let outcome = module_map_fetch_outcome_for_key_with_owner(owner, &key)?;
        self.resume_chromium_tree_fetch_outcome_with_owner(owner, client, outcome)
    }

    pub(crate) fn finish_joined_module_map_fetch_for_local_key_with_owner<O>(
        &mut self,
        owner: &mut O,
        key: &ModuleMapKey,
        client: module_tree::SingleModuleClientToken,
    ) -> std::result::Result<NativeModuleGraphJobAdvance, ModuleLoadError>
    where
        O: NativeModuleTreeDocumentOwnerAdapter,
    {
        self.finish_joined_module_map_fetch_with_owner(owner, chromium_module_key(key), client)
    }

    fn advance_owner_lane(
        &mut self,
        vm: &mut ScriptVm,
        _job_name: &str,
    ) -> std::result::Result<NativeModuleGraphJobAdvance, ModuleLoadError> {
        self.advance_chromium_tree_owner_lane(vm)
    }

    #[cfg(test)]
    pub(crate) fn has_chromium_tree_for_test(&self) -> bool {
        self.tree_job.is_some()
    }

    #[cfg(test)]
    pub(crate) fn pending_joined_client_count_for_test(&self) -> usize {
        self.tree_job
            .as_ref()
            .map(NativeModuleTreeJob::pending_joined_client_count)
            .unwrap_or(0)
    }

    fn prepare_dynamic_import_loader_with_owner<O>(
        &mut self,
        owner: &mut O,
    ) -> std::result::Result<(), ModuleLoadError>
    where
        O: NativeModuleTreeDocumentOwnerAdapter,
    {
        if self.tree_job.is_some() {
            return Ok(());
        }
        let NativeModuleGraphJobKind::DynamicImport(request) = &self.kind else {
            panic!("native dynamic import graph job missing request");
        };
        let root = dynamic_import_root_input(owner, request)?;
        trace_module_graph_job_created("dynamic_import_external", &root);
        self.tree_job = external_chromium_tree_root_input(&root)?
            .map(tree_adapter::dynamic_import_tree_job)
            .map(NativeModuleTreeJob::new);
        Ok(())
    }

    pub(crate) fn into_dynamic_import_request(self) -> PendingDynamicModuleImport {
        match self.kind {
            NativeModuleGraphJobKind::DynamicImport(request) => *request,
            NativeModuleGraphJobKind::ParserOwned => {
                panic!("native dynamic import graph job missing request")
            }
            NativeModuleGraphJobKind::RuntimeModuleScript => {
                panic!("native dynamic import graph job missing request")
            }
        }
    }

    pub(crate) fn dynamic_import_request(&self) -> Option<&PendingDynamicModuleImport> {
        match &self.kind {
            NativeModuleGraphJobKind::DynamicImport(request) => Some(request),
            NativeModuleGraphJobKind::ParserOwned
            | NativeModuleGraphJobKind::RuntimeModuleScript => None,
        }
    }

    fn advance_chromium_tree_owner_lane(
        &mut self,
        vm: &mut ScriptVm,
    ) -> std::result::Result<NativeModuleGraphJobAdvance, ModuleLoadError> {
        let mut owner = NativeModuleTreeDocumentOwner::new(vm);
        self.advance_chromium_tree_owner_lane_with_owner(&mut owner)
    }

    pub(crate) fn advance_chromium_tree_owner_lane_with_owner<O>(
        &mut self,
        owner: &mut O,
    ) -> std::result::Result<NativeModuleGraphJobAdvance, ModuleLoadError>
    where
        O: NativeModuleTreeDocumentOwnerAdapter,
    {
        let job_kind = self.kind_label();
        let (poll, tree_id) = {
            let tree_job = self.tree_job_mut()?;
            let tree_id = tree_job.chromium_tree().tree_id();
            trace_module_tree_poll_start(job_kind, tree_job.chromium_tree());
            let mut host = RendererModuleScriptTreeHost::new(&mut *owner);
            let drive = tree_job.drive(&mut host);
            (drive, tree_id)
        };
        trace_module_tree_drive_result(job_kind, tree_id, &poll);
        self.advance_from_chromium_tree_drive(owner, poll)
    }

    fn finish_module_script_fetch_for_request(
        &mut self,
        vm: &mut ScriptVm,
        request: &NativeModuleGraphFetchRequest,
        source: std::result::Result<ModuleGraphFetchedSource, ModuleLoadError>,
    ) -> std::result::Result<NativeModuleGraphJobAdvance, ModuleLoadError> {
        self.finish_pending_chromium_tree_fetch_for_request(vm, request, source)
    }

    fn finish_pending_chromium_tree_fetch_for_request(
        &mut self,
        vm: &mut ScriptVm,
        request: &NativeModuleGraphFetchRequest,
        source: std::result::Result<ModuleGraphFetchedSource, ModuleLoadError>,
    ) -> std::result::Result<NativeModuleGraphJobAdvance, ModuleLoadError> {
        let mut owner = NativeModuleTreeDocumentOwner::new(vm);
        self.finish_pending_chromium_tree_fetch_for_request_with_owner(&mut owner, request, source)
    }

    fn finish_pending_chromium_tree_fetch_for_request_with_owner<O>(
        &mut self,
        owner: &mut O,
        request: &NativeModuleGraphFetchRequest,
        source: std::result::Result<ModuleGraphFetchedSource, ModuleLoadError>,
    ) -> std::result::Result<NativeModuleGraphJobAdvance, ModuleLoadError>
    where
        O: NativeModuleTreeDocumentOwnerAdapter,
    {
        let client = request.tree_client.ok_or_else(|| {
            ModuleLoadError::new(
                ModuleLoadStage::Fetch,
                "module graph fetch request was missing its module tree client token",
            )
        })?;
        if let Err(error) = &source {
            let key = request.pending_fetch_key().cloned().ok_or_else(|| {
                ModuleLoadError::new(
                    ModuleLoadStage::Fetch,
                    "failed module graph fetch request was missing its module map key",
                )
            })?;
            // Settle the shared fetch before failing this graph, so joined
            // clients and later imports observe the cached fetch failure.
            owner.mark_module_failed(key, error.clone());
        }
        self.finish_pending_chromium_tree_fetch_for_client_with_owner(
            owner, client, request, source,
        )
    }

    fn finish_pending_chromium_tree_fetch_for_client_with_owner<O>(
        &mut self,
        owner: &mut O,
        client: module_tree::SingleModuleClientToken,
        request: &NativeModuleGraphFetchRequest,
        source: std::result::Result<ModuleGraphFetchedSource, ModuleLoadError>,
    ) -> std::result::Result<NativeModuleGraphJobAdvance, ModuleLoadError>
    where
        O: NativeModuleTreeDocumentOwnerAdapter,
    {
        trace_module_tree_fetch_completed_to_job(client, source.is_ok());
        let outcome = match source {
            Ok(source) => module_tree::ModuleFetchOutcome::Fetched(Box::new(
                chromium_fetched_source_for_request(source, request)?,
            )),
            Err(error) => module_tree::ModuleFetchOutcome::Failed(chromium_error(error)),
        };
        self.resume_chromium_tree_fetch_outcome_with_owner(owner, client, outcome)
    }

    pub(crate) fn resume_chromium_tree_fetch_outcome_with_owner<O>(
        &mut self,
        owner: &mut O,
        client: module_tree::SingleModuleClientToken,
        outcome: module_tree::ModuleFetchOutcome,
    ) -> std::result::Result<NativeModuleGraphJobAdvance, ModuleLoadError>
    where
        O: NativeModuleTreeDocumentOwnerAdapter,
    {
        let drive = {
            let tree_job = self.tree_job_mut()?;
            let mut host = RendererModuleScriptTreeHost::new(&mut *owner);
            tree_job.resume_single_module_outcome_and_drive(&mut host, client, outcome)
        };
        trace_module_tree_resume_drive(self.kind_label(), &drive);
        self.advance_from_chromium_tree_drive(owner, drive)
    }

    fn tree_job_mut(&mut self) -> std::result::Result<&mut NativeModuleTreeJob, ModuleLoadError> {
        self.tree_job.as_mut().ok_or_else(|| {
            ModuleLoadError::new(
                ModuleLoadStage::Compile,
                "native module graph job was missing module script tree",
            )
        })
    }

    fn advance_from_chromium_tree_drive<O>(
        &mut self,
        owner: &mut O,
        drive: module_tree::ModuleScriptTreeDrive,
    ) -> std::result::Result<NativeModuleGraphJobAdvance, ModuleLoadError>
    where
        O: NativeModuleTreeDocumentOwnerAdapter,
    {
        let advance = self.tree_job_mut()?.advance_from_drive(
            drive,
            |key| local_module_key(key).map(|_| ()),
            native_tree_fetch_request_from_chromium,
        )?;
        match advance {
            NativeModuleTreeJobAdvance::NeedFetches(fetches) => {
                let mut requests = Vec::with_capacity(fetches.len());
                for fetch in fetches {
                    let key = fetch.key().clone();
                    let request = native_fetch_request_from_tree_fetch(&fetch)?.with_tree_fetch(
                        fetch.client(),
                        fetch.graph_level(),
                        key.clone(),
                        fetch.dependency().cloned(),
                    );
                    owner.dispatch_module_fetch_csp_report_only_violation(
                        &key,
                        &request.fetch_metadata,
                    );
                    if let Some(error) =
                        owner.csp_blocked_module_fetch_error(&key, &request.fetch_metadata)
                    {
                        owner.mark_module_failed(key.clone(), error.clone());
                        return Err(error);
                    }
                    trace_module_tree_fetch_emitted(fetch.request(), &key);
                    requests.push(request);
                }
                Ok(NativeModuleGraphJobAdvance::NeedFetches(requests))
            }
            NativeModuleTreeJobAdvance::WaitingForFetches { client_count } => {
                if client_count > 0 {
                    trace_module_tree_waiting(self.kind_label(), client_count);
                }
                Ok(NativeModuleGraphJobAdvance::WaitingForFetches)
            }
            NativeModuleTreeJobAdvance::Complete(graph) => {
                trace_module_tree_complete(self.kind_label(), &graph);
                Ok(NativeModuleGraphJobAdvance::Complete(local_graph(graph)))
            }
            NativeModuleTreeJobAdvance::Failed(error) => Err(local_error(error)),
            NativeModuleTreeJobAdvance::Aborted(reason) => Err(chromium_abort_error(reason)),
            NativeModuleTreeJobAdvance::PendingWithoutWork => Err(ModuleLoadError::new(
                ModuleLoadStage::Fetch,
                "module script tree reached a pending state without fetch, wait, or completion",
            )),
            NativeModuleTreeJobAdvance::IgnoredStaleCompletion => Err(ModuleLoadError::new(
                ModuleLoadStage::Fetch,
                "module script tree ignored a stale completion during owner-lane advance",
            )),
        }
    }
}

fn trace_module_graph_job_created(kind: &'static str, root: &ModuleRootInput) {
    if !moli_trace::module_load_trace_enabled() {
        return;
    }
    tracing::info!(
        target: "moli_module_load",
        event = "module_graph_job_created",
        kind,
        url = %root.source_url,
        base_url = %root.base_url,
        initiator_url = %root.initiator_url,
        phase = ?root.phase,
        parser_owned = root.parser_owned,
        integrity = ?root.fetch_metadata.request_metadata.integrity,
    );
}

fn trace_module_tree_poll_start(job_kind: &'static str, tree: &module_tree::ModuleScriptTreeJob) {
    if !moli_trace::module_load_trace_enabled() {
        return;
    }
    tracing::info!(
        target: "moli_module_load",
        event = "module_tree_poll_start",
        job_kind,
        tree_id = tree.tree_id().0,
        state = ?tree.state(),
        pending_client_count = tree.pending_client_count(),
    );
}

fn trace_module_tree_drive_result(
    job_kind: &'static str,
    tree_id: module_tree::ModuleTreeId,
    drive: &module_tree::ModuleScriptTreeDrive,
) {
    if !moli_trace::module_load_trace_enabled() {
        return;
    }
    match drive {
        module_tree::ModuleScriptTreeDrive::NeedFetches(fetches) => {
            tracing::info!(
                target: "moli_module_load",
                event = "module_tree_drive_result",
                job_kind,
                tree_id = tree_id.0,
                result = "need_fetches",
                fetch_count = fetches.len(),
                joined_fetch_count = fetches.joined_fetches.len(),
            );
        }
        module_tree::ModuleScriptTreeDrive::WaitingForSingleModuleClients(wait) => {
            tracing::info!(
                target: "moli_module_load",
                event = "module_tree_drive_result",
                job_kind,
                tree_id = tree_id.0,
                result = "waiting_for_single_module_clients",
                client_count = wait.client_count,
                joined_fetch_count = wait.joined_fetches.len(),
            );
        }
        module_tree::ModuleScriptTreeDrive::Complete(graph) => {
            tracing::info!(
                target: "moli_module_load",
                event = "module_tree_drive_result",
                job_kind,
                tree_id = tree_id.0,
                result = "complete",
                entry_count = graph.entries.len(),
                dependency_edge_count = graph.dependency_edges.len(),
                joined_fetch_count = 0usize,
            );
        }
        module_tree::ModuleScriptTreeDrive::Failed(error) => {
            tracing::info!(
                target: "moli_module_load",
                event = "module_tree_drive_result",
                job_kind,
                tree_id = tree_id.0,
                result = "failed",
                stage = ?error.stage,
                joined_fetch_count = 0usize,
            );
        }
        module_tree::ModuleScriptTreeDrive::Aborted(reason) => {
            tracing::info!(
                target: "moli_module_load",
                event = "module_tree_drive_result",
                job_kind,
                tree_id = tree_id.0,
                result = "aborted",
                reason = ?reason,
                joined_fetch_count = 0usize,
            );
        }
        module_tree::ModuleScriptTreeDrive::Pending(idle) => {
            tracing::info!(
                target: "moli_module_load",
                event = "module_tree_drive_result",
                job_kind,
                tree_id = tree_id.0,
                result = "pending",
                joined_fetch_count = idle.joined_fetches.len(),
            );
        }
        module_tree::ModuleScriptTreeDrive::IgnoredStaleCompletion(idle) => {
            tracing::info!(
                target: "moli_module_load",
                event = "module_tree_drive_result",
                job_kind,
                tree_id = tree_id.0,
                result = "ignored_stale_completion",
                joined_fetch_count = idle.joined_fetches.len(),
            );
        }
    }
}

fn trace_module_tree_resume_drive(
    job_kind: &'static str,
    drive: &module_tree::ModuleScriptTreeDrive,
) {
    if !moli_trace::module_load_trace_enabled() {
        return;
    }
    match drive {
        module_tree::ModuleScriptTreeDrive::NeedFetches(fetches) => {
            tracing::info!(
                target: "moli_module_load",
                event = "module_tree_resume_drive",
                job_kind,
                result = "need_fetches",
                fetch_count = fetches.len(),
                joined_fetch_count = fetches.joined_fetches.len(),
            );
        }
        module_tree::ModuleScriptTreeDrive::WaitingForSingleModuleClients(wait) => {
            tracing::info!(
                target: "moli_module_load",
                event = "module_tree_resume_drive",
                job_kind,
                result = "waiting_for_single_module_clients",
                client_count = wait.client_count,
                joined_fetch_count = wait.joined_fetches.len(),
            );
        }
        module_tree::ModuleScriptTreeDrive::Complete(graph) => {
            tracing::info!(
                target: "moli_module_load",
                event = "module_tree_resume_drive",
                job_kind,
                result = "complete",
                entry_count = graph.entries.len(),
                dependency_edge_count = graph.dependency_edges.len(),
            );
        }
        module_tree::ModuleScriptTreeDrive::Failed(error) => {
            tracing::info!(
                target: "moli_module_load",
                event = "module_tree_resume_drive",
                job_kind,
                result = "failed",
                stage = ?error.stage,
            );
        }
        module_tree::ModuleScriptTreeDrive::Aborted(reason) => {
            tracing::info!(
                target: "moli_module_load",
                event = "module_tree_resume_drive",
                job_kind,
                result = "aborted",
                reason = ?reason,
            );
        }
        module_tree::ModuleScriptTreeDrive::Pending(idle) => {
            tracing::info!(
                target: "moli_module_load",
                event = "module_tree_resume_drive",
                job_kind,
                result = "pending",
                joined_fetch_count = idle.joined_fetches.len(),
            );
        }
        module_tree::ModuleScriptTreeDrive::IgnoredStaleCompletion(idle) => {
            tracing::info!(
                target: "moli_module_load",
                event = "module_tree_resume_drive",
                job_kind,
                result = "ignored_stale_completion",
                joined_fetch_count = idle.joined_fetches.len(),
            );
        }
    }
}

fn trace_module_tree_fetch_emitted(fetch: &module_tree::ModuleFetchRequest, key: &ModuleMapKey) {
    if !moli_trace::module_load_trace_enabled() {
        return;
    }
    tracing::info!(
        target: "moli_module_load",
        event = "module_tree_fetch_emitted",
        tree_id = fetch.tree_id.0,
        client_sequence = fetch.client.sequence,
        url = %fetch.source_url,
        key_url = %key.url(),
        graph_level = ?fetch.graph_level,
        phase = ?fetch.phase,
        requester = ?fetch.requester,
        ordering = ?fetch.ordering,
        initiator_url = %fetch.initiator_url,
    );
}

fn trace_module_tree_fetch_registered(
    request: &module_tree::ModuleFetchRequest,
    client: module_tree::SingleModuleClientToken,
    disposition: &'static str,
    entry_id: Option<u64>,
) {
    if !moli_trace::module_load_trace_enabled() {
        return;
    }
    tracing::info!(
        target: "moli_module_load",
        event = "module_tree_fetch_registered",
        tree_id = request.tree_id.0,
        client_sequence = client.sequence,
        url = %request.source_url,
        graph_level = ?request.graph_level,
        phase = ?request.phase,
        requester = ?request.requester,
        ordering = ?request.ordering,
        disposition,
        entry_id,
    );
}

fn trace_module_tree_fetch_completed_to_job(
    client: module_tree::SingleModuleClientToken,
    ok: bool,
) {
    if !moli_trace::module_load_trace_enabled() {
        return;
    }
    tracing::info!(
        target: "moli_module_load",
        event = "module_tree_fetch_completed_to_job",
        tree_id = client.tree_id.0,
        client_sequence = client.sequence,
        ok,
    );
}

fn trace_module_tree_waiting(job_kind: &'static str, client_count: usize) {
    if !moli_trace::module_load_trace_enabled() {
        return;
    }
    tracing::info!(
        target: "moli_module_load",
        event = "module_tree_waiting_for_clients",
        job_kind,
        client_count,
    );
}

fn trace_module_tree_complete(job_kind: &'static str, graph: &module_tree::ModuleGraphHandle) {
    if !moli_trace::module_load_trace_enabled() {
        return;
    }
    tracing::info!(
        target: "moli_module_load",
        event = "module_tree_complete",
        job_kind,
        root_entry = graph.root_entry.0,
        entry_count = graph.entries.len(),
        dependency_edge_count = graph.dependency_edges.len(),
    );
}

struct RendererModuleScriptTreeHost<O> {
    owner: O,
}

impl<O> RendererModuleScriptTreeHost<O> {
    fn new(owner: O) -> Self {
        Self { owner }
    }
}

impl<O: NativeModuleTreeDocumentOwnerAdapter> RendererModuleScriptTreeHost<O> {
    fn owner_fetched_source_from_entry(
        &self,
        entry: ModuleEntryId,
        request_key: module_tree::ModuleMapKey,
        source: ModuleSource,
    ) -> module_tree::FetchedModuleSource {
        let effective_key = self.owner.module_entry_key(entry);
        let source_url = effective_key.url().clone();
        let effective_fetch_metadata = self.owner.module_effective_fetch_metadata(entry);
        module_tree::FetchedModuleSource::new(
            request_key,
            chromium_module_key(&effective_key),
            source_url.clone(),
            source_url,
            chromium_source(source),
            chromium_fetch_metadata(&effective_fetch_metadata),
        )
    }

    fn owner_ready_module_from_entry(&self, entry: ModuleEntryId) -> module_tree::ReadyModule {
        let effective_key = self.owner.module_entry_key(entry);
        let source_url = effective_key.url().clone();
        let effective_fetch_metadata = self.owner.module_effective_fetch_metadata(entry);
        module_tree::ReadyModule::new(
            chromium_entry_id(entry),
            chromium_module_key(&effective_key),
            source_url.clone(),
            chromium_fetch_metadata(&effective_fetch_metadata),
        )
    }
}

impl<O: NativeModuleTreeDocumentOwnerAdapter> module_tree::ModuleScriptTreeHost
    for RendererModuleScriptTreeHost<O>
{
    fn resolve_module_request(
        &mut self,
        specifier: &str,
        base_url: &Url,
        attributes: &module_tree::ModuleAttributesKey,
        requested_phase: module_tree::ModuleImportPhase,
    ) -> std::result::Result<module_tree::ResolvedModuleRequest, module_tree::ModuleLoadError> {
        let resolved_url = self
            .owner
            .resolve_module_specifier(specifier, base_url)
            .map_err(|error| {
                module_tree::ModuleLoadError::new(
                    module_tree::ModuleLoadStage::Resolve,
                    format!(
                        "failed to resolve module specifier `{specifier}` from `{base_url}`: {error}"
                    ),
                )
            })?;
        let attributes = local_attributes(attributes);
        let local_key = ModuleMapKey::from_url_and_attributes(&resolved_url, &attributes).map_err(
            |message| {
                module_tree::ModuleLoadError::new(
                    module_tree::ModuleLoadStage::Resolve,
                    format!("{message} for import `{specifier}`"),
                )
                .with_error_constructor(module_tree::ModuleErrorConstructorKind::TypeError)
            },
        )?;
        if requested_phase == module_tree::ModuleImportPhase::Source
            && local_key.kind() != ModuleKind::WebAssembly
        {
            return Err(module_tree::ModuleLoadError::new(
                module_tree::ModuleLoadStage::Resolve,
                format!(
                    "source-phase import `{specifier}` does not resolve to a WebAssembly module"
                ),
            )
            .with_error_constructor(module_tree::ModuleErrorConstructorKind::SyntaxError));
        }
        let integrity = self.owner.resolve_module_integrity(&resolved_url);
        Ok(module_tree::ResolvedModuleRequest {
            key: chromium_module_key(&local_key),
            source_url: resolved_url.clone(),
            base_url: resolved_url,
            kind: chromium_module_kind(local_key.kind()),
            attributes: chromium_attributes(&attributes),
            phase: requested_phase,
            integrity,
        })
    }

    fn start_or_join_single_module_fetch(
        &mut self,
        request: module_tree::ModuleFetchRequest,
        client: module_tree::SingleModuleClientToken,
    ) -> module_tree::SingleModuleFetchDisposition {
        let key = match local_module_key(&request.key) {
            Ok(key) => key,
            Err(error) => {
                trace_module_tree_fetch_registered(&request, client, "failed_key_conversion", None);
                return module_tree::SingleModuleFetchDisposition::Completed(
                    module_tree::ModuleFetchOutcome::Failed(chromium_error(error)),
                );
            }
        };
        match self.owner.start_or_join_module_fetch(key.clone()) {
            ModuleMapFetchDisposition::StartedFetch(entry_id) => {
                trace_module_tree_fetch_registered(
                    &request,
                    client,
                    "started_network_fetch",
                    Some(u64::from(entry_id.raw())),
                );
                module_tree::SingleModuleFetchDisposition::StartedNetworkFetch {
                    fetch_id: module_tree::ModuleFetchId(u64::from(entry_id.raw())),
                }
            }
            ModuleMapFetchDisposition::JoinedFetching(_) => {
                self.register_joined_module_fetch_client(key, &request);
                trace_module_tree_fetch_registered(&request, client, "joined_existing_fetch", None);
                module_tree::SingleModuleFetchDisposition::JoinedExistingFetch
            }
            ModuleMapFetchDisposition::AlreadyFetched(entry_id) => {
                trace_module_tree_fetch_registered(
                    &request,
                    client,
                    "already_fetched_completion_queued",
                    Some(u64::from(entry_id.raw())),
                );
                let outcome = self
                    .owner
                    .module_source(entry_id)
                    .map(|source| {
                        module_tree::ModuleFetchOutcome::Fetched(Box::new(
                            self.owner_fetched_source_from_entry(
                                entry_id,
                                request.key.clone(),
                                source,
                            ),
                        ))
                    })
                    .unwrap_or_else(|| {
                        module_tree::ModuleFetchOutcome::Failed(module_tree::ModuleLoadError::new(
                            module_tree::ModuleLoadStage::Fetch,
                            "fetched module map entry did not retain source",
                        ))
                    });
                module_tree::SingleModuleFetchDisposition::Completed(outcome)
            }
            ModuleMapFetchDisposition::AlreadyCompiled(entry_id) => {
                trace_module_tree_fetch_registered(
                    &request,
                    client,
                    "already_compiled_completion_queued",
                    Some(u64::from(entry_id.raw())),
                );
                module_tree::SingleModuleFetchDisposition::Completed(
                    module_tree::ModuleFetchOutcome::Ready(Box::new(
                        self.owner_ready_module_from_entry(entry_id),
                    )),
                )
            }
            ModuleMapFetchDisposition::AlreadyFailed(entry_id) => {
                trace_module_tree_fetch_registered(
                    &request,
                    client,
                    "already_failed_completion_queued",
                    Some(u64::from(entry_id.raw())),
                );
                let error = self
                    .owner
                    .module_failure(entry_id)
                    .map(chromium_error)
                    .unwrap_or_else(|| {
                        module_tree::ModuleLoadError::new(
                            module_tree::ModuleLoadStage::Resolve,
                            "module previously failed to load",
                        )
                    });
                module_tree::SingleModuleFetchDisposition::Completed(
                    module_tree::ModuleFetchOutcome::Failed(error),
                )
            }
        }
    }

    fn compile_module_source(
        &mut self,
        fetched_source: module_tree::FetchedModuleSource,
        phase: module_tree::ModuleImportPhase,
    ) -> std::result::Result<module_tree::CompiledModuleSnapshot, module_tree::ModuleLoadError>
    {
        let local_request_key =
            local_module_key(&fetched_source.request_key).map_err(chromium_error)?;
        let local_key = local_module_key(&fetched_source.key).map_err(chromium_error)?;
        let source = local_source(fetched_source.source);
        let source_url = fetched_source.source_url.clone();
        let local_effective_fetch_metadata =
            local_fetch_metadata(&fetched_source.effective_fetch_metadata);
        self.owner.insert_module_source_for_request(
            local_request_key.clone(),
            local_key.clone(),
            source.clone(),
            local_effective_fetch_metadata.clone(),
        );
        let (record, identity) = self
            .owner
            .compile_module_record(
                local_key.clone(),
                &source,
                &source_url,
                &local_effective_fetch_metadata,
            )
            .map_err(chromium_error)?;
        let requests = record
            .requests()
            .iter()
            .map(chromium_request_record)
            .collect();
        let entry = self.owner.insert_compiled_module_record(
            local_request_key,
            record,
            identity,
            local_effective_fetch_metadata,
        );
        Ok(module_tree::CompiledModuleSnapshot {
            entry: chromium_entry_id(entry),
            key: fetched_source.key,
            base_url: fetched_source.base_url,
            effective_fetch_metadata: fetched_source.effective_fetch_metadata,
            requested_modules: requests,
            phase,
            has_parse_error: false,
            parse_error: None,
        })
    }

    fn module_dependencies(
        &self,
        entry: module_tree::ModuleEntryId,
    ) -> std::result::Result<module_tree::ModuleDependencySnapshot, module_tree::ModuleLoadError>
    {
        let entry = local_entry_id(entry);
        let key = self.owner.module_entry_key(entry);
        let base_url = self.owner.module_entry_url(entry);
        let effective_fetch_metadata = self.owner.module_effective_fetch_metadata(entry);
        let requested_modules = self
            .owner
            .module_requests(entry)
            .iter()
            .map(chromium_request_record)
            .collect();
        Ok(module_tree::ModuleDependencySnapshot {
            entry: chromium_entry_id(entry),
            key: chromium_module_key(&key),
            base_url,
            effective_fetch_metadata: chromium_fetch_metadata(&effective_fetch_metadata),
            requested_modules,
        })
    }

    fn link_module_graph(
        &mut self,
        root: module_tree::ModuleEntryId,
        entries: &[module_tree::ModuleEntryId],
        dependency_edges: &[module_tree::ModuleDependencyEdge],
    ) -> std::result::Result<module_tree::ModuleGraphHandle, module_tree::ModuleLoadError> {
        let mut dependencies_by_parent: HashMap<ModuleEntryId, Vec<ModuleResolvedDependency>> =
            HashMap::new();
        for edge in dependency_edges {
            let parent = local_entry_id(edge.parent_entry);
            let child_key = local_module_key(&edge.child_key).map_err(chromium_error)?;
            dependencies_by_parent
                .entry(parent)
                .or_default()
                .push(ModuleResolvedDependency::new(
                    edge.specifier.clone(),
                    local_attributes(&edge.attributes),
                    child_key,
                ));
        }
        for (entry, dependencies) in dependencies_by_parent {
            self.owner
                .set_module_resolved_dependencies(entry, dependencies);
        }
        Ok(module_tree::ModuleGraphHandle {
            root_entry: root,
            entries: entries.to_vec(),
            entry_phases: HashMap::new(),
            dependency_edges: dependency_edges.to_vec(),
        })
    }

    fn mark_module_failed(
        &mut self,
        key: module_tree::ModuleMapKey,
        error: module_tree::ModuleLoadError,
    ) -> module_tree::ModuleEntryId {
        let local_key =
            local_module_key(&key).unwrap_or_else(|_| ModuleMapKey::java_script(key.url.clone()));
        let entry = self.owner.mark_module_failed(local_key, local_error(error));
        chromium_entry_id(entry)
    }
}

fn module_map_fetch_outcome_for_key_with_owner<O>(
    owner: &O,
    request_key: &module_tree::ModuleMapKey,
) -> std::result::Result<module_tree::ModuleFetchOutcome, ModuleLoadError>
where
    O: NativeModuleTreeDocumentOwnerAdapter,
{
    let local_key = local_module_key(request_key)?;
    let entry_id = owner.module_entry_id(&local_key).ok_or_else(|| {
        ModuleLoadError::new(
            ModuleLoadStage::Fetch,
            format!(
                "module map fanout for `{}` had no module map entry",
                local_key.url()
            ),
        )
    })?;
    let outcome = match owner.module_entry_state(entry_id) {
        ModuleMapEntryState::Fetched => {
            let source = owner.module_source(entry_id).ok_or_else(|| {
                ModuleLoadError::new(
                    ModuleLoadStage::Fetch,
                    "fetched module map entry did not retain source",
                )
            })?;
            module_tree::ModuleFetchOutcome::Fetched(Box::new(
                chromium_fetched_source_from_owner_entry(
                    owner,
                    entry_id,
                    request_key.clone(),
                    source,
                ),
            ))
        }
        ModuleMapEntryState::Compiled
        | ModuleMapEntryState::Instantiated
        | ModuleMapEntryState::Evaluating
        | ModuleMapEntryState::Evaluated => module_tree::ModuleFetchOutcome::Ready(Box::new(
            chromium_ready_module_from_owner_entry(owner, entry_id),
        )),
        ModuleMapEntryState::Failed => {
            let error = owner
                .module_failure(entry_id)
                .map(chromium_error)
                .unwrap_or_else(|| {
                    module_tree::ModuleLoadError::new(
                        module_tree::ModuleLoadStage::Fetch,
                        "module previously failed to load",
                    )
                });
            module_tree::ModuleFetchOutcome::Failed(error)
        }
        ModuleMapEntryState::Fetching => {
            return Err(ModuleLoadError::new(
                ModuleLoadStage::Fetch,
                format!(
                    "module map fanout for `{}` fired while entry was still fetching",
                    local_key.url()
                ),
            ));
        }
    };
    Ok(outcome)
}

fn native_tree_fetch_request_from_chromium(
    request: module_tree::ModuleFetchRequest,
) -> std::result::Result<NativeModuleTreeFetchRequest, ModuleLoadError> {
    let key = local_module_key(&request.key)?;
    let dependency = native_dependency_request_from_chromium(&request)?;
    Ok(NativeModuleTreeFetchRequest::new(request, key, dependency))
}

fn native_fetch_request_from_tree_fetch(
    request: &NativeModuleTreeFetchRequest,
) -> std::result::Result<NativeModuleGraphFetchRequest, ModuleLoadError> {
    let raw = request.request();
    Ok(NativeModuleGraphFetchRequest::new(
        raw.source_url.clone(),
        raw.initiator_url.clone(),
        local_fetch_metadata(&raw.fetch_metadata),
        local_module_kind(raw.kind),
    ))
}

fn native_dependency_request_from_chromium(
    request: &module_tree::ModuleFetchRequest,
) -> std::result::Result<Option<NativeModuleGraphDependencyRequest>, ModuleLoadError> {
    let Some(parent) = request.parent.as_ref() else {
        return Ok(None);
    };
    let specifier = request.specifier.clone().ok_or_else(|| {
        ModuleLoadError::new(
            ModuleLoadStage::Fetch,
            "dependent module fetch request was missing its original specifier",
        )
    })?;
    Ok(Some(NativeModuleGraphDependencyRequest::new(
        local_module_key(&parent.key)?,
        local_entry_id(parent.entry),
        specifier,
        local_import_phase(request.phase),
    )))
}

fn chromium_entry_id(entry: ModuleEntryId) -> module_tree::ModuleEntryId {
    module_tree::ModuleEntryId(entry.raw())
}

fn local_entry_id(entry: module_tree::ModuleEntryId) -> ModuleEntryId {
    ModuleEntryId::from_raw(entry.0)
}

fn chromium_source(source: ModuleSource) -> module_tree::ModuleSource {
    match source {
        ModuleSource::Text(source) => module_tree::ModuleSource::Text(source),
        ModuleSource::Binary(bytes) => module_tree::ModuleSource::Binary(bytes),
    }
}

fn chromium_fetched_source_from_owner_entry<O>(
    owner: &O,
    entry_id: ModuleEntryId,
    request_key: module_tree::ModuleMapKey,
    source: ModuleSource,
) -> module_tree::FetchedModuleSource
where
    O: NativeModuleTreeDocumentOwnerAdapter,
{
    let effective_key = owner.module_entry_key(entry_id);
    let source_url = effective_key.url().clone();
    let effective_fetch_metadata = owner.module_effective_fetch_metadata(entry_id);
    module_tree::FetchedModuleSource::new(
        request_key,
        chromium_module_key(&effective_key),
        source_url.clone(),
        source_url,
        chromium_source(source),
        chromium_fetch_metadata(&effective_fetch_metadata),
    )
}

fn chromium_ready_module_from_owner_entry<O>(
    owner: &O,
    entry_id: ModuleEntryId,
) -> module_tree::ReadyModule
where
    O: NativeModuleTreeDocumentOwnerAdapter,
{
    let effective_key = owner.module_entry_key(entry_id);
    let source_url = effective_key.url().clone();
    let effective_fetch_metadata = owner.module_effective_fetch_metadata(entry_id);
    module_tree::ReadyModule::new(
        chromium_entry_id(entry_id),
        chromium_module_key(&effective_key),
        source_url.clone(),
        chromium_fetch_metadata(&effective_fetch_metadata),
    )
}

fn chromium_fetched_source_for_request(
    fetched_source: ModuleGraphFetchedSource,
    request: &NativeModuleGraphFetchRequest,
) -> std::result::Result<module_tree::FetchedModuleSource, ModuleLoadError> {
    let request_key = request.pending_fetch_key().ok_or_else(|| {
        ModuleLoadError::new(
            ModuleLoadStage::Fetch,
            "module graph fetched source was missing its pending module map key",
        )
    })?;
    let effective_key = request
        .effective_key_for_fetched_source(&fetched_source)
        .ok_or_else(|| {
            ModuleLoadError::new(
                ModuleLoadStage::Fetch,
                "module graph fetched source was missing its effective module map key",
            )
        })?;
    let final_url = fetched_source.final_url().clone();
    let effective_fetch_metadata =
        request.effective_fetch_metadata_for_fetched_source(&fetched_source);
    Ok(module_tree::FetchedModuleSource::new(
        chromium_module_key(request_key),
        chromium_module_key(&effective_key),
        final_url.clone(),
        final_url,
        chromium_source(fetched_source.into_source()),
        chromium_fetch_metadata(&effective_fetch_metadata),
    ))
}

fn local_source(source: module_tree::ModuleSource) -> ModuleSource {
    match source {
        module_tree::ModuleSource::Text(source) => ModuleSource::Text(source),
        module_tree::ModuleSource::Binary(bytes) => ModuleSource::Binary(bytes),
    }
}

fn native_module_map_single_module_client_from_request(
    request: &module_tree::ModuleFetchRequest,
) -> super::NativeModuleMapSingleModuleClient {
    match request.requester {
        module_tree::ModuleFetchRequester::ParserPendingScript
        | module_tree::ModuleFetchRequester::RuntimeModuleScript => {
            super::NativeModuleMapSingleModuleClient::module_script(request.client, request.phase)
        }
        module_tree::ModuleFetchRequester::DynamicImport => {
            super::NativeModuleMapSingleModuleClient::dynamic_import(request.client, request.phase)
        }
        module_tree::ModuleFetchRequester::ModulePreload => {
            unreachable!("modulepreload cannot be represented as a single-module tree client")
        }
    }
}

impl<O: NativeModuleTreeDocumentOwnerAdapter> RendererModuleScriptTreeHost<O> {
    fn register_joined_module_fetch_client(
        &mut self,
        key: ModuleMapKey,
        request: &module_tree::ModuleFetchRequest,
    ) {
        match request.requester {
            module_tree::ModuleFetchRequester::ParserPendingScript
            | module_tree::ModuleFetchRequester::RuntimeModuleScript
            | module_tree::ModuleFetchRequester::DynamicImport => {
                let client = native_module_map_single_module_client_from_request(request);
                self.owner.suspend_module_fetch_waiter(key, client);
            }
            module_tree::ModuleFetchRequester::ModulePreload => {
                self.owner.record_runtime_warning(format_args!(
                    "module script tree produced a modulepreload joined fetch client for `{}`",
                    key.url()
                ));
            }
        }
    }
}

fn chromium_request_record(request: &ModuleRequestRecord) -> module_tree::ModuleRequestRecord {
    module_tree::ModuleRequestRecord {
        specifier: request.specifier().to_owned(),
        attributes: chromium_attributes(request.attributes()),
        phase: chromium_import_phase(request.phase()),
        position: module_tree::TextPosition::default(),
    }
}

fn chromium_module_key(key: &ModuleMapKey) -> module_tree::ModuleMapKey {
    module_tree::ModuleMapKey::new(
        key.url().clone(),
        chromium_module_kind(key.kind()),
        chromium_attributes(key.attributes()),
    )
}

fn local_module_key(
    key: &module_tree::ModuleMapKey,
) -> std::result::Result<ModuleMapKey, ModuleLoadError> {
    let attributes = local_attributes(&key.attributes);
    match key.kind {
        module_tree::ModuleKind::JavaScript => Ok(ModuleMapKey::java_script_with_attributes(
            key.url.clone(),
            attributes,
        )),
        module_tree::ModuleKind::Json => Ok(ModuleMapKey::json_with_attributes(
            key.url.clone(),
            attributes,
        )),
        module_tree::ModuleKind::Css => Ok(ModuleMapKey::css_with_attributes(
            key.url.clone(),
            attributes,
        )),
        module_tree::ModuleKind::WebAssembly => Ok(ModuleMapKey::webassembly(key.url.clone())),
    }
}

fn local_attributes(attributes: &module_tree::ModuleAttributesKey) -> ModuleAttributesKey {
    ModuleAttributesKey::from_pairs(attributes.attributes.clone())
}

fn local_module_kind(kind: module_tree::ModuleKind) -> ModuleKind {
    match kind {
        module_tree::ModuleKind::JavaScript => ModuleKind::JavaScript,
        module_tree::ModuleKind::Json => ModuleKind::Json,
        module_tree::ModuleKind::Css => ModuleKind::Css,
        module_tree::ModuleKind::WebAssembly => ModuleKind::WebAssembly,
    }
}

fn local_graph(graph: module_tree::ModuleGraphHandle) -> ModuleGraphHandle {
    ModuleGraphHandle {
        root_entry: local_entry_id(graph.root_entry),
        entries: graph.entries.into_iter().map(local_entry_id).collect(),
    }
}

fn chromium_error(error: ModuleLoadError) -> module_tree::ModuleLoadError {
    let mut converted =
        module_tree::ModuleLoadError::new(chromium_load_stage(error.stage()), error.message());
    if let Some(constructor) = error.error_constructor() {
        let constructor = match constructor {
            ScriptErrorConstructorKind::Error => module_tree::ModuleErrorConstructorKind::Error,
            ScriptErrorConstructorKind::SyntaxError => {
                module_tree::ModuleErrorConstructorKind::SyntaxError
            }
            ScriptErrorConstructorKind::TypeError => {
                module_tree::ModuleErrorConstructorKind::TypeError
            }
            ScriptErrorConstructorKind::WebAssemblyCompileError => {
                module_tree::ModuleErrorConstructorKind::WebAssemblyCompileError
            }
            ScriptErrorConstructorKind::WebAssemblyLinkError => {
                module_tree::ModuleErrorConstructorKind::WebAssemblyLinkError
            }
        };
        converted = converted.with_error_constructor(constructor);
    }
    converted
}

fn local_error(error: module_tree::ModuleLoadError) -> ModuleLoadError {
    let mut converted = ModuleLoadError::new(local_load_stage(error.stage), error.message);
    if let Some(constructor) = error.error_constructor {
        converted = converted.with_error_constructor(local_error_constructor(constructor));
    }
    converted
}

fn local_error_constructor(
    constructor: module_tree::ModuleErrorConstructorKind,
) -> ScriptErrorConstructorKind {
    match constructor {
        module_tree::ModuleErrorConstructorKind::Error => ScriptErrorConstructorKind::Error,
        module_tree::ModuleErrorConstructorKind::SyntaxError => {
            ScriptErrorConstructorKind::SyntaxError
        }
        module_tree::ModuleErrorConstructorKind::TypeError => ScriptErrorConstructorKind::TypeError,
        module_tree::ModuleErrorConstructorKind::WebAssemblyCompileError => {
            ScriptErrorConstructorKind::WebAssemblyCompileError
        }
        module_tree::ModuleErrorConstructorKind::WebAssemblyLinkError => {
            ScriptErrorConstructorKind::WebAssemblyLinkError
        }
    }
}

fn chromium_abort_error(reason: module_tree::ModuleTreeAbortReason) -> ModuleLoadError {
    ModuleLoadError::new(
        ModuleLoadStage::Fetch,
        format!("module script tree aborted: {reason:?}"),
    )
}

fn chromium_load_stage(stage: ModuleLoadStage) -> module_tree::ModuleLoadStage {
    match stage {
        ModuleLoadStage::Fetch => module_tree::ModuleLoadStage::Fetch,
        ModuleLoadStage::Compile => module_tree::ModuleLoadStage::Compile,
        ModuleLoadStage::Resolve => module_tree::ModuleLoadStage::Resolve,
        ModuleLoadStage::Instantiate => module_tree::ModuleLoadStage::Instantiate,
        ModuleLoadStage::Evaluate => module_tree::ModuleLoadStage::Evaluate,
    }
}

fn local_load_stage(stage: module_tree::ModuleLoadStage) -> ModuleLoadStage {
    match stage {
        module_tree::ModuleLoadStage::Resolve => ModuleLoadStage::Resolve,
        module_tree::ModuleLoadStage::Fetch => ModuleLoadStage::Fetch,
        module_tree::ModuleLoadStage::Instantiate => ModuleLoadStage::Instantiate,
        module_tree::ModuleLoadStage::Evaluate => ModuleLoadStage::Evaluate,
        module_tree::ModuleLoadStage::Decode
        | module_tree::ModuleLoadStage::TypeCheck
        | module_tree::ModuleLoadStage::Compile
        | module_tree::ModuleLoadStage::DependencyDiscovery
        | module_tree::ModuleLoadStage::Link
        | module_tree::ModuleLoadStage::Abort => ModuleLoadStage::Compile,
    }
}

fn local_fetch_metadata(metadata: &module_tree::ModuleFetchMetadata) -> ModuleFetchMetadata {
    ModuleFetchMetadata {
        credentials_mode: match metadata.credentials_mode {
            module_tree::CredentialsMode::Omit => RequestCredentialsMode::Omit,
            module_tree::CredentialsMode::SameOrigin => RequestCredentialsMode::SameOrigin,
            module_tree::CredentialsMode::Include => RequestCredentialsMode::Include,
        },
        request_metadata: ScriptFetchRequestMetadata {
            cross_origin: None,
            referrer_policy: local_referrer_policy(metadata.referrer_policy).map(str::to_owned),
            document_referrer_policy: None,
            charset: metadata.charset.clone(),
            integrity: metadata.integrity.clone(),
            nonce: metadata.nonce.clone(),
            fetch_priority: match metadata.fetch_priority {
                module_tree::FetchPriorityHint::Auto => Some(moli_fetch::FetchPriorityHint::Auto),
                module_tree::FetchPriorityHint::Low => Some(moli_fetch::FetchPriorityHint::Low),
                module_tree::FetchPriorityHint::High => Some(moli_fetch::FetchPriorityHint::High),
            },
            scheduler_priority: metadata.scheduler_priority.map(|priority| match priority {
                module_tree::ScriptFetchSchedulerPriority::VeryHigh => {
                    ScriptFetchSchedulerPriority::VeryHigh
                }
                module_tree::ScriptFetchSchedulerPriority::High => {
                    ScriptFetchSchedulerPriority::High
                }
                module_tree::ScriptFetchSchedulerPriority::Normal => {
                    ScriptFetchSchedulerPriority::Auto
                }
                module_tree::ScriptFetchSchedulerPriority::Low => ScriptFetchSchedulerPriority::Low,
                module_tree::ScriptFetchSchedulerPriority::Background => {
                    ScriptFetchSchedulerPriority::Low
                }
            }),
        },
        parser_inserted: metadata.parser_inserted,
    }
}

fn local_referrer_policy(policy: module_tree::ReferrerPolicy) -> Option<&'static str> {
    match policy {
        module_tree::ReferrerPolicy::EmptyString => None,
        module_tree::ReferrerPolicy::NoReferrer => Some("no-referrer"),
        module_tree::ReferrerPolicy::NoReferrerWhenDowngrade => Some("no-referrer-when-downgrade"),
        module_tree::ReferrerPolicy::Origin => Some("origin"),
        module_tree::ReferrerPolicy::OriginWhenCrossOrigin => Some("origin-when-cross-origin"),
        module_tree::ReferrerPolicy::SameOrigin => Some("same-origin"),
        module_tree::ReferrerPolicy::StrictOrigin => Some("strict-origin"),
        module_tree::ReferrerPolicy::StrictOriginWhenCrossOrigin => {
            Some("strict-origin-when-cross-origin")
        }
        module_tree::ReferrerPolicy::UnsafeUrl => Some("unsafe-url"),
    }
}

fn module_key_for_root(
    root: &ModuleRootInput,
) -> std::result::Result<ModuleMapKey, ModuleLoadError> {
    let key = module_key_for_attributes(&root.source_url, &root.attributes).map_err(|message| {
        ModuleLoadError::new(
            ModuleLoadStage::Resolve,
            format!("{message} for module `{}`", root.source_url),
        )
        .with_error_constructor(ScriptErrorConstructorKind::TypeError)
    })?;
    validate_source_phase_key(root.phase, &key, "module", root.source_url.as_str())?;
    Ok(key)
}

fn module_key_for_attributes(
    url: &Url,
    attributes: &ModuleAttributesKey,
) -> std::result::Result<ModuleMapKey, String> {
    ModuleMapKey::from_url_and_attributes(url, attributes)
}

fn validate_source_phase_key(
    phase: ModuleImportPhase,
    key: &ModuleMapKey,
    label: &str,
    subject: &str,
) -> std::result::Result<(), ModuleLoadError> {
    if phase == ModuleImportPhase::Source && key.kind() != ModuleKind::WebAssembly {
        return Err(ModuleLoadError::new(
            ModuleLoadStage::Resolve,
            format!("source-phase {label} `{subject}` does not resolve to a WebAssembly module"),
        )
        .with_error_constructor(ScriptErrorConstructorKind::SyntaxError));
    }
    Ok(())
}

pub(crate) async fn execute_native_module_script_source(
    vm: &mut ScriptVm,
    source: ModuleSource,
    base_url: &Url,
    initiator_url: &Url,
    fetch_metadata: &ScriptFetchMetadata,
    source_is_external: bool,
    completion_owner: ModuleScriptCompletionOwner,
) -> std::result::Result<ModuleScriptExecutionOutcome, ModuleLoadError> {
    let job = module_script_graph_job_for_owner(
        vm,
        source,
        base_url,
        initiator_url,
        fetch_metadata,
        source_is_external,
        completion_owner,
    )?;
    execute_native_module_script_graph_job(vm, job)
}

pub(crate) async fn execute_external_native_module_script_graph(
    vm: &mut ScriptVm,
    base_url: &Url,
    initiator_url: &Url,
    fetch_metadata: &ScriptFetchMetadata,
    completion_owner: ModuleScriptCompletionOwner,
) -> std::result::Result<ModuleScriptExecutionOutcome, ModuleLoadError> {
    let job = external_module_script_graph_job(
        vm,
        base_url,
        initiator_url,
        fetch_metadata,
        completion_owner,
    );
    execute_native_module_script_graph_job(vm, job)
}

fn execute_native_module_script_graph_job(
    vm: &mut ScriptVm,
    job: NativeModuleGraphJob,
) -> std::result::Result<ModuleScriptExecutionOutcome, ModuleLoadError> {
    let advance = advance_module_script_graph(vm, job)?;
    match advance {
        ModuleScriptGraphAdvance::NeedFetches(batch) => {
            Ok(ModuleScriptExecutionOutcome::SuspendedModuleFetches(batch))
        }
        ModuleScriptGraphAdvance::Complete(graph) => {
            Ok(ModuleScriptExecutionOutcome::CompletedModuleGraph(graph))
        }
    }
}

fn module_script_root_input_with_source_override(
    vm: &mut ScriptVm,
    source: ModuleSource,
    base_url: &Url,
    initiator_url: &Url,
    fetch_metadata: &ScriptFetchMetadata,
    source_is_external: bool,
    completion_owner: ModuleScriptCompletionOwner,
) -> ModuleRootInput {
    let source_url = if source_is_external {
        base_url.clone()
    } else {
        next_inline_module_url(vm, base_url)
    };
    ModuleRootInput {
        source_url,
        base_url: base_url.clone(),
        initiator_url: initiator_url.clone(),
        attributes: ModuleAttributesKey::empty(),
        phase: ModuleImportPhase::Evaluation,
        source_override: Some(source),
        fetch_metadata: ModuleFetchMetadata::from_loaded_module_script_fetch_metadata(
            fetch_metadata,
        ),
        parser_owned: completion_owner == ModuleScriptCompletionOwner::Parser,
    }
}

fn external_module_script_root_input(
    base_url: &Url,
    initiator_url: &Url,
    fetch_metadata: &ScriptFetchMetadata,
    completion_owner: ModuleScriptCompletionOwner,
) -> ModuleRootInput {
    ModuleRootInput {
        source_url: base_url.clone(),
        base_url: base_url.clone(),
        initiator_url: initiator_url.clone(),
        attributes: ModuleAttributesKey::empty(),
        phase: ModuleImportPhase::Evaluation,
        source_override: None,
        fetch_metadata: ModuleFetchMetadata::from_top_level_script_fetch_metadata(fetch_metadata),
        parser_owned: completion_owner == ModuleScriptCompletionOwner::Parser,
    }
}

fn external_chromium_tree_root_input(
    root: &ModuleRootInput,
) -> std::result::Result<Option<moli_module_script_tree::ModuleRootInput>, ModuleLoadError> {
    if root.source_override.is_some() {
        return Ok(None);
    }
    let key = module_key_for_root(root)?;
    Ok(Some(moli_module_script_tree::ModuleRootInput::External(
        moli_module_script_tree::ModuleExternalRootInput {
            source_url: root.source_url.clone(),
            base_url: root.base_url.clone(),
            initiator_url: root.initiator_url.clone(),
            attributes: chromium_attributes(&root.attributes),
            phase: chromium_import_phase(root.phase),
            kind_hint: Some(chromium_module_kind(key.kind())),
            fetch_metadata: chromium_fetch_metadata(&root.fetch_metadata),
            referrer: moli_module_script_tree::ModuleReferrer::client(),
            position: moli_module_script_tree::TextPosition::default(),
        },
    )))
}

fn chromium_attributes(
    attributes: &ModuleAttributesKey,
) -> moli_module_script_tree::ModuleAttributesKey {
    moli_module_script_tree::ModuleAttributesKey::from_pairs(attributes.pairs().to_vec())
}

fn chromium_module_kind(kind: ModuleKind) -> moli_module_script_tree::ModuleKind {
    match kind {
        ModuleKind::JavaScript => moli_module_script_tree::ModuleKind::JavaScript,
        ModuleKind::Json => moli_module_script_tree::ModuleKind::Json,
        ModuleKind::Css => moli_module_script_tree::ModuleKind::Css,
        ModuleKind::ModulePreloadText => moli_module_script_tree::ModuleKind::JavaScript,
        ModuleKind::WebAssembly => moli_module_script_tree::ModuleKind::WebAssembly,
    }
}

fn chromium_import_phase(phase: ModuleImportPhase) -> moli_module_script_tree::ModuleImportPhase {
    match phase {
        ModuleImportPhase::Evaluation => moli_module_script_tree::ModuleImportPhase::Evaluation,
        ModuleImportPhase::Source => moli_module_script_tree::ModuleImportPhase::Source,
    }
}

fn local_import_phase(phase: moli_module_script_tree::ModuleImportPhase) -> ModuleImportPhase {
    match phase {
        moli_module_script_tree::ModuleImportPhase::Evaluation => ModuleImportPhase::Evaluation,
        moli_module_script_tree::ModuleImportPhase::Source => ModuleImportPhase::Source,
    }
}

fn chromium_fetch_metadata(
    metadata: &ModuleFetchMetadata,
) -> moli_module_script_tree::ModuleFetchMetadata {
    moli_module_script_tree::ModuleFetchMetadata {
        credentials_mode: match metadata.credentials_mode {
            RequestCredentialsMode::Omit => moli_module_script_tree::CredentialsMode::Omit,
            RequestCredentialsMode::SameOrigin => {
                moli_module_script_tree::CredentialsMode::SameOrigin
            }
            RequestCredentialsMode::Include => moli_module_script_tree::CredentialsMode::Include,
        },
        referrer_policy: chromium_referrer_policy(
            metadata.request_metadata.referrer_policy.as_deref(),
        ),
        integrity: metadata.request_metadata.integrity.clone(),
        nonce: metadata.request_metadata.nonce.clone(),
        charset: metadata.request_metadata.charset.clone(),
        fetch_priority: match metadata.request_metadata.fetch_priority {
            Some(moli_fetch::FetchPriorityHint::Low) => {
                moli_module_script_tree::FetchPriorityHint::Low
            }
            Some(moli_fetch::FetchPriorityHint::High) => {
                moli_module_script_tree::FetchPriorityHint::High
            }
            Some(moli_fetch::FetchPriorityHint::Auto) | None => {
                moli_module_script_tree::FetchPriorityHint::Auto
            }
        },
        scheduler_priority: metadata
            .request_metadata
            .scheduler_priority
            .map(|priority| match priority {
                ScriptFetchSchedulerPriority::VeryHigh => {
                    moli_module_script_tree::ScriptFetchSchedulerPriority::VeryHigh
                }
                ScriptFetchSchedulerPriority::High => {
                    moli_module_script_tree::ScriptFetchSchedulerPriority::High
                }
                ScriptFetchSchedulerPriority::Low => {
                    moli_module_script_tree::ScriptFetchSchedulerPriority::Low
                }
                ScriptFetchSchedulerPriority::Auto => {
                    moli_module_script_tree::ScriptFetchSchedulerPriority::Normal
                }
            }),
        request_context: moli_module_script_tree::ModuleRequestContext::Script,
        destination: moli_module_script_tree::ModuleRequestDestination::Script,
        parser_inserted: metadata.parser_inserted,
    }
}

fn chromium_referrer_policy(policy: Option<&str>) -> moli_module_script_tree::ReferrerPolicy {
    match policy {
        Some("no-referrer") => moli_module_script_tree::ReferrerPolicy::NoReferrer,
        Some("no-referrer-when-downgrade") => {
            moli_module_script_tree::ReferrerPolicy::NoReferrerWhenDowngrade
        }
        Some("origin") => moli_module_script_tree::ReferrerPolicy::Origin,
        Some("origin-when-cross-origin") => {
            moli_module_script_tree::ReferrerPolicy::OriginWhenCrossOrigin
        }
        Some("same-origin") => moli_module_script_tree::ReferrerPolicy::SameOrigin,
        Some("strict-origin") => moli_module_script_tree::ReferrerPolicy::StrictOrigin,
        Some("strict-origin-when-cross-origin") => {
            moli_module_script_tree::ReferrerPolicy::StrictOriginWhenCrossOrigin
        }
        Some("unsafe-url") => moli_module_script_tree::ReferrerPolicy::UnsafeUrl,
        _ => moli_module_script_tree::ReferrerPolicy::EmptyString,
    }
}

#[cfg(test)]
fn module_script_inline_tree_job(
    vm: &mut ScriptVm,
    root: ModuleRootInput,
) -> std::result::Result<NativeModuleGraphJob, ModuleLoadError> {
    module_script_inline_tree_job_for_owner(vm, root, true, ModuleScriptCompletionOwner::Parser)
}

fn module_script_inline_tree_job_for_owner(
    vm: &mut ScriptVm,
    root: ModuleRootInput,
    source_is_external: bool,
    completion_owner: ModuleScriptCompletionOwner,
) -> std::result::Result<NativeModuleGraphJob, ModuleLoadError> {
    let trace_label = match completion_owner {
        ModuleScriptCompletionOwner::Parser => "parser_owned_inline",
        ModuleScriptCompletionOwner::Runtime => "runtime_module_script_inline",
    };
    trace_module_graph_job_created(trace_label, &root);
    let key = module_key_for_root(&root)?;
    // This adapter also accepts externally sourced roots whose bytes are already
    // loaded. Only those roots have a fetch URL to check. Actual inline roots
    // passed source-text CSP before graph creation; their synthetic identity URL
    // is not a request. Dependency fetches keep their own URL policy checks.
    if source_is_external {
        vm.dispatch_module_fetch_csp_report_only_violation_for_owner(&key, &root.fetch_metadata);
        if let Some(error) = vm.csp_blocked_module_fetch_error_for_owner(&key, &root.fetch_metadata)
        {
            vm.document_runtime
                .mark_native_module_failed(key.clone(), error.clone());
            return Err(error);
        }
    }
    if let Some(entry) = reusable_inline_module_entry(vm, &key)? {
        return Ok(native_module_graph_job_for_inline_entry(
            &root,
            &key,
            entry,
            completion_owner,
        ));
    }
    let source = root.source_override.clone().ok_or_else(|| {
        ModuleLoadError::new(
            ModuleLoadStage::Fetch,
            format!("module `{}` has no source override", root.source_url),
        )
    })?;
    vm.document_runtime.insert_native_module_source_for_request(
        key.clone(),
        key.clone(),
        source.clone(),
        root.fetch_metadata.clone(),
    );
    let (record, identity) = match vm.compile_native_module_record(
        key.clone(),
        &source,
        &root.base_url,
        &root.fetch_metadata,
    ) {
        Ok(result) => result,
        Err(error) => {
            vm.document_runtime
                .mark_native_module_failed(key.clone(), error.clone());
            return Err(error);
        }
    };
    let entry = vm
        .document_runtime
        .insert_native_compiled_module_record_with_metadata(
            key.clone(),
            record,
            identity,
            root.fetch_metadata.clone(),
        );
    Ok(native_module_graph_job_for_inline_entry(
        &root,
        &key,
        entry,
        completion_owner,
    ))
}

fn reusable_inline_module_entry(
    vm: &ScriptVm,
    key: &ModuleMapKey,
) -> std::result::Result<Option<ModuleEntryId>, ModuleLoadError> {
    let Some(entry) = vm.document_runtime.native_module_entry_id(key) else {
        return Ok(None);
    };
    match vm.document_runtime.native_module_entry_state(entry) {
        ModuleMapEntryState::Compiled
        | ModuleMapEntryState::Instantiated
        | ModuleMapEntryState::Evaluating
        | ModuleMapEntryState::Evaluated => Ok(Some(entry)),
        ModuleMapEntryState::Failed => Err(vm
            .document_runtime
            .native_module_failure(entry)
            .unwrap_or_else(|| {
                ModuleLoadError::new(
                    ModuleLoadStage::Fetch,
                    format!("module `{}` previously failed to load", key.url()),
                )
            })),
        ModuleMapEntryState::Fetching | ModuleMapEntryState::Fetched => Ok(None),
    }
}

fn native_module_graph_job_for_inline_entry(
    root: &ModuleRootInput,
    key: &ModuleMapKey,
    entry: ModuleEntryId,
    completion_owner: ModuleScriptCompletionOwner,
) -> NativeModuleGraphJob {
    let chromium_root = moli_module_script_tree::ModuleRootInput::Inline(
        moli_module_script_tree::ModuleInlineRootInput {
            root_key: chromium_module_key(key),
            root_entry: chromium_entry_id(entry),
            source_url: root.source_url.clone(),
            base_url: root.base_url.clone(),
            phase: chromium_import_phase(root.phase),
            fetch_metadata: chromium_fetch_metadata(&root.fetch_metadata),
            referrer: moli_module_script_tree::ModuleReferrer::client(),
            position: moli_module_script_tree::TextPosition::default(),
        },
    );
    let chromium_tree = match completion_owner {
        ModuleScriptCompletionOwner::Parser => tree_adapter::parser_owned_tree_job(chromium_root),
        ModuleScriptCompletionOwner::Runtime => {
            tree_adapter::runtime_module_script_tree_job(chromium_root)
        }
    };
    let kind = match completion_owner {
        ModuleScriptCompletionOwner::Parser => NativeModuleGraphJobKind::ParserOwned,
        ModuleScriptCompletionOwner::Runtime => NativeModuleGraphJobKind::RuntimeModuleScript,
    };
    NativeModuleGraphJob {
        tree_job: Some(NativeModuleTreeJob::new(chromium_tree)),
        kind,
    }
}

#[cfg(test)]
fn module_script_graph_job(
    vm: &mut ScriptVm,
    source: ModuleSource,
    base_url: &Url,
    initiator_url: &Url,
    fetch_metadata: &ScriptFetchMetadata,
    source_is_external: bool,
) -> std::result::Result<NativeModuleGraphJob, ModuleLoadError> {
    module_script_graph_job_for_owner(
        vm,
        source,
        base_url,
        initiator_url,
        fetch_metadata,
        source_is_external,
        ModuleScriptCompletionOwner::Parser,
    )
}

fn module_script_graph_job_for_owner(
    vm: &mut ScriptVm,
    source: ModuleSource,
    base_url: &Url,
    initiator_url: &Url,
    fetch_metadata: &ScriptFetchMetadata,
    source_is_external: bool,
    completion_owner: ModuleScriptCompletionOwner,
) -> std::result::Result<NativeModuleGraphJob, ModuleLoadError> {
    let root = module_script_root_input_with_source_override(
        vm,
        source,
        base_url,
        initiator_url,
        fetch_metadata,
        source_is_external,
        completion_owner,
    );
    module_script_inline_tree_job_for_owner(vm, root, source_is_external, completion_owner)
}

pub(crate) fn parser_owned_loaded_module_script_graph_job(
    vm: &mut ScriptVm,
    source: ModuleSource,
    base_url: &Url,
    initiator_url: &Url,
    fetch_metadata: &ScriptFetchMetadata,
    source_is_external: bool,
) -> std::result::Result<NativeModuleGraphJob, ModuleLoadError> {
    module_script_graph_job_for_owner(
        vm,
        source,
        base_url,
        initiator_url,
        fetch_metadata,
        source_is_external,
        ModuleScriptCompletionOwner::Parser,
    )
}

pub(crate) fn runtime_owned_loaded_module_script_graph_job(
    vm: &mut ScriptVm,
    source: ModuleSource,
    base_url: &Url,
    initiator_url: &Url,
    fetch_metadata: &ScriptFetchMetadata,
    source_is_external: bool,
) -> std::result::Result<NativeModuleGraphJob, ModuleLoadError> {
    module_script_graph_job_for_owner(
        vm,
        source,
        base_url,
        initiator_url,
        fetch_metadata,
        source_is_external,
        ModuleScriptCompletionOwner::Runtime,
    )
}

fn external_module_script_graph_job(
    vm: &mut ScriptVm,
    base_url: &Url,
    initiator_url: &Url,
    fetch_metadata: &ScriptFetchMetadata,
    completion_owner: ModuleScriptCompletionOwner,
) -> NativeModuleGraphJob {
    let integrity = super::resolve_module_integrity(vm, base_url);
    let root = external_module_script_root_input(
        base_url,
        initiator_url,
        fetch_metadata,
        completion_owner,
    )
    .with_import_map_integrity_if_absent(integrity);
    match completion_owner {
        ModuleScriptCompletionOwner::Parser => NativeModuleGraphJob::parser_owned(root),
        ModuleScriptCompletionOwner::Runtime => NativeModuleGraphJob::runtime_module_script(root),
    }
}

pub(crate) fn parser_owned_external_module_script_graph_job(
    vm: &mut ScriptVm,
    base_url: &Url,
    initiator_url: &Url,
    fetch_metadata: &ScriptFetchMetadata,
) -> NativeModuleGraphJob {
    external_module_script_graph_job(
        vm,
        base_url,
        initiator_url,
        fetch_metadata,
        ModuleScriptCompletionOwner::Parser,
    )
}

pub(crate) fn runtime_owned_external_module_script_graph_job(
    vm: &mut ScriptVm,
    base_url: &Url,
    initiator_url: &Url,
    fetch_metadata: &ScriptFetchMetadata,
) -> NativeModuleGraphJob {
    external_module_script_graph_job(
        vm,
        base_url,
        initiator_url,
        fetch_metadata,
        ModuleScriptCompletionOwner::Runtime,
    )
}

pub(crate) fn advance_module_script_graph(
    vm: &mut ScriptVm,
    mut job: NativeModuleGraphJob,
) -> std::result::Result<ModuleScriptGraphAdvance, ModuleLoadError> {
    let advance = job.advance_module_script_owner_lane(vm)?;
    Ok(module_script_graph_advance_from_native(job, advance))
}

pub(crate) fn module_script_graph_advance_from_native(
    job: NativeModuleGraphJob,
    advance: NativeModuleGraphJobAdvance,
) -> ModuleScriptGraphAdvance {
    match advance {
        NativeModuleGraphJobAdvance::NeedFetches(requests) => {
            ModuleScriptGraphAdvance::NeedFetches(Box::new(ModuleScriptGraphFetchBatch::new(
                job,
                requests
                    .into_iter()
                    .map(|request| ModuleScriptGraphFetchContinuation { request })
                    .collect(),
            )))
        }
        NativeModuleGraphJobAdvance::WaitingForFetches => ModuleScriptGraphAdvance::NeedFetches(
            Box::new(ModuleScriptGraphFetchBatch::new(job, Vec::new())),
        ),
        NativeModuleGraphJobAdvance::Complete(graph) => ModuleScriptGraphAdvance::Complete(graph),
    }
}

pub(crate) fn next_inline_module_url(vm: &mut ScriptVm, base_url: &Url) -> Url {
    let mut inline_url = base_url.clone();
    inline_url.set_fragment(Some(&format!(
        "__moli_inline_module_{}",
        next_inline_module_eval_id(vm)
    )));
    inline_url
}

fn dynamic_import_root_input<O>(
    owner: &mut O,
    request: &PendingDynamicModuleImport,
) -> std::result::Result<ModuleRootInput, ModuleLoadError>
where
    O: NativeModuleTreeDocumentOwnerAdapter,
{
    let source_url = match request.resolved_url() {
        Some(url) => url.clone(),
        None => owner
            .resolve_module_specifier(request.specifier(), request.base_url())
            .map_err(|error| {
                ModuleLoadError::new(
                    ModuleLoadStage::Resolve,
                    format!(
                        "failed to resolve dynamic import `{}` from `{}`: {error}",
                        request.specifier(),
                        request.base_url()
                    ),
                )
            })?,
    };
    let integrity = owner.resolve_module_integrity(&source_url);
    let initiator_url = owner.module_request_initiator_url(request.child_browsing_context_handle());
    Ok(ModuleRootInput {
        source_url: source_url.clone(),
        base_url: source_url,
        initiator_url,
        attributes: request.attributes().clone(),
        phase: request.phase(),
        source_override: None,
        fetch_metadata: ModuleFetchMetadata::from_dynamic_import_referrer_fetch_metadata(
            request.fetch_metadata(),
        )
        .with_import_map_integrity(integrity),
        parser_owned: false,
    })
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::module_runtime::NativeModulepreloadFetchStart;
    use crate::{
        dom::native::{DomHost, NativeDom},
        module_runtime::NativeModuleSingleFetchRequest,
        network::{
            RendererResourceTaskRunner, ResourceRequestClient,
            loads::{ResourceLoadDisposition, ResourceLoadKind, ResourceLoadRegistry},
        },
        script_vm::{ScriptVmDefaultWorldBootstrap, StandaloneScriptVmHarness},
        types::{ModuleGraphFetchCompletion, ModuleGraphFetchOrdering, ModuleGraphFetchRequester},
    };
    use moli_fetch::FetchConfig;
    use tokio::sync::oneshot;

    fn url(raw: &str) -> Url {
        Url::parse(raw).expect("test url should parse")
    }

    fn new_test_vm(url: &str) -> StandaloneScriptVmHarness {
        let _js_runtime = crate::JsRuntime::initialize();
        let page_task_queue = crate::page_task_queue::PageTaskQueueTestHarness::new();
        let post_domcontentloaded_page_task_sender =
            page_task_queue.owner_attached_runtime_page_task_sender_for_test();
        let page_task_front_injection_tx = page_task_queue.parser_boundary_sender();
        ScriptVmDefaultWorldBootstrap::standalone_from_dom_host_for_test(
            DomHost::from_dom(NativeDom::new(url::Url::parse(url).expect("test url"))),
            post_domcontentloaded_page_task_sender,
            page_task_front_injection_tx,
        )
        .expect("script vm bootstrap should succeed")
        .finish()
        .expect("script vm finish should succeed")
    }

    #[test]
    fn synthetic_text_module_compilation_shares_fetched_source_and_releases_map_reference() {
        for (module_type, text) in [
            ("json", r#"{"answer":42}"#),
            ("css", "body { color: red; }"),
        ] {
            let mut vm = new_test_vm("https://app.example.test/page");
            let source_url = url(&format!("https://app.example.test/source.{module_type}"));
            let attributes =
                ModuleAttributesKey::from_pairs(vec![("type".to_owned(), module_type.to_owned())]);
            let key = ModuleMapKey::from_url_and_attributes(&source_url, &attributes).unwrap();
            let text_source: std::sync::Arc<str> = text.into();
            let weak_source = std::sync::Arc::downgrade(&text_source);
            let source = ModuleSource::text(text_source);
            let fetched = module_tree::FetchedModuleSource::new(
                chromium_module_key(&key),
                chromium_module_key(&key),
                source_url.clone(),
                source_url,
                chromium_source(source.clone()),
                module_tree::ModuleFetchMetadata::default(),
            );
            let snapshot = {
                let mut host =
                    RendererModuleScriptTreeHost::new(NativeModuleTreeDocumentOwner::new(&mut vm));
                module_tree::ModuleScriptTreeHost::compile_module_source(
                    &mut host,
                    fetched.clone(),
                    module_tree::ModuleImportPhase::Evaluation,
                )
                .expect("synthetic module should compile")
            };
            let entry = local_entry_id(snapshot.entry);
            assert!(vm.document_runtime.native_compiled_module(entry).is_some());
            assert!(
                vm.document_runtime.native_module_source(entry).is_none(),
                "{module_type}: compiled module map must release its fetched source",
            );
            drop(fetched);
            drop(source);
            assert_eq!(
                weak_source.strong_count(),
                1,
                "{module_type}: only the compiled record should own the original text allocation",
            );
            assert_eq!(weak_source.upgrade().unwrap().as_ref(), text);
            drop(vm);
            assert!(weak_source.upgrade().is_none());
        }
    }

    #[test]
    fn wasm_module_compilation_shares_fetched_bytes_and_preserves_map_source() {
        let bytes = b"\0asm\x01\0\0\0";
        for phase in [
            module_tree::ModuleImportPhase::Evaluation,
            module_tree::ModuleImportPhase::Source,
        ] {
            let mut vm = new_test_vm("https://app.example.test/page");
            let source_url = url("https://app.example.test/source.wasm");
            let key = ModuleMapKey::webassembly(source_url.clone());
            let shared_bytes: std::sync::Arc<[u8]> = bytes.as_slice().into();
            let weak_source = std::sync::Arc::downgrade(&shared_bytes);
            let source = ModuleSource::binary(shared_bytes);
            let source_pointer = source.binary_source().unwrap().as_ptr();
            let fetched = module_tree::FetchedModuleSource::new(
                chromium_module_key(&key),
                chromium_module_key(&key),
                source_url.clone(),
                source_url,
                chromium_source(source.clone()),
                module_tree::ModuleFetchMetadata::default(),
            );
            let snapshot = {
                let mut host =
                    RendererModuleScriptTreeHost::new(NativeModuleTreeDocumentOwner::new(&mut vm));
                module_tree::ModuleScriptTreeHost::compile_module_source(
                    &mut host,
                    fetched.clone(),
                    phase,
                )
                .expect("Wasm module should compile")
            };
            let entry = local_entry_id(snapshot.entry);
            let retained_source = vm.document_runtime.native_module_source(entry).unwrap();
            assert_eq!(retained_source.binary_source(), Some(bytes.as_slice()));
            assert_eq!(
                retained_source.binary_source().unwrap().as_ptr(),
                source_pointer,
                "{phase:?}: compilation must share the original fetched byte allocation",
            );
            drop(retained_source);
            drop(fetched);
            drop(source);
            assert_eq!(
                weak_source.strong_count(),
                1,
                "{phase:?}: the module map should retain the original byte allocation",
            );
            drop(vm);
            assert!(weak_source.upgrade().is_none());
        }
    }

    #[test]
    fn native_json_module_fetch_request_uses_json_destination_metadata() {
        let fetch_request = NativeModuleGraphFetchRequest::new_for_test(
            url("https://app.example.test/data.json"),
            url("https://app.example.test/page"),
            ModuleFetchMetadata::default(),
            ModuleKind::Json,
        )
        .request(&moli_url::WebOrigin::from_url(&url(
            "https://app.example.test/page",
        )))
        .expect("native JSON module request should build");

        assert_eq!(
            fetch_request.browser_request_metadata(),
            Some(BrowserRequestMetadata::JsonModule)
        );
    }

    #[test]
    fn native_css_module_fetch_request_uses_style_destination_metadata() {
        let fetch_request = NativeModuleGraphFetchRequest::new_for_test(
            url("https://app.example.test/sheet.css"),
            url("https://app.example.test/page"),
            ModuleFetchMetadata::default(),
            ModuleKind::Css,
        )
        .request(&moli_url::WebOrigin::from_url(&url(
            "https://app.example.test/page",
        )))
        .expect("native CSS module request should build");

        assert_eq!(
            fetch_request.resource_type,
            RequestResourceType::CssStyleSheet
        );
        assert_eq!(
            fetch_request.browser_request_metadata(),
            Some(BrowserRequestMetadata::StyleModule)
        );
    }

    #[test]
    fn modulepreload_json_single_fetch_uses_json_destination_metadata() {
        let root_url = url("https://app.example.test/data.json");
        let single_fetch = NativeModuleSingleFetchRequest::new(
            root_url.clone(),
            root_url.clone(),
            url("https://app.example.test/page"),
            ModuleMapKey::json_with_attributes(root_url, ModuleAttributesKey::empty()),
            ModuleFetchMetadata::default(),
        );
        let graph_request = single_fetch.fetch_request();
        let fetch_request = graph_request
            .request(&moli_url::WebOrigin::from_url(&url(
                "https://app.example.test/page",
            )))
            .expect("modulepreload JSON fetch request should build");

        assert_eq!(
            fetch_request.browser_request_metadata(),
            Some(BrowserRequestMetadata::JsonModule)
        );
    }

    #[test]
    fn modulepreload_css_single_fetch_uses_style_destination_metadata() {
        let root_url = url("https://app.example.test/sheet.css");
        let single_fetch = NativeModuleSingleFetchRequest::new(
            root_url.clone(),
            root_url.clone(),
            url("https://app.example.test/page"),
            ModuleMapKey::css_with_attributes(root_url, ModuleAttributesKey::empty()),
            ModuleFetchMetadata::default(),
        );
        let graph_request = single_fetch.fetch_request();
        let fetch_request = graph_request
            .request(&moli_url::WebOrigin::from_url(&url(
                "https://app.example.test/page",
            )))
            .expect("modulepreload CSS fetch request should build");

        assert_eq!(
            fetch_request.resource_type,
            RequestResourceType::CssStyleSheet
        );
        assert_eq!(
            fetch_request.browser_request_metadata(),
            Some(BrowserRequestMetadata::StyleModule)
        );
    }

    fn modulepreload_single_fetch_request(root_url: Url) -> NativeModuleSingleFetchRequest {
        modulepreload_single_fetch_request_with_metadata(root_url, ModuleFetchMetadata::default())
    }

    fn modulepreload_single_fetch_request_with_metadata(
        root_url: Url,
        metadata: ModuleFetchMetadata,
    ) -> NativeModuleSingleFetchRequest {
        let module_key = ModuleMapKey::java_script(root_url.clone());
        NativeModuleSingleFetchRequest::new(
            root_url.clone(),
            root_url,
            url("https://app.example.test/page"),
            module_key,
            metadata,
        )
    }

    fn suspend_registered_modulepreload_fetch(
        vm: &mut ScriptVm,
        request: NativeModuleSingleFetchRequest,
    ) -> u64 {
        let start = vm
            .document_runtime
            .fetch_single_native_module_for_modulepreload(request)
            .expect("modulepreload single fetch registration should succeed");
        let NativeModulepreloadFetchStart::Started(request) = start else {
            panic!("new modulepreload single fetch should start network scheduling");
        };
        vm.document_runtime
            .suspend_native_modulepreload_fetch(*request)
    }

    fn wasm_root_input(
        source_url: &str,
        bytes: &[u8],
        phase: ModuleImportPhase,
    ) -> ModuleRootInput {
        root_input(source_url, ModuleSource::binary(bytes.to_vec()), phase)
    }

    fn root_input(
        source_url: &str,
        source: ModuleSource,
        phase: ModuleImportPhase,
    ) -> ModuleRootInput {
        let source_url = url(source_url);
        ModuleRootInput {
            source_url: source_url.clone(),
            base_url: source_url,
            initiator_url: url("https://app.example.test/page"),
            attributes: ModuleAttributesKey::empty(),
            phase,
            source_override: Some(source),
            fetch_metadata: ModuleFetchMetadata::default(),
            parser_owned: true,
        }
    }

    fn expect_single_fetch(
        advance: ModuleScriptGraphAdvance,
        context: &str,
    ) -> Box<ModuleScriptGraphFetchBatch> {
        match advance {
            ModuleScriptGraphAdvance::NeedFetches(fetches) => {
                assert_eq!(
                    fetches.fetches.len(),
                    1,
                    "{context} should request exactly one fetch"
                );
                fetches
            }
            ModuleScriptGraphAdvance::Complete(_) => {
                panic!("{context} should not complete before fetch")
            }
        }
    }

    fn expect_single_joined_wait(
        advance: ModuleScriptGraphAdvance,
        context: &str,
    ) -> NativeModuleGraphJob {
        match advance {
            ModuleScriptGraphAdvance::NeedFetches(fetches) => {
                let (job, fetches) = fetches.into_parts();
                assert!(
                    fetches.is_empty(),
                    "{context} should not request owned fetches while waiting for a joined module map fetch"
                );
                assert_eq!(
                    job.pending_joined_client_count_for_test(),
                    1,
                    "{context} should wait for exactly one joined module map fetch"
                );
                job
            }
            ModuleScriptGraphAdvance::Complete(_) => {
                panic!("{context} should not complete before joined fetch")
            }
        }
    }

    #[test]
    fn parser_external_graph_job_carries_chromium_tree_shadow_state() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let job = parser_owned_external_module_script_graph_job(
            &mut vm,
            &url("https://app.example.test/root.mjs"),
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
        );

        assert!(
            job.has_chromium_tree_for_test(),
            "external parser module roots should create the new module tree job"
        );
    }

    #[test]
    fn source_override_graph_job_uses_inline_chromium_tree_in_production_path() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let root_url = url("https://app.example.test/root.mjs");
        let root_key = ModuleMapKey::java_script(root_url.clone());
        let job = module_script_graph_job(
            &mut vm,
            ModuleSource::text("export const value = 1;".to_owned()),
            &root_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
            true,
        )
        .expect("source override root should compile into inline tree");

        assert!(
            job.has_chromium_tree_for_test(),
            "production source_override roots should use an inline module tree"
        );
        let graph = match advance_module_script_graph(&mut vm, job)
            .expect("source override graph should complete without network fetch")
        {
            ModuleScriptGraphAdvance::Complete(graph) => graph,
            ModuleScriptGraphAdvance::NeedFetches(fetches) => {
                let (_, fetches) = fetches.into_parts();
                panic!(
                    "source override without dependencies should not fetch {} modules",
                    fetches.len()
                )
            }
        };
        let entry = vm
            .document_runtime
            .native_module_entry_id(&root_key)
            .expect("source override root should be in module map");
        assert_eq!(graph.root_entry, entry);
        assert_eq!(
            vm.document_runtime.native_module_entry_state(entry),
            ModuleMapEntryState::Compiled
        );
    }

    #[test]
    fn loaded_external_module_roots_still_enforce_url_csp() {
        for owner in [
            ModuleScriptCompletionOwner::Parser,
            ModuleScriptCompletionOwner::Runtime,
        ] {
            let mut vm = new_test_vm("https://app.example.test/page");
            vm.set_response_content_security_policies(&["script-src 'unsafe-inline'".to_owned()]);
            let root_url = url("https://app.example.test/root.mjs");
            let Err(error) = module_script_graph_job_for_owner(
                &mut vm,
                ModuleSource::text("globalThis.__externalModuleRan = true;".to_owned()),
                &root_url,
                &url("https://app.example.test/page"),
                &ScriptFetchMetadata::default(),
                true,
                owner,
            ) else {
                panic!("having loaded source must not bypass external module URL policy");
            };
            assert_eq!(error.stage(), ModuleLoadStage::Fetch);
            assert!(error.message().contains(root_url.as_str()));
            assert_eq!(vm.eval("typeof __externalModuleRan").unwrap(), "undefined");
        }
    }

    #[test]
    fn inline_module_roots_preserve_dependency_url_csp() {
        let dependency_url = url("https://dependencies.example.test/child.mjs");
        for owner in [
            ModuleScriptCompletionOwner::Parser,
            ModuleScriptCompletionOwner::Runtime,
        ] {
            for allow_dependency in [false, true] {
                let mut vm = new_test_vm("https://app.example.test/page");
                vm.set_response_content_security_policies(&[if allow_dependency {
                    "script-src 'unsafe-inline' https://dependencies.example.test".to_owned()
                } else {
                    "script-src 'unsafe-inline'".to_owned()
                }]);
                let job = module_script_graph_job_for_owner(
                    &mut vm,
                    ModuleSource::text(format!("import '{}';", dependency_url)),
                    &url("https://app.example.test/page"),
                    &url("https://app.example.test/page"),
                    &ScriptFetchMetadata::default(),
                    false,
                    owner,
                )
                .expect("an admitted inline root must not undergo external URL CSP checks");
                let advance = advance_module_script_graph(&mut vm, job);
                if allow_dependency {
                    let fetch = expect_single_fetch(advance.unwrap(), "allowed inline dependency");
                    assert_eq!(fetch.pending_fetch_key().unwrap().url(), &dependency_url);
                } else {
                    let Err(error) = advance else {
                        panic!("inline roots must not exempt their imports from CSP");
                    };
                    assert_eq!(error.stage(), ModuleLoadStage::Fetch);
                    assert!(error.message().contains(dependency_url.as_str()));
                }
            }
        }
    }

    #[test]
    fn source_override_tree_fetches_sibling_dependencies_in_one_batch() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let root_url = url("https://app.example.test/root.mjs");
        let job = module_script_graph_job(
            &mut vm,
            ModuleSource::text(
                r#"
import "./a.mjs";
import "./b.mjs";
import "./c.mjs";
"#
                .to_owned(),
            ),
            &root_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
            true,
        )
        .expect("source override root should compile into inline tree");

        match advance_module_script_graph(&mut vm, job)
            .expect("source override graph should request sibling dependencies")
        {
            ModuleScriptGraphAdvance::Complete(_) => {
                panic!("source override graph should not complete before dependency fetches")
            }
            ModuleScriptGraphAdvance::NeedFetches(fetches) => {
                let (_, fetches) = fetches.into_parts();
                let urls: Vec<_> = fetches
                    .iter()
                    .map(|fetch| fetch.request().source_url().as_str())
                    .collect();
                assert_eq!(
                    urls,
                    vec![
                        "https://app.example.test/a.mjs",
                        "https://app.example.test/b.mjs",
                        "https://app.example.test/c.mjs",
                    ]
                );
            }
        }
    }

    #[test]
    fn module_fetch_metadata_defaults_to_same_origin_credentials() {
        let metadata = ModuleFetchMetadata::default();
        let request = NativeModuleGraphFetchRequest {
            source_url: url("https://cdn.example.test/dep.mjs"),
            initiator_url: url("https://app.example.test/page"),
            fetch_metadata: metadata,
            kind: ModuleKind::JavaScript,
            tree_client: None,
            tree_graph_level: None,
            module_key: None,
            dependency: None,
        }
        .request(&moli_url::WebOrigin::from_url(&url(
            "https://app.example.test/page",
        )))
        .expect("request should build");

        assert_eq!(
            request.credentials_mode,
            RequestCredentialsMode::SameOrigin,
            "module graph fetches should not use Request::new's Include default"
        );
        assert_eq!(
            request.cookie_context.initiator_url.as_ref(),
            Some(&url("https://app.example.test/page")),
            "same-origin credentials need the document initiator to classify the target URL"
        );
    }

    #[test]
    fn module_fetch_metadata_maps_use_credentials_to_include() {
        let script_metadata = ScriptFetchMetadata {
            cross_origin: Some("use-credentials".to_owned()),
            referrer_policy: Some("no-referrer".to_owned()),
            fetch_priority: Some(moli_fetch::FetchPriorityHint::High),
            ..ScriptFetchMetadata::default()
        };
        let metadata =
            ModuleFetchMetadata::from_parser_owned_script_fetch_metadata(&script_metadata);
        assert_eq!(
            metadata.request_metadata.cross_origin.as_deref(),
            Some("use-credentials")
        );
        let request = NativeModuleGraphFetchRequest {
            source_url: url("https://app.example.test/dep.mjs"),
            initiator_url: url("https://app.example.test/page"),
            fetch_metadata: metadata,
            kind: ModuleKind::JavaScript,
            tree_client: None,
            tree_graph_level: None,
            module_key: None,
            dependency: None,
        }
        .request(&moli_url::WebOrigin::from_url(&url(
            "https://app.example.test/page",
        )))
        .expect("request should build");

        assert_eq!(request.credentials_mode, RequestCredentialsMode::Include);
        let request_metadata = request
            .subresource_request_metadata()
            .expect("module graph request should carry generic request metadata");
        assert_eq!(
            request_metadata.referrer_policy.as_deref(),
            Some("no-referrer")
        );
        assert_eq!(
            request.priority_hints.fetch_priority,
            Some(moli_fetch::FetchPriorityHint::High)
        );
        assert_eq!(
            request_metadata.integrity, None,
            "top-level script integrity must not be inherited by every graph dependency"
        );
    }

    #[test]
    fn top_level_module_fetch_metadata_preserves_element_only_options() {
        let script_metadata = ScriptFetchMetadata {
            charset: Some("utf-8".to_owned()),
            integrity: Some("sha384-entry".to_owned()),
            nonce: Some("nonce-entry".to_owned()),
            parser_inserted: true,
            ..ScriptFetchMetadata::default()
        };
        let metadata = ModuleFetchMetadata::from_top_level_script_fetch_metadata(&script_metadata);
        assert_eq!(metadata.request_metadata.charset.as_deref(), Some("utf-8"));
        assert_eq!(
            metadata.request_metadata.nonce.as_deref(),
            Some("nonce-entry")
        );
        assert!(metadata.parser_inserted);
        let request = NativeModuleGraphFetchRequest {
            source_url: url("https://app.example.test/entry.mjs"),
            initiator_url: url("https://app.example.test/page"),
            fetch_metadata: metadata,
            kind: ModuleKind::JavaScript,
            tree_client: None,
            tree_graph_level: None,
            module_key: None,
            dependency: None,
        }
        .request(&moli_url::WebOrigin::from_url(&url(
            "https://app.example.test/page",
        )))
        .expect("request should build");

        let request_metadata = request
            .subresource_request_metadata()
            .expect("module graph request should carry generic request metadata");
        assert_eq!(request_metadata.integrity.as_deref(), Some("sha384-entry"));
    }

    #[test]
    fn modulepreload_fetch_metadata_uses_auto_priority() {
        let script_metadata = ScriptFetchMetadata {
            cross_origin: Some("use-credentials".to_owned()),
            referrer_policy: Some("no-referrer".to_owned()),
            integrity: Some("sha384-preload".to_owned()),
            fetch_priority: Some(moli_fetch::FetchPriorityHint::High),
            ..ScriptFetchMetadata::default()
        };
        let metadata =
            ModuleFetchMetadata::from_modulepreload_script_fetch_metadata(&script_metadata);
        assert_eq!(
            metadata.request_metadata.fetch_priority, None,
            "Chromium ModulePreloadIfNeeded passes FetchPriorityHint::kAuto regardless of the link fetchpriority attribute"
        );
        let request = NativeModuleGraphFetchRequest {
            source_url: url("https://app.example.test/preload.mjs"),
            initiator_url: url("https://app.example.test/page"),
            fetch_metadata: metadata,
            kind: ModuleKind::JavaScript,
            tree_client: None,
            tree_graph_level: None,
            module_key: None,
            dependency: None,
        }
        .request(&moli_url::WebOrigin::from_url(&url(
            "https://app.example.test/page",
        )))
        .expect("request should build");

        assert_eq!(request.credentials_mode, RequestCredentialsMode::Include);
        let request_metadata = request
            .subresource_request_metadata()
            .expect("modulepreload request should carry generic request metadata");
        assert_eq!(
            request_metadata.referrer_policy.as_deref(),
            Some("no-referrer")
        );
        assert_eq!(
            request_metadata.integrity.as_deref(),
            Some("sha384-preload")
        );
        assert_eq!(
            request.priority_hints.fetch_priority, None,
            "modulepreload priority lowering should not leave a request hint"
        );
    }

    #[test]
    fn descendant_module_fetch_metadata_preserves_csp_provenance() {
        let script_metadata = ScriptFetchMetadata {
            cross_origin: Some("use-credentials".to_owned()),
            charset: Some("utf-8".to_owned()),
            integrity: Some("sha384-entry".to_owned()),
            nonce: Some("nonce-entry".to_owned()),
            fetch_priority: Some(moli_fetch::FetchPriorityHint::High),
            parser_inserted: true,
            ..ScriptFetchMetadata::default()
        };
        let dependency_metadata =
            ModuleFetchMetadata::from_top_level_script_fetch_metadata(&script_metadata)
                .for_descendant_fetches();
        assert_eq!(dependency_metadata.request_metadata.charset, None);
        assert_eq!(dependency_metadata.request_metadata.integrity, None);
        assert_eq!(dependency_metadata.nonce(), Some("nonce-entry"));
        assert!(dependency_metadata.parser_inserted);
        assert_eq!(
            dependency_metadata.request_metadata.fetch_priority,
            Some(moli_fetch::FetchPriorityHint::Auto)
        );
        let request = NativeModuleGraphFetchRequest {
            source_url: url("https://app.example.test/dep.mjs"),
            initiator_url: url("https://app.example.test/page"),
            fetch_metadata: dependency_metadata,
            kind: ModuleKind::JavaScript,
            tree_client: None,
            tree_graph_level: None,
            module_key: None,
            dependency: None,
        }
        .request(&moli_url::WebOrigin::from_url(&url(
            "https://app.example.test/page",
        )))
        .expect("request should build");

        let request_metadata = request
            .subresource_request_metadata()
            .expect("module graph request should carry generic request metadata");
        assert_eq!(request.credentials_mode, RequestCredentialsMode::Include);
        assert_eq!(
            request.priority_hints.fetch_priority,
            Some(moli_fetch::FetchPriorityHint::Auto)
        );
        assert_eq!(request_metadata.integrity, None);
    }

    #[test]
    fn dynamic_import_root_preserves_referrer_nonce() {
        let script_metadata = ScriptFetchMetadata {
            nonce: Some("nonce-entry".to_owned()),
            charset: Some("utf-8".to_owned()),
            integrity: Some("sha384-entry".to_owned()),
            parser_inserted: true,
            ..ScriptFetchMetadata::default()
        };
        let metadata =
            ModuleFetchMetadata::from_dynamic_import_referrer_fetch_metadata(&script_metadata);
        assert_eq!(metadata.nonce(), Some("nonce-entry"));
        assert!(metadata.parser_inserted);
        assert_eq!(
            metadata.request_metadata.charset, None,
            "dynamic import root must not inherit parser-only charset"
        );
        assert_eq!(
            metadata.request_metadata.integrity, None,
            "dynamic import root integrity comes from import maps, not the referrer script element"
        );
        let request = NativeModuleGraphFetchRequest {
            source_url: url("https://app.example.test/dynamic.mjs"),
            initiator_url: url("https://app.example.test/page"),
            fetch_metadata: metadata,
            kind: ModuleKind::JavaScript,
            tree_client: None,
            tree_graph_level: None,
            module_key: None,
            dependency: None,
        }
        .request(&moli_url::WebOrigin::from_url(&url(
            "https://app.example.test/page",
        )))
        .expect("request should build");

        let request_metadata = request
            .subresource_request_metadata()
            .expect("dynamic import root should carry generic request metadata");
        assert_eq!(request_metadata.integrity, None);
    }

    #[test]
    fn loaded_module_script_source_preserves_nonce_without_element_fetch_options() {
        let script_metadata = ScriptFetchMetadata {
            nonce: Some("nonce-entry".to_owned()),
            charset: Some("utf-8".to_owned()),
            integrity: Some("sha384-entry".to_owned()),
            parser_inserted: true,
            ..ScriptFetchMetadata::default()
        };
        let metadata =
            ModuleFetchMetadata::from_loaded_module_script_fetch_metadata(&script_metadata);
        assert_eq!(metadata.nonce(), Some("nonce-entry"));
        assert!(metadata.parser_inserted);
        assert_eq!(metadata.request_metadata.charset, None);
        assert_eq!(metadata.request_metadata.integrity, None);
        let request = NativeModuleGraphFetchRequest {
            source_url: url("https://app.example.test/inline.mjs"),
            initiator_url: url("https://app.example.test/page"),
            fetch_metadata: metadata,
            kind: ModuleKind::JavaScript,
            tree_client: None,
            tree_graph_level: None,
            module_key: None,
            dependency: None,
        }
        .request(&moli_url::WebOrigin::from_url(&url(
            "https://app.example.test/page",
        )))
        .expect("request should build");

        let request_metadata = request
            .subresource_request_metadata()
            .expect("loaded module source should carry generic request metadata");
        assert_eq!(request_metadata.integrity, None);
    }

    #[test]
    fn parser_owned_module_fetch_metadata_uses_default_script_priority() {
        let script_metadata = ScriptFetchMetadata {
            fetch_priority: Some(moli_fetch::FetchPriorityHint::Low),
            ..ScriptFetchMetadata::default()
        };
        let metadata =
            ModuleFetchMetadata::from_parser_owned_script_fetch_metadata(&script_metadata);
        let request = NativeModuleGraphFetchRequest {
            source_url: url("https://app.example.test/entry.mjs"),
            initiator_url: url("https://app.example.test/page"),
            fetch_metadata: metadata,
            kind: ModuleKind::JavaScript,
            tree_client: None,
            tree_graph_level: None,
            module_key: None,
            dependency: None,
        }
        .request(&moli_url::WebOrigin::from_url(&url(
            "https://app.example.test/page",
        )))
        .expect("request should build");

        assert_eq!(
            request.priority_hints.fetch_priority,
            Some(moli_fetch::FetchPriorityHint::Low)
        );
        assert_eq!(
            request.resource_type,
            moli_fetch::RequestResourceType::Script,
            "module graph requests use Chromium's default script priority before author hints"
        );
    }

    #[test]
    fn external_parser_module_graph_starts_with_root_fetching_entry() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let root_url = url("https://app.example.test/entry");
        let root_key = ModuleMapKey::java_script(root_url.clone());
        let job = parser_owned_external_module_script_graph_job(
            &mut vm,
            &root_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
        );

        let fetch = expect_single_fetch(
            advance_module_script_graph(&mut vm, job)
                .expect("external parser module graph should advance"),
            "external module root",
        );
        assert_eq!(fetch.request().source_url(), &root_url);
        assert_eq!(fetch.pending_fetch_key(), Some(&root_key));

        let entry = vm
            .document_runtime
            .native_module_entry_id(&root_key)
            .expect("external root fetch should reserve module map entry");
        assert_eq!(
            vm.document_runtime.native_module_entry_state(entry),
            ModuleMapEntryState::Fetching
        );
    }

    #[test]
    fn external_parser_module_tree_fetches_and_compiles_dependency_graph() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let root_url = url("https://app.example.test/root.mjs");
        let dep_url = url("https://app.example.test/dep.mjs");
        let root_key = ModuleMapKey::java_script(root_url.clone());
        let dep_key = ModuleMapKey::java_script(dep_url.clone());
        let job = parser_owned_external_module_script_graph_job(
            &mut vm,
            &root_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
        );

        let root_fetch = expect_single_fetch(
            advance_module_script_graph(&mut vm, job)
                .expect("external parser graph should request root"),
            "external parser root",
        );
        assert_eq!(root_fetch.request().source_url(), &root_url);
        assert!(
            root_fetch.request().dependency.is_none(),
            "top-level root fetch should not carry dependency parent payload"
        );
        let dep_fetch = expect_single_fetch(
            root_fetch
                .finish_source_for_test(
                    &mut vm,
                    Ok(ModuleSource::text(
                        "import { value } from './dep.mjs'; export { value };".to_owned(),
                    )),
                )
                .expect("root fetch should compile and discover dependency"),
            "single dependency graph",
        );
        assert_eq!(dep_fetch.request().source_url(), &dep_url);
        let root_entry_before_dependency = vm
            .document_runtime
            .native_module_entry_id(&root_key)
            .expect("root should be in module map after root fetch completion");
        let dependency = dep_fetch
            .request()
            .dependency
            .as_ref()
            .expect("dependent fetch should retain tree parent payload");
        assert_eq!(dependency.parent_key(), &root_key);
        assert_eq!(dependency.parent_entry_id(), root_entry_before_dependency);
        assert_eq!(dependency.specifier(), "./dep.mjs");
        assert_eq!(dependency.phase(), ModuleImportPhase::Evaluation);
        let graph = match dep_fetch
            .finish_source_for_test(
                &mut vm,
                Ok(ModuleSource::text("export const value = 1;".to_owned())),
            )
            .expect("dependency fetch should compile")
        {
            ModuleScriptGraphAdvance::Complete(graph) => graph,
            ModuleScriptGraphAdvance::NeedFetches(_) => {
                panic!("external parser graph should not request more fetches")
            }
        };

        let root_entry = vm
            .document_runtime
            .native_module_entry_id(&root_key)
            .expect("root should be in module map");
        let dep_entry = vm
            .document_runtime
            .native_module_entry_id(&dep_key)
            .expect("dependency should be in module map");
        assert_eq!(graph.root_entry, root_entry);
        assert_eq!(
            vm.document_runtime.native_module_entry_state(root_entry),
            ModuleMapEntryState::Compiled
        );
        assert_eq!(
            vm.document_runtime.native_module_entry_state(dep_entry),
            ModuleMapEntryState::Compiled
        );
        assert_eq!(
            vm.document_runtime
                .native_module_resolved_dependencies(root_entry)
                .len(),
            1
        );
    }

    #[test]
    fn static_import_with_invalid_attribute_key_fails_before_dependency_fetch() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let root_url = url("https://app.example.test/root.mjs");
        let job = parser_owned_external_module_script_graph_job(
            &mut vm,
            &root_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
        );

        let root_fetch = expect_single_fetch(
            advance_module_script_graph(&mut vm, job)
                .expect("external parser graph should request root"),
            "invalid import attribute root",
        );
        let error = match root_fetch.finish_source_for_test(
            &mut vm,
            Ok(ModuleSource::text(
                r#"import "./dep.mjs" with { foo: "bar" };"#.to_owned(),
            )),
        ) {
            Ok(_) => panic!("invalid import attribute key should fail during module creation"),
            Err(error) => error,
        };

        assert_eq!(error.stage(), ModuleLoadStage::Compile);
        assert_eq!(
            error.error_constructor(),
            Some(ScriptErrorConstructorKind::SyntaxError)
        );
        assert!(
            error.message().contains("Invalid attribute key \"foo\"."),
            "{}",
            error.message()
        );
    }

    #[test]
    fn static_import_with_text_module_type_fails_before_dependency_fetch() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let root_url = url("https://app.example.test/root.mjs");
        let job = parser_owned_external_module_script_graph_job(
            &mut vm,
            &root_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
        );

        let root_fetch = expect_single_fetch(
            advance_module_script_graph(&mut vm, job)
                .expect("external parser graph should request root"),
            "text module type root",
        );
        let error = match root_fetch.finish_source_for_test(
            &mut vm,
            Ok(ModuleSource::text(
                r#"import text from "./dep.txt" with { type: "text" };"#.to_owned(),
            )),
        ) {
            Ok(_) => panic!("text import attribute type should fail before dependency fetch"),
            Err(error) => error,
        };

        assert_eq!(error.stage(), ModuleLoadStage::Resolve);
        assert_eq!(
            error.error_constructor(),
            Some(ScriptErrorConstructorKind::TypeError)
        );
        assert!(
            error
                .message()
                .contains("module type `text` is not a valid module type for import `./dep.txt`"),
            "{}",
            error.message()
        );
    }

    #[test]
    fn dynamic_import_with_text_module_type_fails_before_fetch() {
        let mut vm = new_test_vm("https://example.test/app/page.html");
        let _js_runtime = crate::JsRuntime::initialize();
        let mut isolate = v8::Isolate::new(Default::default());
        let scope = std::pin::pin!(v8::HandleScope::new(&mut isolate));
        let scope = &mut scope.init();
        let context = v8::Context::new(scope, Default::default());
        let scope = &mut v8::ContextScope::new(scope, context);
        let resolver = v8::PromiseResolver::new(scope).expect("promise resolver");
        let mut job = NativeModuleGraphJob::dynamic_import(PendingDynamicModuleImport::new(
            v8::Global::new(scope, scope.get_current_context()),
            v8::Global::new(scope, resolver),
            crate::module_runtime::DynamicModuleImportOwner::main_for_test(),
            "./dep.txt",
            url("https://example.test/app/page.html"),
            ModuleAttributesKey::from_pairs(vec![("type".to_owned(), "text".to_owned())]),
            ModuleImportPhase::Evaluation,
        ));

        let error = match job.advance_dynamic_import_owner_lane(&mut vm) {
            Ok(_) => panic!("text module type dynamic import should fail before root fetch"),
            Err(error) => error,
        };

        assert!(!job.has_chromium_tree_for_test());
        assert_eq!(error.stage(), ModuleLoadStage::Resolve);
        assert!(
            error.message().contains(
                "module type `text` is not a valid module type for module `https://example.test/app/dep.txt`"
            ),
            "{}",
            error.message()
        );
    }

    #[test]
    fn external_parser_module_uses_response_url_as_dependency_base_without_aliasing_map_key() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let request_url = url("https://app.example.test/request/root.mjs");
        let response_url = url("https://cdn.example.test/final/root.mjs");
        let dep_url = url("https://cdn.example.test/final/dep.mjs");
        let request_key = ModuleMapKey::java_script(request_url.clone());
        let response_key = ModuleMapKey::java_script(response_url.clone());
        let job = parser_owned_external_module_script_graph_job(
            &mut vm,
            &request_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
        );

        let root_fetch = expect_single_fetch(
            advance_module_script_graph(&mut vm, job)
                .expect("external parser graph should request root"),
            "redirected external parser root",
        );
        assert_eq!(root_fetch.request().source_url(), &request_url);
        let dep_fetch = expect_single_fetch(
            root_fetch
                .finish_fetch(
                    &mut vm,
                    Ok(ModuleGraphFetchedSource::new(
                        response_url.clone(),
                        true,
                        ModuleSource::text("import './dep.mjs';".to_owned()),
                    )
                    .with_response_referrer_policy(Some("no-referrer".to_owned()))),
                )
                .expect("redirected root fetch should compile and discover dependency"),
            "redirected dependency graph",
        );

        assert_eq!(
            dep_fetch.request().source_url(),
            &dep_url,
            "relative imports must resolve against the response final URL"
        );
        assert_eq!(
            dep_fetch
                .request()
                .fetch_metadata
                .request_metadata
                .referrer_policy
                .as_deref(),
            Some("no-referrer"),
            "response Referrer-Policy must become descendant fetch metadata"
        );

        let root_entry = vm
            .document_runtime
            .native_module_entry_id(&request_key)
            .expect("request URL remains the module map key");
        assert!(
            vm.document_runtime
                .native_module_entry_id(&response_key)
                .is_none(),
            "Chromium module map keys are request URLs, not response final URLs"
        );
        assert_eq!(
            vm.document_runtime
                .native_module_entry_key(root_entry)
                .url()
                .as_str(),
            response_url.as_str(),
            "compiled module source/base identity should use the response URL"
        );
    }

    #[test]
    fn already_compiled_redirected_module_reuses_effective_base_for_dependencies() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let request_url = url("https://app.example.test/request/root.mjs");
        let response_url = url("https://cdn.example.test/final/root.mjs");
        let dep_url = url("https://cdn.example.test/final/dep.mjs");
        let request_key = ModuleMapKey::java_script(request_url.clone());

        let first_job = parser_owned_external_module_script_graph_job(
            &mut vm,
            &request_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
        );
        let root_fetch = expect_single_fetch(
            advance_module_script_graph(&mut vm, first_job)
                .expect("first graph should request root"),
            "first redirected root",
        );
        let dep_fetch = expect_single_fetch(
            root_fetch
                .finish_fetch(
                    &mut vm,
                    Ok(ModuleGraphFetchedSource::new(
                        response_url.clone(),
                        true,
                        ModuleSource::text("import './dep.mjs';".to_owned()),
                    )),
                )
                .expect("first root fetch should discover dependency"),
            "first redirected dependency",
        );
        assert_eq!(dep_fetch.request().source_url(), &dep_url);
        match dep_fetch
            .finish_source_for_test(
                &mut vm,
                Ok(ModuleSource::text("export const dep = 1;".to_owned())),
            )
            .expect("dependency fetch should complete first graph")
        {
            ModuleScriptGraphAdvance::Complete(_) => {}
            _ => panic!("first graph should complete after dependency"),
        }

        assert_eq!(
            vm.document_runtime.native_module_entry_state(
                vm.document_runtime
                    .native_module_entry_id(&request_key)
                    .expect("request URL entry should remain")
            ),
            ModuleMapEntryState::Compiled
        );

        let second_job = parser_owned_external_module_script_graph_job(
            &mut vm,
            &request_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
        );
        match advance_module_script_graph(&mut vm, second_job)
            .expect("second graph should reuse compiled root and dependency")
        {
            ModuleScriptGraphAdvance::Complete(_) => {}
            ModuleScriptGraphAdvance::NeedFetches(fetches) => {
                let (_, fetches) = fetches.into_parts();
                panic!(
                    "second graph should reuse compiled redirected graph, requested {} fetches",
                    fetches.len()
                )
            }
        }
    }

    #[test]
    fn dependency_fetch_uses_import_map_integrity_for_resolved_url() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let import_map_base = url("https://app.example.test/app/index.html");
        vm.document_runtime
            .register_import_map_source(r#"{"integrity":{"/dep.mjs":"sha384-dep"}}"#)
            .expect("import map should register");
        let root_url = url("https://app.example.test/root.mjs");
        let job = module_script_graph_job(
            &mut vm,
            ModuleSource::text("import './dep.mjs';".to_owned()),
            &root_url,
            &import_map_base,
            &ScriptFetchMetadata::default(),
            true,
        )
        .expect("parser graph should compile source override");

        let dep_fetch = expect_single_fetch(
            advance_module_script_graph(&mut vm, job)
                .expect("source override graph should request dependency"),
            "import-map integrity dependency",
        );
        assert_eq!(
            dep_fetch.request().source_url().as_str(),
            "https://app.example.test/dep.mjs"
        );
        assert_eq!(
            dep_fetch.request().integrity_for_test(),
            Some("sha384-dep"),
            "dependency fetch integrity should come from import map"
        );
    }

    #[test]
    fn dynamic_import_root_uses_import_map_integrity_for_resolved_url() {
        let mut vm = new_test_vm("https://example.test/app/page.html");
        vm.document_runtime
            .register_import_map_source(
                r#"{"imports":{"dyn":"./dynamic.mjs"},"integrity":{"./dynamic.mjs":"sha384-dyn"}}"#,
            )
            .expect("import map should register");
        let _js_runtime = crate::JsRuntime::initialize();
        let mut isolate = v8::Isolate::new(Default::default());
        let scope = std::pin::pin!(v8::HandleScope::new(&mut isolate));
        let scope = &mut scope.init();
        let context = v8::Context::new(scope, Default::default());
        let scope = &mut v8::ContextScope::new(scope, context);
        let resolver = v8::PromiseResolver::new(scope).expect("promise resolver");
        let mut job = NativeModuleGraphJob::dynamic_import(PendingDynamicModuleImport::new(
            v8::Global::new(scope, scope.get_current_context()),
            v8::Global::new(scope, resolver),
            crate::module_runtime::DynamicModuleImportOwner::main_for_test(),
            "dyn",
            url("https://example.test/app/page.html"),
            ModuleAttributesKey::empty(),
            ModuleImportPhase::Evaluation,
        ));

        let fetches = match job
            .advance_dynamic_import_owner_lane(&mut vm)
            .expect("dynamic import graph should request root")
        {
            NativeModuleGraphJobAdvance::NeedFetches(requests) => requests,
            NativeModuleGraphJobAdvance::Complete(_) => {
                panic!("dynamic import should not complete before root fetch")
            }
            NativeModuleGraphJobAdvance::WaitingForFetches => {
                panic!("dynamic import should not wait before root fetch")
            }
        };
        assert_eq!(fetches.len(), 1);
        let fetch = fetches
            .first()
            .expect("dynamic import root fetch should be present");
        assert_eq!(
            fetch.source_url().as_str(),
            "https://example.test/app/dynamic.mjs"
        );
        assert_eq!(fetch.integrity_for_test(), Some("sha384-dyn"));
    }

    #[test]
    fn external_module_root_uses_import_map_integrity_when_element_integrity_is_absent() {
        let mut vm = new_test_vm("https://app.example.test/page");
        vm.document_runtime
            .register_import_map_source(r#"{"integrity":{"/entry.mjs":"sha384-entry"}}"#)
            .expect("import map should register");
        let entry_url = url("https://app.example.test/entry.mjs");
        let job = parser_owned_external_module_script_graph_job(
            &mut vm,
            &entry_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
        );

        let root_fetch = expect_single_fetch(
            advance_module_script_graph(&mut vm, job).expect("external graph should request root"),
            "external root import-map integrity",
        );
        assert_eq!(root_fetch.request().source_url(), &entry_url);
        assert_eq!(
            root_fetch.request().integrity_for_test(),
            Some("sha384-entry")
        );
    }

    #[test]
    fn external_module_root_element_integrity_overrides_import_map_integrity() {
        let mut vm = new_test_vm("https://app.example.test/page");
        vm.document_runtime
            .register_import_map_source(r#"{"integrity":{"/entry.mjs":"sha384-map"}}"#)
            .expect("import map should register");
        let entry_url = url("https://app.example.test/entry.mjs");
        let script_metadata = ScriptFetchMetadata {
            integrity: Some("sha384-element".to_owned()),
            ..ScriptFetchMetadata::default()
        };
        let job = parser_owned_external_module_script_graph_job(
            &mut vm,
            &entry_url,
            &url("https://app.example.test/page"),
            &script_metadata,
        );

        let root_fetch = expect_single_fetch(
            advance_module_script_graph(&mut vm, job).expect("external graph should request root"),
            "external root element integrity",
        );
        assert_eq!(
            root_fetch.request().integrity_for_test(),
            Some("sha384-element")
        );
    }

    #[tokio::test(flavor = "multi_thread")]
    async fn module_graph_fetch_reuses_script_text_cache_across_same_site_page_initiators()
    -> anyhow::Result<()> {
        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await?;
        let addr = listener.local_addr()?;
        let server = tokio::spawn(async move {
            let (mut stream, _) = listener.accept().await.unwrap();
            read_http_request_head(&mut stream).await.unwrap();
            let body = "export default function cachedModule() {}";
            let response = format!(
                "HTTP/1.1 200 OK\r\nContent-Type: text/javascript\r\nCache-Control: max-age=60\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
                body.len(),
                body
            );
            tokio::io::AsyncWriteExt::write_all(&mut stream, response.as_bytes())
                .await
                .unwrap();

            assert!(
                tokio::time::timeout(std::time::Duration::from_millis(100), listener.accept())
                    .await
                    .is_err(),
                "second module fetch should be served from the loader script text cache"
            );
        });

        let loader = ResourceRequestClient::new(&FetchConfig::default())?;
        let module_url = Url::parse(&format!("http://{addr}/cached-module.js"))?;
        let first_response = fetch_module_for_test(
            &loader,
            module_url.clone(),
            ModuleKind::JavaScript,
            Url::parse(&format!("http://{addr}/first-page.html"))?,
            ModuleFetchMetadata::default(),
        )
        .await?;
        let second_response = fetch_module_for_test(
            &loader,
            module_url,
            ModuleKind::JavaScript,
            Url::parse(&format!("http://{addr}/second-page.html"))?,
            ModuleFetchMetadata::default(),
        )
        .await?;

        assert!(
            !first_response.from_cache,
            "first network result should come from the network"
        );
        assert!(
            second_response.from_cache,
            "second module graph network result should preserve loader cache provenance"
        );

        server.await?;
        Ok(())
    }

    #[tokio::test(flavor = "multi_thread")]
    async fn module_graph_fetch_rejects_integrity_mismatch() -> anyhow::Result<()> {
        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await?;
        let addr = listener.local_addr()?;
        let server = tokio::spawn(async move {
            let (mut stream, _) = listener.accept().await.unwrap();
            read_http_request_head(&mut stream).await.unwrap();
            let body = "export default 'not the expected body';";
            let response = format!(
                "HTTP/1.1 200 OK\r\nContent-Type: text/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
                body.len(),
                body
            );
            tokio::io::AsyncWriteExt::write_all(&mut stream, response.as_bytes())
                .await
                .unwrap();
        });

        let loader = ResourceRequestClient::new(&FetchConfig::default())?;
        let module_url = Url::parse(&format!("http://{addr}/bad-integrity.js"))?;
        let metadata = ModuleFetchMetadata {
            request_metadata: ScriptFetchRequestMetadata {
                integrity: Some(
                    "sha384-Li9vy3DqF8tnTXuiaAJuML3ky+er10rcgNR/VqsVpcw+ThHmYcwiB1pbOxEbzJr7"
                        .to_owned(),
                ),
                ..ScriptFetchRequestMetadata::default()
            },
            ..ModuleFetchMetadata::default()
        };
        let error = fetch_module_for_test(
            &loader,
            module_url,
            ModuleKind::JavaScript,
            Url::parse(&format!("http://{addr}/page.html"))?,
            metadata,
        )
        .await
        .expect_err("an integrity mismatch must reject the module fetch");

        assert!(
            error.to_string().contains("failed its integrity check"),
            "module graph fetch should report an integrity mismatch: {error:#}"
        );
        server.await?;
        Ok(())
    }

    #[tokio::test(flavor = "multi_thread")]
    async fn module_graph_fetch_enforces_response_mime_for_module_kinds() -> anyhow::Result<()> {
        for (kind, mime, body) in [
            (
                ModuleKind::JavaScript,
                "text/javascript",
                "export const answer = 42;",
            ),
            (ModuleKind::Json, "application/json", r#"{"answer":42}"#),
            (ModuleKind::Json, "text/json", r#"{"answer":42}"#),
            (ModuleKind::Css, "text/css", "#test { color: red; }"),
            (
                ModuleKind::WebAssembly,
                "application/wasm",
                "\0asm\x01\0\0\0",
            ),
        ] {
            let cases = [
                (vec![mime.to_owned()], true),
                (
                    vec![format!("{}; charset=utf-16", mime.to_ascii_uppercase())],
                    true,
                ),
                (vec!["text/plain".to_owned(), mime.to_owned()], true),
                (vec![format!("text/plain, {mime}")], true),
                (
                    vec![mime.to_owned(), "invalid".to_owned(), "*/*".to_owned()],
                    true,
                ),
                (vec![mime.to_owned(), "text/plain".to_owned()], false),
                (vec![format!("{mime}, text/plain")], false),
                (vec![format!(r#"text/plain; a=",{mime}""#)], false),
                (
                    vec![r#"text/plain; a=""#.to_owned(), mime.to_owned()],
                    false,
                ),
                (vec!["text/plain".to_owned()], false),
                (vec!["applic(ation/vnd.api+json".to_owned()], false),
                (vec!["application/vnd)api+json".to_owned()], false),
                (vec!["*/*".to_owned()], false),
                (vec![String::new()], false),
                (vec![], false),
            ];
            for (values, accepts) in cases {
                let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await?;
                let addr = listener.local_addr()?;
                let fields: String = values
                    .iter()
                    .map(|value| format!("Content-Type: {value}\r\n"))
                    .collect();
                let server = tokio::spawn(async move {
                    let (mut stream, _) = listener.accept().await.unwrap();
                    read_http_request_head(&mut stream).await.unwrap();
                    let response = format!(
                        "HTTP/1.1 200 OK\r\n{fields}Content-Length: {}\r\nConnection: close\r\n\r\n{body}",
                        body.len()
                    );
                    tokio::io::AsyncWriteExt::write_all(&mut stream, response.as_bytes())
                        .await
                        .unwrap();
                });
                let loader = ResourceRequestClient::new(&FetchConfig::default())?;
                let result = fetch_module_for_test(
                    &loader,
                    Url::parse(&format!("http://{addr}/module"))?,
                    kind,
                    Url::parse(&format!("http://{addr}/page"))?,
                    ModuleFetchMetadata::default(),
                )
                .await;
                server.await?;
                assert_eq!(result.is_ok(), accepts, "{kind:?}: {values:?}: {result:?}");
                if let Err(error) = result {
                    let expected = match kind {
                        ModuleKind::JavaScript | ModuleKind::WebAssembly => {
                            "unsupported script MIME type"
                        }
                        ModuleKind::Json => "non-JSON module response",
                        ModuleKind::Css => "non-CSS module response",
                        ModuleKind::ModulePreloadText => {
                            unreachable!("text preloads do not enforce a response MIME type")
                        }
                    };
                    assert!(error.to_string().contains(expected), "{error:#}");
                }
            }
        }
        Ok(())
    }

    async fn fetch_module_for_test(
        loader: &ResourceRequestClient,
        source_url: Url,
        kind: ModuleKind,
        initiator_url: Url,
        fetch_metadata: ModuleFetchMetadata,
    ) -> anyhow::Result<crate::protocol_types::NavigationResponse> {
        let request = NativeModuleGraphFetchRequest {
            source_url,
            initiator_url,
            fetch_metadata,
            kind,
            tree_client: None,
            tree_graph_level: None,
            module_key: None,
            dependency: None,
        };
        let (tx, rx) = oneshot::channel();
        let registry = ResourceLoadRegistry::new(
            RendererResourceTaskRunner::from_current_tokio()
                .expect("module fetch test must own a Tokio runtime"),
        );
        let load = registry
            .register(
                ResourceLoadKind::Script,
                ResourceLoadDisposition::Ordinary,
                loader.frozen_request_client(),
                None,
            )
            .expect("module fetch test load should register");
        request.fetch_source_callback_with_load(
            loader,
            load,
            moli_url::WebOrigin::from_url(request.initiator_url()),
            move |result, network_result| {
                let _ = tx.send((result, network_result));
            },
        )?;
        let (result, network_result) = rx.await?;
        let source_result = result.map_err(anyhow::Error::msg);
        let network_result = network_result.expect("module fetch should record network result");
        let response = match network_result.as_ref() {
            Ok(response) => response.clone(),
            Err(error) => return Err(anyhow::anyhow!(error.clone())),
        };
        source_result?;
        Ok(response)
    }

    async fn read_http_request_head(stream: &mut tokio::net::TcpStream) -> std::io::Result<()> {
        use tokio::io::AsyncReadExt;

        let mut request = Vec::new();
        let mut byte = [0_u8; 1];
        loop {
            let read = stream.read(&mut byte).await?;
            if read == 0 {
                return Err(std::io::Error::new(
                    std::io::ErrorKind::UnexpectedEof,
                    "client closed before sending complete request",
                ));
            }
            request.push(byte[0]);
            if request.ends_with(b"\r\n\r\n") {
                return Ok(());
            }
        }
    }

    #[test]
    fn dependency_load_inherits_module_fetch_metadata_and_initiator() {
        let script_metadata = ScriptFetchMetadata {
            referrer_policy: Some("origin".to_owned()),
            ..ScriptFetchMetadata::default()
        };
        let root_metadata =
            ModuleFetchMetadata::from_parser_owned_script_fetch_metadata(&script_metadata);
        let request = NativeModuleGraphFetchRequest {
            source_url: url("https://cdn.example.test/dep.mjs"),
            initiator_url: url("https://app.example.test/page"),
            fetch_metadata: root_metadata.for_descendant_fetches(),
            kind: ModuleKind::JavaScript,
            tree_client: None,
            tree_graph_level: None,
            module_key: None,
            dependency: None,
        }
        .request(&moli_url::WebOrigin::from_url(&url(
            "https://app.example.test/page",
        )))
        .expect("request should build");

        assert_eq!(request.credentials_mode, RequestCredentialsMode::SameOrigin);
        assert_eq!(
            request.cookie_context.initiator_url.as_ref(),
            Some(&url("https://app.example.test/page"))
        );
        assert_eq!(
            request
                .subresource_request_metadata()
                .and_then(|metadata| metadata.referrer_policy.as_deref()),
            Some("origin")
        );
    }

    #[test]
    fn graph_waits_for_reused_compiled_dependency_pending_static_child() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let parent_url = url("https://app.example.test/parent.mjs");
        let parent_job = module_script_graph_job(
            &mut vm,
            ModuleSource::text(
                r#"import { value } from "./child.mjs"; export { value };"#.to_owned(),
            ),
            &parent_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
            true,
        )
        .expect("parent graph should compile source override");

        let child_key = match advance_module_script_graph(&mut vm, parent_job)
            .expect("parent graph should advance")
        {
            ModuleScriptGraphAdvance::NeedFetches(fetches) => {
                let (_, mut fetches) = fetches.into_parts();
                assert_eq!(fetches.len(), 1);
                fetches
                    .pop()
                    .expect("dependency fetch should be present")
                    .pending_fetch_key()
                    .expect("dependency fetch should have a module key")
                    .clone()
            }
            ModuleScriptGraphAdvance::Complete(_) => {
                panic!("parent graph should wait for child fetch")
            }
        };
        assert_eq!(
            child_key.url().as_str(),
            "https://app.example.test/child.mjs"
        );

        let root_url = url("https://app.example.test/root.mjs");
        let parser_job = module_script_graph_job(
            &mut vm,
            ModuleSource::text(
                r#"import { value } from "./parent.mjs"; window.graphValue = value;"#.to_owned(),
            ),
            &root_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
            true,
        )
        .expect("parser graph should compile source override");

        let joined_job = expect_single_joined_wait(
            advance_module_script_graph(&mut vm, parser_job).expect("parser graph should advance"),
            "parser graph reusing pending child",
        );
        assert_eq!(
            joined_job.pending_joined_client_count_for_test(),
            1,
            "parser graph should wait on the pending child fetch through its owner job"
        );
        assert_eq!(
            vm.document_runtime
                .native_module_script_client_count_for_testing(),
            1,
            "joined child client should be stored on the module map entry"
        );
    }

    #[test]
    fn source_phase_graph_reusing_evaluation_wasm_entry_does_not_chase_dependencies() {
        const WASM_IMPORT_JS_DEPENDENCY: &[u8] = &[
            0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x04, 0x01, 0x60, 0x00, 0x00,
            0x02, 0x14, 0x01, 0x08, 0x2e, 0x2f, 0x64, 0x65, 0x70, 0x2e, 0x6a, 0x73, 0x07, 0x6c,
            0x6f, 0x67, 0x45, 0x78, 0x65, 0x63, 0x00, 0x00, 0x07, 0x07, 0x01, 0x03, 0x6c, 0x6f,
            0x67, 0x00, 0x00,
        ];
        let mut vm = new_test_vm("https://app.example.test/page");
        let wasm_url = "https://app.example.test/execute-start.wasm";
        let wasm_key = ModuleMapKey::webassembly(url(wasm_url));
        let dep_key = ModuleMapKey::java_script(url("https://app.example.test/dep.js"));

        let evaluation_job = module_script_inline_tree_job(
            &mut vm,
            wasm_root_input(
                wasm_url,
                WASM_IMPORT_JS_DEPENDENCY,
                ModuleImportPhase::Evaluation,
            ),
        )
        .expect("evaluation wasm graph should compile source override");
        let fetch = expect_single_fetch(
            advance_module_script_graph(&mut vm, evaluation_job)
                .expect("evaluation graph should request wasm dependency fetch"),
            "evaluation wasm graph",
        );
        assert_eq!(fetch.pending_fetch_key(), Some(&dep_key));

        let wasm_entry = vm
            .document_runtime
            .native_module_entry_id(&wasm_key)
            .expect("wasm entry should be compiled");
        assert_eq!(
            vm.document_runtime.native_module_entry_state(wasm_entry),
            ModuleMapEntryState::Compiled
        );
        let dep_entry = vm
            .document_runtime
            .native_module_entry_id(&dep_key)
            .expect("dependency fetch should be registered");
        assert_eq!(
            vm.document_runtime.native_module_entry_state(dep_entry),
            ModuleMapEntryState::Fetching
        );

        let source_job = module_script_inline_tree_job(
            &mut vm,
            wasm_root_input(
                wasm_url,
                WASM_IMPORT_JS_DEPENDENCY,
                ModuleImportPhase::Source,
            ),
        )
        .expect("source-phase wasm graph should compile source override");
        match advance_module_script_graph(&mut vm, source_job)
            .expect("source-phase graph should ignore evaluation dependencies")
        {
            ModuleScriptGraphAdvance::Complete(_) => {}
            ModuleScriptGraphAdvance::NeedFetches(_) => {
                panic!("source-phase graph should not batch fetch dependencies")
            }
        }
    }

    #[test]
    fn parser_owned_graph_fetches_sibling_dependencies_in_one_batch() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let root_url = url("https://app.example.test/root.mjs");
        let job = module_script_graph_job(
            &mut vm,
            ModuleSource::text(
                r#"
import "./a.mjs";
import "./b.mjs";
import "./c.mjs";
"#
                .to_owned(),
            ),
            &root_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
            true,
        )
        .expect("parser-owned graph should compile source override");

        match advance_module_script_graph(&mut vm, job).expect("parser-owned graph should advance")
        {
            ModuleScriptGraphAdvance::NeedFetches(fetches) => {
                let (_, fetches) = fetches.into_parts();
                let urls: Vec<_> = fetches
                    .iter()
                    .map(|fetch| fetch.request().source_url().as_str())
                    .collect();
                assert_eq!(
                    urls,
                    vec![
                        "https://app.example.test/a.mjs",
                        "https://app.example.test/b.mjs",
                        "https://app.example.test/c.mjs",
                    ]
                );
            }
            ModuleScriptGraphAdvance::Complete(_) => {
                panic!("parser-owned graph should not complete before dependency fetches")
            }
        }
    }

    #[test]
    fn parser_owned_sibling_dependency_batch_accepts_out_of_order_completions() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let root_url = url("https://app.example.test/root.mjs");
        let job = module_script_graph_job(
            &mut vm,
            ModuleSource::text(
                r#"
import "./a.mjs";
import "./b.mjs";
"#
                .to_owned(),
            ),
            &root_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
            true,
        )
        .expect("parser-owned graph should compile source override");

        let (mut job, mut fetches) =
            match advance_module_script_graph(&mut vm, job).expect("graph should advance") {
                ModuleScriptGraphAdvance::NeedFetches(fetches) => fetches.into_parts(),
                ModuleScriptGraphAdvance::Complete(_) => {
                    panic!("graph should not complete before dependency fetches")
                }
            };
        assert_eq!(
            job.pending_joined_client_count_for_test(),
            0,
            "graph should not join existing fetches before scheduling siblings"
        );
        assert_eq!(fetches.len(), 2);
        fetches.sort_by(|left, right| {
            right
                .request()
                .source_url()
                .cmp(left.request().source_url())
        });
        let first_completion = fetches.remove(0);
        assert_eq!(
            first_completion.request().source_url().as_str(),
            "https://app.example.test/b.mjs"
        );
        first_completion
            .finish_source_for_test(
                &mut vm,
                &mut job,
                Ok(ModuleSource::text("export const b = 2;".to_owned())),
            )
            .expect("b.mjs should compile");
        let job = match advance_module_script_graph(&mut vm, job)
            .expect("graph should still wait for a.mjs")
        {
            ModuleScriptGraphAdvance::NeedFetches(fetches) => {
                let (job, fetches) = fetches.into_parts();
                assert!(
                    fetches.is_empty(),
                    "out-of-order owned completion should not schedule additional fetches"
                );
                assert_eq!(
                    job.pending_joined_client_count_for_test(),
                    0,
                    "out-of-order owned completion should not register joined fetches"
                );
                job
            }
            _ => panic!("expected graph to wait for the remaining dependency client"),
        };

        let mut job = job;
        let second_completion = fetches.remove(0);
        assert_eq!(
            second_completion.request().source_url().as_str(),
            "https://app.example.test/a.mjs"
        );
        second_completion
            .finish_source_for_test(
                &mut vm,
                &mut job,
                Ok(ModuleSource::text("export const a = 1;".to_owned())),
            )
            .expect("a.mjs should compile");
        match advance_module_script_graph(&mut vm, job).expect("graph should complete") {
            ModuleScriptGraphAdvance::Complete(_) => {}
            _ => panic!("expected graph completion after both dependency clients"),
        }
    }

    #[test]
    fn parser_owned_join_wait_does_not_drop_pending_owned_fetch_client() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let root_url = url("https://app.example.test/root.mjs");
        let leaf_url = url("https://app.example.test/leaf.mjs");
        let _modulepreload_load_id = suspend_registered_modulepreload_fetch(
            &mut vm,
            modulepreload_single_fetch_request(leaf_url.clone()),
        );

        let job = module_script_graph_job(
            &mut vm,
            ModuleSource::text(
                r#"
import "./parent-a.mjs";
import "./parent-b.mjs";
"#
                .to_owned(),
            ),
            &root_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
            true,
        )
        .expect("parser-owned graph should compile source override");

        let (mut job, mut fetches) =
            match advance_module_script_graph(&mut vm, job).expect("graph should advance") {
                ModuleScriptGraphAdvance::NeedFetches(fetches) => fetches.into_parts(),
                ModuleScriptGraphAdvance::Complete(_) => {
                    panic!("graph should not complete before dependency fetches")
                }
            };
        assert_eq!(
            job.pending_joined_client_count_for_test(),
            0,
            "graph should not join existing fetches before scheduling parents"
        );
        assert_eq!(fetches.len(), 2);

        let parent_a_index = fetches
            .iter()
            .position(|fetch| {
                fetch.request().source_url().as_str() == "https://app.example.test/parent-a.mjs"
            })
            .expect("parent-a fetch should be present");
        let parent_a = fetches.remove(parent_a_index);
        let parent_a_advance = parent_a
            .finish_source_for_test(
                &mut vm,
                &mut job,
                Ok(ModuleSource::text(
                    "import './leaf.mjs'; export const a = 1;".to_owned(),
                )),
            )
            .expect("parent-a should compile and join leaf modulepreload");
        let mut job = match module_script_graph_advance_from_native(job, parent_a_advance) {
            ModuleScriptGraphAdvance::NeedFetches(fetches) => {
                let (job, fetches) = fetches.into_parts();
                assert!(
                    fetches.is_empty(),
                    "parent-a should not schedule more owned fetches while parent-b is still pending"
                );
                assert_eq!(
                    job.pending_joined_client_count_for_test(),
                    1,
                    "parent-a should register the joined leaf while parent-b is still pending"
                );
                assert_eq!(
                    vm.document_runtime
                        .native_module_script_client_count_for_testing(),
                    1,
                    "joined leaf should be stored on the module map entry"
                );
                job
            }
            _ => panic!("graph should wait for the remaining owned dependency client"),
        };
        let joined_clients = job.take_pending_joined_clients();
        assert_eq!(
            joined_clients.len(),
            1,
            "owner facade should drain the joined leaf client before restoring the graph job"
        );

        let parent_b = fetches.pop().expect("parent-b fetch should remain");
        assert_eq!(
            parent_b.request().source_url().as_str(),
            "https://app.example.test/parent-b.mjs"
        );
        parent_b
            .finish_source_for_test(
                &mut vm,
                &mut job,
                Ok(ModuleSource::text(
                    "import './leaf.mjs'; export const b = 2;".to_owned(),
                )),
            )
            .expect("parent-b should compile");
        match advance_module_script_graph(&mut vm, job)
            .expect("graph should now wait for the joined leaf modulepreload")
        {
            ModuleScriptGraphAdvance::NeedFetches(fetches) => {
                let (job, fetches) = fetches.into_parts();
                assert!(
                    fetches.is_empty(),
                    "joined leaf wait should not schedule another owned fetch"
                );
                assert_eq!(
                    job.pending_joined_client_count_for_test(),
                    0,
                    "joined leaf should already have been registered while parent-b was pending"
                );
            }
            _ => panic!("graph should keep waiting for the already-registered leaf join"),
        }
    }

    #[test]
    fn parser_owned_sibling_dependency_batches_join_repeated_module_map_entries() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let first_root_url = url("https://app.example.test/first-root.mjs");
        let first_job = module_script_graph_job(
            &mut vm,
            ModuleSource::text(
                r#"
import "./a.mjs";
import "./shared.mjs";
"#
                .to_owned(),
            ),
            &first_root_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
            true,
        )
        .expect("first parser-owned graph should compile source override");

        match advance_module_script_graph(&mut vm, first_job)
            .expect("first parser-owned graph should advance")
        {
            ModuleScriptGraphAdvance::NeedFetches(fetches) => {
                let (job, fetches) = fetches.into_parts();
                assert_eq!(
                    job.pending_joined_client_count_for_test(),
                    0,
                    "first graph should not join existing fetches before scheduling siblings"
                );
                let urls: Vec<_> = fetches
                    .iter()
                    .map(|fetch| fetch.request().source_url().as_str())
                    .collect();
                assert_eq!(
                    urls,
                    vec![
                        "https://app.example.test/a.mjs",
                        "https://app.example.test/shared.mjs",
                    ]
                );
            }
            ModuleScriptGraphAdvance::Complete(_) => {
                panic!("first graph should not complete before dependency fetches")
            }
        }
        let second_root_url = url("https://app.example.test/second-root.mjs");
        let second_job = module_script_graph_job(
            &mut vm,
            ModuleSource::text(
                r#"
import "./b.mjs";
import "./shared.mjs";
"#
                .to_owned(),
            ),
            &second_root_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
            true,
        )
        .expect("second parser-owned graph should compile source override");
        match advance_module_script_graph(&mut vm, second_job)
            .expect("second parser-owned graph should advance")
        {
            ModuleScriptGraphAdvance::NeedFetches(fetches) => {
                let (job, fetches) = fetches.into_parts();
                let urls: Vec<_> = fetches
                    .iter()
                    .map(|fetch| fetch.request().source_url().as_str())
                    .collect();
                assert_eq!(
                    urls,
                    vec!["https://app.example.test/b.mjs"],
                    "second graph should fetch only the new sibling; shared.mjs joins the module map entry reserved by the first graph"
                );
                assert_eq!(
                    job.pending_joined_client_count_for_test(),
                    1,
                    "second graph should register one joined waiter for shared.mjs"
                );
                assert_eq!(
                    vm.document_runtime
                        .native_module_script_client_count_for_testing(),
                    1,
                    "joined shared module should be stored on the module map entry"
                );
            }
            ModuleScriptGraphAdvance::Complete(_) => {
                panic!("second graph should not complete before dependency fetches")
            }
        }
    }

    #[test]
    fn parser_graph_joins_pending_modulepreload_without_taking_owner() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let root_url = url("https://app.example.test/root.mjs");
        let start = vm
            .document_runtime
            .fetch_single_native_module_for_modulepreload(modulepreload_single_fetch_request(
                root_url.clone(),
            ))
            .expect("modulepreload should reserve the module map entry");
        let NativeModulepreloadFetchStart::Started(request) = start else {
            panic!("new modulepreload should start one single fetch")
        };
        vm.document_runtime
            .suspend_native_modulepreload_fetch(*request);

        let parser_job = parser_owned_external_module_script_graph_job(
            &mut vm,
            &root_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
        );
        match advance_module_script_graph(&mut vm, parser_job)
            .expect("parser graph should join the pending modulepreload")
        {
            ModuleScriptGraphAdvance::NeedFetches(fetches) => {
                let (job, fetches) = fetches.into_parts();
                assert!(
                    fetches.is_empty(),
                    "parser graph must not take ownership of the pending modulepreload"
                );
                assert_eq!(
                    job.pending_joined_client_count_for_test(),
                    1,
                    "parser graph should register one module map waiter"
                );
            }
            ModuleScriptGraphAdvance::Complete(_) => {
                panic!("parser graph should not complete before modulepreload fetch completion")
            }
        }
        assert!(
            vm.document_runtime
                .has_inflight_native_modulepreload_fetch(),
            "joined parser graph must leave the in-flight modulepreload fetch owned by modulepreload"
        );
        assert!(
            vm.document_runtime.has_native_module_script_fetch_waiters(),
            "FetchSingle JoinedFetching should register the parser module script client on the module map entry"
        );
    }

    #[test]
    fn modulepreload_completion_fetches_single_module_without_descendants() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let root_url = url("https://app.example.test/root.mjs");
        let dep_url = url("https://app.example.test/dep.mjs");
        let root_key = ModuleMapKey::java_script(root_url.clone());
        let dep_key = ModuleMapKey::java_script(dep_url);
        let load_id = suspend_registered_modulepreload_fetch(
            &mut vm,
            modulepreload_single_fetch_request(root_url.clone()),
        );

        vm.complete_native_module_graph_fetch(crate::types::ModuleGraphFetchCompletion {
            load_id,
            requester: ModuleGraphFetchRequester::ModulePreload,
            ordering: ModuleGraphFetchOrdering::BackgroundPreload,
            request_url: root_url.clone(),
            result: Ok(ModuleGraphFetchedSource::new(
                root_url,
                false,
                ModuleSource::text("import './dep.mjs'; export const root = 1;".to_owned()),
            )),
            network_result: None,
        })
        .expect("modulepreload completion should be accepted");

        let root_entry = vm
            .document_runtime
            .native_module_entry_id(&root_key)
            .expect("modulepreload root should remain in module map");
        assert_eq!(
            vm.document_runtime.native_module_entry_state(root_entry),
            ModuleMapEntryState::Fetched,
            "modulepreload should fetch the single root module but not compile the graph"
        );
        assert!(
            vm.document_runtime
                .native_module_entry_id(&dep_key)
                .is_none(),
            "modulepreload must not fetch descendants"
        );
    }

    #[test]
    fn modulepreload_single_fetch_uses_import_map_integrity_when_element_integrity_is_absent() {
        let mut vm = new_test_vm("https://app.example.test/page");
        vm.document_runtime
            .register_import_map_source(r#"{"integrity":{"/root.mjs":"sha384-root"}}"#)
            .expect("import map should register");
        let root_url = url("https://app.example.test/root.mjs");
        let metadata = ModuleFetchMetadata::from_modulepreload_script_fetch_metadata(
            &ScriptFetchMetadata::default(),
        )
        .with_import_map_integrity_if_absent(
            vm.document_runtime.resolve_module_integrity(&root_url),
        );

        let start = vm
            .document_runtime
            .fetch_single_native_module_for_modulepreload(
                modulepreload_single_fetch_request_with_metadata(root_url, metadata),
            )
            .expect("modulepreload should reserve the module map entry");
        let NativeModulepreloadFetchStart::Started(started) = start else {
            panic!("new modulepreload should start a single fetch")
        };
        assert_eq!(
            started
                .fetch_metadata()
                .request_metadata
                .integrity
                .as_deref(),
            Some("sha384-root")
        );
    }

    #[test]
    fn modulepreload_element_integrity_overrides_import_map_integrity() {
        let mut vm = new_test_vm("https://app.example.test/page");
        vm.document_runtime
            .register_import_map_source(r#"{"integrity":{"/root.mjs":"sha384-map"}}"#)
            .expect("import map should register");
        let root_url = url("https://app.example.test/root.mjs");
        let script_metadata = ScriptFetchMetadata {
            integrity: Some("sha384-element".to_owned()),
            ..ScriptFetchMetadata::default()
        };
        let metadata =
            ModuleFetchMetadata::from_modulepreload_script_fetch_metadata(&script_metadata)
                .with_import_map_integrity_if_absent(
                    vm.document_runtime.resolve_module_integrity(&root_url),
                );

        let start = vm
            .document_runtime
            .fetch_single_native_module_for_modulepreload(
                modulepreload_single_fetch_request_with_metadata(root_url, metadata),
            )
            .expect("modulepreload should reserve the module map entry");
        let NativeModulepreloadFetchStart::Started(started) = start else {
            panic!("new modulepreload should start a single fetch")
        };
        assert_eq!(
            started
                .fetch_metadata()
                .request_metadata
                .integrity
                .as_deref(),
            Some("sha384-element")
        );
    }

    #[test]
    fn parser_graph_reuses_modulepreload_single_fetch_then_fetches_dependencies() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let root_url = url("https://app.example.test/root.mjs");
        let dep_url = url("https://app.example.test/dep.mjs");
        let root_source = "import './dep.mjs'; export const root = 1;";
        let root_key = ModuleMapKey::java_script(root_url.clone());
        let dep_key = ModuleMapKey::java_script(dep_url.clone());
        let load_id = suspend_registered_modulepreload_fetch(
            &mut vm,
            modulepreload_single_fetch_request(root_url.clone()),
        );
        vm.complete_native_module_graph_fetch(crate::types::ModuleGraphFetchCompletion {
            load_id,
            requester: ModuleGraphFetchRequester::ModulePreload,
            ordering: ModuleGraphFetchOrdering::BackgroundPreload,
            request_url: root_url.clone(),
            result: Ok(ModuleGraphFetchedSource::new(
                root_url.clone(),
                false,
                ModuleSource::text(root_source.to_owned()),
            )),
            network_result: None,
        })
        .expect("modulepreload completion should be accepted");

        let parser_job = module_script_graph_job(
            &mut vm,
            ModuleSource::text(root_source.to_owned()),
            &root_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
            true,
        )
        .expect("parser graph should compile source override");
        let fetch = expect_single_fetch(
            advance_module_script_graph(&mut vm, parser_job)
                .expect("parser graph should reuse modulepreload root"),
            "parser graph after modulepreload root reuse",
        );
        assert_eq!(fetch.request().source_url(), &dep_url);
        assert_eq!(
            vm.document_runtime.native_module_entry_state(
                vm.document_runtime
                    .native_module_entry_id(&root_key)
                    .expect("root entry should remain")
            ),
            ModuleMapEntryState::Compiled,
            "parser graph should compile the fetched modulepreload root"
        );
        assert_eq!(
            vm.document_runtime.native_module_entry_state(
                vm.document_runtime
                    .native_module_entry_id(&dep_key)
                    .expect("dependency fetch should be registered")
            ),
            ModuleMapEntryState::Fetching
        );
    }

    #[test]
    fn modulepreload_joins_existing_parser_fetch_without_resetting_entry() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let root_url = url("https://app.example.test/root.mjs");
        let root_key = ModuleMapKey::java_script(root_url.clone());
        let parser_job = parser_owned_external_module_script_graph_job(
            &mut vm,
            &root_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
        );

        let fetch = expect_single_fetch(
            advance_module_script_graph(&mut vm, parser_job)
                .expect("parser graph should reserve root fetch"),
            "parser graph root",
        );
        assert_eq!(fetch.pending_fetch_key(), Some(&root_key));
        let entry_id = vm
            .document_runtime
            .native_module_entry_id(&root_key)
            .expect("parser graph should create root entry");
        assert_eq!(
            vm.document_runtime.native_module_entry_state(entry_id),
            ModuleMapEntryState::Fetching
        );

        let start = vm
            .document_runtime
            .fetch_single_native_module_for_modulepreload(modulepreload_single_fetch_request(
                root_url.clone(),
            ))
            .expect("modulepreload should join existing root fetch");
        assert_eq!(
            start,
            NativeModulepreloadFetchStart::Joined,
            "joining an existing parser fetch should not schedule a modulepreload network fetch"
        );

        assert_eq!(
            vm.document_runtime.native_module_entry_state(entry_id),
            ModuleMapEntryState::Fetching,
            "modulepreload join must not reset or complete the parser-owned fetching entry"
        );
        assert!(
            !vm.document_runtime
                .has_inflight_native_modulepreload_fetch(),
            "joining an existing module fetch must not create an in-flight modulepreload fetch"
        );
    }

    #[test]
    fn failed_owned_fetch_settles_module_map_and_notifies_joined_graph() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let initiator_url = url("https://app.example.test/page");
        let first_root_url = url("https://app.example.test/first.mjs");
        let second_root_url = url("https://app.example.test/second.mjs");
        let dependency_url = url("https://app.example.test/shared.mjs");
        let dependency_key = ModuleMapKey::java_script(dependency_url.clone());
        let source = ModuleSource::text("import './shared.mjs';".to_owned());

        let first_job = module_script_graph_job_for_owner(
            &mut vm,
            source.clone(),
            &first_root_url,
            &initiator_url,
            &ScriptFetchMetadata::default(),
            false,
            ModuleScriptCompletionOwner::Runtime,
        )
        .expect("first runtime module graph should build");
        let first_fetch = expect_single_fetch(
            advance_module_script_graph(&mut vm, first_job)
                .expect("first runtime module graph should reserve the dependency fetch"),
            "first runtime module graph dependency",
        );

        let second_job = module_script_graph_job_for_owner(
            &mut vm,
            source,
            &second_root_url,
            &initiator_url,
            &ScriptFetchMetadata::default(),
            false,
            ModuleScriptCompletionOwner::Runtime,
        )
        .expect("second runtime module graph should build");
        let _second_job = expect_single_joined_wait(
            advance_module_script_graph(&mut vm, second_job)
                .expect("second runtime module graph should join the dependency fetch"),
            "second runtime module graph dependency",
        );

        let fetch_error = ModuleLoadError::new(ModuleLoadStage::Fetch, "shared fetch failed");
        let error = match first_fetch.finish_source_for_test(&mut vm, Err(fetch_error.clone())) {
            Ok(_) => panic!("the owning runtime module graph should fail"),
            Err(error) => error,
        };
        assert_eq!(error, fetch_error);

        let dependency_entry = vm
            .document_runtime
            .native_module_entry_id(&dependency_key)
            .expect("failed dependency should remain in the module map");
        assert_eq!(
            vm.document_runtime
                .native_module_entry_state(dependency_entry),
            ModuleMapEntryState::Failed,
            "the fetch owner must settle the shared module map entry before its graph fails"
        );

        let event = vm
            .document_runtime
            .take_next_native_module_owner_event()
            .expect("the joined graph should receive a terminal module map notification");
        let super::super::NativeModuleOwnerEvent::ModuleMapTerminalNotification(notification) =
            event
        else {
            panic!("joined module graph should receive a module map terminal notification");
        };
        let (key, clients, successful) = notification.into_parts();
        let (single_module_clients, parser_root_module_clients, modulepreload_link_clients) =
            clients.into_parts();
        assert_eq!(key, dependency_key);
        assert!(!successful);
        assert_eq!(single_module_clients.len(), 1);
        assert!(parser_root_module_clients.is_empty());
        assert!(modulepreload_link_clients.is_empty());
    }

    #[test]
    fn parser_graph_observes_sticky_modulepreload_failure_without_refetching() {
        let mut vm = new_test_vm("https://app.example.test/page");
        let root_url = url("https://app.example.test/root.mjs");
        let root_key = ModuleMapKey::java_script(root_url.clone());
        let load_id = suspend_registered_modulepreload_fetch(
            &mut vm,
            modulepreload_single_fetch_request(root_url.clone()),
        );

        vm.complete_native_module_graph_fetch(ModuleGraphFetchCompletion {
            load_id,
            requester: ModuleGraphFetchRequester::ModulePreload,
            ordering: ModuleGraphFetchOrdering::BackgroundPreload,
            request_url: root_url.clone(),
            result: Err("network failure".to_owned()),
            network_result: None,
        })
        .expect("modulepreload failure completion should be accepted");
        let entry_id = vm
            .document_runtime
            .native_module_entry_id(&root_key)
            .expect("failed modulepreload should leave sticky module map entry");
        assert_eq!(
            vm.document_runtime.native_module_entry_state(entry_id),
            ModuleMapEntryState::Failed
        );

        let parser_job = parser_owned_external_module_script_graph_job(
            &mut vm,
            &root_url,
            &url("https://app.example.test/page"),
            &ScriptFetchMetadata::default(),
        );
        let error = match advance_module_script_graph(&mut vm, parser_job) {
            Ok(ModuleScriptGraphAdvance::Complete(_)) => {
                panic!("parser graph should not complete after root failure")
            }
            Ok(ModuleScriptGraphAdvance::NeedFetches(_)) => {
                panic!("parser graph should not batch fetch after root failure")
            }
            Err(error) => error,
        };
        assert!(
            error.message().contains("network failure"),
            "parser graph should receive the sticky modulepreload failure, got: {}",
            error.message()
        );
        assert_eq!(
            vm.document_runtime.native_module_entry_state(entry_id),
            ModuleMapEntryState::Failed,
            "failed module entry must not be reset to a new fetch"
        );
    }
}