fix(tests): stagger iframe worker launch + richer import error

Reported: on production tko.io under Safari, one spec
occasionally fails with the opaque WebKit message
`Importing a module script failed.` — most often a spec that
imports a large chunk graph (e.g. `builds/reference/spec/
bindingGlobalsBehavior.js`, which imports the full reference
build). Chromium handles the same graph fine. The failure mode
is known across Astro, SvelteKit, Nuxt, Immich, and tracks
against upstream WebKit bug 242740.

Two changes:

1. **Stagger worker launch** in tests.astro. With pool=4 every
   worker used to spawn its first iframe simultaneously, hitting
   the same shared module-graph chunks concurrently — that's
   what triggers the WebKit race. A 120ms per-worker offset
   spaces the first-round fetches (360ms total head-start for
   pool=4) and removes the contention without materially
   slowing the run (still ~5.2s end-to-end; was ~5.4s).
2. **Richer error on failure** in tests-frame.html. Keep the
   original dynamic `import()` (no retry) but in the catch,
   re-fetch the spec URL with `cache: 'no-store'` and report
   HTTP status, content-length, and content-type alongside the
   original WebKit message in both the in-frame err div and
   the `import-error` postMessage. Gives something actionable
   when the failure does surface.

Author: Brian M Hunt

tko.io/public/tests-frame.html

@@ -64,11 +64,36 @@
     <script type="module">
       const qs = new URLSearchParams(location.search)
       const slug = qs.get('spec')
+      const specUrl = `/tests/source/${slug}.js`
+
+      // On failure the opaque WebKit "Importing a module script
+      // failed." message carries no URL or status. Refetch the
+      // spec URL in the catch and surface HTTP status + size so
+      // the parent can show something useful. The parent throttles
+      // iframe start-up to avoid the concurrent-fetch race that
+      // produces the opaque error in the first place; see the
+      // source-mode worker stagger in tests.astro.
+      //
+      // Refs:
+      //   https://github.com/withastro/astro/issues/14775
+      //   https://github.com/sveltejs/kit/issues/5208
+      //   https://github.com/nuxt/nuxt/issues/33478
+      //   https://bugs.webkit.org/show_bug.cgi?id=242740
+      async function diagnose(err) {
+        try {
+          const res = await fetch(specUrl, { cache: 'no-store' })
+          const size = res.headers.get('content-length') ?? '?'
+          return `import failed at ${specUrl} [HTTP ${res.status} ${res.statusText}, ${size}B, ${res.headers.get('content-type') || 'unknown'}]: ${err?.message || err}`
+        } catch (fetchErr) {
+          return `import failed at ${specUrl} (fetch also failed: ${fetchErr?.message || fetchErr}): ${err?.message || err}`
+        }
+      }
+
       if (!slug) {
         document.getElementById('err').textContent = 'missing ?spec= query param'
       } else {
         try {
-          await import(`/tests/source/${slug}.js`)
+          await import(specUrl)
           const runner = mocha.run()
           runner.on('pass', t => parent.postMessage({ type: 'pass', slug, title: t.fullTitle(), duration: t.duration }, '*'))
           runner.on('fail', (t, err) => parent.postMessage({
@@ -80,8 +105,9 @@
           runner.on('end', () => parent.postMessage({ type: 'end', slug, stats: runner.stats }, '*'))
           parent.postMessage({ type: 'start', slug, total: runner.total }, '*')
         } catch (err) {
-          document.getElementById('err').textContent = 'import failed: ' + (err?.message || err)
-          parent.postMessage({ type: 'import-error', slug, err: err?.message || String(err) }, '*')
+          const detail = await diagnose(err)
+          document.getElementById('err').textContent = detail
+          parent.postMessage({ type: 'import-error', slug, err: detail }, '*')
         }
       }
     </script>

tko.io/src/pages/tests.astro

@@ -633,14 +633,27 @@
         }
 
         // Phase 1: parallel hidden specs.
-        async function hiddenWorker() {
+        //
+        // Stagger the initial worker launches. If all N workers
+        // spawn their first iframe simultaneously, they all hit
+        // the same shared module-graph chunks concurrently and
+        // WebKit's module loader occasionally reports the opaque
+        // "Importing a module script failed." error on one of
+        // them. A per-worker start-offset of 120ms spaces the
+        // first-round fetches enough to avoid the race without
+        // materially slowing the run (pool=4 ⇒ 360ms total head-
+        // start before full concurrency). Subsequent picks within
+        // a worker are already serial.
+        const workerStagger = 120
+        async function hiddenWorker(index) {
+          if (index > 0) await new Promise(r => setTimeout(r, index * workerStagger))
           while (hiddenQueue.length) {
             const spec = hiddenQueue.shift()
             if (!spec) return
             await runOne(spec, { host: hiddenHost, label: null, grantFocus: false })
           }
         }
-        await Promise.all(Array.from({ length: page.pool }, hiddenWorker))
+        await Promise.all(Array.from({ length: page.pool }, (_, i) => hiddenWorker(i)))
 
         // Phase 2: serial focus specs in the visible workarea.
         for (const spec of focusQueue) {