feat: ESM loader overhaul — Web/Node parity, ns:module dev surface, HTTP module loader

build.gradle

@@ -193,6 +193,9 @@ def getAssembleReleaseBuildArguments = { ->
     if (onlyX86) {
         arguments.add("-PonlyX86")
     }
+    if (project.hasProperty("abis")) {
+        arguments.add("-Pabis=${project.property('abis')}")
+    }
     if (useCCache) {
         arguments.add("-PuseCCache")
     }
@@ -462,6 +465,9 @@ def getRunTestsBuildArguments = { taskName ->
     if (onlyX86) {
         arguments.add("-PonlyX86")
     }
+    if (project.hasProperty("abis")) {
+        arguments.add("-Pabis=${project.property('abis')}")
+    }
     if (useCCache) {
         arguments.add("-PuseCCache")
     }

test-app/app/src/main/AndroidManifest.xml

@@ -10,6 +10,7 @@
     <application
 	android:requestLegacyExternalStorage="true"
         android:name="com.tns.NativeScriptApplication"
+        android:networkSecurityConfig="@xml/network_security_config"
         android:allowBackup="true"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"

test-app/app/src/main/assets/app/esm/createrequire/microtask-tla-guarded.mjs

@@ -0,0 +1,6 @@
+// Exclusive to the microtask-context refusal spec: that refusal happens before
+// evaluation, so this fixture must never be evaluated by any other spec or the
+// guard would have nothing left to refuse.
+await Promise.resolve();
+
+export const value = "ok";

test-app/app/src/main/assets/app/esm/createrequire/microtask-tla.mjs

@@ -0,0 +1,5 @@
+// Top-level await that settles from microtasks alone, so a pumping require can
+// finish it while a strict require must still refuse the async graph.
+await Promise.resolve();
+
+export const value = "ok";

test-app/app/src/main/assets/app/esm/createrequire/node-module-import.mjs

@@ -0,0 +1,9 @@
+// The ESM route into the node:module shim: a static import, resolved by the
+// engine's module resolver rather than by require().
+import { createRequire } from "node:module";
+
+export const createRequireType = typeof createRequire;
+
+export function requireFrom(filename, specifier) {
+    return createRequire(filename)(specifier);
+}

test-app/app/src/main/assets/app/esm/createrequire/target.js

@@ -0,0 +1 @@
+exports.tag = "createrequire-target";

test-app/app/src/main/assets/app/esm/createrequire/tla-deadline.mjs

@@ -0,0 +1,3 @@
+// Exclusive to the deadlineSeconds spec: same never-settling park, so the
+// require always reaches its deadline and throws.
+export const value = await new Promise(function () {});

test-app/app/src/main/assets/app/esm/createrequire/tla-foreground-task.mjs

@@ -0,0 +1,7 @@
+// Settles only if v8 foreground tasks are pumped while the module evaluation
+// promise is pending: the notify wakeup arrives as a platform task.
+const i32 = new Int32Array(new SharedArrayBuffer(4));
+const wait = Atomics.waitAsync(i32, 0, 0);
+Atomics.notify(i32, 0);
+
+export const value = await wait.value;

test-app/app/src/main/assets/app/esm/createrequire/tla-return-pending.mjs

@@ -0,0 +1,4 @@
+// Exclusive to the onTimeout:"return-pending" spec. Parks on a promise nothing
+// ever settles, so the outcome cannot depend on how v8 schedules a wakeup task
+// — the deadline is always what ends the wait.
+export const value = await new Promise(function () {});

test-app/app/src/main/assets/app/esm/fs-fallback.mjs

@@ -0,0 +1,2 @@
+export const ok = true;
+export default { ok };

test-app/app/src/main/assets/app/esm/graph/bg-solo.mjs

@@ -0,0 +1 @@
+export const name = "bg-solo";

test-app/app/src/main/assets/app/esm/graph/cycle-a.mjs

@@ -0,0 +1,8 @@
+import { bValue, describeA } from "./cycle-b.mjs";
+
+export function describeB() {
+    return "a-saw-" + bValue;
+}
+
+export const aValue = "a";
+export const roundTrip = describeA();

test-app/app/src/main/assets/app/esm/graph/cycle-b.mjs

@@ -0,0 +1,7 @@
+import { aValue } from "./cycle-a.mjs";
+
+export function describeA() {
+    return "b-saw-" + aValue;
+}
+
+export const bValue = "b";

test-app/app/src/main/assets/app/esm/graph/diamond-entry.mjs

@@ -0,0 +1,7 @@
+import { name as leftName } from "./left.mjs";
+import { name as rightName } from "./right.mjs";
+
+(globalThis.__nsGraphOrder = globalThis.__nsGraphOrder || []).push("entry");
+
+export const order = globalThis.__nsGraphOrder.slice();
+export const names = [leftName, rightName];

test-app/app/src/main/assets/app/esm/graph/left.mjs

@@ -0,0 +1,6 @@
+import { name as sharedName } from "./shared.mjs";
+
+(globalThis.__nsGraphOrder = globalThis.__nsGraphOrder || []).push("left");
+
+export const seenShared = sharedName;
+export const name = "left";

test-app/app/src/main/assets/app/esm/graph/right.mjs

@@ -0,0 +1,6 @@
+import { name as sharedName } from "./shared.mjs";
+
+(globalThis.__nsGraphOrder = globalThis.__nsGraphOrder || []).push("right");
+
+export const seenShared = sharedName;
+export const name = "right";

test-app/app/src/main/assets/app/esm/graph/shared.mjs

@@ -0,0 +1,3 @@
+(globalThis.__nsGraphOrder = globalThis.__nsGraphOrder || []).push("shared");
+
+export const name = "shared";

test-app/app/src/main/assets/app/esm/hmr/test-esm-module.mjs

@@ -0,0 +1,24 @@
+export const testValue = "http-esm-loaded";
+export const timestamp = Date.now();
+
+// `import.meta.hot` exists only when a dev server injects a hot context into the
+// served source; a disk module must therefore see nothing here.
+const hotContext = (typeof import.meta !== "undefined" && import.meta) ? import.meta.hot : undefined;
+
+export function getHotContext() {
+    return hotContext;
+}
+
+export function callInvalidateSafe() {
+    if (!hotContext || typeof hotContext.invalidate !== "function") {
+        return false;
+    }
+    hotContext.invalidate();
+    return true;
+}
+
+export default function testFunction() {
+    return "HTTP ESM loader working at " + new Date().toISOString();
+}
+
+export { testFunction as namedExport };

test-app/app/src/main/assets/app/esm/identity.json

@@ -0,0 +1,4 @@
+{
+    "name": "esm-identity-fixture",
+    "value": 42
+}

test-app/app/src/main/assets/app/esm/interop/agreement.mjs

@@ -0,0 +1,3 @@
+export default { tag: "agreement" };
+
+export const named = "named";

test-app/app/src/main/assets/app/esm/interop/default-live.mjs

@@ -0,0 +1,9 @@
+// Default export through a `let` binding, so the facade's re-export has to
+// stay live: a copied value would freeze `default` at 1.
+let current = 1;
+
+export { current as default };
+
+export function bump() {
+    current += 1;
+}

test-app/app/src/main/assets/app/esm/interop/identity.mjs

@@ -0,0 +1,3 @@
+export default { tag: "identity" };
+
+export const named = "named";

test-app/app/src/main/assets/app/esm/interop/module-exports.mjs

@@ -0,0 +1,10 @@
+// An arbitrary-string export name claims the whole require() result.
+function theExport(a, b) {
+    return a + b;
+}
+
+theExport.marker = "module.exports fixture";
+
+export { theExport as "module.exports" };
+
+export default "ignored when module.exports is present";

test-app/app/src/main/assets/app/esm/interop/named-only.mjs

@@ -0,0 +1,5 @@
+export const alpha = "a";
+
+export function beta() {
+    return "b";
+}

test-app/app/src/main/assets/app/esm/interop/own-esmodule.mjs

@@ -0,0 +1,4 @@
+// Declaring __esModule opts out of the facade, so this value survives require().
+export const __esModule = "mine";
+
+export default { tag: "own-esmodule" };

test-app/app/src/main/assets/app/esm/meta/nested/child.mjs

@@ -0,0 +1 @@
+export const childMeta = import.meta;

test-app/app/src/main/assets/app/esm/meta/parent.mjs

@@ -0,0 +1,4 @@
+import { childMeta } from "./nested/child.mjs";
+
+export const parentMeta = import.meta;
+export { childMeta };

test-app/app/src/main/assets/app/esm/mixed/a-entry.mjs

@@ -0,0 +1,6 @@
+import { leaf as leafName } from "./a-mid.mjs";
+
+(globalThis.__nsMixedOrdera = globalThis.__nsMixedOrdera || []).push("entry");
+
+export const leaf = leafName;
+export const order = globalThis.__nsMixedOrdera.slice();

test-app/app/src/main/assets/app/esm/mixed/a-mid.mjs

@@ -0,0 +1,7 @@
+// The HTTP leaf arrives through a bare specifier the import map points at a
+// ModuleTestServer URL, so this file needs no baked-in origin.
+import { name as leafName } from "ns-test-leaf-a";
+
+(globalThis.__nsMixedOrdera = globalThis.__nsMixedOrdera || []).push("mid");
+
+export const leaf = leafName;

test-app/app/src/main/assets/app/esm/mixed/b-entry.mjs

@@ -0,0 +1,6 @@
+import { leaf as leafName } from "./b-mid.mjs";
+
+(globalThis.__nsMixedOrderb = globalThis.__nsMixedOrderb || []).push("entry");
+
+export const leaf = leafName;
+export const order = globalThis.__nsMixedOrderb.slice();

test-app/app/src/main/assets/app/esm/mixed/b-mid.mjs

@@ -0,0 +1,7 @@
+// The HTTP leaf arrives through a bare specifier the import map points at a
+// ModuleTestServer URL, so this file needs no baked-in origin.
+import { name as leafName } from "ns-test-leaf-b";
+
+(globalThis.__nsMixedOrderb = globalThis.__nsMixedOrderb || []).push("mid");
+
+export const leaf = leafName;

test-app/app/src/main/assets/app/esm/nodebuiltins/importsNodePath.mjs

@@ -0,0 +1,5 @@
+// A static import is the third route to a built-in module, alongside require()
+// and import(); this fixture exists to fail on it.
+import "node:path";
+
+export const unreachable = true;

test-app/app/src/main/assets/app/esm/relative/dependency.mjs

@@ -0,0 +1,10 @@
+export const relativeValue = "relative-import-success";
+
+export function getDependencyPayload() {
+    return {
+        from: "dependency",
+        timestamp: Date.now(),
+    };
+}
+
+export default relativeValue;

test-app/app/src/main/assets/app/esm/relative/entry.mjs

@@ -0,0 +1,9 @@
+import defaultValue, { relativeValue, getDependencyPayload } from "./dependency.mjs";
+
+export const viaDefault = defaultValue;
+export const viaNamed = relativeValue;
+
+export function readDependencyPayload() {
+    const payload = getDependencyPayload();
+    return typeof payload === "object" && payload.from === "dependency";
+}

test-app/app/src/main/assets/app/esm/relative/meta.mjs

@@ -0,0 +1,2 @@
+export const metaUrl = import.meta.url;
+export const metaDirname = import.meta.dirname;

test-app/app/src/main/assets/app/esm/scoped/inside/deep/mid.mjs

@@ -0,0 +1,4 @@
+// Two scopes match this referrer; the more specific one must win.
+import { name as scoped } from "ns-scoped-leaf";
+
+export const leaf = scoped;

test-app/app/src/main/assets/app/esm/scoped/inside/mid.mjs

@@ -0,0 +1,7 @@
+// Inside the scope: "ns-scoped-leaf" is overridden there, while
+// "ns-scoped-fallthrough" is not and must fall through to top-level imports.
+import { name as scoped } from "ns-scoped-leaf";
+import { name as fellThrough } from "ns-scoped-fallthrough";
+
+export const leaf = scoped;
+export const fallthrough = fellThrough;

test-app/app/src/main/assets/app/esm/scoped/outside/mid.mjs

@@ -0,0 +1,4 @@
+// No scope matches this referrer, so the top-level imports entry applies.
+import { name as scoped } from "ns-scoped-leaf";
+
+export const leaf = scoped;

test-app/app/src/main/assets/app/esm/scoped/survivor.mjs

@@ -0,0 +1,5 @@
+// Resolves only through the map installed before a rejected update, proving
+// the rejected update left the previous vocabulary in place.
+import { name as scoped } from "ns-survivor";
+
+export const leaf = scoped;

test-app/app/src/main/assets/app/esm/vocab/leafA.mjs

@@ -0,0 +1 @@
+export const name = "vocab-a";

test-app/app/src/main/assets/app/esm/vocab/leafB.mjs

@@ -0,0 +1 @@
+export const name = "vocab-b";

test-app/app/src/main/assets/app/esm/vocab/leafC.mjs

@@ -0,0 +1 @@
+export const name = "vocab-c";

test-app/app/src/main/assets/app/mainpage.js

@@ -87,6 +87,18 @@ require('./tests/testPrimordials');
 require('./tests/testInspect');
 // The ns:/node: builtin modules
 require('./tests/testNsUtil');
+require('./tests/testNsRuntime');
+require('./tests/testNsModule');
+// Remote-module security gate (debug builds allow remote modules outright)
+require('./tests/testRemoteModuleSecurity');
+// The ES module loader: require(esm) interop and the createRequire factories
+require('./tests/testEsmInterop');
+require('./tests/testCreateRequire');
+require('./tests/testNodeUrlModule');
+require('./tests/testImportMetaResolution');
+require('./tests/testWorkerEsmEntry');
+// Fetches from the in-app loopback fixture server, so it goes last
+require('./tests/testEsmHttpLoader');
 // Node-API addon surface
 require('./tests/NapiTests');
 require('./tests/NapiCoverageTests');

test-app/app/src/main/assets/app/tests/esmEntryHelper.mjs

@@ -0,0 +1,3 @@
+// Imported statically by an ES module worker entry, proving a static import in
+// an entry module resolves during instantiation.
+export const WORKER_TAG = "esm-entry";

test-app/app/src/main/assets/app/tests/esmEntryRelativeWorker.mjs

@@ -0,0 +1,5 @@
+// Reached through a relative worker specifier. Module code is strict, so the
+// message handler is installed on globalThis rather than by bare assignment.
+globalThis.onmessage = function (msg) {
+    postMessage("relative-entry:" + msg.data);
+};

test-app/app/src/main/assets/app/tests/esmEntryResolvedWorker.mjs

@@ -0,0 +1,13 @@
+// Reached through an extension-less worker specifier: no `.js` sibling exists,
+// so only this file can answer. The top-level await parks on a NON-nestable
+// foreground task, which the in-place yield window cannot settle, so a message
+// posted at construction has to wait on the settle-gated queue.
+const i32 = new Int32Array(new SharedArrayBuffer(4));
+const wait = Atomics.waitAsync(i32, 0, 0);
+Atomics.notify(i32, 0);
+
+const settled = await wait.value;
+
+globalThis.onmessage = function (msg) {
+    postMessage("resolved-entry:" + settled + ":" + msg.data);
+};

test-app/app/src/main/assets/app/tests/esmEntrySyncWorker.mjs

@@ -0,0 +1,7 @@
+// A fully synchronous ES module worker entry. Module code is strict, so the
+// message handler is installed on globalThis rather than by bare assignment.
+import { WORKER_TAG } from "./esmEntryHelper.mjs";
+
+globalThis.onmessage = function (msg) {
+    postMessage(WORKER_TAG + ":" + msg.data);
+};

test-app/app/src/main/assets/app/tests/esmEntryTlaWorker.mjs

@@ -0,0 +1,12 @@
+// An ES module worker entry with top-level await, parked on a NON-nestable
+// foreground task: the in-place yield window cannot settle it, so the entry
+// finishes from the real event loop and the message queue enables on settle.
+const i32 = new Int32Array(new SharedArrayBuffer(4));
+const wait = Atomics.waitAsync(i32, 0, 0);
+Atomics.notify(i32, 0);
+
+const settled = await wait.value;
+
+globalThis.onmessage = function (msg) {
+    postMessage("tla-entry:" + settled + ":" + msg.data);
+};

test-app/app/src/main/assets/app/tests/importMapWorker.js

@@ -0,0 +1,9 @@
+// Resolves whatever bare specifier the parent asks for, through the import map
+// this worker inherited at spawn.
+onmessage = function (msg) {
+    import(msg.data).then(function (mod) {
+        postMessage({ ok: true, name: mod.name });
+    }).catch(function (error) {
+        postMessage({ ok: false, error: String((error && error.message) || error) });
+    });
+};

test-app/app/src/main/assets/app/tests/lateHandlerWorker.js

@@ -0,0 +1,8 @@
+// Worker realms carry only the native __ns__-prefixed timers (the friendly
+// setTimeout global is installed by userland, e.g. @nativescript/core).
+__ns__setTimeout(function () {
+    onmessage = function (msg) {
+        postMessage("late:" + msg.data);
+    };
+    postMessage("ready");
+}, 200);