@ugo-studio/jspp 0.1.9 → 0.2.1

package/src/prelude/any_value.hpp

@@ -17,83 +17,101 @@
 #include <cmath>
 #include <optional>
 #include <coroutine>
-#include <variant>
 
 #include "types.hpp"
 #include "values/non_values.hpp"
-#include "values/object.hpp"
-#include "values/array.hpp"
-#include "values/function.hpp"
-#include "values/iterator.hpp"
-#include "values/promise.hpp"
-#include "values/symbol.hpp"
-#include "values/string.hpp"
-#include "values/descriptors.hpp"
-#include "exception.hpp"
-#include "utils/well_known_symbols.hpp"
 
 namespace jspp
 {
-    enum class JsType : uint8_t
-    {
-        Undefined = 0,
-        Null = 1,
-        Uninitialized = 2,
-        Boolean = 3,
-        Number = 4,
-        String = 5,
-        Object = 6,
-        Array = 7,
-        Function = 8,
-        Iterator = 9,
-        Symbol = 10,
-        Promise = 11,
-        DataDescriptor = 12,
-        AccessorDescriptor = 13,
-        AsyncIterator = 14,
-    };
-
-    // The variant order MUST match JsType
-    using AnyValueVariant = std::variant<
-        JsUndefined,
-        JsNull,
-        JsUninitialized,
-        bool,
-        double,
-        std::shared_ptr<JsString>,
-        std::shared_ptr<JsObject>,
-        std::shared_ptr<JsArray>,
-        std::shared_ptr<JsFunction>,
-        std::shared_ptr<JsIterator<AnyValue>>,
-        std::shared_ptr<JsSymbol>,
-        std::shared_ptr<JsPromise>,
-        std::shared_ptr<DataDescriptor>,
-        std::shared_ptr<AccessorDescriptor>,
-        std::shared_ptr<JsAsyncIterator<AnyValue>>>;
+    // NAN BOXING SCHEME (64-bit)
+    // -------------------------
+    // Any value that is NOT a NaN double or is a "quiet" NaN is stored as a double.
+    // We use the top bits of the NaN space for tagging.
+    //
+    // Any value >= 0xFFFC000000000000 is a special tag.
+    //
+    // Tagging (bits 48-63):
+    // 0xFFFC: Pointer to HeapObject
+    // 0xFFFD: Boolean (bit 0 is value)
+    // 0xFFFE: Special (Undefined, Null, Uninitialized)
 
     class AnyValue
     {
     private:
-        AnyValueVariant storage;
+        uint64_t storage;
+
+        static constexpr uint64_t TAG_BASE          = 0xFFFC000000000000ULL;
+        static constexpr uint64_t TAG_POINTER       = 0xFFFC000000000000ULL;
+        static constexpr uint64_t TAG_BOOLEAN       = 0xFFFD000000000000ULL;
+        static constexpr uint64_t TAG_SPECIAL       = 0xFFFE000000000000ULL;
+        
+        static constexpr uint64_t VAL_UNDEFINED     = 0x1ULL;
+        static constexpr uint64_t VAL_NULL          = 0x2ULL;
+        static constexpr uint64_t VAL_UNINITIALIZED = 0x3ULL;
+
+        static constexpr uint64_t TAG_MASK          = 0xFFFF000000000000ULL;
+        static constexpr uint64_t PAYLOAD_MASK      = 0x0000FFFFFFFFFFFFULL;
+
+        inline bool has_tag(uint64_t tag) const noexcept {
+            return (storage & TAG_MASK) == tag;
+        }
 
     public:
+        inline HeapObject* get_ptr() const noexcept {
+            return reinterpret_cast<HeapObject*>(storage & PAYLOAD_MASK);
+        }
+
         // default ctor (Undefined)
-        AnyValue() noexcept = default;
+        AnyValue() noexcept : storage(TAG_SPECIAL | VAL_UNDEFINED) {}
+
+        explicit AnyValue(double d) noexcept {
+            std::memcpy(&storage, &d, 8);
+            if (storage >= TAG_BASE) [[unlikely]] {
+                storage = 0x7FF8000000000000ULL;
+            }
+        }
 
-        // Copy/Move handled by std::variant
-        AnyValue(const AnyValue &) = default;
-        AnyValue(AnyValue &&) noexcept = default;
-        AnyValue &operator=(const AnyValue &) = default;
-        AnyValue &operator=(AnyValue &&) noexcept = default;
+        explicit AnyValue(bool b) noexcept : storage(TAG_BOOLEAN | (b ? 1 : 0)) {}
 
-        ~AnyValue() = default;
+        AnyValue(const AnyValue &other) noexcept : storage(other.storage) {
+            if (is_heap_object()) get_ptr()->ref();
+        }
+
+        AnyValue(AnyValue &&other) noexcept : storage(other.storage) {
+            other.storage = TAG_SPECIAL | VAL_UNDEFINED;
+        }
+
+        AnyValue &operator=(const AnyValue &other) noexcept {
+            if (this != &other) {
+                if (is_heap_object()) get_ptr()->deref();
+                storage = other.storage;
+                if (is_heap_object()) get_ptr()->ref();
+            }
+            return *this;
+        }
+
+        AnyValue &operator=(AnyValue &&other) noexcept {
+            if (this != &other) {
+                if (is_heap_object()) get_ptr()->deref();
+                storage = other.storage;
+                other.storage = TAG_SPECIAL | VAL_UNDEFINED;
+            }
+            return *this;
+        }
+
+        ~AnyValue() {
+            if (is_heap_object()) get_ptr()->deref();
+        }
 
         // Assignments
-        AnyValue &operator=(const double &val)
-        {
-            storage = val;
+        AnyValue &operator=(double val) noexcept {
+            if (is_heap_object()) get_ptr()->deref();
+            std::memcpy(&storage, &val, 8);
+            if (storage >= TAG_BASE) [[unlikely]] {
+                storage = 0x7FF8000000000000ULL;
+            }
             return *this;
-        };
+        }
 
         friend void swap(AnyValue &a, AnyValue &b) noexcept
         {
@@ -114,415 +132,191 @@ namespace jspp
         // factories -------------------------------------------------------
         static AnyValue make_number(double d) noexcept
         {
-            AnyValue v;
-            v.storage = d;
-            return v;
+            return AnyValue(d);
         }
         static AnyValue make_nan() noexcept
         {
             AnyValue v;
-            v.storage = std::numeric_limits<double>::quiet_NaN();
+            v.storage = 0x7FF8000000000000ULL;
             return v;
         }
         static AnyValue make_uninitialized() noexcept
         {
             AnyValue v;
-            v.storage = JsUninitialized{};
+            v.storage = TAG_SPECIAL | VAL_UNINITIALIZED;
             return v;
         }
         static AnyValue make_undefined() noexcept
         {
             AnyValue v;
-            v.storage = JsUndefined{};
+            v.storage = TAG_SPECIAL | VAL_UNDEFINED;
             return v;
         }
         static AnyValue make_null() noexcept
         {
             AnyValue v;
-            v.storage = JsNull{};
+            v.storage = TAG_SPECIAL | VAL_NULL;
             return v;
         }
         static AnyValue make_boolean(bool b) noexcept
         {
-            AnyValue v;
-            v.storage = b;
-            return v;
-        }
-        static AnyValue make_string(const std::string &raw_s) noexcept
-        {
-            AnyValue v;
-            v.storage = std::make_shared<JsString>(raw_s);
-            return v;
-        }
-        static AnyValue make_object(std::initializer_list<std::pair<std::string, AnyValue>> props) noexcept
-        {
-            AnyValue v;
-            v.storage = std::make_shared<JsObject>(props);
-            return v;
-        }
-        static AnyValue make_object(const std::map<std::string, AnyValue> &props) noexcept
-        {
-            AnyValue v;
-            v.storage = std::make_shared<JsObject>(props);
-            return v;
-        }
-        static AnyValue make_object_with_proto(std::initializer_list<std::pair<std::string, AnyValue>> props, const AnyValue &proto) noexcept
-        {
-            AnyValue v;
-            auto protoPtr = std::make_shared<AnyValue>(proto);
-            v.storage = std::make_shared<JsObject>(props, protoPtr);
-            return v;
-        }
-        static AnyValue make_object_with_proto(const std::map<std::string, AnyValue> &props, const AnyValue &proto) noexcept
-        {
-            AnyValue v;
-            auto protoPtr = std::make_shared<AnyValue>(proto);
-            v.storage = std::make_shared<JsObject>(props, protoPtr);
-            return v;
-        }
-        static AnyValue make_array(std::span<const AnyValue> dense) noexcept
-        {
-            AnyValue v;
-            std::vector<AnyValue> vec;
-            vec.reserve(dense.size());
-            for (const auto &item : dense)
-                vec.push_back(item);
-            v.storage = std::make_shared<JsArray>(std::move(vec));
-            return v;
-        }
-        static AnyValue make_array(const std::vector<AnyValue> &dense) noexcept
-        {
-            AnyValue v;
-            v.storage = std::make_shared<JsArray>(dense);
-            return v;
-        }
-        static AnyValue make_array(std::vector<AnyValue> &&dense) noexcept
-        {
-            AnyValue v;
-            v.storage = std::make_shared<JsArray>(std::move(dense));
-            return v;
-        }
-        static AnyValue make_array_with_proto(std::span<const AnyValue> dense, const AnyValue &proto) noexcept
-        {
-            AnyValue v;
-            std::vector<AnyValue> vec;
-            vec.reserve(dense.size());
-            for (const auto &item : dense)
-                vec.push_back(item);
-            v.storage = std::make_shared<JsArray>(std::move(vec));
-            std::get<std::shared_ptr<JsArray>>(v.storage)->proto = std::make_shared<AnyValue>(proto);
-            return v;
-        }
-        static AnyValue make_array_with_proto(const std::vector<AnyValue> &dense, const AnyValue &proto) noexcept
-        {
-            AnyValue v;
-            v.storage = std::make_shared<JsArray>(dense);
-            std::get<std::shared_ptr<JsArray>>(v.storage)->proto = std::make_shared<AnyValue>(proto);
-            return v;
-        }
-        static AnyValue make_function(const JsFunctionCallable &call, const std::optional<std::string> &name = std::nullopt, bool is_constructor = true) noexcept
-        {
-            AnyValue v;
-            v.storage = std::make_shared<JsFunction>(call, name, std::unordered_map<std::string, AnyValue>{}, false, is_constructor);
-
-            auto proto = make_object({});
-            proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
-            v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
-
-            return v;
-        }
-        static AnyValue make_class(const JsFunctionCallable &call, const std::optional<std::string> &name = std::nullopt) noexcept
-        {
-            AnyValue v;
-            // use Constructor A with is_cls = true
-            v.storage = std::make_shared<JsFunction>(call, name, std::unordered_map<std::string, AnyValue>{}, true);
-
-            auto proto = make_object({});
-            proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
-            v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
-
-            return v;
-        }
-        static AnyValue make_generator(const JsFunctionCallable &call, const std::optional<std::string> &name = std::nullopt) noexcept
-        {
-            AnyValue v;
-            // use Constructor B with is_gen = true
-            v.storage = std::make_shared<JsFunction>(call, true, name);
-
-            auto proto = make_object({});
-            proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
-            v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
-
-            return v;
-        }
-        static AnyValue make_async_function(const JsFunctionCallable &call, const std::optional<std::string> &name = std::nullopt) noexcept
-        {
-            AnyValue v;
-            // use Constructor C with is_async_func = true
-            v.storage = std::make_shared<JsFunction>(call, false, true, name);
-
-            auto proto = make_object({});
-            proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
-            v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
-
-            return v;
-        }
-        static AnyValue make_async_generator(const JsFunctionCallable &call, const std::optional<std::string> &name = std::nullopt) noexcept
-        {
-            AnyValue v;
-            // use Constructor C with is_gen = true and is_async_func = true
-            v.storage = std::make_shared<JsFunction>(call, true, true, name);
-
-            auto proto = make_object({});
-            proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
-            v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
-
-            return v;
-        }
-        static AnyValue make_symbol(const std::string &description = "") noexcept
-        {
-            AnyValue v;
-            v.storage = std::make_shared<JsSymbol>(description);
-            return v;
-        }
-        static AnyValue make_promise(const JsPromise &promise) noexcept
-        {
-            AnyValue v;
-            v.storage = std::make_shared<JsPromise>(promise);
-            return v;
-        }
-        static AnyValue make_data_descriptor(const AnyValue &value, bool writable, bool enumerable, bool configurable) noexcept
-        {
-            AnyValue v;
-            v.storage = std::make_shared<DataDescriptor>(std::make_shared<AnyValue>(value), writable, enumerable, configurable);
-            return v;
-        }
+            return AnyValue(b);
+        }
+
+        static AnyValue make_string(const std::string &raw_s) noexcept;
+        static AnyValue make_object(std::initializer_list<std::pair<std::string, AnyValue>> props) noexcept;
+        static AnyValue make_object(const std::map<std::string, AnyValue> &props) noexcept;
+        static AnyValue make_object_with_proto(std::initializer_list<std::pair<std::string, AnyValue>> props, AnyValue proto) noexcept;
+        static AnyValue make_object_with_proto(const std::map<std::string, AnyValue> &props, AnyValue proto) noexcept;
+        static AnyValue make_array(std::span<const AnyValue> dense) noexcept;
+        static AnyValue make_array(const std::vector<AnyValue> &dense) noexcept;
+        static AnyValue make_array(std::vector<AnyValue> &&dense) noexcept;
+        static AnyValue make_array_with_proto(std::span<const AnyValue> dense, AnyValue proto) noexcept;
+        static AnyValue make_array_with_proto(const std::vector<AnyValue> &dense, AnyValue proto) noexcept;
+        static AnyValue make_function(const JsFunctionCallable &call, const std::optional<std::string> &name = std::nullopt, bool is_constructor = true) noexcept;
+        static AnyValue make_class(const JsFunctionCallable &call, const std::optional<std::string> &name = std::nullopt) noexcept;
+        static AnyValue make_generator(const JsFunctionCallable &call, const std::optional<std::string> &name = std::nullopt) noexcept;
+        static AnyValue make_async_function(const JsFunctionCallable &call, const std::optional<std::string> &name = std::nullopt) noexcept;
+        static AnyValue make_async_generator(const JsFunctionCallable &call, const std::optional<std::string> &name = std::nullopt) noexcept;
+        static AnyValue make_symbol(const std::string &description = "") noexcept;
+        static AnyValue make_promise(const JsPromise &promise) noexcept;
+        static AnyValue make_data_descriptor(AnyValue value, bool writable, bool enumerable, bool configurable) noexcept;
         static AnyValue make_accessor_descriptor(const std::optional<std::function<AnyValue(const AnyValue &, std::span<const AnyValue>)>> &get,
                                                  const std::optional<std::function<AnyValue(const AnyValue &, std::span<const AnyValue>)>> &set,
                                                  bool enumerable,
-                                                 bool configurable) noexcept
-        {
-            AnyValue v;
-            v.storage = std::make_shared<AccessorDescriptor>(get, set, enumerable, configurable);
-            return v;
-        }
+                                                 bool configurable) noexcept;
 
-        static AnyValue from_symbol(std::shared_ptr<JsSymbol> sym) noexcept
-        {
-            AnyValue v;
-            v.storage = std::move(sym);
-            return v;
-        }
-        static AnyValue from_string(std::shared_ptr<JsString> str) noexcept
-        {
-            AnyValue v;
-            v.storage = std::move(str);
-            return v;
-        }
-        static AnyValue from_iterator(JsIterator<AnyValue> &&iterator) noexcept
-        {
-            AnyValue v;
-            v.storage = std::make_shared<JsIterator<AnyValue>>(std::move(iterator));
-            return v;
-        }
-        static AnyValue from_iterator_ref(JsIterator<AnyValue> *iterator) noexcept
-        {
-            AnyValue v;
-            v.storage = std::shared_ptr<JsIterator<AnyValue>>(iterator, [](JsIterator<AnyValue> *) {});
-            return v;
-        }
-        static AnyValue from_async_iterator(JsAsyncIterator<AnyValue> &&iterator) noexcept
-        {
+        static AnyValue from_symbol(JsSymbol *sym) noexcept;
+        static AnyValue from_string(JsString *str) noexcept;
+        static AnyValue from_iterator(JsIterator<AnyValue> &&iterator) noexcept;
+        static AnyValue from_iterator_ref(JsIterator<AnyValue> *iterator) noexcept;
+        static AnyValue from_async_iterator(JsAsyncIterator<AnyValue> &&iterator) noexcept;
+
+        // internal factory for wrapping raw heap object pointers
+        static AnyValue from_ptr(HeapObject* ptr) noexcept {
             AnyValue v;
-            v.storage = std::make_shared<JsAsyncIterator<AnyValue>>(std::move(iterator));
+            v.storage = TAG_POINTER | reinterpret_cast<uint64_t>(ptr);
+            ptr->ref();
             return v;
         }
 
-        // PROPERTY RESOLUTION HELPERS ---------------------------------------
-        static AnyValue resolve_property_for_read(const AnyValue &val, const AnyValue &thisVal, const std::string &propName) noexcept
-        {
-            switch (val.get_type())
-            {
-            case JsType::DataDescriptor:
-            {
-                return *(val.as_data_descriptor()->value);
-            }
-            case JsType::AccessorDescriptor:
-            {
-                const auto &accessor = val.as_accessor_descriptor();
-                if (accessor->get.has_value())
-                    return accessor->get.value()(thisVal, std::span<const AnyValue>{});
-                else
-                {
-                    static AnyValue undefined = AnyValue{};
-                    return undefined;
-                }
-            }
-            default:
-            {
-                return val;
-            }
-            }
-        }
-        static AnyValue resolve_property_for_write(AnyValue &val, const AnyValue &thisVal, const AnyValue &new_val, const std::string &propName)
-        {
-            switch (val.get_type())
-            {
-            case JsType::DataDescriptor:
-            {
-                const auto &data = val.as_data_descriptor();
-                if (data->writable)
-                {
-                    *(data->value) = new_val;
-                    return new_val;
-                }
-                else
-                {
-                    throw Exception::make_exception("Cannot assign to read only property '" + propName + "' of object '#<Object>'", "TypeError");
-                }
-            }
-            case JsType::AccessorDescriptor:
-            {
-                const auto &accessor = val.as_accessor_descriptor();
-                if (accessor->set.has_value())
-                {
-                    const AnyValue args[] = {new_val};
-                    accessor->set.value()(thisVal, args);
-                    return new_val;
-                }
-                else
-                {
-                    throw Exception::make_exception("Cannot set property of #<Object> which has only a getter", "TypeError");
-                }
-            }
-            default:
-            {
-                val = new_val;
-                return new_val;
-            }
-            }
-        }
+        static AnyValue resolve_property_for_read(const AnyValue &val, const AnyValue &thisVal, const std::string &propName) noexcept;
+        static AnyValue resolve_property_for_write(AnyValue &val, const AnyValue &thisVal, const AnyValue &new_val, const std::string &propName);
 
         // TYPE CHECKERS AND ACCESSORS ---------------------------------------
-        JsType get_type() const noexcept { return static_cast<JsType>(storage.index()); }
-        bool is_number() const noexcept { return storage.index() == 4; }
-        bool is_string() const noexcept { return storage.index() == 5; }
-        bool is_object() const noexcept { return storage.index() == 6; }
-        bool is_array() const noexcept { return storage.index() == 7; }
-        bool is_function() const noexcept { return storage.index() == 8; }
-        bool is_iterator() const noexcept { return storage.index() == 9; }
-        bool is_boolean() const noexcept { return storage.index() == 3; }
-        bool is_symbol() const noexcept { return storage.index() == 10; }
-        bool is_promise() const noexcept { return storage.index() == 11; }
-        bool is_null() const noexcept { return storage.index() == 1; }
-        bool is_undefined() const noexcept { return storage.index() == 0; }
-        bool is_uninitialized() const noexcept { return storage.index() == 2; }
-        bool is_data_descriptor() const noexcept { return storage.index() == 12; }
-        bool is_accessor_descriptor() const noexcept { return storage.index() == 13; }
-        bool is_async_iterator() const noexcept { return storage.index() == 14; }
-        bool is_generator() const noexcept { return is_function() && as_function()->is_generator; }
-
-        // --- TYPE CASTERS
+        JsType get_type() const noexcept {
+            if (is_number()) return JsType::Number;
+            if (is_heap_object()) return get_ptr()->get_heap_type();
+            if (is_boolean()) return JsType::Boolean;
+            if (is_undefined()) return JsType::Undefined;
+            if (is_null()) return JsType::Null;
+            if (is_uninitialized()) return JsType::Uninitialized;
+            return JsType::Undefined;
+        }
+
+        inline bool is_number() const noexcept { return storage < TAG_BASE; }
+        inline bool is_heap_object() const noexcept { return has_tag(TAG_POINTER); }
+        inline bool is_string() const noexcept { return is_heap_object() && get_ptr()->get_heap_type() == JsType::String; }
+        inline bool is_object() const noexcept { return is_heap_object() && get_ptr()->get_heap_type() == JsType::Object; }
+        inline bool is_array() const noexcept { return is_heap_object() && get_ptr()->get_heap_type() == JsType::Array; }
+        inline bool is_function() const noexcept { return is_heap_object() && get_ptr()->get_heap_type() == JsType::Function; }
+        inline bool is_iterator() const noexcept { return is_heap_object() && get_ptr()->get_heap_type() == JsType::Iterator; }
+        inline bool is_boolean() const noexcept { return has_tag(TAG_BOOLEAN); }
+        inline bool is_symbol() const noexcept { return is_heap_object() && get_ptr()->get_heap_type() == JsType::Symbol; }
+        inline bool is_promise() const noexcept { return is_heap_object() && get_ptr()->get_heap_type() == JsType::Promise; }
+        inline bool is_null() const noexcept { return storage == (TAG_SPECIAL | VAL_NULL); }
+        inline bool is_undefined() const noexcept { return storage == (TAG_SPECIAL | VAL_UNDEFINED); }
+        inline bool is_uninitialized() const noexcept { return storage == (TAG_SPECIAL | VAL_UNINITIALIZED); }
+        inline bool is_data_descriptor() const noexcept { return is_heap_object() && get_ptr()->get_heap_type() == JsType::DataDescriptor; }
+        inline bool is_accessor_descriptor() const noexcept { return is_heap_object() && get_ptr()->get_heap_type() == JsType::AccessorDescriptor; }
+        inline bool is_async_iterator() const noexcept { return is_heap_object() && get_ptr()->get_heap_type() == JsType::AsyncIterator; }
+        
+        JsString* as_string() const noexcept;
+        JsObject* as_object() const noexcept;
+        JsArray* as_array() const noexcept;
+        JsFunction* as_function() const noexcept;
+        JsSymbol* as_symbol() const noexcept;
+        JsPromise* as_promise() const noexcept;
+        JsIterator<AnyValue>* as_iterator() const noexcept;
+        JsAsyncIterator<AnyValue>* as_async_iterator() const noexcept;
+        DataDescriptor* as_data_descriptor() const noexcept;
+        AccessorDescriptor* as_accessor_descriptor() const noexcept;
+        
+        bool is_generator() const noexcept;
+
         double as_double() const noexcept
         {
-            return std::get<double>(storage);
+            double d;
+            std::memcpy(&d, &storage, 8);
+            return d;
         }
         bool as_boolean() const noexcept
         {
-            return std::get<bool>(storage);
-        }
-        JsString *as_string() const noexcept
-        {
-            return std::get<std::shared_ptr<JsString>>(storage).get();
-        }
-        JsObject *as_object() const noexcept
-        {
-            return std::get<std::shared_ptr<JsObject>>(storage).get();
-        }
-        JsArray *as_array() const noexcept
-        {
-            return std::get<std::shared_ptr<JsArray>>(storage).get();
-        }
-        JsFunction *as_function() const noexcept
-        {
-            return std::get<std::shared_ptr<JsFunction>>(storage).get();
-        }
-        JsSymbol *as_symbol() const noexcept
-        {
-            return std::get<std::shared_ptr<JsSymbol>>(storage).get();
-        }
-        JsPromise *as_promise() const noexcept
-        {
-            return std::get<std::shared_ptr<JsPromise>>(storage).get();
-        }
-        std::shared_ptr<JsIterator<AnyValue>> as_iterator() const
-        {
-            return std::get<std::shared_ptr<JsIterator<AnyValue>>>(storage);
-        }
-        std::shared_ptr<JsAsyncIterator<AnyValue>> as_async_iterator() const
-        {
-            return std::get<std::shared_ptr<JsAsyncIterator<AnyValue>>>(storage);
-        }
-        DataDescriptor *as_data_descriptor() const noexcept
-        {
-            return std::get<std::shared_ptr<DataDescriptor>>(storage).get();
-        }
-        AccessorDescriptor *as_accessor_descriptor() const noexcept
-        {
-            return std::get<std::shared_ptr<AccessorDescriptor>>(storage).get();
+            return static_cast<bool>(storage & 1);
         }
 
-        // --- CO_AWAIT Operator ---
         auto operator co_await() const;
 
-        // --- PROPERTY ACCESS OPERATORS
         bool has_property(const std::string &key) const;
+        bool has_property(const char* key) const { return has_property(std::string(key)); }
+
         AnyValue get_own_property(const std::string &key) const;
+        AnyValue get_own_property(const char* key) const { return get_own_property(std::string(key)); }
         AnyValue get_own_property(uint32_t idx) const;
+        AnyValue get_own_property(int idx) const { return get_own_property(static_cast<uint32_t>(idx)); }
         AnyValue get_own_property(const AnyValue &key) const;
-        // for getting values with a specific receiver (used in inheritance chains)
+
         AnyValue get_property_with_receiver(const std::string &key, const AnyValue &receiver) const;
-        // for setting values
+        AnyValue get_property_with_receiver(const char* key, const AnyValue &receiver) const { return get_property_with_receiver(std::string(key), receiver); }
+
         AnyValue set_own_property(const std::string &key, const AnyValue &value) const;
+        AnyValue set_own_property(const char* key, const AnyValue &value) const { return set_own_property(std::string(key), value); }
         AnyValue set_own_property(uint32_t idx, const AnyValue &value) const;
+        AnyValue set_own_property(int idx, const AnyValue &value) const { return set_own_property(static_cast<uint32_t>(idx), value); }
         AnyValue set_own_property(const AnyValue &key, const AnyValue &value) const;
-        // for calling the gotten the property
+
         AnyValue call_own_property(const std::string &key, std::span<const AnyValue> args) const;
+        AnyValue call_own_property(const char* key, std::span<const AnyValue> args) const { return call_own_property(std::string(key), args); }
         AnyValue call_own_property(uint32_t idx, std::span<const AnyValue> args) const;
+        AnyValue call_own_property(int idx, std::span<const AnyValue> args) const { return call_own_property(static_cast<uint32_t>(idx), args); }
         AnyValue call_own_property(const AnyValue &key, std::span<const AnyValue> args) const;
 
-        // --- DEFINERS (Object.defineProperty semantics)
         void define_data_property(const std::string &key, const AnyValue &value);
+        void define_data_property(const char* key, const AnyValue &value) { define_data_property(std::string(key), value); }
         void define_data_property(const AnyValue &key, const AnyValue &value);
         void define_data_property(const std::string &key, const AnyValue &value, bool writable, bool enumerable, bool configurable);
+        void define_data_property(const char* key, const AnyValue &value, bool writable, bool enumerable, bool configurable) { define_data_property(std::string(key), value, writable, enumerable, configurable); }
+
         void define_getter(const std::string &key, const AnyValue &getter);
+        void define_getter(const char* key, const AnyValue &getter) { define_getter(std::string(key), getter); }
         void define_getter(const AnyValue &key, const AnyValue &getter);
+
         void define_setter(const std::string &key, const AnyValue &setter);
+        void define_setter(const char* key, const AnyValue &setter) { define_setter(std::string(key), setter); }
         void define_setter(const AnyValue &key, const AnyValue &setter);
 
-        // --- HELPERS
-        const AnyValue call(const AnyValue &thisVal, std::span<const AnyValue> args, const std::optional<std::string> &expr) const;
-        const AnyValue construct(std::span<const AnyValue> args, const std::optional<std::string> &name) const;
+        AnyValue call(const AnyValue &thisVal, std::span<const AnyValue> args, const std::optional<std::string> &expr = std::nullopt) const;
+        AnyValue construct(std::span<const AnyValue> args, const std::optional<std::string> &name = std::nullopt) const;
         void set_prototype(const AnyValue &proto);
         std::string to_std_string() const;
+
+        inline uint64_t get_storage() const noexcept { return storage; }
+        inline void* get_raw_ptr() const noexcept { return reinterpret_cast<void*>(storage & PAYLOAD_MASK); }
     };
 
-    // Awaiter for AnyValue
     struct AnyValueAwaiter
     {
-        AnyValue value; // Held by value
+        AnyValue value;
         bool await_ready();
         void await_suspend(std::coroutine_handle<> h);
         AnyValue await_resume();
     };
 
-    // Inline implementation of operator co_await
     inline auto AnyValue::operator co_await() const
     {
         return AnyValueAwaiter{*this};
     }
 
-    // Global Constants for Optimization
     namespace Constants
     {
         inline const AnyValue UNINITIALIZED = AnyValue::make_uninitialized();
@@ -534,4 +328,4 @@ namespace jspp
         inline const AnyValue ZERO = AnyValue::make_number(0.0);
         inline const AnyValue ONE = AnyValue::make_number(1.0);
     }
-}
+}