@mikrojs/native 0.0.7

package/src/mik_sys.cpp

@@ -0,0 +1,239 @@
+#include <quickjs.h>
+#include <sys/time.h>
+#include <time.h>
+
+#ifdef CONFIG_IDF_TARGET
+#include <esp_app_desc.h>
+#include <esp_chip_info.h>
+#include <esp_flash.h>
+#ifdef CONFIG_SPIRAM
+#include <esp_psram.h>
+#endif
+#endif
+
+#include "mikrojs/platform.h"
+#include "mikrojs/private.h"
+#include "mikrojs/utils.h"
+
+static JSValue mik__sys_eval_script(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    const char* str;
+    size_t len;
+    str = JS_ToCStringLen(ctx, &len, argv[0]);
+    if (!str) {
+        return JS_EXCEPTION;
+    }
+    JSValue ret = JS_Eval(ctx, str, len, "<evalScript>",
+                          JS_EVAL_TYPE_GLOBAL | JS_EVAL_FLAG_ASYNC | JS_EVAL_FLAG_BACKTRACE_BARRIER);
+    JS_FreeCString(ctx, str);
+    return ret;
+}
+
+static JSValue mik__sys_memory_usage(JSContext* ctx, JSValue this_val, int argc,
+                                         JSValue* argv) {
+    JSMemoryUsage mem;
+    JS_ComputeMemoryUsage(JS_GetRuntime(ctx), &mem);
+
+    const MIKPlatform* platform = MIK_GetPlatform();
+
+    JSValue obj = JS_NewObject(ctx);
+    JS_SetPropertyStr(ctx, obj, "heapTotal",
+                      JS_NewInt64(ctx, mem.malloc_limit > 0 ? mem.malloc_limit : mem.malloc_size));
+    JS_SetPropertyStr(ctx, obj, "heapUsed", JS_NewInt64(ctx, mem.malloc_size));
+    JS_SetPropertyStr(ctx, obj, "systemFree",
+                      JS_NewInt64(ctx, (int64_t)platform->get_free_system_mem()));
+    JS_SetPropertyStr(ctx, obj, "systemMinFree",
+                      JS_NewInt64(ctx, (int64_t)platform->get_min_free_system_mem()));
+    JS_SetPropertyStr(ctx, obj, "systemTotal",
+                      JS_NewInt64(ctx, (int64_t)platform->get_total_system_mem()));
+    JS_SetPropertyStr(ctx, obj, "systemLargestFree",
+                      JS_NewInt64(ctx, (int64_t)platform->get_largest_free_system_mem()));
+    return obj;
+}
+
+/* Curated QuickJS-heap breakdown. Covers the "where is memory going?"
+ * fields from JSMemoryUsage; skips redundancy with `memoryUsage()`
+ * (malloc_size/limit) and low-signal fields (atom counts, pc2line debug
+ * info, allocation counts, internal fast-vs-regular distinctions).
+ * If you need one of the excluded fields for a specific investigation,
+ * add it here — they're all available via JS_ComputeMemoryUsage. */
+static JSValue mik__sys_js_memory_usage(JSContext* ctx, JSValue this_val, int argc,
+                                        JSValue* argv) {
+    JSMemoryUsage mem;
+    JS_ComputeMemoryUsage(JS_GetRuntime(ctx), &mem);
+
+    const struct {
+        const char* name;
+        int64_t value;
+    } fields[] = {
+        {"strCount", mem.str_count},
+        {"strSize", mem.str_size},
+        {"objCount", mem.obj_count},
+        {"objSize", mem.obj_size},
+        {"propCount", mem.prop_count},
+        {"propSize", mem.prop_size},
+        {"shapeCount", mem.shape_count},
+        {"shapeSize", mem.shape_size},
+        {"jsFuncCount", mem.js_func_count},
+        {"jsFuncCodeSize", mem.js_func_code_size},
+        {"arrayCount", mem.array_count},
+        {"fastArrayElements", mem.fast_array_elements},
+        {"binaryObjectSize", mem.binary_object_size},
+    };
+
+    JSValue obj = JS_NewObject(ctx);
+    for (const auto& f : fields) {
+        JS_SetPropertyStr(ctx, obj, f.name, JS_NewInt64(ctx, f.value));
+    }
+    return obj;
+}
+
+static JSValue mik__sys_gc(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    JS_RunGC(JS_GetRuntime(ctx));
+    return JS_UNDEFINED;
+}
+
+static JSValue mik__sys_active_timers(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    MIKRuntime* mik_rt = static_cast<MIKRuntime*>(JS_GetContextOpaque(ctx));
+    CHECK_NOT_NULL(mik_rt);
+    return JS_NewInt32(ctx, static_cast<int32_t>(mik_rt->timers->entries.size()));
+}
+
+static JSValue mik__sys_set_time(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    int64_t millis;
+    if (JS_ToInt64(ctx, &millis, argv[0])) {
+        return JS_EXCEPTION;
+    }
+    struct timeval tv = {
+        .tv_sec = static_cast<time_t>(millis / 1000),
+        .tv_usec = static_cast<suseconds_t>((millis % 1000) * 1000),
+    };
+    if (settimeofday(&tv, NULL) != 0) {
+        return mik_throw_errno(ctx, errno);
+    }
+    return JS_UNDEFINED;
+}
+
+static JSValue mik__sys_uptime(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    const MIKPlatform* platform = MIK_GetPlatform();
+    JSValue obj = JS_NewObject(ctx);
+    JS_SetPropertyStr(ctx, obj, "boot",
+                      JS_NewFloat64(ctx, static_cast<double>(platform->get_boot_us()) / 1000.0));
+    JS_SetPropertyStr(ctx, obj, "rtc",
+                      JS_NewFloat64(ctx, static_cast<double>(platform->get_rtc_us()) / 1000.0));
+    return obj;
+}
+
+static JSValue mik__sys_restart(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    MIK_GetPlatform()->restart();
+    return JS_UNDEFINED;
+}
+
+static JSValue mik__sys_board(JSContext* ctx) {
+    JSValue obj = JS_NewObject(ctx);
+#ifdef MIK_BOARD_NAME
+    JS_SetPropertyStr(ctx, obj, "name", JS_NewString(ctx, MIK_BOARD_NAME));
+#else
+    JS_SetPropertyStr(ctx, obj, "name", JS_NewString(ctx, "generic"));
+#endif
+
+#ifdef CONFIG_IDF_TARGET
+    JS_SetPropertyStr(ctx, obj, "chip", JS_NewString(ctx, CONFIG_IDF_TARGET));
+
+    esp_chip_info_t chip_info;
+    esp_chip_info(&chip_info);
+    JS_SetPropertyStr(ctx, obj, "cores", JS_NewInt32(ctx, chip_info.cores));
+    JS_SetPropertyStr(ctx, obj, "revision", JS_NewInt32(ctx, chip_info.revision));
+
+    /* Features as string array */
+    JSValue features = JS_NewArray(ctx);
+    uint32_t fi = 0;
+    if (chip_info.features & CHIP_FEATURE_WIFI_BGN)
+        JS_SetPropertyUint32(ctx, features, fi++, JS_NewString(ctx, "wifi"));
+    if (chip_info.features & CHIP_FEATURE_BLE)
+        JS_SetPropertyUint32(ctx, features, fi++, JS_NewString(ctx, "ble"));
+    if (chip_info.features & CHIP_FEATURE_BT)
+        JS_SetPropertyUint32(ctx, features, fi++, JS_NewString(ctx, "bt"));
+    if (chip_info.features & CHIP_FEATURE_IEEE802154)
+        JS_SetPropertyUint32(ctx, features, fi++, JS_NewString(ctx, "ieee802154"));
+    JS_SetPropertyStr(ctx, obj, "features", features);
+
+    /* Flash size in bytes */
+    uint32_t flash_size = 0;
+    esp_flash_get_size(NULL, &flash_size);
+    JS_SetPropertyStr(ctx, obj, "flash", JS_NewInt64(ctx, flash_size));
+
+    /* PSRAM size in bytes */
+#ifdef CONFIG_SPIRAM
+    JS_SetPropertyStr(ctx, obj, "psram", JS_NewInt64(ctx, esp_psram_get_size()));
+#else
+    JS_SetPropertyStr(ctx, obj, "psram", JS_NewInt64(ctx, 0));
+#endif
+
+#else
+    JS_SetPropertyStr(ctx, obj, "chip", JS_NewString(ctx, "host"));
+    JS_SetPropertyStr(ctx, obj, "cores", JS_NewInt32(ctx, 1));
+    JS_SetPropertyStr(ctx, obj, "revision", JS_NewInt32(ctx, 0));
+    JS_SetPropertyStr(ctx, obj, "features", JS_NewArray(ctx));
+    JS_SetPropertyStr(ctx, obj, "flash", JS_NewInt64(ctx, 0));
+    JS_SetPropertyStr(ctx, obj, "psram", JS_NewInt64(ctx, 0));
+#endif
+    return obj;
+}
+
+// MIK_BUILD_DATE_UTC is a real UTC ISO-8601 string injected by CMake at
+// configure time (`string(TIMESTAMP ... UTC)`). Preferred over `__DATE__`/
+// `__TIME__` and `esp_app_desc_t::date/time`, which are the build host's
+// *local* time and can't be correctly labelled as UTC without knowing the
+// build machine's timezone.
+#ifndef MIK_BUILD_DATE_UTC
+#define MIK_BUILD_DATE_UTC "unknown"
+#endif
+
+static JSValue mik__sys_firmware(JSContext* ctx) {
+    JSValue obj = JS_NewObject(ctx);
+#ifdef CONFIG_IDF_TARGET
+    const esp_app_desc_t* desc = esp_app_get_description();
+    char elf_hash[65];
+    for (int i = 0; i < 32; i++) {
+        snprintf(elf_hash + i * 2, 3, "%02x", desc->app_elf_sha256[i]);
+    }
+    JS_SetPropertyStr(ctx, obj, "hash", JS_NewString(ctx, elf_hash));
+    JS_SetPropertyStr(ctx, obj, "date", JS_NewString(ctx, MIK_BUILD_DATE_UTC));
+    JS_SetPropertyStr(ctx, obj, "idfVersion", JS_NewString(ctx, desc->idf_ver));
+#else
+    JS_SetPropertyStr(ctx, obj, "hash", JS_NewString(ctx, "dev"));
+    JS_SetPropertyStr(ctx, obj, "date", JS_NewString(ctx, MIK_BUILD_DATE_UTC));
+    JS_SetPropertyStr(ctx, obj, "idfVersion", JS_NewString(ctx, "n/a"));
+#endif
+    return obj;
+}
+
+void mik__sys_api_init(JSContext* ctx, JSValue ns) {
+    JS_SetPropertyStr(ctx, ns, "evalScript",
+                      JS_NewCFunction(ctx, mik__sys_eval_script, "evalScript", 1));
+    JS_SetPropertyStr(ctx, ns, "memoryUsage",
+                      JS_NewCFunction(ctx, mik__sys_memory_usage, "memoryUsage", 0));
+    JS_SetPropertyStr(ctx, ns, "jsMemoryUsage",
+                      JS_NewCFunction(ctx, mik__sys_js_memory_usage, "jsMemoryUsage", 0));
+    JS_SetPropertyStr(ctx, ns, "gc", JS_NewCFunction(ctx, mik__sys_gc, "gc", 0));
+    JS_SetPropertyStr(ctx, ns, "activeTimers",
+                      JS_NewCFunction(ctx, mik__sys_active_timers, "activeTimers", 0));
+    JS_SetPropertyStr(ctx, ns, "setTime",
+                      JS_NewCFunction(ctx, mik__sys_set_time, "setTime", 1));
+    JS_SetPropertyStr(ctx, ns, "uptime",
+                      JS_NewCFunction(ctx, mik__sys_uptime, "uptime", 0));
+    JS_SetPropertyStr(ctx, ns, "restart",
+                      JS_NewCFunction(ctx, mik__sys_restart, "restart", 0));
+    JS_SetPropertyStr(ctx, ns, "version",
+#ifdef MIK_FW_VERSION
+                      JS_NewString(ctx, MIK_FW_VERSION));
+#else
+                      JS_NewString(ctx, "0.0.0-dev"));
+#endif
+    JS_SetPropertyStr(ctx, ns, "board", mik__sys_board(ctx));
+    JS_SetPropertyStr(ctx, ns, "firmware", mik__sys_firmware(ctx));
+
+    const char* device_id = MIK_GetPlatform()->get_device_id();
+    JS_SetPropertyStr(ctx, ns, "deviceId",
+                      device_id ? JS_NewString(ctx, device_id) : JS_UNDEFINED);
+}

package/src/mik_text_encoding.cpp

@@ -0,0 +1,443 @@
+#include <quickjs.h>
+#include <string.h>
+
+#include "mikrojs/utils.h"
+
+/* ---- TextEncoder ---- */
+
+static JSClassID textencoder_class_id;
+
+static JSClassDef textencoder_classdef = {
+    .class_name = "TextEncoder",
+    .finalizer = nullptr,
+    .gc_mark = nullptr,
+    .call = nullptr,
+    .exotic = nullptr,
+};
+
+static JSValue mik__text_encoder_constructor(JSContext* ctx, JSValue new_target, int argc,
+                                             JSValue* argv) {
+    return JS_NewObjectClass(ctx, textencoder_class_id);
+}
+
+static JSValue mik__text_encoder_encode(JSContext* ctx, JSValue this_val, int argc,
+                                        JSValue* argv) {
+    const char* str = JS_ToCString(ctx, argv[0]);
+    if (!str) {
+        return JS_EXCEPTION;
+    }
+    JSValue ret = JS_NewUint8ArrayCopy(ctx, (const uint8_t*)str, strlen(str));
+    JS_FreeCString(ctx, str);
+    return ret;
+}
+
+static const JSCFunctionListEntry mik__text_encoder_proto_funcs[] = {
+    MIK_CFUNC_DEF("encode", 1, mik__text_encoder_encode),
+};
+
+/* ---- TextDecoder ---- */
+
+typedef struct {
+    uint8_t pending[4];   /* up to 3 bytes of a leading incomplete sequence */
+    uint8_t pending_len;  /* 0..3 */
+} MIKTextDecoder;
+
+static JSClassID textdecoder_class_id;
+
+static void mik__text_decoder_finalizer(JSRuntime* rt, JSValue val) {
+    MIKTextDecoder* state = static_cast<MIKTextDecoder*>(JS_GetOpaque(val, textdecoder_class_id));
+    if (state) js_free_rt(rt, state);
+}
+
+static JSClassDef textdecoder_classdef = {
+    .class_name = "TextDecoder",
+    .finalizer = mik__text_decoder_finalizer,
+    .gc_mark = nullptr,
+    .call = nullptr,
+    .exotic = nullptr,
+};
+
+/* Case-insensitive ASCII match for utf-8 / utf8 (with optional surrounding
+ * ASCII whitespace, matching WHATWG "get an encoding" label trimming). */
+static bool is_utf8_label(const char* s) {
+    while (*s == ' ' || *s == '\t' || *s == '\n' || *s == '\r' || *s == '\f') s++;
+    const char* end = s + strlen(s);
+    while (end > s && (end[-1] == ' ' || end[-1] == '\t' || end[-1] == '\n' ||
+                       end[-1] == '\r' || end[-1] == '\f')) {
+        end--;
+    }
+    size_t len = (size_t)(end - s);
+    char buf[8];
+    if (len == 0 || len >= sizeof(buf)) return false;
+    for (size_t i = 0; i < len; i++) {
+        char c = s[i];
+        if (c >= 'A' && c <= 'Z') c = (char)(c + 32);
+        buf[i] = c;
+    }
+    buf[len] = '\0';
+    return strcmp(buf, "utf-8") == 0 || strcmp(buf, "utf8") == 0;
+}
+
+static JSValue mik__text_decoder_constructor(JSContext* ctx, JSValue new_target, int argc,
+                                             JSValue* argv) {
+    if (argc >= 1 && !JS_IsUndefined(argv[0])) {
+        const char* label = JS_ToCString(ctx, argv[0]);
+        if (!label) return JS_EXCEPTION;
+        bool ok = is_utf8_label(label);
+        JS_FreeCString(ctx, label);
+        if (!ok) {
+            return JS_ThrowRangeError(ctx, "TextDecoder: only 'utf-8' is supported");
+        }
+    }
+    JSValue obj = JS_NewObjectClass(ctx, textdecoder_class_id);
+    if (JS_IsException(obj)) return obj;
+    MIKTextDecoder* state = static_cast<MIKTextDecoder*>(js_mallocz(ctx, sizeof(MIKTextDecoder)));
+    if (!state) {
+        JS_FreeValue(ctx, obj);
+        return JS_EXCEPTION;
+    }
+    JS_SetOpaque(obj, state);
+    return obj;
+}
+
+/* Return the expected UTF-8 sequence length given a lead byte, or 0 if the
+ * byte is not a valid lead. */
+static int utf8_seq_len(uint8_t b) {
+    if (b < 0x80) return 1;
+    if ((b & 0xE0) == 0xC0) return 2;
+    if ((b & 0xF0) == 0xE0) return 3;
+    if ((b & 0xF8) == 0xF0) return 4;
+    return 0;
+}
+
+/* Validate a complete UTF-8 sequence of the given length. Checks continuation
+ * bytes, overlong encodings, surrogate range, and max codepoint. */
+static bool utf8_seq_valid(const uint8_t* p, int len) {
+    if (len == 1) return p[0] < 0x80;
+    for (int i = 1; i < len; i++) {
+        if ((p[i] & 0xC0) != 0x80) return false;
+    }
+    if (len == 2) {
+        return p[0] >= 0xC2;  /* reject overlong */
+    }
+    if (len == 3) {
+        if (p[0] == 0xE0 && p[1] < 0xA0) return false;  /* overlong */
+        if (p[0] == 0xED && p[1] >= 0xA0) return false;  /* surrogate */
+        return true;
+    }
+    if (len == 4) {
+        if (p[0] == 0xF0 && p[1] < 0x90) return false;  /* overlong */
+        if (p[0] == 0xF4 && p[1] >= 0x90) return false;  /* > U+10FFFF */
+        if (p[0] > 0xF4) return false;
+        return true;
+    }
+    return false;
+}
+
+/* Append U+FFFD (EF BF BD) to buffer. */
+static void append_replacement(uint8_t* out, size_t* out_len) {
+    out[(*out_len)++] = 0xEF;
+    out[(*out_len)++] = 0xBF;
+    out[(*out_len)++] = 0xBD;
+}
+
+static JSValue mik__text_decoder_decode(JSContext* ctx, JSValue this_val, int argc,
+                                        JSValue* argv) {
+    MIKTextDecoder* state =
+        static_cast<MIKTextDecoder*>(JS_GetOpaque2(ctx, this_val, textdecoder_class_id));
+    if (!state) return JS_EXCEPTION;
+
+    const uint8_t* data = nullptr;
+    size_t len = 0;
+    if (argc >= 1 && !JS_IsUndefined(argv[0])) {
+        if (JS_GetTypedArrayType(argv[0]) != JS_TYPED_ARRAY_UINT8) {
+            return JS_ThrowTypeError(ctx, "expected Uint8Array");
+        }
+        data = JS_GetUint8Array(ctx, &len, argv[0]);
+        if (!data) return JS_EXCEPTION;
+    }
+
+    bool stream = false;
+    if (argc >= 2 && JS_IsObject(argv[1])) {
+        JSValue sv = JS_GetPropertyStr(ctx, argv[1], "stream");
+        if (JS_IsException(sv)) return JS_EXCEPTION;
+        stream = JS_ToBool(ctx, sv);
+        JS_FreeValue(ctx, sv);
+    }
+
+    /* Common fast path: no pending bytes, scan `data` in place. Slow path
+     * (pending carry-over) copies pending + data into a buffer. */
+    size_t total = state->pending_len + len;
+    const uint8_t* input;
+    uint8_t stackbuf[8];
+    uint8_t* heap_input = nullptr;
+    if (state->pending_len == 0) {
+        input = data;
+    } else if (total <= sizeof(stackbuf)) {
+        memcpy(stackbuf, state->pending, state->pending_len);
+        if (len > 0) memcpy(stackbuf + state->pending_len, data, len);
+        input = stackbuf;
+    } else {
+        heap_input = static_cast<uint8_t*>(js_malloc(ctx, total));
+        if (!heap_input) return JS_EXCEPTION;
+        memcpy(heap_input, state->pending, state->pending_len);
+        memcpy(heap_input + state->pending_len, data, len);
+        input = heap_input;
+    }
+    state->pending_len = 0;
+
+    /* Worst case output: every byte becomes U+FFFD (3 bytes). */
+    size_t out_cap = total * 3;
+    if (out_cap == 0) out_cap = 1;
+    uint8_t* out = static_cast<uint8_t*>(js_malloc(ctx, out_cap));
+    if (!out) {
+        if (heap_input) js_free(ctx, heap_input);
+        return JS_EXCEPTION;
+    }
+    size_t out_len = 0;
+
+    size_t i = 0;
+    while (i < total) {
+        uint8_t b = input[i];
+        int seq = utf8_seq_len(b);
+        if (seq == 0) {
+            append_replacement(out, &out_len);
+            i++;
+            continue;
+        }
+        if (i + seq > total) {
+            /* Incomplete trailing sequence. */
+            if (stream) {
+                size_t held = total - i;
+                for (size_t k = 0; k < held; k++) state->pending[k] = input[i + k];
+                state->pending_len = (uint8_t)held;
+                break;
+            }
+            /* Flush: one U+FFFD per held byte. */
+            for (size_t k = i; k < total; k++) append_replacement(out, &out_len);
+            i = total;
+            break;
+        }
+        if (!utf8_seq_valid(input + i, seq)) {
+            append_replacement(out, &out_len);
+            i++;
+            continue;
+        }
+        memcpy(out + out_len, input + i, seq);
+        out_len += seq;
+        i += seq;
+    }
+
+    if (heap_input) js_free(ctx, heap_input);
+    JSValue ret = JS_NewStringLen(ctx, (const char*)out, out_len);
+    js_free(ctx, out);
+    return ret;
+}
+
+static const JSCFunctionListEntry mik__text_decoder_proto_funcs[] = {
+    MIK_CFUNC_DEF("decode", 1, mik__text_decoder_decode),
+};
+
+/* ---- btoa / atob ---- */
+
+static const char b64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+static const uint8_t b64_decode_table[256] = {
+    /* clang-format off */
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255, 62,255,255,255, 63,
+     52, 53, 54, 55, 56, 57, 58, 59, 60, 61,255,255,255,  0,255,255,
+    255,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
+     15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,255,255,255,255,255,
+    255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+     41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    /* clang-format on */
+};
+
+/* btoa: encode a binary string to base64.
+ * Per the web spec, each JS character's code point is treated as a raw byte.
+ * We must iterate by code point, not by UTF-8 bytes, since JS_ToCStringLen
+ * returns UTF-8 where e.g. U+0080 becomes two bytes (\xC2\x80). */
+static JSValue mik__btoa(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    JSValue str_val = argv[0];
+    JSValue len_val = JS_GetPropertyStr(ctx, str_val, "length");
+    int64_t len;
+    if (JS_ToInt64(ctx, &len, len_val)) {
+        JS_FreeValue(ctx, len_val);
+        return JS_EXCEPTION;
+    }
+    JS_FreeValue(ctx, len_val);
+
+    /* Extract code points into a byte buffer, validating latin1 range */
+    uint8_t* bytes = static_cast<uint8_t*>(js_malloc(ctx, len > 0 ? len : 1));
+    if (!bytes) return JS_EXCEPTION;
+
+    JSAtom charCodeAt_atom = JS_NewAtom(ctx, "charCodeAt");
+    for (int64_t i = 0; i < len; i++) {
+        JSValue idx = JS_NewInt64(ctx, i);
+        JSValue code = JS_Invoke(ctx, str_val, charCodeAt_atom, 1, &idx);
+        JS_FreeValue(ctx, idx);
+        if (JS_IsException(code)) {
+            JS_FreeAtom(ctx, charCodeAt_atom);
+            js_free(ctx, bytes);
+            return JS_EXCEPTION;
+        }
+        int32_t cp;
+        JS_ToInt32(ctx, &cp, code);
+        JS_FreeValue(ctx, code);
+        if (cp > 0xFF) {
+            JS_FreeAtom(ctx, charCodeAt_atom);
+            js_free(ctx, bytes);
+            return JS_ThrowRangeError(ctx,
+                                      "The string to be encoded contains characters outside of the "
+                                      "Latin1 range");
+        }
+        bytes[i] = (uint8_t)cp;
+    }
+    JS_FreeAtom(ctx, charCodeAt_atom);
+
+    size_t out_len = 4 * ((len + 2) / 3);
+    char* out = static_cast<char*>(js_malloc(ctx, out_len + 1));
+    if (!out) {
+        js_free(ctx, bytes);
+        return JS_EXCEPTION;
+    }
+
+    size_t j = 0;
+    for (int64_t i = 0; i < len; i += 3) {
+        uint32_t a = bytes[i];
+        uint32_t b = (i + 1 < len) ? bytes[i + 1] : 0;
+        uint32_t c = (i + 2 < len) ? bytes[i + 2] : 0;
+        uint32_t triple = (a << 16) | (b << 8) | c;
+
+        out[j++] = b64_table[(triple >> 18) & 0x3F];
+        out[j++] = b64_table[(triple >> 12) & 0x3F];
+        out[j++] = (i + 1 < len) ? b64_table[(triple >> 6) & 0x3F] : '=';
+        out[j++] = (i + 2 < len) ? b64_table[triple & 0x3F] : '=';
+    }
+    out[j] = '\0';
+
+    js_free(ctx, bytes);
+    JSValue ret = JS_NewStringLen(ctx, out, j);
+    js_free(ctx, out);
+    return ret;
+}
+
+/* atob: decode a base64 string to a binary string */
+static JSValue mik__atob(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    size_t len;
+    const char* str = JS_ToCStringLen(ctx, &len, argv[0]);
+    if (!str) return JS_EXCEPTION;
+
+    /* Strip whitespace and validate */
+    size_t out_cap = (len * 3) / 4 + 1;
+    char* out = static_cast<char*>(js_malloc(ctx, out_cap));
+    if (!out) {
+        JS_FreeCString(ctx, str);
+        return JS_EXCEPTION;
+    }
+
+    uint32_t accum = 0;
+    int bits = 0;
+    size_t j = 0;
+    int pad = 0;
+
+    for (size_t i = 0; i < len; i++) {
+        char ch = str[i];
+        if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' || ch == '\f') continue;
+        if (ch == '=') {
+            pad++;
+            continue;
+        }
+        if (pad > 0) {
+            /* Data after padding */
+            js_free(ctx, out);
+            JS_FreeCString(ctx, str);
+            return JS_ThrowSyntaxError(ctx,
+                                       "The string to be decoded is not correctly encoded");
+        }
+        uint8_t val = b64_decode_table[(uint8_t)ch];
+        if (val == 255) {
+            js_free(ctx, out);
+            JS_FreeCString(ctx, str);
+            return JS_ThrowSyntaxError(ctx,
+                                       "The string to be decoded is not correctly encoded");
+        }
+        accum = (accum << 6) | val;
+        bits += 6;
+        if (bits >= 8) {
+            bits -= 8;
+            out[j++] = (char)((accum >> bits) & 0xFF);
+        }
+    }
+
+    JS_FreeCString(ctx, str);
+
+    /* Convert decoded bytes to a JS string. Bytes 0x80-0xFF must become
+     * their corresponding Unicode code points (U+0080-U+00FF), which in
+     * UTF-8 are two-byte sequences. Build a UTF-8 buffer. */
+    size_t utf8_cap = j * 2 + 1;  /* worst case: every byte is 0x80-0xFF */
+    char* utf8 = static_cast<char*>(js_malloc(ctx, utf8_cap));
+    if (!utf8) {
+        js_free(ctx, out);
+        return JS_EXCEPTION;
+    }
+    size_t utf8_len = 0;
+    for (size_t i = 0; i < j; i++) {
+        uint8_t b = (uint8_t)out[i];
+        if (b < 0x80) {
+            utf8[utf8_len++] = (char)b;
+        } else {
+            utf8[utf8_len++] = (char)(0xC0 | (b >> 6));
+            utf8[utf8_len++] = (char)(0x80 | (b & 0x3F));
+        }
+    }
+
+    js_free(ctx, out);
+    JSValue ret = JS_NewStringLen(ctx, utf8, utf8_len);
+    js_free(ctx, utf8);
+    return ret;
+}
+
+/* ---- Registration ---- */
+
+void mik__text_encoding_init(JSContext* ctx, JSValue global) {
+    JSRuntime* rt = JS_GetRuntime(ctx);
+
+    /* TextEncoder */
+    JS_NewClassID(rt, &textencoder_class_id);
+    JS_NewClass(rt, textencoder_class_id, &textencoder_classdef);
+    JSValue te_proto = JS_NewObject(ctx);
+    JS_SetPropertyFunctionList(ctx, te_proto, mik__text_encoder_proto_funcs,
+                               countof(mik__text_encoder_proto_funcs));
+    JS_SetClassProto(ctx, textencoder_class_id, te_proto);
+    JSValue te_ctor = JS_NewCFunction2(ctx, mik__text_encoder_constructor, "TextEncoder", 0,
+                                       JS_CFUNC_constructor, 0);
+    JS_DefinePropertyValueStr(ctx, global, "TextEncoder", te_ctor, JS_PROP_C_W_E);
+
+    /* TextDecoder */
+    JS_NewClassID(rt, &textdecoder_class_id);
+    JS_NewClass(rt, textdecoder_class_id, &textdecoder_classdef);
+    JSValue td_proto = JS_NewObject(ctx);
+    JS_SetPropertyFunctionList(ctx, td_proto, mik__text_decoder_proto_funcs,
+                               countof(mik__text_decoder_proto_funcs));
+    JS_SetClassProto(ctx, textdecoder_class_id, td_proto);
+    JSValue td_ctor = JS_NewCFunction2(ctx, mik__text_decoder_constructor, "TextDecoder", 0,
+                                       JS_CFUNC_constructor, 0);
+    JS_DefinePropertyValueStr(ctx, global, "TextDecoder", td_ctor, JS_PROP_C_W_E);
+
+    /* btoa / atob */
+    JS_DefinePropertyValueStr(ctx, global, "btoa",
+                              JS_NewCFunction(ctx, mik__btoa, "btoa", 1), JS_PROP_C_W_E);
+    JS_DefinePropertyValueStr(ctx, global, "atob",
+                              JS_NewCFunction(ctx, mik__atob, "atob", 1), JS_PROP_C_W_E);
+}