fix(test): skip Astro frontmatter in script extraction; drain microtasks before clock advance

CI surfaced two harness bugs the local smoke-tests didn't catch:

1. `extract_script_body` and the discovery walker greedily matched the
   first `<script>` substring in the source, which in setup.astro is
   actually a frontmatter comment: `// below in the <script> block keyed
   off the entry's id.` That made the "script body" start mid-frontmatter
   and the extracted text wasn't valid JS — esbuild and JSDOM both
   rejected it with "Unexpected identifier 'keyed'".

   Fix: strip the `--- ... ---` Astro frontmatter block before searching
   for `<script>` tags. Plain .py and .html sources have no frontmatter
   and pass through unchanged.

2. `clock.advance(settleMs)` returned immediately when no timers were
   yet scheduled, but the script under test often awaits a chain of
   stubbed-fetch promises BEFORE hitting its first `setTimeout`. With
   only one microtask drain between eval and advance, those promises
   hadn't resolved yet, so no timers existed, advance was a no-op, and
   the script stayed suspended — `restartAddon`'s POST to
   /api/settings/restart never fired and the `alert(msg)` in the 4xx
   branch never ran.

   Fix: drain microtasks aggressively at the start of advance() so
   pending promises get to schedule their timers, and drain again when
   the timer queue temporarily empties (a promise resolution may queue
   new timers).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: kingpanther13

tests/js/harness.mjs

@@ -130,6 +130,17 @@ class FakeClock {
   // to the real event loop with setImmediate.
   async advance(untilMs) {
     const target = this.now + untilMs;
+
+    // Drain microtasks aggressively up front. The script under test may
+    // be awaiting a chain of stubbed-fetch promises before it hits its
+    // first setTimeout — if we checked for ready timers immediately,
+    // we'd see none and return without advancing, leaving the script
+    // suspended forever. Letting promises resolve first gives them a
+    // chance to schedule timers we can then fire.
+    for (let i = 0; i < 50; i++) {
+      await new Promise((r) => setImmediate(r));
+    }
+
     // Outer loop in case a fired task schedules more tasks before target.
     // Cap iterations to surface runaway recursion as a test failure rather
     // than hanging the suite.
@@ -142,7 +153,19 @@ class FakeClock {
           nextId = id;
         }
       }
-      if (nextId == null) break;
+      if (nextId == null) {
+        // No ready timers. Drain microtasks one more time in case a
+        // recently-resolved promise just queued one, then re-check.
+        for (let i = 0; i < 10; i++) {
+          await new Promise((r) => setImmediate(r));
+        }
+        let stillNone = true;
+        for (const [, t] of this.tasks) {
+          if (t.time <= target) { stillNone = false; break; }
+        }
+        if (stillNone) break;
+        continue;
+      }
       const task = this.tasks.get(nextId);
       this.now = task.time;
       if (task.interval != null) {

tests/src/unit/_js_harness.py

@@ -192,24 +192,45 @@ def astro_vars_prelude(vars_: dict[str, Any]) -> str:
     return "\n".join(parts)
 
 
+def _strip_astro_frontmatter(source: str) -> str:
+    """Drop the leading ``--- ... ---`` block if present.
+
+    Astro frontmatter is TypeScript that runs at build-time, not JS that
+    runs in the browser, so any ``<script>`` substring inside a comment
+    or string there is not a real script tag. Stripping it before
+    searching prevents
+    ``// below in the <script> block keyed off the entry's id``
+    (line 17 of setup.astro) from being mis-matched as the script.
+    """
+    if not source.startswith("---\n"):
+        return source
+    close = source.find("\n---\n", 4)
+    if close == -1:
+        return source
+    return source[close + len("\n---\n") :]
+
+
 def extract_script_body(source: str, *, marker: str = "<script>") -> str:
     """Return the first non-external inline ``<script>`` body in ``source``.
 
     Handles both the bare ``<script>`` form used by ``_SETTINGS_HTML`` and
     attributed forms like Astro's ``<script define:vars={...}>``. The body
     is everything between the opening tag's ``>`` and the next
     ``</script>``. External scripts (``<script src=...></script>``) are
-    skipped — they have no inline body to extract.
+    skipped — they have no inline body to extract. Astro frontmatter is
+    skipped before searching so ``<script>`` mentions in frontmatter
+    comments don't match.
     """
-    for match in re.finditer(r"<script\b([^>]*)>", source):
+    search_source = _strip_astro_frontmatter(source)
+    for match in re.finditer(r"<script\b([^>]*)>", search_source):
         attrs = match.group(1)
         if re.search(r"\bsrc\s*=", attrs):
             continue
         start = match.end()
-        end = source.find("</script>", start)
+        end = search_source.find("</script>", start)
         if end == -1:
             raise ValueError("unterminated <script> in source")
-        return source[start:end]
+        return search_source[start:end]
     raise ValueError(f"no inline <script> tag in source (marker hint: {marker!r})")
 
 
@@ -303,7 +324,7 @@ def _render_settings() -> str:
     site_dir = repo_root / "site" / "src"
     if site_dir.is_dir():
         for path in sorted(site_dir.rglob("*.astro")):
-            text = path.read_text(encoding="utf-8")
+            text = _strip_astro_frontmatter(path.read_text(encoding="utf-8"))
             for match in re.finditer(r"<script\b([^>]*)>", text):
                 attrs = match.group(1)
                 if re.search(r"\bsrc\s*=", attrs):