@mikrojs/firmware 0.6.0-pr-72.g464c29c → 0.6.1

package/components/mikrojs/CMakeLists.txt

@@ -65,6 +65,7 @@ idf_component_register(
     "${MIK_SRC_DIR}/mik_cbor.cpp"
     "${MIK_SRC_DIR}/mik_result.cpp"
     "${MIK_SRC_DIR}/mik_udp.cpp"
+    "${MIK_SRC_DIR}/mik_observable.cpp"
     "${MIK_SRC_DIR}/mikrojs.cpp"
     # nanocbor CBOR codec
     "${MIK_NANOCBOR_DIR}/src/encoder.c"
@@ -131,7 +132,7 @@ include("${MIK_BYTECODE_CMAKE}")
 
 # Force linker to include self-registering native modules
 set(_MIK_MODULES cbor pin i2c spi http wifi rtc nvs_kv sntp sleep neopixel pwm uart)
-set(_MIK_BYTECODE_MODULES cbor env result schema fs http/helpers http/request i2c kv/nvs kv/rtc kv/shared neopixel pin pwm reader sleep spi sntp stdio stream sys test uart udp wifi)
+set(_MIK_BYTECODE_MODULES cbor env result schema fs http/helpers http/request i2c kv/nvs kv/rtc kv/shared neopixel observable observable/lazy observable/operators pin pwm reader sleep spi sntp stdio stream sys test uart udp wifi)
 if(CONFIG_BT_ENABLED)
     list(APPEND _MIK_MODULES ble)
     list(APPEND _MIK_BYTECODE_MODULES ble)

package/components/mikrojs/mik_wifi.cpp

@@ -9,6 +9,7 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/queue.h"
 #include "nvs_flash.h"
+#include "mikrojs/platform.h"
 #include "private.h"
 #include "utils.h"
 
@@ -251,7 +252,29 @@ static void mik__wifi_event_handler(void* arg, esp_event_base_t event_base, int3
     }
 }
 
-esp_err_t mik__wifi_ensure_initialized() {
+/* Pick the DHCP hostname for the STA netif: configured `wifi.hostname` from
+ * mikro.config.json takes priority; otherwise default to `mikrojs-<device-id>`.
+ * Returns true if a hostname was applied. */
+static bool mik__wifi_apply_hostname(JSContext* ctx) {
+    if (!s_sta_netif) return false;
+    char buf[64];
+    const char* hostname = nullptr;
+    if (ctx) {
+        MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
+        if (mik_rt && mik_rt->config.wifi_hostname[0] != '\0') {
+            hostname = mik_rt->config.wifi_hostname;
+        }
+    }
+    if (!hostname) {
+        const char* dev_id = MIK_GetPlatform()->get_device_id();
+        if (!dev_id || !dev_id[0]) return false;
+        snprintf(buf, sizeof(buf), "mikrojs-%s", dev_id);
+        hostname = buf;
+    }
+    return esp_netif_set_hostname(s_sta_netif, hostname) == ESP_OK;
+}
+
+esp_err_t mik__wifi_ensure_initialized(JSContext* ctx) {
     if (s_wifi_initialized) return ESP_OK;
 
     esp_err_t err = nvs_flash_init();
@@ -272,6 +295,7 @@ esp_err_t mik__wifi_ensure_initialized() {
      * asserting in esp_netif_create_default_wifi_sta. */
     if (!s_sta_netif) {
         s_sta_netif = esp_netif_create_default_wifi_sta();
+        if (s_sta_netif) mik__wifi_apply_hostname(ctx);
     }
     if (!s_sta_netif) return ESP_FAIL;
 
@@ -310,8 +334,8 @@ fail_after_init:
 
 /* Start the WiFi radio.  Deferred from init so the radio is not active
  * until connect() or scan() is actually called. */
-static esp_err_t mik__wifi_ensure_started() {
-    esp_err_t err = mik__wifi_ensure_initialized();
+static esp_err_t mik__wifi_ensure_started(JSContext* ctx) {
+    esp_err_t err = mik__wifi_ensure_initialized(ctx);
     if (err != ESP_OK) return err;
     if (s_wifi_started) return ESP_OK;
 
@@ -374,7 +398,7 @@ static JSClassDef mik_wifi_classdef = {
 };
 
 static JSValue mik__wifi_constructor(JSContext* ctx, JSValue new_target, int argc, JSValue* argv) {
-    esp_err_t err = mik__wifi_ensure_initialized();
+    esp_err_t err = mik__wifi_ensure_initialized(ctx);
     if (err != ESP_OK) {
         return JS_ThrowInternalError(ctx, "WiFi init failed: %s", esp_err_to_name(err));
     }
@@ -386,7 +410,7 @@ static JSValue mik__wifi_connect(JSContext* ctx, JSValue this_val, int argc, JSV
         return mik__result_err_tag(ctx, "CountryNotSet");
     }
 
-    esp_err_t start_err = mik__wifi_ensure_started();
+    esp_err_t start_err = mik__wifi_ensure_started(ctx);
     if (start_err != ESP_OK) {
         return mik__result_err_named(ctx, "StartFailed",
                                "Failed to start WiFi radio: %s", esp_err_to_name(start_err));
@@ -478,7 +502,7 @@ static JSValue mik__wifi_scan(JSContext* ctx, JSValue this_val, int argc, JSValu
         return mik__result_err_tag(ctx, "CountryNotSet");
     }
 
-    esp_err_t start_err = mik__wifi_ensure_started();
+    esp_err_t start_err = mik__wifi_ensure_started(ctx);
     if (start_err != ESP_OK) {
         return mik__result_err_named(ctx, "StartFailed",
                                "Failed to start WiFi radio: %s", esp_err_to_name(start_err));
@@ -631,22 +655,6 @@ static JSValue mik__wifi_get_hostname(JSContext* ctx, JSValue this_val, int argc
     return JS_NewString(ctx, hostname);
 }
 
-static JSValue mik__wifi_set_hostname(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
-    if (!s_sta_netif) {
-        return mik__result_err_tag(ctx, "NotInitialized");
-    }
-    const char* hostname = JS_ToCString(ctx, argv[0]);
-    if (!hostname) return JS_EXCEPTION;
-
-    esp_err_t err = esp_netif_set_hostname(s_sta_netif, hostname);
-    JS_FreeCString(ctx, hostname);
-    if (err != ESP_OK) {
-        return mik__result_err_named(ctx, "SetFailed",
-                               "Failed to set hostname: %s", esp_err_to_name(err));
-    }
-    return mik__result_ok_void(ctx);
-}
-
 static JSValue mik__wifi_get_ip_config(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
     if (!s_sta_netif) {
         return JS_UNDEFINED;
@@ -746,7 +754,7 @@ static JSValue mik__wifi_ap_start(JSContext* ctx, JSValue this_val, int argc, JS
         return mik__result_err_tag(ctx, "CountryNotSet");
     }
 
-    esp_err_t err = mik__wifi_ensure_started();
+    esp_err_t err = mik__wifi_ensure_started(ctx);
     if (err != ESP_OK) {
         return mik__result_err_named(ctx, "StartFailed",
                                "Failed to start WiFi radio: %s", esp_err_to_name(err));
@@ -952,26 +960,11 @@ static JSValue mik__wifi_get_country(JSContext* ctx, JSValue this_val, int argc,
     return JS_NewStringLen(ctx, cc, 2);
 }
 
-static JSValue mik__wifi_set_country(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
-    const char* cc = JS_ToCString(ctx, argv[0]);
-    if (!cc) return JS_EXCEPTION;
-
-    esp_err_t err = esp_wifi_set_country_code(cc, true);
-    JS_FreeCString(ctx, cc);
-
-    if (err != ESP_OK) {
-        return mik__result_err_named(ctx, "SetFailed",
-                               "Failed to set WiFi country code: %s", esp_err_to_name(err));
-    }
-    s_country_configured = true;
-    return mik__result_ok_void(ctx);
-}
-
 /* ── TX power ──────────────────────────────────────────────────────── */
 
 static JSValue mik__wifi_get_tx_power(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
     /* esp_wifi_get_max_tx_power requires the radio to be started. */
-    esp_err_t start_err = mik__wifi_ensure_started();
+    esp_err_t start_err = mik__wifi_ensure_started(ctx);
     if (start_err != ESP_OK) {
         return mik__result_err_named(ctx, "GetFailed",
                                "Failed to get TX power: %s", esp_err_to_name(start_err));
@@ -988,7 +981,7 @@ static JSValue mik__wifi_get_tx_power(JSContext* ctx, JSValue this_val, int argc
 static JSValue mik__wifi_set_tx_power(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
     double dbm;
     if (JS_ToFloat64(ctx, &dbm, argv[0])) return JS_EXCEPTION;
-    esp_err_t start_err = mik__wifi_ensure_started();
+    esp_err_t start_err = mik__wifi_ensure_started(ctx);
     if (start_err != ESP_OK) {
         return mik__result_err_named(ctx, "SetFailed",
                                "Failed to set TX power: %s", esp_err_to_name(start_err));
@@ -1097,7 +1090,6 @@ static const JSCFunctionListEntry mik__wifi_proto_funcs[] = {
     MIK_CFUNC_DEF("off", 2, mik__wifi_off),
     MIK_CFUNC_DEF("mac", 0, mik__wifi_mac),
     MIK_CFUNC_DEF("getHostname", 0, mik__wifi_get_hostname),
-    MIK_CFUNC_DEF("setHostname", 1, mik__wifi_set_hostname),
     MIK_CFUNC_DEF("getIpConfig", 0, mik__wifi_get_ip_config),
     MIK_CFUNC_DEF("setIpConfig", 1, mik__wifi_set_ip_config),
     MIK_CFUNC_DEF("apStart", 1, mik__wifi_ap_start),
@@ -1108,7 +1100,6 @@ static const JSCFunctionListEntry mik__wifi_proto_funcs[] = {
     MIK_CFUNC_DEF("getPowerSave", 0, mik__wifi_get_power_save),
     MIK_CFUNC_DEF("setPowerSave", 1, mik__wifi_set_power_save),
     MIK_CFUNC_DEF("getCountry", 0, mik__wifi_get_country),
-    MIK_CFUNC_DEF("setCountry", 1, mik__wifi_set_country),
     MIK_CFUNC_DEF("getTxPower", 0, mik__wifi_get_tx_power),
     MIK_CFUNC_DEF("setTxPower", 1, mik__wifi_set_tx_power),
     MIK_CFUNC_DEF("getRssiThreshold", 0, mik__wifi_get_rssi_threshold),

package/components/mikrojs/test/wifi_test.cpp

@@ -28,11 +28,15 @@ static void setup() {
     vTaskDelay(pdMS_TO_TICKS(100));
     rt = MIK_NewRuntime();
     ctx = MIK_GetJSContext(rt);
+    /* Country is config-only — populate it directly so wifi ops that gate on
+     * mik__wifi_try_auto_country can proceed. */
+    MIKConfig cfg;
+    MIK_DefaultConfig(&cfg);
+    snprintf(cfg.wifi_country, sizeof(cfg.wifi_country), "US");
+    MIK_SetConfig(rt, &cfg);
     /* WiFi module is self-registered and lazily initialized.
-     * The import below triggers init + loop consumer registration.
-     * Then drain any stale events from previous tests. */
-    const char* init_code =
-        "import { Wifi } from \"native:wifi\"; new Wifi().setCountry(\"US\");";
+     * The import below triggers init + loop consumer registration. */
+    const char* init_code = "import { Wifi } from \"native:wifi\"; new Wifi();";
     JSValue ret = MIK_EvalModuleContent(ctx, "mikrojs/test-setup", init_code, strlen(init_code));
     if (!JS_IsException(ret)) {
         JS_FreeValue(ctx, ret);
@@ -332,14 +336,22 @@ TEST_CASE("Wifi mac returns a valid MAC address format", "[wifi]") {
     teardown();
 }
 
-TEST_CASE("Wifi hostname get/set round-trips", "[wifi]") {
-    setup();
+TEST_CASE("Wifi hostname reflects configured wifi.hostname", "[wifi]") {
+    /* Custom setup with wifi.hostname populated. Mirrors setup() but injects
+     * a hostname before the lazy netif init runs. */
+    esp_wifi_disconnect();
+    vTaskDelay(pdMS_TO_TICKS(100));
+    rt = MIK_NewRuntime();
+    ctx = MIK_GetJSContext(rt);
+    MIKConfig cfg;
+    MIK_DefaultConfig(&cfg);
+    snprintf(cfg.wifi_country, sizeof(cfg.wifi_country), "US");
+    snprintf(cfg.wifi_hostname, sizeof(cfg.wifi_hostname), "test-device");
+    MIK_SetConfig(rt, &cfg);
 
     JSValue ret = eval_module(R"(
         import { Wifi } from "native:wifi";
-        const wifi = new Wifi();
-        wifi.setHostname("test-device");
-        globalThis.__hostname = wifi.getHostname();
+        globalThis.__hostname = new Wifi().getHostname();
     )");
     TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
 
@@ -446,13 +458,15 @@ TEST_CASE("Wifi power save get/set round-trips", "[wifi]") {
     teardown();
 }
 
-TEST_CASE("Wifi country get/set round-trips", "[wifi]") {
+TEST_CASE("Wifi country reflects configured wifi.country", "[wifi]") {
     setup();
 
+    /* setup() populated wifi_country = "US"; trigger a wifi op so
+     * mik__wifi_try_auto_country applies it, then read back via getCountry. */
     JSValue ret = eval_module(R"(
         import { Wifi } from "native:wifi";
         const wifi = new Wifi();
-        wifi.setCountry("US");
+        wifi.scan();
         globalThis.__cc = wifi.getCountry();
     )");
     TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikrojs/firmware",
-  "version": "0.6.0-pr-72.g464c29c",
+  "version": "0.6.1",
   "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.6.0-pr-72.g464c29c",
-    "@mikrojs/quickjs": "0.6.0-pr-72.g464c29c"
+    "@mikrojs/quickjs": "0.6.1",
+    "@mikrojs/native": "0.6.1"
   },
   "engines": {
     "node": ">=24.0.0"

package/sdkconfig.defaults

@@ -132,13 +132,3 @@ CONFIG_MBEDTLS_ECP_DP_BP512R1_ENABLED=n
 CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_CMN=y
 CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_CROSS_SIGNED_VERIFY=y
 
-# TLS record buffers must come from internal SRAM. The ESP-IDF default for
-# the inbound buffer is 16 KB, which competes with QuickJS heap allocations
-# for contiguous internal SRAM and causes HTTPS handshake failures (error
-# 0x7002) on apps with significant retained JS state. Halving it to 8 KB
-# leaves enough room for typical TLS records (handshake fragments are well
-# under 4 KB; modern servers rarely send >4 KB application records, and
-# mbedTLS will fragment larger records). The outbound buffer was already
-# 4 KB via CONFIG_MBEDTLS_ASYMMETRIC_CONTENT_LEN=y.
-CONFIG_MBEDTLS_SSL_IN_CONTENT_LEN=8192
-