checkout const-serialize as per DioxusLabs#4932 and fix build

Author: wheregmis

packages/cli/src/build/assets.rs

@@ -169,9 +169,13 @@ impl ManganisVersion {
             }
             ManganisVersion::New => {
                 // New format: serialize as BundledAsset directly (backward compatible)
-                // Use a 4096-byte buffer to match the buffer size used in macro serialization
-                let buffer = serialize_const(asset, ConstVec::<u8, 4096>::new_with_max_size());
-                buffer.as_ref().to_vec()
+                // Pad to 4096 bytes to match the linker output size
+                let buffer = serialize_const(asset, ConstVec::new());
+                let mut data = buffer.as_ref().to_vec();
+                if data.len() < 4096 {
+                    data.resize(4096, 0);
+                }
+                data
             }
         }
     }
@@ -180,8 +184,12 @@ impl ManganisVersion {
         match self {
             ManganisVersion::Legacy => None,
             ManganisVersion::New => {
-                let buffer = serialize_const(data, ConstVec::<u8, 4096>::new_with_max_size());
-                Some(buffer.as_ref().to_vec())
+                let buffer = serialize_const(data, ConstVec::new());
+                let mut bytes = buffer.as_ref().to_vec();
+                if bytes.len() < 4096 {
+                    bytes.resize(4096, 0);
+                }
+                Some(bytes)
             }
         }
     }

packages/const-serialize/src/array.rs

@@ -22,11 +22,11 @@ unsafe impl<const N: usize, T: SerializeConst> SerializeConst for [T; N] {
 }
 
 /// Serialize a constant sized array that is stored at the pointer passed in
-pub(crate) const unsafe fn serialize_const_array<const MAX_SIZE: usize>(
+pub(crate) const unsafe fn serialize_const_array(
     ptr: *const (),
-    mut to: ConstVec<u8, MAX_SIZE>,
+    mut to: ConstVec<u8>,
     layout: &ArrayLayout,
-) -> ConstVec<u8, MAX_SIZE> {
+) -> ConstVec<u8> {
     let len = layout.len;
     let mut i = 0;
     to = write_array(to, len);

packages/const-serialize/src/enum.rs

@@ -1,11 +1,11 @@
 use crate::*;
 
 /// Serialize an enum that is stored at the pointer passed in
-pub(crate) const unsafe fn serialize_const_enum<const MAX_SIZE: usize>(
+pub(crate) const unsafe fn serialize_const_enum(
     ptr: *const (),
-    mut to: ConstVec<u8, MAX_SIZE>,
+    mut to: ConstVec<u8>,
     layout: &EnumLayout,
-) -> ConstVec<u8, MAX_SIZE> {
+) -> ConstVec<u8> {
     let byte_ptr = ptr as *const u8;
     let discriminant = layout.discriminant.read(byte_ptr);
 

packages/const-serialize/src/lib.rs

@@ -66,11 +66,11 @@ pub unsafe trait SerializeConst: Sized {
 }
 
 /// Serialize a pointer to a type that is stored at the pointer passed in
-const unsafe fn serialize_const_ptr<const MAX_SIZE: usize>(
+const unsafe fn serialize_const_ptr(
     ptr: *const (),
-    to: ConstVec<u8, MAX_SIZE>,
+    to: ConstVec<u8>,
     layout: &Layout,
-) -> ConstVec<u8, MAX_SIZE> {
+) -> ConstVec<u8> {
     match layout {
         Layout::Enum(layout) => serialize_const_enum(ptr, to, layout),
         Layout::Struct(layout) => serialize_const_struct(ptr, to, layout),
@@ -103,10 +103,7 @@ const unsafe fn serialize_const_ptr<const MAX_SIZE: usize>(
 /// assert_eq!(buffer.as_ref(), &[0xa3, 0x61, 0x61, 0x1a, 0x11, 0x11, 0x11, 0x11, 0x61, 0x62, 0x18, 0x22, 0x61, 0x63, 0x1a, 0x33, 0x33, 0x33, 0x33]);
 /// ```
 #[must_use = "The data is serialized into the returned buffer"]
-pub const fn serialize_const<T: SerializeConst, const MAX_SIZE: usize>(
-    data: &T,
-    to: ConstVec<u8, MAX_SIZE>,
-) -> ConstVec<u8, MAX_SIZE> {
+pub const fn serialize_const<T: SerializeConst>(data: &T, to: ConstVec<u8>) -> ConstVec<u8> {
     let ptr = data as *const T as *const ();
     // SAFETY: The pointer is valid and the layout is correct
     unsafe { serialize_const_ptr(ptr, to, &T::MEMORY_LAYOUT) }

packages/const-serialize/src/list.rs

@@ -35,11 +35,11 @@ impl ListLayout {
 }
 
 /// Serialize a dynamically sized list that is stored at the pointer passed in
-pub(crate) const unsafe fn serialize_const_list<const MAX_SIZE: usize>(
+pub(crate) const unsafe fn serialize_const_list(
     ptr: *const (),
-    mut to: ConstVec<u8, MAX_SIZE>,
+    mut to: ConstVec<u8>,
     layout: &ListLayout,
-) -> ConstVec<u8, MAX_SIZE> {
+) -> ConstVec<u8> {
     // Read the length of the list
     let len_ptr = ptr.wrapping_byte_offset(layout.len_offset as _);
     let len = layout.len_layout.read(len_ptr as *const u8) as usize;

packages/const-serialize/src/primitive.rs

@@ -71,11 +71,11 @@ impl_serialize_const!(f32);
 impl_serialize_const!(f64);
 
 /// Serialize a primitive type that is stored at the pointer passed in
-pub(crate) const unsafe fn serialize_const_primitive<const MAX_SIZE: usize>(
+pub(crate) const unsafe fn serialize_const_primitive(
     ptr: *const (),
-    to: ConstVec<u8, MAX_SIZE>,
+    to: ConstVec<u8>,
     layout: &PrimitiveLayout,
-) -> ConstVec<u8, MAX_SIZE> {
+) -> ConstVec<u8> {
     let ptr = ptr as *const u8;
     let mut offset = 0;
     let mut i64_bytes = [0u8; 8];

packages/const-serialize/src/struct.rs

@@ -34,11 +34,11 @@ impl StructLayout {
 }
 
 /// Serialize a struct that is stored at the pointer passed in
-pub(crate) const unsafe fn serialize_const_struct<const MAX_SIZE: usize>(
+pub(crate) const unsafe fn serialize_const_struct(
     ptr: *const (),
-    to: ConstVec<u8, MAX_SIZE>,
+    to: ConstVec<u8>,
     layout: &StructLayout,
-) -> ConstVec<u8, MAX_SIZE> {
+) -> ConstVec<u8> {
     let mut i = 0;
     let field_count = layout.data.len();
     let mut to = write_map(to, field_count);

packages/dx-macro-helpers/src/lib.rs

@@ -48,9 +48,10 @@ pub const fn serialize_to_const_with_max<const MAX_SIZE: usize>(
     value: &impl SerializeConst,
     memory_layout_size: usize,
 ) -> ConstVec<u8, MAX_SIZE> {
-    // Serialize directly into the larger buffer to avoid overflow
+    // Serialize using the default buffer, then copy into the larger buffer
+    let serialized = const_serialize::serialize_const(value, ConstVec::new());
     let mut data: ConstVec<u8, MAX_SIZE> = ConstVec::new_with_max_size();
-    data = const_serialize::serialize_const(value, data);
+    data = data.extend(serialized.as_ref());
     // Reserve the maximum size of the type (pad to MEMORY_LAYOUT size)
     while data.len() < memory_layout_size {
         data = data.push(0);

packages/manganis/manganis/src/macro_helpers.rs

@@ -32,10 +32,10 @@ pub const fn create_bundled_asset_relative(
 /// linker section size. const-serialize deserialization will ignore
 /// the padding (zeros) at the end.
 pub const fn serialize_asset(asset: &BundledAsset) -> ConstVec<u8, 4096> {
-    // Serialize directly into a 4096-byte buffer and pad to full size
-    // This matches the CLI's expectation for the fixed buffer size
+    // Serialize using the default buffer, then expand into the fixed-size buffer
+    let serialized = const_serialize::serialize_const(asset, ConstVec::new());
     let mut data: ConstVec<u8, 4096> = ConstVec::new_with_max_size();
-    data = const_serialize::serialize_const(asset, data);
+    data = data.extend(serialized.as_ref());
     // Pad to full buffer size (4096) to match linker section size
     while data.len() < 4096 {
         data = data.push(0);

packages/permissions/permissions/src/lib.rs

@@ -59,10 +59,10 @@ pub mod macro_helpers {
     /// the padding (zeros) at the end.
     pub const fn serialize_permission(permission: &Permission) -> ConstVec<u8, 4096> {
         let symbol_data = SymbolData::Permission(*permission);
-        // Serialize into a 4096-byte buffer and pad to full size
-        // This matches the CLI's expectation for the fixed buffer size
+        // Serialize using the default buffer, then expand into the fixed-size buffer
+        let serialized = const_serialize::serialize_const(&symbol_data, ConstVec::new());
         let mut data: ConstVec<u8, 4096> = ConstVec::new_with_max_size();
-        data = const_serialize::serialize_const(&symbol_data, data);
+        data = data.extend(serialized.as_ref());
         // Pad to full buffer size (4096) to match linker section size
         while data.len() < 4096 {
             data = data.push(0);