turbopack_core/chunk/

chunking_context.rs

use anyhow::Result;
use bincode::{Decode, Encode};
use rustc_hash::{FxHashMap, FxHashSet};
use serde::{Deserialize, Serialize};
use turbo_rcstr::RcStr;
use turbo_tasks::{ResolvedVc, Upcast, Vc, turbobail};
use turbo_tasks_fs::FileSystemPath;
use turbo_tasks_hash::DeterministicHash;

use crate::{
    asset::{Asset, AssetContent},
    chunk::{
        ChunkItem, ChunkType, ChunkableModule, availability_info::AvailabilityInfo,
        chunk_id_strategy::ModuleIdStrategy,
    },
    environment::{ChunkLoading, Environment},
    ident::AssetIdent,
    module::Module,
    module_graph::{
        ModuleGraph, binding_usage_info::ModuleExportUsage, chunk_group_info::ChunkGroup,
        module_batches::BatchingConfig, style_groups::StyleGroupsAlgorithm,
    },
    output::{
        ExpandOutputAssetsInput, OutputAsset, OutputAssets, OutputAssetsReferences,
        OutputAssetsWithReferenced, expand_output_assets,
    },
    reference::ModuleReference,
};

#[turbo_tasks::task_input]
#[derive(
    Debug, Clone, Copy, PartialEq, Eq, Hash, Deserialize, DeterministicHash, Encode, Decode,
)]
#[serde(rename_all = "kebab-case")]
pub enum MangleType {
    OptimalSize,
    Deterministic,
}

#[turbo_tasks::value(shared, task_input)]
#[derive(Debug, Clone, Copy, Hash, DeterministicHash, Deserialize)]
pub enum MinifyType {
    // TODO instead of adding a new property here,
    // refactor that to Minify(MinifyOptions) to allow defaults on MinifyOptions
    Minify { mangle: Option<MangleType> },
    NoMinify,
}

impl Default for MinifyType {
    fn default() -> Self {
        Self::Minify {
            mangle: Some(MangleType::OptimalSize),
        }
    }
}

#[turbo_tasks::value(shared, task_input)]
#[derive(Debug, Default, Clone, Copy, Hash, DeterministicHash)]
pub enum SourceMapsType {
    /// Extracts source maps from input files and writes source maps for output files.
    #[default]
    Full,
    /// Ignores existing input source maps, but writes source maps for output files.
    Partial,
    /// Ignores the existence of source maps and does not write source maps for output files.
    None,
}

/// Suffix to append to asset URLs.
#[turbo_tasks::value(shared)]
#[derive(Debug, Clone)]
pub enum AssetSuffix {
    /// No suffix.
    None,
    /// A constant suffix to append to URLs.
    Constant(RcStr),
    /// Infer the suffix at runtime from the script src attribute.
    /// Only valid in browser runtime for chunk loading, not for static asset URL generation.
    Inferred,
    /// Read the suffix from a global variable at runtime.
    /// Used for server-side rendering where the suffix is set via `globalThis.{global_name}`.
    FromGlobal(RcStr),
}

/// URL behavior configuration for static assets.
#[turbo_tasks::value(shared)]
#[derive(Debug, Clone)]
pub struct UrlBehavior {
    pub suffix: AssetSuffix,
    /// Static suffix for contexts that cannot use dynamic JS expressions (e.g., CSS `url()`
    /// references). Must be a constant string known at build time (e.g., `?dpl=<deployment_id>`).
    pub static_suffix: ResolvedVc<Option<RcStr>>,
}

#[turbo_tasks::task_input]
#[derive(
    Debug,
    Clone,
    Copy,
    PartialEq,
    Eq,
    Hash,
    Serialize,
    Deserialize,
    DeterministicHash,
    Encode,
    Decode,
)]
pub enum ChunkGroupType {
    Entry,
    Evaluated,
}

#[turbo_tasks::value(shared)]
#[derive(Clone)]
pub struct ChunkGroupResult {
    pub assets: ResolvedVc<OutputAssets>,
    pub referenced_assets: ResolvedVc<OutputAssets>,
    pub references: ResolvedVc<OutputAssetsReferences>,
    pub availability_info: AvailabilityInfo,
    pub chunk_group_bootstrap_params: Option<RcStr>,
}

impl ChunkGroupResult {
    pub fn empty() -> Vc<Self> {
        ChunkGroupResult {
            assets: ResolvedVc::cell(vec![]),
            referenced_assets: ResolvedVc::cell(vec![]),
            references: ResolvedVc::cell(vec![]),
            availability_info: AvailabilityInfo::root(),
            chunk_group_bootstrap_params: None,
        }
        .cell()
    }

    pub fn empty_resolved() -> ResolvedVc<Self> {
        ChunkGroupResult {
            assets: ResolvedVc::cell(vec![]),
            referenced_assets: ResolvedVc::cell(vec![]),
            references: ResolvedVc::cell(vec![]),
            availability_info: AvailabilityInfo::root(),
            chunk_group_bootstrap_params: None,
        }
        .resolved_cell()
    }
}

#[turbo_tasks::value_impl]
impl ChunkGroupResult {
    #[turbo_tasks::function]
    pub fn output_assets_with_referenced(&self) -> Vc<OutputAssetsWithReferenced> {
        OutputAssetsWithReferenced {
            assets: self.assets,
            referenced_assets: self.referenced_assets,
            references: self.references,
        }
        .cell()
    }

    #[turbo_tasks::function]
    pub async fn concatenate(&self, next: Vc<Self>) -> Result<Vc<Self>> {
        let next = next.await?;
        Ok(ChunkGroupResult {
            assets: self.assets.concatenate(*next.assets).to_resolved().await?,
            referenced_assets: self
                .referenced_assets
                .concatenate(*next.referenced_assets)
                .to_resolved()
                .await?,
            references: self
                .references
                .concatenate(*next.references)
                .to_resolved()
                .await?,
            availability_info: next.availability_info,
            chunk_group_bootstrap_params: next.chunk_group_bootstrap_params.clone(),
        }
        .cell())
    }

    #[turbo_tasks::function]
    pub async fn all_assets(&self) -> Result<Vc<OutputAssets>> {
        Ok(Vc::cell(
            expand_output_assets(
                self.assets
                    .await?
                    .into_iter()
                    .chain(self.referenced_assets.await?)
                    .map(ExpandOutputAssetsInput::Asset)
                    .chain(
                        self.references
                            .await?
                            .into_iter()
                            .map(ExpandOutputAssetsInput::Reference),
                    ),
                false,
            )
            .await?,
        ))
    }

    /// Returns only primary asset entries. Doesn't expand OutputAssets. Doesn't return referenced
    /// assets.
    #[turbo_tasks::function]
    pub fn primary_assets(&self) -> Vc<OutputAssets> {
        *self.assets
    }

    #[turbo_tasks::function]
    pub async fn referenced_assets(&self) -> Result<Vc<OutputAssets>> {
        Ok(Vc::cell(
            expand_output_assets(
                self.referenced_assets
                    .await?
                    .into_iter()
                    .map(ExpandOutputAssetsInput::Asset)
                    .chain(
                        self.references
                            .await?
                            .into_iter()
                            .map(ExpandOutputAssetsInput::Reference),
                    ),
                false,
            )
            .await?,
        ))
    }
}

#[turbo_tasks::value(shared)]
pub struct EntryChunkGroupResult {
    pub asset: ResolvedVc<Box<dyn OutputAsset>>,
    pub availability_info: AvailabilityInfo,
}

#[turbo_tasks::task_input]
#[derive(Default, Debug, Clone, PartialEq, Eq, Hash, Encode, Decode)]
pub struct ChunkingConfig {
    /// Try to avoid creating more than 1 chunk smaller than this size.
    /// It merges multiple small chunks into bigger ones to avoid that.
    pub min_chunk_size: usize,

    /// Try to avoid creating more than this number of chunks per group.
    /// It merges multiple chunks into bigger ones to avoid that.
    pub max_chunk_count_per_group: usize,

    /// Never merges chunks bigger than this size with other chunks.
    /// This makes sure that code in big chunks is not duplicated in multiple chunks.
    pub max_merge_chunk_size: usize,

    /// When enabled, a merged chunk also emits its constituent component chunks (referenced,
    /// loaded on demand) so the runtime can fetch an individual component chunk instead of the
    /// whole merged chunk when it is already cached.
    pub generate_component_chunks: bool,

    /// Minimum size for a component chunk to be emitted on its own when
    /// `generate_component_chunks` is enabled. Component chunks smaller than this are folded
    /// into a single remainder component chunk.
    pub min_component_chunk_size: usize,

    /// Selects the algorithm used to compute
    /// [`crate::module_graph::style_groups::StyleGroups`]. Only consulted for the CSS chunk
    /// type.
    pub style_groups_algorithm: StyleGroupsAlgorithm,

    /// First-page-load priority as an integer percentage (`0..=100`), or `None` to use the
    /// default. Used by the production chunker's merge heuristics.
    pub first_page_load_priority: Option<u32>,

    /// Priority boost as an integer percentage (e.g. `150` for a 1.5x boost), or `None` to use the
    /// default. Used by the production chunker's merge heuristics.
    pub priority_boost_percent: Option<u32>,

    /// Estimated request cost in bytes, or `None` to use the default. Used by the production
    /// chunker's merge heuristics.
    pub request_cost: Option<u64>,

    #[allow(dead_code)]
    pub placeholder_for_future_extensions: (),
}

#[turbo_tasks::value(transparent)]
pub struct ChunkingConfigs(FxHashMap<ResolvedVc<Box<dyn ChunkType>>, ChunkingConfig>);

/// turbopack-browser needs to know the original
/// source of the hmr chunk list to properly map to a
/// EcmascriptDevChunkListSource and provide the correct
/// updates. This maps one to one with that.
/// We could consider lifting EcmascriptDevChunkListSource to
/// core instead if this grows. Or using this type in browser instead.
#[turbo_tasks::task_input]
#[derive(Eq, PartialEq, Debug, Clone, Copy, Hash, Serialize, Deserialize, Encode, Decode)]
pub enum HmrChunkListSource {
    Entry,
    Dynamic,
}

#[turbo_tasks::value(shared)]
#[derive(Debug, Clone, Copy, Hash, Default, Deserialize)]
pub enum SourceMapSourceType {
    AbsoluteFileUri,
    RelativeUri,
    #[default]
    TurbopackUri,
}

#[turbo_tasks::value(transparent, cell = "keyed")]
#[allow(clippy::type_complexity)]
/// For each reference, the targets it resolves to that were dropped as unused. One reference can
/// resolve to several targets, which are dropped independently.
pub struct UnusedReferences(
    FxHashMap<ResolvedVc<Box<dyn ModuleReference>>, FxHashSet<ResolvedVc<Box<dyn Module>>>>,
);

#[turbo_tasks::value(shared)]
#[derive(Debug, Clone, Default)]
pub struct WorkerConfigurationOptions {
    /// The worker base-path override. When `Some`, takes precedence over
    /// `chunk_base_path` for the worker entrypoint URL and the module chunks
    /// loaded inside the worker.
    pub asset_prefix: Option<RcStr>,
    /// The list of global variable names to forward to workers. These globals
    /// are read from `globalThis` at worker creation time and passed to the
    /// worker via URL params.
    pub forwarded_globals: Vec<RcStr>,
}

/// A context for the chunking that influences the way chunks are created
#[turbo_tasks::value_trait]
pub trait ChunkingContext {
    #[turbo_tasks::function]
    fn name(self: Vc<Self>) -> Vc<RcStr>;
    #[turbo_tasks::function]
    fn source_map_source_type(self: Vc<Self>) -> Vc<SourceMapSourceType>;
    /// The root path of the project
    #[turbo_tasks::function]
    fn root_path(self: Vc<Self>) -> Vc<FileSystemPath>;
    /// The output root path in the output filesystem
    #[turbo_tasks::function]
    fn output_root(self: Vc<Self>) -> Vc<FileSystemPath>;
    /// A relative path how to reach the root path from the output root. This is used to compute
    /// original paths at runtime relative to the output files. e. g. import.meta.url needs that.
    #[turbo_tasks::function]
    fn output_root_to_root_path(self: Vc<Self>) -> Vc<RcStr>;

    // TODO remove this, a chunking context should not be bound to a specific
    // environment since this can change due to transitions in the module graph
    #[turbo_tasks::function]
    fn environment(self: Vc<Self>) -> Vc<Environment>;

    /// The path to the folder where all chunks are placed. This can be used to compute relative
    /// paths.
    #[turbo_tasks::function]
    fn chunk_root_path(self: Vc<Self>) -> Vc<FileSystemPath>;

    #[turbo_tasks::function]
    fn chunk_loading(self: Vc<Self>) -> Vc<ChunkLoading> {
        self.environment().chunk_loading()
    }

    // TODO(alexkirsz) Remove this from the chunking context. This should be at the
    // discretion of chunking context implementors. However, we currently use this
    // in a couple of places in `turbopack-css`, so we need to remove that
    // dependency first.
    #[turbo_tasks::function]
    fn chunk_path(
        self: Vc<Self>,
        asset: Option<Vc<Box<dyn Asset>>>,
        ident: Vc<AssetIdent>,
        content_hashing_prefix: Option<RcStr>,
        extension: RcStr,
    ) -> Vc<FileSystemPath>;

    /// Reference Source Map Assets for chunks
    #[turbo_tasks::function]
    fn reference_chunk_source_maps(self: Vc<Self>, chunk: Vc<Box<dyn OutputAsset>>) -> Vc<bool>;

    /// Include Source Maps for modules
    #[turbo_tasks::function]
    fn reference_module_source_maps(self: Vc<Self>, module: Vc<Box<dyn Module>>) -> Vc<bool>;

    /// Returns a URL (relative or absolute, depending on the asset prefix) to
    /// the static asset based on its `ident`.
    /// The `tag` is an arbitrary string that can be used to distinguish
    /// different usages of the same asset (e.g. different base paths).
    #[turbo_tasks::function]
    fn asset_url(self: Vc<Self>, ident: FileSystemPath, tag: Option<RcStr>) -> Result<Vc<RcStr>>;

    #[turbo_tasks::function]
    fn service_worker_scope_base_path(self: Vc<Self>) -> Vc<RcStr> {
        Vc::cell(RcStr::default())
    }

    #[turbo_tasks::function]
    fn asset_path(
        self: Vc<Self>,
        content: Vc<AssetContent>,
        original_asset_ident: Vc<AssetIdent>,
        tag: Option<RcStr>,
    ) -> Vc<FileSystemPath>;

    /// Returns the URL behavior for a given tag.
    /// This determines how asset URLs are suffixed (e.g., for deployment IDs).
    #[turbo_tasks::function]
    fn url_behavior(self: Vc<Self>, _tag: Option<RcStr>) -> Vc<UrlBehavior> {
        UrlBehavior {
            suffix: AssetSuffix::Inferred,
            static_suffix: ResolvedVc::cell(None),
        }
        .cell()
    }

    #[turbo_tasks::function]
    fn chunking_configs(self: Vc<Self>) -> Vc<ChunkingConfigs> {
        Vc::cell(Default::default())
    }

    #[turbo_tasks::function]
    fn batching_config(self: Vc<Self>) -> Vc<BatchingConfig> {
        BatchingConfig::new(BatchingConfig {
            ..Default::default()
        })
    }

    /// Whether async modules should create an new availability boundary and therefore nested async
    /// modules include less modules. Enabling this will lead to better optimized async chunks,
    /// but it will require to compute all possible paths in the application, which might lead to
    /// many combinations.
    #[turbo_tasks::function]
    fn is_nested_async_availability_enabled(self: Vc<Self>) -> Vc<bool> {
        Vc::cell(false)
    }

    /// Whether to use `MergeableModule` to merge modules if possible.
    #[turbo_tasks::function]
    fn is_module_merging_enabled(self: Vc<Self>) -> Vc<bool> {
        Vc::cell(false)
    }

    /// Whether to include information about the content of the chunk into the runtime, to allow
    /// more incremental loading of individual chunk items.
    #[turbo_tasks::function]
    fn is_dynamic_chunk_content_loading_enabled(self: Vc<Self>) -> Vc<bool> {
        Vc::cell(false)
    }

    #[turbo_tasks::function]
    fn minify_type(self: Vc<Self>) -> Vc<MinifyType> {
        MinifyType::NoMinify.cell()
    }

    #[turbo_tasks::function]
    fn should_use_absolute_url_references(self: Vc<Self>) -> Vc<bool> {
        Vc::cell(false)
    }

    #[turbo_tasks::function]
    fn async_loader_chunk_item(
        &self,
        module: Vc<Box<dyn ChunkableModule>>,
        module_graph: Vc<ModuleGraph>,
        availability_info: AvailabilityInfo,
    ) -> Vc<Box<dyn ChunkItem>>;
    #[turbo_tasks::function]
    fn async_loader_chunk_item_ident(&self, module: Vc<Box<dyn ChunkableModule>>)
    -> Vc<AssetIdent>;

    /// Places a synthesized chunk item into a standalone output chunk without module graph
    /// traversal.
    #[turbo_tasks::function]
    fn standalone_chunk(
        self: Vc<Self>,
        chunk_item: ResolvedVc<Box<dyn ChunkItem>>,
    ) -> Vc<Box<dyn OutputAsset>>;

    #[turbo_tasks::function]
    fn chunk_group(
        self: Vc<Self>,
        ident: Vc<AssetIdent>,
        chunk_group: ChunkGroup,
        module_graph: Vc<ModuleGraph>,
        availability_info: AvailabilityInfo,
    ) -> Vc<ChunkGroupResult>;

    /// Like [`Self::chunk_group`], but additionally produces an evaluate chunk
    /// (and, in dev, a chunk-list register chunk) that bootstraps and runs
    /// `chunk_group`'s entries.
    ///
    /// `extra_chunks` are not part of this chunk group's module graph, but they
    /// are loaded alongside the entries (and tracked in the chunk-list register
    /// chunk for HMR) — used to extend the entry's HMR-tracked chunks with
    /// chunks computed elsewhere (e.g. app-router client references).
    #[turbo_tasks::function]
    fn evaluated_chunk_group(
        self: Vc<Self>,
        ident: Vc<AssetIdent>,
        chunk_group: ChunkGroup,
        module_graph: Vc<ModuleGraph>,
        extra_chunks: Vc<OutputAssets>,
        availability_info: AvailabilityInfo,
    ) -> Vc<ChunkGroupResult>;

    /// In development, produces a standalone HMR chunk-list register chunk
    /// that tracks `chunks` for hot-module-replacement without producing an
    /// evaluate chunk. Returns `None` (empty vec) outside dev or when HMR is
    /// disabled. Used to register a page-specific chunk list that covers
    /// client-reference chunks built outside the shared module graph.
    #[turbo_tasks::function]
    fn hmr_chunk_list(
        self: Vc<Self>,
        _ident: Vc<AssetIdent>,
        _chunks: Vc<OutputAssets>,
        _source: HmrChunkListSource,
    ) -> Vc<OutputAssets> {
        OutputAssets::empty()
    }

    /// Generates an output chunk that:
    /// * loads the given extra_chunks in addition to the generated chunks; and
    /// * evaluates the given assets; and
    /// * exports the result of evaluating the last module as a CommonJS default export.
    #[turbo_tasks::function]
    fn entry_chunk_group(
        self: Vc<Self>,
        path: FileSystemPath,
        chunk_group: ChunkGroup,
        module_graph: Vc<ModuleGraph>,
        extra_chunks: Vc<OutputAssets>,
        extra_referenced_assets: Vc<OutputAssets>,
        availability_info: AvailabilityInfo,
    ) -> Result<Vc<EntryChunkGroupResult>>;

    #[turbo_tasks::function]
    async fn chunk_item_id_strategy(self: Vc<Self>) -> Result<Vc<ModuleIdStrategy>>;

    #[turbo_tasks::function]
    async fn module_export_usage(
        self: Vc<Self>,
        module: Vc<Box<dyn Module>>,
    ) -> Result<Vc<ModuleExportUsage>>;

    #[turbo_tasks::function]
    async fn unused_references(self: Vc<Self>) -> Result<Vc<UnusedReferences>>;

    /// Returns whether debug IDs are enabled for this chunking context.
    #[turbo_tasks::function]
    fn debug_ids_enabled(self: Vc<Self>) -> Vc<bool>;

    /// Returns the worker-related configuration: the base-path override and the
    /// list of globals to forward to workers.
    #[turbo_tasks::function]
    fn worker_configuration_options(self: Vc<Self>) -> Vc<WorkerConfigurationOptions> {
        WorkerConfigurationOptions::default().cell()
    }

    /// Returns the worker entrypoint for this chunking context.
    #[turbo_tasks::function]
    async fn worker_entrypoint(self: Vc<Self>) -> Result<Vc<Box<dyn OutputAsset>>> {
        turbobail!("Worker entrypoint is not supported by {}", self.name());
    }
}
pub trait ChunkingContextExt {
    fn root_chunk_group(
        self: Vc<Self>,
        ident: Vc<AssetIdent>,
        chunk_group: ChunkGroup,
        module_graph: Vc<ModuleGraph>,
    ) -> Vc<ChunkGroupResult>
    where
        Self: Send;

    fn root_chunk_group_assets(
        self: Vc<Self>,
        ident: Vc<AssetIdent>,
        chunk_group: ChunkGroup,
        module_graph: Vc<ModuleGraph>,
    ) -> Vc<OutputAssetsWithReferenced>
    where
        Self: Send;

    fn evaluated_chunk_group_assets(
        self: Vc<Self>,
        ident: Vc<AssetIdent>,
        chunk_group: ChunkGroup,
        module_graph: Vc<ModuleGraph>,
        extra_chunks: Vc<OutputAssets>,
        availability_info: AvailabilityInfo,
    ) -> Vc<OutputAssetsWithReferenced>
    where
        Self: Send;

    fn entry_chunk_group_asset(
        self: Vc<Self>,
        path: FileSystemPath,
        chunk_group: ChunkGroup,
        module_graph: Vc<ModuleGraph>,
        extra_chunks: Vc<OutputAssets>,
        extra_referenced_assets: Vc<OutputAssets>,
        availability_info: AvailabilityInfo,
    ) -> Vc<Box<dyn OutputAsset>>
    where
        Self: Send;

    fn root_entry_chunk_group(
        self: Vc<Self>,
        path: FileSystemPath,
        chunk_group: ChunkGroup,
        module_graph: Vc<ModuleGraph>,
        extra_chunks: Vc<OutputAssets>,
        extra_referenced_assets: Vc<OutputAssets>,
    ) -> Vc<EntryChunkGroupResult>
    where
        Self: Send;

    fn root_entry_chunk_group_asset(
        self: Vc<Self>,
        path: FileSystemPath,
        chunk_group: ChunkGroup,
        module_graph: Vc<ModuleGraph>,
        extra_chunks: Vc<OutputAssets>,
        extra_referenced_assets: Vc<OutputAssets>,
    ) -> Vc<Box<dyn OutputAsset>>
    where
        Self: Send;

    fn chunk_group_assets(
        self: Vc<Self>,
        ident: Vc<AssetIdent>,
        chunk_group: ChunkGroup,
        module_graph: Vc<ModuleGraph>,
        availability_info: AvailabilityInfo,
    ) -> Vc<OutputAssetsWithReferenced>
    where
        Self: Send;

    /// Computes the relative path from the chunk output root to the project root.
    ///
    /// This is used to compute relative paths for source maps in certain configurations.
    fn relative_path_from_chunk_root_to_project_root(self: Vc<Self>) -> Vc<RcStr>
    where
        Self: Send;
}

impl<T: ChunkingContext + Send + Upcast<Box<dyn ChunkingContext>>> ChunkingContextExt for T {
    fn root_chunk_group(
        self: Vc<Self>,
        ident: Vc<AssetIdent>,
        chunk_group: ChunkGroup,
        module_graph: Vc<ModuleGraph>,
    ) -> Vc<ChunkGroupResult> {
        self.chunk_group(ident, chunk_group, module_graph, AvailabilityInfo::root())
    }

    fn root_chunk_group_assets(
        self: Vc<Self>,
        ident: Vc<AssetIdent>,
        chunk_group: ChunkGroup,
        module_graph: Vc<ModuleGraph>,
    ) -> Vc<OutputAssetsWithReferenced> {
        root_chunk_group_assets(
            Vc::upcast_non_strict(self),
            ident,
            chunk_group,
            module_graph,
        )
    }

    fn evaluated_chunk_group_assets(
        self: Vc<Self>,
        ident: Vc<AssetIdent>,
        chunk_group: ChunkGroup,
        module_graph: Vc<ModuleGraph>,
        extra_chunks: Vc<OutputAssets>,
        availability_info: AvailabilityInfo,
    ) -> Vc<OutputAssetsWithReferenced> {
        evaluated_chunk_group_assets(
            Vc::upcast_non_strict(self),
            ident,
            chunk_group,
            module_graph,
            extra_chunks,
            availability_info,
        )
    }

    fn entry_chunk_group_asset(
        self: Vc<Self>,
        path: FileSystemPath,
        chunk_group: ChunkGroup,
        module_graph: Vc<ModuleGraph>,
        extra_chunks: Vc<OutputAssets>,
        extra_referenced_assets: Vc<OutputAssets>,
        availability_info: AvailabilityInfo,
    ) -> Vc<Box<dyn OutputAsset>> {
        entry_chunk_group_asset(
            Vc::upcast_non_strict(self),
            path,
            chunk_group,
            module_graph,
            extra_chunks,
            extra_referenced_assets,
            availability_info,
        )
    }

    fn root_entry_chunk_group(
        self: Vc<Self>,
        path: FileSystemPath,
        chunk_group: ChunkGroup,
        module_graph: Vc<ModuleGraph>,
        extra_chunks: Vc<OutputAssets>,
        extra_referenced_assets: Vc<OutputAssets>,
    ) -> Vc<EntryChunkGroupResult> {
        self.entry_chunk_group(
            path,
            chunk_group,
            module_graph,
            extra_chunks,
            extra_referenced_assets,
            AvailabilityInfo::root(),
        )
    }

    fn root_entry_chunk_group_asset(
        self: Vc<Self>,
        path: FileSystemPath,
        chunk_group: ChunkGroup,
        module_graph: Vc<ModuleGraph>,
        extra_chunks: Vc<OutputAssets>,
        extra_referenced_assets: Vc<OutputAssets>,
    ) -> Vc<Box<dyn OutputAsset>> {
        entry_chunk_group_asset(
            Vc::upcast_non_strict(self),
            path,
            chunk_group,
            module_graph,
            extra_chunks,
            extra_referenced_assets,
            AvailabilityInfo::root(),
        )
    }

    fn chunk_group_assets(
        self: Vc<Self>,
        ident: Vc<AssetIdent>,
        chunk_group: ChunkGroup,
        module_graph: Vc<ModuleGraph>,
        availability_info: AvailabilityInfo,
    ) -> Vc<OutputAssetsWithReferenced> {
        chunk_group_assets(
            Vc::upcast_non_strict(self),
            ident,
            chunk_group,
            module_graph,
            availability_info,
        )
    }

    fn relative_path_from_chunk_root_to_project_root(self: Vc<Self>) -> Vc<RcStr> {
        relative_path_from_chunk_root_to_project_root(Vc::upcast_non_strict(self))
    }
}

#[turbo_tasks::function]
async fn relative_path_from_chunk_root_to_project_root(
    chunking_context: Vc<Box<dyn ChunkingContext>>,
) -> Result<Vc<RcStr>> {
    // Example,
    //   project root: /project/root
    //   output root: /project/root/dist
    //   chunk root path: /project/root/dist/ssr/chunks
    //   output_root_to_chunk_root: ../
    //
    // Example2,
    //   project root: /project/root
    //   output root: /project/out
    //   chunk root path: /project/out/ssr/chunks
    //   output_root_to_chunk_root: ../root
    //
    // From that we want to return  ../../../root to get from a path in `chunks` to a path in the
    // project root.

    let chunk_root_path = chunking_context.chunk_root_path().await?;
    let output_root = chunking_context.output_root().await?;
    let chunk_to_output_root = chunk_root_path.get_relative_path_to(&output_root);
    let Some(chunk_to_output_root) = chunk_to_output_root else {
        turbobail!(
            "expected chunk_root_path: {} to be inside of output_root: {}",
            chunking_context.chunk_root_path(),
            chunking_context.output_root()
        );
    };
    let output_root_to_chunk_root_path = chunking_context.output_root_to_root_path().await?;

    // Note we cannot use `normalize_path` here since it rejects paths that start with `../`
    Ok(Vc::cell(
        format!(
            "{}/{}",
            chunk_to_output_root, output_root_to_chunk_root_path
        )
        .into(),
    ))
}

#[turbo_tasks::function]
fn root_chunk_group_assets(
    chunking_context: Vc<Box<dyn ChunkingContext>>,
    ident: Vc<AssetIdent>,
    chunk_group: ChunkGroup,
    module_graph: Vc<ModuleGraph>,
) -> Vc<OutputAssetsWithReferenced> {
    chunking_context
        .root_chunk_group(ident, chunk_group, module_graph)
        .output_assets_with_referenced()
}

#[turbo_tasks::function]
fn evaluated_chunk_group_assets(
    chunking_context: Vc<Box<dyn ChunkingContext>>,
    ident: Vc<AssetIdent>,
    chunk_group: ChunkGroup,
    module_graph: Vc<ModuleGraph>,
    extra_chunks: Vc<OutputAssets>,
    availability_info: AvailabilityInfo,
) -> Vc<OutputAssetsWithReferenced> {
    chunking_context
        .evaluated_chunk_group(
            ident,
            chunk_group,
            module_graph,
            extra_chunks,
            availability_info,
        )
        .output_assets_with_referenced()
}

#[turbo_tasks::function]
async fn entry_chunk_group_asset(
    chunking_context: Vc<Box<dyn ChunkingContext>>,
    path: FileSystemPath,
    chunk_group: ChunkGroup,
    module_graph: Vc<ModuleGraph>,
    extra_chunks: Vc<OutputAssets>,
    extra_referenced_assets: Vc<OutputAssets>,
    availability_info: AvailabilityInfo,
) -> Result<Vc<Box<dyn OutputAsset>>> {
    Ok(*chunking_context
        .entry_chunk_group(
            path,
            chunk_group,
            module_graph,
            extra_chunks,
            extra_referenced_assets,
            availability_info,
        )
        .await?
        .asset)
}

#[turbo_tasks::function]
fn chunk_group_assets(
    chunking_context: Vc<Box<dyn ChunkingContext>>,
    ident: Vc<AssetIdent>,
    chunk_group: ChunkGroup,
    module_graph: Vc<ModuleGraph>,
    availability_info: AvailabilityInfo,
) -> Vc<OutputAssetsWithReferenced> {
    chunking_context
        .chunk_group(ident, chunk_group, module_graph, availability_info)
        .output_assets_with_referenced()
}