@mikrojs/native 0.12.0 → 0.14.0-pr-229.g0d8db1b

package/src/mikrojs.cpp

@@ -2,6 +2,7 @@
 
 #include <quickjs.h>
 
+#include <atomic>
 #include <cerrno>
 #include <cstdio>
 #include <fcntl.h>
@@ -91,7 +92,7 @@ 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", "unloadNamespace", "isUnloadableNamespace"};
+    "deviceId",   "resetReason", "activeTimers",   "unloadNamespace", "isUnloadableNamespace"};
 
 static int mik__sys_module_init(JSContext* ctx, JSModuleDef* m) {
     JSValue ns = JS_NewObjectProto(ctx, JS_NULL);
@@ -111,21 +112,19 @@ static int mik__stdio_module_init(JSContext* ctx, JSModuleDef* m) {
     return 0;
 }
 
-static JSValue mik__dispatch_event(JSContext* ctx, JSValue* event) {
-    MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
-    CHECK_NOT_NULL(mik_rt);
-
-    if (mik_rt->freeing) {
-        return JS_UNDEFINED;
-    }
-
-    JSValue global_obj = JS_GetGlobalObject(ctx);
-    JSValue ret = JS_Call(ctx, mik_rt->builtins.dispatch_event_func, global_obj, 1, event);
-    JS_FreeValue(ctx, global_obj);
-
-    return ret;
-}
-
+/* Host promise-rejection tracker. Rather than report eagerly the instant a
+ * promise rejects, defer the decision to the end-of-turn flush
+ * (mik__flush_unhandled_rejections): a promise that rejects without a
+ * handler is queued, and a promise that later gets a handler is removed
+ * from the queue. This mirrors the HTML/WinterCG unhandledrejection
+ * algorithm. It matters because some promises are born rejected before a
+ * handler can be attached. The clearest example is a module's evaluation
+ * promise, which the dynamic-import loader rejects (when the module body
+ * throws) and only then attaches its .then to. Reporting eagerly surfaced
+ * that transient rejection as a spurious second "Uncaught (in promise)".
+ *
+ * This is the same add-on-reject / remove-on-handle / report-after-drain
+ * pattern quickjs-libc's js_std_promise_rejection_tracker uses. */
 static void mik__promise_rejection_tracker(JSContext* ctx, JSValue promise, JSValue reason,
                                            bool is_handled, void* opaque) {
     MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
@@ -135,68 +134,109 @@ static void mik__promise_rejection_tracker(JSContext* ctx, JSValue promise, JSVa
         return;
     }
 
-    if (!is_handled) {
-        /* If the runtime hasn't loaded the event infrastructure yet,
-         * report and bail. */
-        if (JS_IsUndefined(mik_rt->builtins.promise_event_ctor) ||
-            JS_IsUndefined(mik_rt->builtins.dispatch_event_func)) {
-            /* During REPL eval, sync errors are wrapped by the async eval
-             * wrapper and appear as promise rejections — don't label them
-             * "(in promise)".  Outside eval (e.g. timer callbacks), they
-             * are genuine unhandled promise rejections. */
-            bool in_promise = !mik__repl_is_evaluating();
-            mik__report_uncaught(ctx, reason, in_promise);
-            /* Notify the error handler (e.g. host bridge) directly.
-             * Don't JS_Throw here — we're inside a QuickJS callback
-             * during promise resolution; throwing would corrupt engine
-             * state and cause mik__execute_jobs to dump the error a
-             * second time. MIK_Stop gates on whether we're inside an
-             * interactive REPL eval (skipping both the stop request and
-             * the restart) so a typo at the prompt doesn't reboot the
-             * device. */
-            if (mik_rt->error_handler_fn) {
-                mik_rt->error_handler_fn(ctx, reason, mik_rt->error_handler_opaque);
+    auto& pending = mik_rt->pending_rejections;
+    void* key = JS_VALUE_GET_PTR(promise);
+
+    if (is_handled) {
+        /* A handler was attached to a previously-rejected promise: cancel its
+         * pending report. */
+        for (size_t i = 0; i < pending.size(); i++) {
+            if (JS_VALUE_GET_PTR(pending[i].promise) == key) {
+                JS_FreeValue(ctx, pending[i].promise);
+                JS_FreeValue(ctx, pending[i].reason);
+                pending.erase(pending.begin() + i);
+                return;
             }
-            MIK_Stop(mik_rt);
-            return;
         }
+        return;
+    }
+
+    /* Rejected with no handler (yet): queue it. Hold references to both the
+     * promise and the reason so they stay alive until the end-of-turn check. */
+    pending.push_back({JS_DupValue(ctx, promise), JS_DupValue(ctx, reason)});
+}
 
-        JSValue event_name = JS_NewString(ctx, "unhandledrejection");
-        JSValue args[3];
-        args[0] = event_name;
-        args[1] = promise;
-        args[2] = reason;
-
-        JSValue event =
-            JS_CallConstructor(ctx, mik_rt->builtins.promise_event_ctor, countof(args), args);
-        if (JS_IsException(event)) {
-            JS_FreeValue(ctx, event_name);
-            mik_dump_error(ctx);
+/* Drop a promise from the pending-rejection queue without reporting it. The
+ * REPL eval pump calls this for the result promise it polls and reports via
+ * the throw path, so the end-of-turn flush doesn't report it a second time. */
+void mik__forget_rejection(JSContext* ctx, JSValue promise) {
+    MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
+    if (!mik_rt) {
+        return;
+    }
+    auto& pending = mik_rt->pending_rejections;
+    void* key = JS_VALUE_GET_PTR(promise);
+    for (size_t i = 0; i < pending.size(); i++) {
+        if (JS_VALUE_GET_PTR(pending[i].promise) == key) {
+            JS_FreeValue(ctx, pending[i].promise);
+            JS_FreeValue(ctx, pending[i].reason);
+            pending.erase(pending.begin() + i);
             return;
         }
-        JSValue ret = mik__dispatch_event(ctx, &event);
+    }
+}
 
-        JS_FreeValue(ctx, event);
-        JS_FreeValue(ctx, event_name);
+/* End-of-turn unhandled-rejection check. Any promise still queued after a
+ * microtask drain rejected and never got a handler: report it, notify the
+ * host error handler, and halt. */
+void mik__flush_unhandled_rejections(JSContext* ctx) {
+    MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
+    if (!mik_rt || mik_rt->freeing || mik_rt->pending_rejections.empty()) {
+        return;
+    }
+    /* During interactive REPL eval, the eval pump polls its result promise
+     * and reports rejections via the throw path; leave the queue alone until
+     * the eval finishes so we don't fight that model. */
+    if (mik__repl_is_evaluating()) {
+        return;
+    }
 
-        if (JS_IsException(ret)) {
-            mik_dump_error(ctx);
-            goto fail;
-        } else {
-            if (JS_ToBool(ctx, ret)) {
-            // The event wasn't cancelled, maybe abort.
-            fail:;
-                MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
-                CHECK_NOT_NULL(mik_rt);
-                mik__report_uncaught(ctx, reason, true);
-                if (mik_rt->error_handler_fn) {
-                    mik_rt->error_handler_fn(ctx, reason, mik_rt->error_handler_opaque);
-                }
-                MIK_Stop(mik_rt);
+    /* Move the queue aside before reporting. Reporting doesn't enqueue JS
+     * jobs, but this keeps the runtime's vector in a clean state regardless. */
+    std::vector<MIKRejectedPromise> rejected;
+    rejected.swap(mik_rt->pending_rejections);
+
+    /* One failed dynamic import leaves two never-handled promises with the
+     * SAME reason: the module's internal sync-evaluation promise (QuickJS runs
+     * a module body as an async function and reads its rejected result by
+     * value, never attaching a handler) and the promise the error propagates
+     * to up the await chain. mik__report_uncaught dedups by reason-object
+     * identity, so the second is a no-op; only act on a fresh report so the
+     * host bridge and the halt don't fire twice. (quickjs-libc reports every
+     * entry; we collapse same-error duplicates.) */
+    for (const MIKRejectedPromise& rp : rejected) {
+        if (mik__report_uncaught(ctx, rp.reason, true)) {
+            /* Notify the error handler (e.g. host bridge) directly. Don't
+             * JS_Throw here: we're between jobs, and throwing would be picked
+             * up as a spurious pending exception. */
+            if (mik_rt->error_handler_fn) {
+                mik_rt->error_handler_fn(ctx, rp.reason, mik_rt->error_handler_opaque);
             }
+            MIK_Stop(mik_rt);
         }
+        JS_FreeValue(ctx, rp.promise);
+        JS_FreeValue(ctx, rp.reason);
+    }
+}
 
-        JS_FreeValue(ctx, ret);
+/* QuickJS only runs the cycle collector automatically once malloc_size
+ * crosses the runtime's GC threshold (256 KB by default), and js_malloc_rt
+ * fails against the memory limit without attempting a GC first. On devices
+ * where mem_limit is below the default threshold the collector would never
+ * fire before allocations start failing, so cyclic garbage (promise chains,
+ * closures) accumulates straight into OOM with collectable memory still
+ * alive. Cap the threshold below the limit so collection happens first.
+ * QuickJS raises the threshold to 1.5x the live size after every GC pass,
+ * which can push it back above the limit, so MIK_Loop re-applies the cap
+ * each turn. */
+static void mik__clamp_gc_threshold(MIKRuntime* mik_rt) {
+    if (mik_rt->options.mem_limit <= 0) {
+        return;
+    }
+    size_t limit = (size_t)mik_rt->options.mem_limit;
+    size_t cap = limit - limit / 8;
+    if (JS_GetGCThreshold(mik_rt->rt) > cap) {
+        JS_SetGCThreshold(mik_rt->rt, cap);
     }
 }
 
@@ -289,12 +329,25 @@ MIKRuntime* MIK_NewRuntimeInternal(MIKRunOptions* options) {
      * exhaust the heap. Overridden via MIK_SetFSReadMax. */
     mik_rt->fs_read_max = 65536;
 
+    /* Reserve the unhandled-rejection queue up-front so the rejection tracker
+     * never has to grow a std::vector on the rejection path. That path fires
+     * for a QuickJS null-OOM rejection, and a reallocation there could throw
+     * std::bad_alloc — which, with CONFIG_COMPILER_CXX_EXCEPTIONS=n on ESP32,
+     * aborts and masks the very OOM we're trying to report. Four slots covers
+     * any realistic per-turn rejection count; the runtime halts on the first
+     * one anyway. */
+    mik_rt->pending_rejections.reserve(4);
+
     /* Check for duplicate native module registrations (global registry) */
     mik__check_module_collisions();
 
     /* Set memory limit */
     JS_SetMemoryLimit(rt, options->mem_limit);
 
+    /* Make sure the cycle collector fires before the memory limit does
+     * (see mik__clamp_gc_threshold). */
+    mik__clamp_gc_threshold(mik_rt);
+
     /* Set stack size */
     JS_SetMaxStackSize(rt, options->stack_size);
     /* loader for ES modules */
@@ -337,11 +390,6 @@ MIKRuntime* MIK_NewRuntimeInternal(MIKRunOptions* options) {
     mik__text_encoding_init(ctx, global_obj);
     mik__abort_init(ctx, global_obj);
 
-    /* Load some builtin references for easy access */
-    mik_rt->builtins.dispatch_event_func = JS_GetPropertyStr(ctx, global_obj, "dispatchEvent");
-    mik_rt->builtins.promise_event_ctor =
-        JS_GetPropertyStr(mik_rt->ctx, global_obj, "PromiseRejectionEvent");
-
     /* Timers */
     mik_rt->timers = MIK_NewTimerRegistry();
     mik__timers_init(ctx, global_obj);
@@ -369,6 +417,13 @@ void MIK_FreeRuntime(MIKRuntime* mik_rt) {
         mik_rt->stdin_state.on_data = JS_UNDEFINED;
     }
 
+    /* Release any still-pending unhandled-rejection entries. */
+    for (const MIKRejectedPromise& rp : mik_rt->pending_rejections) {
+        JS_FreeValue(mik_rt->ctx, rp.promise);
+        JS_FreeValue(mik_rt->ctx, rp.reason);
+    }
+    mik_rt->pending_rejections.clear();
+
     /* Destroy registered loop consumers */
     for (const auto& consumer : mik_rt->loop_consumers) {
         if (consumer.destroy_fn) {
@@ -384,10 +439,6 @@ void MIK_FreeRuntime(MIKRuntime* mik_rt) {
     /* Destroy the JS engine. */
     JS_FreeValue(mik_rt->ctx, mik_rt->env_obj);
     mik_rt->env_obj = JS_UNDEFINED;
-    JS_FreeValue(mik_rt->ctx, mik_rt->builtins.dispatch_event_func);
-    mik_rt->builtins.dispatch_event_func = JS_UNDEFINED;
-    JS_FreeValue(mik_rt->ctx, mik_rt->builtins.promise_event_ctor);
-    mik_rt->builtins.promise_event_ctor = JS_UNDEFINED;
     JS_FreeValue(mik_rt->ctx, mik_rt->result_ok_void_singleton);
     mik_rt->result_ok_void_singleton = JS_UNDEFINED;
     JS_FreeValue(mik_rt->ctx, mik_rt->result_proto);
@@ -510,9 +561,43 @@ static void mik__check_module_collisions(void) {
     }
 }
 
+/* A chain of already-settled promises drains as one uninterrupted storm of
+ * jobs, and the test supervisor strings whole files of such chains together
+ * with runtime recycles in between. On ESP32 the main task runs above the
+ * idle task, so a multi-second stretch like that starves idle: the task
+ * watchdog (5 s, watching IDLE0) prints a register dump, and FreeRTOS
+ * housekeeping (freeing TCBs of exited tasks, e.g. per-request HTTP tasks)
+ * stalls. Force one platform yield per second of continuous job execution
+ * so idle always gets a slice. The timestamp is global on purpose: the
+ * starvation accumulates across MIK_Loop calls and across runtime recycles.
+ * Costs at most one tick (~10 ms) per second of busy work. */
+#define MIK__YIELD_INTERVAL_US (1000 * 1000)
+
+/* Atomic because the Node addon can pump two runtimes' loops from
+ * different worker threads; relaxed ordering is enough — a missed or
+ * extra yield is harmless, a torn 64-bit write is not. */
+static std::atomic<int64_t> mik__last_yield_us{0};
+
+static void mik__maybe_yield(void) {
+    const MIKPlatform* platform = MIK_GetPlatform();
+    int64_t now = platform->get_boot_us();
+    int64_t last = mik__last_yield_us.load(std::memory_order_relaxed);
+    /* now < last happens when the boot clock resets (deep sleep) or a test
+     * swaps in a platform with a different clock; restart the interval. */
+    if (last == 0 || now < last) {
+        mik__last_yield_us.store(now, std::memory_order_relaxed);
+        return;
+    }
+    if (now - last >= MIK__YIELD_INTERVAL_US) {
+        platform->yield();
+        mik__last_yield_us.store(platform->get_boot_us(), std::memory_order_relaxed);
+    }
+}
+
 void mik__execute_jobs(JSContext* ctx) {
     JSContext* ctx1;
     int err;
+    bool ran_any = false;
 
     /* execute the pending jobs */
     for (;;) {
@@ -529,7 +614,31 @@ void mik__execute_jobs(JSContext* ctx) {
             }
             break;
         }
+        ran_any = true;
+        /* A GC pass inside this job raises the threshold to 1.5x live size,
+         * which lands above mem_limit whenever live >= ~2/3 of the limit —
+         * silently disabling cycle GC for the rest of the storm. Re-clamp
+         * between jobs so collection keeps firing; the check is a field
+         * read + compare when no GC ran. */
+        MIKRuntime* job_rt = MIK_GetRuntime(ctx1);
+        if (job_rt) {
+            mik__clamp_gc_threshold(job_rt);
+        }
+        mik__maybe_yield();
     }
+
+    /* The yield interval measures continuous BUSY work. An empty drain
+     * means the loop is idling (the idle task is getting time between
+     * turns), so re-arm the interval — otherwise the first job after a
+     * quiet period pays a spurious ~10 ms yield for wall-clock time spent
+     * doing nothing. */
+    if (!ran_any) {
+        mik__last_yield_us.store(MIK_GetPlatform()->get_boot_us(), std::memory_order_relaxed);
+    }
+
+    /* Microtask checkpoint: every reject/handle transition for this turn has
+     * now run, so whatever is still queued is a genuine unhandled rejection. */
+    mik__flush_unhandled_rejections(ctx);
 }
 
 /* main loop which calls the user JS callbacks */
@@ -576,7 +685,18 @@ int MIK_Loop(MIKRuntime* mik_rt) {
     }
 
     mik__execute_jobs(mik_rt->ctx);
-    return 0;
+
+    /* Backstop for GC passes outside the job drain (timer callbacks, loop
+     * consumers, top-level eval): a pass there may have raised the
+     * threshold above the memory limit; pull it back so the next turn's
+     * collection still fires before allocations fail. Within the job
+     * drain, mik__execute_jobs re-clamps after every job. */
+    mik__clamp_gc_threshold(mik_rt);
+
+    /* The end-of-turn unhandled-rejection flush inside mik__execute_jobs may
+     * have requested a stop; surface it this iteration rather than making the
+     * caller loop once more to notice. */
+    return mik_rt->stop_requested ? 1 : 0;
 }
 
 void MIK_SetConfig(MIKRuntime* mik_rt, const MIKConfig* config) {
@@ -961,6 +1081,13 @@ JSValue MIK_EvalModule(JSContext* ctx, const char* filename, bool is_main) {
 }
 
 int MIK_RunEntry(MIKRuntime* mik_rt, const char* entry) {
+    return MIK_RunEntryErr(mik_rt, entry, NULL, 0);
+}
+
+int MIK_RunEntryErr(MIKRuntime* mik_rt, const char* entry, char* err_buf, size_t err_buf_size) {
+    if (err_buf && err_buf_size > 0) {
+        err_buf[0] = '\0';
+    }
     if (!mik_rt || !entry || entry[0] == '\0') {
         return -EINVAL;
     }
@@ -987,6 +1114,7 @@ int MIK_RunEntry(MIKRuntime* mik_rt, const char* entry) {
 
     JSValue result = MIK_EvalModule(ctx, entry, true);
     bool failed = JS_IsException(result);
+    bool rejected = false;
     /* Modules with top-level await return a Promise. A module body that
      * throws synchronously rejects that promise before JS_EvalFunction
      * returns, but the value itself is still an Object (rejected Promise),
@@ -998,7 +1126,25 @@ int MIK_RunEntry(MIKRuntime* mik_rt, const char* entry) {
         JSPromiseStateEnum state = JS_PromiseState(ctx, result);
         if (state == JS_PROMISE_REJECTED) {
             failed = true;
+            rejected = true;
+        }
+    }
+    if (failed && err_buf && err_buf_size > 0) {
+        /* Capture the failure's string form for the caller. Without an
+         * err_buf the pending exception is intentionally left on ctx,
+         * matching MIK_RunEntry's historical behavior. */
+        JSValue exc = rejected ? JS_PromiseResult(ctx, result) : JS_GetException(ctx);
+        const char* msg = JS_ToCString(ctx, exc);
+        if (msg) {
+            snprintf(err_buf, err_buf_size, "%s", msg);
+            JS_FreeCString(ctx, msg);
+        } else {
+            /* Stringifying the exception itself threw (e.g. OOM) — drop
+             * the secondary exception so it can't leak into later evals. */
+            JSValue stray = JS_GetException(ctx);
+            JS_FreeValue(ctx, stray);
         }
+        JS_FreeValue(ctx, exc);
     }
     JS_FreeValue(ctx, result);
     return failed ? -EFAULT : 0;

package/src/modules.cpp

@@ -245,11 +245,11 @@ static JSModuleDef* mik_module_loader_inner(JSContext* ctx, const char* module_n
         /* mik__load_builtin returns NULL either because the module isn't in
          * the table, or because deserialization failed (e.g. stack overflow
          * from deeply nested .bjs loading). If deserialization failed, the
-         * real exception is already on ctx — don't replace it. */
-        JSValue pending = JS_GetException(ctx);
-        if (!JS_IsNull(pending)) {
-            JS_Throw(ctx, pending);
-        } else {
+         * real exception is already on ctx — don't replace it. Probe with
+         * JS_HasException, NOT JS_GetException + JS_IsNull: quickjs-ng
+         * returns JS_UNINITIALIZED from an empty exception slot, and
+         * re-throwing that surfaced as a bare "[uninitialized]" error. */
+        if (!JS_HasException(ctx)) {
             JS_ThrowReferenceError(ctx, "Builtin module '%s' is not available in this build",
                                    module_name);
         }
@@ -285,13 +285,8 @@ JSModuleDef* mik_module_loader(JSContext* ctx, const char* module_name, void* op
         JSModuleDef* result = mik_module_loader_inner(ctx, module_name, opaque);
         if (debug) {
             if (result == nullptr) {
-                JSValue exc = JS_GetException(ctx);
-                bool has_exc = !JS_IsNull(exc) && !JS_IsUndefined(exc);
                 fprintf(stderr, "[mik-modules] FAIL: %s (exception=%s)\n", module_name,
-                        has_exc ? "set" : "NULL");
-                /* Re-throw so the caller still sees the exception. */
-                if (has_exc) JS_Throw(ctx, exc);
-                else JS_FreeValue(ctx, exc);
+                        JS_HasException(ctx) ? "set" : "NULL");
             } else {
                 fprintf(stderr, "[mik-modules] ok:   %s\n", module_name);
             }
@@ -319,12 +314,8 @@ JSModuleDef* mik_module_loader(JSContext* ctx, const char* module_name, void* op
     JSModuleDef* m = mik_module_loader_inner(ctx, module_name, opaque);
     if (debug) {
         if (m == nullptr) {
-            JSValue exc = JS_GetException(ctx);
-            bool has_exc = !JS_IsNull(exc) && !JS_IsUndefined(exc);
             fprintf(stderr, "[mik-modules] FAIL: %s (exception=%s)\n", module_name,
-                    has_exc ? "set" : "NULL");
-            if (has_exc) JS_Throw(ctx, exc);
-            else JS_FreeValue(ctx, exc);
+                    JS_HasException(ctx) ? "set" : "NULL");
         } else {
             fprintf(stderr, "[mik-modules] ok:   %s\n", module_name);
         }

package/src/platform_posix.cpp

@@ -116,6 +116,10 @@ static const char* posix_get_device_id(void) {
     return id;
 }
 
+static const char* posix_get_reset_reason(void) {
+    return "unknown";  /* Desktop processes have no chip reset concept */
+}
+
 static void posix_log(int level, const char* tag, const char* fmt, ...) {
     if (level < MIK_LOG_ERROR || level > MIK_LOG_VERBOSE) return;
     fprintf(stderr, "[%s] %s: ", mik_log_level_name(level), tag);
@@ -147,6 +151,7 @@ static const MIKPlatform posix_platform = {
     .stderr_write = posix_stderr_write,
     .stdin_read = posix_stdin_read,
     .get_device_id = posix_get_device_id,
+    .get_reset_reason = posix_get_reset_reason,
 };
 
 static const MIKPlatform* current_platform = &posix_platform;

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) Bjørge Næss
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.