@mikrojs/firmware 0.8.0-pr-115.g87a99f9 → 0.8.0

package/components/mikrojs/include/mikrojs_esp32.h

@@ -64,6 +64,16 @@ void mik_logfile_resume(void);
 /* Serial binary I/O (mik_serial_io.cpp) */
 void mik__serial_binary_begin_no_echo(void);
 
+/* Detach the USB Serial/JTAG peripheral from the host (uninstalls the
+ * driver and disables the PHY pad) so the CLI sees a clean disconnect
+ * before light sleep. No-op when the active console isn't USJ. */
+void mik__serial_io_detach_usb(void);
+
+/* Re-attach the USB Serial/JTAG peripheral after a prior detach. The
+ * host re-enumerates the device. No-op when the active console isn't
+ * USJ. */
+void mik__serial_io_attach_usb(void);
+
 /* Shared NVS helpers (mik_serial_io.cpp) */
 extern const char* MIK__NVS_NS_ENV;  /* env var values */
 extern const char* MIK__NVS_NS_SEC;  /* secret-flag markers (u8) */

package/components/mikrojs/mik_serial_io.cpp

@@ -17,6 +17,8 @@
 
 #if SOC_USB_SERIAL_JTAG_SUPPORTED
 #include "driver/usb_serial_jtag.h"
+#include "esp_rom_sys.h"
+#include "hal/usb_serial_jtag_ll.h"
 /* mikrojs owns the USB-Serial/JTAG peripheral directly. Leaving
  * CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG=y would have ESP-IDF register a
  * VFS and write to the TX FIFO from stdio, racing our driver ISR. */
@@ -74,35 +76,41 @@ static enum { CONSOLE_UART, CONSOLE_USB_SERIAL_JTAG } s_console =
 static bool s_usj_installed = false;
 #endif
 
-void mik__console_init(void) {
 #if SOC_USB_SERIAL_JTAG_SUPPORTED
-    /* Install USB-Serial/JTAG via the public driver API only. No VFS
-     * registration, no `fileno(stdin)`, no newlib integration — that's
-     * the whole point of this path.
-     *
-     * Both rings are sized to fit the largest single TLV frame plus a
-     * little headroom for the next frame's header to land alongside it.
-     *
-     * RX (host → device): the largest single command frame is a
-     * CMD_DEPLOY_PUT_CHUNK (≤ 2 KB body + 5 B header). Deploy PUTs no
-     * longer carry the file body in one frame — they're streamed as
-     * begin + N chunks with per-chunk MSG_OK pacing — so this size is
-     * a function of the chunk size, not of the largest deployable file.
-     * 4 KB gives ~2× headroom over a single chunk so the next command
-     * can be queued behind it.
-     *
-     * TX (device → host): bumped from the IDF default (256 B) to 2 KB
-     * so MSG_READY resends during the boot-handshake window don't fill
-     * the ring before the CLI's TTY starts draining. At 256 B the ring
-     * fills after ~3 MSG_READY sends, then subsequent writes (including
-     * the MSG_OK response to the first CMD_RUNTIME_PAUSE) stall long
-     * enough to blow past the CLI's 10 s pause timeout and force a
-     * restart-and-retry on every `mikro dev`. 2 KB is still small
-     * enough not to meaningfully dent RAM for display-heavy apps. */
+/* Install USB-Serial/JTAG via the public driver API only. No VFS
+ * registration, no `fileno(stdin)`, no newlib integration — that's
+ * the whole point of this path.
+ *
+ * Both rings are sized to fit the largest single TLV frame plus a
+ * little headroom for the next frame's header to land alongside it.
+ *
+ * RX (host → device): the largest single command frame is a
+ * CMD_DEPLOY_PUT_CHUNK (≤ 2 KB body + 5 B header). Deploy PUTs no
+ * longer carry the file body in one frame — they're streamed as
+ * begin + N chunks with per-chunk MSG_OK pacing — so this size is
+ * a function of the chunk size, not of the largest deployable file.
+ * 4 KB gives ~2× headroom over a single chunk so the next command
+ * can be queued behind it.
+ *
+ * TX (device → host): bumped from the IDF default (256 B) to 2 KB
+ * so MSG_READY resends during the boot-handshake window don't fill
+ * the ring before the CLI's TTY starts draining. At 256 B the ring
+ * fills after ~3 MSG_READY sends, then subsequent writes (including
+ * the MSG_OK response to the first CMD_RUNTIME_PAUSE) stall long
+ * enough to blow past the CLI's 10 s pause timeout and force a
+ * restart-and-retry on every `mikro dev`. 2 KB is still small
+ * enough not to meaningfully dent RAM for display-heavy apps. */
+static bool mik__usj_install_with_default_config(void) {
     usb_serial_jtag_driver_config_t usj_cfg = USB_SERIAL_JTAG_DRIVER_CONFIG_DEFAULT();
     usj_cfg.rx_buffer_size = 4096;
     usj_cfg.tx_buffer_size = 2048;
-    s_usj_installed = (usb_serial_jtag_driver_install(&usj_cfg) == ESP_OK);
+    return usb_serial_jtag_driver_install(&usj_cfg) == ESP_OK;
+}
+#endif
+
+void mik__console_init(void) {
+#if SOC_USB_SERIAL_JTAG_SUPPORTED
+    s_usj_installed = mik__usj_install_with_default_config();
 #endif
 
 #if MIK_CONSOLE_HAS_UART
@@ -228,6 +236,84 @@ void mik__serial_binary_begin_no_echo(void) {
      * so `\n` passes through unchanged on both USJ and UART paths. */
 }
 
+/* ── USB detach/attach for light sleep ─────────────────────────────
+ *
+ * Light sleep on USJ-console chips (C3, C6, S3, …) powers down the
+ * digital peripheral domain but leaves the USB device enumerated on
+ * the host. node-serialport doesn't see a close, so the CLI can't
+ * tell the difference between "device is busy" and "device is asleep".
+ *
+ * To make the disconnect visible we uninstall the driver and pull
+ * down the D+ pad before sleeping. On wake we restore the pad and
+ * re-install the driver. The host re-enumerates, the CLI's existing
+ * disconnect → reconnect path handles the rest. */
+
+void mik__serial_io_detach_usb(void) {
+#if SOC_USB_SERIAL_JTAG_SUPPORTED
+    if (s_console != CONSOLE_USB_SERIAL_JTAG) return;
+    if (!s_usj_installed) return;
+
+    /* USJ has no public flush API. A short delay covers TX-ring drain
+     * for the typical log-line-sized writes we send before sleeping. */
+    vTaskDelay(pdMS_TO_TICKS(20));
+
+    usb_serial_jtag_driver_uninstall();
+    s_usj_installed = false;
+
+    /* Force a host-visible disconnect by overriding D+/D- pulls to
+     * present SE0 on the bus. `usb_serial_jtag_ll_phy_enable_pad(false)`
+     * (which ESP-IDF's own sleep prep uses) only gates the internal pad
+     * routing for leakage — it does NOT release the host-visible 1.5 k
+     * D+ pullup, so the host still sees the device enumerated. The
+     * pull-override is the only mechanism in ESP-IDF v6.0.1 that
+     * actually triggers a re-enumerate. C6 has no `_SUPPORT_LIGHT_SLEEP`
+     * cap for USJ (IDF-6395 in soc_caps.h), so this is the supported
+     * path.
+     * Refs:
+     *   components/hal/include/hal/usb_serial_jtag_ll.h
+     *   docs.espressif.com/projects/esp-iot-solution/.../usb_serial_jtag.html
+     */
+    usb_serial_jtag_pull_override_vals_t off = {
+        .dp_pu = 0,
+        .dm_pu = 0,
+        .dp_pd = 1,
+        .dm_pd = 1,
+    };
+    usb_serial_jtag_ll_phy_enable_pull_override(&off);
+    /* >2.5 ms of SE0 so the host registers a disconnect rather than a
+     * USB suspend. 5 ms gives plenty of margin without meaningfully
+     * delaying sleep entry. */
+    esp_rom_delay_us(5000);
+#endif
+}
+
+void mik__serial_io_attach_usb(void) {
+#if SOC_USB_SERIAL_JTAG_SUPPORTED
+    if (s_console != CONSOLE_USB_SERIAL_JTAG) return;
+    if (s_usj_installed) return;
+
+    /* `disable_pull_override` only flips `pad_pull_override` back to 0;
+     * the `dp_pullup`/`dp_pulldown` register fields still hold the
+     * disconnect values from detach (D+ pullup off, D+ pulldown on),
+     * so the host sees no connect signal until the peripheral autopilots
+     * — which only happens reliably once the driver is active. Drive
+     * the override to an explicit "connect" state (D+ pullup on,
+     * everything else off) first so the host sees J-state immediately,
+     * install the driver while the override holds it, then release. */
+    usb_serial_jtag_pull_override_vals_t connect = {
+        .dp_pu = 1,
+        .dm_pu = 0,
+        .dp_pd = 0,
+        .dm_pd = 0,
+    };
+    usb_serial_jtag_ll_phy_enable_pull_override(&connect);
+
+    s_usj_installed = mik__usj_install_with_default_config();
+
+    usb_serial_jtag_ll_phy_disable_pull_override();
+#endif
+}
+
 /* ── NVS helpers ─────────────────────────────────────────────────── */
 
 const char* MIK__NVS_NS_ENV = "mik.env";

package/components/mikrojs/mik_sleep.cpp

@@ -1,9 +1,33 @@
 #include "driver/gpio.h"
+#include "driver/rtc_io.h"
 #include "esp_sleep.h"
 #include "soc/soc_caps.h"
 
 #include "mikrojs/private.h"
 #include "mikrojs/utils.h"
+#include "mikrojs_esp32.h"
+
+/* For deep-sleep wakeup, the chip's digital pad config (set by `pinMode`)
+ * doesn't persist — only the RTC-IO pad does. Without an explicit RTC
+ * pull, EXT0/EXT1 pins float and trigger spurious wakes. Configure the
+ * RTC pull to the opposite of the wake direction so the pin idles in
+ * the non-trigger state and a button press flips it. */
+static void mik__rtc_pull_for_wake(int pin, bool wake_on_high) {
+#if SOC_RTCIO_INPUT_OUTPUT_SUPPORTED
+    if (!rtc_gpio_is_valid_gpio(static_cast<gpio_num_t>(pin))) return;
+    gpio_num_t g = static_cast<gpio_num_t>(pin);
+    rtc_gpio_pullup_dis(g);
+    rtc_gpio_pulldown_dis(g);
+    if (wake_on_high) {
+        rtc_gpio_pulldown_en(g);
+    } else {
+        rtc_gpio_pullup_en(g);
+    }
+#else
+    (void)pin;
+    (void)wake_on_high;
+#endif
+}
 
 static const char* mik__wakeup_cause_str(uint32_t causes) {
     if (causes & BIT(ESP_SLEEP_WAKEUP_TIMER)) return "timer";
@@ -15,17 +39,221 @@ static const char* mik__wakeup_cause_str(uint32_t causes) {
     return "undefined";
 }
 
+/* ── Wakeup source configuration ───────────────────────────────────── */
+
+static bool mik__configure_timer(JSContext* ctx, JSValue sources) {
+    JSValue v = JS_GetPropertyStr(ctx, sources, "timer");
+    bool ok = true;
+    if (!JS_IsUndefined(v)) {
+        double ms;
+        if (JS_ToFloat64(ctx, &ms, v)) {
+            ok = false;
+        } else if (ms < 0) {
+            JS_ThrowRangeError(ctx, "timer must be >= 0");
+            ok = false;
+        } else {
+            uint64_t us = static_cast<uint64_t>(ms * 1000.0);
+            esp_err_t err = esp_sleep_enable_timer_wakeup(us);
+            if (err != ESP_OK) {
+                JS_ThrowInternalError(ctx, "timer wakeup failed: %s", esp_err_to_name(err));
+                ok = false;
+            }
+        }
+    }
+    JS_FreeValue(ctx, v);
+    return ok;
+}
+
+static bool mik__read_level(JSContext* ctx, JSValue obj, const char* key, int* out_level) {
+    JSValue v = JS_GetPropertyStr(ctx, obj, key);
+    const char* s = JS_ToCString(ctx, v);
+    JS_FreeValue(ctx, v);
+    if (!s) return false;
+    bool ok = true;
+    if (strcmp(s, "high") == 0)
+        *out_level = 1;
+    else if (strcmp(s, "low") == 0)
+        *out_level = 0;
+    else {
+        JS_ThrowRangeError(ctx, "%s must be 'high' or 'low'", key);
+        ok = false;
+    }
+    JS_FreeCString(ctx, s);
+    return ok;
+}
+
+static bool mik__configure_gpio(JSContext* ctx, JSValue sources) {
+    JSValue gpio = JS_GetPropertyStr(ctx, sources, "gpio");
+    if (JS_IsUndefined(gpio)) {
+        JS_FreeValue(ctx, gpio);
+        return true;
+    }
+
+    JSValue pin_val = JS_GetPropertyStr(ctx, gpio, "pin");
+    int32_t pin;
+    bool ok = !JS_ToInt32(ctx, &pin, pin_val);
+    JS_FreeValue(ctx, pin_val);
+
+    int level = 0;
+    if (ok) ok = mik__read_level(ctx, gpio, "level", &level);
+    JS_FreeValue(ctx, gpio);
+    if (!ok) return false;
+
+    gpio_int_type_t intr = (level == 1) ? GPIO_INTR_HIGH_LEVEL : GPIO_INTR_LOW_LEVEL;
+    esp_err_t err = gpio_wakeup_enable(static_cast<gpio_num_t>(pin), intr);
+    if (err != ESP_OK) {
+        JS_ThrowInternalError(ctx, "GPIO wakeup on pin %d failed: %s", pin, esp_err_to_name(err));
+        return false;
+    }
+    err = esp_sleep_enable_gpio_wakeup();
+    if (err != ESP_OK) {
+        JS_ThrowInternalError(ctx, "GPIO wakeup source failed: %s", esp_err_to_name(err));
+        return false;
+    }
+    return true;
+}
+
+static bool mik__configure_ext0(JSContext* ctx, JSValue sources) {
+    JSValue ext0 = JS_GetPropertyStr(ctx, sources, "ext0");
+    if (JS_IsUndefined(ext0)) {
+        JS_FreeValue(ctx, ext0);
+        return true;
+    }
+#if SOC_PM_SUPPORT_EXT0_WAKEUP
+    JSValue pin_val = JS_GetPropertyStr(ctx, ext0, "pin");
+    int32_t pin;
+    bool ok = !JS_ToInt32(ctx, &pin, pin_val);
+    JS_FreeValue(ctx, pin_val);
+
+    int level = 0;
+    if (ok) ok = mik__read_level(ctx, ext0, "level", &level);
+    JS_FreeValue(ctx, ext0);
+    if (!ok) return false;
+
+    mik__rtc_pull_for_wake(pin, level == 1);
+    esp_err_t err = esp_sleep_enable_ext0_wakeup(static_cast<gpio_num_t>(pin), level);
+    if (err != ESP_OK) {
+        JS_ThrowInternalError(ctx, "EXT0 wakeup on pin %d failed: %s", pin, esp_err_to_name(err));
+        return false;
+    }
+    return true;
+#else
+    JS_FreeValue(ctx, ext0);
+    JS_ThrowInternalError(ctx, "EXT0 wakeup is not supported on this chip");
+    return false;
+#endif
+}
+
+static bool mik__configure_ext1(JSContext* ctx, JSValue sources) {
+    JSValue ext1 = JS_GetPropertyStr(ctx, sources, "ext1");
+    if (JS_IsUndefined(ext1)) {
+        JS_FreeValue(ctx, ext1);
+        return true;
+    }
+#if SOC_PM_SUPPORT_EXT1_WAKEUP
+    JSValue pins_val = JS_GetPropertyStr(ctx, ext1, "pins");
+    JSValue len_val = JS_GetPropertyStr(ctx, pins_val, "length");
+    uint32_t pin_count;
+    bool ok = !JS_ToUint32(ctx, &pin_count, len_val);
+    JS_FreeValue(ctx, len_val);
+
+    uint64_t pin_mask = 0;
+    for (uint32_t i = 0; ok && i < pin_count; i++) {
+        JSValue pin_val = JS_GetPropertyUint32(ctx, pins_val, i);
+        int32_t pin;
+        if (JS_ToInt32(ctx, &pin, pin_val))
+            ok = false;
+        else
+            pin_mask |= (1ULL << pin);
+        JS_FreeValue(ctx, pin_val);
+    }
+    JS_FreeValue(ctx, pins_val);
+
+    int mode_value = 0;
+    if (ok) {
+        JSValue mode_val = JS_GetPropertyStr(ctx, ext1, "mode");
+        const char* mode_str = JS_ToCString(ctx, mode_val);
+        JS_FreeValue(ctx, mode_val);
+        if (!mode_str) {
+            ok = false;
+        } else {
+            if (strcmp(mode_str, "any-low") == 0) {
+                // ESP32's EXT1 only ships ALL_LOW (wake when every selected pin
+                // is low); newer chips ship ANY_LOW. The two are equivalent for
+                // a single-pin mask, so we accept that case on ESP32 and route
+                // it through ALL_LOW. Multi-pin "any-low" can't be honored on
+                // ESP32 — the hardware always requires every pin to be low —
+                // so we reject it loudly rather than silently changing the
+                // wake condition.
+#if CONFIG_IDF_TARGET_ESP32
+                if (pin_count > 1) {
+                    JS_ThrowTypeError(
+                        ctx,
+                        "'any-low' with multiple pins is not supported on ESP32: "
+                        "hardware can only wake when all selected pins are low. "
+                        "Use one pin per ext1 source, or use 'any-high' mode.");
+                    ok = false;
+                } else {
+                    mode_value = ESP_EXT1_WAKEUP_ALL_LOW;
+                }
+#else
+                mode_value = ESP_EXT1_WAKEUP_ANY_LOW;
+#endif
+            } else if (strcmp(mode_str, "any-high") == 0) {
+                mode_value = ESP_EXT1_WAKEUP_ANY_HIGH;
+            } else {
+                JS_ThrowRangeError(ctx, "ext1.mode must be 'any-low' or 'any-high'");
+                ok = false;
+            }
+            JS_FreeCString(ctx, mode_str);
+        }
+    }
+    JS_FreeValue(ctx, ext1);
+    if (!ok) return false;
+
+    const bool wake_on_high = mode_value == ESP_EXT1_WAKEUP_ANY_HIGH;
+    for (int pin = 0; pin < 64; pin++) {
+        if (pin_mask & (1ULL << pin)) {
+            mik__rtc_pull_for_wake(pin, wake_on_high);
+        }
+    }
+    esp_err_t err = esp_sleep_enable_ext1_wakeup(
+        pin_mask, static_cast<esp_sleep_ext1_wakeup_mode_t>(mode_value));
+    if (err != ESP_OK) {
+        JS_ThrowInternalError(ctx, "EXT1 wakeup failed: %s", esp_err_to_name(err));
+        return false;
+    }
+    return true;
+#else
+    JS_FreeValue(ctx, ext1);
+    JS_ThrowInternalError(ctx, "EXT1 wakeup is not supported on this chip");
+    return false;
+#endif
+}
+
+/* Clears any previously-configured sources, then applies the ones in
+ * `sources`. Throws and returns false on any error. */
+static bool mik__configure_wakeup_sources(JSContext* ctx, JSValue sources) {
+    if (!JS_IsObject(sources)) {
+        JS_ThrowTypeError(ctx, "wakeup sources must be an object");
+        return false;
+    }
+    esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_ALL);
+    if (!mik__configure_timer(ctx, sources)) return false;
+    if (!mik__configure_gpio(ctx, sources)) return false;
+    if (!mik__configure_ext0(ctx, sources)) return false;
+    if (!mik__configure_ext1(ctx, sources)) return false;
+    return true;
+}
+
 /* ── native:sleep JS module ─────────────────────────────────────────── */
 
 static JSValue mik__sleep_deep(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
-    int64_t ms;
-    if (JS_ToInt64(ctx, &ms, argv[0])) return JS_EXCEPTION;
+    if (!mik__configure_wakeup_sources(ctx, argv[0])) return JS_EXCEPTION;
 
-    if (ms > 0) {
-        esp_err_t err = esp_sleep_enable_timer_wakeup(static_cast<uint64_t>(ms) * 1000);
-        if (err != ESP_OK)
-            return JS_ThrowInternalError(ctx, "timer wakeup failed: %s", esp_err_to_name(err));
-    }
+    /* Flush + close the file log so the buffered line buffer and stdio
+     * buffer make it to flash; deep sleep reboots the chip otherwise. */
+    mik_logfile_close();
 
     /* Note: we intentionally do NOT call MIK_FreeRuntime() here.  We are inside
      * a JS function call, so the runtime still has live GC objects on the call
@@ -37,23 +265,19 @@ static JSValue mik__sleep_deep(JSContext* ctx, JSValue this_val, int argc, JSVal
 }
 
 static JSValue mik__sleep_light(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
-    int64_t ms;
-    if (JS_ToInt64(ctx, &ms, argv[0])) return JS_EXCEPTION;
-
-    if (ms > 0) {
-        esp_err_t err = esp_sleep_enable_timer_wakeup(static_cast<uint64_t>(ms) * 1000);
-        if (err != ESP_OK)
-            return mik__result_err_named(ctx, "WakeupConfigFailed",
-                                         "failed to enable timer wakeup: %s",
-                                         esp_err_to_name(err));
-    }
+    if (!mik__configure_wakeup_sources(ctx, argv[0])) return JS_EXCEPTION;
 
+    /* Tear down USB before sleeping so the host sees a clean unplug,
+     * not a silent enumerated-but-asleep device. This lets `mikro dev`
+     * trigger its existing reconnect path. Restored after wake. */
+    mik__serial_io_detach_usb();
     esp_err_t err = esp_light_sleep_start();
+    mik__serial_io_attach_usb();
+
     if (err != ESP_OK)
-        return mik__result_err_named(ctx, "LightSleepFailed",
-                                     "light sleep failed: %s", esp_err_to_name(err));
+        return JS_ThrowInternalError(ctx, "light sleep failed: %s", esp_err_to_name(err));
 
-    return mik__result_ok_void(ctx);
+    return JS_UNDEFINED;
 }
 
 static JSValue mik__sleep_get_wakeup_cause(JSContext* ctx, JSValue this_val, int argc,
@@ -62,126 +286,24 @@ static JSValue mik__sleep_get_wakeup_cause(JSContext* ctx, JSValue this_val, int
     return JS_NewString(ctx, mik__wakeup_cause_str(causes));
 }
 
-static JSValue mik__sleep_enable_timer_wakeup(JSContext* ctx, JSValue this_val, int argc,
-                                               JSValue* argv) {
-    int64_t us;
-    if (JS_ToInt64(ctx, &us, argv[0])) return JS_EXCEPTION;
-
-    esp_err_t err = esp_sleep_enable_timer_wakeup(static_cast<uint64_t>(us));
-    if (err != ESP_OK)
-        return mik__result_err_named(ctx, "WakeupConfigFailed",
-                                     "failed to enable timer wakeup: %s", esp_err_to_name(err));
-
-    return mik__result_ok_void(ctx);
-}
-
-static JSValue mik__sleep_enable_gpio_wakeup(JSContext* ctx, JSValue this_val, int argc,
+static JSValue mik__sleep_can_wake_from_ext0(JSContext* ctx, JSValue this_val, int argc,
                                               JSValue* argv) {
-    int32_t pin, level;
-    if (JS_ToInt32(ctx, &pin, argv[0])) return JS_EXCEPTION;
-    if (JS_ToInt32(ctx, &level, argv[1])) return JS_EXCEPTION;
-
-    esp_err_t err =
-        gpio_wakeup_enable(static_cast<gpio_num_t>(pin), static_cast<gpio_int_type_t>(level));
-    if (err != ESP_OK)
-        return mik__result_err_named(ctx, "WakeupConfigFailed",
-                                     "failed to enable GPIO wakeup on pin %d: %s", pin,
-                                     esp_err_to_name(err));
-
-    err = esp_sleep_enable_gpio_wakeup();
-    if (err != ESP_OK)
-        return mik__result_err_named(ctx, "WakeupConfigFailed",
-                                     "failed to enable GPIO wakeup source: %s",
-                                     esp_err_to_name(err));
-
-    return mik__result_ok_void(ctx);
-}
-
-/* EXT0 / EXT1 wakeup is chip-specific (not on ESP32-C3, C6, H2). We still
- * register the JS exports unconditionally so `mikrojs/sleep`'s static
- * re-exports resolve on every target; the function bodies return a
- * `WakeupConfigFailed` error on chips where the capability is missing. */
-static JSValue mik__sleep_enable_ext0_wakeup(JSContext* ctx, JSValue this_val, int argc,
-                                             JSValue* argv) {
 #if SOC_PM_SUPPORT_EXT0_WAKEUP
-    int32_t pin, level;
-    if (JS_ToInt32(ctx, &pin, argv[0])) return JS_EXCEPTION;
-    if (JS_ToInt32(ctx, &level, argv[1])) return JS_EXCEPTION;
-
-    esp_err_t err = esp_sleep_enable_ext0_wakeup(static_cast<gpio_num_t>(pin), level);
-    if (err != ESP_OK)
-        return mik__result_err_named(ctx, "WakeupConfigFailed",
-                                     "failed to enable EXT0 wakeup on pin %d: %s", pin,
-                                     esp_err_to_name(err));
-
-    return mik__result_ok_void(ctx);
+    return JS_TRUE;
 #else
-    return mik__result_err_named(ctx, "WakeupConfigFailed",
-                                 "EXT0 wakeup is not supported on this chip");
+    return JS_FALSE;
 #endif
 }
 
-static JSValue mik__sleep_enable_ext1_wakeup(JSContext* ctx, JSValue this_val, int argc,
-                                             JSValue* argv) {
+static JSValue mik__sleep_can_wake_from_ext1(JSContext* ctx, JSValue this_val, int argc,
+                                              JSValue* argv) {
 #if SOC_PM_SUPPORT_EXT1_WAKEUP
-    int64_t pin_mask;
-    int32_t mode;
-    if (JS_ToInt64(ctx, &pin_mask, argv[0])) return JS_EXCEPTION;
-    if (JS_ToInt32(ctx, &mode, argv[1])) return JS_EXCEPTION;
-
-    esp_err_t err = esp_sleep_enable_ext1_wakeup(static_cast<uint64_t>(pin_mask),
-                                                  static_cast<esp_sleep_ext1_wakeup_mode_t>(mode));
-    if (err != ESP_OK)
-        return mik__result_err_named(ctx, "WakeupConfigFailed",
-                                     "failed to enable EXT1 wakeup: %s", esp_err_to_name(err));
-
-    return mik__result_ok_void(ctx);
+    return JS_TRUE;
 #else
-    return mik__result_err_named(ctx, "WakeupConfigFailed",
-                                 "EXT1 wakeup is not supported on this chip");
+    return JS_FALSE;
 #endif
 }
 
-static JSValue mik__sleep_disable_wakeup_source(JSContext* ctx, JSValue this_val, int argc,
-                                                 JSValue* argv) {
-    esp_sleep_source_t source = ESP_SLEEP_WAKEUP_ALL;
-
-    if (argc > 0 && !JS_IsUndefined(argv[0])) {
-        const char* str = JS_ToCString(ctx, argv[0]);
-        if (!str) return JS_EXCEPTION;
-
-        bool valid = true;
-        if (strcmp(str, "timer") == 0)
-            source = ESP_SLEEP_WAKEUP_TIMER;
-        else if (strcmp(str, "ext0") == 0)
-            source = ESP_SLEEP_WAKEUP_EXT0;
-        else if (strcmp(str, "ext1") == 0)
-            source = ESP_SLEEP_WAKEUP_EXT1;
-        else if (strcmp(str, "gpio") == 0)
-            source = ESP_SLEEP_WAKEUP_GPIO;
-        else if (strcmp(str, "touchpad") == 0)
-            source = ESP_SLEEP_WAKEUP_TOUCHPAD;
-        else if (strcmp(str, "ulp") == 0)
-            source = ESP_SLEEP_WAKEUP_ULP;
-        else
-            valid = false;
-
-        if (!valid) {
-            JSValue err = JS_ThrowRangeError(ctx, "unknown wakeup source: %s", str);
-            JS_FreeCString(ctx, str);
-            return err;
-        }
-        JS_FreeCString(ctx, str);
-    }
-
-    esp_err_t err = esp_sleep_disable_wakeup_source(source);
-    if (err != ESP_OK)
-        return mik__result_err_named(ctx, "DisableWakeupFailed",
-                                     "failed to disable wakeup source: %s", esp_err_to_name(err));
-
-    return mik__result_ok_void(ctx);
-}
-
 /* ── Module init ─────────────────────────────────────────────────── */
 
 static int mik__sleep_module_init(JSContext* ctx, JSModuleDef* m) {
@@ -192,20 +314,11 @@ static int mik__sleep_module_init(JSContext* ctx, JSModuleDef* m) {
     JS_SetModuleExport(ctx, m, "getWakeupCause",
                        JS_NewCFunction(ctx, mik__sleep_get_wakeup_cause, "getWakeupCause", 0));
     JS_SetModuleExport(
-        ctx, m, "enableTimerWakeup",
-        JS_NewCFunction(ctx, mik__sleep_enable_timer_wakeup, "enableTimerWakeup", 1));
-    JS_SetModuleExport(
-        ctx, m, "enableGpioWakeup",
-        JS_NewCFunction(ctx, mik__sleep_enable_gpio_wakeup, "enableGpioWakeup", 2));
-    JS_SetModuleExport(
-        ctx, m, "enableExt0Wakeup",
-        JS_NewCFunction(ctx, mik__sleep_enable_ext0_wakeup, "enableExt0Wakeup", 2));
-    JS_SetModuleExport(
-        ctx, m, "enableExt1Wakeup",
-        JS_NewCFunction(ctx, mik__sleep_enable_ext1_wakeup, "enableExt1Wakeup", 2));
+        ctx, m, "canWakeFromExt0",
+        JS_NewCFunction(ctx, mik__sleep_can_wake_from_ext0, "canWakeFromExt0", 0));
     JS_SetModuleExport(
-        ctx, m, "disableWakeupSource",
-        JS_NewCFunction(ctx, mik__sleep_disable_wakeup_source, "disableWakeupSource", 1));
+        ctx, m, "canWakeFromExt1",
+        JS_NewCFunction(ctx, mik__sleep_can_wake_from_ext1, "canWakeFromExt1", 0));
     return 0;
 }
 
@@ -215,11 +328,8 @@ static JSModuleDef* mik__sleep_init(JSContext* ctx) {
     JS_AddModuleExport(ctx, m, "deepSleep");
     JS_AddModuleExport(ctx, m, "lightSleep");
     JS_AddModuleExport(ctx, m, "getWakeupCause");
-    JS_AddModuleExport(ctx, m, "enableTimerWakeup");
-    JS_AddModuleExport(ctx, m, "enableGpioWakeup");
-    JS_AddModuleExport(ctx, m, "enableExt0Wakeup");
-    JS_AddModuleExport(ctx, m, "enableExt1Wakeup");
-    JS_AddModuleExport(ctx, m, "disableWakeupSource");
+    JS_AddModuleExport(ctx, m, "canWakeFromExt0");
+    JS_AddModuleExport(ctx, m, "canWakeFromExt1");
     return m;
 }
 

package/components/mikrojs/test/sleep_test.cpp

@@ -31,26 +31,17 @@ TEST_CASE("native:sleep exports expected functions", "[modules]") {
     setup();
 
     JSValue ret = eval_module(R"(
-        import {
-            deepSleep, lightSleep, getWakeupCause,
-            enableTimerWakeup, enableGpioWakeup,
-            disableWakeupSource
-        } from "native:sleep";
+        import { deepSleep, lightSleep, getWakeupCause } 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++) {
+    const char* names[] = {"__deepSleep", "__lightSleep", "__getWakeupCause"};
+    for (int i = 0; i < 3; i++) {
         JSValue v = JS_GetPropertyStr(ctx, global, names[i]);
         TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, v), names[i]);
         JS_FreeValue(ctx, v);
@@ -92,77 +83,15 @@ TEST_CASE("native:sleep getWakeupCause returns a string", "[modules]") {
     teardown();
 }
 
-/* ── enableTimerWakeup accepts microseconds ──────────────────────── */
+/* ── invalid gpio.level throws RangeError ────────────────────────── */
 
-TEST_CASE("native:sleep enableTimerWakeup does not throw", "[modules]") {
+TEST_CASE("native:sleep lightSleep throws RangeError on invalid level", "[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";
+        import { lightSleep } from "native:sleep";
         try {
-            disableWakeupSource("invalid");
+            lightSleep({gpio: {pin: 0, level: "bogus"}});
             globalThis.__threw = false;
         } catch (e) {
             globalThis.__threw = true;
@@ -174,8 +103,7 @@ TEST_CASE("native:sleep disableWakeupSource throws on invalid source", "[modules
     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");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, threw), "lightSleep should throw on invalid level");
     JS_FreeValue(ctx, threw);
 
     JSValue isRange = JS_GetPropertyStr(ctx, global, "__isRangeError");
@@ -190,19 +118,19 @@ TEST_CASE("native:sleep disableWakeupSource throws on invalid source", "[modules
 /* 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]") {
+TEST_CASE("native:sleep lightSleep with 1us timer returns or rejects gracefully", "[modules]") {
 #if !SOC_USB_SERIAL_JTAG_SUPPORTED
-    TEST_IGNORE_MESSAGE("light sleep disconnects UART console — skipped on non-USB targets");
+    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);
+            lightSleep({timer: 1});
             globalThis.__result = "ok";
         } catch (e) {
-            // Light sleep may fail on boards with USB JTAG or other constraints
+            /* Light sleep may throw on boards with USB JTAG or other constraints */
             globalThis.__result = "caught:" + e.message;
         }
     )");
@@ -212,7 +140,7 @@ TEST_CASE("native:sleep lightSleep with 1ms returns or rejects gracefully", "[mo
     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 */
+    /* Either "ok" (sleep succeeded) or "caught:..." (threw a catchable error) */
     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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikrojs/firmware",
-  "version": "0.8.0-pr-115.g87a99f9",
+  "version": "0.8.0",
   "description": "Mikro.js ESP32 firmware: ESP-IDF component, build tools, and project template",
   "keywords": [
     "esp-idf",
@@ -51,8 +51,8 @@
   },
   "dependencies": {
     "esbuild": "^0.28.0",
-    "@mikrojs/native": "0.8.0-pr-115.g87a99f9",
-    "@mikrojs/quickjs": "0.8.0-pr-115.g87a99f9"
+    "@mikrojs/quickjs": "0.8.0",
+    "@mikrojs/native": "0.8.0"
   },
   "engines": {
     "node": ">=24.0.0"