@mikrojs/native 0.20.1 → 0.21.0-next.20260913195055

package/src/gpio_claim.cpp

@@ -0,0 +1,63 @@
+#include <cstring>
+#include <string>
+
+#include "mikrojs/mikrojs.h"
+#include "mikrojs/private.h"
+#include "mikrojs/utils.h"
+
+/* Runtime-wide exclusive GPIO pin claims. Only touched from the JS task, so no
+ * locking. Owners are static strings, so the table never frees anything. */
+
+#define MIK__GPIO_MAX 64
+
+static const char* s_owner[MIK__GPIO_MAX] = {};
+
+static bool mik__gpio_tracked(int gpio) {
+    return gpio >= 0 && gpio < MIK__GPIO_MAX;
+}
+
+bool MIK_ClaimGpio(int gpio, const char* owner) {
+    if (!owner) return false;
+    if (!mik__gpio_tracked(gpio)) return true;
+    if (s_owner[gpio]) return false;
+    s_owner[gpio] = owner;
+    return true;
+}
+
+void MIK_ReleaseGpio(int gpio, const char* owner) {
+    /* A stale release from one module must not free another module's claim. */
+    if (owner && mik__gpio_tracked(gpio) && s_owner[gpio] && strcmp(s_owner[gpio], owner) == 0) {
+        s_owner[gpio] = nullptr;
+    }
+}
+
+const char* MIK_GpioOwner(int gpio) {
+    return mik__gpio_tracked(gpio) ? s_owner[gpio] : nullptr;
+}
+
+/* Owners are class names ("by Pwm"), except the console ("by the console"). */
+static std::string mik__gpio_in_use_message(int gpio, const char* owner) {
+    std::string message = "GPIO " + std::to_string(gpio) + " is already in use by ";
+    if (strcmp(owner, "console") == 0) message += "the ";
+    return message + owner;
+}
+
+JSValue mik__claim_gpios(JSContext* ctx, const int* gpios, int count, const char* owner) {
+    for (int i = 0; i < count; i++) {
+        if (MIK_ClaimGpio(gpios[i], owner)) continue;
+        const char* holder = MIK_GpioOwner(gpios[i]);
+        JSValue error = JS_NewObject(ctx);
+        JS_SetPropertyStr(ctx, error, "name", JS_NewString(ctx, "GpioInUse"));
+        JS_SetPropertyStr(ctx, error, "owner", JS_NewString(ctx, holder));
+        std::string message = mik__gpio_in_use_message(gpios[i], holder);
+        JS_SetPropertyStr(ctx, error, "message",
+                          JS_NewStringLen(ctx, message.data(), message.size()));
+        mik__release_gpios(gpios, i, owner);
+        return mik__result_err_obj(ctx, error);
+    }
+    return JS_UNDEFINED;
+}
+
+void mik__release_gpios(const int* gpios, int count, const char* owner) {
+    for (int i = 0; i < count; i++) MIK_ReleaseGpio(gpios[i], owner);
+}

package/src/mik_abort.cpp

@@ -52,8 +52,7 @@ static JSValue mik__abort_lazy_get(JSContext* ctx, JSValue this_val, int magic)
          * would surface a bare 'null'. Mirrors the module loader's
          * missing-builtin fallback. */
         if (!JS_HasException(ctx)) {
-            JS_ThrowReferenceError(ctx,
-                                   "Builtin module 'mikro/abort' is not available in this build");
+            JS_ThrowTypeError(ctx, "Failed to resolve module specifier 'mikro/abort'");
         }
         JS_FreeValue(ctx, global_obj);
         return JS_EXCEPTION;

package/src/mik_console.cpp

@@ -3,7 +3,6 @@
 #include <cstring>
 #include <string>
 #include <unistd.h>
-#include <vector>
 
 #include <quickjs.h>
 
@@ -122,41 +121,6 @@ static std::string mik__format(JSContext* ctx, int argc, JSValue* argv, bool col
     return result;
 }
 
-/* ── Error formatting (port of console.ts formatError) ───────────── */
-
-static std::string mik__format_error(JSContext* ctx, JSValue error) {
-    JSValue stack_val = JS_GetPropertyStr(ctx, error, "stack");
-    JSValue msg_val = JS_GetPropertyStr(ctx, error, "message");
-
-    const char* stack = JS_ToCString(ctx, stack_val);
-    const char* msg = JS_ToCString(ctx, msg_val);
-
-    std::string result;
-    if (stack && msg && strstr(stack, msg)) {
-        /* Stack already includes message */
-        result = stack;
-    } else {
-        JSValue name_val = JS_GetPropertyStr(ctx, error, "name");
-        const char* name = JS_ToCString(ctx, name_val);
-        result = name ? name : "Error";
-        result += ": ";
-        result += msg ? msg : "";
-        if (stack) {
-            result += "\n";
-            result += stack;
-        }
-        if (name) JS_FreeCString(ctx, name);
-        JS_FreeValue(ctx, name_val);
-    }
-
-    if (stack) JS_FreeCString(ctx, stack);
-    if (msg) JS_FreeCString(ctx, msg);
-    JS_FreeValue(ctx, stack_val);
-    JS_FreeValue(ctx, msg_val);
-
-    return result;
-}
-
 /* ── Console methods ─────────────────────────────────────────────── */
 
 static JSValue mik__console_log(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
@@ -205,24 +169,9 @@ static JSValue mik__console_error_warn(JSContext* ctx, JSValue this_val, int arg
                                        int magic) {
     uint8_t msg_type = magic == 0 ? MIK_MSG_ERROR : MIK_MSG_WARN;
 
-    /* Map Error objects to their stack traces */
-    std::vector<JSValue> mapped;
-    mapped.reserve(argc);
-
-    for (int i = 0; i < argc; i++) {
-        if (JS_IsError(argv[i])) {
-            std::string err_str = mik__format_error(ctx, argv[i]);
-            mapped.push_back(JS_NewString(ctx, err_str.c_str()));
-        } else {
-            mapped.push_back(JS_DupValue(ctx, argv[i]));
-        }
-    }
-
-    std::string output = mik__format(ctx, argc, mapped.data(), true);
-
-    for (auto& v : mapped) {
-        JS_FreeValue(ctx, v);
-    }
+    /* Error arguments render through inspect: name, message, extra fields,
+     * stack and cause chain. Same output as console.log for the same value. */
+    std::string output = mik__format(ctx, argc, argv, true);
 
     if (mik__repl_is_protocol_mode()) {
         mik__repl_proto_send_output(msg_type, output.c_str(), output.size());
@@ -236,6 +185,152 @@ static JSValue mik__console_error_warn(JSContext* ctx, JSValue this_val, int arg
 
 /* ── Uncaught error reporting ─────────────────────────────────────── */
 
+/* Bounded stack-buffer writer for the uncaught path: never touches the
+ * C++ heap (see mik__report_uncaught). Silently truncates when full. */
+struct MIKBoundedBuf {
+    char* buf;
+    size_t cap;
+    size_t pos = 0;
+    void append(const char* s, size_t len) {
+        if (pos >= cap - 1) return;
+        size_t avail = cap - 1 - pos;
+        size_t n = len < avail ? len : avail;
+        memcpy(buf + pos, s, n);
+        pos += n;
+    }
+    void cstr(const char* s) {
+        if (s) append(s, strlen(s));
+    }
+};
+
+/* One primitive as a log token (strings quoted). Objects print as
+ * [object]: nested inspection would need the C++ heap. */
+static void mik__append_primitive(JSContext* ctx, JSValue v, MIKBoundedBuf& out) {
+    if (JS_IsObject(v)) {
+        out.cstr("[object]");
+        return;
+    }
+    /* Allocation-free spellings first: a null rejection is how QuickJS
+     * reports OOM, so this must work with no heap at all */
+    if (JS_IsNull(v)) {
+        out.cstr("null");
+        return;
+    }
+    if (JS_IsUndefined(v)) {
+        out.cstr("undefined");
+        return;
+    }
+    if (JS_IsBool(v)) {
+        out.cstr(JS_ToBool(ctx, v) ? "true" : "false");
+        return;
+    }
+    if (JS_VALUE_GET_TAG(v) == JS_TAG_INT) {
+        char num[16];
+        int n = snprintf(num, sizeof(num), "%d", JS_VALUE_GET_INT(v));
+        if (n > 0) out.append(num, (size_t)n);
+        return;
+    }
+    bool quote = JS_IsString(v);
+    /* JS-heap allocation only; returns NULL on OOM instead of throwing */
+    const char* s = JS_ToCString(ctx, v);
+    if (!s) {
+        /* Symbols reject ToString */
+        JS_FreeValue(ctx, JS_GetException(ctx));
+        out.cstr("[primitive]");
+        return;
+    }
+    if (quote) out.cstr("'");
+    out.cstr(s);
+    if (quote) out.cstr("'");
+    JS_FreeCString(ctx, s);
+}
+
+/* "Name: message { extra: fields }" then the stack frames, `indent`
+ * prefixed to every frame line. Also fits a plain object (a Result error
+ * as a panic cause has name/message and no stack). */
+static void mik__append_error_head(JSContext* ctx, JSValue exc, const char* indent, MIKBoundedBuf& out) {
+    JSValue name_val = JS_GetPropertyStr(ctx, exc, "name");
+    JSValue msg_val = JS_GetPropertyStr(ctx, exc, "message");
+    if (JS_IsException(name_val) || JS_IsException(msg_val)) {
+        JS_FreeValue(ctx, JS_GetException(ctx));
+    }
+    /* Non-string name/message count as absent (a native Result error has
+     * code + message and no name) */
+    const char* name = JS_IsString(name_val) ? JS_ToCString(ctx, name_val) : nullptr;
+    const char* emsg = JS_IsString(msg_val) ? JS_ToCString(ctx, msg_val) : nullptr;
+
+    if (name && name[0]) {
+        out.cstr(name);
+        if (emsg && emsg[0]) {
+            out.cstr(": ");
+            out.cstr(emsg);
+        }
+    } else if (emsg && emsg[0]) {
+        out.cstr(emsg);
+    } else {
+        out.cstr("[object]");
+    }
+
+    if (name) JS_FreeCString(ctx, name);
+    if (emsg) JS_FreeCString(ctx, emsg);
+    JS_FreeValue(ctx, name_val);
+    JS_FreeValue(ctx, msg_val);
+
+    /* Own enumerable fields beyond the standard ones: code, errno, path... */
+    JSPropertyEnum* ptab = nullptr;
+    uint32_t plen = 0;
+    if (JS_GetOwnPropertyNames(ctx, &ptab, &plen, exc, JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY) ==
+        0) {
+        bool first = true;
+        for (uint32_t i = 0; i < plen; i++) {
+            const char* key = JS_AtomToCString(ctx, ptab[i].atom);
+            if (key && strcmp(key, "name") != 0 && strcmp(key, "message") != 0 &&
+                strcmp(key, "stack") != 0 && strcmp(key, "cause") != 0) {
+                JSValue v = JS_GetProperty(ctx, exc, ptab[i].atom);
+                if (JS_IsException(v)) {
+                    JS_FreeValue(ctx, JS_GetException(ctx));
+                } else {
+                    out.cstr(first ? " { " : ", ");
+                    first = false;
+                    out.cstr(key);
+                    out.cstr(": ");
+                    mik__append_primitive(ctx, v, out);
+                }
+                JS_FreeValue(ctx, v);
+            }
+            if (key) JS_FreeCString(ctx, key);
+            JS_FreeAtom(ctx, ptab[i].atom);
+        }
+        if (!first) out.cstr(" }");
+        js_free(ctx, ptab);
+    } else {
+        JS_FreeValue(ctx, JS_GetException(ctx));
+    }
+
+    JSValue stack_val = JS_GetPropertyStr(ctx, exc, "stack");
+    if (JS_IsString(stack_val)) {
+        const char* stack = JS_ToCString(ctx, stack_val);
+        if (stack) {
+            const char* p = stack;
+            while (*p) {
+                const char* nl = strchr(p, '\n');
+                size_t len = nl ? (size_t)(nl - p) : strlen(p);
+                if (len) {
+                    out.cstr("\n");
+                    out.cstr(indent);
+                    out.append(p, len);
+                }
+                if (!nl) break;
+                p = nl + 1;
+            }
+            JS_FreeCString(ctx, stack);
+        }
+    } else if (JS_IsException(stack_val)) {
+        JS_FreeValue(ctx, JS_GetException(ctx));
+    }
+    JS_FreeValue(ctx, stack_val);
+}
+
 /* Dedup across report paths: one error can reach this function more than
  * once for a single failure. The sync throw path (mik_dump_error) can report
  * an error whose promise still sits in the deferred flush queue, e.g. an
@@ -275,77 +370,59 @@ bool mik__report_uncaught(JSContext* ctx, JSValue exc, bool in_promise) {
      * abort() — masking the real OOM the reporter was trying to surface.
      * Messages longer than the buffer get truncated, which beats
      * aborting. */
-    char buf[512];
-    size_t pos = 0;
-    auto append = [&](const char* s, size_t len) {
-        if (pos >= sizeof(buf) - 1) return;
-        size_t avail = sizeof(buf) - 1 - pos;
-        size_t n = len < avail ? len : avail;
-        memcpy(buf + pos, s, n);
-        pos += n;
-    };
-    auto append_cstr = [&](const char* s) {
-        if (s) append(s, strlen(s));
-    };
+    char buf[1024];
+    MIKBoundedBuf out{buf, sizeof(buf)};
 
-    append_cstr(in_promise ? "Uncaught (in promise) " : "Uncaught ");
+    out.cstr(in_promise ? "Uncaught (in promise) " : "Uncaught ");
 
     if (JS_IsObject(exc)) {
-        JSValue name_val = JS_GetPropertyStr(ctx, exc, "name");
-        JSValue msg_val = JS_GetPropertyStr(ctx, exc, "message");
-        const char* name = JS_ToCString(ctx, name_val);
-        const char* emsg = JS_ToCString(ctx, msg_val);
-
-        if (name && name[0]) {
-            append_cstr(name);
-            if (emsg && emsg[0]) {
-                append_cstr(": ");
-                append_cstr(emsg);
+        mik__append_error_head(ctx, exc, "", out);
+
+        /* Cause chain: a panic's cause is the Result error that triggered
+         * it, so this is usually the line that says what actually failed.
+         * Bounded depth; `seen` cuts cycles. */
+        static const char* const indents[] = {"", "  ", "    ", "      ", "        "};
+        void* seen[countof(indents)] = {JS_VALUE_GET_PTR(exc)};
+        JSValue cur = JS_DupValue(ctx, exc);
+        for (size_t level = 1; level < countof(indents); level++) {
+            JSValue cause = JS_GetPropertyStr(ctx, cur, "cause");
+            JS_FreeValue(ctx, cur);
+            cur = cause;
+            if (JS_IsException(cause)) {
+                JS_FreeValue(ctx, JS_GetException(ctx));
+                break;
             }
-        } else if (emsg && emsg[0]) {
-            append_cstr(emsg);
-        } else {
-            append_cstr("[object]");
-        }
-
-        if (name) JS_FreeCString(ctx, name);
-        if (emsg) JS_FreeCString(ctx, emsg);
-        JS_FreeValue(ctx, name_val);
-        JS_FreeValue(ctx, msg_val);
-
-        JSValue stack_val = JS_GetPropertyStr(ctx, exc, "stack");
-        if (JS_IsString(stack_val)) {
-            const char* stack = JS_ToCString(ctx, stack_val);
-            if (stack && stack[0]) {
-                append_cstr("\n");
-                append_cstr(stack);
+            if (JS_IsUndefined(cause)) break;
+            out.cstr("\n");
+            out.cstr(indents[level]);
+            out.cstr("[cause]: ");
+            if (!JS_IsObject(cause)) {
+                mik__append_primitive(ctx, cause, out);
+                break;
+            }
+            bool cyclic = false;
+            for (size_t j = 0; j < level; j++) {
+                if (seen[j] == JS_VALUE_GET_PTR(cause)) cyclic = true;
+            }
+            if (cyclic) {
+                out.cstr("[Circular]");
+                break;
             }
-            if (stack) JS_FreeCString(ctx, stack);
+            seen[level] = JS_VALUE_GET_PTR(cause);
+            mik__append_error_head(ctx, cause, indents[level], out);
         }
-        JS_FreeValue(ctx, stack_val);
+        JS_FreeValue(ctx, cur);
     } else {
         /* Describe primitive rejections by type without going through
          * mik_inspect (which allocates a std::string). */
-        if (JS_IsNull(exc)) {
-            append_cstr("null");
-        } else if (JS_IsUndefined(exc)) {
-            append_cstr("undefined");
-        } else if (JS_IsBool(exc)) {
-            append_cstr(JS_ToBool(ctx, exc) ? "true" : "false");
-        } else if (JS_IsNumber(exc)) {
-            double d = 0;
-            JS_ToFloat64(ctx, &d, exc);
-            char num[32];
-            int n = snprintf(num, sizeof(num), "%g", d);
-            if (n > 0) append(num, (size_t)n);
-        } else if (JS_IsString(exc)) {
+        if (JS_IsString(exc)) {
             const char* s = JS_ToCString(ctx, exc);
             if (s) {
-                append_cstr(s);
+                out.cstr(s);
                 JS_FreeCString(ctx, s);
             }
         } else {
-            append_cstr("[primitive]");
+            mik__append_primitive(ctx, exc, out);
         }
 
         /* Primitive rejections lose the throw-site stack (the async
@@ -359,17 +436,17 @@ bool mik__report_uncaught(JSContext* ctx, JSValue exc, bool in_promise) {
             int n = snprintf(note, sizeof(note),
                              "\n  (primitive rejection, systemFree=%zuB at report time)",
                              plat->get_free_system_mem());
-            if (n > 0) append(note, (size_t)n);
+            if (n > 0) out.append(note, (size_t)n);
         }
     }
 
     if (mik__repl_is_protocol_mode()) {
-        mik__repl_proto_send_output(MIK_MSG_ERROR, buf, pos);
+        mik__repl_proto_send_output(MIK_MSG_ERROR, buf, out.pos);
         return true;
     }
 
-    append_cstr("\r\n");
-    MIK_GetPlatform()->stderr_write(buf, pos);
+    out.cstr("\r\n");
+    MIK_GetPlatform()->stderr_write(buf, out.pos);
     return true;
 }
 

package/src/mik_http_client.cpp

@@ -50,20 +50,9 @@ JSValue hc_iter_result(JSContext* ctx, bool done, JSValue value) {
     return o;
 }
 
-JSAtom hc_async_iterator_atom(JSContext* ctx) {
-    JSValue g = JS_GetGlobalObject(ctx);
-    JSValue sym_ctor = JS_GetPropertyStr(ctx, g, "Symbol");
-    JSValue sym = JS_GetPropertyStr(ctx, sym_ctor, "asyncIterator");
-    JSAtom atom = JS_ValueToAtom(ctx, sym);
-    JS_FreeValue(ctx, sym);
-    JS_FreeValue(ctx, sym_ctor);
-    JS_FreeValue(ctx, g);
-    return atom;
-}
-
 /* source[Symbol.asyncIterator]() — returns the iterator (owned) or exception. */
 JSValue hc_get_async_iterator(JSContext* ctx, JSValue source) {
-    JSAtom atom = hc_async_iterator_atom(ctx);
+    JSAtom atom = mik__async_iterator_atom(ctx);
     JSValue fn = JS_GetProperty(ctx, source, atom);
     JS_FreeAtom(ctx, atom);
     if (JS_IsException(fn)) return fn;
@@ -757,7 +746,7 @@ JSValue hc_make_response(JSContext* ctx, JSValue raw) {
                               JS_PROP_C_W_E);
 
     JSValue body = JS_NewObject(ctx);
-    JSAtom iter_atom = hc_async_iterator_atom(ctx);
+    JSAtom iter_atom = mik__async_iterator_atom(ctx);
     JS_DefinePropertyValue(ctx, body, iter_atom,
                            JS_NewCFunctionData(ctx, hc_resp_body_iterator_cf, 0, 0, 2, data),
                            JS_PROP_C_W_E);
@@ -1093,7 +1082,7 @@ JSValue hc_on_headers(JSContext* ctx, JSValue this_val, int argc, JSValue* argv,
     }
 
     JSValue raw_body = JS_NewObject(ctx);
-    JSAtom iter_atom = hc_async_iterator_atom(ctx);
+    JSAtom iter_atom = mik__async_iterator_atom(ctx);
     JS_DefinePropertyValue(ctx, raw_body, iter_atom,
                            JS_NewCFunctionData(ctx, hc_transport_iterator_cf, 0, 0, 1, &st),
                            JS_PROP_C_W_E);

package/src/mik_inspect.cpp

@@ -18,6 +18,8 @@ struct InspectOpts {
     bool colors;
     bool show_hidden;
     std::vector<void*> seen;
+    /* Nesting of [cause] rendering, capped like mik__report_uncaught */
+    int cause_level = 0;
 };
 
 /* ── Helpers ─────────────────────────────────────────────────────── */
@@ -85,6 +87,7 @@ static std::string quote_key(const char* key) {
 /* ── Forward declaration ─────────────────────────────────────────── */
 
 static std::string inspect_value(JSContext* ctx, JSValue value, InspectOpts& opts, int depth);
+static std::string indent_continuation(const std::string& s);
 
 /* ── Custom inspect callback state (single-threaded JS) ──────────── */
 
@@ -263,7 +266,7 @@ static std::string inspect_array_items(JSContext* ctx, JSValue arr, uint32_t len
         if (JS_IsException(item)) {
             out += getter_threw(ctx, opts);
         } else {
-            out += inspect_value(ctx, item, opts, depth);
+            out += indent_continuation(inspect_value(ctx, item, opts, depth));
         }
         JS_FreeValue(ctx, item);
     }
@@ -318,7 +321,7 @@ static std::string inspect_properties(JSContext* ctx, JSValue obj, InspectOpts&
             if (JS_IsException(val)) {
                 out += getter_threw(ctx, opts);
             } else {
-                out += inspect_value(ctx, val, opts, depth);
+                out += indent_continuation(inspect_value(ctx, val, opts, depth));
             }
             JS_FreeValue(ctx, val);
         }
@@ -474,6 +477,51 @@ static std::string inspect_regexp(JSContext* ctx, JSValue value, InspectOpts& op
     return stylize("/(?:)/", MIK_TOKEN_REGEXP, opts);
 }
 
+/* Indent every line after the first by two spaces so a multi-line value
+ * (an error's stack frames, its own cause) nests visibly under its parent. */
+static std::string indent_continuation(const std::string& s) {
+    std::string out;
+    out.reserve(s.size() + 8);
+    for (char c : s) {
+        out += c;
+        if (c == '\n') out += "  ";
+    }
+    return out;
+}
+
+/* "\n  [cause]: <value>" for an own cause, or "". Shared by Errors and
+ * plain objects, since Result errors carry cause as an ordinary field.
+ * The chain is what a log line exists for, so it renders past the depth
+ * limit; the caller keeps the parent on the seen list to bound cycles. */
+static std::string inspect_cause(JSContext* ctx, JSValue value, InspectOpts& opts, int depth) {
+    JSValue cause = JS_GetPropertyStr(ctx, value, "cause");
+    if (JS_IsException(cause)) {
+        drain_exception(ctx);
+        return "";
+    }
+    /* Same cap as mik__report_uncaught; bounds recursion on the JS task stack */
+    static const int MAX_CAUSE_LEVEL = 4;
+    std::string out;
+    if (!JS_IsUndefined(cause)) {
+        out = "\n  [cause]: ";
+        if (opts.cause_level >= MAX_CAUSE_LEVEL) {
+            out += TRUNCATOR;
+        } else {
+            opts.cause_level++;
+            out += indent_continuation(inspect_value(ctx, cause, opts, depth < 1 ? 1 : depth));
+            opts.cause_level--;
+        }
+    }
+    JS_FreeValue(ctx, cause);
+    return out;
+}
+
+/* Errors render as
+ *   Name: message { extra: props }
+ *       at frame (file:line:col)
+ *     [cause]: <inspected cause>
+ * The header keeps name, message and every own enumerable field (code,
+ * errno, ...) on one line; the stack and the cause chain follow. */
 static std::string inspect_error(JSContext* ctx, JSValue value, InspectOpts& opts, int depth) {
     /* Get name and message */
     JSValue name_val = JS_GetPropertyStr(ctx, value, "name");
@@ -498,16 +546,40 @@ static std::string inspect_error(JSContext* ctx, JSValue value, InspectOpts& opt
     JS_FreeValue(ctx, name_val);
     JS_FreeValue(ctx, msg_val);
 
-    /* Inspect extra properties (skip standard error keys) */
+    if (is_seen(opts, value)) return result + " [Circular]";
+    opts.seen.push_back(JS_VALUE_GET_PTR(value));
+
+    /* Inspect extra properties (skip standard error keys; cause is rendered
+     * below so it reads the same whether QuickJS or a panic defined it) */
     static const char* const error_keys[] = {"stack",     "line",       "column",     "name",
                                              "message",   "fileName",   "lineNumber", "columnNumber",
-                                             "number",    "description"};
+                                             "number",    "description", "cause"};
     std::string props =
         inspect_properties(ctx, value, opts, depth, error_keys, countof(error_keys));
     if (!props.empty()) {
         result += " { " + props + " }";
     }
 
+    /* QuickJS stacks are frame lines only ("    at ..."), no header line */
+    JSValue stack_val = JS_GetPropertyStr(ctx, value, "stack");
+    if (JS_IsException(stack_val)) drain_exception(ctx);
+    if (JS_IsString(stack_val)) {
+        const char* stack = JS_ToCString(ctx, stack_val);
+        if (stack) {
+            std::string frames(stack);
+            JS_FreeCString(ctx, stack);
+            while (!frames.empty() && frames.back() == '\n') frames.pop_back();
+            if (!frames.empty()) {
+                result += "\n";
+                result += frames;
+            }
+        }
+    }
+    JS_FreeValue(ctx, stack_val);
+
+    result += inspect_cause(ctx, value, opts, depth);
+
+    opts.seen.pop_back();
     return result;
 }
 
@@ -603,9 +675,9 @@ static std::string inspect_map(JSContext* ctx, JSValue value, InspectOpts& opts,
 
         if (!first) items += ", ";
         first = false;
-        items += inspect_value(ctx, key, opts, depth);
+        items += indent_continuation(inspect_value(ctx, key, opts, depth));
         items += " => ";
-        items += inspect_value(ctx, val, opts, depth);
+        items += indent_continuation(inspect_value(ctx, val, opts, depth));
 
         JS_FreeValue(ctx, key);
         JS_FreeValue(ctx, val);
@@ -673,7 +745,7 @@ static std::string inspect_set(JSContext* ctx, JSValue value, InspectOpts& opts,
         JSValue val = JS_GetPropertyStr(ctx, step, "value");
         if (!first) items += ", ";
         first = false;
-        items += inspect_value(ctx, val, opts, depth);
+        items += indent_continuation(inspect_value(ctx, val, opts, depth));
         JS_FreeValue(ctx, val);
         JS_FreeValue(ctx, step);
     }
@@ -746,11 +818,16 @@ static std::string inspect_object(JSContext* ctx, JSValue value, InspectOpts& op
 
     if (plen == 0) return "{}";
 
+    /* A cause field chains below the braces like an Error's, so a Result
+     * error wrapped around another keeps its whole chain readable */
+    static const char* const cause_key[] = {"cause"};
     opts.seen.push_back(JS_VALUE_GET_PTR(value));
-    std::string props = inspect_properties(ctx, value, opts, depth);
+    std::string props = inspect_properties(ctx, value, opts, depth, cause_key, 1);
+    std::string result = props.empty() ? "{}" : "{ " + props + " }";
+    result += inspect_cause(ctx, value, opts, depth);
     opts.seen.pop_back();
 
-    return "{ " + props + " }";
+    return result;
 }
 
 static std::string inspect_class(JSContext* ctx, JSValue value, const std::string& type_name,