diff --git a/crates/node-file-trace/src/lib.rs b/crates/node-file-trace/src/lib.rs
index aed9b901d4c38..97da3112d6725 100644
--- a/crates/node-file-trace/src/lib.rs
+++ b/crates/node-file-trace/src/lib.rs
@@ -17,41 +17,39 @@ use anyhow::{anyhow, Context, Result};
 #[cfg(feature = "cli")]
 use clap::Parser;
 #[cfg(feature = "node-api")]
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
+#[cfg(feature = "node-api")]
+use serde::Serialize;
 use tokio::sync::mpsc::channel;
 use turbo_tasks::{
-    backend::Backend,
-    primitives::{OptionStringVc, StringsVc},
-    util::FormatDuration,
-    NothingVc, TaskId, TransientInstance, TransientValue, TurboTasks, TurboTasksBackendApi,
-    UpdateInfo, Value,
+    backend::Backend, util::FormatDuration, Nothing, TaskId, TransientInstance, TransientValue,
+    TurboTasks, TurboTasksBackendApi, UpdateInfo, Value, Vc,
 };
 use turbo_tasks_fs::{
-    glob::GlobVc, DirectoryEntry, DiskFileSystemVc, FileSystem, FileSystemPathVc, FileSystemVc,
-    ReadGlobResultVc,
+    glob::Glob, DirectoryEntry, DiskFileSystem, FileSystem, FileSystemPath, ReadGlobResult,
 };
 use turbo_tasks_memory::{
     stats::{ReferenceType, Stats},
     viz, MemoryBackend,
 };
 use turbopack::{
-    emit_asset, emit_with_completion, module_options::ModuleOptionsContext, rebase::RebasedAssetVc,
-    resolve_options_context::ResolveOptionsContext, transition::TransitionsByNameVc,
-    ModuleAssetContextVc,
+    emit_asset, emit_with_completion, module_options::ModuleOptionsContext, rebase::RebasedAsset,
+    resolve_options_context::ResolveOptionsContext, transition::TransitionsByName,
+    ModuleAssetContext,
 };
-use turbopack_cli_utils::issue::{ConsoleUiVc, IssueSeverityCliOption, LogOptions};
+use turbopack_cli_utils::issue::{ConsoleUi, IssueSeverityCliOption, LogOptions};
 use turbopack_core::{
-    asset::{Asset, AssetVc, AssetsVc},
+    asset::{Asset, Assets},
     compile_time_info::CompileTimeInfo,
-    context::{AssetContext, AssetContextVc},
-    environment::{EnvironmentIntention, EnvironmentVc, ExecutionEnvironment, NodeJsEnvironment},
-    issue::{IssueContextExt, IssueReporter, IssueSeverity, IssueVc},
+    context::AssetContext,
+    environment::{Environment, EnvironmentIntention, ExecutionEnvironment, NodeJsEnvironment},
+    issue::{Issue, IssueContextExt, IssueReporter, IssueSeverity},
     reference::all_assets,
     resolve::options::{ImportMapping, ResolvedMap},
-    source_asset::SourceAssetVc,
+    source_asset::SourceAsset,
 };
 
-use crate::nft_json::NftJsonAssetVc;
+use crate::nft_json::NftJsonAsset;
 
 #[cfg(feature = "persistent_cache")]
 #[cfg_attr(feature = "cli", derive(clap::Args))]
@@ -195,8 +193,8 @@ impl Args {
     }
 }
 
-async fn create_fs(name: &str, context: &str, watch: bool) -> Result<FileSystemVc> {
-    let fs = DiskFileSystemVc::new(name.to_string(), context.to_string());
+async fn create_fs(name: &str, context: &str, watch: bool) -> Result<Vc<Box<dyn FileSystem>>> {
+    let fs = DiskFileSystem::new(name.to_string(), context.to_string());
     if watch {
         fs.await?.start_watching()?;
     } else {
@@ -206,14 +204,14 @@ async fn create_fs(name: &str, context: &str, watch: bool) -> Result<FileSystemV
 }
 
 async fn add_glob_results(
-    context: AssetContextVc,
-    result: ReadGlobResultVc,
-    list: &mut Vec<AssetVc>,
+    context: Vc<Box<dyn AssetContext>>,
+    result: Vc<ReadGlobResult>,
+    list: &mut Vec<Vc<Box<dyn Asset>>>,
 ) -> Result<()> {
     let result = result.await?;
     for entry in result.results.values() {
         if let DirectoryEntry::File(path) = entry {
-            let source = SourceAssetVc::new(*path).into();
+            let source = Vc::upcast(SourceAsset::new(*path));
             list.push(context.process(
                 source,
                 Value::new(turbopack_core::reference_type::ReferenceType::Undefined),
@@ -222,9 +220,9 @@ async fn add_glob_results(
     }
     for result in result.inner.values() {
         fn recurse<'a>(
-            context: AssetContextVc,
-            result: ReadGlobResultVc,
-            list: &'a mut Vec<AssetVc>,
+            context: Vc<Box<dyn AssetContext>>,
+            result: Vc<ReadGlobResult>,
+            list: &'a mut Vec<Vc<Box<dyn Asset>>>,
         ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>> {
             Box::pin(add_glob_results(context, result, list))
         }
@@ -236,36 +234,36 @@ async fn add_glob_results(
 
 #[turbo_tasks::function]
 async fn input_to_modules<'a>(
-    fs: FileSystemVc,
+    fs: Vc<Box<dyn FileSystem>>,
     input: Vec<String>,
     exact: bool,
     process_cwd: Option<String>,
     context: String,
     module_options: TransientInstance<ModuleOptionsContext>,
     resolve_options: TransientInstance<ResolveOptionsContext>,
-) -> Result<AssetsVc> {
+) -> Result<Vc<Assets>> {
     let root = fs.root();
     let process_cwd = process_cwd
         .clone()
         .map(|p| p.trim_start_matches(&context).to_owned());
 
-    let context: AssetContextVc =
+    let context: Vc<Box<dyn AssetContext>> =
         create_module_asset(root, process_cwd, module_options, resolve_options).into();
 
     let mut list = Vec::new();
     for input in input.iter() {
         if exact {
-            let source = SourceAssetVc::new(root.join(input)).into();
+            let source = Vc::upcast(SourceAsset::new(root.join(input)));
             list.push(context.process(
                 source,
                 Value::new(turbopack_core::reference_type::ReferenceType::Undefined),
             ));
         } else {
-            let glob = GlobVc::new(input);
+            let glob = Glob::new(input);
             add_glob_results(context, root.read_glob(glob, false), &mut list).await?;
         };
     }
-    Ok(AssetsVc::cell(list))
+    Ok(Vc::cell(list))
 }
 
 fn process_context(dir: &Path, context_directory: Option<&String>) -> Result<String> {
@@ -493,15 +491,13 @@ async fn run<B: Backend + 'static, F: Future<Output = ()>>(
             );
 
             let source = TransientValue::new(output.into());
-            let issues = IssueVc::peek_issues_with_path(output)
+            let issues = Issue::peek_issues_with_path(output)
                 .await?
                 .strongly_consistent()
                 .await?;
 
-            let console_ui = ConsoleUiVc::new(log_options);
-            console_ui
-                .as_issue_reporter()
-                .report_issues(TransientInstance::new(issues), source);
+            let console_ui = ConsoleUi::new(log_options);
+            Vc::upcast(console_ui).report_issues(TransientInstance::new(issues), source);
 
             if has_return_value {
                 let output_read_ref = output.await?;
@@ -509,7 +505,7 @@ async fn run<B: Backend + 'static, F: Future<Output = ()>>(
                 sender.send(output_iter.collect::<Vec<String>>()).await?;
                 drop(sender);
             }
-            Ok(NothingVc::new().into())
+            Ok(Nothing::new().into())
         })
     });
     finish(tt, task).await?;
@@ -527,7 +523,7 @@ async fn main_operation(
     args: TransientInstance<Args>,
     module_options: TransientInstance<ModuleOptionsContext>,
     resolve_options: TransientInstance<ResolveOptionsContext>,
-) -> Result<StringsVc> {
+) -> Result<Vc<Vec<String>>> {
     let dir = current_dir.into_value();
     let args = &*args;
     let &CommonArgs {
@@ -565,7 +561,7 @@ async fn main_operation(
                 }
             }
 
-            return Ok(StringsVc::cell(result.into_iter().collect::<Vec<_>>()));
+            return Ok(Vc::cell(result.into_iter().collect::<Vec<_>>()));
         }
         Args::Annotate { common: _ } => {
             let input = process_input(&dir, &context, input).unwrap();
@@ -583,7 +579,7 @@ async fn main_operation(
             .await?
             .iter()
             {
-                let nft_asset = NftJsonAssetVc::new(*module);
+                let nft_asset = NftJsonAsset::new(*module);
                 let path = nft_asset.ident().path().await?.path.clone();
                 output_nft_assets.push(path);
                 emits.push(emit_asset(nft_asset.into()));
@@ -592,7 +588,7 @@ async fn main_operation(
             for emit in emits {
                 emit.await?;
             }
-            return Ok(StringsVc::cell(output_nft_assets));
+            return Ok(Vc::cell(output_nft_assets));
         }
         Args::Build {
             ref output_directory,
@@ -616,7 +612,7 @@ async fn main_operation(
             .await?
             .iter()
             {
-                let rebased = RebasedAssetVc::new(*module, input_dir, output_dir).into();
+                let rebased = Vc::upcast(RebasedAsset::new(*module, input_dir, output_dir));
                 emits.push(emit_with_completion(rebased, output_dir));
             }
             // Wait for all files to be emitted
@@ -626,20 +622,20 @@ async fn main_operation(
         }
         Args::Size { common: _ } => todo!(),
     }
-    Ok(StringsVc::cell(Vec::new()))
+    Ok(Vc::cell(Vec::new()))
 }
 
 #[turbo_tasks::function]
 async fn create_module_asset(
-    root: FileSystemPathVc,
+    root: Vc<FileSystemPath>,
     process_cwd: Option<String>,
     module_options: TransientInstance<ModuleOptionsContext>,
     resolve_options: TransientInstance<ResolveOptionsContext>,
-) -> Result<ModuleAssetContextVc> {
-    let env = EnvironmentVc::new(
+) -> Result<Vc<ModuleAssetContext>> {
+    let env = Environment::new(
         Value::new(ExecutionEnvironment::NodeJsLambda(
             NodeJsEnvironment {
-                cwd: OptionStringVc::cell(process_cwd),
+                cwd: Vc::cell(process_cwd),
                 ..Default::default()
             }
             .into(),
@@ -650,12 +646,12 @@ async fn create_module_asset(
     let glob_mappings = vec![
         (
             root,
-            GlobVc::new("**/*/next/dist/server/next.js"),
+            Glob::new("**/*/next/dist/server/next.js"),
             ImportMapping::Ignore.into(),
         ),
         (
             root,
-            GlobVc::new("**/*/next/dist/bin/next"),
+            Glob::new("**/*/next/dist/bin/next"),
             ImportMapping::Ignore.into(),
         ),
     ];
@@ -672,8 +668,8 @@ async fn create_module_asset(
         );
     }
 
-    Ok(ModuleAssetContextVc::new(
-        TransitionsByNameVc::cell(HashMap::new()),
+    Ok(ModuleAssetContext::new(
+        Vc::cell(HashMap::new()),
         compile_time_info,
         ModuleOptionsContext::clone(&*module_options).cell(),
         resolve_options.cell(),
diff --git a/crates/node-file-trace/src/nft_json.rs b/crates/node-file-trace/src/nft_json.rs
index 38d88d0d2132f..15b88906c971a 100644
--- a/crates/node-file-trace/src/nft_json.rs
+++ b/crates/node-file-trace/src/nft_json.rs
@@ -1,21 +1,22 @@
 use anyhow::Result;
 use serde_json::json;
+use turbo_tasks::Vc;
 use turbo_tasks_fs::{File, FileSystem};
 use turbopack_core::{
-    asset::{Asset, AssetContentVc, AssetVc},
-    ident::AssetIdentVc,
+    asset::{Asset, AssetContent},
+    ident::AssetIdent,
     reference::all_assets,
 };
 
 #[turbo_tasks::value(shared)]
 pub struct NftJsonAsset {
-    entry: AssetVc,
+    entry: Vc<Box<dyn Asset>>,
 }
 
 #[turbo_tasks::value_impl]
-impl NftJsonAssetVc {
+impl NftJsonAsset {
     #[turbo_tasks::function]
-    pub fn new(entry: AssetVc) -> Self {
+    pub fn new(entry: Vc<Box<dyn Asset>>) -> Vc<Self> {
         Self::cell(NftJsonAsset { entry })
     }
 }
@@ -23,15 +24,15 @@ impl NftJsonAssetVc {
 #[turbo_tasks::value_impl]
 impl Asset for NftJsonAsset {
     #[turbo_tasks::function]
-    async fn ident(&self) -> Result<AssetIdentVc> {
+    async fn ident(&self) -> Result<Vc<AssetIdent>> {
         let path = self.entry.ident().path().await?;
-        Ok(AssetIdentVc::from_path(
+        Ok(AssetIdent::from_path(
             path.fs.root().join(&format!("{}.nft.json", path.path)),
         ))
     }
 
     #[turbo_tasks::function]
-    async fn content(&self) -> Result<AssetContentVc> {
+    async fn content(&self) -> Result<Vc<AssetContent>> {
         let context = self.entry.ident().path().parent().await?;
         // For clippy -- This explicit deref is necessary
         let entry_path = &*self.entry.ident().path().await?;