Vendor dependencies for 0.3.0 release

vendor/bevy_reflect/src/serde/ser/arrays.rs

@@ -0,0 +1,28 @@
+use crate::{serde::TypedReflectSerializer, Array, TypeRegistry};
+use serde::{ser::SerializeTuple, Serialize};
+
+use super::ReflectSerializerProcessor;
+
+/// A serializer for [`Array`] values.
+pub(super) struct ArraySerializer<'a, P> {
+    pub array: &'a dyn Array,
+    pub registry: &'a TypeRegistry,
+    pub processor: Option<&'a P>,
+}
+
+impl<P: ReflectSerializerProcessor> Serialize for ArraySerializer<'_, P> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_tuple(self.array.len())?;
+        for value in self.array.iter() {
+            state.serialize_element(&TypedReflectSerializer::new_internal(
+                value,
+                self.registry,
+                self.processor,
+            ))?;
+        }
+        state.end()
+    }
+}

vendor/bevy_reflect/src/serde/ser/custom_serialization.rs

@@ -0,0 +1,62 @@
+use crate::serde::ser::error_utils::make_custom_error;
+#[cfg(feature = "debug_stack")]
+use crate::serde::ser::error_utils::TYPE_INFO_STACK;
+use crate::serde::ReflectSerializeWithRegistry;
+use crate::{PartialReflect, ReflectSerialize, TypeRegistry};
+use core::borrow::Borrow;
+use serde::{Serialize, Serializer};
+
+/// Attempts to serialize a [`PartialReflect`] value with custom [`ReflectSerialize`]
+/// or [`ReflectSerializeWithRegistry`] type data.
+///
+/// On success, returns the result of the serialization.
+/// On failure, returns the original serializer and the error that occurred.
+pub(super) fn try_custom_serialize<S: Serializer>(
+    value: &dyn PartialReflect,
+    type_registry: &TypeRegistry,
+    serializer: S,
+) -> Result<Result<S::Ok, S::Error>, (S, S::Error)> {
+    let Some(value) = value.try_as_reflect() else {
+        return Err((
+            serializer,
+            make_custom_error(format_args!(
+                "type `{}` does not implement `Reflect`",
+                value.reflect_type_path()
+            )),
+        ));
+    };
+
+    let info = value.reflect_type_info();
+
+    let Some(registration) = type_registry.get(info.type_id()) else {
+        return Err((
+            serializer,
+            make_custom_error(format_args!(
+                "type `{}` is not registered in the type registry",
+                info.type_path(),
+            )),
+        ));
+    };
+
+    if let Some(reflect_serialize) = registration.data::<ReflectSerialize>() {
+        #[cfg(feature = "debug_stack")]
+        TYPE_INFO_STACK.with_borrow_mut(crate::type_info_stack::TypeInfoStack::pop);
+
+        Ok(reflect_serialize
+            .get_serializable(value)
+            .borrow()
+            .serialize(serializer))
+    } else if let Some(reflect_serialize_with_registry) =
+        registration.data::<ReflectSerializeWithRegistry>()
+    {
+        #[cfg(feature = "debug_stack")]
+        TYPE_INFO_STACK.with_borrow_mut(crate::type_info_stack::TypeInfoStack::pop);
+
+        Ok(reflect_serialize_with_registry.serialize(value, serializer, type_registry))
+    } else {
+        Err((serializer, make_custom_error(format_args!(
+            "type `{}` did not register the `ReflectSerialize` or `ReflectSerializeWithRegistry` type data. For certain types, this may need to be registered manually using `register_type_data`",
+            info.type_path(),
+        ))))
+    }
+}

vendor/bevy_reflect/src/serde/ser/enums.rs

@@ -0,0 +1,130 @@
+use crate::{
+    serde::{ser::error_utils::make_custom_error, TypedReflectSerializer},
+    Enum, TypeInfo, TypeRegistry, VariantInfo, VariantType,
+};
+use serde::{
+    ser::{SerializeStructVariant, SerializeTupleVariant},
+    Serialize,
+};
+
+use super::ReflectSerializerProcessor;
+
+/// A serializer for [`Enum`] values.
+pub(super) struct EnumSerializer<'a, P> {
+    pub enum_value: &'a dyn Enum,
+    pub registry: &'a TypeRegistry,
+    pub processor: Option<&'a P>,
+}
+
+impl<P: ReflectSerializerProcessor> Serialize for EnumSerializer<'_, P> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let type_info = self.enum_value.get_represented_type_info().ok_or_else(|| {
+            make_custom_error(format_args!(
+                "cannot get type info for `{}`",
+                self.enum_value.reflect_type_path()
+            ))
+        })?;
+
+        let enum_info = match type_info {
+            TypeInfo::Enum(enum_info) => enum_info,
+            info => {
+                return Err(make_custom_error(format_args!(
+                    "expected enum type but received {info:?}"
+                )));
+            }
+        };
+
+        let enum_name = enum_info.type_path_table().ident().unwrap();
+        let variant_index = self.enum_value.variant_index() as u32;
+        let variant_info = enum_info
+            .variant_at(variant_index as usize)
+            .ok_or_else(|| {
+                make_custom_error(format_args!(
+                    "variant at index `{variant_index}` does not exist",
+                ))
+            })?;
+        let variant_name = variant_info.name();
+        let variant_type = self.enum_value.variant_type();
+        let field_len = self.enum_value.field_len();
+
+        match variant_type {
+            VariantType::Unit => {
+                if type_info.type_path_table().module_path() == Some("core::option")
+                    && type_info.type_path_table().ident() == Some("Option")
+                {
+                    serializer.serialize_none()
+                } else {
+                    serializer.serialize_unit_variant(enum_name, variant_index, variant_name)
+                }
+            }
+            VariantType::Struct => {
+                let struct_info = match variant_info {
+                    VariantInfo::Struct(struct_info) => struct_info,
+                    info => {
+                        return Err(make_custom_error(format_args!(
+                            "expected struct variant type but received {info:?}",
+                        )));
+                    }
+                };
+
+                let mut state = serializer.serialize_struct_variant(
+                    enum_name,
+                    variant_index,
+                    variant_name,
+                    field_len,
+                )?;
+                for (index, field) in self.enum_value.iter_fields().enumerate() {
+                    let field_info = struct_info.field_at(index).unwrap();
+                    state.serialize_field(
+                        field_info.name(),
+                        &TypedReflectSerializer::new_internal(
+                            field.value(),
+                            self.registry,
+                            self.processor,
+                        ),
+                    )?;
+                }
+                state.end()
+            }
+            VariantType::Tuple if field_len == 1 => {
+                let field = self.enum_value.field_at(0).unwrap();
+
+                if type_info.type_path_table().module_path() == Some("core::option")
+                    && type_info.type_path_table().ident() == Some("Option")
+                {
+                    serializer.serialize_some(&TypedReflectSerializer::new_internal(
+                        field,
+                        self.registry,
+                        self.processor,
+                    ))
+                } else {
+                    serializer.serialize_newtype_variant(
+                        enum_name,
+                        variant_index,
+                        variant_name,
+                        &TypedReflectSerializer::new_internal(field, self.registry, self.processor),
+                    )
+                }
+            }
+            VariantType::Tuple => {
+                let mut state = serializer.serialize_tuple_variant(
+                    enum_name,
+                    variant_index,
+                    variant_name,
+                    field_len,
+                )?;
+                for field in self.enum_value.iter_fields() {
+                    state.serialize_field(&TypedReflectSerializer::new_internal(
+                        field.value(),
+                        self.registry,
+                        self.processor,
+                    ))?;
+                }
+                state.end()
+            }
+        }
+    }
+}

vendor/bevy_reflect/src/serde/ser/error_utils.rs

@@ -0,0 +1,29 @@
+use core::fmt::Display;
+use serde::ser::Error;
+
+#[cfg(feature = "debug_stack")]
+use std::thread_local;
+
+#[cfg(feature = "debug_stack")]
+thread_local! {
+    /// The thread-local [`TypeInfoStack`] used for debugging.
+    ///
+    /// [`TypeInfoStack`]: crate::type_info_stack::TypeInfoStack
+    pub(super) static TYPE_INFO_STACK: core::cell::RefCell<crate::type_info_stack::TypeInfoStack> = const { core::cell::RefCell::new(
+        crate::type_info_stack::TypeInfoStack::new()
+    ) };
+}
+
+/// A helper function for generating a custom serialization error message.
+///
+/// This function should be preferred over [`Error::custom`] as it will include
+/// other useful information, such as the [type info stack].
+///
+/// [type info stack]: crate::type_info_stack::TypeInfoStack
+pub(super) fn make_custom_error<E: Error>(msg: impl Display) -> E {
+    #[cfg(feature = "debug_stack")]
+    return TYPE_INFO_STACK
+        .with_borrow(|stack| E::custom(format_args!("{} (stack: {:?})", msg, stack)));
+    #[cfg(not(feature = "debug_stack"))]
+    return E::custom(msg);
+}

vendor/bevy_reflect/src/serde/ser/lists.rs

@@ -0,0 +1,28 @@
+use crate::{serde::TypedReflectSerializer, List, TypeRegistry};
+use serde::{ser::SerializeSeq, Serialize};
+
+use super::ReflectSerializerProcessor;
+
+/// A serializer for [`List`] values.
+pub(super) struct ListSerializer<'a, P> {
+    pub list: &'a dyn List,
+    pub registry: &'a TypeRegistry,
+    pub processor: Option<&'a P>,
+}
+
+impl<P: ReflectSerializerProcessor> Serialize for ListSerializer<'_, P> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_seq(Some(self.list.len()))?;
+        for value in self.list.iter() {
+            state.serialize_element(&TypedReflectSerializer::new_internal(
+                value,
+                self.registry,
+                self.processor,
+            ))?;
+        }
+        state.end()
+    }
+}

vendor/bevy_reflect/src/serde/ser/maps.rs

@@ -0,0 +1,27 @@
+use crate::{serde::TypedReflectSerializer, Map, TypeRegistry};
+use serde::{ser::SerializeMap, Serialize};
+
+use super::ReflectSerializerProcessor;
+
+/// A serializer for [`Map`] values.
+pub(super) struct MapSerializer<'a, P> {
+    pub map: &'a dyn Map,
+    pub registry: &'a TypeRegistry,
+    pub processor: Option<&'a P>,
+}
+
+impl<P: ReflectSerializerProcessor> Serialize for MapSerializer<'_, P> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_map(Some(self.map.len()))?;
+        for (key, value) in self.map.iter() {
+            state.serialize_entry(
+                &TypedReflectSerializer::new_internal(key, self.registry, self.processor),
+                &TypedReflectSerializer::new_internal(value, self.registry, self.processor),
+            )?;
+        }
+        state.end()
+    }
+}

vendor/bevy_reflect/src/serde/ser/mod.rs

@@ -0,0 +1,733 @@
+pub use processor::*;
+pub use serializable::*;
+pub use serialize_with_registry::*;
+pub use serializer::*;
+
+mod arrays;
+mod custom_serialization;
+mod enums;
+mod error_utils;
+mod lists;
+mod maps;
+mod processor;
+mod serializable;
+mod serialize_with_registry;
+mod serializer;
+mod sets;
+mod structs;
+mod tuple_structs;
+mod tuples;
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        serde::{ReflectSerializer, ReflectSerializerProcessor},
+        PartialReflect, Reflect, ReflectSerialize, Struct, TypeRegistry,
+    };
+    #[cfg(feature = "functions")]
+    use alloc::boxed::Box;
+    use alloc::{
+        string::{String, ToString},
+        vec,
+        vec::Vec,
+    };
+    use bevy_platform::collections::{HashMap, HashSet};
+    use core::{any::TypeId, f32::consts::PI, ops::RangeInclusive};
+    use ron::{extensions::Extensions, ser::PrettyConfig};
+    use serde::{Serialize, Serializer};
+
+    #[derive(Reflect, Debug, PartialEq)]
+    struct MyStruct {
+        primitive_value: i8,
+        option_value: Option<String>,
+        option_value_complex: Option<SomeStruct>,
+        tuple_value: (f32, usize),
+        list_value: Vec<i32>,
+        array_value: [i32; 5],
+        map_value: HashMap<u8, usize>,
+        set_value: HashSet<u8>,
+        struct_value: SomeStruct,
+        tuple_struct_value: SomeTupleStruct,
+        unit_struct: SomeUnitStruct,
+        unit_enum: SomeEnum,
+        newtype_enum: SomeEnum,
+        tuple_enum: SomeEnum,
+        struct_enum: SomeEnum,
+        ignored_struct: SomeIgnoredStruct,
+        ignored_tuple_struct: SomeIgnoredTupleStruct,
+        ignored_struct_variant: SomeIgnoredEnum,
+        ignored_tuple_variant: SomeIgnoredEnum,
+        custom_serialize: CustomSerialize,
+    }
+
+    #[derive(Reflect, Debug, PartialEq)]
+    struct SomeStruct {
+        foo: i64,
+    }
+
+    #[derive(Reflect, Debug, PartialEq)]
+    struct SomeTupleStruct(String);
+
+    #[derive(Reflect, Debug, PartialEq)]
+    struct SomeUnitStruct;
+
+    #[derive(Reflect, Debug, PartialEq)]
+    struct SomeIgnoredStruct {
+        #[reflect(ignore)]
+        ignored: i32,
+    }
+
+    #[derive(Reflect, Debug, PartialEq)]
+    struct SomeIgnoredTupleStruct(#[reflect(ignore)] i32);
+
+    #[derive(Reflect, Debug, PartialEq)]
+    enum SomeEnum {
+        Unit,
+        NewType(usize),
+        Tuple(f32, f32),
+        Struct { foo: String },
+    }
+
+    #[derive(Reflect, Debug, PartialEq)]
+    enum SomeIgnoredEnum {
+        Tuple(#[reflect(ignore)] f32, #[reflect(ignore)] f32),
+        Struct {
+            #[reflect(ignore)]
+            foo: String,
+        },
+    }
+
+    #[derive(Reflect, Debug, PartialEq, Serialize)]
+    struct SomeSerializableStruct {
+        foo: i64,
+    }
+
+    /// Implements a custom serialize using `#[reflect(Serialize)]`.
+    ///
+    /// For testing purposes, this just uses the generated one from deriving Serialize.
+    #[derive(Reflect, Debug, PartialEq, Serialize)]
+    #[reflect(Serialize)]
+    struct CustomSerialize {
+        value: usize,
+        #[serde(rename = "renamed")]
+        inner_struct: SomeSerializableStruct,
+    }
+
+    fn get_registry() -> TypeRegistry {
+        let mut registry = TypeRegistry::default();
+        registry.register::<MyStruct>();
+        registry.register::<SomeStruct>();
+        registry.register::<SomeTupleStruct>();
+        registry.register::<SomeUnitStruct>();
+        registry.register::<SomeIgnoredStruct>();
+        registry.register::<SomeIgnoredTupleStruct>();
+        registry.register::<SomeIgnoredEnum>();
+        registry.register::<CustomSerialize>();
+        registry.register::<SomeEnum>();
+        registry.register::<SomeSerializableStruct>();
+        registry.register_type_data::<SomeSerializableStruct, ReflectSerialize>();
+        registry.register::<String>();
+        registry.register::<Option<String>>();
+        registry.register_type_data::<Option<String>, ReflectSerialize>();
+        registry
+    }
+
+    fn get_my_struct() -> MyStruct {
+        let mut map = <HashMap<_, _>>::default();
+        map.insert(64, 32);
+
+        let mut set = <HashSet<_>>::default();
+        set.insert(64);
+
+        MyStruct {
+            primitive_value: 123,
+            option_value: Some(String::from("Hello world!")),
+            option_value_complex: Some(SomeStruct { foo: 123 }),
+            tuple_value: (PI, 1337),
+            list_value: vec![-2, -1, 0, 1, 2],
+            array_value: [-2, -1, 0, 1, 2],
+            map_value: map,
+            set_value: set,
+            struct_value: SomeStruct { foo: 999999999 },
+            tuple_struct_value: SomeTupleStruct(String::from("Tuple Struct")),
+            unit_struct: SomeUnitStruct,
+            unit_enum: SomeEnum::Unit,
+            newtype_enum: SomeEnum::NewType(123),
+            tuple_enum: SomeEnum::Tuple(1.23, 3.21),
+            struct_enum: SomeEnum::Struct {
+                foo: String::from("Struct variant value"),
+            },
+            ignored_struct: SomeIgnoredStruct { ignored: 123 },
+            ignored_tuple_struct: SomeIgnoredTupleStruct(123),
+            ignored_struct_variant: SomeIgnoredEnum::Struct {
+                foo: String::from("Struct Variant"),
+            },
+            ignored_tuple_variant: SomeIgnoredEnum::Tuple(1.23, 3.45),
+            custom_serialize: CustomSerialize {
+                value: 100,
+                inner_struct: SomeSerializableStruct { foo: 101 },
+            },
+        }
+    }
+
+    #[test]
+    fn should_serialize() {
+        let input = get_my_struct();
+        let registry = get_registry();
+
+        let serializer = ReflectSerializer::new(&input, &registry);
+
+        let config = PrettyConfig::default()
+            .new_line(String::from("\n"))
+            .indentor(String::from("    "));
+
+        let output = ron::ser::to_string_pretty(&serializer, config).unwrap();
+        let expected = r#"{
+    "bevy_reflect::serde::ser::tests::MyStruct": (
+        primitive_value: 123,
+        option_value: Some("Hello world!"),
+        option_value_complex: Some((
+            foo: 123,
+        )),
+        tuple_value: (3.1415927, 1337),
+        list_value: [
+            -2,
+            -1,
+            0,
+            1,
+            2,
+        ],
+        array_value: (-2, -1, 0, 1, 2),
+        map_value: {
+            64: 32,
+        },
+        set_value: [
+            64,
+        ],
+        struct_value: (
+            foo: 999999999,
+        ),
+        tuple_struct_value: ("Tuple Struct"),
+        unit_struct: (),
+        unit_enum: Unit,
+        newtype_enum: NewType(123),
+        tuple_enum: Tuple(1.23, 3.21),
+        struct_enum: Struct(
+            foo: "Struct variant value",
+        ),
+        ignored_struct: (),
+        ignored_tuple_struct: (),
+        ignored_struct_variant: Struct(),
+        ignored_tuple_variant: Tuple(),
+        custom_serialize: (
+            value: 100,
+            renamed: (
+                foo: 101,
+            ),
+        ),
+    ),
+}"#;
+        assert_eq!(expected, output);
+    }
+
+    #[test]
+    fn should_serialize_option() {
+        #[derive(Reflect, Debug, PartialEq)]
+        struct OptionTest {
+            none: Option<()>,
+            simple: Option<String>,
+            complex: Option<SomeStruct>,
+        }
+
+        let value = OptionTest {
+            none: None,
+            simple: Some(String::from("Hello world!")),
+            complex: Some(SomeStruct { foo: 123 }),
+        };
+
+        let registry = get_registry();
+        let serializer = ReflectSerializer::new(&value, &registry);
+
+        // === Normal === //
+        let config = PrettyConfig::default()
+            .new_line(String::from("\n"))
+            .indentor(String::from("    "));
+
+        let output = ron::ser::to_string_pretty(&serializer, config).unwrap();
+        let expected = r#"{
+    "bevy_reflect::serde::ser::tests::OptionTest": (
+        none: None,
+        simple: Some("Hello world!"),
+        complex: Some((
+            foo: 123,
+        )),
+    ),
+}"#;
+
+        assert_eq!(expected, output);
+
+        // === Implicit Some === //
+        let config = PrettyConfig::default()
+            .new_line(String::from("\n"))
+            .extensions(Extensions::IMPLICIT_SOME)
+            .indentor(String::from("    "));
+
+        let output = ron::ser::to_string_pretty(&serializer, config).unwrap();
+        let expected = r#"#![enable(implicit_some)]
+{
+    "bevy_reflect::serde::ser::tests::OptionTest": (
+        none: None,
+        simple: "Hello world!",
+        complex: (
+            foo: 123,
+        ),
+    ),
+}"#;
+
+        assert_eq!(expected, output);
+    }
+
+    #[test]
+    fn enum_should_serialize() {
+        #[derive(Reflect)]
+        enum MyEnum {
+            Unit,
+            NewType(usize),
+            Tuple(f32, f32),
+            Struct { value: String },
+        }
+
+        let mut registry = get_registry();
+        registry.register::<MyEnum>();
+
+        let config = PrettyConfig::default().new_line(String::from("\n"));
+
+        // === Unit Variant === //
+        let value = MyEnum::Unit;
+        let serializer = ReflectSerializer::new(&value, &registry);
+        let output = ron::ser::to_string_pretty(&serializer, config.clone()).unwrap();
+        let expected = r#"{
+    "bevy_reflect::serde::ser::tests::MyEnum": Unit,
+}"#;
+        assert_eq!(expected, output);
+
+        // === NewType Variant === //
+        let value = MyEnum::NewType(123);
+        let serializer = ReflectSerializer::new(&value, &registry);
+        let output = ron::ser::to_string_pretty(&serializer, config.clone()).unwrap();
+        let expected = r#"{
+    "bevy_reflect::serde::ser::tests::MyEnum": NewType(123),
+}"#;
+        assert_eq!(expected, output);
+
+        // === Tuple Variant === //
+        let value = MyEnum::Tuple(1.23, 3.21);
+        let serializer = ReflectSerializer::new(&value, &registry);
+        let output = ron::ser::to_string_pretty(&serializer, config.clone()).unwrap();
+        let expected = r#"{
+    "bevy_reflect::serde::ser::tests::MyEnum": Tuple(1.23, 3.21),
+}"#;
+        assert_eq!(expected, output);
+
+        // === Struct Variant === //
+        let value = MyEnum::Struct {
+            value: String::from("I <3 Enums"),
+        };
+        let serializer = ReflectSerializer::new(&value, &registry);
+        let output = ron::ser::to_string_pretty(&serializer, config).unwrap();
+        let expected = r#"{
+    "bevy_reflect::serde::ser::tests::MyEnum": Struct(
+        value: "I <3 Enums",
+    ),
+}"#;
+        assert_eq!(expected, output);
+    }
+
+    #[test]
+    fn should_serialize_non_self_describing_binary() {
+        let input = get_my_struct();
+        let registry = get_registry();
+
+        let serializer = ReflectSerializer::new(&input, &registry);
+        let config = bincode::config::standard().with_fixed_int_encoding();
+        let bytes = bincode::serde::encode_to_vec(&serializer, config).unwrap();
+
+        let expected: Vec<u8> = vec![
+            1, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 0, 0, 0, 0, 98, 101, 118, 121, 95, 114, 101, 102,
+            108, 101, 99, 116, 58, 58, 115, 101, 114, 100, 101, 58, 58, 115, 101, 114, 58, 58, 116,
+            101, 115, 116, 115, 58, 58, 77, 121, 83, 116, 114, 117, 99, 116, 123, 1, 12, 0, 0, 0,
+            0, 0, 0, 0, 72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33, 1, 123, 0, 0, 0,
+            0, 0, 0, 0, 219, 15, 73, 64, 57, 5, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 254, 255,
+            255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 254, 255, 255, 255,
+            255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 64, 32,
+            0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 64, 255, 201, 154, 59, 0, 0, 0, 0, 12, 0,
+            0, 0, 0, 0, 0, 0, 84, 117, 112, 108, 101, 32, 83, 116, 114, 117, 99, 116, 0, 0, 0, 0,
+            1, 0, 0, 0, 123, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 164, 112, 157, 63, 164, 112, 77, 64,
+            3, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 83, 116, 114, 117, 99, 116, 32, 118, 97, 114, 105,
+            97, 110, 116, 32, 118, 97, 108, 117, 101, 1, 0, 0, 0, 0, 0, 0, 0, 100, 0, 0, 0, 0, 0,
+            0, 0, 101, 0, 0, 0, 0, 0, 0, 0,
+        ];
+
+        assert_eq!(expected, bytes);
+    }
+
+    #[test]
+    fn should_serialize_self_describing_binary() {
+        let input = get_my_struct();
+        let registry = get_registry();
+
+        let serializer = ReflectSerializer::new(&input, &registry);
+        let bytes: Vec<u8> = rmp_serde::to_vec(&serializer).unwrap();
+
+        let expected: Vec<u8> = vec![
+            129, 217, 41, 98, 101, 118, 121, 95, 114, 101, 102, 108, 101, 99, 116, 58, 58, 115,
+            101, 114, 100, 101, 58, 58, 115, 101, 114, 58, 58, 116, 101, 115, 116, 115, 58, 58, 77,
+            121, 83, 116, 114, 117, 99, 116, 220, 0, 20, 123, 172, 72, 101, 108, 108, 111, 32, 119,
+            111, 114, 108, 100, 33, 145, 123, 146, 202, 64, 73, 15, 219, 205, 5, 57, 149, 254, 255,
+            0, 1, 2, 149, 254, 255, 0, 1, 2, 129, 64, 32, 145, 64, 145, 206, 59, 154, 201, 255,
+            172, 84, 117, 112, 108, 101, 32, 83, 116, 114, 117, 99, 116, 144, 164, 85, 110, 105,
+            116, 129, 167, 78, 101, 119, 84, 121, 112, 101, 123, 129, 165, 84, 117, 112, 108, 101,
+            146, 202, 63, 157, 112, 164, 202, 64, 77, 112, 164, 129, 166, 83, 116, 114, 117, 99,
+            116, 145, 180, 83, 116, 114, 117, 99, 116, 32, 118, 97, 114, 105, 97, 110, 116, 32,
+            118, 97, 108, 117, 101, 144, 144, 129, 166, 83, 116, 114, 117, 99, 116, 144, 129, 165,
+            84, 117, 112, 108, 101, 144, 146, 100, 145, 101,
+        ];
+
+        assert_eq!(expected, bytes);
+    }
+
+    #[test]
+    fn should_serialize_dynamic_option() {
+        #[derive(Default, Reflect)]
+        struct OtherStruct {
+            some: Option<SomeStruct>,
+            none: Option<SomeStruct>,
+        }
+
+        let value = OtherStruct {
+            some: Some(SomeStruct { foo: 999999999 }),
+            none: None,
+        };
+        let dynamic = value.to_dynamic_struct();
+        let reflect = dynamic.as_partial_reflect();
+
+        let registry = get_registry();
+
+        let serializer = ReflectSerializer::new(reflect, &registry);
+
+        let mut buf = Vec::new();
+
+        let format = serde_json::ser::PrettyFormatter::with_indent(b"    ");
+        let mut ser = serde_json::Serializer::with_formatter(&mut buf, format);
+
+        serializer.serialize(&mut ser).unwrap();
+
+        let output = core::str::from_utf8(&buf).unwrap();
+        let expected = r#"{
+    "bevy_reflect::serde::ser::tests::OtherStruct": {
+        "some": {
+            "foo": 999999999
+        },
+        "none": null
+    }
+}"#;
+
+        assert_eq!(expected, output);
+    }
+
+    #[test]
+    fn should_return_error_if_missing_registration() {
+        let value = RangeInclusive::<f32>::new(0.0, 1.0);
+        let registry = TypeRegistry::new();
+
+        let serializer = ReflectSerializer::new(&value, &registry);
+        let error = ron::ser::to_string(&serializer).unwrap_err();
+        #[cfg(feature = "debug_stack")]
+        assert_eq!(
+            error,
+            ron::Error::Message(
+                "type `core::ops::RangeInclusive<f32>` is not registered in the type registry (stack: `core::ops::RangeInclusive<f32>`)"
+                    .to_string(),
+            )
+        );
+        #[cfg(not(feature = "debug_stack"))]
+        assert_eq!(
+            error,
+            ron::Error::Message(
+                "type `core::ops::RangeInclusive<f32>` is not registered in the type registry"
+                    .to_string(),
+            )
+        );
+    }
+
+    #[test]
+    fn should_return_error_if_missing_type_data() {
+        let value = RangeInclusive::<f32>::new(0.0, 1.0);
+        let mut registry = TypeRegistry::new();
+        registry.register::<RangeInclusive<f32>>();
+
+        let serializer = ReflectSerializer::new(&value, &registry);
+        let error = ron::ser::to_string(&serializer).unwrap_err();
+        #[cfg(feature = "debug_stack")]
+        assert_eq!(
+            error,
+            ron::Error::Message(
+                "type `core::ops::RangeInclusive<f32>` did not register the `ReflectSerialize` or `ReflectSerializeWithRegistry` type data. For certain types, this may need to be registered manually using `register_type_data` (stack: `core::ops::RangeInclusive<f32>`)".to_string()
+            )
+        );
+        #[cfg(not(feature = "debug_stack"))]
+        assert_eq!(
+            error,
+            ron::Error::Message(
+                "type `core::ops::RangeInclusive<f32>` did not register the `ReflectSerialize` type data. For certain types, this may need to be registered manually using `register_type_data`".to_string()
+            )
+        );
+    }
+
+    #[test]
+    fn should_use_processor_for_custom_serialization() {
+        #[derive(Reflect, Debug, PartialEq)]
+        struct Foo {
+            bar: i32,
+            qux: i64,
+        }
+
+        struct FooProcessor;
+
+        impl ReflectSerializerProcessor for FooProcessor {
+            fn try_serialize<S>(
+                &self,
+                value: &dyn PartialReflect,
+                _: &TypeRegistry,
+                serializer: S,
+            ) -> Result<Result<S::Ok, S>, S::Error>
+            where
+                S: Serializer,
+            {
+                let Some(value) = value.try_as_reflect() else {
+                    return Ok(Err(serializer));
+                };
+
+                let type_id = value.reflect_type_info().type_id();
+                if type_id == TypeId::of::<i64>() {
+                    Ok(Ok(serializer.serialize_str("custom!")?))
+                } else {
+                    Ok(Err(serializer))
+                }
+            }
+        }
+
+        let value = Foo { bar: 123, qux: 456 };
+
+        let mut registry = TypeRegistry::new();
+        registry.register::<Foo>();
+
+        let processor = FooProcessor;
+        let serializer = ReflectSerializer::with_processor(&value, &registry, &processor);
+
+        let config = PrettyConfig::default().new_line(String::from("\n"));
+        let output = ron::ser::to_string_pretty(&serializer, config).unwrap();
+
+        let expected = r#"{
+    "bevy_reflect::serde::ser::tests::Foo": (
+        bar: 123,
+        qux: "custom!",
+    ),
+}"#;
+
+        assert_eq!(expected, output);
+    }
+
+    #[test]
+    fn should_use_processor_for_multiple_registrations() {
+        #[derive(Reflect, Debug, PartialEq)]
+        struct Foo {
+            bar: i32,
+            sub: SubFoo,
+        }
+
+        #[derive(Reflect, Debug, PartialEq)]
+        struct SubFoo {
+            val: i32,
+        }
+
+        struct FooProcessor;
+
+        impl ReflectSerializerProcessor for FooProcessor {
+            fn try_serialize<S>(
+                &self,
+                value: &dyn PartialReflect,
+                _: &TypeRegistry,
+                serializer: S,
+            ) -> Result<Result<S::Ok, S>, S::Error>
+            where
+                S: Serializer,
+            {
+                let Some(value) = value.try_as_reflect() else {
+                    return Ok(Err(serializer));
+                };
+
+                let type_id = value.reflect_type_info().type_id();
+                if type_id == TypeId::of::<i32>() {
+                    Ok(Ok(serializer.serialize_str("an i32")?))
+                } else if type_id == TypeId::of::<SubFoo>() {
+                    Ok(Ok(serializer.serialize_str("a SubFoo")?))
+                } else {
+                    Ok(Err(serializer))
+                }
+            }
+        }
+
+        let value = Foo {
+            bar: 123,
+            sub: SubFoo { val: 456 },
+        };
+
+        let mut registry = TypeRegistry::new();
+        registry.register::<Foo>();
+        registry.register::<SubFoo>();
+
+        let processor = FooProcessor;
+        let serializer = ReflectSerializer::with_processor(&value, &registry, &processor);
+
+        let config = PrettyConfig::default().new_line(String::from("\n"));
+        let output = ron::ser::to_string_pretty(&serializer, config).unwrap();
+
+        let expected = r#"{
+    "bevy_reflect::serde::ser::tests::Foo": (
+        bar: "an i32",
+        sub: "a SubFoo",
+    ),
+}"#;
+
+        assert_eq!(expected, output);
+    }
+
+    #[test]
+    fn should_propagate_processor_serialize_error() {
+        struct ErroringProcessor;
+
+        impl ReflectSerializerProcessor for ErroringProcessor {
+            fn try_serialize<S>(
+                &self,
+                value: &dyn PartialReflect,
+                _: &TypeRegistry,
+                serializer: S,
+            ) -> Result<Result<S::Ok, S>, S::Error>
+            where
+                S: Serializer,
+            {
+                let Some(value) = value.try_as_reflect() else {
+                    return Ok(Err(serializer));
+                };
+
+                let type_id = value.reflect_type_info().type_id();
+                if type_id == TypeId::of::<i32>() {
+                    Err(serde::ser::Error::custom("my custom serialize error"))
+                } else {
+                    Ok(Err(serializer))
+                }
+            }
+        }
+
+        let value = 123_i32;
+
+        let registry = TypeRegistry::new();
+
+        let processor = ErroringProcessor;
+        let serializer = ReflectSerializer::with_processor(&value, &registry, &processor);
+        let error = ron::ser::to_string_pretty(&serializer, PrettyConfig::default()).unwrap_err();
+
+        #[cfg(feature = "debug_stack")]
+        assert_eq!(
+            error,
+            ron::Error::Message("my custom serialize error (stack: `i32`)".to_string())
+        );
+        #[cfg(not(feature = "debug_stack"))]
+        assert_eq!(
+            error,
+            ron::Error::Message("my custom serialize error".to_string())
+        );
+    }
+
+    #[cfg(feature = "functions")]
+    mod functions {
+        use super::*;
+        use crate::func::{DynamicFunction, IntoFunction};
+        use alloc::string::ToString;
+
+        #[test]
+        fn should_not_serialize_function() {
+            #[derive(Reflect)]
+            #[reflect(from_reflect = false)]
+            struct MyStruct {
+                func: DynamicFunction<'static>,
+            }
+
+            let value: Box<dyn Reflect> = Box::new(MyStruct {
+                func: String::new.into_function(),
+            });
+
+            let registry = TypeRegistry::new();
+            let serializer = ReflectSerializer::new(value.as_partial_reflect(), &registry);
+
+            let error = ron::ser::to_string(&serializer).unwrap_err();
+
+            #[cfg(feature = "debug_stack")]
+            assert_eq!(
+                error,
+                ron::Error::Message("functions cannot be serialized (stack: `bevy_reflect::serde::ser::tests::functions::MyStruct`)".to_string())
+            );
+
+            #[cfg(not(feature = "debug_stack"))]
+            assert_eq!(
+                error,
+                ron::Error::Message("functions cannot be serialized".to_string())
+            );
+        }
+    }
+
+    #[cfg(feature = "debug_stack")]
+    mod debug_stack {
+        use super::*;
+
+        #[test]
+        fn should_report_context_in_errors() {
+            #[derive(Reflect)]
+            struct Foo {
+                bar: Bar,
+            }
+
+            #[derive(Reflect)]
+            struct Bar {
+                some_other_field: Option<u32>,
+                baz: Baz,
+            }
+
+            #[derive(Reflect)]
+            struct Baz {
+                value: Vec<RangeInclusive<f32>>,
+            }
+
+            let value = Foo {
+                bar: Bar {
+                    some_other_field: Some(123),
+                    baz: Baz {
+                        value: vec![0.0..=1.0],
+                    },
+                },
+            };
+
+            let registry = TypeRegistry::new();
+            let serializer = ReflectSerializer::new(&value, &registry);
+
+            let error = ron::ser::to_string(&serializer).unwrap_err();
+            assert_eq!(
+                error,
+                ron::Error::Message(
+                    "type `core::ops::RangeInclusive<f32>` is not registered in the type registry (stack: `bevy_reflect::serde::ser::tests::debug_stack::Foo` -> `bevy_reflect::serde::ser::tests::debug_stack::Bar` -> `bevy_reflect::serde::ser::tests::debug_stack::Baz` -> `alloc::vec::Vec<core::ops::RangeInclusive<f32>>` -> `core::ops::RangeInclusive<f32>`)".to_string()
+                )
+            );
+        }
+    }
+}

vendor/bevy_reflect/src/serde/ser/processor.rs

@@ -0,0 +1,196 @@
+use serde::Serializer;
+
+use crate::{PartialReflect, TypeRegistry};
+
+/// Allows overriding the default serialization behavior of
+/// [`ReflectSerializer`] and [`TypedReflectSerializer`] for specific values.
+///
+/// When serializing a reflected value, you may want to override the default
+/// behavior and use your own logic for serialization. This logic may also be
+/// context-dependent, and only apply for a single use of your
+/// [`ReflectSerializer`]. To achieve this, you can create a processor and pass
+/// it into your serializer.
+///
+/// Whenever the serializer attempts to serialize a value, it will first call
+/// [`try_serialize`] on your processor, which may take ownership of the
+/// serializer and write into the serializer (successfully or not), or return
+/// ownership of the serializer back, and continue with the default logic.
+///
+/// The deserialization equivalent of this is [`ReflectDeserializerProcessor`].
+///
+/// # Compared to [`SerializeWithRegistry`]
+///
+/// [`SerializeWithRegistry`] allows you to define how your type will be
+/// serialized by a [`TypedReflectSerializer`], given the extra context of the
+/// [`TypeRegistry`]. If your type can be serialized entirely using that, then
+/// you should prefer implementing that trait instead of using a processor.
+///
+/// However, you may need more context-dependent data which is only present in
+/// the scope where you create the [`TypedReflectSerializer`]. For example, if
+/// you need to use a reference to a value while serializing, then there is no
+/// way to do this with [`SerializeWithRegistry`] as you can't pass that
+/// reference into anywhere. This is where a processor is useful, as the
+/// processor can capture local variables.
+///
+/// A [`ReflectSerializerProcessor`] always takes priority over a
+/// [`SerializeWithRegistry`] implementation, so this is also useful for
+/// overriding serialization behavior if you need to do something custom.
+///
+/// # Examples
+///
+/// Serializing a reflected value when saving an asset to disk, and replacing
+/// asset handles with the handle path (if it has one):
+///
+/// ```
+/// # use core::any::Any;
+/// # use serde::Serialize;
+/// # use bevy_reflect::{PartialReflect, Reflect, TypeData, TypeRegistry};
+/// # use bevy_reflect::serde::{ReflectSerializer, ReflectSerializerProcessor};
+/// #
+/// # #[derive(Debug, Clone, Reflect)]
+/// # struct Handle<T>(T);
+/// # #[derive(Debug, Clone, Reflect)]
+/// # struct Mesh;
+/// #
+/// # struct ReflectHandle;
+/// # impl TypeData for ReflectHandle {
+/// #     fn clone_type_data(&self) -> Box<dyn TypeData> {
+/// #         unimplemented!()
+/// #     }
+/// # }
+/// # impl ReflectHandle {
+/// #     fn downcast_handle_untyped(&self, handle: &(dyn Any + 'static)) -> Option<UntypedHandle> {
+/// #         unimplemented!()
+/// #     }
+/// # }
+/// #
+/// # #[derive(Debug, Clone)]
+/// # struct UntypedHandle;
+/// # impl UntypedHandle {
+/// #     fn path(&self) -> Option<&str> {
+/// #         unimplemented!()
+/// #     }
+/// # }
+/// # type AssetError = Box<dyn core::error::Error>;
+/// #
+/// #[derive(Debug, Clone, Reflect)]
+/// struct MyAsset {
+///     name: String,
+///     mesh: Handle<Mesh>,
+/// }
+///
+/// struct HandleProcessor;
+///
+/// impl ReflectSerializerProcessor for HandleProcessor {
+///     fn try_serialize<S>(
+///         &self,
+///         value: &dyn PartialReflect,
+///         registry: &TypeRegistry,
+///         serializer: S,
+///     ) -> Result<Result<S::Ok, S>, S::Error>
+///     where
+///         S: serde::Serializer,
+///     {
+///         let Some(value) = value.try_as_reflect() else {
+///             // we don't have any info on this type; do the default serialization logic
+///             return Ok(Err(serializer));
+///         };
+///         let type_id = value.reflect_type_info().type_id();
+///         let Some(reflect_handle) = registry.get_type_data::<ReflectHandle>(type_id) else {
+///             // this isn't a `Handle<T>`
+///             return Ok(Err(serializer));
+///         };
+///
+///         let untyped_handle = reflect_handle
+///             .downcast_handle_untyped(value.as_any())
+///             .unwrap();
+///         if let Some(path) = untyped_handle.path() {
+///             Ok(Ok(serializer.serialize_str(path)?))
+///         } else {
+///             Ok(Ok(serializer.serialize_unit()?))
+///         }
+///     }
+/// }
+///
+/// fn save(type_registry: &TypeRegistry, asset: &MyAsset) -> Result<Vec<u8>, AssetError> {
+///     let mut asset_bytes = Vec::new();
+///
+///     let processor = HandleProcessor;
+///     let serializer = ReflectSerializer::with_processor(asset, type_registry, &processor);
+///     let mut ron_serializer = ron::Serializer::new(&mut asset_bytes, None)?;
+///
+///     serializer.serialize(&mut ron_serializer)?;
+///     Ok(asset_bytes)
+/// }
+/// ```
+///
+/// [`ReflectSerializer`]: crate::serde::ReflectSerializer
+/// [`TypedReflectSerializer`]: crate::serde::TypedReflectSerializer
+/// [`try_serialize`]: Self::try_serialize
+/// [`SerializeWithRegistry`]: crate::serde::SerializeWithRegistry
+/// [`ReflectDeserializerProcessor`]: crate::serde::ReflectDeserializerProcessor
+pub trait ReflectSerializerProcessor {
+    /// Attempts to serialize the value which a [`TypedReflectSerializer`] is
+    /// currently looking at.
+    ///
+    /// If you want to override the default serialization, return
+    /// `Ok(Ok(value))` with an `Ok` output from the serializer.
+    ///
+    /// If you don't want to override the serialization, return ownership of
+    /// the serializer back via `Ok(Err(serializer))`.
+    ///
+    /// You can use the type registry to read info about the type you're
+    /// serializing, or just try to downcast the value directly:
+    ///
+    /// ```
+    /// # use bevy_reflect::{TypeRegistration, TypeRegistry, PartialReflect};
+    /// # use bevy_reflect::serde::ReflectSerializerProcessor;
+    /// # use core::any::TypeId;
+    /// struct I32AsStringProcessor;
+    ///
+    /// impl ReflectSerializerProcessor for I32AsStringProcessor {
+    ///     fn try_serialize<S>(
+    ///         &self,
+    ///         value: &dyn PartialReflect,
+    ///         registry: &TypeRegistry,
+    ///         serializer: S,
+    ///     ) -> Result<Result<S::Ok, S>, S::Error>
+    ///     where
+    ///         S: serde::Serializer
+    ///     {
+    ///         if let Some(value) = value.try_downcast_ref::<i32>() {
+    ///             let value_as_string = format!("{value:?}");
+    ///             Ok(Ok(serializer.serialize_str(&value_as_string)?))
+    ///         } else {
+    ///             // Not an `i32`, just do the default serialization
+    ///             Ok(Err(serializer))
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// [`TypedReflectSerializer`]: crate::serde::TypedReflectSerializer
+    /// [`Reflect`]: crate::Reflect
+    fn try_serialize<S>(
+        &self,
+        value: &dyn PartialReflect,
+        registry: &TypeRegistry,
+        serializer: S,
+    ) -> Result<Result<S::Ok, S>, S::Error>
+    where
+        S: Serializer;
+}
+
+impl ReflectSerializerProcessor for () {
+    fn try_serialize<S>(
+        &self,
+        _value: &dyn PartialReflect,
+        _registry: &TypeRegistry,
+        serializer: S,
+    ) -> Result<Result<S::Ok, S>, S::Error>
+    where
+        S: Serializer,
+    {
+        Ok(Err(serializer))
+    }
+}

vendor/bevy_reflect/src/serde/ser/serializable.rs

@@ -0,0 +1,19 @@
+use alloc::boxed::Box;
+use core::ops::Deref;
+
+/// A type-erased serializable value.
+pub enum Serializable<'a> {
+    Owned(Box<dyn erased_serde::Serialize + 'a>),
+    Borrowed(&'a dyn erased_serde::Serialize),
+}
+
+impl<'a> Deref for Serializable<'a> {
+    type Target = dyn erased_serde::Serialize + 'a;
+
+    fn deref(&self) -> &Self::Target {
+        match self {
+            Serializable::Borrowed(serialize) => serialize,
+            Serializable::Owned(serialize) => serialize,
+        }
+    }
+}

vendor/bevy_reflect/src/serde/ser/serialize_with_registry.rs

@@ -0,0 +1,101 @@
+use crate::{FromType, Reflect, TypeRegistry};
+use alloc::boxed::Box;
+use serde::{Serialize, Serializer};
+
+/// Trait used to provide finer control when serializing a reflected type with one of
+/// the reflection serializers.
+///
+/// This trait is the reflection equivalent of `serde`'s [`Serialize`] trait.
+/// The main difference is that this trait provides access to the [`TypeRegistry`],
+/// which means that we can use the registry and all its stored type information
+/// to serialize our type.
+///
+/// This can be useful when writing a custom reflection serializer where we may
+/// want to handle parts of the serialization process, but temporarily pass control
+/// to the standard reflection serializer for other parts.
+///
+/// For the deserialization equivalent of this trait, see [`DeserializeWithRegistry`].
+///
+/// # Rationale
+///
+/// Without this trait and its associated [type data], such a serializer would have to
+/// write out all of the serialization logic itself, possibly including
+/// unnecessary code duplication and trivial implementations.
+///
+/// This is because a normal [`Serialize`] implementation has no knowledge of the
+/// [`TypeRegistry`] and therefore cannot create a reflection-based serializer for
+/// nested items.
+///
+/// # Implementors
+///
+/// In order for this to work with the reflection serializers like [`TypedReflectSerializer`]
+/// and [`ReflectSerializer`], implementors should be sure to register the
+/// [`ReflectSerializeWithRegistry`] type data.
+/// This can be done [via the registry] or by adding `#[reflect(SerializeWithRegistry)]` to
+/// the type definition.
+///
+/// [`DeserializeWithRegistry`]: crate::serde::DeserializeWithRegistry
+/// [type data]: ReflectSerializeWithRegistry
+/// [`TypedReflectSerializer`]: crate::serde::TypedReflectSerializer
+/// [`ReflectSerializer`]: crate::serde::ReflectSerializer
+/// [via the registry]: TypeRegistry::register_type_data
+pub trait SerializeWithRegistry {
+    fn serialize<S>(&self, serializer: S, registry: &TypeRegistry) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer;
+}
+
+/// Type data used to serialize a [`Reflect`] type with a custom [`SerializeWithRegistry`] implementation.
+#[derive(Clone)]
+pub struct ReflectSerializeWithRegistry {
+    serialize: for<'a> fn(
+        value: &'a dyn Reflect,
+        registry: &'a TypeRegistry,
+    ) -> Box<dyn erased_serde::Serialize + 'a>,
+}
+
+impl ReflectSerializeWithRegistry {
+    /// Serialize a [`Reflect`] type with this type data's custom [`SerializeWithRegistry`] implementation.
+    pub fn serialize<S>(
+        &self,
+        value: &dyn Reflect,
+        serializer: S,
+        registry: &TypeRegistry,
+    ) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        ((self.serialize)(value, registry)).serialize(serializer)
+    }
+}
+
+impl<T: Reflect + SerializeWithRegistry> FromType<T> for ReflectSerializeWithRegistry {
+    fn from_type() -> Self {
+        Self {
+            serialize: |value: &dyn Reflect, registry| {
+                let value = value.downcast_ref::<T>().unwrap_or_else(|| {
+                    panic!(
+                        "Expected value to be of type {} but received {}",
+                        core::any::type_name::<T>(),
+                        value.reflect_type_path()
+                    )
+                });
+                Box::new(SerializableWithRegistry { value, registry })
+            },
+        }
+    }
+}
+
+struct SerializableWithRegistry<'a, T: SerializeWithRegistry> {
+    value: &'a T,
+    registry: &'a TypeRegistry,
+}
+
+impl<'a, T: SerializeWithRegistry> Serialize for SerializableWithRegistry<'a, T> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.value.serialize(serializer, self.registry)
+    }
+}

vendor/bevy_reflect/src/serde/ser/serializer.rs

@@ -0,0 +1,326 @@
+#[cfg(feature = "debug_stack")]
+use crate::serde::ser::error_utils::TYPE_INFO_STACK;
+use crate::{
+    serde::ser::{
+        arrays::ArraySerializer, custom_serialization::try_custom_serialize, enums::EnumSerializer,
+        error_utils::make_custom_error, lists::ListSerializer, maps::MapSerializer,
+        sets::SetSerializer, structs::StructSerializer, tuple_structs::TupleStructSerializer,
+        tuples::TupleSerializer,
+    },
+    PartialReflect, ReflectRef, TypeRegistry,
+};
+use serde::{ser::SerializeMap, Serialize, Serializer};
+
+use super::ReflectSerializerProcessor;
+
+/// A general purpose serializer for reflected types.
+///
+/// This is the serializer counterpart to [`ReflectDeserializer`].
+///
+/// See [`TypedReflectSerializer`] for a serializer that serializes a known type.
+///
+/// # Output
+///
+/// This serializer will output a map with a single entry,
+/// where the key is the _full_ [type path] of the reflected type
+/// and the value is the serialized data.
+///
+/// If you want to override serialization for specific values, you can pass in
+/// a reference to a [`ReflectSerializerProcessor`] which will take priority
+/// over all other serialization methods - see [`with_processor`].
+///
+/// # Example
+///
+/// ```
+/// # use bevy_reflect::prelude::*;
+/// # use bevy_reflect::{TypeRegistry, serde::ReflectSerializer};
+/// #[derive(Reflect, PartialEq, Debug)]
+/// #[type_path = "my_crate"]
+/// struct MyStruct {
+///   value: i32
+/// }
+///
+/// let mut registry = TypeRegistry::default();
+/// registry.register::<MyStruct>();
+///
+/// let input = MyStruct { value: 123 };
+///
+/// let reflect_serializer = ReflectSerializer::new(&input, &registry);
+/// let output = ron::to_string(&reflect_serializer).unwrap();
+///
+/// assert_eq!(output, r#"{"my_crate::MyStruct":(value:123)}"#);
+/// ```
+///
+/// [`ReflectDeserializer`]: crate::serde::ReflectDeserializer
+/// [type path]: crate::TypePath::type_path
+/// [`with_processor`]: Self::with_processor
+pub struct ReflectSerializer<'a, P = ()> {
+    value: &'a dyn PartialReflect,
+    registry: &'a TypeRegistry,
+    processor: Option<&'a P>,
+}
+
+impl<'a> ReflectSerializer<'a, ()> {
+    /// Creates a serializer with no processor.
+    ///
+    /// If you want to add custom logic for serializing certain values, use
+    /// [`with_processor`].
+    ///
+    /// [`with_processor`]: Self::with_processor
+    pub fn new(value: &'a dyn PartialReflect, registry: &'a TypeRegistry) -> Self {
+        Self {
+            value,
+            registry,
+            processor: None,
+        }
+    }
+}
+
+impl<'a, P: ReflectSerializerProcessor> ReflectSerializer<'a, P> {
+    /// Creates a serializer with a processor.
+    ///
+    /// If you do not need any custom logic for handling certain values, use
+    /// [`new`].
+    ///
+    /// [`new`]: Self::new
+    pub fn with_processor(
+        value: &'a dyn PartialReflect,
+        registry: &'a TypeRegistry,
+        processor: &'a P,
+    ) -> Self {
+        Self {
+            value,
+            registry,
+            processor: Some(processor),
+        }
+    }
+}
+
+impl<P: ReflectSerializerProcessor> Serialize for ReflectSerializer<'_, P> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut state = serializer.serialize_map(Some(1))?;
+        state.serialize_entry(
+            self.value
+                .get_represented_type_info()
+                .ok_or_else(|| {
+                    if self.value.is_dynamic() {
+                        make_custom_error(format_args!(
+                            "cannot serialize dynamic value without represented type: `{}`",
+                            self.value.reflect_type_path()
+                        ))
+                    } else {
+                        make_custom_error(format_args!(
+                            "cannot get type info for `{}`",
+                            self.value.reflect_type_path()
+                        ))
+                    }
+                })?
+                .type_path(),
+            &TypedReflectSerializer::new_internal(self.value, self.registry, self.processor),
+        )?;
+        state.end()
+    }
+}
+
+/// A serializer for reflected types whose type will be known during deserialization.
+///
+/// This is the serializer counterpart to [`TypedReflectDeserializer`].
+///
+/// See [`ReflectSerializer`] for a serializer that serializes an unknown type.
+///
+/// # Output
+///
+/// Since the type is expected to be known during deserialization,
+/// this serializer will not output any additional type information,
+/// such as the [type path].
+///
+/// Instead, it will output just the serialized data.
+///
+/// If you want to override serialization for specific values, you can pass in
+/// a reference to a [`ReflectSerializerProcessor`] which will take priority
+/// over all other serialization methods - see [`with_processor`].
+///
+/// # Example
+///
+/// ```
+/// # use bevy_reflect::prelude::*;
+/// # use bevy_reflect::{TypeRegistry, serde::TypedReflectSerializer};
+/// #[derive(Reflect, PartialEq, Debug)]
+/// #[type_path = "my_crate"]
+/// struct MyStruct {
+///   value: i32
+/// }
+///
+/// let mut registry = TypeRegistry::default();
+/// registry.register::<MyStruct>();
+///
+/// let input = MyStruct { value: 123 };
+///
+/// let reflect_serializer = TypedReflectSerializer::new(&input, &registry);
+/// let output = ron::to_string(&reflect_serializer).unwrap();
+///
+/// assert_eq!(output, r#"(value:123)"#);
+/// ```
+///
+/// [`TypedReflectDeserializer`]: crate::serde::TypedReflectDeserializer
+/// [type path]: crate::TypePath::type_path
+/// [`with_processor`]: Self::with_processor
+pub struct TypedReflectSerializer<'a, P = ()> {
+    value: &'a dyn PartialReflect,
+    registry: &'a TypeRegistry,
+    processor: Option<&'a P>,
+}
+
+impl<'a> TypedReflectSerializer<'a, ()> {
+    /// Creates a serializer with no processor.
+    ///
+    /// If you want to add custom logic for serializing certain values, use
+    /// [`with_processor`].
+    ///
+    /// [`with_processor`]: Self::with_processor
+    pub fn new(value: &'a dyn PartialReflect, registry: &'a TypeRegistry) -> Self {
+        #[cfg(feature = "debug_stack")]
+        TYPE_INFO_STACK.set(crate::type_info_stack::TypeInfoStack::new());
+
+        Self {
+            value,
+            registry,
+            processor: None,
+        }
+    }
+}
+
+impl<'a, P> TypedReflectSerializer<'a, P> {
+    /// Creates a serializer with a processor.
+    ///
+    /// If you do not need any custom logic for handling certain values, use
+    /// [`new`].
+    ///
+    /// [`new`]: Self::new
+    pub fn with_processor(
+        value: &'a dyn PartialReflect,
+        registry: &'a TypeRegistry,
+        processor: &'a P,
+    ) -> Self {
+        #[cfg(feature = "debug_stack")]
+        TYPE_INFO_STACK.set(crate::type_info_stack::TypeInfoStack::new());
+
+        Self {
+            value,
+            registry,
+            processor: Some(processor),
+        }
+    }
+
+    /// An internal constructor for creating a serializer without resetting the type info stack.
+    pub(super) fn new_internal(
+        value: &'a dyn PartialReflect,
+        registry: &'a TypeRegistry,
+        processor: Option<&'a P>,
+    ) -> Self {
+        Self {
+            value,
+            registry,
+            processor,
+        }
+    }
+}
+
+impl<P: ReflectSerializerProcessor> Serialize for TypedReflectSerializer<'_, P> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        #[cfg(feature = "debug_stack")]
+        {
+            if let Some(info) = self.value.get_represented_type_info() {
+                TYPE_INFO_STACK.with_borrow_mut(|stack| stack.push(info));
+            }
+        }
+
+        // First, check if our processor wants to serialize this type
+        // This takes priority over any other serialization operations
+        let serializer = if let Some(processor) = self.processor {
+            match processor.try_serialize(self.value, self.registry, serializer) {
+                Ok(Ok(value)) => {
+                    return Ok(value);
+                }
+                Err(err) => {
+                    return Err(make_custom_error(err));
+                }
+                Ok(Err(serializer)) => serializer,
+            }
+        } else {
+            serializer
+        };
+
+        // Handle both Value case and types that have a custom `Serialize`
+        let (serializer, error) = match try_custom_serialize(self.value, self.registry, serializer)
+        {
+            Ok(result) => return result,
+            Err(value) => value,
+        };
+
+        let output = match self.value.reflect_ref() {
+            ReflectRef::Struct(struct_value) => StructSerializer {
+                struct_value,
+                registry: self.registry,
+                processor: self.processor,
+            }
+            .serialize(serializer),
+            ReflectRef::TupleStruct(tuple_struct) => TupleStructSerializer {
+                tuple_struct,
+                registry: self.registry,
+                processor: self.processor,
+            }
+            .serialize(serializer),
+            ReflectRef::Tuple(tuple) => TupleSerializer {
+                tuple,
+                registry: self.registry,
+                processor: self.processor,
+            }
+            .serialize(serializer),
+            ReflectRef::List(list) => ListSerializer {
+                list,
+                registry: self.registry,
+                processor: self.processor,
+            }
+            .serialize(serializer),
+            ReflectRef::Array(array) => ArraySerializer {
+                array,
+                registry: self.registry,
+                processor: self.processor,
+            }
+            .serialize(serializer),
+            ReflectRef::Map(map) => MapSerializer {
+                map,
+                registry: self.registry,
+                processor: self.processor,
+            }
+            .serialize(serializer),
+            ReflectRef::Set(set) => SetSerializer {
+                set,
+                registry: self.registry,
+                processor: self.processor,
+            }
+            .serialize(serializer),
+            ReflectRef::Enum(enum_value) => EnumSerializer {
+                enum_value,
+                registry: self.registry,
+                processor: self.processor,
+            }
+            .serialize(serializer),
+            #[cfg(feature = "functions")]
+            ReflectRef::Function(_) => Err(make_custom_error("functions cannot be serialized")),
+            ReflectRef::Opaque(_) => Err(error),
+        };
+
+        #[cfg(feature = "debug_stack")]
+        TYPE_INFO_STACK.with_borrow_mut(crate::type_info_stack::TypeInfoStack::pop);
+
+        output
+    }
+}

vendor/bevy_reflect/src/serde/ser/sets.rs

@@ -0,0 +1,28 @@
+use crate::{serde::TypedReflectSerializer, Set, TypeRegistry};
+use serde::{ser::SerializeSeq, Serialize};
+
+use super::ReflectSerializerProcessor;
+
+/// A serializer for [`Set`] values.
+pub(super) struct SetSerializer<'a, P> {
+    pub set: &'a dyn Set,
+    pub registry: &'a TypeRegistry,
+    pub processor: Option<&'a P>,
+}
+
+impl<P: ReflectSerializerProcessor> Serialize for SetSerializer<'_, P> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_seq(Some(self.set.len()))?;
+        for value in self.set.iter() {
+            state.serialize_element(&TypedReflectSerializer::new_internal(
+                value,
+                self.registry,
+                self.processor,
+            ))?;
+        }
+        state.end()
+    }
+}

vendor/bevy_reflect/src/serde/ser/structs.rs

@@ -0,0 +1,62 @@
+use crate::{
+    serde::{ser::error_utils::make_custom_error, SerializationData, TypedReflectSerializer},
+    Struct, TypeInfo, TypeRegistry,
+};
+use serde::{ser::SerializeStruct, Serialize};
+
+use super::ReflectSerializerProcessor;
+
+/// A serializer for [`Struct`] values.
+pub(super) struct StructSerializer<'a, P> {
+    pub struct_value: &'a dyn Struct,
+    pub registry: &'a TypeRegistry,
+    pub processor: Option<&'a P>,
+}
+
+impl<P: ReflectSerializerProcessor> Serialize for StructSerializer<'_, P> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let type_info = self
+            .struct_value
+            .get_represented_type_info()
+            .ok_or_else(|| {
+                make_custom_error(format_args!(
+                    "cannot get type info for `{}`",
+                    self.struct_value.reflect_type_path()
+                ))
+            })?;
+
+        let struct_info = match type_info {
+            TypeInfo::Struct(struct_info) => struct_info,
+            info => {
+                return Err(make_custom_error(format_args!(
+                    "expected struct type but received {info:?}"
+                )));
+            }
+        };
+
+        let serialization_data = self
+            .registry
+            .get(type_info.type_id())
+            .and_then(|registration| registration.data::<SerializationData>());
+        let ignored_len = serialization_data.map(SerializationData::len).unwrap_or(0);
+        let mut state = serializer.serialize_struct(
+            struct_info.type_path_table().ident().unwrap(),
+            self.struct_value.field_len() - ignored_len,
+        )?;
+
+        for (index, value) in self.struct_value.iter_fields().enumerate() {
+            if serialization_data.is_some_and(|data| data.is_field_skipped(index)) {
+                continue;
+            }
+            let key = struct_info.field_at(index).unwrap().name();
+            state.serialize_field(
+                key,
+                &TypedReflectSerializer::new_internal(value, self.registry, self.processor),
+            )?;
+        }
+        state.end()
+    }
+}

vendor/bevy_reflect/src/serde/ser/tuple_structs.rs

@@ -0,0 +1,71 @@
+use crate::{
+    serde::{ser::error_utils::make_custom_error, SerializationData, TypedReflectSerializer},
+    TupleStruct, TypeInfo, TypeRegistry,
+};
+use serde::{ser::SerializeTupleStruct, Serialize};
+
+use super::ReflectSerializerProcessor;
+
+/// A serializer for [`TupleStruct`] values.
+pub(super) struct TupleStructSerializer<'a, P> {
+    pub tuple_struct: &'a dyn TupleStruct,
+    pub registry: &'a TypeRegistry,
+    pub processor: Option<&'a P>,
+}
+
+impl<P: ReflectSerializerProcessor> Serialize for TupleStructSerializer<'_, P> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let type_info = self
+            .tuple_struct
+            .get_represented_type_info()
+            .ok_or_else(|| {
+                make_custom_error(format_args!(
+                    "cannot get type info for `{}`",
+                    self.tuple_struct.reflect_type_path()
+                ))
+            })?;
+
+        let tuple_struct_info = match type_info {
+            TypeInfo::TupleStruct(tuple_struct_info) => tuple_struct_info,
+            info => {
+                return Err(make_custom_error(format_args!(
+                    "expected tuple struct type but received {info:?}"
+                )));
+            }
+        };
+
+        let serialization_data = self
+            .registry
+            .get(type_info.type_id())
+            .and_then(|registration| registration.data::<SerializationData>());
+        let ignored_len = serialization_data.map(SerializationData::len).unwrap_or(0);
+
+        if self.tuple_struct.field_len() == 1 && serialization_data.is_none() {
+            let field = self.tuple_struct.field(0).unwrap();
+            return serializer.serialize_newtype_struct(
+                tuple_struct_info.type_path_table().ident().unwrap(),
+                &TypedReflectSerializer::new_internal(field, self.registry, self.processor),
+            );
+        }
+
+        let mut state = serializer.serialize_tuple_struct(
+            tuple_struct_info.type_path_table().ident().unwrap(),
+            self.tuple_struct.field_len() - ignored_len,
+        )?;
+
+        for (index, value) in self.tuple_struct.iter_fields().enumerate() {
+            if serialization_data.is_some_and(|data| data.is_field_skipped(index)) {
+                continue;
+            }
+            state.serialize_field(&TypedReflectSerializer::new_internal(
+                value,
+                self.registry,
+                self.processor,
+            ))?;
+        }
+        state.end()
+    }
+}

vendor/bevy_reflect/src/serde/ser/tuples.rs

@@ -0,0 +1,29 @@
+use crate::{serde::TypedReflectSerializer, Tuple, TypeRegistry};
+use serde::{ser::SerializeTuple, Serialize};
+
+use super::ReflectSerializerProcessor;
+
+/// A serializer for [`Tuple`] values.
+pub(super) struct TupleSerializer<'a, P> {
+    pub tuple: &'a dyn Tuple,
+    pub registry: &'a TypeRegistry,
+    pub processor: Option<&'a P>,
+}
+
+impl<P: ReflectSerializerProcessor> Serialize for TupleSerializer<'_, P> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_tuple(self.tuple.field_len())?;
+
+        for value in self.tuple.iter_fields() {
+            state.serialize_element(&TypedReflectSerializer::new_internal(
+                value,
+                self.registry,
+                self.processor,
+            ))?;
+        }
+        state.end()
+    }
+}