From 3cd3457d2a7e580a94b6c15c3fefc4b99ebd1524 Mon Sep 17 00:00:00 2001
From: leehack <leehack@gmail.com>
Date: Fri, 13 Nov 2026 19:49:21 -0500
Subject: [PATCH] Run the chat-app Web smoke in Safari and Firefox and add a
 WebGPU generation E2E (#1025)

--browser safari|firefox serves require-corp and drives the real-model smoke
through safaridriver or geckodriver; --backend webgpu offloads all layers.
The Dart web scenarios reject both browsers: package:test pages are never
cross-origin isolated. web-webgpu-generation compares full-offload WebGPU
text with CPU Wasm in direct and worker runtimes.
---
 doc/testing_matrix.md                         |  39 ++++-
 .../webgpu/webgpu_generation_e2e_test.dart    | 154 ++++++++++++++++++
 ...wright_chat_app_real_model_smoke_test.dart |  94 ++++++++++-
 test/unit/tooling/run_local_e2e_test.dart     | 153 +++++++++++++++++
 test/unit/tooling/test_matrix_test.dart       |  53 ++++++
 .../playwright_chat_app_real_model_smoke.py   |  35 ++--
 tool/testing/run_local_e2e.dart               | 122 +++++++++++++-
 tool/testing/safari_webdriver.py              |  55 ++++++-
 tool/testing/test_matrix.dart                 |  53 ++++++
 9 files changed, 728 insertions(+), 30 deletions(-)
 create mode 100644 test/e2e/webgpu/webgpu_generation_e2e_test.dart

diff --git a/doc/testing_matrix.md b/doc/testing_matrix.md
index 939cbe2cd..0b428c90a 100644
--- a/doc/testing_matrix.md
+++ b/doc/testing_matrix.md
@@ -161,7 +161,7 @@ Pick targeted rows based on the touched surface:
 | Tool-result media (`LlamaToolResultContent.content`, `LlamaToolOutput`) | `root-vm`, `tool-result-image-smoke`, validation `qwen3vl-gguf-cpu` / `-metal` (`M01`) |
 | LiteRT-LM embedding engine | `litert-lm-multimodal-embedding`; includes the documented local-only upstream WebGPU parity diagnostic |
 | LiteRT-LM native backend | `litert-lm-lifecycle`, `litert-lm-engine-smoke`, `litert-lm-chat-features-smoke`, `litert-lm-json-schema`, `litert-lm-asr-smoke`, `litert-lm-asr-preservation`, `litert-lm-media-preservation`, `litert-lm-utility-preservation` |
-| Web bridge bootstrap or interop | `web-bridge-smoke`, `web-mock-chat-smoke`, `web-real-model-smoke`, `web-tool-penalty-smoke`, `web-lazy-grammar`, `web-tool-choice-grammar` |
+| Web bridge bootstrap or interop | `web-bridge-smoke`, `web-mock-chat-smoke`, `web-real-model-smoke`, `web-real-model-smoke-safari`, `web-real-model-smoke-firefox`, `web-tool-penalty-smoke`, `web-lazy-grammar`, `web-webgpu-generation`, `web-tool-choice-grammar` |
 | WebGPU multimodal | `webgpu-multimodal-regression`, `web-speech-task-cancel`, plus `web-speech-to-text-smoke` for typed Qwen3-ASR and `web-text-to-speech-smoke` for typed Qwen3-TTS |
 | Large WebGPU GGUF / wasm64 selection | `gemma4-webgpu-mem64` |
 | LiteRT-LM web / Gemma 4 web bundle | `gemma4-litert-web` |
@@ -232,7 +232,7 @@ The matrix is designed to cover these essential axes:
 | Axis | Covered by |
 | --- | --- |
 | llama.cpp native GGUF | `root-vm`, `native-prompt-reuse-parity`, `native-inference-benchmark`, `gguf-chat-features-smoke`, `gguf-audio-chat-smoke`, `decision-model-smoke` |
-| llama.cpp WebGPU GGUF | `web-bridge-smoke`, `web-mock-chat-smoke`, `web-real-model-smoke`, `web-tool-penalty-smoke`, `web-lazy-grammar`, `web-tool-choice-grammar`, `webgpu-multimodal-regression`, `web-speech-to-text-smoke`, `web-text-to-speech-smoke`, `web-speech-task-cancel`, `gemma4-webgpu-mem64`, `decision-model-web-smoke` |
+| llama.cpp WebGPU GGUF | `web-bridge-smoke`, `web-mock-chat-smoke`, `web-real-model-smoke`, `web-real-model-smoke-safari`, `web-real-model-smoke-firefox`, `web-tool-penalty-smoke`, `web-lazy-grammar`, `web-webgpu-generation`, `web-tool-choice-grammar`, `webgpu-multimodal-regression`, `web-speech-to-text-smoke`, `web-text-to-speech-smoke`, `web-speech-task-cancel`, `gemma4-webgpu-mem64`, `decision-model-web-smoke` |
 | LiteRT-LM native `.litertlm` | `litert-lm-engine-smoke`, `litert-lm-chat-features-smoke`, `native-hook-bundles` |
 | LiteRT-LM web `.litertlm` | `gemma4-litert-web` |
 | Model families | Qwen 2.5 prompt reuse, Qwen 3/3.5 chat/multimodal, Gemma 4 tool/thinking/mem64/LiteRT-LM/audio, Laya ModernBERT decision encoder and head |
@@ -1464,6 +1464,41 @@ This qualifies the Web grammar plumbing on the selected weights, not hardware
 WebGPU or LFM2 auto accuracy/enforcement (#1715). The latter still needs its
 separate template contract and false-probe restriction.
 
+## Safari and Firefox chat-app smoke
+
+`web-real-model-smoke-safari` and `web-real-model-smoke-firefox` run
+`chat-app-web-real-model-smoke --browser safari|firefox` through
+`tool/testing/safari_webdriver.py`. The runner serves the repo with
+`--coep require-corp`, because both browsers expose `SharedArrayBuffer` only to
+cross-origin isolated pages. `--backend webgpu` adds `--backend-index 0
+--gpu-layers 99`; the default stays CPU Wasm. Run each with `--dry-run` first.
+
+- Safari needs Settings > Developer > Allow Remote Automation and an unlocked
+  screen; a hidden page fails before the model loads.
+- Firefox runs the binary in `FIREFOX_EXECUTABLE` through the geckodriver in
+  `GECKODRIVER` (default: `PATH`). geckodriver's script sandbox hides page
+  globals, so the helper installs its capture hooks as a page `<script>`.
+- Both cover plain chat only: no tool-call, speech or mmproj checks.
+- The Dart web scenarios (`web-lazy-grammar`, `web-webgpu-generation` and the
+  other `dart test -p chrome*` scenarios) reject `--browser safari|firefox`:
+  `package:test` pages are never cross-origin isolated.
+
+## Web WebGPU generation
+
+`web-webgpu-generation` loads one GGUF at `gpuLayers: 99` and at `gpuLayers: 0`
+through the pinned bridge in direct and worker runtimes, and requires the first
+eight greedy tokens to match with no replacement characters. Later divergence is
+printed as `WEBGPU_GENERATION_MATCH`, not failed. Use a small model that
+llamadart does not cap on WebGPU (not Qwen3.5-0.8B). Stage
+`build/webgpu_generation_e2e/config.json`:
+
+```json
+{"assets":"bridge/","model":"models/stories15M.gguf"}
+```
+
+Copy the model beside it; the runner fetches the pinned assets into `bridge/`
+and uses `chrome-webgpu`. Without a WebGPU adapter the suite fails.
+
 ## Web tool-choice grammar
 
 `web-tool-choice-grammar` ([#1673](https://github.com/leehack/llamadart/issues/1673))
diff --git a/test/e2e/webgpu/webgpu_generation_e2e_test.dart b/test/e2e/webgpu/webgpu_generation_e2e_test.dart
new file mode 100644
index 000000000..6943c0e8a
--- /dev/null
+++ b/test/e2e/webgpu/webgpu_generation_e2e_test.dart
@@ -0,0 +1,154 @@
+/// Real pinned-asset text generation at full WebGPU offload, compared with the
+/// CPU Wasm runtime, in direct and worker runtimes (#1025).
+///
+/// Stage build/webgpu_generation_e2e/config.json with {"assets":"bridge/",
+/// "model":"models/stories15M.gguf"} beside the pinned bridge files and the
+/// model, then run the web-webgpu-generation scenario. The model must not be
+/// one llamadart caps on WebGPU (Qwen3.5-0.8B).
+@TestOn('browser')
+@Tags(['local-only', 'e2e'])
+@Timeout(Duration(minutes: 10))
+library;
+
+import 'dart:convert';
+import 'dart:js_interop';
+import 'dart:js_interop_unsafe';
+
+import 'package:llamadart/llamadart.dart';
+import 'package:llamadart/src/backends/webgpu/interop.dart';
+import 'package:llamadart/src/backends/webgpu/webgpu_backend.dart';
+import 'package:test/test.dart';
+import 'package:web/web.dart' show window;
+
+const _greedy = GenerationParams(
+  maxTokens: 32,
+  temp: 0,
+  topK: 1,
+  topP: 1,
+  penalty: 1,
+  seed: 7,
+);
+const _prompt = 'Once upon a time';
+
+void main() {
+  final configUrl = Uri.base.resolve(
+    '../../../build/webgpu_generation_e2e/config.json',
+  );
+  late Map<String, dynamic> config;
+  late JSFunction constructor;
+  String asset(String name) =>
+      configUrl.resolve(config['assets'] as String).resolve(name).toString();
+
+  LlamaEngine newEngine(bool worker) => LlamaEngine(
+    WebGpuLlamaBackend(
+      bridgeFactory: ([_]) => constructor.callAsConstructor<LlamaWebGpuBridge>(
+        JSObject()
+          ..['disableWorker'] = (!worker).toJS
+          ..['workerUrl'] = asset('llama_webgpu_bridge_worker.js').toJS
+          ..['coreModuleUrl'] = asset('llama_webgpu_core.js').toJS
+          ..['wasmUrl'] = asset('llama_webgpu_core.wasm').toJS,
+      ),
+    ),
+  );
+
+  Future<String> generate(bool worker, ModelParams params, int tokens) async {
+    final engine = newEngine(worker);
+    try {
+      await engine.loadModelFromUrl(
+        configUrl.resolve(config['model'] as String).toString(),
+        modelParams: params,
+      );
+      final metadata = await engine.getMetadata();
+      expect(
+        metadata['llamadart.webgpu.execution'],
+        worker ? 'worker' : 'main-thread',
+      );
+      if (params.device == ComputeDevice.gpu) {
+        expect(await engine.getBackendName(), contains('WebGPU'));
+        expect(metadata['llamadart.webgpu.n_gpu_layers'], '99');
+      }
+      final watch = Stopwatch()..start();
+      final text = await engine
+          .generate(_prompt, params: _greedy.copyWith(maxTokens: tokens))
+          .join();
+      print(
+        'WEBGPU_GENERATION ${jsonEncode({'runtime': worker ? 'worker' : 'direct', 'device': params.device.name, 'backend': await engine.getBackendName(), 'tokens': tokens, 'ms': watch.elapsedMilliseconds, 'text': text})}',
+      );
+      return text;
+    } finally {
+      await engine.dispose();
+    }
+  }
+
+  setUpAll(() async {
+    final response = await window.fetch(configUrl.toString().toJS).toDart;
+    expect(response.ok, isTrue, reason: 'Missing $configUrl');
+    config =
+        jsonDecode((await response.text().toDart).toDart)
+            as Map<String, dynamic>;
+    final module = await importModule(
+      asset('llama_webgpu_bridge.js').toJS,
+    ).toDart;
+    constructor = module['LlamaWebGpuBridge']! as JSFunction;
+    final adapter = await _adapterInfo();
+    print('WEBGPU_ADAPTER ${jsonEncode(adapter)}');
+    expect(
+      adapter['error'],
+      isNull,
+      reason: 'This test needs a WebGPU adapter.',
+    );
+  });
+
+  for (final worker in [false, true]) {
+    test('${worker ? 'worker' : 'direct'} full WebGPU offload generates the '
+        'CPU runtime text', () async {
+      const cpu = ModelParams(
+        contextSize: 512,
+        gpuLayers: 0,
+        device: ComputeDevice.cpu,
+        numberOfThreads: 2,
+        numberOfThreadsBatch: 2,
+      );
+      const gpu = ModelParams(
+        contextSize: 512,
+        gpuLayers: 99,
+        device: ComputeDevice.gpu,
+        numberOfThreads: 2,
+        numberOfThreadsBatch: 2,
+      );
+      // Greedy text can diverge late across GPU drivers, so the gate is the
+      // first tokens; the full runs are recorded for the qualification table.
+      final cpuHead = await generate(worker, cpu, 8);
+      final gpuHead = await generate(worker, gpu, 8);
+      expect(gpuHead, isNotEmpty);
+      expect(gpuHead, isNot(contains('�')));
+      expect(gpuHead, cpuHead);
+      final cpuText = await generate(worker, cpu, 32);
+      final gpuText = await generate(worker, gpu, 32);
+      expect(gpuText, isNot(contains('�')));
+      print(
+        'WEBGPU_GENERATION_MATCH ${jsonEncode({'runtime': worker ? 'worker' : 'direct', 'fullTextEqual': gpuText == cpuText})}',
+      );
+    });
+  }
+}
+
+Future<Map<String, Object?>> _adapterInfo() async {
+  final gpu = (window as JSObject)
+      .getProperty<JSObject?>('navigator'.toJS)
+      ?.getProperty<JSAny?>('gpu'.toJS);
+  if (gpu == null || !gpu.isA<JSObject>()) return {'error': 'no navigator.gpu'};
+  final adapter = await (gpu as JSObject)
+      .callMethod<JSPromise<JSAny?>>('requestAdapter'.toJS)
+      .toDart;
+  if (adapter == null) return {'error': 'no adapter'};
+  final info = (adapter as JSObject).getProperty<JSObject?>('info'.toJS);
+  String? field(String name) =>
+      (info?.getProperty<JSAny?>(name.toJS) as JSString?)?.toDart;
+  return {
+    'vendor': field('vendor'),
+    'architecture': field('architecture'),
+    'device': field('device'),
+    'description': field('description'),
+  };
+}
diff --git a/test/unit/tooling/playwright_chat_app_real_model_smoke_test.dart b/test/unit/tooling/playwright_chat_app_real_model_smoke_test.dart
index 838be8a4c..894a0b2c1 100644
--- a/test/unit/tooling/playwright_chat_app_real_model_smoke_test.dart
+++ b/test/unit/tooling/playwright_chat_app_real_model_smoke_test.dart
@@ -434,6 +434,29 @@ void main() {
     );
   });
 
+  test('rejects tool-call expectations in Firefox', () async {
+    final result = await _runProcess(
+      Platform.isWindows ? 'python' : 'python3',
+      [
+        _script,
+        'http://127.0.0.1:1/',
+        '--model-url',
+        'http://127.0.0.1:1/model.gguf',
+        '--expect-tool-call',
+        'getWeather',
+        '--browser',
+        'firefox',
+      ],
+      environment: {'PYTHONPATH': tempDir.path},
+    );
+
+    expect(result.exitCode, 2);
+    expect(
+      result.stderr,
+      contains('--browser firefox does not record tool-call completions'),
+    );
+  });
+
   test('rejects speech input in Safari', () async {
     final audio = File(p.join(tempDir.path, 'speech.wav'))
       ..writeAsBytesSync(const <int>[0]);
@@ -472,6 +495,7 @@ void main() {
         required String visibility,
         required int frames,
         int stderrBytes = 0,
+        String browser = 'safari',
       }) async {
         final driver = File(p.join(tempDir.path, 'fake_safaridriver'))
           ..writeAsStringSync(_fakeSafariDriver);
@@ -495,10 +519,12 @@ void main() {
             '--response-timeout-ms',
             '4000',
             '--browser',
-            'safari',
+            browser,
           ],
           environment: {
             'PYTHONPATH': tempDir.path,
+            'GECKODRIVER': driver.path,
+            'FIREFOX_EXECUTABLE': '/fake/Firefox.app/Contents/MacOS/firefox',
             'LLAMADART_FAKE_SAFARI_SCENARIO': jsonEncode({
               'logPath': logPath,
               'visibility': visibility,
@@ -551,6 +577,72 @@ void main() {
         expect(run.commands.last['method'], 'DELETE');
       });
 
+      test(
+        'Firefox starts geckodriver and injects scripts as page elements',
+        () async {
+          final run = await runSafari(
+            visibility: 'visible',
+            frames: 60,
+            browser: 'firefox',
+          );
+
+          expect(run.result.exitCode, 0, reason: '${run.result.stderr}');
+          final session = run.commands.firstWhere(
+            (c) => c['command'] == 'session',
+          );
+          expect(session['body']['capabilities']['alwaysMatch'], {
+            'browserName': 'firefox',
+            'moz:firefoxOptions': {
+              'binary': '/fake/Firefox.app/Contents/MacOS/firefox',
+            },
+          });
+          final scripts = [
+            for (final c in run.commands)
+              if (c['command'] == 'sync') c['body'] as Map<String, dynamic>,
+          ];
+          final injections = scripts
+              .where(
+                (b) =>
+                    (b['script'] as String).contains("createElement('script')"),
+              )
+              .toList();
+          expect(injections, hasLength(2));
+          for (final injection in injections) {
+            expect(
+              (injection['args'] as List).single,
+              contains('__llamadartRealBridgePatchTimer'),
+            );
+          }
+          expect(
+            scripts.where(
+              (b) => (b['script'] as String).contains(
+                '__llamadartRealBridgePatchTimer',
+              ),
+            ),
+            isEmpty,
+            reason: 'the init script must not run in the driver sandbox',
+          );
+          expect(run.commands.last['method'], 'DELETE');
+        },
+      );
+
+      test('Safari executes the init script directly', () async {
+        final run = await runSafari(visibility: 'visible', frames: 60);
+
+        final scripts = [
+          for (final c in run.commands)
+            if (c['command'] == 'sync') (c['body'] as Map)['script'] as String,
+        ];
+        expect(
+          scripts.where((s) => s.contains('__llamadartRealBridgePatchTimer')),
+          hasLength(2),
+        );
+        expect(
+          scripts.where((s) => s.contains("createElement('script')")),
+          isEmpty,
+        );
+      });
+
       for (final (name, visibility, frames) in [
         ('is hidden', 'hidden', 60),
         ('renders no frames', 'visible', 0),
diff --git a/test/unit/tooling/run_local_e2e_test.dart b/test/unit/tooling/run_local_e2e_test.dart
index 805264659..ccbe2740a 100644
--- a/test/unit/tooling/run_local_e2e_test.dart
+++ b/test/unit/tooling/run_local_e2e_test.dart
@@ -663,6 +663,159 @@ Future<void> main(List<String> args) async {
     }
   });
 
+  group('chat-app Web real-model smoke in Safari and Firefox', () {
+    Future<LocalE2eResult> dryRun(List<String> extra) => runLocalE2e(
+      [
+        '--scenario',
+        'chat-app-web-real-model-smoke',
+        '--skip-build',
+        '--dry-run',
+        ...extra,
+      ],
+      projectRoot: '/repo',
+      displayShell: LocalE2eDisplayShell.posix,
+    );
+
+    for (final browser in ['safari', 'firefox']) {
+      test('$browser serves require-corp and forwards the browser', () async {
+        final result = await dryRun(['--browser', browser]);
+
+        expect(result.exitCode, 0, reason: result.stderr);
+        expect(
+          result.stdout,
+          contains('--port 7358 --coep require-corp'),
+          reason: 'the page must be cross-origin isolated',
+        );
+        expect(result.stdout, contains('--browser $browser'));
+        expect(result.stdout, isNot(contains('--backend-index')));
+      });
+    }
+
+    test('chrome keeps the default COEP and omits --browser', () async {
+      final result = await dryRun(['--browser', 'chrome']);
+
+      expect(result.exitCode, 0, reason: result.stderr);
+      expect(result.stdout, isNot(contains('--coep')));
+      expect(result.stdout, isNot(contains('--browser')));
+    });
+
+    test(
+      '--backend webgpu asks for full offload on the auto backend',
+      () async {
+        final result = await dryRun([
+          '--browser',
+          'safari',
+          '--backend',
+          'webgpu',
+        ]);
+
+        expect(result.exitCode, 0, reason: result.stderr);
+        expect(result.stdout, contains('--backend-index 0 --gpu-layers 99'));
+        expect(result.stdout, contains('--browser safari'));
+      },
+    );
+
+    test('--backend cpu keeps the CPU runtime', () async {
+      final result = await dryRun(['--backend', 'cpu']);
+
+      expect(result.exitCode, 0, reason: result.stderr);
+      expect(result.stdout, isNot(contains('--gpu-layers')));
+    });
+
+    test('rejects other backends and other scenarios', () async {
+      final backend = await dryRun(['--backend', 'vulkan']);
+      expect(backend.exitCode, 64);
+      expect(backend.stderr, contains('--backend cpu or webgpu'));
+      final scenario = await runLocalE2e([
+        '--scenario',
+        'chat-app-web-tool-penalty-smoke',
+        '--backend',
+        'webgpu',
+      ], projectRoot: '/repo');
+      expect(scenario.exitCode, 64);
+      expect(scenario.stderr, contains('--backend webgpu applies only'));
+    });
+
+    test(
+      'Dart web scenarios reject Safari and Firefox for isolation',
+      () async {
+        for (final name in [
+          'web-lazy-grammar',
+          'web-webgpu-generation',
+          'web-multimodal-embeddings-webgpu',
+        ]) {
+          for (final browser in ['safari', 'firefox']) {
+            final result = await runLocalE2e([
+              '--scenario',
+              name,
+              '--browser',
+              browser,
+              '--dry-run',
+            ], projectRoot: '/repo');
+            expect(result.exitCode, 64, reason: '$name $browser');
+            expect(result.stderr, contains('never cross-origin isolated'));
+            expect(result.stderr, contains(name));
+          }
+        }
+      },
+    );
+
+    test('Firefox stays rejected outside the chat-app smoke', () async {
+      final result = await runLocalE2e([
+        '--scenario',
+        'chat-app-web-litert-gemma4-smoke',
+        '--browser',
+        'firefox',
+        '--dry-run',
+      ], projectRoot: '/repo');
+      expect(result.exitCode, 64);
+      expect(result.stderr, contains('--browser chrome or safari'));
+    });
+  });
+
+  group('web-webgpu-generation', () {
+    test(
+      'dry-run fetches pinned assets and runs the WebGPU platform',
+      () async {
+        final result = await runLocalE2e(
+          ['--scenario', 'web-webgpu-generation', '--dry-run'],
+          projectRoot: '/repo',
+          displayShell: LocalE2eDisplayShell.posix,
+        );
+
+        expect(result.exitCode, 0, reason: result.stderr);
+        expect(
+          result.stdout,
+          contains(
+            'WEBGPU_BRIDGE_OUT_DIR=/repo/build/webgpu_generation_e2e/bridge',
+          ),
+        );
+        expect(
+          result.stdout,
+          contains(
+            'dart test -p chrome-webgpu --run-skipped -t local-only '
+            'test/e2e/webgpu/webgpu_generation_e2e_test.dart',
+          ),
+        );
+      },
+    );
+
+    test('a real run requires the staged config', () async {
+      final root = await Directory.systemTemp.createTemp('lane-1025h-config-');
+      addTearDown(() => root.delete(recursive: true));
+      final result = await runLocalE2e([
+        '--scenario',
+        'web-webgpu-generation',
+      ], projectRoot: root.path);
+
+      expect(result.exitCode, 64);
+      expect(
+        result.stderr,
+        contains('build/webgpu_generation_e2e/config.json'),
+      );
+    });
+  });
+
   test(
     'Qwen scenario preserves UTF-8 stdout from the real child process',
     () async {
diff --git a/test/unit/tooling/test_matrix_test.dart b/test/unit/tooling/test_matrix_test.dart
index 4e89a0832..ccbba9284 100644
--- a/test/unit/tooling/test_matrix_test.dart
+++ b/test/unit/tooling/test_matrix_test.dart
@@ -428,6 +428,59 @@ void main() {
     }
   });
 
+  test('Safari and Firefox rows select the isolated chat-app smoke', () async {
+    final doc = File('doc/testing_matrix.md').readAsStringSync();
+    for (final browser in ['safari', 'firefox']) {
+      final row = testMatrixRows.singleWhere(
+        (row) => row.id == 'web-real-model-smoke-$browser',
+      );
+      expect(row.mode, startsWith('local-only'));
+      expect(row.command, contains('--browser $browser'));
+      expect(row.covers, contains('require-corp'));
+      expect(doc, contains('`${row.id}`'));
+      final command = row.command
+          .replaceFirst('FIREFOX_EXECUTABLE=<firefox> ', '')
+          .replaceAll('<model-url>', 'http://127.0.0.1:1/m.gguf')
+          .replaceAll(' [--backend webgpu]', '')
+          .split(' ');
+      final result = await runLocalE2e(
+        [...command.skip(3), '--skip-build', '--dry-run'],
+        projectRoot: '/repo',
+        displayShell: LocalE2eDisplayShell.posix,
+      );
+      expect(result.exitCode, 0, reason: result.stderr);
+      expect(result.stdout, contains('--coep require-corp'));
+      expect(result.stdout, contains('--browser $browser'));
+    }
+    expect(doc, contains('## Safari and Firefox chat-app smoke'));
+  });
+
+  test(
+    'the WebGPU generation row reaches its scenario and test file',
+    () async {
+      final row = testMatrixRows.singleWhere(
+        (row) => row.id == 'web-webgpu-generation',
+      );
+      expect(row.mode, contains('local-only'));
+      final result = await runLocalE2e(
+        row.command.split(' ').skip(3).toList()..add('--dry-run'),
+        projectRoot: '/repo',
+      );
+      expect(result.exitCode, 0, reason: result.stderr);
+      expect(
+        result.stdout,
+        contains('test/e2e/webgpu/webgpu_generation_e2e_test.dart'),
+      );
+      expect(
+        File('test/e2e/webgpu/webgpu_generation_e2e_test.dart').existsSync(),
+        isTrue,
+      );
+      final doc = File('doc/testing_matrix.md').readAsStringSync();
+      expect(doc, contains('`web-webgpu-generation`'));
+      expect(doc, contains('## Web WebGPU generation'));
+    },
+  );
+
   test('the Web tool penalty row asserts the call and drops any-response', () {
     final row = testMatrixRows.singleWhere(
       (row) => row.id == 'web-tool-penalty-smoke',
diff --git a/tool/testing/playwright_chat_app_real_model_smoke.py b/tool/testing/playwright_chat_app_real_model_smoke.py
index 2afeec5c1..4193a6d99 100644
--- a/tool/testing/playwright_chat_app_real_model_smoke.py
+++ b/tool/testing/playwright_chat_app_real_model_smoke.py
@@ -261,15 +261,15 @@ def _require_visible_page(session: SafariSession) -> None:
     # Flutter frames, and Safari can terminate it while a large model loads.
     if state["visibility"] != "visible" or state["frames"] == 0:
         raise RuntimeError(
-            "Safari page is not visible; unlock the screen and keep the "
-            f"automation window in front: {state}"
+            f"{session.browser.capitalize()} page is not visible; unlock the "
+            f"screen and keep the automation window in front: {state}"
         )
 
 
-def run_safari(
+def run_webdriver(
     args, init_script: str, *, started_at: float, remote_fetch_mode: str
 ) -> int:
-    with SafariSession() as session:
+    with SafariSession(browser=args.browser) as session:
         page = _SafariPage(session)
         emit("safari_session", version=session.capabilities.get("browserVersion"))
         session.set_window_size(1440, 1100)
@@ -277,9 +277,9 @@ def run_safari(
         # WebDriver has no init script: seed settings, reload so the app reads
         # them, then install the capture globals before the model loads.
         session.navigate(args.app_url)
-        session.execute(init_script)
+        session.run_in_page(init_script)
         session.navigate(args.app_url)
-        session.execute(init_script)
+        session.run_in_page(init_script)
         _require_visible_page(session)
 
         _find_semantics(session, "flt-semantics-placeholder", "", 120)
@@ -611,17 +611,20 @@ def main() -> int:
     parser.add_argument("--headed", action="store_true")
     parser.add_argument(
         "--browser",
-        choices=["chromium", "safari"],
+        choices=["chromium", "safari", "firefox"],
         default="chromium",
-        help="safari drives the Safari app through safaridriver (plain chat only).",
+        help=(
+            "safari drives the Safari app through safaridriver; firefox drives "
+            "FIREFOX_EXECUTABLE through geckodriver (plain chat only)."
+        ),
     )
     args = parser.parse_args()
-    if args.browser == "safari" and (
+    if args.browser != "chromium" and (
         args.speech_audio_path or args.prefetch_mmproj_cache
     ):
         parser.error(
-            "--browser safari supports plain chat only, without speech input "
-            "or mmproj prefetch"
+            f"--browser {args.browser} supports plain chat only, without speech "
+            "input or mmproj prefetch"
         )
     if args.expect_mmproj_cache_hit and not args.prefetch_mmproj_cache:
         parser.error("--expect-mmproj-cache-hit requires --prefetch-mmproj-cache")
@@ -637,8 +640,10 @@ def main() -> int:
             "--expect-tool-call, --expect-tool-argument and "
             "--expect-tool-result conflict with --allow-any-response"
         )
-    if args.expect_tool_call and args.browser == "safari":
-        parser.error("--browser safari does not record tool-call completions")
+    if args.expect_tool_call and args.browser != "chromium":
+        parser.error(
+            f"--browser {args.browser} does not record tool-call completions"
+        )
     if args.speech_audio_path:
         audio_path = Path(args.speech_audio_path).resolve()
         if not audio_path.is_file():
@@ -959,8 +964,8 @@ def main() -> int:
         )}
     """
 
-    if args.browser == "safari":
-        return run_safari(
+    if args.browser != "chromium":
+        return run_webdriver(
             args,
             init_script,
             started_at=started_at,
diff --git a/tool/testing/run_local_e2e.dart b/tool/testing/run_local_e2e.dart
index c52150cc2..98fe085b3 100644
--- a/tool/testing/run_local_e2e.dart
+++ b/tool/testing/run_local_e2e.dart
@@ -197,6 +197,9 @@ class LocalE2eRunContext {
   final bool skipBuild;
   final Map<String, String>? _environment;
 
+  /// Whether `--backend webgpu` asked the Web smoke for full WebGPU offload.
+  bool get webgpuRequested => backendProvided && backend == 'webgpu';
+
   /// The process environment scenarios read, or what a test injected.
   Map<String, String> get environment => _environment ?? Platform.environment;
 
@@ -281,6 +284,8 @@ List<LocalE2eCommandStep> _webRealModelSmokeSteps(
   List<String> extraSmokeArguments, {
   String? defaultExpect,
 }) {
+  // Safari and Firefox are cross-origin isolated only under require-corp.
+  final webDriverBrowser = _isWebDriverBrowser(context.browser);
   return [
     _prepareChatAppWebBuild(context),
     LocalE2eCommandStep(
@@ -292,6 +297,7 @@ List<LocalE2eCommandStep> _webRealModelSmokeSteps(
         '.',
         '--port',
         '${context.port}',
+        if (webDriverBrowser) ...['--coep', 'require-corp'],
       ],
       description: 'Serve repo root with COOP/COEP headers',
       background: true,
@@ -311,12 +317,22 @@ List<LocalE2eCommandStep> _webRealModelSmokeSteps(
             : defaultExpect ?? context.expect,
         if (context.allowAnyResponse) '--allow-any-response',
         ...extraSmokeArguments,
+        if (context.webgpuRequested) ...[
+          '--backend-index',
+          '0',
+          '--gpu-layers',
+          '99',
+        ],
+        if (webDriverBrowser) ...['--browser', context.browser!],
       ],
       description: 'Run Playwright real-model chat app smoke',
     ),
   ];
 }
 
+bool _isWebDriverBrowser(String? browser) =>
+    browser == 'safari' || browser == 'firefox';
+
 LocalE2eCommandStep _prepareChatAppWebBuild(LocalE2eRunContext context) =>
     LocalE2eCommandStep(
       workingDirectory: context.projectRoot,
@@ -341,6 +357,19 @@ const List<String> _referenceEditComponentVariables = [
   'LLAMADART_REFERENCE_EDIT_T5XXL',
 ];
 
+/// Scenarios that run `dart test -p chrome*`; their pages are not served with
+/// COOP/COEP headers.
+const Set<String> _dartWebE2eScenarios = {
+  'decision-model-web-smoke',
+  'web-lazy-grammar',
+  'web-tool-choice-grammar',
+  'web-speech-task-cancel',
+  'web-multimodal-embeddings',
+  'web-multimodal-embeddings-webgpu',
+  'web-webgpu-generation',
+  'webgpu-multimodal-regression',
+};
+
 List<LocalE2eScenario> buildLocalE2eScenarios({String? projectRoot}) {
   return [
     LocalE2eScenario(
@@ -1432,6 +1461,41 @@ List<LocalE2eScenario> buildLocalE2eScenarios({String? projectRoot}) {
         ),
       ],
     ),
+    LocalE2eScenario(
+      name: 'web-webgpu-generation',
+      group: LocalE2eScenarioGroup.webSmoke,
+      description:
+          'Check pinned-asset text generation at full WebGPU offload against '
+          'the CPU Wasm runtime in direct and worker runtimes; needs a WebGPU '
+          'adapter and a staged build/webgpu_generation_e2e/config.json.',
+      requiresDevice: false,
+      stepsBuilder: (context) => [
+        LocalE2eCommandStep(
+          workingDirectory: context.projectRoot,
+          executable: 'bash',
+          arguments: const ['scripts/fetch_webgpu_bridge_assets.sh'],
+          environment: {
+            'WEBGPU_BRIDGE_OUT_DIR':
+                '${context.projectRoot}/build/webgpu_generation_e2e/bridge',
+          },
+          description: 'Fetch pinned WebGPU bridge assets for the test server',
+        ),
+        LocalE2eCommandStep(
+          workingDirectory: context.projectRoot,
+          executable: 'dart',
+          arguments: const [
+            'test',
+            '-p',
+            'chrome-webgpu',
+            '--run-skipped',
+            '-t',
+            'local-only',
+            'test/e2e/webgpu/webgpu_generation_e2e_test.dart',
+          ],
+          description: 'Web full-offload WebGPU generation',
+        ),
+      ],
+    ),
     LocalE2eScenario(
       name: 'web-tool-choice-grammar',
       group: LocalE2eScenarioGroup.webSmoke,
@@ -3020,17 +3084,52 @@ Future<LocalE2eResult> runLocalE2e(
       );
     }
   }
+  if (parsed.browser case final browser? when _isWebDriverBrowser(browser)) {
+    if (_dartWebE2eScenarios.contains(scenario.name)) {
+      return LocalE2eResult(
+        64,
+        stderr:
+            '--browser $browser is not supported by ${scenario.name}: '
+            'package:test pages are never cross-origin isolated, so the '
+            'WebGPU bridge cannot load its pthread core in $browser. Use '
+            'chat-app-web-real-model-smoke, which serves '
+            'Cross-Origin-Embedder-Policy: require-corp.\n',
+      );
+    }
+  }
   if (parsed.browser case final browser?
       when !const [
             'litert-lm-web-text-history',
             'chat-app-web-litert-gemma4-smoke',
+            'chat-app-web-real-model-smoke',
           ].contains(scenario.name) ||
-          !const ['chrome', 'safari'].contains(browser)) {
+          !const ['chrome', 'safari', 'firefox'].contains(browser) ||
+          (browser == 'firefox' &&
+              scenario.name != 'chat-app-web-real-model-smoke')) {
     return const LocalE2eResult(
       64,
       stderr:
           '--browser chrome or safari applies only to litert-lm-web-text-history '
-          'and chat-app-web-litert-gemma4-smoke.\n',
+          'and chat-app-web-litert-gemma4-smoke; chat-app-web-real-model-smoke '
+          'also accepts firefox.\n',
+    );
+  }
+  if (scenario.name == 'chat-app-web-real-model-smoke' &&
+      parsed.backendProvided &&
+      !const ['cpu', 'webgpu'].contains(parsed.backend)) {
+    return const LocalE2eResult(
+      64,
+      stderr:
+          'chat-app-web-real-model-smoke requires --backend cpu or webgpu.\n',
+    );
+  }
+  if (scenario.name != 'chat-app-web-real-model-smoke' &&
+      parsed.backend == 'webgpu') {
+    return LocalE2eResult(
+      64,
+      stderr:
+          '--backend webgpu applies only to chat-app-web-real-model-smoke; '
+          '${scenario.name} does not accept it.\n',
     );
   }
   if (const [
@@ -3481,6 +3580,19 @@ Future<LocalE2eResult> runLocalE2e(
     }
   }
 
+  if (scenario.name == 'web-webgpu-generation' &&
+      !parsed.dryRun &&
+      !File('$root/build/webgpu_generation_e2e/config.json').existsSync()) {
+    return const LocalE2eResult(
+      64,
+      stderr:
+          'web-webgpu-generation requires build/webgpu_generation_e2e/config.json '
+          'with {"assets":"bridge/","model":"models/<gguf>"} beside a model '
+          'that WebGPU does not cap (not Qwen3.5-0.8B); see '
+          'test/e2e/webgpu/webgpu_generation_e2e_test.dart.\n',
+    );
+  }
+
   if (scenario.name == 'web-multimodal-embeddings-webgpu' && !parsed.dryRun) {
     final configFile = File('$root/build/webgpu_embeddings_e2e/config.json');
     Object? gpuLayers;
@@ -3769,8 +3881,10 @@ Options:
   --config-path <path>           Optional decision head config JSON for head files without laya.config metadata.
   --model-url <url>              Model URL for real-model web smoke.
   --mmproj-url <url>             Projector URL for real-model web smoke.
-  --backend <name>               Backend for local model scenarios (default: auto; decision-model-smoke: cpu).
-  --browser <name>               LiteRT-LM Web history and Gemma 4 smoke browser: chrome (default) or safari (safaridriver).
+  --backend <name>               Backend for local model scenarios (default: auto; decision-model-smoke: cpu;
+                                 chat-app-web-real-model-smoke: cpu or webgpu for full WebGPU offload).
+  --browser <name>               LiteRT-LM Web history and Gemma 4 smoke browser: chrome (default) or safari (safaridriver);
+                                 chat-app-web-real-model-smoke also accepts firefox (geckodriver, binary from FIREFOX_EXECUTABLE).
   --speculative-cases <list>     Benchmark cases for llama.cpp speculative benchmark.
   --benchmark-gpu-layers <n>     GPU layers for benchmark scenarios (default: 0).
   --benchmark-max-tokens <n>     Max tokens for benchmark scenarios (default: 128).
diff --git a/tool/testing/safari_webdriver.py b/tool/testing/safari_webdriver.py
index cdb74605c..00655694f 100644
--- a/tool/testing/safari_webdriver.py
+++ b/tool/testing/safari_webdriver.py
@@ -1,9 +1,13 @@
-"""Drive the Safari app through safaridriver (W3C WebDriver).
+"""Drive Safari (safaridriver) or Firefox (geckodriver) over W3C WebDriver.
 
-Requires Safari's Settings > Developer > Allow Remote Automation.
+Safari needs Settings > Developer > Allow Remote Automation. Firefox runs the
+binary in FIREFOX_EXECUTABLE (the system Firefox when unset) through the
+geckodriver in GECKODRIVER (the one on PATH when unset).
 """
 import contextlib
 import json
+import os
+import shutil
 import socket
 import subprocess
 import tempfile
@@ -33,10 +37,27 @@ def _free_port() -> int:
         return probe.getsockname()[1]
 
 
+def _driver_command(browser: str) -> tuple[str, dict[str, Any]]:
+    """Returns the driver executable and the W3C capabilities for [browser]."""
+    if browser == "safari":
+        return SAFARIDRIVER, {"browserName": "safari"}
+    if browser != "firefox":
+        raise ValueError(f"Unsupported WebDriver browser: {browser}")
+    driver = os.environ.get("GECKODRIVER") or shutil.which("geckodriver")
+    if not driver:
+        raise WebDriverError("geckodriver not found: set GECKODRIVER or add it to PATH")
+    capabilities: dict[str, Any] = {"browserName": "firefox"}
+    if binary := os.environ.get("FIREFOX_EXECUTABLE"):
+        capabilities["moz:firefoxOptions"] = {"binary": binary}
+    return driver, capabilities
+
+
 class SafariSession:
-    """One safaridriver process and one Safari automation window."""
+    """One WebDriver process (safaridriver or geckodriver) and one browser window."""
 
-    def __init__(self, *, command_timeout_s: float = 300) -> None:
+    def __init__(self, *, browser: str = "safari", command_timeout_s: float = 300) -> None:
+        self.browser = browser
+        driver, capabilities = _driver_command(browser)
         self._timeout = command_timeout_s
         self._port = _free_port()
         # A file, not a pipe: nothing reads stderr while the driver runs, and a
@@ -44,7 +65,7 @@ def __init__(self, *, command_timeout_s: float = 300) -> None:
         self._stderr = tempfile.TemporaryFile()
         try:
             self._driver = subprocess.Popen(
-                [SAFARIDRIVER, "-p", str(self._port)],
+                [driver, "-p", str(self._port)],
                 stdout=subprocess.DEVNULL,
                 stderr=self._stderr,
             )
@@ -58,7 +79,7 @@ def __init__(self, *, command_timeout_s: float = 300) -> None:
             value = self._request(
                 "POST",
                 "/session",
-                {"capabilities": {"alwaysMatch": {"browserName": "safari"}}},
+                {"capabilities": {"alwaysMatch": capabilities}},
             )
             self.session_id = value["sessionId"]
             self.capabilities = value.get("capabilities", {})
@@ -70,7 +91,7 @@ def _wait_for_driver(self) -> None:
         deadline = time.monotonic() + _DRIVER_START_TIMEOUT_S
         while time.monotonic() < deadline:
             if self._driver.poll() is not None:
-                raise WebDriverError(f"safaridriver exited: {self._driver_stderr()}")
+                raise WebDriverError(f"{self.browser} driver exited: {self._driver_stderr()}")
             try:
                 self._request("GET", "/status")
                 return
@@ -78,7 +99,7 @@ def _wait_for_driver(self) -> None:
                 time.sleep(0.2)
         detail = self._driver_stderr()
         raise WebDriverError(
-            f"safaridriver did not start within {_DRIVER_START_TIMEOUT_S} s"
+            f"{self.browser} driver did not start within {_DRIVER_START_TIMEOUT_S} s"
             + (f": {detail}" if detail else "")
         )
 
@@ -117,6 +138,24 @@ def execute(self, script: str, *args: Any) -> Any:
             "POST", "/execute/sync", {"script": script, "args": list(args)}
         )
 
+    def run_in_page(self, script: str) -> None:
+        """Runs [script] in the page's own JavaScript world.
+
+        geckodriver executes scripts in a sandbox that hides page globals and
+        wraps page objects, so a script that installs capture hooks must run
+        as a page <script> element there.
+        """
+        if self.browser != "firefox":
+            self.execute(script)
+            return
+        self.execute(
+            "const node = document.createElement('script');"
+            "node.textContent = arguments[0];"
+            "document.documentElement.appendChild(node);"
+            "node.remove();",
+            script,
+        )
+
     def click(self, element: str) -> None:
         self._command("POST", f"/element/{element}/click", {})
 
diff --git a/tool/testing/test_matrix.dart b/tool/testing/test_matrix.dart
index 1aef061c8..aefccc96e 100644
--- a/tool/testing/test_matrix.dart
+++ b/tool/testing/test_matrix.dart
@@ -898,6 +898,24 @@ const List<TestMatrixRow> testMatrixRows = <TestMatrixRow>[
         'Web grammar capability, trigger transport or bridge pin changes. '
         'Stage build/web_lazy_grammar/config.json as doc/testing_matrix.md describes.',
   ),
+  TestMatrixRow(
+    id: 'web-webgpu-generation',
+    tier: 'targeted',
+    mode: 'local-only, WebGPU browser',
+    covers:
+        'pinned-asset text generation at full WebGPU offload (99 layers) '
+        'against the CPU Wasm runtime in direct and worker runtimes: the '
+        'WebGPU backend and layer count are reported, the first eight greedy '
+        'tokens equal the CPU text and no output holds a replacement '
+        'character; later divergence is recorded, not failed; Chrome only',
+    command:
+        'dart run tool/testing/run_local_e2e.dart --scenario '
+        'web-webgpu-generation',
+    useWhen:
+        'WebGPU generation, layer offload or bridge pin changes on a machine '
+        'with a WebGPU adapter. Stage build/webgpu_generation_e2e/config.json '
+        'as doc/testing_matrix.md describes.',
+  ),
   TestMatrixRow(
     id: 'web-tool-choice-grammar',
     tier: 'targeted',
@@ -1583,6 +1601,41 @@ const List<TestMatrixRow> testMatrixRows = <TestMatrixRow>[
     useWhen:
         'Web chat app, web model loading, or WebGPU bridge runtime changes.',
   ),
+  TestMatrixRow(
+    id: 'web-real-model-smoke-safari',
+    tier: 'targeted',
+    mode: 'local-only, macOS Safari',
+    covers:
+        'built Flutter web chat app with a real GGUF in Safari through '
+        'safaridriver, served cross-origin isolated (require-corp); plain '
+        'chat, CPU Wasm or full WebGPU offload (--backend webgpu); needs an '
+        'unlocked screen and Allow Remote Automation; no tool, speech or '
+        'mmproj coverage',
+    command:
+        'dart run tool/testing/run_local_e2e.dart --scenario '
+        'chat-app-web-real-model-smoke --browser safari --model-url '
+        '<model-url> [--backend webgpu]',
+    useWhen:
+        'Safari support claims, WebGPU bridge pin or web model loading '
+        'changes. Run CPU and WebGPU separately and record the Safari version.',
+  ),
+  TestMatrixRow(
+    id: 'web-real-model-smoke-firefox',
+    tier: 'targeted',
+    mode: 'local-only, Firefox',
+    covers:
+        'built Flutter web chat app with a real GGUF in Firefox through '
+        'geckodriver (binary from FIREFOX_EXECUTABLE), served cross-origin '
+        'isolated (require-corp); plain chat, CPU Wasm or full WebGPU offload '
+        '(--backend webgpu); no tool, speech or mmproj coverage',
+    command:
+        'FIREFOX_EXECUTABLE=<firefox> dart run tool/testing/run_local_e2e.dart '
+        '--scenario chat-app-web-real-model-smoke --browser firefox '
+        '--model-url <model-url> [--backend webgpu]',
+    useWhen:
+        'Firefox support claims, WebGPU bridge pin or web model loading '
+        'changes. geckodriver must be on PATH or in GECKODRIVER.',
+  ),
   TestMatrixRow(
     id: 'web-tool-penalty-smoke',
     tier: 'targeted',