@ugo-studio/jspp 0.1.3 → 0.1.4

package/src/prelude/library/console.hpp

@@ -5,8 +5,8 @@
 #include "values/non_values.hpp"
 #include "values/object.hpp"
 #include "values/function.hpp"
-#include "operators.hpp"
-#include "log_string.hpp"
+#include "utils/operators.hpp"
+#include "utils/log_any_value/log_any_value.hpp"
 
 #include <cmath>
 #include <sstream>
@@ -14,39 +14,39 @@
 
 static std::map<std::string, std::chrono::steady_clock::time_point> timers = {};
 
-auto logFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
+auto logFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args)
                                            {
                                                for (size_t i = 0; i < args.size(); ++i)
                                                {
-                                                   std::cout << jspp::LogString::to_log_string(args[i]);
+                                                   std::cout << jspp::LogAnyValue::to_log_string(args[i]);
                                                    if (i < args.size() - 1)
                                                        std::cout << " ";
                                                }
-                                               std::cout << "\n";
+                                               std::cout << "\n" << std::flush;
                                                return jspp::AnyValue::make_undefined(); }, "log");
-auto warnFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
+auto warnFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args)
                                             {
                                                 std::cerr << "\033[33m";
                                                 for (size_t i = 0; i < args.size(); ++i)
                                                 {
-                                                    std::cout << jspp::LogString::to_log_string(args[i]);
+                                                    std::cout << jspp::LogAnyValue::to_log_string(args[i]);
                                                     if (i < args.size() - 1)
                                                         std::cout << " ";
                                                 }
-                                                std::cerr << "\033[0m" << "\n"; // reset
+                                                std::cerr << "\033[0m" << "\n" << std::flush; // reset
                                                 return jspp::AnyValue::make_undefined(); }, "warn");
-auto errorFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
+auto errorFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args)
                                              {
                                                  std::cerr << "\033[31m";
                                                  for (size_t i = 0; i < args.size(); ++i)
                                                  {
-                                                     std::cout << jspp::LogString::to_log_string(args[i]);
+                                                     std::cout << jspp::LogAnyValue::to_log_string(args[i]);
                                                      if (i < args.size() - 1)
                                                          std::cout << " ";
                                                  }
-                                                 std::cerr << "\033[0m" << "\n"; // reset
+                                                 std::cerr << "\033[0m" << "\n" << std::flush; // reset
                                                  return jspp::AnyValue::make_undefined(); }, "error");
-auto timeFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
+auto timeFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args)
                                             {
                                                 auto start = std::chrono::steady_clock::now(); // capture immediately
                                                 auto key_str = args.size() > 0 ? args[0].to_std_string() : "default";
@@ -83,7 +83,7 @@ static auto format_duration = [](double ms) -> std::string
     return ss.str();
 };
 
-auto timeEndFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
+auto timeEndFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args)
                                                {
                                                    auto end = std::chrono::steady_clock::now(); // capture immediately
                                                    auto key_str = args.size() > 0 ? args[0].to_std_string() : "default";

package/src/prelude/library/error.hpp

@@ -0,0 +1,111 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+
+// Declare Error variable
+inline jspp::AnyValue Error;
+
+// Constructor logic
+inline auto errorConstructor = [](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args) -> jspp::AnyValue
+{
+    // Access global Error to get prototype
+    jspp::AnyValue proto = Error.get_own_property("prototype");
+
+    jspp::AnyValue target = thisVal;
+    bool is_construct_call = false;
+
+    if (target.is_object())
+    {
+        auto obj = target.as_object();
+        if (obj->proto && (*obj->proto).is_strictly_equal_to_primitive(proto))
+        {
+            is_construct_call = true;
+        }
+    }
+
+    if (!is_construct_call)
+    {
+        target = jspp::AnyValue::make_object_with_proto({}, proto);
+    }
+
+    std::string message = "";
+    if (!args.empty() && !args[0].is_undefined())
+    {
+        message = args[0].to_std_string();
+    }
+
+    target.define_data_property("message", jspp::AnyValue::make_string(message), true, false, true);
+    target.define_data_property("name", jspp::AnyValue::make_string("Error"), true, false, true);
+    target.define_data_property("stack", jspp::AnyValue::make_string("Error: " + message + "\n    at <unknown>"), true, false, true);
+
+    if (args.size() > 1 && args[1].is_object())
+    {
+        jspp::AnyValue cause = args[1].get_own_property("cause");
+        if (!cause.is_undefined())
+        {
+            target.define_data_property("cause", cause, true, false, true);
+        }
+    }
+
+    return target;
+};
+
+// Static Error.isError(val) implementation
+inline auto isErrorFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args) -> jspp::AnyValue
+                                                      {
+    if (args.empty()) return jspp::AnyValue::make_boolean(false);
+    
+    jspp::AnyValue val = args[0];
+    if (!val.is_object()) return jspp::AnyValue::make_boolean(false);
+    
+    // Check if it inherits from Error.prototype
+    // This is essentially 'instanceof Error'
+    jspp::AnyValue proto = Error.get_own_property("prototype");
+    
+    // Walk prototype chain
+    if (val.is_object()) {
+        auto current = val.as_object()->proto;
+        while (current && !(*current).is_null()) {
+             if ((*current).is_strictly_equal_to_primitive(proto)) return jspp::AnyValue::make_boolean(true);
+             if ((*current).is_object()) current = (*current).as_object()->proto;
+             else break;
+        }
+    }
+    
+    return jspp::AnyValue::make_boolean(false); }, "isError");
+
+// toString method for Error.prototype
+inline auto errorToStringFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args) -> jspp::AnyValue
+                                                            {
+    std::string name = "Error";
+    std::string msg = "";
+    
+    jspp::AnyValue n = thisVal.get_own_property("name");
+    if (!n.is_undefined()) name = n.to_std_string();
+    
+    jspp::AnyValue m = thisVal.get_own_property("message");
+    if (!m.is_undefined()) msg = m.to_std_string();
+    
+    if (name.empty() && msg.empty()) return jspp::AnyValue::make_string("Error");
+    if (name.empty()) return jspp::AnyValue::make_string(msg);
+    if (msg.empty()) return jspp::AnyValue::make_string(name);
+    
+    return jspp::AnyValue::make_string(name + ": " + msg); }, "toString");
+
+// Initialize Error class and its prototype
+struct ErrorInit
+{
+    ErrorInit()
+    {
+        // Initialize Error class
+        Error = jspp::AnyValue::make_class(errorConstructor, "Error");
+
+        // Define Error.prototype.toString
+        auto proto = Error.get_own_property("prototype");
+        proto.define_data_property("toString", errorToStringFn, true, false, true);
+
+        // Define static Error.isError
+        Error.define_data_property("isError", isErrorFn,true ,false,true);
+    }
+} errorInit;

package/src/prelude/library/global.hpp

@@ -1,10 +1,21 @@
 #pragma once
 
 #include "types.hpp"
-#include "object.hpp"
-#include "console.hpp"
+#include "values/non_values.hpp"
+#include "values/object.hpp"
+#include "values/function.hpp"
+#include "utils/operators.hpp"
 
-inline auto global = jspp::Object::make_object({
+#include "library/promise.hpp"
+#include "library/timer.hpp"
+
+inline auto global = jspp::AnyValue::make_object({
     {"console", console},
+    {"performance", performance},
+    {"Error", Error},
+    {"Promise", Promise},
+    {"setTimeout", setTimeout},
+    {"clearTimeout", clearTimeout},
+    {"setInterval", setInterval},
+    {"clearInterval", clearInterval},
 });
-inline auto globalThis = global;

package/src/prelude/library/performance.hpp

@@ -5,7 +5,7 @@
 #include "values/non_values.hpp"
 #include "values/object.hpp"
 #include "values/function.hpp"
-#include "operators.hpp"
+#include "utils/operators.hpp"
 
 inline auto performance = jspp::AnyValue::make_object({
     {"now",
@@ -13,7 +13,7 @@ inline auto performance = jspp::AnyValue::make_object({
          // [C++14 Feature] Generalized Lambda Capture
          // We initialize 'startTime' RIGHT HERE inside the [].
          // It acts like a private variable stored inside this specific function.
-         [startTime = std::chrono::steady_clock::now()](const std::vector<jspp::AnyValue> &)
+         [startTime = std::chrono::steady_clock::now()](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &)
          {
              // We calculate the diff against the captured startTime
              std::chrono::duration<double, std::milli> duration =

package/src/prelude/library/promise.hpp

@@ -0,0 +1,121 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/promise.hpp"
+#include "any_value.hpp"
+#include "exception.hpp"
+
+inline auto Promise = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+    if (args.empty() || !args[0].is_function()) {
+        throw jspp::Exception::make_exception("Promise resolver undefined is not a function", "TypeError");
+    }
+    auto executor = args[0].as_function();
+
+    jspp::JsPromise promise;
+    auto state = promise.state; // Share state
+
+    // resolve function
+    auto resolveFn = jspp::AnyValue::make_function([state](const jspp::AnyValue&, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+        jspp::JsPromise p; p.state = state;
+        p.resolve(args.empty() ? jspp::AnyValue::make_undefined() : args[0]);
+        return jspp::AnyValue::make_undefined();
+    }, "resolve");
+
+    // reject function
+    auto rejectFn = jspp::AnyValue::make_function([state](const jspp::AnyValue&, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+        jspp::JsPromise p; p.state = state;
+        p.reject(args.empty() ? jspp::AnyValue::make_undefined() : args[0]);
+        return jspp::AnyValue::make_undefined();
+    }, "reject");
+
+    try {
+        executor->call(jspp::AnyValue::make_undefined(), {resolveFn, rejectFn});
+    } catch (const jspp::Exception& e) {
+        promise.reject(*e.data);
+    } catch (...) {
+        promise.reject(jspp::AnyValue::make_string("Unknown error during Promise execution"));
+    }
+
+    return jspp::AnyValue::make_promise(promise);
+
+}, "Promise");
+
+struct PromiseInit {
+    PromiseInit() {
+        // Promise.resolve(value)
+        Promise.define_data_property("resolve", jspp::AnyValue::make_function([](const jspp::AnyValue&, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+            jspp::JsPromise p;
+            p.resolve(args.empty() ? jspp::AnyValue::make_undefined() : args[0]);
+            return jspp::AnyValue::make_promise(p);
+        }, "resolve"));
+
+        // Promise.reject(reason)
+        Promise.define_data_property("reject", jspp::AnyValue::make_function([](const jspp::AnyValue&, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+            jspp::JsPromise p;
+            p.reject(args.empty() ? jspp::AnyValue::make_undefined() : args[0]);
+            return jspp::AnyValue::make_promise(p);
+        }, "reject"));
+        
+        // Promise.all(iterable)
+        Promise.define_data_property("all", jspp::AnyValue::make_function([](const jspp::AnyValue&, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+             // Basic implementation for arrays
+             if (args.empty() || !args[0].is_array()) {
+                  // If not array, reject? Or treat as non-iterable?
+                  // Should throw TypeError if not iterable. For now assume array.
+                  // If empty array, return resolved empty array.
+                  // TODO: Strict iterable check
+             }
+             
+             // Handle non-array iterable or empty args
+             if (args.empty() || !args[0].is_array()) {
+                 jspp::JsPromise p; p.reject(jspp::AnyValue::make_string("Promise.all argument must be an array"));
+                 return jspp::AnyValue::make_promise(p);
+             }
+
+             auto arr = args[0].as_array();
+             size_t len = arr->length;
+             if (len == 0) {
+                 jspp::JsPromise p; p.resolve(jspp::AnyValue::make_array({}));
+                 return jspp::AnyValue::make_promise(p);
+             }
+
+             jspp::JsPromise masterPromise;
+             auto masterState = masterPromise.state;
+             
+             auto results = std::make_shared<std::vector<std::optional<jspp::AnyValue>>>(len);
+             auto count = std::make_shared<size_t>(len);
+             
+             // Check if already rejected to avoid further processing
+             auto rejected = std::make_shared<bool>(false);
+
+             for (size_t i = 0; i < len; ++i) {
+                 jspp::AnyValue item = arr->get_property(static_cast<uint32_t>(i));
+                 
+                 auto handleResult = [masterState, results, count, i, rejected](jspp::AnyValue res) {
+                      if (*rejected) return;
+                      (*results)[i] = res;
+                      (*count)--;
+                      if (*count == 0) {
+                          jspp::JsPromise p; p.state = masterState;
+                          p.resolve(jspp::AnyValue::make_array(*results)); 
+                      }
+                 };
+                 
+                 auto handleReject = [masterState, rejected](jspp::AnyValue reason) {
+                      if (*rejected) return;
+                      *rejected = true;
+                      jspp::JsPromise p; p.state = masterState;
+                      p.reject(reason);
+                 };
+
+                 if (item.is_promise()) {
+                     item.as_promise()->then(handleResult, handleReject);
+                 } else {
+                     handleResult(item);
+                 }
+             }
+             
+             return jspp::AnyValue::make_promise(masterPromise);
+        }, "all"));
+    }
+} promiseInit;

package/src/prelude/library/symbol.hpp

@@ -1,20 +1,19 @@
 #pragma once
 
 #include "types.hpp"
-#include "well_known_symbols.hpp"
+#include "utils/well_known_symbols.hpp"
 
 #include "values/object.hpp"
 #include "any_value.hpp"
 
 inline auto Symbol = jspp::AnyValue::make_object({
     {"iterator", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::iterator)},
-    {"toString", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::toString)},
 });
 
 // #pragma once
 
 // #include "types.hpp"
-// #include "well_known_symbols.hpp"
+// #include "utils/well_known_symbols.hpp"
 // #include "values/object.hpp"
 // #include "any_value.hpp"
 
@@ -42,7 +41,7 @@ inline auto Symbol = jspp::AnyValue::make_object({
 // // Implementation of Symbol.keyFor(sym)
 // inline auto keyForFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
 //     if (args.empty() || !args[0].is_symbol()) {
-//         throw jspp::RuntimeError::make_error("Symbol.keyFor requires a symbol argument", "TypeError");
+//         throw jspp::Exception::make_exception("Symbol.keyFor requires a symbol argument", "TypeError");
 //     }
 
 //     jspp::JsSymbol* sym = args[0].as_symbol();

package/src/prelude/library/timer.hpp

@@ -0,0 +1,92 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "scheduler.hpp"
+#include "values/function.hpp"
+#include "exception.hpp"
+
+// setTimeout(callback, delay, ...args)
+inline auto setTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+    if (args.empty() || !args[0].is_function()) {
+        throw jspp::Exception::make_exception("Callback must be a function", "TypeError");
+    }
+    
+    auto callback = args[0];
+    double delay = 0;
+    if (args.size() > 1 && args[1].is_number()) {
+        delay = args[1].as_double();
+    }
+    
+    // Capture arguments
+    std::vector<jspp::AnyValue> callArgs;
+    for (size_t i = 2; i < args.size(); ++i) {
+        callArgs.push_back(args[i]);
+    }
+
+    auto task = [callback, callArgs]() {
+         try {
+             callback.as_function()->call(jspp::AnyValue::make_undefined(), callArgs);
+         } catch (const jspp::Exception& e) {
+             std::cerr << "Uncaught exception in setTimeout: " << e.what() << "\n";
+         } catch (const std::exception& e) {
+             std::cerr << "Uncaught exception in setTimeout: " << e.what() << "\n";
+         } catch (...) {
+             std::cerr << "Uncaught unknown exception in setTimeout\n";
+         }
+    };
+
+    size_t id = jspp::Scheduler::instance().set_timeout(task, static_cast<size_t>(delay));
+    return jspp::AnyValue::make_number(static_cast<double>(id));
+}, "setTimeout");
+
+// clearTimeout(id)
+inline auto clearTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+    if (!args.empty() && args[0].is_number()) {
+        size_t id = static_cast<size_t>(args[0].as_double());
+        jspp::Scheduler::instance().clear_timer(id);
+    }
+    return jspp::AnyValue::make_undefined();
+}, "clearTimeout");
+
+// setInterval(callback, delay, ...args)
+inline auto setInterval = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+    if (args.empty() || !args[0].is_function()) {
+        throw jspp::Exception::make_exception("Callback must be a function", "TypeError");
+    }
+    
+    auto callback = args[0];
+    double delay = 0;
+    if (args.size() > 1 && args[1].is_number()) {
+        delay = args[1].as_double();
+    }
+    
+    std::vector<jspp::AnyValue> callArgs;
+    for (size_t i = 2; i < args.size(); ++i) {
+        callArgs.push_back(args[i]);
+    }
+
+    auto task = [callback, callArgs]() {
+         try {
+             callback.as_function()->call(jspp::AnyValue::make_undefined(), callArgs);
+         } catch (const jspp::Exception& e) {
+             std::cerr << "Uncaught exception in setInterval: " << e.what() << "\n";
+         } catch (const std::exception& e) {
+             std::cerr << "Uncaught exception in setInterval: " << e.what() << "\n";
+         } catch (...) {
+             std::cerr << "Uncaught unknown exception in setInterval\n";
+         }
+    };
+
+    size_t id = jspp::Scheduler::instance().set_interval(task, static_cast<size_t>(delay));
+    return jspp::AnyValue::make_number(static_cast<double>(id));
+}, "setInterval");
+
+// clearInterval(id)
+inline auto clearInterval = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+    if (!args.empty() && args[0].is_number()) {
+        size_t id = static_cast<size_t>(args[0].as_double());
+        jspp::Scheduler::instance().clear_timer(id);
+    }
+    return jspp::AnyValue::make_undefined();
+}, "clearInterval");

package/src/prelude/scheduler.hpp

@@ -0,0 +1,145 @@
+#pragma once
+#include <deque>
+#include <functional>
+#include <chrono>
+#include <queue>
+#include <unordered_set>
+#include <vector>
+#include <thread>
+#include <iostream>
+
+namespace jspp {
+    class Scheduler {
+    public:
+        using Task = std::function<void()>;
+        using TimePoint = std::chrono::steady_clock::time_point;
+        
+        struct Timer {
+            size_t id;
+            TimePoint next_run;
+            std::chrono::milliseconds interval; // 0 if not repeating
+            Task task;
+            
+            // Min-heap priority queue (smallest time at top)
+            bool operator>(const Timer& other) const {
+                return next_run > other.next_run;
+            }
+        };
+
+        static Scheduler& instance() {
+            static Scheduler s;
+            return s;
+        }
+
+        void enqueue(Task task) {
+            tasks.push_back(std::move(task));
+        }
+
+        size_t set_timeout(Task task, size_t delay_ms) {
+            return schedule_timer(std::move(task), delay_ms, false);
+        }
+
+        size_t set_interval(Task task, size_t delay_ms) {
+             return schedule_timer(std::move(task), delay_ms, true);
+        }
+        
+        void clear_timer(size_t id) {
+            cancelled_timers.insert(id);
+        }
+
+        void run() {
+            while (true) {
+                bool has_work = false;
+
+                // 1. Process all immediate tasks (microtask/task queue)
+                while (!tasks.empty()) {
+                    Task task = tasks.front();
+                    tasks.pop_front();
+                    task();
+                    has_work = true;
+                }
+
+                // 2. Process timers
+                auto now = std::chrono::steady_clock::now();
+                while (!timers.empty()) {
+                    // Peek top
+                    const auto& top = timers.top();
+                    
+                    // Cleanup cancelled timers lazily
+                    if (cancelled_timers.count(top.id)) {
+                        cancelled_timers.erase(top.id);
+                        timers.pop();
+                        continue;
+                    }
+                    
+                    if (top.next_run <= now) {
+                        // Timer is ready
+                        Timer t = top;
+                        timers.pop();
+                        
+                        // Execute task
+                        t.task();
+                        has_work = true;
+                        
+                        // Reschedule if interval and not cancelled during execution
+                        if (t.interval.count() > 0 && cancelled_timers.find(t.id) == cancelled_timers.end()) {
+                            // Drift-safe(ish) scheduling: run next interval relative to now
+                            // Note: JS allows drift.
+                            t.next_run = std::chrono::steady_clock::now() + t.interval;
+                            timers.push(t);
+                        }
+                    } else {
+                        break; // Next timer is in the future
+                    }
+                }
+
+                // 3. Exit or Wait
+                if (!has_work) {
+                    if (tasks.empty() && timers.empty()) {
+                        break; // No pending work, exit event loop
+                    }
+                    
+                    if (!timers.empty()) {
+                        auto next_time = timers.top().next_run;
+                        std::this_thread::sleep_until(next_time);
+                    }
+                }
+            }
+        }
+        
+        bool has_tasks() const {
+            return !tasks.empty() || !timers.empty();
+        }
+
+    private:
+        std::deque<Task> tasks;
+        std::priority_queue<Timer, std::vector<Timer>, std::greater<Timer>> timers;
+        std::unordered_set<size_t> cancelled_timers;
+        size_t next_timer_id = 1;
+        const size_t MAX_TIMER_ID = 2147483647; // 2^31 - 1
+
+        size_t schedule_timer(Task task, size_t delay_ms, bool repeat) {
+            size_t id = next_timer_id++;
+            if (next_timer_id > MAX_TIMER_ID) {
+                next_timer_id = 1;
+            }
+            
+            // If we wrap around, ensure we don't accidentally treat this new ID as cancelled
+            // (in case an old timer with this ID is still lingering in the 'cancelled' set)
+            if (cancelled_timers.count(id)) {
+                cancelled_timers.erase(id);
+            }
+            
+            auto now = std::chrono::steady_clock::now();
+            
+            Timer t;
+            t.id = id;
+            t.next_run = now + std::chrono::milliseconds(delay_ms);
+            t.interval = repeat ? std::chrono::milliseconds(delay_ms) : std::chrono::milliseconds(0);
+            t.task = std::move(task);
+            
+            timers.push(t);
+            return id;
+        }
+    };
+}

package/src/prelude/types.hpp

@@ -26,6 +26,7 @@ namespace jspp
     struct JsObject;        // can set property
     struct JsArray;         // can set property
     struct JsFunction;      // can set property
+    struct JsPromise;       // can set property
     struct JsSymbol;        // can set property (but usually doesn't have own props)
 
     template <typename T>
@@ -36,7 +37,7 @@ namespace jspp
     struct AccessorDescriptor;
 
     // Custom runtime exception
-    struct RuntimeError;
+    struct Exception;
 
     // Dynamic AnyValue
     class AnyValue;
@@ -45,6 +46,10 @@ namespace jspp
     inline AnyValue pow(const AnyValue &lhs, const AnyValue &rhs);
 
     // AnyValue prototypes
+    namespace ObjectPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsObject *self);
+    }
     namespace StringPrototypes
     {
         inline std::optional<AnyValue> get(const std::string &key, JsString *self);
@@ -57,6 +62,10 @@ namespace jspp
     {
         inline std::optional<AnyValue> get(const std::string &key, JsFunction *self);
     }
+    namespace PromisePrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsPromise *self);
+    }
     namespace IteratorPrototypes
     {
         inline std::optional<AnyValue> get(const std::string &key, JsIterator<AnyValue> *self);