feat(rule): gate sync rule-result resolution behind runTypeASync flag

Resolving each rule's result via setTimeout(0) (Deque #1172) creates one
macrotask transition per rule (~335). On large DOMs with advance ON these
interleave with DevTools IPC (resource.getContent), ballooning the
per-rule resolve from ~8ms to ~180ms and inflating axe.run from ~14s to
~85s.

When axe._cache 'runTypeASync' is set (by a11y-engine-core run.js from the
a11yCoreConfig flag), resolve synchronously to eliminate the contention.
The flag defaults OFF, preserving the original deferred behaviour.

On the OFF path, instrument the schedule-to-fire delay of each yield and
accumulate {totalMs,count,maxMs} onto axe._typeASyncYield so every scan
reports how much wall-clock the async resolve costs — the exact time the
flag would recover. Read back into Type A telemetry by a11y-engine-core.

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

Author: chikara1608

lib/core/base/rule.js

@@ -310,11 +310,49 @@ Rule.prototype.run = function run(context, options = {}, resolve, reject) {
     if (options.performanceTimer) {
       this._logRulePerformance();
     }
-    // Defer the rule's execution to prevent "unresponsive script" warnings.
-    // See https://github.com/dequelabs/axe-core/pull/1172 for discussion and details.
-    setTimeout(() => {
+    // [a11y-core]: gate rule-result resolution on the runTypeASync feature
+    // flag (set into axe._cache by a11y-engine-core run.js). The original
+    // setTimeout(0) defer (Deque #1172) creates one macrotask transition per
+    // rule (~335) that, on large DOMs with advance ON, interleaves with
+    // DevTools IPC (resource.getContent) and inflated axe.run from ~14s to
+    // ~85s. Resolving synchronously eliminates that contention.
+    if (cache.get('runTypeASync')) {
       resolve(ruleResult);
-    }, 0);
+    } else {
+      // [a11y-core]: original deferred path retained as the default (avoids
+      // "unresponsive script" warnings, Deque #1172). Instrument the
+      // schedule-to-fire delay of this yield so each scan reports how much
+      // wall-clock the async resolve costs — this is the exact time the
+      // runTypeASync flag would recover. Accumulate onto the axe global, not
+      // axe._cache, which is cleared on teardown before resolve fires.
+      let scheduledAt;
+      try {
+        scheduledAt = window.performance.now();
+      } catch {
+        scheduledAt = undefined;
+      }
+      setTimeout(() => {
+        try {
+          if (scheduledAt !== undefined) {
+            const yieldDelay = window.performance.now() - scheduledAt;
+            const yieldStats = axe._typeASyncYield || {
+              totalMs: 0,
+              count: 0,
+              maxMs: 0
+            };
+            yieldStats.totalMs += yieldDelay;
+            yieldStats.count += 1;
+            if (yieldDelay > yieldStats.maxMs) {
+              yieldStats.maxMs = yieldDelay;
+            }
+            axe._typeASyncYield = yieldStats;
+          }
+        } catch {
+          // instrumentation must never break rule resolution
+        }
+        resolve(ruleResult);
+      }, 0);
+    }
   }).catch(error => {
     if (options.performanceTimer) {
       this._logRulePerformance();