diff --git a/include/iris/x4/attribute/smart_ptr.hpp b/include/iris/x4/attribute/smart_ptr.hpp
new file mode 100644
index 000000000..4cd6ed234
--- /dev/null
+++ b/include/iris/x4/attribute/smart_ptr.hpp
@@ -0,0 +1,384 @@
+#ifndef IRIS_ZZ_X4_ATTRIBUTE_SMART_PTR_HPP
+#define IRIS_ZZ_X4_ATTRIBUTE_SMART_PTR_HPP
+
+/*=============================================================================
+    Copyright (c) 2026 The Iris Project Contributors
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#include <iris/x4/core/parser.hpp>
+#include <iris/x4/core/parser_traits.hpp>
+
+#include <concepts>
+#include <string>
+#include <iterator>
+#include <type_traits>
+#include <utility>
+#include <memory>
+#include <format>
+
+namespace iris::x4 {
+
+namespace detail {
+
+// Since we need to do double-buffering anyway, we can additionally
+// provide strong exception guarantee in the parse(...) functions
+// below.
+template<class Ptr>
+struct [[nodiscard]] smart_ptr_rollback_guard
+{
+    ~smart_ptr_rollback_guard() noexcept
+    {
+        if (!parse_ok) {
+            ptr = std::move(old_ptr);
+        }
+    }
+
+    bool& parse_ok;
+    Ptr& old_ptr;
+    Ptr& ptr;
+};
+
+// ----------------------------------------------------
+
+template<class Derived, class Subject, class T, class DeleterT>
+struct unique_ptr_parser_base
+    : proxy_parser<Subject, Derived>
+{
+    using base_type = proxy_parser<Subject, Derived>;
+
+    // https://eel.is/c++draft/unique.ptr.single.ctor
+
+    template<class SubjectT>
+        requires
+            (!std::is_pointer_v<DeleterT> && std::is_default_constructible_v<DeleterT>) &&
+            (!std::same_as<std::remove_cvref_t<SubjectT>, Derived>) &&
+            std::is_constructible_v<base_type, SubjectT>
+    constexpr explicit unique_ptr_parser_base(SubjectT&& subject)
+        noexcept(
+            std::is_nothrow_constructible_v<base_type, SubjectT> &&
+            std::is_nothrow_default_constructible_v<DeleterT>
+        )
+        : base_type(std::forward<SubjectT>(subject))
+    {}
+
+    template<class SubjectT>
+        requires
+            (!std::same_as<std::remove_cvref_t<SubjectT>, Derived>) &&
+            std::is_constructible_v<base_type, SubjectT> &&
+            std::is_constructible_v<DeleterT, DeleterT const&>
+    constexpr unique_ptr_parser_base(SubjectT&& subject, DeleterT const& d)
+        noexcept(
+            std::is_nothrow_constructible_v<base_type, SubjectT> &&
+            std::is_nothrow_default_constructible_v<DeleterT>
+        )
+        : base_type(std::forward<SubjectT>(subject))
+        , deleter_(d)
+    {}
+
+    template<class SubjectT>
+        requires
+            (!std::same_as<std::remove_cvref_t<SubjectT>, Derived>) &&
+            std::is_constructible_v<base_type, SubjectT> &&
+            std::is_constructible_v<DeleterT, DeleterT&&>
+    constexpr unique_ptr_parser_base(SubjectT&& subject, std::remove_reference_t<DeleterT>&& d)
+        noexcept(
+            std::is_nothrow_constructible_v<base_type, SubjectT> &&
+            std::is_nothrow_default_constructible_v<DeleterT>
+        )
+        : base_type(std::forward<SubjectT>(subject))
+        , deleter_(std::move(d))
+    {}
+
+    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
+    [[nodiscard]] constexpr bool
+    parse(It& it, Se const& se, Context const& ctx, Attr& ptr) const
+        noexcept(false) // never noexcept; requires dynamic memory allocation
+    {
+        static_assert(std::same_as<typename Attr::deleter_type, DeleterT>, "Incompatible deleter type provided for unique_ptr_parser");
+
+        bool parse_ok = false;
+        auto old_ptr = std::exchange(ptr, std::unique_ptr<T, DeleterT>(new T(), deleter_));
+
+        smart_ptr_rollback_guard<std::unique_ptr<T, DeleterT>>
+        guard{parse_ok, old_ptr, ptr};
+
+        parse_ok = this->subject.parse(it, se, ctx, *ptr);
+        return parse_ok;
+    }
+
+private:
+    IRIS_NO_UNIQUE_ADDRESS DeleterT deleter_{};
+};
+
+template<class Derived, class Subject, class T>
+struct unique_ptr_parser_base<Derived, Subject, T, std::default_delete<T>>
+    : proxy_parser<Subject, Derived>
+{
+    using base_type = proxy_parser<Subject, Derived>;
+
+    template<class SubjectT>
+        requires
+            (!std::same_as<std::remove_cvref_t<SubjectT>, Derived>) &&
+            std::is_constructible_v<base_type, SubjectT>
+    constexpr explicit unique_ptr_parser_base(SubjectT&& subject)
+        noexcept(std::is_nothrow_constructible_v<base_type, SubjectT>)
+        : base_type(std::forward<SubjectT>(subject))
+    {}
+
+    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
+    [[nodiscard]] constexpr bool
+    parse(It& it, Se const& se, Context const& ctx, Attr& ptr) const
+        noexcept(false) // never noexcept; requires dynamic memory allocation
+    {
+        static_assert(std::same_as<typename Attr::deleter_type, std::default_delete<T>>, "Incompatible deleter type provided for unique_ptr_parser");
+
+        bool parse_ok = false;
+        auto old_ptr = std::exchange(ptr, std::make_unique<T>());
+
+        smart_ptr_rollback_guard<std::unique_ptr<T, std::default_delete<T>>>
+        guard{parse_ok, old_ptr, ptr};
+
+        parse_ok = this->subject.parse(it, se, ctx, *ptr);
+        return parse_ok;
+    }
+};
+
+} // detail
+
+template<class Subject, class T = parser_traits<Subject>::attribute_type, class DeleterT = std::default_delete<T>>
+struct unique_ptr_parser : detail::unique_ptr_parser_base<
+    unique_ptr_parser<Subject, T, DeleterT>,
+    Subject, T, DeleterT
+>
+{
+    static_assert(X4Attribute<T>);
+    static_assert(!X4UnusedAttribute<T>, "*_ptr_parser with `unused_type` is meaningless");
+
+    using element_type = T;
+    using deleter_type = DeleterT;
+    using attribute_type = std::unique_ptr<T, DeleterT>;
+
+    static constexpr bool requires_exact_attribute_type = true;
+
+    using unique_ptr_parser::unique_ptr_parser_base::unique_ptr_parser_base;
+
+    [[nodiscard]] constexpr std::string get_x4_info() const
+    {
+        return std::format("unique_ptr({})", get_info<Subject>{}(this->subject));
+    }
+};
+
+namespace parsers {
+
+template<int = 0, X4Subject Subject>
+[[nodiscard]] constexpr auto unique_ptr(Subject&& subject)
+    noexcept(
+        is_parser_nothrow_castable_v<Subject> &&
+        std::is_nothrow_constructible_v<
+            unique_ptr_parser<as_parser_plain_t<Subject>>,
+            as_parser_t<Subject>
+        >
+    )
+{
+    return unique_ptr_parser<as_parser_plain_t<Subject>>{
+        as_parser(std::forward<Subject>(subject))
+    };
+}
+
+template<class T, class DeleterT = std::default_delete<T>, X4Subject Subject>
+[[nodiscard]] constexpr auto unique_ptr(Subject&& subject)
+    noexcept(
+        is_parser_nothrow_castable_v<Subject> &&
+        std::is_nothrow_constructible_v<
+            unique_ptr_parser<as_parser_plain_t<Subject>, T, DeleterT>,
+            as_parser_t<Subject>
+        >
+    )
+{
+    return unique_ptr_parser<as_parser_plain_t<Subject>, T, DeleterT>{
+        as_parser(std::forward<Subject>(subject))
+    };
+}
+
+// ^^^ These cannot be CPO because we want to overload them via template parameter
+
+} // parsers
+
+using parsers::unique_ptr;
+
+
+// ----------------------------------------------------
+// ----------------------------------------------------
+// ----------------------------------------------------
+
+
+namespace detail {
+
+template<class Derived, class Subject, class T, class DeleterT>
+struct shared_ptr_parser_base
+    : proxy_parser<Subject, Derived>
+{
+    using base_type = proxy_parser<Subject, Derived>;
+
+    // https://eel.is/c++draft/util.smartptr.shared.const
+
+    template<class SubjectT>
+        requires
+            (!std::is_pointer_v<DeleterT> && std::is_default_constructible_v<DeleterT>) &&
+            (!std::same_as<std::remove_cvref_t<SubjectT>, Derived>) &&
+            std::is_constructible_v<base_type, SubjectT>
+    constexpr explicit shared_ptr_parser_base(SubjectT&& subject)
+        noexcept(
+            std::is_nothrow_constructible_v<base_type, SubjectT> &&
+            std::is_nothrow_default_constructible_v<DeleterT>
+        )
+        : base_type(std::forward<SubjectT>(subject))
+    {}
+
+    template<class SubjectT>
+        requires
+            (!std::same_as<std::remove_cvref_t<SubjectT>, Derived>) &&
+            std::is_constructible_v<base_type, SubjectT> &&
+            std::is_constructible_v<DeleterT, DeleterT const&>
+    constexpr shared_ptr_parser_base(SubjectT&& subject, DeleterT const& d)
+        noexcept(
+            std::is_nothrow_constructible_v<base_type, SubjectT> &&
+            std::is_nothrow_default_constructible_v<DeleterT>
+        )
+        : base_type(std::forward<SubjectT>(subject))
+        , deleter_(d)
+    {}
+
+    template<class SubjectT>
+        requires
+            (!std::same_as<std::remove_cvref_t<SubjectT>, Derived>) &&
+            std::is_constructible_v<base_type, SubjectT> &&
+            std::is_constructible_v<DeleterT, DeleterT&&>
+    constexpr shared_ptr_parser_base(SubjectT&& subject, std::remove_reference_t<DeleterT>&& d)
+        noexcept(
+            std::is_nothrow_constructible_v<base_type, SubjectT> &&
+            std::is_nothrow_default_constructible_v<DeleterT>
+        )
+        : base_type(std::forward<SubjectT>(subject))
+        , deleter_(std::move(d))
+    {}
+
+    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
+    [[nodiscard]] constexpr bool
+    parse(It& it, Se const& se, Context const& ctx, Attr& ptr) const
+        noexcept(false) // never noexcept; requires dynamic memory allocation
+    {
+        bool parse_ok = false;
+        auto old_ptr = std::exchange(ptr, std::shared_ptr<T>(new T(), deleter_));
+
+        smart_ptr_rollback_guard<std::shared_ptr<T>>
+        guard{parse_ok, old_ptr, ptr};
+
+        parse_ok = this->subject.parse(it, se, ctx, *ptr);
+        return parse_ok;
+    }
+
+private:
+    IRIS_NO_UNIQUE_ADDRESS DeleterT deleter_{};
+};
+
+template<class Derived, class Subject, class T>
+struct shared_ptr_parser_base<Derived, Subject, T, std::default_delete<T>>
+    : proxy_parser<Subject, Derived>
+{
+    using base_type = proxy_parser<Subject, Derived>;
+
+    template<class SubjectT>
+        requires
+            (!std::same_as<std::remove_cvref_t<SubjectT>, Derived>) &&
+            std::is_constructible_v<base_type, SubjectT>
+    constexpr explicit shared_ptr_parser_base(SubjectT&& subject)
+        noexcept(std::is_nothrow_constructible_v<base_type, SubjectT>)
+        : base_type(std::forward<SubjectT>(subject))
+    {}
+
+    template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, X4Attribute Attr>
+    [[nodiscard]] constexpr bool
+    parse(It& it, Se const& se, Context const& ctx, Attr& ptr) const
+        noexcept(false) // never noexcept; requires dynamic memory allocation
+    {
+        bool parse_ok = false;
+        auto old_ptr = std::exchange(ptr, std::make_shared<T>());
+
+        smart_ptr_rollback_guard<std::shared_ptr<T>>
+        guard{parse_ok, old_ptr, ptr};
+
+        parse_ok = this->subject.parse(it, se, ctx, *ptr);
+        return parse_ok;
+    }
+};
+
+} // detail
+
+template<class Subject, class T = parser_traits<Subject>::attribute_type, class DeleterT = std::default_delete<T>>
+struct shared_ptr_parser : detail::shared_ptr_parser_base<
+    shared_ptr_parser<Subject, T, DeleterT>,
+    Subject, T, DeleterT
+>
+{
+    static_assert(X4Attribute<T>);
+    static_assert(!X4UnusedAttribute<T>, "*_ptr_parser with `unused_type` is meaningless");
+
+    using element_type = T;
+    using deleter_type = DeleterT;
+    using attribute_type = std::shared_ptr<T>;
+
+    static constexpr bool requires_exact_attribute_type = true;
+
+    using shared_ptr_parser::shared_ptr_parser_base::shared_ptr_parser_base;
+
+    [[nodiscard]] constexpr std::string get_x4_info() const
+    {
+        return std::format("shared_ptr({})", get_info<Subject>{}(this->subject));
+    }
+};
+
+namespace parsers {
+
+template<int = 0, X4Subject Subject>
+[[nodiscard]] constexpr auto shared_ptr(Subject&& subject)
+    noexcept(
+        is_parser_nothrow_castable_v<Subject> &&
+        std::is_nothrow_constructible_v<
+            shared_ptr_parser<as_parser_plain_t<Subject>>,
+            as_parser_t<Subject>
+        >
+    )
+{
+    return shared_ptr_parser<as_parser_plain_t<Subject>>{
+        as_parser(std::forward<Subject>(subject))
+    };
+}
+
+template<class T, class DeleterT = std::default_delete<T>, X4Subject Subject>
+[[nodiscard]] constexpr auto shared_ptr(Subject&& subject)
+    noexcept(
+        is_parser_nothrow_castable_v<Subject> &&
+        std::is_nothrow_constructible_v<
+            shared_ptr_parser<as_parser_plain_t<Subject>, T, DeleterT>,
+            as_parser_t<Subject>
+        >
+    )
+{
+    return shared_ptr_parser<as_parser_plain_t<Subject>, T, DeleterT>{
+        as_parser(std::forward<Subject>(subject))
+    };
+}
+
+// ^^^ These cannot be CPO because we want to overload them via template parameter
+
+} // parsers
+
+using parsers::shared_ptr;
+
+} // iris::x4
+
+#endif
diff --git a/include/iris/x4/core/parser.hpp b/include/iris/x4/core/parser.hpp
index 988e0f555..24ad68ba5 100644
--- a/include/iris/x4/core/parser.hpp
+++ b/include/iris/x4/core/parser.hpp
@@ -214,28 +214,28 @@ struct as_parser_fn
 
     template<class Derived>
     [[nodiscard]] static constexpr auto&&
-    operator()(parser<Derived>& p) noexcept
+    operator()(parser<Derived>& p IRIS_LIFETIMEBOUND) noexcept
     {
         return p.derived();
     }
 
     template<class Derived>
     [[nodiscard]] static constexpr auto&&
-    operator()(parser<Derived> const& p) noexcept
+    operator()(parser<Derived> const& p IRIS_LIFETIMEBOUND) noexcept
     {
         return p.derived();
     }
 
     template<class Derived>
     [[nodiscard]] static constexpr auto&&
-    operator()(parser<Derived>&& p) noexcept
+    operator()(parser<Derived>&& p IRIS_LIFETIMEBOUND) noexcept
     {
         return std::move(p).derived();
     }
 
     template<class Derived>
     [[nodiscard]] static constexpr auto&&
-    operator()(parser<Derived> const&& p) noexcept
+    operator()(parser<Derived> const&& p IRIS_LIFETIMEBOUND) noexcept
     {
         return std::move(p).derived();
     }
diff --git a/include/iris/x4/debug/print_attribute.hpp b/include/iris/x4/debug/print_attribute.hpp
index ee71588ce..67580e866 100644
--- a/include/iris/x4/debug/print_attribute.hpp
+++ b/include/iris/x4/debug/print_attribute.hpp
@@ -23,9 +23,12 @@
 
 #include <iris/string.hpp>
 
+#include <iris/bits/specialization_of.hpp>
+
 #include <print>
 #include <iterator>
-#include <concepts>
+#include <memory>
+#include <type_traits>
 
 #include <cstdint>
 
@@ -220,8 +223,23 @@ struct print_attribute_debug
 
     static void call(std::ostream& out, traits::CategorizedAttr<traits::plain_attr> auto const& val)
     {
-        if constexpr (std::formattable<T, char>) {
+        if constexpr (
+            std::disjunction_v<
+                std::is_pointer<T>,
+                is_ttp_specialization_of<T, std::unique_ptr>,
+                is_ttp_specialization_of<T, std::shared_ptr>
+            >
+        ) {
+            auto const* ptr = std::to_address(val);
+            if (!ptr) {
+                out << "nullptr";
+            } else {
+                print_attribute_debug<typename std::pointer_traits<T>::element_type>::call(out, *ptr);
+            }
+
+        } else if constexpr (std::formattable<T, char>) {
             std::format_to(std::ostreambuf_iterator{out}, "{}", val);
+
         } else {
             // TODO: https://github.com/iris-cpp/iris/issues/51
             //static_assert(iris::req::ADL_ostreamable_v<T>);
diff --git a/test/x4/CMakeLists.txt b/test/x4/CMakeLists.txt
index 0ea63393f..bf0d0e4e5 100644
--- a/test/x4/CMakeLists.txt
+++ b/test/x4/CMakeLists.txt
@@ -87,6 +87,7 @@ x4_define_tests(
     seek
     sequence
     skip
+    smart_ptr
     substitution
     symbols1
     symbols2
diff --git a/test/x4/smart_ptr.cpp b/test/x4/smart_ptr.cpp
new file mode 100644
index 000000000..dff2ecbcd
--- /dev/null
+++ b/test/x4/smart_ptr.cpp
@@ -0,0 +1,227 @@
+/*=============================================================================
+    Copyright (c) 2026 The Iris Project Contributors
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+
+#include "iris_x4_test.hpp"
+
+#include <iris/x4/attribute/smart_ptr.hpp>
+#include <iris/x4/auxiliary/eps.hpp>
+#include <iris/x4/numeric/int.hpp>
+
+#include <stdexcept>
+
+template<class T>
+struct custom_deleter
+{
+    static constexpr void operator()(T* ptr) noexcept
+    {
+        delete ptr;
+    }
+};
+
+TEST_CASE("unique_ptr (std::default_delete<T>)")
+{
+    using x4::unique_ptr;
+    using x4::int_;
+    using x4::eps;
+
+    // Initial ptr = nullptr
+    {
+        std::unique_ptr<int> result;
+        REQUIRE(parse("1", unique_ptr(int_), result));
+        REQUIRE(!!result);
+        CHECK(*result == 1);
+    }
+    {
+        std::unique_ptr<int> result;
+        REQUIRE_FALSE(parse("1", unique_ptr<int>(eps(false)), result));
+        REQUIRE(!result);
+    }
+    {
+        std::unique_ptr<int> result;
+        REQUIRE_THROWS_AS(
+            parse("1", unique_ptr<int>(eps[([] { throw std::runtime_error{"failed"}; })]), result),
+            std::runtime_error
+        );
+        REQUIRE(!result);
+    }
+
+    // Initial ptr = some valid value
+    {
+        std::unique_ptr<int> result = std::make_unique<int>(42);
+        REQUIRE(parse("1", unique_ptr(int_), result));
+        REQUIRE(!!result);
+        CHECK(*result == 1);
+    }
+    {
+        std::unique_ptr<int> result = std::make_unique<int>(42);
+        REQUIRE_FALSE(parse("1", unique_ptr<int>(eps(false)), result));
+        REQUIRE(!!result);
+        CHECK(*result == 42);
+    }
+    {
+        std::unique_ptr<int> result = std::make_unique<int>(42);
+        REQUIRE_THROWS_AS(
+            parse("1", unique_ptr<int>(eps[([] { throw std::runtime_error{"failed"}; })]), result),
+            std::runtime_error
+        );
+        REQUIRE(!!result);
+        CHECK(*result == 42);
+    }
+}
+
+TEST_CASE("unique_ptr (custom deleter)")
+{
+    using x4::unique_ptr;
+    using x4::int_;
+    using x4::eps;
+
+    // Initial ptr = nullptr
+    {
+        std::unique_ptr<int, custom_deleter<int>> result;
+        REQUIRE(parse("1", unique_ptr<int, custom_deleter<int>>(int_), result));
+        REQUIRE(!!result);
+        CHECK(*result == 1);
+    }
+    {
+        std::unique_ptr<int, custom_deleter<int>> result;
+        REQUIRE_FALSE(parse("1", unique_ptr<int, custom_deleter<int>>(eps(false)), result));
+        REQUIRE(!result);
+    }
+    {
+        std::unique_ptr<int, custom_deleter<int>> result;
+        REQUIRE_THROWS_AS(
+            parse("1", unique_ptr<int, custom_deleter<int>>(eps[([] { throw std::runtime_error{"failed"}; })]), result),
+            std::runtime_error
+        );
+        REQUIRE(!result);
+    }
+
+    // Initial ptr = some valid value
+    {
+        std::unique_ptr<int, custom_deleter<int>> result(new int(42), custom_deleter<int>{});
+        REQUIRE(parse("1", unique_ptr<int, custom_deleter<int>>(int_), result));
+        REQUIRE(!!result);
+        CHECK(*result == 1);
+    }
+    {
+        std::unique_ptr<int, custom_deleter<int>> result(new int(42), custom_deleter<int>{});
+        REQUIRE_FALSE(parse("1", unique_ptr<int, custom_deleter<int>>(eps(false)), result));
+        REQUIRE(!!result);
+        CHECK(*result == 42);
+    }
+    {
+        std::unique_ptr<int, custom_deleter<int>> result(new int(42), custom_deleter<int>{});
+        REQUIRE_THROWS_AS(
+            parse("1", unique_ptr<int, custom_deleter<int>>(eps[([] { throw std::runtime_error{"failed"}; })]), result),
+            std::runtime_error
+        );
+        REQUIRE(!!result);
+        CHECK(*result == 42);
+    }
+}
+
+TEST_CASE("shared_ptr (std::default_delete<T>)")
+{
+    using x4::shared_ptr;
+    using x4::int_;
+    using x4::eps;
+
+    // Initial ptr = nullptr
+    {
+        std::shared_ptr<int> result;
+        REQUIRE(parse("1", shared_ptr(int_), result));
+        REQUIRE(!!result);
+        CHECK(*result == 1);
+    }
+    {
+        std::shared_ptr<int> result;
+        REQUIRE_FALSE(parse("1", shared_ptr<int>(eps(false)), result));
+        REQUIRE(!result);
+    }
+    {
+        std::shared_ptr<int> result;
+        REQUIRE_THROWS_AS(
+            parse("1", shared_ptr<int>(eps[([] { throw std::runtime_error{"failed"}; })]), result),
+            std::runtime_error
+        );
+        REQUIRE(!result);
+    }
+
+    // Initial ptr = some valid value
+    {
+        std::shared_ptr<int> result = std::make_shared<int>(42);
+        REQUIRE(parse("1", shared_ptr(int_), result));
+        REQUIRE(!!result);
+        CHECK(*result == 1);
+    }
+    {
+        std::shared_ptr<int> result = std::make_shared<int>(42);
+        REQUIRE_FALSE(parse("1", shared_ptr<int>(eps(false)), result));
+        REQUIRE(!!result);
+        CHECK(*result == 42);
+    }
+    {
+        std::shared_ptr<int> result = std::make_shared<int>(42);
+        REQUIRE_THROWS_AS(
+            parse("1", shared_ptr<int>(eps[([] { throw std::runtime_error{"failed"}; })]), result),
+            std::runtime_error
+        );
+        REQUIRE(!!result);
+        CHECK(*result == 42);
+    }
+}
+
+TEST_CASE("shared_ptr (custom deleter)")
+{
+    using x4::shared_ptr;
+    using x4::int_;
+    using x4::eps;
+
+    // Initial ptr = nullptr
+    {
+        std::shared_ptr<int> result;
+        REQUIRE(parse("1", shared_ptr<int, custom_deleter<int>>(int_), result));
+        REQUIRE(!!result);
+        CHECK(*result == 1);
+    }
+    {
+        std::shared_ptr<int> result;
+        REQUIRE_FALSE(parse("1", shared_ptr<int, custom_deleter<int>>(eps(false)), result));
+        REQUIRE(!result);
+    }
+    {
+        std::shared_ptr<int> result;
+        REQUIRE_THROWS_AS(
+            parse("1", shared_ptr<int, custom_deleter<int>>(eps[([] { throw std::runtime_error{"failed"}; })]), result),
+            std::runtime_error
+        );
+        REQUIRE(!result);
+    }
+
+    // Initial ptr = some valid value
+    {
+        std::shared_ptr<int> result(new int(42), custom_deleter<int>{});
+        REQUIRE(parse("1", shared_ptr<int, custom_deleter<int>>(int_), result));
+        REQUIRE(!!result);
+        CHECK(*result == 1);
+    }
+    {
+        std::shared_ptr<int> result(new int(42), custom_deleter<int>{});
+        REQUIRE_FALSE(parse("1", shared_ptr<int, custom_deleter<int>>(eps(false)), result));
+        REQUIRE(!!result);
+        CHECK(*result == 42);
+    }
+    {
+        std::shared_ptr<int> result(new int(42), custom_deleter<int>{});
+        REQUIRE_THROWS_AS(
+            parse("1", shared_ptr<int, custom_deleter<int>>(eps[([] { throw std::runtime_error{"failed"}; })]), result),
+            std::runtime_error
+        );
+        REQUIRE(!!result);
+        CHECK(*result == 42);
+    }
+}