@mikrojs/firmware 0.6.1 → 0.7.0

package/components/mikrojs/CMakeLists.txt

@@ -83,6 +83,7 @@ idf_component_register(
     "mik_deploy.cpp"
     "mik_http.cpp"
     "mik_i2c.cpp"
+    "mik_logfile.cpp"
     "mik_neopixel.cpp"
     "mik_pin.cpp"
     "mik_pwm.cpp"

package/components/mikrojs/include/mikrojs_esp32.h

@@ -41,6 +41,26 @@ int mik__console_read(void* buf, size_t len);
 /* Write to the active console.  Returns bytes written. */
 int mik__console_write(const void* buf, size_t len);
 
+/* Tap installed by mik_logfile so console output is mirrored into the
+ * on-device log file. Called from mik__console_write before the actual
+ * UART/USB-JTAG write, so output is captured even when no host is
+ * attached. Single slot; mik_logfile owns it. */
+typedef void (*mik_console_tap_fn)(const void* buf, size_t len);
+void mik__console_set_tap(mik_console_tap_fn fn);
+
+/* File logging (mik_logfile.cpp).
+ * Initialized after MIK_LoadConfig once the filesystem is mounted.
+ * No-op when MIKConfig.log_file is empty. */
+typedef struct MIKConfig MIKConfig;
+void mik_logfile_init(const MIKConfig* config);
+void mik_logfile_close(void);
+void mik_logfile_flush(void);
+/* Release/restore the underlying FILE* so the host can read the file
+ * without contention. Output between suspend/resume is dropped. No-op
+ * when file logging is disabled. */
+void mik_logfile_suspend(void);
+void mik_logfile_resume(void);
+
 /* Serial binary I/O (mik_serial_io.cpp) */
 void mik__serial_binary_begin_no_echo(void);
 

package/components/mikrojs/mik_deploy.cpp

@@ -582,3 +582,53 @@ bool mik__handle_deploy_command(MIKReplTransport* transport, uint8_t cmd_type,
             return false;
     }
 }
+
+/*
+ * Handle MIK_CMD_FS_GET: stream the contents of a file off the device.
+ * Payload: u16le path_len | path.
+ * Suspends the file logger so its buffered writes are flushed to disk and
+ * its FILE* released before we open the same path for reading, then
+ * resumes it once streaming is done.
+ */
+bool mik__handle_fs_get(MIKReplTransport* transport, uint32_t payload_len) {
+    if (payload_len < 2) {
+        mik__proto_drain(transport, payload_len);
+        mik__proto_send_err(transport, "fs get: short header");
+        return true;
+    }
+    uint8_t nl[2];
+    if (!mik__proto_read_exact(transport, nl, 2)) return false;
+    uint16_t path_len = nl[0] | (nl[1] << 8);
+    if (path_len == 0 || path_len >= 256 || (uint32_t)path_len + 2 > payload_len) {
+        mik__proto_drain(transport, payload_len - 2);
+        mik__proto_send_err(transport, "fs get: bad path length");
+        return true;
+    }
+    char path[256];
+    if (!mik__proto_read_exact(transport, path, path_len)) return false;
+    path[path_len] = '\0';
+    uint32_t consumed = 2 + (uint32_t)path_len;
+    if (payload_len > consumed) mik__proto_drain(transport, payload_len - consumed);
+
+    mik_logfile_suspend();
+
+    FILE* f = fopen(path, "r");
+    if (!f) {
+        char msg[160];
+        snprintf(msg, sizeof(msg), "fs get: open failed: %s", strerror(errno));
+        mik__proto_send_err(transport, msg);
+        mik_logfile_resume();
+        return true;
+    }
+
+    uint8_t buf[512];
+    for (;;) {
+        size_t n = fread(buf, 1, sizeof(buf), f);
+        if (n == 0) break;
+        mik__proto_send(transport, MIK_MSG_FS_CHUNK, buf, n);
+    }
+    fclose(f);
+    mik_logfile_resume();
+    mik__proto_send_ok(transport);
+    return true;
+}

package/components/mikrojs/mik_http.cpp

@@ -668,15 +668,48 @@ static JSValue mik__http_next_message(JSContext* ctx, JSValue this_val, int argc
     return promise;
 }
 
-/* pendingCount() — number of in-flight requests whose terminal message has
- * not yet been consumed. Useful for tests that want to verify cancel+drain
- * freed a slot without relying on heap-headroom for a follow-up request. */
+/* Forward decl: defined further down, called here so pendingCount() drains
+ * result_queue before reading the counter. */
+void mik__http_consume(JSContext* ctx);
+
+/* pendingCount() — number of in-flight requests with work still visible to
+ * JS (headers/body not yet delivered, not cancelled). Useful for tests that
+ * want to verify cancel+drain freed a slot without relying on heap-headroom
+ * for a follow-up request.
+ *
+ * Semantic shift vs. a "raw slot count": this returns the JS-visible pending
+ * count, not the native slot count. Cancelled-but-not-yet-drained entries
+ * still occupy a native slot (until the BG task wakes from a blocking call
+ * and posts its terminal message) but are excluded from this count. If you
+ * need to know whether a follow-up `request()` will hit TooManyPending, this
+ * is not the right number — the slot may still be held. See
+ * MIK_HTTP_MAX_PENDING and the js_cancelled exclusion below.
+ *
+ * Drains result_queue first via the consume loop. Without this, a request
+ * whose native task has already posted its terminal message but whose
+ * message hasn't been processed by the next event-loop tick reads as
+ * "still pending" — even though it'd drop microseconds later. Surfaced
+ * as an intermittent "in-flight HTTP request at teardown" warning when
+ * the test harness reads pendingCount() synchronously right after the
+ * last awaited test step. */
 static JSValue mik__http_pending_count(JSContext* ctx, JSValue this_val, int argc,
                                        JSValue* argv) {
     MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
     CHECK_NOT_NULL(mik_rt);
     if (!mik__http_st(mik_rt)) return JS_NewUint32(ctx, 0);
-    return JS_NewUint32(ctx, mik__http_st(mik_rt)->pending_count);
+    mik__http_consume(ctx);
+    /* Exclude explicitly-cancelled entries. JS has signalled intent to
+     * release; the entry stays alive only until the native task wakes
+     * from a blocking call (TLS handshake, DNS) and posts its terminal
+     * message. That's not a leak — counting it as one fires false
+     * "in-flight HTTP at teardown" warnings on tests that abort or
+     * time out a request and exit before the native task has noticed. */
+    MIKHttpState* state = mik__http_st(mik_rt);
+    uint32_t live = 0;
+    for (size_t i = 0; i < state->pending_count; i++) {
+        if (!state->pending[i].js_cancelled) live++;
+    }
+    return JS_NewUint32(ctx, live);
 }
 
 /* cancel(id) — signal a pending request to abort */

package/components/mikrojs/mik_logfile.cpp

@@ -0,0 +1,269 @@
+#include "mikrojs/mikrojs.h"
+#include "mikrojs/platform.h"
+#include "mikrojs/private.h"
+#include "mikrojs_esp32.h"
+
+#include <cstdarg>
+#include <cstdio>
+#include <cstring>
+#include <ctime>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+#include "esp_log.h"
+#include "esp_timer.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/semphr.h"
+
+static const char* TAG = "mik_logfile";
+
+/* Static buffers — total ~1.5 KiB plus a FreeRTOS mutex. */
+static char s_line_buf[512];        /* current line being assembled */
+static char s_stdio_buf[1024];      /* setvbuf target for the FILE* */
+static char s_path_main[96];        /* "<dir>/log.txt"   */
+static char s_path_rot[100];        /* "<dir>/log.txt.1" */
+static SemaphoreHandle_t s_mtx = nullptr;
+static FILE* s_file = nullptr;
+static size_t s_file_size = 0;
+static size_t s_line_pos = 0;
+static bool s_line_has_ts = false;
+static uint32_t s_max_size = 0;
+static MIKLogFlush s_flush_policy = MIK_LOG_FLUSH_ERROR;
+static vprintf_like_t s_prev_vprintf = nullptr;
+
+/* Time threshold for treating the RTC as wall-clock-set (Jan 1 2020). */
+static const time_t WALL_CLOCK_THRESHOLD = 1577836800;
+
+static int format_timestamp(char* buf, size_t buf_size) {
+    struct timeval tv;
+    gettimeofday(&tv, nullptr);
+    if (tv.tv_sec > WALL_CLOCK_THRESHOLD) {
+        struct tm tm;
+        gmtime_r(&tv.tv_sec, &tm);
+        return snprintf(buf, buf_size, "%04d-%02d-%02dT%02d:%02d:%02d.%03ldZ ",
+                        tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min,
+                        tm.tm_sec, (long)(tv.tv_usec / 1000));
+    }
+    int64_t us = esp_timer_get_time();
+    int64_t s = us / 1000000;
+    int64_t ms = (us / 1000) % 1000;
+    return snprintf(buf, buf_size, "[+%lld.%03llds] ", (long long)s, (long long)ms);
+}
+
+/* Recognize lines that should trigger an immediate fflush under flush='error'.
+ * Patterns: ESP_LOG ("E (12345)" / "W (12345)") and mikrojs platform.log
+ * ("[ERROR]" / "[WARN]"). False negatives just delay the flush — they don't
+ * lose data — so a conservative match is fine. */
+static bool line_is_error_level(const char* line, size_t len) {
+    if (len >= 2 && (line[0] == 'E' || line[0] == 'W') && line[1] == ' ') return true;
+    if (len >= 7 && memcmp(line, "[ERROR]", 7) == 0) return true;
+    if (len >= 6 && memcmp(line, "[WARN]", 6) == 0) return true;
+    return false;
+}
+
+/* Caller holds s_mtx. */
+static void rotate_if_needed() {
+    if (s_file_size < s_max_size) return;
+    fclose(s_file);
+    s_file = nullptr;
+    unlink(s_path_rot);
+    rename(s_path_main, s_path_rot);
+    s_file = fopen(s_path_main, "a");
+    if (s_file) {
+        setvbuf(s_file, s_stdio_buf, _IOFBF, sizeof(s_stdio_buf));
+        s_file_size = 0;
+    }
+}
+
+/* Caller holds s_mtx. */
+static void emit_line() {
+    if (s_line_pos == 0) return;
+    if (!s_file) {
+        s_line_pos = 0;
+        s_line_has_ts = false;
+        return;
+    }
+    size_t n = fwrite(s_line_buf, 1, s_line_pos, s_file);
+    s_file_size += n;
+    bool is_err = line_is_error_level(s_line_buf, s_line_pos);
+    if (s_flush_policy == MIK_LOG_FLUSH_LINE ||
+        (s_flush_policy == MIK_LOG_FLUSH_ERROR && is_err)) {
+        fflush(s_file);
+    }
+    rotate_if_needed();
+    s_line_pos = 0;
+    s_line_has_ts = false;
+}
+
+/* Caller holds s_mtx. */
+static void append_byte(uint8_t c) {
+    if (!s_line_has_ts) {
+        int n = format_timestamp(s_line_buf, sizeof(s_line_buf) - 1);
+        if (n < 0 || (size_t)n >= sizeof(s_line_buf) - 1) n = 0;
+        s_line_pos = (size_t)n;
+        s_line_has_ts = true;
+    }
+    if (s_line_pos < sizeof(s_line_buf) - 1) {
+        s_line_buf[s_line_pos++] = (char)c;
+    }
+    if (c == '\n' || s_line_pos >= sizeof(s_line_buf) - 1) {
+        if (s_line_pos == 0 || s_line_buf[s_line_pos - 1] != '\n') {
+            s_line_buf[s_line_pos++] = '\n';
+        }
+        emit_line();
+    }
+}
+
+static void console_tap(const void* buf, size_t len) {
+    if (!s_mtx) return;
+    if (xSemaphoreTake(s_mtx, pdMS_TO_TICKS(50)) != pdTRUE) return;
+    const uint8_t* p = (const uint8_t*)buf;
+    for (size_t i = 0; i < len; i++) append_byte(p[i]);
+    xSemaphoreGive(s_mtx);
+}
+
+/* Fired by mik__repl_proto_send_output before TLV framing. Gives us the
+ * un-wrapped body bytes plus the message type, so console.error etc.
+ * forces an immediate flush without relying on prefix pattern matching. */
+static void log_emit_tap(uint8_t msg_type, const void* data, size_t len) {
+    if (!s_mtx) return;
+    if (xSemaphoreTake(s_mtx, pdMS_TO_TICKS(50)) != pdTRUE) return;
+    const uint8_t* p = (const uint8_t*)data;
+    for (size_t i = 0; i < len; i++) append_byte(p[i]);
+    /* Ensure the line is closed even if the body lacks a trailing newline
+     * (mik__repl_proto_send_output is called once per logical message). */
+    if (s_line_pos > 0 && s_line_buf[s_line_pos - 1] != '\n') {
+        append_byte((uint8_t)'\n');
+    }
+    if (s_file && (msg_type == MIK_MSG_ERROR || msg_type == MIK_MSG_WARN ||
+                   msg_type == MIK_MSG_EVAL_ERROR)) {
+        fflush(s_file);
+    }
+    xSemaphoreGive(s_mtx);
+}
+
+static int log_vprintf_tap(const char* fmt, va_list args) {
+    /* Forward to the previously-installed vprintf so terminal output is
+     * unchanged, then format a copy into the line buffer for the file. */
+    va_list copy;
+    va_copy(copy, args);
+    int rv = s_prev_vprintf ? s_prev_vprintf(fmt, args) : vprintf(fmt, args);
+
+    if (s_mtx) {
+        char line[256];
+        int n = vsnprintf(line, sizeof(line), fmt, copy);
+        if (n > 0) {
+            if ((size_t)n >= sizeof(line)) n = (int)sizeof(line) - 1;
+            if (xSemaphoreTake(s_mtx, pdMS_TO_TICKS(50)) == pdTRUE) {
+                for (int i = 0; i < n; i++) append_byte((uint8_t)line[i]);
+                xSemaphoreGive(s_mtx);
+            }
+        }
+    }
+    va_end(copy);
+    return rv;
+}
+
+void mik_logfile_init(const MIKConfig* config) {
+    const MIKPlatform* platform = MIK_GetPlatform();
+    if (!config || config->log_dir[0] == '\0') return;
+    if (s_file) return;
+
+    /* Ensure the directory exists. mkdir errors when it already exists,
+     * which is fine. */
+    mkdir(config->log_dir, 0775);
+
+    if ((size_t)snprintf(s_path_main, sizeof(s_path_main), "%s/log.txt", config->log_dir) >=
+        sizeof(s_path_main)) {
+        platform->log(MIK_LOG_WARN, TAG, "log dir path too long");
+        return;
+    }
+    snprintf(s_path_rot, sizeof(s_path_rot), "%s.1", s_path_main);
+
+    s_mtx = xSemaphoreCreateMutex();
+    if (!s_mtx) return;
+
+    s_file = fopen(s_path_main, "a");
+    if (!s_file) {
+        platform->log(MIK_LOG_WARN, TAG, "Could not open log file");
+        vSemaphoreDelete(s_mtx);
+        s_mtx = nullptr;
+        return;
+    }
+    setvbuf(s_file, s_stdio_buf, _IOFBF, sizeof(s_stdio_buf));
+    fseek(s_file, 0, SEEK_END);
+    long pos = ftell(s_file);
+    s_file_size = pos > 0 ? (size_t)pos : 0;
+    s_max_size = config->log_max_size;
+    s_flush_policy = config->log_flush;
+
+    mik__console_set_tap(console_tap);
+    mik__set_log_emit_tap(log_emit_tap);
+    s_prev_vprintf = esp_log_set_vprintf(log_vprintf_tap);
+
+    platform->log(MIK_LOG_INFO, TAG, "File log enabled (size=%u, max=%u)",
+                  (unsigned)s_file_size, (unsigned)s_max_size);
+}
+
+void mik_logfile_suspend(void) {
+    if (!s_mtx) return;
+    if (xSemaphoreTake(s_mtx, pdMS_TO_TICKS(100)) != pdTRUE) return;
+    if (s_file) {
+        fflush(s_file);
+        fclose(s_file);
+        s_file = nullptr;
+    }
+    xSemaphoreGive(s_mtx);
+}
+
+void mik_logfile_resume(void) {
+    if (!s_mtx) return;
+    if (xSemaphoreTake(s_mtx, pdMS_TO_TICKS(100)) != pdTRUE) return;
+    if (!s_file) {
+        s_file = fopen(s_path_main, "a");
+        if (s_file) {
+            setvbuf(s_file, s_stdio_buf, _IOFBF, sizeof(s_stdio_buf));
+            fseek(s_file, 0, SEEK_END);
+            long pos = ftell(s_file);
+            s_file_size = pos > 0 ? (size_t)pos : 0;
+        }
+    }
+    xSemaphoreGive(s_mtx);
+}
+
+void mik_logfile_flush(void) {
+    if (!s_mtx || !s_file) return;
+    if (xSemaphoreTake(s_mtx, pdMS_TO_TICKS(50)) != pdTRUE) return;
+    fflush(s_file);
+    xSemaphoreGive(s_mtx);
+}
+
+void mik_logfile_close(void) {
+    if (!s_mtx) return;
+    if (xSemaphoreTake(s_mtx, pdMS_TO_TICKS(100)) != pdTRUE) return;
+    mik__console_set_tap(nullptr);
+    mik__set_log_emit_tap(nullptr);
+    if (s_prev_vprintf) {
+        esp_log_set_vprintf(s_prev_vprintf);
+        s_prev_vprintf = nullptr;
+    }
+    if (s_line_pos > 0) {
+        if (s_line_buf[s_line_pos - 1] != '\n' && s_line_pos < sizeof(s_line_buf)) {
+            s_line_buf[s_line_pos++] = '\n';
+        }
+        if (s_file) fwrite(s_line_buf, 1, s_line_pos, s_file);
+        s_line_pos = 0;
+    }
+    if (s_file) {
+        fflush(s_file);
+        fclose(s_file);
+        s_file = nullptr;
+    }
+    s_file_size = 0;
+    s_line_has_ts = false;
+    SemaphoreHandle_t mtx = s_mtx;
+    s_mtx = nullptr;
+    xSemaphoreGive(mtx);
+    vSemaphoreDelete(mtx);
+}

package/components/mikrojs/mik_main.cpp

@@ -127,6 +127,7 @@ bool mik__handle_deploy_command(MIKReplTransport* transport, uint8_t cmd_type,
                                 uint32_t payload_len);
 bool mik__handle_config_command(MIKReplTransport* transport, uint8_t cmd_type,
                                 uint32_t payload_len);
+bool mik__handle_fs_get(MIKReplTransport* transport, uint32_t payload_len);
 void mik__deploy_session_reset(void);
 
 static void platform_session_end(void* ctx) {
@@ -163,6 +164,11 @@ static bool platform_command_handler(MIKReplTransport* transport, uint8_t cmd_ty
         return mik__handle_deploy_command(transport, cmd_type, payload_len);
     }
 
+    /* File pull (0x2B) */
+    if (cmd_type == MIK_CMD_FS_GET) {
+        return mik__handle_fs_get(transport, payload_len);
+    }
+
     /* Config commands (0x40-0x42) */
     if (cmd_type >= MIK_CMD_CONFIG_LIST && cmd_type <= MIK_CMD_CONFIG_DELETE) {
         return mik__handle_config_command(transport, cmd_type, payload_len);
@@ -277,6 +283,9 @@ void MIK_Main(void) {
     MIKConfig app_config;
     MIK_LoadConfig("/appfs", &app_config);
 
+    /* Start file logging if configured (no-op when log_file is empty). */
+    mik_logfile_init(&app_config);
+
     /* Create JS runtime — reserve heap for WiFi, TLS, HTTP, LittleFS, and other
      * ESP-IDF subsystems that allocate after the runtime is created.
      * WiFi + lwIP ≈ 50-65 KB, TLS ≈ 40 KB, HTTP task ≈ 8 KB, misc ≈ 15 KB. */

package/components/mikrojs/mik_serial_io.cpp

@@ -162,7 +162,21 @@ int mik__console_read(void* buf, size_t len) {
 #endif
 }
 
+static mik_console_tap_fn s_console_tap = nullptr;
+
+void mik__console_set_tap(mik_console_tap_fn fn) {
+    s_console_tap = fn;
+}
+
 int mik__console_write(const void* buf, size_t len) {
+    /* Mirror to file-log tap (if installed) before the host write. This
+     * captures output even when USB-JTAG has no host attached. Skip the
+     * tap while a TLV protocol frame is being written — the file logger
+     * has a higher-level tap on the un-framed body via the log-emit
+     * hook, so capturing the wire bytes here would just embed the
+     * [type][len] header in the log file. */
+    mik_console_tap_fn tap = s_console_tap;
+    if (tap && !mik__proto_send_in_progress) tap(buf, len);
 #if SOC_USB_SERIAL_JTAG_SUPPORTED
     if (s_console == CONSOLE_USB_SERIAL_JTAG) {
         /* No host attached: the ring buffer would fill and block writes

package/components/mikrojs/mik_uart.cpp

@@ -12,6 +12,11 @@
 static JSClassID mik_uart_class_id;
 static int mik__uart_slot = -1;
 
+/* Forward decl: defined alongside the iterator class further down. The Uart
+ * state holds a non-owning backpointer so end() can mark the active iterator
+ * as exhausted without having to reach through JS. */
+struct MIKUartIterState;
+
 /* ── State ────────────────────────────────────────────────────────── */
 
 struct MIKUartState {
@@ -22,6 +27,11 @@ struct MIKUartState {
     bool begun;
     bool reading;     // active read() iterator exists
     MIKPromise read_promise;  // pending next() promise (when waiting for data)
+    /* Non-owning ref to the active iterator (when reading == true). The iter
+     * holds a strong ref to this Uart via uart_jsval, so this back-edge is
+     * always cleared (iter_return / finalizer) before the Uart can outlive
+     * the iterator. */
+    MIKUartIterState* iter;
 };
 
 /* Per-runtime tracking of all Uart instances for the loop consumer */
@@ -98,6 +108,7 @@ static JSValue js_uart_constructor(JSContext* ctx, JSValue new_target, int argc,
     s->baud_rate = 115200;
     s->begun = false;
     s->reading = false;
+    s->iter = nullptr;
     s->read_promise.p = JS_UNDEFINED;
     s->read_promise.rfuncs[0] = JS_UNDEFINED;
     s->read_promise.rfuncs[1] = JS_UNDEFINED;
@@ -193,19 +204,29 @@ static JSValue js_uart_begin(JSContext* ctx, JSValue this_val, int argc, JSValue
     return mik__result_ok_void(ctx);
 }
 
+/* Forward decls — bodies live with the iterator class. */
+static JSValue mik__uart_iter_yield(JSContext* ctx, JSValue inner_result);
+static void mik__uart_iter_mark_ended(MIKUartIterState* it);
+
 static JSValue js_uart_end(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
     auto* s = mik__uart_get(ctx, this_val);
     if (!s) return JS_EXCEPTION;
     if (!s->begun) return mik__result_ok_void(ctx);  // idempotent
 
-    /* Cancel any pending read. MIK_FreePromise frees the JSValues but
-     * doesn't reset the slot, so MIK_ClearPromise is required to keep
-     * MIK_IsPromisePending honest if the Uart is begun + read again. */
+    /* If a read() iterator is active, deliver a terminal err item so any
+     * awaiting next() unblocks with err(NotStarted) rather than hanging.
+     * Also flip the iterator's `ended` flag so its next call resolves with
+     * {done:true} — without this, the awaiter consumes the err yield, then
+     * the next call hits the `!s->begun` branch in iter_next and emits a
+     * second err yield. The active iterator backpointer makes that flip
+     * possible without reaching through JS. */
     if (s->reading) {
         if (MIK_IsPromisePending(ctx, &s->read_promise)) {
-            MIK_FreePromise(ctx, &s->read_promise);
+            JSValue err_yield = mik__uart_iter_yield(ctx, mik__result_err_tag(ctx, "NotStarted"));
+            MIK_ResolvePromise(ctx, &s->read_promise, 1, &err_yield);
             MIK_ClearPromise(ctx, &s->read_promise);
         }
+        if (s->iter) mik__uart_iter_mark_ended(s->iter);
         s->reading = false;
     }
 
@@ -260,6 +281,7 @@ struct MIKUartIterState {
      * iterator could outlive its parent Uart, leading to a UAF here. */
     MIKUartState* uart;
     JSValue uart_jsval;
+    bool ended;  // sticky: once true, next() returns {done:true} immediately
 };
 
 static void mik__uart_iter_finalizer(JSRuntime* rt, JSValue val) {
@@ -269,11 +291,16 @@ static void mik__uart_iter_finalizer(JSRuntime* rt, JSValue val) {
      * safe here — except after iterator.return() nulled it out. */
     if (it->uart) {
         it->uart->reading = false;
+        if (it->uart->iter == it) it->uart->iter = nullptr;
     }
     JS_FreeValueRT(rt, it->uart_jsval);
     free(it);
 }
 
+static void mik__uart_iter_mark_ended(MIKUartIterState* it) {
+    if (it) it->ended = true;
+}
+
 static void mik__uart_iter_gc_mark(JSRuntime* rt, JSValue val, JS_MarkFunc* mark_func) {
     auto* it = static_cast<MIKUartIterState*>(JS_GetOpaque(val, mik_uart_iter_class_id));
     if (!it) return;
@@ -286,7 +313,24 @@ static JSClassDef mik_uart_iter_class = {
     .gc_mark = mik__uart_iter_gc_mark,
 };
 
-/* Try to read available data and return {done: false, value: Uint8Array} synchronously */
+/* Build {done:false, value: Result<Uint8Array, UartError>} wrapper. Takes
+ * ownership of the inner Result value. */
+static JSValue mik__uart_iter_yield(JSContext* ctx, JSValue inner_result) {
+    JSValue out = JS_NewObject(ctx);
+    JS_DefinePropertyValueStr(ctx, out, "done", JS_FALSE, JS_PROP_C_W_E);
+    JS_DefinePropertyValueStr(ctx, out, "value", inner_result, JS_PROP_C_W_E);
+    return out;
+}
+
+static JSValue mik__uart_iter_done(JSContext* ctx) {
+    JSValue out = JS_NewObject(ctx);
+    JS_DefinePropertyValueStr(ctx, out, "done", JS_TRUE, JS_PROP_C_W_E);
+    JS_DefinePropertyValueStr(ctx, out, "value", JS_UNDEFINED, JS_PROP_C_W_E);
+    return out;
+}
+
+/* Try to read available data and return {done:false, value: ok(Uint8Array)}
+ * synchronously, or JS_UNDEFINED if no data is buffered yet. */
 static JSValue mik__uart_try_read(JSContext* ctx, MIKUartState* s) {
     size_t buffered = 0;
     uart_get_buffered_data_len(s->port, &buffered);
@@ -302,18 +346,27 @@ static JSValue mik__uart_try_read(JSContext* ctx, MIKUartState* s) {
     }
 
     JSValue arr = MIK_NewUint8Array(ctx, buf, read);
-    JSValue result = JS_NewObject(ctx);
-    JS_DefinePropertyValueStr(ctx, result, "done", JS_FALSE, JS_PROP_C_W_E);
-    JS_DefinePropertyValueStr(ctx, result, "value", arr, JS_PROP_C_W_E);
-    return result;
+    return mik__uart_iter_yield(ctx, mik__result_ok(ctx, arr));
 }
 
 static JSValue js_uart_iter_next(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
     auto* it = static_cast<MIKUartIterState*>(JS_GetOpaque2(ctx, this_val, mik_uart_iter_class_id));
     if (!it || !it->uart) return JS_ThrowInternalError(ctx, "invalid uart iterator");
+
+    if (it->ended) {
+        JSValue done_result = mik__uart_iter_done(ctx);
+        return MIK_NewResolvedPromise(ctx, 1, &done_result);
+    }
+
     MIKUartState* s = it->uart;
 
-    if (!s->begun) return JS_Throw(ctx, JS_NewString(ctx, "UART not started"));
+    /* If end() has invalidated the underlying port, surface NotStarted as
+     * a single err item and mark the iterator done. */
+    if (!s->begun) {
+        it->ended = true;
+        JSValue err_yield = mik__uart_iter_yield(ctx, mik__result_err_tag(ctx, "NotStarted"));
+        return MIK_NewResolvedPromise(ctx, 1, &err_yield);
+    }
 
     /* Try synchronous read first */
     JSValue sync_result = mik__uart_try_read(ctx, s);
@@ -343,6 +396,7 @@ static JSValue js_uart_iter_return(JSContext* ctx, JSValue this_val, int argc, J
     }
 
     it->uart->reading = false;
+    if (it->uart->iter == it) it->uart->iter = nullptr;
     it->uart = nullptr;
 
 done:
@@ -384,6 +438,7 @@ static JSValue js_uart_read(JSContext* ctx, JSValue this_val, int argc, JSValue*
         return JS_EXCEPTION;
     }
     JS_SetOpaque(iter_obj, it);
+    s->iter = it;
 
     return mik__result_ok(ctx, iter_obj);
 }
@@ -468,9 +523,7 @@ void mik__uart_consume(JSContext* ctx) {
         }
 
         JSValue arr = MIK_NewUint8Array(ctx, buf, read_bytes);
-        JSValue result = JS_NewObject(ctx);
-        JS_DefinePropertyValueStr(ctx, result, "done", JS_FALSE, JS_PROP_C_W_E);
-        JS_DefinePropertyValueStr(ctx, result, "value", arr, JS_PROP_C_W_E);
+        JSValue result = mik__uart_iter_yield(ctx, mik__result_ok(ctx, arr));
         MIK_ResolvePromise(ctx, &s->read_promise, 1, &result);
         MIK_ClearPromise(ctx, &s->read_promise);
     }

package/components/mikrojs/platform_esp32.cpp

@@ -182,12 +182,22 @@ static void esp32_log(int level, const char* tag, const char* fmt, ...) {
     esp_log_level_t tag_level = esp_log_level_get(tag);
     if (tag_level == ESP_LOG_NONE || esp_level > tag_level) return;
 
-    printf("[%s] %s: ", mik_log_level_name(level), tag);
+    /* Route through mik__console_write rather than printf so the file-log
+     * tap captures these lines along with JS console output. */
+    char buf[256];
+    int n = snprintf(buf, sizeof(buf), "[%s] %s: ", mik_log_level_name(level), tag);
+    if (n < 0) return;
+    if ((size_t)n >= sizeof(buf)) n = (int)sizeof(buf) - 1;
     va_list args;
     va_start(args, fmt);
-    vprintf(fmt, args);
+    int m = vsnprintf(buf + n, sizeof(buf) - (size_t)n, fmt, args);
     va_end(args);
-    putchar('\n');
+    if (m < 0) m = 0;
+    size_t total = (size_t)n + (size_t)m;
+    if (total >= sizeof(buf)) total = sizeof(buf) - 1;
+    /* Replace trailing NUL with newline; if exactly full, overwrite last byte. */
+    buf[total] = '\n';
+    mik__console_write(buf, total + 1);
 }
 
 static const MIKPlatform esp32_platform = {

package/package.json

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