Unverified Commit 9ffb2fce authored by Tobias Koppers's avatar Tobias Koppers Committed by GitHub

Turbopack: track availability by chunk group (#98685)

### What?

Replaces Turbopack's retained available-module sets with compact
chunk-group bitmaps.

This is PR 5 of a six-PR stack, based on `canary` (#98733, #99686 and
#99749 are already merged):

1. #98823 — Pages Router dev client graph chaining
2. #99910 — regression test for Pages Router `_app` availability
(#99789)
3. #98734 — use graph-derived merged groups
4. #99750 — chunking takes a `ChunkGroupKey`
5. **This PR** — chunk-group availability bitmaps
6. #99050 — keyed chunk-group index lookups

### Why?

`AvailabilityInfo` previously retained every concrete module, module
batch, and async-loader item emitted by ancestor chunk groups. The same
module lists were duplicated across availability chains, increasing
memory use for large graphs.

The module graph already records which chunk groups contain each module.
Retaining only available group indices lets availability checks reuse
that information.

### How?

- Stores available chunk-group indices in a roaring bitmap
(`AvailableChunkGroups`), replacing `AvailableModules`.
- Determines module availability by intersecting its `ChunkGroupInfo`
membership bitmap with the available groups.
- Uses a batch's representative first module, because every module in a
batch has identical group membership.
- Tracks async-loader membership by the parent groups that emit each
loader, preserving nested loader deduplication.
- Scopes availability to its `ModuleGraph`: chunk-group indices only
mean something inside one graph's `ChunkGroupInfo`, so the graph is
stored alongside the bitmap and asserted on every use, and `translate`
re-expresses availability in another graph by mapping indices through
their canonical `ChunkGroupKey`s. Groups the target graph doesn't have
are dropped, which can only duplicate a module, never omit one.

Behavior is unchanged. Availability-dependent asset identifiers are
derived from the *identity* of the available chunk groups — each group
rendered via `ChunkGroupKey::ident_str` (module idents plus merge tags,
merged parents resolved recursively) and sorted — never from the raw
graph-local indices, which are only meaningful within a single
`ModuleGraph` and would collide across the per-endpoint graphs used in
development. Deterministic filenames change as a result; the snapshots
are updated accordingly and the module IDs they contain are identical.

One observable improvement: in Turbopack dev, `/_app` and the page are
chunked in the same graph (#98823), and availability is now tracked by
chunk-group membership, so modules shared by both are loaded only once.
The `// @gate !(turbopack && dev)` that #99910 put on the "loads modules
shared by _app and the page only once" assertion in
`app-document-import-order` is therefore stale, and this PR removes it.

### Verification

- `turbopack-core` — 164 passed
- `next-core` — 84 passed
- Turbopack snapshots — 126 passed
- Nested async availability coverage verifies shared-module and loader
deduplication
- Pages/App development and production suites, including
`404-page-router`, `server-navigation-error`, client-reference chunking,
and full `css-order`
- Turbopack dev `app-document-import-order` (now ungated) and
`pages-app-availability-boundary`, on this PR and on #99050
- Affected Cargo checks and Rust formatting

### Benchmarks

Measured on commits `64b73c08` (this PR) against `c543a06d` (#98823) —
the pre-rebase SHAs of this stack. The stack has since been rebased onto
newer canary; the refactor's code diff is byte-identical across that
rebase, so these numbers still characterise this patch, but they were
not re-measured on the current heads.

The two commits were one apart and differed only in Rust, so the JS
build was shared and the two native binaries were swapped in place with
their sha256 asserted before every run.

`next build --turbopack`, cold (`rm -rf .next`) every run, **3 runs per
side, sides interleaved**. Memory is the peak **aggregate RSS of the
whole build process tree**, sampled from `/proc` every 50 ms (GNU `time
-v` reports only the max of a single waited-for child, which understates
a multi-process build). Median shown, with min–max in brackets.
"disjoint" = the two sides' ranges do not overlap at all.

**Workloads where availability actually engages** — it only does work
when a chunk group inherits availability from a parent, i.e. dynamic
imports or multiple entries:

| Workload | Metric | base | this PR | Δ | |
|---|---|---|---|---|---|
| 200 routes × 6 dynamic imports | build | 108.7 s [105.7–111.6] |
**75.9 s** [74.0–78.0] | **−30.1%** | disjoint |
| | peak RSS | 3462 MB [3361–3467] | **3093 MB** [3052–3153] |
**−10.7%** | disjoint |
| 750 routes, no dynamic imports | build | 314.5 s [313.1–323.0] |
**292.4 s** [289.4–311.2] | **−7.0%** | disjoint |
| | peak RSS | 9220 MB [9212–9687] | 10904 MB [9196–11164] | — |
inconclusive |

**Control workloads** — single entry, no `import()`, so availability is
effectively root everywhere and there is nothing to improve:

| Workload | build Δ | peak RSS Δ | |
|---|---|---|---|
| `bench/module-cost` (~18.6k static modules) | −3.3% | 0.0% | noise |
| `bench/heavy-npm-deps` (1 page, heavy deps) | −1.9% | −1.6% | noise |

Build time improves monotonically with how much availability a workload
exercises (−1.9%, −3.3%, −7.0%, −30.1%). Emitted `.js` file counts are
identical between sides on every workload, consistent with unchanged
behaviour.

Caveats: the dynamic-import workload is synthetic and its 30% figure is
not a typical-app claim; n=3 with no statistical test; aggregate RSS
double-counts pages shared between processes; the 750-route memory
result is bimodal on this PR's side (its own range spans the base
median) and is therefore reported as inconclusive rather than a
regression. The many-pages fixture was reduced from its stock 3000
routes to 750 because 3000 exceeds the 16 GB benchmark machine and
thrashes, which would measure swap rather than chunking.

<!-- NEXT_JS_LLM -->


<!-- fleet 4f67c6f7-bbe2-454b-9a17-822a60ef8f7e -->
Co-authored-by: 's avatarvercel-fleet-prod[bot] <318278635+vercel-fleet-prod[bot]@users.noreply.github.com>
Co-authored-by: 's avatarTobias Koppers <1365881+sokra@users.noreply.github.com>
parent 9bbacd4d
......@@ -942,17 +942,27 @@ impl PageEndpoint {
let module_graph = self.client_module_graph();
let evaluatable_assets = client_entry_modules(self.client_evaluatable_assets()).await?;
// Like App Router layouts, `/_app` is always loaded before the page. Chunk it first so
// the page's chunks don't include modules that the browser already downloaded with
// `/_app`.
// Like App Router layouts, `/_app` is always loaded before the page. Treat it as
// already available so the page's chunks don't include modules that the browser
// already downloaded with `/_app`. `client_module_graph` chains `/_app`'s entry group
// into this page's graph, so the group resolves within the very graph this page is
// chunked with.
let availability_info = if this.pathname == "/_app" {
AvailabilityInfo::root()
} else {
this.pages_project
.app_page_endpoint()
.client_chunk_group()
AvailabilityInfo::root()
.with_chunk_group(
module_graph.to_resolved().await?,
ChunkGroupKey::Entry(
client_entry_modules(
this.pages_project
.app_page_endpoint()
.client_evaluatable_assets(),
)
.await?,
),
)
.await?
.availability_info
};
let client_chunk_group = client_chunking_context.evaluated_chunk_group(
AssetIdent::from_path(this.page.await?.base_path.clone()).into_vc(),
......
......@@ -17,10 +17,6 @@ describe('Root components import order', () => {
})
})
// Turbopack dev chunks `_app` from its own module graph, so its batches (and therefore its
// availability info) don't match those in the page's graph, and the shared module is emitted
// for both entries.
// @gate !(turbopack && dev)
it('loads modules shared by _app and the page only once', async () => {
const requests: Set<string> = new Set()
await next.browser('/', {
......
......@@ -104,6 +104,7 @@ An [`OutputAsset`] is generated for each [`Chunk`]. The [`ChunkingContext`] impl
## Available Modules
The chunking process tracks which modules are already available in parent chunk groups via [`AvailableModules`], to avoid duplication in nested chunk groups.
The chunking process tracks which parent chunk groups are already available in [`AvailabilityInfo`], to avoid duplication in nested chunk groups. A module (or module batch) counts as available when its chunk group membership bitmap from [`ChunkGroupInfo`] intersects the set of available chunk groups, so only chunk group identities are retained instead of the full module sets.
[`AvailableModules`]: crate::chunk::available_modules::AvailableModules
[`AvailabilityInfo`]: crate::chunk::availability_info::AvailabilityInfo
[`ChunkGroupInfo`]: crate::module_graph::chunk_group_info::ChunkGroupInfo
......@@ -2,11 +2,14 @@ use anyhow::Result;
use bincode::{Decode, Encode};
use bitfield::bitfield;
use turbo_rcstr::RcStr;
use turbo_tasks::{OperationVc, ResolvedVc};
use turbo_tasks::ResolvedVc;
use crate::{
chunk::available_modules::{AvailableModules, AvailableModulesSet},
chunk::available_chunk_groups::AvailableChunkGroups,
module::Modules,
module_graph::{
ModuleGraph, chunk_group_info::ChunkGroupKey, module_batch::ChunkableModuleOrBatch,
},
};
bitfield! {
......@@ -21,8 +24,8 @@ bitfield! {
#[derive(Eq, PartialEq, Hash, Clone, Copy, Debug, Encode, Decode)]
pub struct AvailabilityInfo {
flags: AvailabilityFlags,
/// There are modules already available.
available_modules: Option<ResolvedVc<AvailableModules>>,
/// Chunk groups whose contents are already available.
available_chunk_groups: Option<ResolvedVc<AvailableChunkGroups>>,
/// The root ChunkGroup::Entry
entry_group: Option<ResolvedVc<Modules>>,
}
......@@ -31,42 +34,78 @@ impl AvailabilityInfo {
pub fn root() -> Self {
Self {
flags: AvailabilityFlags::default(),
available_modules: None,
available_chunk_groups: None,
entry_group: None,
}
}
pub fn available_modules(&self) -> Option<ResolvedVc<AvailableModules>> {
self.available_modules
pub fn available_chunk_groups(&self) -> Option<ResolvedVc<AvailableChunkGroups>> {
self.available_chunk_groups
}
pub async fn with_modules(self, modules: OperationVc<AvailableModulesSet>) -> Result<Self> {
Ok(if let Some(available_modules) = self.available_modules {
Self {
flags: self.flags,
available_modules: Some(
available_modules
.with_modules(modules)
pub async fn with_chunk_group(
self,
module_graph: ResolvedVc<ModuleGraph>,
chunk_group: ChunkGroupKey,
) -> Result<Self> {
let chunk_group = *module_graph
.chunk_group_info()
.get_index_of(chunk_group)
.await? as u32;
Ok(Self {
flags: self.flags,
available_chunk_groups: Some(
if let Some(available_chunk_groups) = self.available_chunk_groups {
available_chunk_groups
.with_chunk_group(*module_graph, chunk_group)
.to_resolved()
.await?
} else {
AvailableChunkGroups::new(*module_graph, chunk_group)
.to_resolved()
.await?,
),
entry_group: self.entry_group,
}
} else {
Self {
flags: self.flags,
available_modules: Some(AvailableModules::new(modules).to_resolved().await?),
entry_group: self.entry_group,
}
.await?
},
),
entry_group: self.entry_group,
})
}
/// Whether the module or module batch is already part of one of the available chunk groups.
pub async fn is_available(
&self,
module_graph: ResolvedVc<ModuleGraph>,
item: ChunkableModuleOrBatch,
) -> Result<bool> {
let Some(available_chunk_groups) = self.available_chunk_groups else {
return Ok(false);
};
let available_chunk_groups = available_chunk_groups.await?;
let chunk_group_info = module_graph.chunk_group_info().await?;
let module = match item {
ChunkableModuleOrBatch::Module(module) => ResolvedVc::upcast(module),
// All modules of a batch have the same chunk groups, so the first one is
// representative.
ChunkableModuleOrBatch::Batch(batch) => match batch.await?.modules.first() {
Some(&module) => ResolvedVc::upcast(module),
None => return Ok(false),
},
ChunkableModuleOrBatch::None(_) => return Ok(false),
};
Ok(chunk_group_info
.module_chunk_groups
.await?
.get(&module)
.is_some_and(|groups| {
!groups.is_disjoint(available_chunk_groups.chunk_groups(module_graph))
}))
}
pub fn in_async_module(self) -> Self {
let mut flags = self.flags;
flags.set_is_in_async_module(true);
Self {
flags,
available_modules: self.available_modules,
available_chunk_groups: self.available_chunk_groups,
entry_group: self.entry_group,
}
}
......@@ -78,7 +117,7 @@ impl AvailabilityInfo {
pub fn with_entry_group(self, entry_group: ResolvedVc<Modules>) -> Self {
Self {
flags: self.flags,
available_modules: self.available_modules,
available_chunk_groups: self.available_chunk_groups,
entry_group: Some(entry_group),
}
}
......@@ -88,10 +127,12 @@ impl AvailabilityInfo {
}
pub async fn ident(&self) -> Result<Option<RcStr>> {
Ok(if let Some(available_modules) = self.available_modules {
Some(available_modules.hash().await?.to_string().into())
} else {
None
})
Ok(
if let Some(available_chunk_groups) = self.available_chunk_groups {
Some(available_chunk_groups.hash().await?.to_string().into())
} else {
None
},
)
}
}
use anyhow::Result;
use bincode::{Decode, Encode};
use turbo_tasks::{
FxIndexSet, JoinIterExt, OperationVc, ReadRef, ResolvedVc, ValueToString, Vc, turbofmt,
};
use turbo_tasks_hash::Xxh3Hash64Hasher;
use crate::{
chunk::ChunkableModule,
module::Module,
module_graph::module_batch::{ChunkableModuleOrBatch, IdentStrings, ModuleBatch},
};
#[turbo_tasks::task_input]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, Encode, Decode)]
pub enum AvailableModuleItem {
Module(ResolvedVc<Box<dyn ChunkableModule>>),
Batch(ResolvedVc<ModuleBatch>),
AsyncLoader(ResolvedVc<Box<dyn ChunkableModule>>),
}
impl AvailableModuleItem {
pub async fn ident_strings(&self) -> Result<IdentStrings> {
Ok(match self {
AvailableModuleItem::Module(module) => {
IdentStrings::Single(module.ident().to_string().owned().await?)
}
AvailableModuleItem::Batch(batch) => {
IdentStrings::Multiple(batch.ident_strings().await?)
}
AvailableModuleItem::AsyncLoader(module) => {
IdentStrings::Single(turbofmt!("async loader {}", module.ident()).await?)
}
})
}
}
impl From<ChunkableModuleOrBatch> for AvailableModuleItem {
fn from(value: ChunkableModuleOrBatch) -> Self {
match value {
ChunkableModuleOrBatch::Module(module) => AvailableModuleItem::Module(module),
ChunkableModuleOrBatch::Batch(batch) => AvailableModuleItem::Batch(batch),
ChunkableModuleOrBatch::None(id) => {
panic!("Cannot create AvailableModuleItem from None({})", id)
}
}
}
}
#[turbo_tasks::value(transparent)]
#[derive(Debug, Clone)]
pub struct AvailableModulesSet(
#[bincode(with = "turbo_bincode::indexset")] FxIndexSet<AvailableModuleItem>,
);
/// Allows to gather information about which assets are already available.
/// Adding more roots will form a linked list like structure to allow caching
/// `include` queries.
#[turbo_tasks::value]
pub struct AvailableModules {
parent: Option<ResolvedVc<AvailableModules>>,
modules: OperationVc<AvailableModulesSet>,
}
#[turbo_tasks::value_impl]
impl AvailableModules {
#[turbo_tasks::function]
pub fn new(modules: OperationVc<AvailableModulesSet>) -> Vc<Self> {
AvailableModules {
parent: None,
modules,
}
.cell()
}
#[turbo_tasks::function]
pub fn with_modules(
self: ResolvedVc<Self>,
modules: OperationVc<AvailableModulesSet>,
) -> Result<Vc<Self>> {
Ok(AvailableModules {
parent: Some(self),
modules,
}
.cell())
}
#[turbo_tasks::function]
pub async fn hash(&self) -> Result<Vc<u64>> {
let mut hasher = Xxh3Hash64Hasher::new();
if let Some(parent) = self.parent {
hasher.write_value(parent.hash().await?);
} else {
hasher.write_value(0u64);
}
let item_idents = self
.modules
.connect()
.await?
.iter()
.map(async |&module| module.ident_strings().await)
.join()
.await;
for idents in item_idents {
let idents = idents?;
match idents {
IdentStrings::Single(ident) => hasher.write_value(ident),
IdentStrings::Multiple(idents) => {
for ident in &idents {
hasher.write_value(ident);
}
}
IdentStrings::None => {}
}
}
Ok(Vc::cell(hasher.finish()))
}
#[turbo_tasks::function]
pub async fn get(&self, item: AvailableModuleItem) -> Result<Vc<bool>> {
if self.modules.connect().await?.contains(&item) {
return Ok(Vc::cell(true));
};
if let Some(parent) = self.parent {
return Ok(parent.get(item));
}
Ok(Vc::cell(false))
}
#[turbo_tasks::function]
pub async fn snapshot(&self) -> Result<Vc<AvailableModulesSnapshot>> {
let modules = self.modules.connect().await?;
let parent = if let Some(parent) = self.parent {
Some(parent.snapshot().await?)
} else {
None
};
Ok(AvailableModulesSnapshot { parent, modules }.cell())
}
}
#[turbo_tasks::value(serialization = "skip")]
#[derive(Debug, Clone)]
pub struct AvailableModulesSnapshot {
parent: Option<ReadRef<AvailableModulesSnapshot>>,
modules: ReadRef<AvailableModulesSet>,
}
impl AvailableModulesSnapshot {
pub fn get(&self, item: AvailableModuleItem) -> bool {
self.modules.contains(&item) || self.parent.as_ref().is_some_and(|parent| parent.get(item))
}
}
......@@ -6,9 +6,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
use smallvec::SmallVec;
use tracing::Instrument;
use turbo_rcstr::rcstr;
use turbo_tasks::{
FxIndexSet, JoinIterExt, OperationVc, ResolvedVc, TryFlatJoinIterExt, TryJoinIterExt, Vc,
};
use turbo_tasks::{FxIndexSet, JoinIterExt, ResolvedVc, TryFlatJoinIterExt, TryJoinIterExt, Vc};
use super::{
ChunkItemWithAsyncModuleInfo, ChunkingContext, availability_info::AvailabilityInfo,
......@@ -17,7 +15,6 @@ use super::{
use crate::{
chunk::{
ChunkGroupContent, ChunkGroupContentInner, ChunkableModule, ChunkingType, Chunks,
available_modules::{AvailableModuleItem, AvailableModulesSet},
chunk_item_batch::{ChunkItemBatchGroup, ChunkItemOrBatchWithAsyncModuleInfo},
},
emit_collect::CollectingModule,
......@@ -76,7 +73,6 @@ pub async fn make_chunk_group(
batch_groups,
async_modules,
collecting_modules,
available_modules: _,
} = &*inner;
let async_module_info = module_graph.async_module_info();
......@@ -231,9 +227,17 @@ pub async fn chunk_group_content(
let entry_group: Option<ResolvedVc<Modules>> =
entry_group_modules(&chunk_groups).map(ResolvedVc::cell);
let available_chunk_groups = chunk_groups
.iter()
.map(ChunkGroup::key)
.collect::<SmallVec<[_; 1]>>();
let chunk_group_content = chunk_group_content_operation(module_graph, chunk_groups, options);
let available_modules = available_modules_operation(chunk_group_content);
let availability_info = availability_info.with_modules(available_modules).await?;
let mut availability_info = availability_info;
for available_chunk_group in available_chunk_groups {
availability_info = availability_info
.with_chunk_group(module_graph, available_chunk_group)
.await?;
}
let availability_info = if let Some(entry_group) = entry_group {
availability_info.with_entry_group(entry_group)
......@@ -277,13 +281,6 @@ fn entry_group_modules(chunk_groups: &[ChunkGroup]) -> Option<Vec<ResolvedVc<Box
has_entry_group.then(|| modules.into_iter().collect())
}
#[turbo_tasks::function(operation)]
async fn available_modules_operation(
chunk_group_content: OperationVc<ChunkGroupContentInner>,
) -> Result<Vc<AvailableModulesSet>> {
Ok(*chunk_group_content.connect().await?.available_modules)
}
#[turbo_tasks::function(operation)]
async fn chunk_group_content_operation(
module_graph: ResolvedVc<ModuleGraph>,
......@@ -320,10 +317,18 @@ async fn chunk_group_content_operation(
.try_join()
.await?;
let chunk_group_info = chunk_group_info.await?;
let available_modules = match availability_info.available_modules() {
Some(available_modules) => Some(available_modules.snapshot().await?),
let available_chunk_groups = match availability_info.available_chunk_groups() {
Some(available_chunk_groups) => {
let available_chunk_groups = available_chunk_groups.await?;
// The bitmap indexes this graph's `ChunkGroupInfo`; indices of another graph would
// resolve to unrelated chunk groups and silently drop modules.
available_chunk_groups.assert_module_graph(module_graph);
Some(available_chunk_groups)
}
None => None,
};
let module_chunk_groups = chunk_group_info.module_chunk_groups.await?;
let async_loader_chunk_groups = chunk_group_info.async_loader_chunk_groups.await?;
// The ordered entries of all groups, in list order. An entry shared by several groups is
// traversed once.
......@@ -380,9 +385,14 @@ async fn chunk_group_content_operation(
return Ok(GraphTraversalAction::Exclude);
};
let is_available = available_modules
.as_ref()
.is_some_and(|available_modules| available_modules.get(chunkable_node.into()));
let is_available = module_batches_graph
.get_first_module(chunkable_node)
.and_then(|module| module_chunk_groups.get(&module))
.is_some_and(|groups| {
available_chunk_groups.as_ref().is_some_and(|available| {
!groups.is_disjoint(available.chunk_groups(module_graph))
})
});
let Some((_, edge)) = parent_info else {
// An entry from the entries list
......@@ -420,10 +430,12 @@ async fn chunk_group_content_operation(
let chunkable_module =
ResolvedVc::try_downcast(edge.module.unwrap())
.context("Module in async chunking edge is not chunkable")?;
let is_async_loader_available =
available_modules.as_ref().is_some_and(|available_modules| {
available_modules
.get(AvailableModuleItem::AsyncLoader(chunkable_module))
let is_async_loader_available = async_loader_chunk_groups
.get(&ResolvedVc::upcast(chunkable_module))
.is_some_and(|groups| {
available_chunk_groups.as_ref().is_some_and(|available| {
!groups.is_disjoint(available.chunk_groups(module_graph))
})
});
if !is_async_loader_available {
state.async_modules.insert(chunkable_module);
......@@ -471,25 +483,6 @@ async fn chunk_group_content_operation(
)?;
}
// This needs to use the unmerged items
let available_modules: FxIndexSet<AvailableModuleItem> = state
.chunkable_items
.iter()
.copied()
.map(Into::into)
.chain(
state
.async_modules
.iter()
.copied()
.map(AvailableModuleItem::AsyncLoader),
)
.collect();
let available_modules: ResolvedVc<AvailableModulesSet> =
Vc::<AvailableModulesSet>::cell(available_modules)
.to_resolved()
.await?;
let should_merge_modules = if should_merge_modules {
let merged_modules = module_graph.merged_modules();
let merged_modules_ref = merged_modules.await?;
......@@ -552,7 +545,6 @@ async fn chunk_group_content_operation(
batch_groups,
async_modules: state.async_modules,
collecting_modules: state.collecting_modules,
available_modules,
}
.cell())
}
......
pub mod availability_info;
pub mod available_modules;
pub mod available_chunk_groups;
pub mod chunk_group;
pub mod chunk_id_strategy;
pub(crate) mod chunk_item_batch;
......@@ -37,7 +37,7 @@ pub use crate::chunk::{
};
use crate::{
asset::Asset,
chunk::{availability_info::AvailabilityInfo, available_modules::AvailableModulesSet},
chunk::availability_info::AvailabilityInfo,
emit_collect::CollectingModule,
ident::AssetIdent,
module::Module,
......@@ -528,7 +528,6 @@ pub struct ChunkGroupContentInner {
/// All modules that implement CollectingModule
#[bincode(with = "turbo_bincode::indexset")]
pub collecting_modules: FxIndexSet<ResolvedVc<Box<dyn CollectingModule>>>,
pub available_modules: ResolvedVc<AvailableModulesSet>,
}
pub struct ChunkGroupContent {
......
......@@ -17,6 +17,7 @@ use turbo_tasks::{
FxIndexMap, FxIndexSet, NonLocalValue, ResolvedVc, TaskInput, TryJoinIterExt, ValueToString,
Vc, debug::ValueDebugFormat, turbofmt,
};
use turbo_tasks_hash::{DeterministicHash, DeterministicHasher};
use crate::{
chunk::ChunkingType,
......@@ -80,6 +81,23 @@ impl Hash for RoaringBitmapWrapper {
}
}
impl DeterministicHash for RoaringBitmapWrapper {
fn deterministic_hash<H: DeterministicHasher>(&self, state: &mut H) {
struct HasherWriter<'a, H: DeterministicHasher>(&'a mut H);
impl<H: DeterministicHasher> std::io::Write for HasherWriter<'_, H> {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
self.0.write_bytes(buf);
Ok(buf.len())
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
// The serialized form is stable across platforms, unlike the in-memory representation.
self.0.serialize_into(HasherWriter(state)).unwrap();
}
}
#[turbo_tasks::value(transparent, cell = "keyed")]
pub struct ModuleToChunkGroups(FxHashMap<ResolvedVc<Box<dyn Module>>, RoaringBitmapWrapper>);
......@@ -98,6 +116,8 @@ pub struct OptionChunkGroupWithIndex(Option<ChunkGroupWithIndex>);
#[turbo_tasks::value]
pub struct ChunkGroupInfo {
pub module_chunk_groups: ResolvedVc<ModuleToChunkGroups>,
/// For each async module, the chunk groups that contain its async loader.
pub async_loader_chunk_groups: ResolvedVc<ModuleToChunkGroups>,
#[bincode(with = "turbo_bincode::indexset")]
pub chunk_groups: FxIndexSet<ChunkGroup>,
#[turbo_tasks(unsafe_ignore)]
......@@ -142,7 +162,7 @@ impl ChunkGroupInfo {
if cfg!(debug_assertions) {
bail!(
"Couldn't find chunk group index for {} in {}",
key.debug_str(self.chunk_group_keys.clone()).await?,
key.debug_str(&self.chunk_group_keys).await?,
self.chunk_groups
.iter()
.map(|c| c.debug_str(self))
......@@ -467,9 +487,20 @@ pub enum ChunkGroupKey {
}
impl ChunkGroupKey {
pub async fn debug_str(
/// A stable identity of this chunk group, independent of the module graph it was discovered
/// in.
///
/// The result contains only module idents and merge tags, never a [`ChunkGroupId`], which is
/// an index into one [`ChunkGroupInfo`] and denotes an unrelated chunk group in another: the
/// parent of a merged chunk group is resolved through `keys` and rendered recursively.
///
/// [`crate::chunk::available_chunk_groups::AvailableChunkGroups::hash`] derives output file
/// names from this, so two chunk groups must render equally exactly when they are the same
/// chunk group. Changing the rendering renames assets; adding anything graph-local to it is a
/// correctness bug.
pub async fn ident_str(
&self,
keys: impl std::ops::Index<usize, Output = Self>,
keys: &(impl std::ops::Index<usize, Output = Self> + ?Sized),
) -> Result<String> {
Ok(match self {
ChunkGroupKey::Entry(entries) => format!(
......@@ -492,7 +523,7 @@ impl ChunkGroupKey {
ChunkGroupKey::IsolatedMerged { parent, merge_tag } => {
format!(
"IsolatedMerged {{ parent: {}, merge_tag: {:?} }}",
Box::pin(keys.index(parent.0 as usize).clone().debug_str(keys)).await?,
Box::pin(keys.index(parent.0 as usize).ident_str(keys)).await?,
merge_tag
)
}
......@@ -510,12 +541,24 @@ impl ChunkGroupKey {
ChunkGroupKey::SharedMerged { parent, merge_tag } => {
format!(
"SharedMerged {{ parent: {}, merge_tag: {:?} }}",
Box::pin(keys.index(parent.0 as usize).clone().debug_str(keys)).await?,
Box::pin(keys.index(parent.0 as usize).ident_str(keys)).await?,
merge_tag
)
}
})
}
/// How this chunk group is shown in debug output.
///
/// Delegates to [`Self::ident_str`], which already renders the chunk group unambiguously.
/// Debug output is free to diverge from it, but note that `ident_str` must stay stable because
/// asset idents are derived from it -- change this wrapper rather than `ident_str` itself.
pub async fn debug_str(
&self,
keys: &(impl std::ops::Index<usize, Output = Self> + ?Sized),
) -> Result<String> {
self.ident_str(keys).await
}
}
#[turbo_tasks::task_input]
......@@ -554,6 +597,10 @@ pub async fn compute_chunk_group_info(graph: &ModuleGraph) -> Result<Vc<ChunkGro
// that module is part of.
let mut module_chunk_groups: FxHashMap<ResolvedVc<Box<dyn Module>>, RoaringBitmapWrapper> =
FxHashMap::default();
let mut async_loader_chunk_groups: FxHashMap<
ResolvedVc<Box<dyn Module>>,
RoaringBitmapWrapper,
> = FxHashMap::default();
let module_count = graph
.graphs
......@@ -663,9 +710,19 @@ pub async fn compute_chunk_group_info(graph: &ModuleGraph) -> Result<Vc<ChunkGro
let chunk_groups = if let Some((parent, ref_data, _)) = parent_info {
match &ref_data.chunking_type {
ChunkingType::Parallel { .. } => ChunkGroupInheritance::Inherit(parent),
ChunkingType::Async => ChunkGroupInheritance::ChunkGroup(Either::Left(
std::iter::once(ChunkGroupKey::Async(node)),
)),
ChunkingType::Async => {
// The async loader for `node` is emitted in every chunk group that
// contains the referencing module, so availability checks for async
// loaders can use the same bitmap intersection as regular modules.
let parent_groups = module_chunk_groups
.get(&parent)
.context("Module chunk group not found")?;
**async_loader_chunk_groups.entry(node).or_default() |=
&**parent_groups;
ChunkGroupInheritance::ChunkGroup(Either::Left(std::iter::once(
ChunkGroupKey::Async(node),
)))
}
ChunkingType::Isolated {
merge_tag: None, ..
} => ChunkGroupInheritance::ChunkGroup(Either::Left(std::iter::once(
......@@ -881,7 +938,7 @@ pub async fn compute_chunk_group_info(graph: &ModuleGraph) -> Result<Vc<ChunkGro
result.push(format!(
" {:?}: {}",
i,
key.debug_str(chunk_groups_map.keys()).await?
key.debug_str(&chunk_groups_map.keys()).await?
));
}
result.push("# Module buckets:".to_string());
......@@ -959,6 +1016,7 @@ pub async fn compute_chunk_group_info(graph: &ModuleGraph) -> Result<Vc<ChunkGro
Ok(ChunkGroupInfo {
module_chunk_groups: ResolvedVc::cell(module_chunk_groups),
async_loader_chunk_groups: ResolvedVc::cell(async_loader_chunk_groups),
chunk_group_keys: chunk_groups_map.keys().cloned().collect(),
chunking_heuristics: ChunkingHeuristicsInfo {
clusters: chunk_group_clusters,
......
......@@ -24,7 +24,7 @@ use crate::{
module_graph::{
GraphTraversalAction, ModuleGraph,
chunk_group_info::{ChunkGroupInfo, ChunkGroupKey, RoaringBitmapWrapper},
module_batch::{ModuleBatch, ModuleBatchGroup, ModuleOrBatch},
module_batch::{ChunkableModuleOrBatch, ModuleBatch, ModuleBatchGroup, ModuleOrBatch},
traced_di_graph::{TracedDiGraph, iter_neighbors_rev},
},
};
......@@ -71,6 +71,8 @@ pub struct ModuleBatchesGraph {
#[bincode(with_serde)]
entries: FxHashMap<ResolvedVc<Box<dyn Module>>, NodeIndex>,
batch_groups: FxHashMap<ModuleOrBatch, ResolvedVc<ModuleBatchGroup>>,
/// The first module of each batch. All modules in a batch have the same chunk groups.
batch_first_modules: FxHashMap<ResolvedVc<ModuleBatch>, ResolvedVc<Box<dyn Module>>>,
/// For chunk groups where the postorder of entries is different than the order of the
/// `ChunkGroup::entries()` this contains Some with the postorder list of entries of that chunk
......@@ -137,6 +139,17 @@ impl ModuleBatchesGraph {
Ok(*self.graph.node_weight(entry).unwrap())
}
pub(crate) fn get_first_module(
&self,
item: ChunkableModuleOrBatch,
) -> Option<ResolvedVc<Box<dyn Module>>> {
match item {
ChunkableModuleOrBatch::Module(module) => Some(ResolvedVc::upcast(module)),
ChunkableModuleOrBatch::Batch(batch) => self.batch_first_modules.get(&batch).copied(),
ChunkableModuleOrBatch::None(_) => None,
}
}
// Clippy complains but there's a type error without the bound
#[allow(clippy::implied_bounds_in_impls)]
/// Traverses all reachable edges in dfs order. The preorder visitor can be used to
......@@ -821,6 +834,26 @@ pub async fn compute_module_batches(
.try_join()
.await?;
let batch_first_modules = pre_batches
.batches
.iter()
.zip(&batches)
.filter_map(|(pre_batch, item)| {
let ModuleOrBatch::Batch(batch) = item else {
return None;
};
pre_batch.items.iter().find_map(|item| match item {
PreBatchItem::ParallelModule(module)
if ResolvedVc::try_downcast::<Box<dyn ChunkableModule>>(*module)
.is_some() =>
{
Some((*batch, *module))
}
_ => None,
})
})
.collect();
// Create the batch groups by grouping batches with the same chunk groups
let mut batch_groups: FxHashMap<_, Vec<_>> = FxHashMap::default();
for (i, pre_batch) in pre_batches.batches.iter().enumerate() {
......@@ -1029,6 +1062,7 @@ pub async fn compute_module_batches(
graph: TracedDiGraph(graph),
entries,
batch_groups,
batch_first_modules,
ordered_entries,
}
.cell())
......
......@@ -65,23 +65,24 @@ impl AsyncLoaderModule {
&self,
module_graph: Vc<ModuleGraph>,
) -> Result<Vc<OutputAssetsWithReferenced>> {
if let Some(chunk_items) = self.availability_info.available_modules() {
let inner_module = ResolvedVc::upcast(self.inner);
let batches = module_graph
.module_batches(self.chunking_context.batching_config())
.await?;
let module_or_batch = batches.get_entry(inner_module).await?;
if let Some(chunkable_module_or_batch) =
ChunkableModuleOrBatch::from_module_or_batch(module_or_batch)
&& *chunk_items.get(chunkable_module_or_batch.into()).await?
{
return Ok(OutputAssetsWithReferenced {
assets: ResolvedVc::cell(vec![]),
referenced_assets: ResolvedVc::cell(vec![]),
references: ResolvedVc::cell(vec![]),
}
.cell());
let inner_module = ResolvedVc::upcast(self.inner);
let batches = module_graph
.module_batches(self.chunking_context.batching_config())
.await?;
let module_or_batch = batches.get_entry(inner_module).await?;
if let Some(chunkable_module_or_batch) =
ChunkableModuleOrBatch::from_module_or_batch(module_or_batch)
&& self
.availability_info
.is_available(module_graph.to_resolved().await?, chunkable_module_or_batch)
.await?
{
return Ok(OutputAssetsWithReferenced {
assets: ResolvedVc::cell(vec![]),
referenced_assets: ResolvedVc::cell(vec![]),
references: ResolvedVc::cell(vec![]),
}
.cell());
}
Ok(self.chunking_context.chunk_group_assets(
self.inner.ident(),
......
......@@ -76,24 +76,25 @@ impl ManifestAsyncModule {
self: ResolvedVc<Self>,
) -> Result<Vc<OutputAssetsWithReferenced>> {
let this = self.await?;
if let Some(chunk_items) = this.availability_info.available_modules() {
let inner_module = ResolvedVc::upcast(this.inner);
let batches = this
.module_graph
.module_batches(this.chunking_context.batching_config())
.await?;
let module_or_batch = batches.get_entry(inner_module).await?;
if let Some(chunkable_module_or_batch) =
ChunkableModuleOrBatch::from_module_or_batch(module_or_batch)
&& *chunk_items.get(chunkable_module_or_batch.into()).await?
{
return Ok(OutputAssetsWithReferenced {
assets: ResolvedVc::cell(vec![]),
referenced_assets: ResolvedVc::cell(vec![]),
references: ResolvedVc::cell(vec![]),
}
.cell());
let inner_module = ResolvedVc::upcast(this.inner);
let batches = this
.module_graph
.module_batches(this.chunking_context.batching_config())
.await?;
let module_or_batch = batches.get_entry(inner_module).await?;
if let Some(chunkable_module_or_batch) =
ChunkableModuleOrBatch::from_module_or_batch(module_or_batch)
&& this
.availability_info
.is_available(this.module_graph, chunkable_module_or_batch)
.await?
{
return Ok(OutputAssetsWithReferenced {
assets: ResolvedVc::cell(vec![]),
referenced_assets: ResolvedVc::cell(vec![]),
references: ResolvedVc::cell(vec![]),
}
.cell());
}
let chunk_item = self.as_chunk_item(*this.module_graph, *this.chunking_context);
let chunk = this
......@@ -143,11 +144,11 @@ impl ManifestAsyncModule {
pub async fn content_ident(&self) -> Result<Vc<AssetIdent>> {
let ident = self.inner.ident();
Ok(
if let Some(available_modules) = self.availability_info.available_modules() {
if let Some(availability_ident) = self.availability_info.ident().await? {
ident
.owned()
.await?
.with_modifier(available_modules.hash().await?.to_string().into())
.with_modifier(availability_ident)
.into_vc()
} else {
ident
......
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
"output/1ece_tests_snapshot_basic-tree-shake_dynamic-import_input_index_1ilscbcayntrz.js",
{"otherChunks":["output/1jsg_tests_snapshot_basic-tree-shake_dynamic-import_input_lib_1y039z71s70lw.js","output/1jsg_tests_snapshot_basic-tree-shake_dynamic-import_input_index_17se2p5tp_9aa.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic-tree-shake/dynamic-import/input/index.js [test] (ecmascript)"]}
"output/1ece_tests_snapshot_basic-tree-shake_dynamic-import_input_index_0prsku-t03dbh.js",
{"otherChunks":["output/1jsg_tests_snapshot_basic-tree-shake_dynamic-import_input_lib_0nr8lpipo84h8.js","output/1jsg_tests_snapshot_basic-tree-shake_dynamic-import_input_index_17se2p5tp_9aa.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic-tree-shake/dynamic-import/input/index.js [test] (ecmascript)"]}
]);
// Dummy runtime
\ No newline at end of file
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/1jsg_tests_snapshot_basic-tree-shake_dynamic-import_input_lib_1y039z71s70lw.js",
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/1jsg_tests_snapshot_basic-tree-shake_dynamic-import_input_lib_0nr8lpipo84h8.js",
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic-tree-shake/dynamic-import/input/lib.js [test] (ecmascript, async loader)", ((__turbopack_context__) => {
__turbopack_context__.v((parentImport) => {
......
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/0_9x_turbopack-tests_tests_snapshot_basic_async_chunk_input_import_1ka8r7j6v97-0.js",
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/0_9x_turbopack-tests_tests_snapshot_basic_async_chunk_input_import_1cmdia814mpg5.js",
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/async_chunk/input/import.js [test] (ecmascript, async loader)", ((__turbopack_context__) => {
__turbopack_context__.v((parentImport) => {
......
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
"output/0rv8_turbopack-tests_tests_snapshot_basic_async_chunk_input_index_0ct4fl_82tnfj.js",
{"otherChunks":["output/0_9x_turbopack-tests_tests_snapshot_basic_async_chunk_input_import_1ka8r7j6v97-0.js","output/1do3_crates_turbopack-tests_tests_snapshot_basic_async_chunk_input_1tjv7ofn7-zgw._.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/async_chunk/input/index.js [test] (ecmascript)"]}
"output/0rv8_turbopack-tests_tests_snapshot_basic_async_chunk_input_index_0o3coff-053h8.js",
{"otherChunks":["output/0_9x_turbopack-tests_tests_snapshot_basic_async_chunk_input_import_1cmdia814mpg5.js","output/1do3_crates_turbopack-tests_tests_snapshot_basic_async_chunk_input_1tjv7ofn7-zgw._.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/async_chunk/input/index.js [test] (ecmascript)"]}
]);
// Dummy runtime
\ No newline at end of file
import { shared } from './shared'
export function first() {
return Promise.all([import('./second'), import('./third')]).then(
([{ second }, { third }]) => shared + second + third
)
}
import { shared } from './shared'
export const second = shared
export const loadThird = () => import('./third')
{
"minifyType": "NoMinify",
"runtime": "NodeJs",
"productionChunking": true
}
module.exports = [
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/first.js [test] (ecmascript)", ((__turbopack_context__) => {
"use strict";
__turbopack_context__.s([
"first",
()=>first
]);
var __TURBOPACK__imported__module__$5b$project$5d2f$turbopack$2f$crates$2f$turbopack$2d$tests$2f$tests$2f$snapshot$2f$basic$2f$nested_async_availability$2f$input$2f$shared$2e$js__$5b$test$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/shared.js [test] (ecmascript)");
;
function first() {
return Promise.all([
__turbopack_context__.A("[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/second.js [test] (ecmascript, async loader)"),
__turbopack_context__.A("[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/third.js [test] (ecmascript, async loader)")
]).then(([{ second }, { third }])=>__TURBOPACK__imported__module__$5b$project$5d2f$turbopack$2f$crates$2f$turbopack$2d$tests$2f$tests$2f$snapshot$2f$basic$2f$nested_async_availability$2f$input$2f$shared$2e$js__$5b$test$5d$__$28$ecmascript$29$__["shared"] + second + third);
}
}),
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/second.js [test] (ecmascript, async loader)", ((__turbopack_context__) => {
__turbopack_context__.v((parentImport) => {
return Promise.all([
"output/1jsg_tests_snapshot_basic_nested_async_availability_input_second_0y5twtlc0uf9g.js"
].map((chunk) => __turbopack_context__.l(chunk))).then(() => {
return parentImport("[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/second.js [test] (ecmascript)");
});
});
}),
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/shared.js [test] (ecmascript)", ((__turbopack_context__) => {
"use strict";
__turbopack_context__.s([
"shared",
()=>shared
]);
const shared = 'shared';
}),
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/third.js [test] (ecmascript, async loader)", ((__turbopack_context__) => {
__turbopack_context__.v((parentImport) => {
return Promise.all([
"output/1jsg_tests_snapshot_basic_nested_async_availability_input_third_18lvy7dfhpmum.js"
].map((chunk) => __turbopack_context__.l(chunk))).then(() => {
return parentImport("[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/third.js [test] (ecmascript)");
});
});
}),
];
//# sourceMappingURL=1jsg_tests_snapshot_basic_nested_async_availability_input_0xj39htr4y5yc._.js.map
\ No newline at end of file
{
"version": 3,
"sources": [],
"sections": [
{"offset": {"line": 4, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/first.js"],"sourcesContent":["import { shared } from './shared'\n\nexport function first() {\n return Promise.all([import('./second'), import('./third')]).then(\n ([{ second }, { third }]) => shared + second + third\n )\n}\n"],"names":["first","Promise","all","then","second","third"],"mappings":";;;;AAAA;;AAEO,SAASA;IACd,OAAOC,QAAQC,GAAG,CAAC;;;KAAuC,EAAEC,IAAI,CAC9D,CAAC,CAAC,EAAEC,MAAM,EAAE,EAAE,EAAEC,KAAK,EAAE,CAAC,GAAK,2NAAM,GAAGD,SAASC;AAEnD"}},
{"offset": {"line": 30, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/shared.js"],"sourcesContent":["export const shared = 'shared'\n"],"names":["shared"],"mappings":";;;;AAAO,MAAMA,SAAS"}}]
}
\ No newline at end of file
module.exports = [
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/first.js [test] (ecmascript, async loader)", ((__turbopack_context__) => {
__turbopack_context__.v((parentImport) => {
return Promise.all([
"output/1jsg_tests_snapshot_basic_nested_async_availability_input_0xj39htr4y5yc._.js"
].map((chunk) => __turbopack_context__.l(chunk))).then(() => {
return parentImport("[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/first.js [test] (ecmascript)");
});
});
}),
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/index.js [test] (ecmascript)", ((__turbopack_context__, module, exports) => {
__turbopack_context__.A("[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/first.js [test] (ecmascript, async loader)").then(({ first })=>first());
}),
];
//# sourceMappingURL=1jsg_tests_snapshot_basic_nested_async_availability_input_1bof-0uzqpz7i._.js.map
\ No newline at end of file
{
"version": 3,
"sources": [],
"sections": [
{"offset": {"line": 13, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/index.js"],"sourcesContent":["import('./first').then(({ first }) => first())\n"],"names":["then","first"],"mappings":"AAAA,sKAAkBA,IAAI,CAAC,CAAC,EAAEC,KAAK,EAAE,GAAKA"}}]
}
\ No newline at end of file
module.exports = [
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/second.js [test] (ecmascript)", ((__turbopack_context__) => {
"use strict";
__turbopack_context__.s([
"loadThird",
()=>loadThird,
"second",
()=>second
]);
var __TURBOPACK__imported__module__$5b$project$5d2f$turbopack$2f$crates$2f$turbopack$2d$tests$2f$tests$2f$snapshot$2f$basic$2f$nested_async_availability$2f$input$2f$shared$2e$js__$5b$test$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/shared.js [test] (ecmascript)");
;
const second = __TURBOPACK__imported__module__$5b$project$5d2f$turbopack$2f$crates$2f$turbopack$2d$tests$2f$tests$2f$snapshot$2f$basic$2f$nested_async_availability$2f$input$2f$shared$2e$js__$5b$test$5d$__$28$ecmascript$29$__["shared"];
const loadThird = ()=>__turbopack_context__.A("[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/third.js [test] (ecmascript, async loader)");
}),
];
//# sourceMappingURL=1jsg_tests_snapshot_basic_nested_async_availability_input_second_0y5twtlc0uf9g.js.map
\ No newline at end of file
{
"version": 3,
"sources": [],
"sections": [
{"offset": {"line": 4, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/second.js"],"sourcesContent":["import { shared } from './shared'\n\nexport const second = shared\nexport const loadThird = () => import('./third')\n"],"names":["second","loadThird"],"mappings":";;;;;;AAAA;;AAEO,MAAMA,SAAS,2NAAM;AACrB,MAAMC,YAAY"}}]
}
\ No newline at end of file
module.exports = [
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/third.js [test] (ecmascript)", ((__turbopack_context__) => {
"use strict";
__turbopack_context__.s([
"third",
()=>third
]);
var __TURBOPACK__imported__module__$5b$project$5d2f$turbopack$2f$crates$2f$turbopack$2d$tests$2f$tests$2f$snapshot$2f$basic$2f$nested_async_availability$2f$input$2f$shared$2e$js__$5b$test$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/shared.js [test] (ecmascript)");
;
const third = __TURBOPACK__imported__module__$5b$project$5d2f$turbopack$2f$crates$2f$turbopack$2d$tests$2f$tests$2f$snapshot$2f$basic$2f$nested_async_availability$2f$input$2f$shared$2e$js__$5b$test$5d$__$28$ecmascript$29$__["shared"];
}),
];
//# sourceMappingURL=1jsg_tests_snapshot_basic_nested_async_availability_input_third_18lvy7dfhpmum.js.map
\ No newline at end of file
{
"version": 3,
"sources": [],
"sections": [
{"offset": {"line": 4, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/third.js"],"sourcesContent":["import { shared } from './shared'\n\nexport const third = shared\n"],"names":["third"],"mappings":";;;;AAAA;;AAEO,MAAMA,QAAQ,2NAAM"}}]
}
\ No newline at end of file
var RUNTIME_PUBLIC_PATH = "output/[turbopack]_runtime.js";
var RELATIVE_ROOT_PATH = "../../../../../../..";
var ASSET_PREFIX = "/";
// Dummy runtime
\ No newline at end of file
var R=require("./[turbopack]_runtime.js")("output/index.entry.js")
R.c("output/1jsg_tests_snapshot_basic_nested_async_availability_input_1bof-0uzqpz7i._.js")
R.m("[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/index.js [test] (ecmascript)")
module.exports=R.m("[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/nested_async_availability/input/index.js [test] (ecmascript)").exports
\ No newline at end of file
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
"output/0rv8_turbopack-tests_tests_snapshot_basic_top-level-await_input_index_1soojxkwtnnhh.js",
{"otherChunks":["output/1jsg_tests_snapshot_basic_top-level-await_input_UserAPI_0c6krugj0zi8y.js","output/1do3_crates_turbopack-tests_tests_snapshot_basic_top-level-await_input_1ih204k-kik67._.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/top-level-await/input/index.js [test] (ecmascript)"]}
"output/0rv8_turbopack-tests_tests_snapshot_basic_top-level-await_input_index_0p2mpntb9a3xv.js",
{"otherChunks":["output/1jsg_tests_snapshot_basic_top-level-await_input_UserAPI_1-a2sx9qemlcl.js","output/1do3_crates_turbopack-tests_tests_snapshot_basic_top-level-await_input_1ih204k-kik67._.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/top-level-await/input/index.js [test] (ecmascript)"]}
]);
// Dummy runtime
\ No newline at end of file
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/1jsg_tests_snapshot_basic_top-level-await_input_UserAPI_0c6krugj0zi8y.js",
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/1jsg_tests_snapshot_basic_top-level-await_input_UserAPI_1-a2sx9qemlcl.js",
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/top-level-await/input/UserAPI.js [test] (ecmascript, async loader)", ((__turbopack_context__) => {
__turbopack_context__.v((parentImport) => {
......
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
"output/0rv8_turbopack-tests_tests_snapshot_basic_use-strict_input_index_0r4xda1wnxaqk.js",
{"otherChunks":["output/1do3_crates_turbopack-tests_tests_snapshot_basic_use-strict_input_0czj5szeqd2rf._.js","output/1do3_crates_turbopack-tests_tests_snapshot_basic_use-strict_input_1wmp5yoyw-hht._.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/use-strict/input/index.js [test] (ecmascript)"]}
"output/0rv8_turbopack-tests_tests_snapshot_basic_use-strict_input_index_1jvifjjio7twx.js",
{"otherChunks":["output/1do3_crates_turbopack-tests_tests_snapshot_basic_use-strict_input_0azj9j3wgo0mj._.js","output/1do3_crates_turbopack-tests_tests_snapshot_basic_use-strict_input_1wmp5yoyw-hht._.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/use-strict/input/index.js [test] (ecmascript)"]}
]);
// Dummy runtime
\ No newline at end of file
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/1do3_crates_turbopack-tests_tests_snapshot_basic_use-strict_input_0czj5szeqd2rf._.js",
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/1do3_crates_turbopack-tests_tests_snapshot_basic_use-strict_input_0azj9j3wgo0mj._.js",
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/basic/use-strict/input/all-strict.js [test] (ecmascript, async loader)", ((__turbopack_context__) => {
__turbopack_context__.v((parentImport) => {
......
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
"output/1i9t_crates_turbopack-tests_tests_snapshot_css_css-modules_input_index_14qn02nwd7xdc.js",
{"otherChunks":["output/0_9x_turbopack-tests_tests_snapshot_css_css-modules_input_style_module_1ihdpzrao37m7.css","output/1jsg_tests_snapshot_css_css-modules_input_style_module_css_0ox2tupot76uj._.js","output/1do3_crates_turbopack-tests_tests_snapshot_css_css-modules_input_0ppd-98kcgm8s._.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/css/css-modules/input/index.js [test] (ecmascript)"]}
"output/1i9t_crates_turbopack-tests_tests_snapshot_css_css-modules_input_index_1imhy-jx0bmy_.js",
{"otherChunks":["output/0_9x_turbopack-tests_tests_snapshot_css_css-modules_input_style_module_1ihdpzrao37m7.css","output/1jsg_tests_snapshot_css_css-modules_input_style_module_css_0gx4jdqopuu5r._.js","output/1do3_crates_turbopack-tests_tests_snapshot_css_css-modules_input_0ppd-98kcgm8s._.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/css/css-modules/input/index.js [test] (ecmascript)"]}
]);
// Dummy runtime
\ No newline at end of file
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/1jsg_tests_snapshot_css_css-modules_input_style_module_css_0ox2tupot76uj._.js",
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/1jsg_tests_snapshot_css_css-modules_input_style_module_css_0gx4jdqopuu5r._.js",
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/css/css-modules/input/style.module.css [test] (css module, async loader)", ((__turbopack_context__) => {
__turbopack_context__.v((parentImport) => {
......
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/1-no_foo_style_css_1pkrete-lgjrt._.js",
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/1-no_foo_style_css_0f25r0omi5r7z._.js",
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/css/css/input/node_modules/foo/style.css [test] (css, async loader)", ((__turbopack_context__) => {
__turbopack_context__.v((parentImport) => {
......
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
"output/1i9t_crates_turbopack-tests_tests_snapshot_css_css_input_index_1zp7hx32x72el.js",
{"otherChunks":["output/turbopack_crates_turbopack-tests_tests_snapshot_css_css_input_028qdx4s25m2y._.css","output/1-no_foo_style_css_1pkrete-lgjrt._.js","output/turbopack_crates_turbopack-tests_tests_snapshot_css_css_input_1f3bnvictpga4._.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/css/css/input/index.js [test] (ecmascript)"]}
"output/1i9t_crates_turbopack-tests_tests_snapshot_css_css_input_index_0jxklqykzfu0p.js",
{"otherChunks":["output/turbopack_crates_turbopack-tests_tests_snapshot_css_css_input_028qdx4s25m2y._.css","output/1-no_foo_style_css_0f25r0omi5r7z._.js","output/turbopack_crates_turbopack-tests_tests_snapshot_css_css_input_1f3bnvictpga4._.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/css/css/input/index.js [test] (ecmascript)"]}
]);
// Dummy runtime
\ No newline at end of file
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
"output/1i9t_crates_turbopack-tests_tests_snapshot_css_cycle_input_index_0p_vx0v56egct.js",
{"otherChunks":["output/turbopack_crates_turbopack-tests_tests_snapshot_css_cycle_input_1idxyqwiqb2px._.js","output/1do3_crates_turbopack-tests_tests_snapshot_css_cycle_input_index_0h88o8aghj5nb.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/css/cycle/input/index.js [test] (ecmascript)"]}
"output/1i9t_crates_turbopack-tests_tests_snapshot_css_cycle_input_index_015e_7dpbch70.js",
{"otherChunks":["output/turbopack_crates_turbopack-tests_tests_snapshot_css_cycle_input_1g4njlv5u3qmb._.js","output/1do3_crates_turbopack-tests_tests_snapshot_css_cycle_input_index_0h88o8aghj5nb.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/css/cycle/input/index.js [test] (ecmascript)"]}
]);
// Dummy runtime
\ No newline at end of file
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/turbopack_crates_turbopack-tests_tests_snapshot_css_cycle_input_1idxyqwiqb2px._.js",
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/turbopack_crates_turbopack-tests_tests_snapshot_css_cycle_input_1g4njlv5u3qmb._.js",
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/css/cycle/input/1.css [test] (css, async loader)", ((__turbopack_context__) => {
__turbopack_context__.v((parentImport) => {
......
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
"output/1i9t_crates_turbopack-tests_tests_snapshot_css_cycle2_input_index_0aidl0_epn5am.js",
{"otherChunks":["output/turbopack_crates_turbopack-tests_tests_snapshot_css_cycle2_input_08nj7rl1ezmoc._.js","output/1do3_crates_turbopack-tests_tests_snapshot_css_cycle2_input_index_1jfnc6g2j7bji.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/css/cycle2/input/index.js [test] (ecmascript)"]}
"output/1i9t_crates_turbopack-tests_tests_snapshot_css_cycle2_input_index_0vq8cit8xh_lu.js",
{"otherChunks":["output/turbopack_crates_turbopack-tests_tests_snapshot_css_cycle2_input_0vrbe2d-ccp52._.js","output/1do3_crates_turbopack-tests_tests_snapshot_css_cycle2_input_index_1jfnc6g2j7bji.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/css/cycle2/input/index.js [test] (ecmascript)"]}
]);
// Dummy runtime
\ No newline at end of file
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/turbopack_crates_turbopack-tests_tests_snapshot_css_cycle2_input_08nj7rl1ezmoc._.js",
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/turbopack_crates_turbopack-tests_tests_snapshot_css_cycle2_input_0vrbe2d-ccp52._.js",
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/css/cycle2/input/1.css [test] (css, async loader)", ((__turbopack_context__) => {
__turbopack_context__.v((parentImport) => {
......
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/1do3_crates_turbopack-tests_tests_snapshot_css_embed-url_input_1ww-zwkkaf7hp._.js",
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/1do3_crates_turbopack-tests_tests_snapshot_css_embed-url_input_18z01simfreml._.js",
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/css/embed-url/input/style.css [test] (css, async loader)", ((__turbopack_context__) => {
__turbopack_context__.v((parentImport) => {
......
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
"output/1i9t_crates_turbopack-tests_tests_snapshot_css_embed-url_input_index_1zd9b4zfrklm2.js",
{"otherChunks":["output/1do3_crates_turbopack-tests_tests_snapshot_css_embed-url_input_0tnpx-5gohpd6._.css","output/1do3_crates_turbopack-tests_tests_snapshot_css_embed-url_input_1ww-zwkkaf7hp._.js","output/1do3_crates_turbopack-tests_tests_snapshot_css_embed-url_input_12dqxgxwmwtgt._.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/css/embed-url/input/index.js [test] (ecmascript)"]}
"output/1i9t_crates_turbopack-tests_tests_snapshot_css_embed-url_input_index_1l5owl9on1ktn.js",
{"otherChunks":["output/1do3_crates_turbopack-tests_tests_snapshot_css_embed-url_input_0tnpx-5gohpd6._.css","output/1do3_crates_turbopack-tests_tests_snapshot_css_embed-url_input_18z01simfreml._.js","output/1do3_crates_turbopack-tests_tests_snapshot_css_embed-url_input_12dqxgxwmwtgt._.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/css/embed-url/input/index.js [test] (ecmascript)"]}
]);
// Dummy runtime
\ No newline at end of file
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
"output/0rv8_turbopack-tests_tests_snapshot_css_split-shared_input_index_1x_bsl2zc0pcy.js",
{"otherChunks":["output/1do3_crates_turbopack-tests_tests_snapshot_css_split-shared_input_1oq4ajlqyqw7x._.js","output/0_9x_turbopack-tests_tests_snapshot_css_split-shared_input_index_1liedlhczucbh.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/css/split-shared/input/index.js [test] (ecmascript)"]}
"output/0rv8_turbopack-tests_tests_snapshot_css_split-shared_input_index_11pj5f6wnfnje.js",
{"otherChunks":["output/1do3_crates_turbopack-tests_tests_snapshot_css_split-shared_input_0gxqja8goibuj._.js","output/0_9x_turbopack-tests_tests_snapshot_css_split-shared_input_index_1liedlhczucbh.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/css/split-shared/input/index.js [test] (ecmascript)"]}
]);
// Dummy runtime
\ No newline at end of file
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/1do3_crates_turbopack-tests_tests_snapshot_css_split-shared_input_1oq4ajlqyqw7x._.js",
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/1do3_crates_turbopack-tests_tests_snapshot_css_split-shared_input_0gxqja8goibuj._.js",
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/css/split-shared/input/b1.css [test] (css, async loader)", ((__turbopack_context__) => {
__turbopack_context__.v((parentImport) => {
......
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/0_9x_turbopack-tests_tests_snapshot_imports_dynamic_input_vercel_mjs_0p1y1g8maq2k6._.js",
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/0_9x_turbopack-tests_tests_snapshot_imports_dynamic_input_vercel_mjs_07_ray5h9b01u._.js",
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/imports/dynamic/input/vercel.mjs [test] (ecmascript, async loader)", ((__turbopack_context__) => {
__turbopack_context__.v((parentImport) => {
......
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
"output/1i9t_crates_turbopack-tests_tests_snapshot_imports_dynamic_input_index_04mn0nss0u3f5.js",
{"otherChunks":["output/0_9x_turbopack-tests_tests_snapshot_imports_dynamic_input_vercel_mjs_0p1y1g8maq2k6._.js","output/1do3_crates_turbopack-tests_tests_snapshot_imports_dynamic_input_index_0ebkhgwcoszgx.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/imports/dynamic/input/index.js [test] (ecmascript)"]}
"output/1i9t_crates_turbopack-tests_tests_snapshot_imports_dynamic_input_index_1xorwpip02nga.js",
{"otherChunks":["output/0_9x_turbopack-tests_tests_snapshot_imports_dynamic_input_vercel_mjs_07_ray5h9b01u._.js","output/1do3_crates_turbopack-tests_tests_snapshot_imports_dynamic_input_index_0ebkhgwcoszgx.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/imports/dynamic/input/index.js [test] (ecmascript)"]}
]);
// Dummy runtime
\ No newline at end of file
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
"output/1ece_tests_snapshot_imports_ignore-comments_input_index_00dzg349l8sna.js",
{"otherChunks":["output/1jsg_tests_snapshot_imports_ignore-comments_input_vercel_mjs_1n6almu16ecal._.js","output/[root-of-the-server]__08ofy-h8v1j4d._.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/input/index.js [test] (ecmascript)"]}
"output/1ece_tests_snapshot_imports_ignore-comments_input_index_06_xk_mupyp3z.js",
{"otherChunks":["output/1jsg_tests_snapshot_imports_ignore-comments_input_vercel_mjs_0dbyuzl-d_6q7._.js","output/[root-of-the-server]__08ofy-h8v1j4d._.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/input/index.js [test] (ecmascript)"]}
]);
// Dummy runtime
\ No newline at end of file
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/1jsg_tests_snapshot_imports_ignore-comments_input_vercel_mjs_1n6almu16ecal._.js",
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/1jsg_tests_snapshot_imports_ignore-comments_input_vercel_mjs_0dbyuzl-d_6q7._.js",
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/imports/ignore-comments/input/vercel.mjs [test] (ecmascript, async loader)", ((__turbopack_context__) => {
__turbopack_context__.v((parentImport) => {
......
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
"output/1ece_tests_snapshot_imports_optional-comments_input_index_1xwgq5bcb3hrz.js",
{"otherChunks":["output/1jsg_tests_snapshot_imports_optional-comments_input_existing_mjs_0sg3w6-apqqas._.js","output/0_9x_turbopack-tests_tests_snapshot_imports_optional-comments_input_1djzxjxdb-z64._.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/imports/optional-comments/input/index.js [test] (ecmascript)"]}
"output/1ece_tests_snapshot_imports_optional-comments_input_index_1u_45hr1okhrx.js",
{"otherChunks":["output/1jsg_tests_snapshot_imports_optional-comments_input_existing_mjs_1xtelc5czoka5._.js","output/0_9x_turbopack-tests_tests_snapshot_imports_optional-comments_input_1djzxjxdb-z64._.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/imports/optional-comments/input/index.js [test] (ecmascript)"]}
]);
// Dummy runtime
\ No newline at end of file
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/1jsg_tests_snapshot_imports_optional-comments_input_existing_mjs_0sg3w6-apqqas._.js",
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/1jsg_tests_snapshot_imports_optional-comments_input_existing_mjs_1xtelc5czoka5._.js",
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/imports/optional-comments/input/existing.mjs [test] (ecmascript, async loader)", ((__turbopack_context__) => {
__turbopack_context__.v((parentImport) => {
......
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
"output/1ece_tests_snapshot_imports_static-and-dynamic_input_index_1twuxs2np7upf.js",
{"otherChunks":["output/1jsg_tests_snapshot_imports_static-and-dynamic_input_vercel_mjs_08p9skj6sz55o._.js","output/0_9x_turbopack-tests_tests_snapshot_imports_static-and-dynamic_input_0dm2mkcc8iok2._.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/imports/static-and-dynamic/input/index.js [test] (ecmascript)"]}
"output/1ece_tests_snapshot_imports_static-and-dynamic_input_index_1385xt227h2id.js",
{"otherChunks":["output/1jsg_tests_snapshot_imports_static-and-dynamic_input_vercel_mjs_1n3jko1eosfvo._.js","output/0_9x_turbopack-tests_tests_snapshot_imports_static-and-dynamic_input_0dm2mkcc8iok2._.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/imports/static-and-dynamic/input/index.js [test] (ecmascript)"]}
]);
// Dummy runtime
\ No newline at end of file
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/1jsg_tests_snapshot_imports_static-and-dynamic_input_vercel_mjs_08p9skj6sz55o._.js",
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/1jsg_tests_snapshot_imports_static-and-dynamic_input_vercel_mjs_1n3jko1eosfvo._.js",
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/imports/static-and-dynamic/input/vercel.mjs [test] (ecmascript, async loader)", ((__turbopack_context__) => {
__turbopack_context__.v((parentImport) => {
......
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/0_9x_turbopack-tests_tests_snapshot_reexport-drop_basic_input_lib_0u9f373obiou1.js",
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/0_9x_turbopack-tests_tests_snapshot_reexport-drop_basic_input_lib_1byl5h_0_o1mx.js",
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/reexport-drop/basic/input/lib.js [test] (ecmascript, async loader)", ((__turbopack_context__) => {
__turbopack_context__.v((parentImport) => {
......
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
"output/0rv8_turbopack-tests_tests_snapshot_reexport-drop_basic_input_index_0omvm8aekjic4.js",
{"otherChunks":["output/0_9x_turbopack-tests_tests_snapshot_reexport-drop_basic_input_lib_0u9f373obiou1.js","output/0_9x_turbopack-tests_tests_snapshot_reexport-drop_basic_input_index_14t7f_000kthh.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/reexport-drop/basic/input/index.js [test] (ecmascript)"]}
"output/0rv8_turbopack-tests_tests_snapshot_reexport-drop_basic_input_index_0qze2yc7userp.js",
{"otherChunks":["output/0_9x_turbopack-tests_tests_snapshot_reexport-drop_basic_input_lib_1byl5h_0_o1mx.js","output/0_9x_turbopack-tests_tests_snapshot_reexport-drop_basic_input_index_14t7f_000kthh.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/reexport-drop/basic/input/index.js [test] (ecmascript)"]}
]);
// Dummy runtime
\ No newline at end of file
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/0_9x_turbopack-tests_tests_snapshot_reexport-drop_dynamic_input_lib_062uldbido_hx.js",
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push(["output/0_9x_turbopack-tests_tests_snapshot_reexport-drop_dynamic_input_lib_0z3c-hfbiu2aw.js",
"[project]/turbopack/crates/turbopack-tests/tests/snapshot/reexport-drop/dynamic/input/lib.js [test] (ecmascript, async loader)", ((__turbopack_context__) => {
__turbopack_context__.v((parentImport) => {
......
(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([
"output/0rv8_turbopack-tests_tests_snapshot_reexport-drop_dynamic_input_index_12h6-cs_3ke_4.js",
{"otherChunks":["output/0_9x_turbopack-tests_tests_snapshot_reexport-drop_dynamic_input_lib_062uldbido_hx.js","output/0_9x_turbopack-tests_tests_snapshot_reexport-drop_dynamic_input_index_138bkaefvbc_e.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/reexport-drop/dynamic/input/index.js [test] (ecmascript)"]}
"output/0rv8_turbopack-tests_tests_snapshot_reexport-drop_dynamic_input_index_0zq-l_3vm3io1.js",
{"otherChunks":["output/0_9x_turbopack-tests_tests_snapshot_reexport-drop_dynamic_input_lib_0z3c-hfbiu2aw.js","output/0_9x_turbopack-tests_tests_snapshot_reexport-drop_dynamic_input_index_138bkaefvbc_e.js"],"runtimeModuleIds":["[project]/turbopack/crates/turbopack-tests/tests/snapshot/reexport-drop/dynamic/input/index.js [test] (ecmascript)"]}
]);
// Dummy runtime
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment