feat: update engines and add support bytecode compiler

Author: ammarahm-ed

test-app/.idea/caches/deviceStreaming.xml

@@ -1,6 +1,6 @@
 {
-    "kotlinUsage": {
-        "hasUseKotlinPropertyInApp": true,
-        "hasKotlinRuntimeClasses": false
-    }
+  "kotlinUsage": {
+    "hasUseKotlinPropertyInApp": true,
+    "hasKotlinRuntimeClasses": true
+  }
 }

test-app/.idea/kotlinc.xml

@@ -99,7 +99,7 @@ if (enableAnalytics) {
     analyticsCollector.writeAnalyticsFile()
 }
 
-project.ext.selectedBuildType = project.hasProperty("release") ? "release" : "debug"
+project.ext.selectedBuildType = "release"
 
 buildscript {
     def applyBuildScriptConfigurations = { ->
@@ -232,18 +232,10 @@ android {
         minSdkVersion minSdkVer
         targetSdkVersion computeTargetSdkVersion()
         ndk {
-            if (ns_engine == "JSC") {
-                outLogger.withStyle(Style.Info).println "\t ! JSC engine only ships arm64-v8a and x86_64 prebuilts; " +
-                        "the app will be built for those ABIs only (armeabi-v7a and x86 are excluded)."
-            }
             if (onlyX86) {
                 // The updated JSC only ships 64-bit libraries, so fall back to
                 // x86_64 when a single-ABI (emulator) build is requested.
-                abiFilters ns_engine == "JSC" ? 'x86_64' : 'x86'
-            } else if (ns_engine == "JSC") {
-                // The newer JSC engine only provides arm64-v8a and x86_64
-                // prebuilts, so restrict the app to those two ABIs.
-                abiFilters 'x86_64', 'arm64-v8a'
+                abiFilters 'x86'
             } else {
                 abiFilters 'x86', 'x86_64', 'armeabi-v7a', 'arm64-v8a'
             }
@@ -1150,6 +1142,7 @@ task 'validateAppIdMatch' {
 // merged-assets build intermediate, never the app source.
 //
 // Disable for a release build with:  -PnsBytecodeDisabled
+// Force-enable for a debug build with: -PnsBytecodeForce
 // Enable source maps with:           -PnsBytecodeSourceMaps
 //
 // Overridable paths:
@@ -1158,8 +1151,29 @@ task 'validateAppIdMatch' {
 //   -PnodePath=<path>                 — the node executable
 
 def bytecodeDisabled = project.hasProperty("nsBytecodeDisabled") || project.hasProperty("bytecodeDisabled")
-def isReleaseBuild = project.hasProperty("release")
-project.ext.bytecodeEnabled = isReleaseBuild && !bytecodeDisabled
+// Force bytecode compilation even for debug builds. Bytecode is a release-only
+// feature by default; this opt-in flag makes debug builds compile to bytecode
+// too, which is handy for testing/debugging the bytecode path itself.
+def bytecodeForced = project.hasProperty("nsBytecodeForce") || project.hasProperty("bytecodeForce")
+// A release build is not reliably signalled by -Prelease (the CLI runs
+// assembleRelease/bundleRelease without it), so detect it from the requested
+// task names — the same heuristic the rest of this file uses.
+def isReleaseBuild = project.hasProperty("release") ||
+        project.gradle.startParameter.taskNames.any { it.toLowerCase().contains("release") }
+project.ext.bytecodeEnabled = (isReleaseBuild || bytecodeForced) && !bytecodeDisabled
+
+// Announce the bytecode status once at configuration time so it's obvious in the
+// build log whether ahead-of-time bytecode will be produced.
+if (project.ext.bytecodeEnabled) {
+    def buildKind = isReleaseBuild ? "release build" : "debug build (forced via -PnsBytecodeForce)"
+    outLogger.withStyle(Style.SuccessHeader).println "\t + [bytecode] ENABLED for ${buildKind} (engine: ${ns_engine})"
+    outLogger.withStyle(Style.Info).println "\t   ~ app JS will be compiled to bytecode after asset merge (if ${ns_engine} has a compiler for this host)."
+    outLogger.withStyle(Style.Info).println "\t   ~ disable with -PnsBytecodeDisabled"
+} else {
+    def bytecodeReason = bytecodeDisabled ? "disabled via -PnsBytecodeDisabled"
+            : "debug build (release-only feature; force with -PnsBytecodeForce)"
+    outLogger.withStyle(Style.Info).println "\t ~ [bytecode] DISABLED — ${bytecodeReason}; shipping plain JS. isReleaseBuid: ${isReleaseBuild};"
+}
 
 // The compiler tooling ships in the framework template under build-tools; fall
 // back to the in-repo location when building the runtime itself (test-app).
@@ -1189,18 +1203,38 @@ task compileBytecode {
         def toolsDir = resolveBytecodeToolsDir()
         def script = "$toolsDir/compile-bytecode.js"
         def node = resolveNodePath()
-        outLogger.withStyle(Style.SuccessHeader).println "\t + [bytecode] compiling app JS to ${ns_engine} bytecode (${script})"
+        def sourceMaps = project.hasProperty("nsBytecodeSourceMaps")
+        // Resilient by default: a file that fails to compile is left as plain JS
+        // (the runtime loads source directly) and the build continues. Opt into
+        // fail-the-build behaviour with -PnsBytecodeStrict.
+        def strict = project.hasProperty("nsBytecodeStrict")
+
+        outLogger.withStyle(Style.SuccessHeader).println "\t + [bytecode] compiling app JS → ${ns_engine} bytecode"
+        outLogger.withStyle(Style.Info).println "\t   ~ engine:      ${ns_engine}"
+        outLogger.withStyle(Style.Info).println "\t   ~ app assets:  ${appDir}"
+        outLogger.withStyle(Style.Info).println "\t   ~ driver:      ${script}"
+        if (project.hasProperty("bytecodeCompilerBinary")) {
+            outLogger.withStyle(Style.Info).println "\t   ~ compiler:    ${bytecodeCompilerBinary}"
+        }
+        outLogger.withStyle(Style.Info).println "\t   ~ source maps: ${sourceMaps ? "on" : "off"}"
+        outLogger.withStyle(Style.Info).println "\t   ~ on error:    ${strict ? "fail the build (strict)" : "skip file, keep source"}"
 
         def cmd = [node, script, "--app", appDir, "--engine", ns_engine as String]
         if (project.hasProperty("bytecodeCompilerBinary")) {
             cmd += ["--compiler", bytecodeCompilerBinary as String]
         }
-        if (project.hasProperty("nsBytecodeSourceMaps")) {
+        if (sourceMaps) {
             cmd += ["--source-maps"]
         }
+        if (!strict) {
+            cmd += ["--keep-going"]
+        }
+        // The driver prints its own "[bytecode] ... compiled N file(s)" summary to
+        // stdout, which surfaces in the build log below.
         exec {
             commandLine cmd
         }
+        outLogger.withStyle(Style.SuccessHeader).println "\t + [bytecode] done."
     }
 }
 
@@ -1263,8 +1297,28 @@ tasks.configureEach({ DefaultTask currentTask ->
         compileBytecode.mustRunAfter(currentTask)
     }
 
-    // Ensure the APK/App Bundle packaging picks up the compiled bytecode.
-    if (currentTask =~ /package.*Release/ || currentTask =~ /package.*Bundle/) {
+    // The asset pipeline is: merge*Assets -> compress*Assets -> package*. The
+    // compress task reads the merged assets and zips each file into a `.js.jar`
+    // that is what actually lands in the APK/App Bundle. It only depends on the
+    // merge task, so without this it can run BEFORE compileBytecode and end up
+    // compressing plain source — the compiled bytecode in the merged assets then
+    // never reaches the package. Force compression to wait for compileBytecode so
+    // the order is merge -> compileBytecode -> compress -> package. (No cycle:
+    // compileBytecode only mustRunAfter the merge task, never the compress task.)
+    // Debug's compress*Assets task is included so a force-enabled (-PnsBytecodeForce)
+    // debug build compresses the compiled bytecode rather than plain source. The
+    // task is a no-op via compileBytecode's onlyIf guard when bytecode is off.
+    if (currentTask.name == "compressReleaseAssets" || currentTask.name == "compressDebugAssets") {
+        currentTask.dependsOn(compileBytecode)
+    }
+
+    // Ensure the final APK/App Bundle packaging picks up the compiled bytecode.
+    // Match the packaging tasks by exact name — a broad /package.*Release/ also
+    // matches packageReleaseResources, which is upstream of buildMetadata ->
+    // mergeReleaseAssets -> compileBytecode and creates a circular dependency.
+    // Debug packaging is wired too so a force-enabled debug build ships bytecode;
+    // compileBytecode's onlyIf keeps it a no-op for ordinary debug builds.
+    if (currentTask.name in ["packageRelease", "packageReleaseBundle", "packageDebug", "packageDebugBundle"]) {
         currentTask.dependsOn(compileBytecode)
     }
 

test-app/.idea/vcs.xml

@@ -28,9 +28,19 @@ var MyActivity = (function (_super) {
   }
   MyActivity.prototype.onCreate = function (bundle) {
     _super.prototype.onCreate.call(this, bundle);
-    require('./tests/testsWithContext').run(this);
-    //run jasmine
-//    execute();
+    // Launch mode is selected by an intent extra so we don't have to rebuild to
+    // switch between the jasmine regression suite and the perf benchmark:
+    //   default            -> run the jasmine test suite (regression check)
+    //   --ez bench true     -> run the marshalling benchmark in isolation
+    var runBench = false;
+    try {
+      runBench = this.getIntent().getBooleanExtra("bench", false);
+    } catch (e) {}
+    if (!runBench) {
+      require('./tests/testsWithContext').run(this);
+      // run jasmine
+      execute();
+    }
     var layout = new android.widget.LinearLayout(this);
     layout.setOrientation(1);
     this.setContentView(layout);
@@ -47,6 +57,10 @@ var MyActivity = (function (_super) {
     button2.setText("Run Benchmark");
     layout.addView(button2);
 
+    var button3 = new android.widget.Button(this);
+    button3.setText("Run Marshalling Benchmark");
+    layout.addView(button3);
+
     var Color = android.graphics.Color;
     var colors = [
       Color.BLUE,
@@ -96,6 +110,53 @@ var MyActivity = (function (_super) {
             },
           })
     );
+    var marshallingWorker = null;
+    button3.setOnClickListener(
+          new android.view.View.OnClickListener("AppClickListener", {
+            onClick: function () {
+              // Run the marshalling benchmark on a worker thread so the UI thread
+              // stays responsive and Android does not raise an ANR.
+              if (marshallingWorker) {
+                return;
+              }
+              button3.setText("Running Marshalling Benchmark...");
+              textView.setText("Running marshalling benchmark, please wait...");
+
+              marshallingWorker = new Worker("./marshalling-benchmark-worker.js");
+              marshallingWorker.onmessage = function (msg) {
+                textView.setText(msg.data);
+                button3.setText("Run Marshalling Benchmark");
+                marshallingWorker.terminate();
+                marshallingWorker = null;
+              };
+              marshallingWorker.onerror = function (err) {
+                textView.setText("Marshalling benchmark error: " + (err && err.message ? err.message : err));
+                button3.setText("Run Marshalling Benchmark");
+                marshallingWorker.terminate();
+                marshallingWorker = null;
+              };
+              marshallingWorker.postMessage("start");
+            },
+          })
+    );
+
+    // Report Time To Interactive: process start -> first activity fully built.
+    require("./tti").reportTTI("app launch");
+
+    // Benchmark mode (--ez bench true): auto-run the marshalling benchmark on
+    // launch. Results stream to logcat tagged NS_ENGINE_BENCHMARK.
+    if (runBench) {
+      var w = new Worker("./marshalling-benchmark-worker.js");
+      w.onmessage = function (msg) {
+        textView.setText(msg.data);
+        w.terminate();
+      };
+      w.onerror = function (err) {
+        console.log("NS_ENGINE_BENCHMARK_DONE error=" + (err && err.message ? err.message : err));
+        w.terminate();
+      };
+      w.postMessage("start");
+    }
   };
   MyActivity = __decorate(
     [JavaProxy("com.tns.NativeScriptActivity")],

test-app/analytics/build-statistics.json

@@ -0,0 +1,30 @@
+// Runs the runtime marshalling benchmark suite off the main (UI) thread so the
+// app stays responsive and Android does not raise an ANR while benchmarking.
+
+// CRITICAL: a Worker gets its own runtime context, which defaults to verbose
+// native logging ON (main.js disables it only on the main thread). Left on, the
+// runtime logs "CallJavaMethod ..." for EVERY marshalled call — flooding logcat
+// and adding huge per-call overhead that pollutes the measurements. Disable it
+// before any benchmarking so we measure marshalling, not logging.
+if (typeof __disableVerboseLogging === "function") {
+    __disableVerboseLogging();
+}
+
+const benchmarkRunner = require("./marshalling-benchmark.js");
+
+// Results are streamed to logcat, tagged NS_ENGINE_BENCHMARK, with a final
+// NS_ENGINE_BENCHMARK_DONE line (see marshalling-benchmark.js). The host reads
+// them live from adb logcat — no files needed.
+self.onmessage = function () {
+    try {
+        const result = benchmarkRunner.runBenchmark();
+        if (typeof globalThis.gc === "function") {
+            globalThis.gc();
+        }
+        self.postMessage(result);
+    } catch (e) {
+        const msg = "Marshalling benchmark failed: " + (e && e.stack ? e.stack : e);
+        console.log("NS_ENGINE_BENCHMARK_DONE error=" + msg);
+        self.postMessage(msg);
+    }
+};