@mikrojs/native 0.8.0 → 0.10.0-next.7.gdacecb0

package/CMakeLists.txt

@@ -81,9 +81,9 @@ endif()
 include(cmake/mikrojs_bytecode.cmake)
 mikrojs_generate_bytecode(
     RUNTIME_DIR "${CMAKE_CURRENT_SOURCE_DIR}/runtime"
-    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
-    MODULE_PREFIX "mikrojs"
-    SYMBOL_PREFIX "mikrojs"
+    MODULES cbor env result schema fs http/helpers http/request i2c kv/nvs kv/rtc kv/shared module neopixel observable observable/lazy observable/operators pin pwm reader sleep spi sntp stdio stream sys test uart udp wifi
+    MODULE_PREFIX "mikro"
+    SYMBOL_PREFIX "mikro"
     TARGET gen_bytecode
 )
 add_dependencies(mikrojs gen_bytecode)

package/cmake/mikrojs_bytecode.cmake

@@ -7,7 +7,7 @@
 #   mikrojs_generate_bytecode(
 #       RUNTIME_DIR <path>         # Directory containing <mod>/<mod>.ts files
 #       MODULES <mod1> <mod2>      # Module names to compile
-#       MODULE_PREFIX <prefix>     # Module name prefix (e.g. "mikrojs" -> "mikrojs/pin")
+#       MODULE_PREFIX <prefix>     # Module name prefix (e.g. "mikro" -> "mikro/pin")
 #       SYMBOL_PREFIX <prefix>     # C symbol prefix (e.g. "mikrojs" -> "mikrojs_pin_bytecode")
 #       TARGET <name>              # Custom target name (default: gen_bytecode)
 #       WORKING_DIRECTORY <dir>    # Working dir for esbuild (default: CMAKE_CURRENT_SOURCE_DIR)

package/include/mikrojs/mikrojs.h

@@ -29,8 +29,20 @@ typedef enum MIKLogFlush {
     MIK_LOG_FLUSH_LINE = 1,
 } MIKLogFlush;
 
+/* What the device does after an uncaught exception (a "panic"). Mirror of
+ * the `onPanic.mode` field in the host-side TS config. */
+typedef enum MIKPanicMode {
+    MIK_PANIC_RESTART = 0,    /* default: reboot after the grace window */
+    MIK_PANIC_DEEP_SLEEP = 1, /* deep-sleep panic_sleep_duration_ms; wake reboots */
+} MIKPanicMode;
+
 typedef struct MIKConfig {
+    /* Grace window after a panic, awake and reachable, before the action
+     * fires (applies to both modes). */
     int panic_restart_delay_ms;
+    MIKPanicMode panic_mode;
+    /* Deep-sleep length for MIK_PANIC_DEEP_SLEEP; ignored otherwise. */
+    int panic_sleep_duration_ms;
     size_t stack_size;
     uint32_t mem_reserved;
     uint32_t fs_read_max; /* 0 = keep runtime default (65536) */

package/include/mikrojs/platform.h

@@ -14,6 +14,10 @@ typedef struct MIKPlatform {
     int64_t (*get_rtc_us)(void);        /* RTC timer, survives deep sleep */
     uint32_t (*random)(void);
     void (*restart)(void);
+    /** Enter deep sleep for `us` microseconds; the timer wake reboots the
+     *  chip, so this never returns on hardware. NULL on platforms without
+     *  deep sleep (hosts), where callers fall back to restart(). */
+    void (*deep_sleep_us)(uint64_t us);
     void (*yield)(void);
     size_t (*get_free_system_mem)(void);
     size_t (*get_min_free_system_mem)(void); /* All-time low watermark */

package/include/mikrojs/private.h

@@ -184,6 +184,16 @@ char* mik_module_normalizer(JSContext* ctx, const char* base_name, const char* n
  * mid-evaluation, or unknown modules. */
 int mik__unload_module(JSContext* ctx, const char* normalized_name);
 
+/* Unload the module whose namespace object is `ns` (reverse lookup via
+ * JS_FindModuleByNamespace, then mik__unload_module by name). Returns the
+ * number of modules freed, 0 if `ns` is not a currently-loaded module's
+ * namespace, or -1 with a pending JS exception. Backs `disposable()`. */
+int mik__unload_namespace(JSContext* ctx, JSValueConst ns);
+
+/* True if `ns` is the namespace of a currently-loaded, non-anchored module
+ * (i.e. one that disposable() is allowed to unload). */
+bool mik__is_unloadable_namespace(JSContext* ctx, JSValueConst ns);
+
 int js_module_set_import_meta(JSContext* ctx, JSValue func_val, bool use_realpath, bool is_main);
 
 JSValue mik__get_args(JSContext* ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikrojs/native",
-  "version": "0.8.0",
+  "version": "0.10.0-next.7.gdacecb0",
   "description": "Mikro.js C++ runtime library and Node.js native addon",
   "keywords": [
     "esp32",
@@ -9,15 +9,15 @@
     "quickjs",
     "runtime"
   ],
-  "homepage": "https://github.com/mikrojs/mikrojs#readme",
+  "homepage": "https://github.com/mikrojs/mikro#readme",
   "bugs": {
-    "url": "https://github.com/mikrojs/mikrojs/issues"
+    "url": "https://github.com/mikrojs/mikro/issues"
   },
   "license": "MIT",
   "author": "Bjørge Næss <bjoerge@gmail.com>",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/mikrojs/mikrojs.git"
+    "url": "git+https://github.com/mikrojs/mikro.git"
   },
   "files": [
     "dist",
@@ -55,6 +55,7 @@
     "./runtime/inspect/types": "./runtime/inspect/types.ts",
     "./runtime/kv/shared": "./runtime/kv/shared.ts",
     "./runtime/kv/types": "./runtime/kv/types.ts",
+    "./runtime/module/types": "./runtime/module/types.ts",
     "./runtime/neopixel/types": "./runtime/neopixel/types.ts",
     "./runtime/observable/operators": "./runtime/observable/operators.ts",
     "./runtime/observable/types": "./runtime/observable/types.ts",
@@ -78,7 +79,7 @@
     "cmake-js": "^8.0.0",
     "node-addon-api": "^8.7.0",
     "node-gyp-build": "^4.8.4",
-    "@mikrojs/quickjs": "0.8.0"
+    "@mikrojs/quickjs": "0.10.0-next.7.gdacecb0"
   },
   "devDependencies": {
     "@swc/core": "^1.15.30",

package/runtime/ble/ble.ts

@@ -1,5 +1,5 @@
-import {lazyEvent} from 'mikrojs/observable/lazy'
-import {err, ok} from 'mikrojs/result'
+import {lazyEvent} from 'mikro/observable/lazy'
+import {err, ok} from 'mikro/result'
 import {Ble as NativeBle} from 'native:ble'
 
 import type {Result} from '../result/types.js'

package/runtime/fs/fs.ts

@@ -1,4 +1,4 @@
-import {err, ok} from 'mikrojs/result'
+import {err, ok} from 'mikro/result'
 import * as native from 'native:fs'
 
 import type {Result} from '../result/types.js'

package/runtime/globals.d.ts

@@ -64,28 +64,4 @@ declare interface ImportMeta {
   readonly basename: string
   readonly path: string
   readonly env: Readonly<Record<string, string | undefined>>
-  /**
-   * Evict a module from the runtime's module cache, recursively freeing
-   * any transitive dependency whose only importer was the unloaded module.
-   * Builtin modules (native:*, mikrojs/*, @mikrojs/*) are anchored
-   * and cannot be unloaded.
-   *
-   * Intended for use with dynamic imports: a static `import` at the top of
-   * the module creates a binding that pins the imported module's exports,
-   * so unloading it while the binding is live reclaims nothing. Prefer
-   * `const x = await import(spec)` + local scope + `import.meta.unload(spec)`.
-   *
-   * **Incompatible with `bundle: true`.** When the build bundles modules
-   * into chunks, source-level specifiers like `./phases/display.js` no
-   * longer correspond to loaded module names (they become chunk names like
-   * `display-GYVGL5MB.js`) — the unload call silently resolves to 0 and
-   * frees nothing. Projects that rely on dynamic-import-then-unload for
-   * memory reclaim need `bundle: false` so specifier strings survive to
-   * runtime unchanged.
-   *
-   * Resolves to the number of modules actually freed (root + transitive
-   * orphans), after a GC pass has run so a subsequent `memoryUsage()`
-   * snapshot reflects the reclaim.
-   */
-  unload(specifier: string): Promise<number>
 }

package/runtime/http/helpers.ts

@@ -3,7 +3,7 @@
 // LTE modem over UART) implement the `Request` type directly and reuse
 // `prepareBody` + `makeResponse` for the boring parts.
 
-import {err, ok} from 'mikrojs/result'
+import {err, ok} from 'mikro/result'
 
 import type {Result} from '../result/types.js'
 

package/runtime/http/native.ts

@@ -8,8 +8,8 @@ import {
   type Request,
   RequestError,
   type RequestOptions,
-} from 'mikrojs/http/helpers'
-import {err, ok} from 'mikrojs/result'
+} from 'mikro/http/helpers'
+import {err, ok} from 'mikro/result'
 
 import type {ErrResult, Result} from '../result/types.js'
 

package/runtime/internal.d.ts

@@ -4,20 +4,20 @@ type NR<T> = {ok: true; value: T} | {ok: false; error: {code: number; message: s
 
 // Internal shared runtime modules. Registered as builtins so sibling bundles
 // can reference them at runtime to dedupe shared code, but not exposed via
-// the public `mikrojs/*` subpath exports so user apps can't accidentally
+// the public `mikro/*` subpath exports so user apps can't accidentally
 // import them. Keep these in sync with the MODULES list in the firmware +
 // @mikrojs/native CMakeLists.
-declare module 'mikrojs/kv/shared' {
+declare module 'mikro/kv/shared' {
   export {KVError, makeCreateValue, type NativeKvFns} from './kv/shared.js'
 }
 
-declare module 'mikrojs/observable/lazy' {
+declare module 'mikro/observable/lazy' {
   export {lazyEvent} from './observable/lazy.js'
 }
 
 declare module 'native:cbor' {
   import type {CborError} from '@mikrojs/native/runtime/cbor/types'
-  import type {Result} from 'mikrojs/result'
+  import type {Result} from 'mikro/result'
   export function encode(value: unknown): Result<Uint8Array, CborError>
   export function decode(data: Uint8Array): Result<unknown, CborError>
 }
@@ -46,6 +46,11 @@ declare module 'native:sys' {
   }
   export function jsMemoryUsage(): JsMemoryUsage
   export function gc(): void
+  /** Unload the module whose namespace object is `ns`; returns the number of
+   *  modules freed (0 if `ns` is not a loaded module's namespace). */
+  export function unloadNamespace(ns: object): number
+  /** True if `ns` is the namespace of a loaded, non-anchored (non-builtin) module. */
+  export function isUnloadableNamespace(ns: object): boolean
   export function activeTimers(): number
   export function setTime(millisSinceEpoch: number): void
   export function uptime(): {boot: number; rtc: number}
@@ -117,7 +122,7 @@ declare module 'native:stdio' {
 
 declare module 'native:pin' {
   import type {PinError} from '@mikrojs/native/runtime/pin/types'
-  import type {Result} from 'mikrojs/result'
+  import type {Result} from 'mikro/result'
   export type PinMode = 0x01 | 0x03 | 0x05
   export function pinMode(pin: number, value: PinMode): Result<void, PinError>
   export function digitalWrite(pin: number, value: 0 | 1): Result<void, PinError>
@@ -138,8 +143,8 @@ declare module 'native:sleep' {
 }
 
 declare module 'native:http' {
-  import type {RequestError} from 'mikrojs/http/helpers'
-  import type {Result} from 'mikrojs/result'
+  import type {RequestError} from 'mikro/http/helpers'
+  import type {Result} from 'mikro/result'
 
   import type {ErrResult} from './result/types.js'
   type HeadersMsg = {status: number; headers: [string, string][]}
@@ -160,7 +165,7 @@ declare module 'native:http' {
 }
 declare module 'native:i2c' {
   import type {I2cError} from '@mikrojs/native/runtime/i2c/types'
-  import type {Result} from 'mikrojs/result'
+  import type {Result} from 'mikro/result'
 
   export interface I2cBaseOptions {
     freq?: number
@@ -192,7 +197,7 @@ declare module 'native:i2c' {
 }
 declare module 'native:spi' {
   import type {SpiError} from '@mikrojs/native/runtime/spi/types'
-  import type {Result} from 'mikrojs/result'
+  import type {Result} from 'mikro/result'
 
   export interface SpiOptions {
     clk: number
@@ -221,7 +226,7 @@ declare module 'native:spi' {
 
 declare module 'native:sntp' {
   import type {SntpError} from '@mikrojs/native/runtime/sntp/types'
-  import type {Result} from 'mikrojs/result'
+  import type {Result} from 'mikro/result'
   /**
    * Native errors: the outer Result covers init/config failures (InitFailed);
    * the inner Result on resolve covers post-start errors (Cancelled).
@@ -257,7 +262,7 @@ declare module 'native:nvs_kv' {
 
 declare module 'native:pwm' {
   import type {PwmError} from '@mikrojs/native/runtime/pwm/types'
-  import type {Result} from 'mikrojs/result'
+  import type {Result} from 'mikro/result'
 
   export declare const Pwm: {
     prototype: Pwm
@@ -274,7 +279,7 @@ declare module 'native:pwm' {
 
 declare module 'native:neopixel' {
   import type {NeoPixelError} from '@mikrojs/native/runtime/neopixel/types'
-  import type {Result} from 'mikrojs/result'
+  import type {Result} from 'mikro/result'
 
   export declare const NeoPixel: {
     prototype: NeoPixel
@@ -292,7 +297,7 @@ declare module 'native:neopixel' {
 
 declare module 'native:uart' {
   import type {UartError} from '@mikrojs/native/runtime/uart/types'
-  import type {Result} from 'mikrojs/result'
+  import type {Result} from 'mikro/result'
 
   export interface UartOptions {
     tx?: number
@@ -324,7 +329,7 @@ declare module 'native:uart' {
 
 declare module 'native:ble' {
   import type {BleError} from '@mikrojs/native/runtime/ble/types'
-  import type {Result} from 'mikrojs/result'
+  import type {Result} from 'mikro/result'
 
   type R<T> = Result<T, BleError>
 
@@ -378,7 +383,7 @@ declare module 'native:ble' {
 
 declare module 'native:wifi' {
   import type {WifiError} from '@mikrojs/native/runtime/wifi/types'
-  import type {Result} from 'mikrojs/result'
+  import type {Result} from 'mikro/result'
 
   type R<T> = Result<T, WifiError>
 
@@ -464,7 +469,7 @@ declare module 'native:udp' {
     UdpError,
     UdpFamily,
   } from '@mikrojs/native/runtime/udp/types'
-  import type {Result} from 'mikrojs/result'
+  import type {Result} from 'mikro/result'
 
   export interface NativeUdpSocket {
     readonly port: number

package/runtime/kv/nvs.ts

@@ -1,4 +1,4 @@
-import {KVError, makeCreateValue} from 'mikrojs/kv/shared'
+import {KVError, makeCreateValue} from 'mikro/kv/shared'
 import {clear, get, info, remove, set} from 'native:nvs_kv'
 
 import type {NvsStorage} from './types.js'

package/runtime/kv/rtc.ts

@@ -1,4 +1,4 @@
-import {KVError, makeCreateValue} from 'mikrojs/kv/shared'
+import {KVError, makeCreateValue} from 'mikro/kv/shared'
 import {clear, get, info, remove, set} from 'native:rtc'
 
 import type {RtcStorage} from './types.js'

package/runtime/kv/shared.ts

@@ -1,7 +1,7 @@
-import {err, ok} from 'mikrojs/result'
+import {err, ok} from 'mikro/result'
 // Typed loosely to avoid deep type instantiation from Infer<S> in parse's generics.
 // Type safety is provided by the storage interface overloads in types.ts.
-import {parse as _parse} from 'mikrojs/schema'
+import {parse as _parse} from 'mikro/schema'
 
 import type {NativeError} from '../result/types.js'
 

package/runtime/module/module.ts

@@ -0,0 +1,37 @@
+import {isUnloadableNamespace, unloadNamespace} from 'native:sys'
+
+/**
+ * Load a dynamically imported module, run `use` with it, then unload it and
+ * reclaim its memory. Use for app phases that pull in code you won't need again:
+ *
+ * ```ts
+ * const status = await withUnload(
+ *   import('./phases/modem.js'),
+ *   (modem) => modem.runPhase(input),
+ * )
+ * // the modem phase is unloaded and reclaimed by the time this resolves
+ * ```
+ *
+ * The module is unloaded when `use` returns (or throws), including any transitive
+ * dependency whose only importer was this module. Don't return one of the
+ * module's exports from `use`; that keeps the module alive. Throws if the
+ * resolved value isn't an unloadable module namespace (e.g. a builtin
+ * `mikrojs/*` or `native:*` module).
+ *
+ * This is non-standard: standard JavaScript modules stay loaded for the life of
+ * the program, and a later `import` re-evaluates an unloaded module from scratch.
+ */
+export async function withUnload<T extends object, R>(
+  mod: Promise<T>,
+  use: (mod: T) => R | Promise<R>,
+): Promise<R> {
+  const ns = await mod
+  if (!isUnloadableNamespace(ns)) {
+    throw new TypeError('withUnload() expects an unloadable module namespace')
+  }
+  try {
+    return await use(ns)
+  } finally {
+    unloadNamespace(ns)
+  }
+}

package/runtime/module/types.ts

@@ -0,0 +1,21 @@
+/** Load a dynamically imported module, run `use` with it, then unload it and
+ *  reclaim its memory:
+ *
+ *  ```ts
+ *  const status = await withUnload(
+ *    import('./phases/modem.js'),
+ *    (modem) => modem.runPhase(input),
+ *  )
+ *  ```
+ *
+ *  The module (and any transitive dependency whose only importer was it) is
+ *  unloaded when `use` returns or throws. Don't return one of the module's
+ *  exports from `use`; that keeps it alive. Throws if the resolved value isn't
+ *  an unloadable module namespace (e.g. a builtin `mikrojs/*` or `native:*`).
+ *
+ *  Non-standard: standard JavaScript modules stay loaded for the life of the
+ *  program, and a later `import` re-evaluates an unloaded module from scratch. */
+export declare function withUnload<T extends object, R>(
+  mod: Promise<T>,
+  use: (mod: T) => R | Promise<R>,
+): Promise<R>

package/runtime/pwm/pwm.ts

@@ -1,4 +1,4 @@
-import {ok} from 'mikrojs/result'
+import {ok} from 'mikro/result'
 import {Pwm as NativePwm} from 'native:pwm'
 
 import type {Result} from '../result/types.js'

package/runtime/reader/reader.ts

@@ -9,7 +9,7 @@
  * lazy-load efficiency.
  */
 
-import {err, ok} from 'mikrojs/result'
+import {err, ok} from 'mikro/result'
 
 import type {Result} from '../result/types.js'
 

package/runtime/reader/types.ts

@@ -7,7 +7,7 @@
  * `packages/mikrojs` and by user apps via their tsconfig.
  */
 
-import type {Result} from 'mikrojs/result'
+import type {Result} from 'mikro/result'
 
 export type ReaderError = {name: 'Timeout'; ms: number} | {name: 'StreamClosed'}
 

package/runtime/schema/schema.ts

@@ -1,4 +1,4 @@
-import {err, ok} from 'mikrojs/result'
+import {err, ok} from 'mikro/result'
 
 import type {Result} from '../result/types.js'
 

package/runtime/sntp/sntp.ts

@@ -1,4 +1,4 @@
-import {err, ok} from 'mikrojs/result'
+import {err, ok} from 'mikro/result'
 import {setTimezone, stop as nativeStop, sync as nativeSync} from 'native:sntp'
 
 import type {Result} from '../result/types.js'

package/runtime/stream/stream.ts

@@ -14,7 +14,7 @@
  * Expand only when a second call site asks for it.
  */
 
-import {err, ok} from 'mikrojs/result'
+import {err, ok} from 'mikro/result'
 
 import type {Result} from '../result/types.js'
 

package/runtime/stream/types.ts

@@ -11,7 +11,7 @@
  * errors widen the error type with a `StreamError` variant.
  */
 
-import type {Result} from 'mikrojs/result'
+import type {Result} from 'mikro/result'
 
 export type StreamError = {name: 'Timeout'; ms: number} | {name: 'StreamClosed'}
 

package/runtime/sys/sys.ts

@@ -1,4 +1,4 @@
-import {err, ok, PanicError, type Result} from 'mikrojs/result'
+import {err, ok, PanicError, type Result} from 'mikro/result'
 import {getWakeupCause as nativeGetWakeupCause} from 'native:sleep'
 import * as native from 'native:sys'
 

package/runtime/test/test.ts

@@ -1,5 +1,5 @@
 /* eslint-disable no-console */
-import {gc, memoryUsage, MonotonicTimestamp} from 'mikrojs/sys'
+import {gc, memoryUsage, MonotonicTimestamp} from 'mikro/sys'
 import {pendingCount as pendingHttpCount} from 'native:http'
 import {activeTimers} from 'native:sys'
 

package/runtime/uart/uart.ts

@@ -1,4 +1,4 @@
-import {ok} from 'mikrojs/result'
+import {ok} from 'mikro/result'
 import * as native from 'native:uart'
 
 import type {Result} from '../result/types.js'

package/runtime/udp/udp.ts

@@ -1,4 +1,4 @@
-import {ok} from 'mikrojs/result'
+import {ok} from 'mikro/result'
 import {Observable} from 'native:observable'
 import {bind as nativeBind, type NativeUdpSocket} from 'native:udp'
 

package/runtime/wifi/wifi.ts

@@ -1,5 +1,5 @@
-import {lazyEvent} from 'mikrojs/observable/lazy'
-import {err, ok} from 'mikrojs/result'
+import {lazyEvent} from 'mikro/observable/lazy'
+import {err, ok} from 'mikro/result'
 import {Wifi as NativeWifi} from 'native:wifi'
 
 import type {Result} from '../result/types.js'

package/scripts/bundle-runtime.js

@@ -104,7 +104,7 @@ for (const name of moduleNames) {
     target: 'es2024',
     platform: 'neutral',
     format: 'esm',
-    external: ['mikrojs', 'mikrojs/*', '@mikrojs/*', 'native:*'],
+    external: ['mikro', 'mikro/*', '@mikrojs/*', 'native:*'],
   })
 
   const output = result.outputFiles?.[0]
@@ -128,7 +128,7 @@ for (const name of moduleNames) {
   // Extract external imports so CMake can pass them as -M flags to qjsc
   const externals = []
   for (const match of source.matchAll(
-    /(?:from|import)\s*["']((?:native:|mikrojs\/|@mikrojs\/)[^"']+)["']/g,
+    /(?:from|import)\s*["']((?:native:|mikro\/|@mikrojs\/)[^"']+)["']/g,
   )) {
     externals.push(match[1])
   }

package/src/builtins.cpp

@@ -14,8 +14,8 @@ typedef struct {
 
 /* Generated by mikrojs_generate_bytecode() in CMake — includes + lookup table.
  * Adding a new module only requires updating the MODULES list in CMakeLists.txt. */
-#include "gen/mikrojs_builtins_table.h"
-#define builtins mikrojs_builtins
+#include "gen/mikro_builtins_table.h"
+#define builtins mikro_builtins
 
 /* External builtins registered by board/driver packages via MIK_REGISTER_BUILTIN() */
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)

package/src/mik_app_config.cpp

@@ -13,6 +13,8 @@ static const char* TAG = "mik_app_config";
 
 void MIK_DefaultConfig(MIKConfig* config) {
     config->panic_restart_delay_ms = 1000;
+    config->panic_mode = MIK_PANIC_RESTART;
+    config->panic_sleep_duration_ms = 0;
     config->stack_size = 0;
     config->mem_reserved = 64 * 1024;
     config->fs_read_max = 0; /* 0 = runtime default (65536) */
@@ -318,9 +320,19 @@ int MIK_LoadConfig(const char* base_path, MIKConfig* config) {
         if (buf) {
             double num_val;
 
-            if (mik__json_get_number(buf, "panicRestartDelay", &num_val)) {
+            if (mik__json_get_number(buf, "onPanic.delay", &num_val)) {
                 config->panic_restart_delay_ms = (int)num_val;
             }
+            char panic_mode_str[16];
+            if (mik__json_get_string(buf, "onPanic.mode", panic_mode_str,
+                                     sizeof(panic_mode_str))) {
+                config->panic_mode = strcmp(panic_mode_str, "deepSleep") == 0
+                                         ? MIK_PANIC_DEEP_SLEEP
+                                         : MIK_PANIC_RESTART;
+            }
+            if (mik__json_get_number(buf, "onPanic.duration", &num_val)) {
+                config->panic_sleep_duration_ms = (int)num_val;
+            }
             if (mik__json_get_number(buf, "stackSize", &num_val)) {
                 config->stack_size = (size_t)num_val;
             }

package/src/mik_sys.cpp

@@ -96,6 +96,24 @@ static JSValue mik__sys_gc(JSContext* ctx, JSValue this_val, int argc, JSValue*
     return JS_UNDEFINED;
 }
 
+/* Backs withUnload()'s unload step. Unloads the module whose
+ * namespace is argv[0]; returns the number of modules freed (0 if not a
+ * loaded module's namespace). Refcounting reclaims the memory once the
+ * caller's reference drops; no GC here. */
+static JSValue mik__sys_unload_namespace(JSContext* ctx, JSValue this_val, int argc,
+                                         JSValue* argv) {
+    int rv = mik__unload_namespace(ctx, argv[0]);
+    if (rv < 0) return JS_EXCEPTION;
+    return JS_NewInt32(ctx, rv);
+}
+
+/* True if argv[0] is the namespace of a loaded, non-anchored module.
+ * withUnload() uses this to reject builtins (native:/mikrojs//@mikrojs/). */
+static JSValue mik__sys_is_unloadable_namespace(JSContext* ctx, JSValue this_val, int argc,
+                                                JSValue* argv) {
+    return JS_NewBool(ctx, mik__is_unloadable_namespace(ctx, argv[0]));
+}
+
 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);
@@ -220,6 +238,11 @@ void mik__sys_api_init(JSContext* ctx, JSValue ns) {
     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, "unloadNamespace",
+                      JS_NewCFunction(ctx, mik__sys_unload_namespace, "unloadNamespace", 1));
+    JS_SetPropertyStr(
+        ctx, ns, "isUnloadableNamespace",
+        JS_NewCFunction(ctx, mik__sys_is_unloadable_namespace, "isUnloadableNamespace", 1));
     JS_SetPropertyStr(ctx, ns, "activeTimers",
                       JS_NewCFunction(ctx, mik__sys_active_timers, "activeTimers", 0));
     JS_SetPropertyStr(ctx, ns, "setTime",

package/src/mik_text_encoding.cpp

@@ -242,44 +242,138 @@ static const JSCFunctionListEntry mik__text_decoder_proto_funcs[] = {
 
 static const char b64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
-static const uint8_t b64_decode_table[256] = {
+/* The base64 decoder below is ported from QuickJS-NG (quickjs.c, `b64_decode`
+ * and its lookup tables), which implements the WHATWG forgiving-base64 decode
+ * algorithm. QuickJS-NG is MIT licensed:
+ *   Copyright (c) 2017-2024 Fabrice Bellard, Charlie Gordon and contributors.
+ * We use only the standard alphabet (atob/btoa never decode base64url) and
+ * surface decode failures as our own error type rather than a DOMException. */
+enum { K_VAL = 1u, K_WS = 2u };
+
+/* Sextet value per base64 character (0 for non-base64 bytes; validity is gated
+ * by b64_flags below). Positional initializer to stay standard C++. */
+static const uint8_t b64_val[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,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,62, 0, 0, 0,63,
+    52,53,54,55,56,57,58,59,60,61, 0, 0, 0, 0, 0, 0,
+     0, 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, 0, 0, 0, 0, 0,
+     0,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, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     /* clang-format on */
 };
 
+/* Per-byte class: K_WS (2) for ASCII whitespace, K_VAL (1) for the 64 standard
+ * base64 alphabet characters, 0 (invalid) otherwise. */
+static const char b64_flags[256] = {
+    /* clang-format off */
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 2, 2, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1,
+     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
+     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
+     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* clang-format on */
+};
+
+/* Implements https://infra.spec.whatwg.org/#forgiving-base64-decode.
+ * Writes decoded bytes to dst and returns the count; sets *err on malformed
+ * input. dst must have room for at least (len / 4) * 3 + 3 bytes. */
+static size_t b64_decode(const char* src, size_t len, uint8_t* dst, int* err) {
+    size_t i, j;
+    uint32_t acc;
+    int seen, pad;
+    unsigned ch;
+
+    acc = 0;
+    seen = 0;
+    for (i = 0, j = 0; i < len; i++) {
+        ch = (unsigned char)src[i];
+        if ((b64_flags[ch] & K_WS)) continue;
+        if (!(b64_flags[ch] & K_VAL)) break;
+        acc = (acc << 6) | b64_val[ch];
+        seen++;
+        if (seen == 4) {
+            dst[j++] = (acc >> 16) & 0xFF;
+            dst[j++] = (acc >> 8) & 0xFF;
+            dst[j++] = acc & 0xFF;
+            seen = 0;
+            acc = 0;
+        }
+    }
+
+    if (seen != 0) {
+        if (seen == 3) {
+            dst[j++] = (acc >> 10) & 0xFF;
+            dst[j++] = (acc >> 2) & 0xFF;
+        } else if (seen == 2) {
+            dst[j++] = (acc >> 4) & 0xFF;
+        } else {
+            *err = 1;
+            return 0;
+        }
+        for (pad = 0; i < len; i++) {
+            ch = (unsigned char)src[i];
+            if (pad < 2 && ch == '=') {
+                pad++;
+            } else if (!(b64_flags[ch] & K_WS)) {
+                break;
+            }
+        }
+        if (pad != 0 && seen + pad != 4) {
+            *err = 1;
+            return 0;
+        }
+    }
+
+    *err = i < len;
+    return j;
+}
+
 /* 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). */
+ * Per the web spec, the argument is first coerced to a string (ToString), then
+ * each character's code point is treated as a raw byte. We iterate by code
+ * point, not by UTF-8 bytes, since JS_ToCStringLen would turn e.g. U+0080 into
+ * two bytes (\xC2\x80). */
 static JSValue mik__btoa(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
-    JSValue str_val = argv[0];
+    JSValue str_val = JS_ToString(ctx, argv[0]);
+    if (JS_IsException(str_val)) return JS_EXCEPTION;
+
     JSValue len_val = JS_GetPropertyStr(ctx, str_val, "length");
     int64_t len;
     if (JS_ToInt64(ctx, &len, len_val)) {
         JS_FreeValue(ctx, len_val);
+        JS_FreeValue(ctx, str_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;
+    if (!bytes) {
+        JS_FreeValue(ctx, str_val);
+        return JS_EXCEPTION;
+    }
 
     JSAtom charCodeAt_atom = JS_NewAtom(ctx, "charCodeAt");
     for (int64_t i = 0; i < len; i++) {
@@ -289,6 +383,7 @@ static JSValue mik__btoa(JSContext* ctx, JSValue this_val, int argc, JSValue* ar
         if (JS_IsException(code)) {
             JS_FreeAtom(ctx, charCodeAt_atom);
             js_free(ctx, bytes);
+            JS_FreeValue(ctx, str_val);
             return JS_EXCEPTION;
         }
         int32_t cp;
@@ -297,6 +392,7 @@ static JSValue mik__btoa(JSContext* ctx, JSValue this_val, int argc, JSValue* ar
         if (cp > 0xFF) {
             JS_FreeAtom(ctx, charCodeAt_atom);
             js_free(ctx, bytes);
+            JS_FreeValue(ctx, str_val);
             return JS_ThrowRangeError(ctx,
                                       "The string to be encoded contains characters outside of the "
                                       "Latin1 range");
@@ -304,6 +400,7 @@ static JSValue mik__btoa(JSContext* ctx, JSValue this_val, int argc, JSValue* ar
         bytes[i] = (uint8_t)cp;
     }
     JS_FreeAtom(ctx, charCodeAt_atom);
+    JS_FreeValue(ctx, str_val);
 
     size_t out_len = 4 * ((len + 2) / 3);
     char* out = static_cast<char*>(js_malloc(ctx, out_len + 1));
@@ -332,55 +429,32 @@ static JSValue mik__btoa(JSContext* ctx, JSValue this_val, int argc, JSValue* ar
     return ret;
 }
 
-/* atob: decode a base64 string to a binary string */
+/* atob: decode a base64 string to a binary string. The argument is coerced to
+ * a string (ToString) per spec, then decoded via the ported forgiving-base64
+ * decoder above. */
 static JSValue mik__atob(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    JSValue str_val = JS_ToString(ctx, argv[0]);
+    if (JS_IsException(str_val)) return JS_EXCEPTION;
     size_t len;
-    const char* str = JS_ToCStringLen(ctx, &len, argv[0]);
+    const char* str = JS_ToCStringLen(ctx, &len, str_val);
+    JS_FreeValue(ctx, str_val);
     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));
+    size_t out_cap = (len / 4) * 3 + 3;
+    uint8_t* out = static_cast<uint8_t*>(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);
-        }
-    }
-
+    int err = 0;
+    size_t j = b64_decode(str, len, out, &err);
     JS_FreeCString(ctx, str);
+    if (err) {
+        js_free(ctx, out);
+        return JS_ThrowSyntaxError(ctx,
+                                   "The string to be decoded is not correctly encoded");
+    }
 
     /* Convert decoded bytes to a JS string. Bytes 0x80-0xFF must become
      * their corresponding Unicode code points (U+0080-U+00FF), which in

package/src/mikrojs.cpp

@@ -89,8 +89,9 @@ static void mik__add_exports(JSContext* ctx, JSModuleDef* m, const char* const*
 }
 
 static const char* const sys_exports[] = {
-    "evalScript", "memoryUsage", "jsMemoryUsage", "gc",       "setTime",      "uptime",
-    "restart",    "version",     "board",         "firmware", "deviceId",     "activeTimers"};
+    "evalScript", "memoryUsage", "jsMemoryUsage",  "gc",          "setTime",
+    "uptime",     "restart",     "version",        "board",       "firmware",
+    "deviceId",   "activeTimers", "unloadNamespace", "isUnloadableNamespace"};
 
 static int mik__sys_module_init(JSContext* ctx, JSModuleDef* m) {
     JSValue ns = JS_NewObjectProto(ctx, JS_NULL);
@@ -542,6 +543,14 @@ int MIK_Loop(MIKRuntime* mik_rt) {
     if (mik_rt->restart_at_us > 0) {
         const MIKPlatform* platform = MIK_GetPlatform();
         if (platform->get_boot_us() >= mik_rt->restart_at_us) {
+            /* The grace window has elapsed; take the configured panic action.
+             * In deep-sleep mode the timer wake reboots the chip, so the wake
+             * IS the restart — and the live --recover window is forfeit by
+             * design (the CPU is suspended). If the platform has no deep-sleep
+             * hook (hosts), fall through to a plain restart. */
+            if (mik_rt->config.panic_mode == MIK_PANIC_DEEP_SLEEP && platform->deep_sleep_us) {
+                platform->deep_sleep_us((uint64_t)mik_rt->config.panic_sleep_duration_ms * 1000);
+            }
             platform->restart();
         }
         return 0;

package/src/modules.cpp

@@ -200,7 +200,7 @@ static JSModuleDef* mik_module_load_from_fs(JSContext* ctx, const char* module_n
 
 static JSModuleDef* mik_module_loader_inner(JSContext* ctx, const char* module_name,
                                             void* opaque) {
-    static const char mikrojs_prefix[] = "mikrojs/";
+    static const char mikro_prefix[] = "mikro/";
 
     /* Virtual modules take priority over builtins — allows host-side JS to
      * override any native:* C module (e.g. mocking device modules for dev). */
@@ -239,7 +239,7 @@ static JSModuleDef* mik_module_loader_inner(JSContext* ctx, const char* module_n
         return nullptr;
     }
 
-    if (strncmp(mikrojs_prefix, module_name, strlen(mikrojs_prefix)) == 0) {
+    if (strncmp(mikro_prefix, module_name, strlen(mikro_prefix)) == 0) {
         JSModuleDef* builtin_m = mik__load_builtin(ctx, module_name);
         if (builtin_m) return builtin_m;
         /* mik__load_builtin returns NULL either because the module isn't in
@@ -360,39 +360,6 @@ JSModuleDef* mik_module_loader(JSContext* ctx, const char* module_name, void* op
 #define MIK__PATHSEP '/'
 #define MIK__PATHSEP_STR "/"
 
-/* import.meta.unload(specifier) implementation. Resolves `specifier` via
- * the standard normalizer using the captured base path (the owning
- * module's logical path, stripped of the `file://` prefix), evicts the
- * resulting module + orphaned deps via mik__unload_module, then runs a
- * GC pass so the caller's next memoryUsage() snapshot reflects the free. */
-static JSValue mik__import_meta_unload(JSContext* ctx, JSValueConst this_val,
-                                       int argc, JSValueConst* argv,
-                                       int magic, JSValueConst* func_data) {
-    (void)magic;
-    (void)this_val;
-    if (argc < 1 || !JS_IsString(argv[0])) {
-        return JS_ThrowTypeError(ctx, "import.meta.unload: specifier must be a string");
-    }
-    const char* specifier = JS_ToCString(ctx, argv[0]);
-    if (!specifier) return JS_EXCEPTION;
-    const char* base = JS_ToCString(ctx, func_data[0]);
-    if (!base) {
-        JS_FreeCString(ctx, specifier);
-        return JS_EXCEPTION;
-    }
-    char* normalized = mik_module_normalizer(ctx, base, specifier, nullptr);
-    JS_FreeCString(ctx, specifier);
-    JS_FreeCString(ctx, base);
-    if (!normalized) return JS_EXCEPTION;
-
-    int rv = mik__unload_module(ctx, normalized);
-    js_free(ctx, normalized);
-    if (rv < 0) return JS_EXCEPTION;
-
-    JS_RunGC(JS_GetRuntime(ctx));
-    return JS_NewInt32(ctx, rv);
-}
-
 int js_module_set_import_meta(JSContext* ctx, JSValue func_val, bool use_realpath, bool is_main) {
     JSModuleDef* m;
     char buf[PATH_MAX + 16] = {0};
@@ -454,16 +421,6 @@ int js_module_set_import_meta(JSContext* ctx, JSValue func_val, bool use_realpat
                                   JS_PROP_C_W_E);
     }
 
-    /* Attach import.meta.unload(specifier). Needs the owning module's
-     * logical path (not URL) as the normalizer base. Only exposed for
-     * file-backed modules; synthetic modules don't have a stable path. */
-    if (use_realpath) {
-        JSValue base_str = JS_NewString(ctx, buf + 7 /* strip "file://" */);
-        JSValue unload_fn = JS_NewCFunctionData(ctx, mik__import_meta_unload, 1, 0, 1, &base_str);
-        JS_FreeValue(ctx, base_str);
-        JS_DefinePropertyValueStr(ctx, meta_obj, "unload", unload_fn, JS_PROP_C_W_E);
-    }
-
     JS_FreeValue(ctx, meta_obj);
     return 0;
 }
@@ -698,11 +655,11 @@ static char* mik__resolve_node_modules(JSContext* ctx, const char* base_dir,
     return NULL;
 }
 
-/* Anchored names (native:, mikrojs/, @mikrojs/) are never unloaded
+/* Anchored names (native:, mikro/, @mikrojs/) are never unloaded
  * and don't contribute meaningfully to the import graph for orphan
  * detection. We skip recording edges where the target is anchored. */
 static bool mik__is_anchored_name(const char* name) {
-    return strncmp(name, "native:", 7) == 0 || strncmp(name, "mikrojs/", 8) == 0 ||
+    return strncmp(name, "native:", 7) == 0 || strncmp(name, "mikro/", 6) == 0 ||
            strncmp(name, "@mikrojs/", 9) == 0;
 }
 
@@ -726,8 +683,8 @@ static char* mik__module_normalizer_impl(JSContext* ctx, const char* base_name,
 
     static const char internal_prefix[] = "native:";
     if (strncmp(name, internal_prefix, strlen(internal_prefix)) == 0) {
-        // Only built-in modules (native:, mikrojs/, @mikrojs/) may import native: internals
-        if (strncmp(base_name, "native:", 7) != 0 && strncmp(base_name, "mikrojs/", 8) != 0 &&
+        // Only built-in modules (native:, mikro/, @mikrojs/) may import native: internals
+        if (strncmp(base_name, "native:", 7) != 0 && strncmp(base_name, "mikro/", 6) != 0 &&
             strncmp(base_name, "@mikrojs/", 9) != 0) {
             JS_ThrowTypeError(ctx, "Failed to resolve module specifier '%s'", name);
             return NULL;
@@ -736,7 +693,7 @@ static char* mik__module_normalizer_impl(JSContext* ctx, const char* base_name,
 
     if (name[0] != '.' && name[0] != '/') {
         /* Built-in modules pass through unchanged */
-        if (strncmp(name, "mikrojs/", 8) == 0 || strncmp(name, "native:", 7) == 0) {
+        if (strncmp(name, "mikro/", 6) == 0 || strncmp(name, "native:", 7) == 0) {
             return js_strdup(ctx, name);
         }
         /* Check if this bare specifier matches an external builtin (board/driver
@@ -942,3 +899,32 @@ int mik__unload_module(JSContext* ctx, const char* normalized_name) {
 
     return freed_count;
 }
+
+/* Resolve `ns` to the loaded module it is the namespace of, returning its
+ * normalized name as a C string (caller frees via JS_FreeCString), or NULL
+ * if `ns` is not an object or not a loaded module's namespace. */
+static const char* mik__module_name_from_ns(JSContext* ctx, JSValueConst ns) {
+    if (!JS_IsObject(ns)) return nullptr;
+    JSModuleDef* m = JS_FindModuleByNamespace(ctx, ns);
+    if (!m) return nullptr;
+    JSAtom atom = JS_GetModuleName(ctx, m);
+    const char* name = JS_AtomToCString(ctx, atom);
+    JS_FreeAtom(ctx, atom);
+    return name;
+}
+
+int mik__unload_namespace(JSContext* ctx, JSValueConst ns) {
+    const char* name = mik__module_name_from_ns(ctx, ns);
+    if (!name) return 0; /* not a loaded module's namespace: idempotent no-op */
+    int rv = mik__unload_module(ctx, name);
+    JS_FreeCString(ctx, name);
+    return rv;
+}
+
+bool mik__is_unloadable_namespace(JSContext* ctx, JSValueConst ns) {
+    const char* name = mik__module_name_from_ns(ctx, ns);
+    if (!name) return false;
+    bool ok = !mik__is_anchored_name(name);
+    JS_FreeCString(ctx, name);
+    return ok;
+}