@mikrojs/firmware 0.0.7

package/components/mikrojs/test/rtc_test.cpp

@@ -0,0 +1,331 @@
+#include "mikrojs.h"
+#include "private.h"
+#include "quickjs.h"
+#include "unity.h"
+
+/* RTC module is self-registered via MIK_REGISTER_MODULE and lazily initialized */
+
+static MIKRuntime* rt;
+static JSContext* ctx;
+
+static void setup() {
+    rt = MIK_NewRuntime();
+    ctx = MIK_GetJSContext(rt);
+}
+
+static void teardown() { MIK_FreeRuntime(rt); }
+
+static JSValue eval_module(const char* code) {
+    JSValue ret = MIK_EvalModuleContent(ctx, "mikrojs/test", code, strlen(code));
+    if (!JS_IsException(ret)) {
+        JS_FreeValue(ctx, ret);
+        mik__execute_jobs(ctx);
+    }
+    return ret;
+}
+
+/* ── Module structure tests ───────────────────────────────────────── */
+
+TEST_CASE("native:rtc exports set, get, remove, clear, info", "[modules]") {
+    setup();
+
+    JSValue ret = eval_module(R"(
+        import { set, get, remove, clear, info } from "native:rtc";
+        globalThis.__setIsFunc = typeof set === "function";
+        globalThis.__getIsFunc = typeof get === "function";
+        globalThis.__removeIsFunc = typeof remove === "function";
+        globalThis.__clearIsFunc = typeof clear === "function";
+        globalThis.__infoIsFunc = typeof info === "function";
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+
+    JSValue v;
+    v = JS_GetPropertyStr(ctx, global, "__setIsFunc");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v), "set should be a function");
+    JS_FreeValue(ctx, v);
+
+    v = JS_GetPropertyStr(ctx, global, "__getIsFunc");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v), "get should be a function");
+    JS_FreeValue(ctx, v);
+
+    v = JS_GetPropertyStr(ctx, global, "__removeIsFunc");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v), "remove should be a function");
+    JS_FreeValue(ctx, v);
+
+    v = JS_GetPropertyStr(ctx, global, "__clearIsFunc");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v), "clear should be a function");
+    JS_FreeValue(ctx, v);
+
+    v = JS_GetPropertyStr(ctx, global, "__infoIsFunc");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v), "info should be a function");
+    JS_FreeValue(ctx, v);
+
+    JS_FreeValue(ctx, global);
+    teardown();
+}
+
+/* ── set/get round-trip ───────────────────────────────────────────── */
+
+TEST_CASE("native:rtc set/get round-trip", "[modules]") {
+    setup();
+
+    JSValue ret = eval_module(R"(
+        import { set, get, clear } from "native:rtc";
+        clear();
+        set("hello", "world");
+        globalThis.__result = get("hello");
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue result = JS_GetPropertyStr(ctx, global, "__result");
+    const char* str = JS_ToCString(ctx, result);
+    TEST_ASSERT_EQUAL_STRING("world", str);
+    JS_FreeCString(ctx, str);
+    JS_FreeValue(ctx, result);
+    JS_FreeValue(ctx, global);
+    teardown();
+}
+
+/* ── get returns undefined for missing key ────────────────────────── */
+
+TEST_CASE("native:rtc get returns undefined for missing key", "[modules]") {
+    setup();
+
+    JSValue ret = eval_module(R"(
+        import { get, clear } from "native:rtc";
+        clear();
+        globalThis.__result = get("nonexistent");
+        globalThis.__isUndef = get("nonexistent") === undefined;
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue isUndef = JS_GetPropertyStr(ctx, global, "__isUndef");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, isUndef), "get should return undefined for missing key");
+    JS_FreeValue(ctx, isUndef);
+    JS_FreeValue(ctx, global);
+    teardown();
+}
+
+/* ── remove deletes entry ─────────────────────────────────────────── */
+
+TEST_CASE("native:rtc remove deletes entry", "[modules]") {
+    setup();
+
+    JSValue ret = eval_module(R"(
+        import { set, get, remove, clear } from "native:rtc";
+        clear();
+        set("key1", "val1");
+        set("key2", "val2");
+        const removed = remove("key1");
+        globalThis.__removed = removed;
+        globalThis.__key1Gone = get("key1") === undefined;
+        globalThis.__key2Still = get("key2") === "val2";
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+
+    JSValue removed = JS_GetPropertyStr(ctx, global, "__removed");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, removed), "remove should return true");
+    JS_FreeValue(ctx, removed);
+
+    JSValue key1Gone = JS_GetPropertyStr(ctx, global, "__key1Gone");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, key1Gone), "key1 should be gone after remove");
+    JS_FreeValue(ctx, key1Gone);
+
+    JSValue key2Still = JS_GetPropertyStr(ctx, global, "__key2Still");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, key2Still), "key2 should still exist");
+    JS_FreeValue(ctx, key2Still);
+
+    JS_FreeValue(ctx, global);
+    teardown();
+}
+
+/* ── remove returns false for missing key ─────────────────────────── */
+
+TEST_CASE("native:rtc remove returns false for missing key", "[modules]") {
+    setup();
+
+    JSValue ret = eval_module(R"(
+        import { remove, clear } from "native:rtc";
+        clear();
+        globalThis.__result = remove("nonexistent");
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue result = JS_GetPropertyStr(ctx, global, "__result");
+    TEST_ASSERT_FALSE_MESSAGE(JS_ToBool(ctx, result), "remove should return false for missing key");
+    JS_FreeValue(ctx, result);
+    JS_FreeValue(ctx, global);
+    teardown();
+}
+
+/* ── clear removes all entries ────────────────────────────────────── */
+
+TEST_CASE("native:rtc clear removes all entries", "[modules]") {
+    setup();
+
+    JSValue ret = eval_module(R"(
+        import { set, get, clear, info } from "native:rtc";
+        clear();
+        set("a", "1");
+        set("b", "2");
+        clear();
+        globalThis.__aGone = get("a") === undefined;
+        globalThis.__bGone = get("b") === undefined;
+        const i = info();
+        globalThis.__entries = i.entries;
+        globalThis.__used = i.used;
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+
+    JSValue aGone = JS_GetPropertyStr(ctx, global, "__aGone");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, aGone), "a should be gone after clear");
+    JS_FreeValue(ctx, aGone);
+
+    JSValue bGone = JS_GetPropertyStr(ctx, global, "__bGone");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, bGone), "b should be gone after clear");
+    JS_FreeValue(ctx, bGone);
+
+    JSValue entries = JS_GetPropertyStr(ctx, global, "__entries");
+    int32_t count;
+    JS_ToInt32(ctx, &count, entries);
+    TEST_ASSERT_EQUAL_INT(0, count);
+    JS_FreeValue(ctx, entries);
+
+    JSValue used = JS_GetPropertyStr(ctx, global, "__used");
+    int32_t used_val;
+    JS_ToInt32(ctx, &used_val, used);
+    TEST_ASSERT_EQUAL_INT(0, used_val);
+    JS_FreeValue(ctx, used);
+
+    JS_FreeValue(ctx, global);
+    teardown();
+}
+
+/* ── info returns correct structure ───────────────────────────────── */
+
+TEST_CASE("native:rtc info returns used, total, entries", "[modules]") {
+    setup();
+
+    JSValue ret = eval_module(R"(
+        import { set, info, clear } from "native:rtc";
+        clear();
+        set("key", "value");
+        const i = info();
+        globalThis.__hasUsed = "used" in i;
+        globalThis.__hasTotal = "total" in i;
+        globalThis.__hasEntries = "entries" in i;
+        globalThis.__entries = i.entries;
+        globalThis.__totalGt0 = i.total > 0;
+        globalThis.__usedGt0 = i.used > 0;
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+
+    JSValue v;
+    v = JS_GetPropertyStr(ctx, global, "__hasUsed");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v), "info should have 'used'");
+    JS_FreeValue(ctx, v);
+
+    v = JS_GetPropertyStr(ctx, global, "__hasTotal");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v), "info should have 'total'");
+    JS_FreeValue(ctx, v);
+
+    v = JS_GetPropertyStr(ctx, global, "__hasEntries");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v), "info should have 'entries'");
+    JS_FreeValue(ctx, v);
+
+    JSValue entries = JS_GetPropertyStr(ctx, global, "__entries");
+    int32_t count;
+    JS_ToInt32(ctx, &count, entries);
+    TEST_ASSERT_EQUAL_INT(1, count);
+    JS_FreeValue(ctx, entries);
+
+    v = JS_GetPropertyStr(ctx, global, "__totalGt0");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v), "total should be > 0");
+    JS_FreeValue(ctx, v);
+
+    v = JS_GetPropertyStr(ctx, global, "__usedGt0");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v), "used should be > 0 after set");
+    JS_FreeValue(ctx, v);
+
+    JS_FreeValue(ctx, global);
+    teardown();
+}
+
+/* ── set overwrites existing key ──────────────────────────────────── */
+
+TEST_CASE("native:rtc set overwrites existing key", "[modules]") {
+    setup();
+
+    JSValue ret = eval_module(R"(
+        import { set, get, info, clear } from "native:rtc";
+        clear();
+        set("key", "old");
+        set("key", "new");
+        globalThis.__result = get("key");
+        globalThis.__entries = info().entries;
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+
+    JSValue result = JS_GetPropertyStr(ctx, global, "__result");
+    const char* str = JS_ToCString(ctx, result);
+    TEST_ASSERT_EQUAL_STRING("new", str);
+    JS_FreeCString(ctx, str);
+    JS_FreeValue(ctx, result);
+
+    JSValue entries = JS_GetPropertyStr(ctx, global, "__entries");
+    int32_t count;
+    JS_ToInt32(ctx, &count, entries);
+    TEST_ASSERT_EQUAL_INT(1, count);
+    JS_FreeValue(ctx, entries);
+
+    JS_FreeValue(ctx, global);
+    teardown();
+}
+
+/* ── set throws on overflow ───────────────────────────────────────── */
+
+TEST_CASE("native:rtc set returns an error Result when storage is full", "[modules]") {
+    setup();
+
+    /* native:rtc set returns a Result rather than throwing. A 2100-byte
+     * value is well under MIK_RTC_MAX_VAL_LEN (64KB) but larger than the
+     * RTC store capacity, so the error is MIK_ERR_KV_STORAGE_FULL
+     * (0x8000 + 0xD3 = 0x80D3), not KV_TOO_LARGE. */
+    JSValue ret = eval_module(R"(
+        import { set, clear } from "native:rtc";
+        clear();
+        const big = "x".repeat(2100);
+        const result = set("big", big);
+        globalThis.__ok = result.ok;
+        globalThis.__errorCode = result.ok ? 0 : result.error.code;
+    )");
+    bool evalOk = !JS_IsException(ret);
+
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue okVal = JS_GetPropertyStr(ctx, global, "__ok");
+    bool resultOk = JS_ToBool(ctx, okVal);
+    JS_FreeValue(ctx, okVal);
+    JSValue codeVal = JS_GetPropertyStr(ctx, global, "__errorCode");
+    int32_t errorCode = 0;
+    JS_ToInt32(ctx, &errorCode, codeVal);
+    JS_FreeValue(ctx, codeVal);
+    JS_FreeValue(ctx, global);
+    teardown();
+
+    TEST_ASSERT_TRUE_MESSAGE(evalOk, "Module eval should not throw");
+    TEST_ASSERT_FALSE_MESSAGE(resultOk, "set should return ok=false when over capacity");
+    TEST_ASSERT_EQUAL_INT32_MESSAGE(0x80D3, errorCode, "error code should be KV_STORAGE_FULL");
+}

package/components/mikrojs/test/runtime_test.cpp

@@ -0,0 +1,89 @@
+#include "esp_flash.h"
+#include "esp_system.h"
+#include "mikrojs.h"
+#include "quickjs.h"
+#include "unity.h"
+
+int jsval_as_int32(JSContext* ctx, JSValue val) {
+    int32_t num;
+    JS_ToInt32(ctx, &num, val);
+    JS_FreeValue(ctx, val);
+    return num;
+}
+
+TEST_CASE("Simple eval works", "[runtime]") {
+    const auto rt = MIK_NewRuntime();
+    const auto ctx = MIK_GetJSContext(rt);
+    const char* code = "2+2";
+    const auto result = JS_Eval(ctx, code, strlen(code), "main.js", JS_EVAL_TYPE_GLOBAL);
+
+    TEST_ASSERT_TRUE(JS_IsNumber(result));
+    TEST_ASSERT_TRUE(JS_IsEqual(ctx, result, JS_NewNumber(ctx, 4)));
+
+    MIK_FreeRuntime(rt);
+}
+
+TEST_CASE("Returns exception upon error", "[runtime]") {
+    const auto rt = MIK_NewRuntime();
+    const auto ctx = MIK_GetJSContext(rt);
+
+    const char* code = "this.will.fail";
+
+    const auto result = JS_Eval(ctx, code, strlen(code), "main.js", JS_EVAL_TYPE_GLOBAL);
+    JS_Eval(ctx, code, strlen(code), "main.js", JS_EVAL_TYPE_GLOBAL);
+
+    TEST_ASSERT_TRUE(JS_IsException(result));
+    JS_FreeValue(ctx, result);
+    MIK_FreeRuntime(rt);
+}
+
+TEST_CASE("Defines setTimeout, clearTimeout, setInterval, clearInterval", "[runtime]") {
+    const auto rt = MIK_NewRuntime();
+    const auto ctx = MIK_GetJSContext(rt);
+
+    auto const eval = [ctx](const char* code) -> JSValue {
+        return JS_Eval(ctx, code, strlen(code), "main.js", JS_EVAL_TYPE_GLOBAL);
+    };
+
+    TEST_ASSERT_EQUAL_STRING_MESSAGE("function", JS_ToCString(ctx, eval("typeof setTimeout")),
+                                     "Expected setTimeout to be defined");
+    TEST_ASSERT_EQUAL_STRING_MESSAGE("function", JS_ToCString(ctx, eval("typeof clearTimeout")),
+                                     "Expected clearTimeout to be defined");
+    TEST_ASSERT_EQUAL_STRING_MESSAGE("function", JS_ToCString(ctx, eval("typeof setInterval")),
+                                     "Expected setInterval to be defined");
+    TEST_ASSERT_EQUAL_STRING_MESSAGE("function", JS_ToCString(ctx, eval("typeof clearInterval")),
+                                     "Expected clearInterval to be defined");
+
+    MIK_FreeRuntime(rt);
+}
+
+TEST_CASE("Does not leak memory when running timers", "[runtime]") {
+    const auto rt = MIK_NewRuntime();
+    const auto ctx = MIK_GetJSContext(rt);
+
+    const char* code = R"(
+    globalThis.ticks = 0;
+    const tick = () => {
+        globalThis.ticks++
+        setTimeout(() => tick(), 0)
+     }
+    setTimeout(() => tick(), 0)
+  )";
+
+    auto const eval = [ctx](const char* code) -> JSValue {
+        return JS_Eval(ctx, code, strlen(code), "main.js", JS_EVAL_TYPE_GLOBAL);
+    };
+    JSValue result = eval(code);
+
+    auto const free_heap_before = esp_get_minimum_free_heap_size();
+    for (int i = 0; i < 1000; i++) {
+        MIK_Loop(rt);
+    }
+    auto ticks = jsval_as_int32(ctx, eval("globalThis.ticks"));
+
+    TEST_ASSERT_EQUAL(ticks, 1000);
+    TEST_ASSERT_INT_WITHIN(1, free_heap_before, esp_get_minimum_free_heap_size());
+
+    JS_FreeValue(ctx, result);
+    MIK_FreeRuntime(rt);
+}

package/components/mikrojs/test/sleep_test.cpp

@@ -0,0 +1,222 @@
+#include "mikrojs.h"
+#include "private.h"
+#include "quickjs.h"
+#include "soc/soc_caps.h"
+#include "unity.h"
+
+/* Sleep module is self-registered via MIK_REGISTER_MODULE and lazily initialized */
+
+static MIKRuntime* rt;
+static JSContext* ctx;
+
+static void setup() {
+    rt = MIK_NewRuntime();
+    ctx = MIK_GetJSContext(rt);
+}
+
+static void teardown() { MIK_FreeRuntime(rt); }
+
+static JSValue eval_module(const char* code) {
+    JSValue ret = MIK_EvalModuleContent(ctx, "mikrojs/test", code, strlen(code));
+    if (!JS_IsException(ret)) {
+        JS_FreeValue(ctx, ret);
+        mik__execute_jobs(ctx);
+    }
+    return ret;
+}
+
+/* ── Module exports ──────────────────────────────────────────────── */
+
+TEST_CASE("native:sleep exports expected functions", "[modules]") {
+    setup();
+
+    JSValue ret = eval_module(R"(
+        import {
+            deepSleep, lightSleep, getWakeupCause,
+            enableTimerWakeup, enableGpioWakeup,
+            disableWakeupSource
+        } from "native:sleep";
+        globalThis.__deepSleep = typeof deepSleep === "function";
+        globalThis.__lightSleep = typeof lightSleep === "function";
+        globalThis.__getWakeupCause = typeof getWakeupCause === "function";
+        globalThis.__enableTimerWakeup = typeof enableTimerWakeup === "function";
+        globalThis.__enableGpioWakeup = typeof enableGpioWakeup === "function";
+        globalThis.__disableWakeupSource = typeof disableWakeupSource === "function";
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+
+    const char* names[] = {"__deepSleep",          "__lightSleep",    "__getWakeupCause",
+                           "__enableTimerWakeup",   "__enableGpioWakeup",
+                           "__disableWakeupSource"};
+    for (int i = 0; i < 6; i++) {
+        JSValue v = JS_GetPropertyStr(ctx, global, names[i]);
+        TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v), names[i]);
+        JS_FreeValue(ctx, v);
+    }
+
+    JS_FreeValue(ctx, global);
+    teardown();
+}
+
+/* ── getWakeupCause returns a string ─────────────────────────────── */
+
+TEST_CASE("native:sleep getWakeupCause returns a string", "[modules]") {
+    setup();
+
+    JSValue ret = eval_module(R"(
+        import { getWakeupCause } from "native:sleep";
+        const cause = getWakeupCause();
+        globalThis.__isString = typeof cause === "string";
+        globalThis.__cause = cause;
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+
+    JSValue isString = JS_GetPropertyStr(ctx, global, "__isString");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, isString), "getWakeupCause should return a string");
+    JS_FreeValue(ctx, isString);
+
+    JSValue cause = JS_GetPropertyStr(ctx, global, "__cause");
+    const char* str = JS_ToCString(ctx, cause);
+    TEST_ASSERT_NOT_NULL_MESSAGE(str, "cause should be a valid string");
+    /* On fresh boot (no prior sleep), cause is typically "undefined" or "timer"
+     * depending on how the test harness rebooted. Just verify it's non-empty. */
+    TEST_ASSERT_GREATER_THAN_MESSAGE(0, strlen(str), "cause should be non-empty");
+    JS_FreeCString(ctx, str);
+    JS_FreeValue(ctx, cause);
+
+    JS_FreeValue(ctx, global);
+    teardown();
+}
+
+/* ── enableTimerWakeup accepts microseconds ──────────────────────── */
+
+TEST_CASE("native:sleep enableTimerWakeup does not throw", "[modules]") {
+    setup();
+
+    JSValue ret = eval_module(R"(
+        import { enableTimerWakeup } from "native:sleep";
+        enableTimerWakeup(5000000);
+        globalThis.__ok = true;
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue ok = JS_GetPropertyStr(ctx, global, "__ok");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, ok), "enableTimerWakeup should succeed");
+    JS_FreeValue(ctx, ok);
+    JS_FreeValue(ctx, global);
+    teardown();
+}
+
+/* ── disableWakeupSource works ───────────────────────────────────── */
+
+TEST_CASE("native:sleep disableWakeupSource clears all sources", "[modules]") {
+    setup();
+
+    JSValue ret = eval_module(R"(
+        import { enableTimerWakeup, disableWakeupSource } from "native:sleep";
+        enableTimerWakeup(1000000);
+        disableWakeupSource();
+        globalThis.__ok = true;
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue ok = JS_GetPropertyStr(ctx, global, "__ok");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, ok), "disableWakeupSource should succeed");
+    JS_FreeValue(ctx, ok);
+    JS_FreeValue(ctx, global);
+    teardown();
+}
+
+/* ── disableWakeupSource with specific source ────────────────────── */
+
+TEST_CASE("native:sleep disableWakeupSource with 'timer'", "[modules]") {
+    setup();
+
+    JSValue ret = eval_module(R"(
+        import { enableTimerWakeup, disableWakeupSource } from "native:sleep";
+        enableTimerWakeup(1000000);
+        disableWakeupSource("timer");
+        globalThis.__ok = true;
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue ok = JS_GetPropertyStr(ctx, global, "__ok");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, ok), "disableWakeupSource('timer') should succeed");
+    JS_FreeValue(ctx, ok);
+    JS_FreeValue(ctx, global);
+    teardown();
+}
+
+/* ── disableWakeupSource throws on invalid source ────────────────── */
+
+TEST_CASE("native:sleep disableWakeupSource throws on invalid source", "[modules]") {
+    setup();
+
+    JSValue ret = eval_module(R"(
+        import { disableWakeupSource } from "native:sleep";
+        try {
+            disableWakeupSource("invalid");
+            globalThis.__threw = false;
+        } catch (e) {
+            globalThis.__threw = true;
+            globalThis.__isRangeError = e instanceof RangeError;
+        }
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+
+    JSValue threw = JS_GetPropertyStr(ctx, global, "__threw");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, threw),
+                             "disableWakeupSource should throw on invalid source");
+    JS_FreeValue(ctx, threw);
+
+    JSValue isRange = JS_GetPropertyStr(ctx, global, "__isRangeError");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, isRange), "error should be RangeError");
+    JS_FreeValue(ctx, isRange);
+
+    JS_FreeValue(ctx, global);
+    teardown();
+}
+
+/* ── lightSleep with very short duration ─────────────────────────── */
+/* Light sleep disconnects UART console on targets without USB Serial/JTAG,
+   causing the test monitor to stall. Only run on chips that have USB
+   Serial/JTAG which keeps the connection alive through light sleep. */
+TEST_CASE("native:sleep lightSleep with 1ms returns or rejects gracefully", "[modules]") {
+#if !SOC_USB_SERIAL_JTAG_SUPPORTED
+    TEST_IGNORE_MESSAGE("light sleep disconnects UART console — skipped on non-USB targets");
+#endif
+    setup();
+
+    JSValue ret = eval_module(R"(
+        import { lightSleep } from "native:sleep";
+        try {
+            lightSleep(1);
+            globalThis.__result = "ok";
+        } catch (e) {
+            // Light sleep may fail on boards with USB JTAG or other constraints
+            globalThis.__result = "caught:" + e.message;
+        }
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue result = JS_GetPropertyStr(ctx, global, "__result");
+    const char* str = JS_ToCString(ctx, result);
+    TEST_ASSERT_NOT_NULL_MESSAGE(str, "result should be set");
+    /* Either "ok" (sleep succeeded) or "caught:..." (threw a catchable error) — both are fine */
+    TEST_ASSERT_TRUE_MESSAGE(strncmp(str, "ok", 2) == 0 || strncmp(str, "caught:", 7) == 0,
+                             "lightSleep should either succeed or throw a catchable error");
+    JS_FreeCString(ctx, str);
+    JS_FreeValue(ctx, result);
+    JS_FreeValue(ctx, global);
+    teardown();
+}