@react-native-harness/platform-android 1.1.0 → 1.2.0

package/src/__tests__/instance.test.ts

@@ -3,9 +3,6 @@ import {
   DEFAULT_METRO_PORT,
   type Config as HarnessConfig,
 } from '@react-native-harness/config';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
 import {
   getAndroidEmulatorPlatformInstance,
   getAndroidPhysicalDevicePlatformInstance,
@@ -27,9 +24,13 @@ const init = {
 };
 
 describe('Android platform instance', () => {
-  beforeEach(() => {
+  beforeEach(async () => {
     vi.restoreAllMocks();
     vi.unstubAllEnvs();
+    vi.spyOn(
+      await import('../environment.js'),
+      'ensureAndroidEmulatorAvailable',
+    ).mockResolvedValue('/tmp/android-sdk');
   });
 
   it('reuses a running emulator and does not shut it down on dispose', async () => {
@@ -191,6 +192,10 @@ describe('Android platform instance', () => {
 
   it('reuses a compatible cached AVD snapshot when caching is enabled', async () => {
     vi.stubEnv('HARNESS_AVD_CACHING', 'true');
+    vi.spyOn(
+      await import('../environment.js'),
+      'getHostAndroidSystemImageArch',
+    ).mockReturnValue('arm64-v8a');
     vi.spyOn(
       await import('../environment.js'),
       'ensureAndroidEmulatorEnvironment',
@@ -382,53 +387,6 @@ describe('Android platform instance', () => {
     );
   });
 
-  it('installs the app from HARNESS_APP_PATH when missing', async () => {
-    const appPath = path.join(os.tmpdir(), 'HarnessPlayground.apk');
-    fs.writeFileSync(appPath, 'apk');
-    vi.stubEnv('HARNESS_APP_PATH', appPath);
-    vi.spyOn(
-      await import('../environment.js'),
-      'ensureAndroidEmulatorEnvironment',
-    ).mockResolvedValue('/tmp/android-sdk');
-    vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['emulator-5554']);
-    vi.spyOn(adb, 'getEmulatorName').mockResolvedValue('Pixel_8_API_35');
-    vi.spyOn(adb, 'waitForBoot').mockResolvedValue('emulator-5554');
-    vi.spyOn(adb, 'isAppInstalled').mockResolvedValue(false);
-    const installApp = vi.spyOn(adb, 'installApp').mockResolvedValue(undefined);
-    vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
-    vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
-    vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
-    vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(
-      undefined,
-    );
-
-    await expect(
-      getAndroidEmulatorPlatformInstance(
-        {
-          name: 'android',
-          device: {
-            type: 'emulator',
-            name: 'Pixel_8_API_35',
-            avd: {
-              apiLevel: 35,
-              profile: 'pixel_8',
-              diskSize: '1G',
-              heapSize: '1G',
-            },
-          },
-          bundleId: 'com.harnessplayground',
-          activityName: '.MainActivity',
-        },
-        harnessConfig,
-        init,
-      ),
-    ).resolves.toBeDefined();
-
-    expect(installApp).toHaveBeenCalledWith('emulator-5554', appPath);
-
-    fs.rmSync(appPath, { force: true });
-  });
-
   it('throws a HarnessAppPathError when HARNESS_APP_PATH is missing', async () => {
     vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['emulator-5554']);
     vi.spyOn(adb, 'getEmulatorName').mockResolvedValue('Pixel_8_API_35');
@@ -607,4 +565,138 @@ describe('Android platform instance', () => {
     expect(appMonitor.addListener(listener)).toBeUndefined();
     expect(appMonitor.removeListener(listener)).toBeUndefined();
   });
+
+  it('grants permissions when permissions are enabled for emulator', async () => {
+    vi.spyOn(
+      await import('../environment.js'),
+      'ensureAndroidEmulatorEnvironment',
+    ).mockResolvedValue('/tmp/android-sdk');
+    vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['emulator-5554']);
+    vi.spyOn(adb, 'getEmulatorName').mockResolvedValue('Pixel_8_API_35');
+    vi.spyOn(adb, 'waitForBoot').mockResolvedValue('emulator-5554');
+    vi.spyOn(adb, 'isAppInstalled').mockResolvedValue(true);
+    vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
+    vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(
+      undefined,
+    );
+    const grantPermissions = vi
+      .spyOn(adb, 'grantPermissions')
+      .mockResolvedValue(undefined);
+
+    const harnessConfigWithPermissions = {
+      ...harnessConfig,
+      permissions: true,
+    } as HarnessConfig;
+
+    await getAndroidEmulatorPlatformInstance(
+      {
+        name: 'android',
+        device: {
+          type: 'emulator',
+          name: 'Pixel_8_API_35',
+          avd: {
+            apiLevel: 35,
+            profile: 'pixel_8',
+            diskSize: '1G',
+            heapSize: '1G',
+          },
+        },
+        bundleId: 'com.harnessplayground',
+        activityName: '.MainActivity',
+      },
+      harnessConfigWithPermissions,
+      init,
+    );
+
+    expect(grantPermissions).toHaveBeenCalledWith(
+      'emulator-5554',
+      'com.harnessplayground',
+    );
+  });
+
+  it('does not grant permissions when permissions are disabled for emulator', async () => {
+    vi.spyOn(
+      await import('../environment.js'),
+      'ensureAndroidEmulatorEnvironment',
+    ).mockResolvedValue('/tmp/android-sdk');
+    vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['emulator-5554']);
+    vi.spyOn(adb, 'getEmulatorName').mockResolvedValue('Pixel_8_API_35');
+    vi.spyOn(adb, 'waitForBoot').mockResolvedValue('emulator-5554');
+    vi.spyOn(adb, 'isAppInstalled').mockResolvedValue(true);
+    vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
+    vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(
+      undefined,
+    );
+    const grantPermissions = vi
+      .spyOn(adb, 'grantPermissions')
+      .mockResolvedValue(undefined);
+
+    await getAndroidEmulatorPlatformInstance(
+      {
+        name: 'android',
+        device: {
+          type: 'emulator',
+          name: 'Pixel_8_API_35',
+          avd: {
+            apiLevel: 35,
+            profile: 'pixel_8',
+            diskSize: '1G',
+            heapSize: '1G',
+          },
+        },
+        bundleId: 'com.harnessplayground',
+        activityName: '.MainActivity',
+      },
+      harnessConfig,
+      init,
+    );
+
+    expect(grantPermissions).not.toHaveBeenCalled();
+  });
+
+  it('grants permissions when permissions are enabled for physical device', async () => {
+    vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['012345']);
+    vi.spyOn(adb, 'getDeviceInfo').mockResolvedValue({
+      manufacturer: 'motorola',
+      model: 'moto g72',
+    });
+    vi.spyOn(adb, 'isAppInstalled').mockResolvedValue(true);
+    vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
+    vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(
+      undefined,
+    );
+    const grantPermissions = vi
+      .spyOn(adb, 'grantPermissions')
+      .mockResolvedValue(undefined);
+
+    const harnessConfigWithPermissions = {
+      ...harnessConfig,
+      permissions: true,
+    } as HarnessConfig;
+
+    await getAndroidPhysicalDevicePlatformInstance(
+      {
+        name: 'android-device',
+        device: {
+          type: 'physical',
+          manufacturer: 'motorola',
+          model: 'moto g72',
+        },
+        bundleId: 'com.harnessplayground',
+        activityName: '.MainActivity',
+      },
+      harnessConfigWithPermissions,
+    );
+
+    expect(grantPermissions).toHaveBeenCalledWith(
+      '012345',
+      'com.harnessplayground',
+    );
+  });
 });

package/src/adb-errors.ts

@@ -0,0 +1,47 @@
+export class AdbError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'AdbError';
+  }
+}
+
+export class AdbDeviceNotFoundError extends AdbError {
+  constructor(adbId: string) {
+    super(
+      `Android device "${adbId}" not found or not connected. ` +
+      `Run "adb devices" to see available devices.`
+    );
+    this.name = 'AdbDeviceNotFoundError';
+  }
+}
+
+export class AdbAppNotInstalledError extends AdbError {
+  constructor(bundleId: string, adbId: string) {
+    super(
+      `App "${bundleId}" is not installed on device "${adbId}". ` +
+      `Install the app before running tests.`
+    );
+    this.name = 'AdbAppNotInstalledError';
+  }
+}
+
+export class AdbPermissionGrantError extends AdbError {
+  constructor(bundleId: string, permissions: string[], adbId: string) {
+    const permissionList = permissions.join(', ');
+    super(
+      `Failed to grant permissions [${permissionList}] to "${bundleId}" on device "${adbId}". ` +
+      `Verify the app is installed and the device supports these permissions.`
+    );
+    this.name = 'AdbPermissionGrantError';
+  }
+}
+
+export class AdbBinaryNotFoundError extends AdbError {
+  constructor() {
+    super(
+      `adb binary not found or not accessible. ` +
+      `Ensure Android SDK is properly installed and ANDROID_HOME is set.`
+    );
+    this.name = 'AdbBinaryNotFoundError';
+  }
+}

package/src/adb-id.ts

@@ -16,6 +16,10 @@ export const getAdbId = async (
 
   for (const adbId of adbIds) {
     if (isAndroidDeviceEmulator(device)) {
+      if (!isAdbIdEmulator(adbId)) {
+        continue;
+      }
+
       const emulatorName = await adb.getEmulatorName(adbId);
 
       if (emulatorName === device.name) {

package/src/adb.ts

@@ -1,5 +1,10 @@
 import { type AndroidAppLaunchOptions } from '@react-native-harness/platforms';
-import { spawn, SubprocessError } from '@react-native-harness/tools';
+import {
+  logger,
+  spawn,
+  SubprocessError,
+  type Subprocess,
+} from '@react-native-harness/tools';
 import { spawn as nodeSpawn } from 'node:child_process';
 import type { ChildProcessByStdio } from 'node:child_process';
 import { access, rm } from 'node:fs/promises';
@@ -23,6 +28,10 @@ import {
   getEmulatorStartupArgs,
   type EmulatorBootMode,
 } from './emulator-startup.js';
+import {
+  AdbAppNotInstalledError,
+  AdbPermissionGrantError,
+} from './adb-errors.js';
 
 const wait = async (ms: number): Promise<void> => {
   await new Promise((resolve) => {
@@ -59,6 +68,7 @@ const waitWithSignal = async (
 
 const EMULATOR_STARTUP_OBSERVATION_TIMEOUT_MS = 5000;
 const EMULATOR_OUTPUT_BUFFER_LIMIT = 16 * 1024;
+const androidAdbLogger = logger.child('android-adb');
 
 export const emulatorProcess = {
   startDetachedProcess: (
@@ -374,6 +384,79 @@ export const getDeviceInfo = async (
   return { manufacturer, model };
 };
 
+const getRequestedPermissions = async (
+  adbId: string,
+  bundleId: string,
+): Promise<string[]> => {
+  const { stdout } = await spawn(getAdbBinaryPath(), [
+    '-s',
+    adbId,
+    'shell',
+    'dumpsys',
+    'package',
+    bundleId,
+  ]);
+
+  const requestedPermissions = new Set<string>();
+  const lines = stdout.split('\n');
+  let inRequestedPermissionsSection = false;
+
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+
+    if (trimmedLine === 'requested permissions:') {
+      inRequestedPermissionsSection = true;
+      continue;
+    }
+
+    if (!inRequestedPermissionsSection) {
+      continue;
+    }
+
+    if (trimmedLine === '') {
+      continue;
+    }
+
+    if (trimmedLine.endsWith(':')) {
+      break;
+    }
+
+    if (/^[a-zA-Z0-9_.]+$/.test(trimmedLine)) {
+      requestedPermissions.add(trimmedLine);
+      continue;
+    }
+
+    break;
+  }
+
+  return [...requestedPermissions];
+};
+
+const getDangerousPermissions = async (adbId: string): Promise<Set<string>> => {
+  const { stdout } = await spawn(getAdbBinaryPath(), [
+    '-s',
+    adbId,
+    'shell',
+    'pm',
+    'list',
+    'permissions',
+    '-g',
+    '-d',
+  ]);
+
+  const dangerousPermissions = new Set<string>();
+
+  for (const match of stdout.matchAll(/permission:([a-zA-Z0-9_.]+)/g)) {
+    const permission = match[1]?.trim();
+
+    if (permission) {
+      dangerousPermissions.add(permission);
+    }
+  }
+
+  return dangerousPermissions;
+};
+
 export const isBootCompleted = async (adbId: string): Promise<boolean> => {
   try {
     const bootCompleted = await getShellProperty(adbId, 'sys.boot_completed');
@@ -398,6 +481,13 @@ export const installApp = async (
   await spawn(getAdbBinaryPath(), ['-s', adbId, 'install', '-r', appPath]);
 };
 
+export const uninstallApp = async (
+  adbId: string,
+  bundleId: string,
+): Promise<void> => {
+  await spawn(getAdbBinaryPath(), ['-s', adbId, 'uninstall', bundleId]);
+};
+
 export const hasAvd = async (name: string): Promise<boolean> => {
   const avds = await getAvds();
   return avds.includes(name);
@@ -680,6 +770,15 @@ export const getLogcatTimestamp = async (adbId: string): Promise<string> => {
   return stdout.trim().replace(/^'+|'+$/g, '');
 };
 
+export const startLogcat = (
+  adbId: string,
+  args: readonly string[],
+): Subprocess =>
+  spawn(getAdbBinaryPath(), ['-s', adbId, ...args], {
+    stdout: 'pipe',
+    stderr: 'pipe',
+  });
+
 export const getAvds = async (): Promise<string[]> => {
   try {
     const emulatorBinaryPath = await ensureEmulatorInstalled();
@@ -730,3 +829,77 @@ export const getConnectedDevices = async (): Promise<AdbDevice[]> => {
 
   return devices;
 };
+
+export const grantPermissions = async (
+  adbId: string,
+  bundleId: string,
+): Promise<void> => {
+  androidAdbLogger.debug('grantPermissions:start %o', {
+    adbId,
+    bundleId,
+  });
+
+  const isInstalled = await isAppInstalled(adbId, bundleId);
+  if (!isInstalled) {
+    throw new AdbAppNotInstalledError(bundleId, adbId);
+  }
+
+  const [requestedPermissions, dangerousPermissions] = await Promise.all([
+    getRequestedPermissions(adbId, bundleId),
+    getDangerousPermissions(adbId),
+  ]);
+  const permissions = requestedPermissions.filter((permission) =>
+    dangerousPermissions.has(permission),
+  );
+
+  androidAdbLogger.debug('grantPermissions:resolved %o', {
+    adbId,
+    bundleId,
+    requestedPermissions,
+    permissions,
+  });
+
+  if (permissions.length === 0) {
+    androidAdbLogger.debug('grantPermissions:skip %o', {
+      adbId,
+      bundleId,
+    });
+    return;
+  }
+
+  const grantCommands = permissions.map((permission) => [
+    '-s',
+    adbId,
+    'shell',
+    'pm',
+    'grant',
+    bundleId,
+    permission,
+  ]);
+
+  try {
+    androidAdbLogger.debug('grantPermissions:commands %o', {
+      adbId,
+      bundleId,
+      grantCommands,
+    });
+
+    await Promise.all(
+      grantCommands.map((args) => spawn(getAdbBinaryPath(), args as string[])),
+    );
+
+    androidAdbLogger.debug('grantPermissions:success %o', {
+      adbId,
+      bundleId,
+      permissions,
+    });
+  } catch (error) {
+    androidAdbLogger.debug('grantPermissions:error %o', {
+      adbId,
+      bundleId,
+      permissions,
+      error,
+    });
+    throw new AdbPermissionGrantError(bundleId, permissions, adbId);
+  }
+};

package/src/app-monitor.ts

@@ -10,7 +10,6 @@ import {
   escapeRegExp,
   getEmitter,
   logger,
-  spawn,
   SubprocessError,
   type Subprocess,
 } from '@react-native-harness/tools';
@@ -445,13 +444,9 @@ export const createAndroidAppMonitor = ({
   const startLogcat = async () => {
     const logcatTimestamp = await adb.getLogcatTimestamp(adbId);
 
-    logcatProcess = spawn(
-      'adb',
-      ['-s', adbId, ...getLogcatArgs(appUid, logcatTimestamp)],
-      {
-        stdout: 'pipe',
-        stderr: 'pipe',
-      }
+    logcatProcess = adb.startLogcat(
+      adbId,
+      getLogcatArgs(appUid, logcatTimestamp)
     );
 
     const currentProcess = logcatProcess;

package/src/emulator-startup.ts

@@ -9,8 +9,6 @@ const COMMON_EMULATOR_ARGS = [
   'swiftshader_indirect',
   '-noaudio',
   '-no-boot-anim',
-  '-camera-back',
-  'none',
 ] as const;
 
 export const getEmulatorStartupArgs = (

package/src/instance.ts

@@ -59,6 +59,20 @@ const getHarnessAppPath = (): string => {
   return appPath;
 };
 
+const getOptionalHarnessAppPath = (): string | undefined => {
+  const appPath = process.env.HARNESS_APP_PATH;
+
+  if (!appPath) {
+    return undefined;
+  }
+
+  if (!fs.existsSync(appPath)) {
+    throw new HarnessAppPathError('invalid', appPath);
+  }
+
+  return appPath;
+};
+
 const configureAndroidRuntime = async (
   adbId: string,
   config: AndroidPlatformConfig,
@@ -180,6 +194,7 @@ export const getAndroidEmulatorPlatformInstance = async (
 ): Promise<HarnessPlatformRunner> => {
   assertAndroidDeviceEmulator(config.device);
   const detectNativeCrashes = harnessConfig.detectNativeCrashes ?? true;
+  const permissionsEnabled = harnessConfig.permissions ?? false;
   const emulatorConfig = config.device;
   const emulatorName = emulatorConfig.name;
   const avdConfig = emulatorConfig.avd;
@@ -250,14 +265,22 @@ export const getAndroidEmulatorPlatformInstance = async (
   );
 
   const isInstalled = await adb.isAppInstalled(adbId, config.bundleId);
+  const appPath = getOptionalHarnessAppPath();
 
-  if (!isInstalled) {
-    const appPath = getHarnessAppPath();
+  if (isInstalled && appPath) {
+    await adb.uninstallApp(adbId, config.bundleId);
     await adb.installApp(adbId, appPath);
+  } else if (!isInstalled) {
+    const installPath = appPath ?? getHarnessAppPath();
+    await adb.installApp(adbId, installPath);
   }
 
   const appUid = await configureAndroidRuntime(adbId, config, harnessConfig);
 
+  if (permissionsEnabled) {
+    await adb.grantPermissions(adbId, config.bundleId);
+  }
+
   return {
     startApp: async (options) => {
       await adb.startApp(
@@ -315,6 +338,7 @@ export const getAndroidPhysicalDevicePlatformInstance = async (
 ): Promise<HarnessPlatformRunner> => {
   assertAndroidDevicePhysical(config.device);
   const detectNativeCrashes = harnessConfig.detectNativeCrashes ?? true;
+  const permissionsEnabled = harnessConfig.permissions ?? false;
 
   const adbId = await getAdbId(config.device);
 
@@ -333,6 +357,10 @@ export const getAndroidPhysicalDevicePlatformInstance = async (
 
   const appUid = await configureAndroidRuntime(adbId, config, harnessConfig);
 
+  if (permissionsEnabled) {
+    await adb.grantPermissions(adbId, config.bundleId);
+  }
+
   return {
     startApp: async (options) => {
       await adb.startApp(

package/test/setup.ts

@@ -0,0 +1,68 @@
+import { PassThrough } from 'node:stream';
+import { vi } from 'vitest';
+import type { ChildProcessByStdio } from 'node:child_process';
+
+const createMockChildProcess = (): ChildProcessByStdio<
+  null,
+  PassThrough,
+  PassThrough
+> => {
+  const stdout = new PassThrough();
+  const stderr = new PassThrough();
+
+  return {
+    stdout,
+    stderr,
+    unref: vi.fn(),
+    once: vi.fn(),
+    removeAllListeners: vi.fn(),
+  } as unknown as ChildProcessByStdio<null, PassThrough, PassThrough>;
+};
+
+const createMockSubprocess = () => ({
+  nodeChildProcess: Promise.resolve({
+    kill: vi.fn(),
+  }),
+  [Symbol.asyncIterator]: async function* () {
+    yield* [];
+  },
+});
+
+vi.mock('../src/adb.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../src/adb.js')>();
+
+  return {
+    ...actual,
+    emulatorProcess: {
+      startDetachedProcess: vi.fn(createMockChildProcess),
+    },
+    verifyAndroidEmulatorSdk: vi.fn().mockResolvedValue(undefined),
+    isAppInstalled: vi.fn().mockResolvedValue(true),
+    reversePort: vi.fn().mockResolvedValue(undefined),
+    stopApp: vi.fn().mockResolvedValue(undefined),
+    startApp: vi.fn().mockResolvedValue(undefined),
+    getDeviceIds: vi.fn().mockResolvedValue([]),
+    getEmulatorName: vi.fn().mockResolvedValue(''),
+    getShellProperty: vi.fn().mockResolvedValue(''),
+    getDeviceInfo: vi.fn().mockResolvedValue(null),
+    isBootCompleted: vi.fn().mockResolvedValue(true),
+    stopEmulator: vi.fn().mockResolvedValue(undefined),
+    installApp: vi.fn().mockResolvedValue(undefined),
+    uninstallApp: vi.fn().mockResolvedValue(undefined),
+    hasAvd: vi.fn().mockResolvedValue(false),
+    createAvd: vi.fn().mockResolvedValue(undefined),
+    deleteAvd: vi.fn().mockResolvedValue(undefined),
+    startEmulator: vi.fn().mockResolvedValue(undefined),
+    waitForEmulator: vi.fn().mockResolvedValue('emulator-5554'),
+    waitForEmulatorDisconnect: vi.fn().mockResolvedValue(undefined),
+    waitForBoot: vi.fn().mockResolvedValue('emulator-5554'),
+    isAppRunning: vi.fn().mockResolvedValue(false),
+    getAppUid: vi.fn().mockResolvedValue(0),
+    setHideErrorDialogs: vi.fn().mockResolvedValue(undefined),
+    getLogcatTimestamp: vi.fn().mockResolvedValue('01-01 00:00:00.000'),
+    startLogcat: vi.fn(createMockSubprocess),
+    getAvds: vi.fn().mockResolvedValue([]),
+    getConnectedDevices: vi.fn().mockResolvedValue([]),
+    grantPermissions: vi.fn().mockResolvedValue(undefined),
+  };
+});

package/vite.config.ts

@@ -0,0 +1,19 @@
+/// <reference types='vitest' />
+import { defineConfig } from 'vite';
+
+export default defineConfig(() => ({
+  root: __dirname,
+  cacheDir: '../../node_modules/.vite/packages/platform-android',
+  test: {
+    watch: false,
+    globals: true,
+    environment: 'node',
+    setupFiles: ['./test/setup.ts'],
+    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: './test-output/vitest/coverage',
+      provider: 'v8' as const,
+    },
+  },
+}));