Merge loops/js into architecture: var hoisting + ASI + matchAll on top of regex engine / TDZ scaffolding

Combined arch's regex platform dispatch (runtime.sx) with loops/js's var-hoisting transpiler
(transpile.sx) and matchAll string method. Plan checkboxes updated to reflect both done.
Conflicts: lib/js/runtime.sx, lib/js/transpile.sx, lib/js/test.sh, plans/js-on-sx.md.

lib/js/test262-runner.py

@@ -52,7 +52,7 @@ UPSTREAM = REPO / "lib" / "js" / "test262-upstream"
 TEST_ROOT = UPSTREAM / "test"
 HARNESS_DIR = UPSTREAM / "harness"
 
-DEFAULT_PER_TEST_TIMEOUT_S = 5.0
+DEFAULT_PER_TEST_TIMEOUT_S = 15.0
 DEFAULT_BATCH_TIMEOUT_S = 120
 
 # Cache dir for precomputed SX source of harness JS (one file per Python run).
@@ -134,6 +134,9 @@ var verifyProperty = function (obj, name, desc, opts) {
   }
 };
 var verifyPrimordialProperty = verifyProperty;
+var verifyEqualTo = function (obj, name, value) {
+  assert.sameValue(obj[name], value, name + " equals");
+};
 var verifyNotEnumerable = function (o, n, v, w, x) { };
 var verifyNotWritable = function (o, n, v, w, x) { };
 var verifyNotConfigurable = function (o, n, v, w, x) { };
@@ -146,6 +149,50 @@ var isConstructor = function (f) {
   // Best-effort: built-in functions and arrows aren't; declared `function` decls are.
   return false;
 };
+// $DONE / asyncTest — async-flag tests call $DONE(err) to signal completion.
+// Since we drain microtasks synchronously, $DONE is just a final-assertion sink.
+var $DONE = function (err) {
+  if (err) { throw new Test262Error((err && err.message) || err); }
+};
+var asyncTest = function (testFunc) {
+  Promise.resolve(testFunc()).then(function () { $DONE(); }, function (e) { $DONE(e); });
+};
+// promiseHelper.js include — used by Promise.all/race tests for ordering checks.
+var checkSequence = function (arr, message) {
+  for (var i = 0; i < arr.length; i = i + 1) {
+    if (arr[i] !== (i + 1)) {
+      throw new Test262Error((message || "Sequence") + " expected " + (i+1) + " at index " + i + " but got " + arr[i]);
+    }
+  }
+  return true;
+};
+var checkSettledPromises = function (settleds, expected, message) {
+  var msg = message ? message + " " : "";
+  if (settleds.length !== expected.length) {
+    throw new Test262Error(msg + "lengths differ: " + settleds.length + " vs " + expected.length);
+  }
+  for (var i = 0; i < settleds.length; i = i + 1) {
+    if (settleds[i].status !== expected[i].status) {
+      throw new Test262Error(msg + "status[" + i + "]: " + settleds[i].status + " vs " + expected[i].status);
+    }
+    if (expected[i].status === "fulfilled" && settleds[i].value !== expected[i].value) {
+      throw new Test262Error(msg + "value[" + i + "]: " + settleds[i].value + " vs " + expected[i].value);
+    }
+    if (expected[i].status === "rejected" && settleds[i].reason !== expected[i].reason) {
+      throw new Test262Error(msg + "reason[" + i + "]: " + settleds[i].reason + " vs " + expected[i].reason);
+    }
+  }
+};
+// decimalToHexString.js include — used by URI/escape tests.
+var decimalToHexString = function (n) {
+  var hex = "0123456789ABCDEF";
+  if (n < 0) { n = n + 65536; }
+  return hex[(n >> 12) & 15] + hex[(n >> 8) & 15] + hex[(n >> 4) & 15] + hex[n & 15];
+};
+var decimalToPercentHexString = function (n) {
+  var hex = "0123456789ABCDEF";
+  return "%" + hex[(n >> 4) & 15] + hex[n & 15];
+};
 // Trivial helper for tests that use Array.isArray-like functionality
 // (many tests reach for it via compareArray)
 """
@@ -358,6 +405,8 @@ def classify_negative_result(fm: Frontmatter, kind: str, payload: str):
             or ("expected" in low and "got" in low)
             or "js-transpile-unop" in low
             or "js-transpile-binop" in low
+            or "js-transpile-assign" in low
+            or "js-transpile" in low
             or "js-compound-update" in low
             or "parse" in low
         ):
@@ -1012,11 +1061,45 @@ def _worker_run(args):
 # ---------------------------------------------------------------------------
 
 
+_HARNESS_INCLUDE_CACHE: dict = {}
+
+# Only inline these small harness files per-test. Large ones like propertyHelper.js
+# multiply js-eval/JIT cost by ~5-10x and push tests over the per-test timeout.
+_INLINE_INCLUDES = {"nans.js", "sta.js", "byteConversionValues.js", "compareArray.js"}
+
+
+def _load_harness_include(name: str) -> str:
+    """Read an upstream harness include file (e.g. nans.js).
+    Returns empty string if the file isn't present.
+    """
+    if name in _HARNESS_INCLUDE_CACHE:
+        return _HARNESS_INCLUDE_CACHE[name]
+    path = HARNESS_DIR / name
+    try:
+        src = path.read_text()
+    except OSError:
+        src = ""
+    _HARNESS_INCLUDE_CACHE[name] = src
+    return src
+
+
 def assemble_source(t):
     """Return JS source to feed to js-eval. Harness is preloaded, so we only
-    append the test source (plus negative-test prep if needed).
+    append the test source (plus a small allowlist of per-test includes).
     """
-    return t.src
+    if not getattr(t.fm, "includes", None):
+        return t.src
+    parts = []
+    for inc in t.fm.includes:
+        if inc not in _INLINE_INCLUDES:
+            continue
+        chunk = _load_harness_include(inc)
+        if chunk:
+            parts.append(chunk)
+    if not parts:
+        return t.src
+    parts.append(t.src)
+    return "\n".join(parts)
 
 
 def aggregate(results):
@@ -1194,7 +1277,7 @@ def main(argv):
     shards = [[] for _ in range(n_workers)]
     for i, t in enumerate(tests):
         shards[i % n_workers].append(
-            (t.rel, t.category, t.src, t.fm.negative_phase, t.fm.negative_type)
+            (t.rel, t.category, assemble_source(t), t.fm.negative_phase, t.fm.negative_type)
         )
 
     t_run_start = time.monotonic()