Skip to content

armgit / moli

Public Imported from GitHub
0

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

44.9 KB
Raw Blame
use std::collections::{HashMap, HashSet, VecDeque};
use std::fmt;

use moli_module_script_tree as module_tree;
use url::Url;

use crate::{
    document_runtime::DomHandle,
    frame_owner_model::{
        FrameDocumentModuleFetchClientStart, FrameDocumentTaskOwner, FrameRealmId,
    },
    native_bridge::{
        OwnerDispatchScope, WindowExecutionContextIdentity, WindowExecutionContextOwner,
    },
    planning::ScriptFetchMetadata,
};

use super::{
    ModuleAttributesKey, ModuleEntryId, ModuleGraphFetchedSource, ModuleImportPhase, ModuleKind,
    ModuleLoadError, ModuleMapKey, NativeDynamicModuleImportReady, NativeModuleGraphFetchRequest,
    NativeModuleGraphJob, NativeModuleGraphJobAdvance, NativeModuleTreeDocumentOwnerAdapter,
};

#[cfg(test)]
use crate::native_bridge::{RuntimeObservableContextToken, WindowExecutionContextAccessPolicy};

pub(crate) struct PendingDynamicModuleImport {
    context: v8::Global<v8::Context>,
    resolver: v8::Global<v8::PromiseResolver>,
    owner: DynamicModuleImportOwner,
    specifier: String,
    base_url: Url,
    resolved_url: Option<Url>,
    attributes: ModuleAttributesKey,
    phase: ModuleImportPhase,
    fetch_metadata: ScriptFetchMetadata,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum DynamicModuleImportDocumentSnapshot {
    Main(FrameDocumentTaskOwner),
    Child {
        child_handle: DomHandle,
        task_owner: FrameDocumentTaskOwner,
        realm_id: FrameRealmId,
    },
}

/// Captures both the document fetch snapshot and the ScriptState-like owner of
/// a dynamic import promise. `document.open()` replaces the former while
/// preserving the latter; navigation retires the execution context itself.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) struct DynamicModuleImportOwner {
    document: DynamicModuleImportDocumentSnapshot,
    execution_context: WindowExecutionContextIdentity,
}

pub(crate) struct PendingDynamicModuleEvaluationReaction {
    request: PendingDynamicModuleImport,
    target: DynamicModuleEvaluationTarget,
}

pub(crate) struct DynamicModuleEvaluationTarget {
    root_entry: ModuleEntryId,
    module: v8::Global<v8::Module>,
}

#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub(crate) struct DynamicModuleExecutionContextRetirement {
    pending_import_count: usize,
    pending_tree_count: usize,
    inflight_fetch_count: usize,
    joined_fetch_count: usize,
    pending_reaction_count: usize,
}

#[derive(Default)]
pub(crate) struct DynamicModuleResolver {
    pending_imports: VecDeque<NativeModuleGraphJob>,
    inflight_fetches: HashMap<u64, DynamicModulePendingTreeId>,
    joined_fetches: HashMap<module_tree::SingleModuleClientToken, DynamicModulePendingTreeId>,
    pending_trees: HashMap<DynamicModulePendingTreeId, DynamicModulePendingTree>,
    pending_reactions: HashMap<u64, PendingDynamicModuleEvaluationReaction>,
    next_reaction_id: u64,
    next_pending_tree_id: u64,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct DynamicModulePendingTreeId(u64);

pub(crate) struct DynamicModuleInflightFetch {
    resume: DynamicModuleFetchResume,
    request: NativeModuleGraphFetchRequest,
    owner_module_fetch_start: Option<FrameDocumentModuleFetchClientStart>,
}

struct DynamicModulePendingTree {
    owner: DynamicModuleImportOwner,
    load_ids: Vec<u64>,
    joined_clients: Vec<module_tree::SingleModuleClientToken>,
    requests: HashMap<u64, NativeModuleGraphFetchRequest>,
    owner_module_fetch_starts: HashMap<u64, FrameDocumentModuleFetchClientStart>,
    job: Option<NativeModuleGraphJob>,
}

pub(crate) struct DynamicModuleJoinedFetch {
    resume: DynamicModuleFetchResume,
    client: module_tree::SingleModuleClientToken,
}

pub(in crate::module_runtime) struct DynamicModuleFetchResume {
    tree_id: DynamicModulePendingTreeId,
    active_joined_client: Option<module_tree::SingleModuleClientToken>,
    job: NativeModuleGraphJob,
}

pub(crate) struct DynamicModuleFetchContinuation {
    resume: DynamicModuleFetchResume,
    advance: NativeModuleGraphJobAdvance,
}

pub(crate) struct DynamicModuleFetchFailure {
    resume: DynamicModuleFetchResume,
    error: ModuleLoadError,
}

#[derive(Clone)]
pub(crate) struct DynamicModuleScheduledFetch {
    load_id: u64,
    request: NativeModuleGraphFetchRequest,
    owner_module_fetch_start: Option<FrameDocumentModuleFetchClientStart>,
}

pub(crate) enum DynamicModuleFetchFinish {
    Advanced(DynamicModuleFetchContinuation),
    Failed(DynamicModuleFetchFailure),
}

pub(crate) enum DynamicModuleFetchOwnerAdvance {
    Waiting {
        scheduled_fetches: Vec<DynamicModuleScheduledFetch>,
    },
    Ready(Box<NativeDynamicModuleImportReady>),
    RestoredAfterUnexpectedComplete,
}

impl DynamicModuleScheduledFetch {
    pub(crate) fn new(
        load_id: u64,
        request: NativeModuleGraphFetchRequest,
        owner_module_fetch_start: Option<FrameDocumentModuleFetchClientStart>,
    ) -> Self {
        Self {
            load_id,
            request,
            owner_module_fetch_start,
        }
    }

    pub(crate) fn load_id(&self) -> u64 {
        self.load_id
    }

    pub(crate) fn owner_module_fetch_start(&self) -> Option<&FrameDocumentModuleFetchClientStart> {
        self.owner_module_fetch_start.as_ref()
    }

    pub(crate) fn into_parts(
        self,
    ) -> (
        u64,
        NativeModuleGraphFetchRequest,
        Option<FrameDocumentModuleFetchClientStart>,
    ) {
        (self.load_id, self.request, self.owner_module_fetch_start)
    }
}

impl PendingDynamicModuleImport {
    pub(crate) fn new(
        context: v8::Global<v8::Context>,
        resolver: v8::Global<v8::PromiseResolver>,
        owner: DynamicModuleImportOwner,
        specifier: impl Into<String>,
        base_url: Url,
        attributes: ModuleAttributesKey,
        phase: ModuleImportPhase,
    ) -> Self {
        Self {
            context,
            resolver,
            owner,
            specifier: specifier.into(),
            base_url,
            resolved_url: None,
            attributes,
            phase,
            fetch_metadata: ScriptFetchMetadata::default(),
        }
    }

    pub(crate) fn with_referrer_fetch_metadata(mut self, metadata: ScriptFetchMetadata) -> Self {
        self.fetch_metadata = metadata;
        self
    }

    pub(crate) fn with_resolved_url(mut self, resolved_url: Url) -> Self {
        self.resolved_url = Some(resolved_url);
        self
    }

    pub(crate) fn context(&self) -> &v8::Global<v8::Context> {
        &self.context
    }

    pub(crate) fn resolver(&self) -> &v8::Global<v8::PromiseResolver> {
        &self.resolver
    }

    pub(crate) fn owner(&self) -> DynamicModuleImportOwner {
        self.owner
    }

    pub(crate) fn specifier(&self) -> &str {
        &self.specifier
    }

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

    pub(crate) fn resolved_url(&self) -> Option<&Url> {
        self.resolved_url.as_ref()
    }

    pub(crate) fn attributes(&self) -> &ModuleAttributesKey {
        &self.attributes
    }

    pub(crate) fn phase(&self) -> ModuleImportPhase {
        self.phase
    }

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

    pub(crate) fn child_browsing_context_handle(&self) -> Option<DomHandle> {
        self.owner.child_handle()
    }
}

impl DynamicModuleImportOwner {
    pub(crate) fn main(
        task_owner: FrameDocumentTaskOwner,
        execution_context: WindowExecutionContextIdentity,
    ) -> Self {
        debug_assert_eq!(
            execution_context.owner(),
            WindowExecutionContextOwner::Frame(task_owner.local_window_id)
        );
        debug_assert_eq!(execution_context.dispatch_scope(), OwnerDispatchScope::Top);
        Self {
            document: DynamicModuleImportDocumentSnapshot::Main(task_owner),
            execution_context,
        }
    }

    pub(crate) fn child(
        child_handle: DomHandle,
        task_owner: FrameDocumentTaskOwner,
        realm_id: FrameRealmId,
        execution_context: WindowExecutionContextIdentity,
    ) -> Self {
        debug_assert_eq!(
            execution_context.owner(),
            WindowExecutionContextOwner::Frame(task_owner.local_window_id)
        );
        debug_assert_eq!(
            execution_context.dispatch_scope(),
            OwnerDispatchScope::Child(child_handle)
        );
        Self {
            document: DynamicModuleImportDocumentSnapshot::Child {
                child_handle,
                task_owner,
                realm_id,
            },
            execution_context,
        }
    }

    #[cfg(test)]
    pub(crate) fn main_for_test() -> Self {
        Self::main_for_test_parts(1, 2, 3)
    }

    #[cfg(test)]
    pub(crate) fn main_for_test_parts(
        scheduler_lane_id: u64,
        local_window_id: u64,
        document_id: u64,
    ) -> Self {
        use crate::frame_owner_model::{DocumentId, FrameSchedulerLaneId, LocalWindowId};

        let task_owner = FrameDocumentTaskOwner::new(
            FrameSchedulerLaneId(scheduler_lane_id),
            LocalWindowId(local_window_id),
            DocumentId(document_id),
        );
        Self::main(
            task_owner,
            WindowExecutionContextIdentity::new(
                WindowExecutionContextOwner::Frame(task_owner.local_window_id),
                OwnerDispatchScope::Top,
                RuntimeObservableContextToken::from_raw(local_window_id),
                WindowExecutionContextAccessPolicy::EnforceWebOrigin,
            ),
        )
    }

    pub(crate) fn child_handle(self) -> Option<DomHandle> {
        match self.document {
            DynamicModuleImportDocumentSnapshot::Main(_) => None,
            DynamicModuleImportDocumentSnapshot::Child { child_handle, .. } => Some(child_handle),
        }
    }

    pub(crate) fn child_parts(self) -> Option<(DomHandle, FrameDocumentTaskOwner, FrameRealmId)> {
        match self.document {
            DynamicModuleImportDocumentSnapshot::Main(_) => None,
            DynamicModuleImportDocumentSnapshot::Child {
                child_handle,
                task_owner,
                realm_id,
            } => Some((child_handle, task_owner, realm_id)),
        }
    }

    pub(crate) fn task_owner(self) -> FrameDocumentTaskOwner {
        match self.document {
            DynamicModuleImportDocumentSnapshot::Main(owner)
            | DynamicModuleImportDocumentSnapshot::Child {
                task_owner: owner, ..
            } => owner,
        }
    }

    pub(crate) fn execution_context(self) -> WindowExecutionContextIdentity {
        self.execution_context
    }

    pub(crate) fn execution_context_owner(self) -> WindowExecutionContextOwner {
        self.execution_context.owner()
    }
}

impl DynamicModuleExecutionContextRetirement {
    pub(crate) fn retired_anything(self) -> bool {
        self != Self::default()
    }

    pub(crate) fn pending_import_count(self) -> usize {
        self.pending_import_count
    }

    pub(crate) fn pending_tree_count(self) -> usize {
        self.pending_tree_count
    }

    pub(crate) fn inflight_fetch_count(self) -> usize {
        self.inflight_fetch_count
    }

    pub(crate) fn joined_fetch_count(self) -> usize {
        self.joined_fetch_count
    }

    pub(crate) fn pending_reaction_count(self) -> usize {
        self.pending_reaction_count
    }
}

impl fmt::Debug for PendingDynamicModuleImport {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("PendingDynamicModuleImport")
            .field("owner", &self.owner)
            .field("specifier", &self.specifier)
            .field("base_url", &self.base_url)
            .field("attributes", &self.attributes)
            .field("phase", &self.phase)
            .field("fetch_metadata", &self.fetch_metadata)
            .finish_non_exhaustive()
    }
}

impl PendingDynamicModuleEvaluationReaction {
    pub(crate) fn new(
        request: PendingDynamicModuleImport,
        target: DynamicModuleEvaluationTarget,
    ) -> Self {
        Self { request, target }
    }

    pub(crate) fn into_parts(self) -> (PendingDynamicModuleImport, DynamicModuleEvaluationTarget) {
        (self.request, self.target)
    }

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

impl DynamicModuleEvaluationTarget {
    pub(crate) fn new(root_entry: ModuleEntryId, module: v8::Global<v8::Module>) -> Self {
        Self { root_entry, module }
    }

    pub(crate) fn root_entry(&self) -> ModuleEntryId {
        self.root_entry
    }

    pub(crate) fn module(&self) -> &v8::Global<v8::Module> {
        &self.module
    }
}

impl fmt::Debug for PendingDynamicModuleEvaluationReaction {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("PendingDynamicModuleEvaluationReaction")
            .field("request", &self.request)
            .field("target", &self.target)
            .finish_non_exhaustive()
    }
}

impl fmt::Debug for DynamicModuleEvaluationTarget {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("DynamicModuleEvaluationTarget")
            .field("root_entry", &self.root_entry)
            .finish_non_exhaustive()
    }
}

impl fmt::Debug for DynamicModuleResolver {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("DynamicModuleResolver")
            .field("pending_import_count", &self.pending_imports.len())
            .field("inflight_fetch_count", &self.inflight_fetches.len())
            .field("joined_fetch_count", &self.joined_fetches.len())
            .field("pending_tree_count", &self.pending_trees.len())
            .field("pending_reaction_count", &self.pending_reactions.len())
            .finish()
    }
}

impl DynamicModuleInflightFetch {
    pub(crate) fn owner(&self) -> DynamicModuleImportOwner {
        self.resume
            .job
            .dynamic_import_request()
            .expect("dynamic module fetch resume must retain its import request")
            .owner()
    }

    pub(crate) fn import_base_url(&self) -> &Url {
        self.resume
            .job
            .dynamic_import_request()
            .expect("dynamic module fetch resume must retain its import request")
            .base_url()
    }

    pub(crate) fn owner_module_fetch_start(&self) -> Option<&FrameDocumentModuleFetchClientStart> {
        self.owner_module_fetch_start.as_ref()
    }

    pub(crate) fn finish_for_owner(
        mut self,
        vm: &mut crate::script_vm::ScriptVm,
        source: std::result::Result<ModuleGraphFetchedSource, ModuleLoadError>,
    ) -> DynamicModuleFetchFinish {
        match self
            .resume
            .job
            .finish_dynamic_import_fetch_for_request(vm, &self.request, source)
        {
            Ok(advance) => DynamicModuleFetchFinish::Advanced(DynamicModuleFetchContinuation::new(
                self.resume,
                advance,
            )),
            Err(error) => {
                DynamicModuleFetchFinish::Failed(DynamicModuleFetchFailure::new(self.resume, error))
            }
        }
    }

    pub(crate) fn finish_with_owner_adapter<O>(
        mut self,
        owner: &mut O,
        source: std::result::Result<ModuleGraphFetchedSource, ModuleLoadError>,
    ) -> DynamicModuleFetchFinish
    where
        O: NativeModuleTreeDocumentOwnerAdapter,
    {
        match self
            .resume
            .job
            .finish_dynamic_import_fetch_for_request_with_owner(owner, &self.request, source)
        {
            Ok(advance) => DynamicModuleFetchFinish::Advanced(DynamicModuleFetchContinuation::new(
                self.resume,
                advance,
            )),
            Err(error) => {
                DynamicModuleFetchFinish::Failed(DynamicModuleFetchFailure::new(self.resume, error))
            }
        }
    }

    pub(crate) fn into_failure(self, error: ModuleLoadError) -> DynamicModuleFetchFinish {
        DynamicModuleFetchFinish::Failed(DynamicModuleFetchFailure::new(self.resume, error))
    }

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

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

    #[cfg(test)]
    pub(crate) fn request_for_test(&self) -> &NativeModuleGraphFetchRequest {
        &self.request
    }

    #[cfg(test)]
    pub(crate) fn finish_with_advance_for_test(
        self,
        advance: NativeModuleGraphJobAdvance,
    ) -> DynamicModuleFetchContinuation {
        DynamicModuleFetchContinuation::new(self.resume, advance)
    }

    #[cfg(test)]
    fn into_raw(self) -> (DynamicModuleFetchResume, NativeModuleGraphFetchRequest) {
        (self.resume, self.request)
    }
}

impl DynamicModuleJoinedFetch {
    pub(crate) fn owner(&self) -> DynamicModuleImportOwner {
        self.resume
            .job
            .dynamic_import_request()
            .expect("joined dynamic module fetch must retain its import request")
            .owner()
    }

    pub(crate) fn import_base_url(&self) -> &Url {
        self.resume
            .job
            .dynamic_import_request()
            .expect("joined dynamic module fetch resume must retain its import request")
            .base_url()
    }

    pub(crate) fn client(&self) -> module_tree::SingleModuleClientToken {
        self.client
    }

    pub(crate) fn finish_for_owner(
        mut self,
        vm: &mut crate::script_vm::ScriptVm,
        key: &ModuleMapKey,
    ) -> DynamicModuleFetchFinish {
        match self.resume.job.finish_joined_module_map_fetch(
            vm,
            chromium_module_key(key),
            self.client,
        ) {
            Ok(advance) => DynamicModuleFetchFinish::Advanced(DynamicModuleFetchContinuation::new(
                self.resume,
                advance,
            )),
            Err(error) => {
                DynamicModuleFetchFinish::Failed(DynamicModuleFetchFailure::new(self.resume, error))
            }
        }
    }

    pub(crate) fn finish_with_owner_adapter<O>(
        mut self,
        owner: &mut O,
        key: &ModuleMapKey,
    ) -> DynamicModuleFetchFinish
    where
        O: NativeModuleTreeDocumentOwnerAdapter,
    {
        match self.resume.job.finish_joined_module_map_fetch_with_owner(
            owner,
            chromium_module_key(key),
            self.client,
        ) {
            Ok(advance) => DynamicModuleFetchFinish::Advanced(DynamicModuleFetchContinuation::new(
                self.resume,
                advance,
            )),
            Err(error) => {
                DynamicModuleFetchFinish::Failed(DynamicModuleFetchFailure::new(self.resume, error))
            }
        }
    }

    pub(crate) fn into_failure(self, error: ModuleLoadError) -> DynamicModuleFetchFinish {
        DynamicModuleFetchFinish::Failed(DynamicModuleFetchFailure::new(self.resume, error))
    }

    #[cfg(test)]
    pub(crate) fn into_failure_for_test(self, error: ModuleLoadError) -> DynamicModuleFetchFailure {
        DynamicModuleFetchFailure::new(self.resume, error)
    }

    #[cfg(test)]
    fn into_raw(
        self,
    ) -> (
        DynamicModuleFetchResume,
        module_tree::SingleModuleClientToken,
    ) {
        (self.resume, self.client)
    }
}

impl DynamicModuleFetchContinuation {
    fn new(resume: DynamicModuleFetchResume, advance: NativeModuleGraphJobAdvance) -> Self {
        Self { resume, advance }
    }

    pub(in crate::module_runtime) fn into_parts(
        self,
    ) -> (DynamicModuleFetchResume, NativeModuleGraphJobAdvance) {
        (self.resume, self.advance)
    }

    pub(crate) fn job(&self) -> &NativeModuleGraphJob {
        &self.resume.job
    }

    pub(crate) fn pending_fetch_requests(&self) -> Option<&[NativeModuleGraphFetchRequest]> {
        match &self.advance {
            NativeModuleGraphJobAdvance::NeedFetches(requests) => Some(requests),
            NativeModuleGraphJobAdvance::WaitingForFetches
            | NativeModuleGraphJobAdvance::Complete(_) => None,
        }
    }
}

impl DynamicModuleFetchFailure {
    fn new(resume: DynamicModuleFetchResume, error: ModuleLoadError) -> Self {
        Self { resume, error }
    }

    #[cfg(test)]
    pub(crate) fn for_test(request: PendingDynamicModuleImport, error: ModuleLoadError) -> Self {
        Self::new(
            DynamicModuleFetchResume {
                tree_id: DynamicModulePendingTreeId(0),
                active_joined_client: None,
                job: NativeModuleGraphJob::dynamic_import(request),
            },
            error,
        )
    }

    pub(in crate::module_runtime) fn into_parts(
        self,
    ) -> (DynamicModuleFetchResume, ModuleLoadError) {
        (self.resume, self.error)
    }
}

impl DynamicModuleFetchResume {
    pub(in crate::module_runtime) fn take_pending_joined_clients(
        &mut self,
    ) -> Vec<module_tree::SingleModuleClientToken> {
        self.job.take_pending_joined_clients()
    }

    pub(in crate::module_runtime) fn into_job(self) -> NativeModuleGraphJob {
        self.job
    }
}

fn chromium_module_key(key: &ModuleMapKey) -> module_tree::ModuleMapKey {
    module_tree::ModuleMapKey::new(
        key.url().clone(),
        match key.kind() {
            ModuleKind::JavaScript => module_tree::ModuleKind::JavaScript,
            ModuleKind::Json => module_tree::ModuleKind::Json,
            ModuleKind::Css => module_tree::ModuleKind::Css,
            ModuleKind::ModulePreloadText => module_tree::ModuleKind::JavaScript,
            ModuleKind::WebAssembly => module_tree::ModuleKind::WebAssembly,
        },
        module_tree::ModuleAttributesKey::from_pairs(key.attributes().pairs().to_vec()),
    )
}

impl DynamicModuleResolver {
    pub(crate) fn retire_execution_context_owner(
        &mut self,
        owner: WindowExecutionContextOwner,
    ) -> DynamicModuleExecutionContextRetirement {
        let pending_import_count_before = self.pending_imports.len();
        self.pending_imports.retain(|job| {
            job.dynamic_import_request()
                .is_none_or(|request| request.owner().execution_context_owner() != owner)
        });

        let retired_tree_ids: HashSet<_> = self
            .pending_trees
            .iter()
            .filter_map(|(tree_id, tree)| {
                (tree.owner.execution_context_owner() == owner).then_some(*tree_id)
            })
            .collect();
        for tree_id in &retired_tree_ids {
            self.pending_trees.remove(tree_id);
        }

        let inflight_fetch_count_before = self.inflight_fetches.len();
        self.inflight_fetches
            .retain(|_, tree_id| !retired_tree_ids.contains(tree_id));
        let joined_fetch_count_before = self.joined_fetches.len();
        self.joined_fetches
            .retain(|_, tree_id| !retired_tree_ids.contains(tree_id));

        let pending_reaction_count_before = self.pending_reactions.len();
        self.pending_reactions
            .retain(|_, reaction| reaction.owner().execution_context_owner() != owner);

        DynamicModuleExecutionContextRetirement {
            pending_import_count: pending_import_count_before - self.pending_imports.len(),
            pending_tree_count: retired_tree_ids.len(),
            inflight_fetch_count: inflight_fetch_count_before - self.inflight_fetches.len(),
            joined_fetch_count: joined_fetch_count_before - self.joined_fetches.len(),
            pending_reaction_count: pending_reaction_count_before - self.pending_reactions.len(),
        }
    }

    pub(crate) fn queue_import(&mut self, request: PendingDynamicModuleImport) {
        self.pending_imports
            .push_back(NativeModuleGraphJob::dynamic_import(request));
    }

    pub(crate) fn take_next_import(&mut self) -> Option<NativeModuleGraphJob> {
        self.pending_imports.pop_front()
    }

    pub(crate) fn resume_import_front(&mut self, job: NativeModuleGraphJob) {
        self.pending_imports.push_front(job);
    }

    pub(crate) fn reserve_evaluation_reaction(
        &mut self,
        request: PendingDynamicModuleImport,
        target: DynamicModuleEvaluationTarget,
    ) -> u64 {
        let reaction_id = self.next_reaction_id;
        self.next_reaction_id = self.next_reaction_id.wrapping_add(1);
        self.pending_reactions.insert(
            reaction_id,
            PendingDynamicModuleEvaluationReaction::new(request, target),
        );
        reaction_id
    }

    pub(crate) fn evaluation_reaction_owner(
        &self,
        reaction_id: u64,
    ) -> Option<DynamicModuleImportOwner> {
        self.pending_reactions
            .get(&reaction_id)
            .map(PendingDynamicModuleEvaluationReaction::owner)
    }

    pub(crate) fn take_evaluation_reaction(
        &mut self,
        reaction_id: u64,
        expected_owner: DynamicModuleImportOwner,
    ) -> Option<PendingDynamicModuleEvaluationReaction> {
        if self.evaluation_reaction_owner(reaction_id) != Some(expected_owner) {
            return None;
        }
        self.pending_reactions.remove(&reaction_id)
    }

    pub(crate) fn suspend_fetches(
        &mut self,
        fetches: Vec<(u64, NativeModuleGraphFetchRequest)>,
        joined_clients: Vec<module_tree::SingleModuleClientToken>,
        job: NativeModuleGraphJob,
        owner_module_fetch_starts: Vec<(u64, FrameDocumentModuleFetchClientStart)>,
    ) {
        if fetches.is_empty() && joined_clients.is_empty() {
            self.resume_import_front(job);
            return;
        }
        let owner = job
            .dynamic_import_request()
            .expect("dynamic module pending tree must retain its import request")
            .owner();
        let tree_id = DynamicModulePendingTreeId(self.next_pending_tree_id);
        self.next_pending_tree_id = self.next_pending_tree_id.wrapping_add(1);
        let mut load_ids = Vec::with_capacity(fetches.len());
        let mut requests = HashMap::with_capacity(fetches.len());
        for (load_id, request) in fetches {
            self.inflight_fetches.insert(load_id, tree_id);
            load_ids.push(load_id);
            requests.insert(load_id, request);
        }
        for client in &joined_clients {
            self.joined_fetches.insert(*client, tree_id);
        }
        let owner_module_fetch_starts = owner_module_fetch_starts.into_iter().collect();
        self.pending_trees.insert(
            tree_id,
            DynamicModulePendingTree {
                owner,
                load_ids,
                joined_clients,
                requests,
                owner_module_fetch_starts,
                job: Some(job),
            },
        );
    }

    pub(crate) fn take_inflight_fetch(
        &mut self,
        load_id: u64,
    ) -> Option<DynamicModuleInflightFetch> {
        let tree_id = self.inflight_fetches.remove(&load_id)?;
        let (request, owner_module_fetch_start, job) = {
            let pending_tree = self.pending_trees.get_mut(&tree_id)?;
            pending_tree
                .load_ids
                .retain(|pending_load_id| *pending_load_id != load_id);
            let request = pending_tree.requests.remove(&load_id)?;
            let owner_module_fetch_start = pending_tree.owner_module_fetch_starts.remove(&load_id);
            let job = pending_tree.job.take()?;
            (request, owner_module_fetch_start, job)
        };
        if self.pending_tree_waits_are_empty(tree_id) {
            self.pending_trees.remove(&tree_id);
        }
        Some(DynamicModuleInflightFetch {
            resume: DynamicModuleFetchResume {
                tree_id,
                active_joined_client: None,
                job,
            },
            request,
            owner_module_fetch_start,
        })
    }

    /// Returns the exact import owner captured by the pending tree that owns
    /// `load_id` without claiming or advancing the fetch.
    ///
    /// Network scheduling uses this projection immediately after suspension to
    /// stamp the stable Page task. Keeping the lookup in the resolver avoids a
    /// second `load_id -> owner` registry in the transport layer.
    pub(crate) fn inflight_fetch_owner(&self, load_id: u64) -> Option<DynamicModuleImportOwner> {
        let tree_id = self.inflight_fetches.get(&load_id)?;
        self.pending_trees.get(tree_id).map(|tree| tree.owner)
    }

    pub(crate) fn take_joined_fetch(
        &mut self,
        client: module_tree::SingleModuleClientToken,
    ) -> Option<DynamicModuleJoinedFetch> {
        let tree_id = self.joined_fetches.remove(&client)?;
        let job = {
            let pending_tree = self.pending_trees.get_mut(&tree_id)?;
            pending_tree
                .joined_clients
                .retain(|pending_client| *pending_client != client);
            pending_tree.job.take()?
        };
        if self.pending_tree_waits_are_empty(tree_id) {
            self.pending_trees.remove(&tree_id);
        }
        Some(DynamicModuleJoinedFetch {
            resume: DynamicModuleFetchResume {
                tree_id,
                active_joined_client: Some(client),
                job,
            },
            client,
        })
    }

    pub(crate) fn restore_inflight_fetch_as_joined_owner_module_client(
        &mut self,
        inflight: DynamicModuleInflightFetch,
    ) -> Option<module_tree::SingleModuleClientToken> {
        let DynamicModuleInflightFetch {
            resume, request, ..
        } = inflight;
        let client = request.tree_client()?;
        let tree_id = resume.tree_id;
        let job = resume.job;
        self.joined_fetches.insert(client, tree_id);
        if let Some(pending_tree) = self.pending_trees.get_mut(&tree_id) {
            pending_tree.joined_clients.push(client);
            debug_assert!(pending_tree.job.is_none());
            pending_tree.job = Some(job);
        } else {
            let owner = job
                .dynamic_import_request()
                .expect("restored dynamic module tree must retain its import request")
                .owner();
            self.pending_trees.insert(
                tree_id,
                DynamicModulePendingTree {
                    owner,
                    load_ids: Vec::new(),
                    joined_clients: vec![client],
                    requests: HashMap::new(),
                    owner_module_fetch_starts: HashMap::new(),
                    job: Some(job),
                },
            );
        }
        Some(client)
    }

    pub(in crate::module_runtime) fn restore_fetch_resume(
        &mut self,
        resume: DynamicModuleFetchResume,
    ) {
        let tree_id = resume.tree_id;
        let job = resume.job;
        let Some(pending_tree) = self.pending_trees.get_mut(&tree_id) else {
            self.resume_import_front(job);
            return;
        };
        debug_assert!(pending_tree.job.is_none());
        pending_tree.job = Some(job);
    }

    pub(in crate::module_runtime) fn extend_pending_tree(
        &mut self,
        resume: DynamicModuleFetchResume,
        fetches: Vec<(u64, NativeModuleGraphFetchRequest)>,
        joined_clients: Vec<module_tree::SingleModuleClientToken>,
        owner_module_fetch_starts: Vec<(u64, FrameDocumentModuleFetchClientStart)>,
    ) {
        let tree_id = resume.tree_id;
        let job = resume.job;
        let Some(pending_tree) = self.pending_trees.get_mut(&tree_id) else {
            self.suspend_fetches(fetches, joined_clients, job, owner_module_fetch_starts);
            return;
        };
        for (load_id, request) in fetches {
            self.inflight_fetches.insert(load_id, tree_id);
            pending_tree.load_ids.push(load_id);
            pending_tree.requests.insert(load_id, request);
        }
        for (load_id, owner_start) in owner_module_fetch_starts {
            pending_tree
                .owner_module_fetch_starts
                .insert(load_id, owner_start);
        }
        for client in joined_clients {
            self.joined_fetches.insert(client, tree_id);
            pending_tree.joined_clients.push(client);
        }
        debug_assert!(pending_tree.job.is_none());
        pending_tree.job = Some(job);
    }

    pub(in crate::module_runtime) fn clear_fetch_resume(
        &mut self,
        resume: DynamicModuleFetchResume,
    ) -> (
        Vec<module_tree::SingleModuleClientToken>,
        NativeModuleGraphJob,
    ) {
        let DynamicModuleFetchResume {
            tree_id,
            active_joined_client,
            job,
            ..
        } = resume;
        let Some(mut pending_tree) = self.pending_trees.remove(&tree_id) else {
            return (active_joined_client.into_iter().collect(), job);
        };
        for load_id in pending_tree.load_ids {
            self.inflight_fetches.remove(&load_id);
            pending_tree.owner_module_fetch_starts.remove(&load_id);
        }
        for client in &pending_tree.joined_clients {
            self.joined_fetches.remove(client);
        }
        let mut joined_clients = pending_tree.joined_clients;
        if let Some(active_joined_client) = active_joined_client {
            joined_clients.push(active_joined_client);
        }
        (joined_clients, job)
    }

    pub(in crate::module_runtime) fn fetch_resume_has_pending_waits(
        &self,
        resume: &DynamicModuleFetchResume,
    ) -> bool {
        self.pending_trees
            .get(&resume.tree_id)
            .map(|pending_tree| {
                !pending_tree.load_ids.is_empty() || !pending_tree.joined_clients.is_empty()
            })
            .unwrap_or(false)
    }

    fn pending_tree_waits_are_empty(&self, tree_id: DynamicModulePendingTreeId) -> bool {
        self.pending_trees
            .get(&tree_id)
            .map(|pending_tree| {
                pending_tree.load_ids.is_empty() && pending_tree.joined_clients.is_empty()
            })
            .unwrap_or(true)
    }

    pub(crate) fn has_pending_import(&self) -> bool {
        !self.pending_imports.is_empty()
            || !self.inflight_fetches.is_empty()
            || !self.joined_fetches.is_empty()
    }

    pub(crate) fn has_ready_import(&self) -> bool {
        !self.pending_imports.is_empty()
    }

    #[cfg(test)]
    pub(crate) fn has_inflight_fetch(&self) -> bool {
        !self.inflight_fetches.is_empty() || !self.joined_fetches.is_empty()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::frame_owner_model::{DocumentId, FrameSchedulerLaneId, LocalWindowId};
    use crate::module_runtime::{ModuleFetchMetadata, ModuleKind};

    fn dynamic_import_request() -> PendingDynamicModuleImport {
        dynamic_import_request_for_owner(DynamicModuleImportOwner::main_for_test())
    }

    fn dynamic_import_request_for_owner(
        owner: DynamicModuleImportOwner,
    ) -> PendingDynamicModuleImport {
        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");
        PendingDynamicModuleImport::new(
            v8::Global::new(scope, scope.get_current_context()),
            v8::Global::new(scope, resolver),
            owner,
            "./dep.mjs",
            Url::parse("https://app.example.test/page").expect("base URL should parse"),
            ModuleAttributesKey::empty(),
            ModuleImportPhase::Evaluation,
        )
    }

    fn test_main_owner(local_window_id: u64, document_id: u64) -> FrameDocumentTaskOwner {
        FrameDocumentTaskOwner::new(
            FrameSchedulerLaneId(1),
            LocalWindowId(local_window_id),
            DocumentId(document_id),
        )
    }

    fn test_dynamic_import_owner(
        local_window_id: u64,
        document_id: u64,
    ) -> DynamicModuleImportOwner {
        let task_owner = test_main_owner(local_window_id, document_id);
        DynamicModuleImportOwner::main(
            task_owner,
            WindowExecutionContextIdentity::new(
                WindowExecutionContextOwner::Frame(task_owner.local_window_id),
                OwnerDispatchScope::Top,
                RuntimeObservableContextToken::from_raw(local_window_id),
                WindowExecutionContextAccessPolicy::EnforceWebOrigin,
            ),
        )
    }

    fn dynamic_fetch_request(path: &str) -> NativeModuleGraphFetchRequest {
        let url = Url::parse(&format!("https://app.example.test/{path}"))
            .expect("fetch URL should parse");
        NativeModuleGraphFetchRequest::new_for_test(
            url.clone(),
            Url::parse("https://app.example.test/page").expect("initiator URL should parse"),
            ModuleFetchMetadata::default(),
            ModuleKind::JavaScript,
        )
    }

    fn joined_fetch_request(sequence: u64) -> module_tree::ModuleFetchRequest {
        let url = Url::parse(&format!("https://app.example.test/joined-{sequence}.mjs"))
            .expect("joined fetch URL should parse");
        module_tree::ModuleFetchRequest {
            key: module_tree::ModuleMapKey::javascript(url.clone()),
            tree_id: module_tree::ModuleTreeId(7),
            client: module_tree::SingleModuleClientToken {
                tree_id: module_tree::ModuleTreeId(7),
                sequence,
            },
            specifier: None,
            source_url: url.clone(),
            base_url: url,
            initiator_url: Url::parse("https://app.example.test/page")
                .expect("initiator URL should parse"),
            referrer: module_tree::ModuleReferrer::client(),
            position: module_tree::TextPosition::default(),
            parent: None,
            kind: module_tree::ModuleKind::JavaScript,
            attributes: module_tree::ModuleAttributesKey::empty(),
            phase: module_tree::ModuleImportPhase::Evaluation,
            graph_level: module_tree::ModuleGraphLevel::Dependent,
            fetch_metadata: module_tree::ModuleFetchMetadata::default(),
            render_blocking: module_tree::RenderBlockingBehavior::NonBlocking,
            requester: module_tree::ModuleFetchRequester::DynamicImport,
            ordering: module_tree::ModuleFetchOrdering::Runtime,
            custom_fetch_type: module_tree::ModuleScriptCustomFetchType::None,
        }
    }

    #[test]
    fn execution_context_retirement_removes_queued_and_suspended_graph_state() {
        let retired_owner = test_dynamic_import_owner(2, 3);
        let retained_same_window_owner = test_dynamic_import_owner(2, 4);
        let retained_owner = test_dynamic_import_owner(5, 6);
        let mut resolver = DynamicModuleResolver::default();

        resolver.queue_import(dynamic_import_request_for_owner(retired_owner));
        let suspended_job = resolver
            .take_next_import()
            .expect("retired owner should provide the suspended graph job");
        let joined_client = joined_fetch_request(90).client;
        resolver.suspend_fetches(
            vec![(11, dynamic_fetch_request("retired.mjs"))],
            vec![joined_client],
            suspended_job,
            Vec::new(),
        );
        resolver.queue_import(dynamic_import_request_for_owner(retired_owner));
        resolver.queue_import(dynamic_import_request_for_owner(retained_same_window_owner));
        resolver.queue_import(dynamic_import_request_for_owner(retained_owner));

        let retirement =
            resolver.retire_execution_context_owner(retired_owner.execution_context_owner());

        assert_eq!(retirement.pending_import_count(), 2);
        assert_eq!(retirement.pending_tree_count(), 1);
        assert_eq!(retirement.inflight_fetch_count(), 1);
        assert_eq!(retirement.joined_fetch_count(), 1);
        assert_eq!(retirement.pending_reaction_count(), 0);
        assert!(retirement.retired_anything());
        assert!(resolver.take_inflight_fetch(11).is_none());
        assert!(resolver.take_joined_fetch(joined_client).is_none());
        let retained_job = resolver
            .take_next_import()
            .expect("replacement owner graph job must remain queued");
        assert_eq!(
            retained_job
                .dynamic_import_request()
                .expect("retained graph job must keep its request")
                .owner(),
            retained_owner
        );
        assert!(resolver.take_next_import().is_none());
    }

    #[test]
    fn inflight_dynamic_import_fetch_is_pending_but_not_ready() {
        let mut resolver = DynamicModuleResolver::default();

        resolver.queue_import(dynamic_import_request());
        assert!(resolver.has_pending_import());
        assert!(resolver.has_ready_import());
        assert!(!resolver.has_inflight_fetch());

        let job = resolver
            .take_next_import()
            .expect("queued dynamic import should be ready");
        resolver.suspend_fetches(
            vec![(11, dynamic_fetch_request("dep.mjs"))],
            Vec::new(),
            job,
            Vec::new(),
        );

        assert!(resolver.has_pending_import());
        assert!(!resolver.has_ready_import());
        assert!(resolver.has_inflight_fetch());

        let inflight = resolver
            .take_inflight_fetch(11)
            .expect("inflight dynamic import should be resumable");
        let (resume, _request) = inflight.into_raw();
        resolver.resume_import_front(resume.into_job());

        assert!(resolver.has_pending_import());
        assert!(resolver.has_ready_import());
        assert!(!resolver.has_inflight_fetch());
    }

    #[test]
    fn dynamic_import_pending_tree_restores_job_until_last_load_finishes() {
        let mut resolver = DynamicModuleResolver::default();
        resolver.queue_import(dynamic_import_request());
        let job = resolver
            .take_next_import()
            .expect("queued dynamic import should be ready");

        resolver.suspend_fetches(
            vec![
                (11, dynamic_fetch_request("a.mjs")),
                (12, dynamic_fetch_request("b.mjs")),
            ],
            Vec::new(),
            job,
            Vec::new(),
        );

        let first = resolver
            .take_inflight_fetch(11)
            .expect("first fetch should take the shared job");
        let (first_resume, _request) = first.into_raw();
        assert!(resolver.fetch_resume_has_pending_waits(&first_resume));
        assert!(resolver.has_inflight_fetch());
        resolver.restore_fetch_resume(first_resume);
        assert!(!resolver.has_ready_import());

        let second = resolver
            .take_inflight_fetch(12)
            .expect("second fetch should recover the restored job");
        let (second_resume, _request) = second.into_raw();
        assert!(!resolver.fetch_resume_has_pending_waits(&second_resume));
        resolver.resume_import_front(second_resume.into_job());

        assert!(resolver.has_ready_import());
        assert!(!resolver.has_inflight_fetch());
    }

    #[test]
    fn joined_dynamic_import_fetch_uses_single_module_client_token() {
        let mut resolver = DynamicModuleResolver::default();
        resolver.queue_import(dynamic_import_request());
        let job = resolver
            .take_next_import()
            .expect("queued dynamic import should be ready");
        let queued_request = joined_fetch_request(90);
        let client = queued_request.client;
        resolver.suspend_fetches(Vec::new(), vec![client], job, Vec::new());

        let joined = resolver
            .take_joined_fetch(client)
            .expect("joined fetch should recover its dynamic import job");
        let (joined_resume, joined_client) = joined.into_raw();

        assert_eq!(joined_client, client);
        assert!(!resolver.fetch_resume_has_pending_waits(&joined_resume));
        assert!(!resolver.has_inflight_fetch());
    }

    #[test]
    fn clear_pending_tree_returns_joined_clients_and_drops_waits() {
        let mut resolver = DynamicModuleResolver::default();
        resolver.queue_import(dynamic_import_request());
        let job = resolver
            .take_next_import()
            .expect("queued dynamic import should be ready");
        let first_join = joined_fetch_request(91);
        let first_client = first_join.client;
        let second_join = joined_fetch_request(92);
        let second_client = second_join.client;
        resolver.suspend_fetches(
            vec![(17, dynamic_fetch_request("clear-group.mjs"))],
            vec![first_client, second_client],
            job,
            Vec::new(),
        );

        let inflight = resolver
            .take_inflight_fetch(17)
            .expect("inflight fetch should recover its dynamic import resume");
        let (resume, _request) = inflight.into_raw();
        let (removed, _job) = resolver.clear_fetch_resume(resume);

        assert_eq!(removed, vec![first_client, second_client]);
        assert!(!resolver.has_inflight_fetch());
        assert!(
            resolver.take_inflight_fetch(17).is_none(),
            "clearing a group should remove its pending load ids"
        );
        assert!(
            resolver
                .take_joined_fetch(joined_fetch_request(91).client)
                .is_none(),
            "clearing a group should remove its joined fetch tokens"
        );
    }
}