diff --git a/Cargo.lock b/Cargo.lock
index 8e10712178e76..640f67d2579c4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9878,7 +9878,6 @@ dependencies = [
  "regex",
  "rustc-hash 2.1.1",
  "serde",
- "serde_with",
  "turbo-bincode",
  "turbo-rcstr",
  "turbo-tasks",
@@ -9906,6 +9905,7 @@ dependencies = [
  "anyhow",
  "markdown",
  "mdxjs",
+ "serde",
  "turbo-rcstr",
  "turbo-tasks",
  "turbo-tasks-fs",
diff --git a/crates/next-core/src/app_structure.rs b/crates/next-core/src/app_structure.rs
index 0e39928fd58e1..4a680371474dc 100644
--- a/crates/next-core/src/app_structure.rs
+++ b/crates/next-core/src/app_structure.rs
@@ -4,7 +4,6 @@ use anyhow::{Context, Result, bail};
 use bincode::{Decode, Encode};
 use indexmap::map::{Entry, OccupiedEntry};
 use rustc_hash::FxHashMap;
-use serde::{Deserialize, Serialize};
 use tracing::Instrument;
 use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{
@@ -38,31 +37,18 @@ fn normalize_underscore(string: &str) -> String {
 #[turbo_tasks::value]
 #[derive(Default, Debug, Clone)]
 pub struct AppDirModules {
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub page: Option<FileSystemPath>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub layout: Option<FileSystemPath>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub error: Option<FileSystemPath>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub global_error: Option<FileSystemPath>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub global_not_found: Option<FileSystemPath>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub loading: Option<FileSystemPath>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub template: Option<FileSystemPath>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub forbidden: Option<FileSystemPath>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub unauthorized: Option<FileSystemPath>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub not_found: Option<FileSystemPath>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub default: Option<FileSystemPath>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub route: Option<FileSystemPath>,
-    #[serde(skip_serializing_if = "Metadata::is_empty", default)]
     pub metadata: Metadata,
 }
 
@@ -87,9 +73,7 @@ impl AppDirModules {
 }
 
 /// A single metadata file plus an optional "alt" text file.
-#[derive(
-    Clone, Debug, Serialize, Deserialize, PartialEq, Eq, TraceRawVcs, NonLocalValue, Encode, Decode,
-)]
+#[derive(Clone, Debug, PartialEq, Eq, TraceRawVcs, NonLocalValue, Encode, Decode)]
 pub enum MetadataWithAltItem {
     Static {
         path: FileSystemPath,
@@ -102,18 +86,7 @@ pub enum MetadataWithAltItem {
 
 /// A single metadata file.
 #[derive(
-    Clone,
-    Debug,
-    Hash,
-    Serialize,
-    Deserialize,
-    PartialEq,
-    Eq,
-    TaskInput,
-    TraceRawVcs,
-    NonLocalValue,
-    Encode,
-    Decode,
+    Clone, Debug, Hash, PartialEq, Eq, TaskInput, TraceRawVcs, NonLocalValue, Encode, Decode,
 )]
 pub enum MetadataItem {
     Static { path: FileSystemPath },
@@ -159,29 +132,12 @@ impl From<MetadataWithAltItem> for MetadataItem {
 }
 
 /// Metadata file that can be placed in any segment of the app directory.
-#[derive(
-    Default,
-    Clone,
-    Debug,
-    Serialize,
-    Deserialize,
-    PartialEq,
-    Eq,
-    TraceRawVcs,
-    NonLocalValue,
-    Encode,
-    Decode,
-)]
+#[derive(Default, Clone, Debug, PartialEq, Eq, TraceRawVcs, NonLocalValue, Encode, Decode)]
 pub struct Metadata {
-    #[serde(skip_serializing_if = "Vec::is_empty", default)]
     pub icon: Vec<MetadataWithAltItem>,
-    #[serde(skip_serializing_if = "Vec::is_empty", default)]
     pub apple: Vec<MetadataWithAltItem>,
-    #[serde(skip_serializing_if = "Vec::is_empty", default)]
     pub twitter: Vec<MetadataWithAltItem>,
-    #[serde(skip_serializing_if = "Vec::is_empty", default)]
     pub open_graph: Vec<MetadataWithAltItem>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub sitemap: Option<MetadataItem>,
     // The page indicates where the metadata is defined and captured.
     // The steps for capturing metadata (get_directory_tree) and constructing
@@ -190,7 +146,6 @@ pub struct Metadata {
     // the actual path incorrectly with fillMetadataSegment.
     //
     // This is only being used for the static metadata files.
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub base_page: Option<AppPage>,
 }
 
@@ -216,11 +171,8 @@ impl Metadata {
 #[turbo_tasks::value]
 #[derive(Default, Clone, Debug)]
 pub struct GlobalMetadata {
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub favicon: Option<MetadataItem>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub robots: Option<MetadataItem>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub manifest: Option<MetadataItem>,
 }
 
@@ -534,8 +486,6 @@ impl ValueDefault for FileSystemPathVec {
     PartialEq,
     Eq,
     Hash,
-    Serialize,
-    Deserialize,
     TraceRawVcs,
     ValueDebugFormat,
     Debug,
diff --git a/crates/next-core/src/next_app/app_page_entry.rs b/crates/next-core/src/next_app/app_page_entry.rs
index ba4dad8aca195..f26bb6f7cd331 100644
--- a/crates/next-core/src/next_app/app_page_entry.rs
+++ b/crates/next-core/src/next_app/app_page_entry.rs
@@ -15,11 +15,10 @@ use turbopack_core::{
 };
 use turbopack_ecmascript::runtime_functions::{TURBOPACK_LOAD, TURBOPACK_REQUIRE};
 
-use super::app_entry::AppEntry;
 use crate::{
     app_page_loader_tree::{AppPageLoaderTreeModule, GLOBAL_ERROR},
     app_structure::AppPageLoaderTree,
-    next_app::{AppPage, AppPath},
+    next_app::{AppPage, AppPath, app_entry::AppEntry},
     next_config::NextConfig,
     next_edge::entry::wrap_edge_entry,
     next_server_component::NextServerComponentTransition,
diff --git a/crates/next-core/src/next_config.rs b/crates/next-core/src/next_config.rs
index d1b6fd00fb303..960583910cbd2 100644
--- a/crates/next-core/src/next_config.rs
+++ b/crates/next-core/src/next_config.rs
@@ -76,7 +76,7 @@ impl Default for CacheKinds {
 }
 
 #[turbo_tasks::value(eq = "manual")]
-#[derive(Clone, Debug, Default, PartialEq)]
+#[derive(Clone, Debug, Default, PartialEq, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
 pub struct NextConfig {
     // IMPORTANT: all fields should be private and access should be wrapped within a turbo-tasks
@@ -859,16 +859,7 @@ pub enum ModuleIds {
 pub struct OptionModuleIds(pub Option<ModuleIds>);
 
 #[derive(
-    Clone,
-    Debug,
-    PartialEq,
-    Serialize,
-    Deserialize,
-    TraceRawVcs,
-    NonLocalValue,
-    OperationValue,
-    Encode,
-    Decode,
+    Clone, Debug, PartialEq, Deserialize, TraceRawVcs, NonLocalValue, OperationValue, Encode, Decode,
 )]
 #[serde(untagged)]
 pub enum MdxRsOptions {
@@ -933,7 +924,6 @@ pub struct OptionalReactCompilerOptions(Option<ResolvedVc<ReactCompilerOptions>>
     Debug,
     Default,
     PartialEq,
-    Serialize,
     Deserialize,
     TraceRawVcs,
     ValueDebugFormat,
@@ -1275,16 +1265,7 @@ pub enum MiddlewarePrefetchType {
 }
 
 #[derive(
-    Clone,
-    Debug,
-    PartialEq,
-    Serialize,
-    Deserialize,
-    TraceRawVcs,
-    NonLocalValue,
-    OperationValue,
-    Encode,
-    Decode,
+    Clone, Debug, PartialEq, Deserialize, TraceRawVcs, NonLocalValue, OperationValue, Encode, Decode,
 )]
 #[serde(untagged)]
 pub enum EmotionTransformOptionsOrBoolean {
@@ -1302,16 +1283,7 @@ impl EmotionTransformOptionsOrBoolean {
 }
 
 #[derive(
-    Clone,
-    Debug,
-    PartialEq,
-    Serialize,
-    Deserialize,
-    TraceRawVcs,
-    NonLocalValue,
-    OperationValue,
-    Encode,
-    Decode,
+    Clone, Debug, PartialEq, Deserialize, TraceRawVcs, NonLocalValue, OperationValue, Encode, Decode,
 )]
 #[serde(untagged)]
 pub enum StyledComponentsTransformOptionsOrBoolean {
@@ -1329,7 +1301,7 @@ impl StyledComponentsTransformOptionsOrBoolean {
 }
 
 #[turbo_tasks::value(eq = "manual")]
-#[derive(Clone, Debug, PartialEq, Default, OperationValue)]
+#[derive(Clone, Debug, PartialEq, Default, OperationValue, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CompilerConfig {
     pub react_remove_properties: Option<ReactRemoveProperties>,
@@ -1340,16 +1312,7 @@ pub struct CompilerConfig {
 }
 
 #[derive(
-    Clone,
-    Debug,
-    PartialEq,
-    Serialize,
-    Deserialize,
-    TraceRawVcs,
-    NonLocalValue,
-    OperationValue,
-    Encode,
-    Decode,
+    Clone, Debug, PartialEq, Deserialize, TraceRawVcs, NonLocalValue, OperationValue, Encode, Decode,
 )]
 #[serde(untagged, rename_all = "camelCase")]
 pub enum ReactRemoveProperties {
@@ -1367,16 +1330,7 @@ impl ReactRemoveProperties {
 }
 
 #[derive(
-    Clone,
-    Debug,
-    PartialEq,
-    Serialize,
-    Deserialize,
-    TraceRawVcs,
-    NonLocalValue,
-    OperationValue,
-    Encode,
-    Decode,
+    Clone, Debug, PartialEq, Deserialize, TraceRawVcs, NonLocalValue, OperationValue, Encode, Decode,
 )]
 #[serde(untagged)]
 pub enum RemoveConsoleConfig {
diff --git a/crates/next-core/src/next_font/google/mod.rs b/crates/next-core/src/next_font/google/mod.rs
index 3e10a8dc96a54..af77d1e2164f2 100644
--- a/crates/next-core/src/next_font/google/mod.rs
+++ b/crates/next-core/src/next_font/google/mod.rs
@@ -37,22 +37,25 @@ use turbopack_node::{
     execution_context::ExecutionContext,
 };
 
-use self::{
-    font_fallback::get_font_fallback,
-    options::{FontDataEntry, FontWeights, NextFontGoogleOptions, options_from_request},
-    stylesheet::build_stylesheet,
-    util::{get_font_axes, get_stylesheet_url},
-};
-use super::{
-    font_fallback::FontFallback,
-    util::{
-        FontCssProperties, FontFamilyType, can_use_next_font, get_request_hash, get_request_id,
-        get_scoped_font_family,
-    },
-};
 use crate::{
-    embed_js::next_js_file_path, mode::NextMode, next_app::metadata::split_extension,
-    next_font::issue::NextFontIssue, util::load_next_js_json_file,
+    embed_js::next_js_file_path,
+    mode::NextMode,
+    next_app::metadata::split_extension,
+    next_font::{
+        font_fallback::FontFallback,
+        google::{
+            font_fallback::get_font_fallback,
+            options::{FontDataEntry, FontWeights, NextFontGoogleOptions, options_from_request},
+            stylesheet::build_stylesheet,
+            util::{get_font_axes, get_stylesheet_url},
+        },
+        issue::NextFontIssue,
+        util::{
+            FontCssProperties, FontFamilyType, can_use_next_font, get_request_hash, get_request_id,
+            get_scoped_font_family,
+        },
+    },
+    util::load_next_js_json_file,
 };
 
 pub mod font_fallback;
@@ -74,6 +77,7 @@ pub const USER_AGENT_FOR_GOOGLE_FONTS: &str = "Mozilla/5.0 (Macintosh; Intel Mac
 pub const GOOGLE_FONTS_INTERNAL_PREFIX: &str = "@vercel/turbopack-next/internal/font/google/font";
 
 #[turbo_tasks::value(transparent)]
+#[derive(Deserialize)]
 struct FontData(#[bincode(with = "turbo_bincode::indexmap")] FxIndexMap<RcStr, FontDataEntry>);
 
 #[turbo_tasks::value(shared)]
diff --git a/crates/next-core/src/next_shared/transforms/relay.rs b/crates/next-core/src/next_shared/transforms/relay.rs
index 51d22a30b3b72..ad863aa5fe93c 100644
--- a/crates/next-core/src/next_shared/transforms/relay.rs
+++ b/crates/next-core/src/next_shared/transforms/relay.rs
@@ -4,8 +4,10 @@ use turbo_tasks_fs::FileSystemPath;
 use turbopack::module_options::ModuleRule;
 use turbopack_ecmascript_plugins::transform::relay::RelayTransformer;
 
-use super::get_ecma_transform_rule;
-use crate::{next_config::NextConfig, next_shared::transforms::EcmascriptTransformStage};
+use crate::{
+    next_config::NextConfig,
+    next_shared::transforms::{EcmascriptTransformStage, get_ecma_transform_rule},
+};
 
 /// Returns a transform rule for the relay graphql transform.
 pub async fn get_relay_transform_rule(
diff --git a/turbopack/crates/turbo-tasks-fs/src/invalidator_map.rs b/turbopack/crates/turbo-tasks-fs/src/invalidator_map.rs
index 7381550034d2f..827633552dd4c 100644
--- a/turbopack/crates/turbo-tasks-fs/src/invalidator_map.rs
+++ b/turbopack/crates/turbo-tasks-fs/src/invalidator_map.rs
@@ -6,12 +6,11 @@ use std::{
 
 use concurrent_queue::ConcurrentQueue;
 use rustc_hash::FxHashMap;
-use serde::{Deserialize, Serialize, de::Visitor};
 use turbo_tasks::{Invalidator, ReadRef};
 
 use crate::{FileContent, LinkContent};
 
-#[derive(Serialize, Deserialize, PartialEq, Eq)]
+#[derive(PartialEq, Eq)]
 pub enum WriteContent {
     File(ReadRef<FileContent>),
     Link(ReadRef<LinkContent>),
@@ -64,49 +63,3 @@ impl InvalidatorMap {
             });
     }
 }
-
-impl Serialize for InvalidatorMap {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        // TODO: This stores absolute `PathBuf`s, which are machine-specific. This should
-        // normalize/denormalize paths relative to the disk filesystem root.
-        //
-        // Potential optimization: We invalidate all fs reads immediately upon resuming from a
-        // persisted cache, but we don't invalidate the fs writes. Those read invalidations trigger
-        // re-inserts into the `InvalidatorMap`. If we knew that certain invalidators were only
-        // needed for reads, we could potentially avoid serializing those paths entirely.
-        let inner: &LockedInvalidatorMap = &self.lock().unwrap();
-        serializer.serialize_newtype_struct("InvalidatorMap", inner)
-    }
-}
-
-impl<'de> Deserialize<'de> for InvalidatorMap {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        struct V;
-
-        impl<'de> Visitor<'de> for V {
-            type Value = InvalidatorMap;
-
-            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-                write!(f, "an InvalidatorMap")
-            }
-
-            fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                Ok(InvalidatorMap {
-                    queue: ConcurrentQueue::unbounded(),
-                    map: Mutex::new(Deserialize::deserialize(deserializer)?),
-                })
-            }
-        }
-
-        deserializer.deserialize_newtype_struct("InvalidatorMap", V)
-    }
-}
diff --git a/turbopack/crates/turbo-tasks-fs/src/lib.rs b/turbopack/crates/turbo-tasks-fs/src/lib.rs
index d6609bafb4a81..d64bea0d98c8f 100644
--- a/turbopack/crates/turbo-tasks-fs/src/lib.rs
+++ b/turbopack/crates/turbo-tasks-fs/src/lib.rs
@@ -2022,61 +2022,12 @@ impl File {
     }
 }
 
-mod mime_option_serde {
-    use std::{fmt, str::FromStr};
-
-    use mime::Mime;
-    use serde::{Deserializer, Serializer, de};
-
-    pub fn serialize<S>(mime: &Option<Mime>, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        if let Some(mime) = mime {
-            serializer.serialize_str(mime.as_ref())
-        } else {
-            serializer.serialize_str("")
-        }
-    }
-
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Mime>, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct Visitor;
-
-        impl de::Visitor<'_> for Visitor {
-            type Value = Option<Mime>;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("a valid MIME type or empty string")
-            }
-
-            fn visit_str<E>(self, value: &str) -> Result<Option<Mime>, E>
-            where
-                E: de::Error,
-            {
-                if value.is_empty() {
-                    Ok(None)
-                } else {
-                    Mime::from_str(value)
-                        .map(Some)
-                        .map_err(|e| E::custom(format!("{e}")))
-                }
-            }
-        }
-
-        deserializer.deserialize_str(Visitor)
-    }
-}
-
 #[turbo_tasks::value(shared)]
 #[derive(Debug, Clone, Default)]
 pub struct FileMeta {
     // Size of the file
     // len: u64,
     permissions: Permissions,
-    #[serde(with = "mime_option_serde")]
     #[bincode(with = "turbo_bincode::mime_option")]
     #[turbo_tasks(trace_ignore)]
     content_type: Option<Mime>,
@@ -2367,19 +2318,7 @@ pub enum RawDirectoryEntry {
     Other,
 }
 
-#[derive(
-    Hash,
-    Clone,
-    Debug,
-    PartialEq,
-    Eq,
-    TraceRawVcs,
-    Serialize,
-    Deserialize,
-    NonLocalValue,
-    Encode,
-    Decode,
-)]
+#[derive(Hash, Clone, Debug, PartialEq, Eq, TraceRawVcs, NonLocalValue, Encode, Decode)]
 pub enum DirectoryEntry {
     File(FileSystemPath),
     Directory(FileSystemPath),
diff --git a/turbopack/crates/turbo-tasks-macros/src/value_macro.rs b/turbopack/crates/turbo-tasks-macros/src/value_macro.rs
index 26082b5ac45af..dce1ab6f2ca83 100644
--- a/turbopack/crates/turbo-tasks-macros/src/value_macro.rs
+++ b/turbopack/crates/turbo-tasks-macros/src/value_macro.rs
@@ -6,7 +6,7 @@ use quote::{ToTokens, quote, quote_spanned};
 use regex::Regex;
 use syn::{
     Error, Expr, ExprLit, Fields, FieldsUnnamed, Generics, Item, ItemEnum, ItemStruct, Lit, LitStr,
-    Meta, MetaNameValue, Result, Token,
+    Meta, MetaNameValue, Token,
     parse::{Parse, ParseStream},
     parse_macro_input, parse_quote,
     spanned::Spanned,
@@ -20,7 +20,7 @@ enum CellMode {
 }
 
 impl Parse for CellMode {
-    fn parse(input: ParseStream) -> Result<Self> {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
         let ident = input.parse::<LitStr>()?;
         Self::try_from(ident)
     }
@@ -29,7 +29,7 @@ impl Parse for CellMode {
 impl TryFrom<LitStr> for CellMode {
     type Error = Error;
 
-    fn try_from(lit: LitStr) -> std::result::Result<Self, Self::Error> {
+    fn try_from(lit: LitStr) -> Result<Self, Self::Error> {
         match lit.value().as_str() {
             "compare" => Ok(CellMode::Compare),
             "new" => Ok(CellMode::New),
@@ -45,7 +45,7 @@ enum SerializationMode {
 }
 
 impl Parse for SerializationMode {
-    fn parse(input: ParseStream) -> Result<Self> {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
         let ident = input.parse::<LitStr>()?;
         Self::try_from(ident)
     }
@@ -54,7 +54,7 @@ impl Parse for SerializationMode {
 impl TryFrom<LitStr> for SerializationMode {
     type Error = Error;
 
-    fn try_from(lit: LitStr) -> std::result::Result<Self, Self::Error> {
+    fn try_from(lit: LitStr) -> Result<Self, Self::Error> {
         match lit.value().as_str() {
             "none" => Ok(SerializationMode::None),
             "auto" => Ok(SerializationMode::Auto),
@@ -78,7 +78,7 @@ struct ValueArguments {
 }
 
 impl Parse for ValueArguments {
-    fn parse(input: ParseStream) -> Result<Self> {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
         let mut result = ValueArguments {
             serialization_mode: SerializationMode::Auto,
             shared: false,
@@ -300,19 +300,11 @@ pub fn value(args: TokenStream, input: TokenStream) -> TokenStream {
         SerializationMode::Auto => {
             struct_attributes.push(quote! {
                 #[derive(
-                    turbo_tasks::macro_helpers::serde::Serialize,
-                    turbo_tasks::macro_helpers::serde::Deserialize,
                     turbo_tasks::macro_helpers::bincode::Encode,
                     turbo_tasks::macro_helpers::bincode::Decode,
                 )]
-                #[serde(crate = "turbo_tasks::macro_helpers::serde")]
                 #[bincode(crate = "turbo_tasks::macro_helpers::bincode")]
             });
-            if transparent {
-                struct_attributes.push(quote! {
-                    #[serde(transparent)]
-                });
-            }
         }
         SerializationMode::None | SerializationMode::Custom => {}
     };
diff --git a/turbopack/crates/turbo-tasks/src/macro_helpers.rs b/turbopack/crates/turbo-tasks/src/macro_helpers.rs
index eda78c557366d..cf895784631bb 100644
--- a/turbopack/crates/turbo-tasks/src/macro_helpers.rs
+++ b/turbopack/crates/turbo-tasks/src/macro_helpers.rs
@@ -4,7 +4,6 @@ pub use async_trait::async_trait;
 pub use bincode;
 pub use once_cell::sync::{Lazy, OnceCell};
 use rustc_hash::FxHashMap;
-pub use serde;
 pub use shrink_to_fit;
 pub use tracing;
 
diff --git a/turbopack/crates/turbopack-core/src/chunk/mod.rs b/turbopack/crates/turbopack-core/src/chunk/mod.rs
index 1d8871ea0d239..c3ef8ae2a3758 100644
--- a/turbopack/crates/turbopack-core/src/chunk/mod.rs
+++ b/turbopack/crates/turbopack-core/src/chunk/mod.rs
@@ -52,8 +52,7 @@ use crate::{
 
 /// A module id, which can be a number or string
 #[turbo_tasks::value(shared, operation)]
-#[derive(Debug, Clone, Hash, Ord, PartialOrd, DeterministicHash)]
-#[serde(untagged)]
+#[derive(Debug, Clone, Hash, Ord, PartialOrd, DeterministicHash, Serialize, Deserialize)]
 pub enum ModuleId {
     Number(u64),
     String(RcStr),
diff --git a/turbopack/crates/turbopack-core/src/compile_time_info.rs b/turbopack/crates/turbopack-core/src/compile_time_info.rs
index ee0afc764dec5..e2ddb3d8a4b1c 100644
--- a/turbopack/crates/turbopack-core/src/compile_time_info.rs
+++ b/turbopack/crates/turbopack-core/src/compile_time_info.rs
@@ -295,19 +295,7 @@ pub struct FreeVarReferences(
     pub  FxIndexMap<Vec<DefinableNameSegment>, FreeVarReference>,
 );
 
-#[derive(
-    Debug,
-    Default,
-    Clone,
-    PartialEq,
-    Eq,
-    Serialize,
-    Deserialize,
-    TraceRawVcs,
-    NonLocalValue,
-    Encode,
-    Decode,
-)]
+#[derive(Debug, Default, Clone, PartialEq, Eq, TraceRawVcs, NonLocalValue, Encode, Decode)]
 pub struct FreeVarReferenceVcs(
     #[bincode(with = "turbo_bincode::indexmap")]
     pub  FxIndexMap<Vec<DefinableNameSegment>, ResolvedVc<FreeVarReference>>,
diff --git a/turbopack/crates/turbopack-core/src/condition.rs b/turbopack/crates/turbopack-core/src/condition.rs
index bc2d3af2f6699..f3d884ee942b1 100644
--- a/turbopack/crates/turbopack-core/src/condition.rs
+++ b/turbopack/crates/turbopack-core/src/condition.rs
@@ -1,11 +1,8 @@
 use bincode::{Decode, Encode};
-use serde::{Deserialize, Serialize};
 use turbo_tasks::{NonLocalValue, trace::TraceRawVcs};
 use turbo_tasks_fs::FileSystemPath;
 
-#[derive(
-    Debug, Clone, Serialize, Deserialize, TraceRawVcs, PartialEq, Eq, NonLocalValue, Encode, Decode,
-)]
+#[derive(Debug, Clone, TraceRawVcs, PartialEq, Eq, NonLocalValue, Encode, Decode)]
 pub enum ContextCondition {
     All(Vec<ContextCondition>),
     Any(Vec<ContextCondition>),
diff --git a/turbopack/crates/turbopack-core/src/issue/mod.rs b/turbopack/crates/turbopack-core/src/issue/mod.rs
index 6cd2a462ef8f0..d56f41e2c8973 100644
--- a/turbopack/crates/turbopack-core/src/issue/mod.rs
+++ b/turbopack/crates/turbopack-core/src/issue/mod.rs
@@ -30,8 +30,9 @@ use crate::{
 };
 
 #[turbo_tasks::value(shared)]
-#[derive(PartialOrd, Ord, Copy, Clone, Hash, Debug, DeterministicHash, TaskInput)]
-#[serde(rename_all = "camelCase")]
+#[derive(
+    PartialOrd, Ord, Copy, Clone, Hash, Debug, DeterministicHash, TaskInput, Serialize, Deserialize,
+)]
 pub enum IssueSeverity {
     Bug,
     Fatal,
@@ -80,7 +81,7 @@ impl Display for IssueSeverity {
 /// Represents a section of structured styled text. This can be interpreted and
 /// rendered by various UIs as appropriate, e.g. HTML for display on the web,
 /// ANSI sequences in TTYs.
-#[derive(Clone, Debug, PartialOrd, Ord, DeterministicHash)]
+#[derive(Clone, Debug, PartialOrd, Ord, DeterministicHash, Serialize)]
 #[turbo_tasks::value(shared)]
 pub enum StyledString {
     /// Multiple [StyledString]s concatenated into a single line. Each item is
@@ -632,7 +633,7 @@ async fn into_plain_trace(traces: Vec<Vec<ReadRef<AssetIdent>>>) -> Result<Vec<P
 }
 
 #[turbo_tasks::value(shared)]
-#[derive(Clone, Debug, PartialOrd, Ord, DeterministicHash)]
+#[derive(Clone, Debug, PartialOrd, Ord, DeterministicHash, Serialize)]
 pub enum IssueStage {
     Config,
     AppStructure,
diff --git a/turbopack/crates/turbopack-core/src/reference/mod.rs b/turbopack/crates/turbopack-core/src/reference/mod.rs
index bdfee53ba2e32..23b4991412538 100644
--- a/turbopack/crates/turbopack-core/src/reference/mod.rs
+++ b/turbopack/crates/turbopack-core/src/reference/mod.rs
@@ -2,7 +2,6 @@ use std::collections::HashSet;
 
 use anyhow::Result;
 use bincode::{Decode, Encode};
-use serde::{Deserialize, Serialize};
 use turbo_rcstr::RcStr;
 use turbo_tasks::{
     FxIndexSet, NonLocalValue, ResolvedVc, TryFlatJoinIterExt, TryJoinIterExt, ValueToString, Vc,
@@ -294,18 +293,7 @@ pub async fn primary_referenced_modules(module: Vc<Box<dyn Module>>) -> Result<V
     Ok(Vc::cell(modules))
 }
 
-#[derive(
-    Clone,
-    Serialize,
-    Deserialize,
-    Eq,
-    PartialEq,
-    ValueDebugFormat,
-    TraceRawVcs,
-    NonLocalValue,
-    Encode,
-    Decode,
-)]
+#[derive(Clone, Eq, PartialEq, ValueDebugFormat, TraceRawVcs, NonLocalValue, Encode, Decode)]
 pub struct ResolvedReference {
     pub chunking_type: ChunkingType,
     pub binding_usage: BindingUsage,
diff --git a/turbopack/crates/turbopack-core/src/resolve/mod.rs b/turbopack/crates/turbopack-core/src/resolve/mod.rs
index 800f62e6245c8..2320b008e7d6c 100644
--- a/turbopack/crates/turbopack-core/src/resolve/mod.rs
+++ b/turbopack/crates/turbopack-core/src/resolve/mod.rs
@@ -100,7 +100,7 @@ impl ModuleResolveResultItem {
 }
 
 #[turbo_tasks::value(shared)]
-#[derive(Clone, Debug, Hash, Default)]
+#[derive(Clone, Debug, Hash, Default, Serialize, Deserialize)]
 pub struct BindingUsage {
     pub import: ImportUsage,
     pub export: ExportUsage,
@@ -115,7 +115,7 @@ impl BindingUsage {
 }
 
 #[turbo_tasks::value(shared)]
-#[derive(Debug, Clone, Default, Hash)]
+#[derive(Debug, Clone, Default, Hash, Serialize, Deserialize)]
 pub enum ImportUsage {
     /// This import is used by some side effect in the module (and can't be tree shaken).
     #[default]
@@ -129,7 +129,7 @@ pub enum ImportUsage {
 }
 
 #[turbo_tasks::value]
-#[derive(Debug, Clone, Default, Hash)]
+#[derive(Debug, Clone, Default, Hash, Serialize, Deserialize)]
 pub enum ExportUsage {
     Named(RcStr),
     /// This means the whole content of the module is used.
@@ -1288,9 +1288,7 @@ pub async fn find_context_file_or_package_key(
     Ok(find_context_file(lookup_path.parent(), names, false))
 }
 
-#[derive(
-    Clone, PartialEq, Eq, Serialize, Deserialize, TraceRawVcs, Debug, NonLocalValue, Encode, Decode,
-)]
+#[derive(Clone, PartialEq, Eq, TraceRawVcs, Debug, NonLocalValue, Encode, Decode)]
 enum FindPackageItem {
     PackageDirectory { name: RcStr, dir: FileSystemPath },
     PackageFile { name: RcStr, file: FileSystemPath },
diff --git a/turbopack/crates/turbopack-core/src/resolve/options.rs b/turbopack/crates/turbopack-core/src/resolve/options.rs
index de19510b87564..249ab434383fa 100644
--- a/turbopack/crates/turbopack-core/src/resolve/options.rs
+++ b/turbopack/crates/turbopack-core/src/resolve/options.rs
@@ -10,13 +10,13 @@ use turbo_tasks::{
 };
 use turbo_tasks_fs::{FileSystemPath, glob::Glob};
 
-use super::{
-    AliasPattern, ExternalType, ResolveResult, ResolveResultItem,
+use crate::resolve::{
+    AliasPattern, ExternalTraced, ExternalType, ResolveResult, ResolveResultItem,
     alias_map::{AliasMap, AliasTemplate},
+    parse::Request,
     pattern::Pattern,
-    plugin::BeforeResolvePlugin,
+    plugin::{AfterResolvePlugin, BeforeResolvePlugin},
 };
-use crate::resolve::{ExternalTraced, parse::Request, plugin::AfterResolvePlugin};
 
 #[turbo_tasks::value(shared)]
 #[derive(Hash, Debug)]
@@ -28,18 +28,7 @@ pub struct ExcludedExtensions(#[bincode(with = "turbo_bincode::indexset")] pub F
 
 /// A location where to resolve modules.
 #[derive(
-    TraceRawVcs,
-    Hash,
-    PartialEq,
-    Eq,
-    Clone,
-    Debug,
-    Serialize,
-    Deserialize,
-    ValueDebugFormat,
-    NonLocalValue,
-    Encode,
-    Decode,
+    TraceRawVcs, Hash, PartialEq, Eq, Clone, Debug, ValueDebugFormat, NonLocalValue, Encode, Decode,
 )]
 pub enum ResolveModules {
     /// when inside of path, use the list of directories to
diff --git a/turbopack/crates/turbopack-core/src/resolve/pattern.rs b/turbopack/crates/turbopack-core/src/resolve/pattern.rs
index 1d0985091a354..d26855f4d145b 100644
--- a/turbopack/crates/turbopack-core/src/resolve/pattern.rs
+++ b/turbopack/crates/turbopack-core/src/resolve/pattern.rs
@@ -8,7 +8,6 @@ use anyhow::{Result, bail};
 use bincode::{Decode, Encode};
 use regex::Regex;
 use rustc_hash::{FxHashMap, FxHashSet};
-use serde::{Deserialize, Serialize};
 use tracing::Instrument;
 use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{
@@ -1490,17 +1489,7 @@ impl ValueToString for Pattern {
 }
 
 #[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    Clone,
-    TraceRawVcs,
-    Serialize,
-    Deserialize,
-    ValueDebugFormat,
-    NonLocalValue,
-    Encode,
-    Decode,
+    Debug, PartialEq, Eq, Clone, TraceRawVcs, ValueDebugFormat, NonLocalValue, Encode, Decode,
 )]
 pub enum PatternMatch {
     File(RcStr, FileSystemPath),
diff --git a/turbopack/crates/turbopack-core/src/resolve/remap.rs b/turbopack/crates/turbopack-core/src/resolve/remap.rs
index 8c5c86c4e2cee..72b9e4896ea78 100644
--- a/turbopack/crates/turbopack-core/src/resolve/remap.rs
+++ b/turbopack/crates/turbopack-core/src/resolve/remap.rs
@@ -61,7 +61,7 @@ pub enum SubpathValue {
 
 /// A `SubpathValue` that was applied to a pattern. See `SubpathValue` for
 /// more details on the variants.
-#[derive(Clone, PartialEq, Eq, Hash, Debug, Serialize, Deserialize)]
+#[derive(Clone, PartialEq, Eq, Hash, Debug)]
 pub enum ReplacedSubpathValue {
     Alternatives(Vec<ReplacedSubpathValue>),
     Conditional(Vec<(RcStr, ReplacedSubpathValue)>),
diff --git a/turbopack/crates/turbopack-core/src/source_map/source_map_asset.rs b/turbopack/crates/turbopack-core/src/source_map/source_map_asset.rs
index 1496f50e5b9de..96804bba51bce 100644
--- a/turbopack/crates/turbopack-core/src/source_map/source_map_asset.rs
+++ b/turbopack/crates/turbopack-core/src/source_map/source_map_asset.rs
@@ -1,6 +1,5 @@
 use anyhow::Result;
 use bincode::{Decode, Encode};
-use serde::{Deserialize, Serialize};
 use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{
     FxIndexSet, NonLocalValue, ResolvedVc, ValueToString, Vc, debug::ValueDebugFormat,
@@ -17,17 +16,7 @@ use crate::{
     source_map::{GenerateSourceMap, SourceMap},
 };
 
-#[derive(
-    PartialEq,
-    Eq,
-    Serialize,
-    Deserialize,
-    NonLocalValue,
-    TraceRawVcs,
-    ValueDebugFormat,
-    Encode,
-    Decode,
-)]
+#[derive(PartialEq, Eq, NonLocalValue, TraceRawVcs, ValueDebugFormat, Encode, Decode)]
 enum PathType {
     Fixed {
         path: FileSystemPath,
diff --git a/turbopack/crates/turbopack-ecmascript-plugins/src/transform/emotion.rs b/turbopack/crates/turbopack-ecmascript-plugins/src/transform/emotion.rs
index ef1ec7ee98081..ca0af10753479 100644
--- a/turbopack/crates/turbopack-ecmascript-plugins/src/transform/emotion.rs
+++ b/turbopack/crates/turbopack-ecmascript-plugins/src/transform/emotion.rs
@@ -29,7 +29,6 @@ use turbopack_ecmascript::{CustomTransformer, TransformContext};
     Eq,
     Debug,
     TraceRawVcs,
-    Serialize,
     Deserialize,
     NonLocalValue,
     OperationValue,
@@ -75,7 +74,7 @@ impl From<&EmotionItemSpecifier> for swc_emotion::ItemSpecifier {
 pub type EmotionImportMapValue = IndexMap<RcStr, EmotionImportItemConfig, FxBuildHasher>;
 
 #[turbo_tasks::value(shared, operation)]
-#[derive(Default, Clone, Debug)]
+#[derive(Default, Clone, Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct EmotionTransformConfig {
     pub sourcemap: Option<bool>,
diff --git a/turbopack/crates/turbopack-ecmascript-plugins/src/transform/relay.rs b/turbopack/crates/turbopack-ecmascript-plugins/src/transform/relay.rs
index 2154802db3cb6..a416d318e8165 100644
--- a/turbopack/crates/turbopack-ecmascript-plugins/src/transform/relay.rs
+++ b/turbopack/crates/turbopack-ecmascript-plugins/src/transform/relay.rs
@@ -11,16 +11,7 @@ use turbo_tasks_fs::FileSystemPath;
 use turbopack_ecmascript::{CustomTransformer, TransformContext};
 
 #[derive(
-    Clone,
-    Debug,
-    PartialEq,
-    Serialize,
-    Deserialize,
-    TraceRawVcs,
-    NonLocalValue,
-    OperationValue,
-    Encode,
-    Decode,
+    Clone, Debug, PartialEq, Deserialize, TraceRawVcs, NonLocalValue, OperationValue, Encode, Decode,
 )]
 #[serde(rename_all = "camelCase")]
 pub struct RelayConfig {
@@ -30,16 +21,7 @@ pub struct RelayConfig {
 }
 
 #[derive(
-    Clone,
-    Debug,
-    PartialEq,
-    Serialize,
-    Deserialize,
-    TraceRawVcs,
-    NonLocalValue,
-    OperationValue,
-    Encode,
-    Decode,
+    Clone, Debug, PartialEq, Deserialize, TraceRawVcs, NonLocalValue, OperationValue, Encode, Decode,
 )]
 #[serde(rename_all = "lowercase")]
 pub enum RelayLanguage {
diff --git a/turbopack/crates/turbopack-ecmascript-plugins/src/transform/styled_components.rs b/turbopack/crates/turbopack-ecmascript-plugins/src/transform/styled_components.rs
index dcfb1b93de07f..52eb665959487 100644
--- a/turbopack/crates/turbopack-ecmascript-plugins/src/transform/styled_components.rs
+++ b/turbopack/crates/turbopack-ecmascript-plugins/src/transform/styled_components.rs
@@ -1,11 +1,12 @@
 use anyhow::Result;
 use async_trait::async_trait;
+use serde::Deserialize;
 use swc_core::{atoms::Wtf8Atom, common::comments::NoopComments, ecma::ast::Program};
 use turbo_tasks::{ValueDefault, Vc};
 use turbopack_ecmascript::{CustomTransformer, TransformContext};
 
 #[turbo_tasks::value(shared, operation)]
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
 pub struct StyledComponentsTransformConfig {
     pub display_name: bool,
diff --git a/turbopack/crates/turbopack-ecmascript/src/chunk/item.rs b/turbopack/crates/turbopack-ecmascript/src/chunk/item.rs
index 6311b29bf58da..6365411b40c74 100644
--- a/turbopack/crates/turbopack-ecmascript/src/chunk/item.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/chunk/item.rs
@@ -35,8 +35,6 @@ use crate::{
     PartialEq,
     Eq,
     Hash,
-    Serialize,
-    Deserialize,
     TraceRawVcs,
     TaskInput,
     NonLocalValue,
diff --git a/turbopack/crates/turbopack-ecmascript/src/code_gen.rs b/turbopack/crates/turbopack-ecmascript/src/code_gen.rs
index 7536b1a13380d..0ac5934e5980d 100644
--- a/turbopack/crates/turbopack-ecmascript/src/code_gen.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/code_gen.rs
@@ -1,6 +1,5 @@
 use anyhow::Result;
 use bincode::{Decode, Encode};
-use serde::{Deserialize, Serialize};
 use swc_core::{
     base::SwcComments,
     ecma::{
@@ -175,17 +174,7 @@ impl_modify!(visit_mut_switch_case, SwitchCase);
 impl_modify!(visit_mut_program, Program);
 
 #[derive(
-    PartialEq,
-    Eq,
-    Serialize,
-    Deserialize,
-    TraceRawVcs,
-    ValueDebugFormat,
-    NonLocalValue,
-    Hash,
-    Debug,
-    Encode,
-    Decode,
+    PartialEq, Eq, TraceRawVcs, ValueDebugFormat, NonLocalValue, Hash, Debug, Encode, Decode,
 )]
 pub enum CodeGen {
     // AMD occurs very rarely and makes the enum much bigger
diff --git a/turbopack/crates/turbopack-ecmascript/src/references/constant_value.rs b/turbopack/crates/turbopack-ecmascript/src/references/constant_value.rs
index 524eafd3c3610..9bf639fc3de8d 100644
--- a/turbopack/crates/turbopack-ecmascript/src/references/constant_value.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/references/constant_value.rs
@@ -1,6 +1,5 @@
 use anyhow::Result;
 use bincode::{Decode, Encode};
-use serde::{Deserialize, Serialize};
 use swc_core::{
     common::{DUMMY_SP, FileName, SourceMap, sync::Lrc},
     ecma::{
@@ -20,18 +19,7 @@ use crate::{
 };
 
 #[derive(
-    Clone,
-    Debug,
-    PartialEq,
-    Eq,
-    Hash,
-    Serialize,
-    Deserialize,
-    TraceRawVcs,
-    ValueDebugFormat,
-    NonLocalValue,
-    Encode,
-    Decode,
+    Clone, Debug, PartialEq, Eq, Hash, TraceRawVcs, ValueDebugFormat, NonLocalValue, Encode, Decode,
 )]
 pub struct ConstantValueCodeGen {
     value: CompileTimeDefineValue,
diff --git a/turbopack/crates/turbopack-ecmascript/src/references/esm/meta.rs b/turbopack/crates/turbopack-ecmascript/src/references/esm/meta.rs
index 97e6df63af99a..40672da6ef4c5 100644
--- a/turbopack/crates/turbopack-ecmascript/src/references/esm/meta.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/references/esm/meta.rs
@@ -28,17 +28,7 @@ use crate::{
 ///
 /// This singleton behavior must be enforced by the caller!
 #[derive(
-    PartialEq,
-    Eq,
-    Serialize,
-    Deserialize,
-    TraceRawVcs,
-    ValueDebugFormat,
-    NonLocalValue,
-    Debug,
-    Hash,
-    Encode,
-    Decode,
+    PartialEq, Eq, TraceRawVcs, ValueDebugFormat, NonLocalValue, Debug, Hash, Encode, Decode,
 )]
 pub struct ImportMetaBinding {
     path: FileSystemPath,
diff --git a/turbopack/crates/turbopack-ecmascript/src/references/pattern_mapping.rs b/turbopack/crates/turbopack-ecmascript/src/references/pattern_mapping.rs
index d6204e64a4bd7..19d9d6d0c05f9 100644
--- a/turbopack/crates/turbopack-ecmascript/src/references/pattern_mapping.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/references/pattern_mapping.rs
@@ -38,17 +38,7 @@ use crate::{
     utils::module_id_to_lit,
 };
 
-#[derive(
-    PartialEq,
-    Eq,
-    ValueDebugFormat,
-    TraceRawVcs,
-    Serialize,
-    Deserialize,
-    NonLocalValue,
-    Encode,
-    Decode,
-)]
+#[derive(PartialEq, Eq, ValueDebugFormat, TraceRawVcs, NonLocalValue, Encode, Decode)]
 pub(crate) enum SinglePatternMapping {
     /// Invalid request.
     Invalid,
diff --git a/turbopack/crates/turbopack-ecmascript/src/transform/mod.rs b/turbopack/crates/turbopack-ecmascript/src/transform/mod.rs
index 2a66ecf2948fa..75af038dea4de 100644
--- a/turbopack/crates/turbopack-ecmascript/src/transform/mod.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/transform/mod.rs
@@ -33,9 +33,7 @@ pub enum EcmascriptInputTransform {
     Plugin(ResolvedVc<TransformPlugin>),
     PresetEnv(ResolvedVc<Environment>),
     React {
-        #[serde(default)]
         development: bool,
-        #[serde(default)]
         refresh: bool,
         // swc.jsc.transform.react.importSource
         import_source: ResolvedVc<Option<RcStr>>,
@@ -45,17 +43,12 @@ pub enum EcmascriptInputTransform {
     // These options are subset of swc_core::ecma::transforms::typescript::Config, but
     // it doesn't derive `Copy` so repeating values in here
     TypeScript {
-        #[serde(default)]
         use_define_for_class_fields: bool,
     },
     Decorators {
-        #[serde(default)]
         is_legacy: bool,
-        #[serde(default)]
         is_ecma: bool,
-        #[serde(default)]
         emit_decorators_metadata: bool,
-        #[serde(default)]
         use_define_for_class_fields: bool,
     },
 }
diff --git a/turbopack/crates/turbopack-image/Cargo.toml b/turbopack/crates/turbopack-image/Cargo.toml
index 94f27b7398288..4f01d1a8aaef6 100644
--- a/turbopack/crates/turbopack-image/Cargo.toml
+++ b/turbopack/crates/turbopack-image/Cargo.toml
@@ -35,7 +35,6 @@ once_cell = { workspace = true }
 regex = { workspace = true }
 rustc-hash = { workspace = true }
 serde = { workspace = true }
-serde_with = { workspace = true }
 turbo-bincode = { workspace = true }
 turbo-rcstr = { workspace = true }
 turbo-tasks = { workspace = true }
diff --git a/turbopack/crates/turbopack-image/src/process/mod.rs b/turbopack/crates/turbopack-image/src/process/mod.rs
index 2935f6a37c373..85ed97372e9db 100644
--- a/turbopack/crates/turbopack-image/src/process/mod.rs
+++ b/turbopack/crates/turbopack-image/src/process/mod.rs
@@ -17,7 +17,6 @@ use image::{
 };
 use mime::Mime;
 use serde::{Deserialize, Serialize};
-use serde_with::{DisplayFromStr, serde_as};
 use turbo_rcstr::rcstr;
 use turbo_tasks::{NonLocalValue, ResolvedVc, Vc, debug::ValueDebugFormat, trace::TraceRawVcs};
 use turbo_tasks_fs::{File, FileContent, FileSystemPath};
@@ -64,7 +63,6 @@ impl BlurPlaceholder {
 
 /// Gathered meta information about an image.
 #[allow(clippy::manual_non_exhaustive)]
-#[serde_as]
 #[turbo_tasks::value]
 #[derive(Default)]
 #[non_exhaustive]
@@ -72,7 +70,6 @@ pub struct ImageMetaData {
     pub width: u32,
     pub height: u32,
     #[turbo_tasks(trace_ignore, debug_ignore)]
-    #[serde_as(as = "Option<DisplayFromStr>")]
     #[bincode(with = "turbo_bincode::mime_option")]
     pub mime_type: Option<Mime>,
     pub blur_placeholder: Option<BlurPlaceholder>,
diff --git a/turbopack/crates/turbopack-mdx/Cargo.toml b/turbopack/crates/turbopack-mdx/Cargo.toml
index a91b76a83ccfe..2bf88da2115f4 100644
--- a/turbopack/crates/turbopack-mdx/Cargo.toml
+++ b/turbopack/crates/turbopack-mdx/Cargo.toml
@@ -14,13 +14,11 @@ workspace = true
 
 [dependencies]
 anyhow = { workspace = true }
-
 markdown = { workspace = true }
 mdxjs = { workspace = true }
-
+serde = { workspace = true }
 turbo-rcstr = { workspace = true }
 turbo-tasks = { workspace = true }
 turbo-tasks-fs = { workspace = true }
 turbopack-core = { workspace = true }
 turbopack-ecmascript = { workspace = true }
-
diff --git a/turbopack/crates/turbopack-mdx/src/lib.rs b/turbopack/crates/turbopack-mdx/src/lib.rs
index c771f6e4bbd25..2e9a95d105ade 100644
--- a/turbopack/crates/turbopack-mdx/src/lib.rs
+++ b/turbopack/crates/turbopack-mdx/src/lib.rs
@@ -4,6 +4,7 @@
 
 use anyhow::Result;
 use mdxjs::{MdxParseOptions, Options, compile};
+use serde::Deserialize;
 use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{ResolvedVc, ValueDefault, Vc};
 use turbo_tasks_fs::{File, FileContent, FileSystemPath, rope::Rope};
@@ -20,7 +21,7 @@ use turbopack_core::{
 };
 
 #[turbo_tasks::value(shared, operation)]
-#[derive(Hash, Debug, Clone)]
+#[derive(Hash, Debug, Clone, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub enum MdxParseConstructs {
     Commonmark,
@@ -31,7 +32,7 @@ pub enum MdxParseConstructs {
 /// into mdxjs. This is thin, near straightforward subset of mdxjs::Options to
 /// enable turbo tasks.
 #[turbo_tasks::value(shared, operation)]
-#[derive(Hash, Debug, Clone)]
+#[derive(Hash, Debug, Clone, Deserialize)]
 #[serde(rename_all = "camelCase", default)]
 pub struct MdxTransformOptions {
     pub development: Option<bool>,
diff --git a/turbopack/crates/turbopack-node/src/source_map/mod.rs b/turbopack/crates/turbopack-node/src/source_map/mod.rs
index 78d67cb8f5992..43305875b0443 100644
--- a/turbopack/crates/turbopack-node/src/source_map/mod.rs
+++ b/turbopack/crates/turbopack-node/src/source_map/mod.rs
@@ -8,6 +8,7 @@ use anyhow::Result;
 use const_format::concatcp;
 use once_cell::sync::Lazy;
 use regex::Regex;
+use serde::Deserialize;
 use turbo_tasks::{ReadRef, Vc};
 use turbo_tasks_fs::{
     FileLinesContent, FileSystemPath, source_context::get_source_context, to_sys_path,
@@ -264,7 +265,7 @@ async fn resolve_source_mapping(
 }
 
 #[turbo_tasks::value(shared)]
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Deserialize)]
 pub struct StructuredError {
     pub name: String,
     pub message: String,
diff --git a/turbopack/crates/turbopack-node/src/transforms/postcss.rs b/turbopack/crates/turbopack-node/src/transforms/postcss.rs
index 88436b8e6533c..22a554ad03fde 100644
--- a/turbopack/crates/turbopack-node/src/transforms/postcss.rs
+++ b/turbopack/crates/turbopack-node/src/transforms/postcss.rs
@@ -36,7 +36,7 @@ use crate::{
     },
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Deserialize)]
 #[turbo_tasks::value]
 #[serde(rename_all = "camelCase")]
 struct PostCssProcessingResult {
diff --git a/turbopack/crates/turbopack-node/src/transforms/webpack.rs b/turbopack/crates/turbopack-node/src/transforms/webpack.rs
index 29ffc970fc8c4..bee1034bfb047 100644
--- a/turbopack/crates/turbopack-node/src/transforms/webpack.rs
+++ b/turbopack/crates/turbopack-node/src/transforms/webpack.rs
@@ -69,7 +69,7 @@ struct BytesBase64 {
     binary: Vec<u8>,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[turbo_tasks::value]
 #[serde(rename_all = "camelCase")]
 struct WebpackLoadersProcessingResult {
@@ -442,19 +442,7 @@ pub enum ResponseMessage {
     TrackFileRead {},
 }
 
-#[derive(
-    Clone,
-    PartialEq,
-    Eq,
-    Hash,
-    TaskInput,
-    Serialize,
-    Deserialize,
-    Debug,
-    TraceRawVcs,
-    Encode,
-    Decode,
-)]
+#[derive(Clone, PartialEq, Eq, Hash, TaskInput, Debug, TraceRawVcs, Encode, Decode)]
 pub struct WebpackLoaderContext {
     pub entries: ResolvedVc<EvaluateEntries>,
     pub cwd: FileSystemPath,
diff --git a/turbopack/crates/turbopack-resolve/src/resolve_options_context.rs b/turbopack/crates/turbopack-resolve/src/resolve_options_context.rs
index 8a36716982327..0d6dcd236a133 100644
--- a/turbopack/crates/turbopack-resolve/src/resolve_options_context.rs
+++ b/turbopack/crates/turbopack-resolve/src/resolve_options_context.rs
@@ -14,66 +14,48 @@ use turbopack_core::{
 #[turbo_tasks::value(shared)]
 #[derive(Default, Clone)]
 pub struct ResolveOptionsContext {
-    #[serde(default)]
     pub emulate_environment: Option<ResolvedVc<Environment>>,
-    #[serde(default)]
     pub enable_types: bool,
-    #[serde(default)]
     pub enable_typescript: bool,
-    #[serde(default)]
     pub enable_react: bool,
-    #[serde(default)]
     pub enable_node_native_modules: bool,
-    #[serde(default)]
     // Enable resolving of .mjs files without the .mjs extension
     pub enable_mjs_extension: bool,
-    #[serde(default)]
     /// Enable resolving of the node_modules folder when within the provided
     /// directory
     pub enable_node_modules: Option<FileSystemPath>,
-    #[serde(default)]
     /// A specific path to a tsconfig.json file to use for resolving modules. If `None`, one will
     /// be looked up through the filesystem
     pub tsconfig_path: Option<FileSystemPath>,
-    #[serde(default)]
     /// Mark well-known Node.js modules as external imports and load them using
     /// native `require`. e.g. url, querystring, os
     pub enable_node_externals: bool,
     /// Mark well-known Edge modules as external imports and load them using
     /// native `require`. e.g. buffer, events, assert
     pub enable_edge_node_externals: bool,
-    #[serde(default)]
     /// Enables the "browser" field and export condition in package.json
     pub browser: bool,
-    #[serde(default)]
     /// Enables the "module" field and export condition in package.json
     pub module: bool,
-    #[serde(default)]
     pub custom_conditions: Vec<RcStr>,
-    #[serde(default)]
     pub custom_extensions: Option<Vec<RcStr>>,
-    #[serde(default)]
     /// An additional import map to use when resolving modules.
     ///
     /// If set, this import map will be applied to `ResolveOption::import_map`.
     /// It is always applied last, so any mapping defined within will take
     /// precedence over any other (e.g. tsconfig.json `compilerOptions.paths`).
     pub import_map: Option<ResolvedVc<ImportMap>>,
-    #[serde(default)]
     /// An import map to fall back to when a request could not be resolved.
     ///
     /// If set, this import map will be applied to
     /// `ResolveOption::fallback_import_map`. It is always applied last, so
     /// any mapping defined within will take precedence over any other.
     pub fallback_import_map: Option<ResolvedVc<ImportMap>>,
-    #[serde(default)]
     /// An additional resolved map to use after modules have been resolved.
     pub resolved_map: Option<ResolvedVc<ResolvedMap>>,
-    #[serde(default)]
     /// A list of rules to use a different resolve option context for certain
     /// context paths. The first matching is used.
     pub rules: Vec<(ContextCondition, ResolvedVc<ResolveOptionsContext>)>,
-    #[serde(default)]
     /// Plugins which get applied before and after resolving.
     pub after_resolve_plugins: Vec<ResolvedVc<Box<dyn AfterResolvePlugin>>>,
     pub before_resolve_plugins: Vec<ResolvedVc<Box<dyn BeforeResolvePlugin>>>,
@@ -82,7 +64,6 @@ pub struct ResolveOptionsContext {
     /// Collect affecting sources for each resolve result.  Useful for tracing.
     pub collect_affecting_sources: bool,
 
-    #[serde(default)]
     pub placeholder_for_future_extensions: (),
 }
 
diff --git a/turbopack/crates/turbopack/src/module_options/match_mode.rs b/turbopack/crates/turbopack/src/module_options/match_mode.rs
index 861e2505e49a5..17bd654d3ff04 100644
--- a/turbopack/crates/turbopack/src/module_options/match_mode.rs
+++ b/turbopack/crates/turbopack/src/module_options/match_mode.rs
@@ -1,21 +1,8 @@
 use bincode::{Decode, Encode};
-use serde::{Deserialize, Serialize};
 use turbo_tasks::{NonLocalValue, trace::TraceRawVcs};
 use turbopack_core::reference_type::ReferenceType;
 
-#[derive(
-    Copy,
-    Clone,
-    Debug,
-    PartialEq,
-    Eq,
-    Serialize,
-    Deserialize,
-    TraceRawVcs,
-    NonLocalValue,
-    Encode,
-    Decode,
-)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, TraceRawVcs, NonLocalValue, Encode, Decode)]
 pub enum MatchMode {
     // Match all but internal references.
     NonInternal,
diff --git a/turbopack/crates/turbopack/src/module_options/module_options_context.rs b/turbopack/crates/turbopack/src/module_options/module_options_context.rs
index 4e0385628793c..32431be4d00d9 100644
--- a/turbopack/crates/turbopack/src/module_options/module_options_context.rs
+++ b/turbopack/crates/turbopack/src/module_options/module_options_context.rs
@@ -22,9 +22,7 @@ use turbopack_node::{
 use super::ModuleRule;
 use crate::module_options::RuleCondition;
 
-#[derive(
-    Clone, PartialEq, Eq, Debug, TraceRawVcs, Serialize, Deserialize, NonLocalValue, Encode, Decode,
-)]
+#[derive(Clone, PartialEq, Eq, Debug, TraceRawVcs, NonLocalValue, Encode, Decode)]
 pub struct LoaderRuleItem {
     pub loaders: ResolvedVc<WebpackLoaderItems>,
     pub rename_as: Option<RcStr>,
@@ -182,7 +180,6 @@ pub struct ExternalsTracingOptions {
 
 #[turbo_tasks::value(shared)]
 #[derive(Clone, Default)]
-#[serde(default)]
 pub struct ModuleOptionsContext {
     pub ecmascript: EcmascriptOptionsContext,
     pub css: CssOptionsContext,
@@ -223,7 +220,6 @@ pub struct ModuleOptionsContext {
 
 #[turbo_tasks::value(shared)]
 #[derive(Clone, Default)]
-#[serde(default)]
 pub struct EcmascriptOptionsContext {
     // TODO this should just be handled via CompileTimeInfo FreeVarReferences, but then it
     // (currently) wouldn't be possible to have different replacement values in user code vs
@@ -257,7 +253,6 @@ pub struct EcmascriptOptionsContext {
 
 #[turbo_tasks::value(shared)]
 #[derive(Clone, Default)]
-#[serde(default)]
 pub struct CssOptionsContext {
     /// This skips `GlobalCss` and `ModuleCss` module assets from being
     /// generated in the module graph, generating only `Css` module assets.
diff --git a/turbopack/crates/turbopack/src/module_options/module_rule.rs b/turbopack/crates/turbopack/src/module_options/module_rule.rs
index 2711e2dde367c..0f5ddaecb340b 100644
--- a/turbopack/crates/turbopack/src/module_options/module_rule.rs
+++ b/turbopack/crates/turbopack/src/module_options/module_rule.rs
@@ -1,6 +1,5 @@
 use anyhow::Result;
 use bincode::{Decode, Encode};
-use serde::{Deserialize, Serialize};
 use turbo_rcstr::RcStr;
 use turbo_tasks::{NonLocalValue, ResolvedVc, trace::TraceRawVcs};
 use turbo_tasks_fs::FileSystemPath;
@@ -12,11 +11,9 @@ use turbopack_css::CssModuleAssetType;
 use turbopack_ecmascript::{EcmascriptInputTransforms, EcmascriptOptions};
 use turbopack_wasm::source::WebAssemblySourceType;
 
-use super::{CustomModuleType, RuleCondition, match_mode::MatchMode};
+use crate::module_options::{CustomModuleType, RuleCondition, match_mode::MatchMode};
 
-#[derive(
-    Debug, Clone, Serialize, Deserialize, TraceRawVcs, PartialEq, Eq, NonLocalValue, Encode, Decode,
-)]
+#[derive(Debug, Clone, TraceRawVcs, PartialEq, Eq, NonLocalValue, Encode, Decode)]
 pub struct ModuleRule {
     condition: RuleCondition,
     effects: Vec<ModuleRuleEffect>,
diff --git a/turbopack/crates/turbopack/src/module_options/rule_condition.rs b/turbopack/crates/turbopack/src/module_options/rule_condition.rs
index 51471faa444f8..0be522faeb6ac 100644
--- a/turbopack/crates/turbopack/src/module_options/rule_condition.rs
+++ b/turbopack/crates/turbopack/src/module_options/rule_condition.rs
@@ -6,7 +6,6 @@ use std::{
 use anyhow::Result;
 use bincode::{Decode, Encode};
 use either::Either;
-use serde::{Deserialize, Serialize};
 use smallvec::SmallVec;
 use turbo_esregex::EsRegex;
 use turbo_tasks::{NonLocalValue, ReadRef, ResolvedVc, trace::TraceRawVcs};
@@ -15,9 +14,7 @@ use turbopack_core::{
     asset::Asset, reference_type::ReferenceType, source::Source, virtual_source::VirtualSource,
 };
 
-#[derive(
-    Debug, Clone, Serialize, Deserialize, TraceRawVcs, PartialEq, Eq, NonLocalValue, Encode, Decode,
-)]
+#[derive(Debug, Clone, TraceRawVcs, PartialEq, Eq, NonLocalValue, Encode, Decode)]
 pub enum RuleCondition {
     All(Vec<RuleCondition>),
     Any(Vec<RuleCondition>),
diff --git a/turbopack/crates/turbopack/src/module_options/transition_rule.rs b/turbopack/crates/turbopack/src/module_options/transition_rule.rs
index 0de49e4da394e..12f531b796587 100644
--- a/turbopack/crates/turbopack/src/module_options/transition_rule.rs
+++ b/turbopack/crates/turbopack/src/module_options/transition_rule.rs
@@ -1,6 +1,5 @@
 use anyhow::Result;
 use bincode::{Decode, Encode};
-use serde::{Deserialize, Serialize};
 use turbo_tasks::{NonLocalValue, ResolvedVc, trace::TraceRawVcs};
 use turbo_tasks_fs::FileSystemPath;
 use turbopack_core::{reference_type::ReferenceType, source::Source};
@@ -10,9 +9,7 @@ use crate::{
     transition::Transition,
 };
 
-#[derive(
-    Debug, Clone, Serialize, Deserialize, TraceRawVcs, PartialEq, Eq, NonLocalValue, Encode, Decode,
-)]
+#[derive(Debug, Clone, TraceRawVcs, PartialEq, Eq, NonLocalValue, Encode, Decode)]
 pub struct TransitionRule {
     condition: RuleCondition,
     transition: ResolvedVc<Box<dyn Transition>>,