next_api/

analyze.rs

mod groups;
mod membership;
mod output_file;

use std::io::Write;

use anyhow::Result;
use bincode::{Decode, Encode};
use byteorder::{BE, WriteBytesExt};
use next_core::app_structure::FileSystemPathVec;
use output_file::{AnalyzedChunkPart, analyze_output_file, analyze_traced_file};
use rustc_hash::{FxHashMap, FxHashSet};
use serde::Serialize;
use turbo_rcstr::RcStr;
use turbo_tasks::{
    FxIndexSet, JoinIterExt, NonLocalValue, ResolvedVc, TryFlatJoinIterExt, TryJoinIterExt,
    ValueToString, ValueToStringRef, Vc,
};
use turbo_tasks_fs::{
    File, FileContent, FileSystemPath,
    rope::{Rope, RopeBuilder},
};
use turbo_tasks_hash::hash_xxh3_hash64;
use turbopack_core::{
    asset::{Asset, AssetContent},
    chunk::{ChunkingType, TracedMode},
    module::Module,
    module_graph::{GraphTraversalAction, ModuleGraph},
    output::{OutputAsset, OutputAssets, OutputAssetsReference},
    reference::all_assets_from_entries,
};
use turbopack_ecmascript::references::service_worker::ServiceWorkerEntryModule;

use crate::route::AnalyzeChunkGroups;

const ANALYZE_SCHEMA_VERSION: u32 = 1;

#[turbo_tasks::value]
#[derive(Clone, Copy, Serialize)]
pub struct BundleTotals {
    pub size: u64,
    pub compressed_size: u64,
}

#[turbo_tasks::value]
#[derive(Clone, Copy, Serialize)]
pub struct RouteBundleSummary {
    pub size: u64,
    pub compressed_size: u64,
    pub client: BundleTotals,
}

#[derive(Serialize)]
pub struct AnalyzeSource {
    pub parent_source_index: Option<u32>,
    /// Path. When there is a parent, this is concatenated to the parent's path.
    /// Folders end with a slash. Might have multiple path segments when folders contain only a
    /// single child.
    pub path: RcStr,
}

#[derive(Clone, Debug, PartialEq, Eq, NonLocalValue, Encode, Decode, Serialize)]
pub struct AnalyzeModule {
    pub ident: RcStr,
    pub path: RcStr,
}

#[derive(Serialize)]
pub struct AnalyzeChunkPart {
    pub source_index: u32,
    pub output_file_index: u32,
    pub size: u32,
    pub compressed_size: u32,
}

#[derive(Serialize)]
pub struct AnalyzeOutputFile {
    pub filename: RcStr,
}

/// Exact endpoint graph root. Client roles and references are build-time
/// provenance; neither establishes that a browser requested a chunk.
#[turbo_tasks::value(shared)]
#[derive(Clone, Debug, Serialize)]
pub struct AnalyzeRouteEntry {
    pub route_entry_id: RcStr,
    pub module_ident: RcStr,
    pub module_path: RcStr,
    pub role: RcStr,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub entry_kind: Option<RcStr>,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub client_references: Vec<AnalyzeClientReferenceEntry>,
}

#[derive(Clone, Debug, PartialEq, Eq, NonLocalValue, Encode, Decode, Serialize)]
pub struct AnalyzeClientReferenceEntry {
    pub module_ident: RcStr,
    pub module_path: RcStr,
    pub reference_kind: RcStr,
}

#[turbo_tasks::value(transparent)]
pub struct AnalyzeRouteEntries(Vec<AnalyzeRouteEntry>);

pub type AnalyzeGraphModule = ResolvedVc<Box<dyn Module>>;
pub type AnalyzeSyncDependents = FxHashMap<AnalyzeGraphModule, Vec<AnalyzeGraphModule>>;
pub type AnalyzeWorkerEntry = (AnalyzeGraphModule, ResolvedVc<ServiceWorkerEntryModule>);

/// Snapshot-scoped module order shared by both artifact writers. Never regenerate
/// indices independently from a route graph or use them across analyzer snapshots.
#[turbo_tasks::value(shared)]
pub struct AnalyzeModuleIndex {
    pub modules: Vec<AnalyzeModule>,
    pub by_ident: FxHashMap<RcStr, u32>,
    /// Fingerprint of the exact ordered module identities serialized in modules.data.
    pub module_index_hash: RcStr,
    /// Cached once for the whole application, not rebuilt for each route.
    pub sync_dependents: AnalyzeSyncDependents,
    pub worker_entries: Vec<AnalyzeWorkerEntry>,
}

#[turbo_tasks::function]
pub async fn analyze_module_index(module_graph: Vc<ModuleGraph>) -> Result<Vc<AnalyzeModuleIndex>> {
    let mut all_modules = FxIndexSet::default();
    let mut sync_dependents: AnalyzeSyncDependents = FxHashMap::default();
    let mut registrations = FxIndexSet::default();
    let graph = module_graph.await?;
    graph.traverse_edges_dfs(
        graph.all_entry_modules(),
        &mut (),
        |parent, node, _| {
            all_modules.insert(node);
            if let Some((importer, reference)) = parent {
                if !matches!(
                    reference.chunking_type,
                    ChunkingType::Async | ChunkingType::Traced { .. }
                ) {
                    sync_dependents.entry(node).or_default().push(importer);
                }
                if let Some(marker) =
                    ResolvedVc::try_downcast_type::<ServiceWorkerEntryModule>(node)
                {
                    registrations.insert((importer, marker));
                }
            }
            Ok(GraphTraversalAction::Continue)
        },
        |_, _, _| Ok(()),
        true,
        false,
    )?;
    let mut modules = Vec::with_capacity(all_modules.len());
    let mut by_ident = FxHashMap::default();
    let idents_and_paths = all_modules
        .iter()
        .copied()
        .map(async |module| {
            let ident = module.ident();
            let ident_str = ident.to_string().owned().await?;
            let path = ident.await?.path.to_string_ref().await?;
            anyhow::Ok((ident_str, path))
        })
        .join()
        .await;
    for pair in idents_and_paths {
        let (ident, path) = pair?;
        if by_ident.contains_key(&ident) {
            continue;
        }
        by_ident.insert(ident.clone(), modules.len() as u32);
        modules.push(AnalyzeModule { ident, path });
    }
    let module_index_hash = format!(
        "{:016x}",
        hash_xxh3_hash64(
            modules
                .iter()
                .map(|module| (module.ident.as_str(), module.path.as_str()))
                .collect::<Vec<_>>()
        )
    )
    .into();
    Ok(AnalyzeModuleIndex {
        modules,
        by_ident,
        module_index_hash,
        sync_dependents,
        worker_entries: registrations.into_iter().collect(),
    }
    .cell())
}

pub fn analyze_route_entry_id(
    route: &str,
    role: &str,
    sub_name: &str,
    module_ident: &str,
) -> RcStr {
    format!("{route}|{role}|{sub_name}|{module_ident}").into()
}

#[derive(Serialize)]
struct EdgesDataReference {
    pub offset: u32,
    pub length: u32,
}

#[derive(Serialize)]
struct AnalyzeDataHeader {
    /// The header and modules.data must use the same supported schema version.
    pub schema_version: u32,
    pub module_index_hash: RcStr,
    pub sources: Vec<AnalyzeSource>,
    pub chunk_parts: Vec<AnalyzeChunkPart>,
    pub output_files: Vec<AnalyzeOutputFile>,
    /// Exact indices into this snapshot's modules.data.modules, one row per output file.
    pub output_file_modules: EdgesDataReference,
    pub output_file_async_loaders: EdgesDataReference,
    pub output_file_module_coverage: Vec<AnalyzeOutputFileCoverage>,
    pub chunk_groups: Vec<AnalyzeChunkGroupData>,
    /// Exact endpoint roots; nested client references do not become roots.
    pub route_entries: Vec<AnalyzeRouteEntry>,
    /// Edges from chunks to chunk parts
    pub output_file_chunk_parts: EdgesDataReference,
    /// Edges from sources to chunk parts
    pub source_chunk_parts: EdgesDataReference,
    /// Edges from sources to their children sources
    pub source_children: EdgesDataReference,
    /// Root level sources, walking their children will reach all sources
    pub source_roots: Vec<u32>,
}

#[derive(Serialize)]
struct ModulesDataHeader {
    /// The header and modules.data must use the same supported schema version.
    pub schema_version: u32,
    pub module_index_hash: RcStr,
    pub modules: Vec<AnalyzeModule>,
    /// Edges from modules to modules
    pub module_dependents: EdgesDataReference,
    /// Edges from modules to modules
    pub async_module_dependents: EdgesDataReference,
    /// Edges from modules to modules
    pub traced_module_dependents: EdgesDataReference,
    /// Edges from modules to modules
    pub module_dependencies: EdgesDataReference,
    /// Edges from modules to modules
    pub async_module_dependencies: EdgesDataReference,
    /// Edges from modules to modules
    pub traced_module_dependencies: EdgesDataReference,
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, NonLocalValue, Encode, Decode, Serialize)]
#[serde(rename_all = "snake_case")]
enum AnalyzeOutputFileCoverage {
    Exact,
    Unsupported,
    #[default]
    NotAChunk,
}

#[derive(Serialize)]
struct AnalyzeChunkGroupData {
    id: u32,
    kind: RcStr,
    /// Async groups identify the dynamically imported target, not a loader stub.
    /// Other group kinds retain their explicitly selected trigger.
    #[serde(skip_serializing_if = "Option::is_none")]
    trigger_module_index: Option<u32>,
    /// Direct emitted output_file indices; group membership is not a claim that
    /// an individual reference contributes every module in a cumulative group.
    output_file_indices: Vec<u32>,
}

struct ChunkLoadCandidate {
    source: u32,
    target: ResolvedVc<Box<dyn OutputAsset>>,
    /// The dynamically imported target, shared by loaders and manifests.
    trigger_module_index: u32,
}

struct AnalyzeOutputFileBuilder {
    output_file: AnalyzeOutputFile,
    chunk_part_indices: Vec<u32>,
    module_indices: Vec<u32>,
    async_loader_indices: Vec<u32>,
    module_coverage: AnalyzeOutputFileCoverage,
}

struct AnalyzeSourceBuilder {
    source: AnalyzeSource,
    child_source_indices: Vec<u32>,
    chunk_part_indices: Vec<u32>,
}

struct AnalyzeModuleBuilder {
    module: AnalyzeModule,
    dependencies: FxIndexSet<u32>,
    async_dependencies: FxIndexSet<u32>,
    traced_dependencies: FxIndexSet<u32>,
    dependents: FxIndexSet<u32>,
    async_dependents: FxIndexSet<u32>,
    traced_dependents: FxIndexSet<u32>,
}

struct AnalyzeDataBuilder {
    sources: Vec<AnalyzeSourceBuilder>,
    source_index_map: FxHashMap<RcStr, u32>,
    chunk_parts: Vec<AnalyzeChunkPart>,
    output_files: Vec<AnalyzeOutputFileBuilder>,
    output_file_index_map: FxHashMap<RcStr, u32>,
    route_entries: Vec<AnalyzeRouteEntry>,
    module_index_hash: RcStr,
    chunk_groups: Vec<AnalyzeChunkGroupData>,
}

struct ModulesDataBuilder {
    modules: Vec<AnalyzeModuleBuilder>,
    module_index_map: FxHashMap<RcStr, u32>,
    module_index_hash: RcStr,
}

/// Shared row-offset encoding used by both analyzer artifacts.
pub struct EdgesData {
    pub offsets: Vec<u32>,
    pub data: Vec<u32>,
}

impl EdgesData {
    fn from_iterator<'a>(iterable: impl IntoIterator<Item = &'a Vec<u32>> + Clone) -> Self {
        let mut current_offset = 0;
        let sum: usize = iterable.clone().into_iter().map(|v| v.len()).sum();
        let mut data = Vec::with_capacity(sum);
        let offsets = iterable
            .into_iter()
            .map(|edges| {
                current_offset += edges.len() as u32;
                data.extend(edges);
                current_offset
            })
            .collect();
        Self { offsets, data }
    }

    fn write(&self, writer: &mut impl Write) -> Result<()> {
        writer.write_u32::<BE>(self.offsets.len() as u32)?;
        for &offset in &self.offsets {
            writer.write_u32::<BE>(offset)?;
        }
        for &data in &self.data {
            writer.write_u32::<BE>(data)?;
        }
        Ok(())
    }
}

struct EdgesDataSectionBuilder {
    data: Vec<u8>,
}

impl EdgesDataSectionBuilder {
    fn new() -> Self {
        Self { data: vec![] }
    }

    fn add_edges(&mut self, edges: &EdgesData) -> EdgesDataReference {
        let offset = self.data.len().try_into().unwrap();
        edges.write(&mut self.data).unwrap();
        let length = (self.data.len() - offset as usize).try_into().unwrap();
        EdgesDataReference { offset, length }
    }
}

impl AnalyzeDataBuilder {
    fn new(route_entries: Vec<AnalyzeRouteEntry>, module_index_hash: RcStr) -> Self {
        Self {
            module_index_hash,
            sources: vec![],
            source_index_map: FxHashMap::default(),
            chunk_parts: vec![],
            output_files: vec![],
            output_file_index_map: FxHashMap::default(),
            route_entries,
            chunk_groups: vec![],
        }
    }

    fn ensure_source(&mut self, path: &str) -> (&mut AnalyzeSourceBuilder, u32) {
        if let Some(&index) = self.source_index_map.get(path) {
            return (&mut self.sources[index as usize], index);
        }
        let index = self.sources.len() as u32;
        let path = RcStr::from(path);
        self.source_index_map.insert(path.clone(), index);
        self.sources.push(AnalyzeSourceBuilder {
            source: AnalyzeSource {
                parent_source_index: None,
                path,
            },
            child_source_indices: vec![],
            chunk_part_indices: vec![],
        });
        (&mut self.sources[index as usize], index)
    }

    fn add_chunk_part(&mut self, chunk_part: AnalyzeChunkPart) -> u32 {
        let i = self.chunk_parts.len() as u32;
        self.chunk_parts.push(chunk_part);
        i
    }

    fn add_output_file(&mut self, output_file: AnalyzeOutputFile) -> u32 {
        if let Some(&index) = self.output_file_index_map.get(&output_file.filename) {
            return index;
        }
        let i = self.output_files.len() as u32;
        self.output_file_index_map
            .insert(output_file.filename.clone(), i);
        self.output_files.push(AnalyzeOutputFileBuilder {
            output_file,
            chunk_part_indices: vec![],
            module_indices: vec![],
            async_loader_indices: vec![],
            module_coverage: AnalyzeOutputFileCoverage::NotAChunk,
        });
        i
    }

    fn add_chunk_part_to_output_file(&mut self, output_file_index: u32, chunk_part_index: u32) {
        self.output_files[output_file_index as usize]
            .chunk_part_indices
            .push(chunk_part_index);
    }

    fn add_chunk_part_to_source(&mut self, source_index: u32, chunk_part_index: u32) {
        self.sources[source_index as usize]
            .chunk_part_indices
            .push(chunk_part_index);
    }

    /// Link the attributed sources into their directory hierarchy before
    /// serializing the route artifact.
    fn finish_sources(&mut self) {
        let mut i: u32 = 0;
        while i < self.sources.len().try_into().unwrap() {
            let source = &self.sources[i as usize];
            let path = source.source.path.as_str();
            if !path.is_empty() {
                let (parent_path, path) = if let Some(pos) = path.trim_end_matches('/').rfind('/') {
                    (&path[..pos + 1], &path[pos + 1..])
                } else {
                    ("", path)
                };
                let parent_path = parent_path.to_string();
                let path = path.into();
                let (parent_source, parent_index) = self.ensure_source(&parent_path);
                parent_source.child_source_indices.push(i);
                self.sources[i as usize].source.parent_source_index = Some(parent_index);
                self.sources[i as usize].source.path = path;
            }
            i += 1;
        }
    }

    fn build(self) -> Rope {
        let source_roots = self
            .sources
            .iter()
            .enumerate()
            .filter_map(|(i, s)| {
                if s.source.parent_source_index.is_none() {
                    Some(i as u32)
                } else {
                    None
                }
            })
            .collect();

        let source_children =
            EdgesData::from_iterator(self.sources.iter().map(|s| &s.child_source_indices));

        let source_chunk_parts =
            EdgesData::from_iterator(self.sources.iter().map(|s| &s.chunk_part_indices));

        let output_file_chunk_parts =
            EdgesData::from_iterator(self.output_files.iter().map(|of| &of.chunk_part_indices));
        let output_file_modules =
            EdgesData::from_iterator(self.output_files.iter().map(|of| &of.module_indices));

        let output_file_async_loaders =
            EdgesData::from_iterator(self.output_files.iter().map(|of| &of.async_loader_indices));
        let mut binary_section = EdgesDataSectionBuilder::new();

        let header = AnalyzeDataHeader {
            schema_version: ANALYZE_SCHEMA_VERSION,
            module_index_hash: self.module_index_hash,
            sources: self.sources.into_iter().map(|s| s.source).collect(),
            chunk_parts: self.chunk_parts,
            output_file_module_coverage: self
                .output_files
                .iter()
                .map(|of| of.module_coverage)
                .collect(),
            output_file_modules: binary_section.add_edges(&output_file_modules),
            output_file_async_loaders: binary_section.add_edges(&output_file_async_loaders),
            output_files: self
                .output_files
                .into_iter()
                .map(|of| of.output_file)
                .collect(),
            chunk_groups: self.chunk_groups,
            route_entries: self.route_entries,
            output_file_chunk_parts: binary_section.add_edges(&output_file_chunk_parts),
            source_chunk_parts: binary_section.add_edges(&source_chunk_parts),
            source_children: binary_section.add_edges(&source_children),
            source_roots,
        };

        let header_json = serde_json::to_vec(&header).unwrap();

        let mut rope = RopeBuilder::default();
        rope.push_bytes(&(header_json.len() as u32).to_be_bytes());
        rope.reserve_bytes(header_json.len() + binary_section.data.len());
        rope.push_bytes(&header_json);
        rope.push_bytes(&binary_section.data);
        rope.build()
    }
}

impl ModulesDataBuilder {
    fn new(module_index_hash: RcStr) -> Self {
        Self {
            module_index_hash,
            modules: vec![],
            module_index_map: FxHashMap::default(),
        }
    }

    fn get_module(&mut self, ident: &str) -> (&mut AnalyzeModuleBuilder, u32) {
        if let Some(&index) = self.module_index_map.get(ident) {
            return (&mut self.modules[index as usize], index);
        }
        panic!("Module with ident `{}` not found", ident);
    }

    fn ensure_module(&mut self, ident: &str, path: &str) -> (&mut AnalyzeModuleBuilder, u32) {
        if let Some(&index) = self.module_index_map.get(ident) {
            return (&mut self.modules[index as usize], index);
        }
        let index = self.modules.len() as u32;
        let ident = RcStr::from(ident);
        let path = RcStr::from(path);
        self.module_index_map.insert(ident.clone(), index);
        self.modules.push(AnalyzeModuleBuilder {
            module: AnalyzeModule { ident, path },
            dependencies: FxIndexSet::default(),
            async_dependencies: FxIndexSet::default(),
            traced_dependencies: FxIndexSet::default(),
            dependents: FxIndexSet::default(),
            async_dependents: FxIndexSet::default(),
            traced_dependents: FxIndexSet::default(),
        });
        (&mut self.modules[index as usize], index)
    }

    fn build(self) -> Rope {
        let module_dependencies_vecs: Vec<Vec<u32>> = self
            .modules
            .iter()
            .map(|s| s.dependencies.iter().copied().collect())
            .collect();
        let async_module_dependencies_vecs: Vec<Vec<u32>> = self
            .modules
            .iter()
            .map(|s| s.async_dependencies.iter().copied().collect())
            .collect();
        let traced_module_dependencies_vecs: Vec<Vec<u32>> = self
            .modules
            .iter()
            .map(|s| s.traced_dependencies.iter().copied().collect())
            .collect();
        let module_dependents_vecs: Vec<Vec<u32>> = self
            .modules
            .iter()
            .map(|s| s.dependents.iter().copied().collect())
            .collect();
        let async_module_dependents_vecs: Vec<Vec<u32>> = self
            .modules
            .iter()
            .map(|s| s.async_dependents.iter().copied().collect())
            .collect();
        let traced_module_dependents_vecs: Vec<Vec<u32>> = self
            .modules
            .iter()
            .map(|s| s.traced_dependents.iter().copied().collect())
            .collect();

        let module_dependencies = EdgesData::from_iterator(&module_dependencies_vecs);
        let async_module_dependencies = EdgesData::from_iterator(&async_module_dependencies_vecs);
        let traced_module_dependencies = EdgesData::from_iterator(&traced_module_dependencies_vecs);
        let module_dependents = EdgesData::from_iterator(&module_dependents_vecs);
        let async_module_dependents = EdgesData::from_iterator(&async_module_dependents_vecs);
        let traced_module_dependents = EdgesData::from_iterator(&traced_module_dependents_vecs);

        let mut binary_section = EdgesDataSectionBuilder::new();

        let header = ModulesDataHeader {
            schema_version: ANALYZE_SCHEMA_VERSION,
            module_index_hash: self.module_index_hash,
            modules: self.modules.into_iter().map(|s| s.module).collect(),
            module_dependents: binary_section.add_edges(&module_dependents),
            async_module_dependents: binary_section.add_edges(&async_module_dependents),
            traced_module_dependents: binary_section.add_edges(&traced_module_dependents),
            module_dependencies: binary_section.add_edges(&module_dependencies),
            async_module_dependencies: binary_section.add_edges(&async_module_dependencies),
            traced_module_dependencies: binary_section.add_edges(&traced_module_dependencies),
        };

        let header_json = serde_json::to_vec(&header).unwrap();

        let mut rope = RopeBuilder::default();
        rope.push_bytes(&(header_json.len() as u32).to_be_bytes());
        rope.reserve_bytes(header_json.len() + binary_section.data.len());
        rope.push_bytes(&header_json);
        rope.push_bytes(&binary_section.data);
        rope.build()
    }
}

/// Merges two sets of output assets into one. Used to combine per-route output
/// assets with shared assets (e.g. `_app`, `_document`) at report generation time.
#[turbo_tasks::function]
pub async fn combine_output_assets(
    primary: Vc<OutputAssets>,
    extra: Vc<OutputAssets>,
) -> Result<Vc<OutputAssets>> {
    let mut combined: Vec<ResolvedVc<Box<dyn OutputAsset>>> =
        primary.await?.iter().copied().collect();
    combined.extend(extra.await?.iter().copied());
    Ok(Vc::cell(combined))
}

/// Merges two sets of traced modules into one. Used to combine per-route traced
/// modules with shared modules (e.g. `_app`, `_document`) at report generation time.
#[turbo_tasks::function]
pub async fn combine_traced_files(
    primary: Vc<FileSystemPathVec>,
    extra: Vc<FileSystemPathVec>,
) -> Result<Vc<FileSystemPathVec>> {
    let mut combined: Vec<FileSystemPath> = primary.await?.iter().cloned().collect();
    combined.extend(extra.await?.iter().cloned());
    Ok(Vc::cell(combined))
}

#[turbo_tasks::value]
pub struct AnalyzedRoute {
    pub content: ResolvedVc<FileContent>,
    pub summary: RouteBundleSummary,
}

#[turbo_tasks::value_impl]
impl AnalyzedRoute {
    #[turbo_tasks::function]
    fn file_content(&self) -> Vc<FileContent> {
        *self.content
    }
}

#[turbo_tasks::function]
pub async fn analyze_output_assets(
    output_assets: Vc<OutputAssets>,
    traced_files: Vc<FileSystemPathVec>,
    route_entries: Vc<AnalyzeRouteEntries>,
    chunk_groups: Vc<AnalyzeChunkGroups>,
    module_graph: Vc<ModuleGraph>,
) -> Result<Vc<AnalyzedRoute>> {
    let output_assets = all_assets_from_entries(output_assets);
    let mut summary = RouteBundleSummary {
        size: 0,
        compressed_size: 0,
        client: BundleTotals {
            size: 0,
            compressed_size: 0,
        },
    };
    let route_entries = route_entries.await?.iter().cloned().collect();
    let module_index_vc = analyze_module_index(module_graph);
    let module_index = module_index_vc.await?;

    let mut builder =
        AnalyzeDataBuilder::new(route_entries, module_index.module_index_hash.clone());
    let mut asset_indices: FxHashMap<ResolvedVc<Box<dyn OutputAsset>>, Vec<u32>> =
        FxHashMap::default();
    let mut candidates = Vec::new();
    let mut browser_chunks = FxHashSet::default();

    let output_assets = output_assets.await?;
    let traced_files = traced_files.await?;
    // One call per file: per-route fan-out over shared assets dominates analysis
    // through task-graph bookkeeping, not the work behind each call.
    let files = output_assets
        .iter()
        .map(|&asset| analyze_output_file(*asset, module_index_vc))
        .chain(
            traced_files
                .iter()
                .map(|path| analyze_traced_file(path.clone())),
        )
        .try_join()
        .await?;

    for file in files.iter().filter_map(|file| (**file).as_ref()) {
        let is_client = file.filename.starts_with("[client-fs]/");
        let output_file_index = builder.add_output_file(AnalyzeOutputFile {
            filename: file.filename.clone(),
        });
        if let Some(emitted) = &file.emitted {
            let membership = &emitted.membership;
            asset_indices
                .entry(emitted.asset)
                .or_default()
                .push(output_file_index);
            if emitted.is_browser_chunk {
                browser_chunks.insert(output_file_index);
            }
            candidates.extend(
                membership
                    .load_targets
                    .iter()
                    .map(|load| ChunkLoadCandidate {
                        source: output_file_index,
                        target: load.target,
                        trigger_module_index: load.trigger_module_index,
                    }),
            );
            let output = &mut builder.output_files[output_file_index as usize];
            output.module_indices.extend(&membership.module_indices);
            output.module_indices.sort_unstable();
            output.module_indices.dedup();
            output
                .async_loader_indices
                .extend(&membership.async_loader_indices);
            output.async_loader_indices.sort_unstable();
            output.async_loader_indices.dedup();
            output.module_coverage = membership.coverage;
        }
        for &AnalyzedChunkPart {
            ref source,
            size,
            compressed_size,
        } in &file.chunk_parts
        {
            let source_index = builder.ensure_source(source).1;
            summary.size += u64::from(size);
            summary.compressed_size += u64::from(compressed_size);
            if is_client {
                summary.client.size += u64::from(size);
                summary.client.compressed_size += u64::from(compressed_size);
            }
            let chunk_part_index = builder.add_chunk_part(AnalyzeChunkPart {
                source_index,
                output_file_index,
                size,
                compressed_size,
            });
            builder.add_chunk_part_to_output_file(output_file_index, chunk_part_index);
            builder.add_chunk_part_to_source(source_index, chunk_part_index);
        }
    }

    groups::collect_groups(
        &mut builder,
        candidates,
        &asset_indices,
        chunk_groups,
        &module_index,
        &browser_chunks,
    )
    .await?;

    builder.finish_sources();

    let rope = builder.build();
    Ok(AnalyzedRoute {
        content: FileContent::Content(File::from(rope))
            .cell()
            .to_resolved()
            .await?,
        summary,
    }
    .cell())
}

#[turbo_tasks::function]
pub async fn analyze_module_graphs(module_graph: Vc<ModuleGraph>) -> Result<Vc<FileContent>> {
    let module_index = analyze_module_index(module_graph).await?;
    let mut builder = ModulesDataBuilder::new(module_index.module_index_hash.clone());

    let mut all_edges = FxIndexSet::default();
    let mut all_async_edges = FxIndexSet::default();
    let mut all_traced_edges = FxIndexSet::default();
    let mut traced_modules = FxHashSet::default();

    let module_graph = module_graph.await?;
    module_graph.traverse_edges_dfs(
        module_graph.all_entry_modules(),
        &mut (),
        |parent, node, _| {
            let Some((parent_node, reference)) = parent else {
                return Ok(GraphTraversalAction::Continue);
            };

            // ChunkingType::Traced{TracedMode::Entry}     => target is always traced
            // ChunkingType::Traced{TracedMode::Transitive}=> target only traced if parent is traced
            // ChunkingType::*                             => target only traced if parent is traced
            if matches!(
                reference.chunking_type,
                ChunkingType::Traced {
                    mode: TracedMode::Entry
                }
            ) || traced_modules.contains(&parent_node)
            {
                traced_modules.insert(node);
                all_traced_edges.insert((parent_node, node));
                return Ok(GraphTraversalAction::Continue);
            };

            match reference.chunking_type {
                ChunkingType::Async => {
                    all_async_edges.insert((parent_node, node));
                }
                _ => {
                    all_edges.insert((parent_node, node));
                }
            }
            Ok(GraphTraversalAction::Continue)
        },
        |_, _, _| Ok(()),
        true,
        false,
    )?;

    type ModulePair = (ResolvedVc<Box<dyn Module>>, ResolvedVc<Box<dyn Module>>);
    async fn mapper((from, to): ModulePair) -> Result<Option<(RcStr, RcStr)>> {
        if from == to {
            return Ok(None);
        }
        let from_ident = from.ident().to_string().owned().await?;
        let to_ident = to.ident().to_string().owned().await?;
        Ok(Some((from_ident, to_ident)))
    }

    for module in &module_index.modules {
        builder.ensure_module(&module.ident, &module.path);
    }

    let all_edges = all_edges
        .iter()
        .copied()
        .map(mapper)
        .try_flat_join()
        .await?;
    let all_async_edges = all_async_edges
        .iter()
        .copied()
        .map(mapper)
        .try_flat_join()
        .await?;
    let all_traced_edges = all_traced_edges
        .iter()
        .copied()
        .map(mapper)
        .try_flat_join()
        .await?;
    for (from_ident, to_ident) in all_edges {
        let from_index = builder.get_module(&from_ident).1;
        let to_index = builder.get_module(&to_ident).1;
        if from_index == to_index {
            continue;
        }
        builder.modules[from_index as usize]
            .dependencies
            .insert(to_index);
        builder.modules[to_index as usize]
            .dependents
            .insert(from_index);
    }
    for (from_ident, to_ident) in all_async_edges {
        let from_index = builder.get_module(&from_ident).1;
        let to_index = builder.get_module(&to_ident).1;
        if from_index == to_index {
            continue;
        }
        builder.modules[from_index as usize]
            .async_dependencies
            .insert(to_index);
        builder.modules[to_index as usize]
            .async_dependents
            .insert(from_index);
    }
    for (from_ident, to_ident) in all_traced_edges {
        let from_index = builder.get_module(&from_ident).1;
        let to_index = builder.get_module(&to_ident).1;
        if from_index == to_index {
            continue;
        }
        builder.modules[from_index as usize]
            .traced_dependencies
            .insert(to_index);
        builder.modules[to_index as usize]
            .traced_dependents
            .insert(from_index);
    }

    let rope = builder.build();
    Ok(FileContent::Content(File::from(rope)).cell())
}

#[turbo_tasks::value]
pub struct AnalyzeDataOutputAsset {
    pub path: FileSystemPath,
    pub output_assets: ResolvedVc<OutputAssets>,
    pub traced_files: ResolvedVc<FileSystemPathVec>,
    pub route_entries: ResolvedVc<AnalyzeRouteEntries>,
    pub chunk_groups: ResolvedVc<AnalyzeChunkGroups>,
    pub module_graph: ResolvedVc<ModuleGraph>,
}

#[turbo_tasks::value_impl]
impl AnalyzeDataOutputAsset {
    #[turbo_tasks::function]
    pub async fn new(
        path: FileSystemPath,
        output_assets: ResolvedVc<OutputAssets>,
        traced_files: ResolvedVc<FileSystemPathVec>,
        route_entries: ResolvedVc<AnalyzeRouteEntries>,
        chunk_groups: ResolvedVc<AnalyzeChunkGroups>,
        module_graph: ResolvedVc<ModuleGraph>,
    ) -> Result<Vc<Self>> {
        Ok(Self {
            path,
            output_assets,
            traced_files,
            route_entries,
            chunk_groups,
            module_graph,
        }
        .cell())
    }
}

#[turbo_tasks::value_impl]
impl Asset for AnalyzeDataOutputAsset {
    #[turbo_tasks::function]
    fn content(&self) -> Vc<AssetContent> {
        let file_content = analyze_output_assets(
            *self.output_assets,
            *self.traced_files,
            *self.route_entries,
            *self.chunk_groups,
            *self.module_graph,
        )
        .file_content();
        AssetContent::file(file_content)
    }
}

#[turbo_tasks::value_impl]
impl OutputAssetsReference for AnalyzeDataOutputAsset {}

#[turbo_tasks::value_impl]
impl OutputAsset for AnalyzeDataOutputAsset {
    #[turbo_tasks::function]
    fn path(&self) -> Vc<FileSystemPath> {
        self.path.clone().cell()
    }
}

#[turbo_tasks::value]
pub struct ModulesDataOutputAsset {
    pub path: FileSystemPath,
    pub module_graph: ResolvedVc<ModuleGraph>,
}

#[turbo_tasks::value_impl]
impl ModulesDataOutputAsset {
    #[turbo_tasks::function]
    pub async fn new(
        path: FileSystemPath,
        module_graph: ResolvedVc<ModuleGraph>,
    ) -> Result<Vc<Self>> {
        Ok(Self { path, module_graph }.cell())
    }
}

#[turbo_tasks::value_impl]
impl Asset for ModulesDataOutputAsset {
    #[turbo_tasks::function]
    fn content(&self) -> Vc<AssetContent> {
        let file_content = analyze_module_graphs(*self.module_graph);
        AssetContent::file(file_content)
    }
}

#[turbo_tasks::value_impl]
impl OutputAssetsReference for ModulesDataOutputAsset {}

#[turbo_tasks::value_impl]
impl OutputAsset for ModulesDataOutputAsset {
    #[turbo_tasks::function]
    fn path(&self) -> Vc<FileSystemPath> {
        self.path.clone().cell()
    }
}