diff --git a/CHANGELOG.md b/CHANGELOG.md
index 86f93d2..7e4d806 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,8 @@
+# 36.1.1-rc7 (api=2.0.0, abi=2.0.0)
+- BREAKING CHANGES:
+	- The in-place constructors for `Box` and `Arc` now require the initializer function to return a result, yielding the uninitialized allocation if allocation succeeded but initialization reported a failure. 
+- Added more constructors (such as `FromIterator`) for `BoxedSlice` and `ArcSlice`.
+
 # 36.1.1-rc6 (api=2.0.0, abi=2.0.0)
 - Refine `RustAlloc`'s implementation such that it stays a ZST.
 
diff --git a/Cargo.toml b/Cargo.toml
index 45e1cb5..24704aa 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,12 +33,12 @@ license = " EPL-2.0 OR Apache-2.0"
 categories = ["development-tools::ffi", "no-std::no-alloc"]
 repository = "https://github.com/ZettaScaleLabs/stabby"
 readme = "stabby/README.md"
-version = "36.1.1-rc6"                                           # Track
+version = "36.1.1-rc7"                                           # Track
 
 [workspace.dependencies]
-stabby-macros = { path = "./stabby-macros/", version = "36.1.1-rc6", default-features = false } # Track
-stabby-abi = { path = "./stabby-abi/", version = "36.1.1-rc6", default-features = false }       # Track
-stabby = { path = "./stabby/", version = "36.1.1-rc6", default-features = false }               # Track
+stabby-macros = { path = "./stabby-macros/", version = "36.1.1-rc7", default-features = false } # Track
+stabby-abi = { path = "./stabby-abi/", version = "36.1.1-rc7", default-features = false }       # Track
+stabby = { path = "./stabby/", version = "36.1.1-rc7", default-features = false }               # Track
 
 abi_stable = "0.11.0"
 libc = "0.2"
diff --git a/stabby-abi/src/alloc/boxed.rs b/stabby-abi/src/alloc/boxed.rs
index 557f635..a26d6b2 100644
--- a/stabby-abi/src/alloc/boxed.rs
+++ b/stabby-abi/src/alloc/boxed.rs
@@ -12,10 +12,14 @@
 //   Pierre Avital, <pierre.avital@me.com>
 //
 
-use crate::IntoDyn;
+use crate::{unreachable_unchecked, IntoDyn};
 
 use super::{vec::*, AllocPtr, AllocSlice, IAlloc};
-use core::{fmt::Debug, ptr::NonNull};
+use core::{
+    fmt::Debug,
+    mem::{ManuallyDrop, MaybeUninit},
+    ptr::NonNull,
+};
 
 /// An ABI-stable Box, provided `Alloc` is ABI-stable.
 #[crate::stabby]
@@ -41,12 +45,21 @@ where
     ///
     /// If the allocation fails, the `constructor` will not be run.
     ///
-    /// If the `constructor` panics, the allocated memory will be leaked.
+    /// # Safety
+    /// `constructor` MUST return `Err(())` if it failed to initialize the passed argument.
+    ///
+    /// # Errors
+    /// Returns the uninitialized allocation if the constructor declares a failure.
     ///
     /// # Panics
     /// If the allocator fails to provide an appropriate allocation.
-    pub fn make<F: FnOnce(&mut core::mem::MaybeUninit<T>)>(constructor: F) -> Self {
-        Self::make_in(constructor, super::DefaultAllocator::new())
+    pub unsafe fn make<
+        F: for<'a> FnOnce(&'a mut core::mem::MaybeUninit<T>) -> Result<&'a mut T, ()>,
+    >(
+        constructor: F,
+    ) -> Result<Self, Box<MaybeUninit<T>>> {
+        // SAFETY: Ensured by parent fn
+        unsafe { Self::make_in(constructor, super::DefaultAllocator::new()) }
     }
     /// Attempts to allocate [`Self`] and store `value` in it.
     ///
@@ -64,85 +77,105 @@ impl<T, Alloc: IAlloc> Box<T, Alloc> {
     /// If the `constructor` panics, the allocated memory will be leaked.
     ///
     /// # Errors
-    /// Returns the `constructor` and the allocator in case of failure.
+    /// - Returns the `constructor` and the allocator in case of allocation failure.
+    /// - Returns the uninitialized allocated memory if `constructor` fails.
+    ///
+    /// # Safety
+    /// `constructor` MUST return `Err(())` if it failed to initialize the passed argument.
     ///
     /// # Notes
     /// Note that the allocation may or may not be zeroed.
-    pub fn try_make_in<F: FnOnce(&mut core::mem::MaybeUninit<T>)>(
+    #[allow(clippy::type_complexity)]
+    pub unsafe fn try_make_in<
+        F: for<'a> FnOnce(&'a mut core::mem::MaybeUninit<T>) -> Result<&'a mut T, ()>,
+    >(
         constructor: F,
         mut alloc: Alloc,
-    ) -> Result<Self, (F, Alloc)> {
+    ) -> Result<Self, Result<Box<MaybeUninit<T>, Alloc>, (F, Alloc)>> {
         let mut ptr = match AllocPtr::alloc(&mut alloc) {
             Some(mut ptr) => {
-                unsafe { ptr.prefix_mut().alloc.write(alloc) };
+                // SAFETY: `ptr` just got allocated via `AllocPtr::alloc`.
+                unsafe { ptr.prefix_mut() }.alloc.write(alloc);
                 ptr
             }
-            None => return Err((constructor, alloc)),
+            None => return Err(Err((constructor, alloc))),
         };
-        unsafe {
-            constructor(ptr.as_mut());
-        }
-        Ok(Self {
-            ptr: unsafe { ptr.assume_init() },
-        })
+        // SAFETY: We are the sole owners of `ptr`
+        constructor(unsafe { ptr.as_mut() }).map_or_else(
+            |()| Err(Ok(Box { ptr })),
+            |_| {
+                Ok(Self {
+                    // SAFETY: `constructor` reported success.
+                    ptr: unsafe { ptr.assume_init() },
+                })
+            },
+        )
     }
     /// Attempts to allocate a [`Self`] and store `value` in it
     /// # Errors
     /// Returns `value` and the allocator in case of failure.
     pub fn try_new_in(value: T, alloc: Alloc) -> Result<Self, (T, Alloc)> {
-        let this = Self::try_make_in(
-            |slot| unsafe {
-                slot.write(core::ptr::read(&value));
-            },
-            alloc,
-        );
+        // SAFETY: `ctor` is a valid constructor, always initializing the value.
+        let this = unsafe {
+            Self::try_make_in(
+                |slot: &mut core::mem::MaybeUninit<T>| {
+                    // SAFETY: `value` will be forgotten if the allocation succeeds and `read` is called.
+                    Ok(slot.write(core::ptr::read(&value)))
+                },
+                alloc,
+            )
+        };
         match this {
-            Ok(this) => Ok(this),
-            Err((_, a)) => Err((value, a)),
+            Ok(this) => {
+                core::mem::forget(value);
+                Ok(this)
+            }
+            Err(Err((_, a))) => Err((value, a)),
+            // SAFETY: the constructor is infallible.
+            Err(Ok(_)) => unsafe { unreachable_unchecked!() },
         }
     }
     /// Attempts to allocate [`Self`], initializing it with `constructor`.
     ///
     /// Note that the allocation may or may not be zeroed.
     ///
+    /// # Errors
+    /// Returns the uninitialized allocated memory if `constructor` fails.
+    ///
+    /// # Safety
+    /// `constructor` MUST return `Err(())` if it failed to initialize the passed argument.
+    ///
     /// # Panics
     /// If the allocator fails to provide an appropriate allocation.
-    pub fn make_in<F: FnOnce(&mut core::mem::MaybeUninit<T>)>(
+    pub unsafe fn make_in<
+        F: for<'a> FnOnce(&'a mut core::mem::MaybeUninit<T>) -> Result<&'a mut T, ()>,
+    >(
         constructor: F,
-        mut alloc: Alloc,
-    ) -> Self {
-        let mut ptr = match AllocPtr::alloc(&mut alloc) {
-            Some(mut ptr) => {
-                unsafe { ptr.prefix_mut().alloc.write(alloc) };
-                ptr
-            }
-            None => panic!("Allocation failed"),
-        };
-        unsafe {
-            constructor(ptr.as_mut());
-        }
-        Self {
-            ptr: unsafe { ptr.assume_init() },
-        }
+        alloc: Alloc,
+    ) -> Result<Self, Box<MaybeUninit<T>, Alloc>> {
+        Self::try_make_in(constructor, alloc).map_err(|e| match e {
+            Ok(uninit) => uninit,
+            Err(_) => panic!("Allocation failed"),
+        })
     }
     /// Attempts to allocate [`Self`] and store `value` in it.
     ///
     /// # Panics
     /// If the allocator fails to provide an appropriate allocation.
     pub fn new_in(value: T, alloc: Alloc) -> Self {
-        Self::make_in(
-            move |slot| {
-                slot.write(value);
-            },
-            alloc,
-        )
+        // SAFETY: `constructor` fits the spec.
+        let this = unsafe { Self::make_in(move |slot| Ok(slot.write(value)), alloc) };
+        // SAFETY: `constructor` is infallible.
+        unsafe { this.unwrap_unchecked() }
     }
     /// Extracts the value from the allocation, freeing said allocation.
     pub fn into_inner(mut this: Self) -> T {
-        let ret = unsafe { core::ptr::read(&*this) };
-        this.free();
+        // SAFETY: `this` will be forgotten, preventing double-frees.
+        let ret = ManuallyDrop::new(unsafe { core::ptr::read(&*this) });
+        // SAFETY: `this` is immediately forgotten as required.
+        unsafe { this.free() };
         core::mem::forget(this);
-        ret
+        ManuallyDrop::into_inner(ret)
     }
     /// Returns the pointer to the inner raw allocation, leaking `this`.
     ///
@@ -161,8 +194,13 @@ impl<T, Alloc: IAlloc> Box<T, Alloc> {
 }
 
 impl<T, Alloc: IAlloc> Box<T, Alloc> {
-    fn free(&mut self) {
+    /// Frees the allocation without destroying the value in it.
+    /// # Safety
+    /// `self` is in an invalid state after this and MUST be forgotten immediately.
+    unsafe fn free(&mut self) {
+        // SAFETY: `Box` guarantees that `alloc` is stored in the prefix, and it won't be reused after this.
         let mut alloc = unsafe { self.ptr.prefix().alloc.assume_init_read() };
+        // SAFETY: `self.ptr` was definitely allocated in `alloc`
         unsafe { self.ptr.free(&mut alloc) }
     }
 }
@@ -200,18 +238,22 @@ impl<T, Alloc: IAlloc> crate::IPtrMut for Box<T, Alloc> {
 impl<T, Alloc: IAlloc> crate::IPtrOwned for Box<T, Alloc> {
     fn drop(this: &mut core::mem::ManuallyDrop<Self>, drop: unsafe extern "C" fn(&mut ())) {
         let rthis = &mut ***this;
+        // SAFETY: This is evil casting shenanigans, but `IPtrOwned` is a type anonimization primitive.
         unsafe {
             drop(core::mem::transmute::<&mut T, &mut ()>(rthis));
         }
-        this.free();
+        // SAFETY: `this` is immediately forgotten.
+        unsafe { this.free() }
     }
 }
 impl<T, Alloc: IAlloc> Drop for Box<T, Alloc> {
     fn drop(&mut self) {
+        // SAFETY: We own the target of `ptr` and guarantee it is initialized.
         unsafe {
             core::ptr::drop_in_place(self.ptr.as_mut());
         }
-        self.free()
+        // SAFETY: `this` is immediately forgotten.
+        unsafe { self.free() }
     }
 }
 impl<T, Alloc: IAlloc> IntoDyn for Box<T, Alloc> {
@@ -219,6 +261,7 @@ impl<T, Alloc: IAlloc> IntoDyn for Box<T, Alloc> {
     type Target = T;
     fn anonimize(self) -> Self::Anonymized {
         let original_prefix = self.ptr.prefix_ptr();
+        // SAFETY: Evil anonimization.
         let anonymized = unsafe { core::mem::transmute::<Self, Self::Anonymized>(self) };
         let anonymized_prefix = anonymized.ptr.prefix_ptr();
         assert_eq!(anonymized_prefix, original_prefix, "The allocation prefix was lost in anonimization, this is definitely a bug, please report it.");
@@ -253,16 +296,19 @@ impl<T, Alloc: IAlloc> BoxedSlice<T, Alloc> {
     }
     /// Cast into a standard slice.
     pub fn as_slice(&self) -> &[T] {
+        // SAFETY: we own this slice.
         unsafe { core::slice::from_raw_parts(self.slice.start.as_ptr(), self.len()) }
     }
     /// Cast into a standard mutable slice.
     pub fn as_slice_mut(&mut self) -> &mut [T] {
+        // SAFETY: we own this slice.
         unsafe { core::slice::from_raw_parts_mut(self.slice.start.as_ptr(), self.len()) }
     }
     /// Attempts to add an element to the boxed slice without reallocating.
     /// # Errors
     /// Returns the value if pushing would require reallocating.
     pub fn try_push(&mut self, value: T) -> Result<(), T> {
+        // SAFETY: the prefix must be initialized for this type to exist.
         if self.slice.len()
             >= unsafe { self.slice.start.prefix() }
                 .capacity
@@ -270,6 +316,7 @@ impl<T, Alloc: IAlloc> BoxedSlice<T, Alloc> {
         {
             return Err(value);
         }
+        // SAFETY: we've acertained that we have enough space to push an element.
         unsafe {
             core::ptr::write(self.slice.end.as_ptr(), value);
             self.slice.end = NonNull::new_unchecked(self.slice.end.as_ptr().add(1));
@@ -278,11 +325,13 @@ impl<T, Alloc: IAlloc> BoxedSlice<T, Alloc> {
     }
     pub(crate) fn into_raw_components(self) -> (AllocSlice<T, Alloc>, usize, Alloc) {
         let slice = self.slice;
+        // SAFETY: We forget `alloc` immediately.
         let alloc = unsafe { core::ptr::read(&self.alloc) };
         core::mem::forget(self);
         let capacity = if core::mem::size_of::<T>() == 0 || slice.is_empty() {
             0
         } else {
+            // SAFETY: we store the capacity in the prefix when constructed.
             unsafe {
                 slice
                     .start
@@ -331,6 +380,7 @@ impl<T, Alloc: IAlloc> From<Vec<T, Alloc>> for BoxedSlice<T, Alloc> {
     fn from(value: Vec<T, Alloc>) -> Self {
         let (mut slice, capacity, alloc) = value.into_raw_components();
         if capacity != 0 {
+            // SAFETY: the AllocSlice is initialized, storing to it is safe.
             unsafe {
                 slice.start.prefix_mut().capacity = core::sync::atomic::AtomicUsize::new(capacity);
             }
@@ -379,6 +429,11 @@ impl<T: Copy, Alloc: IAlloc + Default> From<&[T]> for BoxedSlice<T, Alloc> {
         Vec::from(value).into()
     }
 }
+impl<T, Alloc: IAlloc + Default> FromIterator<T> for BoxedSlice<T, Alloc> {
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+        Vec::from_iter(iter).into()
+    }
+}
 
 impl<T, Alloc: IAlloc> Drop for BoxedSlice<T, Alloc> {
     fn drop(&mut self) {
diff --git a/stabby-abi/src/alloc/collections/arc_btree.rs b/stabby-abi/src/alloc/collections/arc_btree.rs
index 6d66d07..d74a0f6 100644
--- a/stabby-abi/src/alloc/collections/arc_btree.rs
+++ b/stabby-abi/src/alloc/collections/arc_btree.rs
@@ -51,6 +51,7 @@ where
                 core::sync::atomic::Ordering::Release,
                 core::sync::atomic::Ordering::Acquire,
             ) {
+                // SAFETY: we've just replaced the old pointer succesfully, we can now free it.
                 Ok(old) => unsafe {
                     core::mem::forget(new);
                     ArcBTreeSet::take_ownership_from_ptr(old);
@@ -158,7 +159,9 @@ pub struct ArcBTreeSet<
     const REPLACE_ON_INSERT: bool = { false },
     const SPLIT_LIMIT: usize = { 5 },
 > {
+    /// The root of the tree
     root: Option<ArcBTreeSetNode<T, Alloc, REPLACE_ON_INSERT, SPLIT_LIMIT>>,
+    /// The allocator of the tree, which is present iff the root is `None`
     alloc: core::mem::MaybeUninit<Alloc>,
 }
 impl<T, Alloc: IAlloc, const REPLACE_ON_INSERT: bool, const SPLIT_LIMIT: usize> Clone
@@ -173,6 +176,7 @@ where
                 root: Some(root),
                 alloc: core::mem::MaybeUninit::uninit(),
             },
+            // SAFETY: if there is no root, then there's an allocator.
             None => unsafe {
                 Self {
                     root: None,
@@ -237,6 +241,7 @@ impl<T, Alloc: IAlloc, const REPLACE_ON_INSERT: bool, const SPLIT_LIMIT: usize>
 {
     fn drop(&mut self) {
         if self.root.is_none() {
+            // SAFETY: The root is `None`, hence the allocator is here.
             unsafe { self.alloc.assume_init_drop() }
         }
     }
@@ -247,9 +252,12 @@ where
     DefaultAllocator: core::default::Default,
 {
     /// Takes a pointer to the root.
+    ///
+    /// For the pointer to own the pointee of `self`, said pointee must be forgotten.
     const fn as_ptr(
         &self,
     ) -> *mut ArcBTreeSetNodeInner<T, DefaultAllocator, REPLACE_ON_INSERT, SPLIT_LIMIT> {
+        // SAFETY: the root is copied and transmuted to a pointer: the pointer is not considered to own the root yet.
         unsafe {
             core::mem::transmute::<
                 Option<ArcBTreeSetNode<T, DefaultAllocator, REPLACE_ON_INSERT, SPLIT_LIMIT>>,
@@ -267,6 +275,7 @@ where
                 alloc: core::mem::MaybeUninit::new(Default::default()),
             },
             Some(ptr) => {
+                // SAFETY: The pointer came from `as_ptr`, and is therefore of the correct layout. We use ManuallyDrop to avoid any risk of double-free
                 let owner: core::mem::ManuallyDrop<_> = unsafe {
                     core::mem::transmute::<
                         NonNull<
@@ -307,6 +316,7 @@ where
                 alloc: core::mem::MaybeUninit::new(Default::default()),
             },
             Some(ptr) => {
+                // SAFETY: The pointer came from `as_ptr`, which must have become the owner by the time this is called.
                 let root = unsafe {
                     core::mem::transmute::<
                         NonNull<
@@ -376,6 +386,7 @@ impl<T: Ord, Alloc: IAlloc, const REPLACE_ON_INSERT: bool, const SPLIT_LIMIT: us
         match &mut self.root {
             Some(inner) => inner.insert(value),
             None => {
+                // SAFETY: root == None <=> allocator is can be taken to construct a node.
                 let alloc = unsafe { self.alloc.assume_init_read() };
                 self.root = Some(ArcBTreeSetNode(Arc::new_in(
                     ArcBTreeSetNodeInner::new(
@@ -468,6 +479,7 @@ mod seal {
         for ArcBTreeSetNodeInner<T, Alloc, REPLACE_ON_INSERT, SPLIT_LIMIT>
     {
         fn drop(&mut self) {
+            // SAFETY: This only yields back the existing entries that can be safetly dropped.
             unsafe { core::ptr::drop_in_place(self.entries_mut()) }
         }
     }
@@ -478,10 +490,9 @@ mod seal {
             let mut entries: [MaybeUninit<
                 ArcBTreeSetEntry<T, Alloc, REPLACE_ON_INSERT, SPLIT_LIMIT>,
             >; SPLIT_LIMIT] = [(); SPLIT_LIMIT].map(|_| core::mem::MaybeUninit::uninit());
-            unsafe {
-                for (i, entry) in self.entries().iter().enumerate() {
-                    *entries.get_unchecked_mut(i) = MaybeUninit::new(entry.clone())
-                }
+            for (i, entry) in self.entries().iter().enumerate() {
+                // SAFETY: the number of entries is guaranteed to be small enough.
+                unsafe { *entries.get_unchecked_mut(i) = MaybeUninit::new(entry.clone()) }
             }
             Self {
                 entries,
@@ -568,13 +579,12 @@ mod seal {
         {
             use core::cmp::Ordering;
             let inner = Arc::make_mut(&mut self.0);
-            let alloc = unsafe {
-                AllocPtr {
-                    ptr: NonNull::new_unchecked(inner),
-                    marker: PhantomData,
-                }
+            let arc = AllocPtr {
+                ptr: NonNull::from(&*inner),
+                marker: PhantomData,
             };
-            let alloc = unsafe { alloc.prefix().alloc.assume_init_ref() };
+            // SAFETY: `arc` is known to bg a valid `Arc`, meaning its prefix contains an initialized alloc.
+            let alloc = unsafe { arc.prefix().alloc.assume_init_ref() };
             let entries = inner.entries_mut();
             for (i, entry) in entries.iter_mut().enumerate() {
                 match entry.value.cmp(&value) {
@@ -640,12 +650,16 @@ mod seal {
         where
             Alloc: Clone,
         {
+            debug_assert!(i < self.len);
+            // SAFETY: See line comments
             unsafe {
-                for j in (i..self.len).rev() {
-                    *self.entries.get_unchecked_mut(j + 1) =
-                        MaybeUninit::new(self.entries.get_unchecked(j).assume_init_read());
-                }
-                self.len += 1;
+                // SAFETY: A node always has at least one slot free thanks to splitting being called at the end of any operations that may increase `self.len`
+                core::ptr::copy(
+                    self.entries.as_ptr().add(i),
+                    self.entries.as_mut_ptr().add(i + 1),
+                    self.len - i,
+                );
+                // SAFETY: A node always has at least one slot free thanks to splitting being called at the end of any operations that may increase `self.len`
                 *self.entries.get_unchecked_mut(i) = MaybeUninit::new(ArcBTreeSetEntry {
                     value,
                     smaller: core::mem::replace(
@@ -658,6 +672,7 @@ mod seal {
                     ),
                 });
             }
+            self.len += 1;
             self.split(alloc)
         }
         fn push(
@@ -669,6 +684,7 @@ mod seal {
         where
             Alloc: Clone,
         {
+            // SAFETY: A node always has at least one slot free thanks to splitting being called at the end of any operations that may increase `self.len`
             unsafe {
                 self.entries
                     .get_unchecked_mut(self.len)
@@ -676,8 +692,8 @@ mod seal {
                         value,
                         smaller: core::mem::replace(&mut self.greater, greater),
                     });
-                self.len += 1;
             }
+            self.len += 1;
             self.split(alloc)
         }
         fn split(
@@ -687,32 +703,36 @@ mod seal {
         where
             Alloc: Clone,
         {
-            unsafe {
-                if self.len == SPLIT_LIMIT {
-                    let ArcBTreeSetEntry {
-                        value: pivot,
-                        smaller,
-                    } = self
-                        .entries
+            if self.len == SPLIT_LIMIT {
+                // SAFETY: we've just confirmed the `SPLIT_LIMIT/2` node is initialized by checking the length
+                let pivot = unsafe {
+                    self.entries
                         .get_unchecked(SPLIT_LIMIT / 2)
-                        .assume_init_read();
-                    let mut right = Self {
-                        entries: [(); SPLIT_LIMIT].map(|_| core::mem::MaybeUninit::uninit()),
-                        len: SPLIT_LIMIT / 2,
-                        greater: self.greater.take(),
-                    };
+                        .assume_init_read()
+                };
+                let ArcBTreeSetEntry {
+                    value: pivot,
+                    smaller,
+                } = pivot;
+                let mut right = Self {
+                    entries: [(); SPLIT_LIMIT].map(|_| core::mem::MaybeUninit::uninit()),
+                    len: SPLIT_LIMIT / 2,
+                    greater: self.greater.take(),
+                };
+                // SAFETY: the left entries are all initialized, allowing to read `SPLIT_LIMIT/2` elements into `right`
+                unsafe {
                     core::ptr::copy_nonoverlapping(
                         self.entries.get_unchecked(SPLIT_LIMIT / 2 + 1),
                         right.entries.get_unchecked_mut(0),
-                        SPLIT_LIMIT / 2,
-                    );
-                    self.greater = smaller;
-                    self.len = SPLIT_LIMIT / 2;
-                    let right = ArcBTreeSetNode(Arc::new_in(right, alloc.clone()));
-                    Some((right, pivot))
-                } else {
-                    None
-                }
+                        right.len,
+                    )
+                };
+                self.greater = smaller;
+                self.len = SPLIT_LIMIT / 2;
+                let right = ArcBTreeSetNode(Arc::new_in(right, alloc.clone()));
+                Some((right, pivot))
+            } else {
+                None
             }
         }
     }
@@ -721,11 +741,13 @@ mod seal {
         ArcBTreeSetNodeInner<T, Alloc, REPLACE_ON_INSERT, SPLIT_LIMIT>
     {
         pub fn entries(&self) -> &[ArcBTreeSetEntry<T, Alloc, REPLACE_ON_INSERT, SPLIT_LIMIT>] {
+            // SAFETY: Entries up to `self.len` are always initialized.
             unsafe { core::mem::transmute(self.entries.get_unchecked(..self.len)) }
         }
         pub fn entries_mut(
             &mut self,
         ) -> &mut [ArcBTreeSetEntry<T, Alloc, REPLACE_ON_INSERT, SPLIT_LIMIT>] {
+            // SAFETY: Entries up to `self.len` are always initialized.
             unsafe { core::mem::transmute(self.entries.get_unchecked_mut(..self.len)) }
         }
     }
diff --git a/stabby-abi/src/alloc/single_or_vec.rs b/stabby-abi/src/alloc/single_or_vec.rs
index 13b22df..c42aba8 100644
--- a/stabby-abi/src/alloc/single_or_vec.rs
+++ b/stabby-abi/src/alloc/single_or_vec.rs
@@ -81,6 +81,7 @@ where
         Self::with_capacity_in(capacity, Alloc::default())
     }
     /// Constructs a new vector in `alloc`, allocating sufficient space for `capacity` elements.
+    ///
     /// # Errors
     /// Returns an [`AllocationError`] if the allocator couldn't provide a sufficient allocation.
     pub fn try_with_capacity_in(capacity: usize, alloc: Alloc) -> Result<Self, Alloc> {
@@ -89,6 +90,7 @@ where
         })
     }
     /// Constructs a new vector, allocating sufficient space for `capacity` elements.
+    ///
     /// # Errors
     /// Returns an [`AllocationError`] if the allocator couldn't provide a sufficient allocation.
     pub fn try_with_capacity(capacity: usize) -> Result<Self, Alloc>
@@ -107,6 +109,7 @@ where
         self.inner.match_ref(|_| false, |vec| vec.is_empty())
     }
     /// Adds `value` at the end of `self`.
+    ///
     /// # Panics
     /// This function panics if the vector tried to grow due to
     /// being full, and the allocator failed to provide a new allocation.
diff --git a/stabby-abi/src/alloc/sync.rs b/stabby-abi/src/alloc/sync.rs
index 7644da2..ee096a7 100644
--- a/stabby-abi/src/alloc/sync.rs
+++ b/stabby-abi/src/alloc/sync.rs
@@ -16,12 +16,12 @@ use core::{
     fmt::Debug,
     hash::Hash,
     marker::PhantomData,
-    mem::ManuallyDrop,
+    mem::{ManuallyDrop, MaybeUninit},
     ptr::NonNull,
     sync::atomic::{AtomicPtr, AtomicUsize, Ordering},
 };
 
-use crate::{vtable::HasDropVt, Dyn, IStable, IntoDyn};
+use crate::{unreachable_unchecked, vtable::HasDropVt, Dyn, IStable, IntoDyn};
 
 use super::{
     vec::{ptr_add, ptr_diff, Vec, VecInner},
@@ -44,10 +44,23 @@ impl<T> Arc<T> {
     ///
     /// Note that the allocation may or may not be zeroed.
     ///
+    /// If the allocation fails, the `constructor` will not be run.
+    ///
+    /// # Safety
+    /// `constructor` MUST return `Err(())` if it failed to initialize the passed argument.
+    ///
+    /// # Errors
+    /// Returns the uninitialized allocation if the constructor declares a failure.
+    ///
     /// # Panics
     /// If the allocator fails to provide an appropriate allocation.
-    pub fn make<F: FnOnce(&mut core::mem::MaybeUninit<T>)>(constructor: F) -> Self {
-        Self::make_in(constructor, DefaultAllocator::new())
+    pub unsafe fn make<
+        F: for<'a> FnOnce(&'a mut core::mem::MaybeUninit<T>) -> Result<&'a mut T, ()>,
+    >(
+        constructor: F,
+    ) -> Result<Self, Arc<MaybeUninit<T>>> {
+        // SAFETY: Ensured by parent fn
+        unsafe { Self::make_in(constructor, super::DefaultAllocator::new()) }
     }
     /// Attempts to allocate [`Self`] and store `value` in it.
     ///
@@ -61,83 +74,104 @@ impl<T> Arc<T> {
 impl<T, Alloc: IAlloc> Arc<T, Alloc> {
     /// Attempts to allocate [`Self`], initializing it with `constructor`.
     ///
+    /// Note that the allocation may or may not be zeroed.
+    ///
+    /// If the `constructor` panics, the allocated memory will be leaked.
+    ///
     /// # Errors
-    /// Returns the constructor and the allocator in case of allocation failure.
+    /// - Returns the `constructor` and the allocator in case of allocation failure.
+    /// - Returns the uninitialized allocated memory if `constructor` fails.
+    ///
+    /// # Safety
+    /// `constructor` MUST return `Err(())` if it failed to initialize the passed argument.
     ///
     /// # Notes
     /// Note that the allocation may or may not be zeroed.
-    pub fn try_make_in<F: FnOnce(&mut core::mem::MaybeUninit<T>)>(
+    #[allow(clippy::type_complexity)]
+    pub unsafe fn try_make_in<
+        F: for<'a> FnOnce(&'a mut core::mem::MaybeUninit<T>) -> Result<&'a mut T, ()>,
+    >(
         constructor: F,
         mut alloc: Alloc,
-    ) -> Result<Self, (F, Alloc)> {
+    ) -> Result<Self, Result<Arc<MaybeUninit<T>, Alloc>, (F, Alloc)>> {
         let mut ptr = match AllocPtr::alloc(&mut alloc) {
             Some(mut ptr) => {
-                unsafe { ptr.prefix_mut().alloc.write(alloc) };
+                // SAFETY: `ptr` just got allocated via `AllocPtr::alloc`.
+                let prefix = unsafe { ptr.prefix_mut() };
+                prefix.alloc.write(alloc);
+                prefix.strong = AtomicUsize::new(1);
+                prefix.weak = AtomicUsize::new(1);
                 ptr
             }
-            None => return Err((constructor, alloc)),
+            None => return Err(Err((constructor, alloc))),
         };
-        unsafe {
-            constructor(ptr.as_mut());
-            ptr.prefix_mut().strong = AtomicUsize::new(1);
-            ptr.prefix_mut().weak = AtomicUsize::new(1)
-        }
-        Ok(Self {
-            ptr: unsafe { ptr.assume_init() },
-        })
+        // SAFETY: We are the sole owners of `ptr`
+        constructor(unsafe { ptr.as_mut() }).map_or_else(
+            |()| Err(Ok(Arc { ptr })),
+            |_| {
+                Ok(Self {
+                    // SAFETY: `constructor` reported success.
+                    ptr: unsafe { ptr.assume_init() },
+                })
+            },
+        )
     }
     /// Attempts to allocate a [`Self`] and store `value` in it
     /// # Errors
     /// Returns `value` and the allocator in case of failure.
     pub fn try_new_in(value: T, alloc: Alloc) -> Result<Self, (T, Alloc)> {
-        let this = Self::try_make_in(
-            |slot| unsafe {
-                slot.write(core::ptr::read(&value));
-            },
-            alloc,
-        );
+        // SAFETY: `ctor` is a valid constructor, always initializing the value.
+        let this = unsafe {
+            Self::try_make_in(
+                |slot: &mut core::mem::MaybeUninit<T>| {
+                    // SAFETY: `value` will be forgotten if the allocation succeeds and `read` is called.
+                    Ok(slot.write(core::ptr::read(&value)))
+                },
+                alloc,
+            )
+        };
         match this {
-            Ok(this) => Ok(this),
-            Err((_, a)) => Err((value, a)),
+            Ok(this) => {
+                core::mem::forget(value);
+                Ok(this)
+            }
+            Err(Err((_, a))) => Err((value, a)),
+            // SAFETY: the constructor is infallible.
+            Err(Ok(_)) => unsafe { unreachable_unchecked!() },
         }
     }
     /// Attempts to allocate [`Self`], initializing it with `constructor`.
     ///
     /// Note that the allocation may or may not be zeroed.
     ///
+    /// # Errors
+    /// Returns the uninitialized allocated memory if `constructor` fails.
+    ///
+    /// # Safety
+    /// `constructor` MUST return `Err(())` if it failed to initialize the passed argument.
+    ///
     /// # Panics
     /// If the allocator fails to provide an appropriate allocation.
-    pub fn make_in<F: FnOnce(&mut core::mem::MaybeUninit<T>)>(
+    pub unsafe fn make_in<
+        F: for<'a> FnOnce(&'a mut core::mem::MaybeUninit<T>) -> Result<&'a mut T, ()>,
+    >(
         constructor: F,
-        mut alloc: Alloc,
-    ) -> Self {
-        let mut ptr = match AllocPtr::alloc(&mut alloc) {
-            Some(mut ptr) => unsafe {
-                ptr.prefix_mut().alloc.write(alloc);
-                ptr
-            },
-            None => panic!("Allocation failed"),
-        };
-        unsafe {
-            constructor(ptr.as_mut());
-            ptr.prefix_mut().strong = AtomicUsize::new(1);
-            ptr.prefix_mut().weak = AtomicUsize::new(1)
-        }
-        Self {
-            ptr: unsafe { ptr.assume_init() },
-        }
+        alloc: Alloc,
+    ) -> Result<Self, Arc<MaybeUninit<T>, Alloc>> {
+        Self::try_make_in(constructor, alloc).map_err(|e| match e {
+            Ok(uninit) => uninit,
+            Err(_) => panic!("Allocation failed"),
+        })
     }
     /// Attempts to allocate [`Self`] and store `value` in it.
     ///
     /// # Panics
     /// If the allocator fails to provide an appropriate allocation.
     pub fn new_in(value: T, alloc: Alloc) -> Self {
-        Self::make_in(
-            move |slot| {
-                slot.write(value);
-            },
-            alloc,
-        )
+        // SAFETY: `constructor` fits the spec.
+        let this = unsafe { Self::make_in(move |slot| Ok(slot.write(value)), alloc) };
+        // SAFETY: `constructor` is infallible.
+        unsafe { this.unwrap_unchecked() }
     }
 
     /// Returns the pointer to the inner raw allocation, leaking `this`.
@@ -285,6 +319,16 @@ pub struct Weak<T, Alloc: IAlloc = super::DefaultAllocator> {
 unsafe impl<T: Send + Sync, Alloc: IAlloc + Send + Sync> Send for Weak<T, Alloc> {}
 // SAFETY: Same constraints as in `std`.
 unsafe impl<T: Send + Sync, Alloc: IAlloc + Send + Sync> Sync for Weak<T, Alloc> {}
+impl<T, Alloc: IAlloc> From<&Arc<T, Alloc>> for Arc<T, Alloc> {
+    fn from(value: &Arc<T, Alloc>) -> Self {
+        value.clone()
+    }
+}
+impl<T, Alloc: IAlloc> From<&Weak<T, Alloc>> for Weak<T, Alloc> {
+    fn from(value: &Weak<T, Alloc>) -> Self {
+        value.clone()
+    }
+}
 impl<T, Alloc: IAlloc> From<&Arc<T, Alloc>> for Weak<T, Alloc> {
     fn from(value: &Arc<T, Alloc>) -> Self {
         unsafe { value.ptr.prefix() }
@@ -586,6 +630,12 @@ impl<'a, T, Alloc: IAlloc> IntoIterator for &'a ArcSlice<T, Alloc> {
     }
 }
 
+impl<T, Alloc: IAlloc + Default> FromIterator<T> for ArcSlice<T, Alloc> {
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+        Vec::from_iter(iter).into()
+    }
+}
+
 /// A weak reference counted slice.
 #[crate::stabby]
 pub struct WeakSlice<T, Alloc: IAlloc = super::DefaultAllocator> {
@@ -637,6 +687,16 @@ impl<T, Alloc: IAlloc> Clone for WeakSlice<T, Alloc> {
         Self { inner: self.inner }
     }
 }
+impl<T, Alloc: IAlloc> From<&ArcSlice<T, Alloc>> for ArcSlice<T, Alloc> {
+    fn from(value: &ArcSlice<T, Alloc>) -> Self {
+        value.clone()
+    }
+}
+impl<T, Alloc: IAlloc> From<&WeakSlice<T, Alloc>> for WeakSlice<T, Alloc> {
+    fn from(value: &WeakSlice<T, Alloc>) -> Self {
+        value.clone()
+    }
+}
 impl<T, Alloc: IAlloc> From<&ArcSlice<T, Alloc>> for WeakSlice<T, Alloc> {
     fn from(value: &ArcSlice<T, Alloc>) -> Self {
         unsafe { value.inner.start.prefix() }
diff --git a/stabby-abi/src/typenum2/unsigned.rs b/stabby-abi/src/typenum2/unsigned.rs
index d8eac54..5f6cc77 100644
--- a/stabby-abi/src/typenum2/unsigned.rs
+++ b/stabby-abi/src/typenum2/unsigned.rs
@@ -91,6 +91,8 @@ pub trait IBitBase {
     type _ATernary<A: Alignment, B: Alignment>: Alignment;
     /// Support for [`IBit`]
     type AsForbiddenValue: ISingleForbiddenValue;
+    /// u8 if B1, () otherwise
+    type _Padding: IStable<Align = U1> + Default + Copy + Unpin;
 }
 /// false
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
@@ -112,6 +114,7 @@ impl IBitBase for B0 {
     type _SaddTernary<A: ISaturatingAdd, B: ISaturatingAdd> = B;
     type _StabTernary<A: IStable, B: IStable> = B;
     type _ATernary<A: Alignment, B: Alignment> = B;
+    type _Padding = ();
     type AsForbiddenValue = Saturator;
 }
 /// true
@@ -134,6 +137,7 @@ impl IBitBase for B1 {
     type _SaddTernary<A: ISaturatingAdd, B: ISaturatingAdd> = A;
     type _StabTernary<A: IStable, B: IStable> = A;
     type _ATernary<A: Alignment, B: Alignment> = A;
+    type _Padding = PadByte;
     type AsForbiddenValue = End;
 }
 /// A boolean. [`B0`] and [`B1`] are the canonical members of this type-class
@@ -456,6 +460,31 @@ impl<Msb: IUnsigned, Bit: IBit> NonZero for UInt<Msb, Bit> {
         <Bit::UTernary<UInt<Msb, B0>, UInt<Msb::_SatDecrement, B1>> as IUnsignedBase>::_Simplified;
     type TruncateAtRightmostOne = Self::_TruncateAtRightmostOne;
 }
+/// A helper to generate padding of appropriate size.
+#[repr(C)]
+pub struct PaddingHelper<Double: IStable<Align = U1>, Bit: IBitBase>(Double, Double, Bit::_Padding);
+impl<Double: IStable<Align = U1> + Default, Bit: IBitBase> Default for PaddingHelper<Double, Bit> {
+    fn default() -> Self {
+        Self(Default::default(), Default::default(), Default::default())
+    }
+}
+impl<Double: IStable<Align = U1> + Copy, Bit: IBitBase> Copy for PaddingHelper<Double, Bit> {}
+impl<Double: IStable<Align = U1> + Copy, Bit: IBitBase> Clone for PaddingHelper<Double, Bit> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+unsafe impl<Double: IStable<Align = U1>, Bit: IBitBase> IStable for PaddingHelper<Double, Bit> {
+    type Align = U1;
+    type Size = <<U2 as IUnsigned>::Mul<Double::Size> as IUnsigned>::Add<Bit::_UTernary<U1, U0>>;
+    type ForbiddenValues = End;
+    type ContainsIndirections = B0;
+    type HasExactlyOneNiche = B0;
+    type UnusedBits = <crate::tuple::Tuple3<Double, Double, Bit::_Padding> as IStable>::UnusedBits;
+    #[cfg(feature = "experimental-ctypes")]
+    type CType = crate::tuple::Tuple3<Double, Double, Bit::_Padding>;
+    primitive_report!("Padding");
+}
 impl<Msb: IUnsigned, Bit: IBit> IUnsignedBase for UInt<Msb, Bit> {
     const _U128: u128 = (Msb::_U128 << 1) | (<Self::Bit as IBit>::BOOL as u128);
     type Bit = Bit;
@@ -476,8 +505,7 @@ impl<Msb: IUnsigned, Bit: IBit> IUnsignedBase for UInt<Msb, Bit> {
         <T::_IsUTerm as IBit>::UTernary<UTerm, UInt<Msb::_Truncate<T::AbsSub<U1>>, Bit>>;
     type _SatDecrement =
         <Bit::UTernary<UInt<Msb, B0>, UInt<Msb::_SatDecrement, B1>> as IUnsignedBase>::_Simplified;
-    type _Padding =
-        OneMoreByte<<<Self as IUnsignedBase>::_SatDecrement as IUnsignedBase>::_Padding>;
+    type _Padding = PaddingHelper<Msb::Padding, Bit>;
     type NextPow2 = <Msb::NextPow2 as IUnsigned>::Add<<Self::_IsUTerm as IBit>::UTernary<U0, U1>>;
     type _TruncateAtRightmostOne = Bit::NzTernary<U1, UInt<Msb::_TruncateAtRightmostOne, B0>>;
     type _NonZero = Self;
diff --git a/stabby-macros/src/structs.rs b/stabby-macros/src/structs.rs
index a64ae93..faebcbd 100644
--- a/stabby-macros/src/structs.rs
+++ b/stabby-macros/src/structs.rs
@@ -213,6 +213,9 @@ pub fn stabby(
     });
     let report_bounds = report.bounds();
     let ctype = cfg!(feature = "experimental-ctypes").then(|| {
+        if matches!(repr, Some(AllowedRepr::Align(_))) {
+            return quote! {type CType = Self;};
+        }
         let ctype = report.crepr();
         quote! {type CType = #ctype;}
     });
diff --git a/stabby/benches/boxed_slices.rs b/stabby/benches/boxed_slices.rs
index b6554d1..e9df13c 100644
--- a/stabby/benches/boxed_slices.rs
+++ b/stabby/benches/boxed_slices.rs
@@ -10,11 +10,7 @@ fn bench_slices(c: &mut Criterion) {
         b.iter(|| stabby::boxed::Box::new(black_box(15)));
     });
     c.bench_function("stabby_box_make", |b| {
-        b.iter(|| {
-            stabby::boxed::Box::make(|slot| {
-                slot.write(black_box(15));
-            })
-        });
+        b.iter(|| unsafe { stabby::boxed::Box::make(|slot| Ok(slot.write(black_box(15)))) });
     });
     c.bench_function("std_box_big_new", |b| {
         b.iter(|| Box::<[usize; 10000]>::new([15; 10000]));
@@ -23,16 +19,16 @@ fn bench_slices(c: &mut Criterion) {
         b.iter(|| stabby::boxed::Box::<[usize; 10000]>::new([15; 10000]));
     });
     c.bench_function("stabby_box_big_make", |b| {
-        b.iter(|| {
+        b.iter(|| unsafe {
             stabby::boxed::Box::<[usize; 10000]>::make(|slot| {
-                for slot in unsafe {
-                    core::mem::transmute::<
-                        &mut MaybeUninit<[usize; 10000]>,
-                        &mut [MaybeUninit<usize>; 10000],
-                    >(slot)
-                } {
+                for slot in core::mem::transmute::<
+                    &mut MaybeUninit<[usize; 10000]>,
+                    &mut [MaybeUninit<usize>; 10000],
+                >(slot)
+                {
                     slot.write(15);
                 }
+                Ok(slot.assume_init_mut())
             })
         });
     });