diff --git a/integration/test-runner/index.ts b/integration/test-runner/index.ts
index c6fe56365c..4544732442 100644
--- a/integration/test-runner/index.ts
+++ b/integration/test-runner/index.ts
@@ -1,11 +1,11 @@
-import { BrowserLauncher, TestRunnerCoreConfig } from '@web/test-runner-core';
-import { runBasicTest } from './tests/basic/runBasicTest.js';
-import { runConfigGroupsTest } from './tests/config-groups/runConfigGroupsTest.js';
-import { runParallelTest } from './tests/parallel/runParallelTest.js';
-import { runTestFailureTest } from './tests/test-failure/runTestFailureTest.js';
-import { runLocationChangeTest } from './tests/location-change/runLocationChangeTest.js';
-import { runFocusTest } from './tests/focus/runFocusTest.js';
-import { runManyTests } from './tests/many/runManyTests.js';
+import type { BrowserLauncher, TestRunnerCoreConfig } from '@web/test-runner-core';
+import { runBasicTest } from './tests/basic/runBasicTest.ts';
+import { runConfigGroupsTest } from './tests/config-groups/runConfigGroupsTest.ts';
+import { runParallelTest } from './tests/parallel/runParallelTest.ts';
+import { runTestFailureTest } from './tests/test-failure/runTestFailureTest.ts';
+import { runLocationChangeTest } from './tests/location-change/runLocationChangeTest.ts';
+import { runFocusTest } from './tests/focus/runFocusTest.ts';
+import { runManyTests } from './tests/many/runManyTests.ts';
 
 export interface Tests {
   basic: boolean;
diff --git a/integration/test-runner/package.json b/integration/test-runner/package.json
index 7d1dd86a9c..a7c7e0e26d 100644
--- a/integration/test-runner/package.json
+++ b/integration/test-runner/package.json
@@ -16,8 +16,9 @@
   "homepage": "https://github.com/modernweb-dev/web/tree/master/packages/test-runner-integration-tests",
   "main": "index.js",
   "scripts": {
-    "test": "mocha test/**/*.test.ts --require ts-node/register --reporter dot",
-    "test:watch": "mocha test/**/*.test.ts --require ts-node/register --watch --watch-files src,test --reporter dot"
+    "test": "node --experimental-strip-types --test --test-force-exit \"test/**/*.test.ts\"",
+    "test:node": "node --experimental-strip-types --test --test-force-exit \"test/**/*.test.ts\"",
+    "test:watch": "node --experimental-strip-types --test --test-force-exit --watch \"test/**/*.test.ts\""
   },
   "dependencies": {
     "@web/dev-server-legacy": "^2.1.0",
diff --git a/integration/test-runner/tests/basic/runBasicTest.ts b/integration/test-runner/tests/basic/runBasicTest.ts
index ce9d9c4b11..d50ca5c8fa 100644
--- a/integration/test-runner/tests/basic/runBasicTest.ts
+++ b/integration/test-runner/tests/basic/runBasicTest.ts
@@ -1,8 +1,9 @@
-import { BrowserLauncher, TestRunnerCoreConfig, TestSession } from '@web/test-runner-core';
+import assert from 'node:assert/strict';
+import { describe, before, it } from 'node:test';
+import type { BrowserLauncher, TestRunnerCoreConfig, TestSession } from '@web/test-runner-core';
 import { runTests } from '@web/test-runner-core/test-helpers';
 import { legacyPlugin } from '@web/dev-server-legacy';
 import { resolve } from 'path';
-import { expect } from 'chai';
 
 export function runBasicTest(
   config: Partial<TestRunnerCoreConfig> & { browsers: BrowserLauncher[] },
@@ -14,78 +15,93 @@ export function runBasicTest(
     before(async () => {
       const result = await runTests({
         ...config,
-        files: [...(config.files ?? []), resolve(__dirname, 'browser-tests', '*.test.js')],
+        files: [
+          ...(config.files ?? []),
+          resolve(import.meta.dirname, 'browser-tests', '*.test.js'),
+        ],
         plugins: [...(config.plugins ?? []), legacyPlugin()],
       });
       allSessions = result.sessions;
 
-      expect(allSessions.every(s => s.passed)).to.equal(true, 'All sessions should have passed');
+      assert.equal(
+        allSessions.every(s => s.passed),
+        true,
+        'All sessions should have passed',
+      );
     });
 
     it('passes basic test', () => {
       const sessions = allSessions.filter(s => s.testFile.endsWith('basic.test.js'));
-      expect(sessions.length === browserCount).to.equal(
-        true,
-        'Each browser should run basic.test.js',
-      );
+      assert.equal(sessions.length === browserCount, true, 'Each browser should run basic.test.js');
       for (const session of sessions) {
-        expect(session.testResults!.tests.length).to.equal(0);
-        expect(session.testResults!.suites.length).to.equal(1);
-        expect(session.testResults!.suites[0].tests.length).to.equal(1);
-        expect(session.testResults!.suites[0].tests.map(t => t.name)).to.eql(['works']);
+        assert.equal(session.testResults!.tests.length, 0);
+        assert.equal(session.testResults!.suites.length, 1);
+        assert.equal(session.testResults!.suites[0].tests.length, 1);
+        assert.deepEqual(
+          session.testResults!.suites[0].tests.map(t => t.name),
+          ['works'],
+        );
       }
     });
 
     it('passes js-syntax test', () => {
       const sessions = allSessions.filter(s => s.testFile.endsWith('js-syntax.test.js'));
-      expect(sessions.length === browserCount).to.equal(
+      assert.equal(
+        sessions.length === browserCount,
         true,
         'Each browser should run js-syntax.test.js',
       );
       for (const session of sessions) {
-        expect(session.testResults!.tests.map(t => t.name)).to.eql([
-          'supports object spread',
-          'supports async functions',
-          'supports exponentiation',
-          'supports classes',
-          'supports template literals',
-          'supports optional chaining',
-          'supports nullish coalescing',
-        ]);
+        assert.deepEqual(
+          session.testResults!.tests.map(t => t.name),
+          [
+            'supports object spread',
+            'supports async functions',
+            'supports exponentiation',
+            'supports classes',
+            'supports template literals',
+            'supports optional chaining',
+            'supports nullish coalescing',
+          ],
+        );
       }
     });
 
     it('passes module-features test', () => {
       const sessions = allSessions.filter(s => s.testFile.endsWith('module-features.test.js'));
-      expect(sessions.length === browserCount).to.equal(
+      assert.equal(
+        sessions.length === browserCount,
         true,
         'Each browser should run module-features.test.js',
       );
       for (const session of sessions) {
-        expect(session.testResults!.tests.map(t => t.name)).to.eql([
-          'supports static imports',
-          'supports dynamic imports',
-          'supports import meta',
-        ]);
+        assert.deepEqual(
+          session.testResults!.tests.map(t => t.name),
+          ['supports static imports', 'supports dynamic imports', 'supports import meta'],
+        );
       }
     });
 
     it('passes timers test', () => {
       const sessions = allSessions.filter(s => s.testFile.endsWith('timers.test.js'));
-      expect(sessions.length === browserCount).to.equal(
+      assert.equal(
+        sessions.length === browserCount,
         true,
         'Each browser should run timers.test.js',
       );
       for (const session of sessions) {
-        expect(session.testResults!.tests.length).to.equal(0);
-        expect(session.testResults!.suites.length).to.equal(1);
-        expect(session.testResults!.suites[0].tests.map(t => t.name)).to.eql([
-          'can call setTimeout',
-          'can cancel setTimeout',
-          'can call and cancel setInterval',
-          'can call requestAnimationFrame',
-          'can cancel requestAnimationFrame',
-        ]);
+        assert.equal(session.testResults!.tests.length, 0);
+        assert.equal(session.testResults!.suites.length, 1);
+        assert.deepEqual(
+          session.testResults!.suites[0].tests.map(t => t.name),
+          [
+            'can call setTimeout',
+            'can cancel setTimeout',
+            'can call and cancel setInterval',
+            'can call requestAnimationFrame',
+            'can cancel requestAnimationFrame',
+          ],
+        );
       }
     });
   });
diff --git a/integration/test-runner/tests/config-groups/runConfigGroupsTest.ts b/integration/test-runner/tests/config-groups/runConfigGroupsTest.ts
index 0e8b0aec1b..ddd1171bf7 100644
--- a/integration/test-runner/tests/config-groups/runConfigGroupsTest.ts
+++ b/integration/test-runner/tests/config-groups/runConfigGroupsTest.ts
@@ -1,4 +1,6 @@
-import {
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import type {
   BrowserLauncher,
   TestRunnerCoreConfig,
   TestRunnerGroupConfig,
@@ -6,7 +8,6 @@ import {
 import { runTests } from '@web/test-runner-core/test-helpers';
 import { legacyPlugin } from '@web/dev-server-legacy';
 import { resolve } from 'path';
-import { expect } from 'chai';
 
 export function runConfigGroupsTest(
   config: Partial<TestRunnerCoreConfig> & { browsers: BrowserLauncher[] },
@@ -18,13 +19,13 @@ export function runConfigGroupsTest(
           name: 'a',
           testRunnerHtml: path =>
             `<html><body><script>window.__group__ = "a";</script><script type="module" src=${path}></script></body></html>`,
-          files: [resolve(__dirname, 'browser-tests', 'test-runner-html-a.test.js')],
+          files: [resolve(import.meta.dirname, 'browser-tests', 'test-runner-html-a.test.js')],
         },
         {
           name: 'b',
           testRunnerHtml: path =>
             `<html><body><script>window.__group__ = "b";</script><script type="module" src=${path}></script></body></html>`,
-          files: [resolve(__dirname, 'browser-tests', 'test-runner-html-b.test.js')],
+          files: [resolve(import.meta.dirname, 'browser-tests', 'test-runner-html-b.test.js')],
         },
       ];
       const result = await runTests(
@@ -35,7 +36,8 @@ export function runConfigGroupsTest(
         groupConfigs,
       );
 
-      expect(result.sessions.every(s => s.passed)).to.equal(
+      assert.equal(
+        result.sessions.every(s => s.passed),
         true,
         'All sessions should have passed',
       );
diff --git a/integration/test-runner/tests/focus/runFocusTest.ts b/integration/test-runner/tests/focus/runFocusTest.ts
index f32b5247d4..e13bdaf54e 100644
--- a/integration/test-runner/tests/focus/runFocusTest.ts
+++ b/integration/test-runner/tests/focus/runFocusTest.ts
@@ -1,8 +1,9 @@
-import { BrowserLauncher, TestRunnerCoreConfig, TestSession } from '@web/test-runner-core';
+import assert from 'node:assert/strict';
+import { describe, before, it } from 'node:test';
+import type { BrowserLauncher, TestRunnerCoreConfig, TestSession } from '@web/test-runner-core';
 import { runTests } from '@web/test-runner-core/test-helpers';
 import { legacyPlugin } from '@web/dev-server-legacy';
 import { resolve } from 'path';
-import { expect } from 'chai';
 
 export function runFocusTest(
   config: Partial<TestRunnerCoreConfig> & { browsers: BrowserLauncher[] },
@@ -13,16 +14,22 @@ export function runFocusTest(
     before(async () => {
       const result = await runTests({
         ...config,
-        // 2 means some are executed concurrently, and some sequentially
         concurrency: 2,
-        files: [...(config.files ?? []), resolve(__dirname, 'browser-tests', '*.test.js')],
+        files: [
+          ...(config.files ?? []),
+          resolve(import.meta.dirname, 'browser-tests', '*.test.js'),
+        ],
         plugins: [...(config.plugins ?? []), legacyPlugin()],
       });
       allSessions = result.sessions;
     });
 
     it.skip('can run tests with focus, concurrently and sequentially', () => {
-      expect(allSessions.every(s => s.passed)).to.equal(true, 'All sessions should have passed');
+      assert.equal(
+        allSessions.every(s => s.passed),
+        true,
+        'All sessions should have passed',
+      );
     });
   });
 }
diff --git a/integration/test-runner/tests/location-change/runLocationChangeTest.ts b/integration/test-runner/tests/location-change/runLocationChangeTest.ts
index 820ffff69c..08bc8922e7 100644
--- a/integration/test-runner/tests/location-change/runLocationChangeTest.ts
+++ b/integration/test-runner/tests/location-change/runLocationChangeTest.ts
@@ -1,8 +1,9 @@
-import { BrowserLauncher, TestRunnerCoreConfig, TestSession } from '@web/test-runner-core';
+import assert from 'node:assert/strict';
+import { describe, before, it } from 'node:test';
+import type { BrowserLauncher, TestRunnerCoreConfig, TestSession } from '@web/test-runner-core';
 import { runTests } from '@web/test-runner-core/test-helpers';
 import { legacyPlugin } from '@web/dev-server-legacy';
 import { resolve } from 'path';
-import { expect } from 'chai';
 
 export function runLocationChangeTest(
   config: Partial<TestRunnerCoreConfig> & { browsers: BrowserLauncher[] },
@@ -15,7 +16,10 @@ export function runLocationChangeTest(
       const result = await runTests(
         {
           ...config,
-          files: [...(config.files ?? []), resolve(__dirname, 'browser-tests', '*.test.js')],
+          files: [
+            ...(config.files ?? []),
+            resolve(import.meta.dirname, 'browser-tests', '*.test.js'),
+          ],
           plugins: [...(config.plugins ?? []), legacyPlugin()],
         },
         undefined,
@@ -23,32 +27,40 @@ export function runLocationChangeTest(
       );
       allSessions = result.sessions;
 
-      expect(allSessions.every(s => s.passed)).to.equal(false, 'All sessions should have failed');
+      assert.equal(
+        allSessions.every(s => s.passed),
+        false,
+        'All sessions should have failed',
+      );
     });
 
     it('handles tests which assign to window.location.href', () => {
       const sessions = allSessions.filter(s => s.testFile.endsWith('fail-location-href.test.js'));
-      expect(sessions.length === browserCount).to.equal(true);
+      assert.equal(sessions.length === browserCount, true);
       for (const session of sessions) {
-        expect(session.testResults).to.equal(undefined);
-        expect(session.logs).to.eql([]);
-        expect(session.errors.length).to.equal(1);
-        expect(session.errors[0].message).to.include(
-          'Tests were interrupted because the page navigated to',
+        assert.equal(session.testResults, undefined);
+        assert.deepEqual(session.logs, []);
+        assert.equal(session.errors.length, 1);
+        assert.ok(
+          session.errors[0].message.includes(
+            'Tests were interrupted because the page navigated to',
+          ),
         );
-        expect(session.errors[0].message).to.include(
-          'This can happen when clicking a link, submitting a form or interacting with window.location.',
+        assert.ok(
+          session.errors[0].message.includes(
+            'This can happen when clicking a link, submitting a form or interacting with window.location.',
+          ),
         );
       }
     });
 
     it('handles tests which call window.location.reload()', () => {
       const sessions = allSessions.filter(s => s.testFile.endsWith('fail-location-reload.test.js'));
-      expect(sessions.length === browserCount).to.equal(true);
+      assert.equal(sessions.length === browserCount, true);
       for (const session of sessions) {
-        expect(session.testResults).to.equal(undefined);
-        expect(session.logs).to.eql([]);
-        expect(session.errors).to.eql([
+        assert.equal(session.testResults, undefined);
+        assert.deepEqual(session.logs, []);
+        assert.deepEqual(session.errors, [
           {
             message:
               'Tests were interrupted because the page was reloaded. This can happen when clicking a link, submitting a form or interacting with window.location.',
@@ -61,17 +73,21 @@ export function runLocationChangeTest(
       const sessions = allSessions.filter(s =>
         s.testFile.endsWith('fail-location-replace.test.js'),
       );
-      expect(sessions.length === browserCount).to.equal(true);
+      assert.equal(sessions.length === browserCount, true);
       for (const session of sessions) {
-        expect(session.testResults).to.equal(undefined);
-        expect(session.logs).to.eql([]);
-        expect(session.errors.length).to.equal(1);
-        expect(session.errors[0].message).to.include(
-          'Tests were interrupted because the page navigated to',
+        assert.equal(session.testResults, undefined);
+        assert.deepEqual(session.logs, []);
+        assert.equal(session.errors.length, 1);
+        assert.ok(
+          session.errors[0].message.includes(
+            'Tests were interrupted because the page navigated to',
+          ),
         );
-        expect(session.errors[0].message).to.include('/new-page/');
-        expect(session.errors[0].message).to.include(
-          'This can happen when clicking a link, submitting a form or interacting with window.location.',
+        assert.ok(session.errors[0].message.includes('/new-page/'));
+        assert.ok(
+          session.errors[0].message.includes(
+            'This can happen when clicking a link, submitting a form or interacting with window.location.',
+          ),
         );
       }
     });
diff --git a/integration/test-runner/tests/many/runManyTests.ts b/integration/test-runner/tests/many/runManyTests.ts
index 6ef326bc5c..526fbbfebd 100644
--- a/integration/test-runner/tests/many/runManyTests.ts
+++ b/integration/test-runner/tests/many/runManyTests.ts
@@ -1,4 +1,5 @@
-import { BrowserLauncher, TestRunnerCoreConfig } from '@web/test-runner-core';
+import { describe, it } from 'node:test';
+import type { BrowserLauncher, TestRunnerCoreConfig } from '@web/test-runner-core';
 import { runTests } from '@web/test-runner-core/test-helpers';
 import { legacyPlugin } from '@web/dev-server-legacy';
 import { resolve } from 'path';
@@ -11,7 +12,10 @@ export function runManyTests(
       await Promise.all([
         runTests({
           ...config,
-          files: [...(config.files ?? []), resolve(__dirname, 'browser-tests', '*.test.js')],
+          files: [
+            ...(config.files ?? []),
+            resolve(import.meta.dirname, 'browser-tests', '*.test.js'),
+          ],
           plugins: [...(config.plugins ?? []), legacyPlugin()],
         }),
       ]);
diff --git a/integration/test-runner/tests/parallel/runParallelTest.ts b/integration/test-runner/tests/parallel/runParallelTest.ts
index 244d8ad766..2858975d7f 100644
--- a/integration/test-runner/tests/parallel/runParallelTest.ts
+++ b/integration/test-runner/tests/parallel/runParallelTest.ts
@@ -1,4 +1,5 @@
-import { BrowserLauncher, TestRunnerCoreConfig } from '@web/test-runner-core';
+import { describe, it } from 'node:test';
+import type { BrowserLauncher, TestRunnerCoreConfig } from '@web/test-runner-core';
 import { runTests } from '@web/test-runner-core/test-helpers';
 import { legacyPlugin } from '@web/dev-server-legacy';
 import { resolve } from 'path';
@@ -14,13 +15,19 @@ export function runParallelTest(
       await Promise.all([
         runTests({
           ...configA,
-          files: [...(configA.files ?? []), resolve(__dirname, 'browser-tests', '*.test.js')],
+          files: [
+            ...(configA.files ?? []),
+            resolve(import.meta.dirname, 'browser-tests', '*.test.js'),
+          ],
           plugins: [...(configA.plugins ?? []), legacyPlugin()],
         }),
 
         runTests({
           ...configB,
-          files: [...(configB.files ?? []), resolve(__dirname, 'browser-tests', '*.test.js')],
+          files: [
+            ...(configB.files ?? []),
+            resolve(import.meta.dirname, 'browser-tests', '*.test.js'),
+          ],
           plugins: [...(configB.plugins ?? []), legacyPlugin()],
         }),
       ]);
diff --git a/integration/test-runner/tests/test-failure/runTestFailureTest.ts b/integration/test-runner/tests/test-failure/runTestFailureTest.ts
index 85be1a0c24..223f9d97a7 100644
--- a/integration/test-runner/tests/test-failure/runTestFailureTest.ts
+++ b/integration/test-runner/tests/test-failure/runTestFailureTest.ts
@@ -1,8 +1,9 @@
-import { BrowserLauncher, TestRunnerCoreConfig, TestSession } from '@web/test-runner-core';
+import assert from 'node:assert/strict';
+import { describe, before, it } from 'node:test';
+import type { BrowserLauncher, TestRunnerCoreConfig, TestSession } from '@web/test-runner-core';
 import { runTests } from '@web/test-runner-core/test-helpers';
 import { legacyPlugin } from '@web/dev-server-legacy';
 import { resolve, sep } from 'path';
-import { expect } from 'chai';
 
 const ERROR_NOT_IMPORTABLE = {
   message:
@@ -34,7 +35,10 @@ export function runTestFailureTest(
       const result = await runTests(
         {
           ...config,
-          files: [...(config.files ?? []), resolve(__dirname, 'browser-tests', '*.test.js')],
+          files: [
+            ...(config.files ?? []),
+            resolve(import.meta.dirname, 'browser-tests', '*.test.js'),
+          ],
           plugins: [...(config.plugins ?? []), legacyPlugin()],
         },
         undefined,
@@ -42,31 +46,39 @@ export function runTestFailureTest(
       );
       allSessions = result.sessions;
 
-      expect(allSessions.every(s => s.passed)).to.equal(false, 'All sessions should have failed');
+      assert.equal(
+        allSessions.every(s => s.passed),
+        false,
+        'All sessions should have failed',
+      );
     });
 
     it('handles tests with 404 imports', () => {
       const sessions = allSessions.filter(s => s.testFile.endsWith('fail-404-import.test.js'));
-      expect(sessions.length === browserCount).to.equal(true);
+      assert.equal(sessions.length === browserCount, true);
       for (const session of sessions) {
-        expect(session.testResults!.suites.length).to.equal(0);
-        expect(session.testResults!.tests.length).to.equal(0);
-        expect(session.request404s).to.eql([
+        assert.equal(session.testResults!.suites.length, 0);
+        assert.equal(session.testResults!.tests.length, 0);
+        assert.deepEqual(session.request404s, [
           'integration/test-runner/tests/test-failure/browser-tests/non-existing.js',
         ]);
-        expect(session.errors).to.eql([ERROR_NOT_IMPORTABLE]);
-        expect(session.logs.length).to.equal(1);
+        assert.deepEqual(session.errors, [ERROR_NOT_IMPORTABLE]);
+        assert.equal(session.logs.length, 1);
         expectFetchModuleFailed((session.logs[0] as any)[0]);
       }
     });
 
     it('handles tests that error with a circular reference', () => {
       const sessions = allSessions.filter(s => s.testFile.endsWith('fail-circular-error.test.js'));
-      expect(sessions.length === browserCount).to.equal(true);
+      assert.equal(sessions.length === browserCount, true);
       for (const session of sessions) {
-        expect(session.testResults!.tests.map(t => t.name)).to.eql(['bad predicate']);
-        expect(session.passed).to.be.false;
-        expect(session.testResults!.tests![0].error!.message).to.equal(
+        assert.deepEqual(
+          session.testResults!.tests.map(t => t.name),
+          ['bad predicate'],
+        );
+        assert.equal(session.passed, false);
+        assert.equal(
+          session.testResults!.tests![0].error!.message,
           "expected { x: 'x', circle: [Circular] } to equal null",
         );
       }
@@ -74,86 +86,96 @@ export function runTestFailureTest(
 
     it('handles tests that throw in afterEach', () => {
       const sessions = allSessions.filter(s => s.testFile.endsWith('fail-after-each.test.js'));
-      expect(sessions.length === browserCount).to.equal(true);
+      assert.equal(sessions.length === browserCount, true);
       for (const session of sessions) {
-        expect(session.testResults!.tests.map(t => t.name)).to.eql([
-          'true is true',
-          'true is really true',
-        ]);
-        expect(session.errors.length).to.equal(1);
-        expect(session.errors[0].message).to.include('error thrown in afterEach hook');
-        expect(session.errors[0].stack).to.include(
-          `test-failure${sep}browser-tests${sep}fail-after-each.test.js`,
+        assert.deepEqual(
+          session.testResults!.tests.map(t => t.name),
+          ['true is true', 'true is really true'],
+        );
+        assert.equal(session.errors.length, 1);
+        assert.ok(session.errors[0].message.includes('error thrown in afterEach hook'));
+        assert.ok(
+          session.errors[0].stack!.includes(
+            `test-failure${sep}browser-tests${sep}fail-after-each.test.js`,
+          ),
         );
-        expect(session.logs).to.eql([]);
+        assert.deepEqual(session.logs, []);
       }
     });
 
     it('handles tests that throw in after', () => {
       const sessions = allSessions.filter(s => s.testFile.endsWith('fail-after.test.js'));
-      expect(sessions.length === browserCount).to.equal(true);
+      assert.equal(sessions.length === browserCount, true);
       for (const session of sessions) {
-        expect(session.testResults!.tests.map(t => t.name)).to.eql([
-          'true is true',
-          'true is really true',
-        ]);
-        expect(session.errors.length).to.equal(1);
-        expect(session.errors[0].message).to.include('error thrown in after hook');
-
-        expect(session.errors[0].stack).to.include(
-          `test-failure${sep}browser-tests${sep}fail-after.test.js`,
+        assert.deepEqual(
+          session.testResults!.tests.map(t => t.name),
+          ['true is true', 'true is really true'],
         );
-        expect(session.logs).to.eql([]);
+        assert.equal(session.errors.length, 1);
+        assert.ok(session.errors[0].message.includes('error thrown in after hook'));
+        assert.ok(
+          session.errors[0].stack!.includes(
+            `test-failure${sep}browser-tests${sep}fail-after.test.js`,
+          ),
+        );
+        assert.deepEqual(session.logs, []);
       }
     });
 
     it('handles tests that throw in beforeEach', () => {
       const sessions = allSessions.filter(s => s.testFile.endsWith('fail-before-each.test.js'));
-      expect(sessions.length === browserCount).to.equal(true);
+      assert.equal(sessions.length === browserCount, true);
       for (const session of sessions) {
-        expect(session.testResults!.tests.map(t => t.name)).to.eql([
-          'true is true',
-          'true is really true',
-        ]);
-        expect(session.errors.length).to.equal(1);
-        expect(session.errors[0].message).to.include('error thrown in beforeEach hook');
-
-        expect(session.errors[0].stack).to.include(
-          `test-failure${sep}browser-tests${sep}fail-before-each.test.js`,
+        assert.deepEqual(
+          session.testResults!.tests.map(t => t.name),
+          ['true is true', 'true is really true'],
+        );
+        assert.equal(session.errors.length, 1);
+        assert.ok(session.errors[0].message.includes('error thrown in beforeEach hook'));
+        assert.ok(
+          session.errors[0].stack!.includes(
+            `test-failure${sep}browser-tests${sep}fail-before-each.test.js`,
+          ),
         );
-        expect(session.logs).to.eql([]);
+        assert.deepEqual(session.logs, []);
       }
     });
 
     it('handles tests that throw in before', () => {
       const sessions = allSessions.filter(s => s.testFile.endsWith('fail-before.test.js'));
-      expect(sessions.length === browserCount).to.equal(true);
+      assert.equal(sessions.length === browserCount, true);
       for (const session of sessions) {
-        expect(session.testResults!.tests.map(t => t.name)).to.eql([
-          'true is true',
-          'true is really true',
-        ]);
-        expect(session.errors.length).to.equal(1);
-        expect(session.errors[0].message).to.include('error thrown in before hook');
-
-        expect(session.errors[0].stack).to.include(
-          `test-failure${sep}browser-tests${sep}fail-before.test.js`,
+        assert.deepEqual(
+          session.testResults!.tests.map(t => t.name),
+          ['true is true', 'true is really true'],
         );
-        expect(session.logs).to.eql([]);
+        assert.equal(session.errors.length, 1);
+        assert.ok(session.errors[0].message.includes('error thrown in before hook'));
+        assert.ok(
+          session.errors[0].stack!.includes(
+            `test-failure${sep}browser-tests${sep}fail-before.test.js`,
+          ),
+        );
+        assert.deepEqual(session.logs, []);
       }
     });
 
     it('handles a custom thrown error', () => {
       const sessions = allSessions.filter(s => s.testFile.endsWith('fail-custom-error.test.js'));
-      expect(sessions.length === browserCount).to.equal(true);
+      assert.equal(sessions.length === browserCount, true);
       for (const session of sessions) {
-        expect(session.testResults!.tests.map(t => t.name)).to.eql(['custom error']);
-        expect(session.testResults!.tests[0].error!.message).to.include('a custom error thrown');
-        expect(session.testResults!.tests[0].error!.stack).to.include(
-          `browser-tests${sep}fail-custom-error.test.js`,
+        assert.deepEqual(
+          session.testResults!.tests.map(t => t.name),
+          ['custom error'],
+        );
+        assert.ok(session.testResults!.tests[0].error!.message.includes('a custom error thrown'));
+        assert.ok(
+          session.testResults!.tests[0].error!.stack!.includes(
+            `browser-tests${sep}fail-custom-error.test.js`,
+          ),
         );
-        expect(session.errors).to.eql([]);
-        expect(session.logs).to.eql([]);
+        assert.deepEqual(session.errors, []);
+        assert.deepEqual(session.logs, []);
       }
     });
 
@@ -161,61 +183,65 @@ export function runTestFailureTest(
       const sessions = allSessions.filter(s =>
         s.testFile.endsWith('fail-error-module-exec.test.js'),
       );
-      expect(sessions.length === browserCount).to.equal(true);
+      assert.equal(sessions.length === browserCount, true);
       for (const session of sessions) {
-        expect(session.testResults!.suites.length).to.equal(0);
-        expect(session.testResults!.tests.length).to.equal(0);
-        expect(session.errors).to.eql([ERROR_NOT_IMPORTABLE]);
-        expect(session.logs[0][0]).to.include('This is thrown before running tests');
+        assert.equal(session.testResults!.suites.length, 0);
+        assert.equal(session.testResults!.tests.length, 0);
+        assert.deepEqual(session.errors, [ERROR_NOT_IMPORTABLE]);
+        assert.ok((session.logs[0][0] as any).includes('This is thrown before running tests'));
       }
     });
 
     it('handles error stack traces correctly', () => {
       const sessions = allSessions.filter(s => s.testFile.endsWith('fail-stack-trace.test.js'));
-      expect(sessions.length === browserCount).to.equal(true);
+      assert.equal(sessions.length === browserCount, true);
       for (const session of sessions) {
-        expect(session.testResults!.tests.length).to.equal(1);
-        expect(session.testResults!.tests[0]!.error!.message).to.include('My error');
-        expect(session.testResults!.tests[0]!.error!.stack).to.include('throwErrorC');
-        expect(session.testResults!.tests[0]!.error!.stack).to.include('fail-stack-trace-c.js');
-        expect(session.errors).to.eql([]);
-        expect(session.logs).to.eql([]);
+        assert.equal(session.testResults!.tests.length, 1);
+        assert.ok(session.testResults!.tests[0]!.error!.message.includes('My error'));
+        assert.ok(session.testResults!.tests[0]!.error!.stack!.includes('throwErrorC'));
+        assert.ok(session.testResults!.tests[0]!.error!.stack!.includes('fail-stack-trace-c.js'));
+        assert.deepEqual(session.errors, []);
+        assert.deepEqual(session.logs, []);
       }
     });
 
     it('handles string diffs correctly', () => {
       const sessions = allSessions.filter(s => s.testFile.endsWith('fail-string-diff.test.js'));
-      expect(sessions.length === browserCount).to.equal(true);
+      assert.equal(sessions.length === browserCount, true);
       for (const session of sessions) {
-        expect(session.testResults!.tests[0]!.name).to.equal('string diff');
-        expect(session.testResults!.tests[0]!.error!.message).to.include(
-          "expected 'foo' to equal 'bar'",
+        assert.equal(session.testResults!.tests[0]!.name, 'string diff');
+        assert.ok(
+          session.testResults!.tests[0]!.error!.message.includes("expected 'foo' to equal 'bar'"),
         );
-        expect(session.testResults!.tests[0]!.error!.expected).to.equal('bar');
-        expect(session.testResults!.tests[0]!.error!.actual).to.equal('foo');
-        expect(session.testResults!.tests.length).to.equal(1);
-        expect(session.errors).to.eql([]);
-        expect(session.logs).to.eql([]);
+        assert.equal(session.testResults!.tests[0]!.error!.expected, 'bar');
+        assert.equal(session.testResults!.tests[0]!.error!.actual, 'foo');
+        assert.equal(session.testResults!.tests.length, 1);
+        assert.deepEqual(session.errors, []);
+        assert.deepEqual(session.logs, []);
       }
     });
 
     it('handles syntax errors', () => {
       const sessions = allSessions.filter(s => s.testFile.endsWith('fail-syntax-error.test.js'));
-      expect(sessions.length === browserCount).to.equal(true);
+      assert.equal(sessions.length === browserCount, true);
       for (const session of sessions) {
-        expect(session.testResults!.suites.length).to.eql(0);
-        expect(session.testResults!.tests.length).to.eql(0);
-        expect(session.errors).to.eql([ERROR_NOT_IMPORTABLE]);
+        assert.equal(session.testResults!.suites.length, 0);
+        assert.equal(session.testResults!.tests.length, 0);
+        assert.deepEqual(session.errors, [ERROR_NOT_IMPORTABLE]);
       }
     });
 
     it('handles tests that error with a readonly actual', () => {
       const sessions = allSessions.filter(s => s.testFile.endsWith('fail-readonly-actual.test.js'));
-      expect(sessions.length === browserCount).to.equal(true);
+      assert.equal(sessions.length === browserCount, true);
       for (const session of sessions) {
-        expect(session.testResults!.tests.map(t => t.name)).to.eql(['readonly actual']);
-        expect(session.passed).to.be.false;
-        expect(session.testResults!.tests![0].error!.message).to.equal(
+        assert.deepEqual(
+          session.testResults!.tests.map(t => t.name),
+          ['readonly actual'],
+        );
+        assert.equal(session.passed, false);
+        assert.equal(
+          session.testResults!.tests![0].error!.message,
           'expected { x: {} } to equal null',
         );
       }
diff --git a/packages/test-runner-chrome/package.json b/packages/test-runner-chrome/package.json
index 4dc77f206b..579497fafd 100644
--- a/packages/test-runner-chrome/package.json
+++ b/packages/test-runner-chrome/package.json
@@ -26,8 +26,8 @@
   },
   "scripts": {
     "build": "tsc",
-    "test:node": "mocha test/**/*.test.ts --require ts-node/register --reporter dot",
-    "test:watch": "mocha test/**/*.test.ts --require ts-node/register --watch --watch-files src,test"
+    "test:node": "node --experimental-strip-types --test --test-force-exit \"test/**/*.test.ts\"",
+    "test:watch": "node --experimental-strip-types --test --test-force-exit --watch \"test/**/*.test.ts\""
   },
   "files": [
     "*.d.ts",
diff --git a/packages/test-runner-chrome/test/chromeLauncher.test.ts b/packages/test-runner-chrome/test/chromeLauncher.test.ts
index 7e129d103a..e714740e9f 100644
--- a/packages/test-runner-chrome/test/chromeLauncher.test.ts
+++ b/packages/test-runner-chrome/test/chromeLauncher.test.ts
@@ -1,9 +1,8 @@
-import { runIntegrationTests } from '../../../integration/test-runner/index.js';
-import { chromeLauncher } from '../src/index.js';
-
-describe('test-runner-chrome', function testRunnerChrome() {
-  this.timeout(20000);
+import { describe } from 'node:test';
+import { runIntegrationTests } from '../../../integration/test-runner/index.ts';
+import { chromeLauncher } from '../dist/index.js';
 
+describe('test-runner-chrome', { timeout: 20000 }, () => {
   function createConfig() {
     return {
       browsers: [chromeLauncher()],
diff --git a/packages/test-runner-playwright/package.json b/packages/test-runner-playwright/package.json
index d7429b9287..18666409f0 100644
--- a/packages/test-runner-playwright/package.json
+++ b/packages/test-runner-playwright/package.json
@@ -26,8 +26,8 @@
   },
   "scripts": {
     "build": "tsc",
-    "test:node": "mocha test/**/*.test.ts --require ts-node/register --reporter dot",
-    "test:watch": "mocha test/**/*.test.ts --require ts-node/register --watch --watch-files src,test"
+    "test:node": "node --experimental-strip-types --test --test-force-exit \"test/**/*.test.ts\"",
+    "test:watch": "node --experimental-strip-types --test --test-force-exit --watch \"test/**/*.test.ts\""
   },
   "files": [
     "*.d.ts",
diff --git a/packages/test-runner-playwright/test/playwrightLauncher.test.ts b/packages/test-runner-playwright/test/playwrightLauncher.test.ts
index 37eceac5c1..39904c2b0d 100644
--- a/packages/test-runner-playwright/test/playwrightLauncher.test.ts
+++ b/packages/test-runner-playwright/test/playwrightLauncher.test.ts
@@ -1,10 +1,9 @@
 import os from 'os';
-import { runIntegrationTests } from '../../../integration/test-runner/index.js';
-import { playwrightLauncher } from '../src/index.js';
-
-describe('test-runner-playwright chromium', function testRunnerPlaywright() {
-  this.timeout(100000);
+import { describe } from 'node:test';
+import { runIntegrationTests } from '../../../integration/test-runner/index.ts';
+import { playwrightLauncher } from '../dist/index.js';
 
+describe('test-runner-playwright chromium', { timeout: 100000 }, () => {
   function createConfig() {
     return { browsers: [playwrightLauncher({ product: 'chromium' })] };
   }
@@ -20,9 +19,7 @@ describe('test-runner-playwright chromium', function testRunnerPlaywright() {
   });
 });
 
-describe('test-runner-playwright webkit', function testRunnerPlaywright() {
-  this.timeout(100000);
-
+describe('test-runner-playwright webkit', { timeout: 100000 }, () => {
   function createConfig() {
     return { browsers: [playwrightLauncher({ product: 'webkit' })] };
   }
@@ -38,11 +35,8 @@ describe('test-runner-playwright webkit', function testRunnerPlaywright() {
   });
 });
 
-// we don't run all tests in the windows CI
 if (os.platform() !== 'win32') {
-  describe('test-runner-playwright firefox', function testRunnerPlaywright() {
-    this.timeout(100000);
-
+  describe('test-runner-playwright firefox', { timeout: 100000 }, () => {
     function createConfig() {
       return { browsers: [playwrightLauncher({ product: 'firefox' })] };
     }
@@ -59,9 +53,7 @@ if (os.platform() !== 'win32') {
     });
   });
 
-  describe('test-runner-playwright all', function testRunnerPlaywright() {
-    this.timeout(100000);
-
+  describe('test-runner-playwright all', { timeout: 100000 }, () => {
     function createConfig() {
       return {
         browsers: [
diff --git a/packages/test-runner-puppeteer/package.json b/packages/test-runner-puppeteer/package.json
index 088d0262b2..373aae8121 100644
--- a/packages/test-runner-puppeteer/package.json
+++ b/packages/test-runner-puppeteer/package.json
@@ -26,8 +26,8 @@
   },
   "scripts": {
     "build": "tsc",
-    "test:node": "mocha test/**/*.test.ts --require ts-node/register --reporter dot",
-    "test:watch": "mocha test/**/*.test.ts --require ts-node/register --watch --watch-files src,test"
+    "test:node": "node --experimental-strip-types --test --test-force-exit \"test/**/*.test.ts\"",
+    "test:watch": "node --experimental-strip-types --test --test-force-exit --watch \"test/**/*.test.ts\""
   },
   "files": [
     "*.d.ts",
diff --git a/packages/test-runner-puppeteer/test/puppeteerLauncher.test.ts b/packages/test-runner-puppeteer/test/puppeteerLauncher.test.ts
index 718410a81a..f418554f41 100644
--- a/packages/test-runner-puppeteer/test/puppeteerLauncher.test.ts
+++ b/packages/test-runner-puppeteer/test/puppeteerLauncher.test.ts
@@ -1,9 +1,8 @@
-import { runIntegrationTests } from '../../../integration/test-runner/index.js';
-import { puppeteerLauncher } from '../src/index.js';
-
-describe('test-runner-puppeteer', function testRunnerPuppeteer() {
-  this.timeout(20000);
+import { describe } from 'node:test';
+import { runIntegrationTests } from '../../../integration/test-runner/index.ts';
+import { puppeteerLauncher } from '../dist/index.js';
 
+describe('test-runner-puppeteer', { timeout: 20000 }, () => {
   function createConfig() {
     return {
       browsers: [puppeteerLauncher()],