@docouno/devkit 0.0.0-stage → 0.3.0

package/templates/electron-react/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "devkit-electron-react",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "node": "^24.22.1"
+  },
+  "scripts": {
+    "check": "devkit-verify && npm run format:check && npm run lint && npm run typecheck && npm test",
+    "format:check": "prettier --check src tsconfig.json tsconfig.node.json tsconfig.test.json eslint.config.mjs prettier.config.mjs vitest.config.mjs electron.vite.config.cjs electron-builder.config.cjs",
+    "lint": "eslint --no-ignore --max-warnings 0 src eslint.config.mjs prettier.config.mjs vitest.config.mjs electron.vite.config.cjs electron-builder.config.cjs",
+    "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.node.json && tsc --noEmit -p tsconfig.test.json",
+    "test": "vitest run --config vitest.config.mjs",
+    "fix": "prettier --write src tsconfig.json tsconfig.node.json tsconfig.test.json eslint.config.mjs prettier.config.mjs vitest.config.mjs electron.vite.config.cjs electron-builder.config.cjs && eslint --no-ignore --max-warnings 0 --fix src eslint.config.mjs prettier.config.mjs vitest.config.mjs electron.vite.config.cjs electron-builder.config.cjs && prettier --write src tsconfig.json tsconfig.node.json tsconfig.test.json eslint.config.mjs prettier.config.mjs vitest.config.mjs electron.vite.config.cjs electron-builder.config.cjs",
+    "build": "npm run typecheck && electron-vite build",
+    "dev": "electron-vite dev",
+    "package": "electron-builder --config electron-builder.config.cjs --linux dir --publish never && tar -czf release/app-linux.tar.gz -C release/linux-unpacked ."
+  },
+  "devDependencies": {
+    "@docouno/env": "0.3.0",
+    "@testing-library/dom": "10.4.2",
+    "@testing-library/react": "16.3.3",
+    "@types/node": "24.19.2",
+    "@types/react": "19.3.0",
+    "@types/react-dom": "19.3.0",
+    "@vitejs/plugin-react": "6.1.2",
+    "eslint": "10.13.0",
+    "jsdom": "30.1.3",
+    "prettier": "3.9.10",
+    "typescript": "6.0.3",
+    "vite": "8.3.5",
+    "vitest": "5.0.5",
+    "react": "19.3.1",
+    "react-dom": "19.3.1",
+    "electron": "45.0.0",
+    "electron-vite": "6.0.0",
+    "electron-builder": "26.15.3"
+  },
+  "devkit": {
+    "sourceDirectories": [
+      "src"
+    ],
+    "typecheckConfigs": [
+      "tsconfig.json",
+      "tsconfig.node.json",
+      "tsconfig.test.json"
+    ],
+    "boundaries": {
+      "forbidCrossAppImports": true
+    }
+  },
+  "main": "dist/main/index.js",
+  "description": "A React desktop application",
+  "author": "Application authors",
+  "license": "MIT"
+}

package/templates/electron-react/prettier.config.mjs

@@ -0,0 +1 @@
+export { default } from '@docouno/env/prettier';

package/templates/electron-react/src/bridge.ts

@@ -0,0 +1,10 @@
+export interface Greeting {
+  message: string;
+}
+export interface DesktopCapabilities {
+  apiEnabled: boolean;
+}
+export interface DesktopBridge {
+  getCapabilities(): Promise<DesktopCapabilities>;
+  greet(name: string): Promise<Greeting>;
+}

package/templates/electron-react/src/main/api.test.ts

@@ -0,0 +1,26 @@
+import { expect, it } from 'vitest';
+import { requestGreeting } from './api.js';
+it('uses the configured backend and encodes the name', async () => {
+  let requested = '';
+  const fetcher: typeof fetch = (input) => {
+    requested = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
+    return Promise.resolve(new Response('{"message":"Hello!"}'));
+  };
+  await expect(requestGreeting('http://api:8080', 'Ada & Bob', fetcher)).resolves.toEqual({
+    message: 'Hello!',
+  });
+  expect(requested).toBe('http://api:8080/api/greeting?name=Ada+%26+Bob');
+});
+it('rejects invalid names and backend failures', async () => {
+  await expect(requestGreeting('http://api:8080', 42)).rejects.toThrow('name');
+  await expect(
+    requestGreeting('http://api:8080', 'Ada', () =>
+      Promise.resolve(new Response('down', { status: 503 })),
+    ),
+  ).rejects.toThrow('503');
+  await expect(
+    requestGreeting('http://api:8080', 'Ada', () =>
+      Promise.resolve(new Response('{"message":42}')),
+    ),
+  ).rejects.toThrow('invalid greeting');
+});

package/templates/electron-react/src/main/api.ts

@@ -0,0 +1,38 @@
+import type { Greeting } from '../bridge.js';
+export async function requestGreeting(
+  target: string,
+  name: unknown,
+  fetcher: typeof fetch = fetch,
+): Promise<Greeting> {
+  if (typeof name !== 'string' || name.length > 80) {
+    throw new Error('A name of at most 80 characters is required.');
+  }
+  const url = new URL('/api/greeting', target);
+  if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) {
+    throw new Error('Invalid API target.');
+  }
+  url.searchParams.set('name', name);
+  const response = await fetcher(url, {
+    headers: { accept: 'application/json' },
+    signal: AbortSignal.timeout(5000),
+  });
+  if (!response.ok) {
+    throw new Error(`API request failed (${response.status}).`);
+  }
+  let reply: unknown;
+  try {
+    reply = await response.json();
+  } catch {
+    throw new Error('API returned invalid JSON.');
+  }
+  if (
+    !reply ||
+    typeof reply !== 'object' ||
+    !('message' in reply) ||
+    typeof reply.message !== 'string' ||
+    !reply.message
+  ) {
+    throw new Error('API returned an invalid greeting.');
+  }
+  return { message: reply.message };
+}

package/templates/electron-react/src/main/index.ts

@@ -0,0 +1,118 @@
+import { app, BrowserWindow, ipcMain, net, protocol } from 'electron';
+import type { IpcMainInvokeEvent } from 'electron';
+import { realpath, stat } from 'node:fs/promises';
+import { join, resolve, sep } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { requestGreeting } from './api.js';
+import { isTrustedRendererURL } from './renderer-url.js';
+
+protocol.registerSchemesAsPrivileged([
+  {
+    scheme: 'app',
+    privileges: { standard: true, secure: true, supportFetchAPI: true, corsEnabled: true },
+  },
+]);
+const rendererRoot = resolve(import.meta.dirname, '../renderer');
+const development =
+  !app.isPackaged && process.env.ELECTRON_RENDERER_URL
+    ? new URL(process.env.ELECTRON_RENDERER_URL)
+    : undefined;
+if (
+  development &&
+  (development.protocol !== 'http:' ||
+    !['localhost', '127.0.0.1', '[::1]'].includes(development.hostname) ||
+    development.username ||
+    development.password)
+) {
+  throw new Error('Development requires a local HTTP renderer origin.');
+}
+const rendererURL = development?.href ?? 'app://local/index.html';
+const apiTarget = process.env.DEVKIT_API_TARGET;
+
+function inside(root: string, file: string): boolean {
+  return file === root || file.startsWith(root + sep);
+}
+
+async function createWindow(): Promise<void> {
+  const root = await realpath(rendererRoot);
+  protocol.handle('app', async (request) => {
+    const url = new URL(request.url);
+    if (
+      url.protocol !== 'app:' ||
+      url.hostname !== 'local' ||
+      url.port ||
+      url.username ||
+      url.password
+    ) {
+      return new Response('Forbidden', { status: 403 });
+    }
+    if (request.method !== 'GET' && request.method !== 'HEAD') {
+      return new Response('Method not allowed', { status: 405 });
+    }
+    try {
+      const relative = decodeURIComponent(url.pathname === '/' ? '/index.html' : url.pathname);
+      const file = resolve(root, '.' + relative);
+      if (!inside(root, file)) {
+        return new Response('Forbidden', { status: 403 });
+      }
+      const actual = await realpath(file);
+      if (!inside(root, actual) || !(await stat(actual)).isFile()) {
+        return new Response('Forbidden', { status: 403 });
+      }
+      return net.fetch(pathToFileURL(actual).href);
+    } catch {
+      return new Response('Not found', { status: 404 });
+    }
+  });
+  const window = new BrowserWindow({
+    width: 1000,
+    height: 760,
+    webPreferences: {
+      preload: join(import.meta.dirname, '../preload/index.cjs'),
+      sandbox: true,
+      contextIsolation: true,
+      nodeIntegration: false,
+      webSecurity: true,
+    },
+  });
+  function assertSender(event: IpcMainInvokeEvent): void {
+    if (
+      event.sender !== window.webContents ||
+      event.senderFrame !== window.webContents.mainFrame ||
+      !isTrustedRendererURL(event.senderFrame.url, rendererURL)
+    ) {
+      throw new Error('Untrusted renderer.');
+    }
+  }
+  ipcMain.handle('desktop:capabilities', (event) => {
+    assertSender(event);
+    return { apiEnabled: Boolean(apiTarget) };
+  });
+  ipcMain.handle('desktop:greet', (event, name: unknown) => {
+    assertSender(event);
+    if (!apiTarget) {
+      throw new Error('No API is configured.');
+    }
+    return requestGreeting(apiTarget, name);
+  });
+  window.webContents.setWindowOpenHandler(() => ({ action: 'deny' }));
+  window.webContents.on('will-navigate', (event, url) => {
+    if (!isTrustedRendererURL(url, rendererURL)) {
+      event.preventDefault();
+    }
+  });
+  window.webContents.session.setPermissionRequestHandler((_contents, _permission, callback) =>
+    callback(false),
+  );
+  window.webContents.session.setPermissionCheckHandler(() => false);
+  await window.loadURL(rendererURL);
+}
+
+app
+  .whenReady()
+  .then(createWindow)
+  .catch((error: unknown) => {
+    console.error(error);
+    app.exit(1);
+  });
+app.on('window-all-closed', () => app.quit());

package/templates/electron-react/src/main/renderer-url.test.ts

@@ -0,0 +1,18 @@
+import { expect, it } from 'vitest';
+import { isTrustedRendererURL } from './renderer-url.js';
+it('matches the exact development origin rather than a port prefix', () => {
+  expect(isTrustedRendererURL('http://localhost:5173/page', 'http://localhost:5173')).toBe(true);
+  expect(isTrustedRendererURL('http://localhost:51730/page', 'http://localhost:5173')).toBe(false);
+  expect(isTrustedRendererURL('http://localhost.example:5173/page', 'http://localhost:5173')).toBe(
+    false,
+  );
+});
+it('matches only the local application scheme and host', () => {
+  expect(isTrustedRendererURL('app://local/index.html', 'app://local/index.html')).toBe(true);
+  expect(isTrustedRendererURL('app://local.example/index.html', 'app://local/index.html')).toBe(
+    false,
+  );
+  expect(isTrustedRendererURL('app://local:9999/index.html', 'app://local/index.html')).toBe(false);
+  expect(isTrustedRendererURL('app://user@local/index.html', 'app://local/index.html')).toBe(false);
+  expect(isTrustedRendererURL('not a URL', 'app://local/index.html')).toBe(false);
+});

package/templates/electron-react/src/main/renderer-url.ts

@@ -0,0 +1,21 @@
+export function isTrustedRendererURL(candidate: string, expected: string): boolean {
+  try {
+    const target = new URL(candidate);
+    const renderer = new URL(expected);
+    if (target.username || target.password) {
+      return false;
+    }
+    if (renderer.protocol === 'http:') {
+      return target.protocol === 'http:' && target.origin === renderer.origin;
+    }
+    return (
+      renderer.protocol === 'app:' &&
+      renderer.hostname === 'local' &&
+      target.protocol === 'app:' &&
+      target.hostname === 'local' &&
+      target.port === ''
+    );
+  } catch {
+    return false;
+  }
+}

package/templates/electron-react/src/preload/index.ts

@@ -0,0 +1,7 @@
+import { contextBridge, ipcRenderer } from 'electron';
+import type { DesktopBridge, DesktopCapabilities, Greeting } from '../bridge.js';
+const bridge: DesktopBridge = {
+  getCapabilities: () => ipcRenderer.invoke('desktop:capabilities') as Promise<DesktopCapabilities>,
+  greet: (name) => ipcRenderer.invoke('desktop:greet', name) as Promise<Greeting>,
+};
+contextBridge.exposeInMainWorld('desktop', Object.freeze(bridge));

package/templates/electron-react/src/renderer/index.html

@@ -0,0 +1,16 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta
+      http-equiv="Content-Security-Policy"
+      content="default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; connect-src 'self' ws://localhost:5173"
+    />
+    <title>Devkit desktop</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/templates/electron-react/src/renderer/src/ClientApp.test.tsx

@@ -0,0 +1,41 @@
+import { cleanup, fireEvent, render, screen } from '@testing-library/react';
+import { afterEach, expect, it } from 'vitest';
+import { ClientApp } from './ClientApp.js';
+
+afterEach(cleanup);
+
+it('works locally without requiring a backend', () => {
+  render(<ClientApp platform="web" />);
+  fireEvent.change(screen.getByLabelText('Name'), { target: { value: ' Ada ' } });
+  expect(screen.getByTestId('local-greeting').textContent).toBe('Hello, Ada!');
+  fireEvent.click(screen.getByRole('button', { name: 'Increment' }));
+  expect(screen.getByTestId('count').textContent).toBe('Clicks: 1');
+  expect(screen.queryByRole('button', { name: 'Ask API' })).toBeNull();
+});
+
+it('uses the supplied API and renders its response', async () => {
+  let requested = '';
+  render(
+    <ClientApp
+      platform="desktop"
+      api={{
+        greet: (name) => {
+          requested = name;
+          return Promise.resolve({ message: 'Hello from API!' });
+        },
+      }}
+    />,
+  );
+  fireEvent.change(screen.getByLabelText('Name'), { target: { value: 'Ada' } });
+  fireEvent.click(screen.getByRole('button', { name: 'Ask API' }));
+  expect(await screen.findByText('Hello from API!')).toBeDefined();
+  expect(requested).toBe('Ada');
+});
+
+it('shows an API failure without substituting a local response', async () => {
+  render(
+    <ClientApp platform="web" api={{ greet: () => Promise.reject(new Error('Unavailable')) }} />,
+  );
+  fireEvent.click(screen.getByRole('button', { name: 'Ask API' }));
+  expect((await screen.findByRole('alert')).textContent).toBe('Unavailable');
+});

package/templates/electron-react/src/renderer/src/ClientApp.tsx

@@ -0,0 +1,75 @@
+import { useEffect, useRef, useState } from 'react';
+
+export interface ClientApi {
+  greet(name: string): Promise<{ message: string }>;
+}
+
+type RemoteState = { phase: 'idle' | 'loading' } | { phase: 'ready' | 'error'; message: string };
+
+export function ClientApp({ api, platform }: { api?: ClientApi; platform: string }) {
+  const [name, setName] = useState('world');
+  const [count, setCount] = useState(0);
+  const [remote, setRemote] = useState<RemoteState>({ phase: 'idle' });
+  const request = useRef(0);
+  useEffect(
+    () => () => {
+      request.current += 1;
+    },
+    [],
+  );
+
+  function requestGreeting() {
+    if (!api) {
+      return;
+    }
+    const current = ++request.current;
+    setRemote({ phase: 'loading' });
+    api.greet(name).then(
+      (reply) => {
+        if (request.current === current) {
+          setRemote({ phase: 'ready', message: reply.message });
+        }
+      },
+      (error: unknown) => {
+        if (request.current === current) {
+          setRemote({
+            phase: 'error',
+            message: error instanceof Error ? error.message : 'API request failed.',
+          });
+        }
+      },
+    );
+  }
+
+  return (
+    <main>
+      <p className="eyebrow">Devkit · {platform}</p>
+      <h1>A small app, ready to change.</h1>
+      <p>One interface for local interaction and an optional API connection.</p>
+      <section className="card" aria-label="Local interaction">
+        <label htmlFor="name">Name</label>
+        <input
+          id="name"
+          value={name}
+          maxLength={80}
+          onChange={(event) => setName(event.target.value)}
+        />
+        <output data-testid="local-greeting">Hello, {name.trim() || 'world'}!</output>
+        <button type="button" onClick={() => setCount((value) => value + 1)}>
+          Increment
+        </button>
+        <span data-testid="count">Clicks: {count}</span>
+      </section>
+      {api && (
+        <section className="api-panel" aria-label="API greeting">
+          <h2>API connection</h2>
+          <button type="button" onClick={requestGreeting} disabled={remote.phase === 'loading'}>
+            {remote.phase === 'loading' ? 'Requesting…' : 'Ask API'}
+          </button>
+          {remote.phase === 'ready' && <p role="status">{remote.message}</p>}
+          {remote.phase === 'error' && <p role="alert">{remote.message}</p>}
+        </section>
+      )}
+    </main>
+  );
+}

package/templates/electron-react/src/renderer/src/api.test.ts

@@ -0,0 +1,15 @@
+import { expect, it } from 'vitest';
+import { greet } from './api.js';
+it('uses the specific desktop greeting bridge', async () => {
+  let requested = '';
+  await expect(
+    greet('Ada', {
+      getCapabilities: () => Promise.resolve({ apiEnabled: true }),
+      greet: (name) => {
+        requested = name;
+        return Promise.resolve({ message: 'Hello, Ada!' });
+      },
+    }),
+  ).resolves.toEqual({ message: 'Hello, Ada!' });
+  expect(requested).toBe('Ada');
+});

package/templates/electron-react/src/renderer/src/api.ts

@@ -0,0 +1,17 @@
+import type { DesktopBridge, Greeting } from '../../bridge.js';
+export async function greet(
+  name: string,
+  bridge: DesktopBridge = window.desktop,
+): Promise<Greeting> {
+  const value: unknown = await bridge.greet(name);
+  if (
+    !value ||
+    typeof value !== 'object' ||
+    !('message' in value) ||
+    typeof value.message !== 'string' ||
+    !value.message
+  ) {
+    throw new Error('Desktop returned an invalid greeting.');
+  }
+  return { message: value.message };
+}

package/templates/electron-react/src/renderer/src/env.d.ts

@@ -0,0 +1,6 @@
+import type { DesktopBridge } from '../../bridge.js';
+declare global {
+  interface Window {
+    desktop: DesktopBridge;
+  }
+}

package/templates/electron-react/src/renderer/src/main.tsx

@@ -0,0 +1,24 @@
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import { ClientApp } from './ClientApp.js';
+import { greet } from './api.js';
+import './style.css';
+const element = document.getElementById('root');
+if (!element) {
+  throw new Error('Missing application root.');
+}
+const root = createRoot(element);
+window.desktop.getCapabilities().then(
+  ({ apiEnabled }) =>
+    root.render(
+      <StrictMode>
+        <ClientApp platform="desktop" {...(apiEnabled ? { api: { greet } } : {})} />
+      </StrictMode>,
+    ),
+  (error: unknown) =>
+    root.render(
+      <p role="alert">
+        {error instanceof Error ? error.message : 'Desktop initialization failed.'}
+      </p>,
+    ),
+);

package/templates/electron-react/src/renderer/src/style.css

@@ -0,0 +1,71 @@
+:root {
+  font-family: system-ui, sans-serif;
+  color: #17233a;
+  background: #f4f7fb;
+  font-synthesis: none;
+}
+
+body {
+  margin: 0;
+}
+main {
+  max-width: 44rem;
+  margin: 4rem auto;
+  padding: 0 1.5rem;
+}
+h1 {
+  font-size: clamp(2rem, 5vw, 3rem);
+  line-height: 1.1;
+}
+h2 {
+  font-size: 1.25rem;
+}
+p {
+  line-height: 1.6;
+}
+.eyebrow {
+  color: #3159a6;
+  font-weight: 650;
+}
+.card,
+.api-panel {
+  display: grid;
+  gap: 1rem;
+  margin-top: 2rem;
+  padding: 1.5rem;
+  border: 1px solid #dce3ef;
+  border-radius: 1rem;
+  background: white;
+}
+input,
+button {
+  font: inherit;
+  padding: 0.75rem 1rem;
+  border-radius: 0.5rem;
+}
+input {
+  border: 1px solid #8391a9;
+}
+button {
+  justify-self: start;
+  border: none;
+  background: #3159a6;
+  color: white;
+  cursor: pointer;
+}
+button:disabled {
+  opacity: 0.65;
+  cursor: wait;
+}
+input:focus-visible,
+button:focus-visible {
+  outline: 3px solid #8eafe8;
+  outline-offset: 3px;
+}
+output {
+  font-size: 1.4rem;
+  font-weight: 600;
+}
+[role='alert'] {
+  color: #a5222a;
+}

package/templates/electron-react/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "@docouno/env/tsconfig/browser.json",
+  "compilerOptions": {
+    "types": ["vite/client"]
+  },
+  "include": ["src/renderer/src/**/*.ts", "src/renderer/src/**/*.tsx"],
+  "exclude": ["src/**/*.test.ts", "src/**/*.test.tsx"]
+}

package/templates/electron-react/tsconfig.node.json

@@ -0,0 +1,13 @@
+{
+  "extends": "@docouno/env/tsconfig/node.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2023", "DOM"],
+    "allowJs": true,
+    "checkJs": true
+  },
+  "include": ["src/main/**/*.ts", "src/preload/**/*.ts", "src/bridge.ts", "*.cjs", "*.mjs"],
+  "exclude": ["src/**/*.test.ts"]
+}

package/templates/electron-react/tsconfig.test.json

@@ -0,0 +1,7 @@
+{
+  "extends": "@docouno/env/tsconfig/browser.json",
+  "compilerOptions": {
+    "types": ["vite/client", "node"]
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx"]
+}

package/templates/electron-react/variants/shared/files/src/renderer/src/main.tsx

@@ -0,0 +1,24 @@
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import { ClientApp } from '__DEVKIT_CLIENT_PACKAGE__';
+import { greet } from './api.js';
+import '__DEVKIT_CLIENT_PACKAGE__/style.css';
+const element = document.getElementById('root');
+if (!element) {
+  throw new Error('Missing application root.');
+}
+const root = createRoot(element);
+window.desktop.getCapabilities().then(
+  ({ apiEnabled }) =>
+    root.render(
+      <StrictMode>
+        <ClientApp platform="desktop" {...(apiEnabled ? { api: { greet } } : {})} />
+      </StrictMode>,
+    ),
+  (error: unknown) =>
+    root.render(
+      <p role="alert">
+        {error instanceof Error ? error.message : 'Desktop initialization failed.'}
+      </p>,
+    ),
+);

package/templates/electron-react/variants/shared/variant.json

@@ -0,0 +1,7 @@
+{
+  "remove": [
+    "src/renderer/src/ClientApp.tsx",
+    "src/renderer/src/ClientApp.test.tsx",
+    "src/renderer/src/style.css"
+  ]
+}

package/templates/electron-react/vitest.config.mjs

@@ -0,0 +1,19 @@
+import react from '@vitejs/plugin-react';
+import { defineConfig } from 'vitest/config';
+import RunnableTestsReporter from '@docouno/env/vitest-reporter';
+
+export default defineConfig({
+  plugins: [react()],
+  cacheDir: 'node_modules/.cache/devkit-vitest',
+  resolve: { dedupe: ['react', 'react-dom'] },
+  test: {
+    environment: 'jsdom',
+    include: ['src/**/*.test.{ts,tsx}'],
+    globals: false,
+    passWithNoTests: false,
+    reporters: ['default', new RunnableTestsReporter()],
+    restoreMocks: true,
+    clearMocks: true,
+    maxWorkers: 2,
+  },
+});